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