1 /* 2 * CAN driver for PEAK System PCAN-USB Pro adapter 3 * Derived from the PCAN project file driver/src/pcan_usbpro.c 4 * 5 * Copyright (C) 2003-2011 PEAK System-Technik GmbH 6 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published 10 * by the Free Software Foundation; version 2 of the License. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 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 28 MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro adapter"); 29 30 /* PCAN-USB Pro Endpoints */ 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 /* PCAN-USB Pro adapter internal clock (MHz) */ 41 #define PCAN_USBPRO_CRYSTAL_HZ 56000000 42 43 /* PCAN-USB Pro command timeout (ms.) */ 44 #define PCAN_USBPRO_COMMAND_TIMEOUT 1000 45 46 /* PCAN-USB Pro rx/tx buffers size */ 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 /* some commands responses need to be re-submitted */ 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 /* handle device specific info used by the netdevices */ 61 struct 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 /* device information */ 69 struct 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 /* internal structure used to handle messages sent to bulk urb */ 76 struct 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 /* records sizes table indexed on message id. (8-bits value) */ 88 static 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 * initialize PCAN-USB Pro message data structure 109 */ 110 static 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 123 static 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 * add one record to a message being built 137 */ 138 static 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 * send PCAN-USB Pro command synchronously 217 */ 218 static 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 /* usb device unregistered? */ 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 * wait for PCAN-USB Pro command response 240 */ 241 static 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 /* usb device unregistered? */ 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 /* loop on records stored into message */ 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 /* check if response corresponds to request */ 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 /* check if channel in response corresponds too */ 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 /* got the response */ 314 else 315 return 0; 316 317 /* otherwise, go on with next record in message */ 318 pc += rec_len; 319 } 320 } 321 322 return (i >= PCAN_USBPRO_RSP_SUBMIT_MAX) ? -ERANGE : err; 323 } 324 325 static 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 /* usb device unregistered? */ 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 362 static 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 372 static 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 /* cache the CCBT value to reuse it before next buson */ 382 pdev->cached_ccbt = ccbt; 383 384 return pcan_usb_pro_send_cmd(dev, &um); 385 } 386 387 static int pcan_usb_pro_set_bus(struct peak_usb_device *dev, u8 onoff) 388 { 389 struct pcan_usb_pro_msg um; 390 391 /* if bus=on, be sure the bitrate being set before! */ 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 405 static 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 415 static 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 425 static 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 436 static 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 462 static 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; /* = tseg1 */ 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 478 static void pcan_usb_pro_restart_complete(struct urb *urb) 479 { 480 /* can delete usb resources */ 481 peak_usb_async_complete(urb); 482 483 /* notify candev and netdev */ 484 peak_usb_restart_complete(urb->context); 485 } 486 487 /* 488 * handle restart but in asynchronously way 489 */ 490 static 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 506 static 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 526 static inline 527 struct 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 534 static 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 571 static 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 /* nothing should be sent while in BUS_OFF state */ 586 if (dev->can.state == CAN_STATE_BUS_OFF) 587 return 0; 588 589 if (!raw_status) { 590 /* no error bit (back to active state) */ 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 /* trick to bypass next comparison and process other errors */ 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 /* donot post any error if current state didn't change */ 626 if (dev->can.state == new_state) 627 return 0; 628 629 /* allocate an skb to store the error frame */ 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 /* CAN_STATE_MAX (trick to handle other errors) */ 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 687 static void pcan_usb_pro_handle_ts(struct pcan_usb_pro_interface *usb_if, 688 struct pcan_usb_pro_rxts *ts) 689 { 690 /* should wait until clock is stabilized */ 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 * callback for bulk IN urb 700 */ 701 static 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 /* loop reading all the records from the incoming message */ 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 /* check if the record goes out of current packet */ 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 769 fail: 770 if (err) 771 pcan_dump_mem("received msg", 772 urb->transfer_buffer, urb->actual_length); 773 774 return err; 775 } 776 777 static 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 809 static 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 /* filter mode: 0-> All OFF; 1->bypass */ 821 err = pcan_usb_pro_set_filter(dev, 1); 822 if (err) 823 return err; 824 825 /* opening first device: */ 826 if (pdev->usb_if->dev_opened_count == 0) { 827 /* reset time_ref */ 828 peak_usb_init_time_ref(&pdev->usb_if->time_ref, &pcan_usb_pro); 829 830 /* ask device to send ts messages */ 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 * stop interface 841 * (last chance before set bus off) 842 */ 843 static 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 /* turn off ts msgs for that interface if no other dev opened */ 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 * called when probing to initialize a device object. 859 */ 860 static 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 /* do this for 1st channel only */ 870 if (!dev->prev_siblings) { 871 /* allocate netdevices common structure attached to first one */ 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 /* number of ts msgs to ignore before taking one into account */ 882 usb_if->cm_ignore_count = 5; 883 884 /* 885 * explicit use of dev_xxx() instead of netdev_xxx() here: 886 * information displayed are related to the device itself, not 887 * to the canx netdevices. 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 /* tell the device the can driver is running */ 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 /* set LED in default state (end of init phase) */ 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 942 static 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 * when rmmod called before unplug and if down, should reset things 949 * before leaving 950 */ 951 if (dev->can.state != CAN_STATE_STOPPED) { 952 /* set bus off on the corresponding channel */ 953 pcan_usb_pro_set_bus(dev, 0); 954 } 955 956 /* if channel #0 (only) */ 957 if (dev->ctrl_idx == 0) { 958 /* turn off calibration message if any device were opened */ 959 if (pdev->usb_if->dev_opened_count > 0) 960 pcan_usb_pro_set_ts(dev, 0); 961 962 /* tell the PCAN-USB Pro device the driver is being unloaded */ 963 pcan_usb_pro_drv_loaded(dev, 0); 964 } 965 } 966 967 /* 968 * called when PCAN-USB Pro adapter is unplugged 969 */ 970 static void pcan_usb_pro_free(struct peak_usb_device *dev) 971 { 972 /* last device: can free pcan_usb_pro_interface object now */ 973 if (!dev->prev_siblings && !dev->next_siblings) 974 kfree(pcan_usb_pro_dev_if(dev)); 975 } 976 977 /* 978 * probe function for new PCAN-USB Pro usb interface 979 */ 980 static 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 /* check interface endpoint addresses */ 988 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) { 989 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc; 990 991 /* 992 * below is the list of valid ep addreses. Any other ep address 993 * is considered as not-CAN interface address => no dev created 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 * describe the PCAN-USB Pro adapter 1013 */ 1014 struct 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 /* size of device private data */ 1034 .sizeof_dev_private = sizeof(struct pcan_usb_pro_device), 1035 1036 /* timestamps usage */ 1037 .ts_used_bits = 32, 1038 .ts_period = 1000000, /* calibration period in ts. */ 1039 .us_per_ts_scale = 1, /* us = (ts * scale) >> shift */ 1040 .us_per_ts_shift = 0, 1041 1042 /* give here messages in/out endpoints */ 1043 .ep_msg_in = PCAN_USBPRO_EP_MSGIN, 1044 .ep_msg_out = {PCAN_USBPRO_EP_MSGOUT_0, PCAN_USBPRO_EP_MSGOUT_1}, 1045 1046 /* size of rx/tx usb buffers */ 1047 .rx_buffer_size = PCAN_USBPRO_RX_BUFFER_SIZE, 1048 .tx_buffer_size = PCAN_USBPRO_TX_BUFFER_SIZE, 1049 1050 /* device callbacks */ 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