can3--socketcan之mcp251x.c

转自http://www.cnblogs.com/-song/archive/2012/05/24/3331872.html

spi驱动结构见
http://blog.csdn.net/songqqnew/article/details/7037583

mcp251x.c几乎是抄袭dm9000的写作格式
参考  

dm9000 driver 1

 理清一下驱动的线索
******************************************************************

在init函数中注册spi驱动mcp251x_can_driver

1. static int __init mcp251x_can_init(void)  
2. {  
3. DBG("init\n");  
4.     return spi_register_driver(&mcp251x_can_driver);  
5. }  

在spi驱动mcp251x_can_driver的probe函数中分配net_device

1. static struct spi_driver mcp251x_can_driver = {  
2.     .driver = {  
3.         .name = DEVICE_NAME,//mcp2515  
4.         .bus = &spi_bus_type,  
5.         .owner = THIS_MODULE,  
6.     },  
7.   
8.   
9.     .id_table = mcp251x_id_table,  
10.     .probe = mcp251x_can_probe,//probe  
11.     .remove = __devexit_p(mcp251x_can_remove),  
12.     .suspend = mcp251x_can_suspend,  
13.     .resume = mcp251x_can_resume,  
14. };  
15.   
16. static int __devinit mcp251x_can_probe(struct spi_device *spi)  
17. {  
18.   
19.     net = alloc_candev(sizeof(struct mcp251x_priv), TX_ECHO_SKB_MAX);  
20.     if (!net) {  
21.     ret = -ENOMEM;  
22.     goto error_alloc;  
23.     }  
24.     //注册net_device  
25.     register_candev(net);  
26.   
27.     //net_device的operation结构体指定了操作函数集合  
28.      static const struct net_device_ops mcp251x_netdev_ops = {  
29.     .ndo_open = mcp251x_open,  
30.     .ndo_stop = mcp251x_stop,  
31.     .ndo_start_xmit = mcp251x_hard_start_xmit,  
32.     };  
33. }  

应用层执行ifconfig can0 up时会调用到mcp251x_open
在mcp251x_open函数中,

1. //打开设备  
2. open_candev(net);  
3. //申请中断  
4. ret = request_irq(spi->irq, mcp251x_can_irq, /*IRQF_DISABLED |*/ IRQF_TRIGGER_LOW ,  DEVICE_NAME, priv);  
5. //初始化工作队列，当做中断(接收)下半部，用于处理接收  
6. INIT_WORK(&priv->irq_work,can_irq_work);  
7. //初始化工作队列，用于处理发送  
8. INIT_WORK(&priv->tx_work, mcp251x_tx_work_handler);  

应用层执行write socket时会调用到mcp251x_hard_start_xmit，
在 mcp251x_hard_start_xmit函数中，

1. //停止协议栈向驱动发送数据(在发送数据的时候需要停止协议栈发来新的需要发送出去的数据)，发送完成后会重新启用  
2. netif_stop_queue(net);  
3. //启动发送工作队列，将数据(skb)发送出去  
4. priv->tx_skb = skb;  
5. queue_work(priv->wq, &priv->tx_work);  

具体看一下这个发送工作队列函数

1. static void mcp251x_tx_work_handler(struct work_struct *ws)  
2. {  
3.     struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,  
4.                          tx_work);  
5.     struct spi_device *spi = priv->spi;  
6.     struct net_device *net = priv->net;  
7.     struct can_frame *frame;  
8.   
9. //  printk("mcp251x_tx_work_handler\n");  
10.   
11.     mutex_lock(&priv->mcp_lock);  
12.     if (priv->tx_skb) {  
13.         if (priv->can.state == CAN_STATE_BUS_OFF) {  
14.             mcp251x_clean(net);  
15.         } else {  
16.             frame = (struct can_frame *)priv->tx_skb->data;  
17.   
18.             if (frame->can_dlc > CAN_FRAME_MAX_DATA_LEN)  
19.                 frame->can_dlc = CAN_FRAME_MAX_DATA_LEN;  
20.             mcp251x_hw_tx(spi, frame, 0);  
21.             priv->tx_len = 1 + frame->can_dlc;  
22.             can_put_echo_skb(priv->tx_skb, net, 0);  
23.             priv->tx_skb = NULL;  
24.         }  
25.     }  
26.     mutex_unlock(&priv->mcp_lock);  
27. }  

怎么接收呢？当然是在中断处理函数中接收，有中断产生时，会启用一个负责接受的工作队列，即中断下半部，去接收。并将接收到的数据保存，以供应用层使用read socket等来读取。

1. static irqreturn_t mcp251x_can_irq(int irq, void *dev_id)  
2. {  
3. DBG("zhongduan :mcp251x_can_irq\n");  
4.        struct mcp251x_priv *priv = dev_id;  
5.         disable_irq_nosync(irq);//禁止中断，工作队列函数中接收完成时会重新使能中断  
6.        if (!work_pending(&priv->irq_work))  
7.         queue_work(priv->wq, &priv->irq_work);//调用工作队列函数  
8.        return IRQ_HANDLED;  
9. }  

接收工作队列函数

1. void can_irq_work(struct work_struct *ws)  
2. {  
3.   
4. DBG("zhongduan bottom: can_irq_work\n");  
5.      struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,  
6.                          irq_work);  
7.      struct spi_device *spi = priv->spi;  
8.      struct net_device *net = priv->net;  
9.   
10.     mutex_lock(&priv->mcp_lock);  
11.         //mcp251x_write_reg(spi, CANINTE, (intset & (~ ( CANINTE_TX2IE) )));  
12.     while (!priv->force_quit) {  
13.         enum can_state new_state;  
14.         u8 intf, eflag;  
15.         
16.         u8 clear_intf = 0;  
17.         int can_id = 0, data1 = 0;  
18.   
19.                  
20.         mcp251x_read_2regs(spi, CANINTF, &intf, &eflag);  
21.                 DBG("intf=%x\n",intf);//一般返回1，表示rxb0里有数据。  
22.                 //mcp251x_write_bits(spi, CANINTF, intf, 0x00);  
23.           
24.         /* mask out flags we don't care about */  
25.         intf &= CANINTF_RX | CANINTF_TX | CANINTF_ERR ;//| CANINTF_MERRF;  
26.   
27.                 if (intf & CANINTF_TX) {//如果是发送完成中断  
28.   
29.             net->stats.tx_packets++;  
30.             net->stats.tx_bytes += priv->tx_len - 1;  
31.             if (priv->tx_len) {  
32.                 can_get_echo_skb(net, 0);  
33.                 priv->tx_len = 0;  
34.             }  
35.             netif_wake_queue(net);//重新开启  
36.         }  
37.   
38.           
39.         /* receive buffer 1 */  
40.         if (intf & CANINTF_RX1IF) {//如果是从mcp251x的buffer 1接收到数据的中断  
41.   
42.             mcp251x_hw_rx(spi, 1);//接收  
43.             /* the MCP2515 does this automatically */  
44.             if (mcp251x_is_2510(spi))  
45.                 clear_intf |= CANINTF_RX1IF;//清除mcp251x里的中断标志  
46.         }  
47.   
48.                 /* receive buffer 0 */  
49.         if (intf & CANINTF_RX0IF) {//如果是从mcp251x的buffer 0接收到数据的中断  
50.   
51.             mcp251x_hw_rx(spi, 0);//接收mcp2515的rxb0里的数据，见下  
52.             /* 
53.              * Free one buffer ASAP 
54.              * (The MCP2515 does this automatically.) 
55.              */  
56.             if (mcp251x_is_2510(spi))  
57.                 mcp251x_write_bits(spi, CANINTF, CANINTF_RX0IF, 0x00);//清除mcp251x里的中断标志  
58.         }  
59.   
60.      
61.         /* any error or tx interrupt we need to clear? */  
62.         if (intf & (CANINTF_ERR | CANINTF_TX))  
63.             clear_intf |= intf & (CANINTF_ERR | CANINTF_TX);  
64.         if (clear_intf)  
65.             mcp251x_write_bits(spi, CANINTF, clear_intf, 0x00);  
66.   
67.         if (eflag)  
68.             mcp251x_write_bits(spi, EFLG, eflag, 0x00);  
69.   
70.   
71.                  
72.         /* Update can state */  
73.         if (eflag & EFLG_TXBO) {  
74.             new_state = CAN_STATE_BUS_OFF;  
75.             can_id |= CAN_ERR_BUSOFF;  
76.         } else if (eflag & EFLG_TXEP) {  
77.             new_state = CAN_STATE_ERROR_PASSIVE;  
78.             can_id |= CAN_ERR_CRTL;  
79.             data1 |= CAN_ERR_CRTL_TX_PASSIVE;  
80.         } else if (eflag & EFLG_RXEP) {  
81.             new_state = CAN_STATE_ERROR_PASSIVE;  
82.             can_id |= CAN_ERR_CRTL;  
83.             data1 |= CAN_ERR_CRTL_RX_PASSIVE;  
84.         } else if (eflag & EFLG_TXWAR) {  
85.             new_state = CAN_STATE_ERROR_WARNING;  
86.             can_id |= CAN_ERR_CRTL;  
87.             data1 |= CAN_ERR_CRTL_TX_WARNING;  
88.         } else if (eflag & EFLG_RXWAR) {  
89.             new_state = CAN_STATE_ERROR_WARNING;  
90.             can_id |= CAN_ERR_CRTL;  
91.             data1 |= CAN_ERR_CRTL_RX_WARNING;  
92.         } else {  
93.             new_state = CAN_STATE_ERROR_ACTIVE;  
94.         }  
95.   
96.         /* Update can state statistics */  
97.         switch (priv->can.state) {  
98.         case CAN_STATE_ERROR_ACTIVE:  
99.             if (new_state >= CAN_STATE_ERROR_WARNING &&  
100.                 new_state <= CAN_STATE_BUS_OFF)  
101.                 priv->can.can_stats.error_warning++;  
102.         case CAN_STATE_ERROR_WARNING:   /* fallthrough */  
103.             if (new_state >= CAN_STATE_ERROR_PASSIVE &&  
104.                 new_state <= CAN_STATE_BUS_OFF)  
105.                 priv->can.can_stats.error_passive++;  
106.             break;  
107.         default:  
108.             break;  
109.         }  
110.         priv->can.state = new_state;  
111.   
112.         if (intf & CANINTF_ERRIF) {  
113.             /* Handle overflow counters */  
114.             if (eflag & (EFLG_RX0OVR | EFLG_RX1OVR)) {  
115.                 if (eflag & EFLG_RX0OVR) {  
116.                     net->stats.rx_over_errors++;  
117.                     net->stats.rx_errors++;  
118.                 }  
119.                 if (eflag & EFLG_RX1OVR) {  
120.                     net->stats.rx_over_errors++;  
121.                     net->stats.rx_errors++;  
122.                 }  
123.                 can_id |= CAN_ERR_CRTL;  
124.                 data1 |= CAN_ERR_CRTL_RX_OVERFLOW;  
125.             }  
126.             mcp251x_error_skb(net, can_id, data1);  
127.         }  
128.   
129.   
130.         if (priv->can.state == CAN_STATE_BUS_OFF) {  
131.             if (priv->can.restart_ms == 0) {  
132.                 priv->force_quit = 1;  
133.                 can_bus_off(net);  
134.                 mcp251x_hw_sleep(spi);  
135.                 break;  
136.             }  
137.         }  
138.   
139.                 if (intf == 0)  
140.             break;  
141.       
142.   
143.     }  
144.         //mcp251x_write_reg(spi, CANINTE, intset);  
145.     mutex_unlock(&priv->mcp_lock);    
146.          
147.         enable_irq(spi->irq);//重新使能中断  
148.         //s3c_gpio_cfgpin(S3C64XX_GPL(8), S3C_GPIO_SFN(3));     
149. }  

附mcp251x.c源码

1. /* 
2.  * CAN bus driver for Microchip 251x CAN Controller with SPI Interface 
3.  * 
4.  * MCP2510 support and bug fixes by Christian Pellegrin 
5.  * <chripell@evolware.org> 
6.  * 
7.  * Copyright 2009 Christian Pellegrin EVOL S.r.l. 
8.  * 
9.  * Copyright 2007 Raymarine UK, Ltd. All Rights Reserved. 
10.  * Written under contract by: 
11.  *   Chris Elston, Katalix Systems, Ltd. 
12.  * 
13.  * Based on Microchip MCP251x CAN controller driver written by 
14.  * David Vrabel, Copyright 2006 Arcom Control Systems Ltd. 
15.  * 
16.  * Based on CAN bus driver for the CCAN controller written by 
17.  * - Sascha Hauer, Marc Kleine-Budde, Pengutronix 
18.  * - Simon Kallweit, intefo AG 
19.  * Copyright 2007 
20.  * 
21.  * This program is free software; you can redistribute it and/or modify 
22.  * it under the terms of the version 2 of the GNU General Public License 
23.  * as published by the Free Software Foundation 
24.  * 
25.  * This program is distributed in the hope that it will be useful, 
26.  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
27.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
28.  * GNU General Public License for more details. 
29.  * 
30.  * You should have received a copy of the GNU General Public License 
31.  * along with this program; if not, write to the Free Software 
32.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
33.  * 
34.  * 
35.  * 
36.  * Your platform definition file should specify something like: 
37.  * 
38.  * static struct mcp251x_platform_data mcp251x_info = { 
39.  *         .oscillator_frequency = 8000000, 
40.  *         .board_specific_setup = &mcp251x_setup, 
41.  *         .power_enable = mcp251x_power_enable, 
42.  *         .transceiver_enable = NULL, 
43.  * }; 
44.  * 
45.  * static struct spi_board_info spi_board_info[] = { 
46.  *         { 
47.  *                 .modalias = "mcp2510", 
48.  *            // or "mcp2515" depending on your controller 
49.  *                 .platform_data = &mcp251x_info, 
50.  *                 .irq = IRQ_EINT13, 
51.  *                 .max_speed_hz = 2*1000*1000, 
52.  *                 .chip_select = 2, 
53.  *         }, 
54.  * }; 
55.  * 
56.  * Please see mcp251x.h for a description of the fields in 
57.  * struct mcp251x_platform_data. 
58.  * 
59.  */  
60.   
61.   
62. #define DEBUG    
63. #ifdef DEBUG      
64. #define DBG(...) printk(" DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); printk(__VA_ARGS__)      
65. #else      
66. #define DBG(...)      
67. #endif      
68.   
69. #include <linux/can/core.h>  
70. #include <linux/can/dev.h>  
71. #include <linux/can/platform/mcp251x.h>  
72. #include <linux/completion.h>  
73. #include <linux/delay.h>  
74. #include <linux/device.h>  
75. #include <linux/dma-mapping.h>  
76. #include <linux/freezer.h>  
77. #include <linux/interrupt.h>  
78. #include <linux/io.h>  
79. #include <linux/kernel.h>  
80. #include <linux/module.h>  
81. #include <linux/netdevice.h>  
82. #include <linux/platform_device.h>  
83. #include <linux/slab.h>  
84. #include <linux/spi/spi.h>  
85. #include <linux/uaccess.h>  
86.   
87.   
88. #include <linux/gpio.h>  
89. #include <plat/gpio-cfg.h>  
90.   
91. /* SPI interface instruction set */  
92. #define INSTRUCTION_WRITE    0x02  
93. #define INSTRUCTION_READ    0x03  
94. #define INSTRUCTION_BIT_MODIFY    0x05  
95. #define INSTRUCTION_LOAD_TXB(n)    (0x40 + 2 * (n))  
96. #define INSTRUCTION_READ_RXB(n)    (((n) == 0) ? 0x90 : 0x94)  
97. #define INSTRUCTION_RESET    0xC0  
98.   
99. /* MPC251x registers */  
100. #define CANSTAT          0x0e  
101. #define CANCTRL          0x0f  
102. #  define CANCTRL_REQOP_MASK        0xe0  
103. #  define CANCTRL_REQOP_CONF        0x80  
104. #  define CANCTRL_REQOP_LISTEN_ONLY 0x60  
105. #  define CANCTRL_REQOP_LOOPBACK    0x40  
106. #  define CANCTRL_REQOP_SLEEP        0x20  
107. #  define CANCTRL_REQOP_NORMAL        0x00  
108. #  define CANCTRL_OSM            0x08  
109. #  define CANCTRL_ABAT            0x10  
110. #define TEC          0x1c  
111. #define REC          0x1d  
112. #define CNF1          0x2a  
113. #  define CNF1_SJW_SHIFT   6  
114. #define CNF2          0x29  
115. #  define CNF2_BTLMODE       0x80  
116. #  define CNF2_SAM         0x40  
117. #  define CNF2_PS1_SHIFT   3  
118. #define CNF3          0x28  
119. #  define CNF3_SOF       0x08  
120. #  define CNF3_WAKFIL       0x04  
121. #  define CNF3_PHSEG2_MASK 0x07  
122. #define CANINTE          0x2b  
123. #  define CANINTE_MERRE 0x80  
124. #  define CANINTE_WAKIE 0x40  
125. #  define CANINTE_ERRIE 0x20  
126. #  define CANINTE_TX2IE 0x10  
127. #  define CANINTE_TX1IE 0x08  
128. #  define CANINTE_TX0IE 0x04  
129. #  define CANINTE_RX1IE 0x02  
130. #  define CANINTE_RX0IE 0x01  
131. #define CANINTF          0x2c  
132. #  define CANINTF_MERRF 0x80  
133. #  define CANINTF_WAKIF 0x40  
134. #  define CANINTF_ERRIF 0x20  
135. #  define CANINTF_TX2IF 0x10  
136. #  define CANINTF_TX1IF 0x08  
137. #  define CANINTF_TX0IF 0x04  
138. #  define CANINTF_RX1IF 0x02  
139. #  define CANINTF_RX0IF 0x01  
140. #  define CANINTF_RX (CANINTF_RX0IF | CANINTF_RX1IF)  
141. #  define CANINTF_TX (CANINTF_TX2IF | CANINTF_TX1IF | CANINTF_TX0IF)  
142. #  define CANINTF_ERR (CANINTF_ERRIF)  
143. #define EFLG          0x2d  
144. #  define EFLG_EWARN    0x01  
145. #  define EFLG_RXWAR    0x02  
146. #  define EFLG_TXWAR    0x04  
147. #  define EFLG_RXEP    0x08  
148. #  define EFLG_TXEP    0x10  
149. #  define EFLG_TXBO    0x20  
150. #  define EFLG_RX0OVR    0x40  
151. #  define EFLG_RX1OVR    0x80  
152. #define TXBCTRL(n)  (((n) * 0x10) + 0x30 + TXBCTRL_OFF)  
153. #  define TXBCTRL_ABTF    0x40  
154. #  define TXBCTRL_MLOA    0x20  
155. #  define TXBCTRL_TXERR 0x10  
156. #  define TXBCTRL_TXREQ 0x08  
157. #define TXBSIDH(n)  (((n) * 0x10) + 0x30 + TXBSIDH_OFF)  
158. #  define SIDH_SHIFT    3  
159. #define TXBSIDL(n)  (((n) * 0x10) + 0x30 + TXBSIDL_OFF)  
160. #  define SIDL_SID_MASK    7  
161. #  define SIDL_SID_SHIFT   5  
162. #  define SIDL_EXIDE_SHIFT 3  
163. #  define SIDL_EID_SHIFT   16  
164. #  define SIDL_EID_MASK    3  
165. #define TXBEID8(n)  (((n) * 0x10) + 0x30 + TXBEID8_OFF)  
166. #define TXBEID0(n)  (((n) * 0x10) + 0x30 + TXBEID0_OFF)  
167. #define TXBDLC(n)   (((n) * 0x10) + 0x30 + TXBDLC_OFF)  
168. #  define DLC_RTR_SHIFT    6  
169. #define TXBCTRL_OFF 0  
170. #define TXBSIDH_OFF 1  
171. #define TXBSIDL_OFF 2  
172. #define TXBEID8_OFF 3  
173. #define TXBEID0_OFF 4  
174. #define TXBDLC_OFF  5  
175. #define TXBDAT_OFF  6  
176. #define RXBCTRL(n)  (((n) * 0x10) + 0x60 + RXBCTRL_OFF)  
177. #  define RXBCTRL_BUKT    0x04  
178. #  define RXBCTRL_RXM0    0x20  
179. #  define RXBCTRL_RXM1    0x40  
180. #define RXBSIDH(n)  (((n) * 0x10) + 0x60 + RXBSIDH_OFF)  
181. #  define RXBSIDH_SHIFT 3  
182. #define RXBSIDL(n)  (((n) * 0x10) + 0x60 + RXBSIDL_OFF)  
183. #  define RXBSIDL_IDE   0x08  
184. #  define RXBSIDL_SRR   0x10  
185. #  define RXBSIDL_EID   3  
186. #  define RXBSIDL_SHIFT 5  
187. #define RXBEID8(n)  (((n) * 0x10) + 0x60 + RXBEID8_OFF)  
188. #define RXBEID0(n)  (((n) * 0x10) + 0x60 + RXBEID0_OFF)  
189. #define RXBDLC(n)   (((n) * 0x10) + 0x60 + RXBDLC_OFF)  
190. #  define RXBDLC_LEN_MASK  0x0f  
191. #  define RXBDLC_RTR       0x40  
192. #define RXBCTRL_OFF 0  
193. #define RXBSIDH_OFF 1  
194. #define RXBSIDL_OFF 2  
195. #define RXBEID8_OFF 3  
196. #define RXBEID0_OFF 4  
197. #define RXBDLC_OFF  5  
198. #define RXBDAT_OFF  6  
199. #define RXFSIDH(n) ((n) * 4)  
200. #define RXFSIDL(n) ((n) * 4 + 1)  
201. #define RXFEID8(n) ((n) * 4 + 2)  
202. #define RXFEID0(n) ((n) * 4 + 3)  
203. #define RXMSIDH(n) ((n) * 4 + 0x20)  
204. #define RXMSIDL(n) ((n) * 4 + 0x21)  
205. #define RXMEID8(n) ((n) * 4 + 0x22)  
206. #define RXMEID0(n) ((n) * 4 + 0x23)  
207.   
208. #define GET_BYTE(val, byte)            \  
209.     (((val) >> ((byte) * 8)) & 0xff)  
210. #define SET_BYTE(val, byte)            \  
211.     (((val) & 0xff) << ((byte) * 8))  
212.   
213. /* 
214.  * Buffer size required for the largest SPI transfer (i.e., reading a 
215.  * frame) 
216.  */  
217. #define CAN_FRAME_MAX_DATA_LEN    8  
218. #define SPI_TRANSFER_BUF_LEN    (6 + CAN_FRAME_MAX_DATA_LEN)  
219. #define CAN_FRAME_MAX_BITS    128  
220.   
221. #define TX_ECHO_SKB_MAX    1  
222.   
223. #define DEVICE_NAME "mcp2515"  
224.   
225.   
226.   
227. //static struct timer_list check_timer;  
228. void can_irq_work(struct work_struct *ws);  
229. //static struct work_struct can_work;  
230.   
231. static int intset;//中断设置  
232.   
233.   
234. static int mcp251x_enable_dma; /* Enable SPI DMA. Default: 0 (Off) */  
235. module_param(mcp251x_enable_dma, int, S_IRUGO);  
236. MODULE_PARM_DESC(mcp251x_enable_dma, "Enable SPI DMA. Default: 0 (Off)");  
237.   
238. static struct can_bittiming_const mcp251x_bittiming_const = {  
239.     .name = DEVICE_NAME,  
240.     .tseg1_min = 3,  
241.     .tseg1_max = 16,  
242.     .tseg2_min = 2,  
243.     .tseg2_max = 8,  
244.     .sjw_max = 4,  
245.     .brp_min = 1,  
246.     .brp_max = 64,  
247.     .brp_inc = 1,  
248. };  
249.   
250. enum mcp251x_model {  
251.     CAN_MCP251X_MCP2510    = 0x2510,  
252.     CAN_MCP251X_MCP2515    = 0x2515,  
253. };  
254.   
255. struct mcp251x_priv {  
256.     struct can_priv       can;  
257.     struct net_device *net;  
258.     struct spi_device *spi;  
259.     enum mcp251x_model model;  
260.   
261.     struct mutex mcp_lock; /* SPI device lock */  
262.   
263.     u8 *spi_tx_buf;  
264.     u8 *spi_rx_buf;  
265.     dma_addr_t spi_tx_dma;  
266.     dma_addr_t spi_rx_dma;  
267.   
268.     struct sk_buff *tx_skb;  
269.     int tx_len;  
270.   
271.     struct workqueue_struct *wq;  
272.     struct work_struct tx_work;  
273.     struct work_struct restart_work;  
274.   
275.         struct work_struct irq_work;  
276.   
277.     int force_quit;  
278.     int after_suspend;  
279. #define AFTER_SUSPEND_UP 1  
280. #define AFTER_SUSPEND_DOWN 2  
281. #define AFTER_SUSPEND_POWER 4  
282. #define AFTER_SUSPEND_RESTART 8  
283.     int restart_tx;  
284. };  
285.   
286. #define MCP251X_IS(_model) \  
287. static inline int mcp251x_is_##_model(struct spi_device *spi) \  
288. { \  
289.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev); \  
290.     return priv->model == CAN_MCP251X_MCP##_model; \  
291. }  
292.   
293. MCP251X_IS(2510);  
294. MCP251X_IS(2515);  
295.   
296. static void mcp251x_clean(struct net_device *net)  
297. {  
298.     struct mcp251x_priv *priv = netdev_priv(net);  
299.   
300. //    DBG("mcp251x_clean\n");  
301.   
302.     if (priv->tx_skb || priv->tx_len)  
303.         net->stats.tx_errors++;  
304.     if (priv->tx_skb)  
305.         dev_kfree_skb(priv->tx_skb);  
306.     if (priv->tx_len)  
307.         can_free_echo_skb(priv->net, 0);  
308.     priv->tx_skb = NULL;  
309.     priv->tx_len = 0;  
310. }  
311.   
312. /* 
313.  * Note about handling of error return of mcp251x_spi_trans: accessing 
314.  * registers via SPI is not really different conceptually than using 
315.  * normal I/O assembler instructions, although it's much more 
316.  * complicated from a practical POV. So it's not advisable to always 
317.  * check the return value of this function. Imagine that every 
318.  * read{b,l}, write{b,l} and friends would be bracketed in "if ( < 0) 
319.  * error();", it would be a great mess (well there are some situation 
320.  * when exception handling C++ like could be useful after all). So we 
321.  * just check that transfers are OK at the beginning of our 
322.  * conversation with the chip and to avoid doing really nasty things 
323.  * (like injecting bogus packets in the network stack). 
324.  */  
325. static int mcp251x_spi_trans(struct spi_device *spi, int len)  
326. {  
327.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
328.     struct spi_transfer t = {  
329.         .tx_buf = priv->spi_tx_buf,  
330.         .rx_buf = priv->spi_rx_buf,  
331.         .len = len,  
332.         .cs_change = 0,  
333.     };  
334.     struct spi_message m;  
335.     int ret;  
336.   
337. //    DBG("mcp251x_spi_trans\n");  
338.   
339.     spi_message_init(&m);  
340.   
341.     if (mcp251x_enable_dma) {  
342.         t.tx_dma = priv->spi_tx_dma;  
343.         t.rx_dma = priv->spi_rx_dma;  
344.         m.is_dma_mapped = 1;  
345.     }  
346.   
347.     spi_message_add_tail(&t, &m);  
348.   
349.     ret = spi_sync(spi, &m);  
350.         //ret= spi_async (spi,&m);  
351.     if (ret)  
352.         dev_err(&spi->dev, "spi transfer failed: ret = %d\n", ret);  
353.          
354.     int i=0;  
355.   
356. DBG("打印spi直接发送的数据\n");  
357. for( i=0;i<len;i++)  
358. {  
359. DBG("priv->spi_tx_buf[%d]=%x\n",i,priv->spi_tx_buf[i]);  
360. }  
361.   
362. DBG("打印spi直接收到的数据\n");  
363. for( i=0;i<len;i++)  
364. {  
365. DBG("priv->spi_rx_buf[%d]=%x\n",i,priv->spi_rx_buf[i]);  
366. }  
367.     return ret;  
368. }  
369.   
370. static u8 mcp251x_read_reg(struct spi_device *spi, uint8_t reg)  
371. {  
372.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
373.   
374.     u8 val = 0;   
375.   
376. //INSTRUCTION_READ=3  
377. //根据mcp2515手册p64，使用spi接口读取寄存器的步骤是发送 命令03+地址  
378. //接收到的寄存器数据在spi_rx_buf[2]  
379.     priv->spi_tx_buf[0] = INSTRUCTION_READ;  
380.     priv->spi_tx_buf[1] = reg;  
381.   
382.     mcp251x_spi_trans(spi, 3);  
383.     val = priv->spi_rx_buf[2];  
384.   
385.     return val;  
386. }  
387.   
388. static void mcp251x_read_2regs(struct spi_device *spi, uint8_t reg,  
389.         uint8_t *v1, uint8_t *v2)  
390. {  
391.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
392.   
393.     priv->spi_tx_buf[0] = INSTRUCTION_READ;  
394.     priv->spi_tx_buf[1] = reg;  
395.   
396.     mcp251x_spi_trans(spi, 4);  
397. 接收到的寄存器数据在spi_rx_buf[2]，spi_rx_buf[3]  
398.     *v1 = priv->spi_rx_buf[2];  
399.     *v2 = priv->spi_rx_buf[3];  
400. }  
401.   
402. static void mcp251x_write_reg(struct spi_device *spi, u8 reg, uint8_t val)  
403. {  
404.       
405.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
406.    
407. //INSTRUCTION_WRITE=2  
408. //根据mcp2515手册p64，使用spi接口写寄存器的步骤是发送 命令02+地址+值  
409.   
410.     priv->spi_tx_buf[0] = INSTRUCTION_WRITE;  
411.     priv->spi_tx_buf[1] = reg;  
412.     priv->spi_tx_buf[2] = val;  
413.   
414.     mcp251x_spi_trans(spi, 3);  
415. }  
416.   
417. static void mcp251x_write_bits(struct spi_device *spi, u8 reg,  
418.                    u8 mask, uint8_t val)  
419. {  
420.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
421.   
422. //INSTRUCTION_BIT_MODIFY=5  
423. //位修改指令，对可执行位操作的寄存器有效  
424.     priv->spi_tx_buf[0] = INSTRUCTION_BIT_MODIFY;  
425.     priv->spi_tx_buf[1] = reg;  
426.     priv->spi_tx_buf[2] = mask;  
427.     priv->spi_tx_buf[3] = val;  
428.   
429.     mcp251x_spi_trans(spi, 4);  
430. }  
431.   
432. static void mcp251x_hw_tx_frame(struct spi_device *spi, u8 *buf,  
433.                 int len, int tx_buf_idx)  
434. {  
435.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
436. //如果是2510,还需要指定使用那个发送缓冲区发送数据  
437. //  
438.     if (mcp251x_is_2510(spi)) {  
439.         int i;  
440.         for (i = 1; i < TXBDAT_OFF + len; i++)  
441.             mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx) + i,  
442.                       buf[i]);  
443.     } else {  
444.         memcpy(priv->spi_tx_buf, buf, TXBDAT_OFF + len);  
445.         mcp251x_spi_trans(spi, TXBDAT_OFF + len);  
446.     }  
447. }  
448.   
449. static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame,  
450.               int tx_buf_idx)  
451. {  
452.     u32 sid, eid, exide, rtr;  
453.     u8 buf[SPI_TRANSFER_BUF_LEN];  
454.     exide = (frame->can_id & CAN_EFF_FLAG) ? 1 : 0; /* Extended ID Enable */  
455. DBG("打印是否扩展帧\n");  
456.     if (exide)  
457.         {  
458.         sid = (frame->can_id & CAN_EFF_MASK) >> 18;  
459.         DBG("是扩展帧\n");  
460.         }  
461.     else  
462.         {  
463.         sid = frame->can_id & CAN_SFF_MASK; /* Standard ID */  
464.         DBG("是标准帧\n");  
465.         }  
466.     eid = frame->can_id & CAN_EFF_MASK; /* Extended ID */  
467.     rtr = (frame->can_id & CAN_RTR_FLAG) ? 1 : 0; /* Remote transmission */  
468. //INSTRUCTION_LOAD_TXB(0)=0x40,即装载tx0缓冲器  
469.     buf[TXBCTRL_OFF] = INSTRUCTION_LOAD_TXB(tx_buf_idx);  
470.     buf[TXBSIDH_OFF] = sid >> SIDH_SHIFT;  
471.     buf[TXBSIDL_OFF] = ((sid & SIDL_SID_MASK) << SIDL_SID_SHIFT) |  
472.         (exide << SIDL_EXIDE_SHIFT) |  
473.         ((eid >> SIDL_EID_SHIFT) & SIDL_EID_MASK);  
474.     buf[TXBEID8_OFF] = GET_BYTE(eid, 1);  
475.     buf[TXBEID0_OFF] = GET_BYTE(eid, 0);  
476.     buf[TXBDLC_OFF] = (rtr << DLC_RTR_SHIFT) | frame->can_dlc;  
477.     memcpy(buf + TXBDAT_OFF, frame->data, frame->can_dlc);  
478. int i;  
479. DBG("打印送给spi的数据\n");  
480. for(i=0;i<SPI_TRANSFER_BUF_LEN;i++)  
481. {  
482. DBG("buf[%d]=%x\n",i,buf[i]);  
483. }  
484.     mcp251x_hw_tx_frame(spi, buf, frame->can_dlc, tx_buf_idx);//装载到tx0缓冲器  
485.     mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx), TXBCTRL_TXREQ);//请求发送tx0  
486. }  
487.   
488. static void mcp251x_hw_rx_frame(struct spi_device *spi, u8 *buf,  
489.                 int buf_idx)  
490. {  
491.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
492.   
493. //        DBG("mcp251x_hw_rx_frame\n");  
494. DBG("打印是否是mcp2515\n");  
495.     if (mcp251x_is_2510(spi)) {  
496. DBG("是mcp2510\n");  
497.         int i, len;  
498.         for (i = 1; i < RXBDAT_OFF; i++)  
499.             buf[i] = mcp251x_read_reg(spi, RXBCTRL(buf_idx) + i);  
500.   
501.         len = get_can_dlc(buf[RXBDLC_OFF] & RXBDLC_LEN_MASK);  
502.         for (; i < (RXBDAT_OFF + len); i++)  
503.             buf[i] = mcp251x_read_reg(spi, RXBCTRL(buf_idx) + i);  
504.     } else {  
505. DBG("是mcp2515\n");  
506. //INSTRUCTION_READ_RXB(0)=90,即读取rx0缓冲器  
507.         priv->spi_tx_buf[RXBCTRL_OFF] = INSTRUCTION_READ_RXB(buf_idx);  
508. /*SPI_TRANSFER_BUF_LEN=14， 
509. 即spi的发送和接收缓冲区都设为14 
510. 因为mcp2515共返回14个字节，假如是读rxbuf0,则 
511. RXBOCTRL 
512. RXB0SIDH 
513. RXB0SIDL 
514. RXB0EID8 
515. RXB0EID0 
516. RXB0DLC 
517. RXB0D0 
518. ... 
519. RXB0D7 
520. */  
521.         mcp251x_spi_trans(spi, SPI_TRANSFER_BUF_LEN);  
522.         memcpy(buf, priv->spi_rx_buf, SPI_TRANSFER_BUF_LEN);  
523.     }  
524. }  
525.   
526. static void mcp251x_hw_rx(struct spi_device *spi, int buf_idx)  
527. {  
528.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
529.     struct sk_buff *skb;  
530.     struct can_frame *frame;  
531.     u8 buf[SPI_TRANSFER_BUF_LEN];  
532.   
533. //    DBG("mcp251x_hw_rx\n");  
534.   
535.     skb = alloc_can_skb(priv->net, &frame);  
536.     if (!skb) {  
537.         dev_err(&spi->dev, "cannot allocate RX skb\n");  
538.         priv->net->stats.rx_dropped++;  
539.         return;  
540.     }  
541.   
542.     mcp251x_hw_rx_frame(spi, buf, buf_idx);// 接收数据  
543.   
544. DBG("打印从spi接收到buf里的数据\n");  
545.     DBG(" buf_idx=%d\n",buf_idx);  
546.     int i;  
547.     for(i=0;i<SPI_TRANSFER_BUF_LEN;i++)  
548.     {  
549.     DBG(" buf[%d]=%x\n",i,buf[i]);  
550.     }  
551.   
552. DBG("打印是否是扩展帧\n");  
553.     if (buf[RXBSIDL_OFF] & RXBSIDL_IDE) {  
554. //buf[RXBSIDL_OFF]即buf[2]即寄存器RXBnSIDL的第4位表示是否是扩展帧  
555. DBG("是扩展帧\n");  
556.         /* Extended ID format */  
557.         frame->can_id = CAN_EFF_FLAG;  
558.         frame->can_id |=  
559.             /* Extended ID part */  
560.             SET_BYTE(buf[RXBSIDL_OFF] & RXBSIDL_EID, 2) |  
561.             SET_BYTE(buf[RXBEID8_OFF], 1) |  
562.             SET_BYTE(buf[RXBEID0_OFF], 0) |  
563.             /* Standard ID part */  
564.             (((buf[RXBSIDH_OFF] << RXBSIDH_SHIFT) |  
565.               (buf[RXBSIDL_OFF] >> RXBSIDL_SHIFT)) << 18);  
566.         /* Remote transmission request */  
567.         if (buf[RXBDLC_OFF] & RXBDLC_RTR)  
568.             frame->can_id |= CAN_RTR_FLAG;  
569.     } else {  
570. DBG("是标准帧\n");  
571.         /* Standard ID format */  
572.   
573. //RXBSIDH的全8位和RXBSIDL的高3位即11位共同组成标准帧的标识符，详见mcp2515手册，  
574. //所以理论上一条can总线最多可分辨2048个设备(扩展帧也是11位标识符)  
575. //如果  
576. //buf[1]=寄存器RXBSIDH=0x24=0010 0100,<<3=0010 0100 000  
577. //buf[2]=寄存器RXBSIDL=0x60=0110 0000,>>5=011  
578. //加上之后=001 0010 0011=0x123  
579.         frame->can_id =  
580.             (buf[RXBSIDH_OFF] << RXBSIDH_SHIFT) |  
581.             (buf[RXBSIDL_OFF] >> RXBSIDL_SHIFT);  
582.   
583.         if (buf[RXBSIDL_OFF] & RXBSIDL_SRR)  
584.             frame->can_id |= CAN_RTR_FLAG;  
585.   
586.     }  
587.     /* Data length */  
588. //buf[3]=寄存器RXBEID8，标准帧不使用  
589. //buf[4]=寄存器RXBEID0，标准帧不使用  
590. //buf[5]=寄存器RXBDLC=数据段长度  
591.     frame->can_dlc = get_can_dlc(buf[RXBDLC_OFF] & RXBDLC_LEN_MASK);  
592. //buf[6]-buf[13]=8个数据寄存器RXB0D0-RXB0D7  
593.     memcpy(frame->data, buf + RXBDAT_OFF, frame->can_dlc);  
594. DBG("打印can_frame的字段\n");  
595. DBG(" frame->can_id=0x%x\n", frame->can_id);  
596. char *p=(char*)&(frame->can_id);  
597. for(i=0;i<4;i++)  
598. {  
599. DBG(" p=%x\n",*p);  
600. p++;  
601. }  
602.   
603. DBG(" frame->can_dlc=%d\n", frame->can_dlc);  
604.   
605. for(i=0;i<8;i++)  
606. {  
607. DBG(" frame->data[%d]=%x\n",i,frame->data[i]);  
608. }  
609.   
610.     priv->net->stats.rx_packets++;  
611.     priv->net->stats.rx_bytes += frame->can_dlc;  
612. DBG("打印skb里的数据\n");  
613. for(i=0;i<20;i++)  
614. {  
615. DBG("skb->data[%d]=%x\n",i,skb->data[i]);  
616. }  
617.     netif_rx_ni(skb);  
618. }  
619.   
620. static void mcp251x_hw_sleep(struct spi_device *spi)  
621. {  
622. //    DBG("mcp251x_hw_sleep\n");  
623.     mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_SLEEP);  
624. }  
625.   
626. static netdev_tx_t mcp251x_hard_start_xmit(struct sk_buff *skb,  
627.                        struct net_device *net)  
628. {  
629.     struct mcp251x_priv *priv = netdev_priv(net);  
630.     struct spi_device *spi = priv->spi;  
631. DBG("从应用层收到发送命令\n");  
632.     if (priv->tx_skb || priv->tx_len) {  
633.         dev_warn(&spi->dev, "hard_xmit called while tx busy\n");  
634.         return NETDEV_TX_BUSY;  
635.     }  
636.   
637.     if (can_dropped_invalid_skb(net, skb))  
638.         return NETDEV_TX_OK;  
639.   
640.     netif_stop_queue(net);  
641.     priv->tx_skb = skb;  
642. DBG("要发送的数据是skb\n");  
643. DBG("启动发送队列\n");  
644.     queue_work(priv->wq, &priv->tx_work);  
645.   
646.     return NETDEV_TX_OK;  
647. }  
648.   
649. static int mcp251x_do_set_mode(struct net_device *net, enum can_mode mode)  
650. {  
651.     struct mcp251x_priv *priv = netdev_priv(net);  
652.            
653. //        DBG("mcp251x_do_set_mode\n");  
654.   
655.     switch (mode) {  
656.     case CAN_MODE_START:  
657.         mcp251x_clean(net);  
658.         /* We have to delay work since SPI I/O may sleep */  
659.         priv->can.state = CAN_STATE_ERROR_ACTIVE;  
660.         priv->restart_tx = 1;  
661.         if (priv->can.restart_ms == 0)  
662.             priv->after_suspend = AFTER_SUSPEND_RESTART;  
663.         queue_work(priv->wq, &priv->restart_work);  
664.         break;  
665.     default:  
666.         return -EOPNOTSUPP;  
667.     }  
668.   
669.     return 0;  
670. }  
671.   
672. static int mcp251x_set_normal_mode(struct spi_device *spi)  
673. {  
674.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
675.     unsigned long timeout;  
676.   
677. //     DBG("mcp251x_set_normal_mode\n");  
678.   
679.     /* Enable interrupts */  
680.         intset=CANINTE_ERRIE | CANINTE_TX2IE | CANINTE_TX1IE | //CANINTF_MERRF |  
681.               CANINTE_TX0IE | CANINTE_RX1IE | CANINTE_RX0IE;  
682.     mcp251x_write_reg(spi, CANINTE,intset);  
683.   
684.   
685.     if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {  
686.         /* Put device into loopback mode */  
687.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LOOPBACK);  
688.     } else if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {  
689.         /* Put device into listen-only mode */  
690.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LISTEN_ONLY);  
691.     } else {  
692.         /* Put device into normal mode */  
693.         mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_NORMAL);  
694.   
695.         /* Wait for the device to enter normal mode */  
696.         timeout = jiffies + HZ;  
697.         while (mcp251x_read_reg(spi, CANSTAT) & CANCTRL_REQOP_MASK) {  
698.             schedule();  
699.             if (time_after(jiffies, timeout)) {  
700.                 dev_err(&spi->dev, "MCP251x didn't"  
701.                     " enter in normal mode\n");  
702.                 return -EBUSY;  
703.             }  
704.         }  
705.     }  
706.     priv->can.state = CAN_STATE_ERROR_ACTIVE;  
707.     return 0;  
708. }  
709.   
710. static int mcp251x_do_set_bittiming(struct net_device *net)  
711. {  
712.     struct mcp251x_priv *priv = netdev_priv(net);  
713.     struct can_bittiming *bt = &priv->can.bittiming;  
714.     struct spi_device *spi = priv->spi;  
715.   
716. //    DBG("mcp251x_do_set_bittiming\n");  
717.   
718.     mcp251x_write_reg(spi, CNF1, ((bt->sjw - 1) << CNF1_SJW_SHIFT) |  
719.               (bt->brp - 1));  
720.     mcp251x_write_reg(spi, CNF2, CNF2_BTLMODE |  
721.               (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES ?  
722.                CNF2_SAM : 0) |  
723.               ((bt->phase_seg1 - 1) << CNF2_PS1_SHIFT) |  
724.               (bt->prop_seg - 1));  
725.     mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK,  
726.                (bt->phase_seg2 - 1));  
727.     dev_info(&spi->dev, "CNF: 0x%02x 0x%02x 0x%02x\n",  
728.          mcp251x_read_reg(spi, CNF1),  
729.          mcp251x_read_reg(spi, CNF2),  
730.          mcp251x_read_reg(spi, CNF3));  
731.   
732.     return 0;  
733. }  
734.   
735. static int mcp251x_setup(struct net_device *net, struct mcp251x_priv *priv,  
736.              struct spi_device *spi)  
737. {  
738.     mcp251x_do_set_bittiming(net);  
739.   
740. //    DBG("mcp251x_setup\n");  
741.   
742.     mcp251x_write_reg(spi, RXBCTRL(0),  
743.               RXBCTRL_BUKT | RXBCTRL_RXM0 | RXBCTRL_RXM1);  
744.     mcp251x_write_reg(spi, RXBCTRL(1),  
745.               RXBCTRL_RXM0 | RXBCTRL_RXM1);  
746.     return 0;  
747. }  
748.   
749. static int mcp251x_hw_reset(struct spi_device *spi)  
750. {  
751.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
752.     int ret;  
753.     unsigned long timeout;  
754.   
755. //    DBG("mcp251x_hw_reset\n");  
756.   
757.     priv->spi_tx_buf[0] = INSTRUCTION_RESET;  
758.     ret = spi_write(spi, priv->spi_tx_buf, 1);  
759.     if (ret) {  
760.         dev_err(&spi->dev, "reset failed: ret = %d\n", ret);  
761.         return -EIO;  
762.     }  
763.   
764.     /* Wait for reset to finish */  
765.     timeout = jiffies + HZ;  
766.     mdelay(10);  
767.     while ((mcp251x_read_reg(spi, CANSTAT) & CANCTRL_REQOP_MASK)  
768.            != CANCTRL_REQOP_CONF) {  
769.         schedule();  
770.         if (time_after(jiffies, timeout)) {  
771.             dev_err(&spi->dev, "MCP251x didn't"  
772.                 " enter in conf mode after reset\n");  
773.             return -EBUSY;  
774.         }  
775.     }  
776.     return 0;  
777. }  
778.   
779. static int mcp251x_hw_probe(struct spi_device *spi)  
780. {  
781.     int st1, st2;  
782.   
783. //    DBG("mcp251x_hw_probe\n");  
784.   
785.     mcp251x_hw_reset(spi);  
786.   
787.     /* 
788.      * Please note that these are "magic values" based on after 
789.      * reset defaults taken from data sheet which allows us to see 
790.      * if we really have a chip on the bus (we avoid common all 
791.      * zeroes or all ones situations) 
792.      */  
793.     st1 = mcp251x_read_reg(spi, CANSTAT) & 0xEE;  
794.     st2 = mcp251x_read_reg(spi, CANCTRL) & 0x17;  
795.   
796.     dev_dbg(&spi->dev, "CANSTAT 0x%02x CANCTRL 0x%02x\n", st1, st2);  
797.   
798.     /* Check for power up default values */  
799.     return (st1 == 0x80 && st2 == 0x07) ? 1 : 0;  
800. }  
801.   
802. static void mcp251x_open_clean(struct net_device *net)  
803. {  
804.     struct mcp251x_priv *priv = netdev_priv(net);  
805.     struct spi_device *spi = priv->spi;  
806.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
807.   
808.         DBG("mcp251x_open_clean\n");  
809.   
810.     free_irq(spi->irq, priv);  
811.     mcp251x_hw_sleep(spi);  
812.     if (pdata->transceiver_enable)  
813.         pdata->transceiver_enable(0);  
814.     close_candev(net);  
815. }  
816.   
817. static int mcp251x_stop(struct net_device *net)  
818. {  
819.     struct mcp251x_priv *priv = netdev_priv(net);  
820.     struct spi_device *spi = priv->spi;  
821.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
822.   
823.      DBG("mcp251x_stop\n");  
824.   
825.     close_candev(net);  
826.   
827.     priv->force_quit = 1;  
828.         
829.     free_irq(spi->irq, priv);  
830.     destroy_workqueue(priv->wq);  
831.     priv->wq = NULL;  
832.   
833. //        del_timer(&check_timer);  //删除定时器  
834.   
835.     mutex_lock(&priv->mcp_lock);  
836.   
837.     /* Disable and clear pending interrupts */  
838.     mcp251x_write_reg(spi, CANINTE, 0x00);  
839.     mcp251x_write_reg(spi, CANINTF, 0x00);  
840.   
841.     mcp251x_write_reg(spi, TXBCTRL(0), 0);  
842.     mcp251x_clean(net);  
843.   
844.     mcp251x_hw_sleep(spi);  
845.   
846.     if (pdata->transceiver_enable)  
847.         pdata->transceiver_enable(0);  
848.   
849.     priv->can.state = CAN_STATE_STOPPED;  
850.   
851.     mutex_unlock(&priv->mcp_lock);  
852.   
853.     return 0;  
854. }  
855.   
856. static void mcp251x_error_skb(struct net_device *net, int can_id, int data1)  
857. {  
858.     struct sk_buff *skb;  
859.     struct can_frame *frame;  
860.   
861.      DBG("mcp251x_error_skb\n");  
862.   
863.     skb = alloc_can_err_skb(net, &frame);  
864.     if (skb) {  
865.         frame->can_id |= can_id;  
866.         frame->data[1] = data1;  
867.         netif_rx_ni(skb);  
868.     } else {  
869.         dev_err(&net->dev,  
870.             "cannot allocate error skb\n");  
871.     }  
872. }  
873.   
874. static void mcp251x_tx_work_handler(struct work_struct *ws)  
875. {  
876. DBG("进入发送队列\n");  
877.     struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,  
878.                          tx_work);  
879.     struct spi_device *spi = priv->spi;  
880.     struct net_device *net = priv->net;  
881.     struct can_frame *frame;  
882.   
883.     mutex_lock(&priv->mcp_lock);  
884.     if (priv->tx_skb) {  
885.         if (priv->can.state == CAN_STATE_BUS_OFF) {  
886.             mcp251x_clean(net);  
887.         } else {  
888. int i;  
889. DBG("打印skb里的数据\n");  
890. for(i=0;i<20;i++)  
891. {  
892. DBG("priv->tx_skb->data[%d]=%x\n",i,priv->tx_skb->data[i]);  
893. }  
894. //将skb里的数据给can_frame以便组织发送  
895.             frame = (struct can_frame *)priv->tx_skb->data;  
896. DBG("打印can_frame的字段\n");  
897. DBG(" frame->can_id=0x%x\n", frame->can_id);  
898. char *p=(char*)&(frame->can_id);  
899. for(i=0;i<4;i++)  
900. {  
901. DBG(" p=%x\n",*p);  
902. p++;  
903. }  
904. DBG(" frame->can_dlc=%d\n", frame->can_dlc);  
905. for(i=0;i<8;i++)  
906. {  
907. DBG(" frame->data[%d]=%x\n",i,frame->data[i]);  
908. }  
909.             if (frame->can_dlc > CAN_FRAME_MAX_DATA_LEN)  
910.                 frame->can_dlc = CAN_FRAME_MAX_DATA_LEN;  
911. //发送  
912.             mcp251x_hw_tx(spi, frame, 0);  
913.   
914.             priv->tx_len = 1 + frame->can_dlc;  
915.             can_put_echo_skb(priv->tx_skb, net, 0);  
916.             priv->tx_skb = NULL;  
917.         }  
918.     }  
919.     mutex_unlock(&priv->mcp_lock);  
920. }  
921.   
922. static void mcp251x_restart_work_handler(struct work_struct *ws)  
923. {  
924.     struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,  
925.                          restart_work);  
926.     struct spi_device *spi = priv->spi;  
927.     struct net_device *net = priv->net;  
928.   
929.     DBG("mcp251x_restart_work_handler\n");  
930.   
931.     mutex_lock(&priv->mcp_lock);  
932.     if (priv->after_suspend) {  
933.         mdelay(10);  
934.         mcp251x_hw_reset(spi);  
935.         mcp251x_setup(net, priv, spi);  
936.         if (priv->after_suspend & AFTER_SUSPEND_RESTART) {  
937.             mcp251x_set_normal_mode(spi);  
938.         } else if (priv->after_suspend & AFTER_SUSPEND_UP) {  
939.             netif_device_attach(net);  
940.             mcp251x_clean(net);  
941.             mcp251x_set_normal_mode(spi);  
942.             netif_wake_queue(net);  
943.         } else {  
944.             mcp251x_hw_sleep(spi);  
945.         }  
946.         priv->after_suspend = 0;  
947.         priv->force_quit = 0;  
948.     }  
949.   
950.     if (priv->restart_tx) {  
951.         priv->restart_tx = 0;  
952.         mcp251x_write_reg(spi, TXBCTRL(0), 0);  
953.         mcp251x_clean(net);  
954.         netif_wake_queue(net);  
955.         mcp251x_error_skb(net, CAN_ERR_RESTARTED, 0);  
956.     }  
957.     mutex_unlock(&priv->mcp_lock);  
958. }  
959.   
960.   
961. /*static void check_timer_callback(unsigned long arg) 
962. { 
963.     //DBG("timer clean CANINTF %X\n",arg); 
964.     //int pin=gpio_get_value(S3C64XX_GPL(8)); 
965.  //   int pin=gpio_get_value(S3C64XX_GPN(5)); 
966.  
967.     int pin=gpio_get_value(S3C64XX_GPL(8)); 
968.  
969. //    DBG("timer pin=%d \n",pin); 
970.  
971.     if(pin==0) 
972.     { 
973. //        struct mcp251x_priv *priv=(struct mcp251x_priv *)arg; 
974. //        schedule_work(&(priv->irq_work));  
975.         DBG("timer schedule work\n"); 
976.     } 
977.     mod_timer(&check_timer,jiffies+8);        //修改定时器 
978.  
979. }*/  
980.   
981.   
982. static irqreturn_t mcp251x_can_irq(int irq, void *dev_id)  
983. {  
984. DBG("有中断产生\n");  
985.        struct mcp251x_priv *priv = dev_id;  
986. //       struct spi_device *spi = priv->spi;  
987.       // int pin=gpio_get_value(S3C64XX_GPL(8));  
988.       // DBG("pin=%d \n",pin);  
989.    
990. //DBG("before disable_irq_nosync(irq);\n");  
991.         disable_irq_nosync(irq);  
992.     //disable_irq(irq);  
993. //DBG("after disable_irq_nosync(irq);\n");  
994.        //s3c_gpio_cfgpin(S3C64XX_GPL(8), S3C_GPIO_INPUT);  //关中断，为什么disable_irq死机  
995.        //while(S3C_GPIO_INPUT!=s3c_gpio_getcfg(S3C64XX_GPL(8)));  
996.        //schedule_work(&(priv->irq_work));   
997.   
998.        if (!work_pending(&priv->irq_work))  
999.         queue_work(priv->wq, &priv->irq_work);  
1000.         
1001.     //enable_irq(irq);  
1002.        return IRQ_HANDLED;  
1003. }  
1004. /* 
1005. static irqreturn_t mcp251x_can_irq(int irq, void *dev_id) 
1006. { 
1007. DBG("mcp251x_can_irq\n"); 
1008.        struct mcp251x_priv *priv = dev_id; 
1009. //       struct spi_device *spi = priv->spi; 
1010.       // int pin=gpio_get_value(S3C64XX_GPL(8)); 
1011.       // DBG("pin=%d \n",pin); 
1012.   
1013.  
1014.         //disable_irq_nosync(irq); 
1015.        s3c_gpio_cfgpin(S3C64XX_GPL(8), S3C_GPIO_INPUT);  //关中断，为什么disable_irq死机 
1016.        while(S3C_GPIO_INPUT!=s3c_gpio_getcfg(S3C64XX_GPL(8))); 
1017.        //schedule_work(&(priv->irq_work));  
1018.  
1019.        if (!work_pending(&priv->irq_work)) 
1020.         queue_work(priv->wq, &priv->irq_work); 
1021.        
1022.        return IRQ_HANDLED; 
1023. } 
1024. */  
1025.   
1026.   
1027.   
1028. void can_irq_work(struct work_struct *ws)  
1029. {  
1030.   
1031. DBG("进入中断下半部\n");  
1032.      struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,  
1033.                          irq_work);  
1034.      struct spi_device *spi = priv->spi;  
1035.      struct net_device *net = priv->net;  
1036.   
1037.     mutex_lock(&priv->mcp_lock);  
1038.         //mcp251x_write_reg(spi, CANINTE, (intset & (~ ( CANINTE_TX2IE) )));  
1039.     while (!priv->force_quit) {  
1040.         enum can_state new_state;  
1041.         u8 intf, eflag;  
1042.         
1043.         u8 clear_intf = 0;  
1044.         int can_id = 0, data1 = 0;  
1045.   
1046.                  
1047.         mcp251x_read_2regs(spi, CANINTF, &intf, &eflag);  
1048. //读取中断标志寄存器，用于判断是什么中断  
1049.                 DBG("中断标志=0x%x\n",intf);  
1050.                 //mcp251x_write_bits(spi, CANINTF, intf, 0x00);  
1051.           
1052.         /* mask out flags we don't care about */  
1053.         intf &= CANINTF_RX | CANINTF_TX | CANINTF_ERR ;//| CANINTF_MERRF;  
1054.   
1055.                 if (intf & CANINTF_TX) {  
1056. DBG("是发送完成中断: \n");  
1057.             net->stats.tx_packets++;  
1058.             net->stats.tx_bytes += priv->tx_len - 1;  
1059.             if (priv->tx_len) {  
1060.                 can_get_echo_skb(net, 0);  
1061.                 priv->tx_len = 0;  
1062.             }  
1063.             netif_wake_queue(net);  
1064.         }  
1065.   
1066.           
1067.         /* receive buffer 1 */  
1068.         if (intf & CANINTF_RX1IF) {  
1069. DBG("是接收到数据中断: \n");  
1070. DBG("receive buffer1有数据\n");  
1071.             mcp251x_hw_rx(spi, 1);  
1072.             /* the MCP2515 does this automatically */  
1073.             if (mcp251x_is_2510(spi))  
1074.                 clear_intf |= CANINTF_RX1IF;  
1075.         }  
1076.   
1077.                 /* receive buffer 0 */  
1078.         if (intf & CANINTF_RX0IF) {  
1079. DBG("是接收到数据中断: \n");  
1080. DBG("receive buffer0有数据\n");  
1081.             mcp251x_hw_rx(spi, 0);  
1082.             /* 
1083.              * Free one buffer ASAP 
1084.              * (The MCP2515 does this automatically.) 
1085.              */  
1086.             if (mcp251x_is_2510(spi))  
1087.                 mcp251x_write_bits(spi, CANINTF, CANINTF_RX0IF, 0x00);  
1088.         }  
1089.   
1090.      
1091.         /* any error or tx interrupt we need to clear? */  
1092.         if (intf & (CANINTF_ERR | CANINTF_TX))  
1093.             clear_intf |= intf & (CANINTF_ERR | CANINTF_TX);  
1094.         if (clear_intf)  
1095.             mcp251x_write_bits(spi, CANINTF, clear_intf, 0x00);  
1096.   
1097.         if (eflag)  
1098.             mcp251x_write_bits(spi, EFLG, eflag, 0x00);  
1099.   
1100.   
1101.                  
1102.         /* Update can state */  
1103.         if (eflag & EFLG_TXBO) {  
1104.             new_state = CAN_STATE_BUS_OFF;  
1105.             can_id |= CAN_ERR_BUSOFF;  
1106.         } else if (eflag & EFLG_TXEP) {  
1107.             new_state = CAN_STATE_ERROR_PASSIVE;  
1108.             can_id |= CAN_ERR_CRTL;  
1109.             data1 |= CAN_ERR_CRTL_TX_PASSIVE;  
1110.         } else if (eflag & EFLG_RXEP) {  
1111.             new_state = CAN_STATE_ERROR_PASSIVE;  
1112.             can_id |= CAN_ERR_CRTL;  
1113.             data1 |= CAN_ERR_CRTL_RX_PASSIVE;  
1114.         } else if (eflag & EFLG_TXWAR) {  
1115.             new_state = CAN_STATE_ERROR_WARNING;  
1116.             can_id |= CAN_ERR_CRTL;  
1117.             data1 |= CAN_ERR_CRTL_TX_WARNING;  
1118.         } else if (eflag & EFLG_RXWAR) {  
1119.             new_state = CAN_STATE_ERROR_WARNING;  
1120.             can_id |= CAN_ERR_CRTL;  
1121.             data1 |= CAN_ERR_CRTL_RX_WARNING;  
1122.         } else {  
1123.             new_state = CAN_STATE_ERROR_ACTIVE;  
1124.         }  
1125.   
1126.         /* Update can state statistics */  
1127.         switch (priv->can.state) {  
1128.         case CAN_STATE_ERROR_ACTIVE:  
1129.             if (new_state >= CAN_STATE_ERROR_WARNING &&  
1130.                 new_state <= CAN_STATE_BUS_OFF)  
1131.                 priv->can.can_stats.error_warning++;  
1132.         case CAN_STATE_ERROR_WARNING:    /* fallthrough */  
1133.             if (new_state >= CAN_STATE_ERROR_PASSIVE &&  
1134.                 new_state <= CAN_STATE_BUS_OFF)  
1135.                 priv->can.can_stats.error_passive++;  
1136.             break;  
1137.         default:  
1138.             break;  
1139.         }  
1140.         priv->can.state = new_state;  
1141.   
1142.         if (intf & CANINTF_ERRIF) {  
1143.             /* Handle overflow counters */  
1144.             if (eflag & (EFLG_RX0OVR | EFLG_RX1OVR)) {  
1145.                 if (eflag & EFLG_RX0OVR) {  
1146.                     net->stats.rx_over_errors++;  
1147.                     net->stats.rx_errors++;  
1148.                 }  
1149.                 if (eflag & EFLG_RX1OVR) {  
1150.                     net->stats.rx_over_errors++;  
1151.                     net->stats.rx_errors++;  
1152.                 }  
1153.                 can_id |= CAN_ERR_CRTL;  
1154.                 data1 |= CAN_ERR_CRTL_RX_OVERFLOW;  
1155.             }  
1156.             mcp251x_error_skb(net, can_id, data1);  
1157.         }  
1158.   
1159.   
1160.         if (priv->can.state == CAN_STATE_BUS_OFF) {  
1161.             if (priv->can.restart_ms == 0) {  
1162.                 priv->force_quit = 1;  
1163.                 can_bus_off(net);  
1164.                 mcp251x_hw_sleep(spi);  
1165.                 break;  
1166.             }  
1167.         }  
1168.   
1169.                 if (intf == 0)  
1170.             break;  
1171.       
1172.   
1173.     }  
1174.         //mcp251x_write_reg(spi, CANINTE, intset);  
1175.     mutex_unlock(&priv->mcp_lock);    
1176.         enable_irq(spi->irq);  
1177.         //s3c_gpio_cfgpin(S3C64XX_GPL(8), S3C_GPIO_SFN(3));    //开中断   
1178. }  
1179.   
1180.   
1181.   
1182.   
1183. static int mcp251x_open(struct net_device *net)  
1184. {  
1185.     struct mcp251x_priv *priv = netdev_priv(net);  
1186.     struct spi_device *spi = priv->spi;  
1187.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
1188.     int ret;  
1189.   
1190.  //       DBG("mcp251x_open\n");  
1191. DBG("mcp251x_open");  
1192.     ret = open_candev(net);  
1193.     if (ret) {  
1194.         dev_err(&spi->dev, "unable to set initial baudrate!\n");  
1195.         return ret;  
1196.     }  
1197.   
1198.     mutex_lock(&priv->mcp_lock);  
1199.     if (pdata->transceiver_enable)  
1200.         pdata->transceiver_enable(1);  
1201.   
1202.     priv->force_quit = 0;  
1203.     priv->tx_skb = NULL;  
1204.     priv->tx_len = 0;  
1205.   
1206. /*    ret = request_threaded_irq(spi->irq, NULL, mcp251x_can_ist, 
1207.           pdata->irq_flags ? pdata->irq_flags : IRQF_TRIGGER_FALLING, //IRQF_TRIGGER_LOW,  //  
1208.           DEVICE_NAME, priv);*/  
1209.   
1210.     ret = request_irq(spi->irq, mcp251x_can_irq,  
1211.               //IRQF_TRIGGER_FALLING,  
1212.                           /*IRQF_DISABLED |*/ IRQF_TRIGGER_LOW , //note by song  
1213.               DEVICE_NAME, priv);  
1214.   
1215.     INIT_WORK(&priv->irq_work,can_irq_work);  
1216.   
1217.   
1218.     if (ret) {  
1219.         dev_err(&spi->dev, "failed to acquire irq %d\n", spi->irq);  
1220.         if (pdata->transceiver_enable)  
1221.             pdata->transceiver_enable(0);  
1222.         close_candev(net);  
1223.         goto open_unlock;  
1224.     }  
1225.   
1226. //    init_timer(&check_timer);   //初始化定时器  
1227. //        check_timer.expires=jiffies+HZ;  
1228. //        check_timer.function=&check_timer_callback;  
1229. //        check_timer.data=(long)priv;  
1230.         //add_timer(&check_timer);        //添加定时器*/  
1231.   
1232.     priv->wq = create_freezable_workqueue("mcp251x_wq");  
1233.         //priv->wq = create_freezeable_workqueue("mcp251x_wq");  
1234.   
1235.     INIT_WORK(&priv->tx_work, mcp251x_tx_work_handler);  
1236.     INIT_WORK(&priv->restart_work, mcp251x_restart_work_handler);  
1237.   
1238.     ret = mcp251x_hw_reset(spi);  
1239.     if (ret) {  
1240.         mcp251x_open_clean(net);  
1241.         goto open_unlock;  
1242.     }  
1243.     ret = mcp251x_setup(net, priv, spi);  
1244.     if (ret) {  
1245.         mcp251x_open_clean(net);  
1246.         goto open_unlock;  
1247.     }  
1248.     ret = mcp251x_set_normal_mode(spi);  
1249.     if (ret) {  
1250.         mcp251x_open_clean(net);  
1251.         goto open_unlock;  
1252.     }  
1253.     netif_wake_queue(net);  
1254.   
1255. open_unlock:  
1256.     mutex_unlock(&priv->mcp_lock);  
1257.     return ret;  
1258. }  
1259.   
1260. static const struct net_device_ops mcp251x_netdev_ops = {  
1261.     .ndo_open = mcp251x_open,  
1262.     .ndo_stop = mcp251x_stop,  
1263.     .ndo_start_xmit = mcp251x_hard_start_xmit,  
1264. };  
1265.   
1266. static int __devinit mcp251x_can_probe(struct spi_device *spi)  
1267. {  
1268.     struct net_device *net;  
1269.     struct mcp251x_priv *priv;  
1270.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
1271.     int ret = -ENODEV;  
1272.   
1273.     DBG("@@@@@@@@@@@@@@@@@@@@\n");  
1274.     DBG("mcp251x_can_probe \n");  
1275.     DBG("@@@@@@@@@@@@@@@@@@@@\n");  
1276.   
1277.     if (!pdata)  
1278.         /* Platform data is required for osc freq */  
1279.         goto error_out;  
1280.   
1281.     /* Allocate can/net device */  
1282.     net = alloc_candev(sizeof(struct mcp251x_priv), TX_ECHO_SKB_MAX);  
1283.     if (!net) {  
1284.         ret = -ENOMEM;  
1285.         goto error_alloc;  
1286.     }  
1287.   
1288.     net->netdev_ops = &mcp251x_netdev_ops;  
1289.     net->flags |= IFF_ECHO;  
1290.   
1291.     priv = netdev_priv(net);  
1292.     priv->can.bittiming_const = &mcp251x_bittiming_const;  
1293.     priv->can.do_set_mode = mcp251x_do_set_mode;  
1294.     priv->can.clock.freq = pdata->oscillator_frequency / 2;  
1295.     priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |  
1296.         CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY;  
1297.     priv->model = spi_get_device_id(spi)->driver_data;  
1298.     priv->net = net;  
1299.     dev_set_drvdata(&spi->dev, priv);  
1300.   
1301.     priv->spi = spi;  
1302.     mutex_init(&priv->mcp_lock);  
1303.       
1304.     /* If requested, allocate DMA buffers */  
1305.     if (mcp251x_enable_dma) {  
1306.         spi->dev.coherent_dma_mask = ~0;  
1307.         /* 
1308.          * Minimum coherent DMA allocation is PAGE_SIZE, so allocate 
1309.          * that much and share it between Tx and Rx DMA buffers. 
1310.          */  
1311.         priv->spi_tx_buf = dma_alloc_coherent(&spi->dev,  
1312.                               PAGE_SIZE,  
1313.                               &priv->spi_tx_dma,  
1314.                               GFP_DMA);  
1315.   
1316.         if (priv->spi_tx_buf) {  
1317.             priv->spi_rx_buf = (u8 *)(priv->spi_tx_buf +  
1318.                           (PAGE_SIZE / 2));  
1319.             priv->spi_rx_dma = (dma_addr_t)(priv->spi_tx_dma +  
1320.                             (PAGE_SIZE / 2));  
1321.         } else {  
1322.             /* Fall back to non-DMA */  
1323.             mcp251x_enable_dma = 0;  
1324.         }  
1325.     }  
1326.   
1327.     /* Allocate non-DMA buffers */  
1328.     if (!mcp251x_enable_dma) {  
1329.         priv->spi_tx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);  
1330.         if (!priv->spi_tx_buf) {  
1331.             ret = -ENOMEM;  
1332.             goto error_tx_buf;  
1333.         }  
1334.         priv->spi_rx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);  
1335.         if (!priv->spi_rx_buf) {  
1336.             ret = -ENOMEM;  
1337.             goto error_rx_buf;  
1338.         }  
1339.     }  
1340.   
1341.     if (pdata->power_enable)  
1342.         pdata->power_enable(1);  
1343.   
1344.     /* Call out to platform specific setup */  
1345.     if (pdata->board_specific_setup)  
1346.         pdata->board_specific_setup(spi);  
1347.   
1348.     SET_NETDEV_DEV(net, &spi->dev);  
1349.   
1350.     /* Configure the SPI bus */  
1351.     spi->mode = SPI_MODE_0;  
1352.     spi->bits_per_word = 8;  
1353.     spi_setup(spi);  
1354.   
1355.     /* Here is OK to not lock the MCP, no one knows about it yet */  
1356.     if (!mcp251x_hw_probe(spi)) {  
1357.         dev_info(&spi->dev, "Probe failed\n");  
1358.         goto error_probe;  
1359.     }  
1360.     mcp251x_hw_sleep(spi);  
1361.   
1362.     if (pdata->transceiver_enable)  
1363.         pdata->transceiver_enable(0);  
1364.   
1365.     ret = register_candev(net);  
1366.     DBG("@@@@@@@@@@@@@@@@@@@@\n");  
1367.     DBG("register_candev ret = %d\n",ret);  
1368.     DBG("@@@@@@@@@@@@@@@@@@@@\n");  
1369.     if (!ret) {  
1370.         dev_info(&spi->dev, "probed\n");  
1371.         return ret;  
1372.     }  
1373. error_probe:  
1374.     if (!mcp251x_enable_dma)  
1375.         kfree(priv->spi_rx_buf);  
1376. error_rx_buf:  
1377.     if (!mcp251x_enable_dma)  
1378.         kfree(priv->spi_tx_buf);  
1379. error_tx_buf:  
1380.     free_candev(net);  
1381.     if (mcp251x_enable_dma)  
1382.         dma_free_coherent(&spi->dev, PAGE_SIZE,  
1383.                   priv->spi_tx_buf, priv->spi_tx_dma);  
1384. error_alloc:  
1385.     if (pdata->power_enable)  
1386.         pdata->power_enable(0);  
1387.     dev_err(&spi->dev, "probe failed\n");  
1388. error_out:  
1389.     return ret;  
1390. }  
1391.   
1392. static int __devexit mcp251x_can_remove(struct spi_device *spi)  
1393. {  
1394.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
1395.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
1396.     struct net_device *net = priv->net;  
1397.   
1398.     DBG("mcp251x_can_remove\n");  
1399.   
1400.     unregister_candev(net);  
1401.     free_candev(net);  
1402.   
1403.     if (mcp251x_enable_dma) {  
1404.         dma_free_coherent(&spi->dev, PAGE_SIZE,  
1405.                   priv->spi_tx_buf, priv->spi_tx_dma);  
1406.     } else {  
1407.         kfree(priv->spi_tx_buf);  
1408.         kfree(priv->spi_rx_buf);  
1409.     }  
1410.   
1411.     if (pdata->power_enable)  
1412.         pdata->power_enable(0);  
1413.   
1414.     return 0;  
1415. }  
1416.   
1417. #ifdef CONFIG_PM  
1418. static int mcp251x_can_suspend(struct spi_device *spi, pm_message_t state)  
1419. {  
1420.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
1421.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
1422.     struct net_device *net = priv->net;  
1423.   
1424.     DBG("mcp251x_can_suspend\n");  
1425.   
1426.     priv->force_quit = 1;  
1427.     disable_irq(spi->irq);  
1428.     /* 
1429.      * Note: at this point neither IST nor workqueues are running. 
1430.      * open/stop cannot be called anyway so locking is not needed 
1431.      */  
1432.     if (netif_running(net)) {  
1433.         netif_device_detach(net);  
1434.   
1435.         mcp251x_hw_sleep(spi);  
1436.         if (pdata->transceiver_enable)  
1437.             pdata->transceiver_enable(0);  
1438.         priv->after_suspend = AFTER_SUSPEND_UP;  
1439.     } else {  
1440.         priv->after_suspend = AFTER_SUSPEND_DOWN;  
1441.     }  
1442.   
1443.     if (pdata->power_enable) {  
1444.         pdata->power_enable(0);  
1445.         priv->after_suspend |= AFTER_SUSPEND_POWER;  
1446.     }  
1447.   
1448.     return 0;  
1449. }  
1450.   
1451. static int mcp251x_can_resume(struct spi_device *spi)  
1452. {  
1453.         DBG("mcp251x_can_resume\n");  
1454.     struct mcp251x_platform_data *pdata = spi->dev.platform_data;  
1455.     struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);  
1456.   
1457.     if (priv->after_suspend & AFTER_SUSPEND_POWER) {  
1458.         pdata->power_enable(1);  
1459.         queue_work(priv->wq, &priv->restart_work);  
1460.     } else {  
1461.         if (priv->after_suspend & AFTER_SUSPEND_UP) {  
1462.             if (pdata->transceiver_enable)  
1463.                 pdata->transceiver_enable(1);  
1464.             queue_work(priv->wq, &priv->restart_work);  
1465.         } else {  
1466.             priv->after_suspend = 0;  
1467.         }  
1468.     }  
1469.     priv->force_quit = 0;  
1470.     enable_irq(spi->irq);  
1471.     return 0;  
1472. }  
1473. #else  
1474. #define mcp251x_can_suspend NULL  
1475. #define mcp251x_can_resume NULL  
1476. #endif  
1477.   
1478. static const struct spi_device_id mcp251x_id_table[] = {  
1479.     { "mcp2510",    CAN_MCP251X_MCP2510 },  
1480.     { "mcp2515",    CAN_MCP251X_MCP2515 },  
1481.     { },  
1482. };  
1483.   
1484. MODULE_DEVICE_TABLE(spi, mcp251x_id_table);  
1485.   
1486. static struct spi_driver mcp251x_can_driver = {  
1487.     .driver = {  
1488.         .name = DEVICE_NAME,  
1489.         .bus = &spi_bus_type,  
1490.         .owner = THIS_MODULE,  
1491.     },  
1492.   
1493.     .id_table = mcp251x_id_table,  
1494.     .probe = mcp251x_can_probe,  
1495.     .remove = __devexit_p(mcp251x_can_remove),  
1496.     .suspend = mcp251x_can_suspend,  
1497.     .resume = mcp251x_can_resume,  
1498. };  
1499.   
1500. static int __init mcp251x_can_init(void)  
1501. {  
1502. DBG("init\n");  
1503.     return spi_register_driver(&mcp251x_can_driver);  
1504. }  
1505.   
1506. static void __exit mcp251x_can_exit(void)  
1507. {  
1508. DBG("exit\n");  
1509.     spi_unregister_driver(&mcp251x_can_driver);  
1510. }  
1511.   
1512. module_init(mcp251x_can_init);  
1513. module_exit(mcp251x_can_exit);  
1514.   
1515. MODULE_AUTHOR("Chris Elston <celston@katalix.com>, "  
1516.           "Christian Pellegrin <chripell@evolware.org>");  
1517. MODULE_DESCRIPTION("Microchip 251x CAN driver");  
1518. MODULE_LICENSE("GPL v2");  

******************************************************************
几个疑点分析----以下讨论适用于te6410
中断注册

1. static inline int __must_check  
2. request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,  
3.         const char *name, void *dev)  
4. {  
5.     return request_threaded_irq(irq, handler, NULL, flags, name, dev);  
6. }  

原来他调用了request_threaded_irq(),并将中断处理函数(上半部)handler作为参数传递过去。追踪到request_threaded_irq，如下

1. int request_threaded_irq(unsigned int irq, irq_handler_t handler,  
2.              irq_handler_t thread_fn, unsigned long irqflags,  
3.              const char *devname, void *dev_id)  

其中要注意的两个参数，
irq_handler_t   handler，中断处理函数上半部
irq_handler_t   thread_fn，中断线程化，这样直接实现了中断处理函数的下半部，不必自己再去使用工作队列实现下半部了
/*
附工作队列的实现
创建工作队列，并加入到一个工作者线程里让其去执行。这个工作者线程可以使内核现成的，也可以使自己心创建的。
创建一个工作队列work_struct，使用DECLARE_WORK静态创建一个工作队列，参数包括队列名称和队列函数，也可使用INIT_WORK动态创建。
创建一个新的工作者线程workqueue_struct,使用create_workqueue，返回值是工作者线程指针。

将工作队列放到指定的工作者线程中去执行，
int queue_work(struct workqueue_struct *wq, struct work_struct *work)
将工作队列放到系统已有的events工作者线程中去执行，直接调用sheldule_work(&work)即可。

工作者线程是一个内核线程，运行在进程上下文。
工作者线程被唤醒时，会依次执行它里面的工作队列----组成了一个链表。

*/

搜索2.6.32.2源码，只发现一个同时使用了这两个参数的例子Broadcom B43 wireless driver,位于dribers/net/wireless/b43/main.c

1. err = request_threaded_irq(dev->dev->irq, b43_interrupt_handler,  
2.                b43_interrupt_thread_handler,  
3.                IRQF_SHARED, KBUILD_MODNAME, dev);  

其在中断上半部b43_interrupt_handler里禁止中断，在中断下半部b43_interrupt_thread_handler里批量读取数据然后重新使能中断(如果要清除中断标志位，则在使能之前先清除一下)。

其余的例子几乎都只使用了一个参数thread_fn，而handler置为NULL,比如
mcs5000_ts.c - Touchscreen driver for MELFAS MCS-5000 controller

1. ret = request_threaded_irq(client->irq, NULL, mcs5000_ts_interrupt,  
2.         IRQF_TRIGGER_LOW | IRQF_ONESHOT, "mcs5000_ts", data);  

又如本文要讨论的 mcp251x.c - CAN bus driver for Microchip 251x CAN Controller with SPI Interface

1. ret = request_threaded_irq(spi->irq, NULL, mcp251x_can_ist,  
2.           IRQF_TRIGGER_FALLING, DEVICE_NAME, priv);  

中断触发
使用IRQF_TRIGGER_FALLING作为中断触发的条件。而mcp2515则是只要有数据发送完成(发给can总线)或有新的数据到来(来自can总线)就会置int引脚低电平，此脚接到0k6410的eint16，向ok6410发送中断中断信号。

MCP2515有八个中断源。CANINTE寄存器包含了使能各中断源的中断使能位。 CANINTF 寄存器包含了各中断源的中断标志位。当发生中断时，INT 引脚将被MCP2515拉为低电平，并保持低电平状态直至MCU清除中断。中断只有在引起相应中断的条件消失后，才会被清除。mcp2515会自动清除中断吗？说明书上没写自动清除。mcp251x.c中却认为可以自动清除？

如果使用低电平触发，则须存在中断上半部，在上半部里面先disable此中断，然后在下半部里面传输完数据之后再enable此中断。
如果不在上半部disable此中断，则由于低电平一直存在，就会一直触发中断，从而一直执行中断上半部，(下半部根本就没机会执行到)，造成死机。

如果使用低电平触发，如果中断上半部函数指针设为NULL，那么即使在中断下半部执行disable此中断，也会造成死机。
因为中断发生时，不会立即执行下半部函数，所以有可能没及时禁掉此中断，造成中断(此时仍然低电平)继续触发而使下半部线程大量重复的创建(或许)造成死机。

如果使用下降沿触发，可以不存在上半部，即上半部函数指针可设为NULL，在下半部中可以先disable此中断，然后读取数据再清除中断标志位

******************************************************************

refer to
lkd2
http://blog.csdn.net/zhangjie201412/article/details/7067448