Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1 | /* |
| 2 | * flexcan.c - FLEXCAN CAN controller driver |
| 3 | * |
| 4 | * Copyright (c) 2005-2006 Varma Electronics Oy |
| 5 | * Copyright (c) 2009 Sascha Hauer, Pengutronix |
| 6 | * Copyright (c) 2010 Marc Kleine-Budde, Pengutronix |
| 7 | * |
| 8 | * Based on code originally by Andrey Volkov <avolkov@varma-el.com> |
| 9 | * |
| 10 | * LICENCE: |
| 11 | * This program is free software; you can redistribute it and/or |
| 12 | * modify it under the terms of the GNU General Public License as |
| 13 | * published by the Free Software Foundation version 2. |
| 14 | * |
| 15 | * This program is distributed in the hope that it will be useful, |
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | * GNU General Public License for more details. |
| 19 | * |
| 20 | */ |
| 21 | |
| 22 | #include <linux/netdevice.h> |
| 23 | #include <linux/can.h> |
| 24 | #include <linux/can/dev.h> |
| 25 | #include <linux/can/error.h> |
Fabio Baltieri | adccadb | 2012-12-18 18:50:58 +0100 | [diff] [blame] | 26 | #include <linux/can/led.h> |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 27 | #include <linux/clk.h> |
| 28 | #include <linux/delay.h> |
| 29 | #include <linux/if_arp.h> |
| 30 | #include <linux/if_ether.h> |
| 31 | #include <linux/interrupt.h> |
| 32 | #include <linux/io.h> |
| 33 | #include <linux/kernel.h> |
| 34 | #include <linux/list.h> |
| 35 | #include <linux/module.h> |
holt@sgi.com | 97efe9a | 2011-08-16 17:32:23 +0000 | [diff] [blame] | 36 | #include <linux/of.h> |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 37 | #include <linux/of_device.h> |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 38 | #include <linux/platform_device.h> |
Fabio Estevam | b7c4114 | 2013-06-10 23:12:57 -0300 | [diff] [blame] | 39 | #include <linux/regulator/consumer.h> |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 40 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 41 | #define DRV_NAME "flexcan" |
| 42 | |
| 43 | /* 8 for RX fifo and 2 error handling */ |
| 44 | #define FLEXCAN_NAPI_WEIGHT (8 + 2) |
| 45 | |
| 46 | /* FLEXCAN module configuration register (CANMCR) bits */ |
| 47 | #define FLEXCAN_MCR_MDIS BIT(31) |
| 48 | #define FLEXCAN_MCR_FRZ BIT(30) |
| 49 | #define FLEXCAN_MCR_FEN BIT(29) |
| 50 | #define FLEXCAN_MCR_HALT BIT(28) |
| 51 | #define FLEXCAN_MCR_NOT_RDY BIT(27) |
| 52 | #define FLEXCAN_MCR_WAK_MSK BIT(26) |
| 53 | #define FLEXCAN_MCR_SOFTRST BIT(25) |
| 54 | #define FLEXCAN_MCR_FRZ_ACK BIT(24) |
| 55 | #define FLEXCAN_MCR_SUPV BIT(23) |
| 56 | #define FLEXCAN_MCR_SLF_WAK BIT(22) |
| 57 | #define FLEXCAN_MCR_WRN_EN BIT(21) |
| 58 | #define FLEXCAN_MCR_LPM_ACK BIT(20) |
| 59 | #define FLEXCAN_MCR_WAK_SRC BIT(19) |
| 60 | #define FLEXCAN_MCR_DOZE BIT(18) |
| 61 | #define FLEXCAN_MCR_SRX_DIS BIT(17) |
| 62 | #define FLEXCAN_MCR_BCC BIT(16) |
| 63 | #define FLEXCAN_MCR_LPRIO_EN BIT(13) |
| 64 | #define FLEXCAN_MCR_AEN BIT(12) |
Marc Kleine-Budde | 4c728d8 | 2014-09-02 16:54:17 +0200 | [diff] [blame] | 65 | #define FLEXCAN_MCR_MAXMB(x) ((x) & 0x7f) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 66 | #define FLEXCAN_MCR_IDAM_A (0 << 8) |
| 67 | #define FLEXCAN_MCR_IDAM_B (1 << 8) |
| 68 | #define FLEXCAN_MCR_IDAM_C (2 << 8) |
| 69 | #define FLEXCAN_MCR_IDAM_D (3 << 8) |
| 70 | |
| 71 | /* FLEXCAN control register (CANCTRL) bits */ |
| 72 | #define FLEXCAN_CTRL_PRESDIV(x) (((x) & 0xff) << 24) |
| 73 | #define FLEXCAN_CTRL_RJW(x) (((x) & 0x03) << 22) |
| 74 | #define FLEXCAN_CTRL_PSEG1(x) (((x) & 0x07) << 19) |
| 75 | #define FLEXCAN_CTRL_PSEG2(x) (((x) & 0x07) << 16) |
| 76 | #define FLEXCAN_CTRL_BOFF_MSK BIT(15) |
| 77 | #define FLEXCAN_CTRL_ERR_MSK BIT(14) |
| 78 | #define FLEXCAN_CTRL_CLK_SRC BIT(13) |
| 79 | #define FLEXCAN_CTRL_LPB BIT(12) |
| 80 | #define FLEXCAN_CTRL_TWRN_MSK BIT(11) |
| 81 | #define FLEXCAN_CTRL_RWRN_MSK BIT(10) |
| 82 | #define FLEXCAN_CTRL_SMP BIT(7) |
| 83 | #define FLEXCAN_CTRL_BOFF_REC BIT(6) |
| 84 | #define FLEXCAN_CTRL_TSYN BIT(5) |
| 85 | #define FLEXCAN_CTRL_LBUF BIT(4) |
| 86 | #define FLEXCAN_CTRL_LOM BIT(3) |
| 87 | #define FLEXCAN_CTRL_PROPSEG(x) ((x) & 0x07) |
| 88 | #define FLEXCAN_CTRL_ERR_BUS (FLEXCAN_CTRL_ERR_MSK) |
| 89 | #define FLEXCAN_CTRL_ERR_STATE \ |
| 90 | (FLEXCAN_CTRL_TWRN_MSK | FLEXCAN_CTRL_RWRN_MSK | \ |
| 91 | FLEXCAN_CTRL_BOFF_MSK) |
| 92 | #define FLEXCAN_CTRL_ERR_ALL \ |
| 93 | (FLEXCAN_CTRL_ERR_BUS | FLEXCAN_CTRL_ERR_STATE) |
| 94 | |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 95 | /* FLEXCAN control register 2 (CTRL2) bits */ |
| 96 | #define FLEXCAN_CRL2_ECRWRE BIT(29) |
| 97 | #define FLEXCAN_CRL2_WRMFRZ BIT(28) |
| 98 | #define FLEXCAN_CRL2_RFFN(x) (((x) & 0x0f) << 24) |
| 99 | #define FLEXCAN_CRL2_TASD(x) (((x) & 0x1f) << 19) |
| 100 | #define FLEXCAN_CRL2_MRP BIT(18) |
| 101 | #define FLEXCAN_CRL2_RRS BIT(17) |
| 102 | #define FLEXCAN_CRL2_EACEN BIT(16) |
| 103 | |
| 104 | /* FLEXCAN memory error control register (MECR) bits */ |
| 105 | #define FLEXCAN_MECR_ECRWRDIS BIT(31) |
| 106 | #define FLEXCAN_MECR_HANCEI_MSK BIT(19) |
| 107 | #define FLEXCAN_MECR_FANCEI_MSK BIT(18) |
| 108 | #define FLEXCAN_MECR_CEI_MSK BIT(16) |
| 109 | #define FLEXCAN_MECR_HAERRIE BIT(15) |
| 110 | #define FLEXCAN_MECR_FAERRIE BIT(14) |
| 111 | #define FLEXCAN_MECR_EXTERRIE BIT(13) |
| 112 | #define FLEXCAN_MECR_RERRDIS BIT(9) |
| 113 | #define FLEXCAN_MECR_ECCDIS BIT(8) |
| 114 | #define FLEXCAN_MECR_NCEFAFRZ BIT(7) |
| 115 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 116 | /* FLEXCAN error and status register (ESR) bits */ |
| 117 | #define FLEXCAN_ESR_TWRN_INT BIT(17) |
| 118 | #define FLEXCAN_ESR_RWRN_INT BIT(16) |
| 119 | #define FLEXCAN_ESR_BIT1_ERR BIT(15) |
| 120 | #define FLEXCAN_ESR_BIT0_ERR BIT(14) |
| 121 | #define FLEXCAN_ESR_ACK_ERR BIT(13) |
| 122 | #define FLEXCAN_ESR_CRC_ERR BIT(12) |
| 123 | #define FLEXCAN_ESR_FRM_ERR BIT(11) |
| 124 | #define FLEXCAN_ESR_STF_ERR BIT(10) |
| 125 | #define FLEXCAN_ESR_TX_WRN BIT(9) |
| 126 | #define FLEXCAN_ESR_RX_WRN BIT(8) |
| 127 | #define FLEXCAN_ESR_IDLE BIT(7) |
| 128 | #define FLEXCAN_ESR_TXRX BIT(6) |
| 129 | #define FLEXCAN_EST_FLT_CONF_SHIFT (4) |
| 130 | #define FLEXCAN_ESR_FLT_CONF_MASK (0x3 << FLEXCAN_EST_FLT_CONF_SHIFT) |
| 131 | #define FLEXCAN_ESR_FLT_CONF_ACTIVE (0x0 << FLEXCAN_EST_FLT_CONF_SHIFT) |
| 132 | #define FLEXCAN_ESR_FLT_CONF_PASSIVE (0x1 << FLEXCAN_EST_FLT_CONF_SHIFT) |
| 133 | #define FLEXCAN_ESR_BOFF_INT BIT(2) |
| 134 | #define FLEXCAN_ESR_ERR_INT BIT(1) |
| 135 | #define FLEXCAN_ESR_WAK_INT BIT(0) |
| 136 | #define FLEXCAN_ESR_ERR_BUS \ |
| 137 | (FLEXCAN_ESR_BIT1_ERR | FLEXCAN_ESR_BIT0_ERR | \ |
| 138 | FLEXCAN_ESR_ACK_ERR | FLEXCAN_ESR_CRC_ERR | \ |
| 139 | FLEXCAN_ESR_FRM_ERR | FLEXCAN_ESR_STF_ERR) |
| 140 | #define FLEXCAN_ESR_ERR_STATE \ |
| 141 | (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | FLEXCAN_ESR_BOFF_INT) |
| 142 | #define FLEXCAN_ESR_ERR_ALL \ |
| 143 | (FLEXCAN_ESR_ERR_BUS | FLEXCAN_ESR_ERR_STATE) |
Wolfgang Grandegger | 6e9d554 | 2011-12-12 16:09:28 +0100 | [diff] [blame] | 144 | #define FLEXCAN_ESR_ALL_INT \ |
| 145 | (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | \ |
| 146 | FLEXCAN_ESR_BOFF_INT | FLEXCAN_ESR_ERR_INT) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 147 | |
| 148 | /* FLEXCAN interrupt flag register (IFLAG) bits */ |
David Jander | 25e9244 | 2014-09-03 16:47:22 +0200 | [diff] [blame] | 149 | /* Errata ERR005829 step7: Reserve first valid MB */ |
| 150 | #define FLEXCAN_TX_BUF_RESERVED 8 |
| 151 | #define FLEXCAN_TX_BUF_ID 9 |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 152 | #define FLEXCAN_IFLAG_BUF(x) BIT(x) |
| 153 | #define FLEXCAN_IFLAG_RX_FIFO_OVERFLOW BIT(7) |
| 154 | #define FLEXCAN_IFLAG_RX_FIFO_WARN BIT(6) |
| 155 | #define FLEXCAN_IFLAG_RX_FIFO_AVAILABLE BIT(5) |
| 156 | #define FLEXCAN_IFLAG_DEFAULT \ |
| 157 | (FLEXCAN_IFLAG_RX_FIFO_OVERFLOW | FLEXCAN_IFLAG_RX_FIFO_AVAILABLE | \ |
| 158 | FLEXCAN_IFLAG_BUF(FLEXCAN_TX_BUF_ID)) |
| 159 | |
| 160 | /* FLEXCAN message buffers */ |
| 161 | #define FLEXCAN_MB_CNT_CODE(x) (((x) & 0xf) << 24) |
Marc Kleine-Budde | c32fe4a | 2014-09-16 12:39:28 +0200 | [diff] [blame] | 162 | #define FLEXCAN_MB_CODE_RX_INACTIVE (0x0 << 24) |
| 163 | #define FLEXCAN_MB_CODE_RX_EMPTY (0x4 << 24) |
| 164 | #define FLEXCAN_MB_CODE_RX_FULL (0x2 << 24) |
| 165 | #define FLEXCAN_MB_CODE_RX_OVERRRUN (0x6 << 24) |
| 166 | #define FLEXCAN_MB_CODE_RX_RANSWER (0xa << 24) |
| 167 | |
| 168 | #define FLEXCAN_MB_CODE_TX_INACTIVE (0x8 << 24) |
| 169 | #define FLEXCAN_MB_CODE_TX_ABORT (0x9 << 24) |
| 170 | #define FLEXCAN_MB_CODE_TX_DATA (0xc << 24) |
| 171 | #define FLEXCAN_MB_CODE_TX_TANSWER (0xe << 24) |
| 172 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 173 | #define FLEXCAN_MB_CNT_SRR BIT(22) |
| 174 | #define FLEXCAN_MB_CNT_IDE BIT(21) |
| 175 | #define FLEXCAN_MB_CNT_RTR BIT(20) |
| 176 | #define FLEXCAN_MB_CNT_LENGTH(x) (((x) & 0xf) << 16) |
| 177 | #define FLEXCAN_MB_CNT_TIMESTAMP(x) ((x) & 0xffff) |
| 178 | |
| 179 | #define FLEXCAN_MB_CODE_MASK (0xf0ffffff) |
| 180 | |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 181 | #define FLEXCAN_TIMEOUT_US (50) |
| 182 | |
Wolfgang Grandegger | bb698ca | 2012-10-10 21:10:42 +0200 | [diff] [blame] | 183 | /* |
| 184 | * FLEXCAN hardware feature flags |
| 185 | * |
| 186 | * Below is some version info we got: |
David Jander | 8a1ce7e | 2014-10-10 15:04:03 +0200 | [diff] [blame] | 187 | * SOC Version IP-Version Glitch- [TR]WRN_INT Memory err RTR re- |
| 188 | * Filter? connected? detection ception in MB |
| 189 | * MX25 FlexCAN2 03.00.00.00 no no no no |
| 190 | * MX28 FlexCAN2 03.00.04.00 yes yes no no |
| 191 | * MX35 FlexCAN2 03.00.00.00 no no no no |
| 192 | * MX53 FlexCAN2 03.00.00.00 yes no no no |
| 193 | * MX6s FlexCAN3 10.00.12.00 yes yes no yes |
| 194 | * VF610 FlexCAN3 ? no yes yes yes? |
Wolfgang Grandegger | bb698ca | 2012-10-10 21:10:42 +0200 | [diff] [blame] | 195 | * |
| 196 | * Some SOCs do not have the RX_WARN & TX_WARN interrupt line connected. |
| 197 | */ |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 198 | #define FLEXCAN_HAS_V10_FEATURES BIT(1) /* For core version >= 10 */ |
Wolfgang Grandegger | bb698ca | 2012-10-10 21:10:42 +0200 | [diff] [blame] | 199 | #define FLEXCAN_HAS_BROKEN_ERR_STATE BIT(2) /* [TR]WRN_INT not connected */ |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 200 | #define FLEXCAN_HAS_MECR_FEATURES BIT(3) /* Memory error detection */ |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 201 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 202 | /* Structure of the message buffer */ |
| 203 | struct flexcan_mb { |
| 204 | u32 can_ctrl; |
| 205 | u32 can_id; |
| 206 | u32 data[2]; |
| 207 | }; |
| 208 | |
| 209 | /* Structure of the hardware registers */ |
| 210 | struct flexcan_regs { |
| 211 | u32 mcr; /* 0x00 */ |
| 212 | u32 ctrl; /* 0x04 */ |
| 213 | u32 timer; /* 0x08 */ |
| 214 | u32 _reserved1; /* 0x0c */ |
| 215 | u32 rxgmask; /* 0x10 */ |
| 216 | u32 rx14mask; /* 0x14 */ |
| 217 | u32 rx15mask; /* 0x18 */ |
| 218 | u32 ecr; /* 0x1c */ |
| 219 | u32 esr; /* 0x20 */ |
| 220 | u32 imask2; /* 0x24 */ |
| 221 | u32 imask1; /* 0x28 */ |
| 222 | u32 iflag2; /* 0x2c */ |
| 223 | u32 iflag1; /* 0x30 */ |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 224 | u32 crl2; /* 0x34 */ |
| 225 | u32 esr2; /* 0x38 */ |
| 226 | u32 imeur; /* 0x3c */ |
| 227 | u32 lrfr; /* 0x40 */ |
| 228 | u32 crcr; /* 0x44 */ |
| 229 | u32 rxfgmask; /* 0x48 */ |
| 230 | u32 rxfir; /* 0x4c */ |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 231 | u32 _reserved3[12]; /* 0x50 */ |
| 232 | struct flexcan_mb cantxfg[64]; /* 0x80 */ |
Marc Kleine-Budde | 66a6ef0 | 2014-09-17 12:50:48 +0200 | [diff] [blame^] | 233 | /* FIFO-mode: |
| 234 | * MB |
| 235 | * 0x080...0x08f 0 RX message buffer |
| 236 | * 0x090...0x0df 1-5 reserverd |
| 237 | * 0x0e0...0x0ff 6-7 8 entry ID table |
| 238 | * (mx25, mx28, mx35, mx53) |
| 239 | * 0x0e0...0x2df 6-7..37 8..128 entry ID table |
| 240 | * size conf'ed via ctrl2::RFFN |
| 241 | * (mx6, vf610) |
| 242 | */ |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 243 | u32 _reserved4[408]; |
| 244 | u32 mecr; /* 0xae0 */ |
| 245 | u32 erriar; /* 0xae4 */ |
| 246 | u32 erridpr; /* 0xae8 */ |
| 247 | u32 errippr; /* 0xaec */ |
| 248 | u32 rerrar; /* 0xaf0 */ |
| 249 | u32 rerrdr; /* 0xaf4 */ |
| 250 | u32 rerrsynr; /* 0xaf8 */ |
| 251 | u32 errsr; /* 0xafc */ |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 252 | }; |
| 253 | |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 254 | struct flexcan_devtype_data { |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 255 | u32 features; /* hardware controller features */ |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 256 | }; |
| 257 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 258 | struct flexcan_priv { |
| 259 | struct can_priv can; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 260 | struct napi_struct napi; |
| 261 | |
| 262 | void __iomem *base; |
| 263 | u32 reg_esr; |
| 264 | u32 reg_ctrl_default; |
| 265 | |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 266 | struct clk *clk_ipg; |
| 267 | struct clk *clk_per; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 268 | struct flexcan_platform_data *pdata; |
Marc Kleine-Budde | dda0b3b | 2012-07-13 14:52:48 +0200 | [diff] [blame] | 269 | const struct flexcan_devtype_data *devtype_data; |
Fabio Estevam | b7c4114 | 2013-06-10 23:12:57 -0300 | [diff] [blame] | 270 | struct regulator *reg_xceiver; |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 271 | }; |
| 272 | |
| 273 | static struct flexcan_devtype_data fsl_p1010_devtype_data = { |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 274 | .features = FLEXCAN_HAS_BROKEN_ERR_STATE, |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 275 | }; |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 276 | static struct flexcan_devtype_data fsl_imx28_devtype_data; |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 277 | static struct flexcan_devtype_data fsl_imx6q_devtype_data = { |
Wolfgang Grandegger | bb698ca | 2012-10-10 21:10:42 +0200 | [diff] [blame] | 278 | .features = FLEXCAN_HAS_V10_FEATURES, |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 279 | }; |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 280 | static struct flexcan_devtype_data fsl_vf610_devtype_data = { |
| 281 | .features = FLEXCAN_HAS_V10_FEATURES | FLEXCAN_HAS_MECR_FEATURES, |
| 282 | }; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 283 | |
Marc Kleine-Budde | 194b9a4 | 2012-07-16 12:58:31 +0200 | [diff] [blame] | 284 | static const struct can_bittiming_const flexcan_bittiming_const = { |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 285 | .name = DRV_NAME, |
| 286 | .tseg1_min = 4, |
| 287 | .tseg1_max = 16, |
| 288 | .tseg2_min = 2, |
| 289 | .tseg2_max = 8, |
| 290 | .sjw_max = 4, |
| 291 | .brp_min = 1, |
| 292 | .brp_max = 256, |
| 293 | .brp_inc = 1, |
| 294 | }; |
| 295 | |
| 296 | /* |
Arnd Bergmann | 0e4b949 | 2014-01-14 11:44:09 +0100 | [diff] [blame] | 297 | * Abstract off the read/write for arm versus ppc. This |
| 298 | * assumes that PPC uses big-endian registers and everything |
| 299 | * else uses little-endian registers, independent of CPU |
| 300 | * endianess. |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 301 | */ |
Arnd Bergmann | 0e4b949 | 2014-01-14 11:44:09 +0100 | [diff] [blame] | 302 | #if defined(CONFIG_PPC) |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 303 | static inline u32 flexcan_read(void __iomem *addr) |
| 304 | { |
| 305 | return in_be32(addr); |
| 306 | } |
| 307 | |
| 308 | static inline void flexcan_write(u32 val, void __iomem *addr) |
| 309 | { |
| 310 | out_be32(addr, val); |
| 311 | } |
| 312 | #else |
| 313 | static inline u32 flexcan_read(void __iomem *addr) |
| 314 | { |
| 315 | return readl(addr); |
| 316 | } |
| 317 | |
| 318 | static inline void flexcan_write(u32 val, void __iomem *addr) |
| 319 | { |
| 320 | writel(val, addr); |
| 321 | } |
| 322 | #endif |
| 323 | |
Marc Kleine-Budde | f003698 | 2014-02-28 17:18:27 +0100 | [diff] [blame] | 324 | static inline int flexcan_transceiver_enable(const struct flexcan_priv *priv) |
| 325 | { |
| 326 | if (!priv->reg_xceiver) |
| 327 | return 0; |
| 328 | |
| 329 | return regulator_enable(priv->reg_xceiver); |
| 330 | } |
| 331 | |
| 332 | static inline int flexcan_transceiver_disable(const struct flexcan_priv *priv) |
| 333 | { |
| 334 | if (!priv->reg_xceiver) |
| 335 | return 0; |
| 336 | |
| 337 | return regulator_disable(priv->reg_xceiver); |
| 338 | } |
| 339 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 340 | static inline int flexcan_has_and_handle_berr(const struct flexcan_priv *priv, |
| 341 | u32 reg_esr) |
| 342 | { |
| 343 | return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) && |
| 344 | (reg_esr & FLEXCAN_ESR_ERR_BUS); |
| 345 | } |
| 346 | |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 347 | static int flexcan_chip_enable(struct flexcan_priv *priv) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 348 | { |
| 349 | struct flexcan_regs __iomem *regs = priv->base; |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 350 | unsigned int timeout = FLEXCAN_TIMEOUT_US / 10; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 351 | u32 reg; |
| 352 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 353 | reg = flexcan_read(®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 354 | reg &= ~FLEXCAN_MCR_MDIS; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 355 | flexcan_write(reg, ®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 356 | |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 357 | while (timeout-- && (flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK)) |
David Jander | 8badd65 | 2014-08-27 12:02:16 +0200 | [diff] [blame] | 358 | udelay(10); |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 359 | |
| 360 | if (flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK) |
| 361 | return -ETIMEDOUT; |
| 362 | |
| 363 | return 0; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 364 | } |
| 365 | |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 366 | static int flexcan_chip_disable(struct flexcan_priv *priv) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 367 | { |
| 368 | struct flexcan_regs __iomem *regs = priv->base; |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 369 | unsigned int timeout = FLEXCAN_TIMEOUT_US / 10; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 370 | u32 reg; |
| 371 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 372 | reg = flexcan_read(®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 373 | reg |= FLEXCAN_MCR_MDIS; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 374 | flexcan_write(reg, ®s->mcr); |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 375 | |
| 376 | while (timeout-- && !(flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK)) |
David Jander | 8badd65 | 2014-08-27 12:02:16 +0200 | [diff] [blame] | 377 | udelay(10); |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 378 | |
| 379 | if (!(flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK)) |
| 380 | return -ETIMEDOUT; |
| 381 | |
| 382 | return 0; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 383 | } |
| 384 | |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 385 | static int flexcan_chip_freeze(struct flexcan_priv *priv) |
| 386 | { |
| 387 | struct flexcan_regs __iomem *regs = priv->base; |
| 388 | unsigned int timeout = 1000 * 1000 * 10 / priv->can.bittiming.bitrate; |
| 389 | u32 reg; |
| 390 | |
| 391 | reg = flexcan_read(®s->mcr); |
| 392 | reg |= FLEXCAN_MCR_HALT; |
| 393 | flexcan_write(reg, ®s->mcr); |
| 394 | |
| 395 | while (timeout-- && !(flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK)) |
David Jander | 8badd65 | 2014-08-27 12:02:16 +0200 | [diff] [blame] | 396 | udelay(100); |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 397 | |
| 398 | if (!(flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK)) |
| 399 | return -ETIMEDOUT; |
| 400 | |
| 401 | return 0; |
| 402 | } |
| 403 | |
| 404 | static int flexcan_chip_unfreeze(struct flexcan_priv *priv) |
| 405 | { |
| 406 | struct flexcan_regs __iomem *regs = priv->base; |
| 407 | unsigned int timeout = FLEXCAN_TIMEOUT_US / 10; |
| 408 | u32 reg; |
| 409 | |
| 410 | reg = flexcan_read(®s->mcr); |
| 411 | reg &= ~FLEXCAN_MCR_HALT; |
| 412 | flexcan_write(reg, ®s->mcr); |
| 413 | |
| 414 | while (timeout-- && (flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK)) |
David Jander | 8badd65 | 2014-08-27 12:02:16 +0200 | [diff] [blame] | 415 | udelay(10); |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 416 | |
| 417 | if (flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK) |
| 418 | return -ETIMEDOUT; |
| 419 | |
| 420 | return 0; |
| 421 | } |
| 422 | |
Marc Kleine-Budde | 4b5b822 | 2014-02-28 15:16:59 +0100 | [diff] [blame] | 423 | static int flexcan_chip_softreset(struct flexcan_priv *priv) |
| 424 | { |
| 425 | struct flexcan_regs __iomem *regs = priv->base; |
| 426 | unsigned int timeout = FLEXCAN_TIMEOUT_US / 10; |
| 427 | |
| 428 | flexcan_write(FLEXCAN_MCR_SOFTRST, ®s->mcr); |
| 429 | while (timeout-- && (flexcan_read(®s->mcr) & FLEXCAN_MCR_SOFTRST)) |
David Jander | 8badd65 | 2014-08-27 12:02:16 +0200 | [diff] [blame] | 430 | udelay(10); |
Marc Kleine-Budde | 4b5b822 | 2014-02-28 15:16:59 +0100 | [diff] [blame] | 431 | |
| 432 | if (flexcan_read(®s->mcr) & FLEXCAN_MCR_SOFTRST) |
| 433 | return -ETIMEDOUT; |
| 434 | |
| 435 | return 0; |
| 436 | } |
| 437 | |
Stefan Agner | ec56acf | 2014-07-15 14:56:20 +0200 | [diff] [blame] | 438 | |
| 439 | static int __flexcan_get_berr_counter(const struct net_device *dev, |
| 440 | struct can_berr_counter *bec) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 441 | { |
| 442 | const struct flexcan_priv *priv = netdev_priv(dev); |
| 443 | struct flexcan_regs __iomem *regs = priv->base; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 444 | u32 reg = flexcan_read(®s->ecr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 445 | |
| 446 | bec->txerr = (reg >> 0) & 0xff; |
| 447 | bec->rxerr = (reg >> 8) & 0xff; |
| 448 | |
| 449 | return 0; |
| 450 | } |
| 451 | |
Stefan Agner | ec56acf | 2014-07-15 14:56:20 +0200 | [diff] [blame] | 452 | static int flexcan_get_berr_counter(const struct net_device *dev, |
| 453 | struct can_berr_counter *bec) |
| 454 | { |
| 455 | const struct flexcan_priv *priv = netdev_priv(dev); |
| 456 | int err; |
| 457 | |
| 458 | err = clk_prepare_enable(priv->clk_ipg); |
| 459 | if (err) |
| 460 | return err; |
| 461 | |
| 462 | err = clk_prepare_enable(priv->clk_per); |
| 463 | if (err) |
| 464 | goto out_disable_ipg; |
| 465 | |
| 466 | err = __flexcan_get_berr_counter(dev, bec); |
| 467 | |
| 468 | clk_disable_unprepare(priv->clk_per); |
| 469 | out_disable_ipg: |
| 470 | clk_disable_unprepare(priv->clk_ipg); |
| 471 | |
| 472 | return err; |
| 473 | } |
| 474 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 475 | static int flexcan_start_xmit(struct sk_buff *skb, struct net_device *dev) |
| 476 | { |
| 477 | const struct flexcan_priv *priv = netdev_priv(dev); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 478 | struct flexcan_regs __iomem *regs = priv->base; |
| 479 | struct can_frame *cf = (struct can_frame *)skb->data; |
| 480 | u32 can_id; |
| 481 | u32 ctrl = FLEXCAN_MB_CNT_CODE(0xc) | (cf->can_dlc << 16); |
| 482 | |
| 483 | if (can_dropped_invalid_skb(dev, skb)) |
| 484 | return NETDEV_TX_OK; |
| 485 | |
| 486 | netif_stop_queue(dev); |
| 487 | |
| 488 | if (cf->can_id & CAN_EFF_FLAG) { |
| 489 | can_id = cf->can_id & CAN_EFF_MASK; |
| 490 | ctrl |= FLEXCAN_MB_CNT_IDE | FLEXCAN_MB_CNT_SRR; |
| 491 | } else { |
| 492 | can_id = (cf->can_id & CAN_SFF_MASK) << 18; |
| 493 | } |
| 494 | |
| 495 | if (cf->can_id & CAN_RTR_FLAG) |
| 496 | ctrl |= FLEXCAN_MB_CNT_RTR; |
| 497 | |
| 498 | if (cf->can_dlc > 0) { |
| 499 | u32 data = be32_to_cpup((__be32 *)&cf->data[0]); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 500 | flexcan_write(data, ®s->cantxfg[FLEXCAN_TX_BUF_ID].data[0]); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 501 | } |
| 502 | if (cf->can_dlc > 3) { |
| 503 | u32 data = be32_to_cpup((__be32 *)&cf->data[4]); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 504 | flexcan_write(data, ®s->cantxfg[FLEXCAN_TX_BUF_ID].data[1]); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 505 | } |
| 506 | |
Reuben Dowle | 9a12349 | 2011-11-01 11:18:03 +1300 | [diff] [blame] | 507 | can_put_echo_skb(skb, dev, 0); |
| 508 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 509 | flexcan_write(can_id, ®s->cantxfg[FLEXCAN_TX_BUF_ID].can_id); |
| 510 | flexcan_write(ctrl, ®s->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 511 | |
David Jander | 25e9244 | 2014-09-03 16:47:22 +0200 | [diff] [blame] | 512 | /* Errata ERR005829 step8: |
| 513 | * Write twice INACTIVE(0x8) code to first MB. |
| 514 | */ |
| 515 | flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE, |
| 516 | ®s->cantxfg[FLEXCAN_TX_BUF_RESERVED].can_ctrl); |
| 517 | flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE, |
| 518 | ®s->cantxfg[FLEXCAN_TX_BUF_RESERVED].can_ctrl); |
| 519 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 520 | return NETDEV_TX_OK; |
| 521 | } |
| 522 | |
| 523 | static void do_bus_err(struct net_device *dev, |
| 524 | struct can_frame *cf, u32 reg_esr) |
| 525 | { |
| 526 | struct flexcan_priv *priv = netdev_priv(dev); |
| 527 | int rx_errors = 0, tx_errors = 0; |
| 528 | |
| 529 | cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; |
| 530 | |
| 531 | if (reg_esr & FLEXCAN_ESR_BIT1_ERR) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 532 | netdev_dbg(dev, "BIT1_ERR irq\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 533 | cf->data[2] |= CAN_ERR_PROT_BIT1; |
| 534 | tx_errors = 1; |
| 535 | } |
| 536 | if (reg_esr & FLEXCAN_ESR_BIT0_ERR) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 537 | netdev_dbg(dev, "BIT0_ERR irq\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 538 | cf->data[2] |= CAN_ERR_PROT_BIT0; |
| 539 | tx_errors = 1; |
| 540 | } |
| 541 | if (reg_esr & FLEXCAN_ESR_ACK_ERR) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 542 | netdev_dbg(dev, "ACK_ERR irq\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 543 | cf->can_id |= CAN_ERR_ACK; |
| 544 | cf->data[3] |= CAN_ERR_PROT_LOC_ACK; |
| 545 | tx_errors = 1; |
| 546 | } |
| 547 | if (reg_esr & FLEXCAN_ESR_CRC_ERR) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 548 | netdev_dbg(dev, "CRC_ERR irq\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 549 | cf->data[2] |= CAN_ERR_PROT_BIT; |
| 550 | cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ; |
| 551 | rx_errors = 1; |
| 552 | } |
| 553 | if (reg_esr & FLEXCAN_ESR_FRM_ERR) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 554 | netdev_dbg(dev, "FRM_ERR irq\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 555 | cf->data[2] |= CAN_ERR_PROT_FORM; |
| 556 | rx_errors = 1; |
| 557 | } |
| 558 | if (reg_esr & FLEXCAN_ESR_STF_ERR) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 559 | netdev_dbg(dev, "STF_ERR irq\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 560 | cf->data[2] |= CAN_ERR_PROT_STUFF; |
| 561 | rx_errors = 1; |
| 562 | } |
| 563 | |
| 564 | priv->can.can_stats.bus_error++; |
| 565 | if (rx_errors) |
| 566 | dev->stats.rx_errors++; |
| 567 | if (tx_errors) |
| 568 | dev->stats.tx_errors++; |
| 569 | } |
| 570 | |
| 571 | static int flexcan_poll_bus_err(struct net_device *dev, u32 reg_esr) |
| 572 | { |
| 573 | struct sk_buff *skb; |
| 574 | struct can_frame *cf; |
| 575 | |
| 576 | skb = alloc_can_err_skb(dev, &cf); |
| 577 | if (unlikely(!skb)) |
| 578 | return 0; |
| 579 | |
| 580 | do_bus_err(dev, cf, reg_esr); |
| 581 | netif_receive_skb(skb); |
| 582 | |
| 583 | dev->stats.rx_packets++; |
| 584 | dev->stats.rx_bytes += cf->can_dlc; |
| 585 | |
| 586 | return 1; |
| 587 | } |
| 588 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 589 | static int flexcan_poll_state(struct net_device *dev, u32 reg_esr) |
| 590 | { |
| 591 | struct flexcan_priv *priv = netdev_priv(dev); |
| 592 | struct sk_buff *skb; |
| 593 | struct can_frame *cf; |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 594 | enum can_state new_state = 0, rx_state = 0, tx_state = 0; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 595 | int flt; |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 596 | struct can_berr_counter bec; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 597 | |
| 598 | flt = reg_esr & FLEXCAN_ESR_FLT_CONF_MASK; |
| 599 | if (likely(flt == FLEXCAN_ESR_FLT_CONF_ACTIVE)) { |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 600 | tx_state = unlikely(reg_esr & FLEXCAN_ESR_TX_WRN) ? |
| 601 | CAN_STATE_ERROR_WARNING : CAN_STATE_ERROR_ACTIVE; |
| 602 | rx_state = unlikely(reg_esr & FLEXCAN_ESR_RX_WRN) ? |
| 603 | CAN_STATE_ERROR_WARNING : CAN_STATE_ERROR_ACTIVE; |
| 604 | new_state = max(tx_state, rx_state); |
Andri Yngvason | 258ce80 | 2015-03-17 13:03:09 +0000 | [diff] [blame] | 605 | } else { |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 606 | __flexcan_get_berr_counter(dev, &bec); |
Andri Yngvason | 258ce80 | 2015-03-17 13:03:09 +0000 | [diff] [blame] | 607 | new_state = flt == FLEXCAN_ESR_FLT_CONF_PASSIVE ? |
| 608 | CAN_STATE_ERROR_PASSIVE : CAN_STATE_BUS_OFF; |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 609 | rx_state = bec.rxerr >= bec.txerr ? new_state : 0; |
| 610 | tx_state = bec.rxerr <= bec.txerr ? new_state : 0; |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 611 | } |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 612 | |
| 613 | /* state hasn't changed */ |
| 614 | if (likely(new_state == priv->can.state)) |
| 615 | return 0; |
| 616 | |
| 617 | skb = alloc_can_err_skb(dev, &cf); |
| 618 | if (unlikely(!skb)) |
| 619 | return 0; |
| 620 | |
Andri Yngvason | 71a3aed | 2014-12-03 17:54:15 +0000 | [diff] [blame] | 621 | can_change_state(dev, cf, tx_state, rx_state); |
| 622 | |
| 623 | if (unlikely(new_state == CAN_STATE_BUS_OFF)) |
| 624 | can_bus_off(dev); |
| 625 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 626 | netif_receive_skb(skb); |
| 627 | |
| 628 | dev->stats.rx_packets++; |
| 629 | dev->stats.rx_bytes += cf->can_dlc; |
| 630 | |
| 631 | return 1; |
| 632 | } |
| 633 | |
| 634 | static void flexcan_read_fifo(const struct net_device *dev, |
| 635 | struct can_frame *cf) |
| 636 | { |
| 637 | const struct flexcan_priv *priv = netdev_priv(dev); |
| 638 | struct flexcan_regs __iomem *regs = priv->base; |
| 639 | struct flexcan_mb __iomem *mb = ®s->cantxfg[0]; |
| 640 | u32 reg_ctrl, reg_id; |
| 641 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 642 | reg_ctrl = flexcan_read(&mb->can_ctrl); |
| 643 | reg_id = flexcan_read(&mb->can_id); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 644 | if (reg_ctrl & FLEXCAN_MB_CNT_IDE) |
| 645 | cf->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG; |
| 646 | else |
| 647 | cf->can_id = (reg_id >> 18) & CAN_SFF_MASK; |
| 648 | |
| 649 | if (reg_ctrl & FLEXCAN_MB_CNT_RTR) |
| 650 | cf->can_id |= CAN_RTR_FLAG; |
| 651 | cf->can_dlc = get_can_dlc((reg_ctrl >> 16) & 0xf); |
| 652 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 653 | *(__be32 *)(cf->data + 0) = cpu_to_be32(flexcan_read(&mb->data[0])); |
| 654 | *(__be32 *)(cf->data + 4) = cpu_to_be32(flexcan_read(&mb->data[1])); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 655 | |
| 656 | /* mark as read */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 657 | flexcan_write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, ®s->iflag1); |
| 658 | flexcan_read(®s->timer); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 659 | } |
| 660 | |
| 661 | static int flexcan_read_frame(struct net_device *dev) |
| 662 | { |
| 663 | struct net_device_stats *stats = &dev->stats; |
| 664 | struct can_frame *cf; |
| 665 | struct sk_buff *skb; |
| 666 | |
| 667 | skb = alloc_can_skb(dev, &cf); |
| 668 | if (unlikely(!skb)) { |
| 669 | stats->rx_dropped++; |
| 670 | return 0; |
| 671 | } |
| 672 | |
| 673 | flexcan_read_fifo(dev, cf); |
| 674 | netif_receive_skb(skb); |
| 675 | |
| 676 | stats->rx_packets++; |
| 677 | stats->rx_bytes += cf->can_dlc; |
| 678 | |
Fabio Baltieri | adccadb | 2012-12-18 18:50:58 +0100 | [diff] [blame] | 679 | can_led_event(dev, CAN_LED_EVENT_RX); |
| 680 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 681 | return 1; |
| 682 | } |
| 683 | |
| 684 | static int flexcan_poll(struct napi_struct *napi, int quota) |
| 685 | { |
| 686 | struct net_device *dev = napi->dev; |
| 687 | const struct flexcan_priv *priv = netdev_priv(dev); |
| 688 | struct flexcan_regs __iomem *regs = priv->base; |
| 689 | u32 reg_iflag1, reg_esr; |
| 690 | int work_done = 0; |
| 691 | |
| 692 | /* |
| 693 | * The error bits are cleared on read, |
| 694 | * use saved value from irq handler. |
| 695 | */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 696 | reg_esr = flexcan_read(®s->esr) | priv->reg_esr; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 697 | |
| 698 | /* handle state changes */ |
| 699 | work_done += flexcan_poll_state(dev, reg_esr); |
| 700 | |
| 701 | /* handle RX-FIFO */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 702 | reg_iflag1 = flexcan_read(®s->iflag1); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 703 | while (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE && |
| 704 | work_done < quota) { |
| 705 | work_done += flexcan_read_frame(dev); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 706 | reg_iflag1 = flexcan_read(®s->iflag1); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 707 | } |
| 708 | |
| 709 | /* report bus errors */ |
| 710 | if (flexcan_has_and_handle_berr(priv, reg_esr) && work_done < quota) |
| 711 | work_done += flexcan_poll_bus_err(dev, reg_esr); |
| 712 | |
| 713 | if (work_done < quota) { |
| 714 | napi_complete(napi); |
| 715 | /* enable IRQs */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 716 | flexcan_write(FLEXCAN_IFLAG_DEFAULT, ®s->imask1); |
| 717 | flexcan_write(priv->reg_ctrl_default, ®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 718 | } |
| 719 | |
| 720 | return work_done; |
| 721 | } |
| 722 | |
| 723 | static irqreturn_t flexcan_irq(int irq, void *dev_id) |
| 724 | { |
| 725 | struct net_device *dev = dev_id; |
| 726 | struct net_device_stats *stats = &dev->stats; |
| 727 | struct flexcan_priv *priv = netdev_priv(dev); |
| 728 | struct flexcan_regs __iomem *regs = priv->base; |
| 729 | u32 reg_iflag1, reg_esr; |
| 730 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 731 | reg_iflag1 = flexcan_read(®s->iflag1); |
| 732 | reg_esr = flexcan_read(®s->esr); |
Wolfgang Grandegger | 6e9d554 | 2011-12-12 16:09:28 +0100 | [diff] [blame] | 733 | /* ACK all bus error and state change IRQ sources */ |
| 734 | if (reg_esr & FLEXCAN_ESR_ALL_INT) |
| 735 | flexcan_write(reg_esr & FLEXCAN_ESR_ALL_INT, ®s->esr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 736 | |
| 737 | /* |
| 738 | * schedule NAPI in case of: |
| 739 | * - rx IRQ |
| 740 | * - state change IRQ |
| 741 | * - bus error IRQ and bus error reporting is activated |
| 742 | */ |
| 743 | if ((reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE) || |
| 744 | (reg_esr & FLEXCAN_ESR_ERR_STATE) || |
| 745 | flexcan_has_and_handle_berr(priv, reg_esr)) { |
| 746 | /* |
| 747 | * The error bits are cleared on read, |
| 748 | * save them for later use. |
| 749 | */ |
| 750 | priv->reg_esr = reg_esr & FLEXCAN_ESR_ERR_BUS; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 751 | flexcan_write(FLEXCAN_IFLAG_DEFAULT & |
| 752 | ~FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, ®s->imask1); |
| 753 | flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL, |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 754 | ®s->ctrl); |
| 755 | napi_schedule(&priv->napi); |
| 756 | } |
| 757 | |
| 758 | /* FIFO overflow */ |
| 759 | if (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_OVERFLOW) { |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 760 | flexcan_write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW, ®s->iflag1); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 761 | dev->stats.rx_over_errors++; |
| 762 | dev->stats.rx_errors++; |
| 763 | } |
| 764 | |
| 765 | /* transmission complete interrupt */ |
| 766 | if (reg_iflag1 & (1 << FLEXCAN_TX_BUF_ID)) { |
Reuben Dowle | 9a12349 | 2011-11-01 11:18:03 +1300 | [diff] [blame] | 767 | stats->tx_bytes += can_get_echo_skb(dev, 0); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 768 | stats->tx_packets++; |
Fabio Baltieri | adccadb | 2012-12-18 18:50:58 +0100 | [diff] [blame] | 769 | can_led_event(dev, CAN_LED_EVENT_TX); |
Marc Kleine-Budde | de59448 | 2014-09-16 15:31:27 +0200 | [diff] [blame] | 770 | /* after sending a RTR frame mailbox is in RX mode */ |
| 771 | flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE, |
| 772 | ®s->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 773 | flexcan_write((1 << FLEXCAN_TX_BUF_ID), ®s->iflag1); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 774 | netif_wake_queue(dev); |
| 775 | } |
| 776 | |
| 777 | return IRQ_HANDLED; |
| 778 | } |
| 779 | |
| 780 | static void flexcan_set_bittiming(struct net_device *dev) |
| 781 | { |
| 782 | const struct flexcan_priv *priv = netdev_priv(dev); |
| 783 | const struct can_bittiming *bt = &priv->can.bittiming; |
| 784 | struct flexcan_regs __iomem *regs = priv->base; |
| 785 | u32 reg; |
| 786 | |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 787 | reg = flexcan_read(®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 788 | reg &= ~(FLEXCAN_CTRL_PRESDIV(0xff) | |
| 789 | FLEXCAN_CTRL_RJW(0x3) | |
| 790 | FLEXCAN_CTRL_PSEG1(0x7) | |
| 791 | FLEXCAN_CTRL_PSEG2(0x7) | |
| 792 | FLEXCAN_CTRL_PROPSEG(0x7) | |
| 793 | FLEXCAN_CTRL_LPB | |
| 794 | FLEXCAN_CTRL_SMP | |
| 795 | FLEXCAN_CTRL_LOM); |
| 796 | |
| 797 | reg |= FLEXCAN_CTRL_PRESDIV(bt->brp - 1) | |
| 798 | FLEXCAN_CTRL_PSEG1(bt->phase_seg1 - 1) | |
| 799 | FLEXCAN_CTRL_PSEG2(bt->phase_seg2 - 1) | |
| 800 | FLEXCAN_CTRL_RJW(bt->sjw - 1) | |
| 801 | FLEXCAN_CTRL_PROPSEG(bt->prop_seg - 1); |
| 802 | |
| 803 | if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) |
| 804 | reg |= FLEXCAN_CTRL_LPB; |
| 805 | if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) |
| 806 | reg |= FLEXCAN_CTRL_LOM; |
| 807 | if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) |
| 808 | reg |= FLEXCAN_CTRL_SMP; |
| 809 | |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 810 | netdev_info(dev, "writing ctrl=0x%08x\n", reg); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 811 | flexcan_write(reg, ®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 812 | |
| 813 | /* print chip status */ |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 814 | netdev_dbg(dev, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__, |
| 815 | flexcan_read(®s->mcr), flexcan_read(®s->ctrl)); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 816 | } |
| 817 | |
| 818 | /* |
| 819 | * flexcan_chip_start |
| 820 | * |
| 821 | * this functions is entered with clocks enabled |
| 822 | * |
| 823 | */ |
| 824 | static int flexcan_chip_start(struct net_device *dev) |
| 825 | { |
| 826 | struct flexcan_priv *priv = netdev_priv(dev); |
| 827 | struct flexcan_regs __iomem *regs = priv->base; |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 828 | u32 reg_mcr, reg_ctrl, reg_crl2, reg_mecr; |
David S. Miller | 1f6d803 | 2014-09-23 12:09:27 -0400 | [diff] [blame] | 829 | int err, i; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 830 | |
| 831 | /* enable module */ |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 832 | err = flexcan_chip_enable(priv); |
| 833 | if (err) |
| 834 | return err; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 835 | |
| 836 | /* soft reset */ |
Marc Kleine-Budde | 4b5b822 | 2014-02-28 15:16:59 +0100 | [diff] [blame] | 837 | err = flexcan_chip_softreset(priv); |
| 838 | if (err) |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 839 | goto out_chip_disable; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 840 | |
| 841 | flexcan_set_bittiming(dev); |
| 842 | |
| 843 | /* |
| 844 | * MCR |
| 845 | * |
| 846 | * enable freeze |
| 847 | * enable fifo |
| 848 | * halt now |
| 849 | * only supervisor access |
| 850 | * enable warning int |
| 851 | * choose format C |
Reuben Dowle | 9a12349 | 2011-11-01 11:18:03 +1300 | [diff] [blame] | 852 | * disable local echo |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 853 | * |
| 854 | */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 855 | reg_mcr = flexcan_read(®s->mcr); |
Marc Kleine-Budde | d5a7b40 | 2013-10-04 10:52:36 +0200 | [diff] [blame] | 856 | reg_mcr &= ~FLEXCAN_MCR_MAXMB(0xff); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 857 | reg_mcr |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_FEN | FLEXCAN_MCR_HALT | |
| 858 | FLEXCAN_MCR_SUPV | FLEXCAN_MCR_WRN_EN | |
Marc Kleine-Budde | d5a7b40 | 2013-10-04 10:52:36 +0200 | [diff] [blame] | 859 | FLEXCAN_MCR_IDAM_C | FLEXCAN_MCR_SRX_DIS | |
| 860 | FLEXCAN_MCR_MAXMB(FLEXCAN_TX_BUF_ID); |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 861 | netdev_dbg(dev, "%s: writing mcr=0x%08x", __func__, reg_mcr); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 862 | flexcan_write(reg_mcr, ®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 863 | |
| 864 | /* |
| 865 | * CTRL |
| 866 | * |
| 867 | * disable timer sync feature |
| 868 | * |
| 869 | * disable auto busoff recovery |
| 870 | * transmit lowest buffer first |
| 871 | * |
| 872 | * enable tx and rx warning interrupt |
| 873 | * enable bus off interrupt |
| 874 | * (== FLEXCAN_CTRL_ERR_STATE) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 875 | */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 876 | reg_ctrl = flexcan_read(®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 877 | reg_ctrl &= ~FLEXCAN_CTRL_TSYN; |
| 878 | reg_ctrl |= FLEXCAN_CTRL_BOFF_REC | FLEXCAN_CTRL_LBUF | |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 879 | FLEXCAN_CTRL_ERR_STATE; |
| 880 | /* |
| 881 | * enable the "error interrupt" (FLEXCAN_CTRL_ERR_MSK), |
| 882 | * on most Flexcan cores, too. Otherwise we don't get |
| 883 | * any error warning or passive interrupts. |
| 884 | */ |
| 885 | if (priv->devtype_data->features & FLEXCAN_HAS_BROKEN_ERR_STATE || |
| 886 | priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) |
| 887 | reg_ctrl |= FLEXCAN_CTRL_ERR_MSK; |
Alexander Stein | bc03a54 | 2014-08-12 10:47:21 +0200 | [diff] [blame] | 888 | else |
| 889 | reg_ctrl &= ~FLEXCAN_CTRL_ERR_MSK; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 890 | |
| 891 | /* save for later use */ |
| 892 | priv->reg_ctrl_default = reg_ctrl; |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 893 | netdev_dbg(dev, "%s: writing ctrl=0x%08x", __func__, reg_ctrl); |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 894 | flexcan_write(reg_ctrl, ®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 895 | |
David Jander | fc05b88 | 2014-08-27 11:58:05 +0200 | [diff] [blame] | 896 | /* clear and invalidate all mailboxes first */ |
| 897 | for (i = FLEXCAN_TX_BUF_ID; i < ARRAY_SIZE(regs->cantxfg); i++) { |
| 898 | flexcan_write(FLEXCAN_MB_CODE_RX_INACTIVE, |
| 899 | ®s->cantxfg[i].can_ctrl); |
| 900 | } |
| 901 | |
David Jander | 25e9244 | 2014-09-03 16:47:22 +0200 | [diff] [blame] | 902 | /* Errata ERR005829: mark first TX mailbox as INACTIVE */ |
| 903 | flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE, |
| 904 | ®s->cantxfg[FLEXCAN_TX_BUF_RESERVED].can_ctrl); |
| 905 | |
Marc Kleine-Budde | c32fe4a | 2014-09-16 12:39:28 +0200 | [diff] [blame] | 906 | /* mark TX mailbox as INACTIVE */ |
| 907 | flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE, |
Marc Kleine-Budde | d5a7b40 | 2013-10-04 10:52:36 +0200 | [diff] [blame] | 908 | ®s->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl); |
| 909 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 910 | /* acceptance mask/acceptance code (accept everything) */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 911 | flexcan_write(0x0, ®s->rxgmask); |
| 912 | flexcan_write(0x0, ®s->rx14mask); |
| 913 | flexcan_write(0x0, ®s->rx15mask); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 914 | |
Wolfgang Grandegger | 4f72e5f | 2012-09-28 03:17:15 +0000 | [diff] [blame] | 915 | if (priv->devtype_data->features & FLEXCAN_HAS_V10_FEATURES) |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 916 | flexcan_write(0x0, ®s->rxfgmask); |
| 917 | |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 918 | /* |
| 919 | * On Vybrid, disable memory error detection interrupts |
| 920 | * and freeze mode. |
| 921 | * This also works around errata e5295 which generates |
| 922 | * false positive memory errors and put the device in |
| 923 | * freeze mode. |
| 924 | */ |
| 925 | if (priv->devtype_data->features & FLEXCAN_HAS_MECR_FEATURES) { |
| 926 | /* |
| 927 | * Follow the protocol as described in "Detection |
| 928 | * and Correction of Memory Errors" to write to |
| 929 | * MECR register |
| 930 | */ |
| 931 | reg_crl2 = flexcan_read(®s->crl2); |
| 932 | reg_crl2 |= FLEXCAN_CRL2_ECRWRE; |
| 933 | flexcan_write(reg_crl2, ®s->crl2); |
| 934 | |
| 935 | reg_mecr = flexcan_read(®s->mecr); |
| 936 | reg_mecr &= ~FLEXCAN_MECR_ECRWRDIS; |
| 937 | flexcan_write(reg_mecr, ®s->mecr); |
| 938 | reg_mecr &= ~(FLEXCAN_MECR_NCEFAFRZ | FLEXCAN_MECR_HANCEI_MSK | |
| 939 | FLEXCAN_MECR_FANCEI_MSK); |
| 940 | flexcan_write(reg_mecr, ®s->mecr); |
| 941 | } |
| 942 | |
Marc Kleine-Budde | f003698 | 2014-02-28 17:18:27 +0100 | [diff] [blame] | 943 | err = flexcan_transceiver_enable(priv); |
| 944 | if (err) |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 945 | goto out_chip_disable; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 946 | |
| 947 | /* synchronize with the can bus */ |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 948 | err = flexcan_chip_unfreeze(priv); |
| 949 | if (err) |
| 950 | goto out_transceiver_disable; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 951 | |
| 952 | priv->can.state = CAN_STATE_ERROR_ACTIVE; |
| 953 | |
| 954 | /* enable FIFO interrupts */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 955 | flexcan_write(FLEXCAN_IFLAG_DEFAULT, ®s->imask1); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 956 | |
| 957 | /* print chip status */ |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 958 | netdev_dbg(dev, "%s: reading mcr=0x%08x ctrl=0x%08x\n", __func__, |
| 959 | flexcan_read(®s->mcr), flexcan_read(®s->ctrl)); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 960 | |
| 961 | return 0; |
| 962 | |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 963 | out_transceiver_disable: |
| 964 | flexcan_transceiver_disable(priv); |
| 965 | out_chip_disable: |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 966 | flexcan_chip_disable(priv); |
| 967 | return err; |
| 968 | } |
| 969 | |
| 970 | /* |
| 971 | * flexcan_chip_stop |
| 972 | * |
| 973 | * this functions is entered with clocks enabled |
| 974 | * |
| 975 | */ |
| 976 | static void flexcan_chip_stop(struct net_device *dev) |
| 977 | { |
| 978 | struct flexcan_priv *priv = netdev_priv(dev); |
| 979 | struct flexcan_regs __iomem *regs = priv->base; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 980 | |
Marc Kleine-Budde | b1aa1c7 | 2014-02-28 17:08:21 +0100 | [diff] [blame] | 981 | /* freeze + disable module */ |
| 982 | flexcan_chip_freeze(priv); |
| 983 | flexcan_chip_disable(priv); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 984 | |
Marc Kleine-Budde | 5be93bd | 2014-02-19 12:00:51 +0100 | [diff] [blame] | 985 | /* Disable all interrupts */ |
| 986 | flexcan_write(0, ®s->imask1); |
| 987 | flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL, |
| 988 | ®s->ctrl); |
| 989 | |
Marc Kleine-Budde | f003698 | 2014-02-28 17:18:27 +0100 | [diff] [blame] | 990 | flexcan_transceiver_disable(priv); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 991 | priv->can.state = CAN_STATE_STOPPED; |
| 992 | |
| 993 | return; |
| 994 | } |
| 995 | |
| 996 | static int flexcan_open(struct net_device *dev) |
| 997 | { |
| 998 | struct flexcan_priv *priv = netdev_priv(dev); |
| 999 | int err; |
| 1000 | |
Fabio Estevam | aa10181 | 2013-07-22 12:41:40 -0300 | [diff] [blame] | 1001 | err = clk_prepare_enable(priv->clk_ipg); |
| 1002 | if (err) |
| 1003 | return err; |
| 1004 | |
| 1005 | err = clk_prepare_enable(priv->clk_per); |
| 1006 | if (err) |
| 1007 | goto out_disable_ipg; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1008 | |
| 1009 | err = open_candev(dev); |
| 1010 | if (err) |
Fabio Estevam | aa10181 | 2013-07-22 12:41:40 -0300 | [diff] [blame] | 1011 | goto out_disable_per; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1012 | |
| 1013 | err = request_irq(dev->irq, flexcan_irq, IRQF_SHARED, dev->name, dev); |
| 1014 | if (err) |
| 1015 | goto out_close; |
| 1016 | |
| 1017 | /* start chip and queuing */ |
| 1018 | err = flexcan_chip_start(dev); |
| 1019 | if (err) |
Marc Kleine-Budde | 7e9e148 | 2014-02-28 14:52:01 +0100 | [diff] [blame] | 1020 | goto out_free_irq; |
Fabio Baltieri | adccadb | 2012-12-18 18:50:58 +0100 | [diff] [blame] | 1021 | |
| 1022 | can_led_event(dev, CAN_LED_EVENT_OPEN); |
| 1023 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1024 | napi_enable(&priv->napi); |
| 1025 | netif_start_queue(dev); |
| 1026 | |
| 1027 | return 0; |
| 1028 | |
Marc Kleine-Budde | 7e9e148 | 2014-02-28 14:52:01 +0100 | [diff] [blame] | 1029 | out_free_irq: |
| 1030 | free_irq(dev->irq, dev); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1031 | out_close: |
| 1032 | close_candev(dev); |
Fabio Estevam | aa10181 | 2013-07-22 12:41:40 -0300 | [diff] [blame] | 1033 | out_disable_per: |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1034 | clk_disable_unprepare(priv->clk_per); |
Fabio Estevam | aa10181 | 2013-07-22 12:41:40 -0300 | [diff] [blame] | 1035 | out_disable_ipg: |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1036 | clk_disable_unprepare(priv->clk_ipg); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1037 | |
| 1038 | return err; |
| 1039 | } |
| 1040 | |
| 1041 | static int flexcan_close(struct net_device *dev) |
| 1042 | { |
| 1043 | struct flexcan_priv *priv = netdev_priv(dev); |
| 1044 | |
| 1045 | netif_stop_queue(dev); |
| 1046 | napi_disable(&priv->napi); |
| 1047 | flexcan_chip_stop(dev); |
| 1048 | |
| 1049 | free_irq(dev->irq, dev); |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1050 | clk_disable_unprepare(priv->clk_per); |
| 1051 | clk_disable_unprepare(priv->clk_ipg); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1052 | |
| 1053 | close_candev(dev); |
| 1054 | |
Fabio Baltieri | adccadb | 2012-12-18 18:50:58 +0100 | [diff] [blame] | 1055 | can_led_event(dev, CAN_LED_EVENT_STOP); |
| 1056 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1057 | return 0; |
| 1058 | } |
| 1059 | |
| 1060 | static int flexcan_set_mode(struct net_device *dev, enum can_mode mode) |
| 1061 | { |
| 1062 | int err; |
| 1063 | |
| 1064 | switch (mode) { |
| 1065 | case CAN_MODE_START: |
| 1066 | err = flexcan_chip_start(dev); |
| 1067 | if (err) |
| 1068 | return err; |
| 1069 | |
| 1070 | netif_wake_queue(dev); |
| 1071 | break; |
| 1072 | |
| 1073 | default: |
| 1074 | return -EOPNOTSUPP; |
| 1075 | } |
| 1076 | |
| 1077 | return 0; |
| 1078 | } |
| 1079 | |
| 1080 | static const struct net_device_ops flexcan_netdev_ops = { |
| 1081 | .ndo_open = flexcan_open, |
| 1082 | .ndo_stop = flexcan_close, |
| 1083 | .ndo_start_xmit = flexcan_start_xmit, |
Oliver Hartkopp | c971fa2 | 2014-03-07 09:23:41 +0100 | [diff] [blame] | 1084 | .ndo_change_mtu = can_change_mtu, |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1085 | }; |
| 1086 | |
Bill Pemberton | 3c8ac0f | 2012-12-03 09:22:44 -0500 | [diff] [blame] | 1087 | static int register_flexcandev(struct net_device *dev) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1088 | { |
| 1089 | struct flexcan_priv *priv = netdev_priv(dev); |
| 1090 | struct flexcan_regs __iomem *regs = priv->base; |
| 1091 | u32 reg, err; |
| 1092 | |
Fabio Estevam | aa10181 | 2013-07-22 12:41:40 -0300 | [diff] [blame] | 1093 | err = clk_prepare_enable(priv->clk_ipg); |
| 1094 | if (err) |
| 1095 | return err; |
| 1096 | |
| 1097 | err = clk_prepare_enable(priv->clk_per); |
| 1098 | if (err) |
| 1099 | goto out_disable_ipg; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1100 | |
| 1101 | /* select "bus clock", chip must be disabled */ |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1102 | err = flexcan_chip_disable(priv); |
| 1103 | if (err) |
| 1104 | goto out_disable_per; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 1105 | reg = flexcan_read(®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1106 | reg |= FLEXCAN_CTRL_CLK_SRC; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 1107 | flexcan_write(reg, ®s->ctrl); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1108 | |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1109 | err = flexcan_chip_enable(priv); |
| 1110 | if (err) |
| 1111 | goto out_chip_disable; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1112 | |
| 1113 | /* set freeze, halt and activate FIFO, restrict register access */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 1114 | reg = flexcan_read(®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1115 | reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT | |
| 1116 | FLEXCAN_MCR_FEN | FLEXCAN_MCR_SUPV; |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 1117 | flexcan_write(reg, ®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1118 | |
| 1119 | /* |
| 1120 | * Currently we only support newer versions of this core |
| 1121 | * featuring a RX FIFO. Older cores found on some Coldfire |
| 1122 | * derivates are not yet supported. |
| 1123 | */ |
holt@sgi.com | 61e271e | 2011-08-16 17:32:20 +0000 | [diff] [blame] | 1124 | reg = flexcan_read(®s->mcr); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1125 | if (!(reg & FLEXCAN_MCR_FEN)) { |
Wolfgang Grandegger | aabdfd6 | 2012-02-01 11:02:05 +0100 | [diff] [blame] | 1126 | netdev_err(dev, "Could not enable RX FIFO, unsupported core\n"); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1127 | err = -ENODEV; |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1128 | goto out_chip_disable; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1129 | } |
| 1130 | |
| 1131 | err = register_candev(dev); |
| 1132 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1133 | /* disable core and turn off clocks */ |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1134 | out_chip_disable: |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1135 | flexcan_chip_disable(priv); |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1136 | out_disable_per: |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1137 | clk_disable_unprepare(priv->clk_per); |
Fabio Estevam | aa10181 | 2013-07-22 12:41:40 -0300 | [diff] [blame] | 1138 | out_disable_ipg: |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1139 | clk_disable_unprepare(priv->clk_ipg); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1140 | |
| 1141 | return err; |
| 1142 | } |
| 1143 | |
Bill Pemberton | 3c8ac0f | 2012-12-03 09:22:44 -0500 | [diff] [blame] | 1144 | static void unregister_flexcandev(struct net_device *dev) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1145 | { |
| 1146 | unregister_candev(dev); |
| 1147 | } |
| 1148 | |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1149 | static const struct of_device_id flexcan_of_match[] = { |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1150 | { .compatible = "fsl,imx6q-flexcan", .data = &fsl_imx6q_devtype_data, }, |
Marc Kleine-Budde | e358784 | 2013-10-03 23:51:55 +0200 | [diff] [blame] | 1151 | { .compatible = "fsl,imx28-flexcan", .data = &fsl_imx28_devtype_data, }, |
| 1152 | { .compatible = "fsl,p1010-flexcan", .data = &fsl_p1010_devtype_data, }, |
Stefan Agner | cdce844 | 2014-07-15 14:56:21 +0200 | [diff] [blame] | 1153 | { .compatible = "fsl,vf610-flexcan", .data = &fsl_vf610_devtype_data, }, |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1154 | { /* sentinel */ }, |
| 1155 | }; |
Marc Kleine-Budde | 4358a9d | 2012-10-04 10:55:35 +0200 | [diff] [blame] | 1156 | MODULE_DEVICE_TABLE(of, flexcan_of_match); |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1157 | |
| 1158 | static const struct platform_device_id flexcan_id_table[] = { |
| 1159 | { .name = "flexcan", .driver_data = (kernel_ulong_t)&fsl_p1010_devtype_data, }, |
| 1160 | { /* sentinel */ }, |
| 1161 | }; |
Marc Kleine-Budde | 4358a9d | 2012-10-04 10:55:35 +0200 | [diff] [blame] | 1162 | MODULE_DEVICE_TABLE(platform, flexcan_id_table); |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1163 | |
Bill Pemberton | 3c8ac0f | 2012-12-03 09:22:44 -0500 | [diff] [blame] | 1164 | static int flexcan_probe(struct platform_device *pdev) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1165 | { |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1166 | const struct of_device_id *of_id; |
Marc Kleine-Budde | dda0b3b | 2012-07-13 14:52:48 +0200 | [diff] [blame] | 1167 | const struct flexcan_devtype_data *devtype_data; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1168 | struct net_device *dev; |
| 1169 | struct flexcan_priv *priv; |
Andreas Werner | 555828e | 2015-03-22 17:35:52 +0100 | [diff] [blame] | 1170 | struct regulator *reg_xceiver; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1171 | struct resource *mem; |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1172 | struct clk *clk_ipg = NULL, *clk_per = NULL; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1173 | void __iomem *base; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1174 | int err, irq; |
holt@sgi.com | 97efe9a | 2011-08-16 17:32:23 +0000 | [diff] [blame] | 1175 | u32 clock_freq = 0; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1176 | |
Andreas Werner | 555828e | 2015-03-22 17:35:52 +0100 | [diff] [blame] | 1177 | reg_xceiver = devm_regulator_get(&pdev->dev, "xceiver"); |
| 1178 | if (PTR_ERR(reg_xceiver) == -EPROBE_DEFER) |
| 1179 | return -EPROBE_DEFER; |
| 1180 | else if (IS_ERR(reg_xceiver)) |
| 1181 | reg_xceiver = NULL; |
| 1182 | |
Hui Wang | afc016d | 2012-06-28 16:21:34 +0800 | [diff] [blame] | 1183 | if (pdev->dev.of_node) |
| 1184 | of_property_read_u32(pdev->dev.of_node, |
| 1185 | "clock-frequency", &clock_freq); |
holt@sgi.com | 97efe9a | 2011-08-16 17:32:23 +0000 | [diff] [blame] | 1186 | |
| 1187 | if (!clock_freq) { |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1188 | clk_ipg = devm_clk_get(&pdev->dev, "ipg"); |
| 1189 | if (IS_ERR(clk_ipg)) { |
| 1190 | dev_err(&pdev->dev, "no ipg clock defined\n"); |
Fabio Estevam | 933e4af | 2013-07-22 12:41:39 -0300 | [diff] [blame] | 1191 | return PTR_ERR(clk_ipg); |
holt@sgi.com | 97efe9a | 2011-08-16 17:32:23 +0000 | [diff] [blame] | 1192 | } |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1193 | |
| 1194 | clk_per = devm_clk_get(&pdev->dev, "per"); |
| 1195 | if (IS_ERR(clk_per)) { |
| 1196 | dev_err(&pdev->dev, "no per clock defined\n"); |
Fabio Estevam | 933e4af | 2013-07-22 12:41:39 -0300 | [diff] [blame] | 1197 | return PTR_ERR(clk_per); |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1198 | } |
Marc Kleine-Budde | 1a3e517 | 2013-11-25 22:15:20 +0100 | [diff] [blame] | 1199 | clock_freq = clk_get_rate(clk_per); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1200 | } |
| 1201 | |
| 1202 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 1203 | irq = platform_get_irq(pdev, 0); |
Fabio Estevam | 933e4af | 2013-07-22 12:41:39 -0300 | [diff] [blame] | 1204 | if (irq <= 0) |
| 1205 | return -ENODEV; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1206 | |
Fabio Estevam | 933e4af | 2013-07-22 12:41:39 -0300 | [diff] [blame] | 1207 | base = devm_ioremap_resource(&pdev->dev, mem); |
| 1208 | if (IS_ERR(base)) |
| 1209 | return PTR_ERR(base); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1210 | |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1211 | of_id = of_match_device(flexcan_of_match, &pdev->dev); |
| 1212 | if (of_id) { |
| 1213 | devtype_data = of_id->data; |
Marc Kleine-Budde | d0873e6 | 2014-03-04 22:04:22 +0100 | [diff] [blame] | 1214 | } else if (platform_get_device_id(pdev)->driver_data) { |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1215 | devtype_data = (struct flexcan_devtype_data *) |
Marc Kleine-Budde | d0873e6 | 2014-03-04 22:04:22 +0100 | [diff] [blame] | 1216 | platform_get_device_id(pdev)->driver_data; |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1217 | } else { |
Fabio Estevam | 933e4af | 2013-07-22 12:41:39 -0300 | [diff] [blame] | 1218 | return -ENODEV; |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1219 | } |
| 1220 | |
Fabio Estevam | 933e4af | 2013-07-22 12:41:39 -0300 | [diff] [blame] | 1221 | dev = alloc_candev(sizeof(struct flexcan_priv), 1); |
| 1222 | if (!dev) |
| 1223 | return -ENOMEM; |
| 1224 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1225 | dev->netdev_ops = &flexcan_netdev_ops; |
| 1226 | dev->irq = irq; |
Reuben Dowle | 9a12349 | 2011-11-01 11:18:03 +1300 | [diff] [blame] | 1227 | dev->flags |= IFF_ECHO; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1228 | |
| 1229 | priv = netdev_priv(dev); |
holt@sgi.com | 97efe9a | 2011-08-16 17:32:23 +0000 | [diff] [blame] | 1230 | priv->can.clock.freq = clock_freq; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1231 | priv->can.bittiming_const = &flexcan_bittiming_const; |
| 1232 | priv->can.do_set_mode = flexcan_set_mode; |
| 1233 | priv->can.do_get_berr_counter = flexcan_get_berr_counter; |
| 1234 | priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | |
| 1235 | CAN_CTRLMODE_LISTENONLY | CAN_CTRLMODE_3_SAMPLES | |
| 1236 | CAN_CTRLMODE_BERR_REPORTING; |
| 1237 | priv->base = base; |
Steffen Trumtrar | 3d42a37 | 2012-07-17 16:14:34 +0200 | [diff] [blame] | 1238 | priv->clk_ipg = clk_ipg; |
| 1239 | priv->clk_per = clk_per; |
Jingoo Han | 84ae664 | 2013-09-10 17:41:30 +0900 | [diff] [blame] | 1240 | priv->pdata = dev_get_platdata(&pdev->dev); |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1241 | priv->devtype_data = devtype_data; |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1242 | |
Andreas Werner | 555828e | 2015-03-22 17:35:52 +0100 | [diff] [blame] | 1243 | priv->reg_xceiver = reg_xceiver; |
Fabio Estevam | b7c4114 | 2013-06-10 23:12:57 -0300 | [diff] [blame] | 1244 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1245 | netif_napi_add(dev, &priv->napi, flexcan_poll, FLEXCAN_NAPI_WEIGHT); |
| 1246 | |
Libo Chen | d75ea94 | 2013-08-21 18:15:08 +0800 | [diff] [blame] | 1247 | platform_set_drvdata(pdev, dev); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1248 | SET_NETDEV_DEV(dev, &pdev->dev); |
| 1249 | |
| 1250 | err = register_flexcandev(dev); |
| 1251 | if (err) { |
| 1252 | dev_err(&pdev->dev, "registering netdev failed\n"); |
| 1253 | goto failed_register; |
| 1254 | } |
| 1255 | |
Fabio Baltieri | adccadb | 2012-12-18 18:50:58 +0100 | [diff] [blame] | 1256 | devm_can_led_init(dev); |
| 1257 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1258 | dev_info(&pdev->dev, "device registered (reg_base=%p, irq=%d)\n", |
| 1259 | priv->base, dev->irq); |
| 1260 | |
| 1261 | return 0; |
| 1262 | |
| 1263 | failed_register: |
| 1264 | free_candev(dev); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1265 | return err; |
| 1266 | } |
| 1267 | |
Bill Pemberton | 3c8ac0f | 2012-12-03 09:22:44 -0500 | [diff] [blame] | 1268 | static int flexcan_remove(struct platform_device *pdev) |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1269 | { |
| 1270 | struct net_device *dev = platform_get_drvdata(pdev); |
Marc Kleine-Budde | d96e43e | 2014-02-28 20:48:36 +0100 | [diff] [blame] | 1271 | struct flexcan_priv *priv = netdev_priv(dev); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1272 | |
| 1273 | unregister_flexcandev(dev); |
Marc Kleine-Budde | d96e43e | 2014-02-28 20:48:36 +0100 | [diff] [blame] | 1274 | netif_napi_del(&priv->napi); |
Marc Kleine-Budde | 9a27586 | 2010-10-21 05:07:58 +0000 | [diff] [blame] | 1275 | free_candev(dev); |
| 1276 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1277 | return 0; |
| 1278 | } |
| 1279 | |
Marc Kleine-Budde | 08c6d35 | 2014-03-05 19:10:44 +0100 | [diff] [blame] | 1280 | static int __maybe_unused flexcan_suspend(struct device *device) |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1281 | { |
Fabio Estevam | 588e7a8 | 2013-05-20 15:43:43 -0300 | [diff] [blame] | 1282 | struct net_device *dev = dev_get_drvdata(device); |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1283 | struct flexcan_priv *priv = netdev_priv(dev); |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1284 | int err; |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1285 | |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1286 | err = flexcan_chip_disable(priv); |
| 1287 | if (err) |
| 1288 | return err; |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1289 | |
| 1290 | if (netif_running(dev)) { |
| 1291 | netif_stop_queue(dev); |
| 1292 | netif_device_detach(dev); |
| 1293 | } |
| 1294 | priv->can.state = CAN_STATE_SLEEPING; |
| 1295 | |
| 1296 | return 0; |
| 1297 | } |
| 1298 | |
Marc Kleine-Budde | 08c6d35 | 2014-03-05 19:10:44 +0100 | [diff] [blame] | 1299 | static int __maybe_unused flexcan_resume(struct device *device) |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1300 | { |
Fabio Estevam | 588e7a8 | 2013-05-20 15:43:43 -0300 | [diff] [blame] | 1301 | struct net_device *dev = dev_get_drvdata(device); |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1302 | struct flexcan_priv *priv = netdev_priv(dev); |
| 1303 | |
| 1304 | priv->can.state = CAN_STATE_ERROR_ACTIVE; |
| 1305 | if (netif_running(dev)) { |
| 1306 | netif_device_attach(dev); |
| 1307 | netif_start_queue(dev); |
| 1308 | } |
Marc Kleine-Budde | 9b00b30 | 2014-02-28 15:30:18 +0100 | [diff] [blame] | 1309 | return flexcan_chip_enable(priv); |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1310 | } |
Fabio Estevam | 588e7a8 | 2013-05-20 15:43:43 -0300 | [diff] [blame] | 1311 | |
| 1312 | static SIMPLE_DEV_PM_OPS(flexcan_pm_ops, flexcan_suspend, flexcan_resume); |
Eric Bénard | 8b5e218 | 2012-05-08 17:12:17 +0200 | [diff] [blame] | 1313 | |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1314 | static struct platform_driver flexcan_driver = { |
holt@sgi.com | c8aef4c | 2011-08-16 17:32:22 +0000 | [diff] [blame] | 1315 | .driver = { |
| 1316 | .name = DRV_NAME, |
Fabio Estevam | 588e7a8 | 2013-05-20 15:43:43 -0300 | [diff] [blame] | 1317 | .pm = &flexcan_pm_ops, |
holt@sgi.com | c8aef4c | 2011-08-16 17:32:22 +0000 | [diff] [blame] | 1318 | .of_match_table = flexcan_of_match, |
| 1319 | }, |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1320 | .probe = flexcan_probe, |
Bill Pemberton | 3c8ac0f | 2012-12-03 09:22:44 -0500 | [diff] [blame] | 1321 | .remove = flexcan_remove, |
Hui Wang | 30c1e67 | 2012-06-28 16:21:35 +0800 | [diff] [blame] | 1322 | .id_table = flexcan_id_table, |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1323 | }; |
| 1324 | |
Axel Lin | 871d337 | 2011-11-27 15:42:31 +0000 | [diff] [blame] | 1325 | module_platform_driver(flexcan_driver); |
Marc Kleine-Budde | e955cea | 2009-07-29 10:20:10 +0200 | [diff] [blame] | 1326 | |
| 1327 | MODULE_AUTHOR("Sascha Hauer <kernel@pengutronix.de>, " |
| 1328 | "Marc Kleine-Budde <kernel@pengutronix.de>"); |
| 1329 | MODULE_LICENSE("GPL v2"); |
| 1330 | MODULE_DESCRIPTION("CAN port driver for flexcan based chip"); |