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