drivers/net/ethernet/nxp/lpc_eth.c

   1 /*
   2  * drivers/net/ethernet/nxp/lpc_eth.c
   3  *
   4  * Author: Kevin Wells <kevin.wells@nxp.com>
   5  *
   6  * Copyright (C) 2010 NXP Semiconductors
   7  * Copyright (C) 2012 Roland Stigge <stigge@antcom.de>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  */
  19
  20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22 #include <linux/module.h>
  23 #include <linux/kernel.h>
  24 #include <linux/sched.h>
  25 #include <linux/slab.h>
  26 #include <linux/delay.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/errno.h>
  29 #include <linux/ioport.h>
  30 #include <linux/crc32.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/ethtool.h>
  34 #include <linux/mii.h>
  35 #include <linux/clk.h>
  36 #include <linux/workqueue.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/etherdevice.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/phy.h>
  41 #include <linux/dma-mapping.h>
  42 #include <linux/of.h>
  43 #include <linux/of_net.h>
  44 #include <linux/types.h>
  45
  46 #include <linux/io.h>
  47 #include <mach/board.h>
  48 #include <mach/platform.h>
  49 #include <mach/hardware.h>
  50
  51 #define MODNAME "lpc-eth"
  52 #define DRV_VERSION "1.00"
  53
  54 #define ENET_MAXF_SIZE 1536
  55 #define ENET_RX_DESC 48
  56 #define ENET_TX_DESC 16
  57
  58 #define NAPI_WEIGHT 16
  59
  60 /*
  61  * Ethernet MAC controller Register offsets
  62  */
  63 #define LPC_ENET_MAC1(x)                        (x + 0x000)
  64 #define LPC_ENET_MAC2(x)                        (x + 0x004)
  65 #define LPC_ENET_IPGT(x)                        (x + 0x008)
  66 #define LPC_ENET_IPGR(x)                        (x + 0x00C)
  67 #define LPC_ENET_CLRT(x)                        (x + 0x010)
  68 #define LPC_ENET_MAXF(x)                        (x + 0x014)
  69 #define LPC_ENET_SUPP(x)                        (x + 0x018)
  70 #define LPC_ENET_TEST(x)                        (x + 0x01C)
  71 #define LPC_ENET_MCFG(x)                        (x + 0x020)
  72 #define LPC_ENET_MCMD(x)                        (x + 0x024)
  73 #define LPC_ENET_MADR(x)                        (x + 0x028)
  74 #define LPC_ENET_MWTD(x)                        (x + 0x02C)
  75 #define LPC_ENET_MRDD(x)                        (x + 0x030)
  76 #define LPC_ENET_MIND(x)                        (x + 0x034)
  77 #define LPC_ENET_SA0(x)                         (x + 0x040)
  78 #define LPC_ENET_SA1(x)                         (x + 0x044)
  79 #define LPC_ENET_SA2(x)                         (x + 0x048)
  80 #define LPC_ENET_COMMAND(x)                     (x + 0x100)
  81 #define LPC_ENET_STATUS(x)                      (x + 0x104)
  82 #define LPC_ENET_RXDESCRIPTOR(x)                (x + 0x108)
  83 #define LPC_ENET_RXSTATUS(x)                    (x + 0x10C)
  84 #define LPC_ENET_RXDESCRIPTORNUMBER(x)          (x + 0x110)
  85 #define LPC_ENET_RXPRODUCEINDEX(x)              (x + 0x114)
  86 #define LPC_ENET_RXCONSUMEINDEX(x)              (x + 0x118)
  87 #define LPC_ENET_TXDESCRIPTOR(x)                (x + 0x11C)
  88 #define LPC_ENET_TXSTATUS(x)                    (x + 0x120)
  89 #define LPC_ENET_TXDESCRIPTORNUMBER(x)          (x + 0x124)
  90 #define LPC_ENET_TXPRODUCEINDEX(x)              (x + 0x128)
  91 #define LPC_ENET_TXCONSUMEINDEX(x)              (x + 0x12C)
  92 #define LPC_ENET_TSV0(x)                        (x + 0x158)
  93 #define LPC_ENET_TSV1(x)                        (x + 0x15C)
  94 #define LPC_ENET_RSV(x)                         (x + 0x160)
  95 #define LPC_ENET_FLOWCONTROLCOUNTER(x)          (x + 0x170)
  96 #define LPC_ENET_FLOWCONTROLSTATUS(x)           (x + 0x174)
  97 #define LPC_ENET_RXFILTER_CTRL(x)               (x + 0x200)
  98 #define LPC_ENET_RXFILTERWOLSTATUS(x)           (x + 0x204)
  99 #define LPC_ENET_RXFILTERWOLCLEAR(x)            (x + 0x208)
 100 #define LPC_ENET_HASHFILTERL(x)                 (x + 0x210)
 101 #define LPC_ENET_HASHFILTERH(x)                 (x + 0x214)
 102 #define LPC_ENET_INTSTATUS(x)                   (x + 0xFE0)
 103 #define LPC_ENET_INTENABLE(x)                   (x + 0xFE4)
 104 #define LPC_ENET_INTCLEAR(x)                    (x + 0xFE8)
 105 #define LPC_ENET_INTSET(x)                      (x + 0xFEC)
 106 #define LPC_ENET_POWERDOWN(x)                   (x + 0xFF4)
 107
 108 /*
 109  * mac1 register definitions
 110  */
 111 #define LPC_MAC1_RECV_ENABLE                    (1 << 0)
 112 #define LPC_MAC1_PASS_ALL_RX_FRAMES             (1 << 1)
 113 #define LPC_MAC1_RX_FLOW_CONTROL                (1 << 2)
 114 #define LPC_MAC1_TX_FLOW_CONTROL                (1 << 3)
 115 #define LPC_MAC1_LOOPBACK                       (1 << 4)
 116 #define LPC_MAC1_RESET_TX                       (1 << 8)
 117 #define LPC_MAC1_RESET_MCS_TX                   (1 << 9)
 118 #define LPC_MAC1_RESET_RX                       (1 << 10)
 119 #define LPC_MAC1_RESET_MCS_RX                   (1 << 11)
 120 #define LPC_MAC1_SIMULATION_RESET               (1 << 14)
 121 #define LPC_MAC1_SOFT_RESET                     (1 << 15)
 122
 123 /*
 124  * mac2 register definitions
 125  */
 126 #define LPC_MAC2_FULL_DUPLEX                    (1 << 0)
 127 #define LPC_MAC2_FRAME_LENGTH_CHECKING          (1 << 1)
 128 #define LPC_MAC2_HUGH_LENGTH_CHECKING           (1 << 2)
 129 #define LPC_MAC2_DELAYED_CRC                    (1 << 3)
 130 #define LPC_MAC2_CRC_ENABLE                     (1 << 4)
 131 #define LPC_MAC2_PAD_CRC_ENABLE                 (1 << 5)
 132 #define LPC_MAC2_VLAN_PAD_ENABLE                (1 << 6)
 133 #define LPC_MAC2_AUTO_DETECT_PAD_ENABLE         (1 << 7)
 134 #define LPC_MAC2_PURE_PREAMBLE_ENFORCEMENT      (1 << 8)
 135 #define LPC_MAC2_LONG_PREAMBLE_ENFORCEMENT      (1 << 9)
 136 #define LPC_MAC2_NO_BACKOFF                     (1 << 12)
 137 #define LPC_MAC2_BACK_PRESSURE                  (1 << 13)
 138 #define LPC_MAC2_EXCESS_DEFER                   (1 << 14)
 139
 140 /*
 141  * ipgt register definitions
 142  */
 143 #define LPC_IPGT_LOAD(n)                        ((n) & 0x7F)
 144
 145 /*
 146  * ipgr register definitions
 147  */
 148 #define LPC_IPGR_LOAD_PART2(n)                  ((n) & 0x7F)
 149 #define LPC_IPGR_LOAD_PART1(n)                  (((n) & 0x7F) << 8)
 150
 151 /*
 152  * clrt register definitions
 153  */
 154 #define LPC_CLRT_LOAD_RETRY_MAX(n)              ((n) & 0xF)
 155 #define LPC_CLRT_LOAD_COLLISION_WINDOW(n)       (((n) & 0x3F) << 8)
 156
 157 /*
 158  * maxf register definitions
 159  */
 160 #define LPC_MAXF_LOAD_MAX_FRAME_LEN(n)          ((n) & 0xFFFF)
 161
 162 /*
 163  * supp register definitions
 164  */
 165 #define LPC_SUPP_SPEED                          (1 << 8)
 166 #define LPC_SUPP_RESET_RMII                     (1 << 11)
 167
 168 /*
 169  * test register definitions
 170  */
 171 #define LPC_TEST_SHORTCUT_PAUSE_QUANTA          (1 << 0)
 172 #define LPC_TEST_PAUSE                          (1 << 1)
 173 #define LPC_TEST_BACKPRESSURE                   (1 << 2)
 174
 175 /*
 176  * mcfg register definitions
 177  */
 178 #define LPC_MCFG_SCAN_INCREMENT                 (1 << 0)
 179 #define LPC_MCFG_SUPPRESS_PREAMBLE              (1 << 1)
 180 #define LPC_MCFG_CLOCK_SELECT(n)                (((n) & 0x7) << 2)
 181 #define LPC_MCFG_CLOCK_HOST_DIV_4               0
 182 #define LPC_MCFG_CLOCK_HOST_DIV_6               2
 183 #define LPC_MCFG_CLOCK_HOST_DIV_8               3
 184 #define LPC_MCFG_CLOCK_HOST_DIV_10              4
 185 #define LPC_MCFG_CLOCK_HOST_DIV_14              5
 186 #define LPC_MCFG_CLOCK_HOST_DIV_20              6
 187 #define LPC_MCFG_CLOCK_HOST_DIV_28              7
 188 #define LPC_MCFG_RESET_MII_MGMT                 (1 << 15)
 189
 190 /*
 191  * mcmd register definitions
 192  */
 193 #define LPC_MCMD_READ                           (1 << 0)
 194 #define LPC_MCMD_SCAN                           (1 << 1)
 195
 196 /*
 197  * madr register definitions
 198  */
 199 #define LPC_MADR_REGISTER_ADDRESS(n)            ((n) & 0x1F)
 200 #define LPC_MADR_PHY_0ADDRESS(n)                (((n) & 0x1F) << 8)
 201
 202 /*
 203  * mwtd register definitions
 204  */
 205 #define LPC_MWDT_WRITE(n)                       ((n) & 0xFFFF)
 206
 207 /*
 208  * mrdd register definitions
 209  */
 210 #define LPC_MRDD_READ_MASK                      0xFFFF
 211
 212 /*
 213  * mind register definitions
 214  */
 215 #define LPC_MIND_BUSY                           (1 << 0)
 216 #define LPC_MIND_SCANNING                       (1 << 1)
 217 #define LPC_MIND_NOT_VALID                      (1 << 2)
 218 #define LPC_MIND_MII_LINK_FAIL                  (1 << 3)
 219
 220 /*
 221  * command register definitions
 222  */
 223 #define LPC_COMMAND_RXENABLE                    (1 << 0)
 224 #define LPC_COMMAND_TXENABLE                    (1 << 1)
 225 #define LPC_COMMAND_REG_RESET                   (1 << 3)
 226 #define LPC_COMMAND_TXRESET                     (1 << 4)
 227 #define LPC_COMMAND_RXRESET                     (1 << 5)
 228 #define LPC_COMMAND_PASSRUNTFRAME               (1 << 6)
 229 #define LPC_COMMAND_PASSRXFILTER                (1 << 7)
 230 #define LPC_COMMAND_TXFLOWCONTROL               (1 << 8)
 231 #define LPC_COMMAND_RMII                        (1 << 9)
 232 #define LPC_COMMAND_FULLDUPLEX                  (1 << 10)
 233
 234 /*
 235  * status register definitions
 236  */
 237 #define LPC_STATUS_RXACTIVE                     (1 << 0)
 238 #define LPC_STATUS_TXACTIVE                     (1 << 1)
 239
 240 /*
 241  * tsv0 register definitions
 242  */
 243 #define LPC_TSV0_CRC_ERROR                      (1 << 0)
 244 #define LPC_TSV0_LENGTH_CHECK_ERROR             (1 << 1)
 245 #define LPC_TSV0_LENGTH_OUT_OF_RANGE            (1 << 2)
 246 #define LPC_TSV0_DONE                           (1 << 3)
 247 #define LPC_TSV0_MULTICAST                      (1 << 4)
 248 #define LPC_TSV0_BROADCAST                      (1 << 5)
 249 #define LPC_TSV0_PACKET_DEFER                   (1 << 6)
 250 #define LPC_TSV0_ESCESSIVE_DEFER                (1 << 7)
 251 #define LPC_TSV0_ESCESSIVE_COLLISION            (1 << 8)
 252 #define LPC_TSV0_LATE_COLLISION                 (1 << 9)
 253 #define LPC_TSV0_GIANT                          (1 << 10)
 254 #define LPC_TSV0_UNDERRUN                       (1 << 11)
 255 #define LPC_TSV0_TOTAL_BYTES(n)                 (((n) >> 12) & 0xFFFF)
 256 #define LPC_TSV0_CONTROL_FRAME                  (1 << 28)
 257 #define LPC_TSV0_PAUSE                          (1 << 29)
 258 #define LPC_TSV0_BACKPRESSURE                   (1 << 30)
 259 #define LPC_TSV0_VLAN                           (1 << 31)
 260
 261 /*
 262  * tsv1 register definitions
 263  */
 264 #define LPC_TSV1_TRANSMIT_BYTE_COUNT(n)         ((n) & 0xFFFF)
 265 #define LPC_TSV1_COLLISION_COUNT(n)             (((n) >> 16) & 0xF)
 266
 267 /*
 268  * rsv register definitions
 269  */
 270 #define LPC_RSV_RECEIVED_BYTE_COUNT(n)          ((n) & 0xFFFF)
 271 #define LPC_RSV_RXDV_EVENT_IGNORED              (1 << 16)
 272 #define LPC_RSV_RXDV_EVENT_PREVIOUSLY_SEEN      (1 << 17)
 273 #define LPC_RSV_CARRIER_EVNT_PREVIOUS_SEEN      (1 << 18)
 274 #define LPC_RSV_RECEIVE_CODE_VIOLATION          (1 << 19)
 275 #define LPC_RSV_CRC_ERROR                       (1 << 20)
 276 #define LPC_RSV_LENGTH_CHECK_ERROR              (1 << 21)
 277 #define LPC_RSV_LENGTH_OUT_OF_RANGE             (1 << 22)
 278 #define LPC_RSV_RECEIVE_OK                      (1 << 23)
 279 #define LPC_RSV_MULTICAST                       (1 << 24)
 280 #define LPC_RSV_BROADCAST                       (1 << 25)
 281 #define LPC_RSV_DRIBBLE_NIBBLE                  (1 << 26)
 282 #define LPC_RSV_CONTROL_FRAME                   (1 << 27)
 283 #define LPC_RSV_PAUSE                           (1 << 28)
 284 #define LPC_RSV_UNSUPPORTED_OPCODE              (1 << 29)
 285 #define LPC_RSV_VLAN                            (1 << 30)
 286
 287 /*
 288  * flowcontrolcounter register definitions
 289  */
 290 #define LPC_FCCR_MIRRORCOUNTER(n)               ((n) & 0xFFFF)
 291 #define LPC_FCCR_PAUSETIMER(n)                  (((n) >> 16) & 0xFFFF)
 292
 293 /*
 294  * flowcontrolstatus register definitions
 295  */
 296 #define LPC_FCCR_MIRRORCOUNTERCURRENT(n)        ((n) & 0xFFFF)
 297
 298 /*
 299  * rxfliterctrl, rxfilterwolstatus, and rxfilterwolclear shared
 300  * register definitions
 301  */
 302 #define LPC_RXFLTRW_ACCEPTUNICAST               (1 << 0)
 303 #define LPC_RXFLTRW_ACCEPTUBROADCAST            (1 << 1)
 304 #define LPC_RXFLTRW_ACCEPTUMULTICAST            (1 << 2)
 305 #define LPC_RXFLTRW_ACCEPTUNICASTHASH           (1 << 3)
 306 #define LPC_RXFLTRW_ACCEPTUMULTICASTHASH        (1 << 4)
 307 #define LPC_RXFLTRW_ACCEPTPERFECT               (1 << 5)
 308
 309 /*
 310  * rxfliterctrl register definitions
 311  */
 312 #define LPC_RXFLTRWSTS_MAGICPACKETENWOL         (1 << 12)
 313 #define LPC_RXFLTRWSTS_RXFILTERENWOL            (1 << 13)
 314
 315 /*
 316  * rxfilterwolstatus/rxfilterwolclear register definitions
 317  */
 318 #define LPC_RXFLTRWSTS_RXFILTERWOL              (1 << 7)
 319 #define LPC_RXFLTRWSTS_MAGICPACKETWOL           (1 << 8)
 320
 321 /*
 322  * intstatus, intenable, intclear, and Intset shared register
 323  * definitions
 324  */
 325 #define LPC_MACINT_RXOVERRUNINTEN               (1 << 0)
 326 #define LPC_MACINT_RXERRORONINT                 (1 << 1)
 327 #define LPC_MACINT_RXFINISHEDINTEN              (1 << 2)
 328 #define LPC_MACINT_RXDONEINTEN                  (1 << 3)
 329 #define LPC_MACINT_TXUNDERRUNINTEN              (1 << 4)
 330 #define LPC_MACINT_TXERRORINTEN                 (1 << 5)
 331 #define LPC_MACINT_TXFINISHEDINTEN              (1 << 6)
 332 #define LPC_MACINT_TXDONEINTEN                  (1 << 7)
 333 #define LPC_MACINT_SOFTINTEN                    (1 << 12)
 334 #define LPC_MACINT_WAKEUPINTEN                  (1 << 13)
 335
 336 /*
 337  * powerdown register definitions
 338  */
 339 #define LPC_POWERDOWN_MACAHB                    (1 << 31)
 340
 341 static phy_interface_t lpc_phy_interface_mode(struct device *dev)
 342 {
 343         if (dev && dev->of_node) {
 344                 const char *mode = of_get_property(dev->of_node,
 345                                                    "phy-mode", NULL);
 346                 if (mode && !strcmp(mode, "mii"))
 347                         return PHY_INTERFACE_MODE_MII;
 348         }
 349         return PHY_INTERFACE_MODE_RMII;
 350 }
 351
 352 static bool use_iram_for_net(struct device *dev)
 353 {
 354         if (dev && dev->of_node)
 355                 return of_property_read_bool(dev->of_node, "use-iram");
 356         return false;
 357 }
 358
 359 /* Receive Status information word */
 360 #define RXSTATUS_SIZE                   0x000007FF
 361 #define RXSTATUS_CONTROL                (1 << 18)
 362 #define RXSTATUS_VLAN                   (1 << 19)
 363 #define RXSTATUS_FILTER                 (1 << 20)
 364 #define RXSTATUS_MULTICAST              (1 << 21)
 365 #define RXSTATUS_BROADCAST              (1 << 22)
 366 #define RXSTATUS_CRC                    (1 << 23)
 367 #define RXSTATUS_SYMBOL                 (1 << 24)
 368 #define RXSTATUS_LENGTH                 (1 << 25)
 369 #define RXSTATUS_RANGE                  (1 << 26)
 370 #define RXSTATUS_ALIGN                  (1 << 27)
 371 #define RXSTATUS_OVERRUN                (1 << 28)
 372 #define RXSTATUS_NODESC                 (1 << 29)
 373 #define RXSTATUS_LAST                   (1 << 30)
 374 #define RXSTATUS_ERROR                  (1 << 31)
 375
 376 #define RXSTATUS_STATUS_ERROR \
 377         (RXSTATUS_NODESC | RXSTATUS_OVERRUN | RXSTATUS_ALIGN | \
 378          RXSTATUS_RANGE | RXSTATUS_LENGTH | RXSTATUS_SYMBOL | RXSTATUS_CRC)
 379
 380 /* Receive Descriptor control word */
 381 #define RXDESC_CONTROL_SIZE             0x000007FF
 382 #define RXDESC_CONTROL_INT              (1 << 31)
 383
 384 /* Transmit Status information word */
 385 #define TXSTATUS_COLLISIONS_GET(x)      (((x) >> 21) & 0xF)
 386 #define TXSTATUS_DEFER                  (1 << 25)
 387 #define TXSTATUS_EXCESSDEFER            (1 << 26)
 388 #define TXSTATUS_EXCESSCOLL             (1 << 27)
 389 #define TXSTATUS_LATECOLL               (1 << 28)
 390 #define TXSTATUS_UNDERRUN               (1 << 29)
 391 #define TXSTATUS_NODESC                 (1 << 30)
 392 #define TXSTATUS_ERROR                  (1 << 31)
 393
 394 /* Transmit Descriptor control word */
 395 #define TXDESC_CONTROL_SIZE             0x000007FF
 396 #define TXDESC_CONTROL_OVERRIDE         (1 << 26)
 397 #define TXDESC_CONTROL_HUGE             (1 << 27)
 398 #define TXDESC_CONTROL_PAD              (1 << 28)
 399 #define TXDESC_CONTROL_CRC              (1 << 29)
 400 #define TXDESC_CONTROL_LAST             (1 << 30)
 401 #define TXDESC_CONTROL_INT              (1 << 31)
 402
 403 /*
 404  * Structure of a TX/RX descriptors and RX status
 405  */
 406 struct txrx_desc_t {
 407         __le32 packet;
 408         __le32 control;
 409 };
 410 struct rx_status_t {
 411         __le32 statusinfo;
 412         __le32 statushashcrc;
 413 };
 414
 415 /*
 416  * Device driver data structure
 417  */
 418 struct netdata_local {
 419         struct platform_device  *pdev;
 420         struct net_device       *ndev;
 421         spinlock_t              lock;
 422         void __iomem            *net_base;
 423         u32                     msg_enable;
 424         unsigned int            skblen[ENET_TX_DESC];
 425         unsigned int            last_tx_idx;
 426         unsigned int            num_used_tx_buffs;
 427         struct mii_bus          *mii_bus;
 428         struct clk              *clk;
 429         dma_addr_t              dma_buff_base_p;
 430         void                    *dma_buff_base_v;
 431         size_t                  dma_buff_size;
 432         struct txrx_desc_t      *tx_desc_v;
 433         u32                     *tx_stat_v;
 434         void                    *tx_buff_v;
 435         struct txrx_desc_t      *rx_desc_v;
 436         struct rx_status_t      *rx_stat_v;
 437         void                    *rx_buff_v;
 438         int                     link;
 439         int                     speed;
 440         int                     duplex;
 441         struct napi_struct      napi;
 442 };
 443
 444 /*
 445  * MAC support functions
 446  */
 447 static void __lpc_set_mac(struct netdata_local *pldat, u8 *mac)
 448 {
 449         u32 tmp;
 450
 451         /* Set station address */
 452         tmp = mac[0] | ((u32)mac[1] << 8);
 453         writel(tmp, LPC_ENET_SA2(pldat->net_base));
 454         tmp = mac[2] | ((u32)mac[3] << 8);
 455         writel(tmp, LPC_ENET_SA1(pldat->net_base));
 456         tmp = mac[4] | ((u32)mac[5] << 8);
 457         writel(tmp, LPC_ENET_SA0(pldat->net_base));
 458
 459         netdev_dbg(pldat->ndev, "Ethernet MAC address %pM\n", mac);
 460 }
 461
 462 static void __lpc_get_mac(struct netdata_local *pldat, u8 *mac)
 463 {
 464         u32 tmp;
 465
 466         /* Get station address */
 467         tmp = readl(LPC_ENET_SA2(pldat->net_base));
 468         mac[0] = tmp & 0xFF;
 469         mac[1] = tmp >> 8;
 470         tmp = readl(LPC_ENET_SA1(pldat->net_base));
 471         mac[2] = tmp & 0xFF;
 472         mac[3] = tmp >> 8;
 473         tmp = readl(LPC_ENET_SA0(pldat->net_base));
 474         mac[4] = tmp & 0xFF;
 475         mac[5] = tmp >> 8;
 476 }
 477
 478 static void __lpc_eth_clock_enable(struct netdata_local *pldat, bool enable)
 479 {
 480         if (enable)
 481                 clk_prepare_enable(pldat->clk);
 482         else
 483                 clk_disable_unprepare(pldat->clk);
 484 }
 485
 486 static void __lpc_params_setup(struct netdata_local *pldat)
 487 {
 488         u32 tmp;
 489
 490         if (pldat->duplex == DUPLEX_FULL) {
 491                 tmp = readl(LPC_ENET_MAC2(pldat->net_base));
 492                 tmp |= LPC_MAC2_FULL_DUPLEX;
 493                 writel(tmp, LPC_ENET_MAC2(pldat->net_base));
 494                 tmp = readl(LPC_ENET_COMMAND(pldat->net_base));
 495                 tmp |= LPC_COMMAND_FULLDUPLEX;
 496                 writel(tmp, LPC_ENET_COMMAND(pldat->net_base));
 497                 writel(LPC_IPGT_LOAD(0x15), LPC_ENET_IPGT(pldat->net_base));
 498         } else {
 499                 tmp = readl(LPC_ENET_MAC2(pldat->net_base));
 500                 tmp &= ~LPC_MAC2_FULL_DUPLEX;
 501                 writel(tmp, LPC_ENET_MAC2(pldat->net_base));
 502                 tmp = readl(LPC_ENET_COMMAND(pldat->net_base));
 503                 tmp &= ~LPC_COMMAND_FULLDUPLEX;
 504                 writel(tmp, LPC_ENET_COMMAND(pldat->net_base));
 505                 writel(LPC_IPGT_LOAD(0x12), LPC_ENET_IPGT(pldat->net_base));
 506         }
 507
 508         if (pldat->speed == SPEED_100)
 509                 writel(LPC_SUPP_SPEED, LPC_ENET_SUPP(pldat->net_base));
 510         else
 511                 writel(0, LPC_ENET_SUPP(pldat->net_base));
 512 }
 513
 514 static void __lpc_eth_reset(struct netdata_local *pldat)
 515 {
 516         /* Reset all MAC logic */
 517         writel((LPC_MAC1_RESET_TX | LPC_MAC1_RESET_MCS_TX | LPC_MAC1_RESET_RX |
 518                 LPC_MAC1_RESET_MCS_RX | LPC_MAC1_SIMULATION_RESET |
 519                 LPC_MAC1_SOFT_RESET), LPC_ENET_MAC1(pldat->net_base));
 520         writel((LPC_COMMAND_REG_RESET | LPC_COMMAND_TXRESET |
 521                 LPC_COMMAND_RXRESET), LPC_ENET_COMMAND(pldat->net_base));
 522 }
 523
 524 static int __lpc_mii_mngt_reset(struct netdata_local *pldat)
 525 {
 526         /* Reset MII management hardware */
 527         writel(LPC_MCFG_RESET_MII_MGMT, LPC_ENET_MCFG(pldat->net_base));
 528
 529         /* Setup MII clock to slowest rate with a /28 divider */
 530         writel(LPC_MCFG_CLOCK_SELECT(LPC_MCFG_CLOCK_HOST_DIV_28),
 531                LPC_ENET_MCFG(pldat->net_base));
 532
 533         return 0;
 534 }
 535
 536 static inline phys_addr_t __va_to_pa(void *addr, struct netdata_local *pldat)
 537 {
 538         phys_addr_t phaddr;
 539
 540         phaddr = addr - pldat->dma_buff_base_v;
 541         phaddr += pldat->dma_buff_base_p;
 542
 543         return phaddr;
 544 }
 545
 546 static void lpc_eth_enable_int(void __iomem *regbase)
 547 {
 548         writel((LPC_MACINT_RXDONEINTEN | LPC_MACINT_TXDONEINTEN),
 549                LPC_ENET_INTENABLE(regbase));
 550 }
 551
 552 static void lpc_eth_disable_int(void __iomem *regbase)
 553 {
 554         writel(0, LPC_ENET_INTENABLE(regbase));
 555 }
 556
 557 /* Setup TX/RX descriptors */
 558 static void __lpc_txrx_desc_setup(struct netdata_local *pldat)
 559 {
 560         u32 *ptxstat;
 561         void *tbuff;
 562         int i;
 563         struct txrx_desc_t *ptxrxdesc;
 564         struct rx_status_t *prxstat;
 565
 566         tbuff = PTR_ALIGN(pldat->dma_buff_base_v, 16);
 567
 568         /* Setup TX descriptors, status, and buffers */
 569         pldat->tx_desc_v = tbuff;
 570         tbuff += sizeof(struct txrx_desc_t) * ENET_TX_DESC;
 571
 572         pldat->tx_stat_v = tbuff;
 573         tbuff += sizeof(u32) * ENET_TX_DESC;
 574
 575         tbuff = PTR_ALIGN(tbuff, 16);
 576         pldat->tx_buff_v = tbuff;
 577         tbuff += ENET_MAXF_SIZE * ENET_TX_DESC;
 578
 579         /* Setup RX descriptors, status, and buffers */
 580         pldat->rx_desc_v = tbuff;
 581         tbuff += sizeof(struct txrx_desc_t) * ENET_RX_DESC;
 582
 583         tbuff = PTR_ALIGN(tbuff, 16);
 584         pldat->rx_stat_v = tbuff;
 585         tbuff += sizeof(struct rx_status_t) * ENET_RX_DESC;
 586
 587         tbuff = PTR_ALIGN(tbuff, 16);
 588         pldat->rx_buff_v = tbuff;
 589         tbuff += ENET_MAXF_SIZE * ENET_RX_DESC;
 590
 591         /* Map the TX descriptors to the TX buffers in hardware */
 592         for (i = 0; i < ENET_TX_DESC; i++) {
 593                 ptxstat = &pldat->tx_stat_v[i];
 594                 ptxrxdesc = &pldat->tx_desc_v[i];
 595
 596                 ptxrxdesc->packet = __va_to_pa(
 597                                 pldat->tx_buff_v + i * ENET_MAXF_SIZE, pldat);
 598                 ptxrxdesc->control = 0;
 599                 *ptxstat = 0;
 600         }
 601
 602         /* Map the RX descriptors to the RX buffers in hardware */
 603         for (i = 0; i < ENET_RX_DESC; i++) {
 604                 prxstat = &pldat->rx_stat_v[i];
 605                 ptxrxdesc = &pldat->rx_desc_v[i];
 606
 607                 ptxrxdesc->packet = __va_to_pa(
 608                                 pldat->rx_buff_v + i * ENET_MAXF_SIZE, pldat);
 609                 ptxrxdesc->control = RXDESC_CONTROL_INT | (ENET_MAXF_SIZE - 1);
 610                 prxstat->statusinfo = 0;
 611                 prxstat->statushashcrc = 0;
 612         }
 613
 614         /* Setup base addresses in hardware to point to buffers and
 615          * descriptors
 616          */
 617         writel((ENET_TX_DESC - 1),
 618                LPC_ENET_TXDESCRIPTORNUMBER(pldat->net_base));
 619         writel(__va_to_pa(pldat->tx_desc_v, pldat),
 620                LPC_ENET_TXDESCRIPTOR(pldat->net_base));
 621         writel(__va_to_pa(pldat->tx_stat_v, pldat),
 622                LPC_ENET_TXSTATUS(pldat->net_base));
 623         writel((ENET_RX_DESC - 1),
 624                LPC_ENET_RXDESCRIPTORNUMBER(pldat->net_base));
 625         writel(__va_to_pa(pldat->rx_desc_v, pldat),
 626                LPC_ENET_RXDESCRIPTOR(pldat->net_base));
 627         writel(__va_to_pa(pldat->rx_stat_v, pldat),
 628                LPC_ENET_RXSTATUS(pldat->net_base));
 629 }
 630
 631 static void __lpc_eth_init(struct netdata_local *pldat)
 632 {
 633         u32 tmp;
 634
 635         /* Disable controller and reset */
 636         tmp = readl(LPC_ENET_COMMAND(pldat->net_base));
 637         tmp &= ~LPC_COMMAND_RXENABLE | LPC_COMMAND_TXENABLE;
 638         writel(tmp, LPC_ENET_COMMAND(pldat->net_base));
 639         tmp = readl(LPC_ENET_MAC1(pldat->net_base));
 640         tmp &= ~LPC_MAC1_RECV_ENABLE;
 641         writel(tmp, LPC_ENET_MAC1(pldat->net_base));
 642
 643         /* Initial MAC setup */
 644         writel(LPC_MAC1_PASS_ALL_RX_FRAMES, LPC_ENET_MAC1(pldat->net_base));
 645         writel((LPC_MAC2_PAD_CRC_ENABLE | LPC_MAC2_CRC_ENABLE),
 646                LPC_ENET_MAC2(pldat->net_base));
 647         writel(ENET_MAXF_SIZE, LPC_ENET_MAXF(pldat->net_base));
 648
 649         /* Collision window, gap */
 650         writel((LPC_CLRT_LOAD_RETRY_MAX(0xF) |
 651                 LPC_CLRT_LOAD_COLLISION_WINDOW(0x37)),
 652                LPC_ENET_CLRT(pldat->net_base));
 653         writel(LPC_IPGR_LOAD_PART2(0x12), LPC_ENET_IPGR(pldat->net_base));
 654
 655         if (lpc_phy_interface_mode(&pldat->pdev->dev) == PHY_INTERFACE_MODE_MII)
 656                 writel(LPC_COMMAND_PASSRUNTFRAME,
 657                        LPC_ENET_COMMAND(pldat->net_base));
 658         else {
 659                 writel((LPC_COMMAND_PASSRUNTFRAME | LPC_COMMAND_RMII),
 660                        LPC_ENET_COMMAND(pldat->net_base));
 661                 writel(LPC_SUPP_RESET_RMII, LPC_ENET_SUPP(pldat->net_base));
 662         }
 663
 664         __lpc_params_setup(pldat);
 665
 666         /* Setup TX and RX descriptors */
 667         __lpc_txrx_desc_setup(pldat);
 668
 669         /* Setup packet filtering */
 670         writel((LPC_RXFLTRW_ACCEPTUBROADCAST | LPC_RXFLTRW_ACCEPTPERFECT),
 671                LPC_ENET_RXFILTER_CTRL(pldat->net_base));
 672
 673         /* Get the next TX buffer output index */
 674         pldat->num_used_tx_buffs = 0;
 675         pldat->last_tx_idx =
 676                 readl(LPC_ENET_TXCONSUMEINDEX(pldat->net_base));
 677
 678         /* Clear and enable interrupts */
 679         writel(0xFFFF, LPC_ENET_INTCLEAR(pldat->net_base));
 680         smp_wmb();
 681         lpc_eth_enable_int(pldat->net_base);
 682
 683         /* Enable controller */
 684         tmp = readl(LPC_ENET_COMMAND(pldat->net_base));
 685         tmp |= LPC_COMMAND_RXENABLE | LPC_COMMAND_TXENABLE;
 686         writel(tmp, LPC_ENET_COMMAND(pldat->net_base));
 687         tmp = readl(LPC_ENET_MAC1(pldat->net_base));
 688         tmp |= LPC_MAC1_RECV_ENABLE;
 689         writel(tmp, LPC_ENET_MAC1(pldat->net_base));
 690 }
 691
 692 static void __lpc_eth_shutdown(struct netdata_local *pldat)
 693 {
 694         /* Reset ethernet and power down PHY */
 695         __lpc_eth_reset(pldat);
 696         writel(0, LPC_ENET_MAC1(pldat->net_base));
 697         writel(0, LPC_ENET_MAC2(pldat->net_base));
 698 }
 699
 700 /*
 701  * MAC<--->PHY support functions
 702  */
 703 static int lpc_mdio_read(struct mii_bus *bus, int phy_id, int phyreg)
 704 {
 705         struct netdata_local *pldat = bus->priv;
 706         unsigned long timeout = jiffies + msecs_to_jiffies(100);
 707         int lps;
 708
 709         writel(((phy_id << 8) | phyreg), LPC_ENET_MADR(pldat->net_base));
 710         writel(LPC_MCMD_READ, LPC_ENET_MCMD(pldat->net_base));
 711
 712         /* Wait for unbusy status */
 713         while (readl(LPC_ENET_MIND(pldat->net_base)) & LPC_MIND_BUSY) {
 714                 if (time_after(jiffies, timeout))
 715                         return -EIO;
 716                 cpu_relax();
 717         }
 718
 719         lps = readl(LPC_ENET_MRDD(pldat->net_base));
 720         writel(0, LPC_ENET_MCMD(pldat->net_base));
 721
 722         return lps;
 723 }
 724
 725 static int lpc_mdio_write(struct mii_bus *bus, int phy_id, int phyreg,
 726                         u16 phydata)
 727 {
 728         struct netdata_local *pldat = bus->priv;
 729         unsigned long timeout = jiffies + msecs_to_jiffies(100);
 730
 731         writel(((phy_id << 8) | phyreg), LPC_ENET_MADR(pldat->net_base));
 732         writel(phydata, LPC_ENET_MWTD(pldat->net_base));
 733
 734         /* Wait for completion */
 735         while (readl(LPC_ENET_MIND(pldat->net_base)) & LPC_MIND_BUSY) {
 736                 if (time_after(jiffies, timeout))
 737                         return -EIO;
 738                 cpu_relax();
 739         }
 740
 741         return 0;
 742 }
 743
 744 static int lpc_mdio_reset(struct mii_bus *bus)
 745 {
 746         return __lpc_mii_mngt_reset((struct netdata_local *)bus->priv);
 747 }
 748
 749 static void lpc_handle_link_change(struct net_device *ndev)
 750 {
 751         struct netdata_local *pldat = netdev_priv(ndev);
 752         struct phy_device *phydev = ndev->phydev;
 753         unsigned long flags;
 754
 755         bool status_change = false;
 756
 757         spin_lock_irqsave(&pldat->lock, flags);
 758
 759         if (phydev->link) {
 760                 if ((pldat->speed != phydev->speed) ||
 761                     (pldat->duplex != phydev->duplex)) {
 762                         pldat->speed = phydev->speed;
 763                         pldat->duplex = phydev->duplex;
 764                         status_change = true;
 765                 }
 766         }
 767
 768         if (phydev->link != pldat->link) {
 769                 if (!phydev->link) {
 770                         pldat->speed = 0;
 771                         pldat->duplex = -1;
 772                 }
 773                 pldat->link = phydev->link;
 774
 775                 status_change = true;
 776         }
 777
 778         spin_unlock_irqrestore(&pldat->lock, flags);
 779
 780         if (status_change)
 781                 __lpc_params_setup(pldat);
 782 }
 783
 784 static int lpc_mii_probe(struct net_device *ndev)
 785 {
 786         struct netdata_local *pldat = netdev_priv(ndev);
 787         struct phy_device *phydev = phy_find_first(pldat->mii_bus);
 788
 789         if (!phydev) {
 790                 netdev_err(ndev, "no PHY found\n");
 791                 return -ENODEV;
 792         }
 793
 794         /* Attach to the PHY */
 795         if (lpc_phy_interface_mode(&pldat->pdev->dev) == PHY_INTERFACE_MODE_MII)
 796                 netdev_info(ndev, "using MII interface\n");
 797         else
 798                 netdev_info(ndev, "using RMII interface\n");
 799         phydev = phy_connect(ndev, phydev_name(phydev),
 800                              &lpc_handle_link_change,
 801                              lpc_phy_interface_mode(&pldat->pdev->dev));
 802
 803         if (IS_ERR(phydev)) {
 804                 netdev_err(ndev, "Could not attach to PHY\n");
 805                 return PTR_ERR(phydev);
 806         }
 807
 808         /* mask with MAC supported features */
 809         phydev->supported &= PHY_BASIC_FEATURES;
 810
 811         phydev->advertising = phydev->supported;
 812
 813         pldat->link = 0;
 814         pldat->speed = 0;
 815         pldat->duplex = -1;
 816
 817         phy_attached_info(phydev);
 818
 819         return 0;
 820 }
 821
 822 static int lpc_mii_init(struct netdata_local *pldat)
 823 {
 824         int err = -ENXIO;
 825
 826         pldat->mii_bus = mdiobus_alloc();
 827         if (!pldat->mii_bus) {
 828                 err = -ENOMEM;
 829                 goto err_out;
 830         }
 831
 832         /* Setup MII mode */
 833         if (lpc_phy_interface_mode(&pldat->pdev->dev) == PHY_INTERFACE_MODE_MII)
 834                 writel(LPC_COMMAND_PASSRUNTFRAME,
 835                        LPC_ENET_COMMAND(pldat->net_base));
 836         else {
 837                 writel((LPC_COMMAND_PASSRUNTFRAME | LPC_COMMAND_RMII),
 838                        LPC_ENET_COMMAND(pldat->net_base));
 839                 writel(LPC_SUPP_RESET_RMII, LPC_ENET_SUPP(pldat->net_base));
 840         }
 841
 842         pldat->mii_bus->name = "lpc_mii_bus";
 843         pldat->mii_bus->read = &lpc_mdio_read;
 844         pldat->mii_bus->write = &lpc_mdio_write;
 845         pldat->mii_bus->reset = &lpc_mdio_reset;
 846         snprintf(pldat->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
 847                  pldat->pdev->name, pldat->pdev->id);
 848         pldat->mii_bus->priv = pldat;
 849         pldat->mii_bus->parent = &pldat->pdev->dev;
 850
 851         platform_set_drvdata(pldat->pdev, pldat->mii_bus);
 852
 853         if (mdiobus_register(pldat->mii_bus))
 854                 goto err_out_unregister_bus;
 855
 856         if (lpc_mii_probe(pldat->ndev) != 0)
 857                 goto err_out_unregister_bus;
 858
 859         return 0;
 860
 861 err_out_unregister_bus:
 862         mdiobus_unregister(pldat->mii_bus);
 863         mdiobus_free(pldat->mii_bus);
 864 err_out:
 865         return err;
 866 }
 867
 868 static void __lpc_handle_xmit(struct net_device *ndev)
 869 {
 870         struct netdata_local *pldat = netdev_priv(ndev);
 871         u32 txcidx, *ptxstat, txstat;
 872
 873         txcidx = readl(LPC_ENET_TXCONSUMEINDEX(pldat->net_base));
 874         while (pldat->last_tx_idx != txcidx) {
 875                 unsigned int skblen = pldat->skblen[pldat->last_tx_idx];
 876
 877                 /* A buffer is available, get buffer status */
 878                 ptxstat = &pldat->tx_stat_v[pldat->last_tx_idx];
 879                 txstat = *ptxstat;
 880
 881                 /* Next buffer and decrement used buffer counter */
 882                 pldat->num_used_tx_buffs--;
 883                 pldat->last_tx_idx++;
 884                 if (pldat->last_tx_idx >= ENET_TX_DESC)
 885                         pldat->last_tx_idx = 0;
 886
 887                 /* Update collision counter */
 888                 ndev->stats.collisions += TXSTATUS_COLLISIONS_GET(txstat);
 889
 890                 /* Any errors occurred? */
 891                 if (txstat & TXSTATUS_ERROR) {
 892                         if (txstat & TXSTATUS_UNDERRUN) {
 893                                 /* FIFO underrun */
 894                                 ndev->stats.tx_fifo_errors++;
 895                         }
 896                         if (txstat & TXSTATUS_LATECOLL) {
 897                                 /* Late collision */
 898                                 ndev->stats.tx_aborted_errors++;
 899                         }
 900                         if (txstat & TXSTATUS_EXCESSCOLL) {
 901                                 /* Excessive collision */
 902                                 ndev->stats.tx_aborted_errors++;
 903                         }
 904                         if (txstat & TXSTATUS_EXCESSDEFER) {
 905                                 /* Defer limit */
 906                                 ndev->stats.tx_aborted_errors++;
 907                         }
 908                         ndev->stats.tx_errors++;
 909                 } else {
 910                         /* Update stats */
 911                         ndev->stats.tx_packets++;
 912                         ndev->stats.tx_bytes += skblen;
 913                 }
 914
 915                 txcidx = readl(LPC_ENET_TXCONSUMEINDEX(pldat->net_base));
 916         }
 917
 918         if (pldat->num_used_tx_buffs <= ENET_TX_DESC/2) {
 919                 if (netif_queue_stopped(ndev))
 920                         netif_wake_queue(ndev);
 921         }
 922 }
 923
 924 static int __lpc_handle_recv(struct net_device *ndev, int budget)
 925 {
 926         struct netdata_local *pldat = netdev_priv(ndev);
 927         struct sk_buff *skb;
 928         u32 rxconsidx, len, ethst;
 929         struct rx_status_t *prxstat;
 930         u8 *prdbuf;
 931         int rx_done = 0;
 932
 933         /* Get the current RX buffer indexes */
 934         rxconsidx = readl(LPC_ENET_RXCONSUMEINDEX(pldat->net_base));
 935         while (rx_done < budget && rxconsidx !=
 936                         readl(LPC_ENET_RXPRODUCEINDEX(pldat->net_base))) {
 937                 /* Get pointer to receive status */
 938                 prxstat = &pldat->rx_stat_v[rxconsidx];
 939                 len = (prxstat->statusinfo & RXSTATUS_SIZE) + 1;
 940
 941                 /* Status error? */
 942                 ethst = prxstat->statusinfo;
 943                 if ((ethst & (RXSTATUS_ERROR | RXSTATUS_STATUS_ERROR)) ==
 944                     (RXSTATUS_ERROR | RXSTATUS_RANGE))
 945                         ethst &= ~RXSTATUS_ERROR;
 946
 947                 if (ethst & RXSTATUS_ERROR) {
 948                         int si = prxstat->statusinfo;
 949                         /* Check statuses */
 950                         if (si & RXSTATUS_OVERRUN) {
 951                                 /* Overrun error */
 952                                 ndev->stats.rx_fifo_errors++;
 953                         } else if (si & RXSTATUS_CRC) {
 954                                 /* CRC error */
 955                                 ndev->stats.rx_crc_errors++;
 956                         } else if (si & RXSTATUS_LENGTH) {
 957                                 /* Length error */
 958                                 ndev->stats.rx_length_errors++;
 959                         } else if (si & RXSTATUS_ERROR) {
 960                                 /* Other error */
 961                                 ndev->stats.rx_length_errors++;
 962                         }
 963                         ndev->stats.rx_errors++;
 964                 } else {
 965                         /* Packet is good */
 966                         skb = dev_alloc_skb(len);
 967                         if (!skb) {
 968                                 ndev->stats.rx_dropped++;
 969                         } else {
 970                                 prdbuf = skb_put(skb, len);
 971
 972                                 /* Copy packet from buffer */
 973                                 memcpy(prdbuf, pldat->rx_buff_v +
 974                                         rxconsidx * ENET_MAXF_SIZE, len);
 975
 976                                 /* Pass to upper layer */
 977                                 skb->protocol = eth_type_trans(skb, ndev);
 978                                 netif_receive_skb(skb);
 979                                 ndev->stats.rx_packets++;
 980                                 ndev->stats.rx_bytes += len;
 981                         }
 982                 }
 983
 984                 /* Increment consume index */
 985                 rxconsidx = rxconsidx + 1;
 986                 if (rxconsidx >= ENET_RX_DESC)
 987                         rxconsidx = 0;
 988                 writel(rxconsidx,
 989                        LPC_ENET_RXCONSUMEINDEX(pldat->net_base));
 990                 rx_done++;
 991         }
 992
 993         return rx_done;
 994 }
 995
 996 static int lpc_eth_poll(struct napi_struct *napi, int budget)
 997 {
 998         struct netdata_local *pldat = container_of(napi,
 999                         struct netdata_local, napi);
1000         struct net_device *ndev = pldat->ndev;
1001         int rx_done = 0;
1002         struct netdev_queue *txq = netdev_get_tx_queue(ndev, 0);
1003
1004         __netif_tx_lock(txq, smp_processor_id());
1005         __lpc_handle_xmit(ndev);
1006         __netif_tx_unlock(txq);
1007         rx_done = __lpc_handle_recv(ndev, budget);
1008
1009         if (rx_done < budget) {
1010                 napi_complete(napi);
1011                 lpc_eth_enable_int(pldat->net_base);
1012         }
1013
1014         return rx_done;
1015 }
1016
1017 static irqreturn_t __lpc_eth_interrupt(int irq, void *dev_id)
1018 {
1019         struct net_device *ndev = dev_id;
1020         struct netdata_local *pldat = netdev_priv(ndev);
1021         u32 tmp;
1022
1023         spin_lock(&pldat->lock);
1024
1025         tmp = readl(LPC_ENET_INTSTATUS(pldat->net_base));
1026         /* Clear interrupts */
1027         writel(tmp, LPC_ENET_INTCLEAR(pldat->net_base));
1028
1029         lpc_eth_disable_int(pldat->net_base);
1030         if (likely(napi_schedule_prep(&pldat->napi)))
1031                 __napi_schedule(&pldat->napi);
1032
1033         spin_unlock(&pldat->lock);
1034
1035         return IRQ_HANDLED;
1036 }
1037
1038 static int lpc_eth_close(struct net_device *ndev)
1039 {
1040         unsigned long flags;
1041         struct netdata_local *pldat = netdev_priv(ndev);
1042
1043         if (netif_msg_ifdown(pldat))
1044                 dev_dbg(&pldat->pdev->dev, "shutting down %s\n", ndev->name);
1045
1046         napi_disable(&pldat->napi);
1047         netif_stop_queue(ndev);
1048
1049         if (ndev->phydev)
1050                 phy_stop(ndev->phydev);
1051
1052         spin_lock_irqsave(&pldat->lock, flags);
1053         __lpc_eth_reset(pldat);
1054         netif_carrier_off(ndev);
1055         writel(0, LPC_ENET_MAC1(pldat->net_base));
1056         writel(0, LPC_ENET_MAC2(pldat->net_base));
1057         spin_unlock_irqrestore(&pldat->lock, flags);
1058
1059         __lpc_eth_clock_enable(pldat, false);
1060
1061         return 0;
1062 }
1063
1064 static int lpc_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1065 {
1066         struct netdata_local *pldat = netdev_priv(ndev);
1067         u32 len, txidx;
1068         u32 *ptxstat;
1069         struct txrx_desc_t *ptxrxdesc;
1070
1071         len = skb->len;
1072
1073         spin_lock_irq(&pldat->lock);
1074
1075         if (pldat->num_used_tx_buffs >= (ENET_TX_DESC - 1)) {
1076                 /* This function should never be called when there are no
1077                    buffers */
1078                 netif_stop_queue(ndev);
1079                 spin_unlock_irq(&pldat->lock);
1080                 WARN(1, "BUG! TX request when no free TX buffers!\n");
1081                 return NETDEV_TX_BUSY;
1082         }
1083
1084         /* Get the next TX descriptor index */
1085         txidx = readl(LPC_ENET_TXPRODUCEINDEX(pldat->net_base));
1086
1087         /* Setup control for the transfer */
1088         ptxstat = &pldat->tx_stat_v[txidx];
1089         *ptxstat = 0;
1090         ptxrxdesc = &pldat->tx_desc_v[txidx];
1091         ptxrxdesc->control =
1092                 (len - 1) | TXDESC_CONTROL_LAST | TXDESC_CONTROL_INT;
1093
1094         /* Copy data to the DMA buffer */
1095         memcpy(pldat->tx_buff_v + txidx * ENET_MAXF_SIZE, skb->data, len);
1096
1097         /* Save the buffer and increment the buffer counter */
1098         pldat->skblen[txidx] = len;
1099         pldat->num_used_tx_buffs++;
1100
1101         /* Start transmit */
1102         txidx++;
1103         if (txidx >= ENET_TX_DESC)
1104                 txidx = 0;
1105         writel(txidx, LPC_ENET_TXPRODUCEINDEX(pldat->net_base));
1106
1107         /* Stop queue if no more TX buffers */
1108         if (pldat->num_used_tx_buffs >= (ENET_TX_DESC - 1))
1109                 netif_stop_queue(ndev);
1110
1111         spin_unlock_irq(&pldat->lock);
1112
1113         dev_kfree_skb(skb);
1114         return NETDEV_TX_OK;
1115 }
1116
1117 static int lpc_set_mac_address(struct net_device *ndev, void *p)
1118 {
1119         struct sockaddr *addr = p;
1120         struct netdata_local *pldat = netdev_priv(ndev);
1121         unsigned long flags;
1122
1123         if (!is_valid_ether_addr(addr->sa_data))
1124                 return -EADDRNOTAVAIL;
1125         memcpy(ndev->dev_addr, addr->sa_data, ETH_ALEN);
1126
1127         spin_lock_irqsave(&pldat->lock, flags);
1128
1129         /* Set station address */
1130         __lpc_set_mac(pldat, ndev->dev_addr);
1131
1132         spin_unlock_irqrestore(&pldat->lock, flags);
1133
1134         return 0;
1135 }
1136
1137 static void lpc_eth_set_multicast_list(struct net_device *ndev)
1138 {
1139         struct netdata_local *pldat = netdev_priv(ndev);
1140         struct netdev_hw_addr_list *mcptr = &ndev->mc;
1141         struct netdev_hw_addr *ha;
1142         u32 tmp32, hash_val, hashlo, hashhi;
1143         unsigned long flags;
1144
1145         spin_lock_irqsave(&pldat->lock, flags);
1146
1147         /* Set station address */
1148         __lpc_set_mac(pldat, ndev->dev_addr);
1149
1150         tmp32 =  LPC_RXFLTRW_ACCEPTUBROADCAST | LPC_RXFLTRW_ACCEPTPERFECT;
1151
1152         if (ndev->flags & IFF_PROMISC)
1153                 tmp32 |= LPC_RXFLTRW_ACCEPTUNICAST |
1154                         LPC_RXFLTRW_ACCEPTUMULTICAST;
1155         if (ndev->flags & IFF_ALLMULTI)
1156                 tmp32 |= LPC_RXFLTRW_ACCEPTUMULTICAST;
1157
1158         if (netdev_hw_addr_list_count(mcptr))
1159                 tmp32 |= LPC_RXFLTRW_ACCEPTUMULTICASTHASH;
1160
1161         writel(tmp32, LPC_ENET_RXFILTER_CTRL(pldat->net_base));
1162
1163
1164         /* Set initial hash table */
1165         hashlo = 0x0;
1166         hashhi = 0x0;
1167
1168         /* 64 bits : multicast address in hash table */
1169         netdev_hw_addr_list_for_each(ha, mcptr) {
1170                 hash_val = (ether_crc(6, ha->addr) >> 23) & 0x3F;
1171
1172                 if (hash_val >= 32)
1173                         hashhi |= 1 << (hash_val - 32);
1174                 else
1175                         hashlo |= 1 << hash_val;
1176         }
1177
1178         writel(hashlo, LPC_ENET_HASHFILTERL(pldat->net_base));
1179         writel(hashhi, LPC_ENET_HASHFILTERH(pldat->net_base));
1180
1181         spin_unlock_irqrestore(&pldat->lock, flags);
1182 }
1183
1184 static int lpc_eth_ioctl(struct net_device *ndev, struct ifreq *req, int cmd)
1185 {
1186         struct phy_device *phydev = ndev->phydev;
1187
1188         if (!netif_running(ndev))
1189                 return -EINVAL;
1190
1191         if (!phydev)
1192                 return -ENODEV;
1193
1194         return phy_mii_ioctl(phydev, req, cmd);
1195 }
1196
1197 static int lpc_eth_open(struct net_device *ndev)
1198 {
1199         struct netdata_local *pldat = netdev_priv(ndev);
1200
1201         if (netif_msg_ifup(pldat))
1202                 dev_dbg(&pldat->pdev->dev, "enabling %s\n", ndev->name);
1203
1204         __lpc_eth_clock_enable(pldat, true);
1205
1206         /* Suspended PHY makes LPC ethernet core block, so resume now */
1207         phy_resume(ndev->phydev);
1208
1209         /* Reset and initialize */
1210         __lpc_eth_reset(pldat);
1211         __lpc_eth_init(pldat);
1212
1213         /* schedule a link state check */
1214         phy_start(ndev->phydev);
1215         netif_start_queue(ndev);
1216         napi_enable(&pldat->napi);
1217
1218         return 0;
1219 }
1220
1221 /*
1222  * Ethtool ops
1223  */
1224 static void lpc_eth_ethtool_getdrvinfo(struct net_device *ndev,
1225         struct ethtool_drvinfo *info)
1226 {
1227         strlcpy(info->driver, MODNAME, sizeof(info->driver));
1228         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1229         strlcpy(info->bus_info, dev_name(ndev->dev.parent),
1230                 sizeof(info->bus_info));
1231 }
1232
1233 static u32 lpc_eth_ethtool_getmsglevel(struct net_device *ndev)
1234 {
1235         struct netdata_local *pldat = netdev_priv(ndev);
1236
1237         return pldat->msg_enable;
1238 }
1239
1240 static void lpc_eth_ethtool_setmsglevel(struct net_device *ndev, u32 level)
1241 {
1242         struct netdata_local *pldat = netdev_priv(ndev);
1243
1244         pldat->msg_enable = level;
1245 }
1246
1247 static const struct ethtool_ops lpc_eth_ethtool_ops = {
1248         .get_drvinfo    = lpc_eth_ethtool_getdrvinfo,
1249         .get_msglevel   = lpc_eth_ethtool_getmsglevel,
1250         .set_msglevel   = lpc_eth_ethtool_setmsglevel,
1251         .get_link       = ethtool_op_get_link,
1252         .get_link_ksettings = phy_ethtool_get_link_ksettings,
1253         .set_link_ksettings = phy_ethtool_set_link_ksettings,
1254 };
1255
1256 static const struct net_device_ops lpc_netdev_ops = {
1257         .ndo_open               = lpc_eth_open,
1258         .ndo_stop               = lpc_eth_close,
1259         .ndo_start_xmit         = lpc_eth_hard_start_xmit,
1260         .ndo_set_rx_mode        = lpc_eth_set_multicast_list,
1261         .ndo_do_ioctl           = lpc_eth_ioctl,
1262         .ndo_set_mac_address    = lpc_set_mac_address,
1263         .ndo_validate_addr      = eth_validate_addr,
1264         .ndo_change_mtu         = eth_change_mtu,
1265 };
1266
1267 static int lpc_eth_drv_probe(struct platform_device *pdev)
1268 {
1269         struct resource *res;
1270         struct net_device *ndev;
1271         struct netdata_local *pldat;
1272         struct phy_device *phydev;
1273         dma_addr_t dma_handle;
1274         int irq, ret;
1275         u32 tmp;
1276
1277         /* Setup network interface for RMII or MII mode */
1278         tmp = __raw_readl(LPC32XX_CLKPWR_MACCLK_CTRL);
1279         tmp &= ~LPC32XX_CLKPWR_MACCTRL_PINS_MSK;
1280         if (lpc_phy_interface_mode(&pdev->dev) == PHY_INTERFACE_MODE_MII)
1281                 tmp |= LPC32XX_CLKPWR_MACCTRL_USE_MII_PINS;
1282         else
1283                 tmp |= LPC32XX_CLKPWR_MACCTRL_USE_RMII_PINS;
1284         __raw_writel(tmp, LPC32XX_CLKPWR_MACCLK_CTRL);
1285
1286         /* Get platform resources */
1287         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1288         irq = platform_get_irq(pdev, 0);
1289         if (!res || irq < 0) {
1290                 dev_err(&pdev->dev, "error getting resources.\n");
1291                 ret = -ENXIO;
1292                 goto err_exit;
1293         }
1294
1295         /* Allocate net driver data structure */
1296         ndev = alloc_etherdev(sizeof(struct netdata_local));
1297         if (!ndev) {
1298                 dev_err(&pdev->dev, "could not allocate device.\n");
1299                 ret = -ENOMEM;
1300                 goto err_exit;
1301         }
1302
1303         SET_NETDEV_DEV(ndev, &pdev->dev);
1304
1305         pldat = netdev_priv(ndev);
1306         pldat->pdev = pdev;
1307         pldat->ndev = ndev;
1308
1309         spin_lock_init(&pldat->lock);
1310
1311         /* Save resources */
1312         ndev->irq = irq;
1313
1314         /* Get clock for the device */
1315         pldat->clk = clk_get(&pdev->dev, NULL);
1316         if (IS_ERR(pldat->clk)) {
1317                 dev_err(&pdev->dev, "error getting clock.\n");
1318                 ret = PTR_ERR(pldat->clk);
1319                 goto err_out_free_dev;
1320         }
1321
1322         /* Enable network clock */
1323         __lpc_eth_clock_enable(pldat, true);
1324
1325         /* Map IO space */
1326         pldat->net_base = ioremap(res->start, resource_size(res));
1327         if (!pldat->net_base) {
1328                 dev_err(&pdev->dev, "failed to map registers\n");
1329                 ret = -ENOMEM;
1330                 goto err_out_disable_clocks;
1331         }
1332         ret = request_irq(ndev->irq, __lpc_eth_interrupt, 0,
1333                           ndev->name, ndev);
1334         if (ret) {
1335                 dev_err(&pdev->dev, "error requesting interrupt.\n");
1336                 goto err_out_iounmap;
1337         }
1338
1339         /* Setup driver functions */
1340         ndev->netdev_ops = &lpc_netdev_ops;
1341         ndev->ethtool_ops = &lpc_eth_ethtool_ops;
1342         ndev->watchdog_timeo = msecs_to_jiffies(2500);
1343
1344         /* Get size of DMA buffers/descriptors region */
1345         pldat->dma_buff_size = (ENET_TX_DESC + ENET_RX_DESC) * (ENET_MAXF_SIZE +
1346                 sizeof(struct txrx_desc_t) + sizeof(struct rx_status_t));
1347         pldat->dma_buff_base_v = 0;
1348
1349         if (use_iram_for_net(&pldat->pdev->dev)) {
1350                 dma_handle = LPC32XX_IRAM_BASE;
1351                 if (pldat->dma_buff_size <= lpc32xx_return_iram_size())
1352                         pldat->dma_buff_base_v =
1353                                 io_p2v(LPC32XX_IRAM_BASE);
1354                 else
1355                         netdev_err(ndev,
1356                                 "IRAM not big enough for net buffers, using SDRAM instead.\n");
1357         }
1358
1359         if (pldat->dma_buff_base_v == 0) {
1360                 ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1361                 if (ret)
1362                         goto err_out_free_irq;
1363
1364                 pldat->dma_buff_size = PAGE_ALIGN(pldat->dma_buff_size);
1365
1366                 /* Allocate a chunk of memory for the DMA ethernet buffers
1367                    and descriptors */
1368                 pldat->dma_buff_base_v =
1369                         dma_alloc_coherent(&pldat->pdev->dev,
1370                                            pldat->dma_buff_size, &dma_handle,
1371                                            GFP_KERNEL);
1372                 if (pldat->dma_buff_base_v == NULL) {
1373                         ret = -ENOMEM;
1374                         goto err_out_free_irq;
1375                 }
1376         }
1377         pldat->dma_buff_base_p = dma_handle;
1378
1379         netdev_dbg(ndev, "IO address space     :%pR\n", res);
1380         netdev_dbg(ndev, "IO address size      :%d\n", resource_size(res));
1381         netdev_dbg(ndev, "IO address (mapped)  :0x%p\n",
1382                         pldat->net_base);
1383         netdev_dbg(ndev, "IRQ number           :%d\n", ndev->irq);
1384         netdev_dbg(ndev, "DMA buffer size      :%d\n", pldat->dma_buff_size);
1385         netdev_dbg(ndev, "DMA buffer P address :0x%08x\n",
1386                         pldat->dma_buff_base_p);
1387         netdev_dbg(ndev, "DMA buffer V address :0x%p\n",
1388                         pldat->dma_buff_base_v);
1389
1390         /* Get MAC address from current HW setting (POR state is all zeros) */
1391         __lpc_get_mac(pldat, ndev->dev_addr);
1392
1393         if (!is_valid_ether_addr(ndev->dev_addr)) {
1394                 const char *macaddr = of_get_mac_address(pdev->dev.of_node);
1395                 if (macaddr)
1396                         memcpy(ndev->dev_addr, macaddr, ETH_ALEN);
1397         }
1398         if (!is_valid_ether_addr(ndev->dev_addr))
1399                 eth_hw_addr_random(ndev);
1400
1401         /* Reset the ethernet controller */
1402         __lpc_eth_reset(pldat);
1403
1404         /* then shut everything down to save power */
1405         __lpc_eth_shutdown(pldat);
1406
1407         /* Set default parameters */
1408         pldat->msg_enable = NETIF_MSG_LINK;
1409
1410         /* Force an MII interface reset and clock setup */
1411         __lpc_mii_mngt_reset(pldat);
1412
1413         /* Force default PHY interface setup in chip, this will probably be
1414            changed by the PHY driver */
1415         pldat->link = 0;
1416         pldat->speed = 100;
1417         pldat->duplex = DUPLEX_FULL;
1418         __lpc_params_setup(pldat);
1419
1420         netif_napi_add(ndev, &pldat->napi, lpc_eth_poll, NAPI_WEIGHT);
1421
1422         ret = register_netdev(ndev);
1423         if (ret) {
1424                 dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
1425                 goto err_out_dma_unmap;
1426         }
1427         platform_set_drvdata(pdev, ndev);
1428
1429         ret = lpc_mii_init(pldat);
1430         if (ret)
1431                 goto err_out_unregister_netdev;
1432
1433         netdev_info(ndev, "LPC mac at 0x%08x irq %d\n",
1434                res->start, ndev->irq);
1435
1436         phydev = ndev->phydev;
1437
1438         device_init_wakeup(&pdev->dev, 1);
1439         device_set_wakeup_enable(&pdev->dev, 0);
1440
1441         return 0;
1442
1443 err_out_unregister_netdev:
1444         unregister_netdev(ndev);
1445 err_out_dma_unmap:
1446         if (!use_iram_for_net(&pldat->pdev->dev) ||
1447             pldat->dma_buff_size > lpc32xx_return_iram_size())
1448                 dma_free_coherent(&pldat->pdev->dev, pldat->dma_buff_size,
1449                                   pldat->dma_buff_base_v,
1450                                   pldat->dma_buff_base_p);
1451 err_out_free_irq:
1452         free_irq(ndev->irq, ndev);
1453 err_out_iounmap:
1454         iounmap(pldat->net_base);
1455 err_out_disable_clocks:
1456         clk_disable_unprepare(pldat->clk);
1457         clk_put(pldat->clk);
1458 err_out_free_dev:
1459         free_netdev(ndev);
1460 err_exit:
1461         pr_err("%s: not found (%d).\n", MODNAME, ret);
1462         return ret;
1463 }
1464
1465 static int lpc_eth_drv_remove(struct platform_device *pdev)
1466 {
1467         struct net_device *ndev = platform_get_drvdata(pdev);
1468         struct netdata_local *pldat = netdev_priv(ndev);
1469
1470         unregister_netdev(ndev);
1471
1472         if (!use_iram_for_net(&pldat->pdev->dev) ||
1473             pldat->dma_buff_size > lpc32xx_return_iram_size())
1474                 dma_free_coherent(&pldat->pdev->dev, pldat->dma_buff_size,
1475                                   pldat->dma_buff_base_v,
1476                                   pldat->dma_buff_base_p);
1477         free_irq(ndev->irq, ndev);
1478         iounmap(pldat->net_base);
1479         mdiobus_unregister(pldat->mii_bus);
1480         mdiobus_free(pldat->mii_bus);
1481         clk_disable_unprepare(pldat->clk);
1482         clk_put(pldat->clk);
1483         free_netdev(ndev);
1484
1485         return 0;
1486 }
1487
1488 #ifdef CONFIG_PM
1489 static int lpc_eth_drv_suspend(struct platform_device *pdev,
1490         pm_message_t state)
1491 {
1492         struct net_device *ndev = platform_get_drvdata(pdev);
1493         struct netdata_local *pldat = netdev_priv(ndev);
1494
1495         if (device_may_wakeup(&pdev->dev))
1496                 enable_irq_wake(ndev->irq);
1497
1498         if (ndev) {
1499                 if (netif_running(ndev)) {
1500                         netif_device_detach(ndev);
1501                         __lpc_eth_shutdown(pldat);
1502                         clk_disable_unprepare(pldat->clk);
1503
1504                         /*
1505                          * Reset again now clock is disable to be sure
1506                          * EMC_MDC is down
1507                          */
1508                         __lpc_eth_reset(pldat);
1509                 }
1510         }
1511
1512         return 0;
1513 }
1514
1515 static int lpc_eth_drv_resume(struct platform_device *pdev)
1516 {
1517         struct net_device *ndev = platform_get_drvdata(pdev);
1518         struct netdata_local *pldat;
1519
1520         if (device_may_wakeup(&pdev->dev))
1521                 disable_irq_wake(ndev->irq);
1522
1523         if (ndev) {
1524                 if (netif_running(ndev)) {
1525                         pldat = netdev_priv(ndev);
1526
1527                         /* Enable interface clock */
1528                         clk_enable(pldat->clk);
1529
1530                         /* Reset and initialize */
1531                         __lpc_eth_reset(pldat);
1532                         __lpc_eth_init(pldat);
1533
1534                         netif_device_attach(ndev);
1535                 }
1536         }
1537
1538         return 0;
1539 }
1540 #endif
1541
1542 #ifdef CONFIG_OF
1543 static const struct of_device_id lpc_eth_match[] = {
1544         { .compatible = "nxp,lpc-eth" },
1545         { }
1546 };
1547 MODULE_DEVICE_TABLE(of, lpc_eth_match);
1548 #endif
1549
1550 static struct platform_driver lpc_eth_driver = {
1551         .probe          = lpc_eth_drv_probe,
1552         .remove         = lpc_eth_drv_remove,
1553 #ifdef CONFIG_PM
1554         .suspend        = lpc_eth_drv_suspend,
1555         .resume         = lpc_eth_drv_resume,
1556 #endif
1557         .driver         = {
1558                 .name   = MODNAME,
1559                 .of_match_table = of_match_ptr(lpc_eth_match),
1560         },
1561 };
1562
1563 module_platform_driver(lpc_eth_driver);
1564
1565 MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com>");
1566 MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
1567 MODULE_DESCRIPTION("LPC Ethernet Driver");
1568 MODULE_LICENSE("GPL");