xref: /linux/drivers/net/can/usb/usb_8dev.c (revision e0bf6c5ca2d3281f231c5f0c9bf145e9513644de)
1 /*
2  * CAN driver for "8 devices" USB2CAN converter
3  *
4  * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at)
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published
8  * by the Free Software Foundation; version 2 of the License.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program.
17  *
18  * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c
19  * and drivers/net/can/usb/esd_usb2.c
20  *
21  * Many thanks to Gerhard Bertelsmann (info@gerhard-bertelsmann.de)
22  * for testing and fixing this driver. Also many thanks to "8 devices",
23  * who were very cooperative and answered my questions.
24  */
25 
26 #include <linux/signal.h>
27 #include <linux/slab.h>
28 #include <linux/module.h>
29 #include <linux/netdevice.h>
30 #include <linux/usb.h>
31 
32 #include <linux/can.h>
33 #include <linux/can/dev.h>
34 #include <linux/can/error.h>
35 #include <linux/can/led.h>
36 
37 /* driver constants */
38 #define MAX_RX_URBS			20
39 #define MAX_TX_URBS			20
40 #define RX_BUFFER_SIZE			64
41 
42 /* vendor and product id */
43 #define USB_8DEV_VENDOR_ID		0x0483
44 #define USB_8DEV_PRODUCT_ID		0x1234
45 
46 /* endpoints */
47 enum usb_8dev_endpoint {
48 	USB_8DEV_ENDP_DATA_RX = 1,
49 	USB_8DEV_ENDP_DATA_TX,
50 	USB_8DEV_ENDP_CMD_RX,
51 	USB_8DEV_ENDP_CMD_TX
52 };
53 
54 /* device CAN clock */
55 #define USB_8DEV_ABP_CLOCK		32000000
56 
57 /* setup flags */
58 #define USB_8DEV_SILENT			0x01
59 #define USB_8DEV_LOOPBACK		0x02
60 #define USB_8DEV_DISABLE_AUTO_RESTRANS	0x04
61 #define USB_8DEV_STATUS_FRAME		0x08
62 
63 /* commands */
64 enum usb_8dev_cmd {
65 	USB_8DEV_RESET = 1,
66 	USB_8DEV_OPEN,
67 	USB_8DEV_CLOSE,
68 	USB_8DEV_SET_SPEED,
69 	USB_8DEV_SET_MASK_FILTER,
70 	USB_8DEV_GET_STATUS,
71 	USB_8DEV_GET_STATISTICS,
72 	USB_8DEV_GET_SERIAL,
73 	USB_8DEV_GET_SOFTW_VER,
74 	USB_8DEV_GET_HARDW_VER,
75 	USB_8DEV_RESET_TIMESTAMP,
76 	USB_8DEV_GET_SOFTW_HARDW_VER
77 };
78 
79 /* command options */
80 #define USB_8DEV_BAUD_MANUAL		0x09
81 #define USB_8DEV_CMD_START		0x11
82 #define USB_8DEV_CMD_END		0x22
83 
84 #define USB_8DEV_CMD_SUCCESS		0
85 #define USB_8DEV_CMD_ERROR		255
86 
87 #define USB_8DEV_CMD_TIMEOUT		1000
88 
89 /* frames */
90 #define USB_8DEV_DATA_START		0x55
91 #define USB_8DEV_DATA_END		0xAA
92 
93 #define USB_8DEV_TYPE_CAN_FRAME		0
94 #define USB_8DEV_TYPE_ERROR_FRAME	3
95 
96 #define USB_8DEV_EXTID			0x01
97 #define USB_8DEV_RTR			0x02
98 #define USB_8DEV_ERR_FLAG		0x04
99 
100 /* status */
101 #define USB_8DEV_STATUSMSG_OK		0x00  /* Normal condition. */
102 #define USB_8DEV_STATUSMSG_OVERRUN	0x01  /* Overrun occured when sending */
103 #define USB_8DEV_STATUSMSG_BUSLIGHT	0x02  /* Error counter has reached 96 */
104 #define USB_8DEV_STATUSMSG_BUSHEAVY	0x03  /* Error count. has reached 128 */
105 #define USB_8DEV_STATUSMSG_BUSOFF	0x04  /* Device is in BUSOFF */
106 #define USB_8DEV_STATUSMSG_STUFF	0x20  /* Stuff Error */
107 #define USB_8DEV_STATUSMSG_FORM		0x21  /* Form Error */
108 #define USB_8DEV_STATUSMSG_ACK		0x23  /* Ack Error */
109 #define USB_8DEV_STATUSMSG_BIT0		0x24  /* Bit1 Error */
110 #define USB_8DEV_STATUSMSG_BIT1		0x25  /* Bit0 Error */
111 #define USB_8DEV_STATUSMSG_CRC		0x27  /* CRC Error */
112 
113 #define USB_8DEV_RP_MASK		0x7F  /* Mask for Receive Error Bit */
114 
115 
116 /* table of devices that work with this driver */
117 static const struct usb_device_id usb_8dev_table[] = {
118 	{ USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) },
119 	{ }					/* Terminating entry */
120 };
121 
122 MODULE_DEVICE_TABLE(usb, usb_8dev_table);
123 
124 struct usb_8dev_tx_urb_context {
125 	struct usb_8dev_priv *priv;
126 
127 	u32 echo_index;
128 	u8 dlc;
129 };
130 
131 /* Structure to hold all of our device specific stuff */
132 struct usb_8dev_priv {
133 	struct can_priv can; /* must be the first member */
134 
135 	struct sk_buff *echo_skb[MAX_TX_URBS];
136 
137 	struct usb_device *udev;
138 	struct net_device *netdev;
139 
140 	atomic_t active_tx_urbs;
141 	struct usb_anchor tx_submitted;
142 	struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS];
143 
144 	struct usb_anchor rx_submitted;
145 
146 	struct can_berr_counter bec;
147 
148 	u8 *cmd_msg_buffer;
149 
150 	struct mutex usb_8dev_cmd_lock;
151 
152 };
153 
154 /* tx frame */
155 struct __packed usb_8dev_tx_msg {
156 	u8 begin;
157 	u8 flags;	/* RTR and EXT_ID flag */
158 	__be32 id;	/* upper 3 bits not used */
159 	u8 dlc;		/* data length code 0-8 bytes */
160 	u8 data[8];	/* 64-bit data */
161 	u8 end;
162 };
163 
164 /* rx frame */
165 struct __packed usb_8dev_rx_msg {
166 	u8 begin;
167 	u8 type;		/* frame type */
168 	u8 flags;		/* RTR and EXT_ID flag */
169 	__be32 id;		/* upper 3 bits not used */
170 	u8 dlc;			/* data length code 0-8 bytes */
171 	u8 data[8];		/* 64-bit data */
172 	__be32 timestamp;	/* 32-bit timestamp */
173 	u8 end;
174 };
175 
176 /* command frame */
177 struct __packed usb_8dev_cmd_msg {
178 	u8 begin;
179 	u8 channel;	/* unkown - always 0 */
180 	u8 command;	/* command to execute */
181 	u8 opt1;	/* optional parameter / return value */
182 	u8 opt2;	/* optional parameter 2 */
183 	u8 data[10];	/* optional parameter and data */
184 	u8 end;
185 };
186 
187 static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size)
188 {
189 	int actual_length;
190 
191 	return usb_bulk_msg(priv->udev,
192 			    usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX),
193 			    msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT);
194 }
195 
196 static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size,
197 				int *actual_length)
198 {
199 	return usb_bulk_msg(priv->udev,
200 			    usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX),
201 			    msg, size, actual_length, USB_8DEV_CMD_TIMEOUT);
202 }
203 
204 /* Send command to device and receive result.
205  * Command was successful when opt1 = 0.
206  */
207 static int usb_8dev_send_cmd(struct usb_8dev_priv *priv,
208 			     struct usb_8dev_cmd_msg *out,
209 			     struct usb_8dev_cmd_msg *in)
210 {
211 	int err;
212 	int num_bytes_read;
213 	struct net_device *netdev;
214 
215 	netdev = priv->netdev;
216 
217 	out->begin = USB_8DEV_CMD_START;
218 	out->end = USB_8DEV_CMD_END;
219 
220 	mutex_lock(&priv->usb_8dev_cmd_lock);
221 
222 	memcpy(priv->cmd_msg_buffer, out,
223 		sizeof(struct usb_8dev_cmd_msg));
224 
225 	err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer,
226 				    sizeof(struct usb_8dev_cmd_msg));
227 	if (err < 0) {
228 		netdev_err(netdev, "sending command message failed\n");
229 		goto failed;
230 	}
231 
232 	err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer,
233 				    sizeof(struct usb_8dev_cmd_msg),
234 				    &num_bytes_read);
235 	if (err < 0) {
236 		netdev_err(netdev, "no command message answer\n");
237 		goto failed;
238 	}
239 
240 	memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg));
241 
242 	if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END ||
243 			num_bytes_read != 16 || in->opt1 != 0)
244 		err = -EPROTO;
245 
246 failed:
247 	mutex_unlock(&priv->usb_8dev_cmd_lock);
248 	return err;
249 }
250 
251 /* Send open command to device */
252 static int usb_8dev_cmd_open(struct usb_8dev_priv *priv)
253 {
254 	struct can_bittiming *bt = &priv->can.bittiming;
255 	struct usb_8dev_cmd_msg outmsg;
256 	struct usb_8dev_cmd_msg inmsg;
257 	u32 ctrlmode = priv->can.ctrlmode;
258 	u32 flags = USB_8DEV_STATUS_FRAME;
259 	__be32 beflags;
260 	__be16 bebrp;
261 
262 	memset(&outmsg, 0, sizeof(outmsg));
263 	outmsg.command = USB_8DEV_OPEN;
264 	outmsg.opt1 = USB_8DEV_BAUD_MANUAL;
265 	outmsg.data[0] = bt->prop_seg + bt->phase_seg1;
266 	outmsg.data[1] = bt->phase_seg2;
267 	outmsg.data[2] = bt->sjw;
268 
269 	/* BRP */
270 	bebrp = cpu_to_be16((u16)bt->brp);
271 	memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp));
272 
273 	/* flags */
274 	if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
275 		flags |= USB_8DEV_LOOPBACK;
276 	if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
277 		flags |= USB_8DEV_SILENT;
278 	if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
279 		flags |= USB_8DEV_DISABLE_AUTO_RESTRANS;
280 
281 	beflags = cpu_to_be32(flags);
282 	memcpy(&outmsg.data[5], &beflags, sizeof(beflags));
283 
284 	return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
285 }
286 
287 /* Send close command to device */
288 static int usb_8dev_cmd_close(struct usb_8dev_priv *priv)
289 {
290 	struct usb_8dev_cmd_msg inmsg;
291 	struct usb_8dev_cmd_msg outmsg = {
292 		.channel = 0,
293 		.command = USB_8DEV_CLOSE,
294 		.opt1 = 0,
295 		.opt2 = 0
296 	};
297 
298 	return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
299 }
300 
301 /* Get firmware and hardware version */
302 static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res)
303 {
304 	struct usb_8dev_cmd_msg	inmsg;
305 	struct usb_8dev_cmd_msg	outmsg = {
306 		.channel = 0,
307 		.command = USB_8DEV_GET_SOFTW_HARDW_VER,
308 		.opt1 = 0,
309 		.opt2 = 0
310 	};
311 
312 	int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg);
313 	if (err)
314 		return err;
315 
316 	*res = be32_to_cpup((__be32 *)inmsg.data);
317 
318 	return err;
319 }
320 
321 /* Set network device mode
322  *
323  * Maybe we should leave this function empty, because the device
324  * set mode variable with open command.
325  */
326 static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode)
327 {
328 	struct usb_8dev_priv *priv = netdev_priv(netdev);
329 	int err = 0;
330 
331 	switch (mode) {
332 	case CAN_MODE_START:
333 		err = usb_8dev_cmd_open(priv);
334 		if (err)
335 			netdev_warn(netdev, "couldn't start device");
336 		break;
337 
338 	default:
339 		return -EOPNOTSUPP;
340 	}
341 
342 	return err;
343 }
344 
345 /* Read error/status frames */
346 static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv,
347 				struct usb_8dev_rx_msg *msg)
348 {
349 	struct can_frame *cf;
350 	struct sk_buff *skb;
351 	struct net_device_stats *stats = &priv->netdev->stats;
352 
353 	/* Error message:
354 	 * byte 0: Status
355 	 * byte 1: bit   7: Receive Passive
356 	 * byte 1: bit 0-6: Receive Error Counter
357 	 * byte 2: Transmit Error Counter
358 	 * byte 3: Always 0 (maybe reserved for future use)
359 	 */
360 
361 	u8 state = msg->data[0];
362 	u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK;
363 	u8 txerr = msg->data[2];
364 	int rx_errors = 0;
365 	int tx_errors = 0;
366 
367 	skb = alloc_can_err_skb(priv->netdev, &cf);
368 	if (!skb)
369 		return;
370 
371 	switch (state) {
372 	case USB_8DEV_STATUSMSG_OK:
373 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
374 		cf->can_id |= CAN_ERR_PROT;
375 		cf->data[2] = CAN_ERR_PROT_ACTIVE;
376 		break;
377 	case USB_8DEV_STATUSMSG_BUSOFF:
378 		priv->can.state = CAN_STATE_BUS_OFF;
379 		cf->can_id |= CAN_ERR_BUSOFF;
380 		priv->can.can_stats.bus_off++;
381 		can_bus_off(priv->netdev);
382 		break;
383 	case USB_8DEV_STATUSMSG_OVERRUN:
384 	case USB_8DEV_STATUSMSG_BUSLIGHT:
385 	case USB_8DEV_STATUSMSG_BUSHEAVY:
386 		cf->can_id |= CAN_ERR_CRTL;
387 		break;
388 	default:
389 		priv->can.state = CAN_STATE_ERROR_WARNING;
390 		cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
391 		priv->can.can_stats.bus_error++;
392 		break;
393 	}
394 
395 	switch (state) {
396 	case USB_8DEV_STATUSMSG_OK:
397 	case USB_8DEV_STATUSMSG_BUSOFF:
398 		break;
399 	case USB_8DEV_STATUSMSG_ACK:
400 		cf->can_id |= CAN_ERR_ACK;
401 		tx_errors = 1;
402 		break;
403 	case USB_8DEV_STATUSMSG_CRC:
404 		cf->data[2] |= CAN_ERR_PROT_UNSPEC;
405 		cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ |
406 			       CAN_ERR_PROT_LOC_CRC_DEL;
407 		rx_errors = 1;
408 		break;
409 	case USB_8DEV_STATUSMSG_BIT0:
410 		cf->data[2] |= CAN_ERR_PROT_BIT0;
411 		tx_errors = 1;
412 		break;
413 	case USB_8DEV_STATUSMSG_BIT1:
414 		cf->data[2] |= CAN_ERR_PROT_BIT1;
415 		tx_errors = 1;
416 		break;
417 	case USB_8DEV_STATUSMSG_FORM:
418 		cf->data[2] |= CAN_ERR_PROT_FORM;
419 		rx_errors = 1;
420 		break;
421 	case USB_8DEV_STATUSMSG_STUFF:
422 		cf->data[2] |= CAN_ERR_PROT_STUFF;
423 		rx_errors = 1;
424 		break;
425 	case USB_8DEV_STATUSMSG_OVERRUN:
426 		cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
427 		stats->rx_over_errors++;
428 		rx_errors = 1;
429 		break;
430 	case USB_8DEV_STATUSMSG_BUSLIGHT:
431 		priv->can.state = CAN_STATE_ERROR_WARNING;
432 		cf->data[1] = (txerr > rxerr) ?
433 			CAN_ERR_CRTL_TX_WARNING :
434 			CAN_ERR_CRTL_RX_WARNING;
435 		priv->can.can_stats.error_warning++;
436 		break;
437 	case USB_8DEV_STATUSMSG_BUSHEAVY:
438 		priv->can.state = CAN_STATE_ERROR_PASSIVE;
439 		cf->data[1] = (txerr > rxerr) ?
440 			CAN_ERR_CRTL_TX_PASSIVE :
441 			CAN_ERR_CRTL_RX_PASSIVE;
442 		priv->can.can_stats.error_passive++;
443 		break;
444 	default:
445 		netdev_warn(priv->netdev,
446 			    "Unknown status/error message (%d)\n", state);
447 		break;
448 	}
449 
450 	if (tx_errors) {
451 		cf->data[2] |= CAN_ERR_PROT_TX;
452 		stats->tx_errors++;
453 	}
454 
455 	if (rx_errors)
456 		stats->rx_errors++;
457 
458 	cf->data[6] = txerr;
459 	cf->data[7] = rxerr;
460 
461 	priv->bec.txerr = txerr;
462 	priv->bec.rxerr = rxerr;
463 
464 	netif_rx(skb);
465 
466 	stats->rx_packets++;
467 	stats->rx_bytes += cf->can_dlc;
468 }
469 
470 /* Read data and status frames */
471 static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv,
472 				struct usb_8dev_rx_msg *msg)
473 {
474 	struct can_frame *cf;
475 	struct sk_buff *skb;
476 	struct net_device_stats *stats = &priv->netdev->stats;
477 
478 	if (msg->type == USB_8DEV_TYPE_ERROR_FRAME &&
479 		   msg->flags == USB_8DEV_ERR_FLAG) {
480 		usb_8dev_rx_err_msg(priv, msg);
481 	} else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) {
482 		skb = alloc_can_skb(priv->netdev, &cf);
483 		if (!skb)
484 			return;
485 
486 		cf->can_id = be32_to_cpu(msg->id);
487 		cf->can_dlc = get_can_dlc(msg->dlc & 0xF);
488 
489 		if (msg->flags & USB_8DEV_EXTID)
490 			cf->can_id |= CAN_EFF_FLAG;
491 
492 		if (msg->flags & USB_8DEV_RTR)
493 			cf->can_id |= CAN_RTR_FLAG;
494 		else
495 			memcpy(cf->data, msg->data, cf->can_dlc);
496 
497 		netif_rx(skb);
498 
499 		stats->rx_packets++;
500 		stats->rx_bytes += cf->can_dlc;
501 
502 		can_led_event(priv->netdev, CAN_LED_EVENT_RX);
503 	} else {
504 		netdev_warn(priv->netdev, "frame type %d unknown",
505 			 msg->type);
506 	}
507 
508 }
509 
510 /* Callback for reading data from device
511  *
512  * Check urb status, call read function and resubmit urb read operation.
513  */
514 static void usb_8dev_read_bulk_callback(struct urb *urb)
515 {
516 	struct usb_8dev_priv *priv = urb->context;
517 	struct net_device *netdev;
518 	int retval;
519 	int pos = 0;
520 
521 	netdev = priv->netdev;
522 
523 	if (!netif_device_present(netdev))
524 		return;
525 
526 	switch (urb->status) {
527 	case 0: /* success */
528 		break;
529 
530 	case -ENOENT:
531 	case -ESHUTDOWN:
532 		return;
533 
534 	default:
535 		netdev_info(netdev, "Rx URB aborted (%d)\n",
536 			 urb->status);
537 		goto resubmit_urb;
538 	}
539 
540 	while (pos < urb->actual_length) {
541 		struct usb_8dev_rx_msg *msg;
542 
543 		if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) {
544 			netdev_err(priv->netdev, "format error\n");
545 			break;
546 		}
547 
548 		msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos);
549 		usb_8dev_rx_can_msg(priv, msg);
550 
551 		pos += sizeof(struct usb_8dev_rx_msg);
552 	}
553 
554 resubmit_urb:
555 	usb_fill_bulk_urb(urb, priv->udev,
556 			  usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX),
557 			  urb->transfer_buffer, RX_BUFFER_SIZE,
558 			  usb_8dev_read_bulk_callback, priv);
559 
560 	retval = usb_submit_urb(urb, GFP_ATOMIC);
561 
562 	if (retval == -ENODEV)
563 		netif_device_detach(netdev);
564 	else if (retval)
565 		netdev_err(netdev,
566 			"failed resubmitting read bulk urb: %d\n", retval);
567 }
568 
569 /* Callback handler for write operations
570  *
571  * Free allocated buffers, check transmit status and
572  * calculate statistic.
573  */
574 static void usb_8dev_write_bulk_callback(struct urb *urb)
575 {
576 	struct usb_8dev_tx_urb_context *context = urb->context;
577 	struct usb_8dev_priv *priv;
578 	struct net_device *netdev;
579 
580 	BUG_ON(!context);
581 
582 	priv = context->priv;
583 	netdev = priv->netdev;
584 
585 	/* free up our allocated buffer */
586 	usb_free_coherent(urb->dev, urb->transfer_buffer_length,
587 			  urb->transfer_buffer, urb->transfer_dma);
588 
589 	atomic_dec(&priv->active_tx_urbs);
590 
591 	if (!netif_device_present(netdev))
592 		return;
593 
594 	if (urb->status)
595 		netdev_info(netdev, "Tx URB aborted (%d)\n",
596 			 urb->status);
597 
598 	netdev->stats.tx_packets++;
599 	netdev->stats.tx_bytes += context->dlc;
600 
601 	can_get_echo_skb(netdev, context->echo_index);
602 
603 	can_led_event(netdev, CAN_LED_EVENT_TX);
604 
605 	/* Release context */
606 	context->echo_index = MAX_TX_URBS;
607 
608 	netif_wake_queue(netdev);
609 }
610 
611 /* Send data to device */
612 static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb,
613 				      struct net_device *netdev)
614 {
615 	struct usb_8dev_priv *priv = netdev_priv(netdev);
616 	struct net_device_stats *stats = &netdev->stats;
617 	struct can_frame *cf = (struct can_frame *) skb->data;
618 	struct usb_8dev_tx_msg *msg;
619 	struct urb *urb;
620 	struct usb_8dev_tx_urb_context *context = NULL;
621 	u8 *buf;
622 	int i, err;
623 	size_t size = sizeof(struct usb_8dev_tx_msg);
624 
625 	if (can_dropped_invalid_skb(netdev, skb))
626 		return NETDEV_TX_OK;
627 
628 	/* create a URB, and a buffer for it, and copy the data to the URB */
629 	urb = usb_alloc_urb(0, GFP_ATOMIC);
630 	if (!urb) {
631 		netdev_err(netdev, "No memory left for URBs\n");
632 		goto nomem;
633 	}
634 
635 	buf = usb_alloc_coherent(priv->udev, size, GFP_ATOMIC,
636 				 &urb->transfer_dma);
637 	if (!buf) {
638 		netdev_err(netdev, "No memory left for USB buffer\n");
639 		goto nomembuf;
640 	}
641 
642 	memset(buf, 0, size);
643 
644 	msg = (struct usb_8dev_tx_msg *)buf;
645 	msg->begin = USB_8DEV_DATA_START;
646 	msg->flags = 0x00;
647 
648 	if (cf->can_id & CAN_RTR_FLAG)
649 		msg->flags |= USB_8DEV_RTR;
650 
651 	if (cf->can_id & CAN_EFF_FLAG)
652 		msg->flags |= USB_8DEV_EXTID;
653 
654 	msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK);
655 	msg->dlc = cf->can_dlc;
656 	memcpy(msg->data, cf->data, cf->can_dlc);
657 	msg->end = USB_8DEV_DATA_END;
658 
659 	for (i = 0; i < MAX_TX_URBS; i++) {
660 		if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
661 			context = &priv->tx_contexts[i];
662 			break;
663 		}
664 	}
665 
666 	/* May never happen! When this happens we'd more URBs in flight as
667 	 * allowed (MAX_TX_URBS).
668 	 */
669 	if (!context)
670 		goto nofreecontext;
671 
672 	context->priv = priv;
673 	context->echo_index = i;
674 	context->dlc = cf->can_dlc;
675 
676 	usb_fill_bulk_urb(urb, priv->udev,
677 			  usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX),
678 			  buf, size, usb_8dev_write_bulk_callback, context);
679 	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
680 	usb_anchor_urb(urb, &priv->tx_submitted);
681 
682 	can_put_echo_skb(skb, netdev, context->echo_index);
683 
684 	atomic_inc(&priv->active_tx_urbs);
685 
686 	err = usb_submit_urb(urb, GFP_ATOMIC);
687 	if (unlikely(err))
688 		goto failed;
689 	else if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
690 		/* Slow down tx path */
691 		netif_stop_queue(netdev);
692 
693 	/* Release our reference to this URB, the USB core will eventually free
694 	 * it entirely.
695 	 */
696 	usb_free_urb(urb);
697 
698 	return NETDEV_TX_OK;
699 
700 nofreecontext:
701 	usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
702 	usb_free_urb(urb);
703 
704 	netdev_warn(netdev, "couldn't find free context");
705 
706 	return NETDEV_TX_BUSY;
707 
708 failed:
709 	can_free_echo_skb(netdev, context->echo_index);
710 
711 	usb_unanchor_urb(urb);
712 	usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
713 
714 	atomic_dec(&priv->active_tx_urbs);
715 
716 	if (err == -ENODEV)
717 		netif_device_detach(netdev);
718 	else
719 		netdev_warn(netdev, "failed tx_urb %d\n", err);
720 
721 nomembuf:
722 	usb_free_urb(urb);
723 
724 nomem:
725 	dev_kfree_skb(skb);
726 	stats->tx_dropped++;
727 
728 	return NETDEV_TX_OK;
729 }
730 
731 static int usb_8dev_get_berr_counter(const struct net_device *netdev,
732 				     struct can_berr_counter *bec)
733 {
734 	struct usb_8dev_priv *priv = netdev_priv(netdev);
735 
736 	bec->txerr = priv->bec.txerr;
737 	bec->rxerr = priv->bec.rxerr;
738 
739 	return 0;
740 }
741 
742 /* Start USB device */
743 static int usb_8dev_start(struct usb_8dev_priv *priv)
744 {
745 	struct net_device *netdev = priv->netdev;
746 	int err, i;
747 
748 	for (i = 0; i < MAX_RX_URBS; i++) {
749 		struct urb *urb = NULL;
750 		u8 *buf;
751 
752 		/* create a URB, and a buffer for it */
753 		urb = usb_alloc_urb(0, GFP_KERNEL);
754 		if (!urb) {
755 			netdev_err(netdev, "No memory left for URBs\n");
756 			err = -ENOMEM;
757 			break;
758 		}
759 
760 		buf = usb_alloc_coherent(priv->udev, RX_BUFFER_SIZE, GFP_KERNEL,
761 					 &urb->transfer_dma);
762 		if (!buf) {
763 			netdev_err(netdev, "No memory left for USB buffer\n");
764 			usb_free_urb(urb);
765 			err = -ENOMEM;
766 			break;
767 		}
768 
769 		usb_fill_bulk_urb(urb, priv->udev,
770 				  usb_rcvbulkpipe(priv->udev,
771 						  USB_8DEV_ENDP_DATA_RX),
772 				  buf, RX_BUFFER_SIZE,
773 				  usb_8dev_read_bulk_callback, priv);
774 		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
775 		usb_anchor_urb(urb, &priv->rx_submitted);
776 
777 		err = usb_submit_urb(urb, GFP_KERNEL);
778 		if (err) {
779 			usb_unanchor_urb(urb);
780 			usb_free_coherent(priv->udev, RX_BUFFER_SIZE, buf,
781 					  urb->transfer_dma);
782 			usb_free_urb(urb);
783 			break;
784 		}
785 
786 		/* Drop reference, USB core will take care of freeing it */
787 		usb_free_urb(urb);
788 	}
789 
790 	/* Did we submit any URBs */
791 	if (i == 0) {
792 		netdev_warn(netdev, "couldn't setup read URBs\n");
793 		return err;
794 	}
795 
796 	/* Warn if we've couldn't transmit all the URBs */
797 	if (i < MAX_RX_URBS)
798 		netdev_warn(netdev, "rx performance may be slow\n");
799 
800 	err = usb_8dev_cmd_open(priv);
801 	if (err)
802 		goto failed;
803 
804 	priv->can.state = CAN_STATE_ERROR_ACTIVE;
805 
806 	return 0;
807 
808 failed:
809 	if (err == -ENODEV)
810 		netif_device_detach(priv->netdev);
811 
812 	netdev_warn(netdev, "couldn't submit control: %d\n", err);
813 
814 	return err;
815 }
816 
817 /* Open USB device */
818 static int usb_8dev_open(struct net_device *netdev)
819 {
820 	struct usb_8dev_priv *priv = netdev_priv(netdev);
821 	int err;
822 
823 	/* common open */
824 	err = open_candev(netdev);
825 	if (err)
826 		return err;
827 
828 	can_led_event(netdev, CAN_LED_EVENT_OPEN);
829 
830 	/* finally start device */
831 	err = usb_8dev_start(priv);
832 	if (err) {
833 		if (err == -ENODEV)
834 			netif_device_detach(priv->netdev);
835 
836 		netdev_warn(netdev, "couldn't start device: %d\n",
837 			 err);
838 
839 		close_candev(netdev);
840 
841 		return err;
842 	}
843 
844 	netif_start_queue(netdev);
845 
846 	return 0;
847 }
848 
849 static void unlink_all_urbs(struct usb_8dev_priv *priv)
850 {
851 	int i;
852 
853 	usb_kill_anchored_urbs(&priv->rx_submitted);
854 
855 	usb_kill_anchored_urbs(&priv->tx_submitted);
856 	atomic_set(&priv->active_tx_urbs, 0);
857 
858 	for (i = 0; i < MAX_TX_URBS; i++)
859 		priv->tx_contexts[i].echo_index = MAX_TX_URBS;
860 }
861 
862 /* Close USB device */
863 static int usb_8dev_close(struct net_device *netdev)
864 {
865 	struct usb_8dev_priv *priv = netdev_priv(netdev);
866 	int err = 0;
867 
868 	/* Send CLOSE command to CAN controller */
869 	err = usb_8dev_cmd_close(priv);
870 	if (err)
871 		netdev_warn(netdev, "couldn't stop device");
872 
873 	priv->can.state = CAN_STATE_STOPPED;
874 
875 	netif_stop_queue(netdev);
876 
877 	/* Stop polling */
878 	unlink_all_urbs(priv);
879 
880 	close_candev(netdev);
881 
882 	can_led_event(netdev, CAN_LED_EVENT_STOP);
883 
884 	return err;
885 }
886 
887 static const struct net_device_ops usb_8dev_netdev_ops = {
888 	.ndo_open = usb_8dev_open,
889 	.ndo_stop = usb_8dev_close,
890 	.ndo_start_xmit = usb_8dev_start_xmit,
891 	.ndo_change_mtu = can_change_mtu,
892 };
893 
894 static const struct can_bittiming_const usb_8dev_bittiming_const = {
895 	.name = "usb_8dev",
896 	.tseg1_min = 1,
897 	.tseg1_max = 16,
898 	.tseg2_min = 1,
899 	.tseg2_max = 8,
900 	.sjw_max = 4,
901 	.brp_min = 1,
902 	.brp_max = 1024,
903 	.brp_inc = 1,
904 };
905 
906 /* Probe USB device
907  *
908  * Check device and firmware.
909  * Set supported modes and bittiming constants.
910  * Allocate some memory.
911  */
912 static int usb_8dev_probe(struct usb_interface *intf,
913 			 const struct usb_device_id *id)
914 {
915 	struct net_device *netdev;
916 	struct usb_8dev_priv *priv;
917 	int i, err = -ENOMEM;
918 	u32 version;
919 	char buf[18];
920 	struct usb_device *usbdev = interface_to_usbdev(intf);
921 
922 	/* product id looks strange, better we also check iProduct string */
923 	if (usb_string(usbdev, usbdev->descriptor.iProduct, buf,
924 		       sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter")) {
925 		dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n");
926 		return -ENODEV;
927 	}
928 
929 	netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS);
930 	if (!netdev) {
931 		dev_err(&intf->dev, "Couldn't alloc candev\n");
932 		return -ENOMEM;
933 	}
934 
935 	priv = netdev_priv(netdev);
936 
937 	priv->udev = usbdev;
938 	priv->netdev = netdev;
939 
940 	priv->can.state = CAN_STATE_STOPPED;
941 	priv->can.clock.freq = USB_8DEV_ABP_CLOCK;
942 	priv->can.bittiming_const = &usb_8dev_bittiming_const;
943 	priv->can.do_set_mode = usb_8dev_set_mode;
944 	priv->can.do_get_berr_counter = usb_8dev_get_berr_counter;
945 	priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
946 				      CAN_CTRLMODE_LISTENONLY |
947 				      CAN_CTRLMODE_ONE_SHOT;
948 
949 	netdev->netdev_ops = &usb_8dev_netdev_ops;
950 
951 	netdev->flags |= IFF_ECHO; /* we support local echo */
952 
953 	init_usb_anchor(&priv->rx_submitted);
954 
955 	init_usb_anchor(&priv->tx_submitted);
956 	atomic_set(&priv->active_tx_urbs, 0);
957 
958 	for (i = 0; i < MAX_TX_URBS; i++)
959 		priv->tx_contexts[i].echo_index = MAX_TX_URBS;
960 
961 	priv->cmd_msg_buffer = kzalloc(sizeof(struct usb_8dev_cmd_msg),
962 				      GFP_KERNEL);
963 	if (!priv->cmd_msg_buffer)
964 		goto cleanup_candev;
965 
966 	usb_set_intfdata(intf, priv);
967 
968 	SET_NETDEV_DEV(netdev, &intf->dev);
969 
970 	mutex_init(&priv->usb_8dev_cmd_lock);
971 
972 	err = register_candev(netdev);
973 	if (err) {
974 		netdev_err(netdev,
975 			"couldn't register CAN device: %d\n", err);
976 		goto cleanup_cmd_msg_buffer;
977 	}
978 
979 	err = usb_8dev_cmd_version(priv, &version);
980 	if (err) {
981 		netdev_err(netdev, "can't get firmware version\n");
982 		goto cleanup_unregister_candev;
983 	} else {
984 		netdev_info(netdev,
985 			 "firmware: %d.%d, hardware: %d.%d\n",
986 			 (version>>24) & 0xff, (version>>16) & 0xff,
987 			 (version>>8) & 0xff, version & 0xff);
988 	}
989 
990 	devm_can_led_init(netdev);
991 
992 	return 0;
993 
994 cleanup_unregister_candev:
995 	unregister_netdev(priv->netdev);
996 
997 cleanup_cmd_msg_buffer:
998 	kfree(priv->cmd_msg_buffer);
999 
1000 cleanup_candev:
1001 	free_candev(netdev);
1002 
1003 	return err;
1004 
1005 }
1006 
1007 /* Called by the usb core when driver is unloaded or device is removed */
1008 static void usb_8dev_disconnect(struct usb_interface *intf)
1009 {
1010 	struct usb_8dev_priv *priv = usb_get_intfdata(intf);
1011 
1012 	usb_set_intfdata(intf, NULL);
1013 
1014 	if (priv) {
1015 		netdev_info(priv->netdev, "device disconnected\n");
1016 
1017 		unregister_netdev(priv->netdev);
1018 		free_candev(priv->netdev);
1019 
1020 		unlink_all_urbs(priv);
1021 	}
1022 
1023 }
1024 
1025 static struct usb_driver usb_8dev_driver = {
1026 	.name =		"usb_8dev",
1027 	.probe =	usb_8dev_probe,
1028 	.disconnect =	usb_8dev_disconnect,
1029 	.id_table =	usb_8dev_table,
1030 };
1031 
1032 module_usb_driver(usb_8dev_driver);
1033 
1034 MODULE_AUTHOR("Bernd Krumboeck <krumboeck@universalnet.at>");
1035 MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces");
1036 MODULE_LICENSE("GPL v2");
1037