1 /*
2 * CAN driver for PEAK System USB adapters
3 * Derived from the PCAN project file driver/src/pcan_usb_core.c
4 *
5 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
6 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
7 *
8 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
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
30 #include "pcan_usb_core.h"
31
32 MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
33 MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");
34 MODULE_LICENSE("GPL v2");
35
36 /* Table of devices that work with this driver */
37 static struct usb_device_id peak_usb_table[] = {
38 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USB_PRODUCT_ID)},
39 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPRO_PRODUCT_ID)},
40 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBFD_PRODUCT_ID)},
41 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPROFD_PRODUCT_ID)},
42 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBCHIP_PRODUCT_ID)},
43 {USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBX6_PRODUCT_ID)},
44 {} /* Terminating entry */
45 };
46
47 MODULE_DEVICE_TABLE(usb, peak_usb_table);
48
49 /* List of supported PCAN-USB adapters (NULL terminated list) */
50 static const struct peak_usb_adapter *const peak_usb_adapters_list[] = {
51 &pcan_usb,
52 &pcan_usb_pro,
53 &pcan_usb_fd,
54 &pcan_usb_pro_fd,
55 &pcan_usb_chip,
56 &pcan_usb_x6,
57 };
58
59 /*
60 * dump memory
61 */
62 #define DUMP_WIDTH 16
pcan_dump_mem(char * prompt,void * p,int l)63 void pcan_dump_mem(char *prompt, void *p, int l)
64 {
65 pr_info("%s dumping %s (%d bytes):\n",
66 PCAN_USB_DRIVER_NAME, prompt ? prompt : "memory", l);
67 print_hex_dump(KERN_INFO, PCAN_USB_DRIVER_NAME " ", DUMP_PREFIX_NONE,
68 DUMP_WIDTH, 1, p, l, false);
69 }
70
71 /*
72 * initialize a time_ref object with usb adapter own settings
73 */
peak_usb_init_time_ref(struct peak_time_ref * time_ref,const struct peak_usb_adapter * adapter)74 void peak_usb_init_time_ref(struct peak_time_ref *time_ref,
75 const struct peak_usb_adapter *adapter)
76 {
77 if (time_ref) {
78 memset(time_ref, 0, sizeof(struct peak_time_ref));
79 time_ref->adapter = adapter;
80 }
81 }
82
83 /*
84 * sometimes, another now may be more recent than current one...
85 */
peak_usb_update_ts_now(struct peak_time_ref * time_ref,u32 ts_now)86 void peak_usb_update_ts_now(struct peak_time_ref *time_ref, u32 ts_now)
87 {
88 time_ref->ts_dev_2 = ts_now;
89
90 /* should wait at least two passes before computing */
91 if (ktime_to_ns(time_ref->tv_host) > 0) {
92 u32 delta_ts = time_ref->ts_dev_2 - time_ref->ts_dev_1;
93
94 if (time_ref->ts_dev_2 < time_ref->ts_dev_1)
95 delta_ts &= (1 << time_ref->adapter->ts_used_bits) - 1;
96
97 time_ref->ts_total += delta_ts;
98 }
99 }
100
101 /*
102 * register device timestamp as now
103 */
peak_usb_set_ts_now(struct peak_time_ref * time_ref,u32 ts_now)104 void peak_usb_set_ts_now(struct peak_time_ref *time_ref, u32 ts_now)
105 {
106 if (ktime_to_ns(time_ref->tv_host_0) == 0) {
107 /* use monotonic clock to correctly compute further deltas */
108 time_ref->tv_host_0 = ktime_get();
109 time_ref->tv_host = ktime_set(0, 0);
110 } else {
111 /*
112 * delta_us should not be >= 2^32 => delta should be < 4294s
113 * handle 32-bits wrapping here: if count of s. reaches 4200,
114 * reset counters and change time base
115 */
116 if (ktime_to_ns(time_ref->tv_host)) {
117 ktime_t delta = ktime_sub(time_ref->tv_host,
118 time_ref->tv_host_0);
119 if (ktime_to_ns(delta) > (4200ull * NSEC_PER_SEC)) {
120 time_ref->tv_host_0 = time_ref->tv_host;
121 time_ref->ts_total = 0;
122 }
123 }
124
125 time_ref->tv_host = ktime_get();
126 time_ref->tick_count++;
127 }
128
129 time_ref->ts_dev_1 = time_ref->ts_dev_2;
130 peak_usb_update_ts_now(time_ref, ts_now);
131 }
132
133 /*
134 * compute time according to current ts and time_ref data
135 */
peak_usb_get_ts_time(struct peak_time_ref * time_ref,u32 ts,ktime_t * time)136 void peak_usb_get_ts_time(struct peak_time_ref *time_ref, u32 ts, ktime_t *time)
137 {
138 /* protect from getting time before setting now */
139 if (ktime_to_ns(time_ref->tv_host)) {
140 u64 delta_us;
141
142 delta_us = ts - time_ref->ts_dev_2;
143 if (ts < time_ref->ts_dev_2)
144 delta_us &= (1 << time_ref->adapter->ts_used_bits) - 1;
145
146 delta_us += time_ref->ts_total;
147
148 delta_us *= time_ref->adapter->us_per_ts_scale;
149 delta_us >>= time_ref->adapter->us_per_ts_shift;
150
151 *time = ktime_add_us(time_ref->tv_host_0, delta_us);
152 } else {
153 *time = ktime_get();
154 }
155 }
156
157 /*
158 * post received skb after having set any hw timestamp
159 */
peak_usb_netif_rx(struct sk_buff * skb,struct peak_time_ref * time_ref,u32 ts_low)160 int peak_usb_netif_rx(struct sk_buff *skb,
161 struct peak_time_ref *time_ref, u32 ts_low)
162 {
163 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
164
165 peak_usb_get_ts_time(time_ref, ts_low, &hwts->hwtstamp);
166
167 return netif_rx(skb);
168 }
169
170 /*
171 * callback for bulk Rx urb
172 */
peak_usb_read_bulk_callback(struct urb * urb)173 static void peak_usb_read_bulk_callback(struct urb *urb)
174 {
175 struct peak_usb_device *dev = urb->context;
176 struct net_device *netdev;
177 int err;
178
179 netdev = dev->netdev;
180
181 if (!netif_device_present(netdev))
182 return;
183
184 /* check reception status */
185 switch (urb->status) {
186 case 0:
187 /* success */
188 break;
189
190 case -EILSEQ:
191 case -ENOENT:
192 case -ECONNRESET:
193 case -ESHUTDOWN:
194 return;
195
196 default:
197 if (net_ratelimit())
198 netdev_err(netdev,
199 "Rx urb aborted (%d)\n", urb->status);
200 goto resubmit_urb;
201 }
202
203 /* protect from any incoming empty msgs */
204 if ((urb->actual_length > 0) && (dev->adapter->dev_decode_buf)) {
205 /* handle these kinds of msgs only if _start callback called */
206 if (dev->state & PCAN_USB_STATE_STARTED) {
207 err = dev->adapter->dev_decode_buf(dev, urb);
208 if (err)
209 pcan_dump_mem("received usb message",
210 urb->transfer_buffer,
211 urb->transfer_buffer_length);
212 }
213 }
214
215 resubmit_urb:
216 usb_fill_bulk_urb(urb, dev->udev,
217 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in),
218 urb->transfer_buffer, dev->adapter->rx_buffer_size,
219 peak_usb_read_bulk_callback, dev);
220
221 usb_anchor_urb(urb, &dev->rx_submitted);
222 err = usb_submit_urb(urb, GFP_ATOMIC);
223 if (!err)
224 return;
225
226 usb_unanchor_urb(urb);
227
228 if (err == -ENODEV)
229 netif_device_detach(netdev);
230 else
231 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n",
232 err);
233 }
234
235 /*
236 * callback for bulk Tx urb
237 */
peak_usb_write_bulk_callback(struct urb * urb)238 static void peak_usb_write_bulk_callback(struct urb *urb)
239 {
240 struct peak_tx_urb_context *context = urb->context;
241 struct peak_usb_device *dev;
242 struct net_device *netdev;
243
244 BUG_ON(!context);
245
246 dev = context->dev;
247 netdev = dev->netdev;
248
249 atomic_dec(&dev->active_tx_urbs);
250
251 if (!netif_device_present(netdev))
252 return;
253
254 /* check tx status */
255 switch (urb->status) {
256 case 0:
257 /* transmission complete */
258 netdev->stats.tx_packets++;
259 netdev->stats.tx_bytes += context->data_len;
260
261 /* prevent tx timeout */
262 netif_trans_update(netdev);
263 break;
264
265 default:
266 if (net_ratelimit())
267 netdev_err(netdev, "Tx urb aborted (%d)\n",
268 urb->status);
269 case -EPROTO:
270 case -ENOENT:
271 case -ECONNRESET:
272 case -ESHUTDOWN:
273
274 break;
275 }
276
277 /* should always release echo skb and corresponding context */
278 can_get_echo_skb(netdev, context->echo_index);
279 context->echo_index = PCAN_USB_MAX_TX_URBS;
280
281 /* do wakeup tx queue in case of success only */
282 if (!urb->status)
283 netif_wake_queue(netdev);
284 }
285
286 /*
287 * called by netdev to send one skb on the CAN interface.
288 */
peak_usb_ndo_start_xmit(struct sk_buff * skb,struct net_device * netdev)289 static netdev_tx_t peak_usb_ndo_start_xmit(struct sk_buff *skb,
290 struct net_device *netdev)
291 {
292 struct peak_usb_device *dev = netdev_priv(netdev);
293 struct peak_tx_urb_context *context = NULL;
294 struct net_device_stats *stats = &netdev->stats;
295 struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
296 struct urb *urb;
297 u8 *obuf;
298 int i, err;
299 size_t size = dev->adapter->tx_buffer_size;
300
301 if (can_dropped_invalid_skb(netdev, skb))
302 return NETDEV_TX_OK;
303
304 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++)
305 if (dev->tx_contexts[i].echo_index == PCAN_USB_MAX_TX_URBS) {
306 context = dev->tx_contexts + i;
307 break;
308 }
309
310 if (!context) {
311 /* should not occur except during restart */
312 return NETDEV_TX_BUSY;
313 }
314
315 urb = context->urb;
316 obuf = urb->transfer_buffer;
317
318 err = dev->adapter->dev_encode_msg(dev, skb, obuf, &size);
319 if (err) {
320 if (net_ratelimit())
321 netdev_err(netdev, "packet dropped\n");
322 dev_kfree_skb(skb);
323 stats->tx_dropped++;
324 return NETDEV_TX_OK;
325 }
326
327 context->echo_index = i;
328
329 /* Note: this works with CANFD frames too */
330 context->data_len = cfd->len;
331
332 usb_anchor_urb(urb, &dev->tx_submitted);
333
334 can_put_echo_skb(skb, netdev, context->echo_index);
335
336 atomic_inc(&dev->active_tx_urbs);
337
338 err = usb_submit_urb(urb, GFP_ATOMIC);
339 if (err) {
340 can_free_echo_skb(netdev, context->echo_index);
341
342 usb_unanchor_urb(urb);
343
344 /* this context is not used in fact */
345 context->echo_index = PCAN_USB_MAX_TX_URBS;
346
347 atomic_dec(&dev->active_tx_urbs);
348
349 switch (err) {
350 case -ENODEV:
351 netif_device_detach(netdev);
352 break;
353 default:
354 netdev_warn(netdev, "tx urb submitting failed err=%d\n",
355 err);
356 /* fall through */
357 case -ENOENT:
358 /* cable unplugged */
359 stats->tx_dropped++;
360 }
361 } else {
362 netif_trans_update(netdev);
363
364 /* slow down tx path */
365 if (atomic_read(&dev->active_tx_urbs) >= PCAN_USB_MAX_TX_URBS)
366 netif_stop_queue(netdev);
367 }
368
369 return NETDEV_TX_OK;
370 }
371
372 /*
373 * start the CAN interface.
374 * Rx and Tx urbs are allocated here. Rx urbs are submitted here.
375 */
peak_usb_start(struct peak_usb_device * dev)376 static int peak_usb_start(struct peak_usb_device *dev)
377 {
378 struct net_device *netdev = dev->netdev;
379 int err, i;
380
381 for (i = 0; i < PCAN_USB_MAX_RX_URBS; i++) {
382 struct urb *urb;
383 u8 *buf;
384
385 /* create a URB, and a buffer for it, to receive usb messages */
386 urb = usb_alloc_urb(0, GFP_KERNEL);
387 if (!urb) {
388 err = -ENOMEM;
389 break;
390 }
391
392 buf = kmalloc(dev->adapter->rx_buffer_size, GFP_KERNEL);
393 if (!buf) {
394 usb_free_urb(urb);
395 err = -ENOMEM;
396 break;
397 }
398
399 usb_fill_bulk_urb(urb, dev->udev,
400 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in),
401 buf, dev->adapter->rx_buffer_size,
402 peak_usb_read_bulk_callback, dev);
403
404 /* ask last usb_free_urb() to also kfree() transfer_buffer */
405 urb->transfer_flags |= URB_FREE_BUFFER;
406 usb_anchor_urb(urb, &dev->rx_submitted);
407
408 err = usb_submit_urb(urb, GFP_KERNEL);
409 if (err) {
410 if (err == -ENODEV)
411 netif_device_detach(dev->netdev);
412
413 usb_unanchor_urb(urb);
414 kfree(buf);
415 usb_free_urb(urb);
416 break;
417 }
418
419 /* drop reference, USB core will take care of freeing it */
420 usb_free_urb(urb);
421 }
422
423 /* did we submit any URBs? Warn if we was not able to submit all urbs */
424 if (i < PCAN_USB_MAX_RX_URBS) {
425 if (i == 0) {
426 netdev_err(netdev, "couldn't setup any rx URB\n");
427 return err;
428 }
429
430 netdev_warn(netdev, "rx performance may be slow\n");
431 }
432
433 /* pre-alloc tx buffers and corresponding urbs */
434 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
435 struct peak_tx_urb_context *context;
436 struct urb *urb;
437 u8 *buf;
438
439 /* create a URB and a buffer for it, to transmit usb messages */
440 urb = usb_alloc_urb(0, GFP_KERNEL);
441 if (!urb) {
442 err = -ENOMEM;
443 break;
444 }
445
446 buf = kmalloc(dev->adapter->tx_buffer_size, GFP_KERNEL);
447 if (!buf) {
448 usb_free_urb(urb);
449 err = -ENOMEM;
450 break;
451 }
452
453 context = dev->tx_contexts + i;
454 context->dev = dev;
455 context->urb = urb;
456
457 usb_fill_bulk_urb(urb, dev->udev,
458 usb_sndbulkpipe(dev->udev, dev->ep_msg_out),
459 buf, dev->adapter->tx_buffer_size,
460 peak_usb_write_bulk_callback, context);
461
462 /* ask last usb_free_urb() to also kfree() transfer_buffer */
463 urb->transfer_flags |= URB_FREE_BUFFER;
464 }
465
466 /* warn if we were not able to allocate enough tx contexts */
467 if (i < PCAN_USB_MAX_TX_URBS) {
468 if (i == 0) {
469 netdev_err(netdev, "couldn't setup any tx URB\n");
470 goto err_tx;
471 }
472
473 netdev_warn(netdev, "tx performance may be slow\n");
474 }
475
476 if (dev->adapter->dev_start) {
477 err = dev->adapter->dev_start(dev);
478 if (err)
479 goto err_adapter;
480 }
481
482 dev->state |= PCAN_USB_STATE_STARTED;
483
484 /* can set bus on now */
485 if (dev->adapter->dev_set_bus) {
486 err = dev->adapter->dev_set_bus(dev, 1);
487 if (err)
488 goto err_adapter;
489 }
490
491 dev->can.state = CAN_STATE_ERROR_ACTIVE;
492
493 return 0;
494
495 err_adapter:
496 if (err == -ENODEV)
497 netif_device_detach(dev->netdev);
498
499 netdev_warn(netdev, "couldn't submit control: %d\n", err);
500
501 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
502 usb_free_urb(dev->tx_contexts[i].urb);
503 dev->tx_contexts[i].urb = NULL;
504 }
505 err_tx:
506 usb_kill_anchored_urbs(&dev->rx_submitted);
507
508 return err;
509 }
510
511 /*
512 * called by netdev to open the corresponding CAN interface.
513 */
peak_usb_ndo_open(struct net_device * netdev)514 static int peak_usb_ndo_open(struct net_device *netdev)
515 {
516 struct peak_usb_device *dev = netdev_priv(netdev);
517 int err;
518
519 /* common open */
520 err = open_candev(netdev);
521 if (err)
522 return err;
523
524 /* finally start device */
525 err = peak_usb_start(dev);
526 if (err) {
527 netdev_err(netdev, "couldn't start device: %d\n", err);
528 close_candev(netdev);
529 return err;
530 }
531
532 netif_start_queue(netdev);
533
534 return 0;
535 }
536
537 /*
538 * unlink in-flight Rx and Tx urbs and free their memory.
539 */
peak_usb_unlink_all_urbs(struct peak_usb_device * dev)540 static void peak_usb_unlink_all_urbs(struct peak_usb_device *dev)
541 {
542 int i;
543
544 /* free all Rx (submitted) urbs */
545 usb_kill_anchored_urbs(&dev->rx_submitted);
546
547 /* free unsubmitted Tx urbs first */
548 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
549 struct urb *urb = dev->tx_contexts[i].urb;
550
551 if (!urb ||
552 dev->tx_contexts[i].echo_index != PCAN_USB_MAX_TX_URBS) {
553 /*
554 * this urb is already released or always submitted,
555 * let usb core free by itself
556 */
557 continue;
558 }
559
560 usb_free_urb(urb);
561 dev->tx_contexts[i].urb = NULL;
562 }
563
564 /* then free all submitted Tx urbs */
565 usb_kill_anchored_urbs(&dev->tx_submitted);
566 atomic_set(&dev->active_tx_urbs, 0);
567 }
568
569 /*
570 * called by netdev to close the corresponding CAN interface.
571 */
peak_usb_ndo_stop(struct net_device * netdev)572 static int peak_usb_ndo_stop(struct net_device *netdev)
573 {
574 struct peak_usb_device *dev = netdev_priv(netdev);
575
576 dev->state &= ~PCAN_USB_STATE_STARTED;
577 netif_stop_queue(netdev);
578
579 /* unlink all pending urbs and free used memory */
580 peak_usb_unlink_all_urbs(dev);
581
582 if (dev->adapter->dev_stop)
583 dev->adapter->dev_stop(dev);
584
585 close_candev(netdev);
586
587 dev->can.state = CAN_STATE_STOPPED;
588
589 /* can set bus off now */
590 if (dev->adapter->dev_set_bus) {
591 int err = dev->adapter->dev_set_bus(dev, 0);
592 if (err)
593 return err;
594 }
595
596 return 0;
597 }
598
599 /*
600 * handle end of waiting for the device to reset
601 */
peak_usb_restart_complete(struct peak_usb_device * dev)602 void peak_usb_restart_complete(struct peak_usb_device *dev)
603 {
604 /* finally MUST update can state */
605 dev->can.state = CAN_STATE_ERROR_ACTIVE;
606
607 /* netdev queue can be awaken now */
608 netif_wake_queue(dev->netdev);
609 }
610
peak_usb_async_complete(struct urb * urb)611 void peak_usb_async_complete(struct urb *urb)
612 {
613 kfree(urb->transfer_buffer);
614 usb_free_urb(urb);
615 }
616
617 /*
618 * device (auto-)restart mechanism runs in a timer context =>
619 * MUST handle restart with asynchronous usb transfers
620 */
peak_usb_restart(struct peak_usb_device * dev)621 static int peak_usb_restart(struct peak_usb_device *dev)
622 {
623 struct urb *urb;
624 int err;
625 u8 *buf;
626
627 /*
628 * if device doesn't define any asynchronous restart handler, simply
629 * wake the netdev queue up
630 */
631 if (!dev->adapter->dev_restart_async) {
632 peak_usb_restart_complete(dev);
633 return 0;
634 }
635
636 /* first allocate a urb to handle the asynchronous steps */
637 urb = usb_alloc_urb(0, GFP_ATOMIC);
638 if (!urb)
639 return -ENOMEM;
640
641 /* also allocate enough space for the commands to send */
642 buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_ATOMIC);
643 if (!buf) {
644 usb_free_urb(urb);
645 return -ENOMEM;
646 }
647
648 /* call the device specific handler for the restart */
649 err = dev->adapter->dev_restart_async(dev, urb, buf);
650 if (!err)
651 return 0;
652
653 kfree(buf);
654 usb_free_urb(urb);
655
656 return err;
657 }
658
659 /*
660 * candev callback used to change CAN mode.
661 * Warning: this is called from a timer context!
662 */
peak_usb_set_mode(struct net_device * netdev,enum can_mode mode)663 static int peak_usb_set_mode(struct net_device *netdev, enum can_mode mode)
664 {
665 struct peak_usb_device *dev = netdev_priv(netdev);
666 int err = 0;
667
668 switch (mode) {
669 case CAN_MODE_START:
670 err = peak_usb_restart(dev);
671 if (err)
672 netdev_err(netdev, "couldn't start device (err %d)\n",
673 err);
674 break;
675
676 default:
677 return -EOPNOTSUPP;
678 }
679
680 return err;
681 }
682
683 /*
684 * candev callback used to set device nominal/arbitration bitrate.
685 */
peak_usb_set_bittiming(struct net_device * netdev)686 static int peak_usb_set_bittiming(struct net_device *netdev)
687 {
688 struct peak_usb_device *dev = netdev_priv(netdev);
689 const struct peak_usb_adapter *pa = dev->adapter;
690
691 if (pa->dev_set_bittiming) {
692 struct can_bittiming *bt = &dev->can.bittiming;
693 int err = pa->dev_set_bittiming(dev, bt);
694
695 if (err)
696 netdev_info(netdev, "couldn't set bitrate (err %d)\n",
697 err);
698 return err;
699 }
700
701 return 0;
702 }
703
704 /*
705 * candev callback used to set device data bitrate.
706 */
peak_usb_set_data_bittiming(struct net_device * netdev)707 static int peak_usb_set_data_bittiming(struct net_device *netdev)
708 {
709 struct peak_usb_device *dev = netdev_priv(netdev);
710 const struct peak_usb_adapter *pa = dev->adapter;
711
712 if (pa->dev_set_data_bittiming) {
713 struct can_bittiming *bt = &dev->can.data_bittiming;
714 int err = pa->dev_set_data_bittiming(dev, bt);
715
716 if (err)
717 netdev_info(netdev,
718 "couldn't set data bitrate (err %d)\n",
719 err);
720
721 return err;
722 }
723
724 return 0;
725 }
726
727 static const struct net_device_ops peak_usb_netdev_ops = {
728 .ndo_open = peak_usb_ndo_open,
729 .ndo_stop = peak_usb_ndo_stop,
730 .ndo_start_xmit = peak_usb_ndo_start_xmit,
731 .ndo_change_mtu = can_change_mtu,
732 };
733
734 /*
735 * create one device which is attached to CAN controller #ctrl_idx of the
736 * usb adapter.
737 */
peak_usb_create_dev(const struct peak_usb_adapter * peak_usb_adapter,struct usb_interface * intf,int ctrl_idx)738 static int peak_usb_create_dev(const struct peak_usb_adapter *peak_usb_adapter,
739 struct usb_interface *intf, int ctrl_idx)
740 {
741 struct usb_device *usb_dev = interface_to_usbdev(intf);
742 int sizeof_candev = peak_usb_adapter->sizeof_dev_private;
743 struct peak_usb_device *dev;
744 struct net_device *netdev;
745 int i, err;
746 u16 tmp16;
747
748 if (sizeof_candev < sizeof(struct peak_usb_device))
749 sizeof_candev = sizeof(struct peak_usb_device);
750
751 netdev = alloc_candev(sizeof_candev, PCAN_USB_MAX_TX_URBS);
752 if (!netdev) {
753 dev_err(&intf->dev, "%s: couldn't alloc candev\n",
754 PCAN_USB_DRIVER_NAME);
755 return -ENOMEM;
756 }
757
758 dev = netdev_priv(netdev);
759
760 /* allocate a buffer large enough to send commands */
761 dev->cmd_buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL);
762 if (!dev->cmd_buf) {
763 err = -ENOMEM;
764 goto lbl_free_candev;
765 }
766
767 dev->udev = usb_dev;
768 dev->netdev = netdev;
769 dev->adapter = peak_usb_adapter;
770 dev->ctrl_idx = ctrl_idx;
771 dev->state = PCAN_USB_STATE_CONNECTED;
772
773 dev->ep_msg_in = peak_usb_adapter->ep_msg_in;
774 dev->ep_msg_out = peak_usb_adapter->ep_msg_out[ctrl_idx];
775
776 dev->can.clock = peak_usb_adapter->clock;
777 dev->can.bittiming_const = peak_usb_adapter->bittiming_const;
778 dev->can.do_set_bittiming = peak_usb_set_bittiming;
779 dev->can.data_bittiming_const = peak_usb_adapter->data_bittiming_const;
780 dev->can.do_set_data_bittiming = peak_usb_set_data_bittiming;
781 dev->can.do_set_mode = peak_usb_set_mode;
782 dev->can.do_get_berr_counter = peak_usb_adapter->do_get_berr_counter;
783 dev->can.ctrlmode_supported = peak_usb_adapter->ctrlmode_supported;
784
785 netdev->netdev_ops = &peak_usb_netdev_ops;
786
787 netdev->flags |= IFF_ECHO; /* we support local echo */
788
789 init_usb_anchor(&dev->rx_submitted);
790
791 init_usb_anchor(&dev->tx_submitted);
792 atomic_set(&dev->active_tx_urbs, 0);
793
794 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++)
795 dev->tx_contexts[i].echo_index = PCAN_USB_MAX_TX_URBS;
796
797 dev->prev_siblings = usb_get_intfdata(intf);
798 usb_set_intfdata(intf, dev);
799
800 SET_NETDEV_DEV(netdev, &intf->dev);
801 netdev->dev_id = ctrl_idx;
802
803 err = register_candev(netdev);
804 if (err) {
805 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
806 goto lbl_restore_intf_data;
807 }
808
809 if (dev->prev_siblings)
810 (dev->prev_siblings)->next_siblings = dev;
811
812 /* keep hw revision into the netdevice */
813 tmp16 = le16_to_cpu(usb_dev->descriptor.bcdDevice);
814 dev->device_rev = tmp16 >> 8;
815
816 if (dev->adapter->dev_init) {
817 err = dev->adapter->dev_init(dev);
818 if (err)
819 goto lbl_unregister_candev;
820 }
821
822 /* set bus off */
823 if (dev->adapter->dev_set_bus) {
824 err = dev->adapter->dev_set_bus(dev, 0);
825 if (err)
826 goto lbl_unregister_candev;
827 }
828
829 /* get device number early */
830 if (dev->adapter->dev_get_device_id)
831 dev->adapter->dev_get_device_id(dev, &dev->device_number);
832
833 netdev_info(netdev, "attached to %s channel %u (device %u)\n",
834 peak_usb_adapter->name, ctrl_idx, dev->device_number);
835
836 return 0;
837
838 lbl_unregister_candev:
839 unregister_candev(netdev);
840
841 lbl_restore_intf_data:
842 usb_set_intfdata(intf, dev->prev_siblings);
843 kfree(dev->cmd_buf);
844
845 lbl_free_candev:
846 free_candev(netdev);
847
848 return err;
849 }
850
851 /*
852 * called by the usb core when the device is unplugged from the system
853 */
peak_usb_disconnect(struct usb_interface * intf)854 static void peak_usb_disconnect(struct usb_interface *intf)
855 {
856 struct peak_usb_device *dev;
857 struct peak_usb_device *dev_prev_siblings;
858
859 /* unregister as many netdev devices as siblings */
860 for (dev = usb_get_intfdata(intf); dev; dev = dev_prev_siblings) {
861 struct net_device *netdev = dev->netdev;
862 char name[IFNAMSIZ];
863
864 dev_prev_siblings = dev->prev_siblings;
865 dev->state &= ~PCAN_USB_STATE_CONNECTED;
866 strncpy(name, netdev->name, IFNAMSIZ);
867
868 unregister_netdev(netdev);
869
870 kfree(dev->cmd_buf);
871 dev->next_siblings = NULL;
872 if (dev->adapter->dev_free)
873 dev->adapter->dev_free(dev);
874
875 free_candev(netdev);
876 dev_info(&intf->dev, "%s removed\n", name);
877 }
878
879 usb_set_intfdata(intf, NULL);
880 }
881
882 /*
883 * probe function for new PEAK-System devices
884 */
peak_usb_probe(struct usb_interface * intf,const struct usb_device_id * id)885 static int peak_usb_probe(struct usb_interface *intf,
886 const struct usb_device_id *id)
887 {
888 struct usb_device *usb_dev = interface_to_usbdev(intf);
889 const u16 usb_id_product = le16_to_cpu(usb_dev->descriptor.idProduct);
890 const struct peak_usb_adapter *peak_usb_adapter = NULL;
891 int i, err = -ENOMEM;
892
893 /* get corresponding PCAN-USB adapter */
894 for (i = 0; i < ARRAY_SIZE(peak_usb_adapters_list); i++)
895 if (peak_usb_adapters_list[i]->device_id == usb_id_product) {
896 peak_usb_adapter = peak_usb_adapters_list[i];
897 break;
898 }
899
900 if (!peak_usb_adapter) {
901 /* should never come except device_id bad usage in this file */
902 pr_err("%s: didn't find device id. 0x%x in devices list\n",
903 PCAN_USB_DRIVER_NAME, usb_id_product);
904 return -ENODEV;
905 }
906
907 /* got corresponding adapter: check if it handles current interface */
908 if (peak_usb_adapter->intf_probe) {
909 err = peak_usb_adapter->intf_probe(intf);
910 if (err)
911 return err;
912 }
913
914 for (i = 0; i < peak_usb_adapter->ctrl_count; i++) {
915 err = peak_usb_create_dev(peak_usb_adapter, intf, i);
916 if (err) {
917 /* deregister already created devices */
918 peak_usb_disconnect(intf);
919 break;
920 }
921 }
922
923 return err;
924 }
925
926 /* usb specific object needed to register this driver with the usb subsystem */
927 static struct usb_driver peak_usb_driver = {
928 .name = PCAN_USB_DRIVER_NAME,
929 .disconnect = peak_usb_disconnect,
930 .probe = peak_usb_probe,
931 .id_table = peak_usb_table,
932 };
933
peak_usb_init(void)934 static int __init peak_usb_init(void)
935 {
936 int err;
937
938 /* register this driver with the USB subsystem */
939 err = usb_register(&peak_usb_driver);
940 if (err)
941 pr_err("%s: usb_register failed (err %d)\n",
942 PCAN_USB_DRIVER_NAME, err);
943
944 return err;
945 }
946
peak_usb_do_device_exit(struct device * d,void * arg)947 static int peak_usb_do_device_exit(struct device *d, void *arg)
948 {
949 struct usb_interface *intf = to_usb_interface(d);
950 struct peak_usb_device *dev;
951
952 /* stop as many netdev devices as siblings */
953 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) {
954 struct net_device *netdev = dev->netdev;
955
956 if (netif_device_present(netdev))
957 if (dev->adapter->dev_exit)
958 dev->adapter->dev_exit(dev);
959 }
960
961 return 0;
962 }
963
peak_usb_exit(void)964 static void __exit peak_usb_exit(void)
965 {
966 int err;
967
968 /* last chance do send any synchronous commands here */
969 err = driver_for_each_device(&peak_usb_driver.drvwrap.driver, NULL,
970 NULL, peak_usb_do_device_exit);
971 if (err)
972 pr_err("%s: failed to stop all can devices (err %d)\n",
973 PCAN_USB_DRIVER_NAME, err);
974
975 /* deregister this driver with the USB subsystem */
976 usb_deregister(&peak_usb_driver);
977
978 pr_info("%s: PCAN-USB interfaces driver unloaded\n",
979 PCAN_USB_DRIVER_NAME);
980 }
981
982 module_init(peak_usb_init);
983 module_exit(peak_usb_exit);
984
