1 /* 2 * CAN bus driver for IFI CANFD controller 3 * 4 * Copyright (C) 2016 Marek Vasut <marex@denx.de> 5 * 6 * Details about this controller can be found at 7 * http://www.ifi-pld.de/IP/CANFD/canfd.html 8 * 9 * This file is licensed under the terms of the GNU General Public 10 * License version 2. This program is licensed "as is" without any 11 * warranty of any kind, whether express or implied. 12 */ 13 14 #include <linux/clk.h> 15 #include <linux/delay.h> 16 #include <linux/ethtool.h> 17 #include <linux/interrupt.h> 18 #include <linux/io.h> 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/netdevice.h> 22 #include <linux/of.h> 23 #include <linux/of_device.h> 24 #include <linux/platform_device.h> 25 26 #include <linux/can/dev.h> 27 28 #define IFI_CANFD_STCMD 0x0 29 #define IFI_CANFD_STCMD_HARDRESET 0xDEADCAFD 30 #define IFI_CANFD_STCMD_ENABLE BIT(0) 31 #define IFI_CANFD_STCMD_ERROR_ACTIVE BIT(2) 32 #define IFI_CANFD_STCMD_ERROR_PASSIVE BIT(3) 33 #define IFI_CANFD_STCMD_BUSOFF BIT(4) 34 #define IFI_CANFD_STCMD_ERROR_WARNING BIT(5) 35 #define IFI_CANFD_STCMD_BUSMONITOR BIT(16) 36 #define IFI_CANFD_STCMD_LOOPBACK BIT(18) 37 #define IFI_CANFD_STCMD_DISABLE_CANFD BIT(24) 38 #define IFI_CANFD_STCMD_ENABLE_ISO BIT(25) 39 #define IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING BIT(26) 40 #define IFI_CANFD_STCMD_NORMAL_MODE ((u32)BIT(31)) 41 42 #define IFI_CANFD_RXSTCMD 0x4 43 #define IFI_CANFD_RXSTCMD_REMOVE_MSG BIT(0) 44 #define IFI_CANFD_RXSTCMD_RESET BIT(7) 45 #define IFI_CANFD_RXSTCMD_EMPTY BIT(8) 46 #define IFI_CANFD_RXSTCMD_OVERFLOW BIT(13) 47 48 #define IFI_CANFD_TXSTCMD 0x8 49 #define IFI_CANFD_TXSTCMD_ADD_MSG BIT(0) 50 #define IFI_CANFD_TXSTCMD_HIGH_PRIO BIT(1) 51 #define IFI_CANFD_TXSTCMD_RESET BIT(7) 52 #define IFI_CANFD_TXSTCMD_EMPTY BIT(8) 53 #define IFI_CANFD_TXSTCMD_FULL BIT(12) 54 #define IFI_CANFD_TXSTCMD_OVERFLOW BIT(13) 55 56 #define IFI_CANFD_INTERRUPT 0xc 57 #define IFI_CANFD_INTERRUPT_ERROR_BUSOFF BIT(0) 58 #define IFI_CANFD_INTERRUPT_ERROR_WARNING BIT(1) 59 #define IFI_CANFD_INTERRUPT_ERROR_STATE_CHG BIT(2) 60 #define IFI_CANFD_INTERRUPT_ERROR_REC_TEC_INC BIT(3) 61 #define IFI_CANFD_INTERRUPT_ERROR_COUNTER BIT(10) 62 #define IFI_CANFD_INTERRUPT_TXFIFO_EMPTY BIT(16) 63 #define IFI_CANFD_INTERRUPT_TXFIFO_REMOVE BIT(22) 64 #define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY BIT(24) 65 #define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER BIT(25) 66 #define IFI_CANFD_INTERRUPT_SET_IRQ ((u32)BIT(31)) 67 68 #define IFI_CANFD_IRQMASK 0x10 69 #define IFI_CANFD_IRQMASK_ERROR_BUSOFF BIT(0) 70 #define IFI_CANFD_IRQMASK_ERROR_WARNING BIT(1) 71 #define IFI_CANFD_IRQMASK_ERROR_STATE_CHG BIT(2) 72 #define IFI_CANFD_IRQMASK_ERROR_REC_TEC_INC BIT(3) 73 #define IFI_CANFD_IRQMASK_SET_ERR BIT(7) 74 #define IFI_CANFD_IRQMASK_SET_TS BIT(15) 75 #define IFI_CANFD_IRQMASK_TXFIFO_EMPTY BIT(16) 76 #define IFI_CANFD_IRQMASK_SET_TX BIT(23) 77 #define IFI_CANFD_IRQMASK_RXFIFO_NEMPTY BIT(24) 78 #define IFI_CANFD_IRQMASK_SET_RX ((u32)BIT(31)) 79 80 #define IFI_CANFD_TIME 0x14 81 #define IFI_CANFD_FTIME 0x18 82 #define IFI_CANFD_TIME_TIMEB_OFF 0 83 #define IFI_CANFD_TIME_TIMEA_OFF 8 84 #define IFI_CANFD_TIME_PRESCALE_OFF 16 85 #define IFI_CANFD_TIME_SJW_OFF_7_9_8_8 25 86 #define IFI_CANFD_TIME_SJW_OFF_4_12_6_6 28 87 #define IFI_CANFD_TIME_SET_SJW_4_12_6_6 BIT(6) 88 #define IFI_CANFD_TIME_SET_TIMEB_4_12_6_6 BIT(7) 89 #define IFI_CANFD_TIME_SET_PRESC_4_12_6_6 BIT(14) 90 #define IFI_CANFD_TIME_SET_TIMEA_4_12_6_6 BIT(15) 91 92 #define IFI_CANFD_TDELAY 0x1c 93 #define IFI_CANFD_TDELAY_DEFAULT 0xb 94 #define IFI_CANFD_TDELAY_MASK 0x3fff 95 #define IFI_CANFD_TDELAY_ABS BIT(14) 96 #define IFI_CANFD_TDELAY_EN BIT(15) 97 98 #define IFI_CANFD_ERROR 0x20 99 #define IFI_CANFD_ERROR_TX_OFFSET 0 100 #define IFI_CANFD_ERROR_TX_MASK 0xff 101 #define IFI_CANFD_ERROR_RX_OFFSET 16 102 #define IFI_CANFD_ERROR_RX_MASK 0xff 103 104 #define IFI_CANFD_ERRCNT 0x24 105 106 #define IFI_CANFD_SUSPEND 0x28 107 108 #define IFI_CANFD_REPEAT 0x2c 109 110 #define IFI_CANFD_TRAFFIC 0x30 111 112 #define IFI_CANFD_TSCONTROL 0x34 113 114 #define IFI_CANFD_TSC 0x38 115 116 #define IFI_CANFD_TST 0x3c 117 118 #define IFI_CANFD_RES1 0x40 119 120 #define IFI_CANFD_ERROR_CTR 0x44 121 #define IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC 0x21302899 122 #define IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST BIT(0) 123 #define IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST BIT(1) 124 #define IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST BIT(2) 125 #define IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST BIT(3) 126 #define IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST BIT(4) 127 #define IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST BIT(5) 128 #define IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST BIT(6) 129 #define IFI_CANFD_ERROR_CTR_OVERLOAD_ALL BIT(8) 130 #define IFI_CANFD_ERROR_CTR_ACK_ERROR_ALL BIT(9) 131 #define IFI_CANFD_ERROR_CTR_BIT0_ERROR_ALL BIT(10) 132 #define IFI_CANFD_ERROR_CTR_BIT1_ERROR_ALL BIT(11) 133 #define IFI_CANFD_ERROR_CTR_STUFF_ERROR_ALL BIT(12) 134 #define IFI_CANFD_ERROR_CTR_CRC_ERROR_ALL BIT(13) 135 #define IFI_CANFD_ERROR_CTR_FORM_ERROR_ALL BIT(14) 136 #define IFI_CANFD_ERROR_CTR_BITPOSITION_OFFSET 16 137 #define IFI_CANFD_ERROR_CTR_BITPOSITION_MASK 0xff 138 #define IFI_CANFD_ERROR_CTR_ER_RESET BIT(30) 139 #define IFI_CANFD_ERROR_CTR_ER_ENABLE ((u32)BIT(31)) 140 141 #define IFI_CANFD_PAR 0x48 142 143 #define IFI_CANFD_CANCLOCK 0x4c 144 145 #define IFI_CANFD_SYSCLOCK 0x50 146 147 #define IFI_CANFD_VER 0x54 148 #define IFI_CANFD_VER_REV_MASK 0xff 149 #define IFI_CANFD_VER_REV_MIN_SUPPORTED 0x15 150 151 #define IFI_CANFD_IP_ID 0x58 152 #define IFI_CANFD_IP_ID_VALUE 0xD073CAFD 153 154 #define IFI_CANFD_TEST 0x5c 155 156 #define IFI_CANFD_RXFIFO_TS_63_32 0x60 157 158 #define IFI_CANFD_RXFIFO_TS_31_0 0x64 159 160 #define IFI_CANFD_RXFIFO_DLC 0x68 161 #define IFI_CANFD_RXFIFO_DLC_DLC_OFFSET 0 162 #define IFI_CANFD_RXFIFO_DLC_DLC_MASK 0xf 163 #define IFI_CANFD_RXFIFO_DLC_RTR BIT(4) 164 #define IFI_CANFD_RXFIFO_DLC_EDL BIT(5) 165 #define IFI_CANFD_RXFIFO_DLC_BRS BIT(6) 166 #define IFI_CANFD_RXFIFO_DLC_ESI BIT(7) 167 #define IFI_CANFD_RXFIFO_DLC_OBJ_OFFSET 8 168 #define IFI_CANFD_RXFIFO_DLC_OBJ_MASK 0x1ff 169 #define IFI_CANFD_RXFIFO_DLC_FNR_OFFSET 24 170 #define IFI_CANFD_RXFIFO_DLC_FNR_MASK 0xff 171 172 #define IFI_CANFD_RXFIFO_ID 0x6c 173 #define IFI_CANFD_RXFIFO_ID_ID_OFFSET 0 174 #define IFI_CANFD_RXFIFO_ID_ID_STD_MASK CAN_SFF_MASK 175 #define IFI_CANFD_RXFIFO_ID_ID_STD_OFFSET 0 176 #define IFI_CANFD_RXFIFO_ID_ID_STD_WIDTH 10 177 #define IFI_CANFD_RXFIFO_ID_ID_XTD_MASK CAN_EFF_MASK 178 #define IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET 11 179 #define IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH 18 180 #define IFI_CANFD_RXFIFO_ID_IDE BIT(29) 181 182 #define IFI_CANFD_RXFIFO_DATA 0x70 /* 0x70..0xac */ 183 184 #define IFI_CANFD_TXFIFO_SUSPEND_US 0xb0 185 186 #define IFI_CANFD_TXFIFO_REPEATCOUNT 0xb4 187 188 #define IFI_CANFD_TXFIFO_DLC 0xb8 189 #define IFI_CANFD_TXFIFO_DLC_DLC_OFFSET 0 190 #define IFI_CANFD_TXFIFO_DLC_DLC_MASK 0xf 191 #define IFI_CANFD_TXFIFO_DLC_RTR BIT(4) 192 #define IFI_CANFD_TXFIFO_DLC_EDL BIT(5) 193 #define IFI_CANFD_TXFIFO_DLC_BRS BIT(6) 194 #define IFI_CANFD_TXFIFO_DLC_FNR_OFFSET 24 195 #define IFI_CANFD_TXFIFO_DLC_FNR_MASK 0xff 196 197 #define IFI_CANFD_TXFIFO_ID 0xbc 198 #define IFI_CANFD_TXFIFO_ID_ID_OFFSET 0 199 #define IFI_CANFD_TXFIFO_ID_ID_STD_MASK CAN_SFF_MASK 200 #define IFI_CANFD_TXFIFO_ID_ID_STD_OFFSET 0 201 #define IFI_CANFD_TXFIFO_ID_ID_STD_WIDTH 10 202 #define IFI_CANFD_TXFIFO_ID_ID_XTD_MASK CAN_EFF_MASK 203 #define IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET 11 204 #define IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH 18 205 #define IFI_CANFD_TXFIFO_ID_IDE BIT(29) 206 207 #define IFI_CANFD_TXFIFO_DATA 0xc0 /* 0xb0..0xfc */ 208 209 #define IFI_CANFD_FILTER_MASK(n) (0x800 + ((n) * 8) + 0) 210 #define IFI_CANFD_FILTER_MASK_EXT BIT(29) 211 #define IFI_CANFD_FILTER_MASK_EDL BIT(30) 212 #define IFI_CANFD_FILTER_MASK_VALID ((u32)BIT(31)) 213 214 #define IFI_CANFD_FILTER_IDENT(n) (0x800 + ((n) * 8) + 4) 215 #define IFI_CANFD_FILTER_IDENT_IDE BIT(29) 216 #define IFI_CANFD_FILTER_IDENT_CANFD BIT(30) 217 #define IFI_CANFD_FILTER_IDENT_VALID ((u32)BIT(31)) 218 219 /* IFI CANFD private data structure */ 220 struct ifi_canfd_priv { 221 struct can_priv can; /* must be the first member */ 222 struct napi_struct napi; 223 struct net_device *ndev; 224 void __iomem *base; 225 }; 226 227 static void ifi_canfd_irq_enable(struct net_device *ndev, bool enable) 228 { 229 struct ifi_canfd_priv *priv = netdev_priv(ndev); 230 u32 enirq = 0; 231 232 if (enable) { 233 enirq = IFI_CANFD_IRQMASK_TXFIFO_EMPTY | 234 IFI_CANFD_IRQMASK_RXFIFO_NEMPTY | 235 IFI_CANFD_IRQMASK_ERROR_STATE_CHG | 236 IFI_CANFD_IRQMASK_ERROR_WARNING | 237 IFI_CANFD_IRQMASK_ERROR_BUSOFF; 238 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) 239 enirq |= IFI_CANFD_INTERRUPT_ERROR_COUNTER; 240 } 241 242 writel(IFI_CANFD_IRQMASK_SET_ERR | 243 IFI_CANFD_IRQMASK_SET_TS | 244 IFI_CANFD_IRQMASK_SET_TX | 245 IFI_CANFD_IRQMASK_SET_RX | enirq, 246 priv->base + IFI_CANFD_IRQMASK); 247 } 248 249 static void ifi_canfd_read_fifo(struct net_device *ndev) 250 { 251 struct net_device_stats *stats = &ndev->stats; 252 struct ifi_canfd_priv *priv = netdev_priv(ndev); 253 struct canfd_frame *cf; 254 struct sk_buff *skb; 255 const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY | 256 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER; 257 u32 rxdlc, rxid; 258 u32 dlc, id; 259 int i; 260 261 rxdlc = readl(priv->base + IFI_CANFD_RXFIFO_DLC); 262 if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL) 263 skb = alloc_canfd_skb(ndev, &cf); 264 else 265 skb = alloc_can_skb(ndev, (struct can_frame **)&cf); 266 267 if (!skb) { 268 stats->rx_dropped++; 269 return; 270 } 271 272 dlc = (rxdlc >> IFI_CANFD_RXFIFO_DLC_DLC_OFFSET) & 273 IFI_CANFD_RXFIFO_DLC_DLC_MASK; 274 if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL) 275 cf->len = can_fd_dlc2len(dlc); 276 else 277 cf->len = can_cc_dlc2len(dlc); 278 279 rxid = readl(priv->base + IFI_CANFD_RXFIFO_ID); 280 id = (rxid >> IFI_CANFD_RXFIFO_ID_ID_OFFSET); 281 if (id & IFI_CANFD_RXFIFO_ID_IDE) { 282 id &= IFI_CANFD_RXFIFO_ID_ID_XTD_MASK; 283 /* 284 * In case the Extended ID frame is received, the standard 285 * and extended part of the ID are swapped in the register, 286 * so swap them back to obtain the correct ID. 287 */ 288 id = (id >> IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET) | 289 ((id & IFI_CANFD_RXFIFO_ID_ID_STD_MASK) << 290 IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH); 291 id |= CAN_EFF_FLAG; 292 } else { 293 id &= IFI_CANFD_RXFIFO_ID_ID_STD_MASK; 294 } 295 cf->can_id = id; 296 297 if (rxdlc & IFI_CANFD_RXFIFO_DLC_ESI) { 298 cf->flags |= CANFD_ESI; 299 netdev_dbg(ndev, "ESI Error\n"); 300 } 301 302 if (!(rxdlc & IFI_CANFD_RXFIFO_DLC_EDL) && 303 (rxdlc & IFI_CANFD_RXFIFO_DLC_RTR)) { 304 cf->can_id |= CAN_RTR_FLAG; 305 } else { 306 if (rxdlc & IFI_CANFD_RXFIFO_DLC_BRS) 307 cf->flags |= CANFD_BRS; 308 309 for (i = 0; i < cf->len; i += 4) { 310 *(u32 *)(cf->data + i) = 311 readl(priv->base + IFI_CANFD_RXFIFO_DATA + i); 312 } 313 314 stats->rx_bytes += cf->len; 315 } 316 stats->rx_packets++; 317 318 /* Remove the packet from FIFO */ 319 writel(IFI_CANFD_RXSTCMD_REMOVE_MSG, priv->base + IFI_CANFD_RXSTCMD); 320 writel(rx_irq_mask, priv->base + IFI_CANFD_INTERRUPT); 321 322 netif_receive_skb(skb); 323 } 324 325 static int ifi_canfd_do_rx_poll(struct net_device *ndev, int quota) 326 { 327 struct ifi_canfd_priv *priv = netdev_priv(ndev); 328 u32 pkts = 0; 329 u32 rxst; 330 331 rxst = readl(priv->base + IFI_CANFD_RXSTCMD); 332 if (rxst & IFI_CANFD_RXSTCMD_EMPTY) { 333 netdev_dbg(ndev, "No messages in RX FIFO\n"); 334 return 0; 335 } 336 337 for (;;) { 338 if (rxst & IFI_CANFD_RXSTCMD_EMPTY) 339 break; 340 if (quota <= 0) 341 break; 342 343 ifi_canfd_read_fifo(ndev); 344 quota--; 345 pkts++; 346 rxst = readl(priv->base + IFI_CANFD_RXSTCMD); 347 } 348 349 return pkts; 350 } 351 352 static int ifi_canfd_handle_lost_msg(struct net_device *ndev) 353 { 354 struct net_device_stats *stats = &ndev->stats; 355 struct sk_buff *skb; 356 struct can_frame *frame; 357 358 netdev_err(ndev, "RX FIFO overflow, message(s) lost.\n"); 359 360 stats->rx_errors++; 361 stats->rx_over_errors++; 362 363 skb = alloc_can_err_skb(ndev, &frame); 364 if (unlikely(!skb)) 365 return 0; 366 367 frame->can_id |= CAN_ERR_CRTL; 368 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 369 370 netif_receive_skb(skb); 371 372 return 1; 373 } 374 375 static int ifi_canfd_handle_lec_err(struct net_device *ndev) 376 { 377 struct ifi_canfd_priv *priv = netdev_priv(ndev); 378 struct net_device_stats *stats = &ndev->stats; 379 struct can_frame *cf; 380 struct sk_buff *skb; 381 u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR); 382 const u32 errmask = IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST | 383 IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST | 384 IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST | 385 IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST | 386 IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST | 387 IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST | 388 IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST; 389 390 if (!(errctr & errmask)) /* No error happened. */ 391 return 0; 392 393 priv->can.can_stats.bus_error++; 394 stats->rx_errors++; 395 396 /* Propagate the error condition to the CAN stack. */ 397 skb = alloc_can_err_skb(ndev, &cf); 398 if (unlikely(!skb)) 399 return 0; 400 401 /* Read the error counter register and check for new errors. */ 402 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 403 404 if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST) 405 cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 406 407 if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST) 408 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 409 410 if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST) 411 cf->data[2] |= CAN_ERR_PROT_BIT0; 412 413 if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST) 414 cf->data[2] |= CAN_ERR_PROT_BIT1; 415 416 if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST) 417 cf->data[2] |= CAN_ERR_PROT_STUFF; 418 419 if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST) 420 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 421 422 if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST) 423 cf->data[2] |= CAN_ERR_PROT_FORM; 424 425 /* Reset the error counter, ack the IRQ and re-enable the counter. */ 426 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 427 writel(IFI_CANFD_INTERRUPT_ERROR_COUNTER, 428 priv->base + IFI_CANFD_INTERRUPT); 429 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR); 430 431 netif_receive_skb(skb); 432 433 return 1; 434 } 435 436 static int ifi_canfd_get_berr_counter(const struct net_device *ndev, 437 struct can_berr_counter *bec) 438 { 439 struct ifi_canfd_priv *priv = netdev_priv(ndev); 440 u32 err; 441 442 err = readl(priv->base + IFI_CANFD_ERROR); 443 bec->rxerr = (err >> IFI_CANFD_ERROR_RX_OFFSET) & 444 IFI_CANFD_ERROR_RX_MASK; 445 bec->txerr = (err >> IFI_CANFD_ERROR_TX_OFFSET) & 446 IFI_CANFD_ERROR_TX_MASK; 447 448 return 0; 449 } 450 451 static int ifi_canfd_handle_state_change(struct net_device *ndev, 452 enum can_state new_state) 453 { 454 struct ifi_canfd_priv *priv = netdev_priv(ndev); 455 struct can_frame *cf; 456 struct sk_buff *skb; 457 struct can_berr_counter bec; 458 459 switch (new_state) { 460 case CAN_STATE_ERROR_ACTIVE: 461 /* error active state */ 462 priv->can.can_stats.error_warning++; 463 priv->can.state = CAN_STATE_ERROR_ACTIVE; 464 break; 465 case CAN_STATE_ERROR_WARNING: 466 /* error warning state */ 467 priv->can.can_stats.error_warning++; 468 priv->can.state = CAN_STATE_ERROR_WARNING; 469 break; 470 case CAN_STATE_ERROR_PASSIVE: 471 /* error passive state */ 472 priv->can.can_stats.error_passive++; 473 priv->can.state = CAN_STATE_ERROR_PASSIVE; 474 break; 475 case CAN_STATE_BUS_OFF: 476 /* bus-off state */ 477 priv->can.state = CAN_STATE_BUS_OFF; 478 ifi_canfd_irq_enable(ndev, 0); 479 priv->can.can_stats.bus_off++; 480 can_bus_off(ndev); 481 break; 482 default: 483 break; 484 } 485 486 /* propagate the error condition to the CAN stack */ 487 skb = alloc_can_err_skb(ndev, &cf); 488 if (unlikely(!skb)) 489 return 0; 490 491 ifi_canfd_get_berr_counter(ndev, &bec); 492 493 switch (new_state) { 494 case CAN_STATE_ERROR_WARNING: 495 /* error warning state */ 496 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT; 497 cf->data[1] = (bec.txerr > bec.rxerr) ? 498 CAN_ERR_CRTL_TX_WARNING : 499 CAN_ERR_CRTL_RX_WARNING; 500 cf->data[6] = bec.txerr; 501 cf->data[7] = bec.rxerr; 502 break; 503 case CAN_STATE_ERROR_PASSIVE: 504 /* error passive state */ 505 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT; 506 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE; 507 if (bec.txerr > 127) 508 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE; 509 cf->data[6] = bec.txerr; 510 cf->data[7] = bec.rxerr; 511 break; 512 case CAN_STATE_BUS_OFF: 513 /* bus-off state */ 514 cf->can_id |= CAN_ERR_BUSOFF; 515 break; 516 default: 517 break; 518 } 519 520 netif_receive_skb(skb); 521 522 return 1; 523 } 524 525 static int ifi_canfd_handle_state_errors(struct net_device *ndev) 526 { 527 struct ifi_canfd_priv *priv = netdev_priv(ndev); 528 u32 stcmd = readl(priv->base + IFI_CANFD_STCMD); 529 int work_done = 0; 530 531 if ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) && 532 (priv->can.state != CAN_STATE_ERROR_ACTIVE)) { 533 netdev_dbg(ndev, "Error, entered active state\n"); 534 work_done += ifi_canfd_handle_state_change(ndev, 535 CAN_STATE_ERROR_ACTIVE); 536 } 537 538 if ((stcmd & IFI_CANFD_STCMD_ERROR_WARNING) && 539 (priv->can.state != CAN_STATE_ERROR_WARNING)) { 540 netdev_dbg(ndev, "Error, entered warning state\n"); 541 work_done += ifi_canfd_handle_state_change(ndev, 542 CAN_STATE_ERROR_WARNING); 543 } 544 545 if ((stcmd & IFI_CANFD_STCMD_ERROR_PASSIVE) && 546 (priv->can.state != CAN_STATE_ERROR_PASSIVE)) { 547 netdev_dbg(ndev, "Error, entered passive state\n"); 548 work_done += ifi_canfd_handle_state_change(ndev, 549 CAN_STATE_ERROR_PASSIVE); 550 } 551 552 if ((stcmd & IFI_CANFD_STCMD_BUSOFF) && 553 (priv->can.state != CAN_STATE_BUS_OFF)) { 554 netdev_dbg(ndev, "Error, entered bus-off state\n"); 555 work_done += ifi_canfd_handle_state_change(ndev, 556 CAN_STATE_BUS_OFF); 557 } 558 559 return work_done; 560 } 561 562 static int ifi_canfd_poll(struct napi_struct *napi, int quota) 563 { 564 struct net_device *ndev = napi->dev; 565 struct ifi_canfd_priv *priv = netdev_priv(ndev); 566 u32 rxstcmd = readl(priv->base + IFI_CANFD_RXSTCMD); 567 int work_done = 0; 568 569 /* Handle bus state changes */ 570 work_done += ifi_canfd_handle_state_errors(ndev); 571 572 /* Handle lost messages on RX */ 573 if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW) 574 work_done += ifi_canfd_handle_lost_msg(ndev); 575 576 /* Handle lec errors on the bus */ 577 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) 578 work_done += ifi_canfd_handle_lec_err(ndev); 579 580 /* Handle normal messages on RX */ 581 if (!(rxstcmd & IFI_CANFD_RXSTCMD_EMPTY)) 582 work_done += ifi_canfd_do_rx_poll(ndev, quota - work_done); 583 584 if (work_done < quota) { 585 napi_complete_done(napi, work_done); 586 ifi_canfd_irq_enable(ndev, 1); 587 } 588 589 return work_done; 590 } 591 592 static irqreturn_t ifi_canfd_isr(int irq, void *dev_id) 593 { 594 struct net_device *ndev = (struct net_device *)dev_id; 595 struct ifi_canfd_priv *priv = netdev_priv(ndev); 596 struct net_device_stats *stats = &ndev->stats; 597 const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY | 598 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER | 599 IFI_CANFD_INTERRUPT_ERROR_COUNTER | 600 IFI_CANFD_INTERRUPT_ERROR_STATE_CHG | 601 IFI_CANFD_INTERRUPT_ERROR_WARNING | 602 IFI_CANFD_INTERRUPT_ERROR_BUSOFF; 603 const u32 tx_irq_mask = IFI_CANFD_INTERRUPT_TXFIFO_EMPTY | 604 IFI_CANFD_INTERRUPT_TXFIFO_REMOVE; 605 const u32 clr_irq_mask = ~((u32)IFI_CANFD_INTERRUPT_SET_IRQ); 606 u32 isr; 607 608 isr = readl(priv->base + IFI_CANFD_INTERRUPT); 609 610 /* No interrupt */ 611 if (isr == 0) 612 return IRQ_NONE; 613 614 /* Clear all pending interrupts but ErrWarn */ 615 writel(clr_irq_mask, priv->base + IFI_CANFD_INTERRUPT); 616 617 /* RX IRQ or bus warning, start NAPI */ 618 if (isr & rx_irq_mask) { 619 ifi_canfd_irq_enable(ndev, 0); 620 napi_schedule(&priv->napi); 621 } 622 623 /* TX IRQ */ 624 if (isr & IFI_CANFD_INTERRUPT_TXFIFO_REMOVE) { 625 stats->tx_bytes += can_get_echo_skb(ndev, 0, NULL); 626 stats->tx_packets++; 627 } 628 629 if (isr & tx_irq_mask) 630 netif_wake_queue(ndev); 631 632 return IRQ_HANDLED; 633 } 634 635 static const struct can_bittiming_const ifi_canfd_bittiming_const = { 636 .name = KBUILD_MODNAME, 637 .tseg1_min = 1, /* Time segment 1 = prop_seg + phase_seg1 */ 638 .tseg1_max = 256, 639 .tseg2_min = 2, /* Time segment 2 = phase_seg2 */ 640 .tseg2_max = 256, 641 .sjw_max = 128, 642 .brp_min = 2, 643 .brp_max = 512, 644 .brp_inc = 1, 645 }; 646 647 static void ifi_canfd_set_bittiming(struct net_device *ndev) 648 { 649 struct ifi_canfd_priv *priv = netdev_priv(ndev); 650 const struct can_bittiming *bt = &priv->can.bittiming; 651 const struct can_bittiming *dbt = &priv->can.data_bittiming; 652 u16 brp, sjw, tseg1, tseg2, tdc; 653 654 /* Configure bit timing */ 655 brp = bt->brp - 2; 656 sjw = bt->sjw - 1; 657 tseg1 = bt->prop_seg + bt->phase_seg1 - 1; 658 tseg2 = bt->phase_seg2 - 2; 659 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) | 660 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) | 661 (brp << IFI_CANFD_TIME_PRESCALE_OFF) | 662 (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8), 663 priv->base + IFI_CANFD_TIME); 664 665 /* Configure data bit timing */ 666 brp = dbt->brp - 2; 667 sjw = dbt->sjw - 1; 668 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1; 669 tseg2 = dbt->phase_seg2 - 2; 670 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) | 671 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) | 672 (brp << IFI_CANFD_TIME_PRESCALE_OFF) | 673 (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8), 674 priv->base + IFI_CANFD_FTIME); 675 676 /* Configure transmitter delay */ 677 tdc = dbt->brp * (dbt->prop_seg + dbt->phase_seg1); 678 tdc &= IFI_CANFD_TDELAY_MASK; 679 writel(IFI_CANFD_TDELAY_EN | tdc, priv->base + IFI_CANFD_TDELAY); 680 } 681 682 static void ifi_canfd_set_filter(struct net_device *ndev, const u32 id, 683 const u32 mask, const u32 ident) 684 { 685 struct ifi_canfd_priv *priv = netdev_priv(ndev); 686 687 writel(mask, priv->base + IFI_CANFD_FILTER_MASK(id)); 688 writel(ident, priv->base + IFI_CANFD_FILTER_IDENT(id)); 689 } 690 691 static void ifi_canfd_set_filters(struct net_device *ndev) 692 { 693 /* Receive all CAN frames (standard ID) */ 694 ifi_canfd_set_filter(ndev, 0, 695 IFI_CANFD_FILTER_MASK_VALID | 696 IFI_CANFD_FILTER_MASK_EXT, 697 IFI_CANFD_FILTER_IDENT_VALID); 698 699 /* Receive all CAN frames (extended ID) */ 700 ifi_canfd_set_filter(ndev, 1, 701 IFI_CANFD_FILTER_MASK_VALID | 702 IFI_CANFD_FILTER_MASK_EXT, 703 IFI_CANFD_FILTER_IDENT_VALID | 704 IFI_CANFD_FILTER_IDENT_IDE); 705 706 /* Receive all CANFD frames */ 707 ifi_canfd_set_filter(ndev, 2, 708 IFI_CANFD_FILTER_MASK_VALID | 709 IFI_CANFD_FILTER_MASK_EDL | 710 IFI_CANFD_FILTER_MASK_EXT, 711 IFI_CANFD_FILTER_IDENT_VALID | 712 IFI_CANFD_FILTER_IDENT_CANFD | 713 IFI_CANFD_FILTER_IDENT_IDE); 714 } 715 716 static void ifi_canfd_start(struct net_device *ndev) 717 { 718 struct ifi_canfd_priv *priv = netdev_priv(ndev); 719 u32 stcmd; 720 721 /* Reset the IP */ 722 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD); 723 writel(IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING, 724 priv->base + IFI_CANFD_STCMD); 725 726 ifi_canfd_set_bittiming(ndev); 727 ifi_canfd_set_filters(ndev); 728 729 /* Reset FIFOs */ 730 writel(IFI_CANFD_RXSTCMD_RESET, priv->base + IFI_CANFD_RXSTCMD); 731 writel(0, priv->base + IFI_CANFD_RXSTCMD); 732 writel(IFI_CANFD_TXSTCMD_RESET, priv->base + IFI_CANFD_TXSTCMD); 733 writel(0, priv->base + IFI_CANFD_TXSTCMD); 734 735 /* Repeat transmission until successful */ 736 writel(0, priv->base + IFI_CANFD_REPEAT); 737 writel(0, priv->base + IFI_CANFD_SUSPEND); 738 739 /* Clear all pending interrupts */ 740 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ), 741 priv->base + IFI_CANFD_INTERRUPT); 742 743 stcmd = IFI_CANFD_STCMD_ENABLE | IFI_CANFD_STCMD_NORMAL_MODE | 744 IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING; 745 746 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 747 stcmd |= IFI_CANFD_STCMD_BUSMONITOR; 748 749 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 750 stcmd |= IFI_CANFD_STCMD_LOOPBACK; 751 752 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && 753 !(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)) 754 stcmd |= IFI_CANFD_STCMD_ENABLE_ISO; 755 756 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD)) 757 stcmd |= IFI_CANFD_STCMD_DISABLE_CANFD; 758 759 priv->can.state = CAN_STATE_ERROR_ACTIVE; 760 761 ifi_canfd_irq_enable(ndev, 1); 762 763 /* Unlock, reset and enable the error counter. */ 764 writel(IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC, 765 priv->base + IFI_CANFD_ERROR_CTR); 766 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 767 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR); 768 769 /* Enable controller */ 770 writel(stcmd, priv->base + IFI_CANFD_STCMD); 771 } 772 773 static void ifi_canfd_stop(struct net_device *ndev) 774 { 775 struct ifi_canfd_priv *priv = netdev_priv(ndev); 776 777 /* Reset and disable the error counter. */ 778 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 779 writel(0, priv->base + IFI_CANFD_ERROR_CTR); 780 781 /* Reset the IP */ 782 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD); 783 784 /* Mask all interrupts */ 785 writel(~0, priv->base + IFI_CANFD_IRQMASK); 786 787 /* Clear all pending interrupts */ 788 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ), 789 priv->base + IFI_CANFD_INTERRUPT); 790 791 /* Set the state as STOPPED */ 792 priv->can.state = CAN_STATE_STOPPED; 793 } 794 795 static int ifi_canfd_set_mode(struct net_device *ndev, enum can_mode mode) 796 { 797 switch (mode) { 798 case CAN_MODE_START: 799 ifi_canfd_start(ndev); 800 netif_wake_queue(ndev); 801 break; 802 default: 803 return -EOPNOTSUPP; 804 } 805 806 return 0; 807 } 808 809 static int ifi_canfd_open(struct net_device *ndev) 810 { 811 struct ifi_canfd_priv *priv = netdev_priv(ndev); 812 int ret; 813 814 ret = open_candev(ndev); 815 if (ret) { 816 netdev_err(ndev, "Failed to open CAN device\n"); 817 return ret; 818 } 819 820 /* Register interrupt handler */ 821 ret = request_irq(ndev->irq, ifi_canfd_isr, IRQF_SHARED, 822 ndev->name, ndev); 823 if (ret < 0) { 824 netdev_err(ndev, "Failed to request interrupt\n"); 825 goto err_irq; 826 } 827 828 ifi_canfd_start(ndev); 829 830 napi_enable(&priv->napi); 831 netif_start_queue(ndev); 832 833 return 0; 834 err_irq: 835 close_candev(ndev); 836 return ret; 837 } 838 839 static int ifi_canfd_close(struct net_device *ndev) 840 { 841 struct ifi_canfd_priv *priv = netdev_priv(ndev); 842 843 netif_stop_queue(ndev); 844 napi_disable(&priv->napi); 845 846 ifi_canfd_stop(ndev); 847 848 free_irq(ndev->irq, ndev); 849 850 close_candev(ndev); 851 852 return 0; 853 } 854 855 static netdev_tx_t ifi_canfd_start_xmit(struct sk_buff *skb, 856 struct net_device *ndev) 857 { 858 struct ifi_canfd_priv *priv = netdev_priv(ndev); 859 struct canfd_frame *cf = (struct canfd_frame *)skb->data; 860 u32 txst, txid, txdlc; 861 int i; 862 863 if (can_dev_dropped_skb(ndev, skb)) 864 return NETDEV_TX_OK; 865 866 /* Check if the TX buffer is full */ 867 txst = readl(priv->base + IFI_CANFD_TXSTCMD); 868 if (txst & IFI_CANFD_TXSTCMD_FULL) { 869 netif_stop_queue(ndev); 870 netdev_err(ndev, "BUG! TX FIFO full when queue awake!\n"); 871 return NETDEV_TX_BUSY; 872 } 873 874 netif_stop_queue(ndev); 875 876 if (cf->can_id & CAN_EFF_FLAG) { 877 txid = cf->can_id & CAN_EFF_MASK; 878 /* 879 * In case the Extended ID frame is transmitted, the 880 * standard and extended part of the ID are swapped 881 * in the register, so swap them back to send the 882 * correct ID. 883 */ 884 txid = (txid >> IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH) | 885 ((txid & IFI_CANFD_TXFIFO_ID_ID_XTD_MASK) << 886 IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET); 887 txid |= IFI_CANFD_TXFIFO_ID_IDE; 888 } else { 889 txid = cf->can_id & CAN_SFF_MASK; 890 } 891 892 txdlc = can_fd_len2dlc(cf->len); 893 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) { 894 txdlc |= IFI_CANFD_TXFIFO_DLC_EDL; 895 if (cf->flags & CANFD_BRS) 896 txdlc |= IFI_CANFD_TXFIFO_DLC_BRS; 897 } 898 899 if (cf->can_id & CAN_RTR_FLAG) 900 txdlc |= IFI_CANFD_TXFIFO_DLC_RTR; 901 902 /* message ram configuration */ 903 writel(txid, priv->base + IFI_CANFD_TXFIFO_ID); 904 writel(txdlc, priv->base + IFI_CANFD_TXFIFO_DLC); 905 906 for (i = 0; i < cf->len; i += 4) { 907 writel(*(u32 *)(cf->data + i), 908 priv->base + IFI_CANFD_TXFIFO_DATA + i); 909 } 910 911 writel(0, priv->base + IFI_CANFD_TXFIFO_REPEATCOUNT); 912 writel(0, priv->base + IFI_CANFD_TXFIFO_SUSPEND_US); 913 914 can_put_echo_skb(skb, ndev, 0, 0); 915 916 /* Start the transmission */ 917 writel(IFI_CANFD_TXSTCMD_ADD_MSG, priv->base + IFI_CANFD_TXSTCMD); 918 919 return NETDEV_TX_OK; 920 } 921 922 static const struct net_device_ops ifi_canfd_netdev_ops = { 923 .ndo_open = ifi_canfd_open, 924 .ndo_stop = ifi_canfd_close, 925 .ndo_start_xmit = ifi_canfd_start_xmit, 926 .ndo_change_mtu = can_change_mtu, 927 }; 928 929 static const struct ethtool_ops ifi_canfd_ethtool_ops = { 930 .get_ts_info = ethtool_op_get_ts_info, 931 }; 932 933 static int ifi_canfd_plat_probe(struct platform_device *pdev) 934 { 935 struct device *dev = &pdev->dev; 936 struct net_device *ndev; 937 struct ifi_canfd_priv *priv; 938 void __iomem *addr; 939 int irq, ret; 940 u32 id, rev; 941 942 addr = devm_platform_ioremap_resource(pdev, 0); 943 if (IS_ERR(addr)) 944 return PTR_ERR(addr); 945 946 irq = platform_get_irq(pdev, 0); 947 if (irq < 0) 948 return -EINVAL; 949 950 id = readl(addr + IFI_CANFD_IP_ID); 951 if (id != IFI_CANFD_IP_ID_VALUE) { 952 dev_err(dev, "This block is not IFI CANFD, id=%08x\n", id); 953 return -EINVAL; 954 } 955 956 rev = readl(addr + IFI_CANFD_VER) & IFI_CANFD_VER_REV_MASK; 957 if (rev < IFI_CANFD_VER_REV_MIN_SUPPORTED) { 958 dev_err(dev, "This block is too old (rev %i), minimum supported is rev %i\n", 959 rev, IFI_CANFD_VER_REV_MIN_SUPPORTED); 960 return -EINVAL; 961 } 962 963 ndev = alloc_candev(sizeof(*priv), 1); 964 if (!ndev) 965 return -ENOMEM; 966 967 ndev->irq = irq; 968 ndev->flags |= IFF_ECHO; /* we support local echo */ 969 ndev->netdev_ops = &ifi_canfd_netdev_ops; 970 ndev->ethtool_ops = &ifi_canfd_ethtool_ops; 971 972 priv = netdev_priv(ndev); 973 priv->ndev = ndev; 974 priv->base = addr; 975 976 netif_napi_add(ndev, &priv->napi, ifi_canfd_poll); 977 978 priv->can.state = CAN_STATE_STOPPED; 979 980 priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK); 981 982 priv->can.bittiming_const = &ifi_canfd_bittiming_const; 983 priv->can.data_bittiming_const = &ifi_canfd_bittiming_const; 984 priv->can.do_set_mode = ifi_canfd_set_mode; 985 priv->can.do_get_berr_counter = ifi_canfd_get_berr_counter; 986 987 /* IFI CANFD can do both Bosch FD and ISO FD */ 988 priv->can.ctrlmode = CAN_CTRLMODE_FD; 989 990 /* IFI CANFD can do both Bosch FD and ISO FD */ 991 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 992 CAN_CTRLMODE_LISTENONLY | 993 CAN_CTRLMODE_FD | 994 CAN_CTRLMODE_FD_NON_ISO | 995 CAN_CTRLMODE_BERR_REPORTING; 996 997 platform_set_drvdata(pdev, ndev); 998 SET_NETDEV_DEV(ndev, dev); 999 1000 ret = register_candev(ndev); 1001 if (ret) { 1002 dev_err(dev, "Failed to register (ret=%d)\n", ret); 1003 goto err_reg; 1004 } 1005 1006 dev_info(dev, "Driver registered: regs=%p, irq=%d, clock=%d\n", 1007 priv->base, ndev->irq, priv->can.clock.freq); 1008 1009 return 0; 1010 1011 err_reg: 1012 free_candev(ndev); 1013 return ret; 1014 } 1015 1016 static void ifi_canfd_plat_remove(struct platform_device *pdev) 1017 { 1018 struct net_device *ndev = platform_get_drvdata(pdev); 1019 1020 unregister_candev(ndev); 1021 platform_set_drvdata(pdev, NULL); 1022 free_candev(ndev); 1023 } 1024 1025 static const struct of_device_id ifi_canfd_of_table[] = { 1026 { .compatible = "ifi,canfd-1.0", .data = NULL }, 1027 { /* sentinel */ }, 1028 }; 1029 MODULE_DEVICE_TABLE(of, ifi_canfd_of_table); 1030 1031 static struct platform_driver ifi_canfd_plat_driver = { 1032 .driver = { 1033 .name = KBUILD_MODNAME, 1034 .of_match_table = ifi_canfd_of_table, 1035 }, 1036 .probe = ifi_canfd_plat_probe, 1037 .remove_new = ifi_canfd_plat_remove, 1038 }; 1039 1040 module_platform_driver(ifi_canfd_plat_driver); 1041 1042 MODULE_AUTHOR("Marek Vasut <marex@denx.de>"); 1043 MODULE_LICENSE("GPL v2"); 1044 MODULE_DESCRIPTION("CAN bus driver for IFI CANFD controller"); 1045