v2.4.9.2 -> v2.4.9.3
[opensuse:kernel.git] / drivers / net / macsonic.c
1 /*
2  * macsonic.c
3  *
4  * (C) 1998 Alan Cox
5  *
6  * Debugging Andreas Ehliar, Michael Schmitz
7  *
8  * Based on code
9  * (C) 1996 by Thomas Bogendoerfer (tsbogend@bigbug.franken.de)
10  * 
11  * This driver is based on work from Andreas Busse, but most of
12  * the code is rewritten.
13  * 
14  * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
15  *
16  * A driver for the Mac onboard Sonic ethernet chip.
17  *
18  * 98/12/21 MSch: judged from tests on Q800, it's basically working, 
19  *                but eating up both receive and transmit resources
20  *                and duplicating packets. Needs more testing.
21  *
22  * 99/01/03 MSch: upgraded to version 0.92 of the core driver, fixed.
23  */
24
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/types.h>
28 #include <linux/ctype.h>
29 #include <linux/fcntl.h>
30 #include <linux/interrupt.h>
31 #include <linux/ptrace.h>
32 #include <linux/init.h>
33 #include <linux/ioport.h>
34 #include <linux/in.h>
35 #include <linux/slab.h>
36 #include <linux/string.h>
37 #include <linux/delay.h>
38 #include <linux/nubus.h>
39 #include <asm/bootinfo.h>
40 #include <asm/system.h>
41 #include <asm/bitops.h>
42 #include <asm/pgtable.h>
43 #include <asm/segment.h>
44 #include <asm/io.h>
45 #include <asm/hwtest.h>
46 #include <asm/dma.h>
47 #include <asm/macintosh.h>
48 #include <asm/macints.h>
49 #include <asm/mac_via.h>
50
51 #include <linux/errno.h>
52
53 #include <linux/netdevice.h>
54 #include <linux/etherdevice.h>
55 #include <linux/skbuff.h>
56 #include <linux/module.h>
57
58 #define SREGS_PAD(n)    u16 n;
59
60 #include "sonic.h"
61
62 static int sonic_debug;
63 static int sonic_version_printed;
64
65 extern int macsonic_probe(struct net_device* dev);
66 extern int mac_onboard_sonic_probe(struct net_device* dev);
67 extern int mac_nubus_sonic_probe(struct net_device* dev);
68
69 /* For onboard SONIC */
70 #define ONBOARD_SONIC_REGISTERS 0x50F0A000
71 #define ONBOARD_SONIC_PROM_BASE 0x50f08000
72
73 enum macsonic_type {
74         MACSONIC_DUODOCK,
75         MACSONIC_APPLE,
76         MACSONIC_APPLE16,
77         MACSONIC_DAYNA,
78         MACSONIC_DAYNALINK
79 };
80
81 /* For the built-in SONIC in the Duo Dock */
82 #define DUODOCK_SONIC_REGISTERS 0xe10000
83 #define DUODOCK_SONIC_PROM_BASE 0xe12000
84
85 /* For Apple-style NuBus SONIC */
86 #define APPLE_SONIC_REGISTERS   0
87 #define APPLE_SONIC_PROM_BASE   0x40000
88
89 /* Daynalink LC SONIC */
90 #define DAYNALINK_PROM_BASE 0x400000
91
92 /* For Dayna-style NuBus SONIC (haven't seen one yet) */
93 #define DAYNA_SONIC_REGISTERS   0x180000
94 /* This is what OpenBSD says.  However, this is definitely in NuBus
95    ROM space so we should be able to get it by walking the NuBus
96    resource directories */
97 #define DAYNA_SONIC_MAC_ADDR    0xffe004
98
99 #define SONIC_READ_PROM(addr) readb(prom_addr+addr)
100
101 int __init macsonic_probe(struct net_device* dev)
102 {
103         int rv;
104
105         /* This will catch fatal stuff like -ENOMEM as well as success */
106         if ((rv = mac_onboard_sonic_probe(dev)) != -ENODEV)
107                 return rv;
108         return mac_nubus_sonic_probe(dev);
109 }
110
111 /*
112  * For reversing the PROM address
113  */
114
115 static unsigned char nibbletab[] = {0, 8, 4, 12, 2, 10, 6, 14,
116                                     1, 9, 5, 13, 3, 11, 7, 15};
117
118 static inline void bit_reverse_addr(unsigned char addr[6])
119 {
120         int i;
121
122         for(i = 0; i < 6; i++)
123                 addr[i] = ((nibbletab[addr[i] & 0xf] << 4) | 
124                            nibbletab[(addr[i] >> 4) &0xf]);
125 }
126
127 int __init macsonic_init(struct net_device* dev)
128 {
129         struct sonic_local* lp = (struct sonic_local *)dev->priv;
130         int i;
131
132         /* Allocate the entire chunk of memory for the descriptors.
133            Note that this cannot cross a 64K boundary. */
134         for (i = 0; i < 20; i++) {
135                 unsigned long desc_base, desc_top;
136                 if ((lp->sonic_desc = 
137                      kmalloc(SIZEOF_SONIC_DESC
138                              * SONIC_BUS_SCALE(lp->dma_bitmode), GFP_KERNEL | GFP_DMA)) == NULL) {
139                         printk(KERN_ERR "%s: couldn't allocate descriptor buffers\n", dev->name);
140                         return -ENOMEM;
141                 }
142                 desc_base = (unsigned long) lp->sonic_desc;
143                 desc_top = desc_base + SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode);
144                 if ((desc_top & 0xffff) >= (desc_base & 0xffff))
145                         break;
146                 /* Hmm. try again (FIXME: does this actually work?) */
147                 kfree(lp->sonic_desc);
148                 printk(KERN_DEBUG
149                        "%s: didn't get continguous chunk [%08lx - %08lx], trying again\n",
150                        dev->name, desc_base, desc_top);
151         }
152
153         if (lp->sonic_desc == NULL) {
154                 printk(KERN_ERR "%s: tried 20 times to allocate descriptor buffers, giving up.\n",
155                        dev->name);
156                 return -ENOMEM;
157         }                      
158
159         /* Now set up the pointers to point to the appropriate places */
160         lp->cda = lp->sonic_desc;
161         lp->tda = lp->cda + (SIZEOF_SONIC_CDA * SONIC_BUS_SCALE(lp->dma_bitmode));
162         lp->rda = lp->tda + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
163                              * SONIC_BUS_SCALE(lp->dma_bitmode));
164         lp->rra = lp->rda + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
165                              * SONIC_BUS_SCALE(lp->dma_bitmode));
166
167         /* FIXME, maybe we should use skbs */
168         if ((lp->rba = (char *)
169              kmalloc(SONIC_NUM_RRS * SONIC_RBSIZE, GFP_KERNEL | GFP_DMA)) == NULL) {
170                 printk(KERN_ERR "%s: couldn't allocate receive buffers\n", dev->name);
171                 return -ENOMEM;
172         }
173
174         {
175                 int rs, ds;
176
177                 /* almost always 12*4096, but let's not take chances */
178                 rs = ((SONIC_NUM_RRS * SONIC_RBSIZE + 4095) / 4096) * 4096;
179                 /* almost always under a page, but let's not take chances */
180                 ds = ((SIZEOF_SONIC_DESC + 4095) / 4096) * 4096;
181                 kernel_set_cachemode(lp->rba, rs, IOMAP_NOCACHE_SER);
182                 kernel_set_cachemode(lp->sonic_desc, ds, IOMAP_NOCACHE_SER);
183         }
184         
185 #if 0
186         flush_cache_all();
187 #endif
188
189         dev->open = sonic_open;
190         dev->stop = sonic_close;
191         dev->hard_start_xmit = sonic_send_packet;
192         dev->get_stats = sonic_get_stats;
193         dev->set_multicast_list = &sonic_multicast_list;
194
195         /*
196          * clear tally counter
197          */
198         sonic_write(dev, SONIC_CRCT, 0xffff);
199         sonic_write(dev, SONIC_FAET, 0xffff);
200         sonic_write(dev, SONIC_MPT, 0xffff);
201
202         /* Fill in the fields of the device structure with ethernet values. */
203         ether_setup(dev);
204         return 0;
205 }
206
207 int __init mac_onboard_sonic_ethernet_addr(struct net_device* dev)
208 {
209         const int prom_addr = ONBOARD_SONIC_PROM_BASE;
210         int i;
211
212         /* On NuBus boards we can sometimes look in the ROM resources.
213            No such luck for comm-slot/onboard. */
214         for(i = 0; i < 6; i++)
215                 dev->dev_addr[i] = SONIC_READ_PROM(i);
216
217         /* Most of the time, the address is bit-reversed.  The NetBSD
218            source has a rather long and detailed historical account of
219            why this is so. */
220         if (memcmp(dev->dev_addr, "\x08\x00\x07", 3) &&
221             memcmp(dev->dev_addr, "\x00\xA0\x40", 3) &&
222             memcmp(dev->dev_addr, "\x00\x05\x02", 3))
223                 bit_reverse_addr(dev->dev_addr);
224         else
225                 return 0;
226
227         /* If we still have what seems to be a bogus address, we'll
228            look in the CAM.  The top entry should be ours. */
229         /* Danger! This only works if MacOS has already initialized
230            the card... */
231         if (memcmp(dev->dev_addr, "\x08\x00\x07", 3) &&
232             memcmp(dev->dev_addr, "\x00\xA0\x40", 3) &&
233             memcmp(dev->dev_addr, "\x00\x05\x02", 3))
234         {
235                 unsigned short val;
236
237                 printk(KERN_INFO "macsonic: PROM seems to be wrong, trying CAM entry 15\n");
238                 
239                 sonic_write(dev, SONIC_CMD, SONIC_CR_RST);
240                 sonic_write(dev, SONIC_CEP, 15);
241
242                 val = sonic_read(dev, SONIC_CAP2);
243                 dev->dev_addr[5] = val >> 8;
244                 dev->dev_addr[4] = val & 0xff;
245                 val = sonic_read(dev, SONIC_CAP1);
246                 dev->dev_addr[3] = val >> 8;
247                 dev->dev_addr[2] = val & 0xff;
248                 val = sonic_read(dev, SONIC_CAP0);
249                 dev->dev_addr[1] = val >> 8;
250                 dev->dev_addr[0] = val & 0xff;
251                 
252                 printk(KERN_INFO "HW Address from CAM 15: ");
253                 for (i = 0; i < 6; i++) {
254                         printk("%2.2x", dev->dev_addr[i]);
255                         if (i < 5)
256                                 printk(":");
257                 }
258                 printk("\n");
259         } else return 0;
260
261         if (memcmp(dev->dev_addr, "\x08\x00\x07", 3) &&
262             memcmp(dev->dev_addr, "\x00\xA0\x40", 3) &&
263             memcmp(dev->dev_addr, "\x00\x05\x02", 3))
264         {
265                 /*
266                  * Still nonsense ... messed up someplace!
267                  */
268                 printk(KERN_ERR "macsonic: ERROR (INVALID MAC)\n");
269                 return -EIO;
270         } else return 0;
271 }
272
273 int __init mac_onboard_sonic_probe(struct net_device* dev)
274 {
275         /* Bwahahaha */
276         static int once_is_more_than_enough;
277         struct sonic_local* lp;
278         int i;
279         
280         if (once_is_more_than_enough)
281                 return -ENODEV;
282         once_is_more_than_enough = 1;
283
284         if (!MACH_IS_MAC)
285                 return -ENODEV;
286
287         printk(KERN_INFO "Checking for internal Macintosh ethernet (SONIC).. ");
288
289         if (macintosh_config->ether_type != MAC_ETHER_SONIC)
290         {
291                 printk("none.\n");
292                 return -ENODEV;
293         }
294
295         /* Bogus probing, on the models which may or may not have
296            Ethernet (BTW, the Ethernet *is* always at the same
297            address, and nothing else lives there, at least if Apple's
298            documentation is to be believed) */
299         if (macintosh_config->ident == MAC_MODEL_Q630 ||
300             macintosh_config->ident == MAC_MODEL_P588 ||
301             macintosh_config->ident == MAC_MODEL_C610) {
302                 unsigned long flags;
303                 int card_present;
304
305                 save_flags(flags);
306                 cli();
307                 card_present = hwreg_present((void*)ONBOARD_SONIC_REGISTERS);
308                 restore_flags(flags);
309
310                 if (!card_present) {
311                         printk("none.\n");
312                         return -ENODEV;
313                 }
314         }
315
316         printk("yes\n");        
317
318         if (dev) {
319                 dev = init_etherdev(dev, sizeof(struct sonic_local));
320                 if (!dev)
321                         return -ENOMEM;
322                 /* methinks this will always be true but better safe than sorry */
323                 if (dev->priv == NULL) {
324                         dev->priv = kmalloc(sizeof(struct sonic_local), GFP_KERNEL);
325                         if (!dev->priv) /* FIXME: kfree dev if necessary */
326                                 return -ENOMEM;
327                 }
328         } else {
329                 dev = init_etherdev(NULL, sizeof(struct sonic_local));
330         }
331
332         if (dev == NULL)
333                 return -ENOMEM;
334
335         lp = (struct sonic_local*) dev->priv;
336         memset(lp, 0, sizeof(struct sonic_local));
337         /* Danger!  My arms are flailing wildly!  You *must* set this
338            before using sonic_read() */
339
340         dev->base_addr = ONBOARD_SONIC_REGISTERS;
341         if (via_alt_mapping)
342                 dev->irq = IRQ_AUTO_3;
343         else
344                 dev->irq = IRQ_NUBUS_9;
345
346         if (!sonic_version_printed) {
347                 printk(KERN_INFO "%s", version);
348                 sonic_version_printed = 1;
349         }
350         printk(KERN_INFO "%s: onboard / comm-slot SONIC at 0x%08lx\n",
351                dev->name, dev->base_addr);
352
353         /* Now do a song and dance routine in an attempt to determine
354            the bus width */
355
356         /* The PowerBook's SONIC is 16 bit always. */
357         if (macintosh_config->ident == MAC_MODEL_PB520) {
358                 lp->reg_offset = 0;
359                 lp->dma_bitmode = 0;
360         } else {
361                 /* Some of the comm-slot cards are 16 bit.  But some
362                    of them are not.  The 32-bit cards use offset 2 and
363                    pad with zeroes or sometimes ones (I think...)
364                    Therefore, if we try offset 0 and get a silicon
365                    revision of 0, we assume 16 bit. */
366                 int sr;
367
368                 /* Technically this is not necessary since we zeroed
369                    it above */
370                 lp->reg_offset = 0;
371                 lp->dma_bitmode = 0;
372                 sr = sonic_read(dev, SONIC_SR);
373                 if (sr == 0 || sr == 0xffff) {
374                         lp->reg_offset = 2;
375                         /* 83932 is 0x0004, 83934 is 0x0100 or 0x0101 */
376                         sr = sonic_read(dev, SONIC_SR);
377                         lp->dma_bitmode = 1;
378                         
379                 }
380                 printk(KERN_INFO
381                        "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
382                        dev->name, sr, lp->dma_bitmode?32:16, lp->reg_offset);
383         }
384
385
386         /* Software reset, then initialize control registers. */
387         sonic_write(dev, SONIC_CMD, SONIC_CR_RST);
388         sonic_write(dev, SONIC_DCR, SONIC_DCR_BMS |
389                     SONIC_DCR_RFT1 | SONIC_DCR_TFT0 | SONIC_DCR_EXBUS |
390                     (lp->dma_bitmode ? SONIC_DCR_DW : 0));
391         /* This *must* be written back to in order to restore the
392            extended programmable output bits */
393         sonic_write(dev, SONIC_DCR2, 0);
394
395         /* Clear *and* disable interrupts to be on the safe side */
396         sonic_write(dev, SONIC_ISR,0x7fff);
397         sonic_write(dev, SONIC_IMR,0);
398
399         /* Now look for the MAC address. */
400         if (mac_onboard_sonic_ethernet_addr(dev) != 0)
401                 return -ENODEV;
402
403         printk(KERN_INFO "MAC ");
404         for (i = 0; i < 6; i++) {
405                 printk("%2.2x", dev->dev_addr[i]);
406                 if (i < 5)
407                         printk(":");
408         }
409
410         printk(" IRQ %d\n", dev->irq);
411
412         /* Shared init code */
413         return macsonic_init(dev);
414 }
415
416 int __init mac_nubus_sonic_ethernet_addr(struct net_device* dev,
417                                          unsigned long prom_addr,
418                                          int id)
419 {
420         int i;
421         for(i = 0; i < 6; i++)
422                 dev->dev_addr[i] = SONIC_READ_PROM(i);
423         /* For now we are going to assume that they're all bit-reversed */
424         bit_reverse_addr(dev->dev_addr);
425
426         return 0;
427 }
428
429 int __init macsonic_ident(struct nubus_dev* ndev)
430 {
431         if (ndev->dr_hw == NUBUS_DRHW_ASANTE_LC && 
432             ndev->dr_sw == NUBUS_DRSW_SONIC_LC)
433                 return MACSONIC_DAYNALINK;
434         if (ndev->dr_hw == NUBUS_DRHW_SONIC &&
435             ndev->dr_sw == NUBUS_DRSW_APPLE) {
436                 /* There has to be a better way to do this... */
437                 if (strstr(ndev->board->name, "DuoDock"))
438                         return MACSONIC_DUODOCK;
439                 else
440                         return MACSONIC_APPLE;
441         }
442         return -1;
443 }
444
445 int __init mac_nubus_sonic_probe(struct net_device* dev)
446 {
447         static int slots;
448         struct nubus_dev* ndev = NULL;
449         struct sonic_local* lp;
450         unsigned long base_addr, prom_addr;
451         u16 sonic_dcr;
452         int id;
453         int i;
454         int reg_offset, dma_bitmode;
455
456         /* Find the first SONIC that hasn't been initialized already */
457         while ((ndev = nubus_find_type(NUBUS_CAT_NETWORK,
458                                        NUBUS_TYPE_ETHERNET, ndev)) != NULL)
459         {
460                 /* Have we seen it already? */
461                 if (slots & (1<<ndev->board->slot))
462                         continue;
463                 slots |= 1<<ndev->board->slot;
464
465                 /* Is it one of ours? */
466                 if ((id = macsonic_ident(ndev)) != -1)
467                         break;
468         }
469
470         if (ndev == NULL)
471                 return -ENODEV;
472
473         switch (id) {
474         case MACSONIC_DUODOCK:
475                 base_addr = ndev->board->slot_addr + DUODOCK_SONIC_REGISTERS;
476                 prom_addr = ndev->board->slot_addr + DUODOCK_SONIC_PROM_BASE;
477                 sonic_dcr = SONIC_DCR_EXBUS | SONIC_DCR_RFT0 | SONIC_DCR_RFT1
478                         | SONIC_DCR_TFT0;
479                 reg_offset = 2;
480                 dma_bitmode = 1;
481                 break;
482         case MACSONIC_APPLE:
483                 base_addr = ndev->board->slot_addr + APPLE_SONIC_REGISTERS;
484                 prom_addr = ndev->board->slot_addr + APPLE_SONIC_PROM_BASE;
485                 sonic_dcr = SONIC_DCR_BMS | SONIC_DCR_RFT1 | SONIC_DCR_TFT0;
486                 reg_offset = 0;
487                 dma_bitmode = 1;
488                 break;
489         case MACSONIC_APPLE16:
490                 base_addr = ndev->board->slot_addr + APPLE_SONIC_REGISTERS;
491                 prom_addr = ndev->board->slot_addr + APPLE_SONIC_PROM_BASE;
492                 sonic_dcr = SONIC_DCR_EXBUS
493                         | SONIC_DCR_RFT1 | SONIC_DCR_TFT0
494                         | SONIC_DCR_PO1 | SONIC_DCR_BMS; 
495                 reg_offset = 0;
496                 dma_bitmode = 0;
497                 break;
498         case MACSONIC_DAYNALINK:
499                 base_addr = ndev->board->slot_addr + APPLE_SONIC_REGISTERS;
500                 prom_addr = ndev->board->slot_addr + DAYNALINK_PROM_BASE;
501                 sonic_dcr = SONIC_DCR_RFT1 | SONIC_DCR_TFT0
502                         | SONIC_DCR_PO1 | SONIC_DCR_BMS; 
503                 reg_offset = 0;
504                 dma_bitmode = 0;
505                 break;
506         case MACSONIC_DAYNA:
507                 base_addr = ndev->board->slot_addr + DAYNA_SONIC_REGISTERS;
508                 prom_addr = ndev->board->slot_addr + DAYNA_SONIC_MAC_ADDR;
509                 sonic_dcr = SONIC_DCR_BMS
510                         | SONIC_DCR_RFT1 | SONIC_DCR_TFT0 | SONIC_DCR_PO1;
511                 reg_offset = 0;
512                 dma_bitmode = 0;
513                 break;
514         default:
515                 printk(KERN_ERR "macsonic: WTF, id is %d\n", id);
516                 return -ENODEV;
517         }
518
519         if (dev) {
520                 dev = init_etherdev(dev, sizeof(struct sonic_local));
521                 /* methinks this will always be true but better safe than sorry */
522                 if (dev->priv == NULL)
523                         dev->priv = kmalloc(sizeof(struct sonic_local), GFP_KERNEL);
524         } else {
525                 dev = init_etherdev(NULL, sizeof(struct sonic_local));
526         }
527
528         if (dev == NULL)
529                 return -ENOMEM;
530
531         lp = (struct sonic_local*) dev->priv;
532         memset(lp, 0, sizeof(struct sonic_local));
533         /* Danger!  My arms are flailing wildly!  You *must* set this
534            before using sonic_read() */
535         lp->reg_offset = reg_offset;
536         lp->dma_bitmode = dma_bitmode;
537         dev->base_addr = base_addr;
538         dev->irq = SLOT2IRQ(ndev->board->slot);
539
540         if (!sonic_version_printed) {
541                 printk(KERN_INFO "%s", version);
542                 sonic_version_printed = 1;
543         }
544         printk(KERN_INFO "%s: %s in slot %X\n",
545                dev->name, ndev->board->name, ndev->board->slot);
546         printk(KERN_INFO "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
547                dev->name, sonic_read(dev, SONIC_SR), dma_bitmode?32:16, reg_offset);
548
549         /* Software reset, then initialize control registers. */
550         sonic_write(dev, SONIC_CMD, SONIC_CR_RST);
551         sonic_write(dev, SONIC_DCR, sonic_dcr
552                     | (dma_bitmode ? SONIC_DCR_DW : 0));
553
554         /* Clear *and* disable interrupts to be on the safe side */
555         sonic_write(dev, SONIC_ISR,0x7fff);
556         sonic_write(dev, SONIC_IMR,0);
557
558         /* Now look for the MAC address. */
559         if (mac_nubus_sonic_ethernet_addr(dev, prom_addr, id) != 0)
560                 return -ENODEV;
561
562         printk(KERN_INFO "MAC ");
563         for (i = 0; i < 6; i++) {
564                 printk("%2.2x", dev->dev_addr[i]);
565                 if (i < 5)
566                         printk(":");
567         }
568         printk(" IRQ %d\n", dev->irq);
569
570         /* Shared init code */
571         return macsonic_init(dev);
572 }
573
574 #ifdef MODULE
575 static char namespace[16] = "";
576 static struct net_device dev_macsonic;
577
578 MODULE_PARM(sonic_debug, "i");
579 MODULE_PARM_DESC(sonic_debug, "macsonic debug level (1-4)");
580
581 EXPORT_NO_SYMBOLS;
582
583 int
584 init_module(void)
585 {
586         dev_macsonic.name = namespace;
587         dev_macsonic.init = macsonic_probe;
588
589         if (register_netdev(&dev_macsonic) != 0) {
590                 printk(KERN_WARNING "macsonic.c: No card found\n");
591                 return -ENXIO;
592         }
593         return 0;
594 }
595
596 void
597 cleanup_module(void)
598 {
599         if (dev_macsonic.priv != NULL) {
600                 unregister_netdev(&dev_macsonic);
601                 kfree(dev_macsonic.priv);
602                 dev_macsonic.priv = NULL;
603         }
604 }
605 #endif /* MODULE */
606
607
608 #define vdma_alloc(foo, bar) ((u32)foo)
609 #define vdma_free(baz)
610 #define sonic_chiptomem(bat) (bat)
611 #define PHYSADDR(quux) (quux)
612
613 #include "sonic.c"
614
615 /*
616  * Local variables:
617  *  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 macsonic.o macsonic.c"
618  *  version-control: t
619  *  kept-new-versions: 5
620  *  c-indent-level: 8
621  *  tab-width: 8
622  * End:
623  *
624  */