Chinaunix首页 | 论坛 | 博客

zhanglong71zhanglong.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

zhanglong71

  • 博客访问： 657951
  • 博文数量： 185
  • 博客积分： 1875
  • 博客等级： 上尉
  • 技术积分： 2107
  • 用 户 组： 普通用户
  • 注册时间： 2010-10-23 23:21
个人简介

有时候，就是想窥视一下不知道的东东，因为好奇！

文章分类

全部博文（185）

文章存档

2024年（1）

2023年（3）

2020年（1）

2019年（1）

2018年（1）

2017年（2）

2016年（69）

2015年（53）

2014年（14）

2013年（1）

2012年（5）

2011年（25）

2010年（9）

我的朋友
最近访客
推荐博文
相关博文
canbus驱动备忘、二

分类： LINUX

2014-09-25 19:44:27

s3c2440+mcp2510的canbus实现。记录备忘。
将2440引脚配置成spi端口。用spi接口配置mcp2510

点击(此处)折叠或打开

  1. #define rCLKCON 0x4C00000C

  3. #define rGPECON 0x56000040
  4. #define rGPEDAT 0x56000044
  5. #define rGPEUP 0x56000048

  7. #define rGPGCON 0x56000060
  8. #define rGPGDAT 0x56000064
  9. #define rGPGUP 0x56000068

  11. #define rSPCON0 0x59000000
  12. #define rSPSTA0 0x59000004
  13. #define rSPPIN0 0x59000008
  14. #define rSPPRE0 0x5900000C
  15. #define rSPTDAT0 0x59000010
  16. #define rSPRDAT0 0x59000014

  18. #define SPI0_READY (ioread8((void *)SPSTA0) & 0x1)

  20. #define MCP2510_CS_H iowrite32(ioread32((void *)GPGDAT) | (0x1<<14), (void *)GPGDAT)
  21. #define MCP2510_CS_L iowrite32(ioread32((void *)GPGDAT) & (~(0x1<<14)), (void *)GPGDAT)

  23. volatile unsigned int *GPGDAT;
  24. volatile u8 *SPTDAT0;
  25. volatile u8 *SPRDAT0;
  26. volatile u8 *SPSTA0;
  27. static unsigned char TXBnCTRL[3] = {0x30, 0x40, 0x50};

  29. static u8 MCP2510_Read(u8 Addr)
  30. {
  31.     u8 result;
  32.     MCP2510_CS_L;
  33.     iowrite8(0x03, (void *)SPTDAT0);
  34.     while(!SPI0_READY);
  35.     iowrite8(Addr, (void *)SPTDAT0);
  36.     while(!SPI0_READY);
  37.     iowrite8(0xFF, (void *)SPTDAT0);
  38.     while(!SPI0_READY);
  39.     result = ioread8((void *)SPRDAT0);
  40.     MCP2510_CS_H;
  41.     return result;
  42. }

  44. static void MCP2510_Write(u8 Addr, u8 Data)
  45. {
  46.     MCP2510_CS_L;
  47.     while(!SPI0_READY);
  48.     iowrite8(0x02, (void *)SPTDAT0);
  49.     while(!SPI0_READY);
  50.     iowrite8(Addr, (void *)SPTDAT0);
  51.     while(!SPI0_READY);
  52.     iowrite8(Data, (void *)SPTDAT0);
  53.     while(!SPI0_READY);
  54.     MCP2510_CS_H;
  55. }

  57. static void MCP2510_BitModi(u8 Addr, u8 Mask, u8 Data)
  58. {
  59.     MCP2510_CS_L;
  60.     iowrite8(0x05, (void *)SPTDAT0);
  61.     while(!SPI0_READY);
  62.     iowrite8(Addr, (void *)SPTDAT0);
  63.     while(!SPI0_READY);
  64.     iowrite8(Mask, (void *)SPTDAT0);
  65.     while(!SPI0_READY);
  66.     iowrite8(Data, (void *)SPTDAT0);
  67.     while(!SPI0_READY);
  68.     MCP2510_CS_H;
  69. }

  71. static void __config_spi(void)
  72. {
  73.     volatile unsigned int *REGISTER;
  74. /* GPG(2, 13)*/
  75.     //设置GPG2为输出(底电平重启), GPG13（外部中断号21）为中断
  76.     REGISTER = (unsigned int *)ioremap(rGPGCON, 4);
  77.     PLOG("GPGCON Value is %u\n", ioread32((void *)REGISTER));
  78.     iowrite32((ioread32((void *)REGISTER) & (~((0x03 << 26) | (0x03 << 4)))) | (0b10 << 26) | (0b01 << 4), (void *)REGISTER);
  79.     PLOG("GPGCON Value is %u\n", ioread32((void *)REGISTER));
  80.     iounmap(REGISTER);

  82.     //使能GPG2、13上拉
  83.     REGISTER = (unsigned int *)ioremap(rGPGUP, 4);
  84.     PLOG("GPGUP Value is %u\n", ioread32((void *)REGISTER));
  85.     iowrite32(ioread32((void *)REGISTER) & (~((0x1 << 13) | (0x1 << 2))), (void *)REGISTER);
  86.     PLOG("GPGUP Value is %u\n", ioread32((void *)REGISTER));
  87.     iounmap(REGISTER);

  89. /* reset mcp2510. Is it necessary ? */
  90.     //设置GPG2为高电平，GPG2和MCP2510的RST连接
  91.     REGISTER = (unsigned int *)ioremap(rGPGDAT, 4);
  92.     PLOG("GPGDAT Value is %u\n", ioread32((void *)REGISTER));
  93.     iowrite32(ioread32((void *)REGISTER) | (0x1 << 2), (void *)REGISTER);
  94.     PLOG("GPGDAT Value is %u\n", ioread32((void *)REGISTER));
  95.     iounmap(REGISTER);

  97.     //设置GPG14为输出，SPI_CS信号
  98.     REGISTER = (unsigned int *)ioremap(rGPGCON, 4);
  99.     PLOG("GPBCON Value is %u\n", ioread32((void *)REGISTER));
  100.     iowrite32((ioread32((void *)REGISTER) & (~(0b11 << 28))) | (0b01 << 28), (void *)REGISTER);
  101.     PLOG("GPBCON Value is %u\n", ioread32((void *)REGISTER));
  102.     iounmap(REGISTER);

  104.     //使能GPG14上拉
  105.     REGISTER = (unsigned int *)ioremap(rGPGUP, 4);
  106.     PLOG("GPBUP Value is %u\n", ioread32((void *)REGISTER));
  107.     iowrite32(ioread32((void *)REGISTER) & (~(0x1 << 14)), (void *)REGISTER);
  108.     PLOG("GPBUP Value is %u\n", ioread32((void *)REGISTER));
  109.     iounmap(REGISTER);

  111.     GPGDAT = (unsigned int *)ioremap(rGPGDAT, 4);
  112.     SPTDAT0 = (u8 *)ioremap(rSPTDAT0, 1);
  113.     SPRDAT0 = (u8 *)ioremap(rSPRDAT0, 1);
  114.     SPSTA0 = (u8 *)ioremap(rSPSTA0, 1);

  116.     //上拉GPG14
  117.     PLOG("GPGDAT Value is %u\n", ioread32((void *)GPGDAT));
  118.     MCP2510_CS_H;
  119.     PLOG("GPGDAT Value is %u\n", ioread32((void *)GPGDAT));

  121.     //打开SPI CLK使能
  122.     REGISTER = (unsigned int *)ioremap(rCLKCON, 4);
  123.     PLOG("CLKCON Value is %u\n", ioread32((void *)REGISTER));
  124.     iowrite32((ioread32((void *)REGISTER) | (1 << 18)), (void *)REGISTER);
  125.     PLOG("CLKCON Value is %u\n", ioread32((void *)REGISTER));
  126.     iounmap(REGISTER);

  128.     //设置GPE11、12、13为SPI功能
  129.     REGISTER = (unsigned int *)ioremap(rGPECON, 4);
  130.     PLOG("GPECON Value is %u\n", ioread32((void *)REGISTER));
  131.     iowrite32((ioread32((void *)REGISTER) & (0xF03FFFFF)) | (0b10 << 26) | (0b10 << 24) | (0b10 << 22), (void *)REGISTER);
  132.     PLOG("GPECON Value is %u\n", ioread32((void *)REGISTER));
  133.     iounmap(REGISTER);

  135.     //设置SPI0波特率
  136.     REGISTER = (unsigned int *)ioremap(rSPPRE0, 4);
  137.     PLOG("SPPRE0 Value is %u\n", ioread8((void *)REGISTER));
  138.     iowrite8(0x9, (void *)REGISTER);
  139.     PLOG("SPPRE0 Value is %u\n", ioread8((void *)REGISTER));
  140.     iounmap(REGISTER);

  142.     //设置SPCON0
  143.     REGISTER = (unsigned int *)ioremap(rSPCON0, 4);
  144.     PLOG("SPCON0 Value is %u\n", ioread8((void *)REGISTER));
  145.     iowrite8((0 << 6)|(0 << 5)|(1 << 4)|(1 << 3)|(0 << 2)|(0 << 1)|(0 << 0), (void *)REGISTER);
  146.     PLOG("SPCON0 Value is %u\n", ioread8((void *)REGISTER));
  147.     iounmap(REGISTER);

  149.     //设置SPPIN0
  150.     REGISTER = (unsigned int *)ioremap(rSPPIN0, 4);
  151.     PLOG("SPPIN0 Value is %u\n", ioread8((void *)REGISTER));
  152.     iowrite8(0, (void *)REGISTER);
  153.     PLOG("SPPIN0 Value is %u\n", ioread8((void *)REGISTER));
  154.     iounmap(REGISTER);
  155. }

通过spi接口初始化mcp2510

点击(此处)折叠或打开

  1. static int __config_mcp2510(void)
  2. {
  3.     int result;
  4.     u8 tmp;

  6.     //注册接收中断服务程序
  7.     if(request_irq(IRQ_EINT21, proc_Interrupt, IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_LOW, "MCP2510", &host))
  8.     {
  9.         result = -EFAULT;
  10.         goto err;
  11.     }

  13.     MCP2510_BitModi(0x0F, 0xE0, 0x80); //设置MCP2510为配置模式

  15.     MCP2510_Write(0x2B, 0x03); //设置(RX1IE, EX0IE)中断使能寄存器, 使能接收缓冲中断
  16.     /** RXFn**/
  17.     for(result = 0x0; result <= 0x0B; result++)
  18.     {
  19.         MCP2510_Write(result, 0x00);
  20.     }
  21.     /** RXFn**/
  22.     for(result = 0x10; result <= 0x1B; result++)
  23.     {
  24.         MCP2510_Write(result, 0x00);
  25.     }
  26.     /** RXFn**/
  27.     MCP2510_Write(0x01, 0x08);
  28.     MCP2510_Write(0x05, 0x08);
  29.     MCP2510_Write(0x09, 0x08);
  30.     MCP2510_Write(0x11, 0x08);
  31.     MCP2510_Write(0x15, 0x08);
  32.     MCP2510_Write(0x19, 0x08);
  33.     /*** 设置RXMn ***/
  34.     for(result = 0x20; result <= 0x27; result++)
  35.     {
  36.         if((result == 0x21) || (result == 0x25))
  37.         {
  38.             MCP2510_Write(result, 0xE0); /** SID(2..0), EID(17,16) **/
  39.         }
  40.         else if((result == 0x20) || (result == 0x24))
  41.         {
  42.             MCP2510_Write(result, 0x0f);
  43.         }
  44.         else
  45.         {
  46.             MCP2510_Write(result, 0x0);
  47.         }
  48.     }


  51.     MCP2510_CS_L; //设置接收屏蔽寄存器RXMn都为0
  52.     iowrite8(0x02, (void *)SPTDAT0);
  53.     while(!SPI0_READY);
  54.     iowrite8(0x20, (void *)SPTDAT0);
  55.     while(!SPI0_READY);
  56.     for(tmp=0; tmp < 8; tmp++)
  57.     {
  58.         iowrite8(0x0, (void *)SPTDAT0);
  59.         while(!SPI0_READY);
  60.     }
  61.     MCP2510_CS_H;

  63.     //设置接收控制寄存器
  64.     MCP2510_BitModi(TXBnCTRL[0], 0x0B, 0x03); //设置TXB0CTRL -发送缓冲器0有最高优先级
  65.     MCP2510_BitModi(TXBnCTRL[1], 0x0B, 0x02); //设置TXB1CTRL -发送缓冲器1有次高优先级
  66.     MCP2510_BitModi(TXBnCTRL[2], 0x0B, 0x01); //设置TXB2CTRL -发送缓冲器2有低优先级

  68.     MCP2510_BitModi(0x60, 0x64, 0x04); //设置RXB0CTRL -接收缓冲器0控制寄存器－
  69.     //接收符合滤波器条件的所有带扩展标识符或标准标识符的有效报文
  70.     //如果RXB0 满， RXB0 接收到的报文将被滚存至RXB1
  71.     MCP2510_BitModi(0x70, 0x60, 0x00); //设置RXB1CTRL -接收缓冲器 1 控制寄存器－
  72.     //接收符合滤波器条件的所有带扩展标识符或标准标识符的有效报文

  74.     //MCP2510_Write(0x2A, 0x02); //设置CNF1
  75.     MCP2510_Write(0x2A, 0x03); //设置CNF1
  76.     MCP2510_Write(0x29, 0x9E); //设置CNF2
  77.     MCP2510_Write(0x28, 0x03); //设置CNF3，设置波特率为125Kbps/s(1, 7, 4, 4)

  79.     MCP2510_Write(0x2C, 0x0); //清空中断标志
  80.     MCP2510_BitModi(0x0F, 0xE0, 0x00); //设置MCP2510为正常模式
  81.     result = 0;
  82. err:

  84.     return result;
  85. }

下面是向canbus总线写入数据

点击(此处)折叠或打开

  1. /***********************************************************************
  2.  *
  3.  * input: SendMsg
  4.  * output:
  5.  * return:
  6.  *
  7.  * descript:
  8.  * send canbus frame via spi interface
  9.  *
  10.  ***********************************************************************/
  11. int __mcp2510Pkt_write(struct CANBus_Message* SendMsg)
  12. {
  13.     int i = 0;
  14.     unsigned char reg;

  16.     if(host.iEnable == 0) /** disable host. don't send data **/
  17.     {
  18.         printk("[%s-%d]Info: host disable !!!\n", __func__, __LINE__);
  19.         return SendMsg->Length;
  20.     }

  22. #if 0
  23.     //读三个发送缓冲器寄存器，以确定哪个发送缓冲器可用。
  24.     for(i = 0; i < 3; i++)
  25.     {
  26.         if(!(MCP2510_Read(TXBnCTRL[i]) & 0x08))
  27.             break;
  28.     }
  29.     //三个缓冲器都不可用，返回错误
  30.     if(i == 3)
  31.     {
  32.         //printk("[%s-%d]Warning: All 3 TX-buffer are busy \n", __func__, __LINE__);
  33.         return -EBUSY;
  34.     }
  35. #else
  36.     /*** 只使用一个缓冲器，牺牲性能，保证顺序. 测试比较得出：牺牲的性能微不足道 ***/
  37.     i = 0;
  38.     if((MCP2510_Read(TXBnCTRL[i]) & 0x08))
  39.     {
  40.         return -EBUSY;
  41.     }
  42. #endif
  43.     
  44.     PLOG("[%s-%d]: Message Length: 0x%x,\tSID: 0x%x, EID: 0x%x, RTR: 0x%x\n sndMessage: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
  45.             __func__, __LINE__,
  46.             SendMsg->Length,
  47.             SendMsg->SID,
  48.             SendMsg->EID,
  49.             SendMsg->RTR,
  50.             SendMsg->Messages[0],
  51.             SendMsg->Messages[1],
  52.             SendMsg->Messages[2],
  53.             SendMsg->Messages[3],
  54.             SendMsg->Messages[4],
  55.             SendMsg->Messages[5],
  56.             SendMsg->Messages[6],
  57.             SendMsg->Messages[7]);
  58.     /** Start send process **/
  59.     MCP2510_CS_L;
  60.     iowrite8(0x02, (void *)SPTDAT0);
  61.     while(!SPI0_READY);
  62.     iowrite8(TXBnCTRL[i] + 1, (void *)SPTDAT0);
  63.     while(!SPI0_READY);
  64.     reg = SendMsg->SID >> 3;
  65.     iowrite8(reg, (void *)SPTDAT0);
  66.     while(!SPI0_READY);
  67.     reg = (unsigned char)(SendMsg->SID << 5);
  68.     reg =reg |(SendMsg->EID >> 16);
  69.     //if(SendMsg->EID)
  70.     if(1)
  71.     {
  72.         reg |= (1 << 3);
  73.     }
  74.     iowrite8(reg, (void *)SPTDAT0);
  75.     while(!SPI0_READY);
  76.     reg = (unsigned char)(SendMsg->EID >> 8);
  77.     iowrite8(reg, (void *)SPTDAT0);
  78.     while(!SPI0_READY);
  79.     reg = (unsigned char)SendMsg->EID;
  80.     iowrite8(reg, (void *)SPTDAT0);
  81.     while(!SPI0_READY);
  82.     if(SendMsg->Length > 8)
  83.     {
  84.         printk("[%s-%d]: the length of data is %d grate than 8 !!! \n", __func__, __LINE__, SendMsg->Length);
  85.         //SendMsg->Length = 8;
  86.     }
  87.     iowrite8(SendMsg->Length | (SendMsg->RTR << 6), (void *)SPTDAT0);

  89.     for(reg = 0; reg < SendMsg->Length; reg++)
  90.     {
  91.         while(!SPI0_READY);
  92.         iowrite8(SendMsg->Messages[reg], (void *)SPTDAT0);
  93.     }
  94.     while(!SPI0_READY);
  95.     //printk("[%s-%d]: %d bytes date had been sent ! \n", __func__, __LINE__, SendMsg->Length);
  96.     MCP2510_CS_H;

  98.     MCP2510_BitModi(TXBnCTRL[i], 0x08, 0x08);

  100.     return SendMsg->Length;

  102. }
下面是中断上下文从canbus总线读取数据

点击(此处)折叠或打开

  1. /*************************************************************************************
  2.  *
  3.  * Function __mcp2510Pkt_read
  4.  *
  5.  * input: intrNum
  6.  * output: pRcvMsg
  7.  * return:
  8.  *
  9.  * descriptor:
  10.  *
  11.  *************************************************************************************/
  12. static int __mcp2510Pkt_read(struct CANBus_Message* pRcvMsg, unsigned char intrNum)
  13. {
  14.     unsigned char revAddr;
  15.     unsigned char uMes;
  16.     //int ret;

  18.     revAddr = (intrNum << 3) + 1; //得到触发中断的接收缓冲器寄存器的地址

  20.     /** read SID/EID/RTR/Length **/
  21.     MCP2510_CS_L;
  22.     while(!SPI0_READY);
  23.     iowrite8(0x03, (void *)SPTDAT0);
  24.     while(!SPI0_READY);
  25.     iowrite8(revAddr, (void *)SPTDAT0);
  26.     while(!SPI0_READY);
  27.     iowrite8(0xFF, (void *)SPTDAT0);
  28.     while(!SPI0_READY);
  29.     pRcvMsg->SID = ioread8((void *)SPRDAT0) << 3;
  30.     iowrite8(0xFF, (void *)SPTDAT0);
  31.     while(!SPI0_READY);
  32.     uMes = ioread8((void *)SPRDAT0);
  33.     pRcvMsg->SID |= (uMes >> 5);
  34.     pRcvMsg->EID = ((uMes << 16) & 0x3ffff);
  35.     if(!(uMes & 0x08))
  36.     {
  37.         pRcvMsg->RTR = (uMes >> 4) & 0x1;
  38.     }
  39.     iowrite8(0xFF, (void *)SPTDAT0);
  40.     while(!SPI0_READY);
  41.     pRcvMsg->EID |= (ioread8((void *)SPRDAT0) << 8);
  42.     iowrite8(0xFF, (void *)SPTDAT0);
  43.     while(!SPI0_READY);
  44.     pRcvMsg->EID |= ioread8((void *)SPRDAT0);
  45.     iowrite8(0xFF, (void *)SPTDAT0);
  46.     while(!SPI0_READY);
  47.     revAddr = ioread8((void *)SPRDAT0);
  48.     if(uMes & 0x08)
  49.     {
  50.         pRcvMsg->RTR = (revAddr >> 6) & 0x1;
  51.     }
  52.     pRcvMsg->Length = revAddr & 0x0F;
  53.     if (pRcvMsg->Length > 8)
  54.     {
  55.         PLOG("[%s-%d]: Message Length is:%u \n", __func__, __LINE__, pRcvMsg->Length);
  56.         pRcvMsg->Length = 8;
  57.     }
  58.     /** read data **/
  59.     for(uMes = 0; uMes < pRcvMsg->Length; uMes++)
  60.     {
  61.         iowrite8(0xFF, (void *)SPTDAT0);
  62.         while(!SPI0_READY);
  63.         pRcvMsg->Messages[uMes] = ioread8((void *)SPRDAT0);
  64.     }
  65.     while(!SPI0_READY);
  66.     MCP2510_CS_H;
  67.     /** Clear interrupt flag **/
  68.     uMes = (intrNum >> 1) - 5;
  69.     MCP2510_BitModi(0x2C, uMes, 0);

  71.     return 1;
  72. }


阅读(1276) | 评论(0) | 转发(0) |
0

上一篇：canbus驱动备忘、一

下一篇：canbus驱动备忘、三

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6