drivers/net/ks8851_mll.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Micrel KS8851_MLL 16bit Network driver
   4  * Copyright (c) 2011 Roberto Cerati <roberto.cerati@bticino.it>
   5  */
   6
   7 #include <log.h>
   8 #include <asm/io.h>
   9 #include <common.h>
  10 #include <command.h>
  11 #include <malloc.h>
  12 #include <net.h>
  13 #include <miiphy.h>
  14 #include <linux/delay.h>
  15
  16 #include "ks8851_mll.h"
  17
  18 #define DRIVERNAME                      "ks8851_mll"
  19
  20 #define RX_BUF_SIZE                     2000
  21
  22 /*
  23  * struct ks_net - KS8851 driver private data
  24  * @dev         : legacy non-DM ethernet device structure
  25  * @iobase      : register base
  26  * @bus_width   : i/o bus width.
  27  * @sharedbus   : Multipex(addr and data bus) mode indicator.
  28  * @extra_byte  : number of extra byte prepended rx pkt.
  29  */
  30 struct ks_net {
  31         phys_addr_t             iobase;
  32         int                     bus_width;
  33         u16                     sharedbus;
  34         u16                     rxfc;
  35         u8                      extra_byte;
  36 };
  37
  38 #define BE3             0x8000      /* Byte Enable 3 */
  39 #define BE2             0x4000      /* Byte Enable 2 */
  40 #define BE1             0x2000      /* Byte Enable 1 */
  41 #define BE0             0x1000      /* Byte Enable 0 */
  42
  43 static u8 ks_rdreg8(struct ks_net *ks, u16 offset)
  44 {
  45         u8 shift_bit = offset & 0x03;
  46         u8 shift_data = (offset & 1) << 3;
  47
  48         writew(offset | (BE0 << shift_bit), ks->iobase + 2);
  49
  50         return (u8)(readw(ks->iobase) >> shift_data);
  51 }
  52
  53 static u16 ks_rdreg16(struct ks_net *ks, u16 offset)
  54 {
  55         writew(offset | ((BE1 | BE0) << (offset & 0x02)), ks->iobase + 2);
  56
  57         return readw(ks->iobase);
  58 }
  59
  60 static void ks_wrreg16(struct ks_net *ks, u16 offset, u16 val)
  61 {
  62         writew(offset | ((BE1 | BE0) << (offset & 0x02)), ks->iobase + 2);
  63         writew(val, ks->iobase);
  64 }
  65
  66 /*
  67  * ks_inblk - read a block of data from QMU. This is called after sudo DMA mode
  68  * enabled.
  69  * @ks: The chip state
  70  * @wptr: buffer address to save data
  71  * @len: length in byte to read
  72  */
  73 static inline void ks_inblk(struct ks_net *ks, u16 *wptr, u32 len)
  74 {
  75         len >>= 1;
  76
  77         while (len--)
  78                 *wptr++ = readw(ks->iobase);
  79 }
  80
  81 /*
  82  * ks_outblk - write data to QMU. This is called after sudo DMA mode enabled.
  83  * @ks: The chip information
  84  * @wptr: buffer address
  85  * @len: length in byte to write
  86  */
  87 static inline void ks_outblk(struct ks_net *ks, u16 *wptr, u32 len)
  88 {
  89         len >>= 1;
  90
  91         while (len--)
  92                 writew(*wptr++, ks->iobase);
  93 }
  94
  95 static void ks_enable_int(struct ks_net *ks)
  96 {
  97         ks_wrreg16(ks, KS_IER, IRQ_LCI | IRQ_TXI | IRQ_RXI);
  98 }
  99
 100 static void ks_set_powermode(struct ks_net *ks, unsigned int pwrmode)
 101 {
 102         unsigned int pmecr;
 103
 104         ks_rdreg16(ks, KS_GRR);
 105         pmecr = ks_rdreg16(ks, KS_PMECR);
 106         pmecr &= ~PMECR_PM_MASK;
 107         pmecr |= pwrmode;
 108
 109         ks_wrreg16(ks, KS_PMECR, pmecr);
 110 }
 111
 112 /*
 113  * ks_read_config - read chip configuration of bus width.
 114  * @ks: The chip information
 115  */
 116 static void ks_read_config(struct ks_net *ks)
 117 {
 118         u16 reg_data = 0;
 119
 120         /* Regardless of bus width, 8 bit read should always work. */
 121         reg_data = ks_rdreg8(ks, KS_CCR) & 0x00FF;
 122         reg_data |= ks_rdreg8(ks, KS_CCR + 1) << 8;
 123
 124         /* addr/data bus are multiplexed */
 125         ks->sharedbus = (reg_data & CCR_SHARED) == CCR_SHARED;
 126
 127         /*
 128          * There are garbage data when reading data from QMU,
 129          * depending on bus-width.
 130          */
 131         if (reg_data & CCR_8BIT) {
 132                 ks->bus_width = ENUM_BUS_8BIT;
 133                 ks->extra_byte = 1;
 134         } else if (reg_data & CCR_16BIT) {
 135                 ks->bus_width = ENUM_BUS_16BIT;
 136                 ks->extra_byte = 2;
 137         } else {
 138                 ks->bus_width = ENUM_BUS_32BIT;
 139                 ks->extra_byte = 4;
 140         }
 141 }
 142
 143 /*
 144  * ks_soft_reset - issue one of the soft reset to the device
 145  * @ks: The device state.
 146  * @op: The bit(s) to set in the GRR
 147  *
 148  * Issue the relevant soft-reset command to the device's GRR register
 149  * specified by @op.
 150  *
 151  * Note, the delays are in there as a caution to ensure that the reset
 152  * has time to take effect and then complete. Since the datasheet does
 153  * not currently specify the exact sequence, we have chosen something
 154  * that seems to work with our device.
 155  */
 156 static void ks_soft_reset(struct ks_net *ks, unsigned int op)
 157 {
 158         /* Disable interrupt first */
 159         ks_wrreg16(ks, KS_IER, 0x0000);
 160         ks_wrreg16(ks, KS_GRR, op);
 161         mdelay(10);     /* wait a short time to effect reset */
 162         ks_wrreg16(ks, KS_GRR, 0);
 163         mdelay(1);      /* wait for condition to clear */
 164 }
 165
 166 void ks_enable_qmu(struct ks_net *ks)
 167 {
 168         u16 w;
 169
 170         w = ks_rdreg16(ks, KS_TXCR);
 171
 172         /* Enables QMU Transmit (TXCR). */
 173         ks_wrreg16(ks, KS_TXCR, w | TXCR_TXE);
 174
 175         /* Enable RX Frame Count Threshold and Auto-Dequeue RXQ Frame */
 176         w = ks_rdreg16(ks, KS_RXQCR);
 177         ks_wrreg16(ks, KS_RXQCR, w | RXQCR_RXFCTE);
 178
 179         /* Enables QMU Receive (RXCR1). */
 180         w = ks_rdreg16(ks, KS_RXCR1);
 181         ks_wrreg16(ks, KS_RXCR1, w | RXCR1_RXE);
 182 }
 183
 184 static void ks_disable_qmu(struct ks_net *ks)
 185 {
 186         u16 w;
 187
 188         w = ks_rdreg16(ks, KS_TXCR);
 189
 190         /* Disables QMU Transmit (TXCR). */
 191         w &= ~TXCR_TXE;
 192         ks_wrreg16(ks, KS_TXCR, w);
 193
 194         /* Disables QMU Receive (RXCR1). */
 195         w = ks_rdreg16(ks, KS_RXCR1);
 196         w &= ~RXCR1_RXE;
 197         ks_wrreg16(ks, KS_RXCR1, w);
 198 }
 199
 200 static inline void ks_read_qmu(struct ks_net *ks, u16 *buf, u32 len)
 201 {
 202         u32 r = ks->extra_byte & 0x1;
 203         u32 w = ks->extra_byte - r;
 204
 205         /* 1. set sudo DMA mode */
 206         ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
 207         ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_SDA);
 208
 209         /*
 210          * 2. read prepend data
 211          *
 212          * read 4 + extra bytes and discard them.
 213          * extra bytes for dummy, 2 for status, 2 for len
 214          */
 215
 216         if (r)
 217                 ks_rdreg8(ks, 0);
 218
 219         ks_inblk(ks, buf, w + 2 + 2);
 220
 221         /* 3. read pkt data */
 222         ks_inblk(ks, buf, ALIGN(len, 4));
 223
 224         /* 4. reset sudo DMA Mode */
 225         ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
 226 }
 227
 228 static int ks_rcv(struct ks_net *ks, uchar *data)
 229 {
 230         u16 sts, len;
 231
 232         if (!ks->rxfc)
 233                 ks->rxfc = ks_rdreg16(ks, KS_RXFCTR) >> 8;
 234
 235         if (!ks->rxfc)
 236                 return 0;
 237
 238         /* Checking Received packet status */
 239         sts = ks_rdreg16(ks, KS_RXFHSR);
 240         /* Get packet len from hardware */
 241         len = ks_rdreg16(ks, KS_RXFHBCR);
 242
 243         if ((sts & RXFSHR_RXFV) && len && (len < RX_BUF_SIZE)) {
 244                 /* read data block including CRC 4 bytes */
 245                 ks_read_qmu(ks, (u16 *)data, len);
 246                 ks->rxfc--;
 247                 return len - 4;
 248         }
 249
 250         ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_RRXEF);
 251         printf(DRIVERNAME ": bad packet (sts=0x%04x len=0x%04x)\n", sts, len);
 252         ks->rxfc = 0;
 253         return 0;
 254 }
 255
 256 /*
 257  * ks_read_selftest - read the selftest memory info.
 258  * @ks: The device state
 259  *
 260  * Read and check the TX/RX memory selftest information.
 261  */
 262 static int ks_read_selftest(struct ks_net *ks)
 263 {
 264         u16 both_done = MBIR_TXMBF | MBIR_RXMBF;
 265         u16 mbir;
 266         int ret = 0;
 267
 268         mbir = ks_rdreg16(ks, KS_MBIR);
 269
 270         if ((mbir & both_done) != both_done) {
 271                 printf(DRIVERNAME ": Memory selftest not finished\n");
 272                 return 0;
 273         }
 274
 275         if (mbir & MBIR_TXMBFA) {
 276                 printf(DRIVERNAME ": TX memory selftest fails\n");
 277                 ret |= 1;
 278         }
 279
 280         if (mbir & MBIR_RXMBFA) {
 281                 printf(DRIVERNAME ": RX memory selftest fails\n");
 282                 ret |= 2;
 283         }
 284
 285         debug(DRIVERNAME ": the selftest passes\n");
 286
 287         return ret;
 288 }
 289
 290 static void ks_setup(struct ks_net *ks)
 291 {
 292         u16 w;
 293
 294         /* Setup Transmit Frame Data Pointer Auto-Increment (TXFDPR) */
 295         ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
 296
 297         /* Setup Receive Frame Data Pointer Auto-Increment */
 298         ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
 299
 300         /* Setup Receive Frame Threshold - 1 frame (RXFCTFC) */
 301         ks_wrreg16(ks, KS_RXFCTR, 1 & RXFCTR_THRESHOLD_MASK);
 302
 303         /* Setup RxQ Command Control (RXQCR) */
 304         ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
 305
 306         /*
 307          * set the force mode to half duplex, default is full duplex
 308          * because if the auto-negotiation fails, most switch uses
 309          * half-duplex.
 310          */
 311         w = ks_rdreg16(ks, KS_P1MBCR);
 312         w &= ~P1MBCR_FORCE_FDX;
 313         ks_wrreg16(ks, KS_P1MBCR, w);
 314
 315         w = TXCR_TXFCE | TXCR_TXPE | TXCR_TXCRC | TXCR_TCGIP;
 316         ks_wrreg16(ks, KS_TXCR, w);
 317
 318         w = RXCR1_RXFCE | RXCR1_RXBE | RXCR1_RXUE | RXCR1_RXME | RXCR1_RXIPFCC;
 319
 320         /* Normal mode */
 321         w |= RXCR1_RXPAFMA;
 322
 323         ks_wrreg16(ks, KS_RXCR1, w);
 324 }
 325
 326 static void ks_setup_int(struct ks_net *ks)
 327 {
 328         /* Clear the interrupts status of the hardware. */
 329         ks_wrreg16(ks, KS_ISR, 0xffff);
 330 }
 331
 332 static int ks8851_mll_detect_chip(struct ks_net *ks)
 333 {
 334         unsigned short val;
 335
 336         ks_read_config(ks);
 337
 338         val = ks_rdreg16(ks, KS_CIDER);
 339
 340         if (val == 0xffff) {
 341                 /* Special case -- no chip present */
 342                 printf(DRIVERNAME ":  is chip mounted ?\n");
 343                 return -1;
 344         } else if ((val & 0xfff0) != CIDER_ID) {
 345                 printf(DRIVERNAME ": Invalid chip id 0x%04x\n", val);
 346                 return -1;
 347         }
 348
 349         debug("Read back KS8851 id 0x%x\n", val);
 350
 351         if ((val & 0xfff0) != CIDER_ID) {
 352                 printf(DRIVERNAME ": Unknown chip ID %04x\n", val);
 353                 return -1;
 354         }
 355
 356         return 0;
 357 }
 358
 359 static void ks8851_mll_reset(struct ks_net *ks)
 360 {
 361         /* wake up powermode to normal mode */
 362         ks_set_powermode(ks, PMECR_PM_NORMAL);
 363         mdelay(1);      /* wait for normal mode to take effect */
 364
 365         /* Disable interrupt and reset */
 366         ks_soft_reset(ks, GRR_GSR);
 367
 368         /* turn off the IRQs and ack any outstanding */
 369         ks_wrreg16(ks, KS_IER, 0x0000);
 370         ks_wrreg16(ks, KS_ISR, 0xffff);
 371
 372         /* shutdown RX/TX QMU */
 373         ks_disable_qmu(ks);
 374 }
 375
 376 static void ks8851_mll_phy_configure(struct ks_net *ks)
 377 {
 378         u16 data;
 379
 380         ks_setup(ks);
 381         ks_setup_int(ks);
 382
 383         /* Probing the phy */
 384         data = ks_rdreg16(ks, KS_OBCR);
 385         ks_wrreg16(ks, KS_OBCR, data | OBCR_ODS_16MA);
 386
 387         debug(DRIVERNAME ": phy initialized\n");
 388 }
 389
 390 static void ks8851_mll_enable(struct ks_net *ks)
 391 {
 392         ks_wrreg16(ks, KS_ISR, 0xffff);
 393         ks_enable_int(ks);
 394         ks_enable_qmu(ks);
 395 }
 396
 397 static int ks8851_mll_init_common(struct ks_net *ks)
 398 {
 399         if (ks_read_selftest(ks)) {
 400                 printf(DRIVERNAME ": Selftest failed\n");
 401                 return -1;
 402         }
 403
 404         ks8851_mll_reset(ks);
 405
 406         /* Configure the PHY, initialize the link state */
 407         ks8851_mll_phy_configure(ks);
 408
 409         ks->rxfc = 0;
 410
 411         /* Turn on Tx + Rx */
 412         ks8851_mll_enable(ks);
 413
 414         return 0;
 415 }
 416
 417 static void ks_write_qmu(struct ks_net *ks, u8 *pdata, u16 len)
 418 {
 419         __le16 txw[2];
 420         /* start header at txb[0] to align txw entries */
 421         txw[0] = 0;
 422         txw[1] = cpu_to_le16(len);
 423
 424         /* 1. set sudo-DMA mode */
 425         ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
 426         ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL | RXQCR_SDA);
 427         /* 2. write status/length info */
 428         ks_outblk(ks, txw, 4);
 429         /* 3. write pkt data */
 430         ks_outblk(ks, (u16 *)pdata, ALIGN(len, 4));
 431         /* 4. reset sudo-DMA mode */
 432         ks_wrreg16(ks, KS_RXQCR, RXQCR_CMD_CNTL);
 433         /* 5. Enqueue Tx(move the pkt from TX buffer into TXQ) */
 434         ks_wrreg16(ks, KS_TXQCR, TXQCR_METFE);
 435         /* 6. wait until TXQCR_METFE is auto-cleared */
 436         do { } while (ks_rdreg16(ks, KS_TXQCR) & TXQCR_METFE);
 437 }
 438
 439 static int ks8851_mll_send_common(struct ks_net *ks, void *packet, int length)
 440 {
 441         u8 *data = (u8 *)packet;
 442         u16 tmplen = (u16)length;
 443         u16 retv;
 444
 445         /*
 446          * Extra space are required:
 447          * 4 byte for alignment, 4 for status/length, 4 for CRC
 448          */
 449         retv = ks_rdreg16(ks, KS_TXMIR) & 0x1fff;
 450         if (retv >= tmplen + 12) {
 451                 ks_write_qmu(ks, data, tmplen);
 452                 return 0;
 453         }
 454
 455         printf(DRIVERNAME ": failed to send packet: No buffer\n");
 456         return -1;
 457 }
 458
 459 static void ks8851_mll_halt_common(struct ks_net *ks)
 460 {
 461         ks8851_mll_reset(ks);
 462 }
 463
 464 /*
 465  * Maximum receive ring size; that is, the number of packets
 466  * we can buffer before overflow happens. Basically, this just
 467  * needs to be enough to prevent a packet being discarded while
 468  * we are processing the previous one.
 469  */
 470 static int ks8851_mll_recv_common(struct ks_net *ks, uchar *data)
 471 {
 472         u16 status;
 473         int ret = 0;
 474
 475         status = ks_rdreg16(ks, KS_ISR);
 476
 477         ks_wrreg16(ks, KS_ISR, status);
 478
 479         if (ks->rxfc || (status & IRQ_RXI))
 480                 ret = ks_rcv(ks, data);
 481
 482         if (status & IRQ_LDI) {
 483                 u16 pmecr = ks_rdreg16(ks, KS_PMECR);
 484
 485                 pmecr &= ~PMECR_WKEVT_MASK;
 486                 ks_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK);
 487         }
 488
 489         return ret;
 490 }
 491
 492 static void ks8851_mll_write_hwaddr_common(struct ks_net *ks, u8 enetaddr[6])
 493 {
 494         u16 addrl, addrm, addrh;
 495
 496         addrh = (enetaddr[0] << 8) | enetaddr[1];
 497         addrm = (enetaddr[2] << 8) | enetaddr[3];
 498         addrl = (enetaddr[4] << 8) | enetaddr[5];
 499
 500         ks_wrreg16(ks, KS_MARH, addrh);
 501         ks_wrreg16(ks, KS_MARM, addrm);
 502         ks_wrreg16(ks, KS_MARL, addrl);
 503 }
 504
 505 static int ks8851_start(struct udevice *dev)
 506 {
 507         struct ks_net *ks = dev_get_priv(dev);
 508
 509         return ks8851_mll_init_common(ks);
 510 }
 511
 512 static void ks8851_stop(struct udevice *dev)
 513 {
 514         struct ks_net *ks = dev_get_priv(dev);
 515
 516         ks8851_mll_halt_common(ks);
 517 }
 518
 519 static int ks8851_send(struct udevice *dev, void *packet, int length)
 520 {
 521         struct ks_net *ks = dev_get_priv(dev);
 522         int ret;
 523
 524         ret = ks8851_mll_send_common(ks, packet, length);
 525
 526         return ret ? 0 : -ETIMEDOUT;
 527 }
 528
 529 static int ks8851_recv(struct udevice *dev, int flags, uchar **packetp)
 530 {
 531         struct ks_net *ks = dev_get_priv(dev);
 532         uchar *data = net_rx_packets[0];
 533         int ret;
 534
 535         ret = ks8851_mll_recv_common(ks, data);
 536         if (ret)
 537                 *packetp = (void *)data;
 538
 539         return ret ? ret : -EAGAIN;
 540 }
 541
 542 static int ks8851_write_hwaddr(struct udevice *dev)
 543 {
 544         struct ks_net *ks = dev_get_priv(dev);
 545         struct eth_pdata *pdata = dev_get_plat(dev);
 546
 547         ks8851_mll_write_hwaddr_common(ks, pdata->enetaddr);
 548
 549         return 0;
 550 }
 551
 552 static int ks8851_read_rom_hwaddr(struct udevice *dev)
 553 {
 554         struct ks_net *ks = dev_get_priv(dev);
 555         struct eth_pdata *pdata = dev_get_plat(dev);
 556         u16 addrl, addrm, addrh;
 557
 558         /* No EEPROM means no valid MAC address. */
 559         if (!(ks_rdreg16(ks, KS_CCR) & CCR_EEPROM))
 560                 return -EINVAL;
 561
 562         /*
 563          * If the EEPROM contains valid MAC address, it is loaded into
 564          * the NIC on power on. Read the MAC out of the NIC registers.
 565          */
 566         addrl = ks_rdreg16(ks, KS_MARL);
 567         addrm = ks_rdreg16(ks, KS_MARM);
 568         addrh = ks_rdreg16(ks, KS_MARH);
 569
 570         pdata->enetaddr[0] = (addrh >> 8) & 0xff;
 571         pdata->enetaddr[1] = addrh & 0xff;
 572         pdata->enetaddr[2] = (addrm >> 8) & 0xff;
 573         pdata->enetaddr[3] = addrm & 0xff;
 574         pdata->enetaddr[4] = (addrl >> 8) & 0xff;
 575         pdata->enetaddr[5] = addrl & 0xff;
 576
 577         return !is_valid_ethaddr(pdata->enetaddr);
 578 }
 579
 580 static int ks8851_bind(struct udevice *dev)
 581 {
 582         return device_set_name(dev, dev->name);
 583 }
 584
 585 static int ks8851_probe(struct udevice *dev)
 586 {
 587         struct ks_net *ks = dev_get_priv(dev);
 588
 589         /* Try to detect chip. Will fail if not present. */
 590         ks8851_mll_detect_chip(ks);
 591
 592         return 0;
 593 }
 594
 595 static int ks8851_of_to_plat(struct udevice *dev)
 596 {
 597         struct ks_net *ks = dev_get_priv(dev);
 598         struct eth_pdata *pdata = dev_get_plat(dev);
 599
 600         pdata->iobase = dev_read_addr(dev);
 601         ks->iobase = pdata->iobase;
 602
 603         return 0;
 604 }
 605
 606 static const struct eth_ops ks8851_ops = {
 607         .start          = ks8851_start,
 608         .stop           = ks8851_stop,
 609         .send           = ks8851_send,
 610         .recv           = ks8851_recv,
 611         .write_hwaddr   = ks8851_write_hwaddr,
 612         .read_rom_hwaddr = ks8851_read_rom_hwaddr,
 613 };
 614
 615 static const struct udevice_id ks8851_ids[] = {
 616         { .compatible = "micrel,ks8851-mll" },
 617         { }
 618 };
 619
 620 U_BOOT_DRIVER(ks8851) = {
 621         .name           = "eth_ks8851",
 622         .id             = UCLASS_ETH,
 623         .of_match       = ks8851_ids,
 624         .bind           = ks8851_bind,
 625         .of_to_plat = ks8851_of_to_plat,
 626         .probe          = ks8851_probe,
 627         .ops            = &ks8851_ops,
 628         .priv_auto      = sizeof(struct ks_net),
 629         .plat_auto      = sizeof(struct eth_pdata),
 630         .flags          = DM_FLAG_ALLOC_PRIV_DMA,
 631 };