1 /* 2 * Janz MODULbus VMOD-ICAN3 CAN Interface Driver 3 * 4 * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation; either version 2 of the License, or (at your 9 * option) any later version. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/interrupt.h> 15 #include <linux/delay.h> 16 #include <linux/platform_device.h> 17 18 #include <linux/netdevice.h> 19 #include <linux/can.h> 20 #include <linux/can/dev.h> 21 #include <linux/can/skb.h> 22 #include <linux/can/error.h> 23 24 #include <linux/mfd/janz.h> 25 #include <asm/io.h> 26 27 /* the DPM has 64k of memory, organized into 256x 256 byte pages */ 28 #define DPM_NUM_PAGES 256 29 #define DPM_PAGE_SIZE 256 30 #define DPM_PAGE_ADDR(p) ((p) * DPM_PAGE_SIZE) 31 32 /* JANZ ICAN3 "old-style" host interface queue page numbers */ 33 #define QUEUE_OLD_CONTROL 0 34 #define QUEUE_OLD_RB0 1 35 #define QUEUE_OLD_RB1 2 36 #define QUEUE_OLD_WB0 3 37 #define QUEUE_OLD_WB1 4 38 39 /* Janz ICAN3 "old-style" host interface control registers */ 40 #define MSYNC_PEER 0x00 /* ICAN only */ 41 #define MSYNC_LOCL 0x01 /* host only */ 42 #define TARGET_RUNNING 0x02 43 #define FIRMWARE_STAMP 0x60 /* big endian firmware stamp */ 44 45 #define MSYNC_RB0 0x01 46 #define MSYNC_RB1 0x02 47 #define MSYNC_RBLW 0x04 48 #define MSYNC_RB_MASK (MSYNC_RB0 | MSYNC_RB1) 49 50 #define MSYNC_WB0 0x10 51 #define MSYNC_WB1 0x20 52 #define MSYNC_WBLW 0x40 53 #define MSYNC_WB_MASK (MSYNC_WB0 | MSYNC_WB1) 54 55 /* Janz ICAN3 "new-style" host interface queue page numbers */ 56 #define QUEUE_TOHOST 5 57 #define QUEUE_FROMHOST_MID 6 58 #define QUEUE_FROMHOST_HIGH 7 59 #define QUEUE_FROMHOST_LOW 8 60 61 /* The first free page in the DPM is #9 */ 62 #define DPM_FREE_START 9 63 64 /* Janz ICAN3 "new-style" and "fast" host interface descriptor flags */ 65 #define DESC_VALID 0x80 66 #define DESC_WRAP 0x40 67 #define DESC_INTERRUPT 0x20 68 #define DESC_IVALID 0x10 69 #define DESC_LEN(len) (len) 70 71 /* Janz ICAN3 Firmware Messages */ 72 #define MSG_CONNECTI 0x02 73 #define MSG_DISCONNECT 0x03 74 #define MSG_IDVERS 0x04 75 #define MSG_MSGLOST 0x05 76 #define MSG_NEWHOSTIF 0x08 77 #define MSG_INQUIRY 0x0a 78 #define MSG_SETAFILMASK 0x10 79 #define MSG_INITFDPMQUEUE 0x11 80 #define MSG_HWCONF 0x12 81 #define MSG_FMSGLOST 0x15 82 #define MSG_CEVTIND 0x37 83 #define MSG_CBTRREQ 0x41 84 #define MSG_COFFREQ 0x42 85 #define MSG_CONREQ 0x43 86 #define MSG_CCONFREQ 0x47 87 #define MSG_NMTS 0xb0 88 #define MSG_LMTS 0xb4 89 90 /* 91 * Janz ICAN3 CAN Inquiry Message Types 92 * 93 * NOTE: there appears to be a firmware bug here. You must send 94 * NOTE: INQUIRY_STATUS and expect to receive an INQUIRY_EXTENDED 95 * NOTE: response. The controller never responds to a message with 96 * NOTE: the INQUIRY_EXTENDED subspec :( 97 */ 98 #define INQUIRY_STATUS 0x00 99 #define INQUIRY_TERMINATION 0x01 100 #define INQUIRY_EXTENDED 0x04 101 102 /* Janz ICAN3 CAN Set Acceptance Filter Mask Message Types */ 103 #define SETAFILMASK_REJECT 0x00 104 #define SETAFILMASK_FASTIF 0x02 105 106 /* Janz ICAN3 CAN Hardware Configuration Message Types */ 107 #define HWCONF_TERMINATE_ON 0x01 108 #define HWCONF_TERMINATE_OFF 0x00 109 110 /* Janz ICAN3 CAN Event Indication Message Types */ 111 #define CEVTIND_EI 0x01 112 #define CEVTIND_DOI 0x02 113 #define CEVTIND_LOST 0x04 114 #define CEVTIND_FULL 0x08 115 #define CEVTIND_BEI 0x10 116 117 #define CEVTIND_CHIP_SJA1000 0x02 118 119 #define ICAN3_BUSERR_QUOTA_MAX 255 120 121 /* Janz ICAN3 CAN Frame Conversion */ 122 #define ICAN3_SNGL 0x02 123 #define ICAN3_ECHO 0x10 124 #define ICAN3_EFF_RTR 0x40 125 #define ICAN3_SFF_RTR 0x10 126 #define ICAN3_EFF 0x80 127 128 #define ICAN3_CAN_TYPE_MASK 0x0f 129 #define ICAN3_CAN_TYPE_SFF 0x00 130 #define ICAN3_CAN_TYPE_EFF 0x01 131 132 #define ICAN3_CAN_DLC_MASK 0x0f 133 134 /* Janz ICAN3 NMTS subtypes */ 135 #define NMTS_CREATE_NODE_REQ 0x0 136 #define NMTS_SLAVE_STATE_IND 0x8 137 #define NMTS_SLAVE_EVENT_IND 0x9 138 139 /* Janz ICAN3 LMTS subtypes */ 140 #define LMTS_BUSON_REQ 0x0 141 #define LMTS_BUSOFF_REQ 0x1 142 #define LMTS_CAN_CONF_REQ 0x2 143 144 /* Janz ICAN3 NMTS Event indications */ 145 #define NE_LOCAL_OCCURRED 0x3 146 #define NE_LOCAL_RESOLVED 0x2 147 #define NE_REMOTE_OCCURRED 0xc 148 #define NE_REMOTE_RESOLVED 0x8 149 150 /* 151 * SJA1000 Status and Error Register Definitions 152 * 153 * Copied from drivers/net/can/sja1000/sja1000.h 154 */ 155 156 /* status register content */ 157 #define SR_BS 0x80 158 #define SR_ES 0x40 159 #define SR_TS 0x20 160 #define SR_RS 0x10 161 #define SR_TCS 0x08 162 #define SR_TBS 0x04 163 #define SR_DOS 0x02 164 #define SR_RBS 0x01 165 166 #define SR_CRIT (SR_BS|SR_ES) 167 168 /* ECC register */ 169 #define ECC_SEG 0x1F 170 #define ECC_DIR 0x20 171 #define ECC_ERR 6 172 #define ECC_BIT 0x00 173 #define ECC_FORM 0x40 174 #define ECC_STUFF 0x80 175 #define ECC_MASK 0xc0 176 177 /* Number of buffers for use in the "new-style" host interface */ 178 #define ICAN3_NEW_BUFFERS 16 179 180 /* Number of buffers for use in the "fast" host interface */ 181 #define ICAN3_TX_BUFFERS 512 182 #define ICAN3_RX_BUFFERS 1024 183 184 /* SJA1000 Clock Input */ 185 #define ICAN3_CAN_CLOCK 8000000 186 187 /* Janz ICAN3 firmware types */ 188 enum ican3_fwtype { 189 ICAN3_FWTYPE_ICANOS, 190 ICAN3_FWTYPE_CAL_CANOPEN, 191 }; 192 193 /* Driver Name */ 194 #define DRV_NAME "janz-ican3" 195 196 /* DPM Control Registers -- starts at offset 0x100 in the MODULbus registers */ 197 struct ican3_dpm_control { 198 /* window address register */ 199 u8 window_address; 200 u8 unused1; 201 202 /* 203 * Read access: clear interrupt from microcontroller 204 * Write access: send interrupt to microcontroller 205 */ 206 u8 interrupt; 207 u8 unused2; 208 209 /* write-only: reset all hardware on the module */ 210 u8 hwreset; 211 u8 unused3; 212 213 /* write-only: generate an interrupt to the TPU */ 214 u8 tpuinterrupt; 215 }; 216 217 struct ican3_dev { 218 219 /* must be the first member */ 220 struct can_priv can; 221 222 /* CAN network device */ 223 struct net_device *ndev; 224 struct napi_struct napi; 225 226 /* module number */ 227 unsigned int num; 228 229 /* base address of registers and IRQ */ 230 struct janz_cmodio_onboard_regs __iomem *ctrl; 231 struct ican3_dpm_control __iomem *dpmctrl; 232 void __iomem *dpm; 233 int irq; 234 235 /* CAN bus termination status */ 236 struct completion termination_comp; 237 bool termination_enabled; 238 239 /* CAN bus error status registers */ 240 struct completion buserror_comp; 241 struct can_berr_counter bec; 242 243 /* firmware type */ 244 enum ican3_fwtype fwtype; 245 char fwinfo[32]; 246 247 /* old and new style host interface */ 248 unsigned int iftype; 249 250 /* queue for echo packets */ 251 struct sk_buff_head echoq; 252 253 /* 254 * Any function which changes the current DPM page must hold this 255 * lock while it is performing data accesses. This ensures that the 256 * function will not be preempted and end up reading data from a 257 * different DPM page than it expects. 258 */ 259 spinlock_t lock; 260 261 /* new host interface */ 262 unsigned int rx_int; 263 unsigned int rx_num; 264 unsigned int tx_num; 265 266 /* fast host interface */ 267 unsigned int fastrx_start; 268 unsigned int fastrx_num; 269 unsigned int fasttx_start; 270 unsigned int fasttx_num; 271 272 /* first free DPM page */ 273 unsigned int free_page; 274 }; 275 276 struct ican3_msg { 277 u8 control; 278 u8 spec; 279 __le16 len; 280 u8 data[252]; 281 }; 282 283 struct ican3_new_desc { 284 u8 control; 285 u8 pointer; 286 }; 287 288 struct ican3_fast_desc { 289 u8 control; 290 u8 command; 291 u8 data[14]; 292 }; 293 294 /* write to the window basic address register */ 295 static inline void ican3_set_page(struct ican3_dev *mod, unsigned int page) 296 { 297 BUG_ON(page >= DPM_NUM_PAGES); 298 iowrite8(page, &mod->dpmctrl->window_address); 299 } 300 301 /* 302 * ICAN3 "old-style" host interface 303 */ 304 305 /* 306 * Receive a message from the ICAN3 "old-style" firmware interface 307 * 308 * LOCKING: must hold mod->lock 309 * 310 * returns 0 on success, -ENOMEM when no message exists 311 */ 312 static int ican3_old_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg) 313 { 314 unsigned int mbox, mbox_page; 315 u8 locl, peer, xord; 316 317 /* get the MSYNC registers */ 318 ican3_set_page(mod, QUEUE_OLD_CONTROL); 319 peer = ioread8(mod->dpm + MSYNC_PEER); 320 locl = ioread8(mod->dpm + MSYNC_LOCL); 321 xord = locl ^ peer; 322 323 if ((xord & MSYNC_RB_MASK) == 0x00) { 324 netdev_dbg(mod->ndev, "no mbox for reading\n"); 325 return -ENOMEM; 326 } 327 328 /* find the first free mbox to read */ 329 if ((xord & MSYNC_RB_MASK) == MSYNC_RB_MASK) 330 mbox = (xord & MSYNC_RBLW) ? MSYNC_RB0 : MSYNC_RB1; 331 else 332 mbox = (xord & MSYNC_RB0) ? MSYNC_RB0 : MSYNC_RB1; 333 334 /* copy the message */ 335 mbox_page = (mbox == MSYNC_RB0) ? QUEUE_OLD_RB0 : QUEUE_OLD_RB1; 336 ican3_set_page(mod, mbox_page); 337 memcpy_fromio(msg, mod->dpm, sizeof(*msg)); 338 339 /* 340 * notify the firmware that the read buffer is available 341 * for it to fill again 342 */ 343 locl ^= mbox; 344 345 ican3_set_page(mod, QUEUE_OLD_CONTROL); 346 iowrite8(locl, mod->dpm + MSYNC_LOCL); 347 return 0; 348 } 349 350 /* 351 * Send a message through the "old-style" firmware interface 352 * 353 * LOCKING: must hold mod->lock 354 * 355 * returns 0 on success, -ENOMEM when no free space exists 356 */ 357 static int ican3_old_send_msg(struct ican3_dev *mod, struct ican3_msg *msg) 358 { 359 unsigned int mbox, mbox_page; 360 u8 locl, peer, xord; 361 362 /* get the MSYNC registers */ 363 ican3_set_page(mod, QUEUE_OLD_CONTROL); 364 peer = ioread8(mod->dpm + MSYNC_PEER); 365 locl = ioread8(mod->dpm + MSYNC_LOCL); 366 xord = locl ^ peer; 367 368 if ((xord & MSYNC_WB_MASK) == MSYNC_WB_MASK) { 369 netdev_err(mod->ndev, "no mbox for writing\n"); 370 return -ENOMEM; 371 } 372 373 /* calculate a free mbox to use */ 374 mbox = (xord & MSYNC_WB0) ? MSYNC_WB1 : MSYNC_WB0; 375 376 /* copy the message to the DPM */ 377 mbox_page = (mbox == MSYNC_WB0) ? QUEUE_OLD_WB0 : QUEUE_OLD_WB1; 378 ican3_set_page(mod, mbox_page); 379 memcpy_toio(mod->dpm, msg, sizeof(*msg)); 380 381 locl ^= mbox; 382 if (mbox == MSYNC_WB1) 383 locl |= MSYNC_WBLW; 384 385 ican3_set_page(mod, QUEUE_OLD_CONTROL); 386 iowrite8(locl, mod->dpm + MSYNC_LOCL); 387 return 0; 388 } 389 390 /* 391 * ICAN3 "new-style" Host Interface Setup 392 */ 393 394 static void ican3_init_new_host_interface(struct ican3_dev *mod) 395 { 396 struct ican3_new_desc desc; 397 unsigned long flags; 398 void __iomem *dst; 399 int i; 400 401 spin_lock_irqsave(&mod->lock, flags); 402 403 /* setup the internal datastructures for RX */ 404 mod->rx_num = 0; 405 mod->rx_int = 0; 406 407 /* tohost queue descriptors are in page 5 */ 408 ican3_set_page(mod, QUEUE_TOHOST); 409 dst = mod->dpm; 410 411 /* initialize the tohost (rx) queue descriptors: pages 9-24 */ 412 for (i = 0; i < ICAN3_NEW_BUFFERS; i++) { 413 desc.control = DESC_INTERRUPT | DESC_LEN(1); /* I L=1 */ 414 desc.pointer = mod->free_page; 415 416 /* set wrap flag on last buffer */ 417 if (i == ICAN3_NEW_BUFFERS - 1) 418 desc.control |= DESC_WRAP; 419 420 memcpy_toio(dst, &desc, sizeof(desc)); 421 dst += sizeof(desc); 422 mod->free_page++; 423 } 424 425 /* fromhost (tx) mid queue descriptors are in page 6 */ 426 ican3_set_page(mod, QUEUE_FROMHOST_MID); 427 dst = mod->dpm; 428 429 /* setup the internal datastructures for TX */ 430 mod->tx_num = 0; 431 432 /* initialize the fromhost mid queue descriptors: pages 25-40 */ 433 for (i = 0; i < ICAN3_NEW_BUFFERS; i++) { 434 desc.control = DESC_VALID | DESC_LEN(1); /* V L=1 */ 435 desc.pointer = mod->free_page; 436 437 /* set wrap flag on last buffer */ 438 if (i == ICAN3_NEW_BUFFERS - 1) 439 desc.control |= DESC_WRAP; 440 441 memcpy_toio(dst, &desc, sizeof(desc)); 442 dst += sizeof(desc); 443 mod->free_page++; 444 } 445 446 /* fromhost hi queue descriptors are in page 7 */ 447 ican3_set_page(mod, QUEUE_FROMHOST_HIGH); 448 dst = mod->dpm; 449 450 /* initialize only a single buffer in the fromhost hi queue (unused) */ 451 desc.control = DESC_VALID | DESC_WRAP | DESC_LEN(1); /* VW L=1 */ 452 desc.pointer = mod->free_page; 453 memcpy_toio(dst, &desc, sizeof(desc)); 454 mod->free_page++; 455 456 /* fromhost low queue descriptors are in page 8 */ 457 ican3_set_page(mod, QUEUE_FROMHOST_LOW); 458 dst = mod->dpm; 459 460 /* initialize only a single buffer in the fromhost low queue (unused) */ 461 desc.control = DESC_VALID | DESC_WRAP | DESC_LEN(1); /* VW L=1 */ 462 desc.pointer = mod->free_page; 463 memcpy_toio(dst, &desc, sizeof(desc)); 464 mod->free_page++; 465 466 spin_unlock_irqrestore(&mod->lock, flags); 467 } 468 469 /* 470 * ICAN3 Fast Host Interface Setup 471 */ 472 473 static void ican3_init_fast_host_interface(struct ican3_dev *mod) 474 { 475 struct ican3_fast_desc desc; 476 unsigned long flags; 477 unsigned int addr; 478 void __iomem *dst; 479 int i; 480 481 spin_lock_irqsave(&mod->lock, flags); 482 483 /* save the start recv page */ 484 mod->fastrx_start = mod->free_page; 485 mod->fastrx_num = 0; 486 487 /* build a single fast tohost queue descriptor */ 488 memset(&desc, 0, sizeof(desc)); 489 desc.control = 0x00; 490 desc.command = 1; 491 492 /* build the tohost queue descriptor ring in memory */ 493 addr = 0; 494 for (i = 0; i < ICAN3_RX_BUFFERS; i++) { 495 496 /* set the wrap bit on the last buffer */ 497 if (i == ICAN3_RX_BUFFERS - 1) 498 desc.control |= DESC_WRAP; 499 500 /* switch to the correct page */ 501 ican3_set_page(mod, mod->free_page); 502 503 /* copy the descriptor to the DPM */ 504 dst = mod->dpm + addr; 505 memcpy_toio(dst, &desc, sizeof(desc)); 506 addr += sizeof(desc); 507 508 /* move to the next page if necessary */ 509 if (addr >= DPM_PAGE_SIZE) { 510 addr = 0; 511 mod->free_page++; 512 } 513 } 514 515 /* make sure we page-align the next queue */ 516 if (addr != 0) 517 mod->free_page++; 518 519 /* save the start xmit page */ 520 mod->fasttx_start = mod->free_page; 521 mod->fasttx_num = 0; 522 523 /* build a single fast fromhost queue descriptor */ 524 memset(&desc, 0, sizeof(desc)); 525 desc.control = DESC_VALID; 526 desc.command = 1; 527 528 /* build the fromhost queue descriptor ring in memory */ 529 addr = 0; 530 for (i = 0; i < ICAN3_TX_BUFFERS; i++) { 531 532 /* set the wrap bit on the last buffer */ 533 if (i == ICAN3_TX_BUFFERS - 1) 534 desc.control |= DESC_WRAP; 535 536 /* switch to the correct page */ 537 ican3_set_page(mod, mod->free_page); 538 539 /* copy the descriptor to the DPM */ 540 dst = mod->dpm + addr; 541 memcpy_toio(dst, &desc, sizeof(desc)); 542 addr += sizeof(desc); 543 544 /* move to the next page if necessary */ 545 if (addr >= DPM_PAGE_SIZE) { 546 addr = 0; 547 mod->free_page++; 548 } 549 } 550 551 spin_unlock_irqrestore(&mod->lock, flags); 552 } 553 554 /* 555 * ICAN3 "new-style" Host Interface Message Helpers 556 */ 557 558 /* 559 * LOCKING: must hold mod->lock 560 */ 561 static int ican3_new_send_msg(struct ican3_dev *mod, struct ican3_msg *msg) 562 { 563 struct ican3_new_desc desc; 564 void __iomem *desc_addr = mod->dpm + (mod->tx_num * sizeof(desc)); 565 566 /* switch to the fromhost mid queue, and read the buffer descriptor */ 567 ican3_set_page(mod, QUEUE_FROMHOST_MID); 568 memcpy_fromio(&desc, desc_addr, sizeof(desc)); 569 570 if (!(desc.control & DESC_VALID)) { 571 netdev_dbg(mod->ndev, "%s: no free buffers\n", __func__); 572 return -ENOMEM; 573 } 574 575 /* switch to the data page, copy the data */ 576 ican3_set_page(mod, desc.pointer); 577 memcpy_toio(mod->dpm, msg, sizeof(*msg)); 578 579 /* switch back to the descriptor, set the valid bit, write it back */ 580 ican3_set_page(mod, QUEUE_FROMHOST_MID); 581 desc.control ^= DESC_VALID; 582 memcpy_toio(desc_addr, &desc, sizeof(desc)); 583 584 /* update the tx number */ 585 mod->tx_num = (desc.control & DESC_WRAP) ? 0 : (mod->tx_num + 1); 586 return 0; 587 } 588 589 /* 590 * LOCKING: must hold mod->lock 591 */ 592 static int ican3_new_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg) 593 { 594 struct ican3_new_desc desc; 595 void __iomem *desc_addr = mod->dpm + (mod->rx_num * sizeof(desc)); 596 597 /* switch to the tohost queue, and read the buffer descriptor */ 598 ican3_set_page(mod, QUEUE_TOHOST); 599 memcpy_fromio(&desc, desc_addr, sizeof(desc)); 600 601 if (!(desc.control & DESC_VALID)) { 602 netdev_dbg(mod->ndev, "%s: no buffers to recv\n", __func__); 603 return -ENOMEM; 604 } 605 606 /* switch to the data page, copy the data */ 607 ican3_set_page(mod, desc.pointer); 608 memcpy_fromio(msg, mod->dpm, sizeof(*msg)); 609 610 /* switch back to the descriptor, toggle the valid bit, write it back */ 611 ican3_set_page(mod, QUEUE_TOHOST); 612 desc.control ^= DESC_VALID; 613 memcpy_toio(desc_addr, &desc, sizeof(desc)); 614 615 /* update the rx number */ 616 mod->rx_num = (desc.control & DESC_WRAP) ? 0 : (mod->rx_num + 1); 617 return 0; 618 } 619 620 /* 621 * Message Send / Recv Helpers 622 */ 623 624 static int ican3_send_msg(struct ican3_dev *mod, struct ican3_msg *msg) 625 { 626 unsigned long flags; 627 int ret; 628 629 spin_lock_irqsave(&mod->lock, flags); 630 631 if (mod->iftype == 0) 632 ret = ican3_old_send_msg(mod, msg); 633 else 634 ret = ican3_new_send_msg(mod, msg); 635 636 spin_unlock_irqrestore(&mod->lock, flags); 637 return ret; 638 } 639 640 static int ican3_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg) 641 { 642 unsigned long flags; 643 int ret; 644 645 spin_lock_irqsave(&mod->lock, flags); 646 647 if (mod->iftype == 0) 648 ret = ican3_old_recv_msg(mod, msg); 649 else 650 ret = ican3_new_recv_msg(mod, msg); 651 652 spin_unlock_irqrestore(&mod->lock, flags); 653 return ret; 654 } 655 656 /* 657 * Quick Pre-constructed Messages 658 */ 659 660 static int ican3_msg_connect(struct ican3_dev *mod) 661 { 662 struct ican3_msg msg; 663 664 memset(&msg, 0, sizeof(msg)); 665 msg.spec = MSG_CONNECTI; 666 msg.len = cpu_to_le16(0); 667 668 return ican3_send_msg(mod, &msg); 669 } 670 671 static int ican3_msg_disconnect(struct ican3_dev *mod) 672 { 673 struct ican3_msg msg; 674 675 memset(&msg, 0, sizeof(msg)); 676 msg.spec = MSG_DISCONNECT; 677 msg.len = cpu_to_le16(0); 678 679 return ican3_send_msg(mod, &msg); 680 } 681 682 static int ican3_msg_newhostif(struct ican3_dev *mod) 683 { 684 struct ican3_msg msg; 685 int ret; 686 687 memset(&msg, 0, sizeof(msg)); 688 msg.spec = MSG_NEWHOSTIF; 689 msg.len = cpu_to_le16(0); 690 691 /* If we're not using the old interface, switching seems bogus */ 692 WARN_ON(mod->iftype != 0); 693 694 ret = ican3_send_msg(mod, &msg); 695 if (ret) 696 return ret; 697 698 /* mark the module as using the new host interface */ 699 mod->iftype = 1; 700 return 0; 701 } 702 703 static int ican3_msg_fasthostif(struct ican3_dev *mod) 704 { 705 struct ican3_msg msg; 706 unsigned int addr; 707 708 memset(&msg, 0, sizeof(msg)); 709 msg.spec = MSG_INITFDPMQUEUE; 710 msg.len = cpu_to_le16(8); 711 712 /* write the tohost queue start address */ 713 addr = DPM_PAGE_ADDR(mod->fastrx_start); 714 msg.data[0] = addr & 0xff; 715 msg.data[1] = (addr >> 8) & 0xff; 716 msg.data[2] = (addr >> 16) & 0xff; 717 msg.data[3] = (addr >> 24) & 0xff; 718 719 /* write the fromhost queue start address */ 720 addr = DPM_PAGE_ADDR(mod->fasttx_start); 721 msg.data[4] = addr & 0xff; 722 msg.data[5] = (addr >> 8) & 0xff; 723 msg.data[6] = (addr >> 16) & 0xff; 724 msg.data[7] = (addr >> 24) & 0xff; 725 726 /* If we're not using the new interface yet, we cannot do this */ 727 WARN_ON(mod->iftype != 1); 728 729 return ican3_send_msg(mod, &msg); 730 } 731 732 /* 733 * Setup the CAN filter to either accept or reject all 734 * messages from the CAN bus. 735 */ 736 static int ican3_set_id_filter(struct ican3_dev *mod, bool accept) 737 { 738 struct ican3_msg msg; 739 int ret; 740 741 /* Standard Frame Format */ 742 memset(&msg, 0, sizeof(msg)); 743 msg.spec = MSG_SETAFILMASK; 744 msg.len = cpu_to_le16(5); 745 msg.data[0] = 0x00; /* IDLo LSB */ 746 msg.data[1] = 0x00; /* IDLo MSB */ 747 msg.data[2] = 0xff; /* IDHi LSB */ 748 msg.data[3] = 0x07; /* IDHi MSB */ 749 750 /* accept all frames for fast host if, or reject all frames */ 751 msg.data[4] = accept ? SETAFILMASK_FASTIF : SETAFILMASK_REJECT; 752 753 ret = ican3_send_msg(mod, &msg); 754 if (ret) 755 return ret; 756 757 /* Extended Frame Format */ 758 memset(&msg, 0, sizeof(msg)); 759 msg.spec = MSG_SETAFILMASK; 760 msg.len = cpu_to_le16(13); 761 msg.data[0] = 0; /* MUX = 0 */ 762 msg.data[1] = 0x00; /* IDLo LSB */ 763 msg.data[2] = 0x00; 764 msg.data[3] = 0x00; 765 msg.data[4] = 0x20; /* IDLo MSB */ 766 msg.data[5] = 0xff; /* IDHi LSB */ 767 msg.data[6] = 0xff; 768 msg.data[7] = 0xff; 769 msg.data[8] = 0x3f; /* IDHi MSB */ 770 771 /* accept all frames for fast host if, or reject all frames */ 772 msg.data[9] = accept ? SETAFILMASK_FASTIF : SETAFILMASK_REJECT; 773 774 return ican3_send_msg(mod, &msg); 775 } 776 777 /* 778 * Bring the CAN bus online or offline 779 */ 780 static int ican3_set_bus_state(struct ican3_dev *mod, bool on) 781 { 782 struct can_bittiming *bt = &mod->can.bittiming; 783 struct ican3_msg msg; 784 u8 btr0, btr1; 785 int res; 786 787 /* This algorithm was stolen from drivers/net/can/sja1000/sja1000.c */ 788 /* The bittiming register command for the ICAN3 just sets the bit timing */ 789 /* registers on the SJA1000 chip directly */ 790 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6); 791 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) | 792 (((bt->phase_seg2 - 1) & 0x7) << 4); 793 if (mod->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 794 btr1 |= 0x80; 795 796 if (mod->fwtype == ICAN3_FWTYPE_ICANOS) { 797 if (on) { 798 /* set bittiming */ 799 memset(&msg, 0, sizeof(msg)); 800 msg.spec = MSG_CBTRREQ; 801 msg.len = cpu_to_le16(4); 802 msg.data[0] = 0x00; 803 msg.data[1] = 0x00; 804 msg.data[2] = btr0; 805 msg.data[3] = btr1; 806 807 res = ican3_send_msg(mod, &msg); 808 if (res) 809 return res; 810 } 811 812 /* can-on/off request */ 813 memset(&msg, 0, sizeof(msg)); 814 msg.spec = on ? MSG_CONREQ : MSG_COFFREQ; 815 msg.len = cpu_to_le16(0); 816 817 return ican3_send_msg(mod, &msg); 818 819 } else if (mod->fwtype == ICAN3_FWTYPE_CAL_CANOPEN) { 820 /* bittiming + can-on/off request */ 821 memset(&msg, 0, sizeof(msg)); 822 msg.spec = MSG_LMTS; 823 if (on) { 824 msg.len = cpu_to_le16(4); 825 msg.data[0] = LMTS_BUSON_REQ; 826 msg.data[1] = 0; 827 msg.data[2] = btr0; 828 msg.data[3] = btr1; 829 } else { 830 msg.len = cpu_to_le16(2); 831 msg.data[0] = LMTS_BUSOFF_REQ; 832 msg.data[1] = 0; 833 } 834 res = ican3_send_msg(mod, &msg); 835 if (res) 836 return res; 837 838 if (on) { 839 /* create NMT Slave Node for error processing 840 * class 2 (with error capability, see CiA/DS203-1) 841 * id 1 842 * name locnod1 (must be exactly 7 bytes) 843 */ 844 memset(&msg, 0, sizeof(msg)); 845 msg.spec = MSG_NMTS; 846 msg.len = cpu_to_le16(11); 847 msg.data[0] = NMTS_CREATE_NODE_REQ; 848 msg.data[1] = 0; 849 msg.data[2] = 2; /* node class */ 850 msg.data[3] = 1; /* node id */ 851 strcpy(msg.data + 4, "locnod1"); /* node name */ 852 return ican3_send_msg(mod, &msg); 853 } 854 return 0; 855 } 856 return -ENOTSUPP; 857 } 858 859 static int ican3_set_termination(struct ican3_dev *mod, bool on) 860 { 861 struct ican3_msg msg; 862 863 memset(&msg, 0, sizeof(msg)); 864 msg.spec = MSG_HWCONF; 865 msg.len = cpu_to_le16(2); 866 msg.data[0] = 0x00; 867 msg.data[1] = on ? HWCONF_TERMINATE_ON : HWCONF_TERMINATE_OFF; 868 869 return ican3_send_msg(mod, &msg); 870 } 871 872 static int ican3_send_inquiry(struct ican3_dev *mod, u8 subspec) 873 { 874 struct ican3_msg msg; 875 876 memset(&msg, 0, sizeof(msg)); 877 msg.spec = MSG_INQUIRY; 878 msg.len = cpu_to_le16(2); 879 msg.data[0] = subspec; 880 msg.data[1] = 0x00; 881 882 return ican3_send_msg(mod, &msg); 883 } 884 885 static int ican3_set_buserror(struct ican3_dev *mod, u8 quota) 886 { 887 struct ican3_msg msg; 888 889 if (mod->fwtype == ICAN3_FWTYPE_ICANOS) { 890 memset(&msg, 0, sizeof(msg)); 891 msg.spec = MSG_CCONFREQ; 892 msg.len = cpu_to_le16(2); 893 msg.data[0] = 0x00; 894 msg.data[1] = quota; 895 } else if (mod->fwtype == ICAN3_FWTYPE_CAL_CANOPEN) { 896 memset(&msg, 0, sizeof(msg)); 897 msg.spec = MSG_LMTS; 898 msg.len = cpu_to_le16(4); 899 msg.data[0] = LMTS_CAN_CONF_REQ; 900 msg.data[1] = 0x00; 901 msg.data[2] = 0x00; 902 msg.data[3] = quota; 903 } else { 904 return -ENOTSUPP; 905 } 906 return ican3_send_msg(mod, &msg); 907 } 908 909 /* 910 * ICAN3 to Linux CAN Frame Conversion 911 */ 912 913 static void ican3_to_can_frame(struct ican3_dev *mod, 914 struct ican3_fast_desc *desc, 915 struct can_frame *cf) 916 { 917 if ((desc->command & ICAN3_CAN_TYPE_MASK) == ICAN3_CAN_TYPE_SFF) { 918 if (desc->data[1] & ICAN3_SFF_RTR) 919 cf->can_id |= CAN_RTR_FLAG; 920 921 cf->can_id |= desc->data[0] << 3; 922 cf->can_id |= (desc->data[1] & 0xe0) >> 5; 923 cf->can_dlc = get_can_dlc(desc->data[1] & ICAN3_CAN_DLC_MASK); 924 memcpy(cf->data, &desc->data[2], cf->can_dlc); 925 } else { 926 cf->can_dlc = get_can_dlc(desc->data[0] & ICAN3_CAN_DLC_MASK); 927 if (desc->data[0] & ICAN3_EFF_RTR) 928 cf->can_id |= CAN_RTR_FLAG; 929 930 if (desc->data[0] & ICAN3_EFF) { 931 cf->can_id |= CAN_EFF_FLAG; 932 cf->can_id |= desc->data[2] << 21; /* 28-21 */ 933 cf->can_id |= desc->data[3] << 13; /* 20-13 */ 934 cf->can_id |= desc->data[4] << 5; /* 12-5 */ 935 cf->can_id |= (desc->data[5] & 0xf8) >> 3; 936 } else { 937 cf->can_id |= desc->data[2] << 3; /* 10-3 */ 938 cf->can_id |= desc->data[3] >> 5; /* 2-0 */ 939 } 940 941 memcpy(cf->data, &desc->data[6], cf->can_dlc); 942 } 943 } 944 945 static void can_frame_to_ican3(struct ican3_dev *mod, 946 struct can_frame *cf, 947 struct ican3_fast_desc *desc) 948 { 949 /* clear out any stale data in the descriptor */ 950 memset(desc->data, 0, sizeof(desc->data)); 951 952 /* we always use the extended format, with the ECHO flag set */ 953 desc->command = ICAN3_CAN_TYPE_EFF; 954 desc->data[0] |= cf->can_dlc; 955 desc->data[1] |= ICAN3_ECHO; 956 957 /* support single transmission (no retries) mode */ 958 if (mod->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 959 desc->data[1] |= ICAN3_SNGL; 960 961 if (cf->can_id & CAN_RTR_FLAG) 962 desc->data[0] |= ICAN3_EFF_RTR; 963 964 /* pack the id into the correct places */ 965 if (cf->can_id & CAN_EFF_FLAG) { 966 desc->data[0] |= ICAN3_EFF; 967 desc->data[2] = (cf->can_id & 0x1fe00000) >> 21; /* 28-21 */ 968 desc->data[3] = (cf->can_id & 0x001fe000) >> 13; /* 20-13 */ 969 desc->data[4] = (cf->can_id & 0x00001fe0) >> 5; /* 12-5 */ 970 desc->data[5] = (cf->can_id & 0x0000001f) << 3; /* 4-0 */ 971 } else { 972 desc->data[2] = (cf->can_id & 0x7F8) >> 3; /* bits 10-3 */ 973 desc->data[3] = (cf->can_id & 0x007) << 5; /* bits 2-0 */ 974 } 975 976 /* copy the data bits into the descriptor */ 977 memcpy(&desc->data[6], cf->data, cf->can_dlc); 978 } 979 980 /* 981 * Interrupt Handling 982 */ 983 984 /* 985 * Handle an ID + Version message response from the firmware. We never generate 986 * this message in production code, but it is very useful when debugging to be 987 * able to display this message. 988 */ 989 static void ican3_handle_idvers(struct ican3_dev *mod, struct ican3_msg *msg) 990 { 991 netdev_dbg(mod->ndev, "IDVERS response: %s\n", msg->data); 992 } 993 994 static void ican3_handle_msglost(struct ican3_dev *mod, struct ican3_msg *msg) 995 { 996 struct net_device *dev = mod->ndev; 997 struct net_device_stats *stats = &dev->stats; 998 struct can_frame *cf; 999 struct sk_buff *skb; 1000 1001 /* 1002 * Report that communication messages with the microcontroller firmware 1003 * are being lost. These are never CAN frames, so we do not generate an 1004 * error frame for userspace 1005 */ 1006 if (msg->spec == MSG_MSGLOST) { 1007 netdev_err(mod->ndev, "lost %d control messages\n", msg->data[0]); 1008 return; 1009 } 1010 1011 /* 1012 * Oops, this indicates that we have lost messages in the fast queue, 1013 * which are exclusively CAN messages. Our driver isn't reading CAN 1014 * frames fast enough. 1015 * 1016 * We'll pretend that the SJA1000 told us that it ran out of buffer 1017 * space, because there is not a better message for this. 1018 */ 1019 skb = alloc_can_err_skb(dev, &cf); 1020 if (skb) { 1021 cf->can_id |= CAN_ERR_CRTL; 1022 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 1023 stats->rx_over_errors++; 1024 stats->rx_errors++; 1025 netif_rx(skb); 1026 } 1027 } 1028 1029 /* 1030 * Handle CAN Event Indication Messages from the firmware 1031 * 1032 * The ICAN3 firmware provides the values of some SJA1000 registers when it 1033 * generates this message. The code below is largely copied from the 1034 * drivers/net/can/sja1000/sja1000.c file, and adapted as necessary 1035 */ 1036 static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg) 1037 { 1038 struct net_device *dev = mod->ndev; 1039 struct net_device_stats *stats = &dev->stats; 1040 enum can_state state = mod->can.state; 1041 u8 isrc, ecc, status, rxerr, txerr; 1042 struct can_frame *cf; 1043 struct sk_buff *skb; 1044 1045 /* we can only handle the SJA1000 part */ 1046 if (msg->data[1] != CEVTIND_CHIP_SJA1000) { 1047 netdev_err(mod->ndev, "unable to handle errors on non-SJA1000\n"); 1048 return -ENODEV; 1049 } 1050 1051 /* check the message length for sanity */ 1052 if (le16_to_cpu(msg->len) < 6) { 1053 netdev_err(mod->ndev, "error message too short\n"); 1054 return -EINVAL; 1055 } 1056 1057 isrc = msg->data[0]; 1058 ecc = msg->data[2]; 1059 status = msg->data[3]; 1060 rxerr = msg->data[4]; 1061 txerr = msg->data[5]; 1062 1063 /* 1064 * This hardware lacks any support other than bus error messages to 1065 * determine if packet transmission has failed. 1066 * 1067 * When TX errors happen, one echo skb needs to be dropped from the 1068 * front of the queue. 1069 * 1070 * A small bit of code is duplicated here and below, to avoid error 1071 * skb allocation when it will just be freed immediately. 1072 */ 1073 if (isrc == CEVTIND_BEI) { 1074 int ret; 1075 netdev_dbg(mod->ndev, "bus error interrupt\n"); 1076 1077 /* TX error */ 1078 if (!(ecc & ECC_DIR)) { 1079 kfree_skb(skb_dequeue(&mod->echoq)); 1080 stats->tx_errors++; 1081 } else { 1082 stats->rx_errors++; 1083 } 1084 1085 /* 1086 * The controller automatically disables bus-error interrupts 1087 * and therefore we must re-enable them. 1088 */ 1089 ret = ican3_set_buserror(mod, 1); 1090 if (ret) { 1091 netdev_err(mod->ndev, "unable to re-enable bus-error\n"); 1092 return ret; 1093 } 1094 1095 /* bus error reporting is off, return immediately */ 1096 if (!(mod->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)) 1097 return 0; 1098 } 1099 1100 skb = alloc_can_err_skb(dev, &cf); 1101 if (skb == NULL) 1102 return -ENOMEM; 1103 1104 /* data overrun interrupt */ 1105 if (isrc == CEVTIND_DOI || isrc == CEVTIND_LOST) { 1106 netdev_dbg(mod->ndev, "data overrun interrupt\n"); 1107 cf->can_id |= CAN_ERR_CRTL; 1108 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 1109 stats->rx_over_errors++; 1110 stats->rx_errors++; 1111 } 1112 1113 /* error warning + passive interrupt */ 1114 if (isrc == CEVTIND_EI) { 1115 netdev_dbg(mod->ndev, "error warning + passive interrupt\n"); 1116 if (status & SR_BS) { 1117 state = CAN_STATE_BUS_OFF; 1118 cf->can_id |= CAN_ERR_BUSOFF; 1119 mod->can.can_stats.bus_off++; 1120 can_bus_off(dev); 1121 } else if (status & SR_ES) { 1122 if (rxerr >= 128 || txerr >= 128) 1123 state = CAN_STATE_ERROR_PASSIVE; 1124 else 1125 state = CAN_STATE_ERROR_WARNING; 1126 } else { 1127 state = CAN_STATE_ERROR_ACTIVE; 1128 } 1129 } 1130 1131 /* bus error interrupt */ 1132 if (isrc == CEVTIND_BEI) { 1133 mod->can.can_stats.bus_error++; 1134 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 1135 1136 switch (ecc & ECC_MASK) { 1137 case ECC_BIT: 1138 cf->data[2] |= CAN_ERR_PROT_BIT; 1139 break; 1140 case ECC_FORM: 1141 cf->data[2] |= CAN_ERR_PROT_FORM; 1142 break; 1143 case ECC_STUFF: 1144 cf->data[2] |= CAN_ERR_PROT_STUFF; 1145 break; 1146 default: 1147 cf->data[3] = ecc & ECC_SEG; 1148 break; 1149 } 1150 1151 if (!(ecc & ECC_DIR)) 1152 cf->data[2] |= CAN_ERR_PROT_TX; 1153 1154 cf->data[6] = txerr; 1155 cf->data[7] = rxerr; 1156 } 1157 1158 if (state != mod->can.state && (state == CAN_STATE_ERROR_WARNING || 1159 state == CAN_STATE_ERROR_PASSIVE)) { 1160 cf->can_id |= CAN_ERR_CRTL; 1161 if (state == CAN_STATE_ERROR_WARNING) { 1162 mod->can.can_stats.error_warning++; 1163 cf->data[1] = (txerr > rxerr) ? 1164 CAN_ERR_CRTL_TX_WARNING : 1165 CAN_ERR_CRTL_RX_WARNING; 1166 } else { 1167 mod->can.can_stats.error_passive++; 1168 cf->data[1] = (txerr > rxerr) ? 1169 CAN_ERR_CRTL_TX_PASSIVE : 1170 CAN_ERR_CRTL_RX_PASSIVE; 1171 } 1172 1173 cf->data[6] = txerr; 1174 cf->data[7] = rxerr; 1175 } 1176 1177 mod->can.state = state; 1178 netif_rx(skb); 1179 return 0; 1180 } 1181 1182 static void ican3_handle_inquiry(struct ican3_dev *mod, struct ican3_msg *msg) 1183 { 1184 switch (msg->data[0]) { 1185 case INQUIRY_STATUS: 1186 case INQUIRY_EXTENDED: 1187 mod->bec.rxerr = msg->data[5]; 1188 mod->bec.txerr = msg->data[6]; 1189 complete(&mod->buserror_comp); 1190 break; 1191 case INQUIRY_TERMINATION: 1192 mod->termination_enabled = msg->data[6] & HWCONF_TERMINATE_ON; 1193 complete(&mod->termination_comp); 1194 break; 1195 default: 1196 netdev_err(mod->ndev, "received an unknown inquiry response\n"); 1197 break; 1198 } 1199 } 1200 1201 /* Handle NMTS Slave Event Indication Messages from the firmware */ 1202 static void ican3_handle_nmtsind(struct ican3_dev *mod, struct ican3_msg *msg) 1203 { 1204 u16 subspec; 1205 1206 subspec = msg->data[0] + msg->data[1] * 0x100; 1207 if (subspec == NMTS_SLAVE_EVENT_IND) { 1208 switch (msg->data[2]) { 1209 case NE_LOCAL_OCCURRED: 1210 case NE_LOCAL_RESOLVED: 1211 /* now follows the same message as Raw ICANOS CEVTIND 1212 * shift the data at the same place and call this method 1213 */ 1214 le16_add_cpu(&msg->len, -3); 1215 memmove(msg->data, msg->data + 3, le16_to_cpu(msg->len)); 1216 ican3_handle_cevtind(mod, msg); 1217 break; 1218 case NE_REMOTE_OCCURRED: 1219 case NE_REMOTE_RESOLVED: 1220 /* should not occurre, ignore */ 1221 break; 1222 default: 1223 netdev_warn(mod->ndev, "unknown NMTS event indication %x\n", 1224 msg->data[2]); 1225 break; 1226 } 1227 } else if (subspec == NMTS_SLAVE_STATE_IND) { 1228 /* ignore state indications */ 1229 } else { 1230 netdev_warn(mod->ndev, "unhandled NMTS indication %x\n", 1231 subspec); 1232 return; 1233 } 1234 } 1235 1236 static void ican3_handle_unknown_message(struct ican3_dev *mod, 1237 struct ican3_msg *msg) 1238 { 1239 netdev_warn(mod->ndev, "received unknown message: spec 0x%.2x length %d\n", 1240 msg->spec, le16_to_cpu(msg->len)); 1241 } 1242 1243 /* 1244 * Handle a control message from the firmware 1245 */ 1246 static void ican3_handle_message(struct ican3_dev *mod, struct ican3_msg *msg) 1247 { 1248 netdev_dbg(mod->ndev, "%s: modno %d spec 0x%.2x len %d bytes\n", __func__, 1249 mod->num, msg->spec, le16_to_cpu(msg->len)); 1250 1251 switch (msg->spec) { 1252 case MSG_IDVERS: 1253 ican3_handle_idvers(mod, msg); 1254 break; 1255 case MSG_MSGLOST: 1256 case MSG_FMSGLOST: 1257 ican3_handle_msglost(mod, msg); 1258 break; 1259 case MSG_CEVTIND: 1260 ican3_handle_cevtind(mod, msg); 1261 break; 1262 case MSG_INQUIRY: 1263 ican3_handle_inquiry(mod, msg); 1264 break; 1265 case MSG_NMTS: 1266 ican3_handle_nmtsind(mod, msg); 1267 break; 1268 default: 1269 ican3_handle_unknown_message(mod, msg); 1270 break; 1271 } 1272 } 1273 1274 /* 1275 * The ican3 needs to store all echo skbs, and therefore cannot 1276 * use the generic infrastructure for this. 1277 */ 1278 static void ican3_put_echo_skb(struct ican3_dev *mod, struct sk_buff *skb) 1279 { 1280 skb = can_create_echo_skb(skb); 1281 if (!skb) 1282 return; 1283 1284 /* save this skb for tx interrupt echo handling */ 1285 skb_queue_tail(&mod->echoq, skb); 1286 } 1287 1288 static unsigned int ican3_get_echo_skb(struct ican3_dev *mod) 1289 { 1290 struct sk_buff *skb = skb_dequeue(&mod->echoq); 1291 struct can_frame *cf; 1292 u8 dlc; 1293 1294 /* this should never trigger unless there is a driver bug */ 1295 if (!skb) { 1296 netdev_err(mod->ndev, "BUG: echo skb not occupied\n"); 1297 return 0; 1298 } 1299 1300 cf = (struct can_frame *)skb->data; 1301 dlc = cf->can_dlc; 1302 1303 /* check flag whether this packet has to be looped back */ 1304 if (skb->pkt_type != PACKET_LOOPBACK) { 1305 kfree_skb(skb); 1306 return dlc; 1307 } 1308 1309 skb->protocol = htons(ETH_P_CAN); 1310 skb->pkt_type = PACKET_BROADCAST; 1311 skb->ip_summed = CHECKSUM_UNNECESSARY; 1312 skb->dev = mod->ndev; 1313 netif_receive_skb(skb); 1314 return dlc; 1315 } 1316 1317 /* 1318 * Compare an skb with an existing echo skb 1319 * 1320 * This function will be used on devices which have a hardware loopback. 1321 * On these devices, this function can be used to compare a received skb 1322 * with the saved echo skbs so that the hardware echo skb can be dropped. 1323 * 1324 * Returns true if the skb's are identical, false otherwise. 1325 */ 1326 static bool ican3_echo_skb_matches(struct ican3_dev *mod, struct sk_buff *skb) 1327 { 1328 struct can_frame *cf = (struct can_frame *)skb->data; 1329 struct sk_buff *echo_skb = skb_peek(&mod->echoq); 1330 struct can_frame *echo_cf; 1331 1332 if (!echo_skb) 1333 return false; 1334 1335 echo_cf = (struct can_frame *)echo_skb->data; 1336 if (cf->can_id != echo_cf->can_id) 1337 return false; 1338 1339 if (cf->can_dlc != echo_cf->can_dlc) 1340 return false; 1341 1342 return memcmp(cf->data, echo_cf->data, cf->can_dlc) == 0; 1343 } 1344 1345 /* 1346 * Check that there is room in the TX ring to transmit another skb 1347 * 1348 * LOCKING: must hold mod->lock 1349 */ 1350 static bool ican3_txok(struct ican3_dev *mod) 1351 { 1352 struct ican3_fast_desc __iomem *desc; 1353 u8 control; 1354 1355 /* check that we have echo queue space */ 1356 if (skb_queue_len(&mod->echoq) >= ICAN3_TX_BUFFERS) 1357 return false; 1358 1359 /* copy the control bits of the descriptor */ 1360 ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16)); 1361 desc = mod->dpm + ((mod->fasttx_num % 16) * sizeof(*desc)); 1362 control = ioread8(&desc->control); 1363 1364 /* if the control bits are not valid, then we have no more space */ 1365 if (!(control & DESC_VALID)) 1366 return false; 1367 1368 return true; 1369 } 1370 1371 /* 1372 * Receive one CAN frame from the hardware 1373 * 1374 * CONTEXT: must be called from user context 1375 */ 1376 static int ican3_recv_skb(struct ican3_dev *mod) 1377 { 1378 struct net_device *ndev = mod->ndev; 1379 struct net_device_stats *stats = &ndev->stats; 1380 struct ican3_fast_desc desc; 1381 void __iomem *desc_addr; 1382 struct can_frame *cf; 1383 struct sk_buff *skb; 1384 unsigned long flags; 1385 1386 spin_lock_irqsave(&mod->lock, flags); 1387 1388 /* copy the whole descriptor */ 1389 ican3_set_page(mod, mod->fastrx_start + (mod->fastrx_num / 16)); 1390 desc_addr = mod->dpm + ((mod->fastrx_num % 16) * sizeof(desc)); 1391 memcpy_fromio(&desc, desc_addr, sizeof(desc)); 1392 1393 spin_unlock_irqrestore(&mod->lock, flags); 1394 1395 /* check that we actually have a CAN frame */ 1396 if (!(desc.control & DESC_VALID)) 1397 return -ENOBUFS; 1398 1399 /* allocate an skb */ 1400 skb = alloc_can_skb(ndev, &cf); 1401 if (unlikely(skb == NULL)) { 1402 stats->rx_dropped++; 1403 goto err_noalloc; 1404 } 1405 1406 /* convert the ICAN3 frame into Linux CAN format */ 1407 ican3_to_can_frame(mod, &desc, cf); 1408 1409 /* 1410 * If this is an ECHO frame received from the hardware loopback 1411 * feature, use the skb saved in the ECHO stack instead. This allows 1412 * the Linux CAN core to support CAN_RAW_RECV_OWN_MSGS correctly. 1413 * 1414 * Since this is a confirmation of a successfully transmitted packet 1415 * sent from this host, update the transmit statistics. 1416 * 1417 * Also, the netdevice queue needs to be allowed to send packets again. 1418 */ 1419 if (ican3_echo_skb_matches(mod, skb)) { 1420 stats->tx_packets++; 1421 stats->tx_bytes += ican3_get_echo_skb(mod); 1422 kfree_skb(skb); 1423 goto err_noalloc; 1424 } 1425 1426 /* update statistics, receive the skb */ 1427 stats->rx_packets++; 1428 stats->rx_bytes += cf->can_dlc; 1429 netif_receive_skb(skb); 1430 1431 err_noalloc: 1432 /* toggle the valid bit and return the descriptor to the ring */ 1433 desc.control ^= DESC_VALID; 1434 1435 spin_lock_irqsave(&mod->lock, flags); 1436 1437 ican3_set_page(mod, mod->fastrx_start + (mod->fastrx_num / 16)); 1438 memcpy_toio(desc_addr, &desc, 1); 1439 1440 /* update the next buffer pointer */ 1441 mod->fastrx_num = (desc.control & DESC_WRAP) ? 0 1442 : (mod->fastrx_num + 1); 1443 1444 /* there are still more buffers to process */ 1445 spin_unlock_irqrestore(&mod->lock, flags); 1446 return 0; 1447 } 1448 1449 static int ican3_napi(struct napi_struct *napi, int budget) 1450 { 1451 struct ican3_dev *mod = container_of(napi, struct ican3_dev, napi); 1452 unsigned long flags; 1453 int received = 0; 1454 int ret; 1455 1456 /* process all communication messages */ 1457 while (true) { 1458 struct ican3_msg uninitialized_var(msg); 1459 ret = ican3_recv_msg(mod, &msg); 1460 if (ret) 1461 break; 1462 1463 ican3_handle_message(mod, &msg); 1464 } 1465 1466 /* process all CAN frames from the fast interface */ 1467 while (received < budget) { 1468 ret = ican3_recv_skb(mod); 1469 if (ret) 1470 break; 1471 1472 received++; 1473 } 1474 1475 /* We have processed all packets that the adapter had, but it 1476 * was less than our budget, stop polling */ 1477 if (received < budget) 1478 napi_complete_done(napi, received); 1479 1480 spin_lock_irqsave(&mod->lock, flags); 1481 1482 /* Wake up the transmit queue if necessary */ 1483 if (netif_queue_stopped(mod->ndev) && ican3_txok(mod)) 1484 netif_wake_queue(mod->ndev); 1485 1486 spin_unlock_irqrestore(&mod->lock, flags); 1487 1488 /* re-enable interrupt generation */ 1489 iowrite8(1 << mod->num, &mod->ctrl->int_enable); 1490 return received; 1491 } 1492 1493 static irqreturn_t ican3_irq(int irq, void *dev_id) 1494 { 1495 struct ican3_dev *mod = dev_id; 1496 u8 stat; 1497 1498 /* 1499 * The interrupt status register on this device reports interrupts 1500 * as zeroes instead of using ones like most other devices 1501 */ 1502 stat = ioread8(&mod->ctrl->int_disable) & (1 << mod->num); 1503 if (stat == (1 << mod->num)) 1504 return IRQ_NONE; 1505 1506 /* clear the MODULbus interrupt from the microcontroller */ 1507 ioread8(&mod->dpmctrl->interrupt); 1508 1509 /* disable interrupt generation, schedule the NAPI poller */ 1510 iowrite8(1 << mod->num, &mod->ctrl->int_disable); 1511 napi_schedule(&mod->napi); 1512 return IRQ_HANDLED; 1513 } 1514 1515 /* 1516 * Firmware reset, startup, and shutdown 1517 */ 1518 1519 /* 1520 * Reset an ICAN module to its power-on state 1521 * 1522 * CONTEXT: no network device registered 1523 */ 1524 static int ican3_reset_module(struct ican3_dev *mod) 1525 { 1526 unsigned long start; 1527 u8 runold, runnew; 1528 1529 /* disable interrupts so no more work is scheduled */ 1530 iowrite8(1 << mod->num, &mod->ctrl->int_disable); 1531 1532 /* the first unallocated page in the DPM is #9 */ 1533 mod->free_page = DPM_FREE_START; 1534 1535 ican3_set_page(mod, QUEUE_OLD_CONTROL); 1536 runold = ioread8(mod->dpm + TARGET_RUNNING); 1537 1538 /* reset the module */ 1539 iowrite8(0x00, &mod->dpmctrl->hwreset); 1540 1541 /* wait until the module has finished resetting and is running */ 1542 start = jiffies; 1543 do { 1544 ican3_set_page(mod, QUEUE_OLD_CONTROL); 1545 runnew = ioread8(mod->dpm + TARGET_RUNNING); 1546 if (runnew == (runold ^ 0xff)) 1547 return 0; 1548 1549 msleep(10); 1550 } while (time_before(jiffies, start + HZ / 2)); 1551 1552 netdev_err(mod->ndev, "failed to reset CAN module\n"); 1553 return -ETIMEDOUT; 1554 } 1555 1556 static void ican3_shutdown_module(struct ican3_dev *mod) 1557 { 1558 ican3_msg_disconnect(mod); 1559 ican3_reset_module(mod); 1560 } 1561 1562 /* 1563 * Startup an ICAN module, bringing it into fast mode 1564 */ 1565 static int ican3_startup_module(struct ican3_dev *mod) 1566 { 1567 int ret; 1568 1569 ret = ican3_reset_module(mod); 1570 if (ret) { 1571 netdev_err(mod->ndev, "unable to reset module\n"); 1572 return ret; 1573 } 1574 1575 /* detect firmware */ 1576 memcpy_fromio(mod->fwinfo, mod->dpm + FIRMWARE_STAMP, sizeof(mod->fwinfo) - 1); 1577 if (strncmp(mod->fwinfo, "JANZ-ICAN3", 10)) { 1578 netdev_err(mod->ndev, "ICAN3 not detected (found %s)\n", mod->fwinfo); 1579 return -ENODEV; 1580 } 1581 if (strstr(mod->fwinfo, "CAL/CANopen")) 1582 mod->fwtype = ICAN3_FWTYPE_CAL_CANOPEN; 1583 else 1584 mod->fwtype = ICAN3_FWTYPE_ICANOS; 1585 1586 /* re-enable interrupts so we can send messages */ 1587 iowrite8(1 << mod->num, &mod->ctrl->int_enable); 1588 1589 ret = ican3_msg_connect(mod); 1590 if (ret) { 1591 netdev_err(mod->ndev, "unable to connect to module\n"); 1592 return ret; 1593 } 1594 1595 ican3_init_new_host_interface(mod); 1596 ret = ican3_msg_newhostif(mod); 1597 if (ret) { 1598 netdev_err(mod->ndev, "unable to switch to new-style interface\n"); 1599 return ret; 1600 } 1601 1602 /* default to "termination on" */ 1603 ret = ican3_set_termination(mod, true); 1604 if (ret) { 1605 netdev_err(mod->ndev, "unable to enable termination\n"); 1606 return ret; 1607 } 1608 1609 /* default to "bus errors enabled" */ 1610 ret = ican3_set_buserror(mod, 1); 1611 if (ret) { 1612 netdev_err(mod->ndev, "unable to set bus-error\n"); 1613 return ret; 1614 } 1615 1616 ican3_init_fast_host_interface(mod); 1617 ret = ican3_msg_fasthostif(mod); 1618 if (ret) { 1619 netdev_err(mod->ndev, "unable to switch to fast host interface\n"); 1620 return ret; 1621 } 1622 1623 ret = ican3_set_id_filter(mod, true); 1624 if (ret) { 1625 netdev_err(mod->ndev, "unable to set acceptance filter\n"); 1626 return ret; 1627 } 1628 1629 return 0; 1630 } 1631 1632 /* 1633 * CAN Network Device 1634 */ 1635 1636 static int ican3_open(struct net_device *ndev) 1637 { 1638 struct ican3_dev *mod = netdev_priv(ndev); 1639 int ret; 1640 1641 /* open the CAN layer */ 1642 ret = open_candev(ndev); 1643 if (ret) { 1644 netdev_err(mod->ndev, "unable to start CAN layer\n"); 1645 return ret; 1646 } 1647 1648 /* bring the bus online */ 1649 ret = ican3_set_bus_state(mod, true); 1650 if (ret) { 1651 netdev_err(mod->ndev, "unable to set bus-on\n"); 1652 close_candev(ndev); 1653 return ret; 1654 } 1655 1656 /* start up the network device */ 1657 mod->can.state = CAN_STATE_ERROR_ACTIVE; 1658 netif_start_queue(ndev); 1659 1660 return 0; 1661 } 1662 1663 static int ican3_stop(struct net_device *ndev) 1664 { 1665 struct ican3_dev *mod = netdev_priv(ndev); 1666 int ret; 1667 1668 /* stop the network device xmit routine */ 1669 netif_stop_queue(ndev); 1670 mod->can.state = CAN_STATE_STOPPED; 1671 1672 /* bring the bus offline, stop receiving packets */ 1673 ret = ican3_set_bus_state(mod, false); 1674 if (ret) { 1675 netdev_err(mod->ndev, "unable to set bus-off\n"); 1676 return ret; 1677 } 1678 1679 /* drop all outstanding echo skbs */ 1680 skb_queue_purge(&mod->echoq); 1681 1682 /* close the CAN layer */ 1683 close_candev(ndev); 1684 return 0; 1685 } 1686 1687 static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev) 1688 { 1689 struct ican3_dev *mod = netdev_priv(ndev); 1690 struct can_frame *cf = (struct can_frame *)skb->data; 1691 struct ican3_fast_desc desc; 1692 void __iomem *desc_addr; 1693 unsigned long flags; 1694 1695 if (can_dropped_invalid_skb(ndev, skb)) 1696 return NETDEV_TX_OK; 1697 1698 spin_lock_irqsave(&mod->lock, flags); 1699 1700 /* check that we can actually transmit */ 1701 if (!ican3_txok(mod)) { 1702 netdev_err(mod->ndev, "BUG: no free descriptors\n"); 1703 spin_unlock_irqrestore(&mod->lock, flags); 1704 return NETDEV_TX_BUSY; 1705 } 1706 1707 /* copy the control bits of the descriptor */ 1708 ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16)); 1709 desc_addr = mod->dpm + ((mod->fasttx_num % 16) * sizeof(desc)); 1710 memset(&desc, 0, sizeof(desc)); 1711 memcpy_fromio(&desc, desc_addr, 1); 1712 1713 /* convert the Linux CAN frame into ICAN3 format */ 1714 can_frame_to_ican3(mod, cf, &desc); 1715 1716 /* 1717 * This hardware doesn't have TX-done notifications, so we'll try and 1718 * emulate it the best we can using ECHO skbs. Add the skb to the ECHO 1719 * stack. Upon packet reception, check if the ECHO skb and received 1720 * skb match, and use that to wake the queue. 1721 */ 1722 ican3_put_echo_skb(mod, skb); 1723 1724 /* 1725 * the programming manual says that you must set the IVALID bit, then 1726 * interrupt, then set the valid bit. Quite weird, but it seems to be 1727 * required for this to work 1728 */ 1729 desc.control |= DESC_IVALID; 1730 memcpy_toio(desc_addr, &desc, sizeof(desc)); 1731 1732 /* generate a MODULbus interrupt to the microcontroller */ 1733 iowrite8(0x01, &mod->dpmctrl->interrupt); 1734 1735 desc.control ^= DESC_VALID; 1736 memcpy_toio(desc_addr, &desc, sizeof(desc)); 1737 1738 /* update the next buffer pointer */ 1739 mod->fasttx_num = (desc.control & DESC_WRAP) ? 0 1740 : (mod->fasttx_num + 1); 1741 1742 /* if there is no free descriptor space, stop the transmit queue */ 1743 if (!ican3_txok(mod)) 1744 netif_stop_queue(ndev); 1745 1746 spin_unlock_irqrestore(&mod->lock, flags); 1747 return NETDEV_TX_OK; 1748 } 1749 1750 static const struct net_device_ops ican3_netdev_ops = { 1751 .ndo_open = ican3_open, 1752 .ndo_stop = ican3_stop, 1753 .ndo_start_xmit = ican3_xmit, 1754 .ndo_change_mtu = can_change_mtu, 1755 }; 1756 1757 /* 1758 * Low-level CAN Device 1759 */ 1760 1761 /* This structure was stolen from drivers/net/can/sja1000/sja1000.c */ 1762 static const struct can_bittiming_const ican3_bittiming_const = { 1763 .name = DRV_NAME, 1764 .tseg1_min = 1, 1765 .tseg1_max = 16, 1766 .tseg2_min = 1, 1767 .tseg2_max = 8, 1768 .sjw_max = 4, 1769 .brp_min = 1, 1770 .brp_max = 64, 1771 .brp_inc = 1, 1772 }; 1773 1774 static int ican3_set_mode(struct net_device *ndev, enum can_mode mode) 1775 { 1776 struct ican3_dev *mod = netdev_priv(ndev); 1777 int ret; 1778 1779 if (mode != CAN_MODE_START) 1780 return -ENOTSUPP; 1781 1782 /* bring the bus online */ 1783 ret = ican3_set_bus_state(mod, true); 1784 if (ret) { 1785 netdev_err(ndev, "unable to set bus-on\n"); 1786 return ret; 1787 } 1788 1789 /* start up the network device */ 1790 mod->can.state = CAN_STATE_ERROR_ACTIVE; 1791 1792 if (netif_queue_stopped(ndev)) 1793 netif_wake_queue(ndev); 1794 1795 return 0; 1796 } 1797 1798 static int ican3_get_berr_counter(const struct net_device *ndev, 1799 struct can_berr_counter *bec) 1800 { 1801 struct ican3_dev *mod = netdev_priv(ndev); 1802 int ret; 1803 1804 ret = ican3_send_inquiry(mod, INQUIRY_STATUS); 1805 if (ret) 1806 return ret; 1807 1808 if (!wait_for_completion_timeout(&mod->buserror_comp, HZ)) { 1809 netdev_info(mod->ndev, "%s timed out\n", __func__); 1810 return -ETIMEDOUT; 1811 } 1812 1813 bec->rxerr = mod->bec.rxerr; 1814 bec->txerr = mod->bec.txerr; 1815 return 0; 1816 } 1817 1818 /* 1819 * Sysfs Attributes 1820 */ 1821 1822 static ssize_t ican3_sysfs_show_term(struct device *dev, 1823 struct device_attribute *attr, 1824 char *buf) 1825 { 1826 struct ican3_dev *mod = netdev_priv(to_net_dev(dev)); 1827 int ret; 1828 1829 ret = ican3_send_inquiry(mod, INQUIRY_TERMINATION); 1830 if (ret) 1831 return ret; 1832 1833 if (!wait_for_completion_timeout(&mod->termination_comp, HZ)) { 1834 netdev_info(mod->ndev, "%s timed out\n", __func__); 1835 return -ETIMEDOUT; 1836 } 1837 1838 return snprintf(buf, PAGE_SIZE, "%u\n", mod->termination_enabled); 1839 } 1840 1841 static ssize_t ican3_sysfs_set_term(struct device *dev, 1842 struct device_attribute *attr, 1843 const char *buf, size_t count) 1844 { 1845 struct ican3_dev *mod = netdev_priv(to_net_dev(dev)); 1846 unsigned long enable; 1847 int ret; 1848 1849 if (kstrtoul(buf, 0, &enable)) 1850 return -EINVAL; 1851 1852 ret = ican3_set_termination(mod, enable); 1853 if (ret) 1854 return ret; 1855 1856 return count; 1857 } 1858 1859 static ssize_t ican3_sysfs_show_fwinfo(struct device *dev, 1860 struct device_attribute *attr, 1861 char *buf) 1862 { 1863 struct ican3_dev *mod = netdev_priv(to_net_dev(dev)); 1864 1865 return scnprintf(buf, PAGE_SIZE, "%s\n", mod->fwinfo); 1866 } 1867 1868 static DEVICE_ATTR(termination, S_IWUSR | S_IRUGO, ican3_sysfs_show_term, 1869 ican3_sysfs_set_term); 1870 static DEVICE_ATTR(fwinfo, S_IRUSR | S_IRUGO, ican3_sysfs_show_fwinfo, NULL); 1871 1872 static struct attribute *ican3_sysfs_attrs[] = { 1873 &dev_attr_termination.attr, 1874 &dev_attr_fwinfo.attr, 1875 NULL, 1876 }; 1877 1878 static const struct attribute_group ican3_sysfs_attr_group = { 1879 .attrs = ican3_sysfs_attrs, 1880 }; 1881 1882 /* 1883 * PCI Subsystem 1884 */ 1885 1886 static int ican3_probe(struct platform_device *pdev) 1887 { 1888 struct janz_platform_data *pdata; 1889 struct net_device *ndev; 1890 struct ican3_dev *mod; 1891 struct resource *res; 1892 struct device *dev; 1893 int ret; 1894 1895 pdata = dev_get_platdata(&pdev->dev); 1896 if (!pdata) 1897 return -ENXIO; 1898 1899 dev_dbg(&pdev->dev, "probe: module number %d\n", pdata->modno); 1900 1901 /* save the struct device for printing */ 1902 dev = &pdev->dev; 1903 1904 /* allocate the CAN device and private data */ 1905 ndev = alloc_candev(sizeof(*mod), 0); 1906 if (!ndev) { 1907 dev_err(dev, "unable to allocate CANdev\n"); 1908 ret = -ENOMEM; 1909 goto out_return; 1910 } 1911 1912 platform_set_drvdata(pdev, ndev); 1913 mod = netdev_priv(ndev); 1914 mod->ndev = ndev; 1915 mod->num = pdata->modno; 1916 netif_napi_add(ndev, &mod->napi, ican3_napi, ICAN3_RX_BUFFERS); 1917 skb_queue_head_init(&mod->echoq); 1918 spin_lock_init(&mod->lock); 1919 init_completion(&mod->termination_comp); 1920 init_completion(&mod->buserror_comp); 1921 1922 /* setup device-specific sysfs attributes */ 1923 ndev->sysfs_groups[0] = &ican3_sysfs_attr_group; 1924 1925 /* the first unallocated page in the DPM is 9 */ 1926 mod->free_page = DPM_FREE_START; 1927 1928 ndev->netdev_ops = &ican3_netdev_ops; 1929 ndev->flags |= IFF_ECHO; 1930 SET_NETDEV_DEV(ndev, &pdev->dev); 1931 1932 mod->can.clock.freq = ICAN3_CAN_CLOCK; 1933 mod->can.bittiming_const = &ican3_bittiming_const; 1934 mod->can.do_set_mode = ican3_set_mode; 1935 mod->can.do_get_berr_counter = ican3_get_berr_counter; 1936 mod->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES 1937 | CAN_CTRLMODE_BERR_REPORTING 1938 | CAN_CTRLMODE_ONE_SHOT; 1939 1940 /* find our IRQ number */ 1941 mod->irq = platform_get_irq(pdev, 0); 1942 if (mod->irq < 0) { 1943 dev_err(dev, "IRQ line not found\n"); 1944 ret = -ENODEV; 1945 goto out_free_ndev; 1946 } 1947 1948 ndev->irq = mod->irq; 1949 1950 /* get access to the MODULbus registers for this module */ 1951 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1952 if (!res) { 1953 dev_err(dev, "MODULbus registers not found\n"); 1954 ret = -ENODEV; 1955 goto out_free_ndev; 1956 } 1957 1958 mod->dpm = ioremap(res->start, resource_size(res)); 1959 if (!mod->dpm) { 1960 dev_err(dev, "MODULbus registers not ioremap\n"); 1961 ret = -ENOMEM; 1962 goto out_free_ndev; 1963 } 1964 1965 mod->dpmctrl = mod->dpm + DPM_PAGE_SIZE; 1966 1967 /* get access to the control registers for this module */ 1968 res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 1969 if (!res) { 1970 dev_err(dev, "CONTROL registers not found\n"); 1971 ret = -ENODEV; 1972 goto out_iounmap_dpm; 1973 } 1974 1975 mod->ctrl = ioremap(res->start, resource_size(res)); 1976 if (!mod->ctrl) { 1977 dev_err(dev, "CONTROL registers not ioremap\n"); 1978 ret = -ENOMEM; 1979 goto out_iounmap_dpm; 1980 } 1981 1982 /* disable our IRQ, then hookup the IRQ handler */ 1983 iowrite8(1 << mod->num, &mod->ctrl->int_disable); 1984 ret = request_irq(mod->irq, ican3_irq, IRQF_SHARED, DRV_NAME, mod); 1985 if (ret) { 1986 dev_err(dev, "unable to request IRQ\n"); 1987 goto out_iounmap_ctrl; 1988 } 1989 1990 /* reset and initialize the CAN controller into fast mode */ 1991 napi_enable(&mod->napi); 1992 ret = ican3_startup_module(mod); 1993 if (ret) { 1994 dev_err(dev, "%s: unable to start CANdev\n", __func__); 1995 goto out_free_irq; 1996 } 1997 1998 /* register with the Linux CAN layer */ 1999 ret = register_candev(ndev); 2000 if (ret) { 2001 dev_err(dev, "%s: unable to register CANdev\n", __func__); 2002 goto out_free_irq; 2003 } 2004 2005 netdev_info(mod->ndev, "module %d: registered CAN device\n", pdata->modno); 2006 return 0; 2007 2008 out_free_irq: 2009 napi_disable(&mod->napi); 2010 iowrite8(1 << mod->num, &mod->ctrl->int_disable); 2011 free_irq(mod->irq, mod); 2012 out_iounmap_ctrl: 2013 iounmap(mod->ctrl); 2014 out_iounmap_dpm: 2015 iounmap(mod->dpm); 2016 out_free_ndev: 2017 free_candev(ndev); 2018 out_return: 2019 return ret; 2020 } 2021 2022 static int ican3_remove(struct platform_device *pdev) 2023 { 2024 struct net_device *ndev = platform_get_drvdata(pdev); 2025 struct ican3_dev *mod = netdev_priv(ndev); 2026 2027 /* unregister the netdevice, stop interrupts */ 2028 unregister_netdev(ndev); 2029 napi_disable(&mod->napi); 2030 iowrite8(1 << mod->num, &mod->ctrl->int_disable); 2031 free_irq(mod->irq, mod); 2032 2033 /* put the module into reset */ 2034 ican3_shutdown_module(mod); 2035 2036 /* unmap all registers */ 2037 iounmap(mod->ctrl); 2038 iounmap(mod->dpm); 2039 2040 free_candev(ndev); 2041 2042 return 0; 2043 } 2044 2045 static struct platform_driver ican3_driver = { 2046 .driver = { 2047 .name = DRV_NAME, 2048 }, 2049 .probe = ican3_probe, 2050 .remove = ican3_remove, 2051 }; 2052 2053 module_platform_driver(ican3_driver); 2054 2055 MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); 2056 MODULE_DESCRIPTION("Janz MODULbus VMOD-ICAN3 Driver"); 2057 MODULE_LICENSE("GPL"); 2058 MODULE_ALIAS("platform:janz-ican3"); 2059