Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1 | /* |
| 2 | * smc911x.c |
| 3 | * This is a driver for SMSC's LAN911{5,6,7,8} single-chip Ethernet devices. |
| 4 | * |
| 5 | * Copyright (C) 2005 Sensoria Corp |
| 6 | * Derived from the unified SMC91x driver by Nicolas Pitre |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 7 | * and the smsc911x.c reference driver by SMSC |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 8 | * |
| 9 | * This program is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License as published by |
| 11 | * the Free Software Foundation; either version 2 of the License, or |
| 12 | * (at your option) any later version. |
| 13 | * |
| 14 | * This program is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | * GNU General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU General Public License |
| 20 | * along with this program; if not, write to the Free Software |
| 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 22 | * |
| 23 | * Arguments: |
| 24 | * watchdog = TX watchdog timeout |
| 25 | * tx_fifo_kb = Size of TX FIFO in KB |
| 26 | * |
| 27 | * History: |
| 28 | * 04/16/05 Dustin McIntire Initial version |
| 29 | */ |
| 30 | static const char version[] = |
| 31 | "smc911x.c: v1.0 04-16-2005 by Dustin McIntire <dustin@sensoria.com>\n"; |
| 32 | |
| 33 | /* Debugging options */ |
| 34 | #define ENABLE_SMC_DEBUG_RX 0 |
| 35 | #define ENABLE_SMC_DEBUG_TX 0 |
| 36 | #define ENABLE_SMC_DEBUG_DMA 0 |
| 37 | #define ENABLE_SMC_DEBUG_PKTS 0 |
| 38 | #define ENABLE_SMC_DEBUG_MISC 0 |
| 39 | #define ENABLE_SMC_DEBUG_FUNC 0 |
| 40 | |
| 41 | #define SMC_DEBUG_RX ((ENABLE_SMC_DEBUG_RX ? 1 : 0) << 0) |
| 42 | #define SMC_DEBUG_TX ((ENABLE_SMC_DEBUG_TX ? 1 : 0) << 1) |
| 43 | #define SMC_DEBUG_DMA ((ENABLE_SMC_DEBUG_DMA ? 1 : 0) << 2) |
| 44 | #define SMC_DEBUG_PKTS ((ENABLE_SMC_DEBUG_PKTS ? 1 : 0) << 3) |
| 45 | #define SMC_DEBUG_MISC ((ENABLE_SMC_DEBUG_MISC ? 1 : 0) << 4) |
| 46 | #define SMC_DEBUG_FUNC ((ENABLE_SMC_DEBUG_FUNC ? 1 : 0) << 5) |
| 47 | |
| 48 | #ifndef SMC_DEBUG |
| 49 | #define SMC_DEBUG ( SMC_DEBUG_RX | \ |
| 50 | SMC_DEBUG_TX | \ |
| 51 | SMC_DEBUG_DMA | \ |
| 52 | SMC_DEBUG_PKTS | \ |
| 53 | SMC_DEBUG_MISC | \ |
| 54 | SMC_DEBUG_FUNC \ |
| 55 | ) |
| 56 | #endif |
| 57 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 58 | #include <linux/init.h> |
| 59 | #include <linux/module.h> |
| 60 | #include <linux/kernel.h> |
| 61 | #include <linux/sched.h> |
| 62 | #include <linux/slab.h> |
| 63 | #include <linux/delay.h> |
| 64 | #include <linux/interrupt.h> |
| 65 | #include <linux/errno.h> |
| 66 | #include <linux/ioport.h> |
| 67 | #include <linux/crc32.h> |
| 68 | #include <linux/device.h> |
| 69 | #include <linux/platform_device.h> |
| 70 | #include <linux/spinlock.h> |
| 71 | #include <linux/ethtool.h> |
| 72 | #include <linux/mii.h> |
| 73 | #include <linux/workqueue.h> |
| 74 | |
| 75 | #include <linux/netdevice.h> |
| 76 | #include <linux/etherdevice.h> |
| 77 | #include <linux/skbuff.h> |
| 78 | |
| 79 | #include <asm/io.h> |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 80 | |
| 81 | #include "smc911x.h" |
| 82 | |
| 83 | /* |
| 84 | * Transmit timeout, default 5 seconds. |
| 85 | */ |
| 86 | static int watchdog = 5000; |
| 87 | module_param(watchdog, int, 0400); |
| 88 | MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds"); |
| 89 | |
| 90 | static int tx_fifo_kb=8; |
| 91 | module_param(tx_fifo_kb, int, 0400); |
| 92 | MODULE_PARM_DESC(tx_fifo_kb,"transmit FIFO size in KB (1<x<15)(default=8)"); |
| 93 | |
| 94 | MODULE_LICENSE("GPL"); |
Kay Sievers | 72abb46 | 2008-04-18 13:50:44 -0700 | [diff] [blame] | 95 | MODULE_ALIAS("platform:smc911x"); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 96 | |
| 97 | /* |
| 98 | * The internal workings of the driver. If you are changing anything |
| 99 | * here with the SMC stuff, you should have the datasheet and know |
| 100 | * what you are doing. |
| 101 | */ |
| 102 | #define CARDNAME "smc911x" |
| 103 | |
| 104 | /* |
| 105 | * Use power-down feature of the chip |
| 106 | */ |
| 107 | #define POWER_DOWN 1 |
| 108 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 109 | #if SMC_DEBUG > 0 |
| 110 | #define DBG(n, args...) \ |
| 111 | do { \ |
| 112 | if (SMC_DEBUG & (n)) \ |
| 113 | printk(args); \ |
| 114 | } while (0) |
| 115 | |
| 116 | #define PRINTK(args...) printk(args) |
| 117 | #else |
| 118 | #define DBG(n, args...) do { } while (0) |
| 119 | #define PRINTK(args...) printk(KERN_DEBUG args) |
| 120 | #endif |
| 121 | |
| 122 | #if SMC_DEBUG_PKTS > 0 |
| 123 | static void PRINT_PKT(u_char *buf, int length) |
| 124 | { |
| 125 | int i; |
| 126 | int remainder; |
| 127 | int lines; |
| 128 | |
| 129 | lines = length / 16; |
| 130 | remainder = length % 16; |
| 131 | |
| 132 | for (i = 0; i < lines ; i ++) { |
| 133 | int cur; |
| 134 | for (cur = 0; cur < 8; cur++) { |
| 135 | u_char a, b; |
| 136 | a = *buf++; |
| 137 | b = *buf++; |
| 138 | printk("%02x%02x ", a, b); |
| 139 | } |
| 140 | printk("\n"); |
| 141 | } |
| 142 | for (i = 0; i < remainder/2 ; i++) { |
| 143 | u_char a, b; |
| 144 | a = *buf++; |
| 145 | b = *buf++; |
| 146 | printk("%02x%02x ", a, b); |
| 147 | } |
| 148 | printk("\n"); |
| 149 | } |
| 150 | #else |
| 151 | #define PRINT_PKT(x...) do { } while (0) |
| 152 | #endif |
| 153 | |
| 154 | |
| 155 | /* this enables an interrupt in the interrupt mask register */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 156 | #define SMC_ENABLE_INT(lp, x) do { \ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 157 | unsigned int __mask; \ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 158 | __mask = SMC_GET_INT_EN((lp)); \ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 159 | __mask |= (x); \ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 160 | SMC_SET_INT_EN((lp), __mask); \ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 161 | } while (0) |
| 162 | |
| 163 | /* this disables an interrupt from the interrupt mask register */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 164 | #define SMC_DISABLE_INT(lp, x) do { \ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 165 | unsigned int __mask; \ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 166 | __mask = SMC_GET_INT_EN((lp)); \ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 167 | __mask &= ~(x); \ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 168 | SMC_SET_INT_EN((lp), __mask); \ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 169 | } while (0) |
| 170 | |
| 171 | /* |
| 172 | * this does a soft reset on the device |
| 173 | */ |
| 174 | static void smc911x_reset(struct net_device *dev) |
| 175 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 176 | struct smc911x_local *lp = netdev_priv(dev); |
Catalin Marinas | 319edaf | 2008-10-20 18:15:30 +0100 | [diff] [blame] | 177 | unsigned int reg, timeout=0, resets=1, irq_cfg; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 178 | unsigned long flags; |
| 179 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 180 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 181 | |
| 182 | /* Take out of PM setting first */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 183 | if ((SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_) == 0) { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 184 | /* Write to the bytetest will take out of powerdown */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 185 | SMC_SET_BYTE_TEST(lp, 0); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 186 | timeout=10; |
| 187 | do { |
| 188 | udelay(10); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 189 | reg = SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_; |
Roel Kluin | db2961c | 2008-04-18 13:50:48 -0700 | [diff] [blame] | 190 | } while (--timeout && !reg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 191 | if (timeout == 0) { |
| 192 | PRINTK("%s: smc911x_reset timeout waiting for PM restore\n", dev->name); |
| 193 | return; |
| 194 | } |
| 195 | } |
| 196 | |
| 197 | /* Disable all interrupts */ |
| 198 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 199 | SMC_SET_INT_EN(lp, 0); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 200 | spin_unlock_irqrestore(&lp->lock, flags); |
| 201 | |
| 202 | while (resets--) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 203 | SMC_SET_HW_CFG(lp, HW_CFG_SRST_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 204 | timeout=10; |
| 205 | do { |
| 206 | udelay(10); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 207 | reg = SMC_GET_HW_CFG(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 208 | /* If chip indicates reset timeout then try again */ |
| 209 | if (reg & HW_CFG_SRST_TO_) { |
| 210 | PRINTK("%s: chip reset timeout, retrying...\n", dev->name); |
| 211 | resets++; |
| 212 | break; |
| 213 | } |
Roel Kluin | db2961c | 2008-04-18 13:50:48 -0700 | [diff] [blame] | 214 | } while (--timeout && (reg & HW_CFG_SRST_)); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 215 | } |
| 216 | if (timeout == 0) { |
| 217 | PRINTK("%s: smc911x_reset timeout waiting for reset\n", dev->name); |
| 218 | return; |
| 219 | } |
| 220 | |
| 221 | /* make sure EEPROM has finished loading before setting GPIO_CFG */ |
| 222 | timeout=1000; |
Roel Kluin | 46578a69 | 2009-02-02 21:39:02 -0800 | [diff] [blame] | 223 | while (--timeout && (SMC_GET_E2P_CMD(lp) & E2P_CMD_EPC_BUSY_)) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 224 | udelay(10); |
Roel Kluin | 46578a69 | 2009-02-02 21:39:02 -0800 | [diff] [blame] | 225 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 226 | if (timeout == 0){ |
| 227 | PRINTK("%s: smc911x_reset timeout waiting for EEPROM busy\n", dev->name); |
| 228 | return; |
| 229 | } |
| 230 | |
| 231 | /* Initialize interrupts */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 232 | SMC_SET_INT_EN(lp, 0); |
| 233 | SMC_ACK_INT(lp, -1); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 234 | |
| 235 | /* Reset the FIFO level and flow control settings */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 236 | SMC_SET_HW_CFG(lp, (lp->tx_fifo_kb & 0xF) << 16); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 237 | //TODO: Figure out what appropriate pause time is |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 238 | SMC_SET_FLOW(lp, FLOW_FCPT_ | FLOW_FCEN_); |
| 239 | SMC_SET_AFC_CFG(lp, lp->afc_cfg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 240 | |
| 241 | |
| 242 | /* Set to LED outputs */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 243 | SMC_SET_GPIO_CFG(lp, 0x70070000); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 244 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 245 | /* |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 246 | * Deassert IRQ for 1*10us for edge type interrupts |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 247 | * and drive IRQ pin push-pull |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 248 | */ |
Catalin Marinas | 319edaf | 2008-10-20 18:15:30 +0100 | [diff] [blame] | 249 | irq_cfg = (1 << 24) | INT_CFG_IRQ_EN_ | INT_CFG_IRQ_TYPE_; |
| 250 | #ifdef SMC_DYNAMIC_BUS_CONFIG |
| 251 | if (lp->cfg.irq_polarity) |
| 252 | irq_cfg |= INT_CFG_IRQ_POL_; |
| 253 | #endif |
| 254 | SMC_SET_IRQ_CFG(lp, irq_cfg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 255 | |
| 256 | /* clear anything saved */ |
| 257 | if (lp->pending_tx_skb != NULL) { |
| 258 | dev_kfree_skb (lp->pending_tx_skb); |
| 259 | lp->pending_tx_skb = NULL; |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 260 | dev->stats.tx_errors++; |
| 261 | dev->stats.tx_aborted_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 262 | } |
| 263 | } |
| 264 | |
| 265 | /* |
| 266 | * Enable Interrupts, Receive, and Transmit |
| 267 | */ |
| 268 | static void smc911x_enable(struct net_device *dev) |
| 269 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 270 | struct smc911x_local *lp = netdev_priv(dev); |
| 271 | unsigned mask, cfg, cr; |
| 272 | unsigned long flags; |
| 273 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 274 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 275 | |
Catalin Marinas | b891a90 | 2008-10-20 18:15:37 +0100 | [diff] [blame] | 276 | spin_lock_irqsave(&lp->lock, flags); |
| 277 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 278 | SMC_SET_MAC_ADDR(lp, dev->dev_addr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 279 | |
| 280 | /* Enable TX */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 281 | cfg = SMC_GET_HW_CFG(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 282 | cfg &= HW_CFG_TX_FIF_SZ_ | 0xFFF; |
| 283 | cfg |= HW_CFG_SF_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 284 | SMC_SET_HW_CFG(lp, cfg); |
| 285 | SMC_SET_FIFO_TDA(lp, 0xFF); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 286 | /* Update TX stats on every 64 packets received or every 1 sec */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 287 | SMC_SET_FIFO_TSL(lp, 64); |
| 288 | SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 289 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 290 | SMC_GET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 291 | cr |= MAC_CR_TXEN_ | MAC_CR_HBDIS_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 292 | SMC_SET_MAC_CR(lp, cr); |
| 293 | SMC_SET_TX_CFG(lp, TX_CFG_TX_ON_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 294 | |
| 295 | /* Add 2 byte padding to start of packets */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 296 | SMC_SET_RX_CFG(lp, (2<<8) & RX_CFG_RXDOFF_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 297 | |
| 298 | /* Turn on receiver and enable RX */ |
| 299 | if (cr & MAC_CR_RXEN_) |
| 300 | DBG(SMC_DEBUG_RX, "%s: Receiver already enabled\n", dev->name); |
| 301 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 302 | SMC_SET_MAC_CR(lp, cr | MAC_CR_RXEN_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 303 | |
| 304 | /* Interrupt on every received packet */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 305 | SMC_SET_FIFO_RSA(lp, 0x01); |
| 306 | SMC_SET_FIFO_RSL(lp, 0x00); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 307 | |
| 308 | /* now, enable interrupts */ |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 309 | mask = INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_ | INT_EN_RSFL_EN_ | |
| 310 | INT_EN_GPT_INT_EN_ | INT_EN_RXDFH_INT_EN_ | INT_EN_RXE_EN_ | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 311 | INT_EN_PHY_INT_EN_; |
| 312 | if (IS_REV_A(lp->revision)) |
| 313 | mask|=INT_EN_RDFL_EN_; |
| 314 | else { |
| 315 | mask|=INT_EN_RDFO_EN_; |
| 316 | } |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 317 | SMC_ENABLE_INT(lp, mask); |
Catalin Marinas | b891a90 | 2008-10-20 18:15:37 +0100 | [diff] [blame] | 318 | |
| 319 | spin_unlock_irqrestore(&lp->lock, flags); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | /* |
| 323 | * this puts the device in an inactive state |
| 324 | */ |
| 325 | static void smc911x_shutdown(struct net_device *dev) |
| 326 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 327 | struct smc911x_local *lp = netdev_priv(dev); |
| 328 | unsigned cr; |
| 329 | unsigned long flags; |
| 330 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 331 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", CARDNAME, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 332 | |
| 333 | /* Disable IRQ's */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 334 | SMC_SET_INT_EN(lp, 0); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 335 | |
| 336 | /* Turn of Rx and TX */ |
| 337 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 338 | SMC_GET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 339 | cr &= ~(MAC_CR_TXEN_ | MAC_CR_RXEN_ | MAC_CR_HBDIS_); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 340 | SMC_SET_MAC_CR(lp, cr); |
| 341 | SMC_SET_TX_CFG(lp, TX_CFG_STOP_TX_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 342 | spin_unlock_irqrestore(&lp->lock, flags); |
| 343 | } |
| 344 | |
| 345 | static inline void smc911x_drop_pkt(struct net_device *dev) |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 346 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 347 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 348 | unsigned int fifo_count, timeout, reg; |
| 349 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 350 | DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n", CARDNAME, __func__); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 351 | fifo_count = SMC_GET_RX_FIFO_INF(lp) & 0xFFFF; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 352 | if (fifo_count <= 4) { |
| 353 | /* Manually dump the packet data */ |
| 354 | while (fifo_count--) |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 355 | SMC_GET_RX_FIFO(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 356 | } else { |
| 357 | /* Fast forward through the bad packet */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 358 | SMC_SET_RX_DP_CTRL(lp, RX_DP_CTRL_FFWD_BUSY_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 359 | timeout=50; |
| 360 | do { |
| 361 | udelay(10); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 362 | reg = SMC_GET_RX_DP_CTRL(lp) & RX_DP_CTRL_FFWD_BUSY_; |
Roel Kluin | db2961c | 2008-04-18 13:50:48 -0700 | [diff] [blame] | 363 | } while (--timeout && reg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 364 | if (timeout == 0) { |
| 365 | PRINTK("%s: timeout waiting for RX fast forward\n", dev->name); |
| 366 | } |
| 367 | } |
| 368 | } |
| 369 | |
| 370 | /* |
| 371 | * This is the procedure to handle the receipt of a packet. |
| 372 | * It should be called after checking for packet presence in |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 373 | * the RX status FIFO. It must be called with the spin lock |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 374 | * already held. |
| 375 | */ |
| 376 | static inline void smc911x_rcv(struct net_device *dev) |
| 377 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 378 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 379 | unsigned int pkt_len, status; |
| 380 | struct sk_buff *skb; |
| 381 | unsigned char *data; |
| 382 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 383 | DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 384 | dev->name, __func__); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 385 | status = SMC_GET_RX_STS_FIFO(lp); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 386 | DBG(SMC_DEBUG_RX, "%s: Rx pkt len %d status 0x%08x \n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 387 | dev->name, (status & 0x3fff0000) >> 16, status & 0xc000ffff); |
| 388 | pkt_len = (status & RX_STS_PKT_LEN_) >> 16; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 389 | if (status & RX_STS_ES_) { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 390 | /* Deal with a bad packet */ |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 391 | dev->stats.rx_errors++; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 392 | if (status & RX_STS_CRC_ERR_) |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 393 | dev->stats.rx_crc_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 394 | else { |
| 395 | if (status & RX_STS_LEN_ERR_) |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 396 | dev->stats.rx_length_errors++; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 397 | if (status & RX_STS_MCAST_) |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 398 | dev->stats.multicast++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 399 | } |
| 400 | /* Remove the bad packet data from the RX FIFO */ |
| 401 | smc911x_drop_pkt(dev); |
| 402 | } else { |
| 403 | /* Receive a valid packet */ |
| 404 | /* Alloc a buffer with extra room for DMA alignment */ |
| 405 | skb=dev_alloc_skb(pkt_len+32); |
| 406 | if (unlikely(skb == NULL)) { |
| 407 | PRINTK( "%s: Low memory, rcvd packet dropped.\n", |
| 408 | dev->name); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 409 | dev->stats.rx_dropped++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 410 | smc911x_drop_pkt(dev); |
| 411 | return; |
| 412 | } |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 413 | /* Align IP header to 32 bits |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 414 | * Note that the device is configured to add a 2 |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 415 | * byte padding to the packet start, so we really |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 416 | * want to write to the orignal data pointer */ |
| 417 | data = skb->data; |
| 418 | skb_reserve(skb, 2); |
| 419 | skb_put(skb,pkt_len-4); |
| 420 | #ifdef SMC_USE_DMA |
| 421 | { |
| 422 | unsigned int fifo; |
| 423 | /* Lower the FIFO threshold if possible */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 424 | fifo = SMC_GET_FIFO_INT(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 425 | if (fifo & 0xFF) fifo--; |
| 426 | DBG(SMC_DEBUG_RX, "%s: Setting RX stat FIFO threshold to %d\n", |
| 427 | dev->name, fifo & 0xff); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 428 | SMC_SET_FIFO_INT(lp, fifo); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 429 | /* Setup RX DMA */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 430 | SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN16_ | ((2<<8) & RX_CFG_RXDOFF_)); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 431 | lp->rxdma_active = 1; |
| 432 | lp->current_rx_skb = skb; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 433 | SMC_PULL_DATA(lp, data, (pkt_len+2+15) & ~15); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 434 | /* Packet processing deferred to DMA RX interrupt */ |
| 435 | } |
| 436 | #else |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 437 | SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN4_ | ((2<<8) & RX_CFG_RXDOFF_)); |
| 438 | SMC_PULL_DATA(lp, data, pkt_len+2+3); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 439 | |
Vitaly Wool | b4cf205 | 2007-04-27 14:42:09 +0400 | [diff] [blame] | 440 | DBG(SMC_DEBUG_PKTS, "%s: Received packet\n", dev->name); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 441 | PRINT_PKT(data, ((pkt_len - 4) <= 64) ? pkt_len - 4 : 64); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 442 | skb->protocol = eth_type_trans(skb, dev); |
| 443 | netif_rx(skb); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 444 | dev->stats.rx_packets++; |
| 445 | dev->stats.rx_bytes += pkt_len-4; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 446 | #endif |
| 447 | } |
| 448 | } |
| 449 | |
| 450 | /* |
| 451 | * This is called to actually send a packet to the chip. |
| 452 | */ |
| 453 | static void smc911x_hardware_send_pkt(struct net_device *dev) |
| 454 | { |
| 455 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 456 | struct sk_buff *skb; |
| 457 | unsigned int cmdA, cmdB, len; |
| 458 | unsigned char *buf; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 459 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 460 | DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 461 | BUG_ON(lp->pending_tx_skb == NULL); |
| 462 | |
| 463 | skb = lp->pending_tx_skb; |
| 464 | lp->pending_tx_skb = NULL; |
| 465 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 466 | /* cmdA {25:24] data alignment [20:16] start offset [10:0] buffer length */ |
| 467 | /* cmdB {31:16] pkt tag [10:0] length */ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 468 | #ifdef SMC_USE_DMA |
| 469 | /* 16 byte buffer alignment mode */ |
| 470 | buf = (char*)((u32)(skb->data) & ~0xF); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 471 | len = (skb->len + 0xF + ((u32)skb->data & 0xF)) & ~0xF; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 472 | cmdA = (1<<24) | (((u32)skb->data & 0xF)<<16) | |
| 473 | TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ | |
| 474 | skb->len; |
| 475 | #else |
| 476 | buf = (char*)((u32)skb->data & ~0x3); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 477 | len = (skb->len + 3 + ((u32)skb->data & 3)) & ~0x3; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 478 | cmdA = (((u32)skb->data & 0x3) << 16) | |
| 479 | TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ | |
| 480 | skb->len; |
| 481 | #endif |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 482 | /* tag is packet length so we can use this in stats update later */ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 483 | cmdB = (skb->len << 16) | (skb->len & 0x7FF); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 484 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 485 | DBG(SMC_DEBUG_TX, "%s: TX PKT LENGTH 0x%04x (%d) BUF 0x%p CMDA 0x%08x CMDB 0x%08x\n", |
| 486 | dev->name, len, len, buf, cmdA, cmdB); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 487 | SMC_SET_TX_FIFO(lp, cmdA); |
| 488 | SMC_SET_TX_FIFO(lp, cmdB); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 489 | |
| 490 | DBG(SMC_DEBUG_PKTS, "%s: Transmitted packet\n", dev->name); |
| 491 | PRINT_PKT(buf, len <= 64 ? len : 64); |
| 492 | |
| 493 | /* Send pkt via PIO or DMA */ |
| 494 | #ifdef SMC_USE_DMA |
| 495 | lp->current_tx_skb = skb; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 496 | SMC_PUSH_DATA(lp, buf, len); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 497 | /* DMA complete IRQ will free buffer and set jiffies */ |
| 498 | #else |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 499 | SMC_PUSH_DATA(lp, buf, len); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 500 | dev->trans_start = jiffies; |
Will Newton | 70d9d15 | 2008-10-28 10:52:36 +0000 | [diff] [blame] | 501 | dev_kfree_skb_irq(skb); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 502 | #endif |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 503 | if (!lp->tx_throttle) { |
| 504 | netif_wake_queue(dev); |
| 505 | } |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 506 | SMC_ENABLE_INT(lp, INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 507 | } |
| 508 | |
| 509 | /* |
| 510 | * Since I am not sure if I will have enough room in the chip's ram |
| 511 | * to store the packet, I call this routine which either sends it |
| 512 | * now, or set the card to generates an interrupt when ready |
| 513 | * for the packet. |
| 514 | */ |
| 515 | static int smc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) |
| 516 | { |
| 517 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 518 | unsigned int free; |
| 519 | unsigned long flags; |
| 520 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 521 | DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 522 | dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 523 | |
Catalin Marinas | b891a90 | 2008-10-20 18:15:37 +0100 | [diff] [blame] | 524 | spin_lock_irqsave(&lp->lock, flags); |
| 525 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 526 | BUG_ON(lp->pending_tx_skb != NULL); |
| 527 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 528 | free = SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TDFREE_; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 529 | DBG(SMC_DEBUG_TX, "%s: TX free space %d\n", dev->name, free); |
| 530 | |
| 531 | /* Turn off the flow when running out of space in FIFO */ |
| 532 | if (free <= SMC911X_TX_FIFO_LOW_THRESHOLD) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 533 | DBG(SMC_DEBUG_TX, "%s: Disabling data flow due to low FIFO space (%d)\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 534 | dev->name, free); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 535 | /* Reenable when at least 1 packet of size MTU present */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 536 | SMC_SET_FIFO_TDA(lp, (SMC911X_TX_FIFO_LOW_THRESHOLD)/64); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 537 | lp->tx_throttle = 1; |
| 538 | netif_stop_queue(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 539 | } |
| 540 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 541 | /* Drop packets when we run out of space in TX FIFO |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 542 | * Account for overhead required for: |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 543 | * |
| 544 | * Tx command words 8 bytes |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 545 | * Start offset 15 bytes |
| 546 | * End padding 15 bytes |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 547 | */ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 548 | if (unlikely(free < (skb->len + 8 + 15 + 15))) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 549 | printk("%s: No Tx free space %d < %d\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 550 | dev->name, free, skb->len); |
| 551 | lp->pending_tx_skb = NULL; |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 552 | dev->stats.tx_errors++; |
| 553 | dev->stats.tx_dropped++; |
Catalin Marinas | b891a90 | 2008-10-20 18:15:37 +0100 | [diff] [blame] | 554 | spin_unlock_irqrestore(&lp->lock, flags); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 555 | dev_kfree_skb(skb); |
| 556 | return 0; |
| 557 | } |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 558 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 559 | #ifdef SMC_USE_DMA |
| 560 | { |
| 561 | /* If the DMA is already running then defer this packet Tx until |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 562 | * the DMA IRQ starts it |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 563 | */ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 564 | if (lp->txdma_active) { |
| 565 | DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Tx DMA running, deferring packet\n", dev->name); |
| 566 | lp->pending_tx_skb = skb; |
| 567 | netif_stop_queue(dev); |
| 568 | spin_unlock_irqrestore(&lp->lock, flags); |
| 569 | return 0; |
| 570 | } else { |
| 571 | DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Activating Tx DMA\n", dev->name); |
| 572 | lp->txdma_active = 1; |
| 573 | } |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 574 | } |
| 575 | #endif |
| 576 | lp->pending_tx_skb = skb; |
| 577 | smc911x_hardware_send_pkt(dev); |
Catalin Marinas | b891a90 | 2008-10-20 18:15:37 +0100 | [diff] [blame] | 578 | spin_unlock_irqrestore(&lp->lock, flags); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 579 | |
| 580 | return 0; |
| 581 | } |
| 582 | |
| 583 | /* |
| 584 | * This handles a TX status interrupt, which is only called when: |
| 585 | * - a TX error occurred, or |
| 586 | * - TX of a packet completed. |
| 587 | */ |
| 588 | static void smc911x_tx(struct net_device *dev) |
| 589 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 590 | struct smc911x_local *lp = netdev_priv(dev); |
| 591 | unsigned int tx_status; |
| 592 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 593 | DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 594 | dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 595 | |
| 596 | /* Collect the TX status */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 597 | while (((SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16) != 0) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 598 | DBG(SMC_DEBUG_TX, "%s: Tx stat FIFO used 0x%04x\n", |
| 599 | dev->name, |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 600 | (SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16); |
| 601 | tx_status = SMC_GET_TX_STS_FIFO(lp); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 602 | dev->stats.tx_packets++; |
| 603 | dev->stats.tx_bytes+=tx_status>>16; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 604 | DBG(SMC_DEBUG_TX, "%s: Tx FIFO tag 0x%04x status 0x%04x\n", |
| 605 | dev->name, (tx_status & 0xffff0000) >> 16, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 606 | tx_status & 0x0000ffff); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 607 | /* count Tx errors, but ignore lost carrier errors when in |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 608 | * full-duplex mode */ |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 609 | if ((tx_status & TX_STS_ES_) && !(lp->ctl_rfduplx && |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 610 | !(tx_status & 0x00000306))) { |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 611 | dev->stats.tx_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 612 | } |
| 613 | if (tx_status & TX_STS_MANY_COLL_) { |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 614 | dev->stats.collisions+=16; |
| 615 | dev->stats.tx_aborted_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 616 | } else { |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 617 | dev->stats.collisions+=(tx_status & TX_STS_COLL_CNT_) >> 3; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 618 | } |
| 619 | /* carrier error only has meaning for half-duplex communication */ |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 620 | if ((tx_status & (TX_STS_LOC_ | TX_STS_NO_CARR_)) && |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 621 | !lp->ctl_rfduplx) { |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 622 | dev->stats.tx_carrier_errors++; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 623 | } |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 624 | if (tx_status & TX_STS_LATE_COLL_) { |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 625 | dev->stats.collisions++; |
| 626 | dev->stats.tx_aborted_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 627 | } |
| 628 | } |
| 629 | } |
| 630 | |
| 631 | |
| 632 | /*---PHY CONTROL AND CONFIGURATION-----------------------------------------*/ |
| 633 | /* |
| 634 | * Reads a register from the MII Management serial interface |
| 635 | */ |
| 636 | |
| 637 | static int smc911x_phy_read(struct net_device *dev, int phyaddr, int phyreg) |
| 638 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 639 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 640 | unsigned int phydata; |
| 641 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 642 | SMC_GET_MII(lp, phyreg, phyaddr, phydata); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 643 | |
| 644 | DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%02x, phydata=0x%04x\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 645 | __func__, phyaddr, phyreg, phydata); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 646 | return phydata; |
| 647 | } |
| 648 | |
| 649 | |
| 650 | /* |
| 651 | * Writes a register to the MII Management serial interface |
| 652 | */ |
| 653 | static void smc911x_phy_write(struct net_device *dev, int phyaddr, int phyreg, |
| 654 | int phydata) |
| 655 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 656 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 657 | |
| 658 | DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 659 | __func__, phyaddr, phyreg, phydata); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 660 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 661 | SMC_SET_MII(lp, phyreg, phyaddr, phydata); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 662 | } |
| 663 | |
| 664 | /* |
| 665 | * Finds and reports the PHY address (115 and 117 have external |
| 666 | * PHY interface 118 has internal only |
| 667 | */ |
| 668 | static void smc911x_phy_detect(struct net_device *dev) |
| 669 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 670 | struct smc911x_local *lp = netdev_priv(dev); |
| 671 | int phyaddr; |
| 672 | unsigned int cfg, id1, id2; |
| 673 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 674 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 675 | |
| 676 | lp->phy_type = 0; |
| 677 | |
| 678 | /* |
| 679 | * Scan all 32 PHY addresses if necessary, starting at |
| 680 | * PHY#1 to PHY#31, and then PHY#0 last. |
| 681 | */ |
| 682 | switch(lp->version) { |
Guennadi Liakhovetski | c6dcb82 | 2008-10-12 21:05:14 -0700 | [diff] [blame] | 683 | case CHIP_9115: |
| 684 | case CHIP_9117: |
| 685 | case CHIP_9215: |
| 686 | case CHIP_9217: |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 687 | cfg = SMC_GET_HW_CFG(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 688 | if (cfg & HW_CFG_EXT_PHY_DET_) { |
| 689 | cfg &= ~HW_CFG_PHY_CLK_SEL_; |
| 690 | cfg |= HW_CFG_PHY_CLK_SEL_CLK_DIS_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 691 | SMC_SET_HW_CFG(lp, cfg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 692 | udelay(10); /* Wait for clocks to stop */ |
| 693 | |
| 694 | cfg |= HW_CFG_EXT_PHY_EN_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 695 | SMC_SET_HW_CFG(lp, cfg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 696 | udelay(10); /* Wait for clocks to stop */ |
| 697 | |
| 698 | cfg &= ~HW_CFG_PHY_CLK_SEL_; |
| 699 | cfg |= HW_CFG_PHY_CLK_SEL_EXT_PHY_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 700 | SMC_SET_HW_CFG(lp, cfg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 701 | udelay(10); /* Wait for clocks to stop */ |
| 702 | |
| 703 | cfg |= HW_CFG_SMI_SEL_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 704 | SMC_SET_HW_CFG(lp, cfg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 705 | |
| 706 | for (phyaddr = 1; phyaddr < 32; ++phyaddr) { |
| 707 | |
| 708 | /* Read the PHY identifiers */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 709 | SMC_GET_PHY_ID1(lp, phyaddr & 31, id1); |
| 710 | SMC_GET_PHY_ID2(lp, phyaddr & 31, id2); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 711 | |
| 712 | /* Make sure it is a valid identifier */ |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 713 | if (id1 != 0x0000 && id1 != 0xffff && |
| 714 | id1 != 0x8000 && id2 != 0x0000 && |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 715 | id2 != 0xffff && id2 != 0x8000) { |
| 716 | /* Save the PHY's address */ |
| 717 | lp->mii.phy_id = phyaddr & 31; |
| 718 | lp->phy_type = id1 << 16 | id2; |
| 719 | break; |
| 720 | } |
| 721 | } |
Guennadi Liakhovetski | f3073ac | 2008-10-11 15:07:16 -0700 | [diff] [blame] | 722 | if (phyaddr < 32) |
| 723 | /* Found an external PHY */ |
| 724 | break; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 725 | } |
| 726 | default: |
| 727 | /* Internal media only */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 728 | SMC_GET_PHY_ID1(lp, 1, id1); |
| 729 | SMC_GET_PHY_ID2(lp, 1, id2); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 730 | /* Save the PHY's address */ |
| 731 | lp->mii.phy_id = 1; |
| 732 | lp->phy_type = id1 << 16 | id2; |
| 733 | } |
| 734 | |
| 735 | DBG(SMC_DEBUG_MISC, "%s: phy_id1=0x%x, phy_id2=0x%x phyaddr=0x%d\n", |
| 736 | dev->name, id1, id2, lp->mii.phy_id); |
| 737 | } |
| 738 | |
| 739 | /* |
| 740 | * Sets the PHY to a configuration as determined by the user. |
| 741 | * Called with spin_lock held. |
| 742 | */ |
| 743 | static int smc911x_phy_fixed(struct net_device *dev) |
| 744 | { |
| 745 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 746 | int phyaddr = lp->mii.phy_id; |
| 747 | int bmcr; |
| 748 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 749 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 750 | |
| 751 | /* Enter Link Disable state */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 752 | SMC_GET_PHY_BMCR(lp, phyaddr, bmcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 753 | bmcr |= BMCR_PDOWN; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 754 | SMC_SET_PHY_BMCR(lp, phyaddr, bmcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 755 | |
| 756 | /* |
| 757 | * Set our fixed capabilities |
| 758 | * Disable auto-negotiation |
| 759 | */ |
| 760 | bmcr &= ~BMCR_ANENABLE; |
| 761 | if (lp->ctl_rfduplx) |
| 762 | bmcr |= BMCR_FULLDPLX; |
| 763 | |
| 764 | if (lp->ctl_rspeed == 100) |
| 765 | bmcr |= BMCR_SPEED100; |
| 766 | |
| 767 | /* Write our capabilities to the phy control register */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 768 | SMC_SET_PHY_BMCR(lp, phyaddr, bmcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 769 | |
| 770 | /* Re-Configure the Receive/Phy Control register */ |
| 771 | bmcr &= ~BMCR_PDOWN; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 772 | SMC_SET_PHY_BMCR(lp, phyaddr, bmcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 773 | |
| 774 | return 1; |
| 775 | } |
| 776 | |
| 777 | /* |
| 778 | * smc911x_phy_reset - reset the phy |
| 779 | * @dev: net device |
| 780 | * @phy: phy address |
| 781 | * |
| 782 | * Issue a software reset for the specified PHY and |
| 783 | * wait up to 100ms for the reset to complete. We should |
| 784 | * not access the PHY for 50ms after issuing the reset. |
| 785 | * |
| 786 | * The time to wait appears to be dependent on the PHY. |
| 787 | * |
| 788 | */ |
| 789 | static int smc911x_phy_reset(struct net_device *dev, int phy) |
| 790 | { |
| 791 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 792 | int timeout; |
| 793 | unsigned long flags; |
| 794 | unsigned int reg; |
| 795 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 796 | DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 797 | |
| 798 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 799 | reg = SMC_GET_PMT_CTRL(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 800 | reg &= ~0xfffff030; |
| 801 | reg |= PMT_CTRL_PHY_RST_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 802 | SMC_SET_PMT_CTRL(lp, reg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 803 | spin_unlock_irqrestore(&lp->lock, flags); |
| 804 | for (timeout = 2; timeout; timeout--) { |
| 805 | msleep(50); |
| 806 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 807 | reg = SMC_GET_PMT_CTRL(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 808 | spin_unlock_irqrestore(&lp->lock, flags); |
| 809 | if (!(reg & PMT_CTRL_PHY_RST_)) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 810 | /* extra delay required because the phy may |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 811 | * not be completed with its reset |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 812 | * when PHY_BCR_RESET_ is cleared. 256us |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 813 | * should suffice, but use 500us to be safe |
| 814 | */ |
| 815 | udelay(500); |
| 816 | break; |
| 817 | } |
| 818 | } |
| 819 | |
| 820 | return reg & PMT_CTRL_PHY_RST_; |
| 821 | } |
| 822 | |
| 823 | /* |
| 824 | * smc911x_phy_powerdown - powerdown phy |
| 825 | * @dev: net device |
| 826 | * @phy: phy address |
| 827 | * |
| 828 | * Power down the specified PHY |
| 829 | */ |
| 830 | static void smc911x_phy_powerdown(struct net_device *dev, int phy) |
| 831 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 832 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 833 | unsigned int bmcr; |
| 834 | |
| 835 | /* Enter Link Disable state */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 836 | SMC_GET_PHY_BMCR(lp, phy, bmcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 837 | bmcr |= BMCR_PDOWN; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 838 | SMC_SET_PHY_BMCR(lp, phy, bmcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 839 | } |
| 840 | |
| 841 | /* |
| 842 | * smc911x_phy_check_media - check the media status and adjust BMCR |
| 843 | * @dev: net device |
| 844 | * @init: set true for initialisation |
| 845 | * |
| 846 | * Select duplex mode depending on negotiation state. This |
| 847 | * also updates our carrier state. |
| 848 | */ |
| 849 | static void smc911x_phy_check_media(struct net_device *dev, int init) |
| 850 | { |
| 851 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 852 | int phyaddr = lp->mii.phy_id; |
| 853 | unsigned int bmcr, cr; |
| 854 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 855 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 856 | |
| 857 | if (mii_check_media(&lp->mii, netif_msg_link(lp), init)) { |
| 858 | /* duplex state has changed */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 859 | SMC_GET_PHY_BMCR(lp, phyaddr, bmcr); |
| 860 | SMC_GET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 861 | if (lp->mii.full_duplex) { |
| 862 | DBG(SMC_DEBUG_MISC, "%s: Configuring for full-duplex mode\n", dev->name); |
| 863 | bmcr |= BMCR_FULLDPLX; |
| 864 | cr |= MAC_CR_RCVOWN_; |
| 865 | } else { |
| 866 | DBG(SMC_DEBUG_MISC, "%s: Configuring for half-duplex mode\n", dev->name); |
| 867 | bmcr &= ~BMCR_FULLDPLX; |
| 868 | cr &= ~MAC_CR_RCVOWN_; |
| 869 | } |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 870 | SMC_SET_PHY_BMCR(lp, phyaddr, bmcr); |
| 871 | SMC_SET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 872 | } |
| 873 | } |
| 874 | |
| 875 | /* |
| 876 | * Configures the specified PHY through the MII management interface |
| 877 | * using Autonegotiation. |
| 878 | * Calls smc911x_phy_fixed() if the user has requested a certain config. |
| 879 | * If RPC ANEG bit is set, the media selection is dependent purely on |
| 880 | * the selection by the MII (either in the MII BMCR reg or the result |
| 881 | * of autonegotiation.) If the RPC ANEG bit is cleared, the selection |
| 882 | * is controlled by the RPC SPEED and RPC DPLX bits. |
| 883 | */ |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 884 | static void smc911x_phy_configure(struct work_struct *work) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 885 | { |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 886 | struct smc911x_local *lp = container_of(work, struct smc911x_local, |
| 887 | phy_configure); |
| 888 | struct net_device *dev = lp->netdev; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 889 | int phyaddr = lp->mii.phy_id; |
| 890 | int my_phy_caps; /* My PHY capabilities */ |
| 891 | int my_ad_caps; /* My Advertised capabilities */ |
| 892 | int status; |
| 893 | unsigned long flags; |
| 894 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 895 | DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 896 | |
| 897 | /* |
| 898 | * We should not be called if phy_type is zero. |
| 899 | */ |
| 900 | if (lp->phy_type == 0) |
David S. Miller | 4bb073c | 2008-06-12 02:22:02 -0700 | [diff] [blame] | 901 | return; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 902 | |
| 903 | if (smc911x_phy_reset(dev, phyaddr)) { |
| 904 | printk("%s: PHY reset timed out\n", dev->name); |
David S. Miller | 4bb073c | 2008-06-12 02:22:02 -0700 | [diff] [blame] | 905 | return; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 906 | } |
| 907 | spin_lock_irqsave(&lp->lock, flags); |
| 908 | |
| 909 | /* |
| 910 | * Enable PHY Interrupts (for register 18) |
| 911 | * Interrupts listed here are enabled |
| 912 | */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 913 | SMC_SET_PHY_INT_MASK(lp, phyaddr, PHY_INT_MASK_ENERGY_ON_ | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 914 | PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_REMOTE_FAULT_ | |
| 915 | PHY_INT_MASK_LINK_DOWN_); |
| 916 | |
| 917 | /* If the user requested no auto neg, then go set his request */ |
| 918 | if (lp->mii.force_media) { |
| 919 | smc911x_phy_fixed(dev); |
| 920 | goto smc911x_phy_configure_exit; |
| 921 | } |
| 922 | |
| 923 | /* Copy our capabilities from MII_BMSR to MII_ADVERTISE */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 924 | SMC_GET_PHY_BMSR(lp, phyaddr, my_phy_caps); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 925 | if (!(my_phy_caps & BMSR_ANEGCAPABLE)) { |
| 926 | printk(KERN_INFO "Auto negotiation NOT supported\n"); |
| 927 | smc911x_phy_fixed(dev); |
| 928 | goto smc911x_phy_configure_exit; |
| 929 | } |
| 930 | |
| 931 | /* CSMA capable w/ both pauses */ |
| 932 | my_ad_caps = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM; |
| 933 | |
| 934 | if (my_phy_caps & BMSR_100BASE4) |
| 935 | my_ad_caps |= ADVERTISE_100BASE4; |
| 936 | if (my_phy_caps & BMSR_100FULL) |
| 937 | my_ad_caps |= ADVERTISE_100FULL; |
| 938 | if (my_phy_caps & BMSR_100HALF) |
| 939 | my_ad_caps |= ADVERTISE_100HALF; |
| 940 | if (my_phy_caps & BMSR_10FULL) |
| 941 | my_ad_caps |= ADVERTISE_10FULL; |
| 942 | if (my_phy_caps & BMSR_10HALF) |
| 943 | my_ad_caps |= ADVERTISE_10HALF; |
| 944 | |
| 945 | /* Disable capabilities not selected by our user */ |
| 946 | if (lp->ctl_rspeed != 100) |
| 947 | my_ad_caps &= ~(ADVERTISE_100BASE4|ADVERTISE_100FULL|ADVERTISE_100HALF); |
| 948 | |
| 949 | if (!lp->ctl_rfduplx) |
| 950 | my_ad_caps &= ~(ADVERTISE_100FULL|ADVERTISE_10FULL); |
| 951 | |
| 952 | /* Update our Auto-Neg Advertisement Register */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 953 | SMC_SET_PHY_MII_ADV(lp, phyaddr, my_ad_caps); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 954 | lp->mii.advertising = my_ad_caps; |
| 955 | |
| 956 | /* |
| 957 | * Read the register back. Without this, it appears that when |
| 958 | * auto-negotiation is restarted, sometimes it isn't ready and |
| 959 | * the link does not come up. |
| 960 | */ |
| 961 | udelay(10); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 962 | SMC_GET_PHY_MII_ADV(lp, phyaddr, status); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 963 | |
| 964 | DBG(SMC_DEBUG_MISC, "%s: phy caps=0x%04x\n", dev->name, my_phy_caps); |
| 965 | DBG(SMC_DEBUG_MISC, "%s: phy advertised caps=0x%04x\n", dev->name, my_ad_caps); |
| 966 | |
| 967 | /* Restart auto-negotiation process in order to advertise my caps */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 968 | SMC_SET_PHY_BMCR(lp, phyaddr, BMCR_ANENABLE | BMCR_ANRESTART); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 969 | |
| 970 | smc911x_phy_check_media(dev, 1); |
| 971 | |
| 972 | smc911x_phy_configure_exit: |
| 973 | spin_unlock_irqrestore(&lp->lock, flags); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 974 | } |
| 975 | |
| 976 | /* |
| 977 | * smc911x_phy_interrupt |
| 978 | * |
| 979 | * Purpose: Handle interrupts relating to PHY register 18. This is |
| 980 | * called from the "hard" interrupt handler under our private spinlock. |
| 981 | */ |
| 982 | static void smc911x_phy_interrupt(struct net_device *dev) |
| 983 | { |
| 984 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 985 | int phyaddr = lp->mii.phy_id; |
| 986 | int status; |
| 987 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 988 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 989 | |
| 990 | if (lp->phy_type == 0) |
| 991 | return; |
| 992 | |
| 993 | smc911x_phy_check_media(dev, 0); |
| 994 | /* read to clear status bits */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 995 | SMC_GET_PHY_INT_SRC(lp, phyaddr,status); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 996 | DBG(SMC_DEBUG_MISC, "%s: PHY interrupt status 0x%04x\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 997 | dev->name, status & 0xffff); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 998 | DBG(SMC_DEBUG_MISC, "%s: AFC_CFG 0x%08x\n", |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 999 | dev->name, SMC_GET_AFC_CFG(lp)); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1000 | } |
| 1001 | |
| 1002 | /*--- END PHY CONTROL AND CONFIGURATION-------------------------------------*/ |
| 1003 | |
| 1004 | /* |
| 1005 | * This is the main routine of the driver, to handle the device when |
| 1006 | * it needs some attention. |
| 1007 | */ |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 1008 | static irqreturn_t smc911x_interrupt(int irq, void *dev_id) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1009 | { |
| 1010 | struct net_device *dev = dev_id; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1011 | struct smc911x_local *lp = netdev_priv(dev); |
| 1012 | unsigned int status, mask, timeout; |
| 1013 | unsigned int rx_overrun=0, cr, pkts; |
| 1014 | unsigned long flags; |
| 1015 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1016 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1017 | |
| 1018 | spin_lock_irqsave(&lp->lock, flags); |
| 1019 | |
| 1020 | /* Spurious interrupt check */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1021 | if ((SMC_GET_IRQ_CFG(lp) & (INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) != |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1022 | (INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) { |
Peter Korsgaard | a4d0927 | 2006-08-14 23:00:17 -0700 | [diff] [blame] | 1023 | spin_unlock_irqrestore(&lp->lock, flags); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1024 | return IRQ_NONE; |
| 1025 | } |
| 1026 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1027 | mask = SMC_GET_INT_EN(lp); |
| 1028 | SMC_SET_INT_EN(lp, 0); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1029 | |
| 1030 | /* set a timeout value, so I don't stay here forever */ |
| 1031 | timeout = 8; |
| 1032 | |
| 1033 | |
| 1034 | do { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1035 | status = SMC_GET_INT(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1036 | |
| 1037 | DBG(SMC_DEBUG_MISC, "%s: INT 0x%08x MASK 0x%08x OUTSIDE MASK 0x%08x\n", |
| 1038 | dev->name, status, mask, status & ~mask); |
| 1039 | |
| 1040 | status &= mask; |
| 1041 | if (!status) |
| 1042 | break; |
| 1043 | |
| 1044 | /* Handle SW interrupt condition */ |
| 1045 | if (status & INT_STS_SW_INT_) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1046 | SMC_ACK_INT(lp, INT_STS_SW_INT_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1047 | mask &= ~INT_EN_SW_INT_EN_; |
| 1048 | } |
| 1049 | /* Handle various error conditions */ |
| 1050 | if (status & INT_STS_RXE_) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1051 | SMC_ACK_INT(lp, INT_STS_RXE_); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 1052 | dev->stats.rx_errors++; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1053 | } |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1054 | if (status & INT_STS_RXDFH_INT_) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1055 | SMC_ACK_INT(lp, INT_STS_RXDFH_INT_); |
| 1056 | dev->stats.rx_dropped+=SMC_GET_RX_DROP(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1057 | } |
| 1058 | /* Undocumented interrupt-what is the right thing to do here? */ |
| 1059 | if (status & INT_STS_RXDF_INT_) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1060 | SMC_ACK_INT(lp, INT_STS_RXDF_INT_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1061 | } |
| 1062 | |
| 1063 | /* Rx Data FIFO exceeds set level */ |
| 1064 | if (status & INT_STS_RDFL_) { |
| 1065 | if (IS_REV_A(lp->revision)) { |
| 1066 | rx_overrun=1; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1067 | SMC_GET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1068 | cr &= ~MAC_CR_RXEN_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1069 | SMC_SET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1070 | DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 1071 | dev->stats.rx_errors++; |
| 1072 | dev->stats.rx_fifo_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1073 | } |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1074 | SMC_ACK_INT(lp, INT_STS_RDFL_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1075 | } |
| 1076 | if (status & INT_STS_RDFO_) { |
| 1077 | if (!IS_REV_A(lp->revision)) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1078 | SMC_GET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1079 | cr &= ~MAC_CR_RXEN_; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1080 | SMC_SET_MAC_CR(lp, cr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1081 | rx_overrun=1; |
| 1082 | DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 1083 | dev->stats.rx_errors++; |
| 1084 | dev->stats.rx_fifo_errors++; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1085 | } |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1086 | SMC_ACK_INT(lp, INT_STS_RDFO_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1087 | } |
| 1088 | /* Handle receive condition */ |
| 1089 | if ((status & INT_STS_RSFL_) || rx_overrun) { |
| 1090 | unsigned int fifo; |
| 1091 | DBG(SMC_DEBUG_RX, "%s: RX irq\n", dev->name); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1092 | fifo = SMC_GET_RX_FIFO_INF(lp); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1093 | pkts = (fifo & RX_FIFO_INF_RXSUSED_) >> 16; |
| 1094 | DBG(SMC_DEBUG_RX, "%s: Rx FIFO pkts %d, bytes %d\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1095 | dev->name, pkts, fifo & 0xFFFF ); |
| 1096 | if (pkts != 0) { |
| 1097 | #ifdef SMC_USE_DMA |
| 1098 | unsigned int fifo; |
| 1099 | if (lp->rxdma_active){ |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1100 | DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1101 | "%s: RX DMA active\n", dev->name); |
| 1102 | /* The DMA is already running so up the IRQ threshold */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1103 | fifo = SMC_GET_FIFO_INT(lp) & ~0xFF; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1104 | fifo |= pkts & 0xFF; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1105 | DBG(SMC_DEBUG_RX, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1106 | "%s: Setting RX stat FIFO threshold to %d\n", |
| 1107 | dev->name, fifo & 0xff); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1108 | SMC_SET_FIFO_INT(lp, fifo); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1109 | } else |
| 1110 | #endif |
| 1111 | smc911x_rcv(dev); |
| 1112 | } |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1113 | SMC_ACK_INT(lp, INT_STS_RSFL_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1114 | } |
| 1115 | /* Handle transmit FIFO available */ |
| 1116 | if (status & INT_STS_TDFA_) { |
| 1117 | DBG(SMC_DEBUG_TX, "%s: TX data FIFO space available irq\n", dev->name); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1118 | SMC_SET_FIFO_TDA(lp, 0xFF); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1119 | lp->tx_throttle = 0; |
| 1120 | #ifdef SMC_USE_DMA |
| 1121 | if (!lp->txdma_active) |
| 1122 | #endif |
| 1123 | netif_wake_queue(dev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1124 | SMC_ACK_INT(lp, INT_STS_TDFA_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1125 | } |
| 1126 | /* Handle transmit done condition */ |
| 1127 | #if 1 |
| 1128 | if (status & (INT_STS_TSFL_ | INT_STS_GPT_INT_)) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1129 | DBG(SMC_DEBUG_TX | SMC_DEBUG_MISC, |
| 1130 | "%s: Tx stat FIFO limit (%d) /GPT irq\n", |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1131 | dev->name, (SMC_GET_FIFO_INT(lp) & 0x00ff0000) >> 16); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1132 | smc911x_tx(dev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1133 | SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000); |
| 1134 | SMC_ACK_INT(lp, INT_STS_TSFL_); |
| 1135 | SMC_ACK_INT(lp, INT_STS_TSFL_ | INT_STS_GPT_INT_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1136 | } |
| 1137 | #else |
| 1138 | if (status & INT_STS_TSFL_) { |
| 1139 | DBG(SMC_DEBUG_TX, "%s: TX status FIFO limit (%d) irq \n", dev->name, ); |
| 1140 | smc911x_tx(dev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1141 | SMC_ACK_INT(lp, INT_STS_TSFL_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1142 | } |
| 1143 | |
| 1144 | if (status & INT_STS_GPT_INT_) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1145 | DBG(SMC_DEBUG_RX, "%s: IRQ_CFG 0x%08x FIFO_INT 0x%08x RX_CFG 0x%08x\n", |
| 1146 | dev->name, |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1147 | SMC_GET_IRQ_CFG(lp), |
| 1148 | SMC_GET_FIFO_INT(lp), |
| 1149 | SMC_GET_RX_CFG(lp)); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1150 | DBG(SMC_DEBUG_RX, "%s: Rx Stat FIFO Used 0x%02x " |
| 1151 | "Data FIFO Used 0x%04x Stat FIFO 0x%08x\n", |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1152 | dev->name, |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1153 | (SMC_GET_RX_FIFO_INF(lp) & 0x00ff0000) >> 16, |
| 1154 | SMC_GET_RX_FIFO_INF(lp) & 0xffff, |
| 1155 | SMC_GET_RX_STS_FIFO_PEEK(lp)); |
| 1156 | SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000); |
| 1157 | SMC_ACK_INT(lp, INT_STS_GPT_INT_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1158 | } |
| 1159 | #endif |
| 1160 | |
Robert P. J. Day | 3a4fa0a | 2007-10-19 23:10:43 +0200 | [diff] [blame] | 1161 | /* Handle PHY interrupt condition */ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1162 | if (status & INT_STS_PHY_INT_) { |
| 1163 | DBG(SMC_DEBUG_MISC, "%s: PHY irq\n", dev->name); |
| 1164 | smc911x_phy_interrupt(dev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1165 | SMC_ACK_INT(lp, INT_STS_PHY_INT_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1166 | } |
| 1167 | } while (--timeout); |
| 1168 | |
| 1169 | /* restore mask state */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1170 | SMC_SET_INT_EN(lp, mask); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1171 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1172 | DBG(SMC_DEBUG_MISC, "%s: Interrupt done (%d loops)\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1173 | dev->name, 8-timeout); |
| 1174 | |
| 1175 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1176 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1177 | return IRQ_HANDLED; |
| 1178 | } |
| 1179 | |
| 1180 | #ifdef SMC_USE_DMA |
| 1181 | static void |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 1182 | smc911x_tx_dma_irq(int dma, void *data) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1183 | { |
| 1184 | struct net_device *dev = (struct net_device *)data; |
| 1185 | struct smc911x_local *lp = netdev_priv(dev); |
| 1186 | struct sk_buff *skb = lp->current_tx_skb; |
| 1187 | unsigned long flags; |
| 1188 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1189 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1190 | |
| 1191 | DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: TX DMA irq handler\n", dev->name); |
| 1192 | /* Clear the DMA interrupt sources */ |
| 1193 | SMC_DMA_ACK_IRQ(dev, dma); |
| 1194 | BUG_ON(skb == NULL); |
| 1195 | dma_unmap_single(NULL, tx_dmabuf, tx_dmalen, DMA_TO_DEVICE); |
| 1196 | dev->trans_start = jiffies; |
| 1197 | dev_kfree_skb_irq(skb); |
| 1198 | lp->current_tx_skb = NULL; |
| 1199 | if (lp->pending_tx_skb != NULL) |
| 1200 | smc911x_hardware_send_pkt(dev); |
| 1201 | else { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1202 | DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1203 | "%s: No pending Tx packets. DMA disabled\n", dev->name); |
| 1204 | spin_lock_irqsave(&lp->lock, flags); |
| 1205 | lp->txdma_active = 0; |
| 1206 | if (!lp->tx_throttle) { |
| 1207 | netif_wake_queue(dev); |
| 1208 | } |
| 1209 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1210 | } |
| 1211 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1212 | DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1213 | "%s: TX DMA irq completed\n", dev->name); |
| 1214 | } |
| 1215 | static void |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 1216 | smc911x_rx_dma_irq(int dma, void *data) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1217 | { |
| 1218 | struct net_device *dev = (struct net_device *)data; |
| 1219 | unsigned long ioaddr = dev->base_addr; |
| 1220 | struct smc911x_local *lp = netdev_priv(dev); |
| 1221 | struct sk_buff *skb = lp->current_rx_skb; |
| 1222 | unsigned long flags; |
| 1223 | unsigned int pkts; |
| 1224 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1225 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1226 | DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA, "%s: RX DMA irq handler\n", dev->name); |
| 1227 | /* Clear the DMA interrupt sources */ |
| 1228 | SMC_DMA_ACK_IRQ(dev, dma); |
| 1229 | dma_unmap_single(NULL, rx_dmabuf, rx_dmalen, DMA_FROM_DEVICE); |
| 1230 | BUG_ON(skb == NULL); |
| 1231 | lp->current_rx_skb = NULL; |
| 1232 | PRINT_PKT(skb->data, skb->len); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1233 | skb->protocol = eth_type_trans(skb, dev); |
Jeff Garzik | 09f75cd | 2007-10-03 17:41:50 -0700 | [diff] [blame] | 1234 | dev->stats.rx_packets++; |
| 1235 | dev->stats.rx_bytes += skb->len; |
Wang Chen | d30f53a | 2007-12-04 10:01:37 +0800 | [diff] [blame] | 1236 | netif_rx(skb); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1237 | |
| 1238 | spin_lock_irqsave(&lp->lock, flags); |
Dmitry Baryshkov | d766a4e | 2008-10-21 04:36:29 +0400 | [diff] [blame] | 1239 | pkts = (SMC_GET_RX_FIFO_INF(lp) & RX_FIFO_INF_RXSUSED_) >> 16; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1240 | if (pkts != 0) { |
| 1241 | smc911x_rcv(dev); |
| 1242 | }else { |
| 1243 | lp->rxdma_active = 0; |
| 1244 | } |
| 1245 | spin_unlock_irqrestore(&lp->lock, flags); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1246 | DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA, |
| 1247 | "%s: RX DMA irq completed. DMA RX FIFO PKTS %d\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1248 | dev->name, pkts); |
| 1249 | } |
| 1250 | #endif /* SMC_USE_DMA */ |
| 1251 | |
| 1252 | #ifdef CONFIG_NET_POLL_CONTROLLER |
| 1253 | /* |
| 1254 | * Polling receive - used by netconsole and other diagnostic tools |
| 1255 | * to allow network i/o with interrupts disabled. |
| 1256 | */ |
| 1257 | static void smc911x_poll_controller(struct net_device *dev) |
| 1258 | { |
| 1259 | disable_irq(dev->irq); |
Vitaly Wool | 9b6d2ef | 2006-12-22 01:08:24 -0800 | [diff] [blame] | 1260 | smc911x_interrupt(dev->irq, dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1261 | enable_irq(dev->irq); |
| 1262 | } |
| 1263 | #endif |
| 1264 | |
| 1265 | /* Our watchdog timed out. Called by the networking layer */ |
| 1266 | static void smc911x_timeout(struct net_device *dev) |
| 1267 | { |
| 1268 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1269 | int status, mask; |
| 1270 | unsigned long flags; |
| 1271 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1272 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1273 | |
| 1274 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1275 | status = SMC_GET_INT(lp); |
| 1276 | mask = SMC_GET_INT_EN(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1277 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1278 | DBG(SMC_DEBUG_MISC, "%s: INT 0x%02x MASK 0x%02x \n", |
| 1279 | dev->name, status, mask); |
| 1280 | |
| 1281 | /* Dump the current TX FIFO contents and restart */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1282 | mask = SMC_GET_TX_CFG(lp); |
| 1283 | SMC_SET_TX_CFG(lp, mask | TX_CFG_TXS_DUMP_ | TX_CFG_TXD_DUMP_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1284 | /* |
| 1285 | * Reconfiguring the PHY doesn't seem like a bad idea here, but |
| 1286 | * smc911x_phy_configure() calls msleep() which calls schedule_timeout() |
| 1287 | * which calls schedule(). Hence we use a work queue. |
| 1288 | */ |
David S. Miller | 4bb073c | 2008-06-12 02:22:02 -0700 | [diff] [blame] | 1289 | if (lp->phy_type != 0) |
| 1290 | schedule_work(&lp->phy_configure); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1291 | |
| 1292 | /* We can accept TX packets again */ |
| 1293 | dev->trans_start = jiffies; |
| 1294 | netif_wake_queue(dev); |
| 1295 | } |
| 1296 | |
| 1297 | /* |
| 1298 | * This routine will, depending on the values passed to it, |
| 1299 | * either make it accept multicast packets, go into |
| 1300 | * promiscuous mode (for TCPDUMP and cousins) or accept |
| 1301 | * a select set of multicast packets |
| 1302 | */ |
| 1303 | static void smc911x_set_multicast_list(struct net_device *dev) |
| 1304 | { |
| 1305 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1306 | unsigned int multicast_table[2]; |
| 1307 | unsigned int mcr, update_multicast = 0; |
| 1308 | unsigned long flags; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1309 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1310 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1311 | |
| 1312 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1313 | SMC_GET_MAC_CR(lp, mcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1314 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1315 | |
| 1316 | if (dev->flags & IFF_PROMISC) { |
| 1317 | |
| 1318 | DBG(SMC_DEBUG_MISC, "%s: RCR_PRMS\n", dev->name); |
| 1319 | mcr |= MAC_CR_PRMS_; |
| 1320 | } |
| 1321 | /* |
| 1322 | * Here, I am setting this to accept all multicast packets. |
| 1323 | * I don't need to zero the multicast table, because the flag is |
| 1324 | * checked before the table is |
| 1325 | */ |
| 1326 | else if (dev->flags & IFF_ALLMULTI || dev->mc_count > 16) { |
| 1327 | DBG(SMC_DEBUG_MISC, "%s: RCR_ALMUL\n", dev->name); |
| 1328 | mcr |= MAC_CR_MCPAS_; |
| 1329 | } |
| 1330 | |
| 1331 | /* |
| 1332 | * This sets the internal hardware table to filter out unwanted |
| 1333 | * multicast packets before they take up memory. |
| 1334 | * |
| 1335 | * The SMC chip uses a hash table where the high 6 bits of the CRC of |
| 1336 | * address are the offset into the table. If that bit is 1, then the |
| 1337 | * multicast packet is accepted. Otherwise, it's dropped silently. |
| 1338 | * |
| 1339 | * To use the 6 bits as an offset into the table, the high 1 bit is |
| 1340 | * the number of the 32 bit register, while the low 5 bits are the bit |
| 1341 | * within that register. |
| 1342 | */ |
| 1343 | else if (dev->mc_count) { |
| 1344 | int i; |
| 1345 | struct dev_mc_list *cur_addr; |
| 1346 | |
| 1347 | /* Set the Hash perfec mode */ |
| 1348 | mcr |= MAC_CR_HPFILT_; |
| 1349 | |
| 1350 | /* start with a table of all zeros: reject all */ |
| 1351 | memset(multicast_table, 0, sizeof(multicast_table)); |
| 1352 | |
| 1353 | cur_addr = dev->mc_list; |
| 1354 | for (i = 0; i < dev->mc_count; i++, cur_addr = cur_addr->next) { |
Peter Korsgaard | 7b31f7f | 2007-11-22 12:25:13 +0100 | [diff] [blame] | 1355 | u32 position; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1356 | |
| 1357 | /* do we have a pointer here? */ |
| 1358 | if (!cur_addr) |
| 1359 | break; |
| 1360 | /* make sure this is a multicast address - |
| 1361 | shouldn't this be a given if we have it here ? */ |
| 1362 | if (!(*cur_addr->dmi_addr & 1)) |
| 1363 | continue; |
| 1364 | |
Peter Korsgaard | 7b31f7f | 2007-11-22 12:25:13 +0100 | [diff] [blame] | 1365 | /* upper 6 bits are used as hash index */ |
| 1366 | position = ether_crc(ETH_ALEN, cur_addr->dmi_addr)>>26; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1367 | |
Peter Korsgaard | 7b31f7f | 2007-11-22 12:25:13 +0100 | [diff] [blame] | 1368 | multicast_table[position>>5] |= 1 << (position&0x1f); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1369 | } |
| 1370 | |
| 1371 | /* be sure I get rid of flags I might have set */ |
| 1372 | mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_); |
| 1373 | |
| 1374 | /* now, the table can be loaded into the chipset */ |
| 1375 | update_multicast = 1; |
| 1376 | } else { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1377 | DBG(SMC_DEBUG_MISC, "%s: ~(MAC_CR_PRMS_|MAC_CR_MCPAS_)\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1378 | dev->name); |
| 1379 | mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_); |
| 1380 | |
| 1381 | /* |
| 1382 | * since I'm disabling all multicast entirely, I need to |
| 1383 | * clear the multicast list |
| 1384 | */ |
| 1385 | memset(multicast_table, 0, sizeof(multicast_table)); |
| 1386 | update_multicast = 1; |
| 1387 | } |
| 1388 | |
| 1389 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1390 | SMC_SET_MAC_CR(lp, mcr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1391 | if (update_multicast) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1392 | DBG(SMC_DEBUG_MISC, |
| 1393 | "%s: update mcast hash table 0x%08x 0x%08x\n", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1394 | dev->name, multicast_table[0], multicast_table[1]); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1395 | SMC_SET_HASHL(lp, multicast_table[0]); |
| 1396 | SMC_SET_HASHH(lp, multicast_table[1]); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1397 | } |
| 1398 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1399 | } |
| 1400 | |
| 1401 | |
| 1402 | /* |
| 1403 | * Open and Initialize the board |
| 1404 | * |
| 1405 | * Set up everything, reset the card, etc.. |
| 1406 | */ |
| 1407 | static int |
| 1408 | smc911x_open(struct net_device *dev) |
| 1409 | { |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 1410 | struct smc911x_local *lp = netdev_priv(dev); |
| 1411 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1412 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1413 | |
| 1414 | /* |
| 1415 | * Check that the address is valid. If its not, refuse |
| 1416 | * to bring the device up. The user must specify an |
| 1417 | * address using ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx |
| 1418 | */ |
| 1419 | if (!is_valid_ether_addr(dev->dev_addr)) { |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1420 | PRINTK("%s: no valid ethernet hw addr\n", __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1421 | return -EINVAL; |
| 1422 | } |
| 1423 | |
| 1424 | /* reset the hardware */ |
| 1425 | smc911x_reset(dev); |
| 1426 | |
| 1427 | /* Configure the PHY, initialize the link state */ |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 1428 | smc911x_phy_configure(&lp->phy_configure); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1429 | |
| 1430 | /* Turn on Tx + Rx */ |
| 1431 | smc911x_enable(dev); |
| 1432 | |
| 1433 | netif_start_queue(dev); |
| 1434 | |
| 1435 | return 0; |
| 1436 | } |
| 1437 | |
| 1438 | /* |
| 1439 | * smc911x_close |
| 1440 | * |
| 1441 | * this makes the board clean up everything that it can |
| 1442 | * and not talk to the outside world. Caused by |
| 1443 | * an 'ifconfig ethX down' |
| 1444 | */ |
| 1445 | static int smc911x_close(struct net_device *dev) |
| 1446 | { |
| 1447 | struct smc911x_local *lp = netdev_priv(dev); |
| 1448 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1449 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1450 | |
| 1451 | netif_stop_queue(dev); |
| 1452 | netif_carrier_off(dev); |
| 1453 | |
| 1454 | /* clear everything */ |
| 1455 | smc911x_shutdown(dev); |
| 1456 | |
| 1457 | if (lp->phy_type != 0) { |
| 1458 | /* We need to ensure that no calls to |
| 1459 | * smc911x_phy_configure are pending. |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1460 | */ |
David S. Miller | 4bb073c | 2008-06-12 02:22:02 -0700 | [diff] [blame] | 1461 | cancel_work_sync(&lp->phy_configure); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1462 | smc911x_phy_powerdown(dev, lp->mii.phy_id); |
| 1463 | } |
| 1464 | |
| 1465 | if (lp->pending_tx_skb) { |
| 1466 | dev_kfree_skb(lp->pending_tx_skb); |
| 1467 | lp->pending_tx_skb = NULL; |
| 1468 | } |
| 1469 | |
| 1470 | return 0; |
| 1471 | } |
| 1472 | |
| 1473 | /* |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1474 | * Ethtool support |
| 1475 | */ |
| 1476 | static int |
| 1477 | smc911x_ethtool_getsettings(struct net_device *dev, struct ethtool_cmd *cmd) |
| 1478 | { |
| 1479 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1480 | int ret, status; |
| 1481 | unsigned long flags; |
| 1482 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1483 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1484 | cmd->maxtxpkt = 1; |
| 1485 | cmd->maxrxpkt = 1; |
| 1486 | |
| 1487 | if (lp->phy_type != 0) { |
| 1488 | spin_lock_irqsave(&lp->lock, flags); |
| 1489 | ret = mii_ethtool_gset(&lp->mii, cmd); |
| 1490 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1491 | } else { |
| 1492 | cmd->supported = SUPPORTED_10baseT_Half | |
| 1493 | SUPPORTED_10baseT_Full | |
| 1494 | SUPPORTED_TP | SUPPORTED_AUI; |
| 1495 | |
| 1496 | if (lp->ctl_rspeed == 10) |
| 1497 | cmd->speed = SPEED_10; |
| 1498 | else if (lp->ctl_rspeed == 100) |
| 1499 | cmd->speed = SPEED_100; |
| 1500 | |
| 1501 | cmd->autoneg = AUTONEG_DISABLE; |
| 1502 | if (lp->mii.phy_id==1) |
| 1503 | cmd->transceiver = XCVR_INTERNAL; |
| 1504 | else |
| 1505 | cmd->transceiver = XCVR_EXTERNAL; |
| 1506 | cmd->port = 0; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1507 | SMC_GET_PHY_SPECIAL(lp, lp->mii.phy_id, status); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1508 | cmd->duplex = |
| 1509 | (status & (PHY_SPECIAL_SPD_10FULL_ | PHY_SPECIAL_SPD_100FULL_)) ? |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1510 | DUPLEX_FULL : DUPLEX_HALF; |
| 1511 | ret = 0; |
| 1512 | } |
| 1513 | |
| 1514 | return ret; |
| 1515 | } |
| 1516 | |
| 1517 | static int |
| 1518 | smc911x_ethtool_setsettings(struct net_device *dev, struct ethtool_cmd *cmd) |
| 1519 | { |
| 1520 | struct smc911x_local *lp = netdev_priv(dev); |
| 1521 | int ret; |
| 1522 | unsigned long flags; |
| 1523 | |
| 1524 | if (lp->phy_type != 0) { |
| 1525 | spin_lock_irqsave(&lp->lock, flags); |
| 1526 | ret = mii_ethtool_sset(&lp->mii, cmd); |
| 1527 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1528 | } else { |
| 1529 | if (cmd->autoneg != AUTONEG_DISABLE || |
| 1530 | cmd->speed != SPEED_10 || |
| 1531 | (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL) || |
| 1532 | (cmd->port != PORT_TP && cmd->port != PORT_AUI)) |
| 1533 | return -EINVAL; |
| 1534 | |
| 1535 | lp->ctl_rfduplx = cmd->duplex == DUPLEX_FULL; |
| 1536 | |
| 1537 | ret = 0; |
| 1538 | } |
| 1539 | |
| 1540 | return ret; |
| 1541 | } |
| 1542 | |
| 1543 | static void |
| 1544 | smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info) |
| 1545 | { |
| 1546 | strncpy(info->driver, CARDNAME, sizeof(info->driver)); |
| 1547 | strncpy(info->version, version, sizeof(info->version)); |
Kay Sievers | db1d7bf | 2009-01-26 21:12:58 -0800 | [diff] [blame] | 1548 | strncpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info)); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1549 | } |
| 1550 | |
| 1551 | static int smc911x_ethtool_nwayreset(struct net_device *dev) |
| 1552 | { |
| 1553 | struct smc911x_local *lp = netdev_priv(dev); |
| 1554 | int ret = -EINVAL; |
| 1555 | unsigned long flags; |
| 1556 | |
| 1557 | if (lp->phy_type != 0) { |
| 1558 | spin_lock_irqsave(&lp->lock, flags); |
| 1559 | ret = mii_nway_restart(&lp->mii); |
| 1560 | spin_unlock_irqrestore(&lp->lock, flags); |
| 1561 | } |
| 1562 | |
| 1563 | return ret; |
| 1564 | } |
| 1565 | |
| 1566 | static u32 smc911x_ethtool_getmsglevel(struct net_device *dev) |
| 1567 | { |
| 1568 | struct smc911x_local *lp = netdev_priv(dev); |
| 1569 | return lp->msg_enable; |
| 1570 | } |
| 1571 | |
| 1572 | static void smc911x_ethtool_setmsglevel(struct net_device *dev, u32 level) |
| 1573 | { |
| 1574 | struct smc911x_local *lp = netdev_priv(dev); |
| 1575 | lp->msg_enable = level; |
| 1576 | } |
| 1577 | |
| 1578 | static int smc911x_ethtool_getregslen(struct net_device *dev) |
| 1579 | { |
| 1580 | /* System regs + MAC regs + PHY regs */ |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1581 | return (((E2P_CMD - ID_REV)/4 + 1) + |
| 1582 | (WUCSR - MAC_CR)+1 + 32) * sizeof(u32); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1583 | } |
| 1584 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1585 | static void smc911x_ethtool_getregs(struct net_device *dev, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1586 | struct ethtool_regs* regs, void *buf) |
| 1587 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1588 | struct smc911x_local *lp = netdev_priv(dev); |
| 1589 | unsigned long flags; |
| 1590 | u32 reg,i,j=0; |
| 1591 | u32 *data = (u32*)buf; |
| 1592 | |
| 1593 | regs->version = lp->version; |
| 1594 | for(i=ID_REV;i<=E2P_CMD;i+=4) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1595 | data[j++] = SMC_inl(lp, i); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1596 | } |
| 1597 | for(i=MAC_CR;i<=WUCSR;i++) { |
| 1598 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1599 | SMC_GET_MAC_CSR(lp, i, reg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1600 | spin_unlock_irqrestore(&lp->lock, flags); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1601 | data[j++] = reg; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1602 | } |
| 1603 | for(i=0;i<=31;i++) { |
| 1604 | spin_lock_irqsave(&lp->lock, flags); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1605 | SMC_GET_MII(lp, i, lp->mii.phy_id, reg); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1606 | spin_unlock_irqrestore(&lp->lock, flags); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1607 | data[j++] = reg & 0xFFFF; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1608 | } |
| 1609 | } |
| 1610 | |
| 1611 | static int smc911x_ethtool_wait_eeprom_ready(struct net_device *dev) |
| 1612 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1613 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1614 | unsigned int timeout; |
| 1615 | int e2p_cmd; |
| 1616 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1617 | e2p_cmd = SMC_GET_E2P_CMD(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1618 | for(timeout=10;(e2p_cmd & E2P_CMD_EPC_BUSY_) && timeout; timeout--) { |
| 1619 | if (e2p_cmd & E2P_CMD_EPC_TIMEOUT_) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1620 | PRINTK("%s: %s timeout waiting for EEPROM to respond\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1621 | dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1622 | return -EFAULT; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1623 | } |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1624 | mdelay(1); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1625 | e2p_cmd = SMC_GET_E2P_CMD(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1626 | } |
| 1627 | if (timeout == 0) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1628 | PRINTK("%s: %s timeout waiting for EEPROM CMD not busy\n", |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1629 | dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1630 | return -ETIMEDOUT; |
| 1631 | } |
| 1632 | return 0; |
| 1633 | } |
| 1634 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1635 | static inline int smc911x_ethtool_write_eeprom_cmd(struct net_device *dev, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1636 | int cmd, int addr) |
| 1637 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1638 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1639 | int ret; |
| 1640 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1641 | if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1642 | return ret; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1643 | SMC_SET_E2P_CMD(lp, E2P_CMD_EPC_BUSY_ | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1644 | ((cmd) & (0x7<<28)) | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1645 | ((addr) & 0xFF)); |
| 1646 | return 0; |
| 1647 | } |
| 1648 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1649 | static inline int smc911x_ethtool_read_eeprom_byte(struct net_device *dev, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1650 | u8 *data) |
| 1651 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1652 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1653 | int ret; |
| 1654 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1655 | if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1656 | return ret; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1657 | *data = SMC_GET_E2P_DATA(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1658 | return 0; |
| 1659 | } |
| 1660 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1661 | static inline int smc911x_ethtool_write_eeprom_byte(struct net_device *dev, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1662 | u8 data) |
| 1663 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1664 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1665 | int ret; |
| 1666 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1667 | if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1668 | return ret; |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1669 | SMC_SET_E2P_DATA(lp, data); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1670 | return 0; |
| 1671 | } |
| 1672 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1673 | static int smc911x_ethtool_geteeprom(struct net_device *dev, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1674 | struct ethtool_eeprom *eeprom, u8 *data) |
| 1675 | { |
| 1676 | u8 eebuf[SMC911X_EEPROM_LEN]; |
| 1677 | int i, ret; |
| 1678 | |
| 1679 | for(i=0;i<SMC911X_EEPROM_LEN;i++) { |
| 1680 | if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_READ_, i ))!=0) |
| 1681 | return ret; |
| 1682 | if ((ret=smc911x_ethtool_read_eeprom_byte(dev, &eebuf[i]))!=0) |
| 1683 | return ret; |
| 1684 | } |
| 1685 | memcpy(data, eebuf+eeprom->offset, eeprom->len); |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1686 | return 0; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1687 | } |
| 1688 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1689 | static int smc911x_ethtool_seteeprom(struct net_device *dev, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1690 | struct ethtool_eeprom *eeprom, u8 *data) |
| 1691 | { |
| 1692 | int i, ret; |
| 1693 | |
| 1694 | /* Enable erase */ |
| 1695 | if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_EWEN_, 0 ))!=0) |
| 1696 | return ret; |
| 1697 | for(i=eeprom->offset;i<(eeprom->offset+eeprom->len);i++) { |
| 1698 | /* erase byte */ |
| 1699 | if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_ERASE_, i ))!=0) |
| 1700 | return ret; |
| 1701 | /* write byte */ |
| 1702 | if ((ret=smc911x_ethtool_write_eeprom_byte(dev, *data))!=0) |
| 1703 | return ret; |
| 1704 | if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_WRITE_, i ))!=0) |
| 1705 | return ret; |
| 1706 | } |
| 1707 | return 0; |
| 1708 | } |
| 1709 | |
| 1710 | static int smc911x_ethtool_geteeprom_len(struct net_device *dev) |
| 1711 | { |
| 1712 | return SMC911X_EEPROM_LEN; |
| 1713 | } |
| 1714 | |
Jeff Garzik | 7282d49 | 2006-09-13 14:30:00 -0400 | [diff] [blame] | 1715 | static const struct ethtool_ops smc911x_ethtool_ops = { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1716 | .get_settings = smc911x_ethtool_getsettings, |
| 1717 | .set_settings = smc911x_ethtool_setsettings, |
| 1718 | .get_drvinfo = smc911x_ethtool_getdrvinfo, |
| 1719 | .get_msglevel = smc911x_ethtool_getmsglevel, |
| 1720 | .set_msglevel = smc911x_ethtool_setmsglevel, |
| 1721 | .nway_reset = smc911x_ethtool_nwayreset, |
| 1722 | .get_link = ethtool_op_get_link, |
| 1723 | .get_regs_len = smc911x_ethtool_getregslen, |
| 1724 | .get_regs = smc911x_ethtool_getregs, |
| 1725 | .get_eeprom_len = smc911x_ethtool_geteeprom_len, |
| 1726 | .get_eeprom = smc911x_ethtool_geteeprom, |
| 1727 | .set_eeprom = smc911x_ethtool_seteeprom, |
| 1728 | }; |
| 1729 | |
| 1730 | /* |
| 1731 | * smc911x_findirq |
| 1732 | * |
| 1733 | * This routine has a simple purpose -- make the SMC chip generate an |
| 1734 | * interrupt, so an auto-detect routine can detect it, and find the IRQ, |
| 1735 | */ |
Al Viro | f57628d | 2008-11-22 17:36:14 +0000 | [diff] [blame] | 1736 | static int __devinit smc911x_findirq(struct net_device *dev) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1737 | { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1738 | struct smc911x_local *lp = netdev_priv(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1739 | int timeout = 20; |
| 1740 | unsigned long cookie; |
| 1741 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1742 | DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1743 | |
| 1744 | cookie = probe_irq_on(); |
| 1745 | |
| 1746 | /* |
| 1747 | * Force a SW interrupt |
| 1748 | */ |
| 1749 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1750 | SMC_SET_INT_EN(lp, INT_EN_SW_INT_EN_); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1751 | |
| 1752 | /* |
| 1753 | * Wait until positive that the interrupt has been generated |
| 1754 | */ |
| 1755 | do { |
| 1756 | int int_status; |
| 1757 | udelay(10); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1758 | int_status = SMC_GET_INT_EN(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1759 | if (int_status & INT_EN_SW_INT_EN_) |
| 1760 | break; /* got the interrupt */ |
| 1761 | } while (--timeout); |
| 1762 | |
| 1763 | /* |
| 1764 | * there is really nothing that I can do here if timeout fails, |
| 1765 | * as autoirq_report will return a 0 anyway, which is what I |
| 1766 | * want in this case. Plus, the clean up is needed in both |
| 1767 | * cases. |
| 1768 | */ |
| 1769 | |
| 1770 | /* and disable all interrupts again */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1771 | SMC_SET_INT_EN(lp, 0); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1772 | |
| 1773 | /* and return what I found */ |
| 1774 | return probe_irq_off(cookie); |
| 1775 | } |
| 1776 | |
| 1777 | /* |
| 1778 | * Function: smc911x_probe(unsigned long ioaddr) |
| 1779 | * |
| 1780 | * Purpose: |
| 1781 | * Tests to see if a given ioaddr points to an SMC911x chip. |
| 1782 | * Returns a 0 on success |
| 1783 | * |
| 1784 | * Algorithm: |
| 1785 | * (1) see if the endian word is OK |
| 1786 | * (1) see if I recognize the chip ID in the appropriate register |
| 1787 | * |
| 1788 | * Here I do typical initialization tasks. |
| 1789 | * |
| 1790 | * o Initialize the structure if needed |
| 1791 | * o print out my vanity message if not done so already |
| 1792 | * o print out what type of hardware is detected |
| 1793 | * o print out the ethernet address |
| 1794 | * o find the IRQ |
| 1795 | * o set up my private data |
| 1796 | * o configure the dev structure with my subroutines |
| 1797 | * o actually GRAB the irq. |
| 1798 | * o GRAB the region |
| 1799 | */ |
Al Viro | f57628d | 2008-11-22 17:36:14 +0000 | [diff] [blame] | 1800 | static int __devinit smc911x_probe(struct net_device *dev) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1801 | { |
| 1802 | struct smc911x_local *lp = netdev_priv(dev); |
| 1803 | int i, retval; |
| 1804 | unsigned int val, chip_id, revision; |
| 1805 | const char *version_string; |
Magnus Damm | 12c03f5 | 2008-06-09 16:33:55 -0700 | [diff] [blame] | 1806 | unsigned long irq_flags; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1807 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 1808 | DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1809 | |
| 1810 | /* First, see if the endian word is recognized */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1811 | val = SMC_GET_BYTE_TEST(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1812 | DBG(SMC_DEBUG_MISC, "%s: endian probe returned 0x%04x\n", CARDNAME, val); |
| 1813 | if (val != 0x87654321) { |
Vernon Sauder | eafdcb4 | 2008-11-20 01:56:08 -0800 | [diff] [blame] | 1814 | printk(KERN_ERR "Invalid chip endian 0x%08x\n",val); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1815 | retval = -ENODEV; |
| 1816 | goto err_out; |
| 1817 | } |
| 1818 | |
| 1819 | /* |
| 1820 | * check if the revision register is something that I |
| 1821 | * recognize. These might need to be added to later, |
| 1822 | * as future revisions could be added. |
| 1823 | */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1824 | chip_id = SMC_GET_PN(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1825 | DBG(SMC_DEBUG_MISC, "%s: id probe returned 0x%04x\n", CARDNAME, chip_id); |
| 1826 | for(i=0;chip_ids[i].id != 0; i++) { |
| 1827 | if (chip_ids[i].id == chip_id) break; |
| 1828 | } |
| 1829 | if (!chip_ids[i].id) { |
| 1830 | printk(KERN_ERR "Unknown chip ID %04x\n", chip_id); |
| 1831 | retval = -ENODEV; |
| 1832 | goto err_out; |
| 1833 | } |
| 1834 | version_string = chip_ids[i].name; |
| 1835 | |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1836 | revision = SMC_GET_REV(lp); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1837 | DBG(SMC_DEBUG_MISC, "%s: revision = 0x%04x\n", CARDNAME, revision); |
| 1838 | |
| 1839 | /* At this point I'll assume that the chip is an SMC911x. */ |
| 1840 | DBG(SMC_DEBUG_MISC, "%s: Found a %s\n", CARDNAME, chip_ids[i].name); |
| 1841 | |
| 1842 | /* Validate the TX FIFO size requested */ |
| 1843 | if ((tx_fifo_kb < 2) || (tx_fifo_kb > 14)) { |
| 1844 | printk(KERN_ERR "Invalid TX FIFO size requested %d\n", tx_fifo_kb); |
| 1845 | retval = -EINVAL; |
| 1846 | goto err_out; |
| 1847 | } |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1848 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1849 | /* fill in some of the fields */ |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1850 | lp->version = chip_ids[i].id; |
| 1851 | lp->revision = revision; |
| 1852 | lp->tx_fifo_kb = tx_fifo_kb; |
| 1853 | /* Reverse calculate the RX FIFO size from the TX */ |
| 1854 | lp->tx_fifo_size=(lp->tx_fifo_kb<<10) - 512; |
| 1855 | lp->rx_fifo_size= ((0x4000 - 512 - lp->tx_fifo_size) / 16) * 15; |
| 1856 | |
| 1857 | /* Set the automatic flow control values */ |
| 1858 | switch(lp->tx_fifo_kb) { |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1859 | /* |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1860 | * AFC_HI is about ((Rx Data Fifo Size)*2/3)/64 |
| 1861 | * AFC_LO is AFC_HI/2 |
| 1862 | * BACK_DUR is about 5uS*(AFC_LO) rounded down |
| 1863 | */ |
| 1864 | case 2:/* 13440 Rx Data Fifo Size */ |
| 1865 | lp->afc_cfg=0x008C46AF;break; |
| 1866 | case 3:/* 12480 Rx Data Fifo Size */ |
| 1867 | lp->afc_cfg=0x0082419F;break; |
| 1868 | case 4:/* 11520 Rx Data Fifo Size */ |
| 1869 | lp->afc_cfg=0x00783C9F;break; |
| 1870 | case 5:/* 10560 Rx Data Fifo Size */ |
| 1871 | lp->afc_cfg=0x006E374F;break; |
| 1872 | case 6:/* 9600 Rx Data Fifo Size */ |
| 1873 | lp->afc_cfg=0x0064328F;break; |
| 1874 | case 7:/* 8640 Rx Data Fifo Size */ |
| 1875 | lp->afc_cfg=0x005A2D7F;break; |
| 1876 | case 8:/* 7680 Rx Data Fifo Size */ |
| 1877 | lp->afc_cfg=0x0050287F;break; |
| 1878 | case 9:/* 6720 Rx Data Fifo Size */ |
| 1879 | lp->afc_cfg=0x0046236F;break; |
| 1880 | case 10:/* 5760 Rx Data Fifo Size */ |
| 1881 | lp->afc_cfg=0x003C1E6F;break; |
| 1882 | case 11:/* 4800 Rx Data Fifo Size */ |
| 1883 | lp->afc_cfg=0x0032195F;break; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1884 | /* |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1885 | * AFC_HI is ~1520 bytes less than RX Data Fifo Size |
| 1886 | * AFC_LO is AFC_HI/2 |
| 1887 | * BACK_DUR is about 5uS*(AFC_LO) rounded down |
| 1888 | */ |
| 1889 | case 12:/* 3840 Rx Data Fifo Size */ |
| 1890 | lp->afc_cfg=0x0024124F;break; |
| 1891 | case 13:/* 2880 Rx Data Fifo Size */ |
| 1892 | lp->afc_cfg=0x0015073F;break; |
| 1893 | case 14:/* 1920 Rx Data Fifo Size */ |
| 1894 | lp->afc_cfg=0x0006032F;break; |
| 1895 | default: |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1896 | PRINTK("%s: ERROR -- no AFC_CFG setting found", |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1897 | dev->name); |
| 1898 | break; |
| 1899 | } |
| 1900 | |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 1901 | DBG(SMC_DEBUG_MISC | SMC_DEBUG_TX | SMC_DEBUG_RX, |
| 1902 | "%s: tx_fifo %d rx_fifo %d afc_cfg 0x%08x\n", CARDNAME, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1903 | lp->tx_fifo_size, lp->rx_fifo_size, lp->afc_cfg); |
| 1904 | |
| 1905 | spin_lock_init(&lp->lock); |
| 1906 | |
| 1907 | /* Get the MAC address */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1908 | SMC_GET_MAC_ADDR(lp, dev->dev_addr); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1909 | |
| 1910 | /* now, reset the chip, and put it into a known state */ |
| 1911 | smc911x_reset(dev); |
| 1912 | |
| 1913 | /* |
| 1914 | * If dev->irq is 0, then the device has to be banged on to see |
| 1915 | * what the IRQ is. |
| 1916 | * |
| 1917 | * Specifying an IRQ is done with the assumption that the user knows |
| 1918 | * what (s)he is doing. No checking is done!!!! |
| 1919 | */ |
| 1920 | if (dev->irq < 1) { |
| 1921 | int trials; |
| 1922 | |
| 1923 | trials = 3; |
| 1924 | while (trials--) { |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 1925 | dev->irq = smc911x_findirq(dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1926 | if (dev->irq) |
| 1927 | break; |
| 1928 | /* kick the card and try again */ |
| 1929 | smc911x_reset(dev); |
| 1930 | } |
| 1931 | } |
| 1932 | if (dev->irq == 0) { |
| 1933 | printk("%s: Couldn't autodetect your IRQ. Use irq=xx.\n", |
| 1934 | dev->name); |
| 1935 | retval = -ENODEV; |
| 1936 | goto err_out; |
| 1937 | } |
| 1938 | dev->irq = irq_canonicalize(dev->irq); |
| 1939 | |
| 1940 | /* Fill in the fields of the device structure with ethernet values. */ |
| 1941 | ether_setup(dev); |
| 1942 | |
| 1943 | dev->open = smc911x_open; |
| 1944 | dev->stop = smc911x_close; |
| 1945 | dev->hard_start_xmit = smc911x_hard_start_xmit; |
| 1946 | dev->tx_timeout = smc911x_timeout; |
| 1947 | dev->watchdog_timeo = msecs_to_jiffies(watchdog); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1948 | dev->set_multicast_list = smc911x_set_multicast_list; |
| 1949 | dev->ethtool_ops = &smc911x_ethtool_ops; |
| 1950 | #ifdef CONFIG_NET_POLL_CONTROLLER |
| 1951 | dev->poll_controller = smc911x_poll_controller; |
| 1952 | #endif |
| 1953 | |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 1954 | INIT_WORK(&lp->phy_configure, smc911x_phy_configure); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1955 | lp->mii.phy_id_mask = 0x1f; |
| 1956 | lp->mii.reg_num_mask = 0x1f; |
| 1957 | lp->mii.force_media = 0; |
| 1958 | lp->mii.full_duplex = 0; |
| 1959 | lp->mii.dev = dev; |
| 1960 | lp->mii.mdio_read = smc911x_phy_read; |
| 1961 | lp->mii.mdio_write = smc911x_phy_write; |
| 1962 | |
| 1963 | /* |
| 1964 | * Locate the phy, if any. |
| 1965 | */ |
| 1966 | smc911x_phy_detect(dev); |
| 1967 | |
| 1968 | /* Set default parameters */ |
| 1969 | lp->msg_enable = NETIF_MSG_LINK; |
| 1970 | lp->ctl_rfduplx = 1; |
| 1971 | lp->ctl_rspeed = 100; |
| 1972 | |
Magnus Damm | 12c03f5 | 2008-06-09 16:33:55 -0700 | [diff] [blame] | 1973 | #ifdef SMC_DYNAMIC_BUS_CONFIG |
| 1974 | irq_flags = lp->cfg.irq_flags; |
| 1975 | #else |
| 1976 | irq_flags = IRQF_SHARED | SMC_IRQ_SENSE; |
| 1977 | #endif |
| 1978 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1979 | /* Grab the IRQ */ |
Vitaly Wool | f2773a2 | 2007-05-13 18:42:08 +0400 | [diff] [blame] | 1980 | retval = request_irq(dev->irq, &smc911x_interrupt, |
Magnus Damm | 12c03f5 | 2008-06-09 16:33:55 -0700 | [diff] [blame] | 1981 | irq_flags, dev->name, dev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1982 | if (retval) |
| 1983 | goto err_out; |
| 1984 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 1985 | #ifdef SMC_USE_DMA |
| 1986 | lp->rxdma = SMC_DMA_REQUEST(dev, smc911x_rx_dma_irq); |
| 1987 | lp->txdma = SMC_DMA_REQUEST(dev, smc911x_tx_dma_irq); |
| 1988 | lp->rxdma_active = 0; |
| 1989 | lp->txdma_active = 0; |
| 1990 | dev->dma = lp->rxdma; |
| 1991 | #endif |
| 1992 | |
| 1993 | retval = register_netdev(dev); |
| 1994 | if (retval == 0) { |
| 1995 | /* now, print out the card info, in a short format.. */ |
| 1996 | printk("%s: %s (rev %d) at %#lx IRQ %d", |
| 1997 | dev->name, version_string, lp->revision, |
| 1998 | dev->base_addr, dev->irq); |
| 1999 | |
| 2000 | #ifdef SMC_USE_DMA |
| 2001 | if (lp->rxdma != -1) |
| 2002 | printk(" RXDMA %d ", lp->rxdma); |
| 2003 | |
| 2004 | if (lp->txdma != -1) |
| 2005 | printk("TXDMA %d", lp->txdma); |
| 2006 | #endif |
| 2007 | printk("\n"); |
| 2008 | if (!is_valid_ether_addr(dev->dev_addr)) { |
| 2009 | printk("%s: Invalid ethernet MAC address. Please " |
| 2010 | "set using ifconfig\n", dev->name); |
| 2011 | } else { |
| 2012 | /* Print the Ethernet address */ |
| 2013 | printk("%s: Ethernet addr: ", dev->name); |
| 2014 | for (i = 0; i < 5; i++) |
| 2015 | printk("%2.2x:", dev->dev_addr[i]); |
| 2016 | printk("%2.2x\n", dev->dev_addr[5]); |
| 2017 | } |
| 2018 | |
| 2019 | if (lp->phy_type == 0) { |
| 2020 | PRINTK("%s: No PHY found\n", dev->name); |
| 2021 | } else if ((lp->phy_type & ~0xff) == LAN911X_INTERNAL_PHY_ID) { |
| 2022 | PRINTK("%s: LAN911x Internal PHY\n", dev->name); |
| 2023 | } else { |
| 2024 | PRINTK("%s: External PHY 0x%08x\n", dev->name, lp->phy_type); |
| 2025 | } |
| 2026 | } |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 2027 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2028 | err_out: |
| 2029 | #ifdef SMC_USE_DMA |
| 2030 | if (retval) { |
| 2031 | if (lp->rxdma != -1) { |
| 2032 | SMC_DMA_FREE(dev, lp->rxdma); |
| 2033 | } |
| 2034 | if (lp->txdma != -1) { |
| 2035 | SMC_DMA_FREE(dev, lp->txdma); |
| 2036 | } |
| 2037 | } |
| 2038 | #endif |
| 2039 | return retval; |
| 2040 | } |
| 2041 | |
| 2042 | /* |
| 2043 | * smc911x_init(void) |
| 2044 | * |
| 2045 | * Output: |
| 2046 | * 0 --> there is a device |
| 2047 | * anything else, error |
| 2048 | */ |
Al Viro | f57628d | 2008-11-22 17:36:14 +0000 | [diff] [blame] | 2049 | static int __devinit smc911x_drv_probe(struct platform_device *pdev) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2050 | { |
| 2051 | struct net_device *ndev; |
| 2052 | struct resource *res; |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 2053 | struct smc911x_local *lp; |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2054 | unsigned int *addr; |
| 2055 | int ret; |
| 2056 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 2057 | DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2058 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 2059 | if (!res) { |
| 2060 | ret = -ENODEV; |
| 2061 | goto out; |
| 2062 | } |
| 2063 | |
| 2064 | /* |
| 2065 | * Request the regions. |
| 2066 | */ |
| 2067 | if (!request_mem_region(res->start, SMC911X_IO_EXTENT, CARDNAME)) { |
| 2068 | ret = -EBUSY; |
| 2069 | goto out; |
| 2070 | } |
| 2071 | |
| 2072 | ndev = alloc_etherdev(sizeof(struct smc911x_local)); |
| 2073 | if (!ndev) { |
| 2074 | printk("%s: could not allocate device.\n", CARDNAME); |
| 2075 | ret = -ENOMEM; |
| 2076 | goto release_1; |
| 2077 | } |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2078 | SET_NETDEV_DEV(ndev, &pdev->dev); |
| 2079 | |
| 2080 | ndev->dma = (unsigned char)-1; |
| 2081 | ndev->irq = platform_get_irq(pdev, 0); |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 2082 | lp = netdev_priv(ndev); |
| 2083 | lp->netdev = ndev; |
Magnus Damm | 12c03f5 | 2008-06-09 16:33:55 -0700 | [diff] [blame] | 2084 | #ifdef SMC_DYNAMIC_BUS_CONFIG |
Andrew Morton | a316084 | 2008-12-01 12:24:46 +0000 | [diff] [blame] | 2085 | { |
| 2086 | struct smc911x_platdata *pd = pdev->dev.platform_data; |
| 2087 | if (!pd) { |
| 2088 | ret = -EINVAL; |
| 2089 | goto release_both; |
| 2090 | } |
| 2091 | memcpy(&lp->cfg, pd, sizeof(lp->cfg)); |
Magnus Damm | 12c03f5 | 2008-06-09 16:33:55 -0700 | [diff] [blame] | 2092 | } |
Magnus Damm | 12c03f5 | 2008-06-09 16:33:55 -0700 | [diff] [blame] | 2093 | #endif |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2094 | |
| 2095 | addr = ioremap(res->start, SMC911X_IO_EXTENT); |
| 2096 | if (!addr) { |
| 2097 | ret = -ENOMEM; |
| 2098 | goto release_both; |
| 2099 | } |
| 2100 | |
| 2101 | platform_set_drvdata(pdev, ndev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 2102 | lp->base = addr; |
| 2103 | ndev->base_addr = res->start; |
| 2104 | ret = smc911x_probe(ndev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2105 | if (ret != 0) { |
| 2106 | platform_set_drvdata(pdev, NULL); |
| 2107 | iounmap(addr); |
| 2108 | release_both: |
| 2109 | free_netdev(ndev); |
| 2110 | release_1: |
| 2111 | release_mem_region(res->start, SMC911X_IO_EXTENT); |
| 2112 | out: |
| 2113 | printk("%s: not found (%d).\n", CARDNAME, ret); |
| 2114 | } |
| 2115 | #ifdef SMC_USE_DMA |
| 2116 | else { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2117 | lp->physaddr = res->start; |
| 2118 | lp->dev = &pdev->dev; |
| 2119 | } |
| 2120 | #endif |
| 2121 | |
| 2122 | return ret; |
| 2123 | } |
| 2124 | |
Al Viro | f57628d | 2008-11-22 17:36:14 +0000 | [diff] [blame] | 2125 | static int __devexit smc911x_drv_remove(struct platform_device *pdev) |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2126 | { |
| 2127 | struct net_device *ndev = platform_get_drvdata(pdev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 2128 | struct smc911x_local *lp = netdev_priv(ndev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2129 | struct resource *res; |
| 2130 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 2131 | DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2132 | platform_set_drvdata(pdev, NULL); |
| 2133 | |
| 2134 | unregister_netdev(ndev); |
| 2135 | |
| 2136 | free_irq(ndev->irq, ndev); |
| 2137 | |
| 2138 | #ifdef SMC_USE_DMA |
| 2139 | { |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2140 | if (lp->rxdma != -1) { |
| 2141 | SMC_DMA_FREE(dev, lp->rxdma); |
| 2142 | } |
| 2143 | if (lp->txdma != -1) { |
| 2144 | SMC_DMA_FREE(dev, lp->txdma); |
| 2145 | } |
| 2146 | } |
| 2147 | #endif |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 2148 | iounmap(lp->base); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2149 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 2150 | release_mem_region(res->start, SMC911X_IO_EXTENT); |
| 2151 | |
| 2152 | free_netdev(ndev); |
| 2153 | return 0; |
| 2154 | } |
| 2155 | |
| 2156 | static int smc911x_drv_suspend(struct platform_device *dev, pm_message_t state) |
| 2157 | { |
| 2158 | struct net_device *ndev = platform_get_drvdata(dev); |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 2159 | struct smc911x_local *lp = netdev_priv(ndev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2160 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 2161 | DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2162 | if (ndev) { |
| 2163 | if (netif_running(ndev)) { |
| 2164 | netif_device_detach(ndev); |
| 2165 | smc911x_shutdown(ndev); |
| 2166 | #if POWER_DOWN |
| 2167 | /* Set D2 - Energy detect only setting */ |
Magnus Damm | 699559f | 2008-06-09 16:33:54 -0700 | [diff] [blame] | 2168 | SMC_SET_PMT_CTRL(lp, 2<<12); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2169 | #endif |
| 2170 | } |
| 2171 | } |
| 2172 | return 0; |
| 2173 | } |
| 2174 | |
| 2175 | static int smc911x_drv_resume(struct platform_device *dev) |
| 2176 | { |
| 2177 | struct net_device *ndev = platform_get_drvdata(dev); |
| 2178 | |
Harvey Harrison | b39d66a | 2008-08-20 16:52:04 -0700 | [diff] [blame] | 2179 | DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2180 | if (ndev) { |
| 2181 | struct smc911x_local *lp = netdev_priv(ndev); |
| 2182 | |
| 2183 | if (netif_running(ndev)) { |
| 2184 | smc911x_reset(ndev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2185 | if (lp->phy_type != 0) |
Andrew Morton | ef8142a | 2006-12-22 01:08:33 -0800 | [diff] [blame] | 2186 | smc911x_phy_configure(&lp->phy_configure); |
Dasgupta, Romit | 347c8d8 | 2008-11-06 15:46:18 +0530 | [diff] [blame] | 2187 | smc911x_enable(ndev); |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2188 | netif_device_attach(ndev); |
| 2189 | } |
| 2190 | } |
| 2191 | return 0; |
| 2192 | } |
| 2193 | |
| 2194 | static struct platform_driver smc911x_driver = { |
| 2195 | .probe = smc911x_drv_probe, |
Al Viro | f57628d | 2008-11-22 17:36:14 +0000 | [diff] [blame] | 2196 | .remove = __devexit_p(smc911x_drv_remove), |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2197 | .suspend = smc911x_drv_suspend, |
| 2198 | .resume = smc911x_drv_resume, |
| 2199 | .driver = { |
| 2200 | .name = CARDNAME, |
Kay Sievers | 72abb46 | 2008-04-18 13:50:44 -0700 | [diff] [blame] | 2201 | .owner = THIS_MODULE, |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2202 | }, |
| 2203 | }; |
Jeff Garzik | d5498be | 2006-04-20 17:39:14 -0400 | [diff] [blame] | 2204 | |
Dustin McIntire | 0a0c72c | 2006-04-19 20:24:51 -0700 | [diff] [blame] | 2205 | static int __init smc911x_init(void) |
| 2206 | { |
| 2207 | return platform_driver_register(&smc911x_driver); |
| 2208 | } |
| 2209 | |
| 2210 | static void __exit smc911x_cleanup(void) |
| 2211 | { |
| 2212 | platform_driver_unregister(&smc911x_driver); |
| 2213 | } |
| 2214 | |
| 2215 | module_init(smc911x_init); |
| 2216 | module_exit(smc911x_cleanup); |