Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 1 | /* |
| 2 | * sja1000.c - Philips SJA1000 network device driver |
| 3 | * |
| 4 | * Copyright (c) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33, |
| 5 | * 38106 Braunschweig, GERMANY |
| 6 | * |
| 7 | * Copyright (c) 2002-2007 Volkswagen Group Electronic Research |
| 8 | * All rights reserved. |
| 9 | * |
| 10 | * Redistribution and use in source and binary forms, with or without |
| 11 | * modification, are permitted provided that the following conditions |
| 12 | * are met: |
| 13 | * 1. Redistributions of source code must retain the above copyright |
| 14 | * notice, this list of conditions and the following disclaimer. |
| 15 | * 2. Redistributions in binary form must reproduce the above copyright |
| 16 | * notice, this list of conditions and the following disclaimer in the |
| 17 | * documentation and/or other materials provided with the distribution. |
| 18 | * 3. Neither the name of Volkswagen nor the names of its contributors |
| 19 | * may be used to endorse or promote products derived from this software |
| 20 | * without specific prior written permission. |
| 21 | * |
| 22 | * Alternatively, provided that this notice is retained in full, this |
| 23 | * software may be distributed under the terms of the GNU General |
| 24 | * Public License ("GPL") version 2, in which case the provisions of the |
| 25 | * GPL apply INSTEAD OF those given above. |
| 26 | * |
| 27 | * The provided data structures and external interfaces from this code |
| 28 | * are not restricted to be used by modules with a GPL compatible license. |
| 29 | * |
| 30 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 31 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 32 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 33 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 34 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 35 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 36 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 37 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 38 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 39 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 40 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH |
| 41 | * DAMAGE. |
| 42 | * |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 43 | */ |
| 44 | |
| 45 | #include <linux/module.h> |
| 46 | #include <linux/init.h> |
| 47 | #include <linux/kernel.h> |
| 48 | #include <linux/sched.h> |
| 49 | #include <linux/types.h> |
| 50 | #include <linux/fcntl.h> |
| 51 | #include <linux/interrupt.h> |
| 52 | #include <linux/ptrace.h> |
| 53 | #include <linux/string.h> |
| 54 | #include <linux/errno.h> |
| 55 | #include <linux/netdevice.h> |
| 56 | #include <linux/if_arp.h> |
| 57 | #include <linux/if_ether.h> |
| 58 | #include <linux/skbuff.h> |
| 59 | #include <linux/delay.h> |
| 60 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 61 | #include <linux/can/dev.h> |
| 62 | #include <linux/can/error.h> |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 63 | #include <linux/can/led.h> |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 64 | |
| 65 | #include "sja1000.h" |
| 66 | |
| 67 | #define DRV_NAME "sja1000" |
| 68 | |
| 69 | MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>"); |
| 70 | MODULE_LICENSE("Dual BSD/GPL"); |
| 71 | MODULE_DESCRIPTION(DRV_NAME "CAN netdevice driver"); |
| 72 | |
Marc Kleine-Budde | 194b9a4 | 2012-07-16 12:58:31 +0200 | [diff] [blame] | 73 | static const struct can_bittiming_const sja1000_bittiming_const = { |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 74 | .name = DRV_NAME, |
| 75 | .tseg1_min = 1, |
| 76 | .tseg1_max = 16, |
| 77 | .tseg2_min = 1, |
| 78 | .tseg2_max = 8, |
| 79 | .sjw_max = 4, |
| 80 | .brp_min = 1, |
| 81 | .brp_max = 64, |
| 82 | .brp_inc = 1, |
| 83 | }; |
| 84 | |
Oliver Hartkopp | 57c8a45 | 2010-05-18 14:03:10 -0700 | [diff] [blame] | 85 | static void sja1000_write_cmdreg(struct sja1000_priv *priv, u8 val) |
| 86 | { |
| 87 | unsigned long flags; |
| 88 | |
| 89 | /* |
| 90 | * The command register needs some locking and time to settle |
| 91 | * the write_reg() operation - especially on SMP systems. |
| 92 | */ |
| 93 | spin_lock_irqsave(&priv->cmdreg_lock, flags); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 94 | priv->write_reg(priv, SJA1000_CMR, val); |
| 95 | priv->read_reg(priv, SJA1000_SR); |
Oliver Hartkopp | 57c8a45 | 2010-05-18 14:03:10 -0700 | [diff] [blame] | 96 | spin_unlock_irqrestore(&priv->cmdreg_lock, flags); |
| 97 | } |
| 98 | |
Oliver Hartkopp | a7762b1 | 2012-02-15 17:51:56 +0100 | [diff] [blame] | 99 | static int sja1000_is_absent(struct sja1000_priv *priv) |
| 100 | { |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 101 | return (priv->read_reg(priv, SJA1000_MOD) == 0xFF); |
Oliver Hartkopp | a7762b1 | 2012-02-15 17:51:56 +0100 | [diff] [blame] | 102 | } |
| 103 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 104 | static int sja1000_probe_chip(struct net_device *dev) |
| 105 | { |
| 106 | struct sja1000_priv *priv = netdev_priv(dev); |
| 107 | |
Oliver Hartkopp | a7762b1 | 2012-02-15 17:51:56 +0100 | [diff] [blame] | 108 | if (priv->reg_base && sja1000_is_absent(priv)) { |
Florian Vaussard | 909285c | 2014-01-31 14:34:33 +0100 | [diff] [blame] | 109 | netdev_err(dev, "probing failed\n"); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 110 | return 0; |
| 111 | } |
| 112 | return -1; |
| 113 | } |
| 114 | |
| 115 | static void set_reset_mode(struct net_device *dev) |
| 116 | { |
| 117 | struct sja1000_priv *priv = netdev_priv(dev); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 118 | unsigned char status = priv->read_reg(priv, SJA1000_MOD); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 119 | int i; |
| 120 | |
| 121 | /* disable interrupts */ |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 122 | priv->write_reg(priv, SJA1000_IER, IRQ_OFF); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 123 | |
| 124 | for (i = 0; i < 100; i++) { |
| 125 | /* check reset bit */ |
| 126 | if (status & MOD_RM) { |
| 127 | priv->can.state = CAN_STATE_STOPPED; |
| 128 | return; |
| 129 | } |
| 130 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 131 | /* reset chip */ |
| 132 | priv->write_reg(priv, SJA1000_MOD, MOD_RM); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 133 | udelay(10); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 134 | status = priv->read_reg(priv, SJA1000_MOD); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 135 | } |
| 136 | |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 137 | netdev_err(dev, "setting SJA1000 into reset mode failed!\n"); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | static void set_normal_mode(struct net_device *dev) |
| 141 | { |
| 142 | struct sja1000_priv *priv = netdev_priv(dev); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 143 | unsigned char status = priv->read_reg(priv, SJA1000_MOD); |
Nikita Edward Baruzdin | 5b853ec | 2014-07-11 16:13:23 +0400 | [diff] [blame] | 144 | u8 mod_reg_val = 0x00; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 145 | int i; |
| 146 | |
| 147 | for (i = 0; i < 100; i++) { |
| 148 | /* check reset bit */ |
| 149 | if ((status & MOD_RM) == 0) { |
| 150 | priv->can.state = CAN_STATE_ERROR_ACTIVE; |
Wolfgang Grandegger | 52c793f | 2010-02-22 22:21:17 +0000 | [diff] [blame] | 151 | /* enable interrupts */ |
| 152 | if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 153 | priv->write_reg(priv, SJA1000_IER, IRQ_ALL); |
Wolfgang Grandegger | 52c793f | 2010-02-22 22:21:17 +0000 | [diff] [blame] | 154 | else |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 155 | priv->write_reg(priv, SJA1000_IER, |
Wolfgang Grandegger | 52c793f | 2010-02-22 22:21:17 +0000 | [diff] [blame] | 156 | IRQ_ALL & ~IRQ_BEI); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 157 | return; |
| 158 | } |
| 159 | |
| 160 | /* set chip to normal mode */ |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 161 | if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) |
Nikita Edward Baruzdin | 5b853ec | 2014-07-11 16:13:23 +0400 | [diff] [blame] | 162 | mod_reg_val |= MOD_LOM; |
| 163 | if (priv->can.ctrlmode & CAN_CTRLMODE_PRESUME_ACK) |
| 164 | mod_reg_val |= MOD_STM; |
| 165 | priv->write_reg(priv, SJA1000_MOD, mod_reg_val); |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 166 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 167 | udelay(10); |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 168 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 169 | status = priv->read_reg(priv, SJA1000_MOD); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 170 | } |
| 171 | |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 172 | netdev_err(dev, "setting SJA1000 into normal mode failed!\n"); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 173 | } |
| 174 | |
Mirza Krak | 9e37bc6 | 2014-08-08 14:30:50 +0200 | [diff] [blame] | 175 | /* |
| 176 | * initialize SJA1000 chip: |
| 177 | * - reset chip |
| 178 | * - set output mode |
| 179 | * - set baudrate |
| 180 | * - enable interrupts |
| 181 | * - start operating mode |
| 182 | */ |
| 183 | static void chipset_init(struct net_device *dev) |
| 184 | { |
| 185 | struct sja1000_priv *priv = netdev_priv(dev); |
| 186 | |
| 187 | /* set clock divider and output control register */ |
| 188 | priv->write_reg(priv, SJA1000_CDR, priv->cdr | CDR_PELICAN); |
| 189 | |
| 190 | /* set acceptance filter (accept all) */ |
| 191 | priv->write_reg(priv, SJA1000_ACCC0, 0x00); |
| 192 | priv->write_reg(priv, SJA1000_ACCC1, 0x00); |
| 193 | priv->write_reg(priv, SJA1000_ACCC2, 0x00); |
| 194 | priv->write_reg(priv, SJA1000_ACCC3, 0x00); |
| 195 | |
| 196 | priv->write_reg(priv, SJA1000_ACCM0, 0xFF); |
| 197 | priv->write_reg(priv, SJA1000_ACCM1, 0xFF); |
| 198 | priv->write_reg(priv, SJA1000_ACCM2, 0xFF); |
| 199 | priv->write_reg(priv, SJA1000_ACCM3, 0xFF); |
| 200 | |
| 201 | priv->write_reg(priv, SJA1000_OCR, priv->ocr | OCR_MODE_NORMAL); |
| 202 | } |
| 203 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 204 | static void sja1000_start(struct net_device *dev) |
| 205 | { |
| 206 | struct sja1000_priv *priv = netdev_priv(dev); |
| 207 | |
| 208 | /* leave reset mode */ |
| 209 | if (priv->can.state != CAN_STATE_STOPPED) |
| 210 | set_reset_mode(dev); |
| 211 | |
Mirza Krak | 9e37bc6 | 2014-08-08 14:30:50 +0200 | [diff] [blame] | 212 | /* Initialize chip if uninitialized at this stage */ |
| 213 | if (!(priv->read_reg(priv, SJA1000_CDR) & CDR_PELICAN)) |
| 214 | chipset_init(dev); |
| 215 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 216 | /* Clear error counters and error code capture */ |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 217 | priv->write_reg(priv, SJA1000_TXERR, 0x0); |
| 218 | priv->write_reg(priv, SJA1000_RXERR, 0x0); |
| 219 | priv->read_reg(priv, SJA1000_ECC); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 220 | |
Mirza Krak | 7cecd9a | 2015-11-10 14:59:34 +0100 | [diff] [blame] | 221 | /* clear interrupt flags */ |
| 222 | priv->read_reg(priv, SJA1000_IR); |
| 223 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 224 | /* leave reset mode */ |
| 225 | set_normal_mode(dev); |
| 226 | } |
| 227 | |
| 228 | static int sja1000_set_mode(struct net_device *dev, enum can_mode mode) |
| 229 | { |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 230 | switch (mode) { |
| 231 | case CAN_MODE_START: |
| 232 | sja1000_start(dev); |
| 233 | if (netif_queue_stopped(dev)) |
| 234 | netif_wake_queue(dev); |
| 235 | break; |
| 236 | |
| 237 | default: |
| 238 | return -EOPNOTSUPP; |
| 239 | } |
| 240 | |
| 241 | return 0; |
| 242 | } |
| 243 | |
| 244 | static int sja1000_set_bittiming(struct net_device *dev) |
| 245 | { |
| 246 | struct sja1000_priv *priv = netdev_priv(dev); |
| 247 | struct can_bittiming *bt = &priv->can.bittiming; |
| 248 | u8 btr0, btr1; |
| 249 | |
| 250 | btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6); |
| 251 | btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) | |
| 252 | (((bt->phase_seg2 - 1) & 0x7) << 4); |
| 253 | if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) |
| 254 | btr1 |= 0x80; |
| 255 | |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 256 | netdev_info(dev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 257 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 258 | priv->write_reg(priv, SJA1000_BTR0, btr0); |
| 259 | priv->write_reg(priv, SJA1000_BTR1, btr1); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 260 | |
| 261 | return 0; |
| 262 | } |
| 263 | |
Wolfgang Grandegger | 52c793f | 2010-02-22 22:21:17 +0000 | [diff] [blame] | 264 | static int sja1000_get_berr_counter(const struct net_device *dev, |
| 265 | struct can_berr_counter *bec) |
| 266 | { |
| 267 | struct sja1000_priv *priv = netdev_priv(dev); |
| 268 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 269 | bec->txerr = priv->read_reg(priv, SJA1000_TXERR); |
| 270 | bec->rxerr = priv->read_reg(priv, SJA1000_RXERR); |
Wolfgang Grandegger | 52c793f | 2010-02-22 22:21:17 +0000 | [diff] [blame] | 271 | |
| 272 | return 0; |
| 273 | } |
| 274 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 275 | /* |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 276 | * transmit a CAN message |
| 277 | * message layout in the sk_buff should be like this: |
| 278 | * xx xx xx xx ff ll 00 11 22 33 44 55 66 77 |
| 279 | * [ can-id ] [flags] [len] [can data (up to 8 bytes] |
| 280 | */ |
Stephen Hemminger | 61357325 | 2009-08-31 19:50:58 +0000 | [diff] [blame] | 281 | static netdev_tx_t sja1000_start_xmit(struct sk_buff *skb, |
| 282 | struct net_device *dev) |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 283 | { |
| 284 | struct sja1000_priv *priv = netdev_priv(dev); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 285 | struct can_frame *cf = (struct can_frame *)skb->data; |
| 286 | uint8_t fi; |
| 287 | uint8_t dlc; |
| 288 | canid_t id; |
| 289 | uint8_t dreg; |
Nikita Edward Baruzdin | dcf9e15 | 2014-07-11 16:13:20 +0400 | [diff] [blame] | 290 | u8 cmd_reg_val = 0x00; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 291 | int i; |
| 292 | |
Oliver Hartkopp | 3ccd4c6 | 2010-01-12 02:00:46 -0800 | [diff] [blame] | 293 | if (can_dropped_invalid_skb(dev, skb)) |
| 294 | return NETDEV_TX_OK; |
| 295 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 296 | netif_stop_queue(dev); |
| 297 | |
| 298 | fi = dlc = cf->can_dlc; |
| 299 | id = cf->can_id; |
| 300 | |
| 301 | if (id & CAN_RTR_FLAG) |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 302 | fi |= SJA1000_FI_RTR; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 303 | |
| 304 | if (id & CAN_EFF_FLAG) { |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 305 | fi |= SJA1000_FI_FF; |
| 306 | dreg = SJA1000_EFF_BUF; |
| 307 | priv->write_reg(priv, SJA1000_FI, fi); |
| 308 | priv->write_reg(priv, SJA1000_ID1, (id & 0x1fe00000) >> 21); |
| 309 | priv->write_reg(priv, SJA1000_ID2, (id & 0x001fe000) >> 13); |
| 310 | priv->write_reg(priv, SJA1000_ID3, (id & 0x00001fe0) >> 5); |
| 311 | priv->write_reg(priv, SJA1000_ID4, (id & 0x0000001f) << 3); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 312 | } else { |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 313 | dreg = SJA1000_SFF_BUF; |
| 314 | priv->write_reg(priv, SJA1000_FI, fi); |
| 315 | priv->write_reg(priv, SJA1000_ID1, (id & 0x000007f8) >> 3); |
| 316 | priv->write_reg(priv, SJA1000_ID2, (id & 0x00000007) << 5); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | for (i = 0; i < dlc; i++) |
Wolfgang Grandegger | 255a915 | 2009-05-30 07:55:49 +0000 | [diff] [blame] | 320 | priv->write_reg(priv, dreg++, cf->data[i]); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 321 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 322 | can_put_echo_skb(skb, dev, 0); |
| 323 | |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 324 | if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) |
Nikita Edward Baruzdin | dcf9e15 | 2014-07-11 16:13:20 +0400 | [diff] [blame] | 325 | cmd_reg_val |= CMD_AT; |
| 326 | |
| 327 | if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) |
| 328 | cmd_reg_val |= CMD_SRR; |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 329 | else |
Nikita Edward Baruzdin | dcf9e15 | 2014-07-11 16:13:20 +0400 | [diff] [blame] | 330 | cmd_reg_val |= CMD_TR; |
| 331 | |
| 332 | sja1000_write_cmdreg(priv, cmd_reg_val); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 333 | |
Patrick McHardy | 6ed1065 | 2009-06-23 06:03:08 +0000 | [diff] [blame] | 334 | return NETDEV_TX_OK; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | static void sja1000_rx(struct net_device *dev) |
| 338 | { |
| 339 | struct sja1000_priv *priv = netdev_priv(dev); |
| 340 | struct net_device_stats *stats = &dev->stats; |
| 341 | struct can_frame *cf; |
| 342 | struct sk_buff *skb; |
| 343 | uint8_t fi; |
| 344 | uint8_t dreg; |
| 345 | canid_t id; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 346 | int i; |
| 347 | |
Oliver Hartkopp | c7cd606 | 2009-12-12 04:13:21 +0000 | [diff] [blame] | 348 | /* create zero'ed CAN frame buffer */ |
Wolfgang Grandegger | 7b6856a | 2009-10-20 00:08:01 -0700 | [diff] [blame] | 349 | skb = alloc_can_skb(dev, &cf); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 350 | if (skb == NULL) |
| 351 | return; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 352 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 353 | fi = priv->read_reg(priv, SJA1000_FI); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 354 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 355 | if (fi & SJA1000_FI_FF) { |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 356 | /* extended frame format (EFF) */ |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 357 | dreg = SJA1000_EFF_BUF; |
| 358 | id = (priv->read_reg(priv, SJA1000_ID1) << 21) |
| 359 | | (priv->read_reg(priv, SJA1000_ID2) << 13) |
| 360 | | (priv->read_reg(priv, SJA1000_ID3) << 5) |
| 361 | | (priv->read_reg(priv, SJA1000_ID4) >> 3); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 362 | id |= CAN_EFF_FLAG; |
| 363 | } else { |
| 364 | /* standard frame format (SFF) */ |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 365 | dreg = SJA1000_SFF_BUF; |
| 366 | id = (priv->read_reg(priv, SJA1000_ID1) << 3) |
| 367 | | (priv->read_reg(priv, SJA1000_ID2) >> 5); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 368 | } |
| 369 | |
Kurt Van Dijck | 87e9af6 | 2011-05-02 04:50:48 +0000 | [diff] [blame] | 370 | cf->can_dlc = get_can_dlc(fi & 0x0F); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 371 | if (fi & SJA1000_FI_RTR) { |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 372 | id |= CAN_RTR_FLAG; |
Oliver Hartkopp | c7cd606 | 2009-12-12 04:13:21 +0000 | [diff] [blame] | 373 | } else { |
Oliver Hartkopp | c7cd606 | 2009-12-12 04:13:21 +0000 | [diff] [blame] | 374 | for (i = 0; i < cf->can_dlc; i++) |
| 375 | cf->data[i] = priv->read_reg(priv, dreg++); |
| 376 | } |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 377 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 378 | cf->can_id = id; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 379 | |
| 380 | /* release receive buffer */ |
Oliver Hartkopp | 57c8a45 | 2010-05-18 14:03:10 -0700 | [diff] [blame] | 381 | sja1000_write_cmdreg(priv, CMD_RRB); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 382 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 383 | stats->rx_packets++; |
Oliver Hartkopp | c7cd606 | 2009-12-12 04:13:21 +0000 | [diff] [blame] | 384 | stats->rx_bytes += cf->can_dlc; |
Marc Kleine-Budde | 889dd06 | 2015-07-11 21:16:08 +0200 | [diff] [blame] | 385 | netif_rx(skb); |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 386 | |
| 387 | can_led_event(dev, CAN_LED_EVENT_RX); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status) |
| 391 | { |
| 392 | struct sja1000_priv *priv = netdev_priv(dev); |
| 393 | struct net_device_stats *stats = &dev->stats; |
| 394 | struct can_frame *cf; |
| 395 | struct sk_buff *skb; |
| 396 | enum can_state state = priv->can.state; |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 397 | enum can_state rx_state, tx_state; |
| 398 | unsigned int rxerr, txerr; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 399 | uint8_t ecc, alc; |
| 400 | |
Wolfgang Grandegger | 7b6856a | 2009-10-20 00:08:01 -0700 | [diff] [blame] | 401 | skb = alloc_can_err_skb(dev, &cf); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 402 | if (skb == NULL) |
| 403 | return -ENOMEM; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 404 | |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 405 | txerr = priv->read_reg(priv, SJA1000_TXERR); |
| 406 | rxerr = priv->read_reg(priv, SJA1000_RXERR); |
| 407 | |
| 408 | cf->data[6] = txerr; |
| 409 | cf->data[7] = rxerr; |
| 410 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 411 | if (isrc & IRQ_DOI) { |
| 412 | /* data overrun interrupt */ |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 413 | netdev_dbg(dev, "data overrun interrupt\n"); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 414 | cf->can_id |= CAN_ERR_CRTL; |
| 415 | cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
| 416 | stats->rx_over_errors++; |
| 417 | stats->rx_errors++; |
Oliver Hartkopp | 57c8a45 | 2010-05-18 14:03:10 -0700 | [diff] [blame] | 418 | sja1000_write_cmdreg(priv, CMD_CDO); /* clear bit */ |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 419 | } |
| 420 | |
| 421 | if (isrc & IRQ_EI) { |
| 422 | /* error warning interrupt */ |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 423 | netdev_dbg(dev, "error warning interrupt\n"); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 424 | |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 425 | if (status & SR_BS) |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 426 | state = CAN_STATE_BUS_OFF; |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 427 | else if (status & SR_ES) |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 428 | state = CAN_STATE_ERROR_WARNING; |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 429 | else |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 430 | state = CAN_STATE_ERROR_ACTIVE; |
| 431 | } |
| 432 | if (isrc & IRQ_BEI) { |
| 433 | /* bus error interrupt */ |
| 434 | priv->can.can_stats.bus_error++; |
| 435 | stats->rx_errors++; |
| 436 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 437 | ecc = priv->read_reg(priv, SJA1000_ECC); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 438 | |
| 439 | cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; |
| 440 | |
| 441 | switch (ecc & ECC_MASK) { |
| 442 | case ECC_BIT: |
| 443 | cf->data[2] |= CAN_ERR_PROT_BIT; |
| 444 | break; |
| 445 | case ECC_FORM: |
| 446 | cf->data[2] |= CAN_ERR_PROT_FORM; |
| 447 | break; |
| 448 | case ECC_STUFF: |
| 449 | cf->data[2] |= CAN_ERR_PROT_STUFF; |
| 450 | break; |
| 451 | default: |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 452 | cf->data[3] = ecc & ECC_SEG; |
| 453 | break; |
| 454 | } |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 455 | /* Error occurred during transmission? */ |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 456 | if ((ecc & ECC_DIR) == 0) |
| 457 | cf->data[2] |= CAN_ERR_PROT_TX; |
| 458 | } |
| 459 | if (isrc & IRQ_EPI) { |
| 460 | /* error passive interrupt */ |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 461 | netdev_dbg(dev, "error passive interrupt\n"); |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 462 | |
| 463 | if (state == CAN_STATE_ERROR_PASSIVE) |
| 464 | state = CAN_STATE_ERROR_WARNING; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 465 | else |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 466 | state = CAN_STATE_ERROR_PASSIVE; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 467 | } |
| 468 | if (isrc & IRQ_ALI) { |
| 469 | /* arbitration lost interrupt */ |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 470 | netdev_dbg(dev, "arbitration lost interrupt\n"); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 471 | alc = priv->read_reg(priv, SJA1000_ALC); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 472 | priv->can.can_stats.arbitration_lost++; |
Wolfgang Grandegger | 8935f57 | 2009-09-01 05:29:41 +0000 | [diff] [blame] | 473 | stats->tx_errors++; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 474 | cf->can_id |= CAN_ERR_LOSTARB; |
| 475 | cf->data[0] = alc & 0x1f; |
| 476 | } |
| 477 | |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 478 | if (state != priv->can.state) { |
| 479 | tx_state = txerr >= rxerr ? state : 0; |
| 480 | rx_state = txerr <= rxerr ? state : 0; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 481 | |
Andri Yngvason | 215db18 | 2014-12-03 17:54:13 +0000 | [diff] [blame] | 482 | can_change_state(dev, cf, tx_state, rx_state); |
| 483 | |
| 484 | if(state == CAN_STATE_BUS_OFF) |
| 485 | can_bus_off(dev); |
| 486 | } |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 487 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 488 | stats->rx_packets++; |
| 489 | stats->rx_bytes += cf->can_dlc; |
Marc Kleine-Budde | 889dd06 | 2015-07-11 21:16:08 +0200 | [diff] [blame] | 490 | netif_rx(skb); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 491 | |
| 492 | return 0; |
| 493 | } |
| 494 | |
| 495 | irqreturn_t sja1000_interrupt(int irq, void *dev_id) |
| 496 | { |
| 497 | struct net_device *dev = (struct net_device *)dev_id; |
| 498 | struct sja1000_priv *priv = netdev_priv(dev); |
| 499 | struct net_device_stats *stats = &dev->stats; |
| 500 | uint8_t isrc, status; |
| 501 | int n = 0; |
| 502 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 503 | if (priv->pre_irq) |
Wolfgang Grandegger | 255a915 | 2009-05-30 07:55:49 +0000 | [diff] [blame] | 504 | priv->pre_irq(priv); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 505 | |
Oliver Hartkopp | 2fea6cd | 2013-11-21 18:03:07 +0100 | [diff] [blame] | 506 | /* Shared interrupts and IRQ off? */ |
| 507 | if (priv->read_reg(priv, SJA1000_IER) == IRQ_OFF) |
| 508 | goto out; |
| 509 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 510 | while ((isrc = priv->read_reg(priv, SJA1000_IR)) && |
| 511 | (n < SJA1000_MAX_IRQ)) { |
Oliver Hartkopp | 2fea6cd | 2013-11-21 18:03:07 +0100 | [diff] [blame] | 512 | |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 513 | status = priv->read_reg(priv, SJA1000_SR); |
Oliver Hartkopp | a7762b1 | 2012-02-15 17:51:56 +0100 | [diff] [blame] | 514 | /* check for absent controller due to hw unplug */ |
| 515 | if (status == 0xFF && sja1000_is_absent(priv)) |
Oliver Hartkopp | 2fea6cd | 2013-11-21 18:03:07 +0100 | [diff] [blame] | 516 | goto out; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 517 | |
| 518 | if (isrc & IRQ_WUI) |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 519 | netdev_warn(dev, "wakeup interrupt\n"); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 520 | |
| 521 | if (isrc & IRQ_TI) { |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 522 | /* transmission buffer released */ |
| 523 | if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT && |
| 524 | !(status & SR_TCS)) { |
| 525 | stats->tx_errors++; |
| 526 | can_free_echo_skb(dev, 0); |
| 527 | } else { |
| 528 | /* transmission complete */ |
| 529 | stats->tx_bytes += |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 530 | priv->read_reg(priv, SJA1000_FI) & 0xf; |
Andreas Larsson | 7146b2d | 2012-09-20 09:50:41 +0200 | [diff] [blame] | 531 | stats->tx_packets++; |
| 532 | can_get_echo_skb(dev, 0); |
| 533 | } |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 534 | netif_wake_queue(dev); |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 535 | can_led_event(dev, CAN_LED_EVENT_TX); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 536 | } |
| 537 | if (isrc & IRQ_RI) { |
| 538 | /* receive interrupt */ |
| 539 | while (status & SR_RBS) { |
| 540 | sja1000_rx(dev); |
Oliver Hartkopp | 06e1d1d | 2013-04-13 21:35:49 +0200 | [diff] [blame] | 541 | status = priv->read_reg(priv, SJA1000_SR); |
Oliver Hartkopp | a7762b1 | 2012-02-15 17:51:56 +0100 | [diff] [blame] | 542 | /* check for absent controller */ |
| 543 | if (status == 0xFF && sja1000_is_absent(priv)) |
Oliver Hartkopp | 2fea6cd | 2013-11-21 18:03:07 +0100 | [diff] [blame] | 544 | goto out; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 545 | } |
| 546 | } |
| 547 | if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) { |
| 548 | /* error interrupt */ |
| 549 | if (sja1000_err(dev, isrc, status)) |
| 550 | break; |
| 551 | } |
Oliver Hartkopp | 2fea6cd | 2013-11-21 18:03:07 +0100 | [diff] [blame] | 552 | n++; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 553 | } |
Oliver Hartkopp | 2fea6cd | 2013-11-21 18:03:07 +0100 | [diff] [blame] | 554 | out: |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 555 | if (priv->post_irq) |
Wolfgang Grandegger | 255a915 | 2009-05-30 07:55:49 +0000 | [diff] [blame] | 556 | priv->post_irq(priv); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 557 | |
| 558 | if (n >= SJA1000_MAX_IRQ) |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 559 | netdev_dbg(dev, "%d messages handled in ISR", n); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 560 | |
| 561 | return (n) ? IRQ_HANDLED : IRQ_NONE; |
| 562 | } |
| 563 | EXPORT_SYMBOL_GPL(sja1000_interrupt); |
| 564 | |
| 565 | static int sja1000_open(struct net_device *dev) |
| 566 | { |
| 567 | struct sja1000_priv *priv = netdev_priv(dev); |
| 568 | int err; |
| 569 | |
| 570 | /* set chip into reset mode */ |
| 571 | set_reset_mode(dev); |
| 572 | |
| 573 | /* common open */ |
| 574 | err = open_candev(dev); |
| 575 | if (err) |
| 576 | return err; |
| 577 | |
| 578 | /* register interrupt handler, if not done by the device driver */ |
| 579 | if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER)) { |
Julia Lawall | 4c9ba61 | 2009-11-18 08:20:44 +0000 | [diff] [blame] | 580 | err = request_irq(dev->irq, sja1000_interrupt, priv->irq_flags, |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 581 | dev->name, (void *)dev); |
| 582 | if (err) { |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 583 | close_candev(dev); |
Wolfgang Grandegger | 128ced8 | 2009-05-30 07:55:48 +0000 | [diff] [blame] | 584 | return -EAGAIN; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 585 | } |
| 586 | } |
| 587 | |
| 588 | /* init and start chi */ |
| 589 | sja1000_start(dev); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 590 | |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 591 | can_led_event(dev, CAN_LED_EVENT_OPEN); |
| 592 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 593 | netif_start_queue(dev); |
| 594 | |
| 595 | return 0; |
| 596 | } |
| 597 | |
| 598 | static int sja1000_close(struct net_device *dev) |
| 599 | { |
| 600 | struct sja1000_priv *priv = netdev_priv(dev); |
| 601 | |
| 602 | netif_stop_queue(dev); |
| 603 | set_reset_mode(dev); |
| 604 | |
| 605 | if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER)) |
| 606 | free_irq(dev->irq, (void *)dev); |
| 607 | |
| 608 | close_candev(dev); |
| 609 | |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 610 | can_led_event(dev, CAN_LED_EVENT_STOP); |
| 611 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 612 | return 0; |
| 613 | } |
| 614 | |
| 615 | struct net_device *alloc_sja1000dev(int sizeof_priv) |
| 616 | { |
| 617 | struct net_device *dev; |
| 618 | struct sja1000_priv *priv; |
| 619 | |
Wolfgang Grandegger | a6e4bc5 | 2009-10-08 22:17:11 +0000 | [diff] [blame] | 620 | dev = alloc_candev(sizeof(struct sja1000_priv) + sizeof_priv, |
| 621 | SJA1000_ECHO_SKB_MAX); |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 622 | if (!dev) |
| 623 | return NULL; |
| 624 | |
| 625 | priv = netdev_priv(dev); |
| 626 | |
| 627 | priv->dev = dev; |
| 628 | priv->can.bittiming_const = &sja1000_bittiming_const; |
| 629 | priv->can.do_set_bittiming = sja1000_set_bittiming; |
| 630 | priv->can.do_set_mode = sja1000_set_mode; |
Wolfgang Grandegger | 52c793f | 2010-02-22 22:21:17 +0000 | [diff] [blame] | 631 | priv->can.do_get_berr_counter = sja1000_get_berr_counter; |
Nikita Edward Baruzdin | dcf9e15 | 2014-07-11 16:13:20 +0400 | [diff] [blame] | 632 | priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | |
| 633 | CAN_CTRLMODE_LISTENONLY | |
| 634 | CAN_CTRLMODE_3_SAMPLES | |
| 635 | CAN_CTRLMODE_ONE_SHOT | |
Nikita Edward Baruzdin | 5b853ec | 2014-07-11 16:13:23 +0400 | [diff] [blame] | 636 | CAN_CTRLMODE_BERR_REPORTING | |
| 637 | CAN_CTRLMODE_PRESUME_ACK; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 638 | |
Oliver Hartkopp | 1f01bfd | 2010-05-19 06:46:38 +0000 | [diff] [blame] | 639 | spin_lock_init(&priv->cmdreg_lock); |
| 640 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 641 | if (sizeof_priv) |
| 642 | priv->priv = (void *)priv + sizeof(struct sja1000_priv); |
| 643 | |
| 644 | return dev; |
| 645 | } |
| 646 | EXPORT_SYMBOL_GPL(alloc_sja1000dev); |
| 647 | |
| 648 | void free_sja1000dev(struct net_device *dev) |
| 649 | { |
| 650 | free_candev(dev); |
| 651 | } |
| 652 | EXPORT_SYMBOL_GPL(free_sja1000dev); |
| 653 | |
| 654 | static const struct net_device_ops sja1000_netdev_ops = { |
Oliver Hartkopp | c971fa2 | 2014-03-07 09:23:41 +0100 | [diff] [blame] | 655 | .ndo_open = sja1000_open, |
| 656 | .ndo_stop = sja1000_close, |
| 657 | .ndo_start_xmit = sja1000_start_xmit, |
| 658 | .ndo_change_mtu = can_change_mtu, |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 659 | }; |
| 660 | |
| 661 | int register_sja1000dev(struct net_device *dev) |
| 662 | { |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 663 | int ret; |
| 664 | |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 665 | if (!sja1000_probe_chip(dev)) |
| 666 | return -ENODEV; |
| 667 | |
| 668 | dev->flags |= IFF_ECHO; /* we support local echo */ |
| 669 | dev->netdev_ops = &sja1000_netdev_ops; |
| 670 | |
| 671 | set_reset_mode(dev); |
| 672 | chipset_init(dev); |
| 673 | |
Fabio Baltieri | a04282f | 2012-12-18 18:51:03 +0100 | [diff] [blame] | 674 | ret = register_candev(dev); |
| 675 | |
| 676 | if (!ret) |
| 677 | devm_can_led_init(dev); |
| 678 | |
| 679 | return ret; |
Wolfgang Grandegger | 429da1c | 2009-05-15 23:39:30 +0000 | [diff] [blame] | 680 | } |
| 681 | EXPORT_SYMBOL_GPL(register_sja1000dev); |
| 682 | |
| 683 | void unregister_sja1000dev(struct net_device *dev) |
| 684 | { |
| 685 | set_reset_mode(dev); |
| 686 | unregister_candev(dev); |
| 687 | } |
| 688 | EXPORT_SYMBOL_GPL(unregister_sja1000dev); |
| 689 | |
| 690 | static __init int sja1000_init(void) |
| 691 | { |
| 692 | printk(KERN_INFO "%s CAN netdevice driver\n", DRV_NAME); |
| 693 | |
| 694 | return 0; |
| 695 | } |
| 696 | |
| 697 | module_init(sja1000_init); |
| 698 | |
| 699 | static __exit void sja1000_exit(void) |
| 700 | { |
| 701 | printk(KERN_INFO "%s: driver removed\n", DRV_NAME); |
| 702 | } |
| 703 | |
| 704 | module_exit(sja1000_exit); |