Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* smc911x.c

2

* smc911x.c

3

* This is a driver for SMSC's LAN911{5,6,7,8} single-chip Ethernet devices.

3

* This is a driver for SMSC's LAN911{5,6,7,8} single-chip Ethernet devices.

4

*

4

*

5

6

* Derived from the unified SMC91x driver by Nicolas Pitre

6

* Derived from the unified SMC91x driver by Nicolas Pitre

7

* and the smsc911x.c reference driver by SMSC

7

* and the smsc911x.c reference driver by SMSC

8

*

8

*

9

* This program is free software; you can redistribute it and/or modify

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

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

11

* the Free Software Foundation; either version 2 of the License, or

12

* (at your option) any later version.

12

* (at your option) any later version.

13

*

13

*

14

* This program is distributed in the hope that it will be useful,

14

* This program is distributed in the hope that it will be useful,

15

* but WITHOUT ANY WARRANTY; without even the implied warranty of

15

* but WITHOUT ANY WARRANTY; without even the implied warranty of

16

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

16

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

* GNU General Public License for more details.

17

* GNU General Public License for more details.

18

*

18

*

19

* You should have received a copy of the GNU General Public License

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

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

21

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

22

*

22

*

23

* Arguments:

23

* Arguments:

24

* watchdog = TX watchdog timeout

24

* watchdog = TX watchdog timeout

25

* tx_fifo_kb = Size of TX FIFO in KB

25

* tx_fifo_kb = Size of TX FIFO in KB

26

*

26

*

27

* History:

27

* History:

28

* 04/16/05 Dustin McIntire Initial version

28

* 04/16/05 Dustin McIntire Initial version

29

*/

29

*/

30

static const char version[] =

30

static const char version[] =

31

"smc911x.c: v1.0 04-16-2005 by Dustin McIntire <dustin@sensoria.com>\n";

31

"smc911x.c: v1.0 04-16-2005 by Dustin McIntire <dustin@sensoria.com>\n";

32

33

/* Debugging options */

33

/* Debugging options */

34

#define ENABLE_SMC_DEBUG_RX 0

34

#define ENABLE_SMC_DEBUG_RX 0

35

#define ENABLE_SMC_DEBUG_TX 0

35

#define ENABLE_SMC_DEBUG_TX 0

36

#define ENABLE_SMC_DEBUG_DMA 0

36

#define ENABLE_SMC_DEBUG_DMA 0

37

#define ENABLE_SMC_DEBUG_PKTS 0

37

#define ENABLE_SMC_DEBUG_PKTS 0

38

#define ENABLE_SMC_DEBUG_MISC 0

38

#define ENABLE_SMC_DEBUG_MISC 0

39

#define ENABLE_SMC_DEBUG_FUNC 0

39

#define ENABLE_SMC_DEBUG_FUNC 0

40

41

#define SMC_DEBUG_RX ((ENABLE_SMC_DEBUG_RX ? 1 : 0) << 0)

41

#define SMC_DEBUG_RX ((ENABLE_SMC_DEBUG_RX ? 1 : 0) << 0)

42

#define SMC_DEBUG_TX ((ENABLE_SMC_DEBUG_TX ? 1 : 0) << 1)

42

#define SMC_DEBUG_TX ((ENABLE_SMC_DEBUG_TX ? 1 : 0) << 1)

43

#define SMC_DEBUG_DMA ((ENABLE_SMC_DEBUG_DMA ? 1 : 0) << 2)

43

#define SMC_DEBUG_DMA ((ENABLE_SMC_DEBUG_DMA ? 1 : 0) << 2)

44

#define SMC_DEBUG_PKTS ((ENABLE_SMC_DEBUG_PKTS ? 1 : 0) << 3)

44

#define SMC_DEBUG_PKTS ((ENABLE_SMC_DEBUG_PKTS ? 1 : 0) << 3)

45

#define SMC_DEBUG_MISC ((ENABLE_SMC_DEBUG_MISC ? 1 : 0) << 4)

45

#define SMC_DEBUG_MISC ((ENABLE_SMC_DEBUG_MISC ? 1 : 0) << 4)

46

#define SMC_DEBUG_FUNC ((ENABLE_SMC_DEBUG_FUNC ? 1 : 0) << 5)

46

#define SMC_DEBUG_FUNC ((ENABLE_SMC_DEBUG_FUNC ? 1 : 0) << 5)

47

48

#ifndef SMC_DEBUG

48

#ifndef SMC_DEBUG

49

#define SMC_DEBUG ( SMC_DEBUG_RX | \

49

#define SMC_DEBUG ( SMC_DEBUG_RX | \

50

SMC_DEBUG_TX | \

50

SMC_DEBUG_TX | \

51

SMC_DEBUG_DMA | \

51

SMC_DEBUG_DMA | \

52

SMC_DEBUG_PKTS | \

52

SMC_DEBUG_PKTS | \

53

SMC_DEBUG_MISC | \

53

SMC_DEBUG_MISC | \

54

SMC_DEBUG_FUNC \

54

SMC_DEBUG_FUNC \

55

)

55

)

56

#endif

56

#endif

57

58

#include <linux/init.h>

58

#include <linux/init.h>

59

#include <linux/module.h>

59

#include <linux/module.h>

60

#include <linux/kernel.h>

60

#include <linux/kernel.h>

61

#include <linux/sched.h>

61

#include <linux/sched.h>

62

#include <linux/slab.h>

62

#include <linux/slab.h>

63

#include <linux/delay.h>

63

#include <linux/delay.h>

64

#include <linux/interrupt.h>

64

#include <linux/interrupt.h>

65

#include <linux/errno.h>

65

#include <linux/errno.h>

66

#include <linux/ioport.h>

66

#include <linux/ioport.h>

67

#include <linux/crc32.h>

67

#include <linux/crc32.h>

68

#include <linux/device.h>

68

#include <linux/device.h>

69

#include <linux/platform_device.h>

69

#include <linux/platform_device.h>

70

#include <linux/spinlock.h>

70

#include <linux/spinlock.h>

71

#include <linux/ethtool.h>

71

#include <linux/ethtool.h>

72

#include <linux/mii.h>

72

#include <linux/mii.h>

73

#include <linux/workqueue.h>

73

#include <linux/workqueue.h>

74

75

#include <linux/netdevice.h>

75

#include <linux/netdevice.h>

76

#include <linux/etherdevice.h>

76

#include <linux/etherdevice.h>

77

#include <linux/skbuff.h>

77

#include <linux/skbuff.h>

78

79

#include <asm/io.h>

79

#include <asm/io.h>

80

81

#include "smc911x.h"

81

#include "smc911x.h"

82

83

/*

83

/*

84

* Transmit timeout, default 5 seconds.

84

* Transmit timeout, default 5 seconds.

85

*/

85

*/

86

static int watchdog = 5000;

86

static int watchdog = 5000;

87

module_param(watchdog, int, 0400);

87

module_param(watchdog, int, 0400);

88

MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");

88

MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");

89

90

static int tx_fifo_kb=8;

90

static int tx_fifo_kb=8;

91

module_param(tx_fifo_kb, int, 0400);

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)");

92

MODULE_PARM_DESC(tx_fifo_kb,"transmit FIFO size in KB (1<x<15)(default=8)");

93

94

MODULE_LICENSE("GPL");

94

MODULE_LICENSE("GPL");

95

MODULE_ALIAS("platform:smc911x");

95

MODULE_ALIAS("platform:smc911x");

96

97

/*

97

/*

98

* The internal workings of the driver. If you are changing anything

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

99

* here with the SMC stuff, you should have the datasheet and know

100

* what you are doing.

100

* what you are doing.

101

*/

101

*/

102

#define CARDNAME "smc911x"

102

#define CARDNAME "smc911x"

103

104

/*

104

/*

105

* Use power-down feature of the chip

105

* Use power-down feature of the chip

106

*/

106

*/

107

#define POWER_DOWN 1

107

#define POWER_DOWN 1

108

109

#if SMC_DEBUG > 0

109

#if SMC_DEBUG > 0

110

#define DBG(n, args...) \

110

#define DBG(n, args...) \

111

do { \

111

do { \

112

if (SMC_DEBUG & (n)) \

112

if (SMC_DEBUG & (n)) \

113

printk(args); \

113

printk(args); \

114

} while (0)

114

} while (0)

115

116

#define PRINTK(args...) printk(args)

116

#define PRINTK(args...) printk(args)

117

#else

117

#else

118

#define DBG(n, args...) do { } while (0)

118

#define DBG(n, args...) do { } while (0)

119

#define PRINTK(args...) printk(KERN_DEBUG args)

119

#define PRINTK(args...) printk(KERN_DEBUG args)

120

#endif

120

#endif

121

122

#if SMC_DEBUG_PKTS > 0

122

#if SMC_DEBUG_PKTS > 0

123

static void PRINT_PKT(u_char *buf, int length)

123

static void PRINT_PKT(u_char *buf, int length)

124

{

124

{

125

int i;

125

int i;

126

int remainder;

126

int remainder;

127

int lines;

127

int lines;

128

129

lines = length / 16;

129

lines = length / 16;

130

remainder = length % 16;

130

remainder = length % 16;

131

132

for (i = 0; i < lines ; i ++) {

132

for (i = 0; i < lines ; i ++) {

133

int cur;

133

int cur;

134

for (cur = 0; cur < 8; cur++) {

134

for (cur = 0; cur < 8; cur++) {

135

u_char a, b;

135

u_char a, b;

136

a = *buf++;

136

a = *buf++;

137

b = *buf++;

137

b = *buf++;

138

printk("%02x%02x ", a, b);

138

printk("%02x%02x ", a, b);

139

}

139

}

140

printk("\n");

140

printk("\n");

141

}

141

}

142

for (i = 0; i < remainder/2 ; i++) {

142

for (i = 0; i < remainder/2 ; i++) {

143

u_char a, b;

143

u_char a, b;

144

a = *buf++;

144

a = *buf++;

145

b = *buf++;

145

b = *buf++;

146

printk("%02x%02x ", a, b);

146

printk("%02x%02x ", a, b);

147

}

147

}

148

printk("\n");

148

printk("\n");

149

}

149

}

150

#else

150

#else

151

#define PRINT_PKT(x...) do { } while (0)

151

#define PRINT_PKT(x...) do { } while (0)

152

#endif

152

#endif

153

154

155

/* this enables an interrupt in the interrupt mask register */

155

/* this enables an interrupt in the interrupt mask register */

156

#define SMC_ENABLE_INT(lp, x) do { \

156

#define SMC_ENABLE_INT(lp, x) do { \

157

unsigned int __mask; \

157

unsigned int __mask; \

158

unsigned long __flags; \

158

unsigned long __flags; \

159

spin_lock_irqsave(&lp->lock, __flags); \

159

spin_lock_irqsave(&lp->lock, __flags); \

160

__mask = SMC_GET_INT_EN((lp)); \

160

__mask = SMC_GET_INT_EN((lp)); \

161

__mask |= (x); \

161

__mask |= (x); \

162

SMC_SET_INT_EN((lp), __mask); \

162

SMC_SET_INT_EN((lp), __mask); \

163

spin_unlock_irqrestore(&lp->lock, __flags); \

163

spin_unlock_irqrestore(&lp->lock, __flags); \

164

} while (0)

164

} while (0)

165

166

/* this disables an interrupt from the interrupt mask register */

166

/* this disables an interrupt from the interrupt mask register */

167

#define SMC_DISABLE_INT(lp, x) do { \

167

#define SMC_DISABLE_INT(lp, x) do { \

168

unsigned int __mask; \

168

unsigned int __mask; \

169

unsigned long __flags; \

169

unsigned long __flags; \

170

spin_lock_irqsave(&lp->lock, __flags); \

170

spin_lock_irqsave(&lp->lock, __flags); \

171

__mask = SMC_GET_INT_EN((lp)); \

171

__mask = SMC_GET_INT_EN((lp)); \

172

__mask &= ~(x); \

172

__mask &= ~(x); \

173

SMC_SET_INT_EN((lp), __mask); \

173

SMC_SET_INT_EN((lp), __mask); \

174

spin_unlock_irqrestore(&lp->lock, __flags); \

174

spin_unlock_irqrestore(&lp->lock, __flags); \

175

} while (0)

175

} while (0)

176

177

/*

177

/*

178

* this does a soft reset on the device

178

* this does a soft reset on the device

179

*/

179

*/

180

static void smc911x_reset(struct net_device *dev)

180

static void smc911x_reset(struct net_device *dev)

181

{

181

{

182

struct smc911x_local *lp = netdev_priv(dev);

182

struct smc911x_local *lp = netdev_priv(dev);

183

unsigned int reg, timeout=0, resets=1;

183

unsigned int reg, timeout=0, resets=1, irq_cfg;

184

unsigned long flags;

184

unsigned long flags;

185

186

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

186

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

187

188

/* Take out of PM setting first */

188

/* Take out of PM setting first */

189

if ((SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_) == 0) {

189

if ((SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_) == 0) {

190

/* Write to the bytetest will take out of powerdown */

190

/* Write to the bytetest will take out of powerdown */

191

SMC_SET_BYTE_TEST(lp, 0);

191

SMC_SET_BYTE_TEST(lp, 0);

192

timeout=10;

192

timeout=10;

193

do {

193

do {

194

udelay(10);

194

udelay(10);

195

reg = SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_;

195

reg = SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_;

196

} while (--timeout && !reg);

196

} while (--timeout && !reg);

197

if (timeout == 0) {

197

if (timeout == 0) {

198

PRINTK("%s: smc911x_reset timeout waiting for PM restore\n", dev->name);

198

PRINTK("%s: smc911x_reset timeout waiting for PM restore\n", dev->name);

199

return;

199

return;

200

}

200

}

201

}

201

}

202

203

/* Disable all interrupts */

203

/* Disable all interrupts */

204

spin_lock_irqsave(&lp->lock, flags);

204

spin_lock_irqsave(&lp->lock, flags);

205

SMC_SET_INT_EN(lp, 0);

205

SMC_SET_INT_EN(lp, 0);

206

spin_unlock_irqrestore(&lp->lock, flags);

206

spin_unlock_irqrestore(&lp->lock, flags);

207

208

while (resets--) {

208

while (resets--) {

209

SMC_SET_HW_CFG(lp, HW_CFG_SRST_);

209

SMC_SET_HW_CFG(lp, HW_CFG_SRST_);

210

timeout=10;

210

timeout=10;

211

do {

211

do {

212

udelay(10);

212

udelay(10);

213

reg = SMC_GET_HW_CFG(lp);

213

reg = SMC_GET_HW_CFG(lp);

214

/* If chip indicates reset timeout then try again */

214

/* If chip indicates reset timeout then try again */

215

if (reg & HW_CFG_SRST_TO_) {

215

if (reg & HW_CFG_SRST_TO_) {

216

PRINTK("%s: chip reset timeout, retrying...\n", dev->name);

216

PRINTK("%s: chip reset timeout, retrying...\n", dev->name);

217

resets++;

217

resets++;

218

break;

218

break;

219

}

219

}

220

} while (--timeout && (reg & HW_CFG_SRST_));

220

} while (--timeout && (reg & HW_CFG_SRST_));

221

}

221

}

222

if (timeout == 0) {

222

if (timeout == 0) {

223

PRINTK("%s: smc911x_reset timeout waiting for reset\n", dev->name);

223

PRINTK("%s: smc911x_reset timeout waiting for reset\n", dev->name);

224

return;

224

return;

225

}

225

}

226

227

/* make sure EEPROM has finished loading before setting GPIO_CFG */

227

/* make sure EEPROM has finished loading before setting GPIO_CFG */

228

timeout=1000;

228

timeout=1000;

229

while ( timeout-- && (SMC_GET_E2P_CMD(lp) & E2P_CMD_EPC_BUSY_)) {

229

while ( timeout-- && (SMC_GET_E2P_CMD(lp) & E2P_CMD_EPC_BUSY_)) {

230

udelay(10);

230

udelay(10);

231

}

231

}

232

if (timeout == 0){

232

if (timeout == 0){

233

PRINTK("%s: smc911x_reset timeout waiting for EEPROM busy\n", dev->name);

233

PRINTK("%s: smc911x_reset timeout waiting for EEPROM busy\n", dev->name);

234

return;

234

return;

235

}

235

}

236

237

/* Initialize interrupts */

237

/* Initialize interrupts */

238

SMC_SET_INT_EN(lp, 0);

238

SMC_SET_INT_EN(lp, 0);

239

SMC_ACK_INT(lp, -1);

239

SMC_ACK_INT(lp, -1);

240

241

/* Reset the FIFO level and flow control settings */

241

/* Reset the FIFO level and flow control settings */

242

SMC_SET_HW_CFG(lp, (lp->tx_fifo_kb & 0xF) << 16);

242

SMC_SET_HW_CFG(lp, (lp->tx_fifo_kb & 0xF) << 16);

243

//TODO: Figure out what appropriate pause time is

243

//TODO: Figure out what appropriate pause time is

244

SMC_SET_FLOW(lp, FLOW_FCPT_ | FLOW_FCEN_);

244

SMC_SET_FLOW(lp, FLOW_FCPT_ | FLOW_FCEN_);

245

SMC_SET_AFC_CFG(lp, lp->afc_cfg);

245

SMC_SET_AFC_CFG(lp, lp->afc_cfg);

246

247

248

/* Set to LED outputs */

248

/* Set to LED outputs */

249

SMC_SET_GPIO_CFG(lp, 0x70070000);

249

SMC_SET_GPIO_CFG(lp, 0x70070000);

250

251

/*

251

/*

252

* Deassert IRQ for 1*10us for edge type interrupts

252

* Deassert IRQ for 1*10us for edge type interrupts

253

* and drive IRQ pin push-pull

253

* and drive IRQ pin push-pull

254

*/

254

*/

255

SMC_SET_IRQ_CFG(lp, (1 << 24) | INT_CFG_IRQ_EN_ | INT_CFG_IRQ_TYPE_);

255

irq_cfg = (1 << 24) | INT_CFG_IRQ_EN_ | INT_CFG_IRQ_TYPE_;

256

#ifdef SMC_DYNAMIC_BUS_CONFIG

257

if (lp->cfg.irq_polarity)

258

irq_cfg |= INT_CFG_IRQ_POL_;

259

#endif

260

SMC_SET_IRQ_CFG(lp, irq_cfg);

256

261

257

/* clear anything saved */

262

/* clear anything saved */

258

if (lp->pending_tx_skb != NULL) {

263

if (lp->pending_tx_skb != NULL) {

259

dev_kfree_skb (lp->pending_tx_skb);

264

dev_kfree_skb (lp->pending_tx_skb);

260

lp->pending_tx_skb = NULL;

265

lp->pending_tx_skb = NULL;

261

dev->stats.tx_errors++;

266

dev->stats.tx_errors++;

262

dev->stats.tx_aborted_errors++;

267

dev->stats.tx_aborted_errors++;

263

}

268

}

264

}

269

}

265

270

266

/*

271

/*

267

* Enable Interrupts, Receive, and Transmit

272

* Enable Interrupts, Receive, and Transmit

268

*/

273

*/

269

static void smc911x_enable(struct net_device *dev)

274

static void smc911x_enable(struct net_device *dev)

270

{

275

{

271

struct smc911x_local *lp = netdev_priv(dev);

276

struct smc911x_local *lp = netdev_priv(dev);

272

unsigned mask, cfg, cr;

277

unsigned mask, cfg, cr;

273

unsigned long flags;

278

unsigned long flags;

274

279

275

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

280

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

276

281

277

SMC_SET_MAC_ADDR(lp, dev->dev_addr);

282

SMC_SET_MAC_ADDR(lp, dev->dev_addr);

278

283

279

/* Enable TX */

284

/* Enable TX */

280

cfg = SMC_GET_HW_CFG(lp);

285

cfg = SMC_GET_HW_CFG(lp);

281

cfg &= HW_CFG_TX_FIF_SZ_ | 0xFFF;

286

cfg &= HW_CFG_TX_FIF_SZ_ | 0xFFF;

282

cfg |= HW_CFG_SF_;

287

cfg |= HW_CFG_SF_;

283

SMC_SET_HW_CFG(lp, cfg);

288

SMC_SET_HW_CFG(lp, cfg);

284

SMC_SET_FIFO_TDA(lp, 0xFF);

289

SMC_SET_FIFO_TDA(lp, 0xFF);

285

/* Update TX stats on every 64 packets received or every 1 sec */

290

/* Update TX stats on every 64 packets received or every 1 sec */

286

SMC_SET_FIFO_TSL(lp, 64);

291

SMC_SET_FIFO_TSL(lp, 64);

287

SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);

292

SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);

288

293

289

spin_lock_irqsave(&lp->lock, flags);

294

spin_lock_irqsave(&lp->lock, flags);

290

SMC_GET_MAC_CR(lp, cr);

295

SMC_GET_MAC_CR(lp, cr);

291

cr |= MAC_CR_TXEN_ | MAC_CR_HBDIS_;

296

cr |= MAC_CR_TXEN_ | MAC_CR_HBDIS_;

292

SMC_SET_MAC_CR(lp, cr);

297

SMC_SET_MAC_CR(lp, cr);

293

SMC_SET_TX_CFG(lp, TX_CFG_TX_ON_);

298

SMC_SET_TX_CFG(lp, TX_CFG_TX_ON_);

294

spin_unlock_irqrestore(&lp->lock, flags);

299

spin_unlock_irqrestore(&lp->lock, flags);

295

300

296

/* Add 2 byte padding to start of packets */

301

/* Add 2 byte padding to start of packets */

297

SMC_SET_RX_CFG(lp, (2<<8) & RX_CFG_RXDOFF_);

302

SMC_SET_RX_CFG(lp, (2<<8) & RX_CFG_RXDOFF_);

298

303

299

/* Turn on receiver and enable RX */

304

/* Turn on receiver and enable RX */

300

if (cr & MAC_CR_RXEN_)

305

if (cr & MAC_CR_RXEN_)

301

DBG(SMC_DEBUG_RX, "%s: Receiver already enabled\n", dev->name);

306

DBG(SMC_DEBUG_RX, "%s: Receiver already enabled\n", dev->name);

302

307

303

spin_lock_irqsave(&lp->lock, flags);

308

spin_lock_irqsave(&lp->lock, flags);

304

SMC_SET_MAC_CR(lp, cr | MAC_CR_RXEN_);

309

SMC_SET_MAC_CR(lp, cr | MAC_CR_RXEN_);

305

spin_unlock_irqrestore(&lp->lock, flags);

310

spin_unlock_irqrestore(&lp->lock, flags);

306

311

307

/* Interrupt on every received packet */

312

/* Interrupt on every received packet */

308

SMC_SET_FIFO_RSA(lp, 0x01);

313

SMC_SET_FIFO_RSA(lp, 0x01);

309

SMC_SET_FIFO_RSL(lp, 0x00);

314

SMC_SET_FIFO_RSL(lp, 0x00);

310

315

311

/* now, enable interrupts */

316

/* now, enable interrupts */

312

mask = INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_ | INT_EN_RSFL_EN_ |

317

mask = INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_ | INT_EN_RSFL_EN_ |

313

INT_EN_GPT_INT_EN_ | INT_EN_RXDFH_INT_EN_ | INT_EN_RXE_EN_ |

318

INT_EN_GPT_INT_EN_ | INT_EN_RXDFH_INT_EN_ | INT_EN_RXE_EN_ |

314

INT_EN_PHY_INT_EN_;

319

INT_EN_PHY_INT_EN_;

315

if (IS_REV_A(lp->revision))

320

if (IS_REV_A(lp->revision))

316

mask|=INT_EN_RDFL_EN_;

321

mask|=INT_EN_RDFL_EN_;

317

else {

322

else {

318

mask|=INT_EN_RDFO_EN_;

323

mask|=INT_EN_RDFO_EN_;

319

}

324

}

320

SMC_ENABLE_INT(lp, mask);

325

SMC_ENABLE_INT(lp, mask);

321

}

326

}

322

327

323

/*

328

/*

324

* this puts the device in an inactive state

329

* this puts the device in an inactive state

325

*/

330

*/

326

static void smc911x_shutdown(struct net_device *dev)

331

static void smc911x_shutdown(struct net_device *dev)

327

{

332

{

328

struct smc911x_local *lp = netdev_priv(dev);

333

struct smc911x_local *lp = netdev_priv(dev);

329

unsigned cr;

334

unsigned cr;

330

unsigned long flags;

335

unsigned long flags;

331

336

332

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", CARDNAME, __func__);

337

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", CARDNAME, __func__);

333

338

334

/* Disable IRQ's */

339

/* Disable IRQ's */

335

SMC_SET_INT_EN(lp, 0);

340

SMC_SET_INT_EN(lp, 0);

336

341

337

/* Turn of Rx and TX */

342

/* Turn of Rx and TX */

338

spin_lock_irqsave(&lp->lock, flags);

343

spin_lock_irqsave(&lp->lock, flags);

339

SMC_GET_MAC_CR(lp, cr);

344

SMC_GET_MAC_CR(lp, cr);

340

cr &= ~(MAC_CR_TXEN_ | MAC_CR_RXEN_ | MAC_CR_HBDIS_);

345

cr &= ~(MAC_CR_TXEN_ | MAC_CR_RXEN_ | MAC_CR_HBDIS_);

341

SMC_SET_MAC_CR(lp, cr);

346

SMC_SET_MAC_CR(lp, cr);

342

SMC_SET_TX_CFG(lp, TX_CFG_STOP_TX_);

347

SMC_SET_TX_CFG(lp, TX_CFG_STOP_TX_);

343

spin_unlock_irqrestore(&lp->lock, flags);

348

spin_unlock_irqrestore(&lp->lock, flags);

344

}

349

}

345

350

346

static inline void smc911x_drop_pkt(struct net_device *dev)

351

static inline void smc911x_drop_pkt(struct net_device *dev)

347

{

352

{

348

struct smc911x_local *lp = netdev_priv(dev);

353

struct smc911x_local *lp = netdev_priv(dev);

349

unsigned int fifo_count, timeout, reg;

354

unsigned int fifo_count, timeout, reg;

350

355

351

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n", CARDNAME, __func__);

356

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n", CARDNAME, __func__);

352

fifo_count = SMC_GET_RX_FIFO_INF(lp) & 0xFFFF;

357

fifo_count = SMC_GET_RX_FIFO_INF(lp) & 0xFFFF;

353

if (fifo_count <= 4) {

358

if (fifo_count <= 4) {

354

/* Manually dump the packet data */

359

/* Manually dump the packet data */

355

while (fifo_count--)

360

while (fifo_count--)

356

SMC_GET_RX_FIFO(lp);

361

SMC_GET_RX_FIFO(lp);

357

} else {

362

} else {

358

/* Fast forward through the bad packet */

363

/* Fast forward through the bad packet */

359

SMC_SET_RX_DP_CTRL(lp, RX_DP_CTRL_FFWD_BUSY_);

364

SMC_SET_RX_DP_CTRL(lp, RX_DP_CTRL_FFWD_BUSY_);

360

timeout=50;

365

timeout=50;

361

do {

366

do {

362

udelay(10);

367

udelay(10);

363

reg = SMC_GET_RX_DP_CTRL(lp) & RX_DP_CTRL_FFWD_BUSY_;

368

reg = SMC_GET_RX_DP_CTRL(lp) & RX_DP_CTRL_FFWD_BUSY_;

364

} while (--timeout && reg);

369

} while (--timeout && reg);

365

if (timeout == 0) {

370

if (timeout == 0) {

366

PRINTK("%s: timeout waiting for RX fast forward\n", dev->name);

371

PRINTK("%s: timeout waiting for RX fast forward\n", dev->name);

367

}

372

}

368

}

373

}

369

}

374

}

370

375

371

/*

376

/*

372

* This is the procedure to handle the receipt of a packet.

377

* This is the procedure to handle the receipt of a packet.

373

* It should be called after checking for packet presence in

378

* It should be called after checking for packet presence in

374

* the RX status FIFO. It must be called with the spin lock

379

* the RX status FIFO. It must be called with the spin lock

375

* already held.

380

* already held.

376

*/

381

*/

377

static inline void smc911x_rcv(struct net_device *dev)

382

static inline void smc911x_rcv(struct net_device *dev)

378

{

383

{

379

struct smc911x_local *lp = netdev_priv(dev);

384

struct smc911x_local *lp = netdev_priv(dev);

380

unsigned int pkt_len, status;

385

unsigned int pkt_len, status;

381

struct sk_buff *skb;

386

struct sk_buff *skb;

382

unsigned char *data;

387

unsigned char *data;

383

388

384

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n",

389

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n",

385

dev->name, __func__);

390

dev->name, __func__);

386

status = SMC_GET_RX_STS_FIFO(lp);

391

status = SMC_GET_RX_STS_FIFO(lp);

387

DBG(SMC_DEBUG_RX, "%s: Rx pkt len %d status 0x%08x \n",

392

DBG(SMC_DEBUG_RX, "%s: Rx pkt len %d status 0x%08x \n",

388

dev->name, (status & 0x3fff0000) >> 16, status & 0xc000ffff);

393

dev->name, (status & 0x3fff0000) >> 16, status & 0xc000ffff);

389

pkt_len = (status & RX_STS_PKT_LEN_) >> 16;

394

pkt_len = (status & RX_STS_PKT_LEN_) >> 16;

390

if (status & RX_STS_ES_) {

395

if (status & RX_STS_ES_) {

391

/* Deal with a bad packet */

396

/* Deal with a bad packet */

392

dev->stats.rx_errors++;

397

dev->stats.rx_errors++;

393

if (status & RX_STS_CRC_ERR_)

398

if (status & RX_STS_CRC_ERR_)

394

dev->stats.rx_crc_errors++;

399

dev->stats.rx_crc_errors++;

395

else {

400

else {

396

if (status & RX_STS_LEN_ERR_)

401

if (status & RX_STS_LEN_ERR_)

397

dev->stats.rx_length_errors++;

402

dev->stats.rx_length_errors++;

398

if (status & RX_STS_MCAST_)

403

if (status & RX_STS_MCAST_)

399

dev->stats.multicast++;

404

dev->stats.multicast++;

400

}

405

}

401

/* Remove the bad packet data from the RX FIFO */

406

/* Remove the bad packet data from the RX FIFO */

402

smc911x_drop_pkt(dev);

407

smc911x_drop_pkt(dev);

403

} else {

408

} else {

404

/* Receive a valid packet */

409

/* Receive a valid packet */

405

/* Alloc a buffer with extra room for DMA alignment */

410

/* Alloc a buffer with extra room for DMA alignment */

406

skb=dev_alloc_skb(pkt_len+32);

411

skb=dev_alloc_skb(pkt_len+32);

407

if (unlikely(skb == NULL)) {

412

if (unlikely(skb == NULL)) {

408

PRINTK( "%s: Low memory, rcvd packet dropped.\n",

413

PRINTK( "%s: Low memory, rcvd packet dropped.\n",

409

dev->name);

414

dev->name);

410

dev->stats.rx_dropped++;

415

dev->stats.rx_dropped++;

411

smc911x_drop_pkt(dev);

416

smc911x_drop_pkt(dev);

412

return;

417

return;

413

}

418

}

414

/* Align IP header to 32 bits

419

/* Align IP header to 32 bits

415

* Note that the device is configured to add a 2

420

* Note that the device is configured to add a 2

416

* byte padding to the packet start, so we really

421

* byte padding to the packet start, so we really

417

* want to write to the orignal data pointer */

422

* want to write to the orignal data pointer */

418

data = skb->data;

423

data = skb->data;

419

skb_reserve(skb, 2);

424

skb_reserve(skb, 2);

420

skb_put(skb,pkt_len-4);

425

skb_put(skb,pkt_len-4);

421

#ifdef SMC_USE_DMA

426

#ifdef SMC_USE_DMA

422

{

427

{

423

unsigned int fifo;

428

unsigned int fifo;

424

/* Lower the FIFO threshold if possible */

429

/* Lower the FIFO threshold if possible */

425

fifo = SMC_GET_FIFO_INT(lp);

430

fifo = SMC_GET_FIFO_INT(lp);

426

if (fifo & 0xFF) fifo--;

431

if (fifo & 0xFF) fifo--;

427

DBG(SMC_DEBUG_RX, "%s: Setting RX stat FIFO threshold to %d\n",

432

DBG(SMC_DEBUG_RX, "%s: Setting RX stat FIFO threshold to %d\n",

428

dev->name, fifo & 0xff);

433

dev->name, fifo & 0xff);

429

SMC_SET_FIFO_INT(lp, fifo);

434

SMC_SET_FIFO_INT(lp, fifo);

430

/* Setup RX DMA */

435

/* Setup RX DMA */

431

SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN16_ | ((2<<8) & RX_CFG_RXDOFF_));

436

SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN16_ | ((2<<8) & RX_CFG_RXDOFF_));

432

lp->rxdma_active = 1;

437

lp->rxdma_active = 1;

433

lp->current_rx_skb = skb;

438

lp->current_rx_skb = skb;

434

SMC_PULL_DATA(lp, data, (pkt_len+2+15) & ~15);

439

SMC_PULL_DATA(lp, data, (pkt_len+2+15) & ~15);

435

/* Packet processing deferred to DMA RX interrupt */

440

/* Packet processing deferred to DMA RX interrupt */

436

}

441

}

437

#else

442

#else

438

SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN4_ | ((2<<8) & RX_CFG_RXDOFF_));

443

SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN4_ | ((2<<8) & RX_CFG_RXDOFF_));

439

SMC_PULL_DATA(lp, data, pkt_len+2+3);

444

SMC_PULL_DATA(lp, data, pkt_len+2+3);

440

445

441

DBG(SMC_DEBUG_PKTS, "%s: Received packet\n", dev->name);

446

DBG(SMC_DEBUG_PKTS, "%s: Received packet\n", dev->name);

442

PRINT_PKT(data, ((pkt_len - 4) <= 64) ? pkt_len - 4 : 64);

447

PRINT_PKT(data, ((pkt_len - 4) <= 64) ? pkt_len - 4 : 64);

443

dev->last_rx = jiffies;

448

dev->last_rx = jiffies;

444

skb->protocol = eth_type_trans(skb, dev);

449

skb->protocol = eth_type_trans(skb, dev);

445

netif_rx(skb);

450

netif_rx(skb);

446

dev->stats.rx_packets++;

451

dev->stats.rx_packets++;

447

dev->stats.rx_bytes += pkt_len-4;

452

dev->stats.rx_bytes += pkt_len-4;

448

#endif

453

#endif

449

}

454

}

450

}

455

}

451

456

452

/*

457

/*

453

* This is called to actually send a packet to the chip.

458

* This is called to actually send a packet to the chip.

454

*/

459

*/

455

static void smc911x_hardware_send_pkt(struct net_device *dev)

460

static void smc911x_hardware_send_pkt(struct net_device *dev)

456

{

461

{

457

struct smc911x_local *lp = netdev_priv(dev);

462

struct smc911x_local *lp = netdev_priv(dev);

458

struct sk_buff *skb;

463

struct sk_buff *skb;

459

unsigned int cmdA, cmdB, len;

464

unsigned int cmdA, cmdB, len;

460

unsigned char *buf;

465

unsigned char *buf;

461

unsigned long flags;

466

unsigned long flags;

462

467

463

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n", dev->name, __func__);

468

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n", dev->name, __func__);

464

BUG_ON(lp->pending_tx_skb == NULL);

469

BUG_ON(lp->pending_tx_skb == NULL);

465

470

466

skb = lp->pending_tx_skb;

471

skb = lp->pending_tx_skb;

467

lp->pending_tx_skb = NULL;

472

lp->pending_tx_skb = NULL;

468

473

469

/* cmdA {25:24] data alignment [20:16] start offset [10:0] buffer length */

474

/* cmdA {25:24] data alignment [20:16] start offset [10:0] buffer length */

470

/* cmdB {31:16] pkt tag [10:0] length */

475

/* cmdB {31:16] pkt tag [10:0] length */

471

#ifdef SMC_USE_DMA

476

#ifdef SMC_USE_DMA

472

/* 16 byte buffer alignment mode */

477

/* 16 byte buffer alignment mode */

473

buf = (char*)((u32)(skb->data) & ~0xF);

478

buf = (char*)((u32)(skb->data) & ~0xF);

474

len = (skb->len + 0xF + ((u32)skb->data & 0xF)) & ~0xF;

479

len = (skb->len + 0xF + ((u32)skb->data & 0xF)) & ~0xF;

475

cmdA = (1<<24) | (((u32)skb->data & 0xF)<<16) |

480

cmdA = (1<<24) | (((u32)skb->data & 0xF)<<16) |

476

TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ |

481

TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ |

477

skb->len;

482

skb->len;

478

#else

483

#else

479

buf = (char*)((u32)skb->data & ~0x3);

484

buf = (char*)((u32)skb->data & ~0x3);

480

len = (skb->len + 3 + ((u32)skb->data & 3)) & ~0x3;

485

len = (skb->len + 3 + ((u32)skb->data & 3)) & ~0x3;

481

cmdA = (((u32)skb->data & 0x3) << 16) |

486

cmdA = (((u32)skb->data & 0x3) << 16) |

482

TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ |

487

TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ |

483

skb->len;

488

skb->len;

484

#endif

489

#endif

485

/* tag is packet length so we can use this in stats update later */

490

/* tag is packet length so we can use this in stats update later */

486

cmdB = (skb->len << 16) | (skb->len & 0x7FF);

491

cmdB = (skb->len << 16) | (skb->len & 0x7FF);

487

492

488

DBG(SMC_DEBUG_TX, "%s: TX PKT LENGTH 0x%04x (%d) BUF 0x%p CMDA 0x%08x CMDB 0x%08x\n",

493

DBG(SMC_DEBUG_TX, "%s: TX PKT LENGTH 0x%04x (%d) BUF 0x%p CMDA 0x%08x CMDB 0x%08x\n",

489

dev->name, len, len, buf, cmdA, cmdB);

494

dev->name, len, len, buf, cmdA, cmdB);

490

SMC_SET_TX_FIFO(lp, cmdA);

495

SMC_SET_TX_FIFO(lp, cmdA);

491

SMC_SET_TX_FIFO(lp, cmdB);

496

SMC_SET_TX_FIFO(lp, cmdB);

492

497

493

DBG(SMC_DEBUG_PKTS, "%s: Transmitted packet\n", dev->name);

498

DBG(SMC_DEBUG_PKTS, "%s: Transmitted packet\n", dev->name);

494

PRINT_PKT(buf, len <= 64 ? len : 64);

499

PRINT_PKT(buf, len <= 64 ? len : 64);

495

500

496

/* Send pkt via PIO or DMA */

501

/* Send pkt via PIO or DMA */

497

#ifdef SMC_USE_DMA

502

#ifdef SMC_USE_DMA

498

lp->current_tx_skb = skb;

503

lp->current_tx_skb = skb;

499

SMC_PUSH_DATA(lp, buf, len);

504

SMC_PUSH_DATA(lp, buf, len);

500

/* DMA complete IRQ will free buffer and set jiffies */

505

/* DMA complete IRQ will free buffer and set jiffies */

501

#else

506

#else

502

SMC_PUSH_DATA(lp, buf, len);

507

SMC_PUSH_DATA(lp, buf, len);

503

dev->trans_start = jiffies;

508

dev->trans_start = jiffies;

504

dev_kfree_skb(skb);

509

dev_kfree_skb(skb);

505

#endif

510

#endif

506

spin_lock_irqsave(&lp->lock, flags);

511

spin_lock_irqsave(&lp->lock, flags);

507

if (!lp->tx_throttle) {

512

if (!lp->tx_throttle) {

508

netif_wake_queue(dev);

513

netif_wake_queue(dev);

509

}

514

}

510

spin_unlock_irqrestore(&lp->lock, flags);

515

spin_unlock_irqrestore(&lp->lock, flags);

511

SMC_ENABLE_INT(lp, INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_);

516

SMC_ENABLE_INT(lp, INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_);

512

}

517

}

513

518

514

/*

519

/*

515

* Since I am not sure if I will have enough room in the chip's ram

520

* Since I am not sure if I will have enough room in the chip's ram

516

* to store the packet, I call this routine which either sends it

521

* to store the packet, I call this routine which either sends it

517

* now, or set the card to generates an interrupt when ready

522

* now, or set the card to generates an interrupt when ready

518

* for the packet.

523

* for the packet.

519

*/

524

*/

520

static int smc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)

525

static int smc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)

521

{

526

{

522

struct smc911x_local *lp = netdev_priv(dev);

527

struct smc911x_local *lp = netdev_priv(dev);

523

unsigned int free;

528

unsigned int free;

524

unsigned long flags;

529

unsigned long flags;

525

530

526

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n",

531

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n",

527

dev->name, __func__);

532

dev->name, __func__);

528

533

529

BUG_ON(lp->pending_tx_skb != NULL);

534

BUG_ON(lp->pending_tx_skb != NULL);

530

535

531

free = SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TDFREE_;

536

free = SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TDFREE_;

532

DBG(SMC_DEBUG_TX, "%s: TX free space %d\n", dev->name, free);

537

DBG(SMC_DEBUG_TX, "%s: TX free space %d\n", dev->name, free);

533

538

534

/* Turn off the flow when running out of space in FIFO */

539

/* Turn off the flow when running out of space in FIFO */

535

if (free <= SMC911X_TX_FIFO_LOW_THRESHOLD) {

540

if (free <= SMC911X_TX_FIFO_LOW_THRESHOLD) {

536

DBG(SMC_DEBUG_TX, "%s: Disabling data flow due to low FIFO space (%d)\n",

541

DBG(SMC_DEBUG_TX, "%s: Disabling data flow due to low FIFO space (%d)\n",

537

dev->name, free);

542

dev->name, free);

538

spin_lock_irqsave(&lp->lock, flags);

543

spin_lock_irqsave(&lp->lock, flags);

539

/* Reenable when at least 1 packet of size MTU present */

544

/* Reenable when at least 1 packet of size MTU present */

540

SMC_SET_FIFO_TDA(lp, (SMC911X_TX_FIFO_LOW_THRESHOLD)/64);

545

SMC_SET_FIFO_TDA(lp, (SMC911X_TX_FIFO_LOW_THRESHOLD)/64);

541

lp->tx_throttle = 1;

546

lp->tx_throttle = 1;

542

netif_stop_queue(dev);

547

netif_stop_queue(dev);

543

spin_unlock_irqrestore(&lp->lock, flags);

548

spin_unlock_irqrestore(&lp->lock, flags);

544

}

549

}

545

550

546

/* Drop packets when we run out of space in TX FIFO

551

/* Drop packets when we run out of space in TX FIFO

547

* Account for overhead required for:

552

* Account for overhead required for:

548

*

553

*

549

* Tx command words 8 bytes

554

* Tx command words 8 bytes

550

* Start offset 15 bytes

555

* Start offset 15 bytes

551

* End padding 15 bytes

556

* End padding 15 bytes

552

*/

557

*/

553

if (unlikely(free < (skb->len + 8 + 15 + 15))) {

558

if (unlikely(free < (skb->len + 8 + 15 + 15))) {

554

printk("%s: No Tx free space %d < %d\n",

559

printk("%s: No Tx free space %d < %d\n",

555

dev->name, free, skb->len);

560

dev->name, free, skb->len);

556

lp->pending_tx_skb = NULL;

561

lp->pending_tx_skb = NULL;

557

dev->stats.tx_errors++;

562

dev->stats.tx_errors++;

558

dev->stats.tx_dropped++;

563

dev->stats.tx_dropped++;

559

dev_kfree_skb(skb);

564

dev_kfree_skb(skb);

560

return 0;

565

return 0;

561

}

566

}

562

567

563

#ifdef SMC_USE_DMA

568

#ifdef SMC_USE_DMA

564

{

569

{

565

/* If the DMA is already running then defer this packet Tx until

570

/* If the DMA is already running then defer this packet Tx until

566

* the DMA IRQ starts it

571

* the DMA IRQ starts it

567

*/

572

*/

568

spin_lock_irqsave(&lp->lock, flags);

573

spin_lock_irqsave(&lp->lock, flags);

569

if (lp->txdma_active) {

574

if (lp->txdma_active) {

570

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Tx DMA running, deferring packet\n", dev->name);

575

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Tx DMA running, deferring packet\n", dev->name);

571

lp->pending_tx_skb = skb;

576

lp->pending_tx_skb = skb;

572

netif_stop_queue(dev);

577

netif_stop_queue(dev);

573

spin_unlock_irqrestore(&lp->lock, flags);

578

spin_unlock_irqrestore(&lp->lock, flags);

574

return 0;

579

return 0;

575

} else {

580

} else {

576

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Activating Tx DMA\n", dev->name);

581

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Activating Tx DMA\n", dev->name);

577

lp->txdma_active = 1;

582

lp->txdma_active = 1;

578

}

583

}

579

spin_unlock_irqrestore(&lp->lock, flags);

584

spin_unlock_irqrestore(&lp->lock, flags);

580

}

585

}

581

#endif

586

#endif

582

lp->pending_tx_skb = skb;

587

lp->pending_tx_skb = skb;

583

smc911x_hardware_send_pkt(dev);

588

smc911x_hardware_send_pkt(dev);

584

589

585

return 0;

590

return 0;

586

}

591

}

587

592

588

/*

593

/*

589

* This handles a TX status interrupt, which is only called when:

594

* This handles a TX status interrupt, which is only called when:

590

* - a TX error occurred, or

595

* - a TX error occurred, or

591

* - TX of a packet completed.

596

* - TX of a packet completed.

592

*/

597

*/

593

static void smc911x_tx(struct net_device *dev)

598

static void smc911x_tx(struct net_device *dev)

594

{

599

{

595

struct smc911x_local *lp = netdev_priv(dev);

600

struct smc911x_local *lp = netdev_priv(dev);

596

unsigned int tx_status;

601

unsigned int tx_status;

597

602

598

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n",

603

DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n",

599

dev->name, __func__);

604

dev->name, __func__);

600

605

601

/* Collect the TX status */

606

/* Collect the TX status */

602

while (((SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16) != 0) {

607

while (((SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16) != 0) {

603

DBG(SMC_DEBUG_TX, "%s: Tx stat FIFO used 0x%04x\n",

608

DBG(SMC_DEBUG_TX, "%s: Tx stat FIFO used 0x%04x\n",

604

dev->name,

609

dev->name,

605

(SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16);

610

(SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16);

606

tx_status = SMC_GET_TX_STS_FIFO(lp);

611

tx_status = SMC_GET_TX_STS_FIFO(lp);

607

dev->stats.tx_packets++;

612

dev->stats.tx_packets++;

608

dev->stats.tx_bytes+=tx_status>>16;

613

dev->stats.tx_bytes+=tx_status>>16;

609

DBG(SMC_DEBUG_TX, "%s: Tx FIFO tag 0x%04x status 0x%04x\n",

614

DBG(SMC_DEBUG_TX, "%s: Tx FIFO tag 0x%04x status 0x%04x\n",

610

dev->name, (tx_status & 0xffff0000) >> 16,

615

dev->name, (tx_status & 0xffff0000) >> 16,

611

tx_status & 0x0000ffff);

616

tx_status & 0x0000ffff);

612

/* count Tx errors, but ignore lost carrier errors when in

617

/* count Tx errors, but ignore lost carrier errors when in

613

* full-duplex mode */

618

* full-duplex mode */

614

if ((tx_status & TX_STS_ES_) && !(lp->ctl_rfduplx &&

619

if ((tx_status & TX_STS_ES_) && !(lp->ctl_rfduplx &&

615

!(tx_status & 0x00000306))) {

620

!(tx_status & 0x00000306))) {

616

dev->stats.tx_errors++;

621

dev->stats.tx_errors++;

617

}

622

}

618

if (tx_status & TX_STS_MANY_COLL_) {

623

if (tx_status & TX_STS_MANY_COLL_) {

619

dev->stats.collisions+=16;

624

dev->stats.collisions+=16;

620

dev->stats.tx_aborted_errors++;

625

dev->stats.tx_aborted_errors++;

621

} else {

626

} else {

622

dev->stats.collisions+=(tx_status & TX_STS_COLL_CNT_) >> 3;

627

dev->stats.collisions+=(tx_status & TX_STS_COLL_CNT_) >> 3;

623

}

628

}

624

/* carrier error only has meaning for half-duplex communication */

629

/* carrier error only has meaning for half-duplex communication */

625

if ((tx_status & (TX_STS_LOC_ | TX_STS_NO_CARR_)) &&

630

if ((tx_status & (TX_STS_LOC_ | TX_STS_NO_CARR_)) &&

626

!lp->ctl_rfduplx) {

631

!lp->ctl_rfduplx) {

627

dev->stats.tx_carrier_errors++;

632

dev->stats.tx_carrier_errors++;

628

}

633

}

629

if (tx_status & TX_STS_LATE_COLL_) {

634

if (tx_status & TX_STS_LATE_COLL_) {

630

dev->stats.collisions++;

635

dev->stats.collisions++;

631

dev->stats.tx_aborted_errors++;

636

dev->stats.tx_aborted_errors++;

632

}

637

}

633

}

638

}

634

}

639

}

635

640

636

641

637

/*---PHY CONTROL AND CONFIGURATION-----------------------------------------*/

642

/*---PHY CONTROL AND CONFIGURATION-----------------------------------------*/

638

/*

643

/*

639

* Reads a register from the MII Management serial interface

644

* Reads a register from the MII Management serial interface

640

*/

645

*/

641

646

642

static int smc911x_phy_read(struct net_device *dev, int phyaddr, int phyreg)

647

static int smc911x_phy_read(struct net_device *dev, int phyaddr, int phyreg)

643

{

648

{

644

struct smc911x_local *lp = netdev_priv(dev);

649

struct smc911x_local *lp = netdev_priv(dev);

645

unsigned int phydata;

650

unsigned int phydata;

646

651

647

SMC_GET_MII(lp, phyreg, phyaddr, phydata);

652

SMC_GET_MII(lp, phyreg, phyaddr, phydata);

648

653

649

DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%02x, phydata=0x%04x\n",

654

DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%02x, phydata=0x%04x\n",

650

__func__, phyaddr, phyreg, phydata);

655

__func__, phyaddr, phyreg, phydata);

651

return phydata;

656

return phydata;

652

}

657

}

653

658

654

659

655

/*

660

/*

656

* Writes a register to the MII Management serial interface

661

* Writes a register to the MII Management serial interface

657

*/

662

*/

658

static void smc911x_phy_write(struct net_device *dev, int phyaddr, int phyreg,

663

static void smc911x_phy_write(struct net_device *dev, int phyaddr, int phyreg,

659

int phydata)

664

int phydata)

660

{

665

{

661

struct smc911x_local *lp = netdev_priv(dev);

666

struct smc911x_local *lp = netdev_priv(dev);

662

667

663

DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n",

668

DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n",

664

__func__, phyaddr, phyreg, phydata);

669

__func__, phyaddr, phyreg, phydata);

665

670

666

SMC_SET_MII(lp, phyreg, phyaddr, phydata);

671

SMC_SET_MII(lp, phyreg, phyaddr, phydata);

667

}

672

}

668

673

669

/*

674

/*

670

* Finds and reports the PHY address (115 and 117 have external

675

* Finds and reports the PHY address (115 and 117 have external

671

* PHY interface 118 has internal only

676

* PHY interface 118 has internal only

672

*/

677

*/

673

static void smc911x_phy_detect(struct net_device *dev)

678

static void smc911x_phy_detect(struct net_device *dev)

674

{

679

{

675

struct smc911x_local *lp = netdev_priv(dev);

680

struct smc911x_local *lp = netdev_priv(dev);

676

int phyaddr;

681

int phyaddr;

677

unsigned int cfg, id1, id2;

682

unsigned int cfg, id1, id2;

678

683

679

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

684

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

680

685

681

lp->phy_type = 0;

686

lp->phy_type = 0;

682

687

683

/*

688

/*

684

* Scan all 32 PHY addresses if necessary, starting at

689

* Scan all 32 PHY addresses if necessary, starting at

685

* PHY#1 to PHY#31, and then PHY#0 last.

690

* PHY#1 to PHY#31, and then PHY#0 last.

686

*/

691

*/

687

switch(lp->version) {

692

switch(lp->version) {

688

case CHIP_9115:

693

case CHIP_9115:

689

case CHIP_9117:

694

case CHIP_9117:

690

case CHIP_9215:

695

case CHIP_9215:

691

case CHIP_9217:

696

case CHIP_9217:

692

cfg = SMC_GET_HW_CFG(lp);

697

cfg = SMC_GET_HW_CFG(lp);

693

if (cfg & HW_CFG_EXT_PHY_DET_) {

698

if (cfg & HW_CFG_EXT_PHY_DET_) {

694

cfg &= ~HW_CFG_PHY_CLK_SEL_;

699

cfg &= ~HW_CFG_PHY_CLK_SEL_;

695

cfg |= HW_CFG_PHY_CLK_SEL_CLK_DIS_;

700

cfg |= HW_CFG_PHY_CLK_SEL_CLK_DIS_;

696

SMC_SET_HW_CFG(lp, cfg);

701

SMC_SET_HW_CFG(lp, cfg);

697

udelay(10); /* Wait for clocks to stop */

702

udelay(10); /* Wait for clocks to stop */

698

703

699

cfg |= HW_CFG_EXT_PHY_EN_;

704

cfg |= HW_CFG_EXT_PHY_EN_;

700

SMC_SET_HW_CFG(lp, cfg);

705

SMC_SET_HW_CFG(lp, cfg);

701

udelay(10); /* Wait for clocks to stop */

706

udelay(10); /* Wait for clocks to stop */

702

707

703

cfg &= ~HW_CFG_PHY_CLK_SEL_;

708

cfg &= ~HW_CFG_PHY_CLK_SEL_;

704

cfg |= HW_CFG_PHY_CLK_SEL_EXT_PHY_;

709

cfg |= HW_CFG_PHY_CLK_SEL_EXT_PHY_;

705

SMC_SET_HW_CFG(lp, cfg);

710

SMC_SET_HW_CFG(lp, cfg);

706

udelay(10); /* Wait for clocks to stop */

711

udelay(10); /* Wait for clocks to stop */

707

712

708

cfg |= HW_CFG_SMI_SEL_;

713

cfg |= HW_CFG_SMI_SEL_;

709

SMC_SET_HW_CFG(lp, cfg);

714

SMC_SET_HW_CFG(lp, cfg);

710

715

711

for (phyaddr = 1; phyaddr < 32; ++phyaddr) {

716

for (phyaddr = 1; phyaddr < 32; ++phyaddr) {

712

717

713

/* Read the PHY identifiers */

718

/* Read the PHY identifiers */

714

SMC_GET_PHY_ID1(lp, phyaddr & 31, id1);

719

SMC_GET_PHY_ID1(lp, phyaddr & 31, id1);

715

SMC_GET_PHY_ID2(lp, phyaddr & 31, id2);

720

SMC_GET_PHY_ID2(lp, phyaddr & 31, id2);

716

721

717

/* Make sure it is a valid identifier */

722

/* Make sure it is a valid identifier */

718

if (id1 != 0x0000 && id1 != 0xffff &&

723

if (id1 != 0x0000 && id1 != 0xffff &&

719

id1 != 0x8000 && id2 != 0x0000 &&

724

id1 != 0x8000 && id2 != 0x0000 &&

720

id2 != 0xffff && id2 != 0x8000) {

725

id2 != 0xffff && id2 != 0x8000) {

721

/* Save the PHY's address */

726

/* Save the PHY's address */

722

lp->mii.phy_id = phyaddr & 31;

727

lp->mii.phy_id = phyaddr & 31;

723

lp->phy_type = id1 << 16 | id2;

728

lp->phy_type = id1 << 16 | id2;

724

break;

729

break;

725

}

730

}

726

}

731

}

727

if (phyaddr < 32)

732

if (phyaddr < 32)

728

/* Found an external PHY */

733

/* Found an external PHY */

729

break;

734

break;

730

}

735

}

731

default:

736

default:

732

/* Internal media only */

737

/* Internal media only */

733

SMC_GET_PHY_ID1(lp, 1, id1);

738

SMC_GET_PHY_ID1(lp, 1, id1);

734

SMC_GET_PHY_ID2(lp, 1, id2);

739

SMC_GET_PHY_ID2(lp, 1, id2);

735

/* Save the PHY's address */

740

/* Save the PHY's address */

736

lp->mii.phy_id = 1;

741

lp->mii.phy_id = 1;

737

lp->phy_type = id1 << 16 | id2;

742

lp->phy_type = id1 << 16 | id2;

738

}

743

}

739

744

740

DBG(SMC_DEBUG_MISC, "%s: phy_id1=0x%x, phy_id2=0x%x phyaddr=0x%d\n",

745

DBG(SMC_DEBUG_MISC, "%s: phy_id1=0x%x, phy_id2=0x%x phyaddr=0x%d\n",

741

dev->name, id1, id2, lp->mii.phy_id);

746

dev->name, id1, id2, lp->mii.phy_id);

742

}

747

}

743

748

744

/*

749

/*

745

* Sets the PHY to a configuration as determined by the user.

750

* Sets the PHY to a configuration as determined by the user.

746

* Called with spin_lock held.

751

* Called with spin_lock held.

747

*/

752

*/

748

static int smc911x_phy_fixed(struct net_device *dev)

753

static int smc911x_phy_fixed(struct net_device *dev)

749

{

754

{

750

struct smc911x_local *lp = netdev_priv(dev);

755

struct smc911x_local *lp = netdev_priv(dev);

751

int phyaddr = lp->mii.phy_id;

756

int phyaddr = lp->mii.phy_id;

752

int bmcr;

757

int bmcr;

753

758

754

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

759

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

755

760

756

/* Enter Link Disable state */

761

/* Enter Link Disable state */

757

SMC_GET_PHY_BMCR(lp, phyaddr, bmcr);

762

SMC_GET_PHY_BMCR(lp, phyaddr, bmcr);

758

bmcr |= BMCR_PDOWN;

763

bmcr |= BMCR_PDOWN;

759

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

764

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

760

765

761

/*

766

/*

762

* Set our fixed capabilities

767

* Set our fixed capabilities

763

* Disable auto-negotiation

768

* Disable auto-negotiation

764

*/

769

*/

765

bmcr &= ~BMCR_ANENABLE;

770

bmcr &= ~BMCR_ANENABLE;

766

if (lp->ctl_rfduplx)

771

if (lp->ctl_rfduplx)

767

bmcr |= BMCR_FULLDPLX;

772

bmcr |= BMCR_FULLDPLX;

768

773

769

if (lp->ctl_rspeed == 100)

774

if (lp->ctl_rspeed == 100)

770

bmcr |= BMCR_SPEED100;

775

bmcr |= BMCR_SPEED100;

771

776

772

/* Write our capabilities to the phy control register */

777

/* Write our capabilities to the phy control register */

773

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

778

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

774

779

775

/* Re-Configure the Receive/Phy Control register */

780

/* Re-Configure the Receive/Phy Control register */

776

bmcr &= ~BMCR_PDOWN;

781

bmcr &= ~BMCR_PDOWN;

777

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

782

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

778

783

779

return 1;

784

return 1;

780

}

785

}

781

786

782

/*

787

/*

783

* smc911x_phy_reset - reset the phy

788

* smc911x_phy_reset - reset the phy

784

* @dev: net device

789

* @dev: net device

785

* @phy: phy address

790

* @phy: phy address

786

*

791

*

787

* Issue a software reset for the specified PHY and

792

* Issue a software reset for the specified PHY and

788

* wait up to 100ms for the reset to complete. We should

793

* wait up to 100ms for the reset to complete. We should

789

* not access the PHY for 50ms after issuing the reset.

794

* not access the PHY for 50ms after issuing the reset.

790

*

795

*

791

* The time to wait appears to be dependent on the PHY.

796

* The time to wait appears to be dependent on the PHY.

792

*

797

*

793

*/

798

*/

794

static int smc911x_phy_reset(struct net_device *dev, int phy)

799

static int smc911x_phy_reset(struct net_device *dev, int phy)

795

{

800

{

796

struct smc911x_local *lp = netdev_priv(dev);

801

struct smc911x_local *lp = netdev_priv(dev);

797

int timeout;

802

int timeout;

798

unsigned long flags;

803

unsigned long flags;

799

unsigned int reg;

804

unsigned int reg;

800

805

801

DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__);

806

DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__);

802

807

803

spin_lock_irqsave(&lp->lock, flags);

808

spin_lock_irqsave(&lp->lock, flags);

804

reg = SMC_GET_PMT_CTRL(lp);

809

reg = SMC_GET_PMT_CTRL(lp);

805

reg &= ~0xfffff030;

810

reg &= ~0xfffff030;

806

reg |= PMT_CTRL_PHY_RST_;

811

reg |= PMT_CTRL_PHY_RST_;

807

SMC_SET_PMT_CTRL(lp, reg);

812

SMC_SET_PMT_CTRL(lp, reg);

808

spin_unlock_irqrestore(&lp->lock, flags);

813

spin_unlock_irqrestore(&lp->lock, flags);

809

for (timeout = 2; timeout; timeout--) {

814

for (timeout = 2; timeout; timeout--) {

810

msleep(50);

815

msleep(50);

811

spin_lock_irqsave(&lp->lock, flags);

816

spin_lock_irqsave(&lp->lock, flags);

812

reg = SMC_GET_PMT_CTRL(lp);

817

reg = SMC_GET_PMT_CTRL(lp);

813

spin_unlock_irqrestore(&lp->lock, flags);

818

spin_unlock_irqrestore(&lp->lock, flags);

814

if (!(reg & PMT_CTRL_PHY_RST_)) {

819

if (!(reg & PMT_CTRL_PHY_RST_)) {

815

/* extra delay required because the phy may

820

/* extra delay required because the phy may

816

* not be completed with its reset

821

* not be completed with its reset

817

* when PHY_BCR_RESET_ is cleared. 256us

822

* when PHY_BCR_RESET_ is cleared. 256us

818

* should suffice, but use 500us to be safe

823

* should suffice, but use 500us to be safe

819

*/

824

*/

820

udelay(500);

825

udelay(500);

821

break;

826

break;

822

}

827

}

823

}

828

}

824

829

825

return reg & PMT_CTRL_PHY_RST_;

830

return reg & PMT_CTRL_PHY_RST_;

826

}

831

}

827

832

828

/*

833

/*

829

* smc911x_phy_powerdown - powerdown phy

834

* smc911x_phy_powerdown - powerdown phy

830

* @dev: net device

835

* @dev: net device

831

* @phy: phy address

836

* @phy: phy address

832

*

837

*

833

* Power down the specified PHY

838

* Power down the specified PHY

834

*/

839

*/

835

static void smc911x_phy_powerdown(struct net_device *dev, int phy)

840

static void smc911x_phy_powerdown(struct net_device *dev, int phy)

836

{

841

{

837

struct smc911x_local *lp = netdev_priv(dev);

842

struct smc911x_local *lp = netdev_priv(dev);

838

unsigned int bmcr;

843

unsigned int bmcr;

839

844

840

/* Enter Link Disable state */

845

/* Enter Link Disable state */

841

SMC_GET_PHY_BMCR(lp, phy, bmcr);

846

SMC_GET_PHY_BMCR(lp, phy, bmcr);

842

bmcr |= BMCR_PDOWN;

847

bmcr |= BMCR_PDOWN;

843

SMC_SET_PHY_BMCR(lp, phy, bmcr);

848

SMC_SET_PHY_BMCR(lp, phy, bmcr);

844

}

849

}

845

850

846

/*

851

/*

847

* smc911x_phy_check_media - check the media status and adjust BMCR

852

* smc911x_phy_check_media - check the media status and adjust BMCR

848

* @dev: net device

853

* @dev: net device

849

* @init: set true for initialisation

854

* @init: set true for initialisation

850

*

855

*

851

* Select duplex mode depending on negotiation state. This

856

* Select duplex mode depending on negotiation state. This

852

* also updates our carrier state.

857

* also updates our carrier state.

853

*/

858

*/

854

static void smc911x_phy_check_media(struct net_device *dev, int init)

859

static void smc911x_phy_check_media(struct net_device *dev, int init)

855

{

860

{

856

struct smc911x_local *lp = netdev_priv(dev);

861

struct smc911x_local *lp = netdev_priv(dev);

857

int phyaddr = lp->mii.phy_id;

862

int phyaddr = lp->mii.phy_id;

858

unsigned int bmcr, cr;

863

unsigned int bmcr, cr;

859

864

860

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

865

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

861

866

862

if (mii_check_media(&lp->mii, netif_msg_link(lp), init)) {

867

if (mii_check_media(&lp->mii, netif_msg_link(lp), init)) {

863

/* duplex state has changed */

868

/* duplex state has changed */

864

SMC_GET_PHY_BMCR(lp, phyaddr, bmcr);

869

SMC_GET_PHY_BMCR(lp, phyaddr, bmcr);

865

SMC_GET_MAC_CR(lp, cr);

870

SMC_GET_MAC_CR(lp, cr);

866

if (lp->mii.full_duplex) {

871

if (lp->mii.full_duplex) {

867

DBG(SMC_DEBUG_MISC, "%s: Configuring for full-duplex mode\n", dev->name);

872

DBG(SMC_DEBUG_MISC, "%s: Configuring for full-duplex mode\n", dev->name);

868

bmcr |= BMCR_FULLDPLX;

873

bmcr |= BMCR_FULLDPLX;

869

cr |= MAC_CR_RCVOWN_;

874

cr |= MAC_CR_RCVOWN_;

870

} else {

875

} else {

871

DBG(SMC_DEBUG_MISC, "%s: Configuring for half-duplex mode\n", dev->name);

876

DBG(SMC_DEBUG_MISC, "%s: Configuring for half-duplex mode\n", dev->name);

872

bmcr &= ~BMCR_FULLDPLX;

877

bmcr &= ~BMCR_FULLDPLX;

873

cr &= ~MAC_CR_RCVOWN_;

878

cr &= ~MAC_CR_RCVOWN_;

874

}

879

}

875

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

880

SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);

876

SMC_SET_MAC_CR(lp, cr);

881

SMC_SET_MAC_CR(lp, cr);

877

}

882

}

878

}

883

}

879

884

880

/*

885

/*

881

* Configures the specified PHY through the MII management interface

886

* Configures the specified PHY through the MII management interface

882

* using Autonegotiation.

887

* using Autonegotiation.

883

* Calls smc911x_phy_fixed() if the user has requested a certain config.

888

* Calls smc911x_phy_fixed() if the user has requested a certain config.

884

* If RPC ANEG bit is set, the media selection is dependent purely on

889

* If RPC ANEG bit is set, the media selection is dependent purely on

885

* the selection by the MII (either in the MII BMCR reg or the result

890

* the selection by the MII (either in the MII BMCR reg or the result

886

* of autonegotiation.) If the RPC ANEG bit is cleared, the selection

891

* of autonegotiation.) If the RPC ANEG bit is cleared, the selection

887

* is controlled by the RPC SPEED and RPC DPLX bits.

892

* is controlled by the RPC SPEED and RPC DPLX bits.

888

*/

893

*/

889

static void smc911x_phy_configure(struct work_struct *work)

894

static void smc911x_phy_configure(struct work_struct *work)

890

{

895

{

891

struct smc911x_local *lp = container_of(work, struct smc911x_local,

896

struct smc911x_local *lp = container_of(work, struct smc911x_local,

892

phy_configure);

897

phy_configure);

893

struct net_device *dev = lp->netdev;

898

struct net_device *dev = lp->netdev;

894

int phyaddr = lp->mii.phy_id;

899

int phyaddr = lp->mii.phy_id;

895

int my_phy_caps; /* My PHY capabilities */

900

int my_phy_caps; /* My PHY capabilities */

896

int my_ad_caps; /* My Advertised capabilities */

901

int my_ad_caps; /* My Advertised capabilities */

897

int status;

902

int status;

898

unsigned long flags;

903

unsigned long flags;

899

904

900

DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__);

905

DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__);

901

906

902

/*

907

/*

903

* We should not be called if phy_type is zero.

908

* We should not be called if phy_type is zero.

904

*/

909

*/

905

if (lp->phy_type == 0)

910

if (lp->phy_type == 0)

906

return;

911

return;

907

912

908

if (smc911x_phy_reset(dev, phyaddr)) {

913

if (smc911x_phy_reset(dev, phyaddr)) {

909

printk("%s: PHY reset timed out\n", dev->name);

914

printk("%s: PHY reset timed out\n", dev->name);

910

return;

915

return;

911

}

916

}

912

spin_lock_irqsave(&lp->lock, flags);

917

spin_lock_irqsave(&lp->lock, flags);

913

918

914

/*

919

/*

915

* Enable PHY Interrupts (for register 18)

920

* Enable PHY Interrupts (for register 18)

916

* Interrupts listed here are enabled

921

* Interrupts listed here are enabled

917

*/

922

*/

918

SMC_SET_PHY_INT_MASK(lp, phyaddr, PHY_INT_MASK_ENERGY_ON_ |

923

SMC_SET_PHY_INT_MASK(lp, phyaddr, PHY_INT_MASK_ENERGY_ON_ |

919

PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_REMOTE_FAULT_ |

924

PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_REMOTE_FAULT_ |

920

PHY_INT_MASK_LINK_DOWN_);

925

PHY_INT_MASK_LINK_DOWN_);

921

926

922

/* If the user requested no auto neg, then go set his request */

927

/* If the user requested no auto neg, then go set his request */

923

if (lp->mii.force_media) {

928

if (lp->mii.force_media) {

924

smc911x_phy_fixed(dev);

929

smc911x_phy_fixed(dev);

925

goto smc911x_phy_configure_exit;

930

goto smc911x_phy_configure_exit;

926

}

931

}

927

932

928

/* Copy our capabilities from MII_BMSR to MII_ADVERTISE */

933

/* Copy our capabilities from MII_BMSR to MII_ADVERTISE */

929

SMC_GET_PHY_BMSR(lp, phyaddr, my_phy_caps);

934

SMC_GET_PHY_BMSR(lp, phyaddr, my_phy_caps);

930

if (!(my_phy_caps & BMSR_ANEGCAPABLE)) {

935

if (!(my_phy_caps & BMSR_ANEGCAPABLE)) {

931

printk(KERN_INFO "Auto negotiation NOT supported\n");

936

printk(KERN_INFO "Auto negotiation NOT supported\n");

932

smc911x_phy_fixed(dev);

937

smc911x_phy_fixed(dev);

933

goto smc911x_phy_configure_exit;

938

goto smc911x_phy_configure_exit;

934

}

939

}

935

940

936

/* CSMA capable w/ both pauses */

941

/* CSMA capable w/ both pauses */

937

my_ad_caps = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;

942

my_ad_caps = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;

938

943

939

if (my_phy_caps & BMSR_100BASE4)

944

if (my_phy_caps & BMSR_100BASE4)

940

my_ad_caps |= ADVERTISE_100BASE4;

945

my_ad_caps |= ADVERTISE_100BASE4;

941

if (my_phy_caps & BMSR_100FULL)

946

if (my_phy_caps & BMSR_100FULL)

942

my_ad_caps |= ADVERTISE_100FULL;

947

my_ad_caps |= ADVERTISE_100FULL;

943

if (my_phy_caps & BMSR_100HALF)

948

if (my_phy_caps & BMSR_100HALF)

944

my_ad_caps |= ADVERTISE_100HALF;

949

my_ad_caps |= ADVERTISE_100HALF;

945

if (my_phy_caps & BMSR_10FULL)

950

if (my_phy_caps & BMSR_10FULL)

946

my_ad_caps |= ADVERTISE_10FULL;

951

my_ad_caps |= ADVERTISE_10FULL;

947

if (my_phy_caps & BMSR_10HALF)

952

if (my_phy_caps & BMSR_10HALF)

948

my_ad_caps |= ADVERTISE_10HALF;

953

my_ad_caps |= ADVERTISE_10HALF;

949

954

950

/* Disable capabilities not selected by our user */

955

/* Disable capabilities not selected by our user */

951

if (lp->ctl_rspeed != 100)

956

if (lp->ctl_rspeed != 100)

952

my_ad_caps &= ~(ADVERTISE_100BASE4|ADVERTISE_100FULL|ADVERTISE_100HALF);

957

my_ad_caps &= ~(ADVERTISE_100BASE4|ADVERTISE_100FULL|ADVERTISE_100HALF);

953

958

954

if (!lp->ctl_rfduplx)

959

if (!lp->ctl_rfduplx)

955

my_ad_caps &= ~(ADVERTISE_100FULL|ADVERTISE_10FULL);

960

my_ad_caps &= ~(ADVERTISE_100FULL|ADVERTISE_10FULL);

956

961

957

/* Update our Auto-Neg Advertisement Register */

962

/* Update our Auto-Neg Advertisement Register */

958

SMC_SET_PHY_MII_ADV(lp, phyaddr, my_ad_caps);

963

SMC_SET_PHY_MII_ADV(lp, phyaddr, my_ad_caps);

959

lp->mii.advertising = my_ad_caps;

964

lp->mii.advertising = my_ad_caps;

960

965

961

/*

966

/*

962

* Read the register back. Without this, it appears that when

967

* Read the register back. Without this, it appears that when

963

* auto-negotiation is restarted, sometimes it isn't ready and

968

* auto-negotiation is restarted, sometimes it isn't ready and

964

* the link does not come up.

969

* the link does not come up.

965

*/

970

*/

966

udelay(10);

971

udelay(10);

967

SMC_GET_PHY_MII_ADV(lp, phyaddr, status);

972

SMC_GET_PHY_MII_ADV(lp, phyaddr, status);

968

973

969

DBG(SMC_DEBUG_MISC, "%s: phy caps=0x%04x\n", dev->name, my_phy_caps);

974

DBG(SMC_DEBUG_MISC, "%s: phy caps=0x%04x\n", dev->name, my_phy_caps);

970

DBG(SMC_DEBUG_MISC, "%s: phy advertised caps=0x%04x\n", dev->name, my_ad_caps);

975

DBG(SMC_DEBUG_MISC, "%s: phy advertised caps=0x%04x\n", dev->name, my_ad_caps);

971

976

972

/* Restart auto-negotiation process in order to advertise my caps */

977

/* Restart auto-negotiation process in order to advertise my caps */

973

SMC_SET_PHY_BMCR(lp, phyaddr, BMCR_ANENABLE | BMCR_ANRESTART);

978

SMC_SET_PHY_BMCR(lp, phyaddr, BMCR_ANENABLE | BMCR_ANRESTART);

974

979

975

smc911x_phy_check_media(dev, 1);

980

smc911x_phy_check_media(dev, 1);

976

981

977

smc911x_phy_configure_exit:

982

smc911x_phy_configure_exit:

978

spin_unlock_irqrestore(&lp->lock, flags);

983

spin_unlock_irqrestore(&lp->lock, flags);

979

}

984

}

980

985

981

/*

986

/*

982

* smc911x_phy_interrupt

987

* smc911x_phy_interrupt

983

*

988

*

984

* Purpose: Handle interrupts relating to PHY register 18. This is

989

* Purpose: Handle interrupts relating to PHY register 18. This is

985

* called from the "hard" interrupt handler under our private spinlock.

990

* called from the "hard" interrupt handler under our private spinlock.

986

*/

991

*/

987

static void smc911x_phy_interrupt(struct net_device *dev)

992

static void smc911x_phy_interrupt(struct net_device *dev)

988

{

993

{

989

struct smc911x_local *lp = netdev_priv(dev);

994

struct smc911x_local *lp = netdev_priv(dev);

990

int phyaddr = lp->mii.phy_id;

995

int phyaddr = lp->mii.phy_id;

991

int status;

996

int status;

992

997

993

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

998

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

994

999

995

if (lp->phy_type == 0)

1000

if (lp->phy_type == 0)

996

return;

1001

return;

997

1002

998

smc911x_phy_check_media(dev, 0);

1003

smc911x_phy_check_media(dev, 0);

999

/* read to clear status bits */

1004

/* read to clear status bits */

1000

SMC_GET_PHY_INT_SRC(lp, phyaddr,status);

1005

SMC_GET_PHY_INT_SRC(lp, phyaddr,status);

1001

DBG(SMC_DEBUG_MISC, "%s: PHY interrupt status 0x%04x\n",

1006

DBG(SMC_DEBUG_MISC, "%s: PHY interrupt status 0x%04x\n",

1002

dev->name, status & 0xffff);

1007

dev->name, status & 0xffff);

1003

DBG(SMC_DEBUG_MISC, "%s: AFC_CFG 0x%08x\n",

1008

DBG(SMC_DEBUG_MISC, "%s: AFC_CFG 0x%08x\n",

1004

dev->name, SMC_GET_AFC_CFG(lp));

1009

dev->name, SMC_GET_AFC_CFG(lp));

1005

}

1010

}

1006

1011

1007

/*--- END PHY CONTROL AND CONFIGURATION-------------------------------------*/

1012

/*--- END PHY CONTROL AND CONFIGURATION-------------------------------------*/

1008

1013

1009

/*

1014

/*

1010

* This is the main routine of the driver, to handle the device when

1015

* This is the main routine of the driver, to handle the device when

1011

* it needs some attention.

1016

* it needs some attention.

1012

*/

1017

*/

1013

static irqreturn_t smc911x_interrupt(int irq, void *dev_id)

1018

static irqreturn_t smc911x_interrupt(int irq, void *dev_id)

1014

{

1019

{

1015

struct net_device *dev = dev_id;

1020

struct net_device *dev = dev_id;

1016

struct smc911x_local *lp = netdev_priv(dev);

1021

struct smc911x_local *lp = netdev_priv(dev);

1017

unsigned int status, mask, timeout;

1022

unsigned int status, mask, timeout;

1018

unsigned int rx_overrun=0, cr, pkts;

1023

unsigned int rx_overrun=0, cr, pkts;

1019

unsigned long flags;

1024

unsigned long flags;

1020

1025

1021

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1026

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1022

1027

1023

spin_lock_irqsave(&lp->lock, flags);

1028

spin_lock_irqsave(&lp->lock, flags);

1024

1029

1025

/* Spurious interrupt check */

1030

/* Spurious interrupt check */

1026

if ((SMC_GET_IRQ_CFG(lp) & (INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) !=

1031

if ((SMC_GET_IRQ_CFG(lp) & (INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) !=

1027

(INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) {

1032

(INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) {

1028

spin_unlock_irqrestore(&lp->lock, flags);

1033

spin_unlock_irqrestore(&lp->lock, flags);

1029

return IRQ_NONE;

1034

return IRQ_NONE;

1030

}

1035

}

1031

1036

1032

mask = SMC_GET_INT_EN(lp);

1037

mask = SMC_GET_INT_EN(lp);

1033

SMC_SET_INT_EN(lp, 0);

1038

SMC_SET_INT_EN(lp, 0);

1034

1039

1035

/* set a timeout value, so I don't stay here forever */

1040

/* set a timeout value, so I don't stay here forever */

1036

timeout = 8;

1041

timeout = 8;

1037

1042

1038

1043

1039

do {

1044

do {

1040

status = SMC_GET_INT(lp);

1045

status = SMC_GET_INT(lp);

1041

1046

1042

DBG(SMC_DEBUG_MISC, "%s: INT 0x%08x MASK 0x%08x OUTSIDE MASK 0x%08x\n",

1047

DBG(SMC_DEBUG_MISC, "%s: INT 0x%08x MASK 0x%08x OUTSIDE MASK 0x%08x\n",

1043

dev->name, status, mask, status & ~mask);

1048

dev->name, status, mask, status & ~mask);

1044

1049

1045

status &= mask;

1050

status &= mask;

1046

if (!status)

1051

if (!status)

1047

break;

1052

break;

1048

1053

1049

/* Handle SW interrupt condition */

1054

/* Handle SW interrupt condition */

1050

if (status & INT_STS_SW_INT_) {

1055

if (status & INT_STS_SW_INT_) {

1051

SMC_ACK_INT(lp, INT_STS_SW_INT_);

1056

SMC_ACK_INT(lp, INT_STS_SW_INT_);

1052

mask &= ~INT_EN_SW_INT_EN_;

1057

mask &= ~INT_EN_SW_INT_EN_;

1053

}

1058

}

1054

/* Handle various error conditions */

1059

/* Handle various error conditions */

1055

if (status & INT_STS_RXE_) {

1060

if (status & INT_STS_RXE_) {

1056

SMC_ACK_INT(lp, INT_STS_RXE_);

1061

SMC_ACK_INT(lp, INT_STS_RXE_);

1057

dev->stats.rx_errors++;

1062

dev->stats.rx_errors++;

1058

}

1063

}

1059

if (status & INT_STS_RXDFH_INT_) {

1064

if (status & INT_STS_RXDFH_INT_) {

1060

SMC_ACK_INT(lp, INT_STS_RXDFH_INT_);

1065

SMC_ACK_INT(lp, INT_STS_RXDFH_INT_);

1061

dev->stats.rx_dropped+=SMC_GET_RX_DROP(lp);

1066

dev->stats.rx_dropped+=SMC_GET_RX_DROP(lp);

1062

}

1067

}

1063

/* Undocumented interrupt-what is the right thing to do here? */

1068

/* Undocumented interrupt-what is the right thing to do here? */

1064

if (status & INT_STS_RXDF_INT_) {

1069

if (status & INT_STS_RXDF_INT_) {

1065

SMC_ACK_INT(lp, INT_STS_RXDF_INT_);

1070

SMC_ACK_INT(lp, INT_STS_RXDF_INT_);

1066

}

1071

}

1067

1072

1068

/* Rx Data FIFO exceeds set level */

1073

/* Rx Data FIFO exceeds set level */

1069

if (status & INT_STS_RDFL_) {

1074

if (status & INT_STS_RDFL_) {

1070

if (IS_REV_A(lp->revision)) {

1075

if (IS_REV_A(lp->revision)) {

1071

rx_overrun=1;

1076

rx_overrun=1;

1072

SMC_GET_MAC_CR(lp, cr);

1077

SMC_GET_MAC_CR(lp, cr);

1073

cr &= ~MAC_CR_RXEN_;

1078

cr &= ~MAC_CR_RXEN_;

1074

SMC_SET_MAC_CR(lp, cr);

1079

SMC_SET_MAC_CR(lp, cr);

1075

DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name);

1080

DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name);

1076

dev->stats.rx_errors++;

1081

dev->stats.rx_errors++;

1077

dev->stats.rx_fifo_errors++;

1082

dev->stats.rx_fifo_errors++;

1078

}

1083

}

1079

SMC_ACK_INT(lp, INT_STS_RDFL_);

1084

SMC_ACK_INT(lp, INT_STS_RDFL_);

1080

}

1085

}

1081

if (status & INT_STS_RDFO_) {

1086

if (status & INT_STS_RDFO_) {

1082

if (!IS_REV_A(lp->revision)) {

1087

if (!IS_REV_A(lp->revision)) {

1083

SMC_GET_MAC_CR(lp, cr);

1088

SMC_GET_MAC_CR(lp, cr);

1084

cr &= ~MAC_CR_RXEN_;

1089

cr &= ~MAC_CR_RXEN_;

1085

SMC_SET_MAC_CR(lp, cr);

1090

SMC_SET_MAC_CR(lp, cr);

1086

rx_overrun=1;

1091

rx_overrun=1;

1087

DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name);

1092

DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name);

1088

dev->stats.rx_errors++;

1093

dev->stats.rx_errors++;

1089

dev->stats.rx_fifo_errors++;

1094

dev->stats.rx_fifo_errors++;

1090

}

1095

}

1091

SMC_ACK_INT(lp, INT_STS_RDFO_);

1096

SMC_ACK_INT(lp, INT_STS_RDFO_);

1092

}

1097

}

1093

/* Handle receive condition */

1098

/* Handle receive condition */

1094

if ((status & INT_STS_RSFL_) || rx_overrun) {

1099

if ((status & INT_STS_RSFL_) || rx_overrun) {

1095

unsigned int fifo;

1100

unsigned int fifo;

1096

DBG(SMC_DEBUG_RX, "%s: RX irq\n", dev->name);

1101

DBG(SMC_DEBUG_RX, "%s: RX irq\n", dev->name);

1097

fifo = SMC_GET_RX_FIFO_INF(lp);

1102

fifo = SMC_GET_RX_FIFO_INF(lp);

1098

pkts = (fifo & RX_FIFO_INF_RXSUSED_) >> 16;

1103

pkts = (fifo & RX_FIFO_INF_RXSUSED_) >> 16;

1099

DBG(SMC_DEBUG_RX, "%s: Rx FIFO pkts %d, bytes %d\n",

1104

DBG(SMC_DEBUG_RX, "%s: Rx FIFO pkts %d, bytes %d\n",

1100

dev->name, pkts, fifo & 0xFFFF );

1105

dev->name, pkts, fifo & 0xFFFF );

1101

if (pkts != 0) {

1106

if (pkts != 0) {

1102

#ifdef SMC_USE_DMA

1107

#ifdef SMC_USE_DMA

1103

unsigned int fifo;

1108

unsigned int fifo;

1104

if (lp->rxdma_active){

1109

if (lp->rxdma_active){

1105

DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA,

1110

DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA,

1106

"%s: RX DMA active\n", dev->name);

1111

"%s: RX DMA active\n", dev->name);

1107

/* The DMA is already running so up the IRQ threshold */

1112

/* The DMA is already running so up the IRQ threshold */

1108

fifo = SMC_GET_FIFO_INT(lp) & ~0xFF;

1113

fifo = SMC_GET_FIFO_INT(lp) & ~0xFF;

1109

fifo |= pkts & 0xFF;

1114

fifo |= pkts & 0xFF;

1110

DBG(SMC_DEBUG_RX,

1115

DBG(SMC_DEBUG_RX,

1111

"%s: Setting RX stat FIFO threshold to %d\n",

1116

"%s: Setting RX stat FIFO threshold to %d\n",

1112

dev->name, fifo & 0xff);

1117

dev->name, fifo & 0xff);

1113

SMC_SET_FIFO_INT(lp, fifo);

1118

SMC_SET_FIFO_INT(lp, fifo);

1114

} else

1119

} else

1115

#endif

1120

#endif

1116

smc911x_rcv(dev);

1121

smc911x_rcv(dev);

1117

}

1122

}

1118

SMC_ACK_INT(lp, INT_STS_RSFL_);

1123

SMC_ACK_INT(lp, INT_STS_RSFL_);

1119

}

1124

}

1120

/* Handle transmit FIFO available */

1125

/* Handle transmit FIFO available */

1121

if (status & INT_STS_TDFA_) {

1126

if (status & INT_STS_TDFA_) {

1122

DBG(SMC_DEBUG_TX, "%s: TX data FIFO space available irq\n", dev->name);

1127

DBG(SMC_DEBUG_TX, "%s: TX data FIFO space available irq\n", dev->name);

1123

SMC_SET_FIFO_TDA(lp, 0xFF);

1128

SMC_SET_FIFO_TDA(lp, 0xFF);

1124

lp->tx_throttle = 0;

1129

lp->tx_throttle = 0;

1125

#ifdef SMC_USE_DMA

1130

#ifdef SMC_USE_DMA

1126

if (!lp->txdma_active)

1131

if (!lp->txdma_active)

1127

#endif

1132

#endif

1128

netif_wake_queue(dev);

1133

netif_wake_queue(dev);

1129

SMC_ACK_INT(lp, INT_STS_TDFA_);

1134

SMC_ACK_INT(lp, INT_STS_TDFA_);

1130

}

1135

}

1131

/* Handle transmit done condition */

1136

/* Handle transmit done condition */

1132

#if 1

1137

#if 1

1133

if (status & (INT_STS_TSFL_ | INT_STS_GPT_INT_)) {

1138

if (status & (INT_STS_TSFL_ | INT_STS_GPT_INT_)) {

1134

DBG(SMC_DEBUG_TX | SMC_DEBUG_MISC,

1139

DBG(SMC_DEBUG_TX | SMC_DEBUG_MISC,

1135

"%s: Tx stat FIFO limit (%d) /GPT irq\n",

1140

"%s: Tx stat FIFO limit (%d) /GPT irq\n",

1136

dev->name, (SMC_GET_FIFO_INT(lp) & 0x00ff0000) >> 16);

1141

dev->name, (SMC_GET_FIFO_INT(lp) & 0x00ff0000) >> 16);

1137

smc911x_tx(dev);

1142

smc911x_tx(dev);

1138

SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);

1143

SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);

1139

SMC_ACK_INT(lp, INT_STS_TSFL_);

1144

SMC_ACK_INT(lp, INT_STS_TSFL_);

1140

SMC_ACK_INT(lp, INT_STS_TSFL_ | INT_STS_GPT_INT_);

1145

SMC_ACK_INT(lp, INT_STS_TSFL_ | INT_STS_GPT_INT_);

1141

}

1146

}

1142

#else

1147

#else

1143

if (status & INT_STS_TSFL_) {

1148

if (status & INT_STS_TSFL_) {

1144

DBG(SMC_DEBUG_TX, "%s: TX status FIFO limit (%d) irq \n", dev->name, );

1149

DBG(SMC_DEBUG_TX, "%s: TX status FIFO limit (%d) irq \n", dev->name, );

1145

smc911x_tx(dev);

1150

smc911x_tx(dev);

1146

SMC_ACK_INT(lp, INT_STS_TSFL_);

1151

SMC_ACK_INT(lp, INT_STS_TSFL_);

1147

}

1152

}

1148

1153

1149

if (status & INT_STS_GPT_INT_) {

1154

if (status & INT_STS_GPT_INT_) {

1150

DBG(SMC_DEBUG_RX, "%s: IRQ_CFG 0x%08x FIFO_INT 0x%08x RX_CFG 0x%08x\n",

1155

DBG(SMC_DEBUG_RX, "%s: IRQ_CFG 0x%08x FIFO_INT 0x%08x RX_CFG 0x%08x\n",

1151

dev->name,

1156

dev->name,

1152

SMC_GET_IRQ_CFG(lp),

1157

SMC_GET_IRQ_CFG(lp),

1153

SMC_GET_FIFO_INT(lp),

1158

SMC_GET_FIFO_INT(lp),

1154

SMC_GET_RX_CFG(lp));

1159

SMC_GET_RX_CFG(lp));

1155

DBG(SMC_DEBUG_RX, "%s: Rx Stat FIFO Used 0x%02x "

1160

DBG(SMC_DEBUG_RX, "%s: Rx Stat FIFO Used 0x%02x "

1156

"Data FIFO Used 0x%04x Stat FIFO 0x%08x\n",

1161

"Data FIFO Used 0x%04x Stat FIFO 0x%08x\n",

1157

dev->name,

1162

dev->name,

1158

(SMC_GET_RX_FIFO_INF(lp) & 0x00ff0000) >> 16,

1163

(SMC_GET_RX_FIFO_INF(lp) & 0x00ff0000) >> 16,

1159

SMC_GET_RX_FIFO_INF(lp) & 0xffff,

1164

SMC_GET_RX_FIFO_INF(lp) & 0xffff,

1160

SMC_GET_RX_STS_FIFO_PEEK(lp));

1165

SMC_GET_RX_STS_FIFO_PEEK(lp));

1161

SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);

1166

SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);

1162

SMC_ACK_INT(lp, INT_STS_GPT_INT_);

1167

SMC_ACK_INT(lp, INT_STS_GPT_INT_);

1163

}

1168

}

1164

#endif

1169

#endif

1165

1170

1166

/* Handle PHY interrupt condition */

1171

/* Handle PHY interrupt condition */

1167

if (status & INT_STS_PHY_INT_) {

1172

if (status & INT_STS_PHY_INT_) {

1168

DBG(SMC_DEBUG_MISC, "%s: PHY irq\n", dev->name);

1173

DBG(SMC_DEBUG_MISC, "%s: PHY irq\n", dev->name);

1169

smc911x_phy_interrupt(dev);

1174

smc911x_phy_interrupt(dev);

1170

SMC_ACK_INT(lp, INT_STS_PHY_INT_);

1175

SMC_ACK_INT(lp, INT_STS_PHY_INT_);

1171

}

1176

}

1172

} while (--timeout);

1177

} while (--timeout);

1173

1178

1174

/* restore mask state */

1179

/* restore mask state */

1175

SMC_SET_INT_EN(lp, mask);

1180

SMC_SET_INT_EN(lp, mask);

1176

1181

1177

DBG(SMC_DEBUG_MISC, "%s: Interrupt done (%d loops)\n",

1182

DBG(SMC_DEBUG_MISC, "%s: Interrupt done (%d loops)\n",

1178

dev->name, 8-timeout);

1183

dev->name, 8-timeout);

1179

1184

1180

spin_unlock_irqrestore(&lp->lock, flags);

1185

spin_unlock_irqrestore(&lp->lock, flags);

1181

1186

1182

return IRQ_HANDLED;

1187

return IRQ_HANDLED;

1183

}

1188

}

1184

1189

1185

#ifdef SMC_USE_DMA

1190

#ifdef SMC_USE_DMA

1186

static void

1191

static void

1187

smc911x_tx_dma_irq(int dma, void *data)

1192

smc911x_tx_dma_irq(int dma, void *data)

1188

{

1193

{

1189

struct net_device *dev = (struct net_device *)data;

1194

struct net_device *dev = (struct net_device *)data;

1190

struct smc911x_local *lp = netdev_priv(dev);

1195

struct smc911x_local *lp = netdev_priv(dev);

1191

struct sk_buff *skb = lp->current_tx_skb;

1196

struct sk_buff *skb = lp->current_tx_skb;

1192

unsigned long flags;

1197

unsigned long flags;

1193

1198

1194

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1199

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1195

1200

1196

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: TX DMA irq handler\n", dev->name);

1201

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: TX DMA irq handler\n", dev->name);

1197

/* Clear the DMA interrupt sources */

1202

/* Clear the DMA interrupt sources */

1198

SMC_DMA_ACK_IRQ(dev, dma);

1203

SMC_DMA_ACK_IRQ(dev, dma);

1199

BUG_ON(skb == NULL);

1204

BUG_ON(skb == NULL);

1200

dma_unmap_single(NULL, tx_dmabuf, tx_dmalen, DMA_TO_DEVICE);

1205

dma_unmap_single(NULL, tx_dmabuf, tx_dmalen, DMA_TO_DEVICE);

1201

dev->trans_start = jiffies;

1206

dev->trans_start = jiffies;

1202

dev_kfree_skb_irq(skb);

1207

dev_kfree_skb_irq(skb);

1203

lp->current_tx_skb = NULL;

1208

lp->current_tx_skb = NULL;

1204

if (lp->pending_tx_skb != NULL)

1209

if (lp->pending_tx_skb != NULL)

1205

smc911x_hardware_send_pkt(dev);

1210

smc911x_hardware_send_pkt(dev);

1206

else {

1211

else {

1207

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA,

1212

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA,

1208

"%s: No pending Tx packets. DMA disabled\n", dev->name);

1213

"%s: No pending Tx packets. DMA disabled\n", dev->name);

1209

spin_lock_irqsave(&lp->lock, flags);

1214

spin_lock_irqsave(&lp->lock, flags);

1210

lp->txdma_active = 0;

1215

lp->txdma_active = 0;

1211

if (!lp->tx_throttle) {

1216

if (!lp->tx_throttle) {

1212

netif_wake_queue(dev);

1217

netif_wake_queue(dev);

1213

}

1218

}

1214

spin_unlock_irqrestore(&lp->lock, flags);

1219

spin_unlock_irqrestore(&lp->lock, flags);

1215

}

1220

}

1216

1221

1217

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA,

1222

DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA,

1218

"%s: TX DMA irq completed\n", dev->name);

1223

"%s: TX DMA irq completed\n", dev->name);

1219

}

1224

}

1220

static void

1225

static void

1221

smc911x_rx_dma_irq(int dma, void *data)

1226

smc911x_rx_dma_irq(int dma, void *data)

1222

{

1227

{

1223

struct net_device *dev = (struct net_device *)data;

1228

struct net_device *dev = (struct net_device *)data;

1224

unsigned long ioaddr = dev->base_addr;

1229

unsigned long ioaddr = dev->base_addr;

1225

struct smc911x_local *lp = netdev_priv(dev);

1230

struct smc911x_local *lp = netdev_priv(dev);

1226

struct sk_buff *skb = lp->current_rx_skb;

1231

struct sk_buff *skb = lp->current_rx_skb;

1227

unsigned long flags;

1232

unsigned long flags;

1228

unsigned int pkts;

1233

unsigned int pkts;

1229

1234

1230

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1235

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1231

DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA, "%s: RX DMA irq handler\n", dev->name);

1236

DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA, "%s: RX DMA irq handler\n", dev->name);

1232

/* Clear the DMA interrupt sources */

1237

/* Clear the DMA interrupt sources */

1233

SMC_DMA_ACK_IRQ(dev, dma);

1238

SMC_DMA_ACK_IRQ(dev, dma);

1234

dma_unmap_single(NULL, rx_dmabuf, rx_dmalen, DMA_FROM_DEVICE);

1239

dma_unmap_single(NULL, rx_dmabuf, rx_dmalen, DMA_FROM_DEVICE);

1235

BUG_ON(skb == NULL);

1240

BUG_ON(skb == NULL);

1236

lp->current_rx_skb = NULL;

1241

lp->current_rx_skb = NULL;

1237

PRINT_PKT(skb->data, skb->len);

1242

PRINT_PKT(skb->data, skb->len);

1238

dev->last_rx = jiffies;

1243

dev->last_rx = jiffies;

1239

skb->protocol = eth_type_trans(skb, dev);

1244

skb->protocol = eth_type_trans(skb, dev);

1240

dev->stats.rx_packets++;

1245

dev->stats.rx_packets++;

1241

dev->stats.rx_bytes += skb->len;

1246

dev->stats.rx_bytes += skb->len;

1242

netif_rx(skb);

1247

netif_rx(skb);

1243

1248

1244

spin_lock_irqsave(&lp->lock, flags);

1249

spin_lock_irqsave(&lp->lock, flags);

1245

pkts = (SMC_GET_RX_FIFO_INF(lp) & RX_FIFO_INF_RXSUSED_) >> 16;

1250

pkts = (SMC_GET_RX_FIFO_INF(lp) & RX_FIFO_INF_RXSUSED_) >> 16;

1246

if (pkts != 0) {

1251

if (pkts != 0) {

1247

smc911x_rcv(dev);

1252

smc911x_rcv(dev);

1248

}else {

1253

}else {

1249

lp->rxdma_active = 0;

1254

lp->rxdma_active = 0;

1250

}

1255

}

1251

spin_unlock_irqrestore(&lp->lock, flags);

1256

spin_unlock_irqrestore(&lp->lock, flags);

1252

DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA,

1257

DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA,

1253

"%s: RX DMA irq completed. DMA RX FIFO PKTS %d\n",

1258

"%s: RX DMA irq completed. DMA RX FIFO PKTS %d\n",

1254

dev->name, pkts);

1259

dev->name, pkts);

1255

}

1260

}

1256

#endif /* SMC_USE_DMA */

1261

#endif /* SMC_USE_DMA */

1257

1262

1258

#ifdef CONFIG_NET_POLL_CONTROLLER

1263

#ifdef CONFIG_NET_POLL_CONTROLLER

1259

/*

1264

/*

1260

* Polling receive - used by netconsole and other diagnostic tools

1265

* Polling receive - used by netconsole and other diagnostic tools

1261

* to allow network i/o with interrupts disabled.

1266

* to allow network i/o with interrupts disabled.

1262

*/

1267

*/

1263

static void smc911x_poll_controller(struct net_device *dev)

1268

static void smc911x_poll_controller(struct net_device *dev)

1264

{

1269

{

1265

disable_irq(dev->irq);

1270

disable_irq(dev->irq);

1266

smc911x_interrupt(dev->irq, dev);

1271

smc911x_interrupt(dev->irq, dev);

1267

enable_irq(dev->irq);

1272

enable_irq(dev->irq);

1268

}

1273

}

1269

#endif

1274

#endif

1270

1275

1271

/* Our watchdog timed out. Called by the networking layer */

1276

/* Our watchdog timed out. Called by the networking layer */

1272

static void smc911x_timeout(struct net_device *dev)

1277

static void smc911x_timeout(struct net_device *dev)

1273

{

1278

{

1274

struct smc911x_local *lp = netdev_priv(dev);

1279

struct smc911x_local *lp = netdev_priv(dev);

1275

int status, mask;

1280

int status, mask;

1276

unsigned long flags;

1281

unsigned long flags;

1277

1282

1278

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1283

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1279

1284

1280

spin_lock_irqsave(&lp->lock, flags);

1285

spin_lock_irqsave(&lp->lock, flags);

1281

status = SMC_GET_INT(lp);

1286

status = SMC_GET_INT(lp);

1282

mask = SMC_GET_INT_EN(lp);

1287

mask = SMC_GET_INT_EN(lp);

1283

spin_unlock_irqrestore(&lp->lock, flags);

1288

spin_unlock_irqrestore(&lp->lock, flags);

1284

DBG(SMC_DEBUG_MISC, "%s: INT 0x%02x MASK 0x%02x \n",

1289

DBG(SMC_DEBUG_MISC, "%s: INT 0x%02x MASK 0x%02x \n",

1285

dev->name, status, mask);

1290

dev->name, status, mask);

1286

1291

1287

/* Dump the current TX FIFO contents and restart */

1292

/* Dump the current TX FIFO contents and restart */

1288

mask = SMC_GET_TX_CFG(lp);

1293

mask = SMC_GET_TX_CFG(lp);

1289

SMC_SET_TX_CFG(lp, mask | TX_CFG_TXS_DUMP_ | TX_CFG_TXD_DUMP_);

1294

SMC_SET_TX_CFG(lp, mask | TX_CFG_TXS_DUMP_ | TX_CFG_TXD_DUMP_);

1290

/*

1295

/*

1291

* Reconfiguring the PHY doesn't seem like a bad idea here, but

1296

* Reconfiguring the PHY doesn't seem like a bad idea here, but

1292

* smc911x_phy_configure() calls msleep() which calls schedule_timeout()

1297

* smc911x_phy_configure() calls msleep() which calls schedule_timeout()

1293

* which calls schedule(). Hence we use a work queue.

1298

* which calls schedule(). Hence we use a work queue.

1294

*/

1299

*/

1295

if (lp->phy_type != 0)

1300

if (lp->phy_type != 0)

1296

schedule_work(&lp->phy_configure);

1301

schedule_work(&lp->phy_configure);

1297

1302

1298

/* We can accept TX packets again */

1303

/* We can accept TX packets again */

1299

dev->trans_start = jiffies;

1304

dev->trans_start = jiffies;

1300

netif_wake_queue(dev);

1305

netif_wake_queue(dev);

1301

}

1306

}

1302

1307

1303

/*

1308

/*

1304

* This routine will, depending on the values passed to it,

1309

* This routine will, depending on the values passed to it,

1305

* either make it accept multicast packets, go into

1310

* either make it accept multicast packets, go into

1306

* promiscuous mode (for TCPDUMP and cousins) or accept

1311

* promiscuous mode (for TCPDUMP and cousins) or accept

1307

* a select set of multicast packets

1312

* a select set of multicast packets

1308

*/

1313

*/

1309

static void smc911x_set_multicast_list(struct net_device *dev)

1314

static void smc911x_set_multicast_list(struct net_device *dev)

1310

{

1315

{

1311

struct smc911x_local *lp = netdev_priv(dev);

1316

struct smc911x_local *lp = netdev_priv(dev);

1312

unsigned int multicast_table[2];

1317

unsigned int multicast_table[2];

1313

unsigned int mcr, update_multicast = 0;

1318

unsigned int mcr, update_multicast = 0;

1314

unsigned long flags;

1319

unsigned long flags;

1315

1320

1316

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1321

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1317

1322

1318

spin_lock_irqsave(&lp->lock, flags);

1323

spin_lock_irqsave(&lp->lock, flags);

1319

SMC_GET_MAC_CR(lp, mcr);

1324

SMC_GET_MAC_CR(lp, mcr);

1320

spin_unlock_irqrestore(&lp->lock, flags);

1325

spin_unlock_irqrestore(&lp->lock, flags);

1321

1326

1322

if (dev->flags & IFF_PROMISC) {

1327

if (dev->flags & IFF_PROMISC) {

1323

1328

1324

DBG(SMC_DEBUG_MISC, "%s: RCR_PRMS\n", dev->name);

1329

DBG(SMC_DEBUG_MISC, "%s: RCR_PRMS\n", dev->name);

1325

mcr |= MAC_CR_PRMS_;

1330

mcr |= MAC_CR_PRMS_;

1326

}

1331

}

1327

/*

1332

/*

1328

* Here, I am setting this to accept all multicast packets.

1333

* Here, I am setting this to accept all multicast packets.

1329

* I don't need to zero the multicast table, because the flag is

1334

* I don't need to zero the multicast table, because the flag is

1330

* checked before the table is

1335

* checked before the table is

1331

*/

1336

*/

1332

else if (dev->flags & IFF_ALLMULTI || dev->mc_count > 16) {

1337

else if (dev->flags & IFF_ALLMULTI || dev->mc_count > 16) {

1333

DBG(SMC_DEBUG_MISC, "%s: RCR_ALMUL\n", dev->name);

1338

DBG(SMC_DEBUG_MISC, "%s: RCR_ALMUL\n", dev->name);

1334

mcr |= MAC_CR_MCPAS_;

1339

mcr |= MAC_CR_MCPAS_;

1335

}

1340

}

1336

1341

1337

/*

1342

/*

1338

* This sets the internal hardware table to filter out unwanted

1343

* This sets the internal hardware table to filter out unwanted

1339

* multicast packets before they take up memory.

1344

* multicast packets before they take up memory.

1340

*

1345

*

1341

* The SMC chip uses a hash table where the high 6 bits of the CRC of

1346

* The SMC chip uses a hash table where the high 6 bits of the CRC of

1342

* address are the offset into the table. If that bit is 1, then the

1347

* address are the offset into the table. If that bit is 1, then the

1343

* multicast packet is accepted. Otherwise, it's dropped silently.

1348

* multicast packet is accepted. Otherwise, it's dropped silently.

1344

*

1349

*

1345

* To use the 6 bits as an offset into the table, the high 1 bit is

1350

* To use the 6 bits as an offset into the table, the high 1 bit is

1346

* the number of the 32 bit register, while the low 5 bits are the bit

1351

* the number of the 32 bit register, while the low 5 bits are the bit

1347

* within that register.

1352

* within that register.

1348

*/

1353

*/

1349

else if (dev->mc_count) {

1354

else if (dev->mc_count) {

1350

int i;

1355

int i;

1351

struct dev_mc_list *cur_addr;

1356

struct dev_mc_list *cur_addr;

1352

1357

1353

/* Set the Hash perfec mode */

1358

/* Set the Hash perfec mode */

1354

mcr |= MAC_CR_HPFILT_;

1359

mcr |= MAC_CR_HPFILT_;

1355

1360

1356

/* start with a table of all zeros: reject all */

1361

/* start with a table of all zeros: reject all */

1357

memset(multicast_table, 0, sizeof(multicast_table));

1362

memset(multicast_table, 0, sizeof(multicast_table));

1358

1363

1359

cur_addr = dev->mc_list;

1364

cur_addr = dev->mc_list;

1360

for (i = 0; i < dev->mc_count; i++, cur_addr = cur_addr->next) {

1365

for (i = 0; i < dev->mc_count; i++, cur_addr = cur_addr->next) {

1361

u32 position;

1366

u32 position;

1362

1367

1363

/* do we have a pointer here? */

1368

/* do we have a pointer here? */

1364

if (!cur_addr)

1369

if (!cur_addr)

1365

break;

1370

break;

1366

/* make sure this is a multicast address -

1371

/* make sure this is a multicast address -

1367

shouldn't this be a given if we have it here ? */

1372

shouldn't this be a given if we have it here ? */

1368

if (!(*cur_addr->dmi_addr & 1))

1373

if (!(*cur_addr->dmi_addr & 1))

1369

continue;

1374

continue;

1370

1375

1371

/* upper 6 bits are used as hash index */

1376

/* upper 6 bits are used as hash index */

1372

position = ether_crc(ETH_ALEN, cur_addr->dmi_addr)>>26;

1377

position = ether_crc(ETH_ALEN, cur_addr->dmi_addr)>>26;

1373

1378

1374

multicast_table[position>>5] |= 1 << (position&0x1f);

1379

multicast_table[position>>5] |= 1 << (position&0x1f);

1375

}

1380

}

1376

1381

1377

/* be sure I get rid of flags I might have set */

1382

/* be sure I get rid of flags I might have set */

1378

mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);

1383

mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);

1379

1384

1380

/* now, the table can be loaded into the chipset */

1385

/* now, the table can be loaded into the chipset */

1381

update_multicast = 1;

1386

update_multicast = 1;

1382

} else {

1387

} else {

1383

DBG(SMC_DEBUG_MISC, "%s: ~(MAC_CR_PRMS_|MAC_CR_MCPAS_)\n",

1388

DBG(SMC_DEBUG_MISC, "%s: ~(MAC_CR_PRMS_|MAC_CR_MCPAS_)\n",

1384

dev->name);

1389

dev->name);

1385

mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);

1390

mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);

1386

1391

1387

/*

1392

/*

1388

* since I'm disabling all multicast entirely, I need to

1393

* since I'm disabling all multicast entirely, I need to

1389

* clear the multicast list

1394

* clear the multicast list

1390

*/

1395

*/

1391

memset(multicast_table, 0, sizeof(multicast_table));

1396

memset(multicast_table, 0, sizeof(multicast_table));

1392

update_multicast = 1;

1397

update_multicast = 1;

1393

}

1398

}

1394

1399

1395

spin_lock_irqsave(&lp->lock, flags);

1400

spin_lock_irqsave(&lp->lock, flags);

1396

SMC_SET_MAC_CR(lp, mcr);

1401

SMC_SET_MAC_CR(lp, mcr);

1397

if (update_multicast) {

1402

if (update_multicast) {

1398

DBG(SMC_DEBUG_MISC,

1403

DBG(SMC_DEBUG_MISC,

1399

"%s: update mcast hash table 0x%08x 0x%08x\n",

1404

"%s: update mcast hash table 0x%08x 0x%08x\n",

1400

dev->name, multicast_table[0], multicast_table[1]);

1405

dev->name, multicast_table[0], multicast_table[1]);

1401

SMC_SET_HASHL(lp, multicast_table[0]);

1406

SMC_SET_HASHL(lp, multicast_table[0]);

1402

SMC_SET_HASHH(lp, multicast_table[1]);

1407

SMC_SET_HASHH(lp, multicast_table[1]);

1403

}

1408

}

1404

spin_unlock_irqrestore(&lp->lock, flags);

1409

spin_unlock_irqrestore(&lp->lock, flags);

1405

}

1410

}

1406

1411

1407

1412

1408

/*

1413

/*

1409

* Open and Initialize the board

1414

* Open and Initialize the board

1410

*

1415

*

1411

* Set up everything, reset the card, etc..

1416

* Set up everything, reset the card, etc..

1412

*/

1417

*/

1413

static int

1418

static int

1414

smc911x_open(struct net_device *dev)

1419

smc911x_open(struct net_device *dev)

1415

{

1420

{

1416

struct smc911x_local *lp = netdev_priv(dev);

1421

struct smc911x_local *lp = netdev_priv(dev);

1417

1422

1418

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1423

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1419

1424

1420

/*

1425

/*

1421

* Check that the address is valid. If its not, refuse

1426

* Check that the address is valid. If its not, refuse

1422

* to bring the device up. The user must specify an

1427

* to bring the device up. The user must specify an

1423

* address using ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx

1428

* address using ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx

1424

*/

1429

*/

1425

if (!is_valid_ether_addr(dev->dev_addr)) {

1430

if (!is_valid_ether_addr(dev->dev_addr)) {

1426

PRINTK("%s: no valid ethernet hw addr\n", __func__);

1431

PRINTK("%s: no valid ethernet hw addr\n", __func__);

1427

return -EINVAL;

1432

return -EINVAL;

1428

}

1433

}

1429

1434

1430

/* reset the hardware */

1435

/* reset the hardware */

1431

smc911x_reset(dev);

1436

smc911x_reset(dev);

1432

1437

1433

/* Configure the PHY, initialize the link state */

1438

/* Configure the PHY, initialize the link state */

1434

smc911x_phy_configure(&lp->phy_configure);

1439

smc911x_phy_configure(&lp->phy_configure);

1435

1440

1436

/* Turn on Tx + Rx */

1441

/* Turn on Tx + Rx */

1437

smc911x_enable(dev);

1442

smc911x_enable(dev);

1438

1443

1439

netif_start_queue(dev);

1444

netif_start_queue(dev);

1440

1445

1441

return 0;

1446

return 0;

1442

}

1447

}

1443

1448

1444

/*

1449

/*

1445

* smc911x_close

1450

* smc911x_close

1446

*

1451

*

1447

* this makes the board clean up everything that it can

1452

* this makes the board clean up everything that it can

1448

* and not talk to the outside world. Caused by

1453

* and not talk to the outside world. Caused by

1449

* an 'ifconfig ethX down'

1454

* an 'ifconfig ethX down'

1450

*/

1455

*/

1451

static int smc911x_close(struct net_device *dev)

1456

static int smc911x_close(struct net_device *dev)

1452

{

1457

{

1453

struct smc911x_local *lp = netdev_priv(dev);

1458

struct smc911x_local *lp = netdev_priv(dev);

1454

1459

1455

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1460

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1456

1461

1457

netif_stop_queue(dev);

1462

netif_stop_queue(dev);

1458

netif_carrier_off(dev);

1463

netif_carrier_off(dev);

1459

1464

1460

/* clear everything */

1465

/* clear everything */

1461

smc911x_shutdown(dev);

1466

smc911x_shutdown(dev);

1462

1467

1463

if (lp->phy_type != 0) {

1468

if (lp->phy_type != 0) {

1464

/* We need to ensure that no calls to

1469

/* We need to ensure that no calls to

1465

* smc911x_phy_configure are pending.

1470

* smc911x_phy_configure are pending.

1466

*/

1471

*/

1467

cancel_work_sync(&lp->phy_configure);

1472

cancel_work_sync(&lp->phy_configure);

1468

smc911x_phy_powerdown(dev, lp->mii.phy_id);

1473

smc911x_phy_powerdown(dev, lp->mii.phy_id);

1469

}

1474

}

1470

1475

1471

if (lp->pending_tx_skb) {

1476

if (lp->pending_tx_skb) {

1472

dev_kfree_skb(lp->pending_tx_skb);

1477

dev_kfree_skb(lp->pending_tx_skb);

1473

lp->pending_tx_skb = NULL;

1478

lp->pending_tx_skb = NULL;

1474

}

1479

}

1475

1480

1476

return 0;

1481

return 0;

1477

}

1482

}

1478

1483

1479

/*

1484

/*

1480

* Ethtool support

1485

* Ethtool support

1481

*/

1486

*/

1482

static int

1487

static int

1483

smc911x_ethtool_getsettings(struct net_device *dev, struct ethtool_cmd *cmd)

1488

smc911x_ethtool_getsettings(struct net_device *dev, struct ethtool_cmd *cmd)

1484

{

1489

{

1485

struct smc911x_local *lp = netdev_priv(dev);

1490

struct smc911x_local *lp = netdev_priv(dev);

1486

int ret, status;

1491

int ret, status;

1487

unsigned long flags;

1492

unsigned long flags;

1488

1493

1489

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1494

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1490

cmd->maxtxpkt = 1;

1495

cmd->maxtxpkt = 1;

1491

cmd->maxrxpkt = 1;

1496

cmd->maxrxpkt = 1;

1492

1497

1493

if (lp->phy_type != 0) {

1498

if (lp->phy_type != 0) {

1494

spin_lock_irqsave(&lp->lock, flags);

1499

spin_lock_irqsave(&lp->lock, flags);

1495

ret = mii_ethtool_gset(&lp->mii, cmd);

1500

ret = mii_ethtool_gset(&lp->mii, cmd);

1496

spin_unlock_irqrestore(&lp->lock, flags);

1501

spin_unlock_irqrestore(&lp->lock, flags);

1497

} else {

1502

} else {

1498

cmd->supported = SUPPORTED_10baseT_Half |

1503

cmd->supported = SUPPORTED_10baseT_Half |

1499

SUPPORTED_10baseT_Full |

1504

SUPPORTED_10baseT_Full |

1500

SUPPORTED_TP | SUPPORTED_AUI;

1505

SUPPORTED_TP | SUPPORTED_AUI;

1501

1506

1502

if (lp->ctl_rspeed == 10)

1507

if (lp->ctl_rspeed == 10)

1503

cmd->speed = SPEED_10;

1508

cmd->speed = SPEED_10;

1504

else if (lp->ctl_rspeed == 100)

1509

else if (lp->ctl_rspeed == 100)

1505

cmd->speed = SPEED_100;

1510

cmd->speed = SPEED_100;

1506

1511

1507

cmd->autoneg = AUTONEG_DISABLE;

1512

cmd->autoneg = AUTONEG_DISABLE;

1508

if (lp->mii.phy_id==1)

1513

if (lp->mii.phy_id==1)

1509

cmd->transceiver = XCVR_INTERNAL;

1514

cmd->transceiver = XCVR_INTERNAL;

1510

else

1515

else

1511

cmd->transceiver = XCVR_EXTERNAL;

1516

cmd->transceiver = XCVR_EXTERNAL;

1512

cmd->port = 0;

1517

cmd->port = 0;

1513

SMC_GET_PHY_SPECIAL(lp, lp->mii.phy_id, status);

1518

SMC_GET_PHY_SPECIAL(lp, lp->mii.phy_id, status);

1514

cmd->duplex =

1519

cmd->duplex =

1515

(status & (PHY_SPECIAL_SPD_10FULL_ | PHY_SPECIAL_SPD_100FULL_)) ?

1520

(status & (PHY_SPECIAL_SPD_10FULL_ | PHY_SPECIAL_SPD_100FULL_)) ?

1516

DUPLEX_FULL : DUPLEX_HALF;

1521

DUPLEX_FULL : DUPLEX_HALF;

1517

ret = 0;

1522

ret = 0;

1518

}

1523

}

1519

1524

1520

return ret;

1525

return ret;

1521

}

1526

}

1522

1527

1523

static int

1528

static int

1524

smc911x_ethtool_setsettings(struct net_device *dev, struct ethtool_cmd *cmd)

1529

smc911x_ethtool_setsettings(struct net_device *dev, struct ethtool_cmd *cmd)

1525

{

1530

{

1526

struct smc911x_local *lp = netdev_priv(dev);

1531

struct smc911x_local *lp = netdev_priv(dev);

1527

int ret;

1532

int ret;

1528

unsigned long flags;

1533

unsigned long flags;

1529

1534

1530

if (lp->phy_type != 0) {

1535

if (lp->phy_type != 0) {

1531

spin_lock_irqsave(&lp->lock, flags);

1536

spin_lock_irqsave(&lp->lock, flags);

1532

ret = mii_ethtool_sset(&lp->mii, cmd);

1537

ret = mii_ethtool_sset(&lp->mii, cmd);

1533

spin_unlock_irqrestore(&lp->lock, flags);

1538

spin_unlock_irqrestore(&lp->lock, flags);

1534

} else {

1539

} else {

1535

if (cmd->autoneg != AUTONEG_DISABLE ||

1540

if (cmd->autoneg != AUTONEG_DISABLE ||

1536

cmd->speed != SPEED_10 ||

1541

cmd->speed != SPEED_10 ||

1537

(cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL) ||

1542

(cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL) ||

1538

(cmd->port != PORT_TP && cmd->port != PORT_AUI))

1543

(cmd->port != PORT_TP && cmd->port != PORT_AUI))

1539

return -EINVAL;

1544

return -EINVAL;

1540

1545

1541

lp->ctl_rfduplx = cmd->duplex == DUPLEX_FULL;

1546

lp->ctl_rfduplx = cmd->duplex == DUPLEX_FULL;

1542

1547

1543

ret = 0;

1548

ret = 0;

1544

}

1549

}

1545

1550

1546

return ret;

1551

return ret;

1547

}

1552

}

1548

1553

1549

static void

1554

static void

1550

smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)

1555

smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)

1551

{

1556

{

1552

strncpy(info->driver, CARDNAME, sizeof(info->driver));

1557

strncpy(info->driver, CARDNAME, sizeof(info->driver));

1553

strncpy(info->version, version, sizeof(info->version));

1558

strncpy(info->version, version, sizeof(info->version));

1554

strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));

1559

strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));

1555

}

1560

}

1556

1561

1557

static int smc911x_ethtool_nwayreset(struct net_device *dev)

1562

static int smc911x_ethtool_nwayreset(struct net_device *dev)

1558

{

1563

{

1559

struct smc911x_local *lp = netdev_priv(dev);

1564

struct smc911x_local *lp = netdev_priv(dev);

1560

int ret = -EINVAL;

1565

int ret = -EINVAL;

1561

unsigned long flags;

1566

unsigned long flags;

1562

1567

1563

if (lp->phy_type != 0) {

1568

if (lp->phy_type != 0) {

1564

spin_lock_irqsave(&lp->lock, flags);

1569

spin_lock_irqsave(&lp->lock, flags);

1565

ret = mii_nway_restart(&lp->mii);

1570

ret = mii_nway_restart(&lp->mii);

1566

spin_unlock_irqrestore(&lp->lock, flags);

1571

spin_unlock_irqrestore(&lp->lock, flags);

1567

}

1572

}

1568

1573

1569

return ret;

1574

return ret;

1570

}

1575

}

1571

1576

1572

static u32 smc911x_ethtool_getmsglevel(struct net_device *dev)

1577

static u32 smc911x_ethtool_getmsglevel(struct net_device *dev)

1573

{

1578

{

1574

struct smc911x_local *lp = netdev_priv(dev);

1579

struct smc911x_local *lp = netdev_priv(dev);

1575

return lp->msg_enable;

1580

return lp->msg_enable;

1576

}

1581

}

1577

1582

1578

static void smc911x_ethtool_setmsglevel(struct net_device *dev, u32 level)

1583

static void smc911x_ethtool_setmsglevel(struct net_device *dev, u32 level)

1579

{

1584

{

1580

struct smc911x_local *lp = netdev_priv(dev);

1585

struct smc911x_local *lp = netdev_priv(dev);

1581

lp->msg_enable = level;

1586

lp->msg_enable = level;

1582

}

1587

}

1583

1588

1584

static int smc911x_ethtool_getregslen(struct net_device *dev)

1589

static int smc911x_ethtool_getregslen(struct net_device *dev)

1585

{

1590

{

1586

/* System regs + MAC regs + PHY regs */

1591

/* System regs + MAC regs + PHY regs */

1587

return (((E2P_CMD - ID_REV)/4 + 1) +

1592

return (((E2P_CMD - ID_REV)/4 + 1) +

1588

(WUCSR - MAC_CR)+1 + 32) * sizeof(u32);

1593

(WUCSR - MAC_CR)+1 + 32) * sizeof(u32);

1589

}

1594

}

1590

1595

1591

static void smc911x_ethtool_getregs(struct net_device *dev,

1596

static void smc911x_ethtool_getregs(struct net_device *dev,

1592

struct ethtool_regs* regs, void *buf)

1597

struct ethtool_regs* regs, void *buf)

1593

{

1598

{

1594

struct smc911x_local *lp = netdev_priv(dev);

1599

struct smc911x_local *lp = netdev_priv(dev);

1595

unsigned long flags;

1600

unsigned long flags;

1596

u32 reg,i,j=0;

1601

u32 reg,i,j=0;

1597

u32 *data = (u32*)buf;

1602

u32 *data = (u32*)buf;

1598

1603

1599

regs->version = lp->version;

1604

regs->version = lp->version;

1600

for(i=ID_REV;i<=E2P_CMD;i+=4) {

1605

for(i=ID_REV;i<=E2P_CMD;i+=4) {

1601

data[j++] = SMC_inl(lp, i);

1606

data[j++] = SMC_inl(lp, i);

1602

}

1607

}

1603

for(i=MAC_CR;i<=WUCSR;i++) {

1608

for(i=MAC_CR;i<=WUCSR;i++) {

1604

spin_lock_irqsave(&lp->lock, flags);

1609

spin_lock_irqsave(&lp->lock, flags);

1605

SMC_GET_MAC_CSR(lp, i, reg);

1610

SMC_GET_MAC_CSR(lp, i, reg);

1606

spin_unlock_irqrestore(&lp->lock, flags);

1611

spin_unlock_irqrestore(&lp->lock, flags);

1607

data[j++] = reg;

1612

data[j++] = reg;

1608

}

1613

}

1609

for(i=0;i<=31;i++) {

1614

for(i=0;i<=31;i++) {

1610

spin_lock_irqsave(&lp->lock, flags);

1615

spin_lock_irqsave(&lp->lock, flags);

1611

SMC_GET_MII(lp, i, lp->mii.phy_id, reg);

1616

SMC_GET_MII(lp, i, lp->mii.phy_id, reg);

1612

spin_unlock_irqrestore(&lp->lock, flags);

1617

spin_unlock_irqrestore(&lp->lock, flags);

1613

data[j++] = reg & 0xFFFF;

1618

data[j++] = reg & 0xFFFF;

1614

}

1619

}

1615

}

1620

}

1616

1621

1617

static int smc911x_ethtool_wait_eeprom_ready(struct net_device *dev)

1622

static int smc911x_ethtool_wait_eeprom_ready(struct net_device *dev)

1618

{

1623

{

1619

struct smc911x_local *lp = netdev_priv(dev);

1624

struct smc911x_local *lp = netdev_priv(dev);

1620

unsigned int timeout;

1625

unsigned int timeout;

1621

int e2p_cmd;

1626

int e2p_cmd;

1622

1627

1623

e2p_cmd = SMC_GET_E2P_CMD(lp);

1628

e2p_cmd = SMC_GET_E2P_CMD(lp);

1624

for(timeout=10;(e2p_cmd & E2P_CMD_EPC_BUSY_) && timeout; timeout--) {

1629

for(timeout=10;(e2p_cmd & E2P_CMD_EPC_BUSY_) && timeout; timeout--) {

1625

if (e2p_cmd & E2P_CMD_EPC_TIMEOUT_) {

1630

if (e2p_cmd & E2P_CMD_EPC_TIMEOUT_) {

1626

PRINTK("%s: %s timeout waiting for EEPROM to respond\n",

1631

PRINTK("%s: %s timeout waiting for EEPROM to respond\n",

1627

dev->name, __func__);

1632

dev->name, __func__);

1628

return -EFAULT;

1633

return -EFAULT;

1629

}

1634

}

1630

mdelay(1);

1635

mdelay(1);

1631

e2p_cmd = SMC_GET_E2P_CMD(lp);

1636

e2p_cmd = SMC_GET_E2P_CMD(lp);

1632

}

1637

}

1633

if (timeout == 0) {

1638

if (timeout == 0) {

1634

PRINTK("%s: %s timeout waiting for EEPROM CMD not busy\n",

1639

PRINTK("%s: %s timeout waiting for EEPROM CMD not busy\n",

1635

dev->name, __func__);

1640

dev->name, __func__);

1636

return -ETIMEDOUT;

1641

return -ETIMEDOUT;

1637

}

1642

}

1638

return 0;

1643

return 0;

1639

}

1644

}

1640

1645

1641

static inline int smc911x_ethtool_write_eeprom_cmd(struct net_device *dev,

1646

static inline int smc911x_ethtool_write_eeprom_cmd(struct net_device *dev,

1642

int cmd, int addr)

1647

int cmd, int addr)

1643

{

1648

{

1644

struct smc911x_local *lp = netdev_priv(dev);

1649

struct smc911x_local *lp = netdev_priv(dev);

1645

int ret;

1650

int ret;

1646

1651

1647

if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)

1652

if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)

1648

return ret;

1653

return ret;

1649

SMC_SET_E2P_CMD(lp, E2P_CMD_EPC_BUSY_ |

1654

SMC_SET_E2P_CMD(lp, E2P_CMD_EPC_BUSY_ |

1650

((cmd) & (0x7<<28)) |

1655

((cmd) & (0x7<<28)) |

1651

((addr) & 0xFF));

1656

((addr) & 0xFF));

1652

return 0;

1657

return 0;

1653

}

1658

}

1654

1659

1655

static inline int smc911x_ethtool_read_eeprom_byte(struct net_device *dev,

1660

static inline int smc911x_ethtool_read_eeprom_byte(struct net_device *dev,

1656

u8 *data)

1661

u8 *data)

1657

{

1662

{

1658

struct smc911x_local *lp = netdev_priv(dev);

1663

struct smc911x_local *lp = netdev_priv(dev);

1659

int ret;

1664

int ret;

1660

1665

1661

if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)

1666

if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)

1662

return ret;

1667

return ret;

1663

*data = SMC_GET_E2P_DATA(lp);

1668

*data = SMC_GET_E2P_DATA(lp);

1664

return 0;

1669

return 0;

1665

}

1670

}

1666

1671

1667

static inline int smc911x_ethtool_write_eeprom_byte(struct net_device *dev,

1672

static inline int smc911x_ethtool_write_eeprom_byte(struct net_device *dev,

1668

u8 data)

1673

u8 data)

1669

{

1674

{

1670

struct smc911x_local *lp = netdev_priv(dev);

1675

struct smc911x_local *lp = netdev_priv(dev);

1671

int ret;

1676

int ret;

1672

1677

1673

if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)

1678

if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)

1674

return ret;

1679

return ret;

1675

SMC_SET_E2P_DATA(lp, data);

1680

SMC_SET_E2P_DATA(lp, data);

1676

return 0;

1681

return 0;

1677

}

1682

}

1678

1683

1679

static int smc911x_ethtool_geteeprom(struct net_device *dev,

1684

static int smc911x_ethtool_geteeprom(struct net_device *dev,

1680

struct ethtool_eeprom *eeprom, u8 *data)

1685

struct ethtool_eeprom *eeprom, u8 *data)

1681

{

1686

{

1682

u8 eebuf[SMC911X_EEPROM_LEN];

1687

u8 eebuf[SMC911X_EEPROM_LEN];

1683

int i, ret;

1688

int i, ret;

1684

1689

1685

for(i=0;i<SMC911X_EEPROM_LEN;i++) {

1690

for(i=0;i<SMC911X_EEPROM_LEN;i++) {

1686

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_READ_, i ))!=0)

1691

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_READ_, i ))!=0)

1687

return ret;

1692

return ret;

1688

if ((ret=smc911x_ethtool_read_eeprom_byte(dev, &eebuf[i]))!=0)

1693

if ((ret=smc911x_ethtool_read_eeprom_byte(dev, &eebuf[i]))!=0)

1689

return ret;

1694

return ret;

1690

}

1695

}

1691

memcpy(data, eebuf+eeprom->offset, eeprom->len);

1696

memcpy(data, eebuf+eeprom->offset, eeprom->len);

1692

return 0;

1697

return 0;

1693

}

1698

}

1694

1699

1695

static int smc911x_ethtool_seteeprom(struct net_device *dev,

1700

static int smc911x_ethtool_seteeprom(struct net_device *dev,

1696

struct ethtool_eeprom *eeprom, u8 *data)

1701

struct ethtool_eeprom *eeprom, u8 *data)

1697

{

1702

{

1698

int i, ret;

1703

int i, ret;

1699

1704

1700

/* Enable erase */

1705

/* Enable erase */

1701

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_EWEN_, 0 ))!=0)

1706

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_EWEN_, 0 ))!=0)

1702

return ret;

1707

return ret;

1703

for(i=eeprom->offset;i<(eeprom->offset+eeprom->len);i++) {

1708

for(i=eeprom->offset;i<(eeprom->offset+eeprom->len);i++) {

1704

/* erase byte */

1709

/* erase byte */

1705

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_ERASE_, i ))!=0)

1710

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_ERASE_, i ))!=0)

1706

return ret;

1711

return ret;

1707

/* write byte */

1712

/* write byte */

1708

if ((ret=smc911x_ethtool_write_eeprom_byte(dev, *data))!=0)

1713

if ((ret=smc911x_ethtool_write_eeprom_byte(dev, *data))!=0)

1709

return ret;

1714

return ret;

1710

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_WRITE_, i ))!=0)

1715

if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_WRITE_, i ))!=0)

1711

return ret;

1716

return ret;

1712

}

1717

}

1713

return 0;

1718

return 0;

1714

}

1719

}

1715

1720

1716

static int smc911x_ethtool_geteeprom_len(struct net_device *dev)

1721

static int smc911x_ethtool_geteeprom_len(struct net_device *dev)

1717

{

1722

{

1718

return SMC911X_EEPROM_LEN;

1723

return SMC911X_EEPROM_LEN;

1719

}

1724

}

1720

1725

1721

static const struct ethtool_ops smc911x_ethtool_ops = {

1726

static const struct ethtool_ops smc911x_ethtool_ops = {

1722

.get_settings = smc911x_ethtool_getsettings,

1727

.get_settings = smc911x_ethtool_getsettings,

1723

.set_settings = smc911x_ethtool_setsettings,

1728

.set_settings = smc911x_ethtool_setsettings,

1724

.get_drvinfo = smc911x_ethtool_getdrvinfo,

1729

.get_drvinfo = smc911x_ethtool_getdrvinfo,

1725

.get_msglevel = smc911x_ethtool_getmsglevel,

1730

.get_msglevel = smc911x_ethtool_getmsglevel,

1726

.set_msglevel = smc911x_ethtool_setmsglevel,

1731

.set_msglevel = smc911x_ethtool_setmsglevel,

1727

.nway_reset = smc911x_ethtool_nwayreset,

1732

.nway_reset = smc911x_ethtool_nwayreset,

1728

.get_link = ethtool_op_get_link,

1733

.get_link = ethtool_op_get_link,

1729

.get_regs_len = smc911x_ethtool_getregslen,

1734

.get_regs_len = smc911x_ethtool_getregslen,

1730

.get_regs = smc911x_ethtool_getregs,

1735

.get_regs = smc911x_ethtool_getregs,

1731

.get_eeprom_len = smc911x_ethtool_geteeprom_len,

1736

.get_eeprom_len = smc911x_ethtool_geteeprom_len,

1732

.get_eeprom = smc911x_ethtool_geteeprom,

1737

.get_eeprom = smc911x_ethtool_geteeprom,

1733

.set_eeprom = smc911x_ethtool_seteeprom,

1738

.set_eeprom = smc911x_ethtool_seteeprom,

1734

};

1739

};

1735

1740

1736

/*

1741

/*

1737

* smc911x_findirq

1742

* smc911x_findirq

1738

*

1743

*

1739

* This routine has a simple purpose -- make the SMC chip generate an

1744

* This routine has a simple purpose -- make the SMC chip generate an

1740

* interrupt, so an auto-detect routine can detect it, and find the IRQ,

1745

* interrupt, so an auto-detect routine can detect it, and find the IRQ,

1741

*/

1746

*/

1742

static int __init smc911x_findirq(struct net_device *dev)

1747

static int __init smc911x_findirq(struct net_device *dev)

1743

{

1748

{

1744

struct smc911x_local *lp = netdev_priv(dev);

1749

struct smc911x_local *lp = netdev_priv(dev);

1745

int timeout = 20;

1750

int timeout = 20;

1746

unsigned long cookie;

1751

unsigned long cookie;

1747

1752

1748

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

1753

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

1749

1754

1750

cookie = probe_irq_on();

1755

cookie = probe_irq_on();

1751

1756

1752

/*

1757

/*

1753

* Force a SW interrupt

1758

* Force a SW interrupt

1754

*/

1759

*/

1755

1760

1756

SMC_SET_INT_EN(lp, INT_EN_SW_INT_EN_);

1761

SMC_SET_INT_EN(lp, INT_EN_SW_INT_EN_);

1757

1762

1758

/*

1763

/*

1759

* Wait until positive that the interrupt has been generated

1764

* Wait until positive that the interrupt has been generated

1760

*/

1765

*/

1761

do {

1766

do {

1762

int int_status;

1767

int int_status;

1763

udelay(10);

1768

udelay(10);

1764

int_status = SMC_GET_INT_EN(lp);

1769

int_status = SMC_GET_INT_EN(lp);

1765

if (int_status & INT_EN_SW_INT_EN_)

1770

if (int_status & INT_EN_SW_INT_EN_)

1766

break; /* got the interrupt */

1771

break; /* got the interrupt */

1767

} while (--timeout);

1772

} while (--timeout);

1768

1773

1769

/*

1774

/*

1770

* there is really nothing that I can do here if timeout fails,

1775

* there is really nothing that I can do here if timeout fails,

1771

* as autoirq_report will return a 0 anyway, which is what I

1776

* as autoirq_report will return a 0 anyway, which is what I

1772

* want in this case. Plus, the clean up is needed in both

1777

* want in this case. Plus, the clean up is needed in both

1773

* cases.

1778

* cases.

1774

*/

1779

*/

1775

1780

1776

/* and disable all interrupts again */

1781

/* and disable all interrupts again */

1777

SMC_SET_INT_EN(lp, 0);

1782

SMC_SET_INT_EN(lp, 0);

1778

1783

1779

/* and return what I found */

1784

/* and return what I found */

1780

return probe_irq_off(cookie);

1785

return probe_irq_off(cookie);

1781

}

1786

}

1782

1787

1783

/*

1788

/*

1784

* Function: smc911x_probe(unsigned long ioaddr)

1789

* Function: smc911x_probe(unsigned long ioaddr)

1785

*

1790

*

1786

* Purpose:

1791

* Purpose:

1787

* Tests to see if a given ioaddr points to an SMC911x chip.

1792

* Tests to see if a given ioaddr points to an SMC911x chip.

1788

* Returns a 0 on success

1793

* Returns a 0 on success

1789

*

1794

*

1790

* Algorithm:

1795

* Algorithm:

1791

* (1) see if the endian word is OK

1796

* (1) see if the endian word is OK

1792

* (1) see if I recognize the chip ID in the appropriate register

1797

* (1) see if I recognize the chip ID in the appropriate register

1793

*

1798

*

1794

* Here I do typical initialization tasks.

1799

* Here I do typical initialization tasks.

1795

*

1800

*

1796

* o Initialize the structure if needed

1801

* o Initialize the structure if needed

1797

* o print out my vanity message if not done so already

1802

* o print out my vanity message if not done so already

1798

* o print out what type of hardware is detected

1803

* o print out what type of hardware is detected

1799

* o print out the ethernet address

1804

* o print out the ethernet address

1800

* o find the IRQ

1805

* o find the IRQ

1801

* o set up my private data

1806

* o set up my private data

1802

* o configure the dev structure with my subroutines

1807

* o configure the dev structure with my subroutines

1803

* o actually GRAB the irq.

1808

* o actually GRAB the irq.

1804

* o GRAB the region

1809

* o GRAB the region

1805

*/

1810

*/

1806

static int __init smc911x_probe(struct net_device *dev)

1811

static int __init smc911x_probe(struct net_device *dev)

1807

{

1812

{

1808

struct smc911x_local *lp = netdev_priv(dev);

1813

struct smc911x_local *lp = netdev_priv(dev);

1809

int i, retval;

1814

int i, retval;

1810

unsigned int val, chip_id, revision;

1815

unsigned int val, chip_id, revision;

1811

const char *version_string;

1816

const char *version_string;

1812

unsigned long irq_flags;

1817

unsigned long irq_flags;

1813

1818

1814

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1819

DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);

1815

1820

1816

/* First, see if the endian word is recognized */

1821

/* First, see if the endian word is recognized */

1817

val = SMC_GET_BYTE_TEST(lp);

1822

val = SMC_GET_BYTE_TEST(lp);

1818

DBG(SMC_DEBUG_MISC, "%s: endian probe returned 0x%04x\n", CARDNAME, val);

1823

DBG(SMC_DEBUG_MISC, "%s: endian probe returned 0x%04x\n", CARDNAME, val);

1819

if (val != 0x87654321) {

1824

if (val != 0x87654321) {

1820

printk(KERN_ERR "Invalid chip endian 0x08%x\n",val);

1825

printk(KERN_ERR "Invalid chip endian 0x08%x\n",val);

1821

retval = -ENODEV;

1826

retval = -ENODEV;

1822

goto err_out;

1827

goto err_out;

1823

}

1828

}

1824

1829

1825

/*

1830

/*

1826

* check if the revision register is something that I

1831

* check if the revision register is something that I

1827

* recognize. These might need to be added to later,

1832

* recognize. These might need to be added to later,

1828

* as future revisions could be added.

1833

* as future revisions could be added.

1829

*/

1834

*/

1830

chip_id = SMC_GET_PN(lp);

1835

chip_id = SMC_GET_PN(lp);

1831

DBG(SMC_DEBUG_MISC, "%s: id probe returned 0x%04x\n", CARDNAME, chip_id);

1836

DBG(SMC_DEBUG_MISC, "%s: id probe returned 0x%04x\n", CARDNAME, chip_id);

1832

for(i=0;chip_ids[i].id != 0; i++) {

1837

for(i=0;chip_ids[i].id != 0; i++) {

1833

if (chip_ids[i].id == chip_id) break;

1838

if (chip_ids[i].id == chip_id) break;

1834

}

1839

}

1835

if (!chip_ids[i].id) {

1840

if (!chip_ids[i].id) {

1836

printk(KERN_ERR "Unknown chip ID %04x\n", chip_id);

1841

printk(KERN_ERR "Unknown chip ID %04x\n", chip_id);

1837

retval = -ENODEV;

1842

retval = -ENODEV;

1838

goto err_out;

1843

goto err_out;

1839

}

1844

}

1840

version_string = chip_ids[i].name;

1845

version_string = chip_ids[i].name;

1841

1846

1842

revision = SMC_GET_REV(lp);

1847

revision = SMC_GET_REV(lp);

1843

DBG(SMC_DEBUG_MISC, "%s: revision = 0x%04x\n", CARDNAME, revision);

1848

DBG(SMC_DEBUG_MISC, "%s: revision = 0x%04x\n", CARDNAME, revision);

1844

1849

1845

/* At this point I'll assume that the chip is an SMC911x. */

1850

/* At this point I'll assume that the chip is an SMC911x. */

1846

DBG(SMC_DEBUG_MISC, "%s: Found a %s\n", CARDNAME, chip_ids[i].name);

1851

DBG(SMC_DEBUG_MISC, "%s: Found a %s\n", CARDNAME, chip_ids[i].name);

1847

1852

1848

/* Validate the TX FIFO size requested */

1853

/* Validate the TX FIFO size requested */

1849

if ((tx_fifo_kb < 2) || (tx_fifo_kb > 14)) {

1854

if ((tx_fifo_kb < 2) || (tx_fifo_kb > 14)) {

1850

printk(KERN_ERR "Invalid TX FIFO size requested %d\n", tx_fifo_kb);

1855

printk(KERN_ERR "Invalid TX FIFO size requested %d\n", tx_fifo_kb);

1851

retval = -EINVAL;

1856

retval = -EINVAL;

1852

goto err_out;

1857

goto err_out;

1853

}

1858

}

1854

1859

1855

/* fill in some of the fields */

1860

/* fill in some of the fields */

1856

lp->version = chip_ids[i].id;

1861

lp->version = chip_ids[i].id;

1857

lp->revision = revision;

1862

lp->revision = revision;

1858

lp->tx_fifo_kb = tx_fifo_kb;

1863

lp->tx_fifo_kb = tx_fifo_kb;

1859

/* Reverse calculate the RX FIFO size from the TX */

1864

/* Reverse calculate the RX FIFO size from the TX */

1860

lp->tx_fifo_size=(lp->tx_fifo_kb<<10) - 512;

1865

lp->tx_fifo_size=(lp->tx_fifo_kb<<10) - 512;

1861

lp->rx_fifo_size= ((0x4000 - 512 - lp->tx_fifo_size) / 16) * 15;

1866

lp->rx_fifo_size= ((0x4000 - 512 - lp->tx_fifo_size) / 16) * 15;

1862

1867

1863

/* Set the automatic flow control values */

1868

/* Set the automatic flow control values */

1864

switch(lp->tx_fifo_kb) {

1869

switch(lp->tx_fifo_kb) {

1865

/*

1870

/*

1866

* AFC_HI is about ((Rx Data Fifo Size)*2/3)/64

1871

* AFC_HI is about ((Rx Data Fifo Size)*2/3)/64

1867

* AFC_LO is AFC_HI/2

1872

* AFC_LO is AFC_HI/2

1868

* BACK_DUR is about 5uS*(AFC_LO) rounded down

1873

* BACK_DUR is about 5uS*(AFC_LO) rounded down

1869

*/

1874

*/

1870

case 2:/* 13440 Rx Data Fifo Size */

1875

case 2:/* 13440 Rx Data Fifo Size */

1871

lp->afc_cfg=0x008C46AF;break;

1876

lp->afc_cfg=0x008C46AF;break;

1872

case 3:/* 12480 Rx Data Fifo Size */

1877

case 3:/* 12480 Rx Data Fifo Size */

1873

lp->afc_cfg=0x0082419F;break;

1878

lp->afc_cfg=0x0082419F;break;

1874

case 4:/* 11520 Rx Data Fifo Size */

1879

case 4:/* 11520 Rx Data Fifo Size */

1875

lp->afc_cfg=0x00783C9F;break;

1880

lp->afc_cfg=0x00783C9F;break;

1876

case 5:/* 10560 Rx Data Fifo Size */

1881

case 5:/* 10560 Rx Data Fifo Size */

1877

lp->afc_cfg=0x006E374F;break;

1882

lp->afc_cfg=0x006E374F;break;

1878

case 6:/* 9600 Rx Data Fifo Size */

1883

case 6:/* 9600 Rx Data Fifo Size */

1879

lp->afc_cfg=0x0064328F;break;

1884

lp->afc_cfg=0x0064328F;break;

1880

case 7:/* 8640 Rx Data Fifo Size */

1885

case 7:/* 8640 Rx Data Fifo Size */

1881

lp->afc_cfg=0x005A2D7F;break;

1886

lp->afc_cfg=0x005A2D7F;break;

1882

case 8:/* 7680 Rx Data Fifo Size */

1887

case 8:/* 7680 Rx Data Fifo Size */

1883

lp->afc_cfg=0x0050287F;break;

1888

lp->afc_cfg=0x0050287F;break;

1884

case 9:/* 6720 Rx Data Fifo Size */

1889

case 9:/* 6720 Rx Data Fifo Size */

1885

lp->afc_cfg=0x0046236F;break;

1890

lp->afc_cfg=0x0046236F;break;

1886

case 10:/* 5760 Rx Data Fifo Size */

1891

case 10:/* 5760 Rx Data Fifo Size */

1887

lp->afc_cfg=0x003C1E6F;break;

1892

lp->afc_cfg=0x003C1E6F;break;

1888

case 11:/* 4800 Rx Data Fifo Size */

1893

case 11:/* 4800 Rx Data Fifo Size */

1889

lp->afc_cfg=0x0032195F;break;

1894

lp->afc_cfg=0x0032195F;break;

1890

/*

1895

/*

1891

* AFC_HI is ~1520 bytes less than RX Data Fifo Size

1896

* AFC_HI is ~1520 bytes less than RX Data Fifo Size

1892

* AFC_LO is AFC_HI/2

1897

* AFC_LO is AFC_HI/2

1893

* BACK_DUR is about 5uS*(AFC_LO) rounded down

1898

* BACK_DUR is about 5uS*(AFC_LO) rounded down

1894

*/

1899

*/

1895

case 12:/* 3840 Rx Data Fifo Size */

1900

case 12:/* 3840 Rx Data Fifo Size */

1896

lp->afc_cfg=0x0024124F;break;

1901

lp->afc_cfg=0x0024124F;break;

1897

case 13:/* 2880 Rx Data Fifo Size */

1902

case 13:/* 2880 Rx Data Fifo Size */

1898

lp->afc_cfg=0x0015073F;break;

1903

lp->afc_cfg=0x0015073F;break;

1899

case 14:/* 1920 Rx Data Fifo Size */

1904

case 14:/* 1920 Rx Data Fifo Size */

1900

lp->afc_cfg=0x0006032F;break;

1905

lp->afc_cfg=0x0006032F;break;

1901

default:

1906

default:

1902

PRINTK("%s: ERROR -- no AFC_CFG setting found",

1907

PRINTK("%s: ERROR -- no AFC_CFG setting found",

1903

dev->name);

1908

dev->name);

1904

break;

1909

break;

1905

}

1910

}

1906

1911

1907

DBG(SMC_DEBUG_MISC | SMC_DEBUG_TX | SMC_DEBUG_RX,

1912

DBG(SMC_DEBUG_MISC | SMC_DEBUG_TX | SMC_DEBUG_RX,

1908

"%s: tx_fifo %d rx_fifo %d afc_cfg 0x%08x\n", CARDNAME,

1913

"%s: tx_fifo %d rx_fifo %d afc_cfg 0x%08x\n", CARDNAME,

1909

lp->tx_fifo_size, lp->rx_fifo_size, lp->afc_cfg);

1914

lp->tx_fifo_size, lp->rx_fifo_size, lp->afc_cfg);

1910

1915

1911

spin_lock_init(&lp->lock);

1916

spin_lock_init(&lp->lock);

1912

1917

1913

/* Get the MAC address */

1918

/* Get the MAC address */

1914

SMC_GET_MAC_ADDR(lp, dev->dev_addr);

1919

SMC_GET_MAC_ADDR(lp, dev->dev_addr);

1915

1920

1916

/* now, reset the chip, and put it into a known state */

1921

/* now, reset the chip, and put it into a known state */

1917

smc911x_reset(dev);

1922

smc911x_reset(dev);

1918

1923

1919

/*

1924

/*

1920

* If dev->irq is 0, then the device has to be banged on to see

1925

* If dev->irq is 0, then the device has to be banged on to see

1921

* what the IRQ is.

1926

* what the IRQ is.

1922

*

1927

*

1923

* Specifying an IRQ is done with the assumption that the user knows

1928

* Specifying an IRQ is done with the assumption that the user knows

1924

* what (s)he is doing. No checking is done!!!!

1929

* what (s)he is doing. No checking is done!!!!

1925

*/

1930

*/

1926

if (dev->irq < 1) {

1931

if (dev->irq < 1) {

1927

int trials;

1932

int trials;

1928

1933

1929

trials = 3;

1934

trials = 3;

1930

while (trials--) {

1935

while (trials--) {

1931

dev->irq = smc911x_findirq(dev);

1936

dev->irq = smc911x_findirq(dev);

1932

if (dev->irq)

1937

if (dev->irq)

1933

break;

1938

break;

1934

/* kick the card and try again */

1939

/* kick the card and try again */

1935

smc911x_reset(dev);

1940

smc911x_reset(dev);

1936

}

1941

}

1937

}

1942

}

1938

if (dev->irq == 0) {

1943

if (dev->irq == 0) {

1939

printk("%s: Couldn't autodetect your IRQ. Use irq=xx.\n",

1944

printk("%s: Couldn't autodetect your IRQ. Use irq=xx.\n",

1940

dev->name);

1945

dev->name);

1941

retval = -ENODEV;

1946

retval = -ENODEV;

1942

goto err_out;

1947

goto err_out;

1943

}

1948

}

1944

dev->irq = irq_canonicalize(dev->irq);

1949

dev->irq = irq_canonicalize(dev->irq);

1945

1950

1946

/* Fill in the fields of the device structure with ethernet values. */

1951

/* Fill in the fields of the device structure with ethernet values. */

1947

ether_setup(dev);

1952

ether_setup(dev);

1948

1953

1949

dev->open = smc911x_open;

1954

dev->open = smc911x_open;

1950

dev->stop = smc911x_close;

1955

dev->stop = smc911x_close;

1951

dev->hard_start_xmit = smc911x_hard_start_xmit;

1956

dev->hard_start_xmit = smc911x_hard_start_xmit;

1952

dev->tx_timeout = smc911x_timeout;

1957

dev->tx_timeout = smc911x_timeout;

1953

dev->watchdog_timeo = msecs_to_jiffies(watchdog);

1958

dev->watchdog_timeo = msecs_to_jiffies(watchdog);

1954

dev->set_multicast_list = smc911x_set_multicast_list;

1959

dev->set_multicast_list = smc911x_set_multicast_list;

1955

dev->ethtool_ops = &smc911x_ethtool_ops;

1960

dev->ethtool_ops = &smc911x_ethtool_ops;

1956

#ifdef CONFIG_NET_POLL_CONTROLLER

1961

#ifdef CONFIG_NET_POLL_CONTROLLER

1957

dev->poll_controller = smc911x_poll_controller;

1962

dev->poll_controller = smc911x_poll_controller;

1958

#endif

1963

#endif

1959

1964

1960

INIT_WORK(&lp->phy_configure, smc911x_phy_configure);

1965

INIT_WORK(&lp->phy_configure, smc911x_phy_configure);

1961

lp->mii.phy_id_mask = 0x1f;

1966

lp->mii.phy_id_mask = 0x1f;

1962

lp->mii.reg_num_mask = 0x1f;

1967

lp->mii.reg_num_mask = 0x1f;

1963

lp->mii.force_media = 0;

1968

lp->mii.force_media = 0;

1964

lp->mii.full_duplex = 0;

1969

lp->mii.full_duplex = 0;

1965

lp->mii.dev = dev;

1970

lp->mii.dev = dev;

1966

lp->mii.mdio_read = smc911x_phy_read;

1971

lp->mii.mdio_read = smc911x_phy_read;

1967

lp->mii.mdio_write = smc911x_phy_write;

1972

lp->mii.mdio_write = smc911x_phy_write;

1968

1973

1969

/*

1974

/*

1970

* Locate the phy, if any.

1975

* Locate the phy, if any.

1971

*/

1976

*/

1972

smc911x_phy_detect(dev);

1977

smc911x_phy_detect(dev);

1973

1978

1974

/* Set default parameters */

1979

/* Set default parameters */

1975

lp->msg_enable = NETIF_MSG_LINK;

1980

lp->msg_enable = NETIF_MSG_LINK;

1976

lp->ctl_rfduplx = 1;

1981

lp->ctl_rfduplx = 1;

1977

lp->ctl_rspeed = 100;

1982

lp->ctl_rspeed = 100;

1978

1983

1979

#ifdef SMC_DYNAMIC_BUS_CONFIG

1984

#ifdef SMC_DYNAMIC_BUS_CONFIG

1980

irq_flags = lp->cfg.irq_flags;

1985

irq_flags = lp->cfg.irq_flags;

1981

#else

1986

#else

1982

irq_flags = IRQF_SHARED | SMC_IRQ_SENSE;

1987

irq_flags = IRQF_SHARED | SMC_IRQ_SENSE;

1983

#endif

1988

#endif

1984

1989

1985

/* Grab the IRQ */

1990

/* Grab the IRQ */

1986

retval = request_irq(dev->irq, &smc911x_interrupt,

1991

retval = request_irq(dev->irq, &smc911x_interrupt,

1987

irq_flags, dev->name, dev);

1992

irq_flags, dev->name, dev);

1988

if (retval)

1993

if (retval)

1989

goto err_out;

1994

goto err_out;

1990

1995

1991

#ifdef SMC_USE_DMA

1996

#ifdef SMC_USE_DMA

1992

lp->rxdma = SMC_DMA_REQUEST(dev, smc911x_rx_dma_irq);

1997

lp->rxdma = SMC_DMA_REQUEST(dev, smc911x_rx_dma_irq);

1993

lp->txdma = SMC_DMA_REQUEST(dev, smc911x_tx_dma_irq);

1998

lp->txdma = SMC_DMA_REQUEST(dev, smc911x_tx_dma_irq);

1994

lp->rxdma_active = 0;

1999

lp->rxdma_active = 0;

1995

lp->txdma_active = 0;

2000

lp->txdma_active = 0;

1996

dev->dma = lp->rxdma;

2001

dev->dma = lp->rxdma;

1997

#endif

2002

#endif

1998

2003

1999

retval = register_netdev(dev);

2004

retval = register_netdev(dev);

2000

if (retval == 0) {

2005

if (retval == 0) {

2001

/* now, print out the card info, in a short format.. */

2006

/* now, print out the card info, in a short format.. */

2002

printk("%s: %s (rev %d) at %#lx IRQ %d",

2007

printk("%s: %s (rev %d) at %#lx IRQ %d",

2003

dev->name, version_string, lp->revision,

2008

dev->name, version_string, lp->revision,

2004

dev->base_addr, dev->irq);

2009

dev->base_addr, dev->irq);

2005

2010

2006

#ifdef SMC_USE_DMA

2011

#ifdef SMC_USE_DMA

2007

if (lp->rxdma != -1)

2012

if (lp->rxdma != -1)

2008

printk(" RXDMA %d ", lp->rxdma);

2013

printk(" RXDMA %d ", lp->rxdma);

2009

2014

2010

if (lp->txdma != -1)

2015

if (lp->txdma != -1)

2011

printk("TXDMA %d", lp->txdma);

2016

printk("TXDMA %d", lp->txdma);

2012

#endif

2017

#endif

2013

printk("\n");

2018

printk("\n");

2014

if (!is_valid_ether_addr(dev->dev_addr)) {

2019

if (!is_valid_ether_addr(dev->dev_addr)) {

2015

printk("%s: Invalid ethernet MAC address. Please "

2020

printk("%s: Invalid ethernet MAC address. Please "

2016

"set using ifconfig\n", dev->name);

2021

"set using ifconfig\n", dev->name);

2017

} else {

2022

} else {

2018

/* Print the Ethernet address */

2023

/* Print the Ethernet address */

2019

printk("%s: Ethernet addr: ", dev->name);

2024

printk("%s: Ethernet addr: ", dev->name);

2020

for (i = 0; i < 5; i++)

2025

for (i = 0; i < 5; i++)

2021

printk("%2.2x:", dev->dev_addr[i]);

2026

printk("%2.2x:", dev->dev_addr[i]);

2022

printk("%2.2x\n", dev->dev_addr[5]);

2027

printk("%2.2x\n", dev->dev_addr[5]);

2023

}

2028

}

2024

2029

2025

if (lp->phy_type == 0) {

2030

if (lp->phy_type == 0) {

2026

PRINTK("%s: No PHY found\n", dev->name);

2031

PRINTK("%s: No PHY found\n", dev->name);

2027

} else if ((lp->phy_type & ~0xff) == LAN911X_INTERNAL_PHY_ID) {

2032

} else if ((lp->phy_type & ~0xff) == LAN911X_INTERNAL_PHY_ID) {

2028

PRINTK("%s: LAN911x Internal PHY\n", dev->name);

2033

PRINTK("%s: LAN911x Internal PHY\n", dev->name);

2029

} else {

2034

} else {

2030

PRINTK("%s: External PHY 0x%08x\n", dev->name, lp->phy_type);

2035

PRINTK("%s: External PHY 0x%08x\n", dev->name, lp->phy_type);

2031

}

2036

}

2032

}

2037

}

2033

2038

2034

err_out:

2039

err_out:

2035

#ifdef SMC_USE_DMA

2040

#ifdef SMC_USE_DMA

2036

if (retval) {

2041

if (retval) {

2037

if (lp->rxdma != -1) {

2042

if (lp->rxdma != -1) {

2038

SMC_DMA_FREE(dev, lp->rxdma);

2043

SMC_DMA_FREE(dev, lp->rxdma);

2039

}

2044

}

2040

if (lp->txdma != -1) {

2045

if (lp->txdma != -1) {

2041

SMC_DMA_FREE(dev, lp->txdma);

2046

SMC_DMA_FREE(dev, lp->txdma);

2042

}

2047

}

2043

}

2048

}

2044

#endif

2049

#endif

2045

return retval;

2050

return retval;

2046

}

2051

}

2047

2052

2048

/*

2053

/*

2049

* smc911x_init(void)

2054

* smc911x_init(void)

2050

*

2055

*

2051

* Output:

2056

* Output:

2052

* 0 --> there is a device

2057

* 0 --> there is a device

2053

* anything else, error

2058

* anything else, error

2054

*/

2059

*/

2055

static int smc911x_drv_probe(struct platform_device *pdev)

2060

static int smc911x_drv_probe(struct platform_device *pdev)

2056

{

2061

{

2057

struct smc91x_platdata *pd = pdev->dev.platform_data;

2062

struct smc911x_platdata *pd = pdev->dev.platform_data;

2058

struct net_device *ndev;

2063

struct net_device *ndev;

2059

struct resource *res;

2064

struct resource *res;

2060

struct smc911x_local *lp;

2065

struct smc911x_local *lp;

2061

unsigned int *addr;

2066

unsigned int *addr;

2062

int ret;

2067

int ret;

2063

2068

2064

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2069

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2065

res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

2070

res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

2066

if (!res) {

2071

if (!res) {

2067

ret = -ENODEV;

2072

ret = -ENODEV;

2068

goto out;

2073

goto out;

2069

}

2074

}

2070

2075

2071

/*

2076

/*

2072

* Request the regions.

2077

* Request the regions.

2073

*/

2078

*/

2074

if (!request_mem_region(res->start, SMC911X_IO_EXTENT, CARDNAME)) {

2079

if (!request_mem_region(res->start, SMC911X_IO_EXTENT, CARDNAME)) {

2075

ret = -EBUSY;

2080

ret = -EBUSY;

2076

goto out;

2081

goto out;

2077

}

2082

}

2078

2083

2079

ndev = alloc_etherdev(sizeof(struct smc911x_local));

2084

ndev = alloc_etherdev(sizeof(struct smc911x_local));

2080

if (!ndev) {

2085

if (!ndev) {

2081

printk("%s: could not allocate device.\n", CARDNAME);

2086

printk("%s: could not allocate device.\n", CARDNAME);

2082

ret = -ENOMEM;

2087

ret = -ENOMEM;

2083

goto release_1;

2088

goto release_1;

2084

}

2089

}

2085

SET_NETDEV_DEV(ndev, &pdev->dev);

2090

SET_NETDEV_DEV(ndev, &pdev->dev);

2086

2091

2087

ndev->dma = (unsigned char)-1;

2092

ndev->dma = (unsigned char)-1;

2088

ndev->irq = platform_get_irq(pdev, 0);

2093

ndev->irq = platform_get_irq(pdev, 0);

2089

lp = netdev_priv(ndev);

2094

lp = netdev_priv(ndev);

2090

lp->netdev = ndev;

2095

lp->netdev = ndev;

2091

#ifdef SMC_DYNAMIC_BUS_CONFIG

2096

#ifdef SMC_DYNAMIC_BUS_CONFIG

2092

if (!pd) {

2097

if (!pd) {

2093

ret = -EINVAL;

2098

ret = -EINVAL;

2094

goto release_both;

2099

goto release_both;

2095

}

2100

}

2096

memcpy(&lp->cfg, pd, sizeof(lp->cfg));

2101

memcpy(&lp->cfg, pd, sizeof(lp->cfg));

2097

#endif

2102

#endif

2098

2103

2099

addr = ioremap(res->start, SMC911X_IO_EXTENT);

2104

addr = ioremap(res->start, SMC911X_IO_EXTENT);

2100

if (!addr) {

2105

if (!addr) {

2101

ret = -ENOMEM;

2106

ret = -ENOMEM;

2102

goto release_both;

2107

goto release_both;

2103

}

2108

}

2104

2109

2105

platform_set_drvdata(pdev, ndev);

2110

platform_set_drvdata(pdev, ndev);

2106

lp->base = addr;

2111

lp->base = addr;

2107

ndev->base_addr = res->start;

2112

ndev->base_addr = res->start;

2108

ret = smc911x_probe(ndev);

2113

ret = smc911x_probe(ndev);

2109

if (ret != 0) {

2114

if (ret != 0) {

2110

platform_set_drvdata(pdev, NULL);

2115

platform_set_drvdata(pdev, NULL);

2111

iounmap(addr);

2116

iounmap(addr);

2112

release_both:

2117

release_both:

2113

free_netdev(ndev);

2118

free_netdev(ndev);

2114

release_1:

2119

release_1:

2115

release_mem_region(res->start, SMC911X_IO_EXTENT);

2120

release_mem_region(res->start, SMC911X_IO_EXTENT);

2116

out:

2121

out:

2117

printk("%s: not found (%d).\n", CARDNAME, ret);

2122

printk("%s: not found (%d).\n", CARDNAME, ret);

2118

}

2123

}

2119

#ifdef SMC_USE_DMA

2124

#ifdef SMC_USE_DMA

2120

else {

2125

else {

2121

lp->physaddr = res->start;

2126

lp->physaddr = res->start;

2122

lp->dev = &pdev->dev;

2127

lp->dev = &pdev->dev;

2123

}

2128

}

2124

#endif

2129

#endif

2125

2130

2126

return ret;

2131

return ret;

2127

}

2132

}

2128

2133

2129

static int smc911x_drv_remove(struct platform_device *pdev)

2134

static int smc911x_drv_remove(struct platform_device *pdev)

2130

{

2135

{

2131

struct net_device *ndev = platform_get_drvdata(pdev);

2136

struct net_device *ndev = platform_get_drvdata(pdev);

2132

struct smc911x_local *lp = netdev_priv(ndev);

2137

struct smc911x_local *lp = netdev_priv(ndev);

2133

struct resource *res;

2138

struct resource *res;

2134

2139

2135

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2140

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2136

platform_set_drvdata(pdev, NULL);

2141

platform_set_drvdata(pdev, NULL);

2137

2142

2138

unregister_netdev(ndev);

2143

unregister_netdev(ndev);

2139

2144

2140

free_irq(ndev->irq, ndev);

2145

free_irq(ndev->irq, ndev);

2141

2146

2142

#ifdef SMC_USE_DMA

2147

#ifdef SMC_USE_DMA

2143

{

2148

{

2144

if (lp->rxdma != -1) {

2149

if (lp->rxdma != -1) {

2145

SMC_DMA_FREE(dev, lp->rxdma);

2150

SMC_DMA_FREE(dev, lp->rxdma);

2146

}

2151

}

2147

if (lp->txdma != -1) {

2152

if (lp->txdma != -1) {

2148

SMC_DMA_FREE(dev, lp->txdma);

2153

SMC_DMA_FREE(dev, lp->txdma);

2149

}

2154

}

2150

}

2155

}

2151

#endif

2156

#endif

2152

iounmap(lp->base);

2157

iounmap(lp->base);

2153

res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

2158

res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

2154

release_mem_region(res->start, SMC911X_IO_EXTENT);

2159

release_mem_region(res->start, SMC911X_IO_EXTENT);

2155

2160

2156

free_netdev(ndev);

2161

free_netdev(ndev);

2157

return 0;

2162

return 0;

2158

}

2163

}

2159

2164

2160

static int smc911x_drv_suspend(struct platform_device *dev, pm_message_t state)

2165

static int smc911x_drv_suspend(struct platform_device *dev, pm_message_t state)

2161

{

2166

{

2162

struct net_device *ndev = platform_get_drvdata(dev);

2167

struct net_device *ndev = platform_get_drvdata(dev);

2163

struct smc911x_local *lp = netdev_priv(ndev);

2168

struct smc911x_local *lp = netdev_priv(ndev);

2164

2169

2165

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2170

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2166

if (ndev) {

2171

if (ndev) {

2167

if (netif_running(ndev)) {

2172

if (netif_running(ndev)) {

2168

netif_device_detach(ndev);

2173

netif_device_detach(ndev);

2169

smc911x_shutdown(ndev);

2174

smc911x_shutdown(ndev);

2170

#if POWER_DOWN

2175

#if POWER_DOWN

2171

/* Set D2 - Energy detect only setting */

2176

/* Set D2 - Energy detect only setting */

2172

SMC_SET_PMT_CTRL(lp, 2<<12);

2177

SMC_SET_PMT_CTRL(lp, 2<<12);

2173

#endif

2178

#endif

2174

}

2179

}

2175

}

2180

}

2176

return 0;

2181

return 0;

2177

}

2182

}

2178

2183

2179

static int smc911x_drv_resume(struct platform_device *dev)

2184

static int smc911x_drv_resume(struct platform_device *dev)

2180

{

2185

{

2181

struct net_device *ndev = platform_get_drvdata(dev);

2186

struct net_device *ndev = platform_get_drvdata(dev);

2182

2187

2183

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2188

DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);

2184

if (ndev) {

2189

if (ndev) {

2185

struct smc911x_local *lp = netdev_priv(ndev);

2190

struct smc911x_local *lp = netdev_priv(ndev);

2186

2191

2187

if (netif_running(ndev)) {

2192

if (netif_running(ndev)) {

2188

smc911x_reset(ndev);

2193

smc911x_reset(ndev);

2189

smc911x_enable(ndev);

2194

smc911x_enable(ndev);

2190

if (lp->phy_type != 0)

2195

if (lp->phy_type != 0)

2191

smc911x_phy_configure(&lp->phy_configure);

2196

smc911x_phy_configure(&lp->phy_configure);

2192

netif_device_attach(ndev);

2197

netif_device_attach(ndev);

2193

}

2198

}

2194

}

2199

}

2195

return 0;

2200

return 0;

2196

}

2201

}

2197

2202

2198

static struct platform_driver smc911x_driver = {

2203

static struct platform_driver smc911x_driver = {

2199

.probe = smc911x_drv_probe,

2204

.probe = smc911x_drv_probe,

2200

.remove = smc911x_drv_remove,

2205

.remove = smc911x_drv_remove,

2201

.suspend = smc911x_drv_suspend,

2206

.suspend = smc911x_drv_suspend,

2202

.resume = smc911x_drv_resume,

2207

.resume = smc911x_drv_resume,

2203

.driver = {

2208

.driver = {

2204

.name = CARDNAME,

2209

.name = CARDNAME,

2205

.owner = THIS_MODULE,

2210

.owner = THIS_MODULE,

2206

},

2211

},

2207

};

2212

};

2208

2213

2209

static int __init smc911x_init(void)

2214

static int __init smc911x_init(void)

2210

{

2215

{

2211

return platform_driver_register(&smc911x_driver);

2216

return platform_driver_register(&smc911x_driver);

2212

}

2217

}

2213

2218

2214

static void __exit smc911x_cleanup(void)

2219

static void __exit smc911x_cleanup(void)

2215

{

2220

{

2216

platform_driver_unregister(&smc911x_driver);

2221

platform_driver_unregister(&smc911x_driver);

2217

}

2222

}

2218

2223

2219

module_init(smc911x_init);

2224

module_init(smc911x_init);

2220

module_exit(smc911x_cleanup);

2225

module_exit(smc911x_cleanup);

2221

2226

 #ifndef __SMC911X_H__
 #define __SMC911X_H__
 #define SMC911X_USE_16BIT (1 << 0)
 #define SMC911X_USE_32BIT (1 << 1)
 struct smc911x_platdata {
 	unsigned long flags;
 	unsigned long irq_flags; /* IRQF_... */
+	int irq_polarity;
 };
 #endif /* __SMC911X_H__ */

GITLAB

smc911x: Add IRQ polarity configuration

 /*
  * smc911x.c
  * This is a driver for SMSC's LAN911{5,6,7,8} single-chip Ethernet devices.
  *
  * Copyright (C) 2005 Sensoria Corp
  *	   Derived from the unified SMC91x driver by Nicolas Pitre
  *	   and the smsc911x.c reference driver by SMSC
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  * Arguments:
  *	 watchdog  = TX watchdog timeout
  *	 tx_fifo_kb = Size of TX FIFO in KB
  *
  * History:
  *	  04/16/05	Dustin McIntire		 Initial version
  */
 static const char version[] =
 	 "smc911x.c: v1.0 04-16-2005 by Dustin McIntire <dustin@sensoria.com>\n";
 /* Debugging options */
 #define ENABLE_SMC_DEBUG_RX		0
 #define ENABLE_SMC_DEBUG_TX		0
 #define ENABLE_SMC_DEBUG_DMA		0
 #define ENABLE_SMC_DEBUG_PKTS		0
 #define ENABLE_SMC_DEBUG_MISC		0
 #define ENABLE_SMC_DEBUG_FUNC		0
 #define SMC_DEBUG_RX		((ENABLE_SMC_DEBUG_RX	? 1 : 0) << 0)
 #define SMC_DEBUG_TX		((ENABLE_SMC_DEBUG_TX	? 1 : 0) << 1)
 #define SMC_DEBUG_DMA		((ENABLE_SMC_DEBUG_DMA	? 1 : 0) << 2)
 #define SMC_DEBUG_PKTS		((ENABLE_SMC_DEBUG_PKTS ? 1 : 0) << 3)
 #define SMC_DEBUG_MISC		((ENABLE_SMC_DEBUG_MISC ? 1 : 0) << 4)
 #define SMC_DEBUG_FUNC		((ENABLE_SMC_DEBUG_FUNC ? 1 : 0) << 5)
 #ifndef SMC_DEBUG
 #define SMC_DEBUG	 ( SMC_DEBUG_RX	  | \
 			   SMC_DEBUG_TX	  | \
 			   SMC_DEBUG_DMA  | \
 			   SMC_DEBUG_PKTS | \
 			   SMC_DEBUG_MISC | \
 			   SMC_DEBUG_FUNC   \
 			 )
 #endif
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
 #include <linux/ioport.h>
 #include <linux/crc32.h>
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
 #include <linux/workqueue.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/skbuff.h>
 #include <asm/io.h>
 #include "smc911x.h"
 /*
  * Transmit timeout, default 5 seconds.
  */
 static int watchdog = 5000;
 module_param(watchdog, int, 0400);
 MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");
 static int tx_fifo_kb=8;
 module_param(tx_fifo_kb, int, 0400);
 MODULE_PARM_DESC(tx_fifo_kb,"transmit FIFO size in KB (1<x<15)(default=8)");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:smc911x");
 /*
  * The internal workings of the driver.  If you are changing anything
  * here with the SMC stuff, you should have the datasheet and know
  * what you are doing.
  */
 #define CARDNAME "smc911x"
 /*
  * Use power-down feature of the chip
  */
 #define POWER_DOWN		 1
 #if SMC_DEBUG > 0
 #define DBG(n, args...)				 \
 	do {					 \
 		if (SMC_DEBUG & (n))		 \
 			printk(args);		 \
 	} while (0)
 #define PRINTK(args...)   printk(args)
 #else
 #define DBG(n, args...)   do { } while (0)
 #define PRINTK(args...)   printk(KERN_DEBUG args)
 #endif
 #if SMC_DEBUG_PKTS > 0
 static void PRINT_PKT(u_char *buf, int length)
 {
 	int i;
 	int remainder;
 	int lines;
 	lines = length / 16;
 	remainder = length % 16;
 	for (i = 0; i < lines ; i ++) {
 		int cur;
 		for (cur = 0; cur < 8; cur++) {
 			u_char a, b;
 			a = *buf++;
 			b = *buf++;
 			printk("%02x%02x ", a, b);
 		}
 		printk("\n");
 	}
 	for (i = 0; i < remainder/2 ; i++) {
 		u_char a, b;
 		a = *buf++;
 		b = *buf++;
 		printk("%02x%02x ", a, b);
 	}
 	printk("\n");
 }
 #else
 #define PRINT_PKT(x...)  do { } while (0)
 #endif
 /* this enables an interrupt in the interrupt mask register */
 #define SMC_ENABLE_INT(lp, x) do {			\
 	unsigned int  __mask;				\
 	unsigned long __flags;				\
 	spin_lock_irqsave(&lp->lock, __flags);		\
 	__mask = SMC_GET_INT_EN((lp));			\
 	__mask |= (x);					\
 	SMC_SET_INT_EN((lp), __mask);			\
 	spin_unlock_irqrestore(&lp->lock, __flags);	\
 } while (0)
 /* this disables an interrupt from the interrupt mask register */
 #define SMC_DISABLE_INT(lp, x) do {			\
 	unsigned int  __mask;				\
 	unsigned long __flags;				\
 	spin_lock_irqsave(&lp->lock, __flags);		\
 	__mask = SMC_GET_INT_EN((lp));			\
 	__mask &= ~(x);					\
 	SMC_SET_INT_EN((lp), __mask);			\
 	spin_unlock_irqrestore(&lp->lock, __flags);	\
 } while (0)
 /*
  * this does a soft reset on the device
  */
 static void smc911x_reset(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
-	unsigned int reg, timeout=0, resets=1;
+	unsigned int reg, timeout=0, resets=1, irq_cfg;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	/*	 Take out of PM setting first */
 	if ((SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_) == 0) {
 		/* Write to the bytetest will take out of powerdown */
 		SMC_SET_BYTE_TEST(lp, 0);
 		timeout=10;
 		do {
 			udelay(10);
 			reg = SMC_GET_PMT_CTRL(lp) & PMT_CTRL_READY_;
 		} while (--timeout && !reg);
 		if (timeout == 0) {
 			PRINTK("%s: smc911x_reset timeout waiting for PM restore\n", dev->name);
 			return;
 		}
 	}
 	/* Disable all interrupts */
 	spin_lock_irqsave(&lp->lock, flags);
 	SMC_SET_INT_EN(lp, 0);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	while (resets--) {
 		SMC_SET_HW_CFG(lp, HW_CFG_SRST_);
 		timeout=10;
 		do {
 			udelay(10);
 			reg = SMC_GET_HW_CFG(lp);
 			/* If chip indicates reset timeout then try again */
 			if (reg & HW_CFG_SRST_TO_) {
 				PRINTK("%s: chip reset timeout, retrying...\n", dev->name);
 				resets++;
 				break;
 			}
 		} while (--timeout && (reg & HW_CFG_SRST_));
 	}
 	if (timeout == 0) {
 		PRINTK("%s: smc911x_reset timeout waiting for reset\n", dev->name);
 		return;
 	}
 	/* make sure EEPROM has finished loading before setting GPIO_CFG */
 	timeout=1000;
 	while ( timeout-- && (SMC_GET_E2P_CMD(lp) & E2P_CMD_EPC_BUSY_)) {
 		udelay(10);
 	}
 	if (timeout == 0){
 		PRINTK("%s: smc911x_reset timeout waiting for EEPROM busy\n", dev->name);
 		return;
 	}
 	/* Initialize interrupts */
 	SMC_SET_INT_EN(lp, 0);
 	SMC_ACK_INT(lp, -1);
 	/* Reset the FIFO level and flow control settings */
 	SMC_SET_HW_CFG(lp, (lp->tx_fifo_kb & 0xF) << 16);
 //TODO: Figure out what appropriate pause time is
 	SMC_SET_FLOW(lp, FLOW_FCPT_ | FLOW_FCEN_);
 	SMC_SET_AFC_CFG(lp, lp->afc_cfg);
 	/* Set to LED outputs */
 	SMC_SET_GPIO_CFG(lp, 0x70070000);
 	/*
 	 * Deassert IRQ for 1*10us for edge type interrupts
 	 * and drive IRQ pin push-pull
 	 */
-	SMC_SET_IRQ_CFG(lp, (1 << 24) | INT_CFG_IRQ_EN_ | INT_CFG_IRQ_TYPE_);
+	irq_cfg = (1 << 24) | INT_CFG_IRQ_EN_ | INT_CFG_IRQ_TYPE_;
+#ifdef SMC_DYNAMIC_BUS_CONFIG
+	if (lp->cfg.irq_polarity)
+		irq_cfg |= INT_CFG_IRQ_POL_;
+#endif
+	SMC_SET_IRQ_CFG(lp, irq_cfg);
 	/* clear anything saved */
 	if (lp->pending_tx_skb != NULL) {
 		dev_kfree_skb (lp->pending_tx_skb);
 		lp->pending_tx_skb = NULL;
 		dev->stats.tx_errors++;
 		dev->stats.tx_aborted_errors++;
 	}
 }
 /*
  * Enable Interrupts, Receive, and Transmit
  */
 static void smc911x_enable(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned mask, cfg, cr;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	SMC_SET_MAC_ADDR(lp, dev->dev_addr);
 	/* Enable TX */
 	cfg = SMC_GET_HW_CFG(lp);
 	cfg &= HW_CFG_TX_FIF_SZ_ | 0xFFF;
 	cfg |= HW_CFG_SF_;
 	SMC_SET_HW_CFG(lp, cfg);
 	SMC_SET_FIFO_TDA(lp, 0xFF);
 	/* Update TX stats on every 64 packets received or every 1 sec */
 	SMC_SET_FIFO_TSL(lp, 64);
 	SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);
 	spin_lock_irqsave(&lp->lock, flags);
 	SMC_GET_MAC_CR(lp, cr);
 	cr |= MAC_CR_TXEN_ | MAC_CR_HBDIS_;
 	SMC_SET_MAC_CR(lp, cr);
 	SMC_SET_TX_CFG(lp, TX_CFG_TX_ON_);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	/* Add 2 byte padding to start of packets */
 	SMC_SET_RX_CFG(lp, (2<<8) & RX_CFG_RXDOFF_);
 	/* Turn on receiver and enable RX */
 	if (cr & MAC_CR_RXEN_)
 		DBG(SMC_DEBUG_RX, "%s: Receiver already enabled\n", dev->name);
 	spin_lock_irqsave(&lp->lock, flags);
 	SMC_SET_MAC_CR(lp, cr | MAC_CR_RXEN_);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	/* Interrupt on every received packet */
 	SMC_SET_FIFO_RSA(lp, 0x01);
 	SMC_SET_FIFO_RSL(lp, 0x00);
 	/* now, enable interrupts */
 	mask = INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_ | INT_EN_RSFL_EN_ |
 		INT_EN_GPT_INT_EN_ | INT_EN_RXDFH_INT_EN_ | INT_EN_RXE_EN_ |
 		INT_EN_PHY_INT_EN_;
 	if (IS_REV_A(lp->revision))
 		mask|=INT_EN_RDFL_EN_;
 	else {
 		mask|=INT_EN_RDFO_EN_;
 	}
 	SMC_ENABLE_INT(lp, mask);
 }
 /*
  * this puts the device in an inactive state
  */
 static void smc911x_shutdown(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned cr;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", CARDNAME, __func__);
 	/* Disable IRQ's */
 	SMC_SET_INT_EN(lp, 0);
 	/* Turn of Rx and TX */
 	spin_lock_irqsave(&lp->lock, flags);
 	SMC_GET_MAC_CR(lp, cr);
 	cr &= ~(MAC_CR_TXEN_ | MAC_CR_RXEN_ | MAC_CR_HBDIS_);
 	SMC_SET_MAC_CR(lp, cr);
 	SMC_SET_TX_CFG(lp, TX_CFG_STOP_TX_);
 	spin_unlock_irqrestore(&lp->lock, flags);
 }
 static inline void smc911x_drop_pkt(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int fifo_count, timeout, reg;
 	DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n", CARDNAME, __func__);
 	fifo_count = SMC_GET_RX_FIFO_INF(lp) & 0xFFFF;
 	if (fifo_count <= 4) {
 		/* Manually dump the packet data */
 		while (fifo_count--)
 			SMC_GET_RX_FIFO(lp);
 	} else	 {
 		/* Fast forward through the bad packet */
 		SMC_SET_RX_DP_CTRL(lp, RX_DP_CTRL_FFWD_BUSY_);
 		timeout=50;
 		do {
 			udelay(10);
 			reg = SMC_GET_RX_DP_CTRL(lp) & RX_DP_CTRL_FFWD_BUSY_;
 		} while (--timeout && reg);
 		if (timeout == 0) {
 			PRINTK("%s: timeout waiting for RX fast forward\n", dev->name);
 		}
 	}
 }
 /*
  * This is the procedure to handle the receipt of a packet.
  * It should be called after checking for packet presence in
  * the RX status FIFO.	 It must be called with the spin lock
  * already held.
  */
 static inline void	 smc911x_rcv(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int pkt_len, status;
 	struct sk_buff *skb;
 	unsigned char *data;
 	DBG(SMC_DEBUG_FUNC | SMC_DEBUG_RX, "%s: --> %s\n",
 		dev->name, __func__);
 	status = SMC_GET_RX_STS_FIFO(lp);
 	DBG(SMC_DEBUG_RX, "%s: Rx pkt len %d status 0x%08x \n",
 		dev->name, (status & 0x3fff0000) >> 16, status & 0xc000ffff);
 	pkt_len = (status & RX_STS_PKT_LEN_) >> 16;
 	if (status & RX_STS_ES_) {
 		/* Deal with a bad packet */
 		dev->stats.rx_errors++;
 		if (status & RX_STS_CRC_ERR_)
 			dev->stats.rx_crc_errors++;
 		else {
 			if (status & RX_STS_LEN_ERR_)
 				dev->stats.rx_length_errors++;
 			if (status & RX_STS_MCAST_)
 				dev->stats.multicast++;
 		}
 		/* Remove the bad packet data from the RX FIFO */
 		smc911x_drop_pkt(dev);
 	} else {
 		/* Receive a valid packet */
 		/* Alloc a buffer with extra room for DMA alignment */
 		skb=dev_alloc_skb(pkt_len+32);
 		if (unlikely(skb == NULL)) {
 			PRINTK( "%s: Low memory, rcvd packet dropped.\n",
 				dev->name);
 			dev->stats.rx_dropped++;
 			smc911x_drop_pkt(dev);
 			return;
 		}
 		/* Align IP header to 32 bits
 		 * Note that the device is configured to add a 2
 		 * byte padding to the packet start, so we really
 		 * want to write to the orignal data pointer */
 		data = skb->data;
 		skb_reserve(skb, 2);
 		skb_put(skb,pkt_len-4);
 #ifdef SMC_USE_DMA
 		{
 		unsigned int fifo;
 		/* Lower the FIFO threshold if possible */
 		fifo = SMC_GET_FIFO_INT(lp);
 		if (fifo & 0xFF) fifo--;
 		DBG(SMC_DEBUG_RX, "%s: Setting RX stat FIFO threshold to %d\n",
 			dev->name, fifo & 0xff);
 		SMC_SET_FIFO_INT(lp, fifo);
 		/* Setup RX DMA */
 		SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN16_ | ((2<<8) & RX_CFG_RXDOFF_));
 		lp->rxdma_active = 1;
 		lp->current_rx_skb = skb;
 		SMC_PULL_DATA(lp, data, (pkt_len+2+15) & ~15);
 		/* Packet processing deferred to DMA RX interrupt */
 		}
 #else
 		SMC_SET_RX_CFG(lp, RX_CFG_RX_END_ALGN4_ | ((2<<8) & RX_CFG_RXDOFF_));
 		SMC_PULL_DATA(lp, data, pkt_len+2+3);
 		DBG(SMC_DEBUG_PKTS, "%s: Received packet\n", dev->name);
 		PRINT_PKT(data, ((pkt_len - 4) <= 64) ? pkt_len - 4 : 64);
 		dev->last_rx = jiffies;
 		skb->protocol = eth_type_trans(skb, dev);
 		netif_rx(skb);
 		dev->stats.rx_packets++;
 		dev->stats.rx_bytes += pkt_len-4;
 #endif
 	}
 }
 /*
  * This is called to actually send a packet to the chip.
  */
 static void smc911x_hardware_send_pkt(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	struct sk_buff *skb;
 	unsigned int cmdA, cmdB, len;
 	unsigned char *buf;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n", dev->name, __func__);
 	BUG_ON(lp->pending_tx_skb == NULL);
 	skb = lp->pending_tx_skb;
 	lp->pending_tx_skb = NULL;
 	/* cmdA {25:24] data alignment [20:16] start offset [10:0] buffer length */
 	/* cmdB {31:16] pkt tag [10:0] length */
 #ifdef SMC_USE_DMA
 	/* 16 byte buffer alignment mode */
 	buf = (char*)((u32)(skb->data) & ~0xF);
 	len = (skb->len + 0xF + ((u32)skb->data & 0xF)) & ~0xF;
 	cmdA = (1<<24) | (((u32)skb->data & 0xF)<<16) |
 			TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ |
 			skb->len;
 #else
 	buf = (char*)((u32)skb->data & ~0x3);
 	len = (skb->len + 3 + ((u32)skb->data & 3)) & ~0x3;
 	cmdA = (((u32)skb->data & 0x3) << 16) |
 			TX_CMD_A_INT_FIRST_SEG_ | TX_CMD_A_INT_LAST_SEG_ |
 			skb->len;
 #endif
 	/* tag is packet length so we can use this in stats update later */
 	cmdB = (skb->len  << 16) | (skb->len & 0x7FF);
 	DBG(SMC_DEBUG_TX, "%s: TX PKT LENGTH 0x%04x (%d) BUF 0x%p CMDA 0x%08x CMDB 0x%08x\n",
 		 dev->name, len, len, buf, cmdA, cmdB);
 	SMC_SET_TX_FIFO(lp, cmdA);
 	SMC_SET_TX_FIFO(lp, cmdB);
 	DBG(SMC_DEBUG_PKTS, "%s: Transmitted packet\n", dev->name);
 	PRINT_PKT(buf, len <= 64 ? len : 64);
 	/* Send pkt via PIO or DMA */
 #ifdef SMC_USE_DMA
 	lp->current_tx_skb = skb;
 	SMC_PUSH_DATA(lp, buf, len);
 	/* DMA complete IRQ will free buffer and set jiffies */
 #else
 	SMC_PUSH_DATA(lp, buf, len);
 	dev->trans_start = jiffies;
 	dev_kfree_skb(skb);
 #endif
 	spin_lock_irqsave(&lp->lock, flags);
 	if (!lp->tx_throttle) {
 		netif_wake_queue(dev);
 	}
 	spin_unlock_irqrestore(&lp->lock, flags);
 	SMC_ENABLE_INT(lp, INT_EN_TDFA_EN_ | INT_EN_TSFL_EN_);
 }
 /*
  * Since I am not sure if I will have enough room in the chip's ram
  * to store the packet, I call this routine which either sends it
  * now, or set the card to generates an interrupt when ready
  * for the packet.
  */
 static int smc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int free;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n",
 		dev->name, __func__);
 	BUG_ON(lp->pending_tx_skb != NULL);
 	free = SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TDFREE_;
 	DBG(SMC_DEBUG_TX, "%s: TX free space %d\n", dev->name, free);
 	/* Turn off the flow when running out of space in FIFO */
 	if (free <= SMC911X_TX_FIFO_LOW_THRESHOLD) {
 		DBG(SMC_DEBUG_TX, "%s: Disabling data flow due to low FIFO space (%d)\n",
 			dev->name, free);
 		spin_lock_irqsave(&lp->lock, flags);
 		/* Reenable when at least 1 packet of size MTU present */
 		SMC_SET_FIFO_TDA(lp, (SMC911X_TX_FIFO_LOW_THRESHOLD)/64);
 		lp->tx_throttle = 1;
 		netif_stop_queue(dev);
 		spin_unlock_irqrestore(&lp->lock, flags);
 	}
 	/* Drop packets when we run out of space in TX FIFO
 	 * Account for overhead required for:
 	 *
 	 *	  Tx command words			 8 bytes
 	 *	  Start offset				 15 bytes
 	 *	  End padding				 15 bytes
 	 */
 	if (unlikely(free < (skb->len + 8 + 15 + 15))) {
 		printk("%s: No Tx free space %d < %d\n",
 			dev->name, free, skb->len);
 		lp->pending_tx_skb = NULL;
 		dev->stats.tx_errors++;
 		dev->stats.tx_dropped++;
 		dev_kfree_skb(skb);
 		return 0;
 	}
 #ifdef SMC_USE_DMA
 	{
 		/* If the DMA is already running then defer this packet Tx until
 		 * the DMA IRQ starts it
 		 */
 		spin_lock_irqsave(&lp->lock, flags);
 		if (lp->txdma_active) {
 			DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Tx DMA running, deferring packet\n", dev->name);
 			lp->pending_tx_skb = skb;
 			netif_stop_queue(dev);
 			spin_unlock_irqrestore(&lp->lock, flags);
 			return 0;
 		} else {
 			DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: Activating Tx DMA\n", dev->name);
 			lp->txdma_active = 1;
 		}
 		spin_unlock_irqrestore(&lp->lock, flags);
 	}
 #endif
 	lp->pending_tx_skb = skb;
 	smc911x_hardware_send_pkt(dev);
 	return 0;
 }
 /*
  * This handles a TX status interrupt, which is only called when:
  * - a TX error occurred, or
  * - TX of a packet completed.
  */
 static void smc911x_tx(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int tx_status;
 	DBG(SMC_DEBUG_FUNC | SMC_DEBUG_TX, "%s: --> %s\n",
 		dev->name, __func__);
 	/* Collect the TX status */
 	while (((SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16) != 0) {
 		DBG(SMC_DEBUG_TX, "%s: Tx stat FIFO used 0x%04x\n",
 			dev->name,
 			(SMC_GET_TX_FIFO_INF(lp) & TX_FIFO_INF_TSUSED_) >> 16);
 		tx_status = SMC_GET_TX_STS_FIFO(lp);
 		dev->stats.tx_packets++;
 		dev->stats.tx_bytes+=tx_status>>16;
 		DBG(SMC_DEBUG_TX, "%s: Tx FIFO tag 0x%04x status 0x%04x\n",
 			dev->name, (tx_status & 0xffff0000) >> 16,
 			tx_status & 0x0000ffff);
 		/* count Tx errors, but ignore lost carrier errors when in
 		 * full-duplex mode */
 		if ((tx_status & TX_STS_ES_) && !(lp->ctl_rfduplx &&
 		    !(tx_status & 0x00000306))) {
 			dev->stats.tx_errors++;
 		}
 		if (tx_status & TX_STS_MANY_COLL_) {
 			dev->stats.collisions+=16;
 			dev->stats.tx_aborted_errors++;
 		} else {
 			dev->stats.collisions+=(tx_status & TX_STS_COLL_CNT_) >> 3;
 		}
 		/* carrier error only has meaning for half-duplex communication */
 		if ((tx_status & (TX_STS_LOC_ | TX_STS_NO_CARR_)) &&
 		    !lp->ctl_rfduplx) {
 			dev->stats.tx_carrier_errors++;
 		}
 		if (tx_status & TX_STS_LATE_COLL_) {
 			dev->stats.collisions++;
 			dev->stats.tx_aborted_errors++;
 		}
 	}
 }
 /*---PHY CONTROL AND CONFIGURATION-----------------------------------------*/
 /*
  * Reads a register from the MII Management serial interface
  */
 static int smc911x_phy_read(struct net_device *dev, int phyaddr, int phyreg)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int phydata;
 	SMC_GET_MII(lp, phyreg, phyaddr, phydata);
 	DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%02x, phydata=0x%04x\n",
 		__func__, phyaddr, phyreg, phydata);
 	return phydata;
 }
 /*
  * Writes a register to the MII Management serial interface
  */
 static void smc911x_phy_write(struct net_device *dev, int phyaddr, int phyreg,
 			int phydata)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	DBG(SMC_DEBUG_MISC, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n",
 		__func__, phyaddr, phyreg, phydata);
 	SMC_SET_MII(lp, phyreg, phyaddr, phydata);
 }
 /*
  * Finds and reports the PHY address (115 and 117 have external
  * PHY interface 118 has internal only
  */
 static void smc911x_phy_detect(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int phyaddr;
 	unsigned int cfg, id1, id2;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	lp->phy_type = 0;
 	/*
 	 * Scan all 32 PHY addresses if necessary, starting at
 	 * PHY#1 to PHY#31, and then PHY#0 last.
 	 */
 	switch(lp->version) {
 		case CHIP_9115:
 		case CHIP_9117:
 		case CHIP_9215:
 		case CHIP_9217:
 			cfg = SMC_GET_HW_CFG(lp);
 			if (cfg & HW_CFG_EXT_PHY_DET_) {
 				cfg &= ~HW_CFG_PHY_CLK_SEL_;
 				cfg |= HW_CFG_PHY_CLK_SEL_CLK_DIS_;
 				SMC_SET_HW_CFG(lp, cfg);
 				udelay(10); /* Wait for clocks to stop */
 				cfg |= HW_CFG_EXT_PHY_EN_;
 				SMC_SET_HW_CFG(lp, cfg);
 				udelay(10); /* Wait for clocks to stop */
 				cfg &= ~HW_CFG_PHY_CLK_SEL_;
 				cfg |= HW_CFG_PHY_CLK_SEL_EXT_PHY_;
 				SMC_SET_HW_CFG(lp, cfg);
 				udelay(10); /* Wait for clocks to stop */
 				cfg |= HW_CFG_SMI_SEL_;
 				SMC_SET_HW_CFG(lp, cfg);
 				for (phyaddr = 1; phyaddr < 32; ++phyaddr) {
 					/* Read the PHY identifiers */
 					SMC_GET_PHY_ID1(lp, phyaddr & 31, id1);
 					SMC_GET_PHY_ID2(lp, phyaddr & 31, id2);
 					/* Make sure it is a valid identifier */
 					if (id1 != 0x0000 && id1 != 0xffff &&
 					    id1 != 0x8000 && id2 != 0x0000 &&
 					    id2 != 0xffff && id2 != 0x8000) {
 						/* Save the PHY's address */
 						lp->mii.phy_id = phyaddr & 31;
 						lp->phy_type = id1 << 16 | id2;
 						break;
 					}
 				}
 				if (phyaddr < 32)
 					/* Found an external PHY */
 					break;
 			}
 		default:
 			/* Internal media only */
 			SMC_GET_PHY_ID1(lp, 1, id1);
 			SMC_GET_PHY_ID2(lp, 1, id2);
 			/* Save the PHY's address */
 			lp->mii.phy_id = 1;
 			lp->phy_type = id1 << 16 | id2;
 	}
 	DBG(SMC_DEBUG_MISC, "%s: phy_id1=0x%x, phy_id2=0x%x phyaddr=0x%d\n",
 		dev->name, id1, id2, lp->mii.phy_id);
 }
 /*
  * Sets the PHY to a configuration as determined by the user.
  * Called with spin_lock held.
  */
 static int smc911x_phy_fixed(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int phyaddr = lp->mii.phy_id;
 	int bmcr;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	/* Enter Link Disable state */
 	SMC_GET_PHY_BMCR(lp, phyaddr, bmcr);
 	bmcr |= BMCR_PDOWN;
 	SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);
 	/*
 	 * Set our fixed capabilities
 	 * Disable auto-negotiation
 	 */
 	bmcr &= ~BMCR_ANENABLE;
 	if (lp->ctl_rfduplx)
 		bmcr |= BMCR_FULLDPLX;
 	if (lp->ctl_rspeed == 100)
 		bmcr |= BMCR_SPEED100;
 	/* Write our capabilities to the phy control register */
 	SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);
 	/* Re-Configure the Receive/Phy Control register */
 	bmcr &= ~BMCR_PDOWN;
 	SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);
 	return 1;
 }
 /*
  * smc911x_phy_reset - reset the phy
  * @dev: net device
  * @phy: phy address
  *
  * Issue a software reset for the specified PHY and
  * wait up to 100ms for the reset to complete.	 We should
  * not access the PHY for 50ms after issuing the reset.
  *
  * The time to wait appears to be dependent on the PHY.
  *
  */
 static int smc911x_phy_reset(struct net_device *dev, int phy)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int timeout;
 	unsigned long flags;
 	unsigned int reg;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__);
 	spin_lock_irqsave(&lp->lock, flags);
 	reg = SMC_GET_PMT_CTRL(lp);
 	reg &= ~0xfffff030;
 	reg |= PMT_CTRL_PHY_RST_;
 	SMC_SET_PMT_CTRL(lp, reg);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	for (timeout = 2; timeout; timeout--) {
 		msleep(50);
 		spin_lock_irqsave(&lp->lock, flags);
 		reg = SMC_GET_PMT_CTRL(lp);
 		spin_unlock_irqrestore(&lp->lock, flags);
 		if (!(reg & PMT_CTRL_PHY_RST_)) {
 			/* extra delay required because the phy may
 			 * not be completed with its reset
 			 * when PHY_BCR_RESET_ is cleared. 256us
 			 * should suffice, but use 500us to be safe
 			 */
 			udelay(500);
 		break;
 		}
 	}
 	return reg & PMT_CTRL_PHY_RST_;
 }
 /*
  * smc911x_phy_powerdown - powerdown phy
  * @dev: net device
  * @phy: phy address
  *
  * Power down the specified PHY
  */
 static void smc911x_phy_powerdown(struct net_device *dev, int phy)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int bmcr;
 	/* Enter Link Disable state */
 	SMC_GET_PHY_BMCR(lp, phy, bmcr);
 	bmcr |= BMCR_PDOWN;
 	SMC_SET_PHY_BMCR(lp, phy, bmcr);
 }
 /*
  * smc911x_phy_check_media - check the media status and adjust BMCR
  * @dev: net device
  * @init: set true for initialisation
  *
  * Select duplex mode depending on negotiation state.	This
  * also updates our carrier state.
  */
 static void smc911x_phy_check_media(struct net_device *dev, int init)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int phyaddr = lp->mii.phy_id;
 	unsigned int bmcr, cr;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	if (mii_check_media(&lp->mii, netif_msg_link(lp), init)) {
 		/* duplex state has changed */
 		SMC_GET_PHY_BMCR(lp, phyaddr, bmcr);
 		SMC_GET_MAC_CR(lp, cr);
 		if (lp->mii.full_duplex) {
 			DBG(SMC_DEBUG_MISC, "%s: Configuring for full-duplex mode\n", dev->name);
 			bmcr |= BMCR_FULLDPLX;
 			cr |= MAC_CR_RCVOWN_;
 		} else {
 			DBG(SMC_DEBUG_MISC, "%s: Configuring for half-duplex mode\n", dev->name);
 			bmcr &= ~BMCR_FULLDPLX;
 			cr &= ~MAC_CR_RCVOWN_;
 		}
 		SMC_SET_PHY_BMCR(lp, phyaddr, bmcr);
 		SMC_SET_MAC_CR(lp, cr);
 	}
 }
 /*
  * Configures the specified PHY through the MII management interface
  * using Autonegotiation.
  * Calls smc911x_phy_fixed() if the user has requested a certain config.
  * If RPC ANEG bit is set, the media selection is dependent purely on
  * the selection by the MII (either in the MII BMCR reg or the result
  * of autonegotiation.)  If the RPC ANEG bit is cleared, the selection
  * is controlled by the RPC SPEED and RPC DPLX bits.
  */
 static void smc911x_phy_configure(struct work_struct *work)
 {
 	struct smc911x_local *lp = container_of(work, struct smc911x_local,
 						phy_configure);
 	struct net_device *dev = lp->netdev;
 	int phyaddr = lp->mii.phy_id;
 	int my_phy_caps; /* My PHY capabilities */
 	int my_ad_caps; /* My Advertised capabilities */
 	int status;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s()\n", dev->name, __func__);
 	/*
 	 * We should not be called if phy_type is zero.
 	 */
 	if (lp->phy_type == 0)
 		return;
 	if (smc911x_phy_reset(dev, phyaddr)) {
 		printk("%s: PHY reset timed out\n", dev->name);
 		return;
 	}
 	spin_lock_irqsave(&lp->lock, flags);
 	/*
 	 * Enable PHY Interrupts (for register 18)
 	 * Interrupts listed here are enabled
 	 */
 	SMC_SET_PHY_INT_MASK(lp, phyaddr, PHY_INT_MASK_ENERGY_ON_ |
 		 PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_REMOTE_FAULT_ |
 		 PHY_INT_MASK_LINK_DOWN_);
 	/* If the user requested no auto neg, then go set his request */
 	if (lp->mii.force_media) {
 		smc911x_phy_fixed(dev);
 		goto smc911x_phy_configure_exit;
 	}
 	/* Copy our capabilities from MII_BMSR to MII_ADVERTISE */
 	SMC_GET_PHY_BMSR(lp, phyaddr, my_phy_caps);
 	if (!(my_phy_caps & BMSR_ANEGCAPABLE)) {
 		printk(KERN_INFO "Auto negotiation NOT supported\n");
 		smc911x_phy_fixed(dev);
 		goto smc911x_phy_configure_exit;
 	}
 	/* CSMA capable w/ both pauses */
 	my_ad_caps = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
 	if (my_phy_caps & BMSR_100BASE4)
 		my_ad_caps |= ADVERTISE_100BASE4;
 	if (my_phy_caps & BMSR_100FULL)
 		my_ad_caps |= ADVERTISE_100FULL;
 	if (my_phy_caps & BMSR_100HALF)
 		my_ad_caps |= ADVERTISE_100HALF;
 	if (my_phy_caps & BMSR_10FULL)
 		my_ad_caps |= ADVERTISE_10FULL;
 	if (my_phy_caps & BMSR_10HALF)
 		my_ad_caps |= ADVERTISE_10HALF;
 	/* Disable capabilities not selected by our user */
 	if (lp->ctl_rspeed != 100)
 		my_ad_caps &= ~(ADVERTISE_100BASE4|ADVERTISE_100FULL|ADVERTISE_100HALF);
 	 if (!lp->ctl_rfduplx)
 		my_ad_caps &= ~(ADVERTISE_100FULL|ADVERTISE_10FULL);
 	/* Update our Auto-Neg Advertisement Register */
 	SMC_SET_PHY_MII_ADV(lp, phyaddr, my_ad_caps);
 	lp->mii.advertising = my_ad_caps;
 	/*
 	 * Read the register back.	 Without this, it appears that when
 	 * auto-negotiation is restarted, sometimes it isn't ready and
 	 * the link does not come up.
 	 */
 	udelay(10);
 	SMC_GET_PHY_MII_ADV(lp, phyaddr, status);
 	DBG(SMC_DEBUG_MISC, "%s: phy caps=0x%04x\n", dev->name, my_phy_caps);
 	DBG(SMC_DEBUG_MISC, "%s: phy advertised caps=0x%04x\n", dev->name, my_ad_caps);
 	/* Restart auto-negotiation process in order to advertise my caps */
 	SMC_SET_PHY_BMCR(lp, phyaddr, BMCR_ANENABLE | BMCR_ANRESTART);
 	smc911x_phy_check_media(dev, 1);
 smc911x_phy_configure_exit:
 	spin_unlock_irqrestore(&lp->lock, flags);
 }
 /*
  * smc911x_phy_interrupt
  *
  * Purpose:  Handle interrupts relating to PHY register 18. This is
  *	 called from the "hard" interrupt handler under our private spinlock.
  */
 static void smc911x_phy_interrupt(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int phyaddr = lp->mii.phy_id;
 	int status;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	if (lp->phy_type == 0)
 		return;
 	smc911x_phy_check_media(dev, 0);
 	/* read to clear status bits */
 	SMC_GET_PHY_INT_SRC(lp, phyaddr,status);
 	DBG(SMC_DEBUG_MISC, "%s: PHY interrupt status 0x%04x\n",
 		dev->name, status & 0xffff);
 	DBG(SMC_DEBUG_MISC, "%s: AFC_CFG 0x%08x\n",
 		dev->name, SMC_GET_AFC_CFG(lp));
 }
 /*--- END PHY CONTROL AND CONFIGURATION-------------------------------------*/
 /*
  * This is the main routine of the driver, to handle the device when
  * it needs some attention.
  */
 static irqreturn_t smc911x_interrupt(int irq, void *dev_id)
 {
 	struct net_device *dev = dev_id;
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int status, mask, timeout;
 	unsigned int rx_overrun=0, cr, pkts;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	spin_lock_irqsave(&lp->lock, flags);
 	/* Spurious interrupt check */
 	if ((SMC_GET_IRQ_CFG(lp) & (INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) !=
 		(INT_CFG_IRQ_INT_ | INT_CFG_IRQ_EN_)) {
 		spin_unlock_irqrestore(&lp->lock, flags);
 		return IRQ_NONE;
 	}
 	mask = SMC_GET_INT_EN(lp);
 	SMC_SET_INT_EN(lp, 0);
 	/* set a timeout value, so I don't stay here forever */
 	timeout = 8;
 	do {
 		status = SMC_GET_INT(lp);
 		DBG(SMC_DEBUG_MISC, "%s: INT 0x%08x MASK 0x%08x OUTSIDE MASK 0x%08x\n",
 			dev->name, status, mask, status & ~mask);
 		status &= mask;
 		if (!status)
 			break;
 		/* Handle SW interrupt condition */
 		if (status & INT_STS_SW_INT_) {
 			SMC_ACK_INT(lp, INT_STS_SW_INT_);
 			mask &= ~INT_EN_SW_INT_EN_;
 		}
 		/* Handle various error conditions */
 		if (status & INT_STS_RXE_) {
 			SMC_ACK_INT(lp, INT_STS_RXE_);
 			dev->stats.rx_errors++;
 		}
 		if (status & INT_STS_RXDFH_INT_) {
 			SMC_ACK_INT(lp, INT_STS_RXDFH_INT_);
 			dev->stats.rx_dropped+=SMC_GET_RX_DROP(lp);
 		 }
 		/* Undocumented interrupt-what is the right thing to do here? */
 		if (status & INT_STS_RXDF_INT_) {
 			SMC_ACK_INT(lp, INT_STS_RXDF_INT_);
 		}
 		/* Rx Data FIFO exceeds set level */
 		if (status & INT_STS_RDFL_) {
 			if (IS_REV_A(lp->revision)) {
 				rx_overrun=1;
 				SMC_GET_MAC_CR(lp, cr);
 				cr &= ~MAC_CR_RXEN_;
 				SMC_SET_MAC_CR(lp, cr);
 				DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name);
 				dev->stats.rx_errors++;
 				dev->stats.rx_fifo_errors++;
 			}
 			SMC_ACK_INT(lp, INT_STS_RDFL_);
 		}
 		if (status & INT_STS_RDFO_) {
 			if (!IS_REV_A(lp->revision)) {
 				SMC_GET_MAC_CR(lp, cr);
 				cr &= ~MAC_CR_RXEN_;
 				SMC_SET_MAC_CR(lp, cr);
 				rx_overrun=1;
 				DBG(SMC_DEBUG_RX, "%s: RX overrun\n", dev->name);
 				dev->stats.rx_errors++;
 				dev->stats.rx_fifo_errors++;
 			}
 			SMC_ACK_INT(lp, INT_STS_RDFO_);
 		}
 		/* Handle receive condition */
 		if ((status & INT_STS_RSFL_) || rx_overrun) {
 			unsigned int fifo;
 			DBG(SMC_DEBUG_RX, "%s: RX irq\n", dev->name);
 			fifo = SMC_GET_RX_FIFO_INF(lp);
 			pkts = (fifo & RX_FIFO_INF_RXSUSED_) >> 16;
 			DBG(SMC_DEBUG_RX, "%s: Rx FIFO pkts %d, bytes %d\n",
 				dev->name, pkts, fifo & 0xFFFF );
 			if (pkts != 0) {
 #ifdef SMC_USE_DMA
 				unsigned int fifo;
 				if (lp->rxdma_active){
 					DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA,
 						"%s: RX DMA active\n", dev->name);
 					/* The DMA is already running so up the IRQ threshold */
 					fifo = SMC_GET_FIFO_INT(lp) & ~0xFF;
 					fifo |= pkts & 0xFF;
 					DBG(SMC_DEBUG_RX,
 						"%s: Setting RX stat FIFO threshold to %d\n",
 						dev->name, fifo & 0xff);
 					SMC_SET_FIFO_INT(lp, fifo);
 				} else
 #endif
 				smc911x_rcv(dev);
 			}
 			SMC_ACK_INT(lp, INT_STS_RSFL_);
 		}
 		/* Handle transmit FIFO available */
 		if (status & INT_STS_TDFA_) {
 			DBG(SMC_DEBUG_TX, "%s: TX data FIFO space available irq\n", dev->name);
 			SMC_SET_FIFO_TDA(lp, 0xFF);
 			lp->tx_throttle = 0;
 #ifdef SMC_USE_DMA
 			if (!lp->txdma_active)
 #endif
 				netif_wake_queue(dev);
 			SMC_ACK_INT(lp, INT_STS_TDFA_);
 		}
 		/* Handle transmit done condition */
 #if 1
 		if (status & (INT_STS_TSFL_ | INT_STS_GPT_INT_)) {
 			DBG(SMC_DEBUG_TX | SMC_DEBUG_MISC,
 				"%s: Tx stat FIFO limit (%d) /GPT irq\n",
 				dev->name, (SMC_GET_FIFO_INT(lp) & 0x00ff0000) >> 16);
 			smc911x_tx(dev);
 			SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);
 			SMC_ACK_INT(lp, INT_STS_TSFL_);
 			SMC_ACK_INT(lp, INT_STS_TSFL_ | INT_STS_GPT_INT_);
 		}
 #else
 		if (status & INT_STS_TSFL_) {
 			DBG(SMC_DEBUG_TX, "%s: TX status FIFO limit (%d) irq \n", dev->name, );
 			smc911x_tx(dev);
 			SMC_ACK_INT(lp, INT_STS_TSFL_);
 		}
 		if (status & INT_STS_GPT_INT_) {
 			DBG(SMC_DEBUG_RX, "%s: IRQ_CFG 0x%08x FIFO_INT 0x%08x RX_CFG 0x%08x\n",
 				dev->name,
 				SMC_GET_IRQ_CFG(lp),
 				SMC_GET_FIFO_INT(lp),
 				SMC_GET_RX_CFG(lp));
 			DBG(SMC_DEBUG_RX, "%s: Rx Stat FIFO Used 0x%02x "
 				"Data FIFO Used 0x%04x Stat FIFO 0x%08x\n",
 				dev->name,
 				(SMC_GET_RX_FIFO_INF(lp) & 0x00ff0000) >> 16,
 				SMC_GET_RX_FIFO_INF(lp) & 0xffff,
 				SMC_GET_RX_STS_FIFO_PEEK(lp));
 			SMC_SET_GPT_CFG(lp, GPT_CFG_TIMER_EN_ | 10000);
 			SMC_ACK_INT(lp, INT_STS_GPT_INT_);
 		}
 #endif
 		/* Handle PHY interrupt condition */
 		if (status & INT_STS_PHY_INT_) {
 			DBG(SMC_DEBUG_MISC, "%s: PHY irq\n", dev->name);
 			smc911x_phy_interrupt(dev);
 			SMC_ACK_INT(lp, INT_STS_PHY_INT_);
 		}
 	} while (--timeout);
 	/* restore mask state */
 	SMC_SET_INT_EN(lp, mask);
 	DBG(SMC_DEBUG_MISC, "%s: Interrupt done (%d loops)\n",
 		dev->name, 8-timeout);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	return IRQ_HANDLED;
 }
 #ifdef SMC_USE_DMA
 static void
 smc911x_tx_dma_irq(int dma, void *data)
 {
 	struct net_device *dev = (struct net_device *)data;
 	struct smc911x_local *lp = netdev_priv(dev);
 	struct sk_buff *skb = lp->current_tx_skb;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA, "%s: TX DMA irq handler\n", dev->name);
 	/* Clear the DMA interrupt sources */
 	SMC_DMA_ACK_IRQ(dev, dma);
 	BUG_ON(skb == NULL);
 	dma_unmap_single(NULL, tx_dmabuf, tx_dmalen, DMA_TO_DEVICE);
 	dev->trans_start = jiffies;
 	dev_kfree_skb_irq(skb);
 	lp->current_tx_skb = NULL;
 	if (lp->pending_tx_skb != NULL)
 		smc911x_hardware_send_pkt(dev);
 	else {
 		DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA,
 			"%s: No pending Tx packets. DMA disabled\n", dev->name);
 		spin_lock_irqsave(&lp->lock, flags);
 		lp->txdma_active = 0;
 		if (!lp->tx_throttle) {
 			netif_wake_queue(dev);
 		}
 		spin_unlock_irqrestore(&lp->lock, flags);
 	}
 	DBG(SMC_DEBUG_TX | SMC_DEBUG_DMA,
 		"%s: TX DMA irq completed\n", dev->name);
 }
 static void
 smc911x_rx_dma_irq(int dma, void *data)
 {
 	struct net_device *dev = (struct net_device *)data;
 	unsigned long ioaddr = dev->base_addr;
 	struct smc911x_local *lp = netdev_priv(dev);
 	struct sk_buff *skb = lp->current_rx_skb;
 	unsigned long flags;
 	unsigned int pkts;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA, "%s: RX DMA irq handler\n", dev->name);
 	/* Clear the DMA interrupt sources */
 	SMC_DMA_ACK_IRQ(dev, dma);
 	dma_unmap_single(NULL, rx_dmabuf, rx_dmalen, DMA_FROM_DEVICE);
 	BUG_ON(skb == NULL);
 	lp->current_rx_skb = NULL;
 	PRINT_PKT(skb->data, skb->len);
 	dev->last_rx = jiffies;
 	skb->protocol = eth_type_trans(skb, dev);
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += skb->len;
 	netif_rx(skb);
 	spin_lock_irqsave(&lp->lock, flags);
 	pkts = (SMC_GET_RX_FIFO_INF(lp) & RX_FIFO_INF_RXSUSED_) >> 16;
 	if (pkts != 0) {
 		smc911x_rcv(dev);
 	}else {
 		lp->rxdma_active = 0;
 	}
 	spin_unlock_irqrestore(&lp->lock, flags);
 	DBG(SMC_DEBUG_RX | SMC_DEBUG_DMA,
 		"%s: RX DMA irq completed. DMA RX FIFO PKTS %d\n",
 		dev->name, pkts);
 }
 #endif	 /* SMC_USE_DMA */
 #ifdef CONFIG_NET_POLL_CONTROLLER
 /*
  * Polling receive - used by netconsole and other diagnostic tools
  * to allow network i/o with interrupts disabled.
  */
 static void smc911x_poll_controller(struct net_device *dev)
 {
 	disable_irq(dev->irq);
 	smc911x_interrupt(dev->irq, dev);
 	enable_irq(dev->irq);
 }
 #endif
 /* Our watchdog timed out. Called by the networking layer */
 static void smc911x_timeout(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int status, mask;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	spin_lock_irqsave(&lp->lock, flags);
 	status = SMC_GET_INT(lp);
 	mask = SMC_GET_INT_EN(lp);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	DBG(SMC_DEBUG_MISC, "%s: INT 0x%02x MASK 0x%02x \n",
 		dev->name, status, mask);
 	/* Dump the current TX FIFO contents and restart */
 	mask = SMC_GET_TX_CFG(lp);
 	SMC_SET_TX_CFG(lp, mask | TX_CFG_TXS_DUMP_ | TX_CFG_TXD_DUMP_);
 	/*
 	 * Reconfiguring the PHY doesn't seem like a bad idea here, but
 	 * smc911x_phy_configure() calls msleep() which calls schedule_timeout()
 	 * which calls schedule().	 Hence we use a work queue.
 	 */
 	if (lp->phy_type != 0)
 		schedule_work(&lp->phy_configure);
 	/* We can accept TX packets again */
 	dev->trans_start = jiffies;
 	netif_wake_queue(dev);
 }
 /*
  * This routine will, depending on the values passed to it,
  * either make it accept multicast packets, go into
  * promiscuous mode (for TCPDUMP and cousins) or accept
  * a select set of multicast packets
  */
 static void smc911x_set_multicast_list(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int multicast_table[2];
 	unsigned int mcr, update_multicast = 0;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	spin_lock_irqsave(&lp->lock, flags);
 	SMC_GET_MAC_CR(lp, mcr);
 	spin_unlock_irqrestore(&lp->lock, flags);
 	if (dev->flags & IFF_PROMISC) {
 		DBG(SMC_DEBUG_MISC, "%s: RCR_PRMS\n", dev->name);
 		mcr |= MAC_CR_PRMS_;
 	}
 	/*
 	 * Here, I am setting this to accept all multicast packets.
 	 * I don't need to zero the multicast table, because the flag is
 	 * checked before the table is
 	 */
 	else if (dev->flags & IFF_ALLMULTI || dev->mc_count > 16) {
 		DBG(SMC_DEBUG_MISC, "%s: RCR_ALMUL\n", dev->name);
 		mcr |= MAC_CR_MCPAS_;
 	}
 	/*
 	 * This sets the internal hardware table to filter out unwanted
 	 * multicast packets before they take up memory.
 	 *
 	 * The SMC chip uses a hash table where the high 6 bits of the CRC of
 	 * address are the offset into the table.	If that bit is 1, then the
 	 * multicast packet is accepted.  Otherwise, it's dropped silently.
 	 *
 	 * To use the 6 bits as an offset into the table, the high 1 bit is
 	 * the number of the 32 bit register, while the low 5 bits are the bit
 	 * within that register.
 	 */
 	else if (dev->mc_count)  {
 		int i;
 		struct dev_mc_list *cur_addr;
 		/* Set the Hash perfec mode */
 		mcr |= MAC_CR_HPFILT_;
 		/* start with a table of all zeros: reject all */
 		memset(multicast_table, 0, sizeof(multicast_table));
 		cur_addr = dev->mc_list;
 		for (i = 0; i < dev->mc_count; i++, cur_addr = cur_addr->next) {
 			u32 position;
 			/* do we have a pointer here? */
 			if (!cur_addr)
 				break;
 			/* make sure this is a multicast address -
 				shouldn't this be a given if we have it here ? */
 			if (!(*cur_addr->dmi_addr & 1))
 				 continue;
 			/* upper 6 bits are used as hash index */
 			position = ether_crc(ETH_ALEN, cur_addr->dmi_addr)>>26;
 			multicast_table[position>>5] |= 1 << (position&0x1f);
 		}
 		/* be sure I get rid of flags I might have set */
 		mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);
 		/* now, the table can be loaded into the chipset */
 		update_multicast = 1;
 	} else	 {
 		DBG(SMC_DEBUG_MISC, "%s: ~(MAC_CR_PRMS_|MAC_CR_MCPAS_)\n",
 			dev->name);
 		mcr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);
 		/*
 		 * since I'm disabling all multicast entirely, I need to
 		 * clear the multicast list
 		 */
 		memset(multicast_table, 0, sizeof(multicast_table));
 		update_multicast = 1;
 	}
 	spin_lock_irqsave(&lp->lock, flags);
 	SMC_SET_MAC_CR(lp, mcr);
 	if (update_multicast) {
 		DBG(SMC_DEBUG_MISC,
 			"%s: update mcast hash table 0x%08x 0x%08x\n",
 			dev->name, multicast_table[0], multicast_table[1]);
 		SMC_SET_HASHL(lp, multicast_table[0]);
 		SMC_SET_HASHH(lp, multicast_table[1]);
 	}
 	spin_unlock_irqrestore(&lp->lock, flags);
 }
 /*
  * Open and Initialize the board
  *
  * Set up everything, reset the card, etc..
  */
 static int
 smc911x_open(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	/*
 	 * Check that the address is valid.  If its not, refuse
 	 * to bring the device up.	 The user must specify an
 	 * address using ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx
 	 */
 	if (!is_valid_ether_addr(dev->dev_addr)) {
 		PRINTK("%s: no valid ethernet hw addr\n", __func__);
 		return -EINVAL;
 	}
 	/* reset the hardware */
 	smc911x_reset(dev);
 	/* Configure the PHY, initialize the link state */
 	smc911x_phy_configure(&lp->phy_configure);
 	/* Turn on Tx + Rx */
 	smc911x_enable(dev);
 	netif_start_queue(dev);
 	return 0;
 }
 /*
  * smc911x_close
  *
  * this makes the board clean up everything that it can
  * and not talk to the outside world.	 Caused by
  * an 'ifconfig ethX down'
  */
 static int smc911x_close(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	netif_stop_queue(dev);
 	netif_carrier_off(dev);
 	/* clear everything */
 	smc911x_shutdown(dev);
 	if (lp->phy_type != 0) {
 		/* We need to ensure that no calls to
 		 * smc911x_phy_configure are pending.
 		 */
 		cancel_work_sync(&lp->phy_configure);
 		smc911x_phy_powerdown(dev, lp->mii.phy_id);
 	}
 	if (lp->pending_tx_skb) {
 		dev_kfree_skb(lp->pending_tx_skb);
 		lp->pending_tx_skb = NULL;
 	}
 	return 0;
 }
 /*
  * Ethtool support
  */
 static int
 smc911x_ethtool_getsettings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int ret, status;
 	unsigned long flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	cmd->maxtxpkt = 1;
 	cmd->maxrxpkt = 1;
 	if (lp->phy_type != 0) {
 		spin_lock_irqsave(&lp->lock, flags);
 		ret = mii_ethtool_gset(&lp->mii, cmd);
 		spin_unlock_irqrestore(&lp->lock, flags);
 	} else {
 		cmd->supported = SUPPORTED_10baseT_Half |
 				SUPPORTED_10baseT_Full |
 				SUPPORTED_TP | SUPPORTED_AUI;
 		if (lp->ctl_rspeed == 10)
 			cmd->speed = SPEED_10;
 		else if (lp->ctl_rspeed == 100)
 			cmd->speed = SPEED_100;
 		cmd->autoneg = AUTONEG_DISABLE;
 		if (lp->mii.phy_id==1)
 			cmd->transceiver = XCVR_INTERNAL;
 		else
 			cmd->transceiver = XCVR_EXTERNAL;
 		cmd->port = 0;
 		SMC_GET_PHY_SPECIAL(lp, lp->mii.phy_id, status);
 		cmd->duplex =
 			(status & (PHY_SPECIAL_SPD_10FULL_ | PHY_SPECIAL_SPD_100FULL_)) ?
 				DUPLEX_FULL : DUPLEX_HALF;
 		ret = 0;
 	}
 	return ret;
 }
 static int
 smc911x_ethtool_setsettings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int ret;
 	unsigned long flags;
 	if (lp->phy_type != 0) {
 		spin_lock_irqsave(&lp->lock, flags);
 		ret = mii_ethtool_sset(&lp->mii, cmd);
 		spin_unlock_irqrestore(&lp->lock, flags);
 	} else {
 		if (cmd->autoneg != AUTONEG_DISABLE ||
 			cmd->speed != SPEED_10 ||
 			(cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL) ||
 			(cmd->port != PORT_TP && cmd->port != PORT_AUI))
 			return -EINVAL;
 		lp->ctl_rfduplx = cmd->duplex == DUPLEX_FULL;
 		ret = 0;
 	}
 	return ret;
 }
 static void
 smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
 	strncpy(info->driver, CARDNAME, sizeof(info->driver));
 	strncpy(info->version, version, sizeof(info->version));
 	strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
 }
 static int smc911x_ethtool_nwayreset(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int ret = -EINVAL;
 	unsigned long flags;
 	if (lp->phy_type != 0) {
 		spin_lock_irqsave(&lp->lock, flags);
 		ret = mii_nway_restart(&lp->mii);
 		spin_unlock_irqrestore(&lp->lock, flags);
 	}
 	return ret;
 }
 static u32 smc911x_ethtool_getmsglevel(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	return lp->msg_enable;
 }
 static void smc911x_ethtool_setmsglevel(struct net_device *dev, u32 level)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	lp->msg_enable = level;
 }
 static int smc911x_ethtool_getregslen(struct net_device *dev)
 {
 	/* System regs + MAC regs + PHY regs */
 	return (((E2P_CMD - ID_REV)/4 + 1) +
 			(WUCSR - MAC_CR)+1 + 32) * sizeof(u32);
 }
 static void smc911x_ethtool_getregs(struct net_device *dev,
 										 struct ethtool_regs* regs, void *buf)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned long flags;
 	u32 reg,i,j=0;
 	u32 *data = (u32*)buf;
 	regs->version = lp->version;
 	for(i=ID_REV;i<=E2P_CMD;i+=4) {
 		data[j++] = SMC_inl(lp, i);
 	}
 	for(i=MAC_CR;i<=WUCSR;i++) {
 		spin_lock_irqsave(&lp->lock, flags);
 		SMC_GET_MAC_CSR(lp, i, reg);
 		spin_unlock_irqrestore(&lp->lock, flags);
 		data[j++] = reg;
 	}
 	for(i=0;i<=31;i++) {
 		spin_lock_irqsave(&lp->lock, flags);
 		SMC_GET_MII(lp, i, lp->mii.phy_id, reg);
 		spin_unlock_irqrestore(&lp->lock, flags);
 		data[j++] = reg & 0xFFFF;
 	}
 }
 static int smc911x_ethtool_wait_eeprom_ready(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	unsigned int timeout;
 	int e2p_cmd;
 	e2p_cmd = SMC_GET_E2P_CMD(lp);
 	for(timeout=10;(e2p_cmd & E2P_CMD_EPC_BUSY_) && timeout; timeout--) {
 		if (e2p_cmd & E2P_CMD_EPC_TIMEOUT_) {
 			PRINTK("%s: %s timeout waiting for EEPROM to respond\n",
 				dev->name, __func__);
 			return -EFAULT;
 		}
 		mdelay(1);
 		e2p_cmd = SMC_GET_E2P_CMD(lp);
 	}
 	if (timeout == 0) {
 		PRINTK("%s: %s timeout waiting for EEPROM CMD not busy\n",
 			dev->name, __func__);
 		return -ETIMEDOUT;
 	}
 	return 0;
 }
 static inline int smc911x_ethtool_write_eeprom_cmd(struct net_device *dev,
 													int cmd, int addr)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int ret;
 	if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)
 		return ret;
 	SMC_SET_E2P_CMD(lp, E2P_CMD_EPC_BUSY_ |
 		((cmd) & (0x7<<28)) |
 		((addr) & 0xFF));
 	return 0;
 }
 static inline int smc911x_ethtool_read_eeprom_byte(struct net_device *dev,
 													u8 *data)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int ret;
 	if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)
 		return ret;
 	*data = SMC_GET_E2P_DATA(lp);
 	return 0;
 }
 static inline int smc911x_ethtool_write_eeprom_byte(struct net_device *dev,
 													 u8 data)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int ret;
 	if ((ret = smc911x_ethtool_wait_eeprom_ready(dev))!=0)
 		return ret;
 	SMC_SET_E2P_DATA(lp, data);
 	return 0;
 }
 static int smc911x_ethtool_geteeprom(struct net_device *dev,
 									  struct ethtool_eeprom *eeprom, u8 *data)
 {
 	u8 eebuf[SMC911X_EEPROM_LEN];
 	int i, ret;
 	for(i=0;i<SMC911X_EEPROM_LEN;i++) {
 		if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_READ_, i ))!=0)
 			return ret;
 		if ((ret=smc911x_ethtool_read_eeprom_byte(dev, &eebuf[i]))!=0)
 			return ret;
 		}
 	memcpy(data, eebuf+eeprom->offset, eeprom->len);
 	return 0;
 }
 static int smc911x_ethtool_seteeprom(struct net_device *dev,
 									   struct ethtool_eeprom *eeprom, u8 *data)
 {
 	int i, ret;
 	/* Enable erase */
 	if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_EWEN_, 0 ))!=0)
 		return ret;
 	for(i=eeprom->offset;i<(eeprom->offset+eeprom->len);i++) {
 		/* erase byte */
 		if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_ERASE_, i ))!=0)
 			return ret;
 		/* write byte */
 		if ((ret=smc911x_ethtool_write_eeprom_byte(dev, *data))!=0)
 			 return ret;
 		if ((ret=smc911x_ethtool_write_eeprom_cmd(dev, E2P_CMD_EPC_CMD_WRITE_, i ))!=0)
 			return ret;
 		}
 	 return 0;
 }
 static int smc911x_ethtool_geteeprom_len(struct net_device *dev)
 {
 	 return SMC911X_EEPROM_LEN;
 }
 static const struct ethtool_ops smc911x_ethtool_ops = {
 	.get_settings	 = smc911x_ethtool_getsettings,
 	.set_settings	 = smc911x_ethtool_setsettings,
 	.get_drvinfo	 = smc911x_ethtool_getdrvinfo,
 	.get_msglevel	 = smc911x_ethtool_getmsglevel,
 	.set_msglevel	 = smc911x_ethtool_setmsglevel,
 	.nway_reset = smc911x_ethtool_nwayreset,
 	.get_link	 = ethtool_op_get_link,
 	.get_regs_len	 = smc911x_ethtool_getregslen,
 	.get_regs	 = smc911x_ethtool_getregs,
 	.get_eeprom_len = smc911x_ethtool_geteeprom_len,
 	.get_eeprom = smc911x_ethtool_geteeprom,
 	.set_eeprom = smc911x_ethtool_seteeprom,
 };
 /*
  * smc911x_findirq
  *
  * This routine has a simple purpose -- make the SMC chip generate an
  * interrupt, so an auto-detect routine can detect it, and find the IRQ,
  */
 static int __init smc911x_findirq(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int timeout = 20;
 	unsigned long cookie;
 	DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);
 	cookie = probe_irq_on();
 	/*
 	 * Force a SW interrupt
 	 */
 	SMC_SET_INT_EN(lp, INT_EN_SW_INT_EN_);
 	/*
 	 * Wait until positive that the interrupt has been generated
 	 */
 	do {
 		int int_status;
 		udelay(10);
 		int_status = SMC_GET_INT_EN(lp);
 		if (int_status & INT_EN_SW_INT_EN_)
 			 break;		/* got the interrupt */
 	} while (--timeout);
 	/*
 	 * there is really nothing that I can do here if timeout fails,
 	 * as autoirq_report will return a 0 anyway, which is what I
 	 * want in this case.	 Plus, the clean up is needed in both
 	 * cases.
 	 */
 	/* and disable all interrupts again */
 	SMC_SET_INT_EN(lp, 0);
 	/* and return what I found */
 	return probe_irq_off(cookie);
 }
 /*
  * Function: smc911x_probe(unsigned long ioaddr)
  *
  * Purpose:
  *	 Tests to see if a given ioaddr points to an SMC911x chip.
  *	 Returns a 0 on success
  *
  * Algorithm:
  *	 (1) see if the endian word is OK
  *	 (1) see if I recognize the chip ID in the appropriate register
  *
  * Here I do typical initialization tasks.
  *
  * o  Initialize the structure if needed
  * o  print out my vanity message if not done so already
  * o  print out what type of hardware is detected
  * o  print out the ethernet address
  * o  find the IRQ
  * o  set up my private data
  * o  configure the dev structure with my subroutines
  * o  actually GRAB the irq.
  * o  GRAB the region
  */
 static int __init smc911x_probe(struct net_device *dev)
 {
 	struct smc911x_local *lp = netdev_priv(dev);
 	int i, retval;
 	unsigned int val, chip_id, revision;
 	const char *version_string;
 	unsigned long irq_flags;
 	DBG(SMC_DEBUG_FUNC, "%s: --> %s\n", dev->name, __func__);
 	/* First, see if the endian word is recognized */
 	val = SMC_GET_BYTE_TEST(lp);
 	DBG(SMC_DEBUG_MISC, "%s: endian probe returned 0x%04x\n", CARDNAME, val);
 	if (val != 0x87654321) {
 		printk(KERN_ERR "Invalid chip endian 0x08%x\n",val);
 		retval = -ENODEV;
 		goto err_out;
 	}
 	/*
 	 * check if the revision register is something that I
 	 * recognize.	These might need to be added to later,
 	 * as future revisions could be added.
 	 */
 	chip_id = SMC_GET_PN(lp);
 	DBG(SMC_DEBUG_MISC, "%s: id probe returned 0x%04x\n", CARDNAME, chip_id);
 	for(i=0;chip_ids[i].id != 0; i++) {
 		if (chip_ids[i].id == chip_id) break;
 	}
 	if (!chip_ids[i].id) {
 		printk(KERN_ERR "Unknown chip ID %04x\n", chip_id);
 		retval = -ENODEV;
 		goto err_out;
 	}
 	version_string = chip_ids[i].name;
 	revision = SMC_GET_REV(lp);
 	DBG(SMC_DEBUG_MISC, "%s: revision = 0x%04x\n", CARDNAME, revision);
 	/* At this point I'll assume that the chip is an SMC911x. */
 	DBG(SMC_DEBUG_MISC, "%s: Found a %s\n", CARDNAME, chip_ids[i].name);
 	/* Validate the TX FIFO size requested */
 	if ((tx_fifo_kb < 2) || (tx_fifo_kb > 14)) {
 		printk(KERN_ERR "Invalid TX FIFO size requested %d\n", tx_fifo_kb);
 		retval = -EINVAL;
 		goto err_out;
 	}
 	/* fill in some of the fields */
 	lp->version = chip_ids[i].id;
 	lp->revision = revision;
 	lp->tx_fifo_kb = tx_fifo_kb;
 	/* Reverse calculate the RX FIFO size from the TX */
 	lp->tx_fifo_size=(lp->tx_fifo_kb<<10) - 512;
 	lp->rx_fifo_size= ((0x4000 - 512 - lp->tx_fifo_size) / 16) * 15;
 	/* Set the automatic flow control values */
 	switch(lp->tx_fifo_kb) {
 		/*
 		 *	 AFC_HI is about ((Rx Data Fifo Size)*2/3)/64
 		 *	 AFC_LO is AFC_HI/2
 		 *	 BACK_DUR is about 5uS*(AFC_LO) rounded down
 		 */
 		case 2:/* 13440 Rx Data Fifo Size */
 			lp->afc_cfg=0x008C46AF;break;
 		case 3:/* 12480 Rx Data Fifo Size */
 			lp->afc_cfg=0x0082419F;break;
 		case 4:/* 11520 Rx Data Fifo Size */
 			lp->afc_cfg=0x00783C9F;break;
 		case 5:/* 10560 Rx Data Fifo Size */
 			lp->afc_cfg=0x006E374F;break;
 		case 6:/* 9600 Rx Data Fifo Size */
 			lp->afc_cfg=0x0064328F;break;
 		case 7:/* 8640 Rx Data Fifo Size */
 			lp->afc_cfg=0x005A2D7F;break;
 		case 8:/* 7680 Rx Data Fifo Size */
 			lp->afc_cfg=0x0050287F;break;
 		case 9:/* 6720 Rx Data Fifo Size */
 			lp->afc_cfg=0x0046236F;break;
 		case 10:/* 5760 Rx Data Fifo Size */
 			lp->afc_cfg=0x003C1E6F;break;
 		case 11:/* 4800 Rx Data Fifo Size */
 			lp->afc_cfg=0x0032195F;break;
 		/*
 		 *	 AFC_HI is ~1520 bytes less than RX Data Fifo Size
 		 *	 AFC_LO is AFC_HI/2
 		 *	 BACK_DUR is about 5uS*(AFC_LO) rounded down
 		 */
 		case 12:/* 3840 Rx Data Fifo Size */
 			lp->afc_cfg=0x0024124F;break;
 		case 13:/* 2880 Rx Data Fifo Size */
 			lp->afc_cfg=0x0015073F;break;
 		case 14:/* 1920 Rx Data Fifo Size */
 			lp->afc_cfg=0x0006032F;break;
 		 default:
 			 PRINTK("%s: ERROR -- no AFC_CFG setting found",
 				dev->name);
 			 break;
 	}
 	DBG(SMC_DEBUG_MISC | SMC_DEBUG_TX | SMC_DEBUG_RX,
 		"%s: tx_fifo %d rx_fifo %d afc_cfg 0x%08x\n", CARDNAME,
 		lp->tx_fifo_size, lp->rx_fifo_size, lp->afc_cfg);
 	spin_lock_init(&lp->lock);
 	/* Get the MAC address */
 	SMC_GET_MAC_ADDR(lp, dev->dev_addr);
 	/* now, reset the chip, and put it into a known state */
 	smc911x_reset(dev);
 	/*
 	 * If dev->irq is 0, then the device has to be banged on to see
 	 * what the IRQ is.
 	 *
 	 * Specifying an IRQ is done with the assumption that the user knows
 	 * what (s)he is doing.  No checking is done!!!!
 	 */
 	if (dev->irq < 1) {
 		int trials;
 		trials = 3;
 		while (trials--) {
 			dev->irq = smc911x_findirq(dev);
 			if (dev->irq)
 				break;
 			/* kick the card and try again */
 			smc911x_reset(dev);
 		}
 	}
 	if (dev->irq == 0) {
 		printk("%s: Couldn't autodetect your IRQ. Use irq=xx.\n",
 			dev->name);
 		retval = -ENODEV;
 		goto err_out;
 	}
 	dev->irq = irq_canonicalize(dev->irq);
 	/* Fill in the fields of the device structure with ethernet values. */
 	ether_setup(dev);
 	dev->open = smc911x_open;
 	dev->stop = smc911x_close;
 	dev->hard_start_xmit = smc911x_hard_start_xmit;
 	dev->tx_timeout = smc911x_timeout;
 	dev->watchdog_timeo = msecs_to_jiffies(watchdog);
 	dev->set_multicast_list = smc911x_set_multicast_list;
 	dev->ethtool_ops = &smc911x_ethtool_ops;
 #ifdef CONFIG_NET_POLL_CONTROLLER
 	dev->poll_controller = smc911x_poll_controller;
 #endif
 	INIT_WORK(&lp->phy_configure, smc911x_phy_configure);
 	lp->mii.phy_id_mask = 0x1f;
 	lp->mii.reg_num_mask = 0x1f;
 	lp->mii.force_media = 0;
 	lp->mii.full_duplex = 0;
 	lp->mii.dev = dev;
 	lp->mii.mdio_read = smc911x_phy_read;
 	lp->mii.mdio_write = smc911x_phy_write;
 	/*
 	 * Locate the phy, if any.
 	 */
 	smc911x_phy_detect(dev);
 	/* Set default parameters */
 	lp->msg_enable = NETIF_MSG_LINK;
 	lp->ctl_rfduplx = 1;
 	lp->ctl_rspeed = 100;
 #ifdef SMC_DYNAMIC_BUS_CONFIG
 	irq_flags = lp->cfg.irq_flags;
 #else
 	irq_flags = IRQF_SHARED | SMC_IRQ_SENSE;
 #endif
 	/* Grab the IRQ */
 	retval = request_irq(dev->irq, &smc911x_interrupt,
 			     irq_flags, dev->name, dev);
 	if (retval)
 		goto err_out;
 #ifdef SMC_USE_DMA
 	lp->rxdma = SMC_DMA_REQUEST(dev, smc911x_rx_dma_irq);
 	lp->txdma = SMC_DMA_REQUEST(dev, smc911x_tx_dma_irq);
 	lp->rxdma_active = 0;
 	lp->txdma_active = 0;
 	dev->dma = lp->rxdma;
 #endif
 	retval = register_netdev(dev);
 	if (retval == 0) {
 		/* now, print out the card info, in a short format.. */
 		printk("%s: %s (rev %d) at %#lx IRQ %d",
 			dev->name, version_string, lp->revision,
 			dev->base_addr, dev->irq);
 #ifdef SMC_USE_DMA
 		if (lp->rxdma != -1)
 			printk(" RXDMA %d ", lp->rxdma);
 		if (lp->txdma != -1)
 			printk("TXDMA %d", lp->txdma);
 #endif
 		printk("\n");
 		if (!is_valid_ether_addr(dev->dev_addr)) {
 			printk("%s: Invalid ethernet MAC address. Please "
 					"set using ifconfig\n", dev->name);
 		} else {
 			/* Print the Ethernet address */
 			printk("%s: Ethernet addr: ", dev->name);
 			for (i = 0; i < 5; i++)
 				printk("%2.2x:", dev->dev_addr[i]);
 			printk("%2.2x\n", dev->dev_addr[5]);
 		}
 		if (lp->phy_type == 0) {
 			PRINTK("%s: No PHY found\n", dev->name);
 		} else if ((lp->phy_type & ~0xff) == LAN911X_INTERNAL_PHY_ID) {
 			PRINTK("%s: LAN911x Internal PHY\n", dev->name);
 		} else {
 			PRINTK("%s: External PHY 0x%08x\n", dev->name, lp->phy_type);
 		}
 	}
 err_out:
 #ifdef SMC_USE_DMA
 	if (retval) {
 		if (lp->rxdma != -1) {
 			SMC_DMA_FREE(dev, lp->rxdma);
 		}
 		if (lp->txdma != -1) {
 			SMC_DMA_FREE(dev, lp->txdma);
 		}
 	}
 #endif
 	return retval;
 }
 /*
  * smc911x_init(void)
  *
  *	  Output:
  *	 0 --> there is a device
  *	 anything else, error
  */
 static int smc911x_drv_probe(struct platform_device *pdev)
 {
-	struct smc91x_platdata *pd = pdev->dev.platform_data;
+	struct smc911x_platdata *pd = pdev->dev.platform_data;
 	struct net_device *ndev;
 	struct resource *res;
 	struct smc911x_local *lp;
 	unsigned int *addr;
 	int ret;
 	DBG(SMC_DEBUG_FUNC, "--> %s\n",  __func__);
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res) {
 		ret = -ENODEV;
 		goto out;
 	}
 	/*
 	 * Request the regions.
 	 */
 	if (!request_mem_region(res->start, SMC911X_IO_EXTENT, CARDNAME)) {
 		 ret = -EBUSY;
 		 goto out;
 	}
 	ndev = alloc_etherdev(sizeof(struct smc911x_local));
 	if (!ndev) {
 		printk("%s: could not allocate device.\n", CARDNAME);
 		ret = -ENOMEM;
 		goto release_1;
 	}
 	SET_NETDEV_DEV(ndev, &pdev->dev);
 	ndev->dma = (unsigned char)-1;
 	ndev->irq = platform_get_irq(pdev, 0);
 	lp = netdev_priv(ndev);
 	lp->netdev = ndev;
 #ifdef SMC_DYNAMIC_BUS_CONFIG
 	if (!pd) {
 		ret = -EINVAL;
 		goto release_both;
 	}
 	memcpy(&lp->cfg, pd, sizeof(lp->cfg));
 #endif
 	addr = ioremap(res->start, SMC911X_IO_EXTENT);
 	if (!addr) {
 		ret = -ENOMEM;
 		goto release_both;
 	}
 	platform_set_drvdata(pdev, ndev);
 	lp->base = addr;
 	ndev->base_addr = res->start;
 	ret = smc911x_probe(ndev);
 	if (ret != 0) {
 		platform_set_drvdata(pdev, NULL);
 		iounmap(addr);
 release_both:
 		free_netdev(ndev);
 release_1:
 		release_mem_region(res->start, SMC911X_IO_EXTENT);
 out:
 		printk("%s: not found (%d).\n", CARDNAME, ret);
 	}
 #ifdef SMC_USE_DMA
 	else {
 		lp->physaddr = res->start;
 		lp->dev = &pdev->dev;
 	}
 #endif
 	return ret;
 }
 static int smc911x_drv_remove(struct platform_device *pdev)
 {
 	struct net_device *ndev = platform_get_drvdata(pdev);
 	struct smc911x_local *lp = netdev_priv(ndev);
 	struct resource *res;
 	DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);
 	platform_set_drvdata(pdev, NULL);
 	unregister_netdev(ndev);
 	free_irq(ndev->irq, ndev);
 #ifdef SMC_USE_DMA
 	{
 		if (lp->rxdma != -1) {
 			SMC_DMA_FREE(dev, lp->rxdma);
 		}
 		if (lp->txdma != -1) {
 			SMC_DMA_FREE(dev, lp->txdma);
 		}
 	}
 #endif
 	iounmap(lp->base);
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	release_mem_region(res->start, SMC911X_IO_EXTENT);
 	free_netdev(ndev);
 	return 0;
 }
 static int smc911x_drv_suspend(struct platform_device *dev, pm_message_t state)
 {
 	struct net_device *ndev = platform_get_drvdata(dev);
 	struct smc911x_local *lp = netdev_priv(ndev);
 	DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);
 	if (ndev) {
 		if (netif_running(ndev)) {
 			netif_device_detach(ndev);
 			smc911x_shutdown(ndev);
 #if POWER_DOWN
 			/* Set D2 - Energy detect only setting */
 			SMC_SET_PMT_CTRL(lp, 2<<12);
 #endif
 		}
 	}
 	return 0;
 }
 static int smc911x_drv_resume(struct platform_device *dev)
 {
 	struct net_device *ndev = platform_get_drvdata(dev);
 	DBG(SMC_DEBUG_FUNC, "--> %s\n", __func__);
 	if (ndev) {
 		struct smc911x_local *lp = netdev_priv(ndev);
 		if (netif_running(ndev)) {
 			smc911x_reset(ndev);
 			smc911x_enable(ndev);
 			if (lp->phy_type != 0)
 				smc911x_phy_configure(&lp->phy_configure);
 			netif_device_attach(ndev);
 		}
 	}
 	return 0;
 }
 static struct platform_driver smc911x_driver = {
 	.probe		 = smc911x_drv_probe,
 	.remove	 = smc911x_drv_remove,
 	.suspend	 = smc911x_drv_suspend,
 	.resume	 = smc911x_drv_resume,
 	.driver	 = {
 		.name	 = CARDNAME,
 		.owner	= THIS_MODULE,
 	},
 };
 static int __init smc911x_init(void)
 {
 	return platform_driver_register(&smc911x_driver);
 }
 static void __exit smc911x_cleanup(void)
 {
 	platform_driver_unregister(&smc911x_driver);
 }
 module_init(smc911x_init);
 module_exit(smc911x_cleanup);