drivers/net/can/janz-ican3.c

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