projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net: ethernet: ax88796: avoid null pointer dereference
[deliverable/linux.git] / drivers / net / ethernet / smsc / smsc9420.c
1 /***************************************************************************
2 *
3 * Copyright (C) 2007,2008 SMSC
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, see <http://www.gnu.org/licenses/>.
17 *
18 ***************************************************************************
19 */
20
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23 #include <linux/interrupt.h>
24 #include <linux/kernel.h>
25 #include <linux/netdevice.h>
26 #include <linux/phy.h>
27 #include <linux/pci.h>
28 #include <linux/if_vlan.h>
29 #include <linux/dma-mapping.h>
30 #include <linux/crc32.h>
31 #include <linux/slab.h>
32 #include <linux/module.h>
33 #include <asm/unaligned.h>
34 #include "smsc9420.h"
35
36 #define DRV_NAME "smsc9420"
37 #define DRV_MDIONAME "smsc9420-mdio"
38 #define DRV_DESCRIPTION "SMSC LAN9420 driver"
39 #define DRV_VERSION "1.01"
40
41 MODULE_LICENSE("GPL");
42 MODULE_VERSION(DRV_VERSION);
43
44 struct smsc9420_dma_desc {
45 u32 status;
46 u32 length;
47 u32 buffer1;
48 u32 buffer2;
49 };
50
51 struct smsc9420_ring_info {
52 struct sk_buff *skb;
53 dma_addr_t mapping;
54 };
55
56 struct smsc9420_pdata {
57 void __iomem *ioaddr;
58 struct pci_dev *pdev;
59 struct net_device *dev;
60
61 struct smsc9420_dma_desc *rx_ring;
62 struct smsc9420_dma_desc *tx_ring;
63 struct smsc9420_ring_info *tx_buffers;
64 struct smsc9420_ring_info *rx_buffers;
65 dma_addr_t rx_dma_addr;
66 dma_addr_t tx_dma_addr;
67 int tx_ring_head, tx_ring_tail;
68 int rx_ring_head, rx_ring_tail;
69
70 spinlock_t int_lock;
71 spinlock_t phy_lock;
72
73 struct napi_struct napi;
74
75 bool software_irq_signal;
76 bool rx_csum;
77 u32 msg_enable;
78
79 struct mii_bus *mii_bus;
80 int last_duplex;
81 int last_carrier;
82 };
83
84 static const struct pci_device_id smsc9420_id_table[] = {
85 { PCI_VENDOR_ID_9420, PCI_DEVICE_ID_9420, PCI_ANY_ID, PCI_ANY_ID, },
86 { 0, }
87 };
88
89 MODULE_DEVICE_TABLE(pci, smsc9420_id_table);
90
91 #define SMSC_MSG_DEFAULT (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
92
93 static uint smsc_debug;
94 static uint debug = -1;
95 module_param(debug, uint, 0);
96 MODULE_PARM_DESC(debug, "debug level");
97
98 static inline u32 smsc9420_reg_read(struct smsc9420_pdata *pd, u32 offset)
99 {
100 return ioread32(pd->ioaddr + offset);
101 }
102
103 static inline void
104 smsc9420_reg_write(struct smsc9420_pdata *pd, u32 offset, u32 value)
105 {
106 iowrite32(value, pd->ioaddr + offset);
107 }
108
109 static inline void smsc9420_pci_flush_write(struct smsc9420_pdata *pd)
110 {
111 /* to ensure PCI write completion, we must perform a PCI read */
112 smsc9420_reg_read(pd, ID_REV);
113 }
114
115 static int smsc9420_mii_read(struct mii_bus *bus, int phyaddr, int regidx)
116 {
117 struct smsc9420_pdata *pd = (struct smsc9420_pdata *)bus->priv;
118 unsigned long flags;
119 u32 addr;
120 int i, reg = -EIO;
121
122 spin_lock_irqsave(&pd->phy_lock, flags);
123
124 /* confirm MII not busy */
125 if ((smsc9420_reg_read(pd, MII_ACCESS) & MII_ACCESS_MII_BUSY_)) {
126 netif_warn(pd, drv, pd->dev, "MII is busy???\n");
127 goto out;
128 }
129
130 /* set the address, index & direction (read from PHY) */
131 addr = ((phyaddr & 0x1F) << 11) | ((regidx & 0x1F) << 6) |
132 MII_ACCESS_MII_READ_;
133 smsc9420_reg_write(pd, MII_ACCESS, addr);
134
135 /* wait for read to complete with 50us timeout */
136 for (i = 0; i < 5; i++) {
137 if (!(smsc9420_reg_read(pd, MII_ACCESS) &
138 MII_ACCESS_MII_BUSY_)) {
139 reg = (u16)smsc9420_reg_read(pd, MII_DATA);
140 goto out;
141 }
142 udelay(10);
143 }
144
145 netif_warn(pd, drv, pd->dev, "MII busy timeout!\n");
146
147 out:
148 spin_unlock_irqrestore(&pd->phy_lock, flags);
149 return reg;
150 }
151
152 static int smsc9420_mii_write(struct mii_bus *bus, int phyaddr, int regidx,
153 u16 val)
154 {
155 struct smsc9420_pdata *pd = (struct smsc9420_pdata *)bus->priv;
156 unsigned long flags;
157 u32 addr;
158 int i, reg = -EIO;
159
160 spin_lock_irqsave(&pd->phy_lock, flags);
161
162 /* confirm MII not busy */
163 if ((smsc9420_reg_read(pd, MII_ACCESS) & MII_ACCESS_MII_BUSY_)) {
164 netif_warn(pd, drv, pd->dev, "MII is busy???\n");
165 goto out;
166 }
167
168 /* put the data to write in the MAC */
169 smsc9420_reg_write(pd, MII_DATA, (u32)val);
170
171 /* set the address, index & direction (write to PHY) */
172 addr = ((phyaddr & 0x1F) << 11) | ((regidx & 0x1F) << 6) |
173 MII_ACCESS_MII_WRITE_;
174 smsc9420_reg_write(pd, MII_ACCESS, addr);
175
176 /* wait for write to complete with 50us timeout */
177 for (i = 0; i < 5; i++) {
178 if (!(smsc9420_reg_read(pd, MII_ACCESS) &
179 MII_ACCESS_MII_BUSY_)) {
180 reg = 0;
181 goto out;
182 }
183 udelay(10);
184 }
185
186 netif_warn(pd, drv, pd->dev, "MII busy timeout!\n");
187
188 out:
189 spin_unlock_irqrestore(&pd->phy_lock, flags);
190 return reg;
191 }
192
193 /* Returns hash bit number for given MAC address
194 * Example:
195 * 01 00 5E 00 00 01 -> returns bit number 31 */
196 static u32 smsc9420_hash(u8 addr[ETH_ALEN])
197 {
198 return (ether_crc(ETH_ALEN, addr) >> 26) & 0x3f;
199 }
200
201 static int smsc9420_eeprom_reload(struct smsc9420_pdata *pd)
202 {
203 int timeout = 100000;
204
205 BUG_ON(!pd);
206
207 if (smsc9420_reg_read(pd, E2P_CMD) & E2P_CMD_EPC_BUSY_) {
208 netif_dbg(pd, drv, pd->dev, "%s: Eeprom busy\n", __func__);
209 return -EIO;
210 }
211
212 smsc9420_reg_write(pd, E2P_CMD,
213 (E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_RELOAD_));
214
215 do {
216 udelay(10);
217 if (!(smsc9420_reg_read(pd, E2P_CMD) & E2P_CMD_EPC_BUSY_))
218 return 0;
219 } while (timeout--);
220
221 netif_warn(pd, drv, pd->dev, "%s: Eeprom timed out\n", __func__);
222 return -EIO;
223 }
224
225 /* Standard ioctls for mii-tool */
226 static int smsc9420_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
227 {
228 if (!netif_running(dev) || !dev->phydev)
229 return -EINVAL;
230
231 return phy_mii_ioctl(dev->phydev, ifr, cmd);
232 }
233
234 static void smsc9420_ethtool_get_drvinfo(struct net_device *netdev,
235 struct ethtool_drvinfo *drvinfo)
236 {
237 struct smsc9420_pdata *pd = netdev_priv(netdev);
238
239 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
240 strlcpy(drvinfo->bus_info, pci_name(pd->pdev),
241 sizeof(drvinfo->bus_info));
242 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
243 }
244
245 static u32 smsc9420_ethtool_get_msglevel(struct net_device *netdev)
246 {
247 struct smsc9420_pdata *pd = netdev_priv(netdev);
248 return pd->msg_enable;
249 }
250
251 static void smsc9420_ethtool_set_msglevel(struct net_device *netdev, u32 data)
252 {
253 struct smsc9420_pdata *pd = netdev_priv(netdev);
254 pd->msg_enable = data;
255 }
256
257 static int smsc9420_ethtool_nway_reset(struct net_device *netdev)
258 {
259 if (!netdev->phydev)
260 return -ENODEV;
261
262 return phy_start_aneg(netdev->phydev);
263 }
264
265 static int smsc9420_ethtool_getregslen(struct net_device *dev)
266 {
267 /* all smsc9420 registers plus all phy registers */
268 return 0x100 + (32 * sizeof(u32));
269 }
270
271 static void
272 smsc9420_ethtool_getregs(struct net_device *dev, struct ethtool_regs *regs,
273 void *buf)
274 {
275 struct smsc9420_pdata *pd = netdev_priv(dev);
276 struct phy_device *phy_dev = dev->phydev;
277 unsigned int i, j = 0;
278 u32 *data = buf;
279
280 regs->version = smsc9420_reg_read(pd, ID_REV);
281 for (i = 0; i < 0x100; i += (sizeof(u32)))
282 data[j++] = smsc9420_reg_read(pd, i);
283
284 // cannot read phy registers if the net device is down
285 if (!phy_dev)
286 return;
287
288 for (i = 0; i <= 31; i++)
289 data[j++] = smsc9420_mii_read(phy_dev->mdio.bus,
290 phy_dev->mdio.addr, i);
291 }
292
293 static void smsc9420_eeprom_enable_access(struct smsc9420_pdata *pd)
294 {
295 unsigned int temp = smsc9420_reg_read(pd, GPIO_CFG);
296 temp &= ~GPIO_CFG_EEPR_EN_;
297 smsc9420_reg_write(pd, GPIO_CFG, temp);
298 msleep(1);
299 }
300
301 static int smsc9420_eeprom_send_cmd(struct smsc9420_pdata *pd, u32 op)
302 {
303 int timeout = 100;
304 u32 e2cmd;
305
306 netif_dbg(pd, hw, pd->dev, "op 0x%08x\n", op);
307 if (smsc9420_reg_read(pd, E2P_CMD) & E2P_CMD_EPC_BUSY_) {
308 netif_warn(pd, hw, pd->dev, "Busy at start\n");
309 return -EBUSY;
310 }
311
312 e2cmd = op | E2P_CMD_EPC_BUSY_;
313 smsc9420_reg_write(pd, E2P_CMD, e2cmd);
314
315 do {
316 msleep(1);
317 e2cmd = smsc9420_reg_read(pd, E2P_CMD);
318 } while ((e2cmd & E2P_CMD_EPC_BUSY_) && (--timeout));
319
320 if (!timeout) {
321 netif_info(pd, hw, pd->dev, "TIMED OUT\n");
322 return -EAGAIN;
323 }
324
325 if (e2cmd & E2P_CMD_EPC_TIMEOUT_) {
326 netif_info(pd, hw, pd->dev,
327 "Error occurred during eeprom operation\n");
328 return -EINVAL;
329 }
330
331 return 0;
332 }
333
334 static int smsc9420_eeprom_read_location(struct smsc9420_pdata *pd,
335 u8 address, u8 *data)
336 {
337 u32 op = E2P_CMD_EPC_CMD_READ_ | address;
338 int ret;
339
340 netif_dbg(pd, hw, pd->dev, "address 0x%x\n", address);
341 ret = smsc9420_eeprom_send_cmd(pd, op);
342
343 if (!ret)
344 data[address] = smsc9420_reg_read(pd, E2P_DATA);
345
346 return ret;
347 }
348
349 static int smsc9420_eeprom_write_location(struct smsc9420_pdata *pd,
350 u8 address, u8 data)
351 {
352 u32 op = E2P_CMD_EPC_CMD_ERASE_ | address;
353 int ret;
354
355 netif_dbg(pd, hw, pd->dev, "address 0x%x, data 0x%x\n", address, data);
356 ret = smsc9420_eeprom_send_cmd(pd, op);
357
358 if (!ret) {
359 op = E2P_CMD_EPC_CMD_WRITE_ | address;
360 smsc9420_reg_write(pd, E2P_DATA, (u32)data);
361 ret = smsc9420_eeprom_send_cmd(pd, op);
362 }
363
364 return ret;
365 }
366
367 static int smsc9420_ethtool_get_eeprom_len(struct net_device *dev)
368 {
369 return SMSC9420_EEPROM_SIZE;
370 }
371
372 static int smsc9420_ethtool_get_eeprom(struct net_device *dev,
373 struct ethtool_eeprom *eeprom, u8 *data)
374 {
375 struct smsc9420_pdata *pd = netdev_priv(dev);
376 u8 eeprom_data[SMSC9420_EEPROM_SIZE];
377 int len, i;
378
379 smsc9420_eeprom_enable_access(pd);
380
381 len = min(eeprom->len, SMSC9420_EEPROM_SIZE);
382 for (i = 0; i < len; i++) {
383 int ret = smsc9420_eeprom_read_location(pd, i, eeprom_data);
384 if (ret < 0) {
385 eeprom->len = 0;
386 return ret;
387 }
388 }
389
390 memcpy(data, &eeprom_data[eeprom->offset], len);
391 eeprom->magic = SMSC9420_EEPROM_MAGIC;
392 eeprom->len = len;
393 return 0;
394 }
395
396 static int smsc9420_ethtool_set_eeprom(struct net_device *dev,
397 struct ethtool_eeprom *eeprom, u8 *data)
398 {
399 struct smsc9420_pdata *pd = netdev_priv(dev);
400 int ret;
401
402 if (eeprom->magic != SMSC9420_EEPROM_MAGIC)
403 return -EINVAL;
404
405 smsc9420_eeprom_enable_access(pd);
406 smsc9420_eeprom_send_cmd(pd, E2P_CMD_EPC_CMD_EWEN_);
407 ret = smsc9420_eeprom_write_location(pd, eeprom->offset, *data);
408 smsc9420_eeprom_send_cmd(pd, E2P_CMD_EPC_CMD_EWDS_);
409
410 /* Single byte write, according to man page */
411 eeprom->len = 1;
412
413 return ret;
414 }
415
416 static const struct ethtool_ops smsc9420_ethtool_ops = {
417 .get_drvinfo = smsc9420_ethtool_get_drvinfo,
418 .get_msglevel = smsc9420_ethtool_get_msglevel,
419 .set_msglevel = smsc9420_ethtool_set_msglevel,
420 .nway_reset = smsc9420_ethtool_nway_reset,
421 .get_link = ethtool_op_get_link,
422 .get_eeprom_len = smsc9420_ethtool_get_eeprom_len,
423 .get_eeprom = smsc9420_ethtool_get_eeprom,
424 .set_eeprom = smsc9420_ethtool_set_eeprom,
425 .get_regs_len = smsc9420_ethtool_getregslen,
426 .get_regs = smsc9420_ethtool_getregs,
427 .get_ts_info = ethtool_op_get_ts_info,
428 .get_link_ksettings = phy_ethtool_get_link_ksettings,
429 .set_link_ksettings = phy_ethtool_set_link_ksettings,
430 };
431
432 /* Sets the device MAC address to dev_addr */
433 static void smsc9420_set_mac_address(struct net_device *dev)
434 {
435 struct smsc9420_pdata *pd = netdev_priv(dev);
436 u8 *dev_addr = dev->dev_addr;
437 u32 mac_high16 = (dev_addr[5] << 8) | dev_addr[4];
438 u32 mac_low32 = (dev_addr[3] << 24) | (dev_addr[2] << 16) |
439 (dev_addr[1] << 8) | dev_addr[0];
440
441 smsc9420_reg_write(pd, ADDRH, mac_high16);
442 smsc9420_reg_write(pd, ADDRL, mac_low32);
443 }
444
445 static void smsc9420_check_mac_address(struct net_device *dev)
446 {
447 struct smsc9420_pdata *pd = netdev_priv(dev);
448
449 /* Check if mac address has been specified when bringing interface up */
450 if (is_valid_ether_addr(dev->dev_addr)) {
451 smsc9420_set_mac_address(dev);
452 netif_dbg(pd, probe, pd->dev,
453 "MAC Address is specified by configuration\n");
454 } else {
455 /* Try reading mac address from device. if EEPROM is present
456 * it will already have been set */
457 u32 mac_high16 = smsc9420_reg_read(pd, ADDRH);
458 u32 mac_low32 = smsc9420_reg_read(pd, ADDRL);
459 dev->dev_addr[0] = (u8)(mac_low32);
460 dev->dev_addr[1] = (u8)(mac_low32 >> 8);
461 dev->dev_addr[2] = (u8)(mac_low32 >> 16);
462 dev->dev_addr[3] = (u8)(mac_low32 >> 24);
463 dev->dev_addr[4] = (u8)(mac_high16);
464 dev->dev_addr[5] = (u8)(mac_high16 >> 8);
465
466 if (is_valid_ether_addr(dev->dev_addr)) {
467 /* eeprom values are valid so use them */
468 netif_dbg(pd, probe, pd->dev,
469 "Mac Address is read from EEPROM\n");
470 } else {
471 /* eeprom values are invalid, generate random MAC */
472 eth_hw_addr_random(dev);
473 smsc9420_set_mac_address(dev);
474 netif_dbg(pd, probe, pd->dev,
475 "MAC Address is set to random\n");
476 }
477 }
478 }
479
480 static void smsc9420_stop_tx(struct smsc9420_pdata *pd)
481 {
482 u32 dmac_control, mac_cr, dma_intr_ena;
483 int timeout = 1000;
484
485 /* disable TX DMAC */
486 dmac_control = smsc9420_reg_read(pd, DMAC_CONTROL);
487 dmac_control &= (~DMAC_CONTROL_ST_);
488 smsc9420_reg_write(pd, DMAC_CONTROL, dmac_control);
489
490 /* Wait max 10ms for transmit process to stop */
491 while (--timeout) {
492 if (smsc9420_reg_read(pd, DMAC_STATUS) & DMAC_STS_TS_)
493 break;
494 udelay(10);
495 }
496
497 if (!timeout)
498 netif_warn(pd, ifdown, pd->dev, "TX DMAC failed to stop\n");
499
500 /* ACK Tx DMAC stop bit */
501 smsc9420_reg_write(pd, DMAC_STATUS, DMAC_STS_TXPS_);
502
503 /* mask TX DMAC interrupts */
504 dma_intr_ena = smsc9420_reg_read(pd, DMAC_INTR_ENA);
505 dma_intr_ena &= ~(DMAC_INTR_ENA_TX_);
506 smsc9420_reg_write(pd, DMAC_INTR_ENA, dma_intr_ena);
507 smsc9420_pci_flush_write(pd);
508
509 /* stop MAC TX */
510 mac_cr = smsc9420_reg_read(pd, MAC_CR) & (~MAC_CR_TXEN_);
511 smsc9420_reg_write(pd, MAC_CR, mac_cr);
512 smsc9420_pci_flush_write(pd);
513 }
514
515 static void smsc9420_free_tx_ring(struct smsc9420_pdata *pd)
516 {
517 int i;
518
519 BUG_ON(!pd->tx_ring);
520
521 if (!pd->tx_buffers)
522 return;
523
524 for (i = 0; i < TX_RING_SIZE; i++) {
525 struct sk_buff *skb = pd->tx_buffers[i].skb;
526
527 if (skb) {
528 BUG_ON(!pd->tx_buffers[i].mapping);
529 pci_unmap_single(pd->pdev, pd->tx_buffers[i].mapping,
530 skb->len, PCI_DMA_TODEVICE);
531 dev_kfree_skb_any(skb);
532 }
533
534 pd->tx_ring[i].status = 0;
535 pd->tx_ring[i].length = 0;
536 pd->tx_ring[i].buffer1 = 0;
537 pd->tx_ring[i].buffer2 = 0;
538 }
539 wmb();
540
541 kfree(pd->tx_buffers);
542 pd->tx_buffers = NULL;
543
544 pd->tx_ring_head = 0;
545 pd->tx_ring_tail = 0;
546 }
547
548 static void smsc9420_free_rx_ring(struct smsc9420_pdata *pd)
549 {
550 int i;
551
552 BUG_ON(!pd->rx_ring);
553
554 if (!pd->rx_buffers)
555 return;
556
557 for (i = 0; i < RX_RING_SIZE; i++) {
558 if (pd->rx_buffers[i].skb)
559 dev_kfree_skb_any(pd->rx_buffers[i].skb);
560
561 if (pd->rx_buffers[i].mapping)
562 pci_unmap_single(pd->pdev, pd->rx_buffers[i].mapping,
563 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
564
565 pd->rx_ring[i].status = 0;
566 pd->rx_ring[i].length = 0;
567 pd->rx_ring[i].buffer1 = 0;
568 pd->rx_ring[i].buffer2 = 0;
569 }
570 wmb();
571
572 kfree(pd->rx_buffers);
573 pd->rx_buffers = NULL;
574
575 pd->rx_ring_head = 0;
576 pd->rx_ring_tail = 0;
577 }
578
579 static void smsc9420_stop_rx(struct smsc9420_pdata *pd)
580 {
581 int timeout = 1000;
582 u32 mac_cr, dmac_control, dma_intr_ena;
583
584 /* mask RX DMAC interrupts */
585 dma_intr_ena = smsc9420_reg_read(pd, DMAC_INTR_ENA);
586 dma_intr_ena &= (~DMAC_INTR_ENA_RX_);
587 smsc9420_reg_write(pd, DMAC_INTR_ENA, dma_intr_ena);
588 smsc9420_pci_flush_write(pd);
589
590 /* stop RX MAC prior to stoping DMA */
591 mac_cr = smsc9420_reg_read(pd, MAC_CR) & (~MAC_CR_RXEN_);
592 smsc9420_reg_write(pd, MAC_CR, mac_cr);
593 smsc9420_pci_flush_write(pd);
594
595 /* stop RX DMAC */
596 dmac_control = smsc9420_reg_read(pd, DMAC_CONTROL);
597 dmac_control &= (~DMAC_CONTROL_SR_);
598 smsc9420_reg_write(pd, DMAC_CONTROL, dmac_control);
599 smsc9420_pci_flush_write(pd);
600
601 /* wait up to 10ms for receive to stop */
602 while (--timeout) {
603 if (smsc9420_reg_read(pd, DMAC_STATUS) & DMAC_STS_RS_)
604 break;
605 udelay(10);
606 }
607
608 if (!timeout)
609 netif_warn(pd, ifdown, pd->dev,
610 "RX DMAC did not stop! timeout\n");
611
612 /* ACK the Rx DMAC stop bit */
613 smsc9420_reg_write(pd, DMAC_STATUS, DMAC_STS_RXPS_);
614 }
615
616 static irqreturn_t smsc9420_isr(int irq, void *dev_id)
617 {
618 struct smsc9420_pdata *pd = dev_id;
619 u32 int_cfg, int_sts, int_ctl;
620 irqreturn_t ret = IRQ_NONE;
621 ulong flags;
622
623 BUG_ON(!pd);
624 BUG_ON(!pd->ioaddr);
625
626 int_cfg = smsc9420_reg_read(pd, INT_CFG);
627
628 /* check if it's our interrupt */
629 if ((int_cfg & (INT_CFG_IRQ_EN_ | INT_CFG_IRQ_INT_)) !=
630 (INT_CFG_IRQ_EN_ | INT_CFG_IRQ_INT_))
631 return IRQ_NONE;
632
633 int_sts = smsc9420_reg_read(pd, INT_STAT);
634
635 if (likely(INT_STAT_DMAC_INT_ & int_sts)) {
636 u32 status = smsc9420_reg_read(pd, DMAC_STATUS);
637 u32 ints_to_clear = 0;
638
639 if (status & DMAC_STS_TX_) {
640 ints_to_clear |= (DMAC_STS_TX_ | DMAC_STS_NIS_);
641 netif_wake_queue(pd->dev);
642 }
643
644 if (status & DMAC_STS_RX_) {
645 /* mask RX DMAC interrupts */
646 u32 dma_intr_ena = smsc9420_reg_read(pd, DMAC_INTR_ENA);
647 dma_intr_ena &= (~DMAC_INTR_ENA_RX_);
648 smsc9420_reg_write(pd, DMAC_INTR_ENA, dma_intr_ena);
649 smsc9420_pci_flush_write(pd);
650
651 ints_to_clear |= (DMAC_STS_RX_ | DMAC_STS_NIS_);
652 napi_schedule(&pd->napi);
653 }
654
655 if (ints_to_clear)
656 smsc9420_reg_write(pd, DMAC_STATUS, ints_to_clear);
657
658 ret = IRQ_HANDLED;
659 }
660
661 if (unlikely(INT_STAT_SW_INT_ & int_sts)) {
662 /* mask software interrupt */
663 spin_lock_irqsave(&pd->int_lock, flags);
664 int_ctl = smsc9420_reg_read(pd, INT_CTL);
665 int_ctl &= (~INT_CTL_SW_INT_EN_);
666 smsc9420_reg_write(pd, INT_CTL, int_ctl);
667 spin_unlock_irqrestore(&pd->int_lock, flags);
668
669 smsc9420_reg_write(pd, INT_STAT, INT_STAT_SW_INT_);
670 pd->software_irq_signal = true;
671 smp_wmb();
672
673 ret = IRQ_HANDLED;
674 }
675
676 /* to ensure PCI write completion, we must perform a PCI read */
677 smsc9420_pci_flush_write(pd);
678
679 return ret;
680 }
681
682 #ifdef CONFIG_NET_POLL_CONTROLLER
683 static void smsc9420_poll_controller(struct net_device *dev)
684 {
685 struct smsc9420_pdata *pd = netdev_priv(dev);
686 const int irq = pd->pdev->irq;
687
688 disable_irq(irq);
689 smsc9420_isr(0, dev);
690 enable_irq(irq);
691 }
692 #endif /* CONFIG_NET_POLL_CONTROLLER */
693
694 static void smsc9420_dmac_soft_reset(struct smsc9420_pdata *pd)
695 {
696 smsc9420_reg_write(pd, BUS_MODE, BUS_MODE_SWR_);
697 smsc9420_reg_read(pd, BUS_MODE);
698 udelay(2);
699 if (smsc9420_reg_read(pd, BUS_MODE) & BUS_MODE_SWR_)
700 netif_warn(pd, drv, pd->dev, "Software reset not cleared\n");
701 }
702
703 static int smsc9420_stop(struct net_device *dev)
704 {
705 struct smsc9420_pdata *pd = netdev_priv(dev);
706 u32 int_cfg;
707 ulong flags;
708
709 BUG_ON(!pd);
710 BUG_ON(!dev->phydev);
711
712 /* disable master interrupt */
713 spin_lock_irqsave(&pd->int_lock, flags);
714 int_cfg = smsc9420_reg_read(pd, INT_CFG) & (~INT_CFG_IRQ_EN_);
715 smsc9420_reg_write(pd, INT_CFG, int_cfg);
716 spin_unlock_irqrestore(&pd->int_lock, flags);
717
718 netif_tx_disable(dev);
719 napi_disable(&pd->napi);
720
721 smsc9420_stop_tx(pd);
722 smsc9420_free_tx_ring(pd);
723
724 smsc9420_stop_rx(pd);
725 smsc9420_free_rx_ring(pd);
726
727 free_irq(pd->pdev->irq, pd);
728
729 smsc9420_dmac_soft_reset(pd);
730
731 phy_stop(dev->phydev);
732
733 phy_disconnect(dev->phydev);
734 mdiobus_unregister(pd->mii_bus);
735 mdiobus_free(pd->mii_bus);
736
737 return 0;
738 }
739
740 static void smsc9420_rx_count_stats(struct net_device *dev, u32 desc_status)
741 {
742 if (unlikely(desc_status & RDES0_ERROR_SUMMARY_)) {
743 dev->stats.rx_errors++;
744 if (desc_status & RDES0_DESCRIPTOR_ERROR_)
745 dev->stats.rx_over_errors++;
746 else if (desc_status & (RDES0_FRAME_TOO_LONG_ |
747 RDES0_RUNT_FRAME_ | RDES0_COLLISION_SEEN_))
748 dev->stats.rx_frame_errors++;
749 else if (desc_status & RDES0_CRC_ERROR_)
750 dev->stats.rx_crc_errors++;
751 }
752
753 if (unlikely(desc_status & RDES0_LENGTH_ERROR_))
754 dev->stats.rx_length_errors++;
755
756 if (unlikely(!((desc_status & RDES0_LAST_DESCRIPTOR_) &&
757 (desc_status & RDES0_FIRST_DESCRIPTOR_))))
758 dev->stats.rx_length_errors++;
759
760 if (desc_status & RDES0_MULTICAST_FRAME_)
761 dev->stats.multicast++;
762 }
763
764 static void smsc9420_rx_handoff(struct smsc9420_pdata *pd, const int index,
765 const u32 status)
766 {
767 struct net_device *dev = pd->dev;
768 struct sk_buff *skb;
769 u16 packet_length = (status & RDES0_FRAME_LENGTH_MASK_)
770 >> RDES0_FRAME_LENGTH_SHFT_;
771
772 /* remove crc from packet lendth */
773 packet_length -= 4;
774
775 if (pd->rx_csum)
776 packet_length -= 2;
777
778 dev->stats.rx_packets++;
779 dev->stats.rx_bytes += packet_length;
780
781 pci_unmap_single(pd->pdev, pd->rx_buffers[index].mapping,
782 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
783 pd->rx_buffers[index].mapping = 0;
784
785 skb = pd->rx_buffers[index].skb;
786 pd->rx_buffers[index].skb = NULL;
787
788 if (pd->rx_csum) {
789 u16 hw_csum = get_unaligned_le16(skb_tail_pointer(skb) +
790 NET_IP_ALIGN + packet_length + 4);
791 put_unaligned_le16(hw_csum, &skb->csum);
792 skb->ip_summed = CHECKSUM_COMPLETE;
793 }
794
795 skb_reserve(skb, NET_IP_ALIGN);
796 skb_put(skb, packet_length);
797
798 skb->protocol = eth_type_trans(skb, dev);
799
800 netif_receive_skb(skb);
801 }
802
803 static int smsc9420_alloc_rx_buffer(struct smsc9420_pdata *pd, int index)
804 {
805 struct sk_buff *skb = netdev_alloc_skb(pd->dev, PKT_BUF_SZ);
806 dma_addr_t mapping;
807
808 BUG_ON(pd->rx_buffers[index].skb);
809 BUG_ON(pd->rx_buffers[index].mapping);
810
811 if (unlikely(!skb))
812 return -ENOMEM;
813
814 mapping = pci_map_single(pd->pdev, skb_tail_pointer(skb),
815 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
816 if (pci_dma_mapping_error(pd->pdev, mapping)) {
817 dev_kfree_skb_any(skb);
818 netif_warn(pd, rx_err, pd->dev, "pci_map_single failed!\n");
819 return -ENOMEM;
820 }
821
822 pd->rx_buffers[index].skb = skb;
823 pd->rx_buffers[index].mapping = mapping;
824 pd->rx_ring[index].buffer1 = mapping + NET_IP_ALIGN;
825 pd->rx_ring[index].status = RDES0_OWN_;
826 wmb();
827
828 return 0;
829 }
830
831 static void smsc9420_alloc_new_rx_buffers(struct smsc9420_pdata *pd)
832 {
833 while (pd->rx_ring_tail != pd->rx_ring_head) {
834 if (smsc9420_alloc_rx_buffer(pd, pd->rx_ring_tail))
835 break;
836
837 pd->rx_ring_tail = (pd->rx_ring_tail + 1) % RX_RING_SIZE;
838 }
839 }
840
841 static int smsc9420_rx_poll(struct napi_struct *napi, int budget)
842 {
843 struct smsc9420_pdata *pd =
844 container_of(napi, struct smsc9420_pdata, napi);
845 struct net_device *dev = pd->dev;
846 u32 drop_frame_cnt, dma_intr_ena, status;
847 int work_done;
848
849 for (work_done = 0; work_done < budget; work_done++) {
850 rmb();
851 status = pd->rx_ring[pd->rx_ring_head].status;
852
853 /* stop if DMAC owns this dma descriptor */
854 if (status & RDES0_OWN_)
855 break;
856
857 smsc9420_rx_count_stats(dev, status);
858 smsc9420_rx_handoff(pd, pd->rx_ring_head, status);
859 pd->rx_ring_head = (pd->rx_ring_head + 1) % RX_RING_SIZE;
860 smsc9420_alloc_new_rx_buffers(pd);
861 }
862
863 drop_frame_cnt = smsc9420_reg_read(pd, MISS_FRAME_CNTR);
864 dev->stats.rx_dropped +=
865 (drop_frame_cnt & 0xFFFF) + ((drop_frame_cnt >> 17) & 0x3FF);
866
867 /* Kick RXDMA */
868 smsc9420_reg_write(pd, RX_POLL_DEMAND, 1);
869 smsc9420_pci_flush_write(pd);
870
871 if (work_done < budget) {
872 napi_complete(&pd->napi);
873
874 /* re-enable RX DMA interrupts */
875 dma_intr_ena = smsc9420_reg_read(pd, DMAC_INTR_ENA);
876 dma_intr_ena |= (DMAC_INTR_ENA_RX_ | DMAC_INTR_ENA_NIS_);
877 smsc9420_reg_write(pd, DMAC_INTR_ENA, dma_intr_ena);
878 smsc9420_pci_flush_write(pd);
879 }
880 return work_done;
881 }
882
883 static void
884 smsc9420_tx_update_stats(struct net_device *dev, u32 status, u32 length)
885 {
886 if (unlikely(status & TDES0_ERROR_SUMMARY_)) {
887 dev->stats.tx_errors++;
888 if (status & (TDES0_EXCESSIVE_DEFERRAL_ |
889 TDES0_EXCESSIVE_COLLISIONS_))
890 dev->stats.tx_aborted_errors++;
891
892 if (status & (TDES0_LOSS_OF_CARRIER_ | TDES0_NO_CARRIER_))
893 dev->stats.tx_carrier_errors++;
894 } else {
895 dev->stats.tx_packets++;
896 dev->stats.tx_bytes += (length & 0x7FF);
897 }
898
899 if (unlikely(status & TDES0_EXCESSIVE_COLLISIONS_)) {
900 dev->stats.collisions += 16;
901 } else {
902 dev->stats.collisions +=
903 (status & TDES0_COLLISION_COUNT_MASK_) >>
904 TDES0_COLLISION_COUNT_SHFT_;
905 }
906
907 if (unlikely(status & TDES0_HEARTBEAT_FAIL_))
908 dev->stats.tx_heartbeat_errors++;
909 }
910
911 /* Check for completed dma transfers, update stats and free skbs */
912 static void smsc9420_complete_tx(struct net_device *dev)
913 {
914 struct smsc9420_pdata *pd = netdev_priv(dev);
915
916 while (pd->tx_ring_tail != pd->tx_ring_head) {
917 int index = pd->tx_ring_tail;
918 u32 status, length;
919
920 rmb();
921 status = pd->tx_ring[index].status;
922 length = pd->tx_ring[index].length;
923
924 /* Check if DMA still owns this descriptor */
925 if (unlikely(TDES0_OWN_ & status))
926 break;
927
928 smsc9420_tx_update_stats(dev, status, length);
929
930 BUG_ON(!pd->tx_buffers[index].skb);
931 BUG_ON(!pd->tx_buffers[index].mapping);
932
933 pci_unmap_single(pd->pdev, pd->tx_buffers[index].mapping,
934 pd->tx_buffers[index].skb->len, PCI_DMA_TODEVICE);
935 pd->tx_buffers[index].mapping = 0;
936
937 dev_kfree_skb_any(pd->tx_buffers[index].skb);
938 pd->tx_buffers[index].skb = NULL;
939
940 pd->tx_ring[index].buffer1 = 0;
941 wmb();
942
943 pd->tx_ring_tail = (pd->tx_ring_tail + 1) % TX_RING_SIZE;
944 }
945 }
946
947 static netdev_tx_t smsc9420_hard_start_xmit(struct sk_buff *skb,
948 struct net_device *dev)
949 {
950 struct smsc9420_pdata *pd = netdev_priv(dev);
951 dma_addr_t mapping;
952 int index = pd->tx_ring_head;
953 u32 tmp_desc1;
954 bool about_to_take_last_desc =
955 (((pd->tx_ring_head + 2) % TX_RING_SIZE) == pd->tx_ring_tail);
956
957 smsc9420_complete_tx(dev);
958
959 rmb();
960 BUG_ON(pd->tx_ring[index].status & TDES0_OWN_);
961 BUG_ON(pd->tx_buffers[index].skb);
962 BUG_ON(pd->tx_buffers[index].mapping);
963
964 mapping = pci_map_single(pd->pdev, skb->data,
965 skb->len, PCI_DMA_TODEVICE);
966 if (pci_dma_mapping_error(pd->pdev, mapping)) {
967 netif_warn(pd, tx_err, pd->dev,
968 "pci_map_single failed, dropping packet\n");
969 return NETDEV_TX_BUSY;
970 }
971
972 pd->tx_buffers[index].skb = skb;
973 pd->tx_buffers[index].mapping = mapping;
974
975 tmp_desc1 = (TDES1_LS_ | ((u32)skb->len & 0x7FF));
976 if (unlikely(about_to_take_last_desc)) {
977 tmp_desc1 |= TDES1_IC_;
978 netif_stop_queue(pd->dev);
979 }
980
981 /* check if we are at the last descriptor and need to set EOR */
982 if (unlikely(index == (TX_RING_SIZE - 1)))
983 tmp_desc1 |= TDES1_TER_;
984
985 pd->tx_ring[index].buffer1 = mapping;
986 pd->tx_ring[index].length = tmp_desc1;
987 wmb();
988
989 /* increment head */
990 pd->tx_ring_head = (pd->tx_ring_head + 1) % TX_RING_SIZE;
991
992 /* assign ownership to DMAC */
993 pd->tx_ring[index].status = TDES0_OWN_;
994 wmb();
995
996 skb_tx_timestamp(skb);
997
998 /* kick the DMA */
999 smsc9420_reg_write(pd, TX_POLL_DEMAND, 1);
1000 smsc9420_pci_flush_write(pd);
1001
1002 return NETDEV_TX_OK;
1003 }
1004
1005 static struct net_device_stats *smsc9420_get_stats(struct net_device *dev)
1006 {
1007 struct smsc9420_pdata *pd = netdev_priv(dev);
1008 u32 counter = smsc9420_reg_read(pd, MISS_FRAME_CNTR);
1009 dev->stats.rx_dropped +=
1010 (counter & 0x0000FFFF) + ((counter >> 17) & 0x000003FF);
1011 return &dev->stats;
1012 }
1013
1014 static void smsc9420_set_multicast_list(struct net_device *dev)
1015 {
1016 struct smsc9420_pdata *pd = netdev_priv(dev);
1017 u32 mac_cr = smsc9420_reg_read(pd, MAC_CR);
1018
1019 if (dev->flags & IFF_PROMISC) {
1020 netif_dbg(pd, hw, pd->dev, "Promiscuous Mode Enabled\n");
1021 mac_cr |= MAC_CR_PRMS_;
1022 mac_cr &= (~MAC_CR_MCPAS_);
1023 mac_cr &= (~MAC_CR_HPFILT_);
1024 } else if (dev->flags & IFF_ALLMULTI) {
1025 netif_dbg(pd, hw, pd->dev, "Receive all Multicast Enabled\n");
1026 mac_cr &= (~MAC_CR_PRMS_);
1027 mac_cr |= MAC_CR_MCPAS_;
1028 mac_cr &= (~MAC_CR_HPFILT_);
1029 } else if (!netdev_mc_empty(dev)) {
1030 struct netdev_hw_addr *ha;
1031 u32 hash_lo = 0, hash_hi = 0;
1032
1033 netif_dbg(pd, hw, pd->dev, "Multicast filter enabled\n");
1034 netdev_for_each_mc_addr(ha, dev) {
1035 u32 bit_num = smsc9420_hash(ha->addr);
1036 u32 mask = 1 << (bit_num & 0x1F);
1037
1038 if (bit_num & 0x20)
1039 hash_hi |= mask;
1040 else
1041 hash_lo |= mask;
1042
1043 }
1044 smsc9420_reg_write(pd, HASHH, hash_hi);
1045 smsc9420_reg_write(pd, HASHL, hash_lo);
1046
1047 mac_cr &= (~MAC_CR_PRMS_);
1048 mac_cr &= (~MAC_CR_MCPAS_);
1049 mac_cr |= MAC_CR_HPFILT_;
1050 } else {
1051 netif_dbg(pd, hw, pd->dev, "Receive own packets only\n");
1052 smsc9420_reg_write(pd, HASHH, 0);
1053 smsc9420_reg_write(pd, HASHL, 0);
1054
1055 mac_cr &= (~MAC_CR_PRMS_);
1056 mac_cr &= (~MAC_CR_MCPAS_);
1057 mac_cr &= (~MAC_CR_HPFILT_);
1058 }
1059
1060 smsc9420_reg_write(pd, MAC_CR, mac_cr);
1061 smsc9420_pci_flush_write(pd);
1062 }
1063
1064 static void smsc9420_phy_update_flowcontrol(struct smsc9420_pdata *pd)
1065 {
1066 struct net_device *dev = pd->dev;
1067 struct phy_device *phy_dev = dev->phydev;
1068 u32 flow;
1069
1070 if (phy_dev->duplex == DUPLEX_FULL) {
1071 u16 lcladv = phy_read(phy_dev, MII_ADVERTISE);
1072 u16 rmtadv = phy_read(phy_dev, MII_LPA);
1073 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1074
1075 if (cap & FLOW_CTRL_RX)
1076 flow = 0xFFFF0002;
1077 else
1078 flow = 0;
1079
1080 netif_info(pd, link, pd->dev, "rx pause %s, tx pause %s\n",
1081 cap & FLOW_CTRL_RX ? "enabled" : "disabled",
1082 cap & FLOW_CTRL_TX ? "enabled" : "disabled");
1083 } else {
1084 netif_info(pd, link, pd->dev, "half duplex\n");
1085 flow = 0;
1086 }
1087
1088 smsc9420_reg_write(pd, FLOW, flow);
1089 }
1090
1091 /* Update link mode if anything has changed. Called periodically when the
1092 * PHY is in polling mode, even if nothing has changed. */
1093 static void smsc9420_phy_adjust_link(struct net_device *dev)
1094 {
1095 struct smsc9420_pdata *pd = netdev_priv(dev);
1096 struct phy_device *phy_dev = dev->phydev;
1097 int carrier;
1098
1099 if (phy_dev->duplex != pd->last_duplex) {
1100 u32 mac_cr = smsc9420_reg_read(pd, MAC_CR);
1101 if (phy_dev->duplex) {
1102 netif_dbg(pd, link, pd->dev, "full duplex mode\n");
1103 mac_cr |= MAC_CR_FDPX_;
1104 } else {
1105 netif_dbg(pd, link, pd->dev, "half duplex mode\n");
1106 mac_cr &= ~MAC_CR_FDPX_;
1107 }
1108 smsc9420_reg_write(pd, MAC_CR, mac_cr);
1109
1110 smsc9420_phy_update_flowcontrol(pd);
1111 pd->last_duplex = phy_dev->duplex;
1112 }
1113
1114 carrier = netif_carrier_ok(dev);
1115 if (carrier != pd->last_carrier) {
1116 if (carrier)
1117 netif_dbg(pd, link, pd->dev, "carrier OK\n");
1118 else
1119 netif_dbg(pd, link, pd->dev, "no carrier\n");
1120 pd->last_carrier = carrier;
1121 }
1122 }
1123
1124 static int smsc9420_mii_probe(struct net_device *dev)
1125 {
1126 struct smsc9420_pdata *pd = netdev_priv(dev);
1127 struct phy_device *phydev = NULL;
1128
1129 BUG_ON(dev->phydev);
1130
1131 /* Device only supports internal PHY at address 1 */
1132 phydev = mdiobus_get_phy(pd->mii_bus, 1);
1133 if (!phydev) {
1134 netdev_err(dev, "no PHY found at address 1\n");
1135 return -ENODEV;
1136 }
1137
1138 phydev = phy_connect(dev, phydev_name(phydev),
1139 smsc9420_phy_adjust_link, PHY_INTERFACE_MODE_MII);
1140
1141 if (IS_ERR(phydev)) {
1142 netdev_err(dev, "Could not attach to PHY\n");
1143 return PTR_ERR(phydev);
1144 }
1145
1146 /* mask with MAC supported features */
1147 phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
1148 SUPPORTED_Asym_Pause);
1149 phydev->advertising = phydev->supported;
1150
1151 phy_attached_info(phydev);
1152
1153 pd->last_duplex = -1;
1154 pd->last_carrier = -1;
1155
1156 return 0;
1157 }
1158
1159 static int smsc9420_mii_init(struct net_device *dev)
1160 {
1161 struct smsc9420_pdata *pd = netdev_priv(dev);
1162 int err = -ENXIO;
1163
1164 pd->mii_bus = mdiobus_alloc();
1165 if (!pd->mii_bus) {
1166 err = -ENOMEM;
1167 goto err_out_1;
1168 }
1169 pd->mii_bus->name = DRV_MDIONAME;
1170 snprintf(pd->mii_bus->id, MII_BUS_ID_SIZE, "%x",
1171 (pd->pdev->bus->number << 8) | pd->pdev->devfn);
1172 pd->mii_bus->priv = pd;
1173 pd->mii_bus->read = smsc9420_mii_read;
1174 pd->mii_bus->write = smsc9420_mii_write;
1175
1176 /* Mask all PHYs except ID 1 (internal) */
1177 pd->mii_bus->phy_mask = ~(1 << 1);
1178
1179 if (mdiobus_register(pd->mii_bus)) {
1180 netif_warn(pd, probe, pd->dev, "Error registering mii bus\n");
1181 goto err_out_free_bus_2;
1182 }
1183
1184 if (smsc9420_mii_probe(dev) < 0) {
1185 netif_warn(pd, probe, pd->dev, "Error probing mii bus\n");
1186 goto err_out_unregister_bus_3;
1187 }
1188
1189 return 0;
1190
1191 err_out_unregister_bus_3:
1192 mdiobus_unregister(pd->mii_bus);
1193 err_out_free_bus_2:
1194 mdiobus_free(pd->mii_bus);
1195 err_out_1:
1196 return err;
1197 }
1198
1199 static int smsc9420_alloc_tx_ring(struct smsc9420_pdata *pd)
1200 {
1201 int i;
1202
1203 BUG_ON(!pd->tx_ring);
1204
1205 pd->tx_buffers = kmalloc_array(TX_RING_SIZE,
1206 sizeof(struct smsc9420_ring_info),
1207 GFP_KERNEL);
1208 if (!pd->tx_buffers)
1209 return -ENOMEM;
1210
1211 /* Initialize the TX Ring */
1212 for (i = 0; i < TX_RING_SIZE; i++) {
1213 pd->tx_buffers[i].skb = NULL;
1214 pd->tx_buffers[i].mapping = 0;
1215 pd->tx_ring[i].status = 0;
1216 pd->tx_ring[i].length = 0;
1217 pd->tx_ring[i].buffer1 = 0;
1218 pd->tx_ring[i].buffer2 = 0;
1219 }
1220 pd->tx_ring[TX_RING_SIZE - 1].length = TDES1_TER_;
1221 wmb();
1222
1223 pd->tx_ring_head = 0;
1224 pd->tx_ring_tail = 0;
1225
1226 smsc9420_reg_write(pd, TX_BASE_ADDR, pd->tx_dma_addr);
1227 smsc9420_pci_flush_write(pd);
1228
1229 return 0;
1230 }
1231
1232 static int smsc9420_alloc_rx_ring(struct smsc9420_pdata *pd)
1233 {
1234 int i;
1235
1236 BUG_ON(!pd->rx_ring);
1237
1238 pd->rx_buffers = kmalloc_array(RX_RING_SIZE,
1239 sizeof(struct smsc9420_ring_info),
1240 GFP_KERNEL);
1241 if (pd->rx_buffers == NULL)
1242 goto out;
1243
1244 /* initialize the rx ring */
1245 for (i = 0; i < RX_RING_SIZE; i++) {
1246 pd->rx_ring[i].status = 0;
1247 pd->rx_ring[i].length = PKT_BUF_SZ;
1248 pd->rx_ring[i].buffer2 = 0;
1249 pd->rx_buffers[i].skb = NULL;
1250 pd->rx_buffers[i].mapping = 0;
1251 }
1252 pd->rx_ring[RX_RING_SIZE - 1].length = (PKT_BUF_SZ | RDES1_RER_);
1253
1254 /* now allocate the entire ring of skbs */
1255 for (i = 0; i < RX_RING_SIZE; i++) {
1256 if (smsc9420_alloc_rx_buffer(pd, i)) {
1257 netif_warn(pd, ifup, pd->dev,
1258 "failed to allocate rx skb %d\n", i);
1259 goto out_free_rx_skbs;
1260 }
1261 }
1262
1263 pd->rx_ring_head = 0;
1264 pd->rx_ring_tail = 0;
1265
1266 smsc9420_reg_write(pd, VLAN1, ETH_P_8021Q);
1267 netif_dbg(pd, ifup, pd->dev, "VLAN1 = 0x%08x\n",
1268 smsc9420_reg_read(pd, VLAN1));
1269
1270 if (pd->rx_csum) {
1271 /* Enable RX COE */
1272 u32 coe = smsc9420_reg_read(pd, COE_CR) | RX_COE_EN;
1273 smsc9420_reg_write(pd, COE_CR, coe);
1274 netif_dbg(pd, ifup, pd->dev, "COE_CR = 0x%08x\n", coe);
1275 }
1276
1277 smsc9420_reg_write(pd, RX_BASE_ADDR, pd->rx_dma_addr);
1278 smsc9420_pci_flush_write(pd);
1279
1280 return 0;
1281
1282 out_free_rx_skbs:
1283 smsc9420_free_rx_ring(pd);
1284 out:
1285 return -ENOMEM;
1286 }
1287
1288 static int smsc9420_open(struct net_device *dev)
1289 {
1290 struct smsc9420_pdata *pd = netdev_priv(dev);
1291 u32 bus_mode, mac_cr, dmac_control, int_cfg, dma_intr_ena, int_ctl;
1292 const int irq = pd->pdev->irq;
1293 unsigned long flags;
1294 int result = 0, timeout;
1295
1296 if (!is_valid_ether_addr(dev->dev_addr)) {
1297 netif_warn(pd, ifup, pd->dev,
1298 "dev_addr is not a valid MAC address\n");
1299 result = -EADDRNOTAVAIL;
1300 goto out_0;
1301 }
1302
1303 netif_carrier_off(dev);
1304
1305 /* disable, mask and acknowledge all interrupts */
1306 spin_lock_irqsave(&pd->int_lock, flags);
1307 int_cfg = smsc9420_reg_read(pd, INT_CFG) & (~INT_CFG_IRQ_EN_);
1308 smsc9420_reg_write(pd, INT_CFG, int_cfg);
1309 smsc9420_reg_write(pd, INT_CTL, 0);
1310 spin_unlock_irqrestore(&pd->int_lock, flags);
1311 smsc9420_reg_write(pd, DMAC_INTR_ENA, 0);
1312 smsc9420_reg_write(pd, INT_STAT, 0xFFFFFFFF);
1313 smsc9420_pci_flush_write(pd);
1314
1315 result = request_irq(irq, smsc9420_isr, IRQF_SHARED, DRV_NAME, pd);
1316 if (result) {
1317 netif_warn(pd, ifup, pd->dev, "Unable to use IRQ = %d\n", irq);
1318 result = -ENODEV;
1319 goto out_0;
1320 }
1321
1322 smsc9420_dmac_soft_reset(pd);
1323
1324 /* make sure MAC_CR is sane */
1325 smsc9420_reg_write(pd, MAC_CR, 0);
1326
1327 smsc9420_set_mac_address(dev);
1328
1329 /* Configure GPIO pins to drive LEDs */
1330 smsc9420_reg_write(pd, GPIO_CFG,
1331 (GPIO_CFG_LED_3_ | GPIO_CFG_LED_2_ | GPIO_CFG_LED_1_));
1332
1333 bus_mode = BUS_MODE_DMA_BURST_LENGTH_16;
1334
1335 #ifdef __BIG_ENDIAN
1336 bus_mode |= BUS_MODE_DBO_;
1337 #endif
1338
1339 smsc9420_reg_write(pd, BUS_MODE, bus_mode);
1340
1341 smsc9420_pci_flush_write(pd);
1342
1343 /* set bus master bridge arbitration priority for Rx and TX DMA */
1344 smsc9420_reg_write(pd, BUS_CFG, BUS_CFG_RXTXWEIGHT_4_1);
1345
1346 smsc9420_reg_write(pd, DMAC_CONTROL,
1347 (DMAC_CONTROL_SF_ | DMAC_CONTROL_OSF_));
1348
1349 smsc9420_pci_flush_write(pd);
1350
1351 /* test the IRQ connection to the ISR */
1352 netif_dbg(pd, ifup, pd->dev, "Testing ISR using IRQ %d\n", irq);
1353 pd->software_irq_signal = false;
1354
1355 spin_lock_irqsave(&pd->int_lock, flags);
1356 /* configure interrupt deassertion timer and enable interrupts */
1357 int_cfg = smsc9420_reg_read(pd, INT_CFG) | INT_CFG_IRQ_EN_;
1358 int_cfg &= ~(INT_CFG_INT_DEAS_MASK);
1359 int_cfg |= (INT_DEAS_TIME & INT_CFG_INT_DEAS_MASK);
1360 smsc9420_reg_write(pd, INT_CFG, int_cfg);
1361
1362 /* unmask software interrupt */
1363 int_ctl = smsc9420_reg_read(pd, INT_CTL) | INT_CTL_SW_INT_EN_;
1364 smsc9420_reg_write(pd, INT_CTL, int_ctl);
1365 spin_unlock_irqrestore(&pd->int_lock, flags);
1366 smsc9420_pci_flush_write(pd);
1367
1368 timeout = 1000;
1369 while (timeout--) {
1370 if (pd->software_irq_signal)
1371 break;
1372 msleep(1);
1373 }
1374
1375 /* disable interrupts */
1376 spin_lock_irqsave(&pd->int_lock, flags);
1377 int_cfg = smsc9420_reg_read(pd, INT_CFG) & (~INT_CFG_IRQ_EN_);
1378 smsc9420_reg_write(pd, INT_CFG, int_cfg);
1379 spin_unlock_irqrestore(&pd->int_lock, flags);
1380
1381 if (!pd->software_irq_signal) {
1382 netif_warn(pd, ifup, pd->dev, "ISR failed signaling test\n");
1383 result = -ENODEV;
1384 goto out_free_irq_1;
1385 }
1386
1387 netif_dbg(pd, ifup, pd->dev, "ISR passed test using IRQ %d\n", irq);
1388
1389 result = smsc9420_alloc_tx_ring(pd);
1390 if (result) {
1391 netif_warn(pd, ifup, pd->dev,
1392 "Failed to Initialize tx dma ring\n");
1393 result = -ENOMEM;
1394 goto out_free_irq_1;
1395 }
1396
1397 result = smsc9420_alloc_rx_ring(pd);
1398 if (result) {
1399 netif_warn(pd, ifup, pd->dev,
1400 "Failed to Initialize rx dma ring\n");
1401 result = -ENOMEM;
1402 goto out_free_tx_ring_2;
1403 }
1404
1405 result = smsc9420_mii_init(dev);
1406 if (result) {
1407 netif_warn(pd, ifup, pd->dev, "Failed to initialize Phy\n");
1408 result = -ENODEV;
1409 goto out_free_rx_ring_3;
1410 }
1411
1412 /* Bring the PHY up */
1413 phy_start(dev->phydev);
1414
1415 napi_enable(&pd->napi);
1416
1417 /* start tx and rx */
1418 mac_cr = smsc9420_reg_read(pd, MAC_CR) | MAC_CR_TXEN_ | MAC_CR_RXEN_;
1419 smsc9420_reg_write(pd, MAC_CR, mac_cr);
1420
1421 dmac_control = smsc9420_reg_read(pd, DMAC_CONTROL);
1422 dmac_control |= DMAC_CONTROL_ST_ | DMAC_CONTROL_SR_;
1423 smsc9420_reg_write(pd, DMAC_CONTROL, dmac_control);
1424 smsc9420_pci_flush_write(pd);
1425
1426 dma_intr_ena = smsc9420_reg_read(pd, DMAC_INTR_ENA);
1427 dma_intr_ena |=
1428 (DMAC_INTR_ENA_TX_ | DMAC_INTR_ENA_RX_ | DMAC_INTR_ENA_NIS_);
1429 smsc9420_reg_write(pd, DMAC_INTR_ENA, dma_intr_ena);
1430 smsc9420_pci_flush_write(pd);
1431
1432 netif_wake_queue(dev);
1433
1434 smsc9420_reg_write(pd, RX_POLL_DEMAND, 1);
1435
1436 /* enable interrupts */
1437 spin_lock_irqsave(&pd->int_lock, flags);
1438 int_cfg = smsc9420_reg_read(pd, INT_CFG) | INT_CFG_IRQ_EN_;
1439 smsc9420_reg_write(pd, INT_CFG, int_cfg);
1440 spin_unlock_irqrestore(&pd->int_lock, flags);
1441
1442 return 0;
1443
1444 out_free_rx_ring_3:
1445 smsc9420_free_rx_ring(pd);
1446 out_free_tx_ring_2:
1447 smsc9420_free_tx_ring(pd);
1448 out_free_irq_1:
1449 free_irq(irq, pd);
1450 out_0:
1451 return result;
1452 }
1453
1454 #ifdef CONFIG_PM
1455
1456 static int smsc9420_suspend(struct pci_dev *pdev, pm_message_t state)
1457 {
1458 struct net_device *dev = pci_get_drvdata(pdev);
1459 struct smsc9420_pdata *pd = netdev_priv(dev);
1460 u32 int_cfg;
1461 ulong flags;
1462
1463 /* disable interrupts */
1464 spin_lock_irqsave(&pd->int_lock, flags);
1465 int_cfg = smsc9420_reg_read(pd, INT_CFG) & (~INT_CFG_IRQ_EN_);
1466 smsc9420_reg_write(pd, INT_CFG, int_cfg);
1467 spin_unlock_irqrestore(&pd->int_lock, flags);
1468
1469 if (netif_running(dev)) {
1470 netif_tx_disable(dev);
1471 smsc9420_stop_tx(pd);
1472 smsc9420_free_tx_ring(pd);
1473
1474 napi_disable(&pd->napi);
1475 smsc9420_stop_rx(pd);
1476 smsc9420_free_rx_ring(pd);
1477
1478 free_irq(pd->pdev->irq, pd);
1479
1480 netif_device_detach(dev);
1481 }
1482
1483 pci_save_state(pdev);
1484 pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
1485 pci_disable_device(pdev);
1486 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1487
1488 return 0;
1489 }
1490
1491 static int smsc9420_resume(struct pci_dev *pdev)
1492 {
1493 struct net_device *dev = pci_get_drvdata(pdev);
1494 struct smsc9420_pdata *pd = netdev_priv(dev);
1495 int err;
1496
1497 pci_set_power_state(pdev, PCI_D0);
1498 pci_restore_state(pdev);
1499
1500 err = pci_enable_device(pdev);
1501 if (err)
1502 return err;
1503
1504 pci_set_master(pdev);
1505
1506 err = pci_enable_wake(pdev, PCI_D0, 0);
1507 if (err)
1508 netif_warn(pd, ifup, pd->dev, "pci_enable_wake failed: %d\n",
1509 err);
1510
1511 if (netif_running(dev)) {
1512 /* FIXME: gross. It looks like ancient PM relic.*/
1513 err = smsc9420_open(dev);
1514 netif_device_attach(dev);
1515 }
1516 return err;
1517 }
1518
1519 #endif /* CONFIG_PM */
1520
1521 static const struct net_device_ops smsc9420_netdev_ops = {
1522 .ndo_open = smsc9420_open,
1523 .ndo_stop = smsc9420_stop,
1524 .ndo_start_xmit = smsc9420_hard_start_xmit,
1525 .ndo_get_stats = smsc9420_get_stats,
1526 .ndo_set_rx_mode = smsc9420_set_multicast_list,
1527 .ndo_do_ioctl = smsc9420_do_ioctl,
1528 .ndo_validate_addr = eth_validate_addr,
1529 .ndo_set_mac_address = eth_mac_addr,
1530 #ifdef CONFIG_NET_POLL_CONTROLLER
1531 .ndo_poll_controller = smsc9420_poll_controller,
1532 #endif /* CONFIG_NET_POLL_CONTROLLER */
1533 };
1534
1535 static int
1536 smsc9420_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1537 {
1538 struct net_device *dev;
1539 struct smsc9420_pdata *pd;
1540 void __iomem *virt_addr;
1541 int result = 0;
1542 u32 id_rev;
1543
1544 pr_info("%s version %s\n", DRV_DESCRIPTION, DRV_VERSION);
1545
1546 /* First do the PCI initialisation */
1547 result = pci_enable_device(pdev);
1548 if (unlikely(result)) {
1549 pr_err("Cannot enable smsc9420\n");
1550 goto out_0;
1551 }
1552
1553 pci_set_master(pdev);
1554
1555 dev = alloc_etherdev(sizeof(*pd));
1556 if (!dev)
1557 goto out_disable_pci_device_1;
1558
1559 SET_NETDEV_DEV(dev, &pdev->dev);
1560
1561 if (!(pci_resource_flags(pdev, SMSC_BAR) & IORESOURCE_MEM)) {
1562 netdev_err(dev, "Cannot find PCI device base address\n");
1563 goto out_free_netdev_2;
1564 }
1565
1566 if ((pci_request_regions(pdev, DRV_NAME))) {
1567 netdev_err(dev, "Cannot obtain PCI resources, aborting\n");
1568 goto out_free_netdev_2;
1569 }
1570
1571 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
1572 netdev_err(dev, "No usable DMA configuration, aborting\n");
1573 goto out_free_regions_3;
1574 }
1575
1576 virt_addr = ioremap(pci_resource_start(pdev, SMSC_BAR),
1577 pci_resource_len(pdev, SMSC_BAR));
1578 if (!virt_addr) {
1579 netdev_err(dev, "Cannot map device registers, aborting\n");
1580 goto out_free_regions_3;
1581 }
1582
1583 /* registers are double mapped with 0 offset for LE and 0x200 for BE */
1584 virt_addr += LAN9420_CPSR_ENDIAN_OFFSET;
1585
1586 pd = netdev_priv(dev);
1587
1588 /* pci descriptors are created in the PCI consistent area */
1589 pd->rx_ring = pci_alloc_consistent(pdev,
1590 sizeof(struct smsc9420_dma_desc) * RX_RING_SIZE +
1591 sizeof(struct smsc9420_dma_desc) * TX_RING_SIZE,
1592 &pd->rx_dma_addr);
1593
1594 if (!pd->rx_ring)
1595 goto out_free_io_4;
1596
1597 /* descriptors are aligned due to the nature of pci_alloc_consistent */
1598 pd->tx_ring = (pd->rx_ring + RX_RING_SIZE);
1599 pd->tx_dma_addr = pd->rx_dma_addr +
1600 sizeof(struct smsc9420_dma_desc) * RX_RING_SIZE;
1601
1602 pd->pdev = pdev;
1603 pd->dev = dev;
1604 pd->ioaddr = virt_addr;
1605 pd->msg_enable = smsc_debug;
1606 pd->rx_csum = true;
1607
1608 netif_dbg(pd, probe, pd->dev, "lan_base=0x%08lx\n", (ulong)virt_addr);
1609
1610 id_rev = smsc9420_reg_read(pd, ID_REV);
1611 switch (id_rev & 0xFFFF0000) {
1612 case 0x94200000:
1613 netif_info(pd, probe, pd->dev,
1614 "LAN9420 identified, ID_REV=0x%08X\n", id_rev);
1615 break;
1616 default:
1617 netif_warn(pd, probe, pd->dev, "LAN9420 NOT identified\n");
1618 netif_warn(pd, probe, pd->dev, "ID_REV=0x%08X\n", id_rev);
1619 goto out_free_dmadesc_5;
1620 }
1621
1622 smsc9420_dmac_soft_reset(pd);
1623 smsc9420_eeprom_reload(pd);
1624 smsc9420_check_mac_address(dev);
1625
1626 dev->netdev_ops = &smsc9420_netdev_ops;
1627 dev->ethtool_ops = &smsc9420_ethtool_ops;
1628
1629 netif_napi_add(dev, &pd->napi, smsc9420_rx_poll, NAPI_WEIGHT);
1630
1631 result = register_netdev(dev);
1632 if (result) {
1633 netif_warn(pd, probe, pd->dev, "error %i registering device\n",
1634 result);
1635 goto out_free_dmadesc_5;
1636 }
1637
1638 pci_set_drvdata(pdev, dev);
1639
1640 spin_lock_init(&pd->int_lock);
1641 spin_lock_init(&pd->phy_lock);
1642
1643 dev_info(&dev->dev, "MAC Address: %pM\n", dev->dev_addr);
1644
1645 return 0;
1646
1647 out_free_dmadesc_5:
1648 pci_free_consistent(pdev, sizeof(struct smsc9420_dma_desc) *
1649 (RX_RING_SIZE + TX_RING_SIZE), pd->rx_ring, pd->rx_dma_addr);
1650 out_free_io_4:
1651 iounmap(virt_addr - LAN9420_CPSR_ENDIAN_OFFSET);
1652 out_free_regions_3:
1653 pci_release_regions(pdev);
1654 out_free_netdev_2:
1655 free_netdev(dev);
1656 out_disable_pci_device_1:
1657 pci_disable_device(pdev);
1658 out_0:
1659 return -ENODEV;
1660 }
1661
1662 static void smsc9420_remove(struct pci_dev *pdev)
1663 {
1664 struct net_device *dev;
1665 struct smsc9420_pdata *pd;
1666
1667 dev = pci_get_drvdata(pdev);
1668 if (!dev)
1669 return;
1670
1671 pd = netdev_priv(dev);
1672 unregister_netdev(dev);
1673
1674 /* tx_buffers and rx_buffers are freed in stop */
1675 BUG_ON(pd->tx_buffers);
1676 BUG_ON(pd->rx_buffers);
1677
1678 BUG_ON(!pd->tx_ring);
1679 BUG_ON(!pd->rx_ring);
1680
1681 pci_free_consistent(pdev, sizeof(struct smsc9420_dma_desc) *
1682 (RX_RING_SIZE + TX_RING_SIZE), pd->rx_ring, pd->rx_dma_addr);
1683
1684 iounmap(pd->ioaddr - LAN9420_CPSR_ENDIAN_OFFSET);
1685 pci_release_regions(pdev);
1686 free_netdev(dev);
1687 pci_disable_device(pdev);
1688 }
1689
1690 static struct pci_driver smsc9420_driver = {
1691 .name = DRV_NAME,
1692 .id_table = smsc9420_id_table,
1693 .probe = smsc9420_probe,
1694 .remove = smsc9420_remove,
1695 #ifdef CONFIG_PM
1696 .suspend = smsc9420_suspend,
1697 .resume = smsc9420_resume,
1698 #endif /* CONFIG_PM */
1699 };
1700
1701 static int __init smsc9420_init_module(void)
1702 {
1703 smsc_debug = netif_msg_init(debug, SMSC_MSG_DEFAULT);
1704
1705 return pci_register_driver(&smsc9420_driver);
1706 }
1707
1708 static void __exit smsc9420_exit_module(void)
1709 {
1710 pci_unregister_driver(&smsc9420_driver);
1711 }
1712
1713 module_init(smsc9420_init_module);
1714 module_exit(smsc9420_exit_module);
Linux kernel - Deliverables
This page took 0.103296 seconds and 5 git commands to generate.