2061 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Janz MODULbus VMOD-ICAN3 CAN Interface Driver4 *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 25626#define DPM_PAGE_SIZE 25627#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 031#define QUEUE_OLD_RB0 132#define QUEUE_OLD_RB1 233#define QUEUE_OLD_WB0 334#define QUEUE_OLD_WB1 435 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 0x0240#define FIRMWARE_STAMP 0x60 /* big endian firmware stamp */41 42#define MSYNC_RB0 0x0143#define MSYNC_RB1 0x0244#define MSYNC_RBLW 0x0445#define MSYNC_RB_MASK (MSYNC_RB0 | MSYNC_RB1)46 47#define MSYNC_WB0 0x1048#define MSYNC_WB1 0x2049#define MSYNC_WBLW 0x4050#define MSYNC_WB_MASK (MSYNC_WB0 | MSYNC_WB1)51 52/* Janz ICAN3 "new-style" host interface queue page numbers */53#define QUEUE_TOHOST 554#define QUEUE_FROMHOST_MID 655#define QUEUE_FROMHOST_HIGH 756#define QUEUE_FROMHOST_LOW 857 58/* The first free page in the DPM is #9 */59#define DPM_FREE_START 960 61/* Janz ICAN3 "new-style" and "fast" host interface descriptor flags */62#define DESC_VALID 0x8063#define DESC_WRAP 0x4064#define DESC_INTERRUPT 0x2065#define DESC_IVALID 0x1066#define DESC_LEN(len) (len)67 68/* Janz ICAN3 Firmware Messages */69#define MSG_CONNECTI 0x0270#define MSG_DISCONNECT 0x0371#define MSG_IDVERS 0x0472#define MSG_MSGLOST 0x0573#define MSG_NEWHOSTIF 0x0874#define MSG_INQUIRY 0x0a75#define MSG_SETAFILMASK 0x1076#define MSG_INITFDPMQUEUE 0x1177#define MSG_HWCONF 0x1278#define MSG_FMSGLOST 0x1579#define MSG_CEVTIND 0x3780#define MSG_CBTRREQ 0x4181#define MSG_COFFREQ 0x4282#define MSG_CONREQ 0x4383#define MSG_CCONFREQ 0x4784#define MSG_NMTS 0xb085#define MSG_LMTS 0xb486 87/*88 * Janz ICAN3 CAN Inquiry Message Types89 *90 * NOTE: there appears to be a firmware bug here. You must send91 * NOTE: INQUIRY_STATUS and expect to receive an INQUIRY_EXTENDED92 * NOTE: response. The controller never responds to a message with93 * NOTE: the INQUIRY_EXTENDED subspec :(94 */95#define INQUIRY_STATUS 0x0096#define INQUIRY_TERMINATION 0x0197#define INQUIRY_EXTENDED 0x0498 99/* Janz ICAN3 CAN Set Acceptance Filter Mask Message Types */100#define SETAFILMASK_REJECT 0x00101#define SETAFILMASK_FASTIF 0x02102 103/* Janz ICAN3 CAN Hardware Configuration Message Types */104#define HWCONF_TERMINATE_ON 0x01105#define HWCONF_TERMINATE_OFF 0x00106 107/* Janz ICAN3 CAN Event Indication Message Types */108#define CEVTIND_EI 0x01109#define CEVTIND_DOI 0x02110#define CEVTIND_LOST 0x04111#define CEVTIND_FULL 0x08112#define CEVTIND_BEI 0x10113 114#define CEVTIND_CHIP_SJA1000 0x02115 116#define ICAN3_BUSERR_QUOTA_MAX 255117 118/* Janz ICAN3 CAN Frame Conversion */119#define ICAN3_SNGL 0x02120#define ICAN3_ECHO 0x10121#define ICAN3_EFF_RTR 0x40122#define ICAN3_SFF_RTR 0x10123#define ICAN3_EFF 0x80124 125#define ICAN3_CAN_TYPE_MASK 0x0f126#define ICAN3_CAN_TYPE_SFF 0x00127#define ICAN3_CAN_TYPE_EFF 0x01128 129#define ICAN3_CAN_DLC_MASK 0x0f130 131/* Janz ICAN3 NMTS subtypes */132#define NMTS_CREATE_NODE_REQ 0x0133#define NMTS_SLAVE_STATE_IND 0x8134#define NMTS_SLAVE_EVENT_IND 0x9135 136/* Janz ICAN3 LMTS subtypes */137#define LMTS_BUSON_REQ 0x0138#define LMTS_BUSOFF_REQ 0x1139#define LMTS_CAN_CONF_REQ 0x2140 141/* Janz ICAN3 NMTS Event indications */142#define NE_LOCAL_OCCURRED 0x3143#define NE_LOCAL_RESOLVED 0x2144#define NE_REMOTE_OCCURRED 0xc145#define NE_REMOTE_RESOLVED 0x8146 147/*148 * SJA1000 Status and Error Register Definitions149 *150 * Copied from drivers/net/can/sja1000/sja1000.h151 */152 153/* status register content */154#define SR_BS 0x80155#define SR_ES 0x40156#define SR_TS 0x20157#define SR_RS 0x10158#define SR_TCS 0x08159#define SR_TBS 0x04160#define SR_DOS 0x02161#define SR_RBS 0x01162 163#define SR_CRIT (SR_BS|SR_ES)164 165/* ECC register */166#define ECC_SEG 0x1F167#define ECC_DIR 0x20168#define ECC_ERR 6169#define ECC_BIT 0x00170#define ECC_FORM 0x40171#define ECC_STUFF 0x80172#define ECC_MASK 0xc0173 174/* Number of buffers for use in the "new-style" host interface */175#define ICAN3_NEW_BUFFERS 16176 177/* Number of buffers for use in the "fast" host interface */178#define ICAN3_TX_BUFFERS 512179#define ICAN3_RX_BUFFERS 1024180 181/* SJA1000 Clock Input */182#define ICAN3_CAN_CLOCK 8000000183 184/* Janz ICAN3 firmware types */185enum 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 */194struct ican3_dpm_control {195 /* window address register */196 u8 window_address;197 u8 unused1;198 199 /*200 * Read access: clear interrupt from microcontroller201 * Write access: send interrupt to microcontroller202 */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 214struct 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 this252 * lock while it is performing data accesses. This ensures that the253 * function will not be preempted and end up reading data from a254 * 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 273struct ican3_msg {274 u8 control;275 u8 spec;276 __le16 len;277 u8 data[252];278};279 280struct ican3_new_desc {281 u8 control;282 u8 pointer;283};284 285struct ican3_fast_desc {286 u8 control;287 u8 command;288 u8 data[14];289};290 291/* write to the window basic address register */292static 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 interface300 */301 302/*303 * Receive a message from the ICAN3 "old-style" firmware interface304 *305 * LOCKING: must hold mod->lock306 *307 * returns 0 on success, -ENOMEM when no message exists308 */309static 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 else329 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 available338 * for it to fill again339 */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 interface349 *350 * LOCKING: must hold mod->lock351 *352 * returns 0 on success, -ENOMEM when no free space exists353 */354static 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 Setup389 */390 391static 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 Setup468 */469 470static 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 Helpers553 */554 555/*556 * LOCKING: must hold mod->lock557 */558static 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->lock588 */589static 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 Helpers619 */620 621static 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 else631 ret = ican3_new_send_msg(mod, msg);632 633 spin_unlock_irqrestore(&mod->lock, flags);634 return ret;635}636 637static 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 else647 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 Messages655 */656 657static 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 668static 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 679static 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 700static 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 all731 * messages from the CAN bus.732 */733static 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 offline776 */777static 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 processing837 * class 2 (with error capability, see CiA/DS203-1)838 * id 1839 * 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 856static 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 869static 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 882static 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 Conversion908 */909 910static 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 942static 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 Handling979 */980 981/*982 * Handle an ID + Version message response from the firmware. We never generate983 * this message in production code, but it is very useful when debugging to be984 * able to display this message.985 */986static 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 991static 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 firmware1000 * are being lost. These are never CAN frames, so we do not generate an1001 * error frame for userspace1002 */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 CAN1011 * frames fast enough.1012 *1013 * We'll pretend that the SJA1000 told us that it ran out of buffer1014 * 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 firmware1028 *1029 * The ICAN3 firmware provides the values of some SJA1000 registers when it1030 * generates this message. The code below is largely copied from the1031 * drivers/net/can/sja1000/sja1000.c file, and adapted as necessary1032 */1033static 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 to1062 * determine if packet transmission has failed.1063 *1064 * When TX errors happen, one echo skb needs to be dropped from the1065 * front of the queue.1066 *1067 * A small bit of code is duplicated here and below, to avoid error1068 * 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 interrupts1084 * 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 else1122 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 1179static 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 */1199static 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 CEVTIND1209 * shift the data at the same place and call this method1210 */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 1233static 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 firmware1242 */1243static 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 cannot1273 * use the generic infrastructure for this.1274 */1275static 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 1287static 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 skb1319 *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 skb1322 * 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 */1326static 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 skb1347 *1348 * LOCKING: must hold mod->lock1349 */1350static 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 hardware1373 *1374 * CONTEXT: must be called from user context1375 */1376static 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 loopback1411 * feature, use the skb saved in the ECHO stack instead. This allows1412 * the Linux CAN core to support CAN_RAW_RECV_OWN_MSGS correctly.1413 *1414 * Since this is a confirmation of a successfully transmitted packet1415 * 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 1432err_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) ? 01443 : (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 1450static 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 it1477 * 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 1494static 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 interrupts1501 * as zeroes instead of using ones like most other devices1502 */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 shutdown1518 */1519 1520/*1521 * Reset an ICAN module to its power-on state1522 *1523 * CONTEXT: no network device registered1524 */1525static 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 1557static 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 mode1565 */1566static 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 else1585 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 Device1635 */1636 1637static 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 1664static 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 1688static 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 and1719 * emulate it the best we can using ECHO skbs. Add the skb to the ECHO1720 * stack. Upon packet reception, check if the ECHO skb and received1721 * 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, then1727 * interrupt, then set the valid bit. Quite weird, but it seems to be1728 * required for this to work1729 */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) ? 01741 : (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 1751static 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 1758static const struct ethtool_ops ican3_ethtool_ops = {1759 .get_ts_info = ethtool_op_get_ts_info,1760};1761 1762/*1763 * Low-level CAN Device1764 */1765 1766/* This structure was stolen from drivers/net/can/sja1000/sja1000.c */1767static 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 1779static 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 1803static 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 Attributes1825 */1826 1827static 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 1846static 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 1864static 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 1873static DEVICE_ATTR_RW(termination);1874static DEVICE_ATTR_RO(fwinfo);1875 1876static struct attribute *ican3_sysfs_attrs[] = {1877 &dev_attr_termination.attr,1878 &dev_attr_fwinfo.attr,1879 NULL,1880};1881 1882static const struct attribute_group ican3_sysfs_attr_group = {1883 .attrs = ican3_sysfs_attrs,1884};1885 1886/*1887 * PCI Subsystem1888 */1889 1890static 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_SAMPLES1942 | CAN_CTRLMODE_BERR_REPORTING1943 | 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 2012out_free_irq:2013 napi_disable(&mod->napi);2014 iowrite8(1 << mod->num, &mod->ctrl->int_disable);2015 free_irq(mod->irq, mod);2016out_iounmap_ctrl:2017 iounmap(mod->ctrl);2018out_iounmap_dpm:2019 iounmap(mod->dpm);2020out_free_ndev:2021 free_candev(ndev);2022out_return:2023 return ret;2024}2025 2026static 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 2047static struct platform_driver ican3_driver = {2048 .driver = {2049 .name = DRV_NAME,2050 },2051 .probe = ican3_probe,2052 .remove = ican3_remove,2053};2054 2055module_platform_driver(ican3_driver);2056 2057MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");2058MODULE_DESCRIPTION("Janz MODULbus VMOD-ICAN3 Driver");2059MODULE_LICENSE("GPL");2060MODULE_ALIAS("platform:janz-ican3");2061