/* * sja1000.c - Philips SJA1000 network device driver * * Copyright (c) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33, * 38106 Braunschweig, GERMANY * * Copyright (c) 2002-2007 Volkswagen Group Electronic Research * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of Volkswagen nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * Alternatively, provided that this notice is retained in full, this * software may be distributed under the terms of the GNU General * Public License ("GPL") version 2, in which case the provisions of the * GPL apply INSTEAD OF those given above. * * The provided data structures and external interfaces from this code * are not restricted to be used by modules with a GPL compatible license. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "sja1000.h" #define DRV_NAME "sja1000" MODULE_AUTHOR("Oliver Hartkopp "); MODULE_LICENSE("Dual BSD/GPL"); MODULE_DESCRIPTION(DRV_NAME "CAN netdevice driver"); static struct can_bittiming_const sja1000_bittiming_const = { .name = DRV_NAME, .tseg1_min = 1, .tseg1_max = 16, .tseg2_min = 1, .tseg2_max = 8, .sjw_max = 4, .brp_min = 1, .brp_max = 64, .brp_inc = 1, }; static void sja1000_write_cmdreg(struct sja1000_priv *priv, u8 val) { unsigned long flags; /* * The command register needs some locking and time to settle * the write_reg() operation - especially on SMP systems. */ spin_lock_irqsave(&priv->cmdreg_lock, flags); priv->write_reg(priv, REG_CMR, val); priv->read_reg(priv, REG_SR); spin_unlock_irqrestore(&priv->cmdreg_lock, flags); } static int sja1000_is_absent(struct sja1000_priv *priv) { return (priv->read_reg(priv, REG_MOD) == 0xFF); } static int sja1000_probe_chip(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); if (priv->reg_base && sja1000_is_absent(priv)) { printk(KERN_INFO "%s: probing @0x%lX failed\n", DRV_NAME, dev->base_addr); return 0; } return -1; } static void set_reset_mode(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); unsigned char status = priv->read_reg(priv, REG_MOD); int i; /* disable interrupts */ priv->write_reg(priv, REG_IER, IRQ_OFF); for (i = 0; i < 100; i++) { /* check reset bit */ if (status & MOD_RM) { priv->can.state = CAN_STATE_STOPPED; return; } priv->write_reg(priv, REG_MOD, MOD_RM); /* reset chip */ udelay(10); status = priv->read_reg(priv, REG_MOD); } dev_err(dev->dev.parent, "setting SJA1000 into reset mode failed!\n"); } static void set_normal_mode(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); unsigned char status = priv->read_reg(priv, REG_MOD); int i; for (i = 0; i < 100; i++) { /* check reset bit */ if ((status & MOD_RM) == 0) { priv->can.state = CAN_STATE_ERROR_ACTIVE; /* enable interrupts */ if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) priv->write_reg(priv, REG_IER, IRQ_ALL); else priv->write_reg(priv, REG_IER, IRQ_ALL & ~IRQ_BEI); return; } /* set chip to normal mode */ priv->write_reg(priv, REG_MOD, 0x00); udelay(10); status = priv->read_reg(priv, REG_MOD); } dev_err(dev->dev.parent, "setting SJA1000 into normal mode failed!\n"); } static void sja1000_start(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); /* leave reset mode */ if (priv->can.state != CAN_STATE_STOPPED) set_reset_mode(dev); /* Clear error counters and error code capture */ priv->write_reg(priv, REG_TXERR, 0x0); priv->write_reg(priv, REG_RXERR, 0x0); priv->read_reg(priv, REG_ECC); /* leave reset mode */ set_normal_mode(dev); } static int sja1000_set_mode(struct net_device *dev, enum can_mode mode) { struct sja1000_priv *priv = netdev_priv(dev); if (!priv->open_time) return -EINVAL; switch (mode) { case CAN_MODE_START: sja1000_start(dev); if (netif_queue_stopped(dev)) netif_wake_queue(dev); break; default: return -EOPNOTSUPP; } return 0; } static int sja1000_set_bittiming(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); struct can_bittiming *bt = &priv->can.bittiming; u8 btr0, btr1; btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6); btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) | (((bt->phase_seg2 - 1) & 0x7) << 4); if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) btr1 |= 0x80; dev_info(dev->dev.parent, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1); priv->write_reg(priv, REG_BTR0, btr0); priv->write_reg(priv, REG_BTR1, btr1); return 0; } static int sja1000_get_berr_counter(const struct net_device *dev, struct can_berr_counter *bec) { struct sja1000_priv *priv = netdev_priv(dev); bec->txerr = priv->read_reg(priv, REG_TXERR); bec->rxerr = priv->read_reg(priv, REG_RXERR); return 0; } /* * initialize SJA1000 chip: * - reset chip * - set output mode * - set baudrate * - enable interrupts * - start operating mode */ static void chipset_init(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); /* set clock divider and output control register */ priv->write_reg(priv, REG_CDR, priv->cdr | CDR_PELICAN); /* set acceptance filter (accept all) */ priv->write_reg(priv, REG_ACCC0, 0x00); priv->write_reg(priv, REG_ACCC1, 0x00); priv->write_reg(priv, REG_ACCC2, 0x00); priv->write_reg(priv, REG_ACCC3, 0x00); priv->write_reg(priv, REG_ACCM0, 0xFF); priv->write_reg(priv, REG_ACCM1, 0xFF); priv->write_reg(priv, REG_ACCM2, 0xFF); priv->write_reg(priv, REG_ACCM3, 0xFF); priv->write_reg(priv, REG_OCR, priv->ocr | OCR_MODE_NORMAL); } /* * transmit a CAN message * message layout in the sk_buff should be like this: * xx xx xx xx ff ll 00 11 22 33 44 55 66 77 * [ can-id ] [flags] [len] [can data (up to 8 bytes] */ static netdev_tx_t sja1000_start_xmit(struct sk_buff *skb, struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); struct can_frame *cf = (struct can_frame *)skb->data; uint8_t fi; uint8_t dlc; canid_t id; uint8_t dreg; int i; if (can_dropped_invalid_skb(dev, skb)) return NETDEV_TX_OK; netif_stop_queue(dev); fi = dlc = cf->can_dlc; id = cf->can_id; if (id & CAN_RTR_FLAG) fi |= FI_RTR; if (id & CAN_EFF_FLAG) { fi |= FI_FF; dreg = EFF_BUF; priv->write_reg(priv, REG_FI, fi); priv->write_reg(priv, REG_ID1, (id & 0x1fe00000) >> (5 + 16)); priv->write_reg(priv, REG_ID2, (id & 0x001fe000) >> (5 + 8)); priv->write_reg(priv, REG_ID3, (id & 0x00001fe0) >> 5); priv->write_reg(priv, REG_ID4, (id & 0x0000001f) << 3); } else { dreg = SFF_BUF; priv->write_reg(priv, REG_FI, fi); priv->write_reg(priv, REG_ID1, (id & 0x000007f8) >> 3); priv->write_reg(priv, REG_ID2, (id & 0x00000007) << 5); } for (i = 0; i < dlc; i++) priv->write_reg(priv, dreg++, cf->data[i]); can_put_echo_skb(skb, dev, 0); sja1000_write_cmdreg(priv, CMD_TR); return NETDEV_TX_OK; } static void sja1000_rx(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); struct net_device_stats *stats = &dev->stats; struct can_frame *cf; struct sk_buff *skb; uint8_t fi; uint8_t dreg; canid_t id; int i; /* create zero'ed CAN frame buffer */ skb = alloc_can_skb(dev, &cf); if (skb == NULL) return; fi = priv->read_reg(priv, REG_FI); if (fi & FI_FF) { /* extended frame format (EFF) */ dreg = EFF_BUF; id = (priv->read_reg(priv, REG_ID1) << (5 + 16)) | (priv->read_reg(priv, REG_ID2) << (5 + 8)) | (priv->read_reg(priv, REG_ID3) << 5) | (priv->read_reg(priv, REG_ID4) >> 3); id |= CAN_EFF_FLAG; } else { /* standard frame format (SFF) */ dreg = SFF_BUF; id = (priv->read_reg(priv, REG_ID1) << 3) | (priv->read_reg(priv, REG_ID2) >> 5); } cf->can_dlc = get_can_dlc(fi & 0x0F); if (fi & FI_RTR) { id |= CAN_RTR_FLAG; } else { for (i = 0; i < cf->can_dlc; i++) cf->data[i] = priv->read_reg(priv, dreg++); } cf->can_id = id; /* release receive buffer */ sja1000_write_cmdreg(priv, CMD_RRB); netif_rx(skb); stats->rx_packets++; stats->rx_bytes += cf->can_dlc; } static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status) { struct sja1000_priv *priv = netdev_priv(dev); struct net_device_stats *stats = &dev->stats; struct can_frame *cf; struct sk_buff *skb; enum can_state state = priv->can.state; uint8_t ecc, alc; skb = alloc_can_err_skb(dev, &cf); if (skb == NULL) return -ENOMEM; if (isrc & IRQ_DOI) { /* data overrun interrupt */ dev_dbg(dev->dev.parent, "data overrun interrupt\n"); cf->can_id |= CAN_ERR_CRTL; cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; stats->rx_over_errors++; stats->rx_errors++; sja1000_write_cmdreg(priv, CMD_CDO); /* clear bit */ } if (isrc & IRQ_EI) { /* error warning interrupt */ dev_dbg(dev->dev.parent, "error warning interrupt\n"); if (status & SR_BS) { state = CAN_STATE_BUS_OFF; cf->can_id |= CAN_ERR_BUSOFF; can_bus_off(dev); } else if (status & SR_ES) { state = CAN_STATE_ERROR_WARNING; } else state = CAN_STATE_ERROR_ACTIVE; } if (isrc & IRQ_BEI) { /* bus error interrupt */ priv->can.can_stats.bus_error++; stats->rx_errors++; ecc = priv->read_reg(priv, REG_ECC); cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; switch (ecc & ECC_MASK) { case ECC_BIT: cf->data[2] |= CAN_ERR_PROT_BIT; break; case ECC_FORM: cf->data[2] |= CAN_ERR_PROT_FORM; break; case ECC_STUFF: cf->data[2] |= CAN_ERR_PROT_STUFF; break; default: cf->data[2] |= CAN_ERR_PROT_UNSPEC; cf->data[3] = ecc & ECC_SEG; break; } /* Error occurred during transmission? */ if ((ecc & ECC_DIR) == 0) cf->data[2] |= CAN_ERR_PROT_TX; } if (isrc & IRQ_EPI) { /* error passive interrupt */ dev_dbg(dev->dev.parent, "error passive interrupt\n"); if (status & SR_ES) state = CAN_STATE_ERROR_PASSIVE; else state = CAN_STATE_ERROR_ACTIVE; } if (isrc & IRQ_ALI) { /* arbitration lost interrupt */ dev_dbg(dev->dev.parent, "arbitration lost interrupt\n"); alc = priv->read_reg(priv, REG_ALC); priv->can.can_stats.arbitration_lost++; stats->tx_errors++; cf->can_id |= CAN_ERR_LOSTARB; cf->data[0] = alc & 0x1f; } if (state != priv->can.state && (state == CAN_STATE_ERROR_WARNING || state == CAN_STATE_ERROR_PASSIVE)) { uint8_t rxerr = priv->read_reg(priv, REG_RXERR); uint8_t txerr = priv->read_reg(priv, REG_TXERR); cf->can_id |= CAN_ERR_CRTL; if (state == CAN_STATE_ERROR_WARNING) { priv->can.can_stats.error_warning++; cf->data[1] = (txerr > rxerr) ? CAN_ERR_CRTL_TX_WARNING : CAN_ERR_CRTL_RX_WARNING; } else { priv->can.can_stats.error_passive++; cf->data[1] = (txerr > rxerr) ? CAN_ERR_CRTL_TX_PASSIVE : CAN_ERR_CRTL_RX_PASSIVE; } cf->data[6] = txerr; cf->data[7] = rxerr; } priv->can.state = state; netif_rx(skb); stats->rx_packets++; stats->rx_bytes += cf->can_dlc; return 0; } irqreturn_t sja1000_interrupt(int irq, void *dev_id) { struct net_device *dev = (struct net_device *)dev_id; struct sja1000_priv *priv = netdev_priv(dev); struct net_device_stats *stats = &dev->stats; uint8_t isrc, status; int n = 0; /* Shared interrupts and IRQ off? */ if (priv->read_reg(priv, REG_IER) == IRQ_OFF) return IRQ_NONE; if (priv->pre_irq) priv->pre_irq(priv); while ((isrc = priv->read_reg(priv, REG_IR)) && (n < SJA1000_MAX_IRQ)) { n++; status = priv->read_reg(priv, REG_SR); /* check for absent controller due to hw unplug */ if (status == 0xFF && sja1000_is_absent(priv)) return IRQ_NONE; if (isrc & IRQ_WUI) dev_warn(dev->dev.parent, "wakeup interrupt\n"); if (isrc & IRQ_TI) { /* transmission complete interrupt */ stats->tx_bytes += priv->read_reg(priv, REG_FI) & 0xf; stats->tx_packets++; can_get_echo_skb(dev, 0); netif_wake_queue(dev); } if (isrc & IRQ_RI) { /* receive interrupt */ while (status & SR_RBS) { sja1000_rx(dev); status = priv->read_reg(priv, REG_SR); /* check for absent controller */ if (status == 0xFF && sja1000_is_absent(priv)) return IRQ_NONE; } } if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) { /* error interrupt */ if (sja1000_err(dev, isrc, status)) break; } } if (priv->post_irq) priv->post_irq(priv); if (n >= SJA1000_MAX_IRQ) dev_dbg(dev->dev.parent, "%d messages handled in ISR", n); return (n) ? IRQ_HANDLED : IRQ_NONE; } EXPORT_SYMBOL_GPL(sja1000_interrupt); static int sja1000_open(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); int err; /* set chip into reset mode */ set_reset_mode(dev); /* common open */ err = open_candev(dev); if (err) return err; /* register interrupt handler, if not done by the device driver */ if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER)) { err = request_irq(dev->irq, sja1000_interrupt, priv->irq_flags, dev->name, (void *)dev); if (err) { close_candev(dev); return -EAGAIN; } } /* init and start chi */ sja1000_start(dev); priv->open_time = jiffies; netif_start_queue(dev); return 0; } static int sja1000_close(struct net_device *dev) { struct sja1000_priv *priv = netdev_priv(dev); netif_stop_queue(dev); set_reset_mode(dev); if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER)) free_irq(dev->irq, (void *)dev); close_candev(dev); priv->open_time = 0; return 0; } struct net_device *alloc_sja1000dev(int sizeof_priv) { struct net_device *dev; struct sja1000_priv *priv; dev = alloc_candev(sizeof(struct sja1000_priv) + sizeof_priv, SJA1000_ECHO_SKB_MAX); if (!dev) return NULL; priv = netdev_priv(dev); priv->dev = dev; priv->can.bittiming_const = &sja1000_bittiming_const; priv->can.do_set_bittiming = sja1000_set_bittiming; priv->can.do_set_mode = sja1000_set_mode; priv->can.do_get_berr_counter = sja1000_get_berr_counter; priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_BERR_REPORTING; spin_lock_init(&priv->cmdreg_lock); if (sizeof_priv) priv->priv = (void *)priv + sizeof(struct sja1000_priv); return dev; } EXPORT_SYMBOL_GPL(alloc_sja1000dev); void free_sja1000dev(struct net_device *dev) { free_candev(dev); } EXPORT_SYMBOL_GPL(free_sja1000dev); static const struct net_device_ops sja1000_netdev_ops = { .ndo_open = sja1000_open, .ndo_stop = sja1000_close, .ndo_start_xmit = sja1000_start_xmit, }; int register_sja1000dev(struct net_device *dev) { if (!sja1000_probe_chip(dev)) return -ENODEV; dev->flags |= IFF_ECHO; /* we support local echo */ dev->netdev_ops = &sja1000_netdev_ops; set_reset_mode(dev); chipset_init(dev); return register_candev(dev); } EXPORT_SYMBOL_GPL(register_sja1000dev); void unregister_sja1000dev(struct net_device *dev) { set_reset_mode(dev); unregister_candev(dev); } EXPORT_SYMBOL_GPL(unregister_sja1000dev); static __init int sja1000_init(void) { printk(KERN_INFO "%s CAN netdevice driver\n", DRV_NAME); return 0; } module_init(sja1000_init); static __exit void sja1000_exit(void) { printk(KERN_INFO "%s: driver removed\n", DRV_NAME); } module_exit(sja1000_exit);