Eric Lee / smarc-fsl-linux-kernel

1

/*

1

/*

2

* Linux ARCnet driver - device-independent routines

2

* Linux ARCnet driver - device-independent routines

3

*

3

*

4

* Written 1997 by David Woodhouse.

4

* Written 1997 by David Woodhouse.

5

* Written 1994-1999 by Avery Pennarun.

5

* Written 1994-1999 by Avery Pennarun.

6

* Written 1999-2000 by Martin Mares <mj@ucw.cz>.

6

* Written 1999-2000 by Martin Mares <mj@ucw.cz>.

7

* Derived from skeleton.c by Donald Becker.

7

* Derived from skeleton.c by Donald Becker.

8

*

8

*

9

* Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)

9

* Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)

10

* for sponsoring the further development of this driver.

10

* for sponsoring the further development of this driver.

11

*

11

*

12

* **********************

12

* **********************

13

*

13

*

14

* The original copyright was as follows:

14

* The original copyright was as follows:

15

*

15

*

16

* skeleton.c Written 1993 by Donald Becker.

16

* skeleton.c Written 1993 by Donald Becker.

17

18

* Director, National Security Agency. This software may only be used

18

* Director, National Security Agency. This software may only be used

19

* and distributed according to the terms of the GNU General Public License as

19

* and distributed according to the terms of the GNU General Public License as

20

* modified by SRC, incorporated herein by reference.

20

* modified by SRC, incorporated herein by reference.

21

*

21

*

22

* **********************

22

* **********************

23

*

23

*

24

* The change log is now in a file called ChangeLog in this directory.

24

* The change log is now in a file called ChangeLog in this directory.

25

*

25

*

26

* Sources:

26

* Sources:

27

* - Crynwr arcnet.com/arcether.com packet drivers.

27

* - Crynwr arcnet.com/arcether.com packet drivers.

28

* - arcnet.c v0.00 dated 1/1/94 and apparently by

28

* - arcnet.c v0.00 dated 1/1/94 and apparently by

29

* Donald Becker - it didn't work :)

29

* Donald Becker - it didn't work :)

30

* - skeleton.c v0.05 dated 11/16/93 by Donald Becker

30

* - skeleton.c v0.05 dated 11/16/93 by Donald Becker

31

* (from Linux Kernel 1.1.45)

31

* (from Linux Kernel 1.1.45)

32

* - RFC's 1201 and 1051 - re: TCP/IP over ARCnet

32

* - RFC's 1201 and 1051 - re: TCP/IP over ARCnet

33

* - The official ARCnet COM9026 data sheets (!) thanks to

33

* - The official ARCnet COM9026 data sheets (!) thanks to

34

* Ken Cornetet <kcornete@nyx10.cs.du.edu>

34

* Ken Cornetet <kcornete@nyx10.cs.du.edu>

35

* - The official ARCnet COM20020 data sheets.

35

* - The official ARCnet COM20020 data sheets.

36

* - Information on some more obscure ARCnet controller chips, thanks

36

* - Information on some more obscure ARCnet controller chips, thanks

37

* to the nice people at SMSC.

37

* to the nice people at SMSC.

38

* - net/inet/eth.c (from kernel 1.1.50) for header-building info.

38

* - net/inet/eth.c (from kernel 1.1.50) for header-building info.

39

* - Alternate Linux ARCnet source by V.Shergin <vsher@sao.stavropol.su>

39

* - Alternate Linux ARCnet source by V.Shergin <vsher@sao.stavropol.su>

40

* - Textual information and more alternate source from Joachim Koenig

40

* - Textual information and more alternate source from Joachim Koenig

41

* <jojo@repas.de>

41

* <jojo@repas.de>

42

*/

42

*/

43

44

#define VERSION "arcnet: v3.93 BETA 2000/04/29 - by Avery Pennarun et al.\n"

44

#define VERSION "arcnet: v3.93 BETA 2000/04/29 - by Avery Pennarun et al.\n"

45

46

#include <linux/module.h>

46

#include <linux/module.h>

47

#include <linux/config.h>

47

#include <linux/config.h>

48

#include <linux/types.h>

48

#include <linux/types.h>

49

#include <linux/delay.h>

49

#include <linux/delay.h>

50

#include <linux/netdevice.h>

50

#include <linux/netdevice.h>

51

#include <linux/if_arp.h>

51

#include <linux/if_arp.h>

52

#include <net/arp.h>

52

#include <net/arp.h>

53

#include <linux/init.h>

53

#include <linux/init.h>

54

#include <linux/arcdevice.h>

54

#include <linux/arcdevice.h>

55

56

/* "do nothing" functions for protocol drivers */

56

/* "do nothing" functions for protocol drivers */

57

static void null_rx(struct net_device *dev, int bufnum,

57

static void null_rx(struct net_device *dev, int bufnum,

58

struct archdr *pkthdr, int length);

58

struct archdr *pkthdr, int length);

59

static int null_build_header(struct sk_buff *skb, struct net_device *dev,

59

static int null_build_header(struct sk_buff *skb, struct net_device *dev,

60

unsigned short type, uint8_t daddr);

60

unsigned short type, uint8_t daddr);

61

static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,

61

static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,

62

int length, int bufnum);

62

int length, int bufnum);

63

64

65

/*

65

/*

66

* one ArcProto per possible proto ID. None of the elements of

66

* one ArcProto per possible proto ID. None of the elements of

67

* arc_proto_map are allowed to be NULL; they will get set to

67

* arc_proto_map are allowed to be NULL; they will get set to

68

* arc_proto_default instead. It also must not be NULL; if you would like

68

* arc_proto_default instead. It also must not be NULL; if you would like

69

* to set it to NULL, set it to &arc_proto_null instead.

69

* to set it to NULL, set it to &arc_proto_null instead.

70

*/

70

*/

71

struct ArcProto *arc_proto_map[256], *arc_proto_default,

71

struct ArcProto *arc_proto_map[256], *arc_proto_default,

72

*arc_bcast_proto, *arc_raw_proto;

72

*arc_bcast_proto, *arc_raw_proto;

73

74

struct ArcProto arc_proto_null =

74

struct ArcProto arc_proto_null =

75

{

75

{

76

.suffix = '?',

76

.suffix = '?',

77

.mtu = XMTU,

77

.mtu = XMTU,

78

.is_ip = 0,

78

.is_ip = 0,

79

.rx = null_rx,

79

.rx = null_rx,

80

.build_header = null_build_header,

80

.build_header = null_build_header,

81

.prepare_tx = null_prepare_tx,

81

.prepare_tx = null_prepare_tx,

82

.continue_tx = NULL,

82

.continue_tx = NULL,

83

.ack_tx = NULL

83

.ack_tx = NULL

84

};

84

};

85

86

/* Exported function prototypes */

86

/* Exported function prototypes */

87

int arcnet_debug = ARCNET_DEBUG;

87

int arcnet_debug = ARCNET_DEBUG;

88

89

EXPORT_SYMBOL(arc_proto_map);

89

EXPORT_SYMBOL(arc_proto_map);

90

EXPORT_SYMBOL(arc_proto_default);

90

EXPORT_SYMBOL(arc_proto_default);

91

EXPORT_SYMBOL(arc_bcast_proto);

91

EXPORT_SYMBOL(arc_bcast_proto);

92

EXPORT_SYMBOL(arc_raw_proto);

92

EXPORT_SYMBOL(arc_raw_proto);

93

EXPORT_SYMBOL(arc_proto_null);

93

EXPORT_SYMBOL(arc_proto_null);

94

EXPORT_SYMBOL(arcnet_unregister_proto);

94

EXPORT_SYMBOL(arcnet_unregister_proto);

95

EXPORT_SYMBOL(arcnet_debug);

95

EXPORT_SYMBOL(arcnet_debug);

96

EXPORT_SYMBOL(alloc_arcdev);

96

EXPORT_SYMBOL(alloc_arcdev);

97

EXPORT_SYMBOL(arcnet_interrupt);

97

EXPORT_SYMBOL(arcnet_interrupt);

98

99

/* Internal function prototypes */

99

/* Internal function prototypes */

100

static int arcnet_open(struct net_device *dev);

100

static int arcnet_open(struct net_device *dev);

101

static int arcnet_close(struct net_device *dev);

101

static int arcnet_close(struct net_device *dev);

102

static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev);

102

static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev);

103

static void arcnet_timeout(struct net_device *dev);

103

static void arcnet_timeout(struct net_device *dev);

104

static int arcnet_header(struct sk_buff *skb, struct net_device *dev,

104

static int arcnet_header(struct sk_buff *skb, struct net_device *dev,

105

unsigned short type, void *daddr, void *saddr,

105

unsigned short type, void *daddr, void *saddr,

106

unsigned len);

106

unsigned len);

107

static int arcnet_rebuild_header(struct sk_buff *skb);

107

static int arcnet_rebuild_header(struct sk_buff *skb);

108

static struct net_device_stats *arcnet_get_stats(struct net_device *dev);

108

static struct net_device_stats *arcnet_get_stats(struct net_device *dev);

109

static int go_tx(struct net_device *dev);

109

static int go_tx(struct net_device *dev);

110

111

static int debug = ARCNET_DEBUG;

111

static int debug = ARCNET_DEBUG;

112

module_param(debug, int, 0);

112

module_param(debug, int, 0);

113

MODULE_LICENSE("GPL");

113

MODULE_LICENSE("GPL");

114

115

static int __init arcnet_init(void)

115

static int __init arcnet_init(void)

116

{

116

{

117

int count;

117

int count;

118

119

arcnet_debug = debug;

119

arcnet_debug = debug;

120

121

printk(VERSION);

121

printk(VERSION);

122

123

#ifdef ALPHA_WARNING

123

#ifdef ALPHA_WARNING

124

BUGLVL(D_EXTRA) {

124

BUGLVL(D_EXTRA) {

125

printk("arcnet: ***\n"

125

printk("arcnet: ***\n"

126

"arcnet: * Read arcnet.txt for important release notes!\n"

126

"arcnet: * Read arcnet.txt for important release notes!\n"

127

"arcnet: *\n"

127

"arcnet: *\n"

128

"arcnet: * This is an ALPHA version! (Last stable release: v3.02) E-mail\n"

128

"arcnet: * This is an ALPHA version! (Last stable release: v3.02) E-mail\n"

129

"arcnet: * me if you have any questions, comments, or bug reports.\n"

129

"arcnet: * me if you have any questions, comments, or bug reports.\n"

130

"arcnet: ***\n");

130

"arcnet: ***\n");

131

}

131

}

132

#endif

132

#endif

133

134

/* initialize the protocol map */

134

/* initialize the protocol map */

135

arc_raw_proto = arc_proto_default = arc_bcast_proto = &arc_proto_null;

135

arc_raw_proto = arc_proto_default = arc_bcast_proto = &arc_proto_null;

136

for (count = 0; count < 256; count++)

136

for (count = 0; count < 256; count++)

137

arc_proto_map[count] = arc_proto_default;

137

arc_proto_map[count] = arc_proto_default;

138

139

BUGLVL(D_DURING)

139

BUGLVL(D_DURING)

140

printk("arcnet: struct sizes: %Zd %Zd %Zd %Zd %Zd\n",

140

printk("arcnet: struct sizes: %Zd %Zd %Zd %Zd %Zd\n",

141

sizeof(struct arc_hardware), sizeof(struct arc_rfc1201),

141

sizeof(struct arc_hardware), sizeof(struct arc_rfc1201),

142

sizeof(struct arc_rfc1051), sizeof(struct arc_eth_encap),

142

sizeof(struct arc_rfc1051), sizeof(struct arc_eth_encap),

143

sizeof(struct archdr));

143

sizeof(struct archdr));

144

145

return 0;

145

return 0;

146

}

146

}

147

148

static void __exit arcnet_exit(void)

148

static void __exit arcnet_exit(void)

149

{

149

{

150

}

150

}

151

152

module_init(arcnet_init);

152

module_init(arcnet_init);

153

module_exit(arcnet_exit);

153

module_exit(arcnet_exit);

154

155

/*

155

/*

156

* Dump the contents of an sk_buff

156

* Dump the contents of an sk_buff

157

*/

157

*/

158

#if ARCNET_DEBUG_MAX & D_SKB

158

#if ARCNET_DEBUG_MAX & D_SKB

159

void arcnet_dump_skb(struct net_device *dev,

159

void arcnet_dump_skb(struct net_device *dev,

160

struct sk_buff *skb, char *desc)

160

struct sk_buff *skb, char *desc)

161

{

161

{

162

int i;

162

int i;

163

164

printk(KERN_DEBUG "%6s: skb dump (%s) follows:", dev->name, desc);

164

printk(KERN_DEBUG "%6s: skb dump (%s) follows:", dev->name, desc);

165

for (i = 0; i < skb->len; i++) {

165

for (i = 0; i < skb->len; i++) {

166

if (i % 16 == 0)

166

if (i % 16 == 0)

167

printk("\n" KERN_DEBUG "[%04X] ", i);

167

printk("\n" KERN_DEBUG "[%04X] ", i);

168

printk("%02X ", ((u_char *) skb->data)[i]);

168

printk("%02X ", ((u_char *) skb->data)[i]);

169

}

169

}

170

printk("\n");

170

printk("\n");

171

}

171

}

172

173

EXPORT_SYMBOL(arcnet_dump_skb);

173

EXPORT_SYMBOL(arcnet_dump_skb);

174

#endif

174

#endif

175

176

177

/*

177

/*

178

* Dump the contents of an ARCnet buffer

178

* Dump the contents of an ARCnet buffer

179

*/

179

*/

180

#if (ARCNET_DEBUG_MAX & (D_RX | D_TX))

180

#if (ARCNET_DEBUG_MAX & (D_RX | D_TX))

181

void arcnet_dump_packet(struct net_device *dev, int bufnum, char *desc,

181

void arcnet_dump_packet(struct net_device *dev, int bufnum, char *desc,

182

int take_arcnet_lock)

182

int take_arcnet_lock)

183

{

183

{

184

struct arcnet_local *lp = dev->priv;

184

struct arcnet_local *lp = dev->priv;

185

int i, length;

185

int i, length;

186

unsigned long flags = 0;

186

unsigned long flags = 0;

187

static uint8_t buf[512];

187

static uint8_t buf[512];

188

189

/* hw.copy_from_card expects IRQ context so take the IRQ lock

189

/* hw.copy_from_card expects IRQ context so take the IRQ lock

190

to keep it single threaded */

190

to keep it single threaded */

191

if(take_arcnet_lock)

191

if(take_arcnet_lock)

192

spin_lock_irqsave(&lp->lock, flags);

192

spin_lock_irqsave(&lp->lock, flags);

193

194

lp->hw.copy_from_card(dev, bufnum, 0, buf, 512);

194

lp->hw.copy_from_card(dev, bufnum, 0, buf, 512);

195

if(take_arcnet_lock)

195

if(take_arcnet_lock)

196

spin_unlock_irqrestore(&lp->lock, flags);

196

spin_unlock_irqrestore(&lp->lock, flags);

197

198

/* if the offset[0] byte is nonzero, this is a 256-byte packet */

198

/* if the offset[0] byte is nonzero, this is a 256-byte packet */

199

length = (buf[2] ? 256 : 512);

199

length = (buf[2] ? 256 : 512);

200

201

printk(KERN_DEBUG "%6s: packet dump (%s) follows:", dev->name, desc);

201

printk(KERN_DEBUG "%6s: packet dump (%s) follows:", dev->name, desc);

202

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

202

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

203

if (i % 16 == 0)

203

if (i % 16 == 0)

204

printk("\n" KERN_DEBUG "[%04X] ", i);

204

printk("\n" KERN_DEBUG "[%04X] ", i);

205

printk("%02X ", buf[i]);

205

printk("%02X ", buf[i]);

206

}

206

}

207

printk("\n");

207

printk("\n");

208

209

}

209

}

210

211

EXPORT_SYMBOL(arcnet_dump_packet);

211

EXPORT_SYMBOL(arcnet_dump_packet);

212

#endif

212

#endif

213

214

215

/*

215

/*

216

* Unregister a protocol driver from the arc_proto_map. Protocol drivers

216

* Unregister a protocol driver from the arc_proto_map. Protocol drivers

217

* are responsible for registering themselves, but the unregister routine

217

* are responsible for registering themselves, but the unregister routine

218

* is pretty generic so we'll do it here.

218

* is pretty generic so we'll do it here.

219

*/

219

*/

220

void arcnet_unregister_proto(struct ArcProto *proto)

220

void arcnet_unregister_proto(struct ArcProto *proto)

221

{

221

{

222

int count;

222

int count;

223

224

if (arc_proto_default == proto)

224

if (arc_proto_default == proto)

225

arc_proto_default = &arc_proto_null;

225

arc_proto_default = &arc_proto_null;

226

if (arc_bcast_proto == proto)

226

if (arc_bcast_proto == proto)

227

arc_bcast_proto = arc_proto_default;

227

arc_bcast_proto = arc_proto_default;

228

if (arc_raw_proto == proto)

228

if (arc_raw_proto == proto)

229

arc_raw_proto = arc_proto_default;

229

arc_raw_proto = arc_proto_default;

230

231

for (count = 0; count < 256; count++) {

231

for (count = 0; count < 256; count++) {

232

if (arc_proto_map[count] == proto)

232

if (arc_proto_map[count] == proto)

233

arc_proto_map[count] = arc_proto_default;

233

arc_proto_map[count] = arc_proto_default;

234

}

234

}

235

}

235

}

236

237

238

/*

238

/*

239

* Add a buffer to the queue. Only the interrupt handler is allowed to do

239

* Add a buffer to the queue. Only the interrupt handler is allowed to do

240

* this, unless interrupts are disabled.

240

* this, unless interrupts are disabled.

241

*

241

*

242

* Note: we don't check for a full queue, since there aren't enough buffers

242

* Note: we don't check for a full queue, since there aren't enough buffers

243

* to more than fill it.

243

* to more than fill it.

244

*/

244

*/

245

static void release_arcbuf(struct net_device *dev, int bufnum)

245

static void release_arcbuf(struct net_device *dev, int bufnum)

246

{

246

{

247

struct arcnet_local *lp = dev->priv;

247

struct arcnet_local *lp = dev->priv;

248

int i;

248

int i;

249

250

lp->buf_queue[lp->first_free_buf++] = bufnum;

250

lp->buf_queue[lp->first_free_buf++] = bufnum;

251

lp->first_free_buf %= 5;

251

lp->first_free_buf %= 5;

252

253

BUGLVL(D_DURING) {

253

BUGLVL(D_DURING) {

254

BUGMSG(D_DURING, "release_arcbuf: freed #%d; buffer queue is now: ",

254

BUGMSG(D_DURING, "release_arcbuf: freed #%d; buffer queue is now: ",

255

bufnum);

255

bufnum);

256

for (i = lp->next_buf; i != lp->first_free_buf; i = (i+1) % 5)

256

for (i = lp->next_buf; i != lp->first_free_buf; i = (i+1) % 5)

257

BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);

257

BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);

258

BUGMSG2(D_DURING, "\n");

258

BUGMSG2(D_DURING, "\n");

259

}

259

}

260

}

260

}

261

262

263

/*

263

/*

264

* Get a buffer from the queue. If this returns -1, there are no buffers

264

* Get a buffer from the queue. If this returns -1, there are no buffers

265

* available.

265

* available.

266

*/

266

*/

267

static int get_arcbuf(struct net_device *dev)

267

static int get_arcbuf(struct net_device *dev)

268

{

268

{

269

struct arcnet_local *lp = dev->priv;

269

struct arcnet_local *lp = dev->priv;

270

int buf = -1, i;

270

int buf = -1, i;

271

272

if (!atomic_dec_and_test(&lp->buf_lock)) {

272

if (!atomic_dec_and_test(&lp->buf_lock)) {

273

/* already in this function */

273

/* already in this function */

274

BUGMSG(D_NORMAL, "get_arcbuf: overlap (%d)!\n",

274

BUGMSG(D_NORMAL, "get_arcbuf: overlap (%d)!\n",

275

lp->buf_lock.counter);

275

lp->buf_lock.counter);

276

}

276

}

277

else { /* we can continue */

277

else { /* we can continue */

278

if (lp->next_buf >= 5)

278

if (lp->next_buf >= 5)

279

lp->next_buf -= 5;

279

lp->next_buf -= 5;

280

281

if (lp->next_buf == lp->first_free_buf)

281

if (lp->next_buf == lp->first_free_buf)

282

BUGMSG(D_NORMAL, "get_arcbuf: BUG: no buffers are available??\n");

282

BUGMSG(D_NORMAL, "get_arcbuf: BUG: no buffers are available??\n");

283

else {

283

else {

284

buf = lp->buf_queue[lp->next_buf++];

284

buf = lp->buf_queue[lp->next_buf++];

285

lp->next_buf %= 5;

285

lp->next_buf %= 5;

286

}

286

}

287

}

287

}

288

289

290

BUGLVL(D_DURING) {

290

BUGLVL(D_DURING) {

291

BUGMSG(D_DURING, "get_arcbuf: got #%d; buffer queue is now: ", buf);

291

BUGMSG(D_DURING, "get_arcbuf: got #%d; buffer queue is now: ", buf);

292

for (i = lp->next_buf; i != lp->first_free_buf; i = (i+1) % 5)

292

for (i = lp->next_buf; i != lp->first_free_buf; i = (i+1) % 5)

293

BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);

293

BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);

294

BUGMSG2(D_DURING, "\n");

294

BUGMSG2(D_DURING, "\n");

295

}

295

}

296

297

atomic_inc(&lp->buf_lock);

297

atomic_inc(&lp->buf_lock);

298

return buf;

298

return buf;

299

}

299

}

300

301

302

static int choose_mtu(void)

302

static int choose_mtu(void)

303

{

303

{

304

int count, mtu = 65535;

304

int count, mtu = 65535;

305

306

/* choose the smallest MTU of all available encaps */

306

/* choose the smallest MTU of all available encaps */

307

for (count = 0; count < 256; count++) {

307

for (count = 0; count < 256; count++) {

308

if (arc_proto_map[count] != &arc_proto_null

308

if (arc_proto_map[count] != &arc_proto_null

309

&& arc_proto_map[count]->mtu < mtu) {

309

&& arc_proto_map[count]->mtu < mtu) {

310

mtu = arc_proto_map[count]->mtu;

310

mtu = arc_proto_map[count]->mtu;

311

}

311

}

312

}

312

}

313

314

return mtu == 65535 ? XMTU : mtu;

314

return mtu == 65535 ? XMTU : mtu;

315

}

315

}

316

317

318

/* Setup a struct device for ARCnet. */

318

/* Setup a struct device for ARCnet. */

319

static void arcdev_setup(struct net_device *dev)

319

static void arcdev_setup(struct net_device *dev)

320

{

320

{

321

dev->type = ARPHRD_ARCNET;

321

dev->type = ARPHRD_ARCNET;

322

dev->hard_header_len = sizeof(struct archdr);

322

dev->hard_header_len = sizeof(struct archdr);

323

dev->mtu = choose_mtu();

323

dev->mtu = choose_mtu();

324

325

dev->addr_len = ARCNET_ALEN;

325

dev->addr_len = ARCNET_ALEN;

326

dev->tx_queue_len = 100;

326

dev->tx_queue_len = 100;

327

dev->broadcast[0] = 0x00; /* for us, broadcasts are address 0 */

327

dev->broadcast[0] = 0x00; /* for us, broadcasts are address 0 */

328

dev->watchdog_timeo = TX_TIMEOUT;

328

dev->watchdog_timeo = TX_TIMEOUT;

329

330

/* New-style flags. */

330

/* New-style flags. */

331

dev->flags = IFF_BROADCAST;

331

dev->flags = IFF_BROADCAST;

332

333

/*

333

/*

334

* Put in this stuff here, so we don't have to export the symbols to

334

* Put in this stuff here, so we don't have to export the symbols to

335

* the chipset drivers.

335

* the chipset drivers.

336

*/

336

*/

337

dev->open = arcnet_open;

337

dev->open = arcnet_open;

338

dev->stop = arcnet_close;

338

dev->stop = arcnet_close;

339

dev->hard_start_xmit = arcnet_send_packet;

339

dev->hard_start_xmit = arcnet_send_packet;

340

dev->tx_timeout = arcnet_timeout;

340

dev->tx_timeout = arcnet_timeout;

341

dev->get_stats = arcnet_get_stats;

341

dev->get_stats = arcnet_get_stats;

342

dev->hard_header = arcnet_header;

342

dev->hard_header = arcnet_header;

343

dev->rebuild_header = arcnet_rebuild_header;

343

dev->rebuild_header = arcnet_rebuild_header;

344

}

344

}

345

346

struct net_device *alloc_arcdev(char *name)

346

struct net_device *alloc_arcdev(char *name)

347

{

347

{

348

struct net_device *dev;

348

struct net_device *dev;

349

350

dev = alloc_netdev(sizeof(struct arcnet_local),

350

dev = alloc_netdev(sizeof(struct arcnet_local),

351

name && *name ? name : "arc%d", arcdev_setup);

351

name && *name ? name : "arc%d", arcdev_setup);

352

if(dev) {

352

if(dev) {

353

struct arcnet_local *lp = (struct arcnet_local *) dev->priv;

353

struct arcnet_local *lp = (struct arcnet_local *) dev->priv;

354

spin_lock_init(&lp->lock);

354

spin_lock_init(&lp->lock);

355

}

355

}

356

357

return dev;

357

return dev;

358

}

358

}

359

360

/*

360

/*

361

* Open/initialize the board. This is called sometime after booting when

361

* Open/initialize the board. This is called sometime after booting when

362

* the 'ifconfig' program is run.

362

* the 'ifconfig' program is run.

363

*

363

*

364

* This routine should set everything up anew at each open, even registers

364

* This routine should set everything up anew at each open, even registers

365

* that "should" only need to be set once at boot, so that there is

365

* that "should" only need to be set once at boot, so that there is

366

* non-reboot way to recover if something goes wrong.

366

* non-reboot way to recover if something goes wrong.

367

*/

367

*/

368

static int arcnet_open(struct net_device *dev)

368

static int arcnet_open(struct net_device *dev)

369

{

369

{

370

struct arcnet_local *lp = dev->priv;

370

struct arcnet_local *lp = dev->priv;

371

int count, newmtu, error;

371

int count, newmtu, error;

372

373

BUGMSG(D_INIT,"opened.");

373

BUGMSG(D_INIT,"opened.");

374

375

if (!try_module_get(lp->hw.owner))

375

if (!try_module_get(lp->hw.owner))

376

return -ENODEV;

376

return -ENODEV;

377

378

BUGLVL(D_PROTO) {

378

BUGLVL(D_PROTO) {

379

int count;

379

int count;

380

BUGMSG(D_PROTO, "protocol map (default is '%c'): ",

380

BUGMSG(D_PROTO, "protocol map (default is '%c'): ",

381

arc_proto_default->suffix);

381

arc_proto_default->suffix);

382

for (count = 0; count < 256; count++)

382

for (count = 0; count < 256; count++)

383

BUGMSG2(D_PROTO, "%c", arc_proto_map[count]->suffix);

383

BUGMSG2(D_PROTO, "%c", arc_proto_map[count]->suffix);

384

BUGMSG2(D_PROTO, "\n");

384

BUGMSG2(D_PROTO, "\n");

385

}

385

}

386

387

388

BUGMSG(D_INIT, "arcnet_open: resetting card.\n");

388

BUGMSG(D_INIT, "arcnet_open: resetting card.\n");

389

390

/* try to put the card in a defined state - if it fails the first

390

/* try to put the card in a defined state - if it fails the first

391

* time, actually reset it.

391

* time, actually reset it.

392

*/

392

*/

393

error = -ENODEV;

393

error = -ENODEV;

394

if (ARCRESET(0) && ARCRESET(1))

394

if (ARCRESET(0) && ARCRESET(1))

395

goto out_module_put;

395

goto out_module_put;

396

397

newmtu = choose_mtu();

397

newmtu = choose_mtu();

398

if (newmtu < dev->mtu)

398

if (newmtu < dev->mtu)

399

dev->mtu = newmtu;

399

dev->mtu = newmtu;

400

401

BUGMSG(D_INIT, "arcnet_open: mtu: %d.\n", dev->mtu);

401

BUGMSG(D_INIT, "arcnet_open: mtu: %d.\n", dev->mtu);

402

403

/* autodetect the encapsulation for each host. */

403

/* autodetect the encapsulation for each host. */

404

memset(lp->default_proto, 0, sizeof(lp->default_proto));

404

memset(lp->default_proto, 0, sizeof(lp->default_proto));

405

406

/* the broadcast address is special - use the 'bcast' protocol */

406

/* the broadcast address is special - use the 'bcast' protocol */

407

for (count = 0; count < 256; count++) {

407

for (count = 0; count < 256; count++) {

408

if (arc_proto_map[count] == arc_bcast_proto) {

408

if (arc_proto_map[count] == arc_bcast_proto) {

409

lp->default_proto[0] = count;

409

lp->default_proto[0] = count;

410

break;

410

break;

411

}

411

}

412

}

412

}

413

414

/* initialize buffers */

414

/* initialize buffers */

415

atomic_set(&lp->buf_lock, 1);

415

atomic_set(&lp->buf_lock, 1);

416

417

lp->next_buf = lp->first_free_buf = 0;

417

lp->next_buf = lp->first_free_buf = 0;

418

release_arcbuf(dev, 0);

418

release_arcbuf(dev, 0);

419

release_arcbuf(dev, 1);

419

release_arcbuf(dev, 1);

420

release_arcbuf(dev, 2);

420

release_arcbuf(dev, 2);

421

release_arcbuf(dev, 3);

421

release_arcbuf(dev, 3);

422

lp->cur_tx = lp->next_tx = -1;

422

lp->cur_tx = lp->next_tx = -1;

423

lp->cur_rx = -1;

423

lp->cur_rx = -1;

424

425

lp->rfc1201.sequence = 1;

425

lp->rfc1201.sequence = 1;

426

427

/* bring up the hardware driver */

427

/* bring up the hardware driver */

428

if (lp->hw.open)

428

if (lp->hw.open)

429

lp->hw.open(dev);

429

lp->hw.open(dev);

430

431

if (dev->dev_addr[0] == 0)

431

if (dev->dev_addr[0] == 0)

432

BUGMSG(D_NORMAL, "WARNING! Station address 00 is reserved "

432

BUGMSG(D_NORMAL, "WARNING! Station address 00 is reserved "

433

"for broadcasts!\n");

433

"for broadcasts!\n");

434

else if (dev->dev_addr[0] == 255)

434

else if (dev->dev_addr[0] == 255)

435

BUGMSG(D_NORMAL, "WARNING! Station address FF may confuse "

435

BUGMSG(D_NORMAL, "WARNING! Station address FF may confuse "

436

"DOS networking programs!\n");

436

"DOS networking programs!\n");

437

438

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

438

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

439

if (ASTATUS() & RESETflag) {

439

if (ASTATUS() & RESETflag) {

440

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

440

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

441

ACOMMAND(CFLAGScmd | RESETclear);

441

ACOMMAND(CFLAGScmd | RESETclear);

442

}

442

}

443

444

445

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

445

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

446

/* make sure we're ready to receive IRQ's. */

446

/* make sure we're ready to receive IRQ's. */

447

AINTMASK(0);

447

AINTMASK(0);

448

udelay(1); /* give it time to set the mask before

448

udelay(1); /* give it time to set the mask before

449

* we reset it again. (may not even be

449

* we reset it again. (may not even be

450

* necessary)

450

* necessary)

451

*/

451

*/

452

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

452

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

453

lp->intmask = NORXflag | RECONflag;

453

lp->intmask = NORXflag | RECONflag;

454

AINTMASK(lp->intmask);

454

AINTMASK(lp->intmask);

455

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

455

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

456

457

netif_start_queue(dev);

457

netif_start_queue(dev);

458

459

return 0;

459

return 0;

460

461

out_module_put:

461

out_module_put:

462

module_put(lp->hw.owner);

462

module_put(lp->hw.owner);

463

return error;

463

return error;

464

}

464

}

465

466

467

/* The inverse routine to arcnet_open - shuts down the card. */

467

/* The inverse routine to arcnet_open - shuts down the card. */

468

static int arcnet_close(struct net_device *dev)

468

static int arcnet_close(struct net_device *dev)

469

{

469

{

470

struct arcnet_local *lp = dev->priv;

470

struct arcnet_local *lp = dev->priv;

471

472

netif_stop_queue(dev);

472

netif_stop_queue(dev);

473

474

/* flush TX and disable RX */

474

/* flush TX and disable RX */

475

AINTMASK(0);

475

AINTMASK(0);

476

ACOMMAND(NOTXcmd); /* stop transmit */

476

ACOMMAND(NOTXcmd); /* stop transmit */

477

ACOMMAND(NORXcmd); /* disable receive */

477

ACOMMAND(NORXcmd); /* disable receive */

478

mdelay(1);

478

mdelay(1);

479

480

/* shut down the card */

480

/* shut down the card */

481

lp->hw.close(dev);

481

lp->hw.close(dev);

482

module_put(lp->hw.owner);

482

module_put(lp->hw.owner);

483

return 0;

483

return 0;

484

}

484

}

485

486

487

static int arcnet_header(struct sk_buff *skb, struct net_device *dev,

487

static int arcnet_header(struct sk_buff *skb, struct net_device *dev,

488

unsigned short type, void *daddr, void *saddr,

488

unsigned short type, void *daddr, void *saddr,

489

unsigned len)

489

unsigned len)

490

{

490

{

491

struct arcnet_local *lp = dev->priv;

491

struct arcnet_local *lp = dev->priv;

492

uint8_t _daddr, proto_num;

492

uint8_t _daddr, proto_num;

493

struct ArcProto *proto;

493

struct ArcProto *proto;

494

495

BUGMSG(D_DURING,

495

BUGMSG(D_DURING,

496

"create header from %d to %d; protocol %d (%Xh); size %u.\n",

496

"create header from %d to %d; protocol %d (%Xh); size %u.\n",

497

saddr ? *(uint8_t *) saddr : -1,

497

saddr ? *(uint8_t *) saddr : -1,

498

daddr ? *(uint8_t *) daddr : -1,

498

daddr ? *(uint8_t *) daddr : -1,

499

type, type, len);

499

type, type, len);

500

501

if (skb->len!=0 && len != skb->len)

501

if (skb->len!=0 && len != skb->len)

502

BUGMSG(D_NORMAL, "arcnet_header: Yikes! skb->len(%d) != len(%d)!\n",

502

BUGMSG(D_NORMAL, "arcnet_header: Yikes! skb->len(%d) != len(%d)!\n",

503

skb->len, len);

503

skb->len, len);

504

505

506

/* Type is host order - ? */

506

/* Type is host order - ? */

507

if(type == ETH_P_ARCNET) {

507

if(type == ETH_P_ARCNET) {

508

proto = arc_raw_proto;

508

proto = arc_raw_proto;

509

BUGMSG(D_DEBUG, "arc_raw_proto used. proto='%c'\n",proto->suffix);

509

BUGMSG(D_DEBUG, "arc_raw_proto used. proto='%c'\n",proto->suffix);

510

_daddr = daddr ? *(uint8_t *) daddr : 0;

510

_daddr = daddr ? *(uint8_t *) daddr : 0;

511

}

511

}

512

else if (!daddr) {

512

else if (!daddr) {

513

/*

513

/*

514

* if the dest addr isn't provided, we can't choose an encapsulation!

514

* if the dest addr isn't provided, we can't choose an encapsulation!

515

* Store the packet type (eg. ETH_P_IP) for now, and we'll push on a

515

* Store the packet type (eg. ETH_P_IP) for now, and we'll push on a

516

* real header when we do rebuild_header.

516

* real header when we do rebuild_header.

517

*/

517

*/

518

*(uint16_t *) skb_push(skb, 2) = type;

518

*(uint16_t *) skb_push(skb, 2) = type;

519

if (skb->nh.raw - skb->mac.raw != 2)

519

if (skb->nh.raw - skb->mac.raw != 2)

520

BUGMSG(D_NORMAL, "arcnet_header: Yikes! diff (%d) is not 2!\n",

520

BUGMSG(D_NORMAL, "arcnet_header: Yikes! diff (%d) is not 2!\n",

521

(int)(skb->nh.raw - skb->mac.raw));

521

(int)(skb->nh.raw - skb->mac.raw));

522

return -2; /* return error -- can't transmit yet! */

522

return -2; /* return error -- can't transmit yet! */

523

}

523

}

524

else {

524

else {

525

/* otherwise, we can just add the header as usual. */

525

/* otherwise, we can just add the header as usual. */

526

_daddr = *(uint8_t *) daddr;

526

_daddr = *(uint8_t *) daddr;

527

proto_num = lp->default_proto[_daddr];

527

proto_num = lp->default_proto[_daddr];

528

proto = arc_proto_map[proto_num];

528

proto = arc_proto_map[proto_num];

529

BUGMSG(D_DURING, "building header for %02Xh using protocol '%c'\n",

529

BUGMSG(D_DURING, "building header for %02Xh using protocol '%c'\n",

530

proto_num, proto->suffix);

530

proto_num, proto->suffix);

531

if (proto == &arc_proto_null && arc_bcast_proto != proto) {

531

if (proto == &arc_proto_null && arc_bcast_proto != proto) {

532

BUGMSG(D_DURING, "actually, let's use '%c' instead.\n",

532

BUGMSG(D_DURING, "actually, let's use '%c' instead.\n",

533

arc_bcast_proto->suffix);

533

arc_bcast_proto->suffix);

534

proto = arc_bcast_proto;

534

proto = arc_bcast_proto;

535

}

535

}

536

}

536

}

537

return proto->build_header(skb, dev, type, _daddr);

537

return proto->build_header(skb, dev, type, _daddr);

538

}

538

}

539

540

541

/*

541

/*

542

* Rebuild the ARCnet hard header. This is called after an ARP (or in the

542

* Rebuild the ARCnet hard header. This is called after an ARP (or in the

543

* future other address resolution) has completed on this sk_buff. We now

543

* future other address resolution) has completed on this sk_buff. We now

544

* let ARP fill in the destination field.

544

* let ARP fill in the destination field.

545

*/

545

*/

546

static int arcnet_rebuild_header(struct sk_buff *skb)

546

static int arcnet_rebuild_header(struct sk_buff *skb)

547

{

547

{

548

struct net_device *dev = skb->dev;

548

struct net_device *dev = skb->dev;

549

struct arcnet_local *lp = dev->priv;

549

struct arcnet_local *lp = dev->priv;

550

int status = 0; /* default is failure */

550

int status = 0; /* default is failure */

551

unsigned short type;

551

unsigned short type;

552

uint8_t daddr=0;

552

uint8_t daddr=0;

553

struct ArcProto *proto;

553

struct ArcProto *proto;

554

555

if (skb->nh.raw - skb->mac.raw != 2) {

555

if (skb->nh.raw - skb->mac.raw != 2) {

556

BUGMSG(D_NORMAL,

556

BUGMSG(D_NORMAL,

557

"rebuild_header: shouldn't be here! (hdrsize=%d)\n",

557

"rebuild_header: shouldn't be here! (hdrsize=%d)\n",

558

(int)(skb->nh.raw - skb->mac.raw));

558

(int)(skb->nh.raw - skb->mac.raw));

559

return 0;

559

return 0;

560

}

560

}

561

type = *(uint16_t *) skb_pull(skb, 2);

561

type = *(uint16_t *) skb_pull(skb, 2);

562

BUGMSG(D_DURING, "rebuild header for protocol %Xh\n", type);

562

BUGMSG(D_DURING, "rebuild header for protocol %Xh\n", type);

563

564

if (type == ETH_P_IP) {

564

if (type == ETH_P_IP) {

565

#ifdef CONFIG_INET

565

#ifdef CONFIG_INET

566

BUGMSG(D_DURING, "rebuild header for ethernet protocol %Xh\n", type);

566

BUGMSG(D_DURING, "rebuild header for ethernet protocol %Xh\n", type);

567

status = arp_find(&daddr, skb) ? 1 : 0;

567

status = arp_find(&daddr, skb) ? 1 : 0;

568

BUGMSG(D_DURING, " rebuilt: dest is %d; protocol %Xh\n",

568

BUGMSG(D_DURING, " rebuilt: dest is %d; protocol %Xh\n",

569

daddr, type);

569

daddr, type);

570

#endif

570

#endif

571

} else {

571

} else {

572

BUGMSG(D_NORMAL,

572

BUGMSG(D_NORMAL,

573

"I don't understand ethernet protocol %Xh addresses!\n", type);

573

"I don't understand ethernet protocol %Xh addresses!\n", type);

574

lp->stats.tx_errors++;

574

lp->stats.tx_errors++;

575

lp->stats.tx_aborted_errors++;

575

lp->stats.tx_aborted_errors++;

576

}

576

}

577

578

/* if we couldn't resolve the address... give up. */

578

/* if we couldn't resolve the address... give up. */

579

if (!status)

579

if (!status)

580

return 0;

580

return 0;

581

582

/* add the _real_ header this time! */

582

/* add the _real_ header this time! */

583

proto = arc_proto_map[lp->default_proto[daddr]];

583

proto = arc_proto_map[lp->default_proto[daddr]];

584

proto->build_header(skb, dev, type, daddr);

584

proto->build_header(skb, dev, type, daddr);

585

586

return 1; /* success */

586

return 1; /* success */

587

}

587

}

588

589

590

591

/* Called by the kernel in order to transmit a packet. */

591

/* Called by the kernel in order to transmit a packet. */

592

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

592

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

593

{

593

{

594

struct arcnet_local *lp = dev->priv;

594

struct arcnet_local *lp = dev->priv;

595

struct archdr *pkt;

595

struct archdr *pkt;

596

struct arc_rfc1201 *soft;

596

struct arc_rfc1201 *soft;

597

struct ArcProto *proto;

597

struct ArcProto *proto;

598

int txbuf;

598

int txbuf;

599

unsigned long flags;

599

unsigned long flags;

600

int freeskb = 0;

600

int freeskb, retval;

601

602

BUGMSG(D_DURING,

602

BUGMSG(D_DURING,

603

"transmit requested (status=%Xh, txbufs=%d/%d, len=%d, protocol %x)\n",

603

"transmit requested (status=%Xh, txbufs=%d/%d, len=%d, protocol %x)\n",

604

ASTATUS(), lp->cur_tx, lp->next_tx, skb->len,skb->protocol);

604

ASTATUS(), lp->cur_tx, lp->next_tx, skb->len,skb->protocol);

605

606

pkt = (struct archdr *) skb->data;

606

pkt = (struct archdr *) skb->data;

607

soft = &pkt->soft.rfc1201;

607

soft = &pkt->soft.rfc1201;

608

proto = arc_proto_map[soft->proto];

608

proto = arc_proto_map[soft->proto];

609

610

BUGMSG(D_SKB_SIZE, "skb: transmitting %d bytes to %02X\n",

610

BUGMSG(D_SKB_SIZE, "skb: transmitting %d bytes to %02X\n",

611

skb->len, pkt->hard.dest);

611

skb->len, pkt->hard.dest);

612

BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "tx");

612

BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "tx");

613

614

/* fits in one packet? */

614

/* fits in one packet? */

615

if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) {

615

if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) {

616

BUGMSG(D_NORMAL, "fixme: packet too large: compensating badly!\n");

616

BUGMSG(D_NORMAL, "fixme: packet too large: compensating badly!\n");

617

dev_kfree_skb(skb);

617

dev_kfree_skb(skb);

618

return 0; /* don't try again */

618

return NETDEV_TX_OK; /* don't try again */

619

}

619

}

620

621

/* We're busy transmitting a packet... */

621

/* We're busy transmitting a packet... */

622

netif_stop_queue(dev);

622

netif_stop_queue(dev);

623

624

spin_lock_irqsave(&lp->lock, flags);

624

spin_lock_irqsave(&lp->lock, flags);

625

AINTMASK(0);

625

AINTMASK(0);

626

if(lp->next_tx == -1)

627

txbuf = get_arcbuf(dev);

627

txbuf = get_arcbuf(dev);

628

else {

629

txbuf = -1;

630

}

628

if (txbuf != -1) {

631

if (txbuf != -1) {

629

if (proto->prepare_tx(dev, pkt, skb->len, txbuf) &&

632

if (proto->prepare_tx(dev, pkt, skb->len, txbuf) &&

630

!proto->ack_tx) {

633

!proto->ack_tx) {

631

/* done right away and we don't want to acknowledge

634

/* done right away and we don't want to acknowledge

632

the package later - forget about it now */

635

the package later - forget about it now */

633

lp->stats.tx_bytes += skb->len;

636

lp->stats.tx_bytes += skb->len;

634

freeskb = 1;

637

freeskb = 1;

635

} else {

638

} else {

636

/* do it the 'split' way */

639

/* do it the 'split' way */

637

lp->outgoing.proto = proto;

640

lp->outgoing.proto = proto;

638

lp->outgoing.skb = skb;

641

lp->outgoing.skb = skb;

639

lp->outgoing.pkt = pkt;

642

lp->outgoing.pkt = pkt;

640

643

644

freeskb = 0;

645

641

if (proto->continue_tx &&

646

if (proto->continue_tx &&

642

proto->continue_tx(dev, txbuf)) {

647

proto->continue_tx(dev, txbuf)) {

643

BUGMSG(D_NORMAL,

648

BUGMSG(D_NORMAL,

644

"bug! continue_tx finished the first time! "

649

"bug! continue_tx finished the first time! "

645

"(proto='%c')\n", proto->suffix);

650

"(proto='%c')\n", proto->suffix);

646

}

651

}

647

}

652

}

648

653

retval = NETDEV_TX_OK;

654

dev->trans_start = jiffies;

649

lp->next_tx = txbuf;

655

lp->next_tx = txbuf;

650

} else {

656

} else {

651

freeskb = 1;

657

retval = NETDEV_TX_BUSY;

658

freeskb = 0;

652

}

659

}

653

660

654

BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__FUNCTION__,ASTATUS());

661

BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__FUNCTION__,ASTATUS());

655

/* make sure we didn't ignore a TX IRQ while we were in here */

662

/* make sure we didn't ignore a TX IRQ while we were in here */

656

AINTMASK(0);

663

AINTMASK(0);

657

664

658

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

665

BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__FUNCTION__);

659

lp->intmask |= TXFREEflag|EXCNAKflag;

666

lp->intmask |= TXFREEflag|EXCNAKflag;

660

AINTMASK(lp->intmask);

667

AINTMASK(lp->intmask);

661

BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__FUNCTION__,ASTATUS());

668

BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__FUNCTION__,ASTATUS());

662

669

663

spin_unlock_irqrestore(&lp->lock, flags);

670

spin_unlock_irqrestore(&lp->lock, flags);

664

if (freeskb) {

671

if (freeskb) {

665

dev_kfree_skb(skb);

672

dev_kfree_skb(skb);

666

}

673

}

667

return 0; /* no need to try again */

674

return retval; /* no need to try again */

668

}

675

}

669

676

670

677

671

/*

678

/*

672

* Actually start transmitting a packet that was loaded into a buffer

679

* Actually start transmitting a packet that was loaded into a buffer

673

* by prepare_tx. This should _only_ be called by the interrupt handler.

680

* by prepare_tx. This should _only_ be called by the interrupt handler.

674

*/

681

*/

675

static int go_tx(struct net_device *dev)

682

static int go_tx(struct net_device *dev)

676

{

683

{

677

struct arcnet_local *lp = dev->priv;

684

struct arcnet_local *lp = dev->priv;

678

685

679

BUGMSG(D_DURING, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%d\n",

686

BUGMSG(D_DURING, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%d\n",

680

ASTATUS(), lp->intmask, lp->next_tx, lp->cur_tx);

687

ASTATUS(), lp->intmask, lp->next_tx, lp->cur_tx);

681

688

682

if (lp->cur_tx != -1 || lp->next_tx == -1)

689

if (lp->cur_tx != -1 || lp->next_tx == -1)

683

return 0;

690

return 0;

684

691

685

BUGLVL(D_TX) arcnet_dump_packet(dev, lp->next_tx, "go_tx", 0);

692

BUGLVL(D_TX) arcnet_dump_packet(dev, lp->next_tx, "go_tx", 0);

686

693

687

lp->cur_tx = lp->next_tx;

694

lp->cur_tx = lp->next_tx;

688

lp->next_tx = -1;

695

lp->next_tx = -1;

689

696

690

/* start sending */

697

/* start sending */

691

ACOMMAND(TXcmd | (lp->cur_tx << 3));

698

ACOMMAND(TXcmd | (lp->cur_tx << 3));

692

699

693

dev->trans_start = jiffies;

694

lp->stats.tx_packets++;

700

lp->stats.tx_packets++;

695

lp->lasttrans_dest = lp->lastload_dest;

701

lp->lasttrans_dest = lp->lastload_dest;

696

lp->lastload_dest = 0;

702

lp->lastload_dest = 0;

697

lp->excnak_pending = 0;

703

lp->excnak_pending = 0;

698

lp->intmask |= TXFREEflag|EXCNAKflag;

704

lp->intmask |= TXFREEflag|EXCNAKflag;

699

705

700

return 1;

706

return 1;

701

}

707

}

702

708

703

709

704

/* Called by the kernel when transmit times out */

710

/* Called by the kernel when transmit times out */

705

static void arcnet_timeout(struct net_device *dev)

711

static void arcnet_timeout(struct net_device *dev)

706

{

712

{

707

unsigned long flags;

713

unsigned long flags;

708

struct arcnet_local *lp = dev->priv;

714

struct arcnet_local *lp = dev->priv;

709

int status = ASTATUS();

715

int status = ASTATUS();

710

char *msg;

716

char *msg;

711

717

712

spin_lock_irqsave(&lp->lock, flags);

718

spin_lock_irqsave(&lp->lock, flags);

713

if (status & TXFREEflag) { /* transmit _DID_ finish */

719

if (status & TXFREEflag) { /* transmit _DID_ finish */

714

msg = " - missed IRQ?";

720

msg = " - missed IRQ?";

715

} else {

721

} else {

716

msg = "";

722

msg = "";

717

lp->stats.tx_aborted_errors++;

723

lp->stats.tx_aborted_errors++;

718

lp->timed_out = 1;

724

lp->timed_out = 1;

719

ACOMMAND(NOTXcmd | (lp->cur_tx << 3));

725

ACOMMAND(NOTXcmd | (lp->cur_tx << 3));

720

}

726

}

721

lp->stats.tx_errors++;

727

lp->stats.tx_errors++;

722

728

723

/* make sure we didn't miss a TX or a EXC NAK IRQ */

729

/* make sure we didn't miss a TX or a EXC NAK IRQ */

724

AINTMASK(0);

730

AINTMASK(0);

725

lp->intmask |= TXFREEflag|EXCNAKflag;

731

lp->intmask |= TXFREEflag|EXCNAKflag;

726

AINTMASK(lp->intmask);

732

AINTMASK(lp->intmask);

727

733

728

spin_unlock_irqrestore(&lp->lock, flags);

734

spin_unlock_irqrestore(&lp->lock, flags);

729

735

730

if (jiffies - lp->last_timeout > 10*HZ) {

736

if (jiffies - lp->last_timeout > 10*HZ) {

731

BUGMSG(D_EXTRA, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)\n",

737

BUGMSG(D_EXTRA, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)\n",

732

msg, status, lp->intmask, lp->lasttrans_dest);

738

msg, status, lp->intmask, lp->lasttrans_dest);

733

lp->last_timeout = jiffies;

739

lp->last_timeout = jiffies;

734

}

740

}

735

741

736

if (lp->cur_tx == -1)

742

if (lp->cur_tx == -1)

737

netif_wake_queue(dev);

743

netif_wake_queue(dev);

738

}

744

}

739

745

740

746

741

/*

747

/*

742

* The typical workload of the driver: Handle the network interface

748

* The typical workload of the driver: Handle the network interface

743

* interrupts. Establish which device needs attention, and call the correct

749

* interrupts. Establish which device needs attention, and call the correct

744

* chipset interrupt handler.

750

* chipset interrupt handler.

745

*/

751

*/

746

irqreturn_t arcnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)

752

irqreturn_t arcnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)

747

{

753

{

748

struct net_device *dev = dev_id;

754

struct net_device *dev = dev_id;

749

struct arcnet_local *lp;

755

struct arcnet_local *lp;

750

int recbuf, status, diagstatus, didsomething, boguscount;

756

int recbuf, status, diagstatus, didsomething, boguscount;

751

int retval = IRQ_NONE;

757

int retval = IRQ_NONE;

752

758

753

BUGMSG(D_DURING, "\n");

759

BUGMSG(D_DURING, "\n");

754

760

755

BUGMSG(D_DURING, "in arcnet_interrupt\n");

761

BUGMSG(D_DURING, "in arcnet_interrupt\n");

756

762

757

lp = dev->priv;

763

lp = dev->priv;

758

if (!lp)

764

if (!lp)

759

BUG();

765

BUG();

760

766

761

spin_lock(&lp->lock);

767

spin_lock(&lp->lock);

762

768

763

/*

769

/*

764

* RESET flag was enabled - if device is not running, we must clear it right

770

* RESET flag was enabled - if device is not running, we must clear it right

765

* away (but nothing else).

771

* away (but nothing else).

766

*/

772

*/

767

if (!netif_running(dev)) {

773

if (!netif_running(dev)) {

768

if (ASTATUS() & RESETflag)

774

if (ASTATUS() & RESETflag)

769

ACOMMAND(CFLAGScmd | RESETclear);

775

ACOMMAND(CFLAGScmd | RESETclear);

770

AINTMASK(0);

776

AINTMASK(0);

771

spin_unlock(&lp->lock);

777

spin_unlock(&lp->lock);

772

return IRQ_HANDLED;

778

return IRQ_HANDLED;

773

}

779

}

774

780

775

BUGMSG(D_DURING, "in arcnet_inthandler (status=%Xh, intmask=%Xh)\n",

781

BUGMSG(D_DURING, "in arcnet_inthandler (status=%Xh, intmask=%Xh)\n",

776

ASTATUS(), lp->intmask);

782

ASTATUS(), lp->intmask);

777

783

778

boguscount = 5;

784

boguscount = 5;

779

do {

785

do {

780

status = ASTATUS();

786

status = ASTATUS();

781

diagstatus = (status >> 8) & 0xFF;

787

diagstatus = (status >> 8) & 0xFF;

782

788

783

BUGMSG(D_DEBUG, "%s: %d: %s: status=%x\n",

789

BUGMSG(D_DEBUG, "%s: %d: %s: status=%x\n",

784

__FILE__,__LINE__,__FUNCTION__,status);

790

__FILE__,__LINE__,__FUNCTION__,status);

785

didsomething = 0;

791

didsomething = 0;

786

792

787

/*

793

/*

788

* RESET flag was enabled - card is resetting and if RX is

794

* RESET flag was enabled - card is resetting and if RX is

789

* disabled, it's NOT because we just got a packet.

795

* disabled, it's NOT because we just got a packet.

790

*

796

*

791

* The card is in an undefined state. Clear it out and start over.

797

* The card is in an undefined state. Clear it out and start over.

792

*/

798

*/

793

if (status & RESETflag) {

799

if (status & RESETflag) {

794

BUGMSG(D_NORMAL, "spurious reset (status=%Xh)\n", status);

800

BUGMSG(D_NORMAL, "spurious reset (status=%Xh)\n", status);

795

arcnet_close(dev);

801

arcnet_close(dev);

796

arcnet_open(dev);

802

arcnet_open(dev);

797

803

798

/* get out of the interrupt handler! */

804

/* get out of the interrupt handler! */

799

break;

805

break;

800

}

806

}

801

/*

807

/*

802

* RX is inhibited - we must have received something. Prepare to

808

* RX is inhibited - we must have received something. Prepare to

803

* receive into the next buffer.

809

* receive into the next buffer.

804

*

810

*

805

* We don't actually copy the received packet from the card until

811

* We don't actually copy the received packet from the card until

806

* after the transmit handler runs (and possibly launches the next

812

* after the transmit handler runs (and possibly launches the next

807

* tx); this should improve latency slightly if we get both types

813

* tx); this should improve latency slightly if we get both types

808

* of interrupts at once.

814

* of interrupts at once.

809

*/

815

*/

810

recbuf = -1;

816

recbuf = -1;

811

if (status & lp->intmask & NORXflag) {

817

if (status & lp->intmask & NORXflag) {

812

recbuf = lp->cur_rx;

818

recbuf = lp->cur_rx;

813

BUGMSG(D_DURING, "Buffer #%d: receive irq (status=%Xh)\n",

819

BUGMSG(D_DURING, "Buffer #%d: receive irq (status=%Xh)\n",

814

recbuf, status);

820

recbuf, status);

815

821

816

lp->cur_rx = get_arcbuf(dev);

822

lp->cur_rx = get_arcbuf(dev);

817

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

823

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

818

BUGMSG(D_DURING, "enabling receive to buffer #%d\n",

824

BUGMSG(D_DURING, "enabling receive to buffer #%d\n",

819

lp->cur_rx);

825

lp->cur_rx);

820

ACOMMAND(RXcmd | (lp->cur_rx << 3) | RXbcasts);

826

ACOMMAND(RXcmd | (lp->cur_rx << 3) | RXbcasts);

821

}

827

}

822

didsomething++;

828

didsomething++;

823

}

829

}

824

830

825

if((diagstatus & EXCNAKflag)) {

831

if((diagstatus & EXCNAKflag)) {

826

BUGMSG(D_DURING, "EXCNAK IRQ (diagstat=%Xh)\n",

832

BUGMSG(D_DURING, "EXCNAK IRQ (diagstat=%Xh)\n",

827

diagstatus);

833

diagstatus);

828

834

829

ACOMMAND(NOTXcmd); /* disable transmit */

835

ACOMMAND(NOTXcmd); /* disable transmit */

830

lp->excnak_pending = 1;

836

lp->excnak_pending = 1;

831

837

832

ACOMMAND(EXCNAKclear);

838

ACOMMAND(EXCNAKclear);

833

lp->intmask &= ~(EXCNAKflag);

839

lp->intmask &= ~(EXCNAKflag);

834

didsomething++;

840

didsomething++;

835

}

841

}

836

842

837

843

838

/* a transmit finished, and we're interested in it. */

844

/* a transmit finished, and we're interested in it. */

839

if ((status & lp->intmask & TXFREEflag) || lp->timed_out) {

845

if ((status & lp->intmask & TXFREEflag) || lp->timed_out) {

840

lp->intmask &= ~(TXFREEflag|EXCNAKflag);

846

lp->intmask &= ~(TXFREEflag|EXCNAKflag);

841

847

842

BUGMSG(D_DURING, "TX IRQ (stat=%Xh)\n", status);

848

BUGMSG(D_DURING, "TX IRQ (stat=%Xh)\n", status);

843

849

844

if (lp->cur_tx != -1 && !lp->timed_out) {

850

if (lp->cur_tx != -1 && !lp->timed_out) {

845

if(!(status & TXACKflag)) {

851

if(!(status & TXACKflag)) {

846

if (lp->lasttrans_dest != 0) {

852

if (lp->lasttrans_dest != 0) {

847

BUGMSG(D_EXTRA,

853

BUGMSG(D_EXTRA,

848

"transmit was not acknowledged! "

854

"transmit was not acknowledged! "

849

"(status=%Xh, dest=%02Xh)\n",

855

"(status=%Xh, dest=%02Xh)\n",

850

status, lp->lasttrans_dest);

856

status, lp->lasttrans_dest);

851

lp->stats.tx_errors++;

857

lp->stats.tx_errors++;

852

lp->stats.tx_carrier_errors++;

858

lp->stats.tx_carrier_errors++;

853

} else {

859

} else {

854

BUGMSG(D_DURING,

860

BUGMSG(D_DURING,

855

"broadcast was not acknowledged; that's normal "

861

"broadcast was not acknowledged; that's normal "

856

"(status=%Xh, dest=%02Xh)\n",

862

"(status=%Xh, dest=%02Xh)\n",

857

status, lp->lasttrans_dest);

863

status, lp->lasttrans_dest);

858

}

864

}

859

}

865

}

860

866

861

if (lp->outgoing.proto &&

867

if (lp->outgoing.proto &&

862

lp->outgoing.proto->ack_tx) {

868

lp->outgoing.proto->ack_tx) {

863

int ackstatus;

869

int ackstatus;

864

if(status & TXACKflag)

870

if(status & TXACKflag)

865

ackstatus=2;

871

ackstatus=2;

866

else if(lp->excnak_pending)

872

else if(lp->excnak_pending)

867

ackstatus=1;

873

ackstatus=1;

868

else

874

else

869

ackstatus=0;

875

ackstatus=0;

870

876

871

lp->outgoing.proto

877

lp->outgoing.proto

872

->ack_tx(dev, ackstatus);

878

->ack_tx(dev, ackstatus);

873

}

879

}

874

}

880

}

875

if (lp->cur_tx != -1)

881

if (lp->cur_tx != -1)

876

release_arcbuf(dev, lp->cur_tx);

882

release_arcbuf(dev, lp->cur_tx);

877

883

878

lp->cur_tx = -1;

884

lp->cur_tx = -1;

879

lp->timed_out = 0;

885

lp->timed_out = 0;

880

didsomething++;

886

didsomething++;

881

887

882

/* send another packet if there is one */

888

/* send another packet if there is one */

883

go_tx(dev);

889

go_tx(dev);

884

890

885

/* continue a split packet, if any */

891

/* continue a split packet, if any */

886

if (lp->outgoing.proto && lp->outgoing.proto->continue_tx) {

892

if (lp->outgoing.proto && lp->outgoing.proto->continue_tx) {

887

int txbuf = get_arcbuf(dev);

893

int txbuf = get_arcbuf(dev);

888

if (txbuf != -1) {

894

if (txbuf != -1) {

889

if (lp->outgoing.proto->continue_tx(dev, txbuf)) {

895

if (lp->outgoing.proto->continue_tx(dev, txbuf)) {

890

/* that was the last segment */

896

/* that was the last segment */

891

lp->stats.tx_bytes += lp->outgoing.skb->len;

897

lp->stats.tx_bytes += lp->outgoing.skb->len;

892

if(!lp->outgoing.proto->ack_tx)

898

if(!lp->outgoing.proto->ack_tx)

893

{

899

{

894

dev_kfree_skb_irq(lp->outgoing.skb);

900

dev_kfree_skb_irq(lp->outgoing.skb);

895

lp->outgoing.proto = NULL;

901

lp->outgoing.proto = NULL;

896

}

902

}

897

}

903

}

898

lp->next_tx = txbuf;

904

lp->next_tx = txbuf;

899

}

905

}

900

}

906

}

901

/* inform upper layers of idleness, if necessary */

907

/* inform upper layers of idleness, if necessary */

902

if (lp->cur_tx == -1)

908

if (lp->cur_tx == -1)

903

netif_wake_queue(dev);

909

netif_wake_queue(dev);

904

}

910

}

905

/* now process the received packet, if any */

911

/* now process the received packet, if any */

906

if (recbuf != -1) {

912

if (recbuf != -1) {

907

BUGLVL(D_RX) arcnet_dump_packet(dev, recbuf, "rx irq", 0);

913

BUGLVL(D_RX) arcnet_dump_packet(dev, recbuf, "rx irq", 0);

908

914

909

arcnet_rx(dev, recbuf);

915

arcnet_rx(dev, recbuf);

910

release_arcbuf(dev, recbuf);

916

release_arcbuf(dev, recbuf);

911

917

912

didsomething++;

918

didsomething++;

913

}

919

}

914

if (status & lp->intmask & RECONflag) {

920

if (status & lp->intmask & RECONflag) {

915

ACOMMAND(CFLAGScmd | CONFIGclear);

921

ACOMMAND(CFLAGScmd | CONFIGclear);

916

lp->stats.tx_carrier_errors++;

922

lp->stats.tx_carrier_errors++;

917

923

918

BUGMSG(D_RECON, "Network reconfiguration detected (status=%Xh)\n",

924

BUGMSG(D_RECON, "Network reconfiguration detected (status=%Xh)\n",

919

status);

925

status);

926

/* MYRECON bit is at bit 7 of diagstatus */

927

if(diagstatus & 0x80)

928

BUGMSG(D_RECON,"Put out that recon myself\n");

920

929

921

/* is the RECON info empty or old? */

930

/* is the RECON info empty or old? */

922

if (!lp->first_recon || !lp->last_recon ||

931

if (!lp->first_recon || !lp->last_recon ||

923

jiffies - lp->last_recon > HZ * 10) {

932

jiffies - lp->last_recon > HZ * 10) {

924

if (lp->network_down)

933

if (lp->network_down)

925

BUGMSG(D_NORMAL, "reconfiguration detected: cabling restored?\n");

934

BUGMSG(D_NORMAL, "reconfiguration detected: cabling restored?\n");

926

lp->first_recon = lp->last_recon = jiffies;

935

lp->first_recon = lp->last_recon = jiffies;

927

lp->num_recons = lp->network_down = 0;

936

lp->num_recons = lp->network_down = 0;

928

937

929

BUGMSG(D_DURING, "recon: clearing counters.\n");

938

BUGMSG(D_DURING, "recon: clearing counters.\n");

930

} else { /* add to current RECON counter */

939

} else { /* add to current RECON counter */

931

lp->last_recon = jiffies;

940

lp->last_recon = jiffies;

932

lp->num_recons++;

941

lp->num_recons++;

933

942

934

BUGMSG(D_DURING, "recon: counter=%d, time=%lds, net=%d\n",

943

BUGMSG(D_DURING, "recon: counter=%d, time=%lds, net=%d\n",

935

lp->num_recons,

944

lp->num_recons,

936

(lp->last_recon - lp->first_recon) / HZ,

945

(lp->last_recon - lp->first_recon) / HZ,

937

lp->network_down);

946

lp->network_down);

938

947

939

/* if network is marked up;

948

/* if network is marked up;

940

* and first_recon and last_recon are 60+ apart;

949

* and first_recon and last_recon are 60+ apart;

941

* and the average no. of recons counted is

950

* and the average no. of recons counted is

942

* > RECON_THRESHOLD/min;

951

* > RECON_THRESHOLD/min;

943

* then print a warning message.

952

* then print a warning message.

944

*/

953

*/

945

if (!lp->network_down

954

if (!lp->network_down

946

&& (lp->last_recon - lp->first_recon) <= HZ * 60

955

&& (lp->last_recon - lp->first_recon) <= HZ * 60

947

&& lp->num_recons >= RECON_THRESHOLD) {

956

&& lp->num_recons >= RECON_THRESHOLD) {

948

lp->network_down = 1;

957

lp->network_down = 1;

949

BUGMSG(D_NORMAL, "many reconfigurations detected: cabling problem?\n");

958

BUGMSG(D_NORMAL, "many reconfigurations detected: cabling problem?\n");

950

} else if (!lp->network_down

959

} else if (!lp->network_down

951

&& lp->last_recon - lp->first_recon > HZ * 60) {

960

&& lp->last_recon - lp->first_recon > HZ * 60) {

952

/* reset counters if we've gone for over a minute. */

961

/* reset counters if we've gone for over a minute. */

953

lp->first_recon = lp->last_recon;

962

lp->first_recon = lp->last_recon;

954

lp->num_recons = 1;

963

lp->num_recons = 1;

955

}

964

}

956

}

965

}

957

} else if (lp->network_down && jiffies - lp->last_recon > HZ * 10) {

966

} else if (lp->network_down && jiffies - lp->last_recon > HZ * 10) {

958

if (lp->network_down)

967

if (lp->network_down)

959

BUGMSG(D_NORMAL, "cabling restored?\n");

968

BUGMSG(D_NORMAL, "cabling restored?\n");

960

lp->first_recon = lp->last_recon = 0;

969

lp->first_recon = lp->last_recon = 0;

961

lp->num_recons = lp->network_down = 0;

970

lp->num_recons = lp->network_down = 0;

962

971

963

BUGMSG(D_DURING, "not recon: clearing counters anyway.\n");

972

BUGMSG(D_DURING, "not recon: clearing counters anyway.\n");

964

}

973

}

965

974

966

if(didsomething) {

975

if(didsomething) {

967

retval |= IRQ_HANDLED;

976

retval |= IRQ_HANDLED;

968

}

977

}

969

}

978

}

970

while (--boguscount && didsomething);

979

while (--boguscount && didsomething);

971

980

972

BUGMSG(D_DURING, "arcnet_interrupt complete (status=%Xh, count=%d)\n",

981

BUGMSG(D_DURING, "arcnet_interrupt complete (status=%Xh, count=%d)\n",

973

ASTATUS(), boguscount);

982

ASTATUS(), boguscount);

974

BUGMSG(D_DURING, "\n");

983

BUGMSG(D_DURING, "\n");

975

984

976

985

977

AINTMASK(0);

986

AINTMASK(0);

978

udelay(1);

987

udelay(1);

979

AINTMASK(lp->intmask);

988

AINTMASK(lp->intmask);

980

989

981

spin_unlock(&lp->lock);

990

spin_unlock(&lp->lock);

982

return retval;

991

return retval;

983

}

992

}

984

993

985

994

986

/*

995

/*

987

* This is a generic packet receiver that calls arcnet??_rx depending on the

996

* This is a generic packet receiver that calls arcnet??_rx depending on the

988

* protocol ID found.

997

* protocol ID found.

989

*/

998

*/

990

void arcnet_rx(struct net_device *dev, int bufnum)

999

void arcnet_rx(struct net_device *dev, int bufnum)

991

{

1000

{

992

struct arcnet_local *lp = dev->priv;

1001

struct arcnet_local *lp = dev->priv;

993

struct archdr pkt;

1002

struct archdr pkt;

994

struct arc_rfc1201 *soft;

1003

struct arc_rfc1201 *soft;

995

int length, ofs;

1004

int length, ofs;

996

1005

997

soft = &pkt.soft.rfc1201;

1006

soft = &pkt.soft.rfc1201;

998

1007

999

lp->hw.copy_from_card(dev, bufnum, 0, &pkt, sizeof(ARC_HDR_SIZE));

1008

lp->hw.copy_from_card(dev, bufnum, 0, &pkt, sizeof(ARC_HDR_SIZE));

1000

if (pkt.hard.offset[0]) {

1009

if (pkt.hard.offset[0]) {

1001

ofs = pkt.hard.offset[0];

1010

ofs = pkt.hard.offset[0];

1002

length = 256 - ofs;

1011

length = 256 - ofs;

1003

} else {

1012

} else {

1004

ofs = pkt.hard.offset[1];

1013

ofs = pkt.hard.offset[1];

1005

length = 512 - ofs;

1014

length = 512 - ofs;

1006

}

1015

}

1007

1016

1008

/* get the full header, if possible */

1017

/* get the full header, if possible */

1009

if (sizeof(pkt.soft) <= length)

1018

if (sizeof(pkt.soft) <= length)

1010

lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft));

1019

lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft));

1011

else {

1020

else {

1012

memset(&pkt.soft, 0, sizeof(pkt.soft));

1021

memset(&pkt.soft, 0, sizeof(pkt.soft));

1013

lp->hw.copy_from_card(dev, bufnum, ofs, soft, length);

1022

lp->hw.copy_from_card(dev, bufnum, ofs, soft, length);

1014

}

1023

}

1015

1024

1016

BUGMSG(D_DURING, "Buffer #%d: received packet from %02Xh to %02Xh "

1025

BUGMSG(D_DURING, "Buffer #%d: received packet from %02Xh to %02Xh "

1017

"(%d+4 bytes)\n",

1026

"(%d+4 bytes)\n",

1018

bufnum, pkt.hard.source, pkt.hard.dest, length);

1027

bufnum, pkt.hard.source, pkt.hard.dest, length);

1019

1028

1020

lp->stats.rx_packets++;

1029

lp->stats.rx_packets++;

1021

lp->stats.rx_bytes += length + ARC_HDR_SIZE;

1030

lp->stats.rx_bytes += length + ARC_HDR_SIZE;

1022

1031

1023

/* call the right receiver for the protocol */

1032

/* call the right receiver for the protocol */

1024

if (arc_proto_map[soft->proto]->is_ip) {

1033

if (arc_proto_map[soft->proto]->is_ip) {

1025

BUGLVL(D_PROTO) {

1034

BUGLVL(D_PROTO) {

1026

struct ArcProto

1035

struct ArcProto

1027

*oldp = arc_proto_map[lp->default_proto[pkt.hard.source]],

1036

*oldp = arc_proto_map[lp->default_proto[pkt.hard.source]],

1028

*newp = arc_proto_map[soft->proto];

1037

*newp = arc_proto_map[soft->proto];

1029

1038

1030

if (oldp != newp) {

1039

if (oldp != newp) {

1031

BUGMSG(D_PROTO,

1040

BUGMSG(D_PROTO,

1032

"got protocol %02Xh; encap for host %02Xh is now '%c'"

1041

"got protocol %02Xh; encap for host %02Xh is now '%c'"

1033

" (was '%c')\n", soft->proto, pkt.hard.source,

1042

" (was '%c')\n", soft->proto, pkt.hard.source,

1034

newp->suffix, oldp->suffix);

1043

newp->suffix, oldp->suffix);

1035

}

1044

}

1036

}

1045

}

1037

1046

1038

/* broadcasts will always be done with the last-used encap. */

1047

/* broadcasts will always be done with the last-used encap. */

1039

lp->default_proto[0] = soft->proto;

1048

lp->default_proto[0] = soft->proto;

1040

1049

1041

/* in striking contrast, the following isn't a hack. */

1050

/* in striking contrast, the following isn't a hack. */

1042

lp->default_proto[pkt.hard.source] = soft->proto;

1051

lp->default_proto[pkt.hard.source] = soft->proto;

1043

}

1052

}

1044

/* call the protocol-specific receiver. */

1053

/* call the protocol-specific receiver. */

1045

arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length);

1054

arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length);

1046

}

1055

}

1047

1056

1048

1057

1049

1058

1050

/*

1059

/*

1051

* Get the current statistics. This may be called with the card open or

1060

* Get the current statistics. This may be called with the card open or

1052

* closed.

1061

* closed.

1053

*/

1062

*/

1054

static struct net_device_stats *arcnet_get_stats(struct net_device *dev)

1063

static struct net_device_stats *arcnet_get_stats(struct net_device *dev)

1055

{

1064

{

1056

struct arcnet_local *lp = dev->priv;

1065

struct arcnet_local *lp = dev->priv;

1057

return &lp->stats;

1066

return &lp->stats;

1058

}

1067

}

1059

1068

1060

1069

1061

static void null_rx(struct net_device *dev, int bufnum,

1070

static void null_rx(struct net_device *dev, int bufnum,

1062

struct archdr *pkthdr, int length)

1071

struct archdr *pkthdr, int length)

1063

{

1072

{

1064

BUGMSG(D_PROTO,

1073

BUGMSG(D_PROTO,

1065

"rx: don't know how to deal with proto %02Xh from host %02Xh.\n",

1074

"rx: don't know how to deal with proto %02Xh from host %02Xh.\n",

1066

pkthdr->soft.rfc1201.proto, pkthdr->hard.source);

1075

pkthdr->soft.rfc1201.proto, pkthdr->hard.source);

1067

}

1076

}

1068

1077

1069

1078

1070

static int null_build_header(struct sk_buff *skb, struct net_device *dev,

1079

static int null_build_header(struct sk_buff *skb, struct net_device *dev,

1071

unsigned short type, uint8_t daddr)

1080

unsigned short type, uint8_t daddr)

1072

{

1081

{

1073

struct arcnet_local *lp = dev->priv;

1082

struct arcnet_local *lp = dev->priv;

1074

1083

1075

BUGMSG(D_PROTO,

1084

BUGMSG(D_PROTO,

1076

"tx: can't build header for encap %02Xh; load a protocol driver.\n",

1085

"tx: can't build header for encap %02Xh; load a protocol driver.\n",

1077

lp->default_proto[daddr]);

1086

lp->default_proto[daddr]);

1078

1087

1079

/* always fails */

1088

/* always fails */

1080

return 0;

1089

return 0;

1081

}

1090

}

1082

1091

1083

1092

1084

/* the "do nothing" prepare_tx function warns that there's nothing to do. */

1093

/* the "do nothing" prepare_tx function warns that there's nothing to do. */

1085

static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,

1094

static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,

1086

int length, int bufnum)

1095

int length, int bufnum)

1087

{

1096

{

1088

struct arcnet_local *lp = dev->priv;

1097

struct arcnet_local *lp = dev->priv;

1089

struct arc_hardware newpkt;

1098

struct arc_hardware newpkt;

1090

1099

1091

BUGMSG(D_PROTO, "tx: no encap for this host; load a protocol driver.\n");

1100

BUGMSG(D_PROTO, "tx: no encap for this host; load a protocol driver.\n");

1092

1101

1093

/* send a packet to myself -- will never get received, of course */

1102

/* send a packet to myself -- will never get received, of course */

1094

newpkt.source = newpkt.dest = dev->dev_addr[0];

1103

newpkt.source = newpkt.dest = dev->dev_addr[0];

1095

1104

1096

/* only one byte of actual data (and it's random) */

1105

/* only one byte of actual data (and it's random) */

1097

newpkt.offset[0] = 0xFF;

1106

newpkt.offset[0] = 0xFF;

1098

1107

1099

lp->hw.copy_to_card(dev, bufnum, 0, &newpkt, ARC_HDR_SIZE);

1108

lp->hw.copy_to_card(dev, bufnum, 0, &newpkt, ARC_HDR_SIZE);

1100

1109

1101

return 1; /* done */

1110

return 1; /* done */

1102

}

1111

}

GITLAB

Eric Lee / smarc-fsl-linux-kernel

[ARCNET]: Fix return value from arcnet_send_packet().