• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Linux ARCnet driver - device-independent routines
3  *
4  * Written 1997 by David Woodhouse.
5  * Written 1994-1999 by Avery Pennarun.
6  * Written 1999-2000 by Martin Mares <mj@ucw.cz>.
7  * Derived from skeleton.c by Donald Becker.
8  *
9  * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
10  *  for sponsoring the further development of this driver.
11  *
12  * **********************
13  *
14  * The original copyright was as follows:
15  *
16  * skeleton.c Written 1993 by Donald Becker.
17  * Copyright 1993 United States Government as represented by the
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
20  * modified by SRC, incorporated herein by reference.
21  *
22  * **********************
23  *
24  * The change log is now in a file called ChangeLog in this directory.
25  *
26  * Sources:
27  *  - Crynwr arcnet.com/arcether.com packet drivers.
28  *  - arcnet.c v0.00 dated 1/1/94 and apparently by
29  *     Donald Becker - it didn't work :)
30  *  - skeleton.c v0.05 dated 11/16/93 by Donald Becker
31  *     (from Linux Kernel 1.1.45)
32  *  - RFC's 1201 and 1051 - re: TCP/IP over ARCnet
33  *  - The official ARCnet COM9026 data sheets (!) thanks to
34  *     Ken Cornetet <kcornete@nyx10.cs.du.edu>
35  *  - The official ARCnet COM20020 data sheets.
36  *  - Information on some more obscure ARCnet controller chips, thanks
37  *     to the nice people at SMSC.
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>
40  *  - Textual information and more alternate source from Joachim Koenig
41  *     <jojo@repas.de>
42  */
43 
44 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
45 
46 #include <linux/module.h>
47 #include <linux/types.h>
48 #include <linux/delay.h>
49 #include <linux/netdevice.h>
50 #include <linux/if_arp.h>
51 #include <net/arp.h>
52 #include <linux/init.h>
53 #include <linux/jiffies.h>
54 
55 #include <linux/leds.h>
56 
57 #include "arcdevice.h"
58 #include "com9026.h"
59 
60 /* "do nothing" functions for protocol drivers */
61 static void null_rx(struct net_device *dev, int bufnum,
62 		    struct archdr *pkthdr, int length);
63 static int null_build_header(struct sk_buff *skb, struct net_device *dev,
64 			     unsigned short type, uint8_t daddr);
65 static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,
66 			   int length, int bufnum);
67 
68 static void arcnet_rx(struct net_device *dev, int bufnum);
69 
70 /* one ArcProto per possible proto ID.  None of the elements of
71  * arc_proto_map are allowed to be NULL; they will get set to
72  * arc_proto_default instead.  It also must not be NULL; if you would like
73  * to set it to NULL, set it to &arc_proto_null instead.
74  */
75 struct ArcProto *arc_proto_map[256];
76 EXPORT_SYMBOL(arc_proto_map);
77 
78 struct ArcProto *arc_proto_default;
79 EXPORT_SYMBOL(arc_proto_default);
80 
81 struct ArcProto *arc_bcast_proto;
82 EXPORT_SYMBOL(arc_bcast_proto);
83 
84 struct ArcProto *arc_raw_proto;
85 EXPORT_SYMBOL(arc_raw_proto);
86 
87 static struct ArcProto arc_proto_null = {
88 	.suffix		= '?',
89 	.mtu		= XMTU,
90 	.is_ip          = 0,
91 	.rx		= null_rx,
92 	.build_header	= null_build_header,
93 	.prepare_tx	= null_prepare_tx,
94 	.continue_tx    = NULL,
95 	.ack_tx         = NULL
96 };
97 
98 /* Exported function prototypes */
99 int arcnet_debug = ARCNET_DEBUG;
100 EXPORT_SYMBOL(arcnet_debug);
101 
102 /* Internal function prototypes */
103 static int arcnet_header(struct sk_buff *skb, struct net_device *dev,
104 			 unsigned short type, const void *daddr,
105 			 const void *saddr, unsigned len);
106 static int go_tx(struct net_device *dev);
107 
108 static int debug = ARCNET_DEBUG;
109 module_param(debug, int, 0);
110 MODULE_LICENSE("GPL");
111 
arcnet_init(void)112 static int __init arcnet_init(void)
113 {
114 	int count;
115 
116 	arcnet_debug = debug;
117 
118 	pr_info("arcnet loaded\n");
119 
120 	/* initialize the protocol map */
121 	arc_raw_proto = arc_proto_default = arc_bcast_proto = &arc_proto_null;
122 	for (count = 0; count < 256; count++)
123 		arc_proto_map[count] = arc_proto_default;
124 
125 	if (BUGLVL(D_DURING))
126 		pr_info("struct sizes: %Zd %Zd %Zd %Zd %Zd\n",
127 			sizeof(struct arc_hardware),
128 			sizeof(struct arc_rfc1201),
129 			sizeof(struct arc_rfc1051),
130 			sizeof(struct arc_eth_encap),
131 			sizeof(struct archdr));
132 
133 	return 0;
134 }
135 
arcnet_exit(void)136 static void __exit arcnet_exit(void)
137 {
138 }
139 
140 module_init(arcnet_init);
141 module_exit(arcnet_exit);
142 
143 /* Dump the contents of an sk_buff */
144 #if ARCNET_DEBUG_MAX & D_SKB
arcnet_dump_skb(struct net_device * dev,struct sk_buff * skb,char * desc)145 void arcnet_dump_skb(struct net_device *dev,
146 		     struct sk_buff *skb, char *desc)
147 {
148 	char hdr[32];
149 
150 	/* dump the packet */
151 	snprintf(hdr, sizeof(hdr), "%6s:%s skb->data:", dev->name, desc);
152 	print_hex_dump(KERN_DEBUG, hdr, DUMP_PREFIX_OFFSET,
153 		       16, 1, skb->data, skb->len, true);
154 }
155 EXPORT_SYMBOL(arcnet_dump_skb);
156 #endif
157 
158 /* Dump the contents of an ARCnet buffer */
159 #if (ARCNET_DEBUG_MAX & (D_RX | D_TX))
arcnet_dump_packet(struct net_device * dev,int bufnum,char * desc,int take_arcnet_lock)160 static void arcnet_dump_packet(struct net_device *dev, int bufnum,
161 			       char *desc, int take_arcnet_lock)
162 {
163 	struct arcnet_local *lp = netdev_priv(dev);
164 	int i, length;
165 	unsigned long flags = 0;
166 	static uint8_t buf[512];
167 	char hdr[32];
168 
169 	/* hw.copy_from_card expects IRQ context so take the IRQ lock
170 	 * to keep it single threaded
171 	 */
172 	if (take_arcnet_lock)
173 		spin_lock_irqsave(&lp->lock, flags);
174 
175 	lp->hw.copy_from_card(dev, bufnum, 0, buf, 512);
176 	if (take_arcnet_lock)
177 		spin_unlock_irqrestore(&lp->lock, flags);
178 
179 	/* if the offset[0] byte is nonzero, this is a 256-byte packet */
180 	length = (buf[2] ? 256 : 512);
181 
182 	/* dump the packet */
183 	snprintf(hdr, sizeof(hdr), "%6s:%s packet dump:", dev->name, desc);
184 	print_hex_dump(KERN_DEBUG, hdr, DUMP_PREFIX_OFFSET,
185 		       16, 1, buf, length, true);
186 }
187 
188 #else
189 
190 #define arcnet_dump_packet(dev, bufnum, desc, take_arcnet_lock) do { } while (0)
191 
192 #endif
193 
194 /* Trigger a LED event in response to a ARCNET device event */
arcnet_led_event(struct net_device * dev,enum arcnet_led_event event)195 void arcnet_led_event(struct net_device *dev, enum arcnet_led_event event)
196 {
197 	struct arcnet_local *lp = netdev_priv(dev);
198 	unsigned long led_delay = 350;
199 	unsigned long tx_delay = 50;
200 
201 	switch (event) {
202 	case ARCNET_LED_EVENT_RECON:
203 		led_trigger_blink_oneshot(lp->recon_led_trig,
204 					  &led_delay, &led_delay, 0);
205 		break;
206 	case ARCNET_LED_EVENT_OPEN:
207 		led_trigger_event(lp->tx_led_trig, LED_OFF);
208 		led_trigger_event(lp->recon_led_trig, LED_OFF);
209 		break;
210 	case ARCNET_LED_EVENT_STOP:
211 		led_trigger_event(lp->tx_led_trig, LED_OFF);
212 		led_trigger_event(lp->recon_led_trig, LED_OFF);
213 		break;
214 	case ARCNET_LED_EVENT_TX:
215 		led_trigger_blink_oneshot(lp->tx_led_trig,
216 					  &tx_delay, &tx_delay, 0);
217 		break;
218 	}
219 }
220 EXPORT_SYMBOL_GPL(arcnet_led_event);
221 
arcnet_led_release(struct device * gendev,void * res)222 static void arcnet_led_release(struct device *gendev, void *res)
223 {
224 	struct arcnet_local *lp = netdev_priv(to_net_dev(gendev));
225 
226 	led_trigger_unregister_simple(lp->tx_led_trig);
227 	led_trigger_unregister_simple(lp->recon_led_trig);
228 }
229 
230 /* Register ARCNET LED triggers for a arcnet device
231  *
232  * This is normally called from a driver's probe function
233  */
devm_arcnet_led_init(struct net_device * netdev,int index,int subid)234 void devm_arcnet_led_init(struct net_device *netdev, int index, int subid)
235 {
236 	struct arcnet_local *lp = netdev_priv(netdev);
237 	void *res;
238 
239 	res = devres_alloc(arcnet_led_release, 0, GFP_KERNEL);
240 	if (!res) {
241 		netdev_err(netdev, "cannot register LED triggers\n");
242 		return;
243 	}
244 
245 	snprintf(lp->tx_led_trig_name, sizeof(lp->tx_led_trig_name),
246 		 "arc%d-%d-tx", index, subid);
247 	snprintf(lp->recon_led_trig_name, sizeof(lp->recon_led_trig_name),
248 		 "arc%d-%d-recon", index, subid);
249 
250 	led_trigger_register_simple(lp->tx_led_trig_name,
251 				    &lp->tx_led_trig);
252 	led_trigger_register_simple(lp->recon_led_trig_name,
253 				    &lp->recon_led_trig);
254 
255 	devres_add(&netdev->dev, res);
256 }
257 EXPORT_SYMBOL_GPL(devm_arcnet_led_init);
258 
259 /* Unregister a protocol driver from the arc_proto_map.  Protocol drivers
260  * are responsible for registering themselves, but the unregister routine
261  * is pretty generic so we'll do it here.
262  */
arcnet_unregister_proto(struct ArcProto * proto)263 void arcnet_unregister_proto(struct ArcProto *proto)
264 {
265 	int count;
266 
267 	if (arc_proto_default == proto)
268 		arc_proto_default = &arc_proto_null;
269 	if (arc_bcast_proto == proto)
270 		arc_bcast_proto = arc_proto_default;
271 	if (arc_raw_proto == proto)
272 		arc_raw_proto = arc_proto_default;
273 
274 	for (count = 0; count < 256; count++) {
275 		if (arc_proto_map[count] == proto)
276 			arc_proto_map[count] = arc_proto_default;
277 	}
278 }
279 EXPORT_SYMBOL(arcnet_unregister_proto);
280 
281 /* Add a buffer to the queue.  Only the interrupt handler is allowed to do
282  * this, unless interrupts are disabled.
283  *
284  * Note: we don't check for a full queue, since there aren't enough buffers
285  * to more than fill it.
286  */
release_arcbuf(struct net_device * dev,int bufnum)287 static void release_arcbuf(struct net_device *dev, int bufnum)
288 {
289 	struct arcnet_local *lp = netdev_priv(dev);
290 	int i;
291 
292 	lp->buf_queue[lp->first_free_buf++] = bufnum;
293 	lp->first_free_buf %= 5;
294 
295 	if (BUGLVL(D_DURING)) {
296 		arc_printk(D_DURING, dev, "release_arcbuf: freed #%d; buffer queue is now: ",
297 			   bufnum);
298 		for (i = lp->next_buf; i != lp->first_free_buf; i = (i + 1) % 5)
299 			arc_cont(D_DURING, "#%d ", lp->buf_queue[i]);
300 		arc_cont(D_DURING, "\n");
301 	}
302 }
303 
304 /* Get a buffer from the queue.
305  * If this returns -1, there are no buffers available.
306  */
get_arcbuf(struct net_device * dev)307 static int get_arcbuf(struct net_device *dev)
308 {
309 	struct arcnet_local *lp = netdev_priv(dev);
310 	int buf = -1, i;
311 
312 	if (!atomic_dec_and_test(&lp->buf_lock)) {
313 		/* already in this function */
314 		arc_printk(D_NORMAL, dev, "get_arcbuf: overlap (%d)!\n",
315 			   lp->buf_lock.counter);
316 	} else {			/* we can continue */
317 		if (lp->next_buf >= 5)
318 			lp->next_buf -= 5;
319 
320 		if (lp->next_buf == lp->first_free_buf) {
321 			arc_printk(D_NORMAL, dev, "get_arcbuf: BUG: no buffers are available??\n");
322 		} else {
323 			buf = lp->buf_queue[lp->next_buf++];
324 			lp->next_buf %= 5;
325 		}
326 	}
327 
328 	if (BUGLVL(D_DURING)) {
329 		arc_printk(D_DURING, dev, "get_arcbuf: got #%d; buffer queue is now: ",
330 			   buf);
331 		for (i = lp->next_buf; i != lp->first_free_buf; i = (i + 1) % 5)
332 			arc_cont(D_DURING, "#%d ", lp->buf_queue[i]);
333 		arc_cont(D_DURING, "\n");
334 	}
335 
336 	atomic_inc(&lp->buf_lock);
337 	return buf;
338 }
339 
choose_mtu(void)340 static int choose_mtu(void)
341 {
342 	int count, mtu = 65535;
343 
344 	/* choose the smallest MTU of all available encaps */
345 	for (count = 0; count < 256; count++) {
346 		if (arc_proto_map[count] != &arc_proto_null &&
347 		    arc_proto_map[count]->mtu < mtu) {
348 			mtu = arc_proto_map[count]->mtu;
349 		}
350 	}
351 
352 	return mtu == 65535 ? XMTU : mtu;
353 }
354 
355 static const struct header_ops arcnet_header_ops = {
356 	.create = arcnet_header,
357 };
358 
359 static const struct net_device_ops arcnet_netdev_ops = {
360 	.ndo_open	= arcnet_open,
361 	.ndo_stop	= arcnet_close,
362 	.ndo_start_xmit = arcnet_send_packet,
363 	.ndo_tx_timeout = arcnet_timeout,
364 };
365 
366 /* Setup a struct device for ARCnet. */
arcdev_setup(struct net_device * dev)367 static void arcdev_setup(struct net_device *dev)
368 {
369 	dev->type = ARPHRD_ARCNET;
370 	dev->netdev_ops = &arcnet_netdev_ops;
371 	dev->header_ops = &arcnet_header_ops;
372 	dev->hard_header_len = sizeof(struct arc_hardware);
373 	dev->mtu = choose_mtu();
374 
375 	dev->addr_len = ARCNET_ALEN;
376 	dev->tx_queue_len = 100;
377 	dev->broadcast[0] = 0x00;	/* for us, broadcasts are address 0 */
378 	dev->watchdog_timeo = TX_TIMEOUT;
379 
380 	/* New-style flags. */
381 	dev->flags = IFF_BROADCAST;
382 }
383 
arcnet_timer(unsigned long data)384 static void arcnet_timer(unsigned long data)
385 {
386 	struct net_device *dev = (struct net_device *)data;
387 
388 	if (!netif_carrier_ok(dev)) {
389 		netif_carrier_on(dev);
390 		netdev_info(dev, "link up\n");
391 	}
392 }
393 
alloc_arcdev(const char * name)394 struct net_device *alloc_arcdev(const char *name)
395 {
396 	struct net_device *dev;
397 
398 	dev = alloc_netdev(sizeof(struct arcnet_local),
399 			   name && *name ? name : "arc%d", NET_NAME_UNKNOWN,
400 			   arcdev_setup);
401 	if (dev) {
402 		struct arcnet_local *lp = netdev_priv(dev);
403 
404 		spin_lock_init(&lp->lock);
405 		init_timer(&lp->timer);
406 		lp->timer.data = (unsigned long) dev;
407 		lp->timer.function = arcnet_timer;
408 	}
409 
410 	return dev;
411 }
412 EXPORT_SYMBOL(alloc_arcdev);
413 
414 /* Open/initialize the board.  This is called sometime after booting when
415  * the 'ifconfig' program is run.
416  *
417  * This routine should set everything up anew at each open, even registers
418  * that "should" only need to be set once at boot, so that there is
419  * non-reboot way to recover if something goes wrong.
420  */
arcnet_open(struct net_device * dev)421 int arcnet_open(struct net_device *dev)
422 {
423 	struct arcnet_local *lp = netdev_priv(dev);
424 	int count, newmtu, error;
425 
426 	arc_printk(D_INIT, dev, "opened.");
427 
428 	if (!try_module_get(lp->hw.owner))
429 		return -ENODEV;
430 
431 	if (BUGLVL(D_PROTO)) {
432 		arc_printk(D_PROTO, dev, "protocol map (default is '%c'): ",
433 			   arc_proto_default->suffix);
434 		for (count = 0; count < 256; count++)
435 			arc_cont(D_PROTO, "%c", arc_proto_map[count]->suffix);
436 		arc_cont(D_PROTO, "\n");
437 	}
438 
439 	arc_printk(D_INIT, dev, "arcnet_open: resetting card.\n");
440 
441 	/* try to put the card in a defined state - if it fails the first
442 	 * time, actually reset it.
443 	 */
444 	error = -ENODEV;
445 	if (lp->hw.reset(dev, 0) && lp->hw.reset(dev, 1))
446 		goto out_module_put;
447 
448 	newmtu = choose_mtu();
449 	if (newmtu < dev->mtu)
450 		dev->mtu = newmtu;
451 
452 	arc_printk(D_INIT, dev, "arcnet_open: mtu: %d.\n", dev->mtu);
453 
454 	/* autodetect the encapsulation for each host. */
455 	memset(lp->default_proto, 0, sizeof(lp->default_proto));
456 
457 	/* the broadcast address is special - use the 'bcast' protocol */
458 	for (count = 0; count < 256; count++) {
459 		if (arc_proto_map[count] == arc_bcast_proto) {
460 			lp->default_proto[0] = count;
461 			break;
462 		}
463 	}
464 
465 	/* initialize buffers */
466 	atomic_set(&lp->buf_lock, 1);
467 
468 	lp->next_buf = lp->first_free_buf = 0;
469 	release_arcbuf(dev, 0);
470 	release_arcbuf(dev, 1);
471 	release_arcbuf(dev, 2);
472 	release_arcbuf(dev, 3);
473 	lp->cur_tx = lp->next_tx = -1;
474 	lp->cur_rx = -1;
475 
476 	lp->rfc1201.sequence = 1;
477 
478 	/* bring up the hardware driver */
479 	if (lp->hw.open)
480 		lp->hw.open(dev);
481 
482 	if (dev->dev_addr[0] == 0)
483 		arc_printk(D_NORMAL, dev, "WARNING!  Station address 00 is reserved for broadcasts!\n");
484 	else if (dev->dev_addr[0] == 255)
485 		arc_printk(D_NORMAL, dev, "WARNING!  Station address FF may confuse DOS networking programs!\n");
486 
487 	arc_printk(D_DEBUG, dev, "%s: %d: %s\n", __FILE__, __LINE__, __func__);
488 	if (lp->hw.status(dev) & RESETflag) {
489 		arc_printk(D_DEBUG, dev, "%s: %d: %s\n",
490 			   __FILE__, __LINE__, __func__);
491 		lp->hw.command(dev, CFLAGScmd | RESETclear);
492 	}
493 
494 	arc_printk(D_DEBUG, dev, "%s: %d: %s\n", __FILE__, __LINE__, __func__);
495 	/* make sure we're ready to receive IRQ's. */
496 	lp->hw.intmask(dev, 0);
497 	udelay(1);		/* give it time to set the mask before
498 				 * we reset it again. (may not even be
499 				 * necessary)
500 				 */
501 	arc_printk(D_DEBUG, dev, "%s: %d: %s\n", __FILE__, __LINE__, __func__);
502 	lp->intmask = NORXflag | RECONflag;
503 	lp->hw.intmask(dev, lp->intmask);
504 	arc_printk(D_DEBUG, dev, "%s: %d: %s\n", __FILE__, __LINE__, __func__);
505 
506 	netif_carrier_off(dev);
507 	netif_start_queue(dev);
508 	mod_timer(&lp->timer, jiffies + msecs_to_jiffies(1000));
509 
510 	arcnet_led_event(dev, ARCNET_LED_EVENT_OPEN);
511 	return 0;
512 
513  out_module_put:
514 	module_put(lp->hw.owner);
515 	return error;
516 }
517 EXPORT_SYMBOL(arcnet_open);
518 
519 /* The inverse routine to arcnet_open - shuts down the card. */
arcnet_close(struct net_device * dev)520 int arcnet_close(struct net_device *dev)
521 {
522 	struct arcnet_local *lp = netdev_priv(dev);
523 
524 	arcnet_led_event(dev, ARCNET_LED_EVENT_STOP);
525 	del_timer_sync(&lp->timer);
526 
527 	netif_stop_queue(dev);
528 	netif_carrier_off(dev);
529 
530 	/* flush TX and disable RX */
531 	lp->hw.intmask(dev, 0);
532 	lp->hw.command(dev, NOTXcmd);	/* stop transmit */
533 	lp->hw.command(dev, NORXcmd);	/* disable receive */
534 	mdelay(1);
535 
536 	/* shut down the card */
537 	lp->hw.close(dev);
538 	module_put(lp->hw.owner);
539 	return 0;
540 }
541 EXPORT_SYMBOL(arcnet_close);
542 
arcnet_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned len)543 static int arcnet_header(struct sk_buff *skb, struct net_device *dev,
544 			 unsigned short type, const void *daddr,
545 			 const void *saddr, unsigned len)
546 {
547 	const struct arcnet_local *lp = netdev_priv(dev);
548 	uint8_t _daddr, proto_num;
549 	struct ArcProto *proto;
550 
551 	arc_printk(D_DURING, dev,
552 		   "create header from %d to %d; protocol %d (%Xh); size %u.\n",
553 		   saddr ? *(uint8_t *)saddr : -1,
554 		   daddr ? *(uint8_t *)daddr : -1,
555 		   type, type, len);
556 
557 	if (skb->len != 0 && len != skb->len)
558 		arc_printk(D_NORMAL, dev, "arcnet_header: Yikes!  skb->len(%d) != len(%d)!\n",
559 			   skb->len, len);
560 
561 	/* Type is host order - ? */
562 	if (type == ETH_P_ARCNET) {
563 		proto = arc_raw_proto;
564 		arc_printk(D_DEBUG, dev, "arc_raw_proto used. proto='%c'\n",
565 			   proto->suffix);
566 		_daddr = daddr ? *(uint8_t *)daddr : 0;
567 	} else if (!daddr) {
568 		/* if the dest addr isn't provided, we can't choose an
569 		 * encapsulation!  Store the packet type (eg. ETH_P_IP)
570 		 * for now, and we'll push on a real header when we do
571 		 * rebuild_header.
572 		 */
573 		*(uint16_t *)skb_push(skb, 2) = type;
574 		/* XXX: Why not use skb->mac_len? */
575 		if (skb->network_header - skb->mac_header != 2)
576 			arc_printk(D_NORMAL, dev, "arcnet_header: Yikes!  diff (%u) is not 2!\n",
577 				   skb->network_header - skb->mac_header);
578 		return -2;	/* return error -- can't transmit yet! */
579 	} else {
580 		/* otherwise, we can just add the header as usual. */
581 		_daddr = *(uint8_t *)daddr;
582 		proto_num = lp->default_proto[_daddr];
583 		proto = arc_proto_map[proto_num];
584 		arc_printk(D_DURING, dev, "building header for %02Xh using protocol '%c'\n",
585 			   proto_num, proto->suffix);
586 		if (proto == &arc_proto_null && arc_bcast_proto != proto) {
587 			arc_printk(D_DURING, dev, "actually, let's use '%c' instead.\n",
588 				   arc_bcast_proto->suffix);
589 			proto = arc_bcast_proto;
590 		}
591 	}
592 	return proto->build_header(skb, dev, type, _daddr);
593 }
594 
595 /* Called by the kernel in order to transmit a packet. */
arcnet_send_packet(struct sk_buff * skb,struct net_device * dev)596 netdev_tx_t arcnet_send_packet(struct sk_buff *skb,
597 			       struct net_device *dev)
598 {
599 	struct arcnet_local *lp = netdev_priv(dev);
600 	struct archdr *pkt;
601 	struct arc_rfc1201 *soft;
602 	struct ArcProto *proto;
603 	int txbuf;
604 	unsigned long flags;
605 	int retval;
606 
607 	arc_printk(D_DURING, dev,
608 		   "transmit requested (status=%Xh, txbufs=%d/%d, len=%d, protocol %x)\n",
609 		   lp->hw.status(dev), lp->cur_tx, lp->next_tx, skb->len, skb->protocol);
610 
611 	pkt = (struct archdr *)skb->data;
612 	soft = &pkt->soft.rfc1201;
613 	proto = arc_proto_map[soft->proto];
614 
615 	arc_printk(D_SKB_SIZE, dev, "skb: transmitting %d bytes to %02X\n",
616 		   skb->len, pkt->hard.dest);
617 	if (BUGLVL(D_SKB))
618 		arcnet_dump_skb(dev, skb, "tx");
619 
620 	/* fits in one packet? */
621 	if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) {
622 		arc_printk(D_NORMAL, dev, "fixme: packet too large: compensating badly!\n");
623 		dev_kfree_skb(skb);
624 		return NETDEV_TX_OK;	/* don't try again */
625 	}
626 
627 	/* We're busy transmitting a packet... */
628 	netif_stop_queue(dev);
629 
630 	spin_lock_irqsave(&lp->lock, flags);
631 	lp->hw.intmask(dev, 0);
632 	if (lp->next_tx == -1)
633 		txbuf = get_arcbuf(dev);
634 	else
635 		txbuf = -1;
636 
637 	if (txbuf != -1) {
638 		if (proto->prepare_tx(dev, pkt, skb->len, txbuf) &&
639 		    !proto->ack_tx) {
640 			/* done right away and we don't want to acknowledge
641 			 *  the package later - forget about it now
642 			 */
643 			dev->stats.tx_bytes += skb->len;
644 			dev_kfree_skb(skb);
645 		} else {
646 			/* do it the 'split' way */
647 			lp->outgoing.proto = proto;
648 			lp->outgoing.skb = skb;
649 			lp->outgoing.pkt = pkt;
650 
651 			if (proto->continue_tx &&
652 			    proto->continue_tx(dev, txbuf)) {
653 				arc_printk(D_NORMAL, dev,
654 					   "bug! continue_tx finished the first time! (proto='%c')\n",
655 					   proto->suffix);
656 			}
657 		}
658 		retval = NETDEV_TX_OK;
659 		lp->next_tx = txbuf;
660 	} else {
661 		retval = NETDEV_TX_BUSY;
662 	}
663 
664 	arc_printk(D_DEBUG, dev, "%s: %d: %s, status: %x\n",
665 		   __FILE__, __LINE__, __func__, lp->hw.status(dev));
666 	/* make sure we didn't ignore a TX IRQ while we were in here */
667 	lp->hw.intmask(dev, 0);
668 
669 	arc_printk(D_DEBUG, dev, "%s: %d: %s\n", __FILE__, __LINE__, __func__);
670 	lp->intmask |= TXFREEflag | EXCNAKflag;
671 	lp->hw.intmask(dev, lp->intmask);
672 	arc_printk(D_DEBUG, dev, "%s: %d: %s, status: %x\n",
673 		   __FILE__, __LINE__, __func__, lp->hw.status(dev));
674 
675 	arcnet_led_event(dev, ARCNET_LED_EVENT_TX);
676 
677 	spin_unlock_irqrestore(&lp->lock, flags);
678 	return retval;		/* no need to try again */
679 }
680 EXPORT_SYMBOL(arcnet_send_packet);
681 
682 /* Actually start transmitting a packet that was loaded into a buffer
683  * by prepare_tx.  This should _only_ be called by the interrupt handler.
684  */
go_tx(struct net_device * dev)685 static int go_tx(struct net_device *dev)
686 {
687 	struct arcnet_local *lp = netdev_priv(dev);
688 
689 	arc_printk(D_DURING, dev, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%d\n",
690 		   lp->hw.status(dev), lp->intmask, lp->next_tx, lp->cur_tx);
691 
692 	if (lp->cur_tx != -1 || lp->next_tx == -1)
693 		return 0;
694 
695 	if (BUGLVL(D_TX))
696 		arcnet_dump_packet(dev, lp->next_tx, "go_tx", 0);
697 
698 	lp->cur_tx = lp->next_tx;
699 	lp->next_tx = -1;
700 
701 	/* start sending */
702 	lp->hw.command(dev, TXcmd | (lp->cur_tx << 3));
703 
704 	dev->stats.tx_packets++;
705 	lp->lasttrans_dest = lp->lastload_dest;
706 	lp->lastload_dest = 0;
707 	lp->excnak_pending = 0;
708 	lp->intmask |= TXFREEflag | EXCNAKflag;
709 
710 	return 1;
711 }
712 
713 /* Called by the kernel when transmit times out */
arcnet_timeout(struct net_device * dev)714 void arcnet_timeout(struct net_device *dev)
715 {
716 	unsigned long flags;
717 	struct arcnet_local *lp = netdev_priv(dev);
718 	int status = lp->hw.status(dev);
719 	char *msg;
720 
721 	spin_lock_irqsave(&lp->lock, flags);
722 	if (status & TXFREEflag) {	/* transmit _DID_ finish */
723 		msg = " - missed IRQ?";
724 	} else {
725 		msg = "";
726 		dev->stats.tx_aborted_errors++;
727 		lp->timed_out = 1;
728 		lp->hw.command(dev, NOTXcmd | (lp->cur_tx << 3));
729 	}
730 	dev->stats.tx_errors++;
731 
732 	/* make sure we didn't miss a TX or a EXC NAK IRQ */
733 	lp->hw.intmask(dev, 0);
734 	lp->intmask |= TXFREEflag | EXCNAKflag;
735 	lp->hw.intmask(dev, lp->intmask);
736 
737 	spin_unlock_irqrestore(&lp->lock, flags);
738 
739 	if (time_after(jiffies, lp->last_timeout + 10 * HZ)) {
740 		arc_printk(D_EXTRA, dev, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)\n",
741 			   msg, status, lp->intmask, lp->lasttrans_dest);
742 		lp->last_timeout = jiffies;
743 	}
744 
745 	if (lp->cur_tx == -1)
746 		netif_wake_queue(dev);
747 }
748 EXPORT_SYMBOL(arcnet_timeout);
749 
750 /* The typical workload of the driver: Handle the network interface
751  * interrupts. Establish which device needs attention, and call the correct
752  * chipset interrupt handler.
753  */
arcnet_interrupt(int irq,void * dev_id)754 irqreturn_t arcnet_interrupt(int irq, void *dev_id)
755 {
756 	struct net_device *dev = dev_id;
757 	struct arcnet_local *lp;
758 	int recbuf, status, diagstatus, didsomething, boguscount;
759 	int retval = IRQ_NONE;
760 
761 	arc_printk(D_DURING, dev, "\n");
762 
763 	arc_printk(D_DURING, dev, "in arcnet_interrupt\n");
764 
765 	lp = netdev_priv(dev);
766 	BUG_ON(!lp);
767 
768 	spin_lock(&lp->lock);
769 
770 	/* RESET flag was enabled - if device is not running, we must
771 	 * clear it right away (but nothing else).
772 	 */
773 	if (!netif_running(dev)) {
774 		if (lp->hw.status(dev) & RESETflag)
775 			lp->hw.command(dev, CFLAGScmd | RESETclear);
776 		lp->hw.intmask(dev, 0);
777 		spin_unlock(&lp->lock);
778 		return retval;
779 	}
780 
781 	arc_printk(D_DURING, dev, "in arcnet_inthandler (status=%Xh, intmask=%Xh)\n",
782 		   lp->hw.status(dev), lp->intmask);
783 
784 	boguscount = 5;
785 	do {
786 		status = lp->hw.status(dev);
787 		diagstatus = (status >> 8) & 0xFF;
788 
789 		arc_printk(D_DEBUG, dev, "%s: %d: %s: status=%x\n",
790 			   __FILE__, __LINE__, __func__, status);
791 		didsomething = 0;
792 
793 		/* RESET flag was enabled - card is resetting and if RX is
794 		 * disabled, it's NOT because we just got a packet.
795 		 *
796 		 * The card is in an undefined state.
797 		 * Clear it out and start over.
798 		 */
799 		if (status & RESETflag) {
800 			arc_printk(D_NORMAL, dev, "spurious reset (status=%Xh)\n",
801 				   status);
802 			arcnet_close(dev);
803 			arcnet_open(dev);
804 
805 			/* get out of the interrupt handler! */
806 			break;
807 		}
808 		/* RX is inhibited - we must have received something.
809 		 * Prepare to receive into the next buffer.
810 		 *
811 		 * We don't actually copy the received packet from the card
812 		 * until after the transmit handler runs (and possibly
813 		 * launches the next tx); this should improve latency slightly
814 		 * if we get both types of interrupts at once.
815 		 */
816 		recbuf = -1;
817 		if (status & lp->intmask & NORXflag) {
818 			recbuf = lp->cur_rx;
819 			arc_printk(D_DURING, dev, "Buffer #%d: receive irq (status=%Xh)\n",
820 				   recbuf, status);
821 
822 			lp->cur_rx = get_arcbuf(dev);
823 			if (lp->cur_rx != -1) {
824 				arc_printk(D_DURING, dev, "enabling receive to buffer #%d\n",
825 					   lp->cur_rx);
826 				lp->hw.command(dev, RXcmd | (lp->cur_rx << 3) | RXbcasts);
827 			}
828 			didsomething++;
829 		}
830 
831 		if ((diagstatus & EXCNAKflag)) {
832 			arc_printk(D_DURING, dev, "EXCNAK IRQ (diagstat=%Xh)\n",
833 				   diagstatus);
834 
835 			lp->hw.command(dev, NOTXcmd);      /* disable transmit */
836 			lp->excnak_pending = 1;
837 
838 			lp->hw.command(dev, EXCNAKclear);
839 			lp->intmask &= ~(EXCNAKflag);
840 			didsomething++;
841 		}
842 
843 		/* a transmit finished, and we're interested in it. */
844 		if ((status & lp->intmask & TXFREEflag) || lp->timed_out) {
845 			lp->intmask &= ~(TXFREEflag | EXCNAKflag);
846 
847 			arc_printk(D_DURING, dev, "TX IRQ (stat=%Xh)\n",
848 				   status);
849 
850 			if (lp->cur_tx != -1 && !lp->timed_out) {
851 				if (!(status & TXACKflag)) {
852 					if (lp->lasttrans_dest != 0) {
853 						arc_printk(D_EXTRA, dev,
854 							   "transmit was not acknowledged! (status=%Xh, dest=%02Xh)\n",
855 							   status,
856 							   lp->lasttrans_dest);
857 						dev->stats.tx_errors++;
858 						dev->stats.tx_carrier_errors++;
859 					} else {
860 						arc_printk(D_DURING, dev,
861 							   "broadcast was not acknowledged; that's normal (status=%Xh, dest=%02Xh)\n",
862 							   status,
863 							   lp->lasttrans_dest);
864 					}
865 				}
866 
867 				if (lp->outgoing.proto &&
868 				    lp->outgoing.proto->ack_tx) {
869 					int ackstatus;
870 
871 					if (status & TXACKflag)
872 						ackstatus = 2;
873 					else if (lp->excnak_pending)
874 						ackstatus = 1;
875 					else
876 						ackstatus = 0;
877 
878 					lp->outgoing.proto
879 						->ack_tx(dev, ackstatus);
880 				}
881 			}
882 			if (lp->cur_tx != -1)
883 				release_arcbuf(dev, lp->cur_tx);
884 
885 			lp->cur_tx = -1;
886 			lp->timed_out = 0;
887 			didsomething++;
888 
889 			/* send another packet if there is one */
890 			go_tx(dev);
891 
892 			/* continue a split packet, if any */
893 			if (lp->outgoing.proto &&
894 			    lp->outgoing.proto->continue_tx) {
895 				int txbuf = get_arcbuf(dev);
896 
897 				if (txbuf != -1) {
898 					if (lp->outgoing.proto->continue_tx(dev, txbuf)) {
899 						/* that was the last segment */
900 						dev->stats.tx_bytes += lp->outgoing.skb->len;
901 						if (!lp->outgoing.proto->ack_tx) {
902 							dev_kfree_skb_irq(lp->outgoing.skb);
903 							lp->outgoing.proto = NULL;
904 						}
905 					}
906 					lp->next_tx = txbuf;
907 				}
908 			}
909 			/* inform upper layers of idleness, if necessary */
910 			if (lp->cur_tx == -1)
911 				netif_wake_queue(dev);
912 		}
913 		/* now process the received packet, if any */
914 		if (recbuf != -1) {
915 			if (BUGLVL(D_RX))
916 				arcnet_dump_packet(dev, recbuf, "rx irq", 0);
917 
918 			arcnet_rx(dev, recbuf);
919 			release_arcbuf(dev, recbuf);
920 
921 			didsomething++;
922 		}
923 		if (status & lp->intmask & RECONflag) {
924 			lp->hw.command(dev, CFLAGScmd | CONFIGclear);
925 			dev->stats.tx_carrier_errors++;
926 
927 			arc_printk(D_RECON, dev, "Network reconfiguration detected (status=%Xh)\n",
928 				   status);
929 			if (netif_carrier_ok(dev)) {
930 				netif_carrier_off(dev);
931 				netdev_info(dev, "link down\n");
932 			}
933 			mod_timer(&lp->timer, jiffies + msecs_to_jiffies(1000));
934 
935 			arcnet_led_event(dev, ARCNET_LED_EVENT_RECON);
936 			/* MYRECON bit is at bit 7 of diagstatus */
937 			if (diagstatus & 0x80)
938 				arc_printk(D_RECON, dev, "Put out that recon myself\n");
939 
940 			/* is the RECON info empty or old? */
941 			if (!lp->first_recon || !lp->last_recon ||
942 			    time_after(jiffies, lp->last_recon + HZ * 10)) {
943 				if (lp->network_down)
944 					arc_printk(D_NORMAL, dev, "reconfiguration detected: cabling restored?\n");
945 				lp->first_recon = lp->last_recon = jiffies;
946 				lp->num_recons = lp->network_down = 0;
947 
948 				arc_printk(D_DURING, dev, "recon: clearing counters.\n");
949 			} else {	/* add to current RECON counter */
950 				lp->last_recon = jiffies;
951 				lp->num_recons++;
952 
953 				arc_printk(D_DURING, dev, "recon: counter=%d, time=%lds, net=%d\n",
954 					   lp->num_recons,
955 					   (lp->last_recon - lp->first_recon) / HZ,
956 					   lp->network_down);
957 
958 				/* if network is marked up;
959 				 * and first_recon and last_recon are 60+ apart;
960 				 * and the average no. of recons counted is
961 				 *    > RECON_THRESHOLD/min;
962 				 * then print a warning message.
963 				 */
964 				if (!lp->network_down &&
965 				    (lp->last_recon - lp->first_recon) <= HZ * 60 &&
966 				    lp->num_recons >= RECON_THRESHOLD) {
967 					lp->network_down = 1;
968 					arc_printk(D_NORMAL, dev, "many reconfigurations detected: cabling problem?\n");
969 				} else if (!lp->network_down &&
970 					   lp->last_recon - lp->first_recon > HZ * 60) {
971 					/* reset counters if we've gone for
972 					 *  over a minute.
973 					 */
974 					lp->first_recon = lp->last_recon;
975 					lp->num_recons = 1;
976 				}
977 			}
978 		} else if (lp->network_down &&
979 			   time_after(jiffies, lp->last_recon + HZ * 10)) {
980 			if (lp->network_down)
981 				arc_printk(D_NORMAL, dev, "cabling restored?\n");
982 			lp->first_recon = lp->last_recon = 0;
983 			lp->num_recons = lp->network_down = 0;
984 
985 			arc_printk(D_DURING, dev, "not recon: clearing counters anyway.\n");
986 			netif_carrier_on(dev);
987 		}
988 
989 		if (didsomething)
990 			retval |= IRQ_HANDLED;
991 	} while (--boguscount && didsomething);
992 
993 	arc_printk(D_DURING, dev, "arcnet_interrupt complete (status=%Xh, count=%d)\n",
994 		   lp->hw.status(dev), boguscount);
995 	arc_printk(D_DURING, dev, "\n");
996 
997 	lp->hw.intmask(dev, 0);
998 	udelay(1);
999 	lp->hw.intmask(dev, lp->intmask);
1000 
1001 	spin_unlock(&lp->lock);
1002 	return retval;
1003 }
1004 EXPORT_SYMBOL(arcnet_interrupt);
1005 
1006 /* This is a generic packet receiver that calls arcnet??_rx depending on the
1007  * protocol ID found.
1008  */
arcnet_rx(struct net_device * dev,int bufnum)1009 static void arcnet_rx(struct net_device *dev, int bufnum)
1010 {
1011 	struct arcnet_local *lp = netdev_priv(dev);
1012 	union {
1013 		struct archdr pkt;
1014 		char buf[512];
1015 	} rxdata;
1016 	struct arc_rfc1201 *soft;
1017 	int length, ofs;
1018 
1019 	soft = &rxdata.pkt.soft.rfc1201;
1020 
1021 	lp->hw.copy_from_card(dev, bufnum, 0, &rxdata.pkt, ARC_HDR_SIZE);
1022 	if (rxdata.pkt.hard.offset[0]) {
1023 		ofs = rxdata.pkt.hard.offset[0];
1024 		length = 256 - ofs;
1025 	} else {
1026 		ofs = rxdata.pkt.hard.offset[1];
1027 		length = 512 - ofs;
1028 	}
1029 
1030 	/* get the full header, if possible */
1031 	if (sizeof(rxdata.pkt.soft) <= length) {
1032 		lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(rxdata.pkt.soft));
1033 	} else {
1034 		memset(&rxdata.pkt.soft, 0, sizeof(rxdata.pkt.soft));
1035 		lp->hw.copy_from_card(dev, bufnum, ofs, soft, length);
1036 	}
1037 
1038 	arc_printk(D_DURING, dev, "Buffer #%d: received packet from %02Xh to %02Xh (%d+4 bytes)\n",
1039 		   bufnum, rxdata.pkt.hard.source, rxdata.pkt.hard.dest, length);
1040 
1041 	dev->stats.rx_packets++;
1042 	dev->stats.rx_bytes += length + ARC_HDR_SIZE;
1043 
1044 	/* call the right receiver for the protocol */
1045 	if (arc_proto_map[soft->proto]->is_ip) {
1046 		if (BUGLVL(D_PROTO)) {
1047 			struct ArcProto
1048 			*oldp = arc_proto_map[lp->default_proto[rxdata.pkt.hard.source]],
1049 			*newp = arc_proto_map[soft->proto];
1050 
1051 			if (oldp != newp) {
1052 				arc_printk(D_PROTO, dev,
1053 					   "got protocol %02Xh; encap for host %02Xh is now '%c' (was '%c')\n",
1054 					   soft->proto, rxdata.pkt.hard.source,
1055 					   newp->suffix, oldp->suffix);
1056 			}
1057 		}
1058 
1059 		/* broadcasts will always be done with the last-used encap. */
1060 		lp->default_proto[0] = soft->proto;
1061 
1062 		/* in striking contrast, the following isn't a hack. */
1063 		lp->default_proto[rxdata.pkt.hard.source] = soft->proto;
1064 	}
1065 	/* call the protocol-specific receiver. */
1066 	arc_proto_map[soft->proto]->rx(dev, bufnum, &rxdata.pkt, length);
1067 }
1068 
null_rx(struct net_device * dev,int bufnum,struct archdr * pkthdr,int length)1069 static void null_rx(struct net_device *dev, int bufnum,
1070 		    struct archdr *pkthdr, int length)
1071 {
1072 	arc_printk(D_PROTO, dev,
1073 		   "rx: don't know how to deal with proto %02Xh from host %02Xh.\n",
1074 		   pkthdr->soft.rfc1201.proto, pkthdr->hard.source);
1075 }
1076 
null_build_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,uint8_t daddr)1077 static int null_build_header(struct sk_buff *skb, struct net_device *dev,
1078 			     unsigned short type, uint8_t daddr)
1079 {
1080 	struct arcnet_local *lp = netdev_priv(dev);
1081 
1082 	arc_printk(D_PROTO, dev,
1083 		   "tx: can't build header for encap %02Xh; load a protocol driver.\n",
1084 		   lp->default_proto[daddr]);
1085 
1086 	/* always fails */
1087 	return 0;
1088 }
1089 
1090 /* the "do nothing" prepare_tx function warns that there's nothing to do. */
null_prepare_tx(struct net_device * dev,struct archdr * pkt,int length,int bufnum)1091 static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,
1092 			   int length, int bufnum)
1093 {
1094 	struct arcnet_local *lp = netdev_priv(dev);
1095 	struct arc_hardware newpkt;
1096 
1097 	arc_printk(D_PROTO, dev, "tx: no encap for this host; load a protocol driver.\n");
1098 
1099 	/* send a packet to myself -- will never get received, of course */
1100 	newpkt.source = newpkt.dest = dev->dev_addr[0];
1101 
1102 	/* only one byte of actual data (and it's random) */
1103 	newpkt.offset[0] = 0xFF;
1104 
1105 	lp->hw.copy_to_card(dev, bufnum, 0, &newpkt, ARC_HDR_SIZE);
1106 
1107 	return 1;		/* done */
1108 }
1109