drivers/net/can/m_can.c

   1 /*
   2  * CAN bus driver for Bosch M_CAN controller
   3  *
   4  * Copyright (C) 2014 Freescale Semiconductor, Inc.
   5  *      Dong Aisheng <b29396@freescale.com>
   6  *
   7  * Bosch M_CAN user manual can be obtained from:
   8  * http://www.bosch-semiconductors.de/media/pdf_1/ipmodules_1/m_can/
   9  * mcan_users_manual_v302.pdf
  10  *
  11  * This file is licensed under the terms of the GNU General Public
  12  * License version 2. This program is licensed "as is" without any
  13  * warranty of any kind, whether express or implied.
  14  */
  15
  16 #include <linux/clk.h>
  17 #include <linux/delay.h>
  18 #include <linux/if_arp.h>
  19 #include <linux/if_ether.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/io.h>
  22 #include <linux/kernel.h>
  23 #include <linux/list.h>
  24 #include <linux/module.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/of.h>
  27 #include <linux/of_device.h>
  28 #include <linux/pinctrl/consumer.h>
  29 #include <linux/platform_device.h>
  30
  31 #include <linux/can/dev.h>
  32
  33 /* napi related */
  34 #define M_CAN_NAPI_WEIGHT       64
  35
  36 /* registers definition */
  37 enum m_can_reg {
  38         M_CAN_CREL      = 0x0,
  39         M_CAN_ENDN      = 0x4,
  40         M_CAN_CUST      = 0x8,
  41         M_CAN_FBTP      = 0xc,
  42         M_CAN_TEST      = 0x10,
  43         M_CAN_RWD       = 0x14,
  44         M_CAN_CCCR      = 0x18,
  45         M_CAN_BTP       = 0x1c,
  46         M_CAN_TSCC      = 0x20,
  47         M_CAN_TSCV      = 0x24,
  48         M_CAN_TOCC      = 0x28,
  49         M_CAN_TOCV      = 0x2c,
  50         M_CAN_ECR       = 0x40,
  51         M_CAN_PSR       = 0x44,
  52         M_CAN_IR        = 0x50,
  53         M_CAN_IE        = 0x54,
  54         M_CAN_ILS       = 0x58,
  55         M_CAN_ILE       = 0x5c,
  56         M_CAN_GFC       = 0x80,
  57         M_CAN_SIDFC     = 0x84,
  58         M_CAN_XIDFC     = 0x88,
  59         M_CAN_XIDAM     = 0x90,
  60         M_CAN_HPMS      = 0x94,
  61         M_CAN_NDAT1     = 0x98,
  62         M_CAN_NDAT2     = 0x9c,
  63         M_CAN_RXF0C     = 0xa0,
  64         M_CAN_RXF0S     = 0xa4,
  65         M_CAN_RXF0A     = 0xa8,
  66         M_CAN_RXBC      = 0xac,
  67         M_CAN_RXF1C     = 0xb0,
  68         M_CAN_RXF1S     = 0xb4,
  69         M_CAN_RXF1A     = 0xb8,
  70         M_CAN_RXESC     = 0xbc,
  71         M_CAN_TXBC      = 0xc0,
  72         M_CAN_TXFQS     = 0xc4,
  73         M_CAN_TXESC     = 0xc8,
  74         M_CAN_TXBRP     = 0xcc,
  75         M_CAN_TXBAR     = 0xd0,
  76         M_CAN_TXBCR     = 0xd4,
  77         M_CAN_TXBTO     = 0xd8,
  78         M_CAN_TXBCF     = 0xdc,
  79         M_CAN_TXBTIE    = 0xe0,
  80         M_CAN_TXBCIE    = 0xe4,
  81         M_CAN_TXEFC     = 0xf0,
  82         M_CAN_TXEFS     = 0xf4,
  83         M_CAN_TXEFA     = 0xf8,
  84 };
  85
  86 /* CC Control Register(CCCR) */
  87 #define CCCR_CCE        BIT(1)
  88 #define CCCR_INIT       BIT(0)
  89
  90 /* Bit Timing & Prescaler Register (BTP) */
  91 #define BTR_BRP_MASK            0x3ff
  92 #define BTR_BRP_SHIFT           16
  93 #define BTR_TSEG1_SHIFT         8
  94 #define BTR_TSEG1_MASK          (0x3f << BTR_TSEG1_SHIFT)
  95 #define BTR_TSEG2_SHIFT         4
  96 #define BTR_TSEG2_MASK          (0xf << BTR_TSEG2_SHIFT)
  97 #define BTR_SJW_SHIFT           0
  98 #define BTR_SJW_MASK            0xf
  99
 100 /* Interrupt Register(IR) */
 101 #define IR_ALL_INT      0xffffffff
 102 #define IR_STE          BIT(31)
 103 #define IR_FOE          BIT(30)
 104 #define IR_ACKE         BIT(29)
 105 #define IR_BE           BIT(28)
 106 #define IR_CRCE         BIT(27)
 107 #define IR_WDI          BIT(26)
 108 #define IR_BO           BIT(25)
 109 #define IR_EW           BIT(24)
 110 #define IR_EP           BIT(23)
 111 #define IR_ELO          BIT(22)
 112 #define IR_BEU          BIT(21)
 113 #define IR_BEC          BIT(20)
 114 #define IR_DRX          BIT(19)
 115 #define IR_TOO          BIT(18)
 116 #define IR_MRAF         BIT(17)
 117 #define IR_TSW          BIT(16)
 118 #define IR_TEFL         BIT(15)
 119 #define IR_TEFF         BIT(14)
 120 #define IR_TEFW         BIT(13)
 121 #define IR_TEFN         BIT(12)
 122 #define IR_TFE          BIT(11)
 123 #define IR_TCF          BIT(10)
 124 #define IR_TC           BIT(9)
 125 #define IR_HPM          BIT(8)
 126 #define IR_RF1L         BIT(7)
 127 #define IR_RF1F         BIT(6)
 128 #define IR_RF1W         BIT(5)
 129 #define IR_RF1N         BIT(4)
 130 #define IR_RF0L         BIT(3)
 131 #define IR_RF0F         BIT(2)
 132 #define IR_RF0W         BIT(1)
 133 #define IR_RF0N         BIT(0)
 134 #define IR_ERR_ALL      (IR_STE | IR_FOE | IR_ACKE | IR_BE | IR_CRCE | \
 135                 IR_WDI | IR_BO | IR_EW | IR_EP | IR_ELO | IR_BEU | \
 136                 IR_BEC | IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | IR_RF1L | \
 137                 IR_RF0L)
 138
 139 /* Rx FIFO 0/1 Configuration (RXF0C/RXF1C) */
 140 #define RXFC_FWM_OFF    24
 141 #define RXFC_FWM_MASK   0x7f
 142 #define RXFC_FWM_1      (1 << RXFC_FWM_OFF)
 143 #define RXFC_FS_OFF     16
 144 #define RXFC_FS_MASK    0x7f
 145
 146 /* Rx FIFO 0/1 Status (RXF0S/RXF1S) */
 147 #define RXFS_RFL        BIT(25)
 148 #define RXFS_FF         BIT(24)
 149 #define RXFS_FPI_OFF    16
 150 #define RXFS_FPI_MASK   0x3f0000
 151 #define RXFS_FGI_OFF    8
 152 #define RXFS_FGI_MASK   0x3f00
 153 #define RXFS_FFL_MASK   0x7f
 154
 155 /* Tx Buffer Configuration(TXBC) */
 156 #define TXBC_NDTB_OFF   16
 157 #define TXBC_NDTB_MASK  0x3f
 158
 159 /* Tx Buffer Element Size Configuration(TXESC) */
 160 #define TXESC_TBDS_8BYTES       0x0
 161 /* Tx Buffer Element */
 162 #define TX_BUF_XTD      BIT(30)
 163 #define TX_BUF_RTR      BIT(29)
 164
 165 /* Rx Buffer Element Size Configuration(TXESC) */
 166 #define M_CAN_RXESC_8BYTES      0x0
 167 /* Tx Buffer Element */
 168 #define RX_BUF_ESI      BIT(31)
 169 #define RX_BUF_XTD      BIT(30)
 170 #define RX_BUF_RTR      BIT(29)
 171
 172 /* Message RAM Configuration (in bytes) */
 173 #define SIDF_ELEMENT_SIZE       4
 174 #define XIDF_ELEMENT_SIZE       8
 175 #define RXF0_ELEMENT_SIZE       16
 176 #define RXF1_ELEMENT_SIZE       16
 177 #define RXB_ELEMENT_SIZE        16
 178 #define TXE_ELEMENT_SIZE        8
 179 #define TXB_ELEMENT_SIZE        16
 180
 181 /* m_can private data structure */
 182 struct m_can_priv {
 183         struct can_priv can;    /* must be the first member */
 184         struct napi_struct napi;
 185         struct net_device *dev;
 186         struct device *device;
 187         struct clk *clk;
 188         void __iomem *base;
 189         u32 irqstatus;
 190
 191         /* message ram configuration */
 192         void __iomem *mram_base;
 193         u32 mram_off;
 194         u32 sidf_elems;
 195         u32 sidf_off;
 196         u32 xidf_elems;
 197         u32 xidf_off;
 198         u32 rxf0_elems;
 199         u32 rxf0_off;
 200         u32 rxf1_elems;
 201         u32 rxf1_off;
 202         u32 rxb_elems;
 203         u32 rxb_off;
 204         u32 txe_elems;
 205         u32 txe_off;
 206         u32 txb_elems;
 207         u32 txb_off;
 208 };
 209
 210 static inline u32 m_can_read(const struct m_can_priv *priv, enum m_can_reg reg)
 211 {
 212         return readl(priv->base + reg);
 213 }
 214
 215 static inline void m_can_write(const struct m_can_priv *priv,
 216                                 enum m_can_reg reg, u32 val)
 217 {
 218         writel(val, priv->base + reg);
 219 }
 220
 221 static inline void m_can_config_endisable(const struct m_can_priv *priv,
 222                                 bool enable)
 223 {
 224         u32 cccr = m_can_read(priv, M_CAN_CCCR);
 225         u32 timeout = 10, val;
 226
 227         if (enable) {
 228                 /* enable m_can configuration */
 229                 m_can_write(priv, M_CAN_CCCR, cccr | CCCR_INIT);
 230                 /* CCCR.CCE can only be set/reset while CCCR.INIT = '1' */
 231                 m_can_write(priv, M_CAN_CCCR, cccr | CCCR_INIT | CCCR_CCE);
 232         } else {
 233                 m_can_write(priv, M_CAN_CCCR, cccr & ~(CCCR_INIT | CCCR_CCE));
 234         }
 235
 236         /* there's a delay for module initialization */
 237         val = enable ? CCCR_INIT | CCCR_CCE : 0;
 238         while ((m_can_read(priv, M_CAN_CCCR) & (CCCR_INIT | CCCR_CCE))
 239                                 != val) {
 240                 if (timeout == 0) {
 241                         netdev_warn(priv->dev, "Failed to init module\n");
 242                         return;
 243                 }
 244                 timeout--;
 245                 udelay(1);
 246         }
 247 }
 248
 249 static void m_can_enable_all_interrupts(struct m_can_priv *priv, bool enable)
 250 {
 251         m_can_write(priv, M_CAN_ILE, enable ? 0x00000003 : 0x0);
 252 }
 253
 254 static int m_can_do_rx_poll(struct net_device *dev, int quota)
 255 {
 256         struct m_can_priv *priv = netdev_priv(dev);
 257         struct net_device_stats *stats = &dev->stats;
 258         struct sk_buff *skb;
 259         struct can_frame *frame;
 260         u32 rxfs, flags, fgi;
 261         u32 num_rx_pkts = 0;
 262
 263         rxfs = m_can_read(priv, M_CAN_RXF0S);
 264         if (!(rxfs & RXFS_FFL_MASK)) {
 265                 netdev_dbg(dev, "no messages in fifo0\n");
 266                 return 0;
 267         }
 268
 269         while ((rxfs & RXFS_FFL_MASK) && (quota > 0)) {
 270                 netdev_dbg(dev, "fifo0 status 0x%x\n", rxfs);
 271                 if (rxfs & RXFS_RFL)
 272                         netdev_warn(dev, "Rx FIFO 0 Message Lost\n");
 273
 274                 skb = alloc_can_skb(dev, &frame);
 275                 if (!skb) {
 276                         stats->rx_dropped++;
 277                         return -ENOMEM;
 278                 }
 279
 280                 fgi = (rxfs & RXFS_FGI_MASK) >> RXFS_FGI_OFF;
 281                 flags = readl(priv->mram_base + priv->rxf0_off + fgi * 16);
 282                 if (flags & RX_BUF_XTD)
 283                         frame->can_id = (flags & CAN_EFF_MASK) | CAN_EFF_FLAG;
 284                 else
 285                         frame->can_id = (flags >> 18) & CAN_SFF_MASK;
 286                 netdev_dbg(dev, "R0 0x%x\n", flags);
 287
 288                 if (flags & RX_BUF_RTR) {
 289                         frame->can_id |= CAN_RTR_FLAG;
 290                 } else {
 291                         flags = readl(priv->mram_base +
 292                                         priv->rxf0_off + fgi * 16 + 0x4);
 293                         frame->can_dlc = get_can_dlc((flags >> 16) & 0x0F);
 294                         netdev_dbg(dev, "R1 0x%x\n", flags);
 295
 296                         *(u32 *)(frame->data + 0) = readl(priv->mram_base +
 297                                         priv->rxf0_off + fgi * 16 + 0x8);
 298                         *(u32 *)(frame->data + 4) = readl(priv->mram_base +
 299                                         priv->rxf0_off + fgi * 16 + 0xC);
 300                         netdev_dbg(dev, "R2 0x%x\n", *(u32 *)(frame->data + 0));
 301                         netdev_dbg(dev, "R3 0x%x\n", *(u32 *)(frame->data + 4));
 302                 }
 303
 304                 /* acknowledge rx fifo 0 */
 305                 m_can_write(priv, M_CAN_RXF0A, fgi);
 306
 307                 netif_receive_skb(skb);
 308                 netdev_dbg(dev, "new packet received\n");
 309
 310                 stats->rx_packets++;
 311                 stats->rx_bytes += frame->can_dlc;
 312
 313                 can_led_event(dev, CAN_LED_EVENT_RX);
 314
 315                 quota--;
 316                 num_rx_pkts++;
 317                 rxfs = m_can_read(priv, M_CAN_RXF0S);
 318         };
 319
 320         return num_rx_pkts;
 321 }
 322
 323 static int m_can_poll(struct napi_struct *napi, int quota)
 324 {
 325         struct net_device *dev = napi->dev;
 326         struct m_can_priv *priv = netdev_priv(dev);
 327         u32 work_done = 0;
 328         u32 irqstatus;
 329
 330         irqstatus = m_can_read(priv, M_CAN_IR);
 331         if (irqstatus)
 332                 netdev_dbg(dev, "irqstatus updated! new 0x%x old 0x%x rxf0s 0x%x\n",
 333                         irqstatus, priv->irqstatus,
 334                         m_can_read(priv, M_CAN_RXF0S));
 335
 336         irqstatus = irqstatus | priv->irqstatus;
 337         if (!irqstatus)
 338                 goto end;
 339
 340         if (irqstatus & IR_RF0N)
 341                 /* handle events corresponding to receive message objects */
 342                 work_done += m_can_do_rx_poll(dev, (quota - work_done));
 343
 344         if (work_done < quota) {
 345                 napi_complete(napi);
 346                 /* enable all IRQs */
 347                 m_can_enable_all_interrupts(priv, true);
 348         }
 349
 350 end:
 351         return work_done;
 352 }
 353
 354 static irqreturn_t m_can_isr(int irq, void *dev_id)
 355 {
 356         struct net_device *dev = (struct net_device *)dev_id;
 357         struct m_can_priv *priv = netdev_priv(dev);
 358         struct net_device_stats *stats = &dev->stats;
 359         u32 ir;
 360
 361         ir = m_can_read(priv, M_CAN_IR);
 362         if (!ir)
 363                 return IRQ_NONE;
 364
 365         netdev_dbg(dev, "ir 0x%x rxfs0 0x%x\n", ir,
 366                         m_can_read(priv, M_CAN_RXF0S));
 367
 368         /* ACK all irqs */
 369         if (ir & IR_ALL_INT)
 370                 m_can_write(priv, M_CAN_IR, ir);
 371
 372         if (ir & IR_ERR_ALL) {
 373                 netdev_dbg(dev, "bus error\n");
 374                 /* TODO: handle bus error */
 375         }
 376
 377         /* save irqstatus for later using */
 378         priv->irqstatus = ir;
 379
 380         /*
 381          * schedule NAPI in case of
 382          * - rx IRQ
 383          * - state change IRQ(TODO)
 384          * - bus error IRQ and bus error reporting (TODO)
 385          */
 386         if (ir & IR_RF0N) {
 387                 m_can_enable_all_interrupts(priv, false);
 388                 napi_schedule(&priv->napi);
 389         }
 390
 391         /* FIFO overflow */
 392         if (ir & IR_RF0L) {
 393                 dev->stats.rx_over_errors++;
 394                 dev->stats.rx_errors++;
 395         }
 396
 397         /* transmission complete interrupt */
 398         if (ir & IR_TC) {
 399                 netdev_dbg(dev, "tx complete\n");
 400                 stats->tx_bytes += can_get_echo_skb(dev, 0);
 401                 stats->tx_packets++;
 402                 can_led_event(dev, CAN_LED_EVENT_TX);
 403                 netif_wake_queue(dev);
 404         }
 405
 406         return IRQ_HANDLED;
 407 }
 408
 409 static const struct can_bittiming_const m_can_bittiming_const = {
 410         .name = KBUILD_MODNAME,
 411         .tseg1_min = 2,         /* Time segment 1 = prop_seg + phase_seg1 */
 412         .tseg1_max = 64,
 413         .tseg2_min = 1,         /* Time segment 2 = phase_seg2 */
 414         .tseg2_max = 16,
 415         .sjw_max = 16,
 416         .brp_min = 1,
 417         .brp_max = 1024,
 418         .brp_inc = 1,
 419 };
 420
 421 static int m_can_set_bittiming(struct net_device *dev)
 422 {
 423         struct m_can_priv *priv = netdev_priv(dev);
 424         const struct can_bittiming *bt = &priv->can.bittiming;
 425         u16 brp, sjw, tseg1, tseg2;
 426         u32 reg_btp;
 427
 428         brp = bt->brp - 1;
 429         sjw = bt->sjw - 1;
 430         tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
 431         tseg2 = bt->phase_seg2 - 1;
 432         reg_btp = (brp << BTR_BRP_SHIFT) | (sjw << BTR_SJW_SHIFT) |
 433                         (tseg1 << BTR_TSEG1_SHIFT) | (tseg2 << BTR_TSEG2_SHIFT);
 434         m_can_write(priv, M_CAN_BTP, reg_btp);
 435         netdev_dbg(dev, "setting BTP 0x%x\n", reg_btp);
 436
 437         return 0;
 438 }
 439
 440 /*
 441  * Configure M_CAN chip:
 442  * - set rx buffer/fifo element size
 443  * - configure rx fifo
 444  * - accept non-matching frame into fifo 0
 445  * - configure tx buffer
 446  * - setup bittiming
 447  * - TODO:
 448  *   1) other working modes support like monitor, loopback...
 449  *   2) lec error status report enable
 450  */
 451 static void m_can_chip_config(struct net_device *dev)
 452 {
 453         struct m_can_priv *priv = netdev_priv(dev);
 454
 455         m_can_config_endisable(priv, true);
 456
 457         /* RX Buffer/FIFO Element Size 8 bytes data field */
 458         m_can_write(priv, M_CAN_RXESC, M_CAN_RXESC_8BYTES);
 459
 460         /* Accept Non-matching Frames Into FIFO 0 */
 461         m_can_write(priv, M_CAN_GFC, 0x0);
 462
 463         /* only support one Tx Buffer currently */
 464         m_can_write(priv, M_CAN_TXBC, (1 << TXBC_NDTB_OFF) |
 465                 (priv->mram_off + priv->txb_off));
 466
 467         /* only support 8 bytes firstly */
 468         m_can_write(priv, M_CAN_TXESC, TXESC_TBDS_8BYTES);
 469
 470         m_can_write(priv, M_CAN_TXEFC, 0x00010000 |
 471                 (priv->mram_off + priv->txe_off));
 472
 473         /* rx fifo configuration, blocking mode, fifo size 1 */
 474         m_can_write(priv, M_CAN_RXF0C, (priv->rxf0_elems << RXFC_FS_OFF) |
 475                 RXFC_FWM_1 | (priv->mram_off + priv->rxf0_off));
 476
 477         m_can_write(priv, M_CAN_RXF1C, (priv->rxf1_elems << RXFC_FS_OFF) |
 478                 RXFC_FWM_1 | (priv->mram_off + priv->rxf1_off));
 479
 480         /* enable all interrupts */
 481         m_can_write(priv, M_CAN_IR, IR_ALL_INT);
 482         m_can_write(priv, M_CAN_IE, IR_ALL_INT);
 483         m_can_write(priv, M_CAN_ILS, 0xFFFF0000);
 484
 485         /* set bittiming params */
 486         m_can_set_bittiming(dev);
 487
 488         m_can_config_endisable(priv, false);
 489 }
 490
 491 static void m_can_start(struct net_device *dev)
 492 {
 493         struct m_can_priv *priv = netdev_priv(dev);
 494
 495         /* basic m_can configuration */
 496         m_can_chip_config(dev);
 497
 498         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 499
 500         /* enable status change, error and module interrupts */
 501         m_can_enable_all_interrupts(priv, true);
 502 }
 503
 504 static int m_can_set_mode(struct net_device *dev, enum can_mode mode)
 505 {
 506         switch (mode) {
 507         case CAN_MODE_START:
 508                 m_can_start(dev);
 509                 netif_wake_queue(dev);
 510                 break;
 511         default:
 512                 return -EOPNOTSUPP;
 513         }
 514
 515         return 0;
 516 }
 517
 518 static int m_can_get_berr_counter(const struct net_device *dev,
 519                                   struct can_berr_counter *bec)
 520 {
 521         /* TODO */
 522
 523         return 0;
 524 }
 525
 526 static void free_m_can_dev(struct net_device *dev)
 527 {
 528         free_candev(dev);
 529 }
 530
 531 static struct net_device *alloc_m_can_dev(void)
 532 {
 533         struct net_device *dev;
 534         struct m_can_priv *priv;
 535
 536         dev = alloc_candev(sizeof(struct m_can_priv), 1);
 537         if (!dev)
 538                 return NULL;
 539
 540         priv = netdev_priv(dev);
 541         netif_napi_add(dev, &priv->napi, m_can_poll, M_CAN_NAPI_WEIGHT);
 542
 543         priv->dev = dev;
 544         priv->can.bittiming_const = &m_can_bittiming_const;
 545         priv->can.do_set_mode = m_can_set_mode;
 546         priv->can.do_get_berr_counter = m_can_get_berr_counter;
 547         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
 548                                         CAN_CTRLMODE_LISTENONLY |
 549                                         CAN_CTRLMODE_BERR_REPORTING;
 550
 551         return dev;
 552 }
 553
 554
 555 static int m_can_open(struct net_device *dev)
 556 {
 557         int err;
 558         struct m_can_priv *priv = netdev_priv(dev);
 559
 560         clk_prepare_enable(priv->clk);
 561
 562         /* open the can device */
 563         err = open_candev(dev);
 564         if (err) {
 565                 netdev_err(dev, "failed to open can device\n");
 566                 goto exit_open_fail;
 567         }
 568
 569         /* register interrupt handler */
 570         err = request_irq(dev->irq, m_can_isr, IRQF_SHARED, dev->name,
 571                                 dev);
 572         if (err < 0) {
 573                 netdev_err(dev, "failed to request interrupt\n");
 574                 goto exit_irq_fail;
 575         }
 576
 577         /* start the m_can controller */
 578         m_can_start(dev);
 579
 580         can_led_event(dev, CAN_LED_EVENT_OPEN);
 581         napi_enable(&priv->napi);
 582         netif_start_queue(dev);
 583
 584         return 0;
 585
 586 exit_irq_fail:
 587         close_candev(dev);
 588 exit_open_fail:
 589         clk_disable_unprepare(priv->clk);
 590         return err;
 591 }
 592
 593 static void m_can_stop(struct net_device *dev)
 594 {
 595         struct m_can_priv *priv = netdev_priv(dev);
 596
 597         /* disable all interrupts */
 598         m_can_enable_all_interrupts(priv, false);
 599
 600         /* set the state as STOPPED */
 601         priv->can.state = CAN_STATE_STOPPED;
 602 }
 603
 604
 605 static int m_can_close(struct net_device *dev)
 606 {
 607         struct m_can_priv *priv = netdev_priv(dev);
 608
 609         netif_stop_queue(dev);
 610         napi_disable(&priv->napi);
 611         m_can_stop(dev);
 612         free_irq(dev->irq, dev);
 613         close_candev(dev);
 614         can_led_event(dev, CAN_LED_EVENT_STOP);
 615
 616         return 0;
 617 }
 618
 619 static netdev_tx_t m_can_start_xmit(struct sk_buff *skb,
 620                                         struct net_device *dev)
 621 {
 622         struct m_can_priv *priv = netdev_priv(dev);
 623         struct can_frame *frame = (struct can_frame *)skb->data;
 624         u32 flags = 0, id;
 625
 626         if (can_dropped_invalid_skb(dev, skb))
 627                 return NETDEV_TX_OK;
 628
 629         netif_stop_queue(dev);
 630
 631         if (frame->can_id & CAN_RTR_FLAG)
 632                 flags |= TX_BUF_RTR;
 633
 634         if (frame->can_id & CAN_EFF_FLAG) {
 635                 id = frame->can_id & CAN_EFF_MASK;
 636                 flags |= TX_BUF_XTD;
 637         } else {
 638                 id = ((frame->can_id & CAN_SFF_MASK) << 18);
 639         }
 640
 641         /* message ram configuration */
 642         writel(id | flags,
 643                 priv->mram_base + priv->mram_off + priv->txb_off);
 644         writel(frame->can_dlc << 16,
 645                 priv->mram_base + priv->mram_off + priv->txb_off + 0x4);
 646         writel(*(u32 *)(frame->data + 0),
 647                 priv->mram_base + priv->mram_off + priv->txb_off + 0x8);
 648         writel(*(u32 *)(frame->data + 4),
 649                 priv->mram_base + priv->mram_off + priv->txb_off + 0xc);
 650
 651         can_put_echo_skb(skb, dev, 0);
 652
 653         /* enable first TX buffer to start transfer  */
 654         m_can_write(priv, M_CAN_TXBTIE, 0x00000001);
 655         m_can_write(priv, M_CAN_TXBAR, 0x00000001);
 656
 657         return NETDEV_TX_OK;
 658 }
 659
 660 static const struct net_device_ops m_can_netdev_ops = {
 661         .ndo_open = m_can_open,
 662         .ndo_stop = m_can_close,
 663         .ndo_start_xmit = m_can_start_xmit,
 664 };
 665
 666 static int register_m_can_dev(struct net_device *dev)
 667 {
 668         dev->flags |= IFF_ECHO; /* we support local echo */
 669         dev->netdev_ops = &m_can_netdev_ops;
 670
 671         return register_candev(dev);
 672 }
 673
 674 static const struct of_device_id m_can_of_table[] = {
 675         { .compatible = "bosch,m_can", .data = NULL },
 676         { /* sentinel */ },
 677 };
 678 MODULE_DEVICE_TABLE(of, m_can_of_table);
 679
 680 static int m_can_of_parse_mram(struct platform_device *pdev,
 681                                 struct m_can_priv *priv)
 682 {
 683         struct device_node *np = pdev->dev.of_node;
 684         struct resource *res;
 685         void __iomem *addr;
 686         u32 out_val[8];
 687         int ret;
 688
 689         /* message ram could be shared */
 690         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "message_ram");
 691         if (!res)
 692                 return -ENODEV;
 693
 694         addr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 695         if (!addr)
 696                 return -ENODEV;
 697
 698         /* get message ram configuration */
 699         ret = of_property_read_u32_array(np, "mram-cfg",
 700                                 out_val, sizeof(out_val) / 4);
 701         if (ret) {
 702                 dev_err(&pdev->dev, "can not get message ram configuration\n");
 703                 return -ENODEV;
 704         }
 705
 706         priv->mram_base = addr;
 707         priv->mram_off = out_val[0];
 708         priv->sidf_elems = out_val[1];
 709         priv->sidf_off = priv->mram_off;
 710         priv->xidf_elems = out_val[2];
 711         priv->xidf_off = priv->sidf_off + priv->sidf_elems * SIDF_ELEMENT_SIZE;
 712         priv->rxf0_elems = out_val[3] & RXFC_FS_MASK;
 713         priv->rxf0_off = priv->xidf_off + priv->xidf_elems * XIDF_ELEMENT_SIZE;
 714         priv->rxf1_elems = out_val[4] & RXFC_FS_MASK;
 715         priv->rxf1_off = priv->rxf0_off + priv->rxf0_elems * RXF0_ELEMENT_SIZE;
 716         priv->rxb_elems = out_val[5];
 717         priv->rxb_off = priv->rxf1_off + priv->rxf1_elems * RXF1_ELEMENT_SIZE;
 718         priv->txe_elems = out_val[6];
 719         priv->txe_off = priv->rxb_off + priv->rxb_elems * RXB_ELEMENT_SIZE;
 720         priv->txb_elems = out_val[7] & TXBC_NDTB_MASK;
 721         priv->txb_off = priv->txe_off + priv->txe_elems * TXE_ELEMENT_SIZE;
 722
 723         dev_dbg(&pdev->dev, "mram_base =%p mram_off =0x%x "
 724                 "sidf %d xidf %d rxf0 %d rxf1 %d rxb %d txe %d txb %d\n",
 725                 priv->mram_base, priv->mram_off, priv->sidf_elems,
 726                 priv->xidf_elems, priv->rxf0_elems, priv->rxf1_elems,
 727                 priv->rxb_elems, priv->txe_elems, priv->txb_elems);
 728
 729         return 0;
 730 }
 731
 732 static int m_can_plat_probe(struct platform_device *pdev)
 733 {
 734         struct net_device *dev;
 735         struct m_can_priv *priv;
 736         struct pinctrl *pinctrl;
 737         struct resource *res;
 738         void __iomem *addr;
 739         struct clk *clk;
 740         int irq, ret;
 741
 742         pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
 743         if (IS_ERR(pinctrl))
 744                 dev_warn(&pdev->dev,
 745                         "failed to configure pins from driver\n");
 746
 747         clk = devm_clk_get(&pdev->dev, NULL);
 748         if (IS_ERR(clk)) {
 749                 dev_err(&pdev->dev, "no clock find\n");
 750                 return PTR_ERR(clk);
 751         }
 752
 753         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "canfd");
 754         addr = devm_request_and_ioremap(&pdev->dev, res);
 755         irq = platform_get_irq(pdev, 0);
 756         if (!addr || irq < 0)
 757                 return -EINVAL;
 758
 759         /* allocate the m_can device */
 760         dev = alloc_m_can_dev();
 761         if (!dev)
 762                 return -ENOMEM;
 763
 764         priv = netdev_priv(dev);
 765         dev->irq = irq;
 766         priv->base = addr;
 767         priv->device = &pdev->dev;
 768         priv->clk = clk;
 769         priv->can.clock.freq = clk_get_rate(clk);
 770
 771         ret = m_can_of_parse_mram(pdev, priv);
 772         if (ret)
 773                 goto failed_free_dev;
 774
 775         platform_set_drvdata(pdev, dev);
 776         SET_NETDEV_DEV(dev, &pdev->dev);
 777
 778         ret = register_m_can_dev(dev);
 779         if (ret) {
 780                 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
 781                         KBUILD_MODNAME, ret);
 782                 goto failed_free_dev;
 783         }
 784
 785         devm_can_led_init(dev);
 786
 787         dev_info(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
 788                  KBUILD_MODNAME, priv->base, dev->irq);
 789
 790         return 0;
 791
 792 failed_free_dev:
 793         free_m_can_dev(dev);
 794         return ret;
 795 }
 796
 797 #ifdef CONFIG_PM
 798 static int m_can_suspend(struct device *dev)
 799 {
 800         struct net_device *ndev = dev_get_drvdata(dev);
 801         struct m_can_priv *priv = netdev_priv(ndev);
 802
 803         if (netif_running(ndev)) {
 804                 netif_stop_queue(ndev);
 805                 netif_device_detach(ndev);
 806         }
 807
 808         /* TODO: enter low power */
 809
 810         priv->can.state = CAN_STATE_SLEEPING;
 811
 812         return 0;
 813 }
 814
 815 static int m_can_resume(struct device *dev)
 816 {
 817         struct net_device *ndev = dev_get_drvdata(dev);
 818         struct m_can_priv *priv = netdev_priv(ndev);
 819
 820         /* TODO: exit low power */
 821
 822         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 823
 824         if (netif_running(ndev)) {
 825                 netif_device_attach(ndev);
 826                 netif_start_queue(ndev);
 827         }
 828
 829         return 0;
 830 }
 831 #endif
 832
 833 static void unregister_m_can_dev(struct net_device *dev)
 834 {
 835         unregister_candev(dev);
 836 }
 837
 838 static int m_can_plat_remove(struct platform_device *pdev)
 839 {
 840         struct net_device *dev = platform_get_drvdata(pdev);
 841
 842         unregister_m_can_dev(dev);
 843         platform_set_drvdata(pdev, NULL);
 844
 845         free_m_can_dev(dev);
 846
 847         return 0;
 848 }
 849
 850 static const struct dev_pm_ops m_can_pmops = {
 851         SET_SYSTEM_SLEEP_PM_OPS(m_can_suspend, m_can_resume)
 852 };
 853
 854 static struct platform_driver m_can_plat_driver = {
 855         .driver = {
 856                 .name = KBUILD_MODNAME,
 857                 .owner = THIS_MODULE,
 858                 .of_match_table = of_match_ptr(m_can_of_table),
 859                 .pm     = &m_can_pmops,
 860         },
 861         .probe = m_can_plat_probe,
 862         .remove = m_can_plat_remove,
 863 };
 864
 865 module_platform_driver(m_can_plat_driver);
 866
 867 MODULE_AUTHOR("Dong Aisheng <b29396@freescale.com>");
 868 MODULE_LICENSE("GPL v2");
 869 MODULE_DESCRIPTION("CAN bus driver for Bosch M_CAN controller");