1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/netdevice.h>
18#include <linux/usb.h>
19#include <linux/module.h>
20
21#include <linux/can.h>
22#include <linux/can/dev.h>
23#include <linux/can/error.h>
24
25#include "pcan_usb_core.h"
26#include "pcan_usb_pro.h"
27
28MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro adapter");
29
30
31#define PCAN_USBPRO_EP_CMDOUT 1
32#define PCAN_USBPRO_EP_CMDIN (PCAN_USBPRO_EP_CMDOUT | USB_DIR_IN)
33#define PCAN_USBPRO_EP_MSGOUT_0 2
34#define PCAN_USBPRO_EP_MSGIN (PCAN_USBPRO_EP_MSGOUT_0 | USB_DIR_IN)
35#define PCAN_USBPRO_EP_MSGOUT_1 3
36#define PCAN_USBPRO_EP_UNUSED (PCAN_USBPRO_EP_MSGOUT_1 | USB_DIR_IN)
37
38#define PCAN_USBPRO_CHANNEL_COUNT 2
39
40
41#define PCAN_USBPRO_CRYSTAL_HZ 56000000
42
43
44#define PCAN_USBPRO_COMMAND_TIMEOUT 1000
45
46
47#define PCAN_USBPRO_RX_BUFFER_SIZE 1024
48#define PCAN_USBPRO_TX_BUFFER_SIZE 64
49
50#define PCAN_USBPRO_MSG_HEADER_LEN 4
51
52
53#define PCAN_USBPRO_RSP_SUBMIT_MAX 2
54
55#define PCAN_USBPRO_RTR 0x01
56#define PCAN_USBPRO_EXT 0x02
57
58#define PCAN_USBPRO_CMD_BUFFER_SIZE 512
59
60
61struct pcan_usb_pro_interface {
62 struct peak_usb_device *dev[PCAN_USBPRO_CHANNEL_COUNT];
63 struct peak_time_ref time_ref;
64 int cm_ignore_count;
65 int dev_opened_count;
66};
67
68
69struct pcan_usb_pro_device {
70 struct peak_usb_device dev;
71 struct pcan_usb_pro_interface *usb_if;
72 u32 cached_ccbt;
73};
74
75
76struct pcan_usb_pro_msg {
77 u8 *rec_ptr;
78 int rec_buffer_size;
79 int rec_buffer_len;
80 union {
81 __le16 *rec_cnt_rd;
82 __le32 *rec_cnt;
83 u8 *rec_buffer;
84 } u;
85};
86
87
88static u16 pcan_usb_pro_sizeof_rec[256] = {
89 [PCAN_USBPRO_SETBTR] = sizeof(struct pcan_usb_pro_btr),
90 [PCAN_USBPRO_SETBUSACT] = sizeof(struct pcan_usb_pro_busact),
91 [PCAN_USBPRO_SETSILENT] = sizeof(struct pcan_usb_pro_silent),
92 [PCAN_USBPRO_SETFILTR] = sizeof(struct pcan_usb_pro_filter),
93 [PCAN_USBPRO_SETTS] = sizeof(struct pcan_usb_pro_setts),
94 [PCAN_USBPRO_GETDEVID] = sizeof(struct pcan_usb_pro_devid),
95 [PCAN_USBPRO_SETLED] = sizeof(struct pcan_usb_pro_setled),
96 [PCAN_USBPRO_RXMSG8] = sizeof(struct pcan_usb_pro_rxmsg),
97 [PCAN_USBPRO_RXMSG4] = sizeof(struct pcan_usb_pro_rxmsg) - 4,
98 [PCAN_USBPRO_RXMSG0] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
99 [PCAN_USBPRO_RXRTR] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
100 [PCAN_USBPRO_RXSTATUS] = sizeof(struct pcan_usb_pro_rxstatus),
101 [PCAN_USBPRO_RXTS] = sizeof(struct pcan_usb_pro_rxts),
102 [PCAN_USBPRO_TXMSG8] = sizeof(struct pcan_usb_pro_txmsg),
103 [PCAN_USBPRO_TXMSG4] = sizeof(struct pcan_usb_pro_txmsg) - 4,
104 [PCAN_USBPRO_TXMSG0] = sizeof(struct pcan_usb_pro_txmsg) - 8,
105};
106
107
108
109
110static u8 *pcan_msg_init(struct pcan_usb_pro_msg *pm, void *buffer_addr,
111 int buffer_size)
112{
113 if (buffer_size < PCAN_USBPRO_MSG_HEADER_LEN)
114 return NULL;
115
116 pm->u.rec_buffer = (u8 *)buffer_addr;
117 pm->rec_buffer_size = pm->rec_buffer_len = buffer_size;
118 pm->rec_ptr = pm->u.rec_buffer + PCAN_USBPRO_MSG_HEADER_LEN;
119
120 return pm->rec_ptr;
121}
122
123static u8 *pcan_msg_init_empty(struct pcan_usb_pro_msg *pm,
124 void *buffer_addr, int buffer_size)
125{
126 u8 *pr = pcan_msg_init(pm, buffer_addr, buffer_size);
127
128 if (pr) {
129 pm->rec_buffer_len = PCAN_USBPRO_MSG_HEADER_LEN;
130 *pm->u.rec_cnt = 0;
131 }
132 return pr;
133}
134
135
136
137
138static int pcan_msg_add_rec(struct pcan_usb_pro_msg *pm, u8 id, ...)
139{
140 int len, i;
141 u8 *pc;
142 va_list ap;
143
144 va_start(ap, id);
145
146 pc = pm->rec_ptr + 1;
147
148 i = 0;
149 switch (id) {
150 case PCAN_USBPRO_TXMSG8:
151 i += 4;
152 case PCAN_USBPRO_TXMSG4:
153 i += 4;
154 case PCAN_USBPRO_TXMSG0:
155 *pc++ = va_arg(ap, int);
156 *pc++ = va_arg(ap, int);
157 *pc++ = va_arg(ap, int);
158 *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
159 pc += 4;
160 memcpy(pc, va_arg(ap, int *), i);
161 pc += i;
162 break;
163
164 case PCAN_USBPRO_SETBTR:
165 case PCAN_USBPRO_GETDEVID:
166 *pc++ = va_arg(ap, int);
167 pc += 2;
168 *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
169 pc += 4;
170 break;
171
172 case PCAN_USBPRO_SETFILTR:
173 case PCAN_USBPRO_SETBUSACT:
174 case PCAN_USBPRO_SETSILENT:
175 *pc++ = va_arg(ap, int);
176 *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
177 pc += 2;
178 break;
179
180 case PCAN_USBPRO_SETLED:
181 *pc++ = va_arg(ap, int);
182 *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
183 pc += 2;
184 *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
185 pc += 4;
186 break;
187
188 case PCAN_USBPRO_SETTS:
189 pc++;
190 *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
191 pc += 2;
192 break;
193
194 default:
195 pr_err("%s: %s(): unknown data type %02Xh (%d)\n",
196 PCAN_USB_DRIVER_NAME, __func__, id, id);
197 pc--;
198 break;
199 }
200
201 len = pc - pm->rec_ptr;
202 if (len > 0) {
203 *pm->u.rec_cnt = cpu_to_le32(le32_to_cpu(*pm->u.rec_cnt) + 1);
204 *pm->rec_ptr = id;
205
206 pm->rec_ptr = pc;
207 pm->rec_buffer_len += len;
208 }
209
210 va_end(ap);
211
212 return len;
213}
214
215
216
217
218static int pcan_usb_pro_send_cmd(struct peak_usb_device *dev,
219 struct pcan_usb_pro_msg *pum)
220{
221 int actual_length;
222 int err;
223
224
225 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
226 return 0;
227
228 err = usb_bulk_msg(dev->udev,
229 usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
230 pum->u.rec_buffer, pum->rec_buffer_len,
231 &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
232 if (err)
233 netdev_err(dev->netdev, "sending command failure: %d\n", err);
234
235 return err;
236}
237
238
239
240
241static int pcan_usb_pro_wait_rsp(struct peak_usb_device *dev,
242 struct pcan_usb_pro_msg *pum)
243{
244 u8 req_data_type, req_channel;
245 int actual_length;
246 int i, err = 0;
247
248
249 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
250 return 0;
251
252 req_data_type = pum->u.rec_buffer[4];
253 req_channel = pum->u.rec_buffer[5];
254
255 *pum->u.rec_cnt = 0;
256 for (i = 0; !err && i < PCAN_USBPRO_RSP_SUBMIT_MAX; i++) {
257 struct pcan_usb_pro_msg rsp;
258 union pcan_usb_pro_rec *pr;
259 u32 r, rec_cnt;
260 u16 rec_len;
261 u8 *pc;
262
263 err = usb_bulk_msg(dev->udev,
264 usb_rcvbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDIN),
265 pum->u.rec_buffer, pum->rec_buffer_len,
266 &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
267 if (err) {
268 netdev_err(dev->netdev, "waiting rsp error %d\n", err);
269 break;
270 }
271
272 if (actual_length == 0)
273 continue;
274
275 err = -EBADMSG;
276 if (actual_length < PCAN_USBPRO_MSG_HEADER_LEN) {
277 netdev_err(dev->netdev,
278 "got abnormal too small rsp (len=%d)\n",
279 actual_length);
280 break;
281 }
282
283 pc = pcan_msg_init(&rsp, pum->u.rec_buffer,
284 actual_length);
285
286 rec_cnt = le32_to_cpu(*rsp.u.rec_cnt);
287
288
289 for (r = 0; r < rec_cnt; r++) {
290 pr = (union pcan_usb_pro_rec *)pc;
291 rec_len = pcan_usb_pro_sizeof_rec[pr->data_type];
292 if (!rec_len) {
293 netdev_err(dev->netdev,
294 "got unprocessed record in msg\n");
295 pcan_dump_mem("rcvd rsp msg", pum->u.rec_buffer,
296 actual_length);
297 break;
298 }
299
300
301 if (pr->data_type != req_data_type)
302 netdev_err(dev->netdev,
303 "got unwanted rsp %xh: ignored\n",
304 pr->data_type);
305
306
307 else if ((req_channel != 0xff) && \
308 (pr->bus_act.channel != req_channel))
309 netdev_err(dev->netdev,
310 "got rsp %xh but on chan%u: ignored\n",
311 req_data_type, pr->bus_act.channel);
312
313
314 else
315 return 0;
316
317
318 pc += rec_len;
319 }
320 }
321
322 return (i >= PCAN_USBPRO_RSP_SUBMIT_MAX) ? -ERANGE : err;
323}
324
325static int pcan_usb_pro_send_req(struct peak_usb_device *dev, int req_id,
326 int req_value, void *req_addr, int req_size)
327{
328 int err;
329 u8 req_type;
330 unsigned int p;
331
332
333 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
334 return 0;
335
336 req_type = USB_TYPE_VENDOR | USB_RECIP_OTHER;
337
338 switch (req_id) {
339 case PCAN_USBPRO_REQ_FCT:
340 p = usb_sndctrlpipe(dev->udev, 0);
341 break;
342
343 default:
344 p = usb_rcvctrlpipe(dev->udev, 0);
345 req_type |= USB_DIR_IN;
346 memset(req_addr, '\0', req_size);
347 break;
348 }
349
350 err = usb_control_msg(dev->udev, p, req_id, req_type, req_value, 0,
351 req_addr, req_size, 2 * USB_CTRL_GET_TIMEOUT);
352 if (err < 0) {
353 netdev_info(dev->netdev,
354 "unable to request usb[type=%d value=%d] err=%d\n",
355 req_id, req_value, err);
356 return err;
357 }
358
359 return 0;
360}
361
362static int pcan_usb_pro_set_ts(struct peak_usb_device *dev, u16 onoff)
363{
364 struct pcan_usb_pro_msg um;
365
366 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
367 pcan_msg_add_rec(&um, PCAN_USBPRO_SETTS, onoff);
368
369 return pcan_usb_pro_send_cmd(dev, &um);
370}
371
372static int pcan_usb_pro_set_bitrate(struct peak_usb_device *dev, u32 ccbt)
373{
374 struct pcan_usb_pro_device *pdev =
375 container_of(dev, struct pcan_usb_pro_device, dev);
376 struct pcan_usb_pro_msg um;
377
378 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
379 pcan_msg_add_rec(&um, PCAN_USBPRO_SETBTR, dev->ctrl_idx, ccbt);
380
381
382 pdev->cached_ccbt = ccbt;
383
384 return pcan_usb_pro_send_cmd(dev, &um);
385}
386
387static int pcan_usb_pro_set_bus(struct peak_usb_device *dev, u8 onoff)
388{
389 struct pcan_usb_pro_msg um;
390
391
392 if (onoff) {
393 struct pcan_usb_pro_device *pdev =
394 container_of(dev, struct pcan_usb_pro_device, dev);
395
396 pcan_usb_pro_set_bitrate(dev, pdev->cached_ccbt);
397 }
398
399 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
400 pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, onoff);
401
402 return pcan_usb_pro_send_cmd(dev, &um);
403}
404
405static int pcan_usb_pro_set_silent(struct peak_usb_device *dev, u8 onoff)
406{
407 struct pcan_usb_pro_msg um;
408
409 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
410 pcan_msg_add_rec(&um, PCAN_USBPRO_SETSILENT, dev->ctrl_idx, onoff);
411
412 return pcan_usb_pro_send_cmd(dev, &um);
413}
414
415static int pcan_usb_pro_set_filter(struct peak_usb_device *dev, u16 filter_mode)
416{
417 struct pcan_usb_pro_msg um;
418
419 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
420 pcan_msg_add_rec(&um, PCAN_USBPRO_SETFILTR, dev->ctrl_idx, filter_mode);
421
422 return pcan_usb_pro_send_cmd(dev, &um);
423}
424
425static int pcan_usb_pro_set_led(struct peak_usb_device *dev, u8 mode,
426 u32 timeout)
427{
428 struct pcan_usb_pro_msg um;
429
430 pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
431 pcan_msg_add_rec(&um, PCAN_USBPRO_SETLED, dev->ctrl_idx, mode, timeout);
432
433 return pcan_usb_pro_send_cmd(dev, &um);
434}
435
436static int pcan_usb_pro_get_device_id(struct peak_usb_device *dev,
437 u32 *device_id)
438{
439 struct pcan_usb_pro_devid *pdn;
440 struct pcan_usb_pro_msg um;
441 int err;
442 u8 *pc;
443
444 pc = pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
445 pcan_msg_add_rec(&um, PCAN_USBPRO_GETDEVID, dev->ctrl_idx);
446
447 err = pcan_usb_pro_send_cmd(dev, &um);
448 if (err)
449 return err;
450
451 err = pcan_usb_pro_wait_rsp(dev, &um);
452 if (err)
453 return err;
454
455 pdn = (struct pcan_usb_pro_devid *)pc;
456 if (device_id)
457 *device_id = le32_to_cpu(pdn->serial_num);
458
459 return err;
460}
461
462static int pcan_usb_pro_set_bittiming(struct peak_usb_device *dev,
463 struct can_bittiming *bt)
464{
465 u32 ccbt;
466
467 ccbt = (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 0x00800000 : 0;
468 ccbt |= (bt->sjw - 1) << 24;
469 ccbt |= (bt->phase_seg2 - 1) << 20;
470 ccbt |= (bt->prop_seg + bt->phase_seg1 - 1) << 16;
471 ccbt |= bt->brp - 1;
472
473 netdev_info(dev->netdev, "setting ccbt=0x%08x\n", ccbt);
474
475 return pcan_usb_pro_set_bitrate(dev, ccbt);
476}
477
478static void pcan_usb_pro_restart_complete(struct urb *urb)
479{
480
481 peak_usb_async_complete(urb);
482
483
484 peak_usb_restart_complete(urb->context);
485}
486
487
488
489
490static int pcan_usb_pro_restart_async(struct peak_usb_device *dev,
491 struct urb *urb, u8 *buf)
492{
493 struct pcan_usb_pro_msg um;
494
495 pcan_msg_init_empty(&um, buf, PCAN_USB_MAX_CMD_LEN);
496 pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, 1);
497
498 usb_fill_bulk_urb(urb, dev->udev,
499 usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
500 buf, PCAN_USB_MAX_CMD_LEN,
501 pcan_usb_pro_restart_complete, dev);
502
503 return usb_submit_urb(urb, GFP_ATOMIC);
504}
505
506static int pcan_usb_pro_drv_loaded(struct peak_usb_device *dev, int loaded)
507{
508 u8 *buffer;
509 int err;
510
511 buffer = kmalloc(PCAN_USBPRO_FCT_DRVLD_REQ_LEN, GFP_KERNEL);
512 if (!buffer)
513 return -ENOMEM;
514
515 buffer[0] = 0;
516 buffer[1] = !!loaded;
517
518 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_FCT,
519 PCAN_USBPRO_FCT_DRVLD, buffer,
520 PCAN_USBPRO_FCT_DRVLD_REQ_LEN);
521 kfree(buffer);
522
523 return err;
524}
525
526static inline
527struct pcan_usb_pro_interface *pcan_usb_pro_dev_if(struct peak_usb_device *dev)
528{
529 struct pcan_usb_pro_device *pdev =
530 container_of(dev, struct pcan_usb_pro_device, dev);
531 return pdev->usb_if;
532}
533
534static int pcan_usb_pro_handle_canmsg(struct pcan_usb_pro_interface *usb_if,
535 struct pcan_usb_pro_rxmsg *rx)
536{
537 const unsigned int ctrl_idx = (rx->len >> 4) & 0x0f;
538 struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
539 struct net_device *netdev = dev->netdev;
540 struct can_frame *can_frame;
541 struct sk_buff *skb;
542 struct timeval tv;
543 struct skb_shared_hwtstamps *hwts;
544
545 skb = alloc_can_skb(netdev, &can_frame);
546 if (!skb)
547 return -ENOMEM;
548
549 can_frame->can_id = le32_to_cpu(rx->id);
550 can_frame->can_dlc = rx->len & 0x0f;
551
552 if (rx->flags & PCAN_USBPRO_EXT)
553 can_frame->can_id |= CAN_EFF_FLAG;
554
555 if (rx->flags & PCAN_USBPRO_RTR)
556 can_frame->can_id |= CAN_RTR_FLAG;
557 else
558 memcpy(can_frame->data, rx->data, can_frame->can_dlc);
559
560 peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(rx->ts32), &tv);
561 hwts = skb_hwtstamps(skb);
562 hwts->hwtstamp = timeval_to_ktime(tv);
563
564 netif_rx(skb);
565 netdev->stats.rx_packets++;
566 netdev->stats.rx_bytes += can_frame->can_dlc;
567
568 return 0;
569}
570
571static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if,
572 struct pcan_usb_pro_rxstatus *er)
573{
574 const u16 raw_status = le16_to_cpu(er->status);
575 const unsigned int ctrl_idx = (er->channel >> 4) & 0x0f;
576 struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
577 struct net_device *netdev = dev->netdev;
578 struct can_frame *can_frame;
579 enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
580 u8 err_mask = 0;
581 struct sk_buff *skb;
582 struct timeval tv;
583 struct skb_shared_hwtstamps *hwts;
584
585
586 if (dev->can.state == CAN_STATE_BUS_OFF)
587 return 0;
588
589 if (!raw_status) {
590
591 dev->can.state = CAN_STATE_ERROR_ACTIVE;
592 return 0;
593 }
594
595 if (raw_status & (PCAN_USBPRO_STATUS_OVERRUN |
596 PCAN_USBPRO_STATUS_QOVERRUN)) {
597
598 new_state = CAN_STATE_MAX;
599 }
600
601 if (raw_status & PCAN_USBPRO_STATUS_BUS) {
602 new_state = CAN_STATE_BUS_OFF;
603 } else if (raw_status & PCAN_USBPRO_STATUS_ERROR) {
604 u32 rx_err_cnt = (le32_to_cpu(er->err_frm) & 0x00ff0000) >> 16;
605 u32 tx_err_cnt = (le32_to_cpu(er->err_frm) & 0xff000000) >> 24;
606
607 if (rx_err_cnt > 127)
608 err_mask |= CAN_ERR_CRTL_RX_PASSIVE;
609 else if (rx_err_cnt > 96)
610 err_mask |= CAN_ERR_CRTL_RX_WARNING;
611
612 if (tx_err_cnt > 127)
613 err_mask |= CAN_ERR_CRTL_TX_PASSIVE;
614 else if (tx_err_cnt > 96)
615 err_mask |= CAN_ERR_CRTL_TX_WARNING;
616
617 if (err_mask & (CAN_ERR_CRTL_RX_WARNING |
618 CAN_ERR_CRTL_TX_WARNING))
619 new_state = CAN_STATE_ERROR_WARNING;
620 else if (err_mask & (CAN_ERR_CRTL_RX_PASSIVE |
621 CAN_ERR_CRTL_TX_PASSIVE))
622 new_state = CAN_STATE_ERROR_PASSIVE;
623 }
624
625
626 if (dev->can.state == new_state)
627 return 0;
628
629
630 skb = alloc_can_err_skb(netdev, &can_frame);
631 if (!skb)
632 return -ENOMEM;
633
634 switch (new_state) {
635 case CAN_STATE_BUS_OFF:
636 can_frame->can_id |= CAN_ERR_BUSOFF;
637 can_bus_off(netdev);
638 break;
639
640 case CAN_STATE_ERROR_PASSIVE:
641 can_frame->can_id |= CAN_ERR_CRTL;
642 can_frame->data[1] |= err_mask;
643 dev->can.can_stats.error_passive++;
644 break;
645
646 case CAN_STATE_ERROR_WARNING:
647 can_frame->can_id |= CAN_ERR_CRTL;
648 can_frame->data[1] |= err_mask;
649 dev->can.can_stats.error_warning++;
650 break;
651
652 case CAN_STATE_ERROR_ACTIVE:
653 break;
654
655 default:
656
657 if (raw_status & PCAN_USBPRO_STATUS_OVERRUN) {
658 can_frame->can_id |= CAN_ERR_PROT;
659 can_frame->data[2] |= CAN_ERR_PROT_OVERLOAD;
660 netdev->stats.rx_over_errors++;
661 netdev->stats.rx_errors++;
662 }
663
664 if (raw_status & PCAN_USBPRO_STATUS_QOVERRUN) {
665 can_frame->can_id |= CAN_ERR_CRTL;
666 can_frame->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
667 netdev->stats.rx_over_errors++;
668 netdev->stats.rx_errors++;
669 }
670
671 new_state = CAN_STATE_ERROR_ACTIVE;
672 break;
673 }
674
675 dev->can.state = new_state;
676
677 peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(er->ts32), &tv);
678 hwts = skb_hwtstamps(skb);
679 hwts->hwtstamp = timeval_to_ktime(tv);
680 netif_rx(skb);
681 netdev->stats.rx_packets++;
682 netdev->stats.rx_bytes += can_frame->can_dlc;
683
684 return 0;
685}
686
687static void pcan_usb_pro_handle_ts(struct pcan_usb_pro_interface *usb_if,
688 struct pcan_usb_pro_rxts *ts)
689{
690
691 if (usb_if->cm_ignore_count > 0)
692 usb_if->cm_ignore_count--;
693 else
694 peak_usb_set_ts_now(&usb_if->time_ref,
695 le32_to_cpu(ts->ts64[1]));
696}
697
698
699
700
701static int pcan_usb_pro_decode_buf(struct peak_usb_device *dev, struct urb *urb)
702{
703 struct pcan_usb_pro_interface *usb_if = pcan_usb_pro_dev_if(dev);
704 struct net_device *netdev = dev->netdev;
705 struct pcan_usb_pro_msg usb_msg;
706 u8 *rec_ptr, *msg_end;
707 u16 rec_cnt;
708 int err = 0;
709
710 rec_ptr = pcan_msg_init(&usb_msg, urb->transfer_buffer,
711 urb->actual_length);
712 if (!rec_ptr) {
713 netdev_err(netdev, "bad msg hdr len %d\n", urb->actual_length);
714 return -EINVAL;
715 }
716
717
718 msg_end = urb->transfer_buffer + urb->actual_length;
719 rec_cnt = le16_to_cpu(*usb_msg.u.rec_cnt_rd);
720 for (; rec_cnt > 0; rec_cnt--) {
721 union pcan_usb_pro_rec *pr = (union pcan_usb_pro_rec *)rec_ptr;
722 u16 sizeof_rec = pcan_usb_pro_sizeof_rec[pr->data_type];
723
724 if (!sizeof_rec) {
725 netdev_err(netdev,
726 "got unsupported rec in usb msg:\n");
727 err = -ENOTSUPP;
728 break;
729 }
730
731
732 if (rec_ptr + sizeof_rec > msg_end) {
733 netdev_err(netdev,
734 "got frag rec: should inc usb rx buf size\n");
735 err = -EBADMSG;
736 break;
737 }
738
739 switch (pr->data_type) {
740 case PCAN_USBPRO_RXMSG8:
741 case PCAN_USBPRO_RXMSG4:
742 case PCAN_USBPRO_RXMSG0:
743 case PCAN_USBPRO_RXRTR:
744 err = pcan_usb_pro_handle_canmsg(usb_if, &pr->rx_msg);
745 if (err < 0)
746 goto fail;
747 break;
748
749 case PCAN_USBPRO_RXSTATUS:
750 err = pcan_usb_pro_handle_error(usb_if, &pr->rx_status);
751 if (err < 0)
752 goto fail;
753 break;
754
755 case PCAN_USBPRO_RXTS:
756 pcan_usb_pro_handle_ts(usb_if, &pr->rx_ts);
757 break;
758
759 default:
760 netdev_err(netdev,
761 "unhandled rec type 0x%02x (%d): ignored\n",
762 pr->data_type, pr->data_type);
763 break;
764 }
765
766 rec_ptr += sizeof_rec;
767 }
768
769fail:
770 if (err)
771 pcan_dump_mem("received msg",
772 urb->transfer_buffer, urb->actual_length);
773
774 return err;
775}
776
777static int pcan_usb_pro_encode_msg(struct peak_usb_device *dev,
778 struct sk_buff *skb, u8 *obuf, size_t *size)
779{
780 struct can_frame *cf = (struct can_frame *)skb->data;
781 u8 data_type, len, flags;
782 struct pcan_usb_pro_msg usb_msg;
783
784 pcan_msg_init_empty(&usb_msg, obuf, *size);
785
786 if ((cf->can_id & CAN_RTR_FLAG) || (cf->can_dlc == 0))
787 data_type = PCAN_USBPRO_TXMSG0;
788 else if (cf->can_dlc <= 4)
789 data_type = PCAN_USBPRO_TXMSG4;
790 else
791 data_type = PCAN_USBPRO_TXMSG8;
792
793 len = (dev->ctrl_idx << 4) | (cf->can_dlc & 0x0f);
794
795 flags = 0;
796 if (cf->can_id & CAN_EFF_FLAG)
797 flags |= 0x02;
798 if (cf->can_id & CAN_RTR_FLAG)
799 flags |= 0x01;
800
801 pcan_msg_add_rec(&usb_msg, data_type, 0, flags, len, cf->can_id,
802 cf->data);
803
804 *size = usb_msg.rec_buffer_len;
805
806 return 0;
807}
808
809static int pcan_usb_pro_start(struct peak_usb_device *dev)
810{
811 struct pcan_usb_pro_device *pdev =
812 container_of(dev, struct pcan_usb_pro_device, dev);
813 int err;
814
815 err = pcan_usb_pro_set_silent(dev,
816 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
817 if (err)
818 return err;
819
820
821 err = pcan_usb_pro_set_filter(dev, 1);
822 if (err)
823 return err;
824
825
826 if (pdev->usb_if->dev_opened_count == 0) {
827
828 peak_usb_init_time_ref(&pdev->usb_if->time_ref, &pcan_usb_pro);
829
830
831 err = pcan_usb_pro_set_ts(dev, 1);
832 }
833
834 pdev->usb_if->dev_opened_count++;
835
836 return err;
837}
838
839
840
841
842
843static int pcan_usb_pro_stop(struct peak_usb_device *dev)
844{
845 struct pcan_usb_pro_device *pdev =
846 container_of(dev, struct pcan_usb_pro_device, dev);
847
848
849 if (pdev->usb_if->dev_opened_count == 1)
850 pcan_usb_pro_set_ts(dev, 0);
851
852 pdev->usb_if->dev_opened_count--;
853
854 return 0;
855}
856
857
858
859
860static int pcan_usb_pro_init(struct peak_usb_device *dev)
861{
862 struct pcan_usb_pro_device *pdev =
863 container_of(dev, struct pcan_usb_pro_device, dev);
864 struct pcan_usb_pro_interface *usb_if = NULL;
865 struct pcan_usb_pro_fwinfo *fi = NULL;
866 struct pcan_usb_pro_blinfo *bi = NULL;
867 int err;
868
869
870 if (!dev->prev_siblings) {
871
872 usb_if = kzalloc(sizeof(struct pcan_usb_pro_interface),
873 GFP_KERNEL);
874 fi = kmalloc(sizeof(struct pcan_usb_pro_fwinfo), GFP_KERNEL);
875 bi = kmalloc(sizeof(struct pcan_usb_pro_blinfo), GFP_KERNEL);
876 if (!usb_if || !fi || !bi) {
877 err = -ENOMEM;
878 goto err_out;
879 }
880
881
882 usb_if->cm_ignore_count = 5;
883
884
885
886
887
888
889 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
890 PCAN_USBPRO_INFO_FW,
891 fi, sizeof(*fi));
892 if (err) {
893 dev_err(dev->netdev->dev.parent,
894 "unable to read %s firmware info (err %d)\n",
895 pcan_usb_pro.name, err);
896 goto err_out;
897 }
898
899 err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
900 PCAN_USBPRO_INFO_BL,
901 bi, sizeof(*bi));
902 if (err) {
903 dev_err(dev->netdev->dev.parent,
904 "unable to read %s bootloader info (err %d)\n",
905 pcan_usb_pro.name, err);
906 goto err_out;
907 }
908
909
910 err = pcan_usb_pro_drv_loaded(dev, 1);
911 if (err)
912 goto err_out;
913
914 dev_info(dev->netdev->dev.parent,
915 "PEAK-System %s hwrev %u serial %08X.%08X (%u channels)\n",
916 pcan_usb_pro.name,
917 bi->hw_rev, bi->serial_num_hi, bi->serial_num_lo,
918 pcan_usb_pro.ctrl_count);
919 } else {
920 usb_if = pcan_usb_pro_dev_if(dev->prev_siblings);
921 }
922
923 pdev->usb_if = usb_if;
924 usb_if->dev[dev->ctrl_idx] = dev;
925
926
927 pcan_usb_pro_set_led(dev, 0, 1);
928
929 kfree(bi);
930 kfree(fi);
931
932 return 0;
933
934 err_out:
935 kfree(bi);
936 kfree(fi);
937 kfree(usb_if);
938
939 return err;
940}
941
942static void pcan_usb_pro_exit(struct peak_usb_device *dev)
943{
944 struct pcan_usb_pro_device *pdev =
945 container_of(dev, struct pcan_usb_pro_device, dev);
946
947
948
949
950
951 if (dev->can.state != CAN_STATE_STOPPED) {
952
953 pcan_usb_pro_set_bus(dev, 0);
954 }
955
956
957 if (dev->ctrl_idx == 0) {
958
959 if (pdev->usb_if->dev_opened_count > 0)
960 pcan_usb_pro_set_ts(dev, 0);
961
962
963 pcan_usb_pro_drv_loaded(dev, 0);
964 }
965}
966
967
968
969
970static void pcan_usb_pro_free(struct peak_usb_device *dev)
971{
972
973 if (!dev->prev_siblings && !dev->next_siblings)
974 kfree(pcan_usb_pro_dev_if(dev));
975}
976
977
978
979
980static int pcan_usb_pro_probe(struct usb_interface *intf)
981{
982 struct usb_host_interface *if_desc;
983 int i;
984
985 if_desc = intf->altsetting;
986
987
988 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
989 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
990
991
992
993
994
995 switch (ep->bEndpointAddress) {
996 case PCAN_USBPRO_EP_CMDOUT:
997 case PCAN_USBPRO_EP_CMDIN:
998 case PCAN_USBPRO_EP_MSGOUT_0:
999 case PCAN_USBPRO_EP_MSGOUT_1:
1000 case PCAN_USBPRO_EP_MSGIN:
1001 case PCAN_USBPRO_EP_UNUSED:
1002 break;
1003 default:
1004 return -ENODEV;
1005 }
1006 }
1007
1008 return 0;
1009}
1010
1011
1012
1013
1014struct peak_usb_adapter pcan_usb_pro = {
1015 .name = "PCAN-USB Pro",
1016 .device_id = PCAN_USBPRO_PRODUCT_ID,
1017 .ctrl_count = PCAN_USBPRO_CHANNEL_COUNT,
1018 .clock = {
1019 .freq = PCAN_USBPRO_CRYSTAL_HZ,
1020 },
1021 .bittiming_const = {
1022 .name = "pcan_usb_pro",
1023 .tseg1_min = 1,
1024 .tseg1_max = 16,
1025 .tseg2_min = 1,
1026 .tseg2_max = 8,
1027 .sjw_max = 4,
1028 .brp_min = 1,
1029 .brp_max = 1024,
1030 .brp_inc = 1,
1031 },
1032
1033
1034 .sizeof_dev_private = sizeof(struct pcan_usb_pro_device),
1035
1036
1037 .ts_used_bits = 32,
1038 .ts_period = 1000000,
1039 .us_per_ts_scale = 1,
1040 .us_per_ts_shift = 0,
1041
1042
1043 .ep_msg_in = PCAN_USBPRO_EP_MSGIN,
1044 .ep_msg_out = {PCAN_USBPRO_EP_MSGOUT_0, PCAN_USBPRO_EP_MSGOUT_1},
1045
1046
1047 .rx_buffer_size = PCAN_USBPRO_RX_BUFFER_SIZE,
1048 .tx_buffer_size = PCAN_USBPRO_TX_BUFFER_SIZE,
1049
1050
1051 .intf_probe = pcan_usb_pro_probe,
1052 .dev_init = pcan_usb_pro_init,
1053 .dev_exit = pcan_usb_pro_exit,
1054 .dev_free = pcan_usb_pro_free,
1055 .dev_set_bus = pcan_usb_pro_set_bus,
1056 .dev_set_bittiming = pcan_usb_pro_set_bittiming,
1057 .dev_get_device_id = pcan_usb_pro_get_device_id,
1058 .dev_decode_buf = pcan_usb_pro_decode_buf,
1059 .dev_encode_msg = pcan_usb_pro_encode_msg,
1060 .dev_start = pcan_usb_pro_start,
1061 .dev_stop = pcan_usb_pro_stop,
1062 .dev_restart_async = pcan_usb_pro_restart_async,
1063};
1064
