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/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_fd_dlc2len(dlc); 275 else 276 cf->len = can_cc_dlc2len(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 stats->rx_bytes += cf->len; 314 } 315 stats->rx_packets++; 316 317 /* Remove the packet from FIFO */ 318 writel(IFI_CANFD_RXSTCMD_REMOVE_MSG, priv->base + IFI_CANFD_RXSTCMD); 319 writel(rx_irq_mask, priv->base + IFI_CANFD_INTERRUPT); 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 return pkts; 349 } 350 351 static int ifi_canfd_handle_lost_msg(struct net_device *ndev) 352 { 353 struct net_device_stats *stats = &ndev->stats; 354 struct sk_buff *skb; 355 struct can_frame *frame; 356 357 netdev_err(ndev, "RX FIFO overflow, message(s) lost.\n"); 358 359 stats->rx_errors++; 360 stats->rx_over_errors++; 361 362 skb = alloc_can_err_skb(ndev, &frame); 363 if (unlikely(!skb)) 364 return 0; 365 366 frame->can_id |= CAN_ERR_CRTL; 367 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 368 369 netif_receive_skb(skb); 370 371 return 1; 372 } 373 374 static int ifi_canfd_handle_lec_err(struct net_device *ndev) 375 { 376 struct ifi_canfd_priv *priv = netdev_priv(ndev); 377 struct net_device_stats *stats = &ndev->stats; 378 struct can_frame *cf; 379 struct sk_buff *skb; 380 u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR); 381 const u32 errmask = IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST | 382 IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST | 383 IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST | 384 IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST | 385 IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST | 386 IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST | 387 IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST; 388 389 if (!(errctr & errmask)) /* No error happened. */ 390 return 0; 391 392 priv->can.can_stats.bus_error++; 393 394 /* Propagate the error condition to the CAN stack. */ 395 skb = alloc_can_err_skb(ndev, &cf); 396 397 /* Read the error counter register and check for new errors. */ 398 if (likely(skb)) 399 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 400 401 if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST) { 402 stats->rx_errors++; 403 if (likely(skb)) 404 cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 405 } 406 407 if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST) { 408 stats->tx_errors++; 409 if (likely(skb)) 410 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 411 } 412 413 if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST) { 414 stats->tx_errors++; 415 if (likely(skb)) 416 cf->data[2] |= CAN_ERR_PROT_BIT0; 417 } 418 419 if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST) { 420 stats->tx_errors++; 421 if (likely(skb)) 422 cf->data[2] |= CAN_ERR_PROT_BIT1; 423 } 424 425 if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST) { 426 stats->rx_errors++; 427 if (likely(skb)) 428 cf->data[2] |= CAN_ERR_PROT_STUFF; 429 } 430 431 if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST) { 432 stats->rx_errors++; 433 if (likely(skb)) 434 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 435 } 436 437 if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST) { 438 stats->rx_errors++; 439 if (likely(skb)) 440 cf->data[2] |= CAN_ERR_PROT_FORM; 441 } 442 443 /* Reset the error counter, ack the IRQ and re-enable the counter. */ 444 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 445 writel(IFI_CANFD_INTERRUPT_ERROR_COUNTER, 446 priv->base + IFI_CANFD_INTERRUPT); 447 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR); 448 449 if (unlikely(!skb)) 450 return 0; 451 452 netif_receive_skb(skb); 453 454 return 1; 455 } 456 457 static int ifi_canfd_get_berr_counter(const struct net_device *ndev, 458 struct can_berr_counter *bec) 459 { 460 struct ifi_canfd_priv *priv = netdev_priv(ndev); 461 u32 err; 462 463 err = readl(priv->base + IFI_CANFD_ERROR); 464 bec->rxerr = (err >> IFI_CANFD_ERROR_RX_OFFSET) & 465 IFI_CANFD_ERROR_RX_MASK; 466 bec->txerr = (err >> IFI_CANFD_ERROR_TX_OFFSET) & 467 IFI_CANFD_ERROR_TX_MASK; 468 469 return 0; 470 } 471 472 static int ifi_canfd_handle_state_change(struct net_device *ndev, 473 enum can_state new_state) 474 { 475 struct ifi_canfd_priv *priv = netdev_priv(ndev); 476 struct can_frame *cf; 477 struct sk_buff *skb; 478 struct can_berr_counter bec; 479 480 switch (new_state) { 481 case CAN_STATE_ERROR_ACTIVE: 482 /* error active state */ 483 priv->can.can_stats.error_warning++; 484 priv->can.state = CAN_STATE_ERROR_ACTIVE; 485 break; 486 case CAN_STATE_ERROR_WARNING: 487 /* error warning state */ 488 priv->can.can_stats.error_warning++; 489 priv->can.state = CAN_STATE_ERROR_WARNING; 490 break; 491 case CAN_STATE_ERROR_PASSIVE: 492 /* error passive state */ 493 priv->can.can_stats.error_passive++; 494 priv->can.state = CAN_STATE_ERROR_PASSIVE; 495 break; 496 case CAN_STATE_BUS_OFF: 497 /* bus-off state */ 498 priv->can.state = CAN_STATE_BUS_OFF; 499 ifi_canfd_irq_enable(ndev, 0); 500 priv->can.can_stats.bus_off++; 501 can_bus_off(ndev); 502 break; 503 default: 504 break; 505 } 506 507 /* propagate the error condition to the CAN stack */ 508 skb = alloc_can_err_skb(ndev, &cf); 509 if (unlikely(!skb)) 510 return 0; 511 512 ifi_canfd_get_berr_counter(ndev, &bec); 513 514 switch (new_state) { 515 case CAN_STATE_ERROR_WARNING: 516 /* error warning state */ 517 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT; 518 cf->data[1] = (bec.txerr > bec.rxerr) ? 519 CAN_ERR_CRTL_TX_WARNING : 520 CAN_ERR_CRTL_RX_WARNING; 521 cf->data[6] = bec.txerr; 522 cf->data[7] = bec.rxerr; 523 break; 524 case CAN_STATE_ERROR_PASSIVE: 525 /* error passive state */ 526 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT; 527 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE; 528 if (bec.txerr > 127) 529 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE; 530 cf->data[6] = bec.txerr; 531 cf->data[7] = bec.rxerr; 532 break; 533 case CAN_STATE_BUS_OFF: 534 /* bus-off state */ 535 cf->can_id |= CAN_ERR_BUSOFF; 536 break; 537 default: 538 break; 539 } 540 541 netif_receive_skb(skb); 542 543 return 1; 544 } 545 546 static int ifi_canfd_handle_state_errors(struct net_device *ndev) 547 { 548 struct ifi_canfd_priv *priv = netdev_priv(ndev); 549 u32 stcmd = readl(priv->base + IFI_CANFD_STCMD); 550 int work_done = 0; 551 552 if ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) && 553 (priv->can.state != CAN_STATE_ERROR_ACTIVE)) { 554 netdev_dbg(ndev, "Error, entered active state\n"); 555 work_done += ifi_canfd_handle_state_change(ndev, 556 CAN_STATE_ERROR_ACTIVE); 557 } 558 559 if ((stcmd & IFI_CANFD_STCMD_ERROR_WARNING) && 560 (priv->can.state != CAN_STATE_ERROR_WARNING)) { 561 netdev_dbg(ndev, "Error, entered warning state\n"); 562 work_done += ifi_canfd_handle_state_change(ndev, 563 CAN_STATE_ERROR_WARNING); 564 } 565 566 if ((stcmd & IFI_CANFD_STCMD_ERROR_PASSIVE) && 567 (priv->can.state != CAN_STATE_ERROR_PASSIVE)) { 568 netdev_dbg(ndev, "Error, entered passive state\n"); 569 work_done += ifi_canfd_handle_state_change(ndev, 570 CAN_STATE_ERROR_PASSIVE); 571 } 572 573 if ((stcmd & IFI_CANFD_STCMD_BUSOFF) && 574 (priv->can.state != CAN_STATE_BUS_OFF)) { 575 netdev_dbg(ndev, "Error, entered bus-off state\n"); 576 work_done += ifi_canfd_handle_state_change(ndev, 577 CAN_STATE_BUS_OFF); 578 } 579 580 return work_done; 581 } 582 583 static int ifi_canfd_poll(struct napi_struct *napi, int quota) 584 { 585 struct net_device *ndev = napi->dev; 586 struct ifi_canfd_priv *priv = netdev_priv(ndev); 587 u32 rxstcmd = readl(priv->base + IFI_CANFD_RXSTCMD); 588 int work_done = 0; 589 590 /* Handle bus state changes */ 591 work_done += ifi_canfd_handle_state_errors(ndev); 592 593 /* Handle lost messages on RX */ 594 if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW) 595 work_done += ifi_canfd_handle_lost_msg(ndev); 596 597 /* Handle lec errors on the bus */ 598 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) 599 work_done += ifi_canfd_handle_lec_err(ndev); 600 601 /* Handle normal messages on RX */ 602 if (!(rxstcmd & IFI_CANFD_RXSTCMD_EMPTY)) 603 work_done += ifi_canfd_do_rx_poll(ndev, quota - work_done); 604 605 if (work_done < quota) { 606 napi_complete_done(napi, work_done); 607 ifi_canfd_irq_enable(ndev, 1); 608 } 609 610 return work_done; 611 } 612 613 static irqreturn_t ifi_canfd_isr(int irq, void *dev_id) 614 { 615 struct net_device *ndev = (struct net_device *)dev_id; 616 struct ifi_canfd_priv *priv = netdev_priv(ndev); 617 struct net_device_stats *stats = &ndev->stats; 618 const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY | 619 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER | 620 IFI_CANFD_INTERRUPT_ERROR_COUNTER | 621 IFI_CANFD_INTERRUPT_ERROR_STATE_CHG | 622 IFI_CANFD_INTERRUPT_ERROR_WARNING | 623 IFI_CANFD_INTERRUPT_ERROR_BUSOFF; 624 const u32 tx_irq_mask = IFI_CANFD_INTERRUPT_TXFIFO_EMPTY | 625 IFI_CANFD_INTERRUPT_TXFIFO_REMOVE; 626 const u32 clr_irq_mask = ~((u32)IFI_CANFD_INTERRUPT_SET_IRQ); 627 u32 isr; 628 629 isr = readl(priv->base + IFI_CANFD_INTERRUPT); 630 631 /* No interrupt */ 632 if (isr == 0) 633 return IRQ_NONE; 634 635 /* Clear all pending interrupts but ErrWarn */ 636 writel(clr_irq_mask, priv->base + IFI_CANFD_INTERRUPT); 637 638 /* RX IRQ or bus warning, start NAPI */ 639 if (isr & rx_irq_mask) { 640 ifi_canfd_irq_enable(ndev, 0); 641 napi_schedule(&priv->napi); 642 } 643 644 /* TX IRQ */ 645 if (isr & IFI_CANFD_INTERRUPT_TXFIFO_REMOVE) { 646 stats->tx_bytes += can_get_echo_skb(ndev, 0, NULL); 647 stats->tx_packets++; 648 } 649 650 if (isr & tx_irq_mask) 651 netif_wake_queue(ndev); 652 653 return IRQ_HANDLED; 654 } 655 656 static const struct can_bittiming_const ifi_canfd_bittiming_const = { 657 .name = KBUILD_MODNAME, 658 .tseg1_min = 1, /* Time segment 1 = prop_seg + phase_seg1 */ 659 .tseg1_max = 256, 660 .tseg2_min = 2, /* Time segment 2 = phase_seg2 */ 661 .tseg2_max = 256, 662 .sjw_max = 128, 663 .brp_min = 2, 664 .brp_max = 512, 665 .brp_inc = 1, 666 }; 667 668 static void ifi_canfd_set_bittiming(struct net_device *ndev) 669 { 670 struct ifi_canfd_priv *priv = netdev_priv(ndev); 671 const struct can_bittiming *bt = &priv->can.bittiming; 672 const struct can_bittiming *dbt = &priv->can.data_bittiming; 673 u16 brp, sjw, tseg1, tseg2, tdc; 674 675 /* Configure bit timing */ 676 brp = bt->brp - 2; 677 sjw = bt->sjw - 1; 678 tseg1 = bt->prop_seg + bt->phase_seg1 - 1; 679 tseg2 = bt->phase_seg2 - 2; 680 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) | 681 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) | 682 (brp << IFI_CANFD_TIME_PRESCALE_OFF) | 683 (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8), 684 priv->base + IFI_CANFD_TIME); 685 686 /* Configure data bit timing */ 687 brp = dbt->brp - 2; 688 sjw = dbt->sjw - 1; 689 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1; 690 tseg2 = dbt->phase_seg2 - 2; 691 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) | 692 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) | 693 (brp << IFI_CANFD_TIME_PRESCALE_OFF) | 694 (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8), 695 priv->base + IFI_CANFD_FTIME); 696 697 /* Configure transmitter delay */ 698 tdc = dbt->brp * (dbt->prop_seg + dbt->phase_seg1); 699 tdc &= IFI_CANFD_TDELAY_MASK; 700 writel(IFI_CANFD_TDELAY_EN | tdc, priv->base + IFI_CANFD_TDELAY); 701 } 702 703 static void ifi_canfd_set_filter(struct net_device *ndev, const u32 id, 704 const u32 mask, const u32 ident) 705 { 706 struct ifi_canfd_priv *priv = netdev_priv(ndev); 707 708 writel(mask, priv->base + IFI_CANFD_FILTER_MASK(id)); 709 writel(ident, priv->base + IFI_CANFD_FILTER_IDENT(id)); 710 } 711 712 static void ifi_canfd_set_filters(struct net_device *ndev) 713 { 714 /* Receive all CAN frames (standard ID) */ 715 ifi_canfd_set_filter(ndev, 0, 716 IFI_CANFD_FILTER_MASK_VALID | 717 IFI_CANFD_FILTER_MASK_EXT, 718 IFI_CANFD_FILTER_IDENT_VALID); 719 720 /* Receive all CAN frames (extended ID) */ 721 ifi_canfd_set_filter(ndev, 1, 722 IFI_CANFD_FILTER_MASK_VALID | 723 IFI_CANFD_FILTER_MASK_EXT, 724 IFI_CANFD_FILTER_IDENT_VALID | 725 IFI_CANFD_FILTER_IDENT_IDE); 726 727 /* Receive all CANFD frames */ 728 ifi_canfd_set_filter(ndev, 2, 729 IFI_CANFD_FILTER_MASK_VALID | 730 IFI_CANFD_FILTER_MASK_EDL | 731 IFI_CANFD_FILTER_MASK_EXT, 732 IFI_CANFD_FILTER_IDENT_VALID | 733 IFI_CANFD_FILTER_IDENT_CANFD | 734 IFI_CANFD_FILTER_IDENT_IDE); 735 } 736 737 static void ifi_canfd_start(struct net_device *ndev) 738 { 739 struct ifi_canfd_priv *priv = netdev_priv(ndev); 740 u32 stcmd; 741 742 /* Reset the IP */ 743 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD); 744 writel(IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING, 745 priv->base + IFI_CANFD_STCMD); 746 747 ifi_canfd_set_bittiming(ndev); 748 ifi_canfd_set_filters(ndev); 749 750 /* Reset FIFOs */ 751 writel(IFI_CANFD_RXSTCMD_RESET, priv->base + IFI_CANFD_RXSTCMD); 752 writel(0, priv->base + IFI_CANFD_RXSTCMD); 753 writel(IFI_CANFD_TXSTCMD_RESET, priv->base + IFI_CANFD_TXSTCMD); 754 writel(0, priv->base + IFI_CANFD_TXSTCMD); 755 756 /* Repeat transmission until successful */ 757 writel(0, priv->base + IFI_CANFD_REPEAT); 758 writel(0, priv->base + IFI_CANFD_SUSPEND); 759 760 /* Clear all pending interrupts */ 761 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ), 762 priv->base + IFI_CANFD_INTERRUPT); 763 764 stcmd = IFI_CANFD_STCMD_ENABLE | IFI_CANFD_STCMD_NORMAL_MODE | 765 IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING; 766 767 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 768 stcmd |= IFI_CANFD_STCMD_BUSMONITOR; 769 770 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 771 stcmd |= IFI_CANFD_STCMD_LOOPBACK; 772 773 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && 774 !(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)) 775 stcmd |= IFI_CANFD_STCMD_ENABLE_ISO; 776 777 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD)) 778 stcmd |= IFI_CANFD_STCMD_DISABLE_CANFD; 779 780 priv->can.state = CAN_STATE_ERROR_ACTIVE; 781 782 ifi_canfd_irq_enable(ndev, 1); 783 784 /* Unlock, reset and enable the error counter. */ 785 writel(IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC, 786 priv->base + IFI_CANFD_ERROR_CTR); 787 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 788 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR); 789 790 /* Enable controller */ 791 writel(stcmd, priv->base + IFI_CANFD_STCMD); 792 } 793 794 static void ifi_canfd_stop(struct net_device *ndev) 795 { 796 struct ifi_canfd_priv *priv = netdev_priv(ndev); 797 798 /* Reset and disable the error counter. */ 799 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 800 writel(0, priv->base + IFI_CANFD_ERROR_CTR); 801 802 /* Reset the IP */ 803 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD); 804 805 /* Mask all interrupts */ 806 writel(~0, priv->base + IFI_CANFD_IRQMASK); 807 808 /* Clear all pending interrupts */ 809 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ), 810 priv->base + IFI_CANFD_INTERRUPT); 811 812 /* Set the state as STOPPED */ 813 priv->can.state = CAN_STATE_STOPPED; 814 } 815 816 static int ifi_canfd_set_mode(struct net_device *ndev, enum can_mode mode) 817 { 818 switch (mode) { 819 case CAN_MODE_START: 820 ifi_canfd_start(ndev); 821 netif_wake_queue(ndev); 822 break; 823 default: 824 return -EOPNOTSUPP; 825 } 826 827 return 0; 828 } 829 830 static int ifi_canfd_open(struct net_device *ndev) 831 { 832 struct ifi_canfd_priv *priv = netdev_priv(ndev); 833 int ret; 834 835 ret = open_candev(ndev); 836 if (ret) { 837 netdev_err(ndev, "Failed to open CAN device\n"); 838 return ret; 839 } 840 841 /* Register interrupt handler */ 842 ret = request_irq(ndev->irq, ifi_canfd_isr, IRQF_SHARED, 843 ndev->name, ndev); 844 if (ret < 0) { 845 netdev_err(ndev, "Failed to request interrupt\n"); 846 goto err_irq; 847 } 848 849 ifi_canfd_start(ndev); 850 851 napi_enable(&priv->napi); 852 netif_start_queue(ndev); 853 854 return 0; 855 err_irq: 856 close_candev(ndev); 857 return ret; 858 } 859 860 static int ifi_canfd_close(struct net_device *ndev) 861 { 862 struct ifi_canfd_priv *priv = netdev_priv(ndev); 863 864 netif_stop_queue(ndev); 865 napi_disable(&priv->napi); 866 867 ifi_canfd_stop(ndev); 868 869 free_irq(ndev->irq, ndev); 870 871 close_candev(ndev); 872 873 return 0; 874 } 875 876 static netdev_tx_t ifi_canfd_start_xmit(struct sk_buff *skb, 877 struct net_device *ndev) 878 { 879 struct ifi_canfd_priv *priv = netdev_priv(ndev); 880 struct canfd_frame *cf = (struct canfd_frame *)skb->data; 881 u32 txst, txid, txdlc; 882 int i; 883 884 if (can_dev_dropped_skb(ndev, skb)) 885 return NETDEV_TX_OK; 886 887 /* Check if the TX buffer is full */ 888 txst = readl(priv->base + IFI_CANFD_TXSTCMD); 889 if (txst & IFI_CANFD_TXSTCMD_FULL) { 890 netif_stop_queue(ndev); 891 netdev_err(ndev, "BUG! TX FIFO full when queue awake!\n"); 892 return NETDEV_TX_BUSY; 893 } 894 895 netif_stop_queue(ndev); 896 897 if (cf->can_id & CAN_EFF_FLAG) { 898 txid = cf->can_id & CAN_EFF_MASK; 899 /* 900 * In case the Extended ID frame is transmitted, the 901 * standard and extended part of the ID are swapped 902 * in the register, so swap them back to send the 903 * correct ID. 904 */ 905 txid = (txid >> IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH) | 906 ((txid & IFI_CANFD_TXFIFO_ID_ID_XTD_MASK) << 907 IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET); 908 txid |= IFI_CANFD_TXFIFO_ID_IDE; 909 } else { 910 txid = cf->can_id & CAN_SFF_MASK; 911 } 912 913 txdlc = can_fd_len2dlc(cf->len); 914 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) { 915 txdlc |= IFI_CANFD_TXFIFO_DLC_EDL; 916 if (cf->flags & CANFD_BRS) 917 txdlc |= IFI_CANFD_TXFIFO_DLC_BRS; 918 } 919 920 if (cf->can_id & CAN_RTR_FLAG) 921 txdlc |= IFI_CANFD_TXFIFO_DLC_RTR; 922 923 /* message ram configuration */ 924 writel(txid, priv->base + IFI_CANFD_TXFIFO_ID); 925 writel(txdlc, priv->base + IFI_CANFD_TXFIFO_DLC); 926 927 for (i = 0; i < cf->len; i += 4) { 928 writel(*(u32 *)(cf->data + i), 929 priv->base + IFI_CANFD_TXFIFO_DATA + i); 930 } 931 932 writel(0, priv->base + IFI_CANFD_TXFIFO_REPEATCOUNT); 933 writel(0, priv->base + IFI_CANFD_TXFIFO_SUSPEND_US); 934 935 can_put_echo_skb(skb, ndev, 0, 0); 936 937 /* Start the transmission */ 938 writel(IFI_CANFD_TXSTCMD_ADD_MSG, priv->base + IFI_CANFD_TXSTCMD); 939 940 return NETDEV_TX_OK; 941 } 942 943 static const struct net_device_ops ifi_canfd_netdev_ops = { 944 .ndo_open = ifi_canfd_open, 945 .ndo_stop = ifi_canfd_close, 946 .ndo_start_xmit = ifi_canfd_start_xmit, 947 .ndo_change_mtu = can_change_mtu, 948 }; 949 950 static const struct ethtool_ops ifi_canfd_ethtool_ops = { 951 .get_ts_info = ethtool_op_get_ts_info, 952 }; 953 954 static int ifi_canfd_plat_probe(struct platform_device *pdev) 955 { 956 struct device *dev = &pdev->dev; 957 struct net_device *ndev; 958 struct ifi_canfd_priv *priv; 959 void __iomem *addr; 960 int irq, ret; 961 u32 id, rev; 962 963 addr = devm_platform_ioremap_resource(pdev, 0); 964 if (IS_ERR(addr)) 965 return PTR_ERR(addr); 966 967 irq = platform_get_irq(pdev, 0); 968 if (irq < 0) 969 return -EINVAL; 970 971 id = readl(addr + IFI_CANFD_IP_ID); 972 if (id != IFI_CANFD_IP_ID_VALUE) { 973 dev_err(dev, "This block is not IFI CANFD, id=%08x\n", id); 974 return -EINVAL; 975 } 976 977 rev = readl(addr + IFI_CANFD_VER) & IFI_CANFD_VER_REV_MASK; 978 if (rev < IFI_CANFD_VER_REV_MIN_SUPPORTED) { 979 dev_err(dev, "This block is too old (rev %i), minimum supported is rev %i\n", 980 rev, IFI_CANFD_VER_REV_MIN_SUPPORTED); 981 return -EINVAL; 982 } 983 984 ndev = alloc_candev(sizeof(*priv), 1); 985 if (!ndev) 986 return -ENOMEM; 987 988 ndev->irq = irq; 989 ndev->flags |= IFF_ECHO; /* we support local echo */ 990 ndev->netdev_ops = &ifi_canfd_netdev_ops; 991 ndev->ethtool_ops = &ifi_canfd_ethtool_ops; 992 993 priv = netdev_priv(ndev); 994 priv->ndev = ndev; 995 priv->base = addr; 996 997 netif_napi_add(ndev, &priv->napi, ifi_canfd_poll); 998 999 priv->can.state = CAN_STATE_STOPPED; 1000 1001 priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK); 1002 1003 priv->can.bittiming_const = &ifi_canfd_bittiming_const; 1004 priv->can.data_bittiming_const = &ifi_canfd_bittiming_const; 1005 priv->can.do_set_mode = ifi_canfd_set_mode; 1006 priv->can.do_get_berr_counter = ifi_canfd_get_berr_counter; 1007 1008 /* IFI CANFD can do both Bosch FD and ISO FD */ 1009 priv->can.ctrlmode = CAN_CTRLMODE_FD; 1010 1011 /* IFI CANFD can do both Bosch FD and ISO FD */ 1012 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 1013 CAN_CTRLMODE_LISTENONLY | 1014 CAN_CTRLMODE_FD | 1015 CAN_CTRLMODE_FD_NON_ISO | 1016 CAN_CTRLMODE_BERR_REPORTING; 1017 1018 platform_set_drvdata(pdev, ndev); 1019 SET_NETDEV_DEV(ndev, dev); 1020 1021 ret = register_candev(ndev); 1022 if (ret) { 1023 dev_err(dev, "Failed to register (ret=%d)\n", ret); 1024 goto err_reg; 1025 } 1026 1027 dev_info(dev, "Driver registered: regs=%p, irq=%d, clock=%d\n", 1028 priv->base, ndev->irq, priv->can.clock.freq); 1029 1030 return 0; 1031 1032 err_reg: 1033 free_candev(ndev); 1034 return ret; 1035 } 1036 1037 static void ifi_canfd_plat_remove(struct platform_device *pdev) 1038 { 1039 struct net_device *ndev = platform_get_drvdata(pdev); 1040 1041 unregister_candev(ndev); 1042 platform_set_drvdata(pdev, NULL); 1043 free_candev(ndev); 1044 } 1045 1046 static const struct of_device_id ifi_canfd_of_table[] = { 1047 { .compatible = "ifi,canfd-1.0", .data = NULL }, 1048 { /* sentinel */ }, 1049 }; 1050 MODULE_DEVICE_TABLE(of, ifi_canfd_of_table); 1051 1052 static struct platform_driver ifi_canfd_plat_driver = { 1053 .driver = { 1054 .name = KBUILD_MODNAME, 1055 .of_match_table = ifi_canfd_of_table, 1056 }, 1057 .probe = ifi_canfd_plat_probe, 1058 .remove_new = ifi_canfd_plat_remove, 1059 }; 1060 1061 module_platform_driver(ifi_canfd_plat_driver); 1062 1063 MODULE_AUTHOR("Marek Vasut <marex@denx.de>"); 1064 MODULE_LICENSE("GPL v2"); 1065 MODULE_DESCRIPTION("CAN bus driver for IFI CANFD controller"); 1066