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