aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/smsc911x.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/smsc911x.c')
-rw-r--r--drivers/net/smsc911x.c466
1 files changed, 308 insertions, 158 deletions
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index 8150ba154116..c6d47d10590c 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -29,6 +29,8 @@
29 * 29 *
30 */ 30 */
31 31
32#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
33
32#include <linux/crc32.h> 34#include <linux/crc32.h>
33#include <linux/delay.h> 35#include <linux/delay.h>
34#include <linux/errno.h> 36#include <linux/errno.h>
@@ -69,6 +71,17 @@ static int debug = 3;
69module_param(debug, int, 0); 71module_param(debug, int, 0);
70MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); 72MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
71 73
74struct smsc911x_data;
75
76struct smsc911x_ops {
77 u32 (*reg_read)(struct smsc911x_data *pdata, u32 reg);
78 void (*reg_write)(struct smsc911x_data *pdata, u32 reg, u32 val);
79 void (*rx_readfifo)(struct smsc911x_data *pdata,
80 unsigned int *buf, unsigned int wordcount);
81 void (*tx_writefifo)(struct smsc911x_data *pdata,
82 unsigned int *buf, unsigned int wordcount);
83};
84
72struct smsc911x_data { 85struct smsc911x_data {
73 void __iomem *ioaddr; 86 void __iomem *ioaddr;
74 87
@@ -116,8 +129,14 @@ struct smsc911x_data {
116 unsigned int clear_bits_mask; 129 unsigned int clear_bits_mask;
117 unsigned int hashhi; 130 unsigned int hashhi;
118 unsigned int hashlo; 131 unsigned int hashlo;
132
133 /* register access functions */
134 const struct smsc911x_ops *ops;
119}; 135};
120 136
137/* Easy access to information */
138#define __smsc_shift(pdata, reg) ((reg) << ((pdata)->config.shift))
139
121static inline u32 __smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg) 140static inline u32 __smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
122{ 141{
123 if (pdata->config.flags & SMSC911X_USE_32BIT) 142 if (pdata->config.flags & SMSC911X_USE_32BIT)
@@ -131,13 +150,29 @@ static inline u32 __smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
131 return 0; 150 return 0;
132} 151}
133 152
153static inline u32
154__smsc911x_reg_read_shift(struct smsc911x_data *pdata, u32 reg)
155{
156 if (pdata->config.flags & SMSC911X_USE_32BIT)
157 return readl(pdata->ioaddr + __smsc_shift(pdata, reg));
158
159 if (pdata->config.flags & SMSC911X_USE_16BIT)
160 return (readw(pdata->ioaddr +
161 __smsc_shift(pdata, reg)) & 0xFFFF) |
162 ((readw(pdata->ioaddr +
163 __smsc_shift(pdata, reg + 2)) & 0xFFFF) << 16);
164
165 BUG();
166 return 0;
167}
168
134static inline u32 smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg) 169static inline u32 smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
135{ 170{
136 u32 data; 171 u32 data;
137 unsigned long flags; 172 unsigned long flags;
138 173
139 spin_lock_irqsave(&pdata->dev_lock, flags); 174 spin_lock_irqsave(&pdata->dev_lock, flags);
140 data = __smsc911x_reg_read(pdata, reg); 175 data = pdata->ops->reg_read(pdata, reg);
141 spin_unlock_irqrestore(&pdata->dev_lock, flags); 176 spin_unlock_irqrestore(&pdata->dev_lock, flags);
142 177
143 return data; 178 return data;
@@ -160,13 +195,32 @@ static inline void __smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
160 BUG(); 195 BUG();
161} 196}
162 197
198static inline void
199__smsc911x_reg_write_shift(struct smsc911x_data *pdata, u32 reg, u32 val)
200{
201 if (pdata->config.flags & SMSC911X_USE_32BIT) {
202 writel(val, pdata->ioaddr + __smsc_shift(pdata, reg));
203 return;
204 }
205
206 if (pdata->config.flags & SMSC911X_USE_16BIT) {
207 writew(val & 0xFFFF,
208 pdata->ioaddr + __smsc_shift(pdata, reg));
209 writew((val >> 16) & 0xFFFF,
210 pdata->ioaddr + __smsc_shift(pdata, reg + 2));
211 return;
212 }
213
214 BUG();
215}
216
163static inline void smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg, 217static inline void smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
164 u32 val) 218 u32 val)
165{ 219{
166 unsigned long flags; 220 unsigned long flags;
167 221
168 spin_lock_irqsave(&pdata->dev_lock, flags); 222 spin_lock_irqsave(&pdata->dev_lock, flags);
169 __smsc911x_reg_write(pdata, reg, val); 223 pdata->ops->reg_write(pdata, reg, val);
170 spin_unlock_irqrestore(&pdata->dev_lock, flags); 224 spin_unlock_irqrestore(&pdata->dev_lock, flags);
171} 225}
172 226
@@ -202,6 +256,40 @@ out:
202 spin_unlock_irqrestore(&pdata->dev_lock, flags); 256 spin_unlock_irqrestore(&pdata->dev_lock, flags);
203} 257}
204 258
259/* Writes a packet to the TX_DATA_FIFO - shifted version */
260static inline void
261smsc911x_tx_writefifo_shift(struct smsc911x_data *pdata, unsigned int *buf,
262 unsigned int wordcount)
263{
264 unsigned long flags;
265
266 spin_lock_irqsave(&pdata->dev_lock, flags);
267
268 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
269 while (wordcount--)
270 __smsc911x_reg_write_shift(pdata, TX_DATA_FIFO,
271 swab32(*buf++));
272 goto out;
273 }
274
275 if (pdata->config.flags & SMSC911X_USE_32BIT) {
276 writesl(pdata->ioaddr + __smsc_shift(pdata,
277 TX_DATA_FIFO), buf, wordcount);
278 goto out;
279 }
280
281 if (pdata->config.flags & SMSC911X_USE_16BIT) {
282 while (wordcount--)
283 __smsc911x_reg_write_shift(pdata,
284 TX_DATA_FIFO, *buf++);
285 goto out;
286 }
287
288 BUG();
289out:
290 spin_unlock_irqrestore(&pdata->dev_lock, flags);
291}
292
205/* Reads a packet out of the RX_DATA_FIFO */ 293/* Reads a packet out of the RX_DATA_FIFO */
206static inline void 294static inline void
207smsc911x_rx_readfifo(struct smsc911x_data *pdata, unsigned int *buf, 295smsc911x_rx_readfifo(struct smsc911x_data *pdata, unsigned int *buf,
@@ -234,6 +322,40 @@ out:
234 spin_unlock_irqrestore(&pdata->dev_lock, flags); 322 spin_unlock_irqrestore(&pdata->dev_lock, flags);
235} 323}
236 324
325/* Reads a packet out of the RX_DATA_FIFO - shifted version */
326static inline void
327smsc911x_rx_readfifo_shift(struct smsc911x_data *pdata, unsigned int *buf,
328 unsigned int wordcount)
329{
330 unsigned long flags;
331
332 spin_lock_irqsave(&pdata->dev_lock, flags);
333
334 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
335 while (wordcount--)
336 *buf++ = swab32(__smsc911x_reg_read_shift(pdata,
337 RX_DATA_FIFO));
338 goto out;
339 }
340
341 if (pdata->config.flags & SMSC911X_USE_32BIT) {
342 readsl(pdata->ioaddr + __smsc_shift(pdata,
343 RX_DATA_FIFO), buf, wordcount);
344 goto out;
345 }
346
347 if (pdata->config.flags & SMSC911X_USE_16BIT) {
348 while (wordcount--)
349 *buf++ = __smsc911x_reg_read_shift(pdata,
350 RX_DATA_FIFO);
351 goto out;
352 }
353
354 BUG();
355out:
356 spin_unlock_irqrestore(&pdata->dev_lock, flags);
357}
358
237/* waits for MAC not busy, with timeout. Only called by smsc911x_mac_read 359/* waits for MAC not busy, with timeout. Only called by smsc911x_mac_read
238 * and smsc911x_mac_write, so assumes mac_lock is held */ 360 * and smsc911x_mac_write, so assumes mac_lock is held */
239static int smsc911x_mac_complete(struct smsc911x_data *pdata) 361static int smsc911x_mac_complete(struct smsc911x_data *pdata)
@@ -248,8 +370,8 @@ static int smsc911x_mac_complete(struct smsc911x_data *pdata)
248 if (!(val & MAC_CSR_CMD_CSR_BUSY_)) 370 if (!(val & MAC_CSR_CMD_CSR_BUSY_))
249 return 0; 371 return 0;
250 } 372 }
251 SMSC_WARNING(HW, "Timed out waiting for MAC not BUSY. " 373 SMSC_WARN(pdata, hw, "Timed out waiting for MAC not BUSY. "
252 "MAC_CSR_CMD: 0x%08X", val); 374 "MAC_CSR_CMD: 0x%08X", val);
253 return -EIO; 375 return -EIO;
254} 376}
255 377
@@ -262,7 +384,7 @@ static u32 smsc911x_mac_read(struct smsc911x_data *pdata, unsigned int offset)
262 384
263 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD); 385 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
264 if (unlikely(temp & MAC_CSR_CMD_CSR_BUSY_)) { 386 if (unlikely(temp & MAC_CSR_CMD_CSR_BUSY_)) {
265 SMSC_WARNING(HW, "MAC busy at entry"); 387 SMSC_WARN(pdata, hw, "MAC busy at entry");
266 return 0xFFFFFFFF; 388 return 0xFFFFFFFF;
267 } 389 }
268 390
@@ -277,7 +399,7 @@ static u32 smsc911x_mac_read(struct smsc911x_data *pdata, unsigned int offset)
277 if (likely(smsc911x_mac_complete(pdata) == 0)) 399 if (likely(smsc911x_mac_complete(pdata) == 0))
278 return smsc911x_reg_read(pdata, MAC_CSR_DATA); 400 return smsc911x_reg_read(pdata, MAC_CSR_DATA);
279 401
280 SMSC_WARNING(HW, "MAC busy after read"); 402 SMSC_WARN(pdata, hw, "MAC busy after read");
281 return 0xFFFFFFFF; 403 return 0xFFFFFFFF;
282} 404}
283 405
@@ -291,8 +413,8 @@ static void smsc911x_mac_write(struct smsc911x_data *pdata,
291 413
292 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD); 414 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
293 if (unlikely(temp & MAC_CSR_CMD_CSR_BUSY_)) { 415 if (unlikely(temp & MAC_CSR_CMD_CSR_BUSY_)) {
294 SMSC_WARNING(HW, 416 SMSC_WARN(pdata, hw,
295 "smsc911x_mac_write failed, MAC busy at entry"); 417 "smsc911x_mac_write failed, MAC busy at entry");
296 return; 418 return;
297 } 419 }
298 420
@@ -310,8 +432,7 @@ static void smsc911x_mac_write(struct smsc911x_data *pdata,
310 if (likely(smsc911x_mac_complete(pdata) == 0)) 432 if (likely(smsc911x_mac_complete(pdata) == 0))
311 return; 433 return;
312 434
313 SMSC_WARNING(HW, 435 SMSC_WARN(pdata, hw, "smsc911x_mac_write failed, MAC busy after write");
314 "smsc911x_mac_write failed, MAC busy after write");
315} 436}
316 437
317/* Get a phy register */ 438/* Get a phy register */
@@ -326,8 +447,7 @@ static int smsc911x_mii_read(struct mii_bus *bus, int phyaddr, int regidx)
326 447
327 /* Confirm MII not busy */ 448 /* Confirm MII not busy */
328 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) { 449 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
329 SMSC_WARNING(HW, 450 SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_read???");
330 "MII is busy in smsc911x_mii_read???");
331 reg = -EIO; 451 reg = -EIO;
332 goto out; 452 goto out;
333 } 453 }
@@ -343,7 +463,7 @@ static int smsc911x_mii_read(struct mii_bus *bus, int phyaddr, int regidx)
343 goto out; 463 goto out;
344 } 464 }
345 465
346 SMSC_WARNING(HW, "Timed out waiting for MII read to finish"); 466 SMSC_WARN(pdata, hw, "Timed out waiting for MII read to finish");
347 reg = -EIO; 467 reg = -EIO;
348 468
349out: 469out:
@@ -364,8 +484,7 @@ static int smsc911x_mii_write(struct mii_bus *bus, int phyaddr, int regidx,
364 484
365 /* Confirm MII not busy */ 485 /* Confirm MII not busy */
366 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) { 486 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
367 SMSC_WARNING(HW, 487 SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_write???");
368 "MII is busy in smsc911x_mii_write???");
369 reg = -EIO; 488 reg = -EIO;
370 goto out; 489 goto out;
371 } 490 }
@@ -385,7 +504,7 @@ static int smsc911x_mii_write(struct mii_bus *bus, int phyaddr, int regidx,
385 goto out; 504 goto out;
386 } 505 }
387 506
388 SMSC_WARNING(HW, "Timed out waiting for MII write to finish"); 507 SMSC_WARN(pdata, hw, "Timed out waiting for MII write to finish");
389 reg = -EIO; 508 reg = -EIO;
390 509
391out: 510out:
@@ -426,18 +545,20 @@ static void smsc911x_phy_initialise_external(struct smsc911x_data *pdata)
426 unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG); 545 unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG);
427 546
428 if (pdata->config.flags & SMSC911X_FORCE_INTERNAL_PHY) { 547 if (pdata->config.flags & SMSC911X_FORCE_INTERNAL_PHY) {
429 SMSC_TRACE(HW, "Forcing internal PHY"); 548 SMSC_TRACE(pdata, hw, "Forcing internal PHY");
430 pdata->using_extphy = 0; 549 pdata->using_extphy = 0;
431 } else if (pdata->config.flags & SMSC911X_FORCE_EXTERNAL_PHY) { 550 } else if (pdata->config.flags & SMSC911X_FORCE_EXTERNAL_PHY) {
432 SMSC_TRACE(HW, "Forcing external PHY"); 551 SMSC_TRACE(pdata, hw, "Forcing external PHY");
433 smsc911x_phy_enable_external(pdata); 552 smsc911x_phy_enable_external(pdata);
434 pdata->using_extphy = 1; 553 pdata->using_extphy = 1;
435 } else if (hwcfg & HW_CFG_EXT_PHY_DET_) { 554 } else if (hwcfg & HW_CFG_EXT_PHY_DET_) {
436 SMSC_TRACE(HW, "HW_CFG EXT_PHY_DET set, using external PHY"); 555 SMSC_TRACE(pdata, hw,
556 "HW_CFG EXT_PHY_DET set, using external PHY");
437 smsc911x_phy_enable_external(pdata); 557 smsc911x_phy_enable_external(pdata);
438 pdata->using_extphy = 1; 558 pdata->using_extphy = 1;
439 } else { 559 } else {
440 SMSC_TRACE(HW, "HW_CFG EXT_PHY_DET clear, using internal PHY"); 560 SMSC_TRACE(pdata, hw,
561 "HW_CFG EXT_PHY_DET clear, using internal PHY");
441 pdata->using_extphy = 0; 562 pdata->using_extphy = 0;
442 } 563 }
443} 564}
@@ -499,7 +620,7 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
499 wrsz += (u32)((ulong)pdata->loopback_tx_pkt & 0x3); 620 wrsz += (u32)((ulong)pdata->loopback_tx_pkt & 0x3);
500 wrsz >>= 2; 621 wrsz >>= 2;
501 622
502 smsc911x_tx_writefifo(pdata, (unsigned int *)bufp, wrsz); 623 pdata->ops->tx_writefifo(pdata, (unsigned int *)bufp, wrsz);
503 624
504 /* Wait till transmit is done */ 625 /* Wait till transmit is done */
505 i = 60; 626 i = 60;
@@ -509,13 +630,13 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
509 } while ((i--) && (!status)); 630 } while ((i--) && (!status));
510 631
511 if (!status) { 632 if (!status) {
512 SMSC_WARNING(HW, "Failed to transmit " 633 SMSC_WARN(pdata, hw,
513 "during loopback test"); 634 "Failed to transmit during loopback test");
514 continue; 635 continue;
515 } 636 }
516 if (status & TX_STS_ES_) { 637 if (status & TX_STS_ES_) {
517 SMSC_WARNING(HW, "Transmit encountered " 638 SMSC_WARN(pdata, hw,
518 "errors during loopback test"); 639 "Transmit encountered errors during loopback test");
519 continue; 640 continue;
520 } 641 }
521 642
@@ -527,13 +648,13 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
527 } while ((i--) && (!status)); 648 } while ((i--) && (!status));
528 649
529 if (!status) { 650 if (!status) {
530 SMSC_WARNING(HW, 651 SMSC_WARN(pdata, hw,
531 "Failed to receive during loopback test"); 652 "Failed to receive during loopback test");
532 continue; 653 continue;
533 } 654 }
534 if (status & RX_STS_ES_) { 655 if (status & RX_STS_ES_) {
535 SMSC_WARNING(HW, "Receive encountered " 656 SMSC_WARN(pdata, hw,
536 "errors during loopback test"); 657 "Receive encountered errors during loopback test");
537 continue; 658 continue;
538 } 659 }
539 660
@@ -543,12 +664,12 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
543 rdsz += (u32)((ulong)pdata->loopback_rx_pkt & 0x3); 664 rdsz += (u32)((ulong)pdata->loopback_rx_pkt & 0x3);
544 rdsz >>= 2; 665 rdsz >>= 2;
545 666
546 smsc911x_rx_readfifo(pdata, (unsigned int *)bufp, rdsz); 667 pdata->ops->rx_readfifo(pdata, (unsigned int *)bufp, rdsz);
547 668
548 if (pktlength != (MIN_PACKET_SIZE + 4)) { 669 if (pktlength != (MIN_PACKET_SIZE + 4)) {
549 SMSC_WARNING(HW, "Unexpected packet size " 670 SMSC_WARN(pdata, hw, "Unexpected packet size "
550 "during loop back test, size=%d, will retry", 671 "during loop back test, size=%d, will retry",
551 pktlength); 672 pktlength);
552 } else { 673 } else {
553 unsigned int j; 674 unsigned int j;
554 int mismatch = 0; 675 int mismatch = 0;
@@ -560,12 +681,12 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
560 } 681 }
561 } 682 }
562 if (!mismatch) { 683 if (!mismatch) {
563 SMSC_TRACE(HW, "Successfully verified " 684 SMSC_TRACE(pdata, hw, "Successfully verified "
564 "loopback packet"); 685 "loopback packet");
565 return 0; 686 return 0;
566 } else { 687 } else {
567 SMSC_WARNING(HW, "Data mismatch " 688 SMSC_WARN(pdata, hw, "Data mismatch "
568 "during loop back test, will retry"); 689 "during loop back test, will retry");
569 } 690 }
570 } 691 }
571 } 692 }
@@ -582,7 +703,7 @@ static int smsc911x_phy_reset(struct smsc911x_data *pdata)
582 BUG_ON(!phy_dev); 703 BUG_ON(!phy_dev);
583 BUG_ON(!phy_dev->bus); 704 BUG_ON(!phy_dev->bus);
584 705
585 SMSC_TRACE(HW, "Performing PHY BCR Reset"); 706 SMSC_TRACE(pdata, hw, "Performing PHY BCR Reset");
586 smsc911x_mii_write(phy_dev->bus, phy_dev->addr, MII_BMCR, BMCR_RESET); 707 smsc911x_mii_write(phy_dev->bus, phy_dev->addr, MII_BMCR, BMCR_RESET);
587 do { 708 do {
588 msleep(1); 709 msleep(1);
@@ -591,7 +712,7 @@ static int smsc911x_phy_reset(struct smsc911x_data *pdata)
591 } while ((i--) && (temp & BMCR_RESET)); 712 } while ((i--) && (temp & BMCR_RESET));
592 713
593 if (temp & BMCR_RESET) { 714 if (temp & BMCR_RESET) {
594 SMSC_WARNING(HW, "PHY reset failed to complete."); 715 SMSC_WARN(pdata, hw, "PHY reset failed to complete");
595 return -EIO; 716 return -EIO;
596 } 717 }
597 /* Extra delay required because the phy may not be completed with 718 /* Extra delay required because the phy may not be completed with
@@ -695,11 +816,11 @@ static void smsc911x_phy_update_flowcontrol(struct smsc911x_data *pdata)
695 else 816 else
696 afc &= ~0xF; 817 afc &= ~0xF;
697 818
698 SMSC_TRACE(HW, "rx pause %s, tx pause %s", 819 SMSC_TRACE(pdata, hw, "rx pause %s, tx pause %s",
699 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"), 820 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
700 (cap & FLOW_CTRL_TX ? "enabled" : "disabled")); 821 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
701 } else { 822 } else {
702 SMSC_TRACE(HW, "half duplex"); 823 SMSC_TRACE(pdata, hw, "half duplex");
703 flow = 0; 824 flow = 0;
704 afc |= 0xF; 825 afc |= 0xF;
705 } 826 }
@@ -722,17 +843,17 @@ static void smsc911x_phy_adjust_link(struct net_device *dev)
722 843
723 if (phy_dev->duplex != pdata->last_duplex) { 844 if (phy_dev->duplex != pdata->last_duplex) {
724 unsigned int mac_cr; 845 unsigned int mac_cr;
725 SMSC_TRACE(HW, "duplex state has changed"); 846 SMSC_TRACE(pdata, hw, "duplex state has changed");
726 847
727 spin_lock_irqsave(&pdata->mac_lock, flags); 848 spin_lock_irqsave(&pdata->mac_lock, flags);
728 mac_cr = smsc911x_mac_read(pdata, MAC_CR); 849 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
729 if (phy_dev->duplex) { 850 if (phy_dev->duplex) {
730 SMSC_TRACE(HW, 851 SMSC_TRACE(pdata, hw,
731 "configuring for full duplex mode"); 852 "configuring for full duplex mode");
732 mac_cr |= MAC_CR_FDPX_; 853 mac_cr |= MAC_CR_FDPX_;
733 } else { 854 } else {
734 SMSC_TRACE(HW, 855 SMSC_TRACE(pdata, hw,
735 "configuring for half duplex mode"); 856 "configuring for half duplex mode");
736 mac_cr &= ~MAC_CR_FDPX_; 857 mac_cr &= ~MAC_CR_FDPX_;
737 } 858 }
738 smsc911x_mac_write(pdata, MAC_CR, mac_cr); 859 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
@@ -744,9 +865,9 @@ static void smsc911x_phy_adjust_link(struct net_device *dev)
744 865
745 carrier = netif_carrier_ok(dev); 866 carrier = netif_carrier_ok(dev);
746 if (carrier != pdata->last_carrier) { 867 if (carrier != pdata->last_carrier) {
747 SMSC_TRACE(HW, "carrier state has changed"); 868 SMSC_TRACE(pdata, hw, "carrier state has changed");
748 if (carrier) { 869 if (carrier) {
749 SMSC_TRACE(HW, "configuring for carrier OK"); 870 SMSC_TRACE(pdata, hw, "configuring for carrier OK");
750 if ((pdata->gpio_orig_setting & GPIO_CFG_LED1_EN_) && 871 if ((pdata->gpio_orig_setting & GPIO_CFG_LED1_EN_) &&
751 (!pdata->using_extphy)) { 872 (!pdata->using_extphy)) {
752 /* Restore original GPIO configuration */ 873 /* Restore original GPIO configuration */
@@ -755,7 +876,7 @@ static void smsc911x_phy_adjust_link(struct net_device *dev)
755 pdata->gpio_setting); 876 pdata->gpio_setting);
756 } 877 }
757 } else { 878 } else {
758 SMSC_TRACE(HW, "configuring for no carrier"); 879 SMSC_TRACE(pdata, hw, "configuring for no carrier");
759 /* Check global setting that LED1 880 /* Check global setting that LED1
760 * usage is 10/100 indicator */ 881 * usage is 10/100 indicator */
761 pdata->gpio_setting = smsc911x_reg_read(pdata, 882 pdata->gpio_setting = smsc911x_reg_read(pdata,
@@ -787,25 +908,25 @@ static int smsc911x_mii_probe(struct net_device *dev)
787 /* find the first phy */ 908 /* find the first phy */
788 phydev = phy_find_first(pdata->mii_bus); 909 phydev = phy_find_first(pdata->mii_bus);
789 if (!phydev) { 910 if (!phydev) {
790 pr_err("%s: no PHY found\n", dev->name); 911 netdev_err(dev, "no PHY found\n");
791 return -ENODEV; 912 return -ENODEV;
792 } 913 }
793 914
794 SMSC_TRACE(PROBE, "PHY %d: addr %d, phy_id 0x%08X", 915 SMSC_TRACE(pdata, probe, "PHY: addr %d, phy_id 0x%08X",
795 phy_addr, phydev->addr, phydev->phy_id); 916 phydev->addr, phydev->phy_id);
796 917
797 ret = phy_connect_direct(dev, phydev, 918 ret = phy_connect_direct(dev, phydev,
798 &smsc911x_phy_adjust_link, 0, 919 &smsc911x_phy_adjust_link, 0,
799 pdata->config.phy_interface); 920 pdata->config.phy_interface);
800 921
801 if (ret) { 922 if (ret) {
802 pr_err("%s: Could not attach to PHY\n", dev->name); 923 netdev_err(dev, "Could not attach to PHY\n");
803 return ret; 924 return ret;
804 } 925 }
805 926
806 pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n", 927 netdev_info(dev,
807 dev->name, phydev->drv->name, 928 "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
808 dev_name(&phydev->dev), phydev->irq); 929 phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
809 930
810 /* mask with MAC supported features */ 931 /* mask with MAC supported features */
811 phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause | 932 phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
@@ -818,13 +939,13 @@ static int smsc911x_mii_probe(struct net_device *dev)
818 939
819#ifdef USE_PHY_WORK_AROUND 940#ifdef USE_PHY_WORK_AROUND
820 if (smsc911x_phy_loopbacktest(dev) < 0) { 941 if (smsc911x_phy_loopbacktest(dev) < 0) {
821 SMSC_WARNING(HW, "Failed Loop Back Test"); 942 SMSC_WARN(pdata, hw, "Failed Loop Back Test");
822 return -ENODEV; 943 return -ENODEV;
823 } 944 }
824 SMSC_TRACE(HW, "Passed Loop Back Test"); 945 SMSC_TRACE(pdata, hw, "Passed Loop Back Test");
825#endif /* USE_PHY_WORK_AROUND */ 946#endif /* USE_PHY_WORK_AROUND */
826 947
827 SMSC_TRACE(HW, "phy initialised successfully"); 948 SMSC_TRACE(pdata, hw, "phy initialised successfully");
828 return 0; 949 return 0;
829} 950}
830 951
@@ -860,8 +981,8 @@ static int __devinit smsc911x_mii_init(struct platform_device *pdev,
860 smsc911x_phy_initialise_external(pdata); 981 smsc911x_phy_initialise_external(pdata);
861 break; 982 break;
862 default: 983 default:
863 SMSC_TRACE(HW, "External PHY is not supported, " 984 SMSC_TRACE(pdata, hw, "External PHY is not supported, "
864 "using internal PHY"); 985 "using internal PHY");
865 pdata->using_extphy = 0; 986 pdata->using_extphy = 0;
866 break; 987 break;
867 } 988 }
@@ -872,12 +993,12 @@ static int __devinit smsc911x_mii_init(struct platform_device *pdev,
872 } 993 }
873 994
874 if (mdiobus_register(pdata->mii_bus)) { 995 if (mdiobus_register(pdata->mii_bus)) {
875 SMSC_WARNING(PROBE, "Error registering mii bus"); 996 SMSC_WARN(pdata, probe, "Error registering mii bus");
876 goto err_out_free_bus_2; 997 goto err_out_free_bus_2;
877 } 998 }
878 999
879 if (smsc911x_mii_probe(dev) < 0) { 1000 if (smsc911x_mii_probe(dev) < 0) {
880 SMSC_WARNING(PROBE, "Error registering mii bus"); 1001 SMSC_WARN(pdata, probe, "Error registering mii bus");
881 goto err_out_unregister_bus_3; 1002 goto err_out_unregister_bus_3;
882 } 1003 }
883 1004
@@ -913,8 +1034,7 @@ static void smsc911x_tx_update_txcounters(struct net_device *dev)
913 * does not reference a hardware defined reserved bit 1034 * does not reference a hardware defined reserved bit
914 * but rather a driver defined one. 1035 * but rather a driver defined one.
915 */ 1036 */
916 SMSC_WARNING(HW, 1037 SMSC_WARN(pdata, hw, "Packet tag reserved bit is high");
917 "Packet tag reserved bit is high");
918 } else { 1038 } else {
919 if (unlikely(tx_stat & TX_STS_ES_)) { 1039 if (unlikely(tx_stat & TX_STS_ES_)) {
920 dev->stats.tx_errors++; 1040 dev->stats.tx_errors++;
@@ -977,8 +1097,8 @@ smsc911x_rx_fastforward(struct smsc911x_data *pdata, unsigned int pktbytes)
977 } while ((val & RX_DP_CTRL_RX_FFWD_) && --timeout); 1097 } while ((val & RX_DP_CTRL_RX_FFWD_) && --timeout);
978 1098
979 if (unlikely(timeout == 0)) 1099 if (unlikely(timeout == 0))
980 SMSC_WARNING(HW, "Timed out waiting for " 1100 SMSC_WARN(pdata, hw, "Timed out waiting for "
981 "RX FFWD to finish, RX_DP_CTRL: 0x%08X", val); 1101 "RX FFWD to finish, RX_DP_CTRL: 0x%08X", val);
982 } else { 1102 } else {
983 unsigned int temp; 1103 unsigned int temp;
984 while (pktwords--) 1104 while (pktwords--)
@@ -1021,8 +1141,8 @@ static int smsc911x_poll(struct napi_struct *napi, int budget)
1021 smsc911x_rx_counterrors(dev, rxstat); 1141 smsc911x_rx_counterrors(dev, rxstat);
1022 1142
1023 if (unlikely(rxstat & RX_STS_ES_)) { 1143 if (unlikely(rxstat & RX_STS_ES_)) {
1024 SMSC_WARNING(RX_ERR, 1144 SMSC_WARN(pdata, rx_err,
1025 "Discarding packet with error bit set"); 1145 "Discarding packet with error bit set");
1026 /* Packet has an error, discard it and continue with 1146 /* Packet has an error, discard it and continue with
1027 * the next */ 1147 * the next */
1028 smsc911x_rx_fastforward(pdata, pktwords); 1148 smsc911x_rx_fastforward(pdata, pktwords);
@@ -1032,8 +1152,8 @@ static int smsc911x_poll(struct napi_struct *napi, int budget)
1032 1152
1033 skb = netdev_alloc_skb(dev, pktlength + NET_IP_ALIGN); 1153 skb = netdev_alloc_skb(dev, pktlength + NET_IP_ALIGN);
1034 if (unlikely(!skb)) { 1154 if (unlikely(!skb)) {
1035 SMSC_WARNING(RX_ERR, 1155 SMSC_WARN(pdata, rx_err,
1036 "Unable to allocate skb for rx packet"); 1156 "Unable to allocate skb for rx packet");
1037 /* Drop the packet and stop this polling iteration */ 1157 /* Drop the packet and stop this polling iteration */
1038 smsc911x_rx_fastforward(pdata, pktwords); 1158 smsc911x_rx_fastforward(pdata, pktwords);
1039 dev->stats.rx_dropped++; 1159 dev->stats.rx_dropped++;
@@ -1046,10 +1166,10 @@ static int smsc911x_poll(struct napi_struct *napi, int budget)
1046 /* Align IP on 16B boundary */ 1166 /* Align IP on 16B boundary */
1047 skb_reserve(skb, NET_IP_ALIGN); 1167 skb_reserve(skb, NET_IP_ALIGN);
1048 skb_put(skb, pktlength - 4); 1168 skb_put(skb, pktlength - 4);
1049 smsc911x_rx_readfifo(pdata, (unsigned int *)skb->head, 1169 pdata->ops->rx_readfifo(pdata,
1050 pktwords); 1170 (unsigned int *)skb->head, pktwords);
1051 skb->protocol = eth_type_trans(skb, dev); 1171 skb->protocol = eth_type_trans(skb, dev);
1052 skb->ip_summed = CHECKSUM_NONE; 1172 skb_checksum_none_assert(skb);
1053 netif_receive_skb(skb); 1173 netif_receive_skb(skb);
1054 1174
1055 /* Update counters */ 1175 /* Update counters */
@@ -1083,8 +1203,8 @@ static void smsc911x_rx_multicast_update(struct smsc911x_data *pdata)
1083 smsc911x_mac_write(pdata, MAC_CR, mac_cr); 1203 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
1084 smsc911x_mac_write(pdata, HASHH, pdata->hashhi); 1204 smsc911x_mac_write(pdata, HASHH, pdata->hashhi);
1085 smsc911x_mac_write(pdata, HASHL, pdata->hashlo); 1205 smsc911x_mac_write(pdata, HASHL, pdata->hashlo);
1086 SMSC_TRACE(HW, "maccr 0x%08X, HASHH 0x%08X, HASHL 0x%08X", 1206 SMSC_TRACE(pdata, hw, "maccr 0x%08X, HASHH 0x%08X, HASHL 0x%08X",
1087 mac_cr, pdata->hashhi, pdata->hashlo); 1207 mac_cr, pdata->hashhi, pdata->hashlo);
1088} 1208}
1089 1209
1090static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata) 1210static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata)
@@ -1102,7 +1222,7 @@ static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata)
1102 1222
1103 /* Check Rx has stopped */ 1223 /* Check Rx has stopped */
1104 if (smsc911x_mac_read(pdata, MAC_CR) & MAC_CR_RXEN_) 1224 if (smsc911x_mac_read(pdata, MAC_CR) & MAC_CR_RXEN_)
1105 SMSC_WARNING(DRV, "Rx not stopped"); 1225 SMSC_WARN(pdata, drv, "Rx not stopped");
1106 1226
1107 /* Perform the update - safe to do now Rx has stopped */ 1227 /* Perform the update - safe to do now Rx has stopped */
1108 smsc911x_rx_multicast_update(pdata); 1228 smsc911x_rx_multicast_update(pdata);
@@ -1131,7 +1251,7 @@ static int smsc911x_soft_reset(struct smsc911x_data *pdata)
1131 } while ((--timeout) && (temp & HW_CFG_SRST_)); 1251 } while ((--timeout) && (temp & HW_CFG_SRST_));
1132 1252
1133 if (unlikely(temp & HW_CFG_SRST_)) { 1253 if (unlikely(temp & HW_CFG_SRST_)) {
1134 SMSC_WARNING(DRV, "Failed to complete reset"); 1254 SMSC_WARN(pdata, drv, "Failed to complete reset");
1135 return -EIO; 1255 return -EIO;
1136 } 1256 }
1137 return 0; 1257 return 0;
@@ -1160,24 +1280,29 @@ static int smsc911x_open(struct net_device *dev)
1160 1280
1161 /* if the phy is not yet registered, retry later*/ 1281 /* if the phy is not yet registered, retry later*/
1162 if (!pdata->phy_dev) { 1282 if (!pdata->phy_dev) {
1163 SMSC_WARNING(HW, "phy_dev is NULL"); 1283 SMSC_WARN(pdata, hw, "phy_dev is NULL");
1164 return -EAGAIN; 1284 return -EAGAIN;
1165 } 1285 }
1166 1286
1167 if (!is_valid_ether_addr(dev->dev_addr)) { 1287 if (!is_valid_ether_addr(dev->dev_addr)) {
1168 SMSC_WARNING(HW, "dev_addr is not a valid MAC address"); 1288 SMSC_WARN(pdata, hw, "dev_addr is not a valid MAC address");
1169 return -EADDRNOTAVAIL; 1289 return -EADDRNOTAVAIL;
1170 } 1290 }
1171 1291
1172 /* Reset the LAN911x */ 1292 /* Reset the LAN911x */
1173 if (smsc911x_soft_reset(pdata)) { 1293 if (smsc911x_soft_reset(pdata)) {
1174 SMSC_WARNING(HW, "soft reset failed"); 1294 SMSC_WARN(pdata, hw, "soft reset failed");
1175 return -EIO; 1295 return -EIO;
1176 } 1296 }
1177 1297
1178 smsc911x_reg_write(pdata, HW_CFG, 0x00050000); 1298 smsc911x_reg_write(pdata, HW_CFG, 0x00050000);
1179 smsc911x_reg_write(pdata, AFC_CFG, 0x006E3740); 1299 smsc911x_reg_write(pdata, AFC_CFG, 0x006E3740);
1180 1300
1301 /* Increase the legal frame size of VLAN tagged frames to 1522 bytes */
1302 spin_lock_irq(&pdata->mac_lock);
1303 smsc911x_mac_write(pdata, VLAN1, ETH_P_8021Q);
1304 spin_unlock_irq(&pdata->mac_lock);
1305
1181 /* Make sure EEPROM has finished loading before setting GPIO_CFG */ 1306 /* Make sure EEPROM has finished loading before setting GPIO_CFG */
1182 timeout = 50; 1307 timeout = 50;
1183 while ((smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) && 1308 while ((smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) &&
@@ -1186,8 +1311,8 @@ static int smsc911x_open(struct net_device *dev)
1186 } 1311 }
1187 1312
1188 if (unlikely(timeout == 0)) 1313 if (unlikely(timeout == 0))
1189 SMSC_WARNING(IFUP, 1314 SMSC_WARN(pdata, ifup,
1190 "Timed out waiting for EEPROM busy bit to clear"); 1315 "Timed out waiting for EEPROM busy bit to clear");
1191 1316
1192 smsc911x_reg_write(pdata, GPIO_CFG, 0x70070000); 1317 smsc911x_reg_write(pdata, GPIO_CFG, 0x70070000);
1193 1318
@@ -1205,22 +1330,22 @@ static int smsc911x_open(struct net_device *dev)
1205 intcfg = ((10 << 24) | INT_CFG_IRQ_EN_); 1330 intcfg = ((10 << 24) | INT_CFG_IRQ_EN_);
1206 1331
1207 if (pdata->config.irq_polarity) { 1332 if (pdata->config.irq_polarity) {
1208 SMSC_TRACE(IFUP, "irq polarity: active high"); 1333 SMSC_TRACE(pdata, ifup, "irq polarity: active high");
1209 intcfg |= INT_CFG_IRQ_POL_; 1334 intcfg |= INT_CFG_IRQ_POL_;
1210 } else { 1335 } else {
1211 SMSC_TRACE(IFUP, "irq polarity: active low"); 1336 SMSC_TRACE(pdata, ifup, "irq polarity: active low");
1212 } 1337 }
1213 1338
1214 if (pdata->config.irq_type) { 1339 if (pdata->config.irq_type) {
1215 SMSC_TRACE(IFUP, "irq type: push-pull"); 1340 SMSC_TRACE(pdata, ifup, "irq type: push-pull");
1216 intcfg |= INT_CFG_IRQ_TYPE_; 1341 intcfg |= INT_CFG_IRQ_TYPE_;
1217 } else { 1342 } else {
1218 SMSC_TRACE(IFUP, "irq type: open drain"); 1343 SMSC_TRACE(pdata, ifup, "irq type: open drain");
1219 } 1344 }
1220 1345
1221 smsc911x_reg_write(pdata, INT_CFG, intcfg); 1346 smsc911x_reg_write(pdata, INT_CFG, intcfg);
1222 1347
1223 SMSC_TRACE(IFUP, "Testing irq handler using IRQ %d", dev->irq); 1348 SMSC_TRACE(pdata, ifup, "Testing irq handler using IRQ %d", dev->irq);
1224 pdata->software_irq_signal = 0; 1349 pdata->software_irq_signal = 0;
1225 smp_wmb(); 1350 smp_wmb();
1226 1351
@@ -1236,14 +1361,15 @@ static int smsc911x_open(struct net_device *dev)
1236 } 1361 }
1237 1362
1238 if (!pdata->software_irq_signal) { 1363 if (!pdata->software_irq_signal) {
1239 dev_warn(&dev->dev, "ISR failed signaling test (IRQ %d)\n", 1364 netdev_warn(dev, "ISR failed signaling test (IRQ %d)\n",
1240 dev->irq); 1365 dev->irq);
1241 return -ENODEV; 1366 return -ENODEV;
1242 } 1367 }
1243 SMSC_TRACE(IFUP, "IRQ handler passed test using IRQ %d", dev->irq); 1368 SMSC_TRACE(pdata, ifup, "IRQ handler passed test using IRQ %d",
1369 dev->irq);
1244 1370
1245 dev_info(&dev->dev, "SMSC911x/921x identified at %#08lx, IRQ: %d\n", 1371 netdev_info(dev, "SMSC911x/921x identified at %#08lx, IRQ: %d\n",
1246 (unsigned long)pdata->ioaddr, dev->irq); 1372 (unsigned long)pdata->ioaddr, dev->irq);
1247 1373
1248 /* Reset the last known duplex and carrier */ 1374 /* Reset the last known duplex and carrier */
1249 pdata->last_duplex = -1; 1375 pdata->last_duplex = -1;
@@ -1308,7 +1434,7 @@ static int smsc911x_stop(struct net_device *dev)
1308 if (pdata->phy_dev) 1434 if (pdata->phy_dev)
1309 phy_stop(pdata->phy_dev); 1435 phy_stop(pdata->phy_dev);
1310 1436
1311 SMSC_TRACE(IFDOWN, "Interface stopped"); 1437 SMSC_TRACE(pdata, ifdown, "Interface stopped");
1312 return 0; 1438 return 0;
1313} 1439}
1314 1440
@@ -1326,8 +1452,8 @@ static int smsc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1326 freespace = smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TDFREE_; 1452 freespace = smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TDFREE_;
1327 1453
1328 if (unlikely(freespace < TX_FIFO_LOW_THRESHOLD)) 1454 if (unlikely(freespace < TX_FIFO_LOW_THRESHOLD))
1329 SMSC_WARNING(TX_ERR, 1455 SMSC_WARN(pdata, tx_err,
1330 "Tx data fifo low, space available: %d", freespace); 1456 "Tx data fifo low, space available: %d", freespace);
1331 1457
1332 /* Word alignment adjustment */ 1458 /* Word alignment adjustment */
1333 tx_cmd_a = (u32)((ulong)skb->data & 0x03) << 16; 1459 tx_cmd_a = (u32)((ulong)skb->data & 0x03) << 16;
@@ -1345,7 +1471,7 @@ static int smsc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1345 wrsz += (u32)((ulong)skb->data & 0x3); 1471 wrsz += (u32)((ulong)skb->data & 0x3);
1346 wrsz >>= 2; 1472 wrsz >>= 2;
1347 1473
1348 smsc911x_tx_writefifo(pdata, (unsigned int *)bufp, wrsz); 1474 pdata->ops->tx_writefifo(pdata, (unsigned int *)bufp, wrsz);
1349 freespace -= (skb->len + 32); 1475 freespace -= (skb->len + 32);
1350 dev_kfree_skb(skb); 1476 dev_kfree_skb(skb);
1351 1477
@@ -1427,7 +1553,7 @@ static void smsc911x_set_multicast_list(struct net_device *dev)
1427 * receiving data */ 1553 * receiving data */
1428 if (!pdata->multicast_update_pending) { 1554 if (!pdata->multicast_update_pending) {
1429 unsigned int temp; 1555 unsigned int temp;
1430 SMSC_TRACE(HW, "scheduling mcast update"); 1556 SMSC_TRACE(pdata, hw, "scheduling mcast update");
1431 pdata->multicast_update_pending = 1; 1557 pdata->multicast_update_pending = 1;
1432 1558
1433 /* Request the hardware to stop, then perform the 1559 /* Request the hardware to stop, then perform the
@@ -1469,7 +1595,7 @@ static irqreturn_t smsc911x_irqhandler(int irq, void *dev_id)
1469 if (unlikely(intsts & inten & INT_STS_RXSTOP_INT_)) { 1595 if (unlikely(intsts & inten & INT_STS_RXSTOP_INT_)) {
1470 /* Called when there is a multicast update scheduled and 1596 /* Called when there is a multicast update scheduled and
1471 * it is now safe to complete the update */ 1597 * it is now safe to complete the update */
1472 SMSC_TRACE(INTR, "RX Stop interrupt"); 1598 SMSC_TRACE(pdata, intr, "RX Stop interrupt");
1473 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXSTOP_INT_); 1599 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXSTOP_INT_);
1474 if (pdata->multicast_update_pending) 1600 if (pdata->multicast_update_pending)
1475 smsc911x_rx_multicast_update_workaround(pdata); 1601 smsc911x_rx_multicast_update_workaround(pdata);
@@ -1486,7 +1612,7 @@ static irqreturn_t smsc911x_irqhandler(int irq, void *dev_id)
1486 } 1612 }
1487 1613
1488 if (unlikely(intsts & inten & INT_STS_RXE_)) { 1614 if (unlikely(intsts & inten & INT_STS_RXE_)) {
1489 SMSC_TRACE(INTR, "RX Error interrupt"); 1615 SMSC_TRACE(pdata, intr, "RX Error interrupt");
1490 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXE_); 1616 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXE_);
1491 serviced = IRQ_HANDLED; 1617 serviced = IRQ_HANDLED;
1492 } 1618 }
@@ -1500,8 +1626,7 @@ static irqreturn_t smsc911x_irqhandler(int irq, void *dev_id)
1500 /* Schedule a NAPI poll */ 1626 /* Schedule a NAPI poll */
1501 __napi_schedule(&pdata->napi); 1627 __napi_schedule(&pdata->napi);
1502 } else { 1628 } else {
1503 SMSC_WARNING(RX_ERR, 1629 SMSC_WARN(pdata, rx_err, "napi_schedule_prep failed");
1504 "napi_schedule_prep failed");
1505 } 1630 }
1506 serviced = IRQ_HANDLED; 1631 serviced = IRQ_HANDLED;
1507 } 1632 }
@@ -1538,7 +1663,7 @@ static int smsc911x_set_mac_address(struct net_device *dev, void *p)
1538 smsc911x_set_hw_mac_address(pdata, dev->dev_addr); 1663 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
1539 spin_unlock_irq(&pdata->mac_lock); 1664 spin_unlock_irq(&pdata->mac_lock);
1540 1665
1541 dev_info(&dev->dev, "MAC Address: %pM\n", dev->dev_addr); 1666 netdev_info(dev, "MAC Address: %pM\n", dev->dev_addr);
1542 1667
1543 return 0; 1668 return 0;
1544} 1669}
@@ -1644,9 +1769,9 @@ static int smsc911x_eeprom_send_cmd(struct smsc911x_data *pdata, u32 op)
1644 int timeout = 100; 1769 int timeout = 100;
1645 u32 e2cmd; 1770 u32 e2cmd;
1646 1771
1647 SMSC_TRACE(DRV, "op 0x%08x", op); 1772 SMSC_TRACE(pdata, drv, "op 0x%08x", op);
1648 if (smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) { 1773 if (smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) {
1649 SMSC_WARNING(DRV, "Busy at start"); 1774 SMSC_WARN(pdata, drv, "Busy at start");
1650 return -EBUSY; 1775 return -EBUSY;
1651 } 1776 }
1652 1777
@@ -1659,12 +1784,12 @@ static int smsc911x_eeprom_send_cmd(struct smsc911x_data *pdata, u32 op)
1659 } while ((e2cmd & E2P_CMD_EPC_BUSY_) && (--timeout)); 1784 } while ((e2cmd & E2P_CMD_EPC_BUSY_) && (--timeout));
1660 1785
1661 if (!timeout) { 1786 if (!timeout) {
1662 SMSC_TRACE(DRV, "TIMED OUT"); 1787 SMSC_TRACE(pdata, drv, "TIMED OUT");
1663 return -EAGAIN; 1788 return -EAGAIN;
1664 } 1789 }
1665 1790
1666 if (e2cmd & E2P_CMD_EPC_TIMEOUT_) { 1791 if (e2cmd & E2P_CMD_EPC_TIMEOUT_) {
1667 SMSC_TRACE(DRV, "Error occured during eeprom operation"); 1792 SMSC_TRACE(pdata, drv, "Error occurred during eeprom operation");
1668 return -EINVAL; 1793 return -EINVAL;
1669 } 1794 }
1670 1795
@@ -1677,7 +1802,7 @@ static int smsc911x_eeprom_read_location(struct smsc911x_data *pdata,
1677 u32 op = E2P_CMD_EPC_CMD_READ_ | address; 1802 u32 op = E2P_CMD_EPC_CMD_READ_ | address;
1678 int ret; 1803 int ret;
1679 1804
1680 SMSC_TRACE(DRV, "address 0x%x", address); 1805 SMSC_TRACE(pdata, drv, "address 0x%x", address);
1681 ret = smsc911x_eeprom_send_cmd(pdata, op); 1806 ret = smsc911x_eeprom_send_cmd(pdata, op);
1682 1807
1683 if (!ret) 1808 if (!ret)
@@ -1693,7 +1818,7 @@ static int smsc911x_eeprom_write_location(struct smsc911x_data *pdata,
1693 u32 temp; 1818 u32 temp;
1694 int ret; 1819 int ret;
1695 1820
1696 SMSC_TRACE(DRV, "address 0x%x, data 0x%x", address, data); 1821 SMSC_TRACE(pdata, drv, "address 0x%x, data 0x%x", address, data);
1697 ret = smsc911x_eeprom_send_cmd(pdata, op); 1822 ret = smsc911x_eeprom_send_cmd(pdata, op);
1698 1823
1699 if (!ret) { 1824 if (!ret) {
@@ -1806,25 +1931,26 @@ static int __devinit smsc911x_init(struct net_device *dev)
1806 struct smsc911x_data *pdata = netdev_priv(dev); 1931 struct smsc911x_data *pdata = netdev_priv(dev);
1807 unsigned int byte_test; 1932 unsigned int byte_test;
1808 1933
1809 SMSC_TRACE(PROBE, "Driver Parameters:"); 1934 SMSC_TRACE(pdata, probe, "Driver Parameters:");
1810 SMSC_TRACE(PROBE, "LAN base: 0x%08lX", 1935 SMSC_TRACE(pdata, probe, "LAN base: 0x%08lX",
1811 (unsigned long)pdata->ioaddr); 1936 (unsigned long)pdata->ioaddr);
1812 SMSC_TRACE(PROBE, "IRQ: %d", dev->irq); 1937 SMSC_TRACE(pdata, probe, "IRQ: %d", dev->irq);
1813 SMSC_TRACE(PROBE, "PHY will be autodetected."); 1938 SMSC_TRACE(pdata, probe, "PHY will be autodetected.");
1814 1939
1815 spin_lock_init(&pdata->dev_lock); 1940 spin_lock_init(&pdata->dev_lock);
1941 spin_lock_init(&pdata->mac_lock);
1816 1942
1817 if (pdata->ioaddr == 0) { 1943 if (pdata->ioaddr == 0) {
1818 SMSC_WARNING(PROBE, "pdata->ioaddr: 0x00000000"); 1944 SMSC_WARN(pdata, probe, "pdata->ioaddr: 0x00000000");
1819 return -ENODEV; 1945 return -ENODEV;
1820 } 1946 }
1821 1947
1822 /* Check byte ordering */ 1948 /* Check byte ordering */
1823 byte_test = smsc911x_reg_read(pdata, BYTE_TEST); 1949 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
1824 SMSC_TRACE(PROBE, "BYTE_TEST: 0x%08X", byte_test); 1950 SMSC_TRACE(pdata, probe, "BYTE_TEST: 0x%08X", byte_test);
1825 if (byte_test == 0x43218765) { 1951 if (byte_test == 0x43218765) {
1826 SMSC_TRACE(PROBE, "BYTE_TEST looks swapped, " 1952 SMSC_TRACE(pdata, probe, "BYTE_TEST looks swapped, "
1827 "applying WORD_SWAP"); 1953 "applying WORD_SWAP");
1828 smsc911x_reg_write(pdata, WORD_SWAP, 0xffffffff); 1954 smsc911x_reg_write(pdata, WORD_SWAP, 0xffffffff);
1829 1955
1830 /* 1 dummy read of BYTE_TEST is needed after a write to 1956 /* 1 dummy read of BYTE_TEST is needed after a write to
@@ -1835,12 +1961,13 @@ static int __devinit smsc911x_init(struct net_device *dev)
1835 } 1961 }
1836 1962
1837 if (byte_test != 0x87654321) { 1963 if (byte_test != 0x87654321) {
1838 SMSC_WARNING(DRV, "BYTE_TEST: 0x%08X", byte_test); 1964 SMSC_WARN(pdata, drv, "BYTE_TEST: 0x%08X", byte_test);
1839 if (((byte_test >> 16) & 0xFFFF) == (byte_test & 0xFFFF)) { 1965 if (((byte_test >> 16) & 0xFFFF) == (byte_test & 0xFFFF)) {
1840 SMSC_WARNING(PROBE, 1966 SMSC_WARN(pdata, probe,
1841 "top 16 bits equal to bottom 16 bits"); 1967 "top 16 bits equal to bottom 16 bits");
1842 SMSC_TRACE(PROBE, "This may mean the chip is set " 1968 SMSC_TRACE(pdata, probe,
1843 "for 32 bit while the bus is reading 16 bit"); 1969 "This may mean the chip is set "
1970 "for 32 bit while the bus is reading 16 bit");
1844 } 1971 }
1845 return -ENODEV; 1972 return -ENODEV;
1846 } 1973 }
@@ -1875,23 +2002,27 @@ static int __devinit smsc911x_init(struct net_device *dev)
1875 break; 2002 break;
1876 2003
1877 default: 2004 default:
1878 SMSC_WARNING(PROBE, "LAN911x not identified, idrev: 0x%08X", 2005 SMSC_WARN(pdata, probe, "LAN911x not identified, idrev: 0x%08X",
1879 pdata->idrev); 2006 pdata->idrev);
1880 return -ENODEV; 2007 return -ENODEV;
1881 } 2008 }
1882 2009
1883 SMSC_TRACE(PROBE, "LAN911x identified, idrev: 0x%08X, generation: %d", 2010 SMSC_TRACE(pdata, probe,
1884 pdata->idrev, pdata->generation); 2011 "LAN911x identified, idrev: 0x%08X, generation: %d",
2012 pdata->idrev, pdata->generation);
1885 2013
1886 if (pdata->generation == 0) 2014 if (pdata->generation == 0)
1887 SMSC_WARNING(PROBE, 2015 SMSC_WARN(pdata, probe,
1888 "This driver is not intended for this chip revision"); 2016 "This driver is not intended for this chip revision");
1889 2017
1890 /* workaround for platforms without an eeprom, where the mac address 2018 /* workaround for platforms without an eeprom, where the mac address
1891 * is stored elsewhere and set by the bootloader. This saves the 2019 * is stored elsewhere and set by the bootloader. This saves the
1892 * mac address before resetting the device */ 2020 * mac address before resetting the device */
1893 if (pdata->config.flags & SMSC911X_SAVE_MAC_ADDRESS) 2021 if (pdata->config.flags & SMSC911X_SAVE_MAC_ADDRESS) {
2022 spin_lock_irq(&pdata->mac_lock);
1894 smsc911x_read_mac_address(dev); 2023 smsc911x_read_mac_address(dev);
2024 spin_unlock_irq(&pdata->mac_lock);
2025 }
1895 2026
1896 /* Reset the LAN911x */ 2027 /* Reset the LAN911x */
1897 if (smsc911x_soft_reset(pdata)) 2028 if (smsc911x_soft_reset(pdata))
@@ -1922,7 +2053,7 @@ static int __devexit smsc911x_drv_remove(struct platform_device *pdev)
1922 BUG_ON(!pdata->ioaddr); 2053 BUG_ON(!pdata->ioaddr);
1923 BUG_ON(!pdata->phy_dev); 2054 BUG_ON(!pdata->phy_dev);
1924 2055
1925 SMSC_TRACE(IFDOWN, "Stopping driver."); 2056 SMSC_TRACE(pdata, ifdown, "Stopping driver");
1926 2057
1927 phy_disconnect(pdata->phy_dev); 2058 phy_disconnect(pdata->phy_dev);
1928 pdata->phy_dev = NULL; 2059 pdata->phy_dev = NULL;
@@ -1946,6 +2077,22 @@ static int __devexit smsc911x_drv_remove(struct platform_device *pdev)
1946 return 0; 2077 return 0;
1947} 2078}
1948 2079
2080/* standard register acces */
2081static const struct smsc911x_ops standard_smsc911x_ops = {
2082 .reg_read = __smsc911x_reg_read,
2083 .reg_write = __smsc911x_reg_write,
2084 .rx_readfifo = smsc911x_rx_readfifo,
2085 .tx_writefifo = smsc911x_tx_writefifo,
2086};
2087
2088/* shifted register access */
2089static const struct smsc911x_ops shifted_smsc911x_ops = {
2090 .reg_read = __smsc911x_reg_read_shift,
2091 .reg_write = __smsc911x_reg_write_shift,
2092 .rx_readfifo = smsc911x_rx_readfifo_shift,
2093 .tx_writefifo = smsc911x_tx_writefifo_shift,
2094};
2095
1949static int __devinit smsc911x_drv_probe(struct platform_device *pdev) 2096static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
1950{ 2097{
1951 struct net_device *dev; 2098 struct net_device *dev;
@@ -1956,11 +2103,11 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
1956 int res_size, irq_flags; 2103 int res_size, irq_flags;
1957 int retval; 2104 int retval;
1958 2105
1959 pr_info("%s: Driver version %s.\n", SMSC_CHIPNAME, SMSC_DRV_VERSION); 2106 pr_info("Driver version %s\n", SMSC_DRV_VERSION);
1960 2107
1961 /* platform data specifies irq & dynamic bus configuration */ 2108 /* platform data specifies irq & dynamic bus configuration */
1962 if (!pdev->dev.platform_data) { 2109 if (!pdev->dev.platform_data) {
1963 pr_warning("%s: platform_data not provided\n", SMSC_CHIPNAME); 2110 pr_warn("platform_data not provided\n");
1964 retval = -ENODEV; 2111 retval = -ENODEV;
1965 goto out_0; 2112 goto out_0;
1966 } 2113 }
@@ -1970,8 +2117,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
1970 if (!res) 2117 if (!res)
1971 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 2118 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1972 if (!res) { 2119 if (!res) {
1973 pr_warning("%s: Could not allocate resource.\n", 2120 pr_warn("Could not allocate resource\n");
1974 SMSC_CHIPNAME);
1975 retval = -ENODEV; 2121 retval = -ENODEV;
1976 goto out_0; 2122 goto out_0;
1977 } 2123 }
@@ -1979,8 +2125,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
1979 2125
1980 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 2126 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1981 if (!irq_res) { 2127 if (!irq_res) {
1982 pr_warning("%s: Could not allocate irq resource.\n", 2128 pr_warn("Could not allocate irq resource\n");
1983 SMSC_CHIPNAME);
1984 retval = -ENODEV; 2129 retval = -ENODEV;
1985 goto out_0; 2130 goto out_0;
1986 } 2131 }
@@ -1992,7 +2137,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
1992 2137
1993 dev = alloc_etherdev(sizeof(struct smsc911x_data)); 2138 dev = alloc_etherdev(sizeof(struct smsc911x_data));
1994 if (!dev) { 2139 if (!dev) {
1995 pr_warning("%s: Could not allocate device.\n", SMSC_CHIPNAME); 2140 pr_warn("Could not allocate device\n");
1996 retval = -ENOMEM; 2141 retval = -ENOMEM;
1997 goto out_release_io_1; 2142 goto out_release_io_1;
1998 } 2143 }
@@ -2012,12 +2157,17 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
2012 pdata->msg_enable = ((1 << debug) - 1); 2157 pdata->msg_enable = ((1 << debug) - 1);
2013 2158
2014 if (pdata->ioaddr == NULL) { 2159 if (pdata->ioaddr == NULL) {
2015 SMSC_WARNING(PROBE, 2160 SMSC_WARN(pdata, probe, "Error smsc911x base address invalid");
2016 "Error smsc911x base address invalid");
2017 retval = -ENOMEM; 2161 retval = -ENOMEM;
2018 goto out_free_netdev_2; 2162 goto out_free_netdev_2;
2019 } 2163 }
2020 2164
2165 /* assume standard, non-shifted, access to HW registers */
2166 pdata->ops = &standard_smsc911x_ops;
2167 /* apply the right access if shifting is needed */
2168 if (config->shift)
2169 pdata->ops = &shifted_smsc911x_ops;
2170
2021 retval = smsc911x_init(dev); 2171 retval = smsc911x_init(dev);
2022 if (retval < 0) 2172 if (retval < 0)
2023 goto out_unmap_io_3; 2173 goto out_unmap_io_3;
@@ -2038,8 +2188,8 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
2038 retval = request_irq(dev->irq, smsc911x_irqhandler, 2188 retval = request_irq(dev->irq, smsc911x_irqhandler,
2039 irq_flags | IRQF_SHARED, dev->name, dev); 2189 irq_flags | IRQF_SHARED, dev->name, dev);
2040 if (retval) { 2190 if (retval) {
2041 SMSC_WARNING(PROBE, 2191 SMSC_WARN(pdata, probe,
2042 "Unable to claim requested irq: %d", dev->irq); 2192 "Unable to claim requested irq: %d", dev->irq);
2043 goto out_unmap_io_3; 2193 goto out_unmap_io_3;
2044 } 2194 }
2045 2195
@@ -2047,19 +2197,16 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
2047 2197
2048 retval = register_netdev(dev); 2198 retval = register_netdev(dev);
2049 if (retval) { 2199 if (retval) {
2050 SMSC_WARNING(PROBE, 2200 SMSC_WARN(pdata, probe, "Error %i registering device", retval);
2051 "Error %i registering device", retval);
2052 goto out_unset_drvdata_4; 2201 goto out_unset_drvdata_4;
2053 } else { 2202 } else {
2054 SMSC_TRACE(PROBE, "Network interface: \"%s\"", dev->name); 2203 SMSC_TRACE(pdata, probe,
2204 "Network interface: \"%s\"", dev->name);
2055 } 2205 }
2056 2206
2057 spin_lock_init(&pdata->mac_lock);
2058
2059 retval = smsc911x_mii_init(pdev, dev); 2207 retval = smsc911x_mii_init(pdev, dev);
2060 if (retval) { 2208 if (retval) {
2061 SMSC_WARNING(PROBE, 2209 SMSC_WARN(pdata, probe, "Error %i initialising mii", retval);
2062 "Error %i initialising mii", retval);
2063 goto out_unregister_netdev_5; 2210 goto out_unregister_netdev_5;
2064 } 2211 }
2065 2212
@@ -2068,31 +2215,33 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
2068 /* Check if mac address has been specified when bringing interface up */ 2215 /* Check if mac address has been specified when bringing interface up */
2069 if (is_valid_ether_addr(dev->dev_addr)) { 2216 if (is_valid_ether_addr(dev->dev_addr)) {
2070 smsc911x_set_hw_mac_address(pdata, dev->dev_addr); 2217 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
2071 SMSC_TRACE(PROBE, "MAC Address is specified by configuration"); 2218 SMSC_TRACE(pdata, probe,
2219 "MAC Address is specified by configuration");
2072 } else if (is_valid_ether_addr(pdata->config.mac)) { 2220 } else if (is_valid_ether_addr(pdata->config.mac)) {
2073 memcpy(dev->dev_addr, pdata->config.mac, 6); 2221 memcpy(dev->dev_addr, pdata->config.mac, 6);
2074 SMSC_TRACE(PROBE, "MAC Address specified by platform data"); 2222 SMSC_TRACE(pdata, probe,
2223 "MAC Address specified by platform data");
2075 } else { 2224 } else {
2076 /* Try reading mac address from device. if EEPROM is present 2225 /* Try reading mac address from device. if EEPROM is present
2077 * it will already have been set */ 2226 * it will already have been set */
2078 smsc911x_read_mac_address(dev); 2227 smsc_get_mac(dev);
2079 2228
2080 if (is_valid_ether_addr(dev->dev_addr)) { 2229 if (is_valid_ether_addr(dev->dev_addr)) {
2081 /* eeprom values are valid so use them */ 2230 /* eeprom values are valid so use them */
2082 SMSC_TRACE(PROBE, 2231 SMSC_TRACE(pdata, probe,
2083 "Mac Address is read from LAN911x EEPROM"); 2232 "Mac Address is read from LAN911x EEPROM");
2084 } else { 2233 } else {
2085 /* eeprom values are invalid, generate random MAC */ 2234 /* eeprom values are invalid, generate random MAC */
2086 random_ether_addr(dev->dev_addr); 2235 random_ether_addr(dev->dev_addr);
2087 smsc911x_set_hw_mac_address(pdata, dev->dev_addr); 2236 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
2088 SMSC_TRACE(PROBE, 2237 SMSC_TRACE(pdata, probe,
2089 "MAC Address is set to random_ether_addr"); 2238 "MAC Address is set to random_ether_addr");
2090 } 2239 }
2091 } 2240 }
2092 2241
2093 spin_unlock_irq(&pdata->mac_lock); 2242 spin_unlock_irq(&pdata->mac_lock);
2094 2243
2095 dev_info(&dev->dev, "MAC Address: %pM\n", dev->dev_addr); 2244 netdev_info(dev, "MAC Address: %pM\n", dev->dev_addr);
2096 2245
2097 return 0; 2246 return 0;
2098 2247
@@ -2176,6 +2325,7 @@ static struct platform_driver smsc911x_driver = {
2176/* Entry point for loading the module */ 2325/* Entry point for loading the module */
2177static int __init smsc911x_init_module(void) 2326static int __init smsc911x_init_module(void)
2178{ 2327{
2328 SMSC_INITIALIZE();
2179 return platform_driver_register(&smsc911x_driver); 2329 return platform_driver_register(&smsc911x_driver);
2180} 2330}
2181 2331
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-04 18:44:58 -0400