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