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