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