can总线驱动的编写

转自http://blog.csdn.net/askbai666888/article/details/8949108

一.系统硬件结构介绍

       系统中 CAN 总线主要用来完成 S3C2410 开发板和 CAN 总线分析仪的数据传输。在S3C2410 开发平台上,MCP2515 芯片用作 CAN 控制器,MCP2551 芯片用作 CAN 收发器,S3C2410 微处理器用作节点控制器。如下图1所示。

can总线驱动的编写_第1张图片


1.1 S3C2410 的 SPI 接口简介
           SPI( Serial Peripheral Interface) 是一个同步串行外围接口,允许 MCU 与各种外围设备以串行方式进行通信。S3C2410 微处理器包括两路 SPI,每一路分别有两个 8 位转移寄存器,用来发送和接收数据。在 SPI 进行传输时,数据同时发送和接收。如果只想发送数据,接收到的数据将是无效的;如果只想接收数据,应当发送全是 1 的数据。
1.2 MCP2551 功能简介
         MCP2551 是 CAN 协议控制器和物理总线之间的接口。这个器件向总线提供了差动的发送能力,向 CAN 控制器提供了差动的接收能力。
1.3 MCP2515 功能简介
         MCP2515是一款独立CAN控制器,是为简化连接CAN总线的应用而开发的。图2 简要显示了MCP2515的结构框图[3]。该器件主要由三个部分组成:

can总线驱动的编写_第2张图片

(1)CAN 协议引擎(处理所有总线上的报文发送和接收) ;
(2)用来为器件及其运行进行配置的控制逻辑和SRAM寄存器;
(3 )SPI协议模块,用来实现SPI通信模式。
二. 驱动程序设计

驱动源码:

[cpp] view plain copy print ?
  1. /* 
  2.  * Microchip MCP2515 CAN controller driver. 
  3.  * 
  4.  * Copyright (C) 2007 Embedall Technology Co., Ltd. 
  5.  * 
  6.  * This program is free software; you can redistribute it and/or modify 
  7.  * it under the terms of the GNU General Public License as published by 
  8.  * the Free Software Foundation; either version 2 of the License, or 
  9.  * (at your option) any later version. 
  10.  */  
  11. #include   
  12. #include   
  13. #include   
  14. #include   
  15. #include   
  16. #include   
  17. #include   
  18. #include   
  19. #include   
  20. #include   
  21. #include   
  22. #include   
  23. #include   
  24. #include   
  25. #include   
  26. #include   
  27. #include   
  28. #include   
  29. #include   
  30.   
  31. /* SPI interface instruction set */  
  32. #define INSTRUCTION_WRITE       0x02  
  33. #define INSTRUCTION_READ        0x03  
  34. #define INSTRUCTION_BIT_MODIFY  0x05  
  35. #define INSTRUCTION_LOAD_TXB(n) (0x40 + 2 * (n))  
  36. #define INSTRUCTION_READ_RXB(n) (0x90 + 4 * (n))  
  37. #define INSTRUCTION_RESET       0xc0  
  38. #define INSTRUCTION_RTS(n)  (0x80 + (1<  
  39. #define INSTRUCTION_RX_STATE    0xb0  
  40. #  define RX_STATE_RTR       0x04  
  41. #  define RX_STATE_IDE       0x08  
  42. #define INSTRUCTION_CAN_STATE   0xa0  
  43. #  define CAN_STATE_TX2IF    0x01  
  44. #  define CAN_STATE_TX2REQ   0x02  
  45. #  define CAN_STATE_TX1IF    0x04  
  46. #  define CAN_STATE_TX1REQ       0x08  
  47. #  define CAN_STATE_TX0IF        0x10  
  48. #  define CAN_STATE_TX0REQ   0x20  
  49. #  define CAN_STATE_RX1IF    0x40  
  50. #  define CAN_STATE_RX0IF    0x80  
  51.   
  52. /* MPC251x registers */  
  53. #define CANSTAT           0x0e  
  54. #define CANCTRL           0x0f  
  55. #  define CANCTRL_REQOP_MASK        0xe0  
  56. #  define CANCTRL_REQOP_CONF        0x80  
  57. #  define CANCTRL_REQOP_LISTEN_ONLY 0x60  
  58. #  define CANCTRL_REQOP_LOOPBACK    0x40  
  59. #  define CANCTRL_REQOP_SLEEP       0x20  
  60. #  define CANCTRL_REQOP_NORMAL      0x00  
  61. #  define CANCTRL_OSM               0x08  
  62. #  define CANCTRL_ABAT              0x10  
  63. #define TEC           0x1c  
  64. #define REC           0x1d  
  65. #define CNF1          0x2a  
  66. #define CNF2          0x29  
  67. #  define CNF2_BTLMODE  0x80  
  68. #define CNF3          0x28  
  69. #  define CNF3_SOF      0x08  
  70. #  define CNF3_WAKFIL   0x04  
  71. #  define CNF3_PHSEG2_MASK 0x07  
  72. #define CANINTE       0x2b  
  73. #  define CANINTE_MERRE 0x80  
  74. #  define CANINTE_WAKIE 0x40  
  75. #  define CANINTE_ERRIE 0x20  
  76. #  define CANINTE_TX2IE 0x10  
  77. #  define CANINTE_TX1IE 0x08  
  78. #  define CANINTE_TX0IE 0x04  
  79. #  define CANINTE_RX1IE 0x02  
  80. #  define CANINTE_RX0IE 0x01  
  81. #define CANINTF       0x2c  
  82. #  define CANINTF_MERRF 0x80  
  83. #  define CANINTF_WAKIF 0x40  
  84. #  define CANINTF_ERRIF 0x20  
  85. #  define CANINTF_TX2IF 0x10  
  86. #  define CANINTF_TX1IF 0x08  
  87. #  define CANINTF_TX0IF 0x04  
  88. #  define CANINTF_RX1IF 0x02  
  89. #  define CANINTF_RX0IF 0x01  
  90. #define EFLG          0x2d  
  91. #  define EFLG_RX1OVR   0x80  
  92. #  define EFLG_RX0OVR   0x40  
  93. #define TXBCTRL(n)  ((n * 0x10) + 0x30)  
  94. #  define TXBCTRL_TXREQ  0x08  
  95. #  define TXBCTRL_TXPRI(n) (n)  
  96. #  define TXBCTRL_TXERR    (1 << 4)  
  97. #  define TXBCTRL_MLOA     (1 << 5)  
  98. #  define TXBCTRL_ABTF     (1 << 6)  
  99. #define RXBCTRL(n)  ((n * 0x10) + 0x60)  
  100. #  define RXBCTRL_MASK   0x60  
  101. #  define RXBCTRL_RXRTR  0x08  
  102. #  define RXBCTRL_BULK  (1 << 2)  
  103. #  define RXBCTRL_RXM_MACH_ALL  (0 << 6)  
  104. #  define RXBCTRL_RXM_MACH_STD  (1 << 6)  
  105. #  define RXBCTRL_RXM_MACH_EXT  (2 << 6)  
  106. #  define RXBCTRL_TXM_MACH_OFF  (3 << 6)  
  107. #  define RXBCTRL_FILHIT_MASK    0x07  
  108. #define RXM_BASE(n)   (0x20 + (n *  4))  
  109. #define RXF_BASE(n)   ((n>2)?(0x10 + (n-3)*4):(0x00 + (n*4)))  
  110.       
  111.       
  112.   
  113. #define SJW1            0x00  
  114. #define SJW2            0x40  
  115. #define SJW3            0x80  
  116. #define SJW4            0xC0  
  117.   
  118. #define BTLMODE_CNF3    0x80  
  119.   
  120. #define SEG1            0x00  
  121. #define SEG2            0x01  
  122. #define SEG3            0x02  
  123. #define SEG4            0x03  
  124. #define SEG5            0x04  
  125. #define SEG6            0x05  
  126. #define SEG7            0x06  
  127. #define SEG8            0x07  
  128.   
  129. #define BRP1            0x00  
  130. #define BRP2            0x01  
  131. #define BRP3            0x02  
  132. #define BRP4            0x03  
  133. #define BRP5            0x04  
  134. #define BRP6            0x05  
  135. #define BRP7            0x06  
  136. #define BRP8            0x07  
  137.   
  138. //#define CAN_FOSC_12MHZ  
  139. #define CAN_FOSC_16MHZ  
  140.   
  141. #if defined(CAN_FOSC_12MHZ)  
  142. #define CAN_CNF1_10K        (SJW3 | 0x1d)  
  143. #define CAN_CNF2_10K        (BTLMODE_CNF3|(SEG6<<3)|SEG7)  
  144. #define CAN_CNF3_10K        (SEG6)  
  145.   
  146. #define CAN_CNF1_20K        (SJW2 | 0x0E)  
  147. #define CAN_CNF2_20K        (BTLMODE_CNF3|(SEG6<<3)|SEG7)  
  148. #define CAN_CNF3_20K        (SEG6)  
  149.   
  150. #define CAN_CNF1_50K        (SJW1 | 0x05)  
  151. #define CAN_CNF2_50K        (BTLMODE_CNF3|(SEG6<<3)|SEG7)  
  152. #define CAN_CNF3_50K        (SEG6)  
  153.   
  154. #define CAN_CNF1_100K       (SJW1 | BRP3)  
  155. #define CAN_CNF2_100K       (BTLMODE_CNF3|(SEG6<<3)|SEG7)  
  156. #define CAN_CNF3_100K       (SEG6)  
  157.   
  158. #define CAN_CNF1_125K       (SJW1 | BRP3)  
  159. #define CAN_CNF2_125K       (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  160. #define CAN_CNF3_125K       (SEG4)  
  161.   
  162. #define CAN_CNF1_250K       (SJW1 | BRP2)  
  163. #define CAN_CNF2_250K       (BTLMODE_CNF3|(SEG3<<3)|SEG5)  
  164. #define CAN_CNF3_250K       (SEG3)  
  165.   
  166. #define CAN_CNF1_500K       (SJW1 | BRP1)  
  167. #define CAN_CNF2_500K       (BTLMODE_CNF3|(SEG3<<3)|SEG5)  
  168. #define CAN_CNF3_500K       (SEG3)  
  169.   
  170. #define CAN_CNF1_750K       (SJW1 | BRP1)  
  171. #define CAN_CNF2_750K       (BTLMODE_CNF3|(SEG3<<2)|SEG1)  
  172. #define CAN_CNF3_750K       (SEG3)  
  173.   
  174. #define CAN_CNF1_1000K      (SJW1 | BRP1)  
  175. #define CAN_CNF2_1000K      (BTLMODE_CNF3|(SEG2<<3)|SEG1)  
  176. #define CAN_CNF3_1000K      (SEG2)  
  177. #elif defined(CAN_FOSC_16MHZ)  
  178. #define CAN_CNF1_10K        (SJW1 | 0x31)  
  179. #define CAN_CNF2_10K        (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  180. #define CAN_CNF3_10K        (SEG4)  
  181.   
  182. #define CAN_CNF1_20K        (SJW1 | 0x18)  
  183. #define CAN_CNF2_20K        (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  184. #define CAN_CNF3_20K        (SEG4)  
  185.   
  186. #define CAN_CNF1_50K        (SJW1 | 0x09)  
  187. #define CAN_CNF2_50K        (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  188. #define CAN_CNF3_50K        (SEG4)  
  189.   
  190. #define CAN_CNF1_100K       (SJW1 | BRP5)  
  191. #define CAN_CNF2_100K       (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  192. #define CAN_CNF3_100K       (SEG4)  
  193.   
  194. #define CAN_CNF1_125K       (SJW1 | BRP4)  
  195. #define CAN_CNF2_125K       (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  196. #define CAN_CNF3_125K       (SEG4)  
  197.   
  198. #define CAN_CNF1_250K       (SJW1 | BRP2)  
  199. #define CAN_CNF2_250K       (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  200. #define CAN_CNF3_250K       (SEG4)  
  201.   
  202. #define CAN_CNF1_500K       (SJW1 | BRP1)  
  203. #define CAN_CNF2_500K       (BTLMODE_CNF3|(SEG4<<3)|SEG7)  
  204. #define CAN_CNF3_500K       (SEG4)  
  205.   
  206. #define CAN_CNF1_750K       (SJW1 | BRP1)  
  207. #define CAN_CNF2_750K       (BTLMODE_CNF3|(SEG3<<3)|SEG4)  
  208. #define CAN_CNF3_750K       (SEG3)  
  209.   
  210. #define CAN_CNF1_800K       (SJW1 | BRP1)  
  211. #define CAN_CNF2_800K       (BTLMODE_CNF3|(SEG3<<3)|SEG3)  
  212. #define CAN_CNF3_800K       (SEG3)  
  213.   
  214. #define CAN_CNF1_1000K      (SJW1 | BRP1)  
  215. #define CAN_CNF2_1000K      (BTLMODE_CNF3|(SEG2<<3)|SEG3)  
  216. #define CAN_CNF3_1000K      (SEG2)  
  217. #endif  /* end define CAN_FOSC_12MHZ */  
  218.   
  219. /* Buffer size required for the largest SPI transfer (i.e., reading a frame). 
  220.  */  
  221. #define SPI_TRANSFER_BUF_LEN (2*(6 + CAN_FRAME_MAX_DATA_LEN))  
  222.   
  223. /* Buffer size required for ring buffer of receive and send */  
  224. #define MCP251X_BUF_LEN 8  
  225.   
  226.   
  227.   
  228. #define CAN_DEV_MAX 8  
  229.   
  230. #define DRIVER_NAME "mcp2515"  
  231.   
  232. static dev_t can_devt;  
  233.   
  234. static int can_minor = 0;  
  235.   
  236. static struct class *can_class;  
  237.   
  238. static int write_udelay=1024;  
  239.   
  240. struct mcp251x {  
  241.     struct cdev cdev;  
  242.     //struct class_device *class_dev;  
  243.     struct device *class_dev;  
  244.     struct semaphore lock;   /* semaphore for spi bus share. */  
  245.     struct semaphore rxblock;    /* semaphore for ring buffer of receive. */  
  246.     struct semaphore txblock;    /* semaphore for ring buffer of send. */  
  247.       
  248.     uint8_t *spi_transfer_buf;   /* temp buffer for spi bus transfer. */  
  249.   
  250.     struct can_frame rxb[MCP251X_BUF_LEN]; /* ring buffer for receive. */  
  251.     struct can_frame txb[MCP251X_BUF_LEN]; /* ring buffer for send. */  
  252.       
  253.     int txbin;           /* pos of in for ring buffer of send. */  
  254.     int txbout;          /* pos of out for ring buffer of send. */  
  255.     int rxbin;           /* pos of in for ring buffer of receive. */  
  256.     int rxbout;          /* pos of out for ring buffer of receive. */  
  257.       
  258.     int bit_rate;        /* save bit rate of current set. */  
  259.     int count;           /* count of the device opened. */  
  260.       
  261.     wait_queue_head_t wq;    /* queue for read process. */  
  262.       
  263.     struct work_struct irq_work; /* bottom half of interrupt task. */  
  264.       
  265.     struct spi_device *spi;  /* save the point of struce spi_device. */  
  266.     struct can_filter filter;    /* save the filter data of current set. */  
  267. };  
  268.   
  269. /* ........................................................................ */  
  270.   
  271. #if 0  
  272. static void mcp251x_start_tx(struct spi_device *spi, uint8_t buf_idx)  
  273. {  
  274.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  275.     uint8_t *tx_buf;  
  276.     int ret;  
  277.       
  278.     tx_buf = chip->spi_transfer_buf;  
  279.       
  280.     down(&chip->lock);  
  281.       
  282.     tx_buf[0] = INSTRUCTION_RTS(buf_idx);  
  283.     ret = spi_write(spi, chip->spi_transfer_buf, 1);  
  284.     if (ret < 0)  
  285.         dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret);  
  286.   
  287.     up(&chip->lock);  
  288. }  
  289. #endif  
  290.   
  291. static uint8_t mcp251x_read_state(struct spi_device *spi, uint8_t cmd)  
  292. {  
  293.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  294.     uint8_t *tx_buf, *rx_buf;  
  295.     uint8_t val;  
  296.     int ret;  
  297.   
  298.     tx_buf = chip->spi_transfer_buf;  
  299.     rx_buf = chip->spi_transfer_buf + 8;  
  300.   
  301.     down(&chip->lock);  
  302.       
  303.     tx_buf[0] = cmd;  
  304.     ret = spi_write_then_read(spi, tx_buf, 1, rx_buf, 1);  
  305.     if (ret < 0) {  
  306.         dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret);  
  307.         val = 0;  
  308.     } else  
  309.         val = rx_buf[0];  
  310.   
  311.     up(&chip->lock);  
  312.   
  313.     return val;  
  314. }  
  315.   
  316.   
  317. static uint8_t mcp251x_read_reg(struct spi_device *spi, uint8_t reg)  
  318. {  
  319.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  320.     uint8_t *tx_buf, *rx_buf;  
  321.     uint8_t val;  
  322.     int ret;  
  323.   
  324.     tx_buf = chip->spi_transfer_buf;  
  325.     rx_buf = chip->spi_transfer_buf + 8;  
  326.   
  327.     down(&chip->lock);  
  328.       
  329.     tx_buf[0] = INSTRUCTION_READ;  
  330.     tx_buf[1] = reg;  
  331.     ret = spi_write_then_read(spi, tx_buf, 2, rx_buf, 1);  
  332.     if (ret < 0) {  
  333.         dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret);  
  334.         val = 0;  
  335.     } else  
  336.         val = rx_buf[0];  
  337.   
  338.     up(&chip->lock);  
  339.   
  340.     return val;  
  341. }  
  342.   
  343.   
  344. static void mcp251x_write_reg(struct spi_device *spi, uint8_t reg, uint8_t val)  
  345. {  
  346.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  347.     int ret;  
  348.   
  349.     down(&chip->lock);  
  350.   
  351.     chip->spi_transfer_buf[0] = INSTRUCTION_WRITE;  
  352.     chip->spi_transfer_buf[1] = reg;  
  353.     chip->spi_transfer_buf[2] = val;  
  354.   
  355.     ret = spi_write(spi, chip->spi_transfer_buf, 3);  
  356.     if (ret < 0)  
  357.         dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret);  
  358.   
  359.     up(&chip->lock);  
  360. }  
  361.   
  362.   
  363. static void mcp251x_write_bits(struct spi_device *spi, uint8_t reg, uint8_t mask, uint8_t val)  
  364. {  
  365.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  366.     int ret;  
  367.   
  368.     down(&chip->lock);  
  369.   
  370.     chip->spi_transfer_buf[0] = INSTRUCTION_BIT_MODIFY;  
  371.     chip->spi_transfer_buf[1] = reg;  
  372.     chip->spi_transfer_buf[2] = mask;  
  373.     chip->spi_transfer_buf[3] = val;  
  374.   
  375.     ret = spi_write(spi, chip->spi_transfer_buf, 4);  
  376.     if (ret < 0)  
  377.         dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret);  
  378.   
  379.     up(&chip->lock);  
  380. }  
  381.   
  382. static void mcp251x_hw_reset(struct spi_device *spi)  
  383. {  
  384.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  385.     int ret;  
  386.   
  387.     down(&chip->lock);  
  388.   
  389.     chip->spi_transfer_buf[0] = INSTRUCTION_RESET;  
  390.   
  391.     ret = spi_write(spi, chip->spi_transfer_buf, 1);  
  392.     if (ret < 0)  
  393.         dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret);  
  394.       
  395.     up(&chip->lock);  
  396. }  
  397.   
  398.   
  399. static void __devinit mcp251x_hw_init(struct spi_device *spi)  
  400. {  
  401.     mcp251x_hw_reset(spi);    
  402.     mcp251x_write_reg(spi,0x0c,0x0c);  
  403. }  
  404.   
  405. static void mcp251x_hw_sleep(struct spi_device *spi)  
  406. {  
  407. #if 0   /* sleep disable */  
  408.     mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_SLEEP);  
  409. #endif  
  410. }  
  411.   
  412. static void mcp251x_hw_wakeup(struct spi_device *spi)  
  413. {  
  414.     /* Can only wake up by generating a wake-up interrupt. */  
  415.     mcp251x_write_bits(spi, CANINTE, CANINTE_WAKIE, CANINTE_WAKIE);  
  416.     mcp251x_write_bits(spi, CANINTF, CANINTF_WAKIF, CANINTF_WAKIF);  
  417.     mdelay(10);  
  418. }  
  419.   
  420.   
  421. static int mcp251x_set_bit_rate(struct spi_device *spi, int bit_rate)  
  422. {  
  423.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  424.     unsigned char canctrl,val;  
  425. #if 0  
  426.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
  427.     int tqs; /* tbit/TQ */  
  428.     int brp;  
  429.     int ps1, ps2, propseg, sjw;  
  430.   
  431.     /* Determine the BRP value that gives the requested bit rate. */  
  432.     for(brp = 0; brp < 8; brp++) {  
  433.         tqs = pdata->f_osc / (2 * (brp + 1)) / bit_rate;  
  434.         if (tqs >= 5 && tqs <= 25  
  435.             && (pdata->f_osc / (2 * (brp + 1)) / tqs) == bit_rate)  
  436.             break;  
  437.     }  
  438.     if (brp >= 8)  
  439.         return -EINVAL;  
  440.   
  441.     /* The CAN bus bit time (tbit) is determined by: 
  442.      *   tbit = (SyncSeg + PropSeg + PS1 + PS2) * TQ 
  443.      * with: 
  444.      *     SyncSeg = 1 
  445.      *     sample point (between PS1 and PS2) must be at 60%-70% of the bit time 
  446.      *     PropSeg + PS1 >= PS2 
  447.      *     PropSeg + PS1 >= Tdelay 
  448.      *     PS2 > SJW 
  449.      *     1 <= PropSeg <= 8, 1 <= PS1 <=8, 2 <= PS2 <= 8 
  450.      * SJW = 1 is sufficient in most cases. 
  451.      * Tdelay is usually 1 or 2 TQ. 
  452.      */  
  453.   
  454.     propseg = ps1 = ps2 = (tqs - 1) / 3;  
  455.     if (tqs - (1 + propseg + ps1 + ps2) == 2)  
  456.         ps1++;  
  457.     if (tqs - (1 + propseg + ps1 + ps2) == 1)  
  458.         ps2++;  
  459.     sjw = 1;  
  460.       
  461.     printk("bit rate: BRP = %d, Tbit = %d TQ, PropSeg = %d, PS1 = %d, PS2 = %d, SJW = %d\n",  
  462.         brp, tqs, propseg, ps1, ps2, sjw);  
  463.   
  464.     dev_dbg(&spi->dev,"bit rate: BRP = %d, Tbit = %d TQ, PropSeg = %d, PS1 = %d, PS2 = %d, SJW = %d\n",  
  465.         brp, tqs, propseg, ps1, ps2, sjw);  
  466.   
  467.     mcp251x_write_reg(spi, CNF1, ((sjw-1) << 6) | brp);  
  468.     mcp251x_write_reg(spi, CNF2, CNF2_BTLMODE | ((ps1-1) << 3) | (propseg-1));  
  469.     mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK, (ps2-1));  
  470.     chip->bit_rate = pdata->f_osc / (2 * (brp + 1)) / tqs;  
  471. #endif  
  472. #if 1  
  473.     canctrl = mcp251x_read_reg(spi, CANCTRL);  
  474. /*  if(canctrl == 0) { 
  475.         printk("mcp2515 read CANCTRL reg error!\n"); 
  476.         return -1; 
  477.     } else { 
  478.         printk("mcp2515 read CANCTRL reg [%x] ok!\n", canctrl); 
  479.     }*/  
  480.     do {  
  481.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_CONF);  
  482.         val = mcp251x_read_reg(spi, CANCTRL);  
  483.     }while((val&0xe0) != CANCTRL_REQOP_CONF);  
  484.               
  485.     switch(bit_rate) {  
  486.         case 10000:  
  487.             /* save the state and put it to config mode. */  
  488.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_10K);  
  489.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_10K);  
  490.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_10K);  
  491.             write_udelay=12800;  
  492.         break;  
  493.           
  494.         case 20000:  
  495.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_20K);  
  496.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_20K);  
  497.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_20K);  
  498.             write_udelay=6400;  
  499.         break;  
  500.           
  501.         case 50000:  
  502.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_50K);  
  503.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_50K);  
  504.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_50K);  
  505.             write_udelay=2560;  
  506.         break;  
  507.           
  508.         case 100000:  
  509.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_100K);  
  510.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_100K);  
  511.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_100K);  
  512.             write_udelay=1280;  
  513.         break;  
  514.           
  515.         case 125000:  
  516.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_125K);  
  517.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_125K);  
  518.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_125K);  
  519.             write_udelay=1024;  
  520.         break;  
  521.           
  522.         case 250000:  
  523.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_250K);  
  524.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_250K);  
  525.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_250K);  
  526.             write_udelay=512;  
  527.         break;  
  528.   
  529.         case 500000:  
  530.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_500K);  
  531.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_500K);  
  532.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_500K);  
  533.             write_udelay=256;  
  534.         break;  
  535.           
  536.         case 750000:  
  537.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_750K);  
  538.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_750K);  
  539.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_750K);  
  540.             write_udelay=171;  
  541.         break;  
  542.   
  543.         case 800000:  
  544.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_800K);  
  545.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_800K);  
  546.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_800K);  
  547.             write_udelay=160;  
  548.         break;  
  549.   
  550.         case 1000000:  
  551.             mcp251x_write_reg(spi, CNF1, CAN_CNF1_1000K);  
  552.             mcp251x_write_reg(spi, CNF2, CAN_CNF2_1000K);  
  553.             mcp251x_write_reg(spi, CNF3, CAN_CNF3_1000K);  
  554.             write_udelay=128;  
  555.         break;  
  556.   
  557.         default:  
  558.             printk(": baud rate %d not support\n", bit_rate);  
  559.         break;  
  560.     }     
  561.     mcp251x_write_reg(spi, CANCTRL, canctrl);  
  562.     chip->bit_rate = bit_rate;  
  563. #endif  
  564.       
  565.     return 0;  
  566. }  
  567.   
  568. static int mcp251x_get_bit_rate(struct spi_device *spi)  
  569. {  
  570.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  571.   
  572.     return chip->bit_rate;  
  573. }  
  574.   
  575. static int mcp251x_set_filter(struct spi_device *spi, struct can_filter *filter)  
  576. {  
  577.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  578.       
  579.     uint8_t canctrl;  
  580.     uint8_t local_buf;  
  581.     int i;  
  582.       
  583.     canctrl = mcp251x_read_reg(spi, CANCTRL);  
  584.       
  585.     mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_CONF);  
  586.   
  587.     for (i=0; i
  588.         if (filter->fid[i].active == 0) {  
  589.             local_buf = 0;  
  590.             mcp251x_write_reg(spi, RXF_BASE(i)+0, local_buf);  
  591. #if 1     
  592.             /* set RXFnSIDL  EXIDE(bit 3) = 0 for receive standard frame */  
  593.             mcp251x_write_reg(spi, RXF_BASE(i)+1, local_buf);  
  594. #else       /* set RXFnSIDL  EXIDE(bit 3) = 1 for receive extend frame */         
  595.             mcp251x_write_reg(spi, RXF_BASE(i)+1, local_buf | 0x08);  
  596. #endif            
  597.             mcp251x_write_reg(spi, RXF_BASE(i)+2, local_buf);  
  598.             mcp251x_write_reg(spi, RXF_BASE(i)+3, local_buf);  
  599.             continue;  
  600.         }  
  601.         local_buf = filter->fid[i].id >> 3;  
  602.         mcp251x_write_reg(spi, RXF_BASE(i)+0, local_buf);  
  603.         local_buf = (filter->fid[i].id << 5) | (filter->fid[i].ide << 3) | (filter->fid[i].eid >> 16);  
  604. #if 1         
  605.         mcp251x_write_reg(spi, RXF_BASE(i)+1, local_buf);     
  606. #else         
  607.         mcp251x_write_reg(spi, RXF_BASE(i)+1, local_buf | 0x08);      
  608. #endif        
  609.         local_buf = filter->fid[i].eid >> 8;  
  610.         mcp251x_write_reg(spi, RXF_BASE(i)+2, local_buf);  
  611.         local_buf = filter->fid[i].eid;  
  612.         mcp251x_write_reg(spi, RXF_BASE(i)+3, local_buf);  
  613.     }  
  614.     for (i=0; i<2; i++) {  
  615.         local_buf = filter->sidmask >> 3;  
  616.         mcp251x_write_reg(spi, RXM_BASE(i)+0, local_buf);  
  617.         local_buf = (filter->sidmask << 5) | (filter->eidmask >> 16);  
  618.         mcp251x_write_reg(spi, RXM_BASE(i)+1, local_buf);  
  619.         local_buf = filter->eidmask >> 8;  
  620.         mcp251x_write_reg(spi, RXM_BASE(i)+2, local_buf);  
  621.         local_buf = filter->eidmask;  
  622.         mcp251x_write_reg(spi, RXM_BASE(i)+3, local_buf);  
  623.     }  
  624.       
  625.     mcp251x_write_reg(spi, CANCTRL, canctrl);  
  626.       
  627.     /* set receive buffer work mode */        
  628.     mcp251x_write_bits(spi, RXBCTRL(0), RXBCTRL_MASK, filter->mode << 5);  
  629.     mcp251x_write_bits(spi, RXBCTRL(1), RXBCTRL_MASK, filter->mode << 5);  
  630.       
  631.     memcpy(&chip->filter, filter, sizeof(struct can_filter));  
  632.       
  633.     return 0;  
  634. }  
  635.   
  636. static int mcp251x_get_filter(struct spi_device *spi, struct can_filter *filter)  
  637. {  
  638.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  639.   
  640.     memcpy(filter, &chip->filter, sizeof(struct can_filter));  
  641.           
  642.     return 0;     
  643. }  
  644.   
  645. /* If MCP251X ready, copy data from ring buffer to MCP251X send buffer and set 
  646.  * TXBCTRL_TXREQ. 
  647.  */  
  648. static int mcp251x_hw_tx(struct spi_device *spi, int tx_buf_idx)  
  649. {  
  650.   
  651.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  652.     uint8_t buf[13] ;  
  653. //  unsigned char val;  
  654.     struct can_frame *frame;  
  655. //  int ret;  
  656.     int i;  
  657.       
  658.   
  659.     dev_dbg(&spi->dev,"%s()\n", __FUNCTION__);  
  660.   
  661.     if (chip->txbout != chip->txbin) {  
  662.   
  663.         if (down_interruptible(&chip->txblock))  
  664.             return -ERESTARTSYS;  
  665.           
  666.         frame = &chip->txb[chip->txbout];  
  667.               
  668.     //  down(&chip->lock);  
  669.               
  670.         if (frame->header.dlc > CAN_FRAME_MAX_DATA_LEN)  
  671.             frame->header.dlc = CAN_FRAME_MAX_DATA_LEN;  
  672.         if (frame->header.ide == 0)  
  673.             frame->header.eid = 0;  
  674.     /*       
  675.         buf[0] = INSTRUCTION_LOAD_TXB(tx_buf_idx); 
  676.         buf[1] = frame->header.id >> 3; 
  677.         buf[2] = (frame->header.id << 5) | (frame->header.ide << 3) 
  678.             | (frame->header.eid >> 16); 
  679.         buf[3]  = frame->header.eid >> 8; 
  680.         buf[4]  = frame->header.eid; 
  681.         buf[5] = (frame->header.rtr << 6) | frame->header.dlc; 
  682.         memcpy(buf + 6, frame->data, frame->header.dlc); 
  683.      
  684.         for(i=0;iheader.dlc+6;i++) { 
  685.             printk("buf[%d] : %d\n",i,buf[i]);       
  686.         } 
  687.         ret = spi_write(spi, buf, 6 + CAN_FRAME_MAX_DATA_LEN); 
  688.         if (ret < 0)  
  689.             dev_dbg(&spi->dev,"%s: failed: ret = %d\n", __FUNCTION__, ret); 
  690.     */  
  691.           
  692.         buf[0] = frame->header.id >> 3;  
  693.         buf[1] = (frame->header.id << 5) | (frame->header.ide << 3)   | (frame->header.eid >> 16);  
  694.         buf[2]  = frame->header.eid >> 8;  
  695.         buf[3]  = frame->header.eid;  
  696.         buf[4] = (frame->header.rtr << 6) | frame->header.dlc;  
  697.         memcpy(buf + 5, frame->data, frame->header.dlc);  
  698.         /*       
  699.         for(i=0;iheader.dlc+5;i++) { 
  700.             printk("buf[%d] : %x\n",i,buf[i]);       
  701.         } 
  702.         */  
  703.         if (tx_buf_idx == 0) {  
  704.             for(i=0;i<(frame->header.dlc+5);i++) {  
  705.                 mcp251x_write_reg(spi,(0x31+i),buf[i]);  
  706.             }  
  707.         } else if(tx_buf_idx ==1) {  
  708.             for(i=0;i<(frame->header.dlc+5);i++)  {  
  709.                 mcp251x_write_reg(spi,(0x41+i),buf[i]);  
  710.             }  
  711.         } else {  
  712.             for(i=0;i<(frame->header.dlc+5);i++)  {  
  713.                 mcp251x_write_reg(spi,(0x51+i),buf[i]);  
  714.             }  
  715.         }  
  716.   
  717.     //  up(&chip->lock);  
  718.           
  719.         /* update pos of ring buffer */  
  720.         chip->txbout++;  
  721.         if (chip->txbout >= MCP251X_BUF_LEN)  
  722.             chip->txbout = 0;  
  723.   
  724.         up(&chip->txblock);  
  725.         mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx), TXBCTRL_TXREQ);  
  726.     }  
  727.     return 0;  
  728. }  
  729.   
  730. /* Receive data from internat buffer of MCP251X and save it to ring buffer. 
  731.  */  
  732. static int mcp251x_hw_rx(struct spi_device *spi, int buf_idx)  
  733. {  
  734.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  735.     uint8_t rx_buf[13];  
  736. //  int ret;  
  737.     struct can_frame *frame;  
  738.     int i;  
  739.       
  740.     if (down_interruptible(&chip->rxblock))  
  741.         return -ERESTARTSYS;  
  742.           
  743.     frame = &chip->rxb[chip->rxbin];  
  744.   
  745. //  down(&chip->lock);  
  746.     /* 
  747.     buf[0] = INSTRUCTION_READ_RXB(buf_idx); 
  748.     rx_buf = buf + (6 + CAN_FRAME_MAX_DATA_LEN); 
  749.     ret = spi_write_then_read(spi, buf, 1, rx_buf, 13); 
  750.     if (ret < 0) 
  751.         dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret); 
  752.     */  
  753.     if (buf_idx == 0)   
  754.         for(i=0;i<(5 + CAN_FRAME_MAX_DATA_LEN);i++) {  
  755.             rx_buf[i] = mcp251x_read_reg(spi,0x61+i);     
  756.         }  
  757.     else  
  758.         for(i=0;i<(5 + CAN_FRAME_MAX_DATA_LEN);i++) {  
  759.             rx_buf[i] = mcp251x_read_reg(spi,0x71+i);     
  760.         }  
  761.   
  762.     frame->header.id = (rx_buf[0] << 3) | (rx_buf[1] >> 5);  
  763.     frame->header.ide = (rx_buf[1] >> 3) & 0x1;  
  764.     frame->header.srr = (rx_buf[1] >> 4) & 0x1;  
  765.     if (frame->header.ide == 1)  
  766.         frame->header.eid = (rx_buf[1] << 16) | (rx_buf[2] << 8) | rx_buf[3];  
  767.     else  
  768.         frame->header.eid = 0;  
  769.     frame->header.rtr = (rx_buf[4] >> 6) & 0x1;  
  770.     frame->header.rb1 = (rx_buf[4] >> 5) & 0x1;  
  771.     frame->header.rb0 = (rx_buf[4] >> 4) & 0x1;  
  772.     frame->header.dlc = rx_buf[4] & 0x0f;  
  773.     memcpy(frame->data, rx_buf + 5, CAN_FRAME_MAX_DATA_LEN);  
  774.       
  775. //  up(&chip->lock);  
  776.   
  777.     /* update pos of ring buffer */  
  778.     chip->rxbin++;  
  779.     if (chip->rxbin >= MCP251X_BUF_LEN)  
  780.         chip->rxbin = 0;  
  781.               
  782.     up(&chip->rxblock);  
  783.   
  784.     return 0;  
  785. }  
  786.   
  787. /* ........................................................................ */  
  788.   
  789. /* bottom half task for interrupt */  
  790. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))  
  791. static void mcp251x_irq_handler(struct work_struct *work)  
  792. {  
  793.     struct mcp251x *chip = container_of(work, struct mcp251x, irq_work);  
  794.     struct spi_device *spi = chip->spi;  
  795. #else  
  796. static void mcp251x_irq_handler(void *dev_id)  
  797. {  
  798.     struct spi_device *spi = dev_id;  
  799.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  800. #endif  
  801.     uint8_t intf, rxs;  
  802.   
  803.     for(;;) {  
  804.           
  805.         intf = mcp251x_read_reg(spi, CANINTF);  
  806.         if (intf == 0x00)  
  807.             break;  
  808.   
  809.         dev_dbg(&spi->dev,"interrupt:%s%s%s%s%s%s%s%s\n",  
  810.             (intf & CANINTF_MERRF) ? " MERR":"",  
  811.             (intf & CANINTF_WAKIF) ? " WAK":"",  
  812.             (intf & CANINTF_ERRIF) ? " ERR":"",  
  813.             (intf & CANINTF_TX2IF) ? " TX2":"",  
  814.             (intf & CANINTF_TX1IF) ? " TX1":"",  
  815.             (intf & CANINTF_TX0IF) ? " TX0":"",  
  816.             (intf & CANINTF_RX1IF) ? " RX1":"",  
  817.             (intf & CANINTF_RX0IF) ? " RX0":"");  
  818.               
  819.         rxs = mcp251x_read_state(spi, INSTRUCTION_RX_STATE);   
  820.         dev_dbg(&spi->dev,   
  821.             "rx_state:%s%s\n",  
  822.             (rxs & RX_STATE_IDE) ? " IDE":"",  
  823.             (rxs & RX_STATE_RTR) ? " RTR":"");  
  824.               
  825.         if (intf & CANINTF_MERRF) {  
  826. #if 0  
  827.             uint8_t txbnctrl;  
  828.             /* if there are no pending Tx buffers, restart queue */  
  829.             txbnctrl = mcp251x_read_reg(spi, TXBCTRL(0));  
  830.             if (!(txbnctrl & TXBCTRL_TXREQ))  
  831.                 netif_wake_queue(&chip->can->ndev);  
  832. #endif  
  833.         }  
  834.         if (intf & CANINTF_ERRIF) {  
  835.             uint8_t eflg = mcp251x_read_reg(spi, EFLG);  
  836.           
  837.             dev_dbg(&spi->dev, "EFLG = 0x%02x\n", eflg);  
  838.           
  839.             if (eflg & (EFLG_RX0OVR | EFLG_RX1OVR)) {  
  840. #if 0  
  841.                 if (eflg & EFLG_RX0OVR)  
  842.                     chip->stats.rx_over_errors++;  
  843.                 if (eflg & EFLG_RX1OVR)  
  844.                     chip->stats.rx_over_errors++;  
  845. #endif  
  846.                 mcp251x_write_reg(spi, EFLG, 0x00);  
  847.             }  
  848.         }  
  849.   
  850.         if (intf & CANINTF_TX0IF) /* If ready to send, copy data to send buffer. */  
  851.             mcp251x_hw_tx(spi, 0);  
  852.         if (intf & CANINTF_TX1IF)  
  853.             mcp251x_hw_tx(spi, 1);  
  854.         if (intf & CANINTF_TX2IF)  
  855.             mcp251x_hw_tx(spi, 2);  
  856.         if (intf & CANINTF_RX0IF) /* If received data, copy data to ring buffer. */  
  857.             mcp251x_hw_rx(spi, 0);  
  858.         if (intf & CANINTF_RX1IF)  
  859.             mcp251x_hw_rx(spi, 1);  
  860.       
  861.         mcp251x_write_bits(spi, CANINTF, intf, 0x00);  
  862.       
  863.         /* If ring buffer of receive is not empty, wake up the read queue. */  
  864.         if (chip->rxbin != chip->rxbout)  
  865.             wake_up_interruptible(&chip->wq);  
  866.     }  
  867. }  
  868.   
  869.   
  870. static irqreturn_t mcp251x_irq(int irq, void *dev_id)  
  871. {  
  872.     struct spi_device *spi = dev_id;  
  873.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  874.   
  875.     /* Can't do anything in interrupt context so fire of the interrupt 
  876.      * handling workqueue. */  
  877.     schedule_work(&chip->irq_work);  
  878.   
  879.     return IRQ_HANDLED;  
  880. }  
  881.   
  882. /* ........................................................................ */  
  883.   
  884. static int mcp251x_open(struct inode *inode, struct file *file)  
  885. {  
  886.     struct mcp251x *chip = container_of(inode->i_cdev, struct mcp251x, cdev);  
  887.     struct spi_device *spi = chip->spi;  
  888.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
  889.       
  890.     file->private_data = chip;  
  891.   
  892.     if (!chip->count) {  
  893.           
  894.         if (pdata->transceiver_enable)  
  895.             pdata->transceiver_enable(1);  
  896.   
  897.         mcp251x_hw_reset(spi);  
  898.         mcp251x_hw_wakeup(spi);  
  899.   
  900.         /* Enable interrupts */  
  901.         mcp251x_write_reg(spi, CANINTE,  
  902.                   CANINTE_ERRIE | CANINTE_TX2IE  
  903.                   | CANINTE_TX1IE | CANINTE_TX0IE  
  904.                   | CANINTE_RX1IE | CANINTE_RX0IE);  
  905.   
  906.         /* put device into normal mode */  
  907.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_NORMAL);  
  908.         mcp251x_write_reg(spi, RXBCTRL(0), RXBCTRL_BULK);  
  909.     }  
  910.       
  911.     chip->count++;  
  912.       
  913.     return 0;  
  914. }  
  915.   
  916. static int mcp251x_release(struct inode *inode, struct file *file)  
  917. {  
  918.       
  919.     struct mcp251x *chip = container_of(inode->i_cdev, struct mcp251x, cdev);  
  920.     struct spi_device *spi = chip->spi;  
  921.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
  922.   
  923.     chip->count--;  
  924.       
  925.     if (chip->count)  
  926.         return 0;  
  927.   
  928.     /* disable and clear pending interrupts */  
  929.     mcp251x_write_reg(spi, CANINTE, 0x00);  
  930.     mcp251x_write_reg(spi, CANINTF, 0x00);  
  931.   
  932.     /* go to sleep */  
  933.     mcp251x_hw_sleep(spi);  
  934.   
  935.     if (pdata->transceiver_enable)  
  936.         pdata->transceiver_enable(0);  
  937.           
  938.   
  939.     return 0;  
  940. }  
  941.   
  942. static int mcp251x_write(struct file *file, const char __user *buf, size_t count, loff_t *ofs)  
  943. {  
  944.       
  945.     struct mcp251x *chip = file->private_data;  
  946.     struct spi_device *spi = chip->spi;  
  947.     struct can_frame *frame;  
  948.     int ret;  
  949.     uint8_t txreq;  
  950.   
  951.     if (count < sizeof(struct can_frame))  
  952.         return -EINVAL;  
  953.   
  954.     if (down_interruptible(&chip->txblock))  
  955.         return -ERESTARTSYS;  
  956.       
  957.     frame = &chip->txb[chip->txbin];  
  958.     ret = copy_from_user(frame, buf, sizeof(struct can_frame));  
  959.       
  960.     chip->txbin++;  
  961.     if (chip->txbin >= MCP251X_BUF_LEN)  
  962.         chip->txbin = 0;  
  963.       
  964.     up(&chip->txblock);  
  965.       
  966.     txreq = mcp251x_read_state(spi, INSTRUCTION_CAN_STATE);  
  967.     if (!(txreq & CAN_STATE_TX0REQ))   
  968.         mcp251x_hw_tx(spi, 0);        
  969.     if (!(txreq & CAN_STATE_TX1REQ))   
  970.         mcp251x_hw_tx(spi, 1);  
  971.     if (!(txreq & CAN_STATE_TX2REQ))  
  972.         mcp251x_hw_tx(spi, 2);  
  973.       
  974.     udelay(write_udelay);  
  975.   
  976.     return count;  
  977. }  
  978.   
  979. static ssize_t mcp251x_read(struct file *file, char __user *buf, size_t count, loff_t *ofs)  
  980. {  
  981.       
  982.     struct mcp251x *chip = file->private_data;  
  983.     struct can_frame *frame;  
  984.       
  985.     if (count != sizeof(struct can_frame))  
  986.         return -EINVAL;  
  987.           
  988.     if (down_interruptible(&chip->rxblock))  
  989.         return -ERESTARTSYS;  
  990.       
  991.     while (chip->rxbin == chip->rxbout) {  
  992.         up(&chip->rxblock);  
  993.         if (file->f_flags & O_NONBLOCK)  
  994.             return -EAGAIN;  
  995.         if (wait_event_interruptible(chip->wq, (chip->rxbin != chip->rxbout)))  
  996.             return -ERESTARTSYS;  
  997.         if (down_interruptible(&chip->rxblock))  
  998.             return -ERESTARTSYS;  
  999.     }  
  1000.       
  1001.     frame = &chip->rxb[chip->rxbout];  
  1002.     if (copy_to_user(buf, frame, sizeof(struct can_frame))) {  
  1003.         up(&chip->rxblock);  
  1004.         return -EFAULT;  
  1005.     }  
  1006.     chip->rxbout++;  
  1007.     if(chip->rxbout >= MCP251X_BUF_LEN)  
  1008.         chip->rxbout = 0;  
  1009.           
  1010.     up(&chip->rxblock);  
  1011.           
  1012.     return count;  
  1013.       
  1014. #if 0  
  1015. retry:  
  1016.     if (chip->rxbin != chip->rxbout) {  
  1017.           
  1018.         down(&chip->rxblock);  
  1019.           
  1020.         frame = &chip->rxb[chip->rxbout];  
  1021.         if (copy_to_user(buf, frame, sizeof(struct can_frame))) {  
  1022.             up(&chip->rxblock);  
  1023.             return -EFAULT;  
  1024.         }  
  1025.         chip->rxbout++;  
  1026.         if(chip->rxbout >= MCP251X_BUF_LEN)  
  1027.             chip->rxbout = 0;  
  1028.           
  1029.         up(&chip->rxblock);  
  1030.           
  1031.         return count;  
  1032.     }  
  1033.     else {  
  1034.         if (file->f_flags & O_NONBLOCK)  
  1035.             return -EAGAIN;  
  1036.         interruptible_sleep_on(&chip->wq);  
  1037.         if (signal_pending(current))  
  1038.             return -ERESTARTSYS;  
  1039.               
  1040.         goto retry;  
  1041.     }  
  1042. #endif  
  1043. }  
  1044.   
  1045. static int mcp251x_ioctl(struct inode *inode, struct file *file,   
  1046.              unsigned int cmd, unsigned long arg)  
  1047. {  
  1048.   
  1049.     struct mcp251x *chip = container_of(inode->i_cdev, struct mcp251x, cdev);  
  1050.     struct spi_device *spi = chip->spi;  
  1051.     int ret = 0;  
  1052.   
  1053.     switch(cmd) {  
  1054.       
  1055.     case CAN_IOCTRESET:     /* reset devcie */  
  1056.         mcp251x_hw_reset(spi);  
  1057.         break;  
  1058.     case CAN_IOCTWAKEUP:    /* wake up device */  
  1059.         mcp251x_hw_wakeup(spi);  
  1060.         break;  
  1061.     case CAN_IOCSRATE:      /* set bit rate */  
  1062.         ret = mcp251x_set_bit_rate(spi, (int)arg);  
  1063.         mdelay(10);  
  1064.         break;  
  1065.     case CAN_IOCGRATE:      /* get bit rate */  
  1066.         *((int *)arg) = mcp251x_get_bit_rate(spi);  
  1067.         break;  
  1068.     case CAN_IOCSFILTER:    /* set filter */  
  1069.         ret = mcp251x_set_filter(spi, (struct can_filter *)arg);  
  1070.         break;  
  1071.     case CAN_IOCGFILTER:    /* get filter */  
  1072.         ret = mcp251x_get_filter(spi, (struct can_filter *)arg);  
  1073.         break;  
  1074.     case CAN_IOCTNORMALMODE:    /* turn to normal mode */  
  1075.         //mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_NORMAL);  
  1076.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_NORMAL);  
  1077.         break;  
  1078.     case CAN_IOCTLOOPBACKMODE:  /* turn to loopback mode */  
  1079.         //mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_LOOPBACK);  
  1080.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LOOPBACK);  
  1081.         break;  
  1082.     case CAN_IOCTLISTENONLYMODE: /* turn to listen only mode */  
  1083.         //mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_LISTEN_ONLY);  
  1084.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LISTEN_ONLY);  
  1085.         break;  
  1086.     case CAN_IOCTSLEEPMODE: /* turn to sleep mode */  
  1087.         mcp251x_hw_sleep(spi);  
  1088.         break;  
  1089.     default:  
  1090.         return -ENOTTY;  
  1091.     }  
  1092.       
  1093.     return ret;  
  1094. }  
  1095.   
  1096. static const struct file_operations mcp251x_fops = {  
  1097.     .owner = THIS_MODULE,  
  1098.     .read = mcp251x_read,  
  1099.     .write = mcp251x_write,  
  1100.     .ioctl = mcp251x_ioctl,  
  1101.     .open = mcp251x_open,  
  1102.     .release = mcp251x_release,  
  1103. };  
  1104.   
  1105. /* ........................................................................ */  
  1106.   
  1107. static int __devexit mcp251x_remove(struct spi_device *spi)  
  1108. {  
  1109.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  1110.   
  1111.     dev_dbg(&spi->dev, "%s: stop\n",  __FUNCTION__);  
  1112.   
  1113.     device_unregister(chip->class_dev);  
  1114.   
  1115.     cdev_del(&chip->cdev);  
  1116.     free_irq(spi->irq, spi);  
  1117.     kfree(chip->spi_transfer_buf);  
  1118.   
  1119.     return 0;  
  1120. }  
  1121.   
  1122. static int __devinit mcp251x_probe(struct spi_device *spi)  
  1123. {  
  1124.     struct mcp251x *chip;  
  1125.     int ret = 0;  
  1126.     int irq;  
  1127.   
  1128.     dev_dbg(&spi->dev,"%s: start\n",  __FUNCTION__);  
  1129.   
  1130.     chip = kmalloc(sizeof(struct mcp251x), GFP_KERNEL);  
  1131.     if (!chip) {  
  1132.         ret = -ENOMEM;  
  1133.         goto error_alloc;  
  1134.     }  
  1135.   
  1136.     dev_set_drvdata(&spi->dev, chip);  
  1137.       
  1138.     chip->txbin = chip->txbout = 0;  
  1139.     chip->rxbin = chip->rxbout = 0;  
  1140.     chip->count = 0;  
  1141.     chip->spi = spi;  
  1142.     init_MUTEX(&chip->lock);  
  1143.     init_MUTEX(&chip->txblock);  
  1144.     init_MUTEX(&chip->rxblock);  
  1145.     init_waitqueue_head(&chip->wq);  
  1146.       
  1147. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))  
  1148.     INIT_WORK(&chip->irq_work, mcp251x_irq_handler);  
  1149. #else  
  1150.     INIT_WORK(&chip->irq_work, mcp251x_irq_handler, spi);  
  1151. #endif  
  1152.       
  1153.     chip->spi_transfer_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);  
  1154.     if (!chip->spi_transfer_buf) {  
  1155.         ret = -ENOMEM;  
  1156.         goto error_buf;  
  1157.     }  
  1158.       
  1159.     ret = gpio_request(spi->irq, spi->modalias);  
  1160.     if (ret < 0) {  
  1161.         pr_err("mcp251x: failed to request GPIO %d,"  
  1162.                         " error %d\n", spi->irq, ret);  
  1163.         goto error_irq;  
  1164.     }  
  1165.   
  1166.     ret = gpio_direction_input(spi->irq);  
  1167.     if (ret < 0) {  
  1168.         pr_err("mcp251x: failed to configure input"  
  1169.                         " direction for GPIO %d, error %d\n",  
  1170.                         spi->irq, ret);  
  1171.         gpio_free(spi->irq);  
  1172.         goto error_irq;  
  1173.     }  
  1174.   
  1175.     irq = gpio_to_irq(spi->irq);  
  1176.     if (irq < 0) {  
  1177.         ret = irq;  
  1178.         pr_err("mcp251x: Unable to get irq number"  
  1179.                         " for GPIO %d, error %d\n",  
  1180.                         spi->irq, ret);  
  1181.         gpio_free(spi->irq);  
  1182.         goto error_irq;  
  1183.     }  
  1184.   
  1185.     ret = request_irq(irq, mcp251x_irq,IRQF_SAMPLE_RANDOM, DRIVER_NAME, spi);// SA_SAMPLE_RANDOM,  
  1186.     if (ret < 0) {  
  1187.         dev_err(&spi->dev,"request irq %d failed (ret = %d)\n", spi->irq, ret);  
  1188.         gpio_free(spi->irq);  
  1189.         goto error_irq;  
  1190.     }  
  1191.       
  1192.     cdev_init(&chip->cdev, &mcp251x_fops);  
  1193.     chip->cdev.owner = THIS_MODULE;  
  1194.     ret = cdev_add(&chip->cdev, MKDEV(MAJOR(can_devt), can_minor), 1);  
  1195.     if (ret < 0) {  
  1196.         dev_err(&spi->dev, "register char device failed (ret = %d)\n", ret);  
  1197.         goto error_register;  
  1198.     }  
  1199.   
  1200.     chip->class_dev = device_create(can_class, NULL,  
  1201.                           MKDEV(MAJOR(can_devt), can_minor),  
  1202.                           &spi->dev, "can%d", can_minor);  
  1203.     if (IS_ERR(chip->class_dev)) {  
  1204.         dev_err(&spi->dev, "cannot create CAN class device\n");  
  1205.         ret = PTR_ERR(chip->class_dev);  
  1206.         goto error_class_reg;  
  1207.     }  
  1208.       
  1209.     dev_info(&spi->dev, "device register at dev(%d:%d)\n",  
  1210.          MAJOR(can_devt), can_minor);  
  1211.       
  1212.     mcp251x_hw_init(spi);  
  1213.     ret = mcp251x_set_bit_rate(spi, 125000); /* A reasonable default */  
  1214.     if(ret == -1) {  
  1215.         printk("mcp2515 set bit rate error!\n");  
  1216.         cdev_del(&chip->cdev);  
  1217.         free_irq(spi->irq, spi);  
  1218.         kfree(chip->spi_transfer_buf);  
  1219.         kfree(chip);  
  1220.         return ret;  
  1221.     }  
  1222.     mcp251x_hw_sleep(spi);  
  1223.   
  1224.     can_minor++;  
  1225.       
  1226.     return 0;  
  1227.       
  1228. error_class_reg:  
  1229.     cdev_del(&chip->cdev);  
  1230. error_register:  
  1231.     free_irq(spi->irq, spi);  
  1232. error_irq:  
  1233.     free_irq(gpio_to_irq(spi->irq), spi);  
  1234.     gpio_free(spi->irq);  
  1235.     kfree(chip->spi_transfer_buf);  
  1236. error_buf:  
  1237.     kfree(chip);  
  1238. error_alloc:  
  1239.     return ret;  
  1240. }  
  1241.   
  1242. #ifdef CONFIG_PM  
  1243. static int mcp251x_suspend(struct spi_device *spi, pm_message_t mesg)  
  1244. {  
  1245.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  1246.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
  1247.   
  1248.     if (chip->count)  
  1249.         return 0;  
  1250.   
  1251.     mcp251x_hw_sleep(spi);  
  1252.     if (pdata->transceiver_enable)  
  1253.         pdata->transceiver_enable(0);  
  1254.   
  1255.     return 0;  
  1256. }  
  1257.   
  1258. static int mcp251x_resume(struct spi_device *spi)  
  1259. {  
  1260.     struct mcp251x *chip = dev_get_drvdata(&spi->dev);  
  1261.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
  1262.   
  1263.     if (!chip->count)  
  1264.         return 0;  
  1265.           
  1266.     if (pdata->transceiver_enable)  
  1267.         pdata->transceiver_enable(1);  
  1268.     mcp251x_hw_wakeup(spi);  
  1269.   
  1270.     return 0;  
  1271. }  
  1272. #endif  
  1273.   
  1274. static struct spi_driver mcp251x_driver = {  
  1275.     .driver = {  
  1276.         .name   = DRIVER_NAME,  
  1277.         .bus    = &spi_bus_type,  
  1278.         .owner  = THIS_MODULE,  
  1279.     },  
  1280.     .probe  = mcp251x_probe,  
  1281.     .remove = __devexit_p(mcp251x_remove),  
  1282. #ifdef CONFIG_PM  
  1283.     .suspend    = mcp251x_suspend,  
  1284.     .resume = mcp251x_resume,  
  1285. #endif  
  1286. };  
  1287.   
  1288. static int __init mcp251x_init(void)  
  1289. {  
  1290.     int ret;  
  1291.       
  1292.     can_class = class_create(THIS_MODULE, "can");  
  1293.     if (IS_ERR(can_class))  
  1294.         return PTR_ERR(can_class);  
  1295.     ret = alloc_chrdev_region(&can_devt, 0, CAN_DEV_MAX, DRIVER_NAME);  
  1296.     if (ret < 0) {  
  1297.         printk(KERN_ERR "%s: failed to allocate char dev region\n",  
  1298.                __FILE__);  
  1299.         class_destroy(can_class);  
  1300.         return ret;  
  1301.     }  
  1302.     return spi_register_driver(&mcp251x_driver);  
  1303. }  
  1304. module_init(mcp251x_init);  
  1305.   
  1306. static void __exit mcp251x_exit(void)  
  1307. {  
  1308.     class_destroy(can_class);  
  1309.     unregister_chrdev_region(can_devt, CAN_DEV_MAX);  
  1310.     spi_unregister_driver(&mcp251x_driver);  
  1311. }  
  1312. module_exit(mcp251x_exit);  
  1313.   
  1314.   
  1315. MODULE_DESCRIPTION("MCP251x CAN controller driver");  
  1316. MODULE_LICENSE("GPL");  
  1317. MODULE_AUTHOR("Quanlin.Bai");  


你可能感兴趣的:(CAN,bus,driver)