blob: cd3c9a5a98b25be77691af97816ab53a45cf06bb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* mac89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */
2/*
3 Written 1996 by Russell Nelson, with reference to skeleton.c
4 written 1993-1994 by Donald Becker.
5
6 This software may be used and distributed according to the terms
7 of the GNU General Public License, incorporated herein by reference.
8
9 The author may be reached at nelson@crynwr.com, Crynwr
10 Software, 11 Grant St., Potsdam, NY 13676
11
12 Changelog:
13
14 Mike Cruse : mcruse@cti-ltd.com
15 : Changes for Linux 2.0 compatibility.
16 : Added dev_id parameter in net_interrupt(),
17 : request_irq() and free_irq(). Just NULL for now.
18
19 Mike Cruse : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
20 : in net_open() and net_close() so kerneld would know
21 : that the module is in use and wouldn't eject the
22 : driver prematurely.
23
24 Mike Cruse : Rewrote init_module() and cleanup_module using 8390.c
25 : as an example. Disabled autoprobing in init_module(),
26 : not a good thing to do to other devices while Linux
27 : is running from all accounts.
28
29 Alan Cox : Removed 1.2 support, added 2.1 extra counters.
30
31 David Huggins-Daines <dhd@debian.org>
32
33 Split this off into mac89x0.c, and gutted it of all parts which are
34 not relevant to the existing CS8900 cards on the Macintosh
35 (i.e. basically the Daynaport CS and LC cards). To be precise:
36
37 * Removed all the media-detection stuff, because these cards are
38 TP-only.
39
40 * Lobotomized the ISA interrupt bogosity, because these cards use
41 a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
42
43 * Basically eliminated everything not relevant to getting the
44 cards minimally functioning on the Macintosh.
45
46 I might add that these cards are badly designed even from the Mac
47 standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
48 I/O space and NuBus interrupts for these cards, but neglected to
49 provide anything even remotely resembling a NuBus ROM. Therefore we
50 have to probe for them in a brain-damaged ISA-like fashion.
51
52 Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
53 check kmalloc and release the allocated memory on failure in
54 mac89x0_probe and in init_module
55 use local_irq_{save,restore}(flags) in net_get_stat, not just
56 local_irq_{dis,en}able()
57*/
58
59static char *version =
60"cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
61
62/* ======================= configure the driver here ======================= */
63
64/* use 0 for production, 1 for verification, >2 for debug */
65#ifndef NET_DEBUG
66#define NET_DEBUG 0
67#endif
68
69/* ======================= end of configuration ======================= */
70
71
72/* Always include 'config.h' first in case the user wants to turn on
73 or override something. */
74#include <linux/module.h>
75
76#define PRINTK(x) printk x
77
78/*
79 Sources:
80
81 Crynwr packet driver epktisa.
82
83 Crystal Semiconductor data sheets.
84
85*/
86
87#include <linux/kernel.h>
88#include <linux/types.h>
89#include <linux/fcntl.h>
90#include <linux/interrupt.h>
91#include <linux/ioport.h>
92#include <linux/in.h>
93#include <linux/slab.h>
94#include <linux/string.h>
95#include <linux/nubus.h>
96#include <linux/errno.h>
97#include <linux/init.h>
98#include <linux/netdevice.h>
99#include <linux/etherdevice.h>
100#include <linux/skbuff.h>
101#include <linux/delay.h>
102
103#include <asm/system.h>
104#include <asm/bitops.h>
105#include <asm/io.h>
106#include <asm/hwtest.h>
107#include <asm/macints.h>
108
109#include "cs89x0.h"
110
111static unsigned int net_debug = NET_DEBUG;
112
113/* Information that need to be kept for each board. */
114struct net_local {
115 struct net_device_stats stats;
116 int chip_type; /* one of: CS8900, CS8920, CS8920M */
117 char chip_revision; /* revision letter of the chip ('A'...) */
118 int send_cmd; /* the propercommand used to send a packet. */
119 int rx_mode;
120 int curr_rx_cfg;
121 int send_underrun; /* keep track of how many underruns in a row we get */
122 struct sk_buff *skb;
123};
124
125/* Index to functions, as function prototypes. */
126
127#if 0
128extern void reset_chip(struct net_device *dev);
129#endif
130static int net_open(struct net_device *dev);
131static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
132static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
133static void set_multicast_list(struct net_device *dev);
134static void net_rx(struct net_device *dev);
135static int net_close(struct net_device *dev);
136static struct net_device_stats *net_get_stats(struct net_device *dev);
137static int set_mac_address(struct net_device *dev, void *addr);
138
139
140/* Example routines you must write ;->. */
141#define tx_done(dev) 1
142
143/* For reading/writing registers ISA-style */
144static inline int
145readreg_io(struct net_device *dev, int portno)
146{
147 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
148 return swab16(nubus_readw(dev->base_addr + DATA_PORT));
149}
150
151static inline void
152writereg_io(struct net_device *dev, int portno, int value)
153{
154 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
155 nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
156}
157
158/* These are for reading/writing registers in shared memory */
159static inline int
160readreg(struct net_device *dev, int portno)
161{
162 return swab16(nubus_readw(dev->mem_start + portno));
163}
164
165static inline void
166writereg(struct net_device *dev, int portno, int value)
167{
168 nubus_writew(swab16(value), dev->mem_start + portno);
169}
170
171/* Probe for the CS8900 card in slot E. We won't bother looking
172 anywhere else until we have a really good reason to do so. */
173struct net_device * __init mac89x0_probe(int unit)
174{
175 struct net_device *dev;
176 static int once_is_enough;
177 struct net_local *lp;
178 static unsigned version_printed;
179 int i, slot;
180 unsigned rev_type = 0;
181 unsigned long ioaddr;
182 unsigned short sig;
183 int err = -ENODEV;
184
185 dev = alloc_etherdev(sizeof(struct net_local));
186 if (!dev)
187 return ERR_PTR(-ENOMEM);
188
189 if (unit >= 0) {
190 sprintf(dev->name, "eth%d", unit);
191 netdev_boot_setup_check(dev);
192 }
193
194 SET_MODULE_OWNER(dev);
195
196 if (once_is_enough)
197 goto out;
198 once_is_enough = 1;
199
200 /* We might have to parameterize this later */
201 slot = 0xE;
202 /* Get out now if there's a real NuBus card in slot E */
203 if (nubus_find_slot(slot, NULL) != NULL)
204 goto out;
205
206 /* The pseudo-ISA bits always live at offset 0x300 (gee,
207 wonder why...) */
208 ioaddr = (unsigned long)
209 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
210 {
211 unsigned long flags;
212 int card_present;
213
214 local_irq_save(flags);
215 card_present = hwreg_present((void*) ioaddr+4)
216 && hwreg_present((void*) ioaddr + DATA_PORT);
217 local_irq_restore(flags);
218
219 if (!card_present)
220 goto out;
221 }
222
223 nubus_writew(0, ioaddr + ADD_PORT);
224 sig = nubus_readw(ioaddr + DATA_PORT);
225 if (sig != swab16(CHIP_EISA_ID_SIG))
226 goto out;
227
228 /* Initialize the net_device structure. */
229 lp = netdev_priv(dev);
230
231 /* Fill in the 'dev' fields. */
232 dev->base_addr = ioaddr;
233 dev->mem_start = (unsigned long)
234 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
235 dev->mem_end = dev->mem_start + 0x1000;
236
237 /* Turn on shared memory */
238 writereg_io(dev, PP_BusCTL, MEMORY_ON);
239
240 /* get the chip type */
241 rev_type = readreg(dev, PRODUCT_ID_ADD);
242 lp->chip_type = rev_type &~ REVISON_BITS;
243 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
244
245 /* Check the chip type and revision in order to set the correct send command
246 CS8920 revision C and CS8900 revision F can use the faster send. */
247 lp->send_cmd = TX_AFTER_381;
248 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
249 lp->send_cmd = TX_NOW;
250 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
251 lp->send_cmd = TX_NOW;
252
253 if (net_debug && version_printed++ == 0)
254 printk(version);
255
256 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
257 dev->name,
258 lp->chip_type==CS8900?'0':'2',
259 lp->chip_type==CS8920M?"M":"",
260 lp->chip_revision,
261 dev->base_addr);
262
263 /* Try to read the MAC address */
264 if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
265 printk("\nmac89x0: No EEPROM, giving up now.\n");
266 goto out1;
267 } else {
268 for (i = 0; i < ETH_ALEN; i += 2) {
269 /* Big-endian (why??!) */
270 unsigned short s = readreg(dev, PP_IA + i);
271 dev->dev_addr[i] = s >> 8;
272 dev->dev_addr[i+1] = s & 0xff;
273 }
274 }
275
276 dev->irq = SLOT2IRQ(slot);
277 printk(" IRQ %d ADDR ", dev->irq);
278
279 /* print the ethernet address. */
280 for (i = 0; i < ETH_ALEN; i++)
281 printk("%2.2x%s", dev->dev_addr[i],
282 ((i < ETH_ALEN-1) ? ":" : ""));
283 printk("\n");
284
285 dev->open = net_open;
286 dev->stop = net_close;
287 dev->hard_start_xmit = net_send_packet;
288 dev->get_stats = net_get_stats;
289 dev->set_multicast_list = &set_multicast_list;
290 dev->set_mac_address = &set_mac_address;
291
292 err = register_netdev(dev);
293 if (err)
294 goto out1;
295 return 0;
296out1:
297 nubus_writew(0, dev->base_addr + ADD_PORT);
298out:
299 free_netdev(dev);
300 return ERR_PTR(err);
301}
302
303#if 0
304/* This is useful for something, but I don't know what yet. */
305void __init reset_chip(struct net_device *dev)
306{
307 int reset_start_time;
308
309 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
310
311 /* wait 30 ms */
312 msleep_interruptible(30);
313
314 /* Wait until the chip is reset */
315 reset_start_time = jiffies;
316 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
317 ;
318}
319#endif
320
321/* Open/initialize the board. This is called (in the current kernel)
322 sometime after booting when the 'ifconfig' program is run.
323
324 This routine should set everything up anew at each open, even
325 registers that "should" only need to be set once at boot, so that
326 there is non-reboot way to recover if something goes wrong.
327 */
328static int
329net_open(struct net_device *dev)
330{
331 struct net_local *lp = netdev_priv(dev);
332 int i;
333
334 /* Disable the interrupt for now */
335 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
336
337 /* Grab the interrupt */
338 if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
339 return -EAGAIN;
340
341 /* Set up the IRQ - Apparently magic */
342 if (lp->chip_type == CS8900)
343 writereg(dev, PP_CS8900_ISAINT, 0);
344 else
345 writereg(dev, PP_CS8920_ISAINT, 0);
346
347 /* set the Ethernet address */
348 for (i=0; i < ETH_ALEN/2; i++)
349 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
350
351 /* Turn on both receive and transmit operations */
352 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
353
354 /* Receive only error free packets addressed to this card */
355 lp->rx_mode = 0;
356 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
357
358 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
359
360 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
361
362 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
363 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
364
365 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
366 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
367
368 /* now that we've got our act together, enable everything */
369 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
370 netif_start_queue(dev);
371 return 0;
372}
373
374static int
375net_send_packet(struct sk_buff *skb, struct net_device *dev)
376{
377 if (dev->tbusy) {
378 /* If we get here, some higher level has decided we are broken.
379 There should really be a "kick me" function call instead. */
380 int tickssofar = jiffies - dev->trans_start;
381 if (tickssofar < 5)
382 return 1;
383 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
384 tx_done(dev) ? "IRQ conflict" : "network cable problem");
385 /* Try to restart the adaptor. */
386 dev->tbusy=0;
387 dev->trans_start = jiffies;
388 }
389
390 /* Block a timer-based transmit from overlapping. This could better be
391 done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
392 if (test_and_set_bit(0, (void*)&dev->tbusy) != 0)
393 printk("%s: Transmitter access conflict.\n", dev->name);
394 else {
395 struct net_local *lp = netdev_priv(dev);
396 unsigned long flags;
397
398 if (net_debug > 3)
399 printk("%s: sent %d byte packet of type %x\n",
400 dev->name, skb->len,
401 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
402 | skb->data[ETH_ALEN+ETH_ALEN+1]);
403
404 /* keep the upload from being interrupted, since we
405 ask the chip to start transmitting before the
406 whole packet has been completely uploaded. */
407 local_irq_save(flags);
408
409 /* initiate a transmit sequence */
410 writereg(dev, PP_TxCMD, lp->send_cmd);
411 writereg(dev, PP_TxLength, skb->len);
412
413 /* Test to see if the chip has allocated memory for the packet */
414 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
415 /* Gasp! It hasn't. But that shouldn't happen since
416 we're waiting for TxOk, so return 1 and requeue this packet. */
417 local_irq_restore(flags);
418 return 1;
419 }
420
421 /* Write the contents of the packet */
422 memcpy_toio(dev->mem_start + PP_TxFrame, skb->data, skb->len+1);
423
424 local_irq_restore(flags);
425 dev->trans_start = jiffies;
426 }
427 dev_kfree_skb (skb);
428
429 return 0;
430}
431
432/* The typical workload of the driver:
433 Handle the network interface interrupts. */
434static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
435{
436 struct net_device *dev = dev_id;
437 struct net_local *lp;
438 int ioaddr, status;
439
440 if (dev == NULL) {
441 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
442 return IRQ_NONE;
443 }
444 if (dev->interrupt)
445 printk("%s: Re-entering the interrupt handler.\n", dev->name);
446 dev->interrupt = 1;
447
448 ioaddr = dev->base_addr;
449 lp = netdev_priv(dev);
450
451 /* we MUST read all the events out of the ISQ, otherwise we'll never
452 get interrupted again. As a consequence, we can't have any limit
453 on the number of times we loop in the interrupt handler. The
454 hardware guarantees that eventually we'll run out of events. Of
455 course, if you're on a slow machine, and packets are arriving
456 faster than you can read them off, you're screwed. Hasta la
457 vista, baby! */
458 while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
459 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
460 switch(status & ISQ_EVENT_MASK) {
461 case ISQ_RECEIVER_EVENT:
462 /* Got a packet(s). */
463 net_rx(dev);
464 break;
465 case ISQ_TRANSMITTER_EVENT:
466 lp->stats.tx_packets++;
467 dev->tbusy = 0;
468 mark_bh(NET_BH); /* Inform upper layers. */
469 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
470 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
471 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
472 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
473 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
474 break;
475 case ISQ_BUFFER_EVENT:
476 if (status & READY_FOR_TX) {
477 /* we tried to transmit a packet earlier,
478 but inexplicably ran out of buffers.
479 That shouldn't happen since we only ever
480 load one packet. Shrug. Do the right
481 thing anyway. */
482 dev->tbusy = 0;
483 mark_bh(NET_BH); /* Inform upper layers. */
484 }
485 if (status & TX_UNDERRUN) {
486 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
487 lp->send_underrun++;
488 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
489 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
490 }
491 break;
492 case ISQ_RX_MISS_EVENT:
493 lp->stats.rx_missed_errors += (status >>6);
494 break;
495 case ISQ_TX_COL_EVENT:
496 lp->stats.collisions += (status >>6);
497 break;
498 }
499 }
500 dev->interrupt = 0;
501 return IRQ_HANDLED;
502}
503
504/* We have a good packet(s), get it/them out of the buffers. */
505static void
506net_rx(struct net_device *dev)
507{
508 struct net_local *lp = netdev_priv(dev);
509 struct sk_buff *skb;
510 int status, length;
511
512 status = readreg(dev, PP_RxStatus);
513 if ((status & RX_OK) == 0) {
514 lp->stats.rx_errors++;
515 if (status & RX_RUNT) lp->stats.rx_length_errors++;
516 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
517 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
518 /* per str 172 */
519 lp->stats.rx_crc_errors++;
520 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
521 return;
522 }
523
524 length = readreg(dev, PP_RxLength);
525 /* Malloc up new buffer. */
526 skb = alloc_skb(length, GFP_ATOMIC);
527 if (skb == NULL) {
528 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
529 lp->stats.rx_dropped++;
530 return;
531 }
532 skb_put(skb, length);
533 skb->dev = dev;
534
535 memcpy_fromio(skb->data, dev->mem_start + PP_RxFrame, length);
536
537 if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
538 dev->name, length,
539 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
540 | skb->data[ETH_ALEN+ETH_ALEN+1]);
541
542 skb->protocol=eth_type_trans(skb,dev);
543 netif_rx(skb);
544 dev->last_rx = jiffies;
545 lp->stats.rx_packets++;
546 lp->stats.rx_bytes += length;
547}
548
549/* The inverse routine to net_open(). */
550static int
551net_close(struct net_device *dev)
552{
553
554 writereg(dev, PP_RxCFG, 0);
555 writereg(dev, PP_TxCFG, 0);
556 writereg(dev, PP_BufCFG, 0);
557 writereg(dev, PP_BusCTL, 0);
558
559 netif_stop_queue(dev);
560
561 free_irq(dev->irq, dev);
562
563 /* Update the statistics here. */
564
565 return 0;
566
567}
568
569/* Get the current statistics. This may be called with the card open or
570 closed. */
571static struct net_device_stats *
572net_get_stats(struct net_device *dev)
573{
574 struct net_local *lp = netdev_priv(dev);
575 unsigned long flags;
576
577 local_irq_save(flags);
578 /* Update the statistics from the device registers. */
579 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
580 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
581 local_irq_restore(flags);
582
583 return &lp->stats;
584}
585
586static void set_multicast_list(struct net_device *dev)
587{
588 struct net_local *lp = netdev_priv(dev);
589
590 if(dev->flags&IFF_PROMISC)
591 {
592 lp->rx_mode = RX_ALL_ACCEPT;
593 }
594 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
595 {
596 /* The multicast-accept list is initialized to accept-all, and we
597 rely on higher-level filtering for now. */
598 lp->rx_mode = RX_MULTCAST_ACCEPT;
599 }
600 else
601 lp->rx_mode = 0;
602
603 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
604
605 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
606 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
607 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
608}
609
610
611static int set_mac_address(struct net_device *dev, void *addr)
612{
613 int i;
614 if (dev->start)
615 return -EBUSY;
616 printk("%s: Setting MAC address to ", dev->name);
617 for (i = 0; i < 6; i++)
618 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
619 printk(".\n");
620 /* set the Ethernet address */
621 for (i=0; i < ETH_ALEN/2; i++)
622 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
623
624 return 0;
625}
626
627#ifdef MODULE
628
629static struct net_device *dev_cs89x0;
630static int debug;
631
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800632module_param(debug, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
634MODULE_LICENSE("GPL");
635
636int
637init_module(void)
638{
639 net_debug = debug;
640 dev_cs89x0 = mac89x0_probe(-1);
641 if (IS_ERR(dev_cs89x0)) {
642 printk(KERN_WARNING "mac89x0.c: No card found\n");
643 return PTR_ERR(dev_cs89x0);
644 }
645 return 0;
646}
647
648void
649cleanup_module(void)
650{
651 unregister_netdev(dev_cs89x0);
652 nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
653 free_netdev(dev_cs89x0);
654}
655#endif /* MODULE */
656
657/*
658 * Local variables:
659 * compile-command: "m68k-linux-gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -ffixed-a2 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h -c -o mac89x0.o mac89x0.c"
660 * version-control: t
661 * kept-new-versions: 5
662 * c-indent-level: 8
663 * tab-width: 8
664 * End:
665 *
666 */