drivers/net/ethernet/microchip/encx24j600.c

   1 /**
   2  * Microchip ENCX24J600 ethernet driver
   3  *
   4  * Copyright (C) 2015 Gridpoint
   5  * Author: Jon Ringle <jringle@gridpoint.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  */
  13
  14 #include <linux/device.h>
  15 #include <linux/errno.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/ethtool.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/regmap.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/spi/spi.h>
  25
  26 #include "encx24j600_hw.h"
  27
  28 #define DRV_NAME        "encx24j600"
  29 #define DRV_VERSION     "1.0"
  30
  31 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
  32 static int debug = -1;
  33 module_param(debug, int, 0);
  34 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
  35
  36 /* SRAM memory layout:
  37  *
  38  * 0x0000-0x05ff TX buffers  1.5KB  (1*1536) reside in the GP area in SRAM
  39  * 0x0600-0x5fff RX buffers 22.5KB (15*1536) reside in the RX area in SRAM
  40  */
  41 #define ENC_TX_BUF_START 0x0000U
  42 #define ENC_RX_BUF_START 0x0600U
  43 #define ENC_RX_BUF_END   0x5fffU
  44 #define ENC_SRAM_SIZE    0x6000U
  45
  46 enum {
  47         RXFILTER_NORMAL,
  48         RXFILTER_MULTI,
  49         RXFILTER_PROMISC
  50 };
  51
  52 struct encx24j600_priv {
  53         struct net_device        *ndev;
  54         struct mutex              lock; /* device access lock */
  55         struct encx24j600_context ctx;
  56         struct sk_buff           *tx_skb;
  57         struct task_struct       *kworker_task;
  58         struct kthread_worker     kworker;
  59         struct kthread_work       tx_work;
  60         struct kthread_work       setrx_work;
  61         u16                       next_packet;
  62         bool                      hw_enabled;
  63         bool                      full_duplex;
  64         bool                      autoneg;
  65         u16                       speed;
  66         int                       rxfilter;
  67         u32                       msg_enable;
  68 };
  69
  70 static void dump_packet(const char *msg, int len, const char *data)
  71 {
  72         pr_debug(DRV_NAME ": %s - packet len:%d\n", msg, len);
  73         print_hex_dump_bytes("pk data: ", DUMP_PREFIX_OFFSET, data, len);
  74 }
  75
  76 static void encx24j600_dump_rsv(struct encx24j600_priv *priv, const char *msg,
  77                                 struct rsv *rsv)
  78 {
  79         struct net_device *dev = priv->ndev;
  80
  81         netdev_info(dev, "RX packet Len:%d\n", rsv->len);
  82         netdev_dbg(dev, "%s - NextPk: 0x%04x\n", msg,
  83                    rsv->next_packet);
  84         netdev_dbg(dev, "RxOK: %d, DribbleNibble: %d\n",
  85                    RSV_GETBIT(rsv->rxstat, RSV_RXOK),
  86                    RSV_GETBIT(rsv->rxstat, RSV_DRIBBLENIBBLE));
  87         netdev_dbg(dev, "CRCErr:%d, LenChkErr: %d, LenOutOfRange: %d\n",
  88                    RSV_GETBIT(rsv->rxstat, RSV_CRCERROR),
  89                    RSV_GETBIT(rsv->rxstat, RSV_LENCHECKERR),
  90                    RSV_GETBIT(rsv->rxstat, RSV_LENOUTOFRANGE));
  91         netdev_dbg(dev, "Multicast: %d, Broadcast: %d, LongDropEvent: %d, CarrierEvent: %d\n",
  92                    RSV_GETBIT(rsv->rxstat, RSV_RXMULTICAST),
  93                    RSV_GETBIT(rsv->rxstat, RSV_RXBROADCAST),
  94                    RSV_GETBIT(rsv->rxstat, RSV_RXLONGEVDROPEV),
  95                    RSV_GETBIT(rsv->rxstat, RSV_CARRIEREV));
  96         netdev_dbg(dev, "ControlFrame: %d, PauseFrame: %d, UnknownOp: %d, VLanTagFrame: %d\n",
  97                    RSV_GETBIT(rsv->rxstat, RSV_RXCONTROLFRAME),
  98                    RSV_GETBIT(rsv->rxstat, RSV_RXPAUSEFRAME),
  99                    RSV_GETBIT(rsv->rxstat, RSV_RXUNKNOWNOPCODE),
 100                    RSV_GETBIT(rsv->rxstat, RSV_RXTYPEVLAN));
 101 }
 102
 103 static u16 encx24j600_read_reg(struct encx24j600_priv *priv, u8 reg)
 104 {
 105         struct net_device *dev = priv->ndev;
 106         unsigned int val = 0;
 107         int ret = regmap_read(priv->ctx.regmap, reg, &val);
 108         if (unlikely(ret))
 109                 netif_err(priv, drv, dev, "%s: error %d reading reg %02x\n",
 110                           __func__, ret, reg);
 111         return val;
 112 }
 113
 114 static void encx24j600_write_reg(struct encx24j600_priv *priv, u8 reg, u16 val)
 115 {
 116         struct net_device *dev = priv->ndev;
 117         int ret = regmap_write(priv->ctx.regmap, reg, val);
 118         if (unlikely(ret))
 119                 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
 120                           __func__, ret, reg, val);
 121 }
 122
 123 static void encx24j600_update_reg(struct encx24j600_priv *priv, u8 reg,
 124                                   u16 mask, u16 val)
 125 {
 126         struct net_device *dev = priv->ndev;
 127         int ret = regmap_update_bits(priv->ctx.regmap, reg, mask, val);
 128         if (unlikely(ret))
 129                 netif_err(priv, drv, dev, "%s: error %d updating reg %02x=%04x~%04x\n",
 130                           __func__, ret, reg, val, mask);
 131 }
 132
 133 static u16 encx24j600_read_phy(struct encx24j600_priv *priv, u8 reg)
 134 {
 135         struct net_device *dev = priv->ndev;
 136         unsigned int val = 0;
 137         int ret = regmap_read(priv->ctx.phymap, reg, &val);
 138         if (unlikely(ret))
 139                 netif_err(priv, drv, dev, "%s: error %d reading %02x\n",
 140                           __func__, ret, reg);
 141         return val;
 142 }
 143
 144 static void encx24j600_write_phy(struct encx24j600_priv *priv, u8 reg, u16 val)
 145 {
 146         struct net_device *dev = priv->ndev;
 147         int ret = regmap_write(priv->ctx.phymap, reg, val);
 148         if (unlikely(ret))
 149                 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
 150                           __func__, ret, reg, val);
 151 }
 152
 153 static void encx24j600_clr_bits(struct encx24j600_priv *priv, u8 reg, u16 mask)
 154 {
 155         encx24j600_update_reg(priv, reg, mask, 0);
 156 }
 157
 158 static void encx24j600_set_bits(struct encx24j600_priv *priv, u8 reg, u16 mask)
 159 {
 160         encx24j600_update_reg(priv, reg, mask, mask);
 161 }
 162
 163 static void encx24j600_cmd(struct encx24j600_priv *priv, u8 cmd)
 164 {
 165         struct net_device *dev = priv->ndev;
 166         int ret = regmap_write(priv->ctx.regmap, cmd, 0);
 167         if (unlikely(ret))
 168                 netif_err(priv, drv, dev, "%s: error %d with cmd %02x\n",
 169                           __func__, ret, cmd);
 170 }
 171
 172 static int encx24j600_raw_read(struct encx24j600_priv *priv, u8 reg, u8 *data,
 173                                size_t count)
 174 {
 175         int ret;
 176         mutex_lock(&priv->ctx.mutex);
 177         ret = regmap_encx24j600_spi_read(&priv->ctx, reg, data, count);
 178         mutex_unlock(&priv->ctx.mutex);
 179
 180         return ret;
 181 }
 182
 183 static int encx24j600_raw_write(struct encx24j600_priv *priv, u8 reg,
 184                                 const u8 *data, size_t count)
 185 {
 186         int ret;
 187         mutex_lock(&priv->ctx.mutex);
 188         ret = regmap_encx24j600_spi_write(&priv->ctx, reg, data, count);
 189         mutex_unlock(&priv->ctx.mutex);
 190
 191         return ret;
 192 }
 193
 194 static void encx24j600_update_phcon1(struct encx24j600_priv *priv)
 195 {
 196         u16 phcon1 = encx24j600_read_phy(priv, PHCON1);
 197         if (priv->autoneg == AUTONEG_ENABLE) {
 198                 phcon1 |= ANEN | RENEG;
 199         } else {
 200                 phcon1 &= ~ANEN;
 201                 if (priv->speed == SPEED_100)
 202                         phcon1 |= SPD100;
 203                 else
 204                         phcon1 &= ~SPD100;
 205
 206                 if (priv->full_duplex)
 207                         phcon1 |= PFULDPX;
 208                 else
 209                         phcon1 &= ~PFULDPX;
 210         }
 211         encx24j600_write_phy(priv, PHCON1, phcon1);
 212 }
 213
 214 /* Waits for autonegotiation to complete. */
 215 static int encx24j600_wait_for_autoneg(struct encx24j600_priv *priv)
 216 {
 217         struct net_device *dev = priv->ndev;
 218         unsigned long timeout = jiffies + msecs_to_jiffies(2000);
 219         u16 phstat1;
 220         u16 estat;
 221         int ret = 0;
 222
 223         phstat1 = encx24j600_read_phy(priv, PHSTAT1);
 224         while ((phstat1 & ANDONE) == 0) {
 225                 if (time_after(jiffies, timeout)) {
 226                         u16 phstat3;
 227
 228                         netif_notice(priv, drv, dev, "timeout waiting for autoneg done\n");
 229
 230                         priv->autoneg = AUTONEG_DISABLE;
 231                         phstat3 = encx24j600_read_phy(priv, PHSTAT3);
 232                         priv->speed = (phstat3 & PHY3SPD100)
 233                                       ? SPEED_100 : SPEED_10;
 234                         priv->full_duplex = (phstat3 & PHY3DPX) ? 1 : 0;
 235                         encx24j600_update_phcon1(priv);
 236                         netif_notice(priv, drv, dev, "Using parallel detection: %s/%s",
 237                                      priv->speed == SPEED_100 ? "100" : "10",
 238                                      priv->full_duplex ? "Full" : "Half");
 239
 240                         return -ETIMEDOUT;
 241                 }
 242                 cpu_relax();
 243                 phstat1 = encx24j600_read_phy(priv, PHSTAT1);
 244         }
 245
 246         estat = encx24j600_read_reg(priv, ESTAT);
 247         if (estat & PHYDPX) {
 248                 encx24j600_set_bits(priv, MACON2, FULDPX);
 249                 encx24j600_write_reg(priv, MABBIPG, 0x15);
 250         } else {
 251                 encx24j600_clr_bits(priv, MACON2, FULDPX);
 252                 encx24j600_write_reg(priv, MABBIPG, 0x12);
 253                 /* Max retransmittions attempt  */
 254                 encx24j600_write_reg(priv, MACLCON, 0x370f);
 255         }
 256
 257         return ret;
 258 }
 259
 260 /* Access the PHY to determine link status */
 261 static void encx24j600_check_link_status(struct encx24j600_priv *priv)
 262 {
 263         struct net_device *dev = priv->ndev;
 264         u16 estat;
 265
 266         estat = encx24j600_read_reg(priv, ESTAT);
 267
 268         if (estat & PHYLNK) {
 269                 if (priv->autoneg == AUTONEG_ENABLE)
 270                         encx24j600_wait_for_autoneg(priv);
 271
 272                 netif_carrier_on(dev);
 273                 netif_info(priv, ifup, dev, "link up\n");
 274         } else {
 275                 netif_info(priv, ifdown, dev, "link down\n");
 276
 277                 /* Re-enable autoneg since we won't know what we might be
 278                  * connected to when the link is brought back up again.
 279                  */
 280                 priv->autoneg  = AUTONEG_ENABLE;
 281                 priv->full_duplex = true;
 282                 priv->speed = SPEED_100;
 283                 netif_carrier_off(dev);
 284         }
 285 }
 286
 287 static void encx24j600_int_link_handler(struct encx24j600_priv *priv)
 288 {
 289         struct net_device *dev = priv->ndev;
 290
 291         netif_dbg(priv, intr, dev, "%s", __func__);
 292         encx24j600_check_link_status(priv);
 293         encx24j600_clr_bits(priv, EIR, LINKIF);
 294 }
 295
 296 static void encx24j600_tx_complete(struct encx24j600_priv *priv, bool err)
 297 {
 298         struct net_device *dev = priv->ndev;
 299
 300         if (!priv->tx_skb) {
 301                 BUG();
 302                 return;
 303         }
 304
 305         mutex_lock(&priv->lock);
 306
 307         if (err)
 308                 dev->stats.tx_errors++;
 309         else
 310                 dev->stats.tx_packets++;
 311
 312         dev->stats.tx_bytes += priv->tx_skb->len;
 313
 314         encx24j600_clr_bits(priv, EIR, TXIF | TXABTIF);
 315
 316         netif_dbg(priv, tx_done, dev, "TX Done%s\n", err ? ": Err" : "");
 317
 318         dev_kfree_skb(priv->tx_skb);
 319         priv->tx_skb = NULL;
 320
 321         netif_wake_queue(dev);
 322
 323         mutex_unlock(&priv->lock);
 324 }
 325
 326 static int encx24j600_receive_packet(struct encx24j600_priv *priv,
 327                                      struct rsv *rsv)
 328 {
 329         struct net_device *dev = priv->ndev;
 330         struct sk_buff *skb = netdev_alloc_skb(dev, rsv->len + NET_IP_ALIGN);
 331         if (!skb) {
 332                 pr_err_ratelimited("RX: OOM: packet dropped\n");
 333                 dev->stats.rx_dropped++;
 334                 return -ENOMEM;
 335         }
 336         skb_reserve(skb, NET_IP_ALIGN);
 337         encx24j600_raw_read(priv, RRXDATA, skb_put(skb, rsv->len), rsv->len);
 338
 339         if (netif_msg_pktdata(priv))
 340                 dump_packet("RX", skb->len, skb->data);
 341
 342         skb->dev = dev;
 343         skb->protocol = eth_type_trans(skb, dev);
 344         skb->ip_summed = CHECKSUM_COMPLETE;
 345
 346         /* Maintain stats */
 347         dev->stats.rx_packets++;
 348         dev->stats.rx_bytes += rsv->len;
 349         priv->next_packet = rsv->next_packet;
 350
 351         netif_rx(skb);
 352
 353         return 0;
 354 }
 355
 356 static void encx24j600_rx_packets(struct encx24j600_priv *priv, u8 packet_count)
 357 {
 358         struct net_device *dev = priv->ndev;
 359
 360         while (packet_count--) {
 361                 struct rsv rsv;
 362                 u16 newrxtail;
 363
 364                 encx24j600_write_reg(priv, ERXRDPT, priv->next_packet);
 365                 encx24j600_raw_read(priv, RRXDATA, (u8 *)&rsv, sizeof(rsv));
 366
 367                 if (netif_msg_rx_status(priv))
 368                         encx24j600_dump_rsv(priv, __func__, &rsv);
 369
 370                 if (!RSV_GETBIT(rsv.rxstat, RSV_RXOK) ||
 371                     (rsv.len > MAX_FRAMELEN)) {
 372                         netif_err(priv, rx_err, dev, "RX Error %04x\n",
 373                                   rsv.rxstat);
 374                         dev->stats.rx_errors++;
 375
 376                         if (RSV_GETBIT(rsv.rxstat, RSV_CRCERROR))
 377                                 dev->stats.rx_crc_errors++;
 378                         if (RSV_GETBIT(rsv.rxstat, RSV_LENCHECKERR))
 379                                 dev->stats.rx_frame_errors++;
 380                         if (rsv.len > MAX_FRAMELEN)
 381                                 dev->stats.rx_over_errors++;
 382                 } else {
 383                         encx24j600_receive_packet(priv, &rsv);
 384                 }
 385
 386                 newrxtail = priv->next_packet - 2;
 387                 if (newrxtail == ENC_RX_BUF_START)
 388                         newrxtail = SRAM_SIZE - 2;
 389
 390                 encx24j600_cmd(priv, SETPKTDEC);
 391                 encx24j600_write_reg(priv, ERXTAIL, newrxtail);
 392         }
 393 }
 394
 395 static irqreturn_t encx24j600_isr(int irq, void *dev_id)
 396 {
 397         struct encx24j600_priv *priv = dev_id;
 398         struct net_device *dev = priv->ndev;
 399         int eir;
 400
 401         /* Clear interrupts */
 402         encx24j600_cmd(priv, CLREIE);
 403
 404         eir = encx24j600_read_reg(priv, EIR);
 405
 406         if (eir & LINKIF)
 407                 encx24j600_int_link_handler(priv);
 408
 409         if (eir & TXIF)
 410                 encx24j600_tx_complete(priv, false);
 411
 412         if (eir & TXABTIF)
 413                 encx24j600_tx_complete(priv, true);
 414
 415         if (eir & RXABTIF) {
 416                 if (eir & PCFULIF) {
 417                         /* Packet counter is full */
 418                         netif_err(priv, rx_err, dev, "Packet counter full\n");
 419                 }
 420                 dev->stats.rx_dropped++;
 421                 encx24j600_clr_bits(priv, EIR, RXABTIF);
 422         }
 423
 424         if (eir & PKTIF) {
 425                 u8 packet_count;
 426
 427                 mutex_lock(&priv->lock);
 428
 429                 packet_count = encx24j600_read_reg(priv, ESTAT) & 0xff;
 430                 while (packet_count) {
 431                         encx24j600_rx_packets(priv, packet_count);
 432                         packet_count = encx24j600_read_reg(priv, ESTAT) & 0xff;
 433                 }
 434
 435                 mutex_unlock(&priv->lock);
 436         }
 437
 438         /* Enable interrupts */
 439         encx24j600_cmd(priv, SETEIE);
 440
 441         return IRQ_HANDLED;
 442 }
 443
 444 static int encx24j600_soft_reset(struct encx24j600_priv *priv)
 445 {
 446         int ret = 0;
 447         int timeout;
 448         u16 eudast;
 449
 450         /* Write and verify a test value to EUDAST */
 451         regcache_cache_bypass(priv->ctx.regmap, true);
 452         timeout = 10;
 453         do {
 454                 encx24j600_write_reg(priv, EUDAST, EUDAST_TEST_VAL);
 455                 eudast = encx24j600_read_reg(priv, EUDAST);
 456                 usleep_range(25, 100);
 457         } while ((eudast != EUDAST_TEST_VAL) && --timeout);
 458         regcache_cache_bypass(priv->ctx.regmap, false);
 459
 460         if (timeout == 0) {
 461                 ret = -ETIMEDOUT;
 462                 goto err_out;
 463         }
 464
 465         /* Wait for CLKRDY to become set */
 466         timeout = 10;
 467         while (!(encx24j600_read_reg(priv, ESTAT) & CLKRDY) && --timeout)
 468                 usleep_range(25, 100);
 469
 470         if (timeout == 0) {
 471                 ret = -ETIMEDOUT;
 472                 goto err_out;
 473         }
 474
 475         /* Issue a System Reset command */
 476         encx24j600_cmd(priv, SETETHRST);
 477         usleep_range(25, 100);
 478
 479         /* Confirm that EUDAST has 0000h after system reset */
 480         if (encx24j600_read_reg(priv, EUDAST) != 0) {
 481                 ret = -EINVAL;
 482                 goto err_out;
 483         }
 484
 485         /* Wait for PHY register and status bits to become available */
 486         usleep_range(256, 1000);
 487
 488 err_out:
 489         return ret;
 490 }
 491
 492 static int encx24j600_hw_reset(struct encx24j600_priv *priv)
 493 {
 494         int ret;
 495
 496         mutex_lock(&priv->lock);
 497         ret = encx24j600_soft_reset(priv);
 498         mutex_unlock(&priv->lock);
 499
 500         return ret;
 501 }
 502
 503 static void encx24j600_reset_hw_tx(struct encx24j600_priv *priv)
 504 {
 505         encx24j600_set_bits(priv, ECON2, TXRST);
 506         encx24j600_clr_bits(priv, ECON2, TXRST);
 507 }
 508
 509 static void encx24j600_hw_init_tx(struct encx24j600_priv *priv)
 510 {
 511         /* Reset TX */
 512         encx24j600_reset_hw_tx(priv);
 513
 514         /* Clear the TXIF flag if were previously set */
 515         encx24j600_clr_bits(priv, EIR, TXIF | TXABTIF);
 516
 517         /* Write the Tx Buffer pointer */
 518         encx24j600_write_reg(priv, EGPWRPT, ENC_TX_BUF_START);
 519 }
 520
 521 static void encx24j600_hw_init_rx(struct encx24j600_priv *priv)
 522 {
 523         encx24j600_cmd(priv, DISABLERX);
 524
 525         /* Set up RX packet start address in the SRAM */
 526         encx24j600_write_reg(priv, ERXST, ENC_RX_BUF_START);
 527
 528         /* Preload the RX Data pointer to the beginning of the RX area */
 529         encx24j600_write_reg(priv, ERXRDPT, ENC_RX_BUF_START);
 530
 531         priv->next_packet = ENC_RX_BUF_START;
 532
 533         /* Set up RX end address in the SRAM */
 534         encx24j600_write_reg(priv, ERXTAIL, ENC_SRAM_SIZE - 2);
 535
 536         /* Reset the  user data pointers    */
 537         encx24j600_write_reg(priv, EUDAST, ENC_SRAM_SIZE);
 538         encx24j600_write_reg(priv, EUDAND, ENC_SRAM_SIZE + 1);
 539
 540         /* Set Max Frame length */
 541         encx24j600_write_reg(priv, MAMXFL, MAX_FRAMELEN);
 542 }
 543
 544 static void encx24j600_dump_config(struct encx24j600_priv *priv,
 545                                    const char *msg)
 546 {
 547         pr_info(DRV_NAME ": %s\n", msg);
 548
 549         /* CHIP configuration */
 550         pr_info(DRV_NAME " ECON1:   %04X\n", encx24j600_read_reg(priv, ECON1));
 551         pr_info(DRV_NAME " ECON2:   %04X\n", encx24j600_read_reg(priv, ECON2));
 552         pr_info(DRV_NAME " ERXFCON: %04X\n", encx24j600_read_reg(priv,
 553                                                                  ERXFCON));
 554         pr_info(DRV_NAME " ESTAT:   %04X\n", encx24j600_read_reg(priv, ESTAT));
 555         pr_info(DRV_NAME " EIR:     %04X\n", encx24j600_read_reg(priv, EIR));
 556         pr_info(DRV_NAME " EIDLED:  %04X\n", encx24j600_read_reg(priv, EIDLED));
 557
 558         /* MAC layer configuration */
 559         pr_info(DRV_NAME " MACON1:  %04X\n", encx24j600_read_reg(priv, MACON1));
 560         pr_info(DRV_NAME " MACON2:  %04X\n", encx24j600_read_reg(priv, MACON2));
 561         pr_info(DRV_NAME " MAIPG:   %04X\n", encx24j600_read_reg(priv, MAIPG));
 562         pr_info(DRV_NAME " MACLCON: %04X\n", encx24j600_read_reg(priv,
 563                                                                  MACLCON));
 564         pr_info(DRV_NAME " MABBIPG: %04X\n", encx24j600_read_reg(priv,
 565                                                                  MABBIPG));
 566
 567         /* PHY configuation */
 568         pr_info(DRV_NAME " PHCON1:  %04X\n", encx24j600_read_phy(priv, PHCON1));
 569         pr_info(DRV_NAME " PHCON2:  %04X\n", encx24j600_read_phy(priv, PHCON2));
 570         pr_info(DRV_NAME " PHANA:   %04X\n", encx24j600_read_phy(priv, PHANA));
 571         pr_info(DRV_NAME " PHANLPA: %04X\n", encx24j600_read_phy(priv,
 572                                                                  PHANLPA));
 573         pr_info(DRV_NAME " PHANE:   %04X\n", encx24j600_read_phy(priv, PHANE));
 574         pr_info(DRV_NAME " PHSTAT1: %04X\n", encx24j600_read_phy(priv,
 575                                                                  PHSTAT1));
 576         pr_info(DRV_NAME " PHSTAT2: %04X\n", encx24j600_read_phy(priv,
 577                                                                  PHSTAT2));
 578         pr_info(DRV_NAME " PHSTAT3: %04X\n", encx24j600_read_phy(priv,
 579                                                                  PHSTAT3));
 580 }
 581
 582 static void encx24j600_set_rxfilter_mode(struct encx24j600_priv *priv)
 583 {
 584         switch (priv->rxfilter) {
 585         case RXFILTER_PROMISC:
 586                 encx24j600_set_bits(priv, MACON1, PASSALL);
 587                 encx24j600_write_reg(priv, ERXFCON, UCEN | MCEN | NOTMEEN);
 588                 break;
 589         case RXFILTER_MULTI:
 590                 encx24j600_clr_bits(priv, MACON1, PASSALL);
 591                 encx24j600_write_reg(priv, ERXFCON, UCEN | CRCEN | BCEN | MCEN);
 592                 break;
 593         case RXFILTER_NORMAL:
 594         default:
 595                 encx24j600_clr_bits(priv, MACON1, PASSALL);
 596                 encx24j600_write_reg(priv, ERXFCON, UCEN | CRCEN | BCEN);
 597                 break;
 598         }
 599 }
 600
 601 static int encx24j600_hw_init(struct encx24j600_priv *priv)
 602 {
 603         int ret = 0;
 604         u16 macon2;
 605
 606         priv->hw_enabled = false;
 607
 608         /* PHY Leds: link status,
 609          * LEDA: Link State + collision events
 610          * LEDB: Link State + transmit/receive events
 611          */
 612         encx24j600_update_reg(priv, EIDLED, 0xff00, 0xcb00);
 613
 614         /* Loopback disabled */
 615         encx24j600_write_reg(priv, MACON1, 0x9);
 616
 617         /* interpacket gap value */
 618         encx24j600_write_reg(priv, MAIPG, 0x0c12);
 619
 620         /* Write the auto negotiation pattern */
 621         encx24j600_write_phy(priv, PHANA, PHANA_DEFAULT);
 622
 623         encx24j600_update_phcon1(priv);
 624         encx24j600_check_link_status(priv);
 625
 626         macon2 = MACON2_RSV1 | TXCRCEN | PADCFG0 | PADCFG2 | MACON2_DEFER;
 627         if ((priv->autoneg == AUTONEG_DISABLE) && priv->full_duplex)
 628                 macon2 |= FULDPX;
 629
 630         encx24j600_set_bits(priv, MACON2, macon2);
 631
 632         priv->rxfilter = RXFILTER_NORMAL;
 633         encx24j600_set_rxfilter_mode(priv);
 634
 635         /* Program the Maximum frame length */
 636         encx24j600_write_reg(priv, MAMXFL, MAX_FRAMELEN);
 637
 638         /* Init Tx pointers */
 639         encx24j600_hw_init_tx(priv);
 640
 641         /* Init Rx pointers */
 642         encx24j600_hw_init_rx(priv);
 643
 644         if (netif_msg_hw(priv))
 645                 encx24j600_dump_config(priv, "Hw is initialized");
 646
 647         return ret;
 648 }
 649
 650 static void encx24j600_hw_enable(struct encx24j600_priv *priv)
 651 {
 652         /* Clear the interrupt flags in case was set */
 653         encx24j600_clr_bits(priv, EIR, (PCFULIF | RXABTIF | TXABTIF | TXIF |
 654                                         PKTIF | LINKIF));
 655
 656         /* Enable the interrupts */
 657         encx24j600_write_reg(priv, EIE, (PCFULIE | RXABTIE | TXABTIE | TXIE |
 658                                          PKTIE | LINKIE | INTIE));
 659
 660         /* Enable RX */
 661         encx24j600_cmd(priv, ENABLERX);
 662
 663         priv->hw_enabled = true;
 664 }
 665
 666 static void encx24j600_hw_disable(struct encx24j600_priv *priv)
 667 {
 668         /* Disable all interrupts */
 669         encx24j600_write_reg(priv, EIE, 0);
 670
 671         /* Disable RX */
 672         encx24j600_cmd(priv, DISABLERX);
 673
 674         priv->hw_enabled = false;
 675 }
 676
 677 static int encx24j600_setlink(struct net_device *dev, u8 autoneg, u16 speed,
 678                               u8 duplex)
 679 {
 680         struct encx24j600_priv *priv = netdev_priv(dev);
 681         int ret = 0;
 682
 683         if (!priv->hw_enabled) {
 684                 /* link is in low power mode now; duplex setting
 685                  * will take effect on next encx24j600_hw_init()
 686                  */
 687                 if (speed == SPEED_10 || speed == SPEED_100) {
 688                         priv->autoneg = (autoneg == AUTONEG_ENABLE);
 689                         priv->full_duplex = (duplex == DUPLEX_FULL);
 690                         priv->speed = (speed == SPEED_100);
 691                 } else {
 692                         netif_warn(priv, link, dev, "unsupported link speed setting\n");
 693                         /*speeds other than SPEED_10 and SPEED_100 */
 694                         /*are not supported by chip */
 695                         ret = -EOPNOTSUPP;
 696                 }
 697         } else {
 698                 netif_warn(priv, link, dev, "Warning: hw must be disabled to set link mode\n");
 699                 ret = -EBUSY;
 700         }
 701         return ret;
 702 }
 703
 704 static void encx24j600_hw_get_macaddr(struct encx24j600_priv *priv,
 705                                       unsigned char *ethaddr)
 706 {
 707         unsigned short val;
 708
 709         val = encx24j600_read_reg(priv, MAADR1);
 710
 711         ethaddr[0] = val & 0x00ff;
 712         ethaddr[1] = (val & 0xff00) >> 8;
 713
 714         val = encx24j600_read_reg(priv, MAADR2);
 715
 716         ethaddr[2] = val & 0x00ffU;
 717         ethaddr[3] = (val & 0xff00U) >> 8;
 718
 719         val = encx24j600_read_reg(priv, MAADR3);
 720
 721         ethaddr[4] = val & 0x00ffU;
 722         ethaddr[5] = (val & 0xff00U) >> 8;
 723 }
 724
 725 /* Program the hardware MAC address from dev->dev_addr.*/
 726 static int encx24j600_set_hw_macaddr(struct net_device *dev)
 727 {
 728         struct encx24j600_priv *priv = netdev_priv(dev);
 729
 730         if (priv->hw_enabled) {
 731                 netif_info(priv, drv, dev, "Hardware must be disabled to set Mac address\n");
 732                 return -EBUSY;
 733         }
 734
 735         mutex_lock(&priv->lock);
 736
 737         netif_info(priv, drv, dev, "%s: Setting MAC address to %pM\n",
 738                    dev->name, dev->dev_addr);
 739
 740         encx24j600_write_reg(priv, MAADR3, (dev->dev_addr[4] |
 741                              dev->dev_addr[5] << 8));
 742         encx24j600_write_reg(priv, MAADR2, (dev->dev_addr[2] |
 743                              dev->dev_addr[3] << 8));
 744         encx24j600_write_reg(priv, MAADR1, (dev->dev_addr[0] |
 745                              dev->dev_addr[1] << 8));
 746
 747         mutex_unlock(&priv->lock);
 748
 749         return 0;
 750 }
 751
 752 /* Store the new hardware address in dev->dev_addr, and update the MAC.*/
 753 static int encx24j600_set_mac_address(struct net_device *dev, void *addr)
 754 {
 755         struct sockaddr *address = addr;
 756
 757         if (netif_running(dev))
 758                 return -EBUSY;
 759         if (!is_valid_ether_addr(address->sa_data))
 760                 return -EADDRNOTAVAIL;
 761
 762         memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
 763         return encx24j600_set_hw_macaddr(dev);
 764 }
 765
 766 static int encx24j600_open(struct net_device *dev)
 767 {
 768         struct encx24j600_priv *priv = netdev_priv(dev);
 769
 770         int ret = request_threaded_irq(priv->ctx.spi->irq, NULL, encx24j600_isr,
 771                                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 772                                        DRV_NAME, priv);
 773         if (unlikely(ret < 0)) {
 774                 netdev_err(dev, "request irq %d failed (ret = %d)\n",
 775                            priv->ctx.spi->irq, ret);
 776                 return ret;
 777         }
 778
 779         encx24j600_hw_disable(priv);
 780         encx24j600_hw_init(priv);
 781         encx24j600_hw_enable(priv);
 782         netif_start_queue(dev);
 783
 784         return 0;
 785 }
 786
 787 static int encx24j600_stop(struct net_device *dev)
 788 {
 789         struct encx24j600_priv *priv = netdev_priv(dev);
 790
 791         netif_stop_queue(dev);
 792         free_irq(priv->ctx.spi->irq, priv);
 793         return 0;
 794 }
 795
 796 static void encx24j600_setrx_proc(struct kthread_work *ws)
 797 {
 798         struct encx24j600_priv *priv =
 799                         container_of(ws, struct encx24j600_priv, setrx_work);
 800
 801         mutex_lock(&priv->lock);
 802         encx24j600_set_rxfilter_mode(priv);
 803         mutex_unlock(&priv->lock);
 804 }
 805
 806 static void encx24j600_set_multicast_list(struct net_device *dev)
 807 {
 808         struct encx24j600_priv *priv = netdev_priv(dev);
 809         int oldfilter = priv->rxfilter;
 810
 811         if (dev->flags & IFF_PROMISC) {
 812                 netif_dbg(priv, link, dev, "promiscuous mode\n");
 813                 priv->rxfilter = RXFILTER_PROMISC;
 814         } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
 815                 netif_dbg(priv, link, dev, "%smulticast mode\n",
 816                           (dev->flags & IFF_ALLMULTI) ? "all-" : "");
 817                 priv->rxfilter = RXFILTER_MULTI;
 818         } else {
 819                 netif_dbg(priv, link, dev, "normal mode\n");
 820                 priv->rxfilter = RXFILTER_NORMAL;
 821         }
 822
 823         if (oldfilter != priv->rxfilter)
 824                 kthread_queue_work(&priv->kworker, &priv->setrx_work);
 825 }
 826
 827 static void encx24j600_hw_tx(struct encx24j600_priv *priv)
 828 {
 829         struct net_device *dev = priv->ndev;
 830         netif_info(priv, tx_queued, dev, "TX Packet Len:%d\n",
 831                    priv->tx_skb->len);
 832
 833         if (netif_msg_pktdata(priv))
 834                 dump_packet("TX", priv->tx_skb->len, priv->tx_skb->data);
 835
 836         if (encx24j600_read_reg(priv, EIR) & TXABTIF)
 837                 /* Last transmition aborted due to error. Reset TX interface */
 838                 encx24j600_reset_hw_tx(priv);
 839
 840         /* Clear the TXIF flag if were previously set */
 841         encx24j600_clr_bits(priv, EIR, TXIF);
 842
 843         /* Set the data pointer to the TX buffer address in the SRAM */
 844         encx24j600_write_reg(priv, EGPWRPT, ENC_TX_BUF_START);
 845
 846         /* Copy the packet into the SRAM */
 847         encx24j600_raw_write(priv, WGPDATA, (u8 *)priv->tx_skb->data,
 848                              priv->tx_skb->len);
 849
 850         /* Program the Tx buffer start pointer */
 851         encx24j600_write_reg(priv, ETXST, ENC_TX_BUF_START);
 852
 853         /* Program the packet length */
 854         encx24j600_write_reg(priv, ETXLEN, priv->tx_skb->len);
 855
 856         /* Start the transmission */
 857         encx24j600_cmd(priv, SETTXRTS);
 858 }
 859
 860 static void encx24j600_tx_proc(struct kthread_work *ws)
 861 {
 862         struct encx24j600_priv *priv =
 863                         container_of(ws, struct encx24j600_priv, tx_work);
 864
 865         mutex_lock(&priv->lock);
 866         encx24j600_hw_tx(priv);
 867         mutex_unlock(&priv->lock);
 868 }
 869
 870 static netdev_tx_t encx24j600_tx(struct sk_buff *skb, struct net_device *dev)
 871 {
 872         struct encx24j600_priv *priv = netdev_priv(dev);
 873
 874         netif_stop_queue(dev);
 875
 876         /* save the timestamp */
 877         netif_trans_update(dev);
 878
 879         /* Remember the skb for deferred processing */
 880         priv->tx_skb = skb;
 881
 882         kthread_queue_work(&priv->kworker, &priv->tx_work);
 883
 884         return NETDEV_TX_OK;
 885 }
 886
 887 /* Deal with a transmit timeout */
 888 static void encx24j600_tx_timeout(struct net_device *dev)
 889 {
 890         struct encx24j600_priv *priv = netdev_priv(dev);
 891
 892         netif_err(priv, tx_err, dev, "TX timeout at %ld, latency %ld\n",
 893                   jiffies, jiffies - dev_trans_start(dev));
 894
 895         dev->stats.tx_errors++;
 896         netif_wake_queue(dev);
 897         return;
 898 }
 899
 900 static int encx24j600_get_regs_len(struct net_device *dev)
 901 {
 902         return SFR_REG_COUNT;
 903 }
 904
 905 static void encx24j600_get_regs(struct net_device *dev,
 906                                 struct ethtool_regs *regs, void *p)
 907 {
 908         struct encx24j600_priv *priv = netdev_priv(dev);
 909         u16 *buff = p;
 910         u8 reg;
 911
 912         regs->version = 1;
 913         mutex_lock(&priv->lock);
 914         for (reg = 0; reg < SFR_REG_COUNT; reg += 2) {
 915                 unsigned int val = 0;
 916                 /* ignore errors for unreadable registers */
 917                 regmap_read(priv->ctx.regmap, reg, &val);
 918                 buff[reg] = val & 0xffff;
 919         }
 920         mutex_unlock(&priv->lock);
 921 }
 922
 923 static void encx24j600_get_drvinfo(struct net_device *dev,
 924                                    struct ethtool_drvinfo *info)
 925 {
 926         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 927         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 928         strlcpy(info->bus_info, dev_name(dev->dev.parent),
 929                 sizeof(info->bus_info));
 930 }
 931
 932 static int encx24j600_get_settings(struct net_device *dev,
 933                                    struct ethtool_cmd *cmd)
 934 {
 935         struct encx24j600_priv *priv = netdev_priv(dev);
 936
 937         cmd->transceiver = XCVR_INTERNAL;
 938         cmd->supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
 939                          SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
 940                          SUPPORTED_Autoneg | SUPPORTED_TP;
 941
 942         ethtool_cmd_speed_set(cmd, priv->speed);
 943         cmd->duplex = priv->full_duplex ? DUPLEX_FULL : DUPLEX_HALF;
 944         cmd->port = PORT_TP;
 945         cmd->autoneg = priv->autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
 946
 947         return 0;
 948 }
 949
 950 static int encx24j600_set_settings(struct net_device *dev,
 951                                    struct ethtool_cmd *cmd)
 952 {
 953         return encx24j600_setlink(dev, cmd->autoneg,
 954                                   ethtool_cmd_speed(cmd), cmd->duplex);
 955 }
 956
 957 static u32 encx24j600_get_msglevel(struct net_device *dev)
 958 {
 959         struct encx24j600_priv *priv = netdev_priv(dev);
 960         return priv->msg_enable;
 961 }
 962
 963 static void encx24j600_set_msglevel(struct net_device *dev, u32 val)
 964 {
 965         struct encx24j600_priv *priv = netdev_priv(dev);
 966         priv->msg_enable = val;
 967 }
 968
 969 static const struct ethtool_ops encx24j600_ethtool_ops = {
 970         .get_settings = encx24j600_get_settings,
 971         .set_settings = encx24j600_set_settings,
 972         .get_drvinfo = encx24j600_get_drvinfo,
 973         .get_msglevel = encx24j600_get_msglevel,
 974         .set_msglevel = encx24j600_set_msglevel,
 975         .get_regs_len = encx24j600_get_regs_len,
 976         .get_regs = encx24j600_get_regs,
 977 };
 978
 979 static const struct net_device_ops encx24j600_netdev_ops = {
 980         .ndo_open = encx24j600_open,
 981         .ndo_stop = encx24j600_stop,
 982         .ndo_start_xmit = encx24j600_tx,
 983         .ndo_set_rx_mode = encx24j600_set_multicast_list,
 984         .ndo_set_mac_address = encx24j600_set_mac_address,
 985         .ndo_tx_timeout = encx24j600_tx_timeout,
 986         .ndo_validate_addr = eth_validate_addr,
 987 };
 988
 989 static int encx24j600_spi_probe(struct spi_device *spi)
 990 {
 991         int ret;
 992
 993         struct net_device *ndev;
 994         struct encx24j600_priv *priv;
 995         u16 eidled;
 996
 997         ndev = alloc_etherdev(sizeof(struct encx24j600_priv));
 998
 999         if (!ndev) {
1000                 ret = -ENOMEM;
1001                 goto error_out;
1002         }
1003
1004         priv = netdev_priv(ndev);
1005         spi_set_drvdata(spi, priv);
1006         dev_set_drvdata(&spi->dev, priv);
1007         SET_NETDEV_DEV(ndev, &spi->dev);
1008
1009         priv->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
1010         priv->ndev = ndev;
1011
1012         /* Default configuration PHY configuration */
1013         priv->full_duplex = true;
1014         priv->autoneg = AUTONEG_ENABLE;
1015         priv->speed = SPEED_100;
1016
1017         priv->ctx.spi = spi;
1018         devm_regmap_init_encx24j600(&spi->dev, &priv->ctx);
1019         ndev->irq = spi->irq;
1020         ndev->netdev_ops = &encx24j600_netdev_ops;
1021
1022         mutex_init(&priv->lock);
1023
1024         /* Reset device and check if it is connected */
1025         if (encx24j600_hw_reset(priv)) {
1026                 netif_err(priv, probe, ndev,
1027                           DRV_NAME ": Chip is not detected\n");
1028                 ret = -EIO;
1029                 goto out_free;
1030         }
1031
1032         /* Initialize the device HW to the consistent state */
1033         if (encx24j600_hw_init(priv)) {
1034                 netif_err(priv, probe, ndev,
1035                           DRV_NAME ": HW initialization error\n");
1036                 ret = -EIO;
1037                 goto out_free;
1038         }
1039
1040         kthread_init_worker(&priv->kworker);
1041         kthread_init_work(&priv->tx_work, encx24j600_tx_proc);
1042         kthread_init_work(&priv->setrx_work, encx24j600_setrx_proc);
1043
1044         priv->kworker_task = kthread_run(kthread_worker_fn, &priv->kworker,
1045                                          "encx24j600");
1046
1047         if (IS_ERR(priv->kworker_task)) {
1048                 ret = PTR_ERR(priv->kworker_task);
1049                 goto out_free;
1050         }
1051
1052         /* Get the MAC address from the chip */
1053         encx24j600_hw_get_macaddr(priv, ndev->dev_addr);
1054
1055         ndev->ethtool_ops = &encx24j600_ethtool_ops;
1056
1057         ret = register_netdev(ndev);
1058         if (unlikely(ret)) {
1059                 netif_err(priv, probe, ndev, "Error %d initializing card encx24j600 card\n",
1060                           ret);
1061                 goto out_free;
1062         }
1063
1064         eidled = encx24j600_read_reg(priv, EIDLED);
1065         if (((eidled & DEVID_MASK) >> DEVID_SHIFT) != ENCX24J600_DEV_ID) {
1066                 ret = -EINVAL;
1067                 goto out_unregister;
1068         }
1069
1070         netif_info(priv, probe, ndev, "Silicon rev ID: 0x%02x\n",
1071                    (eidled & REVID_MASK) >> REVID_SHIFT);
1072
1073         netif_info(priv, drv, priv->ndev, "MAC address %pM\n", ndev->dev_addr);
1074
1075         return ret;
1076
1077 out_unregister:
1078         unregister_netdev(priv->ndev);
1079 out_free:
1080         free_netdev(ndev);
1081
1082 error_out:
1083         return ret;
1084 }
1085
1086 static int encx24j600_spi_remove(struct spi_device *spi)
1087 {
1088         struct encx24j600_priv *priv = dev_get_drvdata(&spi->dev);
1089
1090         unregister_netdev(priv->ndev);
1091
1092         free_netdev(priv->ndev);
1093
1094         return 0;
1095 }
1096
1097 static const struct spi_device_id encx24j600_spi_id_table[] = {
1098         { .name = "encx24j600" },
1099         { /* sentinel */ }
1100 };
1101 MODULE_DEVICE_TABLE(spi, encx24j600_spi_id_table);
1102
1103 static struct spi_driver encx24j600_spi_net_driver = {
1104         .driver = {
1105                 .name   = DRV_NAME,
1106                 .owner  = THIS_MODULE,
1107                 .bus    = &spi_bus_type,
1108         },
1109         .probe          = encx24j600_spi_probe,
1110         .remove         = encx24j600_spi_remove,
1111         .id_table       = encx24j600_spi_id_table,
1112 };
1113
1114 static int __init encx24j600_init(void)
1115 {
1116         return spi_register_driver(&encx24j600_spi_net_driver);
1117 }
1118 module_init(encx24j600_init);
1119
1120 static void encx24j600_exit(void)
1121 {
1122         spi_unregister_driver(&encx24j600_spi_net_driver);
1123 }
1124 module_exit(encx24j600_exit);
1125
1126 MODULE_DESCRIPTION(DRV_NAME " ethernet driver");
1127 MODULE_AUTHOR("Jon Ringle <jringle@gridpoint.com>");
1128 MODULE_LICENSE("GPL");
1129 MODULE_ALIAS("spi:" DRV_NAME);