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