1 // SPDX-License-Identifier: GPL-2.0+ 2 /* Renesas R-Car CAN device driver 3 * 4 * Copyright (C) 2013 Cogent Embedded, Inc. <source@cogentembedded.com> 5 * Copyright (C) 2013 Renesas Solutions Corp. 6 */ 7 8 #include <linux/bitfield.h> 9 #include <linux/bits.h> 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/types.h> 13 #include <linux/interrupt.h> 14 #include <linux/errno.h> 15 #include <linux/ethtool.h> 16 #include <linux/netdevice.h> 17 #include <linux/platform_device.h> 18 #include <linux/can/dev.h> 19 #include <linux/clk.h> 20 #include <linux/of.h> 21 #include <linux/pm_runtime.h> 22 23 #define RCAR_CAN_DRV_NAME "rcar_can" 24 25 /* Clock Select Register settings */ 26 enum CLKR { 27 CLKR_CLKP1 = 0, /* Peripheral clock (clkp1) */ 28 CLKR_CLKP2 = 1, /* Peripheral clock (clkp2) */ 29 CLKR_CLKEXT = 3, /* Externally input clock */ 30 }; 31 32 #define RCAR_SUPPORTED_CLOCKS (BIT(CLKR_CLKP1) | BIT(CLKR_CLKP2) | \ 33 BIT(CLKR_CLKEXT)) 34 35 /* Mailbox configuration: 36 * mailbox 60 - 63 - Rx FIFO mailboxes 37 * mailbox 56 - 59 - Tx FIFO mailboxes 38 * non-FIFO mailboxes are not used 39 */ 40 #define RCAR_CAN_N_MBX 64 /* Number of mailboxes in non-FIFO mode */ 41 #define RCAR_CAN_RX_FIFO_MBX 60 /* Mailbox - window to Rx FIFO */ 42 #define RCAR_CAN_TX_FIFO_MBX 56 /* Mailbox - window to Tx FIFO */ 43 #define RCAR_CAN_FIFO_DEPTH 4 44 45 /* Mailbox registers structure */ 46 struct rcar_can_mbox_regs { 47 u32 id; /* IDE and RTR bits, SID and EID */ 48 u8 stub; /* Not used */ 49 u8 dlc; /* Data Length Code - bits [0..3] */ 50 u8 data[8]; /* Data Bytes */ 51 u8 tsh; /* Time Stamp Higher Byte */ 52 u8 tsl; /* Time Stamp Lower Byte */ 53 }; 54 55 struct rcar_can_regs { 56 struct rcar_can_mbox_regs mb[RCAR_CAN_N_MBX]; /* Mailbox registers */ 57 u32 mkr_2_9[8]; /* Mask Registers 2-9 */ 58 u32 fidcr[2]; /* FIFO Received ID Compare Register */ 59 u32 mkivlr1; /* Mask Invalid Register 1 */ 60 u32 mier1; /* Mailbox Interrupt Enable Register 1 */ 61 u32 mkr_0_1[2]; /* Mask Registers 0-1 */ 62 u32 mkivlr0; /* Mask Invalid Register 0*/ 63 u32 mier0; /* Mailbox Interrupt Enable Register 0 */ 64 u8 pad_440[0x3c0]; 65 u8 mctl[64]; /* Message Control Registers */ 66 u16 ctlr; /* Control Register */ 67 u16 str; /* Status register */ 68 u8 bcr[3]; /* Bit Configuration Register */ 69 u8 clkr; /* Clock Select Register */ 70 u8 rfcr; /* Receive FIFO Control Register */ 71 u8 rfpcr; /* Receive FIFO Pointer Control Register */ 72 u8 tfcr; /* Transmit FIFO Control Register */ 73 u8 tfpcr; /* Transmit FIFO Pointer Control Register */ 74 u8 eier; /* Error Interrupt Enable Register */ 75 u8 eifr; /* Error Interrupt Factor Judge Register */ 76 u8 recr; /* Receive Error Count Register */ 77 u8 tecr; /* Transmit Error Count Register */ 78 u8 ecsr; /* Error Code Store Register */ 79 u8 cssr; /* Channel Search Support Register */ 80 u8 mssr; /* Mailbox Search Status Register */ 81 u8 msmr; /* Mailbox Search Mode Register */ 82 u16 tsr; /* Time Stamp Register */ 83 u8 afsr; /* Acceptance Filter Support Register */ 84 u8 pad_857; 85 u8 tcr; /* Test Control Register */ 86 u8 pad_859[7]; 87 u8 ier; /* Interrupt Enable Register */ 88 u8 isr; /* Interrupt Status Register */ 89 u8 pad_862; 90 u8 mbsmr; /* Mailbox Search Mask Register */ 91 }; 92 93 struct rcar_can_priv { 94 struct can_priv can; /* Must be the first member! */ 95 struct net_device *ndev; 96 struct napi_struct napi; 97 struct rcar_can_regs __iomem *regs; 98 struct clk *can_clk; 99 u32 tx_head; 100 u32 tx_tail; 101 u8 clock_select; 102 u8 ier; 103 }; 104 105 static const struct can_bittiming_const rcar_can_bittiming_const = { 106 .name = RCAR_CAN_DRV_NAME, 107 .tseg1_min = 4, 108 .tseg1_max = 16, 109 .tseg2_min = 2, 110 .tseg2_max = 8, 111 .sjw_max = 4, 112 .brp_min = 1, 113 .brp_max = 1024, 114 .brp_inc = 1, 115 }; 116 117 /* Control Register bits */ 118 #define RCAR_CAN_CTLR_BOM GENMASK(12, 11) /* Bus-Off Recovery Mode Bits */ 119 #define RCAR_CAN_CTLR_BOM_ENT 1 /* Entry to halt mode */ 120 /* at bus-off entry */ 121 #define RCAR_CAN_CTLR_SLPM BIT(10) /* Sleep Mode */ 122 #define RCAR_CAN_CTLR_CANM GENMASK(9, 8) /* Operating Mode Select Bit */ 123 #define RCAR_CAN_CTLR_CANM_OPER 0 /* Operation Mode */ 124 #define RCAR_CAN_CTLR_CANM_RESET 1 /* Reset Mode */ 125 #define RCAR_CAN_CTLR_CANM_HALT 2 /* Halt Mode */ 126 #define RCAR_CAN_CTLR_CANM_FORCE_RESET 3 /* Reset Mode (forcible) */ 127 #define RCAR_CAN_CTLR_MLM BIT(3) /* Message Lost Mode Select */ 128 #define RCAR_CAN_CTLR_IDFM GENMASK(2, 1) /* ID Format Mode Select Bits */ 129 #define RCAR_CAN_CTLR_IDFM_STD 0 /* Standard ID mode */ 130 #define RCAR_CAN_CTLR_IDFM_EXT 1 /* Extended ID mode */ 131 #define RCAR_CAN_CTLR_IDFM_MIXED 2 /* Mixed ID mode */ 132 #define RCAR_CAN_CTLR_MBM BIT(0) /* Mailbox Mode select */ 133 134 /* Status Register bits */ 135 #define RCAR_CAN_STR_RSTST BIT(8) /* Reset Status Bit */ 136 137 /* FIFO Received ID Compare Registers 0 and 1 bits */ 138 #define RCAR_CAN_FIDCR_IDE BIT(31) /* ID Extension Bit */ 139 #define RCAR_CAN_FIDCR_RTR BIT(30) /* Remote Transmission Request Bit */ 140 141 /* Receive FIFO Control Register bits */ 142 #define RCAR_CAN_RFCR_RFEST BIT(7) /* Receive FIFO Empty Status Flag */ 143 #define RCAR_CAN_RFCR_RFE BIT(0) /* Receive FIFO Enable */ 144 145 /* Transmit FIFO Control Register bits */ 146 #define RCAR_CAN_TFCR_TFUST GENMASK(3, 1) /* Transmit FIFO Unsent Message */ 147 /* Number Status Bits */ 148 #define RCAR_CAN_TFCR_TFE BIT(0) /* Transmit FIFO Enable */ 149 150 #define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */ 151 /* for Rx mailboxes 0-31 */ 152 #define RCAR_CAN_N_RX_MKREGS2 8 153 154 /* Bit Configuration Register settings */ 155 #define RCAR_CAN_BCR_TSEG1 GENMASK(23, 20) 156 #define RCAR_CAN_BCR_BRP GENMASK(17, 8) 157 #define RCAR_CAN_BCR_SJW GENMASK(5, 4) 158 #define RCAR_CAN_BCR_TSEG2 GENMASK(2, 0) 159 160 /* Mailbox and Mask Registers bits */ 161 #define RCAR_CAN_IDE BIT(31) /* ID Extension */ 162 #define RCAR_CAN_RTR BIT(30) /* Remote Transmission Request */ 163 #define RCAR_CAN_SID GENMASK(28, 18) /* Standard ID */ 164 #define RCAR_CAN_EID GENMASK(28, 0) /* Extended ID */ 165 166 /* Mailbox Interrupt Enable Register 1 bits */ 167 #define RCAR_CAN_MIER1_RXFIE BIT(28) /* Receive FIFO Interrupt Enable */ 168 #define RCAR_CAN_MIER1_TXFIE BIT(24) /* Transmit FIFO Interrupt Enable */ 169 170 /* Interrupt Enable Register bits */ 171 #define RCAR_CAN_IER_ERSIE BIT(5) /* Error (ERS) Interrupt Enable Bit */ 172 #define RCAR_CAN_IER_RXFIE BIT(4) /* Reception FIFO Interrupt */ 173 /* Enable Bit */ 174 #define RCAR_CAN_IER_TXFIE BIT(3) /* Transmission FIFO Interrupt */ 175 /* Enable Bit */ 176 /* Interrupt Status Register bits */ 177 #define RCAR_CAN_ISR_ERSF BIT(5) /* Error (ERS) Interrupt Status Bit */ 178 #define RCAR_CAN_ISR_RXFF BIT(4) /* Reception FIFO Interrupt */ 179 /* Status Bit */ 180 #define RCAR_CAN_ISR_TXFF BIT(3) /* Transmission FIFO Interrupt */ 181 /* Status Bit */ 182 183 /* Error Interrupt Enable Register bits */ 184 #define RCAR_CAN_EIER_BLIE BIT(7) /* Bus Lock Interrupt Enable */ 185 #define RCAR_CAN_EIER_OLIE BIT(6) /* Overload Frame Transmit */ 186 /* Interrupt Enable */ 187 #define RCAR_CAN_EIER_ORIE BIT(5) /* Receive Overrun Interrupt Enable */ 188 #define RCAR_CAN_EIER_BORIE BIT(4) /* Bus-Off Recovery Interrupt Enable */ 189 #define RCAR_CAN_EIER_BOEIE BIT(3) /* Bus-Off Entry Interrupt Enable */ 190 #define RCAR_CAN_EIER_EPIE BIT(2) /* Error Passive Interrupt Enable */ 191 #define RCAR_CAN_EIER_EWIE BIT(1) /* Error Warning Interrupt Enable */ 192 #define RCAR_CAN_EIER_BEIE BIT(0) /* Bus Error Interrupt Enable */ 193 194 /* Error Interrupt Factor Judge Register bits */ 195 #define RCAR_CAN_EIFR_BLIF BIT(7) /* Bus Lock Detect Flag */ 196 #define RCAR_CAN_EIFR_OLIF BIT(6) /* Overload Frame Transmission */ 197 /* Detect Flag */ 198 #define RCAR_CAN_EIFR_ORIF BIT(5) /* Receive Overrun Detect Flag */ 199 #define RCAR_CAN_EIFR_BORIF BIT(4) /* Bus-Off Recovery Detect Flag */ 200 #define RCAR_CAN_EIFR_BOEIF BIT(3) /* Bus-Off Entry Detect Flag */ 201 #define RCAR_CAN_EIFR_EPIF BIT(2) /* Error Passive Detect Flag */ 202 #define RCAR_CAN_EIFR_EWIF BIT(1) /* Error Warning Detect Flag */ 203 #define RCAR_CAN_EIFR_BEIF BIT(0) /* Bus Error Detect Flag */ 204 205 /* Error Code Store Register bits */ 206 #define RCAR_CAN_ECSR_EDPM BIT(7) /* Error Display Mode Select Bit */ 207 #define RCAR_CAN_ECSR_ADEF BIT(6) /* ACK Delimiter Error Flag */ 208 #define RCAR_CAN_ECSR_BE0F BIT(5) /* Bit Error (dominant) Flag */ 209 #define RCAR_CAN_ECSR_BE1F BIT(4) /* Bit Error (recessive) Flag */ 210 #define RCAR_CAN_ECSR_CEF BIT(3) /* CRC Error Flag */ 211 #define RCAR_CAN_ECSR_AEF BIT(2) /* ACK Error Flag */ 212 #define RCAR_CAN_ECSR_FEF BIT(1) /* Form Error Flag */ 213 #define RCAR_CAN_ECSR_SEF BIT(0) /* Stuff Error Flag */ 214 215 #define RCAR_CAN_NAPI_WEIGHT 4 216 #define MAX_STR_READS 0x100 217 218 static void tx_failure_cleanup(struct net_device *ndev) 219 { 220 int i; 221 222 for (i = 0; i < RCAR_CAN_FIFO_DEPTH; i++) 223 can_free_echo_skb(ndev, i, NULL); 224 } 225 226 static void rcar_can_error(struct net_device *ndev) 227 { 228 struct rcar_can_priv *priv = netdev_priv(ndev); 229 struct can_frame *cf; 230 struct sk_buff *skb; 231 u8 eifr, txerr = 0, rxerr = 0; 232 233 /* Propagate the error condition to the CAN stack */ 234 skb = alloc_can_err_skb(ndev, &cf); 235 236 eifr = readb(&priv->regs->eifr); 237 if (eifr & (RCAR_CAN_EIFR_EWIF | RCAR_CAN_EIFR_EPIF)) { 238 txerr = readb(&priv->regs->tecr); 239 rxerr = readb(&priv->regs->recr); 240 if (skb) 241 cf->can_id |= CAN_ERR_CRTL; 242 } 243 if (eifr & RCAR_CAN_EIFR_BEIF) { 244 int rx_errors = 0, tx_errors = 0; 245 u8 ecsr; 246 247 netdev_dbg(priv->ndev, "Bus error interrupt:\n"); 248 if (skb) 249 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT; 250 251 ecsr = readb(&priv->regs->ecsr); 252 if (ecsr & RCAR_CAN_ECSR_ADEF) { 253 netdev_dbg(priv->ndev, "ACK Delimiter Error\n"); 254 tx_errors++; 255 writeb((u8)~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr); 256 if (skb) 257 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 258 } 259 if (ecsr & RCAR_CAN_ECSR_BE0F) { 260 netdev_dbg(priv->ndev, "Bit Error (dominant)\n"); 261 tx_errors++; 262 writeb((u8)~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr); 263 if (skb) 264 cf->data[2] |= CAN_ERR_PROT_BIT0; 265 } 266 if (ecsr & RCAR_CAN_ECSR_BE1F) { 267 netdev_dbg(priv->ndev, "Bit Error (recessive)\n"); 268 tx_errors++; 269 writeb((u8)~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr); 270 if (skb) 271 cf->data[2] |= CAN_ERR_PROT_BIT1; 272 } 273 if (ecsr & RCAR_CAN_ECSR_CEF) { 274 netdev_dbg(priv->ndev, "CRC Error\n"); 275 rx_errors++; 276 writeb((u8)~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr); 277 if (skb) 278 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 279 } 280 if (ecsr & RCAR_CAN_ECSR_AEF) { 281 netdev_dbg(priv->ndev, "ACK Error\n"); 282 tx_errors++; 283 writeb((u8)~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr); 284 if (skb) { 285 cf->can_id |= CAN_ERR_ACK; 286 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 287 } 288 } 289 if (ecsr & RCAR_CAN_ECSR_FEF) { 290 netdev_dbg(priv->ndev, "Form Error\n"); 291 rx_errors++; 292 writeb((u8)~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr); 293 if (skb) 294 cf->data[2] |= CAN_ERR_PROT_FORM; 295 } 296 if (ecsr & RCAR_CAN_ECSR_SEF) { 297 netdev_dbg(priv->ndev, "Stuff Error\n"); 298 rx_errors++; 299 writeb((u8)~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr); 300 if (skb) 301 cf->data[2] |= CAN_ERR_PROT_STUFF; 302 } 303 304 priv->can.can_stats.bus_error++; 305 ndev->stats.rx_errors += rx_errors; 306 ndev->stats.tx_errors += tx_errors; 307 writeb((u8)~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr); 308 } 309 if (eifr & RCAR_CAN_EIFR_EWIF) { 310 netdev_dbg(priv->ndev, "Error warning interrupt\n"); 311 priv->can.state = CAN_STATE_ERROR_WARNING; 312 priv->can.can_stats.error_warning++; 313 /* Clear interrupt condition */ 314 writeb((u8)~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr); 315 if (skb) 316 cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_WARNING : 317 CAN_ERR_CRTL_RX_WARNING; 318 } 319 if (eifr & RCAR_CAN_EIFR_EPIF) { 320 netdev_dbg(priv->ndev, "Error passive interrupt\n"); 321 priv->can.state = CAN_STATE_ERROR_PASSIVE; 322 priv->can.can_stats.error_passive++; 323 /* Clear interrupt condition */ 324 writeb((u8)~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr); 325 if (skb) 326 cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_PASSIVE : 327 CAN_ERR_CRTL_RX_PASSIVE; 328 } 329 if (eifr & RCAR_CAN_EIFR_BOEIF) { 330 netdev_dbg(priv->ndev, "Bus-off entry interrupt\n"); 331 tx_failure_cleanup(ndev); 332 priv->ier = RCAR_CAN_IER_ERSIE; 333 writeb(priv->ier, &priv->regs->ier); 334 priv->can.state = CAN_STATE_BUS_OFF; 335 /* Clear interrupt condition */ 336 writeb((u8)~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr); 337 priv->can.can_stats.bus_off++; 338 can_bus_off(ndev); 339 if (skb) 340 cf->can_id |= CAN_ERR_BUSOFF; 341 } else if (skb) { 342 cf->can_id |= CAN_ERR_CNT; 343 cf->data[6] = txerr; 344 cf->data[7] = rxerr; 345 } 346 if (eifr & RCAR_CAN_EIFR_ORIF) { 347 netdev_dbg(priv->ndev, "Receive overrun error interrupt\n"); 348 ndev->stats.rx_over_errors++; 349 ndev->stats.rx_errors++; 350 writeb((u8)~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr); 351 if (skb) { 352 cf->can_id |= CAN_ERR_CRTL; 353 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 354 } 355 } 356 if (eifr & RCAR_CAN_EIFR_OLIF) { 357 netdev_dbg(priv->ndev, 358 "Overload Frame Transmission error interrupt\n"); 359 ndev->stats.rx_over_errors++; 360 ndev->stats.rx_errors++; 361 writeb((u8)~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr); 362 if (skb) { 363 cf->can_id |= CAN_ERR_PROT; 364 cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 365 } 366 } 367 368 if (skb) 369 netif_rx(skb); 370 } 371 372 static void rcar_can_tx_done(struct net_device *ndev) 373 { 374 struct rcar_can_priv *priv = netdev_priv(ndev); 375 struct net_device_stats *stats = &ndev->stats; 376 u8 isr; 377 378 while (1) { 379 u8 unsent = FIELD_GET(RCAR_CAN_TFCR_TFUST, 380 readb(&priv->regs->tfcr)); 381 382 if (priv->tx_head - priv->tx_tail <= unsent) 383 break; 384 stats->tx_packets++; 385 stats->tx_bytes += 386 can_get_echo_skb(ndev, 387 priv->tx_tail % RCAR_CAN_FIFO_DEPTH, 388 NULL); 389 390 priv->tx_tail++; 391 netif_wake_queue(ndev); 392 } 393 /* Clear interrupt */ 394 isr = readb(&priv->regs->isr); 395 writeb(isr & ~RCAR_CAN_ISR_TXFF, &priv->regs->isr); 396 } 397 398 static irqreturn_t rcar_can_interrupt(int irq, void *dev_id) 399 { 400 struct net_device *ndev = dev_id; 401 struct rcar_can_priv *priv = netdev_priv(ndev); 402 u8 isr; 403 404 isr = readb(&priv->regs->isr); 405 if (!(isr & priv->ier)) 406 return IRQ_NONE; 407 408 if (isr & RCAR_CAN_ISR_ERSF) 409 rcar_can_error(ndev); 410 411 if (isr & RCAR_CAN_ISR_TXFF) 412 rcar_can_tx_done(ndev); 413 414 if (isr & RCAR_CAN_ISR_RXFF) { 415 if (napi_schedule_prep(&priv->napi)) { 416 /* Disable Rx FIFO interrupts */ 417 priv->ier &= ~RCAR_CAN_IER_RXFIE; 418 writeb(priv->ier, &priv->regs->ier); 419 __napi_schedule(&priv->napi); 420 } 421 } 422 423 return IRQ_HANDLED; 424 } 425 426 static void rcar_can_set_bittiming(struct net_device *ndev) 427 { 428 struct rcar_can_priv *priv = netdev_priv(ndev); 429 struct can_bittiming *bt = &priv->can.bittiming; 430 u32 bcr; 431 432 bcr = FIELD_PREP(RCAR_CAN_BCR_TSEG1, bt->phase_seg1 + bt->prop_seg - 1) | 433 FIELD_PREP(RCAR_CAN_BCR_BRP, bt->brp - 1) | 434 FIELD_PREP(RCAR_CAN_BCR_SJW, bt->sjw - 1) | 435 FIELD_PREP(RCAR_CAN_BCR_TSEG2, bt->phase_seg2 - 1); 436 /* Don't overwrite CLKR with 32-bit BCR access; CLKR has 8-bit access. 437 * All the registers are big-endian but they get byte-swapped on 32-bit 438 * read/write (but not on 8-bit, contrary to the manuals)... 439 */ 440 writel((bcr << 8) | priv->clock_select, &priv->regs->bcr); 441 } 442 443 static void rcar_can_start(struct net_device *ndev) 444 { 445 struct rcar_can_priv *priv = netdev_priv(ndev); 446 u16 ctlr; 447 int i; 448 449 /* Set controller to known mode: 450 * - FIFO mailbox mode 451 * - accept all messages 452 * - overrun mode 453 * CAN is in sleep mode after MCU hardware or software reset. 454 */ 455 ctlr = readw(&priv->regs->ctlr); 456 ctlr &= ~RCAR_CAN_CTLR_SLPM; 457 writew(ctlr, &priv->regs->ctlr); 458 /* Go to reset mode */ 459 ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET); 460 writew(ctlr, &priv->regs->ctlr); 461 for (i = 0; i < MAX_STR_READS; i++) { 462 if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST) 463 break; 464 } 465 rcar_can_set_bittiming(ndev); 466 /* Select mixed ID mode */ 467 ctlr |= FIELD_PREP(RCAR_CAN_CTLR_IDFM, RCAR_CAN_CTLR_IDFM_MIXED); 468 /* Entry to halt mode automatically at bus-off */ 469 ctlr |= FIELD_PREP(RCAR_CAN_CTLR_BOM, RCAR_CAN_CTLR_BOM_ENT); 470 ctlr |= RCAR_CAN_CTLR_MBM; /* Select FIFO mailbox mode */ 471 ctlr |= RCAR_CAN_CTLR_MLM; /* Overrun mode */ 472 writew(ctlr, &priv->regs->ctlr); 473 474 /* Accept all SID and EID */ 475 writel(0, &priv->regs->mkr_2_9[6]); 476 writel(0, &priv->regs->mkr_2_9[7]); 477 /* In FIFO mailbox mode, write "0" to bits 24 to 31 */ 478 writel(0, &priv->regs->mkivlr1); 479 /* Accept all frames */ 480 writel(0, &priv->regs->fidcr[0]); 481 writel(RCAR_CAN_FIDCR_IDE | RCAR_CAN_FIDCR_RTR, &priv->regs->fidcr[1]); 482 /* Enable and configure FIFO mailbox interrupts */ 483 writel(RCAR_CAN_MIER1_RXFIE | RCAR_CAN_MIER1_TXFIE, &priv->regs->mier1); 484 485 priv->ier = RCAR_CAN_IER_ERSIE | RCAR_CAN_IER_RXFIE | 486 RCAR_CAN_IER_TXFIE; 487 writeb(priv->ier, &priv->regs->ier); 488 489 /* Accumulate error codes */ 490 writeb(RCAR_CAN_ECSR_EDPM, &priv->regs->ecsr); 491 /* Enable error interrupts */ 492 writeb(RCAR_CAN_EIER_EWIE | RCAR_CAN_EIER_EPIE | RCAR_CAN_EIER_BOEIE | 493 (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING ? 494 RCAR_CAN_EIER_BEIE : 0) | RCAR_CAN_EIER_ORIE | 495 RCAR_CAN_EIER_OLIE, &priv->regs->eier); 496 priv->can.state = CAN_STATE_ERROR_ACTIVE; 497 498 /* Go to operation mode */ 499 FIELD_MODIFY(RCAR_CAN_CTLR_CANM, &ctlr, RCAR_CAN_CTLR_CANM_OPER); 500 writew(ctlr, &priv->regs->ctlr); 501 for (i = 0; i < MAX_STR_READS; i++) { 502 if (!(readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)) 503 break; 504 } 505 /* Enable Rx and Tx FIFO */ 506 writeb(RCAR_CAN_RFCR_RFE, &priv->regs->rfcr); 507 writeb(RCAR_CAN_TFCR_TFE, &priv->regs->tfcr); 508 } 509 510 static int rcar_can_open(struct net_device *ndev) 511 { 512 struct rcar_can_priv *priv = netdev_priv(ndev); 513 int err; 514 515 err = pm_runtime_resume_and_get(ndev->dev.parent); 516 if (err) { 517 netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n", 518 ERR_PTR(err)); 519 goto out; 520 } 521 err = clk_prepare_enable(priv->can_clk); 522 if (err) { 523 netdev_err(ndev, "failed to enable CAN clock: %pe\n", 524 ERR_PTR(err)); 525 goto out_rpm; 526 } 527 err = open_candev(ndev); 528 if (err) { 529 netdev_err(ndev, "open_candev() failed %pe\n", ERR_PTR(err)); 530 goto out_can_clock; 531 } 532 napi_enable(&priv->napi); 533 err = request_irq(ndev->irq, rcar_can_interrupt, 0, ndev->name, ndev); 534 if (err) { 535 netdev_err(ndev, "request_irq(%d) failed %pe\n", ndev->irq, 536 ERR_PTR(err)); 537 goto out_close; 538 } 539 rcar_can_start(ndev); 540 netif_start_queue(ndev); 541 return 0; 542 out_close: 543 napi_disable(&priv->napi); 544 close_candev(ndev); 545 out_can_clock: 546 clk_disable_unprepare(priv->can_clk); 547 out_rpm: 548 pm_runtime_put(ndev->dev.parent); 549 out: 550 return err; 551 } 552 553 static void rcar_can_stop(struct net_device *ndev) 554 { 555 struct rcar_can_priv *priv = netdev_priv(ndev); 556 u16 ctlr; 557 int i; 558 559 /* Go to (force) reset mode */ 560 ctlr = readw(&priv->regs->ctlr); 561 ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET); 562 writew(ctlr, &priv->regs->ctlr); 563 for (i = 0; i < MAX_STR_READS; i++) { 564 if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST) 565 break; 566 } 567 writel(0, &priv->regs->mier0); 568 writel(0, &priv->regs->mier1); 569 writeb(0, &priv->regs->ier); 570 writeb(0, &priv->regs->eier); 571 /* Go to sleep mode */ 572 ctlr |= RCAR_CAN_CTLR_SLPM; 573 writew(ctlr, &priv->regs->ctlr); 574 priv->can.state = CAN_STATE_STOPPED; 575 } 576 577 static int rcar_can_close(struct net_device *ndev) 578 { 579 struct rcar_can_priv *priv = netdev_priv(ndev); 580 581 netif_stop_queue(ndev); 582 rcar_can_stop(ndev); 583 free_irq(ndev->irq, ndev); 584 napi_disable(&priv->napi); 585 clk_disable_unprepare(priv->can_clk); 586 pm_runtime_put(ndev->dev.parent); 587 close_candev(ndev); 588 return 0; 589 } 590 591 static netdev_tx_t rcar_can_start_xmit(struct sk_buff *skb, 592 struct net_device *ndev) 593 { 594 struct rcar_can_priv *priv = netdev_priv(ndev); 595 struct can_frame *cf = (struct can_frame *)skb->data; 596 u32 data, i; 597 598 if (can_dev_dropped_skb(ndev, skb)) 599 return NETDEV_TX_OK; 600 601 if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */ 602 data = FIELD_PREP(RCAR_CAN_EID, cf->can_id & CAN_EFF_MASK) | 603 RCAR_CAN_IDE; 604 else /* Standard frame format */ 605 data = FIELD_PREP(RCAR_CAN_SID, cf->can_id & CAN_SFF_MASK); 606 607 if (cf->can_id & CAN_RTR_FLAG) { /* Remote transmission request */ 608 data |= RCAR_CAN_RTR; 609 } else { 610 for (i = 0; i < cf->len; i++) 611 writeb(cf->data[i], 612 &priv->regs->mb[RCAR_CAN_TX_FIFO_MBX].data[i]); 613 } 614 615 writel(data, &priv->regs->mb[RCAR_CAN_TX_FIFO_MBX].id); 616 617 writeb(cf->len, &priv->regs->mb[RCAR_CAN_TX_FIFO_MBX].dlc); 618 619 can_put_echo_skb(skb, ndev, priv->tx_head % RCAR_CAN_FIFO_DEPTH, 0); 620 priv->tx_head++; 621 /* Start Tx: write 0xff to the TFPCR register to increment 622 * the CPU-side pointer for the transmit FIFO to the next 623 * mailbox location 624 */ 625 writeb(0xff, &priv->regs->tfpcr); 626 /* Stop the queue if we've filled all FIFO entries */ 627 if (priv->tx_head - priv->tx_tail >= RCAR_CAN_FIFO_DEPTH) 628 netif_stop_queue(ndev); 629 630 return NETDEV_TX_OK; 631 } 632 633 static const struct net_device_ops rcar_can_netdev_ops = { 634 .ndo_open = rcar_can_open, 635 .ndo_stop = rcar_can_close, 636 .ndo_start_xmit = rcar_can_start_xmit, 637 }; 638 639 static const struct ethtool_ops rcar_can_ethtool_ops = { 640 .get_ts_info = ethtool_op_get_ts_info, 641 }; 642 643 static void rcar_can_rx_pkt(struct rcar_can_priv *priv) 644 { 645 struct net_device_stats *stats = &priv->ndev->stats; 646 struct can_frame *cf; 647 struct sk_buff *skb; 648 u32 data; 649 u8 dlc; 650 651 skb = alloc_can_skb(priv->ndev, &cf); 652 if (!skb) { 653 stats->rx_dropped++; 654 return; 655 } 656 657 data = readl(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].id); 658 if (data & RCAR_CAN_IDE) 659 cf->can_id = FIELD_GET(RCAR_CAN_EID, data) | CAN_EFF_FLAG; 660 else 661 cf->can_id = FIELD_GET(RCAR_CAN_SID, data); 662 663 dlc = readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].dlc); 664 cf->len = can_cc_dlc2len(dlc); 665 if (data & RCAR_CAN_RTR) { 666 cf->can_id |= CAN_RTR_FLAG; 667 } else { 668 for (dlc = 0; dlc < cf->len; dlc++) 669 cf->data[dlc] = 670 readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].data[dlc]); 671 672 stats->rx_bytes += cf->len; 673 } 674 stats->rx_packets++; 675 676 netif_receive_skb(skb); 677 } 678 679 static int rcar_can_rx_poll(struct napi_struct *napi, int quota) 680 { 681 struct rcar_can_priv *priv = container_of(napi, 682 struct rcar_can_priv, napi); 683 int num_pkts; 684 685 for (num_pkts = 0; num_pkts < quota; num_pkts++) { 686 u8 rfcr, isr; 687 688 isr = readb(&priv->regs->isr); 689 /* Clear interrupt bit */ 690 if (isr & RCAR_CAN_ISR_RXFF) 691 writeb(isr & ~RCAR_CAN_ISR_RXFF, &priv->regs->isr); 692 rfcr = readb(&priv->regs->rfcr); 693 if (rfcr & RCAR_CAN_RFCR_RFEST) 694 break; 695 rcar_can_rx_pkt(priv); 696 /* Write 0xff to the RFPCR register to increment 697 * the CPU-side pointer for the receive FIFO 698 * to the next mailbox location 699 */ 700 writeb(0xff, &priv->regs->rfpcr); 701 } 702 /* All packets processed */ 703 if (num_pkts < quota) { 704 napi_complete_done(napi, num_pkts); 705 priv->ier |= RCAR_CAN_IER_RXFIE; 706 writeb(priv->ier, &priv->regs->ier); 707 } 708 return num_pkts; 709 } 710 711 static int rcar_can_do_set_mode(struct net_device *ndev, enum can_mode mode) 712 { 713 switch (mode) { 714 case CAN_MODE_START: 715 rcar_can_start(ndev); 716 netif_wake_queue(ndev); 717 return 0; 718 default: 719 return -EOPNOTSUPP; 720 } 721 } 722 723 static int rcar_can_get_berr_counter(const struct net_device *ndev, 724 struct can_berr_counter *bec) 725 { 726 struct rcar_can_priv *priv = netdev_priv(ndev); 727 int err; 728 729 err = pm_runtime_resume_and_get(ndev->dev.parent); 730 if (err) 731 return err; 732 733 bec->txerr = readb(&priv->regs->tecr); 734 bec->rxerr = readb(&priv->regs->recr); 735 736 pm_runtime_put(ndev->dev.parent); 737 738 return 0; 739 } 740 741 static const char * const clock_names[] = { 742 [CLKR_CLKP1] = "clkp1", 743 [CLKR_CLKP2] = "clkp2", 744 [CLKR_CLKEXT] = "can_clk", 745 }; 746 747 static int rcar_can_probe(struct platform_device *pdev) 748 { 749 struct device *dev = &pdev->dev; 750 struct rcar_can_priv *priv; 751 struct net_device *ndev; 752 void __iomem *addr; 753 u32 clock_select = CLKR_CLKP1; 754 int err = -ENODEV; 755 int irq; 756 757 of_property_read_u32(dev->of_node, "renesas,can-clock-select", 758 &clock_select); 759 760 irq = platform_get_irq(pdev, 0); 761 if (irq < 0) { 762 err = irq; 763 goto fail; 764 } 765 766 addr = devm_platform_ioremap_resource(pdev, 0); 767 if (IS_ERR(addr)) { 768 err = PTR_ERR(addr); 769 goto fail; 770 } 771 772 ndev = alloc_candev(sizeof(struct rcar_can_priv), RCAR_CAN_FIFO_DEPTH); 773 if (!ndev) { 774 err = -ENOMEM; 775 goto fail; 776 } 777 778 priv = netdev_priv(ndev); 779 780 if (!(BIT(clock_select) & RCAR_SUPPORTED_CLOCKS)) { 781 err = -EINVAL; 782 dev_err(dev, "invalid CAN clock selected\n"); 783 goto fail_clk; 784 } 785 priv->can_clk = devm_clk_get(dev, clock_names[clock_select]); 786 if (IS_ERR(priv->can_clk)) { 787 dev_err(dev, "cannot get CAN clock: %pe\n", priv->can_clk); 788 err = PTR_ERR(priv->can_clk); 789 goto fail_clk; 790 } 791 792 ndev->netdev_ops = &rcar_can_netdev_ops; 793 ndev->ethtool_ops = &rcar_can_ethtool_ops; 794 ndev->irq = irq; 795 ndev->flags |= IFF_ECHO; 796 priv->ndev = ndev; 797 priv->regs = addr; 798 priv->clock_select = clock_select; 799 priv->can.clock.freq = clk_get_rate(priv->can_clk); 800 priv->can.bittiming_const = &rcar_can_bittiming_const; 801 priv->can.do_set_mode = rcar_can_do_set_mode; 802 priv->can.do_get_berr_counter = rcar_can_get_berr_counter; 803 priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING; 804 platform_set_drvdata(pdev, ndev); 805 SET_NETDEV_DEV(ndev, dev); 806 807 netif_napi_add_weight(ndev, &priv->napi, rcar_can_rx_poll, 808 RCAR_CAN_NAPI_WEIGHT); 809 810 pm_runtime_enable(dev); 811 812 err = register_candev(ndev); 813 if (err) { 814 dev_err(dev, "register_candev() failed %pe\n", ERR_PTR(err)); 815 goto fail_rpm; 816 } 817 818 dev_info(dev, "device registered (IRQ%d)\n", ndev->irq); 819 820 return 0; 821 fail_rpm: 822 pm_runtime_disable(dev); 823 netif_napi_del(&priv->napi); 824 fail_clk: 825 free_candev(ndev); 826 fail: 827 return err; 828 } 829 830 static void rcar_can_remove(struct platform_device *pdev) 831 { 832 struct net_device *ndev = platform_get_drvdata(pdev); 833 struct rcar_can_priv *priv = netdev_priv(ndev); 834 835 unregister_candev(ndev); 836 pm_runtime_disable(&pdev->dev); 837 netif_napi_del(&priv->napi); 838 free_candev(ndev); 839 } 840 841 static int rcar_can_suspend(struct device *dev) 842 { 843 struct net_device *ndev = dev_get_drvdata(dev); 844 struct rcar_can_priv *priv = netdev_priv(ndev); 845 u16 ctlr; 846 847 if (!netif_running(ndev)) 848 return 0; 849 850 netif_stop_queue(ndev); 851 netif_device_detach(ndev); 852 853 ctlr = readw(&priv->regs->ctlr); 854 ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_HALT); 855 writew(ctlr, &priv->regs->ctlr); 856 ctlr |= RCAR_CAN_CTLR_SLPM; 857 writew(ctlr, &priv->regs->ctlr); 858 priv->can.state = CAN_STATE_SLEEPING; 859 860 pm_runtime_put(dev); 861 return 0; 862 } 863 864 static int rcar_can_resume(struct device *dev) 865 { 866 struct net_device *ndev = dev_get_drvdata(dev); 867 int err; 868 869 if (!netif_running(ndev)) 870 return 0; 871 872 err = pm_runtime_resume_and_get(dev); 873 if (err) { 874 netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n", 875 ERR_PTR(err)); 876 return err; 877 } 878 879 rcar_can_start(ndev); 880 881 netif_device_attach(ndev); 882 netif_start_queue(ndev); 883 884 return 0; 885 } 886 887 static DEFINE_SIMPLE_DEV_PM_OPS(rcar_can_pm_ops, rcar_can_suspend, 888 rcar_can_resume); 889 890 static const struct of_device_id rcar_can_of_table[] __maybe_unused = { 891 { .compatible = "renesas,can-r8a7778" }, 892 { .compatible = "renesas,can-r8a7779" }, 893 { .compatible = "renesas,can-r8a7790" }, 894 { .compatible = "renesas,can-r8a7791" }, 895 { .compatible = "renesas,rcar-gen1-can" }, 896 { .compatible = "renesas,rcar-gen2-can" }, 897 { .compatible = "renesas,rcar-gen3-can" }, 898 { } 899 }; 900 MODULE_DEVICE_TABLE(of, rcar_can_of_table); 901 902 static struct platform_driver rcar_can_driver = { 903 .driver = { 904 .name = RCAR_CAN_DRV_NAME, 905 .of_match_table = of_match_ptr(rcar_can_of_table), 906 .pm = pm_sleep_ptr(&rcar_can_pm_ops), 907 }, 908 .probe = rcar_can_probe, 909 .remove = rcar_can_remove, 910 }; 911 912 module_platform_driver(rcar_can_driver); 913 914 MODULE_AUTHOR("Cogent Embedded, Inc."); 915 MODULE_LICENSE("GPL"); 916 MODULE_DESCRIPTION("CAN driver for Renesas R-Car SoC"); 917 MODULE_ALIAS("platform:" RCAR_CAN_DRV_NAME); 918