1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * CAN driver for EMS Dr. Thomas Wuensche CPC-USB/ARM7 |
4 | * |
5 | * Copyright (C) 2004-2009 EMS Dr. Thomas Wuensche |
6 | */ |
7 | #include <linux/ethtool.h> |
8 | #include <linux/signal.h> |
9 | #include <linux/slab.h> |
10 | #include <linux/module.h> |
11 | #include <linux/netdevice.h> |
12 | #include <linux/usb.h> |
13 | |
14 | #include <linux/can.h> |
15 | #include <linux/can/dev.h> |
16 | #include <linux/can/error.h> |
17 | |
18 | MODULE_AUTHOR("Sebastian Haas <haas@ems-wuensche.com>" ); |
19 | MODULE_DESCRIPTION("CAN driver for EMS Dr. Thomas Wuensche CAN/USB interfaces" ); |
20 | MODULE_LICENSE("GPL v2" ); |
21 | |
22 | /* Control-Values for CPC_Control() Command Subject Selection */ |
23 | #define CONTR_CAN_MESSAGE 0x04 |
24 | #define CONTR_CAN_STATE 0x0C |
25 | #define CONTR_BUS_ERROR 0x1C |
26 | |
27 | /* Control Command Actions */ |
28 | #define CONTR_CONT_OFF 0 |
29 | #define CONTR_CONT_ON 1 |
30 | #define CONTR_ONCE 2 |
31 | |
32 | /* Messages from CPC to PC */ |
33 | #define CPC_MSG_TYPE_CAN_FRAME 1 /* CAN data frame */ |
34 | #define CPC_MSG_TYPE_RTR_FRAME 8 /* CAN remote frame */ |
35 | #define CPC_MSG_TYPE_CAN_PARAMS 12 /* Actual CAN parameters */ |
36 | #define CPC_MSG_TYPE_CAN_STATE 14 /* CAN state message */ |
37 | #define CPC_MSG_TYPE_EXT_CAN_FRAME 16 /* Extended CAN data frame */ |
38 | #define CPC_MSG_TYPE_EXT_RTR_FRAME 17 /* Extended remote frame */ |
39 | #define CPC_MSG_TYPE_CONTROL 19 /* change interface behavior */ |
40 | #define CPC_MSG_TYPE_CONFIRM 20 /* command processed confirmation */ |
41 | #define CPC_MSG_TYPE_OVERRUN 21 /* overrun events */ |
42 | #define CPC_MSG_TYPE_CAN_FRAME_ERROR 23 /* detected bus errors */ |
43 | #define CPC_MSG_TYPE_ERR_COUNTER 25 /* RX/TX error counter */ |
44 | |
45 | /* Messages from the PC to the CPC interface */ |
46 | #define CPC_CMD_TYPE_CAN_FRAME 1 /* CAN data frame */ |
47 | #define CPC_CMD_TYPE_CONTROL 3 /* control of interface behavior */ |
48 | #define CPC_CMD_TYPE_CAN_PARAMS 6 /* set CAN parameters */ |
49 | #define CPC_CMD_TYPE_RTR_FRAME 13 /* CAN remote frame */ |
50 | #define CPC_CMD_TYPE_CAN_STATE 14 /* CAN state message */ |
51 | #define CPC_CMD_TYPE_EXT_CAN_FRAME 15 /* Extended CAN data frame */ |
52 | #define CPC_CMD_TYPE_EXT_RTR_FRAME 16 /* Extended CAN remote frame */ |
53 | #define CPC_CMD_TYPE_CAN_EXIT 200 /* exit the CAN */ |
54 | |
55 | #define CPC_CMD_TYPE_INQ_ERR_COUNTER 25 /* request the CAN error counters */ |
56 | #define CPC_CMD_TYPE_CLEAR_MSG_QUEUE 8 /* clear CPC_MSG queue */ |
57 | #define CPC_CMD_TYPE_CLEAR_CMD_QUEUE 28 /* clear CPC_CMD queue */ |
58 | |
59 | #define CPC_CC_TYPE_SJA1000 2 /* Philips basic CAN controller */ |
60 | |
61 | #define CPC_CAN_ECODE_ERRFRAME 0x01 /* Ecode type */ |
62 | |
63 | /* Overrun types */ |
64 | #define CPC_OVR_EVENT_CAN 0x01 |
65 | #define CPC_OVR_EVENT_CANSTATE 0x02 |
66 | #define CPC_OVR_EVENT_BUSERROR 0x04 |
67 | |
68 | /* |
69 | * If the CAN controller lost a message we indicate it with the highest bit |
70 | * set in the count field. |
71 | */ |
72 | #define CPC_OVR_HW 0x80 |
73 | |
74 | /* Size of the "struct ems_cpc_msg" without the union */ |
75 | #define 11 |
76 | #define CPC_CAN_MSG_MIN_SIZE 5 |
77 | |
78 | /* Define these values to match your devices */ |
79 | #define USB_CPCUSB_VENDOR_ID 0x12D6 |
80 | |
81 | #define USB_CPCUSB_ARM7_PRODUCT_ID 0x0444 |
82 | |
83 | /* Mode register NXP LPC2119/SJA1000 CAN Controller */ |
84 | #define SJA1000_MOD_NORMAL 0x00 |
85 | #define SJA1000_MOD_RM 0x01 |
86 | |
87 | /* ECC register NXP LPC2119/SJA1000 CAN Controller */ |
88 | #define SJA1000_ECC_SEG 0x1F |
89 | #define SJA1000_ECC_DIR 0x20 |
90 | #define SJA1000_ECC_ERR 0x06 |
91 | #define SJA1000_ECC_BIT 0x00 |
92 | #define SJA1000_ECC_FORM 0x40 |
93 | #define SJA1000_ECC_STUFF 0x80 |
94 | #define SJA1000_ECC_MASK 0xc0 |
95 | |
96 | /* Status register content */ |
97 | #define SJA1000_SR_BS 0x80 |
98 | #define SJA1000_SR_ES 0x40 |
99 | |
100 | #define SJA1000_DEFAULT_OUTPUT_CONTROL 0xDA |
101 | |
102 | /* |
103 | * The device actually uses a 16MHz clock to generate the CAN clock |
104 | * but it expects SJA1000 bit settings based on 8MHz (is internally |
105 | * converted). |
106 | */ |
107 | #define EMS_USB_ARM7_CLOCK 8000000 |
108 | |
109 | #define CPC_TX_QUEUE_TRIGGER_LOW 25 |
110 | #define CPC_TX_QUEUE_TRIGGER_HIGH 35 |
111 | |
112 | /* |
113 | * CAN-Message representation in a CPC_MSG. Message object type is |
114 | * CPC_MSG_TYPE_CAN_FRAME or CPC_MSG_TYPE_RTR_FRAME or |
115 | * CPC_MSG_TYPE_EXT_CAN_FRAME or CPC_MSG_TYPE_EXT_RTR_FRAME. |
116 | */ |
117 | struct cpc_can_msg { |
118 | __le32 id; |
119 | u8 length; |
120 | u8 msg[8]; |
121 | }; |
122 | |
123 | /* Representation of the CAN parameters for the SJA1000 controller */ |
124 | struct cpc_sja1000_params { |
125 | u8 mode; |
126 | u8 acc_code0; |
127 | u8 acc_code1; |
128 | u8 acc_code2; |
129 | u8 acc_code3; |
130 | u8 acc_mask0; |
131 | u8 acc_mask1; |
132 | u8 acc_mask2; |
133 | u8 acc_mask3; |
134 | u8 btr0; |
135 | u8 btr1; |
136 | u8 outp_contr; |
137 | }; |
138 | |
139 | /* CAN params message representation */ |
140 | struct cpc_can_params { |
141 | u8 cc_type; |
142 | |
143 | /* Will support M16C CAN controller in the future */ |
144 | union { |
145 | struct cpc_sja1000_params sja1000; |
146 | } cc_params; |
147 | }; |
148 | |
149 | /* Structure for confirmed message handling */ |
150 | struct cpc_confirm { |
151 | u8 error; /* error code */ |
152 | }; |
153 | |
154 | /* Structure for overrun conditions */ |
155 | struct cpc_overrun { |
156 | u8 event; |
157 | u8 count; |
158 | }; |
159 | |
160 | /* SJA1000 CAN errors (compatible to NXP LPC2119) */ |
161 | struct cpc_sja1000_can_error { |
162 | u8 ecc; |
163 | u8 rxerr; |
164 | u8 txerr; |
165 | }; |
166 | |
167 | /* structure for CAN error conditions */ |
168 | struct cpc_can_error { |
169 | u8 ecode; |
170 | |
171 | struct { |
172 | u8 cc_type; |
173 | |
174 | /* Other controllers may also provide error code capture regs */ |
175 | union { |
176 | struct cpc_sja1000_can_error sja1000; |
177 | } regs; |
178 | } cc; |
179 | }; |
180 | |
181 | /* |
182 | * Structure containing RX/TX error counter. This structure is used to request |
183 | * the values of the CAN controllers TX and RX error counter. |
184 | */ |
185 | struct cpc_can_err_counter { |
186 | u8 rx; |
187 | u8 tx; |
188 | }; |
189 | |
190 | /* Main message type used between library and application */ |
191 | struct __packed ems_cpc_msg { |
192 | u8 type; /* type of message */ |
193 | u8 length; /* length of data within union 'msg' */ |
194 | u8 msgid; /* confirmation handle */ |
195 | __le32 ts_sec; /* timestamp in seconds */ |
196 | __le32 ts_nsec; /* timestamp in nano seconds */ |
197 | |
198 | union __packed { |
199 | u8 generic[64]; |
200 | struct cpc_can_msg can_msg; |
201 | struct cpc_can_params can_params; |
202 | struct cpc_confirm confirmation; |
203 | struct cpc_overrun overrun; |
204 | struct cpc_can_error error; |
205 | struct cpc_can_err_counter err_counter; |
206 | u8 can_state; |
207 | } msg; |
208 | }; |
209 | |
210 | /* |
211 | * Table of devices that work with this driver |
212 | * NOTE: This driver supports only CPC-USB/ARM7 (LPC2119) yet. |
213 | */ |
214 | static struct usb_device_id ems_usb_table[] = { |
215 | {USB_DEVICE(USB_CPCUSB_VENDOR_ID, USB_CPCUSB_ARM7_PRODUCT_ID)}, |
216 | {} /* Terminating entry */ |
217 | }; |
218 | |
219 | MODULE_DEVICE_TABLE(usb, ems_usb_table); |
220 | |
221 | #define RX_BUFFER_SIZE 64 |
222 | #define 4 |
223 | #define INTR_IN_BUFFER_SIZE 4 |
224 | |
225 | #define MAX_RX_URBS 10 |
226 | #define MAX_TX_URBS 10 |
227 | |
228 | struct ems_usb; |
229 | |
230 | struct ems_tx_urb_context { |
231 | struct ems_usb *dev; |
232 | |
233 | u32 echo_index; |
234 | }; |
235 | |
236 | struct ems_usb { |
237 | struct can_priv can; /* must be the first member */ |
238 | |
239 | struct sk_buff *echo_skb[MAX_TX_URBS]; |
240 | |
241 | struct usb_device *udev; |
242 | struct net_device *netdev; |
243 | |
244 | atomic_t active_tx_urbs; |
245 | struct usb_anchor tx_submitted; |
246 | struct ems_tx_urb_context tx_contexts[MAX_TX_URBS]; |
247 | |
248 | struct usb_anchor rx_submitted; |
249 | |
250 | struct urb *intr_urb; |
251 | |
252 | u8 *tx_msg_buffer; |
253 | |
254 | u8 *intr_in_buffer; |
255 | unsigned int free_slots; /* remember number of available slots */ |
256 | |
257 | struct ems_cpc_msg active_params; /* active controller parameters */ |
258 | void *rxbuf[MAX_RX_URBS]; |
259 | dma_addr_t rxbuf_dma[MAX_RX_URBS]; |
260 | }; |
261 | |
262 | static void ems_usb_read_interrupt_callback(struct urb *urb) |
263 | { |
264 | struct ems_usb *dev = urb->context; |
265 | struct net_device *netdev = dev->netdev; |
266 | int err; |
267 | |
268 | if (!netif_device_present(dev: netdev)) |
269 | return; |
270 | |
271 | switch (urb->status) { |
272 | case 0: |
273 | dev->free_slots = dev->intr_in_buffer[1]; |
274 | if (dev->free_slots > CPC_TX_QUEUE_TRIGGER_HIGH && |
275 | netif_queue_stopped(dev: netdev)) |
276 | netif_wake_queue(dev: netdev); |
277 | break; |
278 | |
279 | case -ECONNRESET: /* unlink */ |
280 | case -ENOENT: |
281 | case -EPIPE: |
282 | case -EPROTO: |
283 | case -ESHUTDOWN: |
284 | return; |
285 | |
286 | default: |
287 | netdev_info(dev: netdev, format: "Rx interrupt aborted %d\n" , urb->status); |
288 | break; |
289 | } |
290 | |
291 | err = usb_submit_urb(urb, GFP_ATOMIC); |
292 | |
293 | if (err == -ENODEV) |
294 | netif_device_detach(dev: netdev); |
295 | else if (err) |
296 | netdev_err(dev: netdev, format: "failed resubmitting intr urb: %d\n" , err); |
297 | } |
298 | |
299 | static void ems_usb_rx_can_msg(struct ems_usb *dev, struct ems_cpc_msg *msg) |
300 | { |
301 | struct can_frame *cf; |
302 | struct sk_buff *skb; |
303 | int i; |
304 | struct net_device_stats *stats = &dev->netdev->stats; |
305 | |
306 | skb = alloc_can_skb(dev: dev->netdev, cf: &cf); |
307 | if (skb == NULL) |
308 | return; |
309 | |
310 | cf->can_id = le32_to_cpu(msg->msg.can_msg.id); |
311 | cf->len = can_cc_dlc2len(msg->msg.can_msg.length & 0xF); |
312 | |
313 | if (msg->type == CPC_MSG_TYPE_EXT_CAN_FRAME || |
314 | msg->type == CPC_MSG_TYPE_EXT_RTR_FRAME) |
315 | cf->can_id |= CAN_EFF_FLAG; |
316 | |
317 | if (msg->type == CPC_MSG_TYPE_RTR_FRAME || |
318 | msg->type == CPC_MSG_TYPE_EXT_RTR_FRAME) { |
319 | cf->can_id |= CAN_RTR_FLAG; |
320 | } else { |
321 | for (i = 0; i < cf->len; i++) |
322 | cf->data[i] = msg->msg.can_msg.msg[i]; |
323 | |
324 | stats->rx_bytes += cf->len; |
325 | } |
326 | stats->rx_packets++; |
327 | |
328 | netif_rx(skb); |
329 | } |
330 | |
331 | static void ems_usb_rx_err(struct ems_usb *dev, struct ems_cpc_msg *msg) |
332 | { |
333 | struct can_frame *cf; |
334 | struct sk_buff *skb; |
335 | struct net_device_stats *stats = &dev->netdev->stats; |
336 | |
337 | skb = alloc_can_err_skb(dev: dev->netdev, cf: &cf); |
338 | if (skb == NULL) |
339 | return; |
340 | |
341 | if (msg->type == CPC_MSG_TYPE_CAN_STATE) { |
342 | u8 state = msg->msg.can_state; |
343 | |
344 | if (state & SJA1000_SR_BS) { |
345 | dev->can.state = CAN_STATE_BUS_OFF; |
346 | cf->can_id |= CAN_ERR_BUSOFF; |
347 | |
348 | dev->can.can_stats.bus_off++; |
349 | can_bus_off(dev: dev->netdev); |
350 | } else if (state & SJA1000_SR_ES) { |
351 | dev->can.state = CAN_STATE_ERROR_WARNING; |
352 | dev->can.can_stats.error_warning++; |
353 | } else { |
354 | dev->can.state = CAN_STATE_ERROR_ACTIVE; |
355 | dev->can.can_stats.error_passive++; |
356 | } |
357 | } else if (msg->type == CPC_MSG_TYPE_CAN_FRAME_ERROR) { |
358 | u8 ecc = msg->msg.error.cc.regs.sja1000.ecc; |
359 | u8 txerr = msg->msg.error.cc.regs.sja1000.txerr; |
360 | u8 rxerr = msg->msg.error.cc.regs.sja1000.rxerr; |
361 | |
362 | /* bus error interrupt */ |
363 | dev->can.can_stats.bus_error++; |
364 | stats->rx_errors++; |
365 | |
366 | cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; |
367 | |
368 | switch (ecc & SJA1000_ECC_MASK) { |
369 | case SJA1000_ECC_BIT: |
370 | cf->data[2] |= CAN_ERR_PROT_BIT; |
371 | break; |
372 | case SJA1000_ECC_FORM: |
373 | cf->data[2] |= CAN_ERR_PROT_FORM; |
374 | break; |
375 | case SJA1000_ECC_STUFF: |
376 | cf->data[2] |= CAN_ERR_PROT_STUFF; |
377 | break; |
378 | default: |
379 | cf->data[3] = ecc & SJA1000_ECC_SEG; |
380 | break; |
381 | } |
382 | |
383 | /* Error occurred during transmission? */ |
384 | if ((ecc & SJA1000_ECC_DIR) == 0) |
385 | cf->data[2] |= CAN_ERR_PROT_TX; |
386 | |
387 | if (dev->can.state == CAN_STATE_ERROR_WARNING || |
388 | dev->can.state == CAN_STATE_ERROR_PASSIVE) { |
389 | cf->can_id |= CAN_ERR_CRTL; |
390 | cf->data[1] = (txerr > rxerr) ? |
391 | CAN_ERR_CRTL_TX_PASSIVE : CAN_ERR_CRTL_RX_PASSIVE; |
392 | } |
393 | } else if (msg->type == CPC_MSG_TYPE_OVERRUN) { |
394 | cf->can_id |= CAN_ERR_CRTL; |
395 | cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
396 | |
397 | stats->rx_over_errors++; |
398 | stats->rx_errors++; |
399 | } |
400 | |
401 | netif_rx(skb); |
402 | } |
403 | |
404 | /* |
405 | * callback for bulk IN urb |
406 | */ |
407 | static void ems_usb_read_bulk_callback(struct urb *urb) |
408 | { |
409 | struct ems_usb *dev = urb->context; |
410 | struct net_device *netdev; |
411 | int retval; |
412 | |
413 | netdev = dev->netdev; |
414 | |
415 | if (!netif_device_present(dev: netdev)) |
416 | return; |
417 | |
418 | switch (urb->status) { |
419 | case 0: /* success */ |
420 | break; |
421 | |
422 | case -ENOENT: |
423 | return; |
424 | |
425 | default: |
426 | netdev_info(dev: netdev, format: "Rx URB aborted (%d)\n" , urb->status); |
427 | goto resubmit_urb; |
428 | } |
429 | |
430 | if (urb->actual_length > CPC_HEADER_SIZE) { |
431 | struct ems_cpc_msg *msg; |
432 | u8 *ibuf = urb->transfer_buffer; |
433 | u8 msg_count, start; |
434 | |
435 | msg_count = ibuf[0] & ~0x80; |
436 | |
437 | start = CPC_HEADER_SIZE; |
438 | |
439 | while (msg_count) { |
440 | msg = (struct ems_cpc_msg *)&ibuf[start]; |
441 | |
442 | switch (msg->type) { |
443 | case CPC_MSG_TYPE_CAN_STATE: |
444 | /* Process CAN state changes */ |
445 | ems_usb_rx_err(dev, msg); |
446 | break; |
447 | |
448 | case CPC_MSG_TYPE_CAN_FRAME: |
449 | case CPC_MSG_TYPE_EXT_CAN_FRAME: |
450 | case CPC_MSG_TYPE_RTR_FRAME: |
451 | case CPC_MSG_TYPE_EXT_RTR_FRAME: |
452 | ems_usb_rx_can_msg(dev, msg); |
453 | break; |
454 | |
455 | case CPC_MSG_TYPE_CAN_FRAME_ERROR: |
456 | /* Process errorframe */ |
457 | ems_usb_rx_err(dev, msg); |
458 | break; |
459 | |
460 | case CPC_MSG_TYPE_OVERRUN: |
461 | /* Message lost while receiving */ |
462 | ems_usb_rx_err(dev, msg); |
463 | break; |
464 | } |
465 | |
466 | start += CPC_MSG_HEADER_LEN + msg->length; |
467 | msg_count--; |
468 | |
469 | if (start > urb->transfer_buffer_length) { |
470 | netdev_err(dev: netdev, format: "format error\n" ); |
471 | break; |
472 | } |
473 | } |
474 | } |
475 | |
476 | resubmit_urb: |
477 | usb_fill_bulk_urb(urb, dev: dev->udev, usb_rcvbulkpipe(dev->udev, 2), |
478 | transfer_buffer: urb->transfer_buffer, RX_BUFFER_SIZE, |
479 | complete_fn: ems_usb_read_bulk_callback, context: dev); |
480 | |
481 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
482 | |
483 | if (retval == -ENODEV) |
484 | netif_device_detach(dev: netdev); |
485 | else if (retval) |
486 | netdev_err(dev: netdev, |
487 | format: "failed resubmitting read bulk urb: %d\n" , retval); |
488 | } |
489 | |
490 | /* |
491 | * callback for bulk IN urb |
492 | */ |
493 | static void ems_usb_write_bulk_callback(struct urb *urb) |
494 | { |
495 | struct ems_tx_urb_context *context = urb->context; |
496 | struct ems_usb *dev; |
497 | struct net_device *netdev; |
498 | |
499 | BUG_ON(!context); |
500 | |
501 | dev = context->dev; |
502 | netdev = dev->netdev; |
503 | |
504 | /* free up our allocated buffer */ |
505 | usb_free_coherent(dev: urb->dev, size: urb->transfer_buffer_length, |
506 | addr: urb->transfer_buffer, dma: urb->transfer_dma); |
507 | |
508 | atomic_dec(v: &dev->active_tx_urbs); |
509 | |
510 | if (!netif_device_present(dev: netdev)) |
511 | return; |
512 | |
513 | if (urb->status) |
514 | netdev_info(dev: netdev, format: "Tx URB aborted (%d)\n" , urb->status); |
515 | |
516 | netif_trans_update(dev: netdev); |
517 | |
518 | /* transmission complete interrupt */ |
519 | netdev->stats.tx_packets++; |
520 | netdev->stats.tx_bytes += can_get_echo_skb(dev: netdev, idx: context->echo_index, |
521 | NULL); |
522 | |
523 | /* Release context */ |
524 | context->echo_index = MAX_TX_URBS; |
525 | |
526 | } |
527 | |
528 | /* |
529 | * Send the given CPC command synchronously |
530 | */ |
531 | static int ems_usb_command_msg(struct ems_usb *dev, struct ems_cpc_msg *msg) |
532 | { |
533 | int actual_length; |
534 | |
535 | /* Copy payload */ |
536 | memcpy(&dev->tx_msg_buffer[CPC_HEADER_SIZE], msg, |
537 | msg->length + CPC_MSG_HEADER_LEN); |
538 | |
539 | /* Clear header */ |
540 | memset(&dev->tx_msg_buffer[0], 0, CPC_HEADER_SIZE); |
541 | |
542 | return usb_bulk_msg(usb_dev: dev->udev, usb_sndbulkpipe(dev->udev, 2), |
543 | data: &dev->tx_msg_buffer[0], |
544 | len: msg->length + CPC_MSG_HEADER_LEN + CPC_HEADER_SIZE, |
545 | actual_length: &actual_length, timeout: 1000); |
546 | } |
547 | |
548 | /* |
549 | * Change CAN controllers' mode register |
550 | */ |
551 | static int ems_usb_write_mode(struct ems_usb *dev, u8 mode) |
552 | { |
553 | dev->active_params.msg.can_params.cc_params.sja1000.mode = mode; |
554 | |
555 | return ems_usb_command_msg(dev, msg: &dev->active_params); |
556 | } |
557 | |
558 | /* |
559 | * Send a CPC_Control command to change behaviour when interface receives a CAN |
560 | * message, bus error or CAN state changed notifications. |
561 | */ |
562 | static int ems_usb_control_cmd(struct ems_usb *dev, u8 val) |
563 | { |
564 | struct ems_cpc_msg cmd; |
565 | |
566 | cmd.type = CPC_CMD_TYPE_CONTROL; |
567 | cmd.length = CPC_MSG_HEADER_LEN + 1; |
568 | |
569 | cmd.msgid = 0; |
570 | |
571 | cmd.msg.generic[0] = val; |
572 | |
573 | return ems_usb_command_msg(dev, msg: &cmd); |
574 | } |
575 | |
576 | /* |
577 | * Start interface |
578 | */ |
579 | static int ems_usb_start(struct ems_usb *dev) |
580 | { |
581 | struct net_device *netdev = dev->netdev; |
582 | int err, i; |
583 | |
584 | dev->intr_in_buffer[0] = 0; |
585 | dev->free_slots = 50; /* initial size */ |
586 | |
587 | for (i = 0; i < MAX_RX_URBS; i++) { |
588 | struct urb *urb = NULL; |
589 | u8 *buf = NULL; |
590 | dma_addr_t buf_dma; |
591 | |
592 | /* create a URB, and a buffer for it */ |
593 | urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
594 | if (!urb) { |
595 | err = -ENOMEM; |
596 | break; |
597 | } |
598 | |
599 | buf = usb_alloc_coherent(dev: dev->udev, RX_BUFFER_SIZE, GFP_KERNEL, |
600 | dma: &buf_dma); |
601 | if (!buf) { |
602 | netdev_err(dev: netdev, format: "No memory left for USB buffer\n" ); |
603 | usb_free_urb(urb); |
604 | err = -ENOMEM; |
605 | break; |
606 | } |
607 | |
608 | urb->transfer_dma = buf_dma; |
609 | |
610 | usb_fill_bulk_urb(urb, dev: dev->udev, usb_rcvbulkpipe(dev->udev, 2), |
611 | transfer_buffer: buf, RX_BUFFER_SIZE, |
612 | complete_fn: ems_usb_read_bulk_callback, context: dev); |
613 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
614 | usb_anchor_urb(urb, anchor: &dev->rx_submitted); |
615 | |
616 | err = usb_submit_urb(urb, GFP_KERNEL); |
617 | if (err) { |
618 | usb_unanchor_urb(urb); |
619 | usb_free_coherent(dev: dev->udev, RX_BUFFER_SIZE, addr: buf, |
620 | dma: urb->transfer_dma); |
621 | usb_free_urb(urb); |
622 | break; |
623 | } |
624 | |
625 | dev->rxbuf[i] = buf; |
626 | dev->rxbuf_dma[i] = buf_dma; |
627 | |
628 | /* Drop reference, USB core will take care of freeing it */ |
629 | usb_free_urb(urb); |
630 | } |
631 | |
632 | /* Did we submit any URBs */ |
633 | if (i == 0) { |
634 | netdev_warn(dev: netdev, format: "couldn't setup read URBs\n" ); |
635 | return err; |
636 | } |
637 | |
638 | /* Warn if we've couldn't transmit all the URBs */ |
639 | if (i < MAX_RX_URBS) |
640 | netdev_warn(dev: netdev, format: "rx performance may be slow\n" ); |
641 | |
642 | /* Setup and start interrupt URB */ |
643 | usb_fill_int_urb(urb: dev->intr_urb, dev: dev->udev, |
644 | usb_rcvintpipe(dev->udev, 1), |
645 | transfer_buffer: dev->intr_in_buffer, |
646 | INTR_IN_BUFFER_SIZE, |
647 | complete_fn: ems_usb_read_interrupt_callback, context: dev, interval: 1); |
648 | |
649 | err = usb_submit_urb(urb: dev->intr_urb, GFP_KERNEL); |
650 | if (err) { |
651 | netdev_warn(dev: netdev, format: "intr URB submit failed: %d\n" , err); |
652 | |
653 | return err; |
654 | } |
655 | |
656 | /* CPC-USB will transfer received message to host */ |
657 | err = ems_usb_control_cmd(dev, CONTR_CAN_MESSAGE | CONTR_CONT_ON); |
658 | if (err) |
659 | goto failed; |
660 | |
661 | /* CPC-USB will transfer CAN state changes to host */ |
662 | err = ems_usb_control_cmd(dev, CONTR_CAN_STATE | CONTR_CONT_ON); |
663 | if (err) |
664 | goto failed; |
665 | |
666 | /* CPC-USB will transfer bus errors to host */ |
667 | err = ems_usb_control_cmd(dev, CONTR_BUS_ERROR | CONTR_CONT_ON); |
668 | if (err) |
669 | goto failed; |
670 | |
671 | err = ems_usb_write_mode(dev, SJA1000_MOD_NORMAL); |
672 | if (err) |
673 | goto failed; |
674 | |
675 | dev->can.state = CAN_STATE_ERROR_ACTIVE; |
676 | |
677 | return 0; |
678 | |
679 | failed: |
680 | netdev_warn(dev: netdev, format: "couldn't submit control: %d\n" , err); |
681 | |
682 | return err; |
683 | } |
684 | |
685 | static void unlink_all_urbs(struct ems_usb *dev) |
686 | { |
687 | int i; |
688 | |
689 | usb_unlink_urb(urb: dev->intr_urb); |
690 | |
691 | usb_kill_anchored_urbs(anchor: &dev->rx_submitted); |
692 | |
693 | for (i = 0; i < MAX_RX_URBS; ++i) |
694 | usb_free_coherent(dev: dev->udev, RX_BUFFER_SIZE, |
695 | addr: dev->rxbuf[i], dma: dev->rxbuf_dma[i]); |
696 | |
697 | usb_kill_anchored_urbs(anchor: &dev->tx_submitted); |
698 | atomic_set(v: &dev->active_tx_urbs, i: 0); |
699 | |
700 | for (i = 0; i < MAX_TX_URBS; i++) |
701 | dev->tx_contexts[i].echo_index = MAX_TX_URBS; |
702 | } |
703 | |
704 | static int ems_usb_open(struct net_device *netdev) |
705 | { |
706 | struct ems_usb *dev = netdev_priv(dev: netdev); |
707 | int err; |
708 | |
709 | err = ems_usb_write_mode(dev, SJA1000_MOD_RM); |
710 | if (err) |
711 | return err; |
712 | |
713 | /* common open */ |
714 | err = open_candev(dev: netdev); |
715 | if (err) |
716 | return err; |
717 | |
718 | /* finally start device */ |
719 | err = ems_usb_start(dev); |
720 | if (err) { |
721 | if (err == -ENODEV) |
722 | netif_device_detach(dev: dev->netdev); |
723 | |
724 | netdev_warn(dev: netdev, format: "couldn't start device: %d\n" , err); |
725 | |
726 | close_candev(dev: netdev); |
727 | |
728 | return err; |
729 | } |
730 | |
731 | |
732 | netif_start_queue(dev: netdev); |
733 | |
734 | return 0; |
735 | } |
736 | |
737 | static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *netdev) |
738 | { |
739 | struct ems_usb *dev = netdev_priv(dev: netdev); |
740 | struct ems_tx_urb_context *context = NULL; |
741 | struct net_device_stats *stats = &netdev->stats; |
742 | struct can_frame *cf = (struct can_frame *)skb->data; |
743 | struct ems_cpc_msg *msg; |
744 | struct urb *urb; |
745 | u8 *buf; |
746 | int i, err; |
747 | size_t size = CPC_HEADER_SIZE + CPC_MSG_HEADER_LEN |
748 | + sizeof(struct cpc_can_msg); |
749 | |
750 | if (can_dev_dropped_skb(dev: netdev, skb)) |
751 | return NETDEV_TX_OK; |
752 | |
753 | /* create a URB, and a buffer for it, and copy the data to the URB */ |
754 | urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC); |
755 | if (!urb) |
756 | goto nomem; |
757 | |
758 | buf = usb_alloc_coherent(dev: dev->udev, size, GFP_ATOMIC, dma: &urb->transfer_dma); |
759 | if (!buf) { |
760 | netdev_err(dev: netdev, format: "No memory left for USB buffer\n" ); |
761 | usb_free_urb(urb); |
762 | goto nomem; |
763 | } |
764 | |
765 | msg = (struct ems_cpc_msg *)&buf[CPC_HEADER_SIZE]; |
766 | |
767 | msg->msg.can_msg.id = cpu_to_le32(cf->can_id & CAN_ERR_MASK); |
768 | msg->msg.can_msg.length = cf->len; |
769 | |
770 | if (cf->can_id & CAN_RTR_FLAG) { |
771 | msg->type = cf->can_id & CAN_EFF_FLAG ? |
772 | CPC_CMD_TYPE_EXT_RTR_FRAME : CPC_CMD_TYPE_RTR_FRAME; |
773 | |
774 | msg->length = CPC_CAN_MSG_MIN_SIZE; |
775 | } else { |
776 | msg->type = cf->can_id & CAN_EFF_FLAG ? |
777 | CPC_CMD_TYPE_EXT_CAN_FRAME : CPC_CMD_TYPE_CAN_FRAME; |
778 | |
779 | for (i = 0; i < cf->len; i++) |
780 | msg->msg.can_msg.msg[i] = cf->data[i]; |
781 | |
782 | msg->length = CPC_CAN_MSG_MIN_SIZE + cf->len; |
783 | } |
784 | |
785 | for (i = 0; i < MAX_TX_URBS; i++) { |
786 | if (dev->tx_contexts[i].echo_index == MAX_TX_URBS) { |
787 | context = &dev->tx_contexts[i]; |
788 | break; |
789 | } |
790 | } |
791 | |
792 | /* |
793 | * May never happen! When this happens we'd more URBs in flight as |
794 | * allowed (MAX_TX_URBS). |
795 | */ |
796 | if (!context) { |
797 | usb_free_coherent(dev: dev->udev, size, addr: buf, dma: urb->transfer_dma); |
798 | usb_free_urb(urb); |
799 | |
800 | netdev_warn(dev: netdev, format: "couldn't find free context\n" ); |
801 | |
802 | return NETDEV_TX_BUSY; |
803 | } |
804 | |
805 | context->dev = dev; |
806 | context->echo_index = i; |
807 | |
808 | usb_fill_bulk_urb(urb, dev: dev->udev, usb_sndbulkpipe(dev->udev, 2), transfer_buffer: buf, |
809 | buffer_length: size, complete_fn: ems_usb_write_bulk_callback, context); |
810 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
811 | usb_anchor_urb(urb, anchor: &dev->tx_submitted); |
812 | |
813 | can_put_echo_skb(skb, dev: netdev, idx: context->echo_index, frame_len: 0); |
814 | |
815 | atomic_inc(v: &dev->active_tx_urbs); |
816 | |
817 | err = usb_submit_urb(urb, GFP_ATOMIC); |
818 | if (unlikely(err)) { |
819 | can_free_echo_skb(dev: netdev, idx: context->echo_index, NULL); |
820 | |
821 | usb_unanchor_urb(urb); |
822 | usb_free_coherent(dev: dev->udev, size, addr: buf, dma: urb->transfer_dma); |
823 | |
824 | atomic_dec(v: &dev->active_tx_urbs); |
825 | |
826 | if (err == -ENODEV) { |
827 | netif_device_detach(dev: netdev); |
828 | } else { |
829 | netdev_warn(dev: netdev, format: "failed tx_urb %d\n" , err); |
830 | |
831 | stats->tx_dropped++; |
832 | } |
833 | } else { |
834 | netif_trans_update(dev: netdev); |
835 | |
836 | /* Slow down tx path */ |
837 | if (atomic_read(v: &dev->active_tx_urbs) >= MAX_TX_URBS || |
838 | dev->free_slots < CPC_TX_QUEUE_TRIGGER_LOW) { |
839 | netif_stop_queue(dev: netdev); |
840 | } |
841 | } |
842 | |
843 | /* |
844 | * Release our reference to this URB, the USB core will eventually free |
845 | * it entirely. |
846 | */ |
847 | usb_free_urb(urb); |
848 | |
849 | return NETDEV_TX_OK; |
850 | |
851 | nomem: |
852 | dev_kfree_skb(skb); |
853 | stats->tx_dropped++; |
854 | |
855 | return NETDEV_TX_OK; |
856 | } |
857 | |
858 | static int ems_usb_close(struct net_device *netdev) |
859 | { |
860 | struct ems_usb *dev = netdev_priv(dev: netdev); |
861 | |
862 | /* Stop polling */ |
863 | unlink_all_urbs(dev); |
864 | |
865 | netif_stop_queue(dev: netdev); |
866 | |
867 | /* Set CAN controller to reset mode */ |
868 | if (ems_usb_write_mode(dev, SJA1000_MOD_RM)) |
869 | netdev_warn(dev: netdev, format: "couldn't stop device" ); |
870 | |
871 | close_candev(dev: netdev); |
872 | |
873 | return 0; |
874 | } |
875 | |
876 | static const struct net_device_ops ems_usb_netdev_ops = { |
877 | .ndo_open = ems_usb_open, |
878 | .ndo_stop = ems_usb_close, |
879 | .ndo_start_xmit = ems_usb_start_xmit, |
880 | .ndo_change_mtu = can_change_mtu, |
881 | }; |
882 | |
883 | static const struct ethtool_ops ems_usb_ethtool_ops = { |
884 | .get_ts_info = ethtool_op_get_ts_info, |
885 | }; |
886 | |
887 | static const struct can_bittiming_const ems_usb_bittiming_const = { |
888 | .name = KBUILD_MODNAME, |
889 | .tseg1_min = 1, |
890 | .tseg1_max = 16, |
891 | .tseg2_min = 1, |
892 | .tseg2_max = 8, |
893 | .sjw_max = 4, |
894 | .brp_min = 1, |
895 | .brp_max = 64, |
896 | .brp_inc = 1, |
897 | }; |
898 | |
899 | static int ems_usb_set_mode(struct net_device *netdev, enum can_mode mode) |
900 | { |
901 | struct ems_usb *dev = netdev_priv(dev: netdev); |
902 | |
903 | switch (mode) { |
904 | case CAN_MODE_START: |
905 | if (ems_usb_write_mode(dev, SJA1000_MOD_NORMAL)) |
906 | netdev_warn(dev: netdev, format: "couldn't start device" ); |
907 | |
908 | if (netif_queue_stopped(dev: netdev)) |
909 | netif_wake_queue(dev: netdev); |
910 | break; |
911 | |
912 | default: |
913 | return -EOPNOTSUPP; |
914 | } |
915 | |
916 | return 0; |
917 | } |
918 | |
919 | static int ems_usb_set_bittiming(struct net_device *netdev) |
920 | { |
921 | struct ems_usb *dev = netdev_priv(dev: netdev); |
922 | struct can_bittiming *bt = &dev->can.bittiming; |
923 | u8 btr0, btr1; |
924 | |
925 | btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6); |
926 | btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) | |
927 | (((bt->phase_seg2 - 1) & 0x7) << 4); |
928 | if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) |
929 | btr1 |= 0x80; |
930 | |
931 | netdev_info(dev: netdev, format: "setting BTR0=0x%02x BTR1=0x%02x\n" , btr0, btr1); |
932 | |
933 | dev->active_params.msg.can_params.cc_params.sja1000.btr0 = btr0; |
934 | dev->active_params.msg.can_params.cc_params.sja1000.btr1 = btr1; |
935 | |
936 | return ems_usb_command_msg(dev, msg: &dev->active_params); |
937 | } |
938 | |
939 | static void init_params_sja1000(struct ems_cpc_msg *msg) |
940 | { |
941 | struct cpc_sja1000_params *sja1000 = |
942 | &msg->msg.can_params.cc_params.sja1000; |
943 | |
944 | msg->type = CPC_CMD_TYPE_CAN_PARAMS; |
945 | msg->length = sizeof(struct cpc_can_params); |
946 | msg->msgid = 0; |
947 | |
948 | msg->msg.can_params.cc_type = CPC_CC_TYPE_SJA1000; |
949 | |
950 | /* Acceptance filter open */ |
951 | sja1000->acc_code0 = 0x00; |
952 | sja1000->acc_code1 = 0x00; |
953 | sja1000->acc_code2 = 0x00; |
954 | sja1000->acc_code3 = 0x00; |
955 | |
956 | /* Acceptance filter open */ |
957 | sja1000->acc_mask0 = 0xFF; |
958 | sja1000->acc_mask1 = 0xFF; |
959 | sja1000->acc_mask2 = 0xFF; |
960 | sja1000->acc_mask3 = 0xFF; |
961 | |
962 | sja1000->btr0 = 0; |
963 | sja1000->btr1 = 0; |
964 | |
965 | sja1000->outp_contr = SJA1000_DEFAULT_OUTPUT_CONTROL; |
966 | sja1000->mode = SJA1000_MOD_RM; |
967 | } |
968 | |
969 | /* |
970 | * probe function for new CPC-USB devices |
971 | */ |
972 | static int ems_usb_probe(struct usb_interface *intf, |
973 | const struct usb_device_id *id) |
974 | { |
975 | struct net_device *netdev; |
976 | struct ems_usb *dev; |
977 | int i, err = -ENOMEM; |
978 | |
979 | netdev = alloc_candev(sizeof(struct ems_usb), MAX_TX_URBS); |
980 | if (!netdev) { |
981 | dev_err(&intf->dev, "ems_usb: Couldn't alloc candev\n" ); |
982 | return -ENOMEM; |
983 | } |
984 | |
985 | dev = netdev_priv(dev: netdev); |
986 | |
987 | dev->udev = interface_to_usbdev(intf); |
988 | dev->netdev = netdev; |
989 | |
990 | dev->can.state = CAN_STATE_STOPPED; |
991 | dev->can.clock.freq = EMS_USB_ARM7_CLOCK; |
992 | dev->can.bittiming_const = &ems_usb_bittiming_const; |
993 | dev->can.do_set_bittiming = ems_usb_set_bittiming; |
994 | dev->can.do_set_mode = ems_usb_set_mode; |
995 | dev->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES; |
996 | |
997 | netdev->netdev_ops = &ems_usb_netdev_ops; |
998 | netdev->ethtool_ops = &ems_usb_ethtool_ops; |
999 | |
1000 | netdev->flags |= IFF_ECHO; /* we support local echo */ |
1001 | |
1002 | init_usb_anchor(anchor: &dev->rx_submitted); |
1003 | |
1004 | init_usb_anchor(anchor: &dev->tx_submitted); |
1005 | atomic_set(v: &dev->active_tx_urbs, i: 0); |
1006 | |
1007 | for (i = 0; i < MAX_TX_URBS; i++) |
1008 | dev->tx_contexts[i].echo_index = MAX_TX_URBS; |
1009 | |
1010 | dev->intr_urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
1011 | if (!dev->intr_urb) |
1012 | goto cleanup_candev; |
1013 | |
1014 | dev->intr_in_buffer = kzalloc(INTR_IN_BUFFER_SIZE, GFP_KERNEL); |
1015 | if (!dev->intr_in_buffer) |
1016 | goto cleanup_intr_urb; |
1017 | |
1018 | dev->tx_msg_buffer = kzalloc(CPC_HEADER_SIZE + |
1019 | sizeof(struct ems_cpc_msg), GFP_KERNEL); |
1020 | if (!dev->tx_msg_buffer) |
1021 | goto cleanup_intr_in_buffer; |
1022 | |
1023 | usb_set_intfdata(intf, data: dev); |
1024 | |
1025 | SET_NETDEV_DEV(netdev, &intf->dev); |
1026 | |
1027 | init_params_sja1000(msg: &dev->active_params); |
1028 | |
1029 | err = ems_usb_command_msg(dev, msg: &dev->active_params); |
1030 | if (err) { |
1031 | netdev_err(dev: netdev, format: "couldn't initialize controller: %d\n" , err); |
1032 | goto cleanup_tx_msg_buffer; |
1033 | } |
1034 | |
1035 | err = register_candev(dev: netdev); |
1036 | if (err) { |
1037 | netdev_err(dev: netdev, format: "couldn't register CAN device: %d\n" , err); |
1038 | goto cleanup_tx_msg_buffer; |
1039 | } |
1040 | |
1041 | return 0; |
1042 | |
1043 | cleanup_tx_msg_buffer: |
1044 | kfree(objp: dev->tx_msg_buffer); |
1045 | |
1046 | cleanup_intr_in_buffer: |
1047 | kfree(objp: dev->intr_in_buffer); |
1048 | |
1049 | cleanup_intr_urb: |
1050 | usb_free_urb(urb: dev->intr_urb); |
1051 | |
1052 | cleanup_candev: |
1053 | free_candev(dev: netdev); |
1054 | |
1055 | return err; |
1056 | } |
1057 | |
1058 | /* |
1059 | * called by the usb core when the device is removed from the system |
1060 | */ |
1061 | static void ems_usb_disconnect(struct usb_interface *intf) |
1062 | { |
1063 | struct ems_usb *dev = usb_get_intfdata(intf); |
1064 | |
1065 | usb_set_intfdata(intf, NULL); |
1066 | |
1067 | if (dev) { |
1068 | unregister_netdev(dev: dev->netdev); |
1069 | |
1070 | unlink_all_urbs(dev); |
1071 | |
1072 | usb_free_urb(urb: dev->intr_urb); |
1073 | |
1074 | kfree(objp: dev->intr_in_buffer); |
1075 | kfree(objp: dev->tx_msg_buffer); |
1076 | |
1077 | free_candev(dev: dev->netdev); |
1078 | } |
1079 | } |
1080 | |
1081 | /* usb specific object needed to register this driver with the usb subsystem */ |
1082 | static struct usb_driver ems_usb_driver = { |
1083 | .name = KBUILD_MODNAME, |
1084 | .probe = ems_usb_probe, |
1085 | .disconnect = ems_usb_disconnect, |
1086 | .id_table = ems_usb_table, |
1087 | }; |
1088 | |
1089 | module_usb_driver(ems_usb_driver); |
1090 | |