[kernel] r8185 - dists/sid/linux-2.6/debian/patches
Christian T. Steigies
cts at alioth.debian.org
Sun Jan 14 23:38:38 CET 2007
Author: cts
Date: Sun Jan 14 23:38:38 2007
New Revision: 8185
Added:
dists/sid/linux-2.6/debian/patches/m68k-mac-adb.patch
dists/sid/linux-2.6/debian/patches/m68k-mac-mace-fix.patch
Log:
more mac fixes by Finn Thain
Added: dists/sid/linux-2.6/debian/patches/m68k-mac-adb.patch
==============================================================================
--- (empty file)
+++ dists/sid/linux-2.6/debian/patches/m68k-mac-adb.patch Sun Jan 14 23:38:38 2007
@@ -0,0 +1,870 @@
+
+Fix a crash caused by requests placed in the queue with the completed flag
+already set. This lead to some ADB_SYNC requests returning early and their
+request structs being popped off the stack while still queued. Stack
+corruption ensued or an invalid request callback pointer was invoked or
+both. Eliminate macii_retransmit() and its buggy reimplementation of
+macii_write(), and have macii_queue_poll() fully initialise the request
+queues.
+
+Fix a bug in macii_queue_poll() where the last_req pointer was not being
+set. This caused some requests to leave the queue before being completed
+(and would also corrupt the stack under certain conditions).
+
+Fix a race in macii_start that could set the state machine to "reading"
+while current_req was null.
+
+No longer send poll commands with the ADBREQ_REPLY flag -- doing that
+caused the replies to be stored in the request buffer where they were
+ignored and eventually lost.
+
+Don't autopoll by continuously sending new Talk commands. Get the
+controller to do that for us. This reduces the ADB interrupt rate on an
+idle bus to about 5 per second. Only autopoll the devices that were
+probed.
+
+Clear the interrupt flag when polling.
+
+Use disable_irq rather than local_irq_save when polling.
+
+Remove excess local_irq_save/restore pairs.
+
+Much better bus timeout and service request detection.
+
+Remove unused code (last_reply, adb_dir etc) and unneeded code
+(prefix_len, first_byte etc).
+
+Change TIP and TACK to their correct names on this ADB controller (ST_EVEN
+and ST_ODD).
+
+Add some commentry.
+
+Add a generous quantity of sanity checks (BUG_ONs).
+
+Let m68k macs use the adb_sync boot param too.
+
+Tested on Mac II, Mac IIci, Quadra 650 and Quadra 700.
+
+Signed-off-by: Finn Thain <fthain at telegraphics.com.au>
+
+
+ arch/m68k/kernel/setup.c | 10
+ drivers/macintosh/via-macii.c | 573 +++++++++++++++++-------------------------
+ 2 files changed, 248 insertions(+), 336 deletions(-)
+
+Index: linux-2.6.18/drivers/macintosh/via-macii.c
+===================================================================
+--- linux-2.6.18.orig/drivers/macintosh/via-macii.c 2007-01-11 20:39:49.000000000 +1100
++++ linux-2.6.18/drivers/macintosh/via-macii.c 2007-01-11 20:41:01.000000000 +1100
+@@ -12,6 +12,15 @@
+ * 1999-08-02 (jmt) - Initial rewrite for Unified ADB.
+ * 2000-03-29 Tony Mantler <tonym at mac.linux-m68k.org>
+ * - Big overhaul, should actually work now.
++ * 2006-12-31 Finn Thain <fthain at telegraphics.com.au> - Another overhaul.
++ *
++ * Suggested reading (FWIW):
++ * Inside Macintosh, ch. 5 ADB Manager
++ * Guide to the Macinstosh Family Hardware, ch. 8 Apple Desktop Bus
++ * Rockwell R6522 VIA datasheet
++ *
++ * Apple's "ADB Analyzer" bus sniffer is invaluable:
++ * ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/
+ */
+
+ #include <stdarg.h>
+@@ -27,7 +36,6 @@
+ #include <asm/macints.h>
+ #include <asm/machw.h>
+ #include <asm/mac_via.h>
+-#include <asm/io.h>
+ #include <asm/system.h>
+
+ static volatile unsigned char *via;
+@@ -53,8 +61,6 @@ static volatile unsigned char *via;
+
+ /* Bits in B data register: all active low */
+ #define TREQ 0x08 /* Transfer request (input) */
+-#define TACK 0x10 /* Transfer acknowledge (output) */
+-#define TIP 0x20 /* Transfer in progress (output) */
+ #define ST_MASK 0x30 /* mask for selecting ADB state bits */
+
+ /* Bits in ACR */
+@@ -66,8 +72,6 @@ static volatile unsigned char *via;
+ #define IER_SET 0x80 /* set bits in IER */
+ #define IER_CLR 0 /* clear bits in IER */
+ #define SR_INT 0x04 /* Shift register full/empty */
+-#define SR_DATA 0x08 /* Shift register data */
+-#define SR_CLOCK 0x10 /* Shift register clock */
+
+ /* ADB transaction states according to GMHW */
+ #define ST_CMD 0x00 /* ADB state: command byte */
+@@ -78,7 +82,6 @@ static volatile unsigned char *via;
+ static int macii_init_via(void);
+ static void macii_start(void);
+ static irqreturn_t macii_interrupt(int irq, void *arg, struct pt_regs *regs);
+-static void macii_retransmit(int);
+ static void macii_queue_poll(void);
+
+ static int macii_probe(void);
+@@ -107,26 +110,35 @@ static enum macii_state {
+ awaiting_reply
+ } macii_state;
+
+-static int need_poll = 0;
+-static int command_byte = 0;
+-static int last_reply = 0;
+-static int last_active = 0;
+-
+-static struct adb_request *current_req;
+-static struct adb_request *last_req;
+-static struct adb_request *retry_req;
+-static unsigned char reply_buf[16];
+-static unsigned char *reply_ptr;
+-static int reply_len;
+-static int reading_reply;
+-static int data_index;
+-static int first_byte;
+-static int prefix_len;
+-static int status = ST_IDLE|TREQ;
+-static int last_status;
+-static int driver_running = 0;
+-
+-/* debug level 10 required for ADB logging (should be && debug_adb, ideally) */
++static struct adb_request *current_req; /* first request struct in the queue */
++static struct adb_request *last_req; /* last request struct in the queue */
++static unsigned char reply_buf[16]; /* storage for autopolled replies */
++static unsigned char *reply_ptr; /* next byte in request data buffer or the static reply_buf */
++static int reading_reply; /* if zero store reply in reply_buf else in request reply buffer */
++static int data_index; /* index of the next byte to send from the request data buffer */
++static int reply_len; /* number of bytes received in reply_buf or request reply buffer */
++static int status; /* VIA's ADB status bits captured upon interrupt */
++static int last_status; /* status bits as at previous interrupt */
++static int srq_asserted; /* poll for the device that asserted a service request if true */
++static int command_byte; /* the most recent command byte transmitted */
++static int autopoll_devs; /* bits set are device addresses to be polled */
++
++/* Sanity check for request queue. Doesn't check for cycles. */
++static int request_is_queued(struct adb_request *req) {
++ struct adb_request *cur;
++ unsigned long flags;
++ local_irq_save(flags);
++ cur = current_req;
++ while (cur) {
++ if (cur == req) {
++ local_irq_restore(flags);
++ return 1;
++ }
++ cur = cur->next;
++ }
++ local_irq_restore(flags);
++ return 0;
++}
+
+ /* Check for MacII style ADB */
+ static int macii_probe(void)
+@@ -148,15 +160,16 @@ int macii_init(void)
+ local_irq_save(flags);
+
+ err = macii_init_via();
+- if (err) return err;
++ if (err) goto out;
+
+ err = request_irq(IRQ_MAC_ADB, macii_interrupt, IRQ_FLG_LOCK, "ADB",
+ macii_interrupt);
+- if (err) return err;
++ if (err) goto out;
+
+ macii_state = idle;
++out:
+ local_irq_restore(flags);
+- return 0;
++ return err;
+ }
+
+ /* initialize the hardware */
+@@ -164,8 +177,8 @@ static int macii_init_via(void)
+ {
+ unsigned char x;
+
+- /* Set the lines up. We want TREQ as input TACK|TIP as output */
+- via[DIRB] = (via[DIRB] | TACK | TIP) & ~TREQ;
++ /* Set the lines up. We want TREQ as input ST_EVEN | ST_ODD as output */
++ via[DIRB] = (via[DIRB] | ST_EVEN | ST_ODD) & ~TREQ;
+
+ /* Set up state: idle */
+ via[B] |= ST_IDLE;
+@@ -180,81 +193,73 @@ static int macii_init_via(void)
+ return 0;
+ }
+
+-/* Send an ADB poll (Talk Register 0 command, tagged on the front of the request queue) */
++/* Send an ADB poll (Talk Register 0 command, prepended to the request queue) */
+ static void macii_queue_poll(void)
+ {
+- static int device = 0;
+- static int in_poll=0;
++ /* No point polling the active device as it will never assert SRQ, so
++ * poll the next device in the autopoll list. This could leave us
++ * stuck in a polling loop if an unprobed device is asserting SRQ.
++ * In theory, that could only happen if a device was plugged in after
++ * probing started. Unplugging it again will break the cycle.
++ * (Simply polling the next higher device often ends up polling almost
++ * every device (after wrapping around), which takes too long.)
++ */
++ int device_mask;
++ int next_device;
+ static struct adb_request req;
+- unsigned long flags;
+-
+- if (in_poll) printk("macii_queue_poll: double poll!\n");
+
+- in_poll++;
+- if (++device > 15) device = 1;
+-
+- adb_request(&req, NULL, ADBREQ_REPLY|ADBREQ_NOSEND, 1,
+- ADB_READREG(device, 0));
+-
+- local_irq_save(flags);
++ if (!autopoll_devs) return;
+
++ device_mask = (1 << (((command_byte & 0xF0) >> 4) + 1)) - 1;
++ if (autopoll_devs & ~device_mask)
++ next_device = ffs(autopoll_devs & ~device_mask) - 1;
++ else
++ next_device = ffs(autopoll_devs) - 1;
++
++ BUG_ON(request_is_queued(&req));
++
++ adb_request(&req, NULL, ADBREQ_NOSEND, 1,
++ ADB_READREG(next_device, 0));
++
++ req.sent = 0;
++ req.complete = 0;
++ req.reply_len = 0;
+ req.next = current_req;
+- current_req = &req;
+-
+- local_irq_restore(flags);
+- macii_start();
+- in_poll--;
+-}
+-
+-/* Send an ADB retransmit (Talk, appended to the request queue) */
+-static void macii_retransmit(int device)
+-{
+- static int in_retransmit = 0;
+- static struct adb_request rt;
+- unsigned long flags;
+-
+- if (in_retransmit) printk("macii_retransmit: double retransmit!\n");
+-
+- in_retransmit++;
+-
+- adb_request(&rt, NULL, ADBREQ_REPLY|ADBREQ_NOSEND, 1,
+- ADB_READREG(device, 0));
+-
+- local_irq_save(flags);
+
+ if (current_req != NULL) {
+- last_req->next = &rt;
+- last_req = &rt;
++ current_req = &req;
+ } else {
+- current_req = &rt;
+- last_req = &rt;
++ current_req = &req;
++ last_req = &req;
+ }
+-
+- if (macii_state == idle) macii_start();
+-
+- local_irq_restore(flags);
+- in_retransmit--;
+ }
+
+ /* Send an ADB request; if sync, poll out the reply 'till it's done */
+ static int macii_send_request(struct adb_request *req, int sync)
+ {
+- int i;
++ int err;
++ unsigned long flags;
++
++ BUG_ON(request_is_queued(req));
+
+- i = macii_write(req);
+- if (i) return i;
++ local_irq_save(flags);
++ err = macii_write(req);
+
+- if (sync) {
+- while (!req->complete) macii_poll();
++ if (!err && sync) {
++ while (!req->complete) {
++ BUG_ON(!request_is_queued(req));
++ macii_poll();
++ }
++ BUG_ON(request_is_queued(req));
+ }
+- return 0;
++
++ local_irq_restore(flags);
++ return err;
+ }
+
+-/* Send an ADB request */
++/* Send an ADB request (append to request queue) */
+ static int macii_write(struct adb_request *req)
+ {
+- unsigned long flags;
+-
+ if (req->nbytes < 2 || req->data[0] != ADB_PACKET || req->nbytes > 15) {
+ req->complete = 1;
+ return -EINVAL;
+@@ -265,8 +270,6 @@ static int macii_write(struct adb_reques
+ req->complete = 0;
+ req->reply_len = 0;
+
+- local_irq_save(flags);
+-
+ if (current_req != NULL) {
+ last_req->next = req;
+ last_req = req;
+@@ -275,28 +278,52 @@ static int macii_write(struct adb_reques
+ last_req = req;
+ if (macii_state == idle) macii_start();
+ }
+-
+- local_irq_restore(flags);
+ return 0;
+ }
+
+ /* Start auto-polling */
+ static int macii_autopoll(int devs)
+ {
+- /* Just ping a random default address */
+- if (!(current_req || retry_req))
+- macii_retransmit( (last_active < 16 && last_active > 0) ? last_active : 3);
+- return 0;
++ static struct adb_request req;
++ unsigned long flags;
++ int err = 0;
++
++ /* bit 1 == device 1, and so on. */
++ autopoll_devs = devs & 0xFFFE;
++
++ if (!autopoll_devs) return 0;
++
++ local_irq_save(flags);
++
++ if (current_req == NULL) {
++ /* Send a Talk Reg 0. The controller will repeatedly transmit
++ * this as long as it is idle.
++ */
++ adb_request(&req, NULL, ADBREQ_NOSEND, 1,
++ ADB_READREG(ffs(autopoll_devs) - 1, 0));
++ err = macii_write(&req);
++ }
++
++ local_irq_restore(flags);
++ return err;
++}
++
++static inline int need_autopoll(void) {
++ /* Was the last command Talk Reg 0
++ * and is the target on the autopoll list?
++ */
++ if ((command_byte & 0x0F) == 0x0C &&
++ ((1 << ((command_byte & 0xF0) >> 4)) & autopoll_devs))
++ return 0;
++ return 1;
+ }
+
+ /* Prod the chip without interrupts */
+ static void macii_poll(void)
+ {
+- unsigned long flags;
+-
+- local_irq_save(flags);
+- if (via[IFR] & SR_INT) macii_interrupt(0, NULL, NULL);
+- local_irq_restore(flags);
++ disable_irq(IRQ_MAC_ADB);
++ macii_interrupt(0, NULL, NULL);
++ enable_irq(IRQ_MAC_ADB);
+ }
+
+ /* Reset the bus */
+@@ -304,73 +331,34 @@ static int macii_reset_bus(void)
+ {
+ static struct adb_request req;
+
++ if (request_is_queued(&req))
++ return 0;
++
+ /* Command = 0, Address = ignored */
+ adb_request(&req, NULL, 0, 1, ADB_BUSRESET);
+
++ /* Don't want any more requests during the Global Reset low time. */
++ udelay(3000);
++
+ return 0;
+ }
+
+ /* Start sending ADB packet */
+ static void macii_start(void)
+ {
+- unsigned long flags;
+ struct adb_request *req;
+
+ req = current_req;
+- if (!req) return;
+-
+- /* assert macii_state == idle */
+- if (macii_state != idle) {
+- printk("macii_start: called while driver busy (%p %x %x)!\n",
+- req, macii_state, (uint) via1[B] & (ST_MASK|TREQ));
+- return;
+- }
+
+- local_irq_save(flags);
+-
+- /*
+- * IRQ signaled ?? (means ADB controller wants to send, or might
+- * be end of packet if we were reading)
+- */
+-#if 0 /* FIXME: This is broke broke broke, for some reason */
+- if ((via[B] & TREQ) == 0) {
+- printk("macii_start: weird poll stuff. huh?\n");
+- /*
+- * FIXME - we need to restart this on a timer
+- * or a collision at boot hangs us.
+- * Never set macii_state to idle here, or macii_start
+- * won't be called again from send_request!
+- * (need to re-check other cases ...)
+- */
+- /*
+- * if the interrupt handler set the need_poll
+- * flag, it's hopefully a SRQ poll or re-Talk
+- * so we try to send here anyway
+- */
+- if (!need_poll) {
+- if (console_loglevel == 10)
+- printk("macii_start: device busy - retry %p state %d status %x!\n",
+- req, macii_state,
+- (uint) via[B] & (ST_MASK|TREQ));
+- retry_req = req;
+- /* set ADB status here ? */
+- local_irq_restore(flags);
+- return;
+- } else {
+- need_poll = 0;
+- }
+- }
+-#endif
+- /*
+- * Another retry pending? (sanity check)
++ BUG_ON(req == NULL);
++
++ BUG_ON(macii_state != idle);
++
++ /* Now send it. Be careful though, that first byte of the request
++ * is actually ADB_PACKET; the real data begins at index 1!
++ * And req->nbytes is the number of bytes of real data plus one.
+ */
+- if (retry_req) {
+- retry_req = NULL;
+- }
+
+- /* Now send it. Be careful though, that first byte of the request */
+- /* is actually ADB_PACKET; the real data begins at index 1! */
+-
+ /* store command byte */
+ command_byte = req->data[1];
+ /* Output mode */
+@@ -382,115 +370,99 @@ static void macii_start(void)
+
+ macii_state = sending;
+ data_index = 2;
+-
+- local_irq_restore(flags);
+ }
+
+ /*
+- * The notorious ADB interrupt handler - does all of the protocol handling,
+- * except for starting new send operations. Relies heavily on the ADB
+- * controller sending and receiving data, thereby generating SR interrupts
+- * for us. This means there has to be always activity on the ADB bus, otherwise
+- * the whole process dies and has to be re-kicked by sending TALK requests ...
+- * CUDA-based Macs seem to solve this with the autopoll option, for MacII-type
+- * ADB the problem isn't solved yet (retransmit of the latest active TALK seems
+- * a good choice; either on timeout or on a timer interrupt).
++ * The notorious ADB interrupt handler - does all of the protocol handling.
++ * Relies on the ADB controller sending and receiving data, thereby
++ * generating shift register (SR) interrupts for us. This means there has
++ * to be activity on the ADB bus. The chip will poll to achieve this.
+ *
+ * The basic ADB state machine was left unchanged from the original MacII code
+ * by Alan Cox, which was based on the CUDA driver for PowerMac.
+- * The syntax of the ADB status lines seems to be totally different on MacII,
+- * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle for
+- * sending, and Idle -> Even -> Odd -> Even ->...-> Idle for receiving. Start
+- * and end of a receive packet are signaled by asserting /IRQ on the interrupt
+- * line. Timeouts are signaled by a sequence of 4 0xFF, with /IRQ asserted on
+- * every other byte. SRQ is probably signaled by 3 or more 0xFF tacked on the
+- * end of a packet. (Thanks to Guido Koerber for eavesdropping on the ADB
+- * protocol with a logic analyzer!!)
+- *
+- * Note: As of 21/10/97, the MacII ADB part works including timeout detection
+- * and retransmit (Talk to the last active device).
++ * The syntax of the ADB status lines seems to be totally different on MacII,
++ * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle
++ * for sending and Idle -> Even -> Odd -> Even ->...-> Idle for receiving. Start
++ * and end of a receive packet are signalled by asserting /IRQ on the interrupt
++ * line (meaning the TREQ bit in port B, not the SR interrupt).
+ */
+ static irqreturn_t macii_interrupt(int irq, void *arg, struct pt_regs *regs)
+ {
+- int x, adbdir;
+- unsigned long flags;
++ int x;
++ static int entered;
+ struct adb_request *req;
+
+- last_status = status;
+-
+- /* prevent races due to SCSI enabling ints */
+- local_irq_save(flags);
+-
+- if (driver_running) {
+- local_irq_restore(flags);
+- return IRQ_NONE;
++ if (!arg) {
++ /* Clear the SR IRQ flag when polling. */
++ if (via[IFR] & SR_INT)
++ via[IFR] = SR_INT;
++ else
++ return IRQ_NONE;
+ }
+
+- driver_running = 1;
+-
++ BUG_ON(entered++);
++
++ last_status = status;
+ status = via[B] & (ST_MASK|TREQ);
+- adbdir = via[ACR] & SR_OUT;
+
+ switch (macii_state) {
+ case idle:
+- x = via[SR];
+- first_byte = x;
+- /* set ADB state = even for first data byte */
+- via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+-
+- reply_buf[0] = first_byte; /* was command_byte?? */
+- reply_ptr = reply_buf + 1;
+- reply_len = 1;
+- prefix_len = 1;
++ BUG_ON(current_req != NULL);
++ reply_ptr = reply_buf;
+ reading_reply = 0;
+-
+- macii_state = reading;
+- break;
++ /* fall through */
+
+ case awaiting_reply:
+- /* handshake etc. for II ?? */
+ x = via[SR];
+- first_byte = x;
+- /* set ADB state = even for first data byte */
+- via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+
+- current_req->reply[0] = first_byte;
+- reply_ptr = current_req->reply + 1;
+- reply_len = 1;
+- prefix_len = 1;
+- reading_reply = 1;
++ if ((status & TREQ) && (x == 0xFF)) {
++ /* Bus timeout without SRQ sequence:
++ * data is "FF" while TREQ is "H"
++ */
++ reply_len = 0;
++ srq_asserted = 0;
++ macii_state = read_done;
++ } else {
++ macii_state = reading;
++ *reply_ptr = x;
++ reply_len = 1;
++ }
+
+- macii_state = reading;
++ /* set ADB state = even for first data byte */
++ via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+ break;
+
+ case sending:
+ req = current_req;
+ if (data_index >= req->nbytes) {
+- /* print an error message if a listen command has no data */
+- if (((command_byte & 0x0C) == 0x08)
+- /* && (console_loglevel == 10) */
+- && (data_index == 2))
+- printk("MacII ADB: listen command with no data: %x!\n",
+- command_byte);
+- /* reset to shift in */
+- via[ACR] &= ~SR_OUT;
+- x = via[SR];
+- /* set ADB state idle - might get SRQ */
+- via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
+-
+ req->sent = 1;
+
+ if (req->reply_expected) {
+ macii_state = awaiting_reply;
++ reply_ptr = req->reply;
++ reading_reply = 1;
+ } else {
++ macii_state = idle;
++ reply_ptr = reply_buf;
++ reading_reply = 0;
++
+ req->complete = 1;
+ current_req = req->next;
+ if (req->done) (*req->done)(req);
+- macii_state = idle;
+- if (current_req || retry_req)
++
++ if (current_req)
+ macii_start();
+ else
+- macii_retransmit((command_byte & 0xF0) >> 4);
++ if (need_autopoll())
++ macii_autopoll(autopoll_devs);
++ }
++
++ if (macii_state != sending) {
++ /* reset to shift in */
++ via[ACR] &= ~SR_OUT;
++ x = via[SR];
++ /* set ADB state idle - might get SRQ */
++ via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
+ }
+ } else {
+ via[SR] = req->data[data_index++];
+@@ -506,148 +478,78 @@ static irqreturn_t macii_interrupt(int i
+ break;
+
+ case reading:
++ x = via[SR];
++ BUG_ON((status & ST_MASK) == ST_CMD ||
++ (status & ST_MASK) == ST_IDLE);
+
+- /* timeout / SRQ handling for II hw */
+- if( (first_byte == 0xFF && (reply_len-prefix_len)==2
+- && memcmp(reply_ptr-2,"\xFF\xFF",2)==0) ||
+- ((reply_len-prefix_len)==3
+- && memcmp(reply_ptr-3,"\xFF\xFF\xFF",3)==0))
+- {
+- /*
+- * possible timeout (in fact, most probably a
+- * timeout, since SRQ can't be signaled without
+- * transfer on the bus).
+- * The last three bytes seen were FF, together
+- * with the starting byte (in case we started
+- * on 'idle' or 'awaiting_reply') this probably
+- * makes four. So this is mostl likely #5!
+- * The timeout signal is a pattern 1 0 1 0 0..
+- * on /INT, meaning we missed it :-(
+- */
+- x = via[SR];
+- if (x != 0xFF) printk("MacII ADB: mistaken timeout/SRQ!\n");
++ /* Bus timeout with SRQ sequence:
++ * data is "XX FF" while TREQ is "L L"
++ * End of packet without SRQ sequence:
++ * data is "XX...YY 00" while TREQ is "L...H L"
++ * End of packet SRQ sequence:
++ * data is "XX...YY 00" while TREQ is "L...L L"
++ * (where XX is the first response byte and
++ * YY is the last byte of valid response data.)
++ */
+
+- if ((status & TREQ) == (last_status & TREQ)) {
+- /* Not a timeout. Unsolicited SRQ? weird. */
+- /* Terminate the SRQ packet and poll */
+- need_poll = 1;
++ srq_asserted = 0;
++ if (!(status & TREQ)) {
++ if (x == 0xFF) {
++ if (!(last_status & TREQ)) {
++ macii_state = read_done;
++ reply_len = 0;
++ srq_asserted = 1;
++ }
++ } else if (x == 0x00) {
++ macii_state = read_done;
++ if (!(last_status & TREQ))
++ srq_asserted = 1;
+ }
+- /* There's no packet to get, so reply is blank */
+- via[B] ^= ST_MASK;
+- reply_ptr -= (reply_len-prefix_len);
+- reply_len = prefix_len;
+- macii_state = read_done;
+- break;
+- } /* end timeout / SRQ handling for II hw. */
++ }
+
+- if((reply_len-prefix_len)>3
+- && memcmp(reply_ptr-3,"\xFF\xFF\xFF",3)==0)
+- {
+- /* SRQ tacked on data packet */
+- /* Terminate the packet (SRQ never ends) */
+- x = via[SR];
+- macii_state = read_done;
+- reply_len -= 3;
+- reply_ptr -= 3;
+- need_poll = 1;
+- /* need to continue; next byte not seen else */
+- } else {
+- /* Sanity check */
+- if (reply_len > 15) reply_len = 0;
+- /* read byte */
+- x = via[SR];
+- *reply_ptr = x;
++ if (macii_state == reading) {
++ BUG_ON(reply_len > 15);
+ reply_ptr++;
++ *reply_ptr = x;
+ reply_len++;
+ }
+- /* The usual handshake ... */
+
+- /*
+- * NetBSD hints that the next to last byte
+- * is sent with IRQ !!
+- * Guido found out it's the last one (0x0),
+- * but IRQ should be asserted already.
+- * Problem with timeout detection: First
+- * transition to /IRQ might be second
+- * byte of timeout packet!
+- * Timeouts are signaled by 4x FF.
+- */
+- if (((status & TREQ) == 0) && (x == 0x00)) { /* != 0xFF */
+- /* invert state bits, toggle ODD/EVEN */
+- via[B] ^= ST_MASK;
+-
+- /* adjust packet length */
+- reply_len--;
+- reply_ptr--;
+- macii_state = read_done;
+- } else {
+- /* not caught: ST_CMD */
+- /* required for re-entry 'reading'! */
+- if ((status & ST_MASK) == ST_IDLE) {
+- /* (in)sanity check - set even */
+- via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+- } else {
+- /* invert state bits */
+- via[B] ^= ST_MASK;
+- }
+- }
++ /* invert state bits, toggle ODD/EVEN */
++ via[B] ^= ST_MASK;
+ break;
+
+ case read_done:
+ x = via[SR];
++
+ if (reading_reply) {
+ req = current_req;
+- req->reply_len = reply_ptr - req->reply;
++ req->reply_len = reply_len;
+ req->complete = 1;
+ current_req = req->next;
+ if (req->done) (*req->done)(req);
+- } else {
+- adb_input(reply_buf, reply_ptr - reply_buf,
+- regs, 0);
+- }
++ } else if (reply_len && autopoll_devs)
++ adb_input(reply_buf, reply_len, regs, 0);
+
+- /*
+- * remember this device ID; it's the latest we got a
+- * reply from!
+- */
+- last_reply = command_byte;
+- last_active = (command_byte & 0xF0) >> 4;
++ macii_state = idle;
+
+ /* SRQ seen before, initiate poll now */
+- if (need_poll) {
+- macii_state = idle;
++ if (srq_asserted)
+ macii_queue_poll();
+- need_poll = 0;
+- break;
+- }
+-
+- /* set ADB state to idle */
+- via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
+-
+- /* /IRQ seen, so the ADB controller has data for us */
+- if ((via[B] & TREQ) != 0) {
+- macii_state = reading;
+
+- reply_buf[0] = command_byte;
+- reply_ptr = reply_buf + 1;
+- reply_len = 1;
+- prefix_len = 1;
+- reading_reply = 0;
+- } else {
+- /* no IRQ, send next packet or wait */
+- macii_state = idle;
+- if (current_req)
+- macii_start();
+- else
+- macii_retransmit(last_active);
+- }
++ if (current_req)
++ macii_start();
++ else
++ if (need_autopoll())
++ macii_autopoll(autopoll_devs);
++
++ if (macii_state == idle)
++ via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
+ break;
+
+ default:
+ break;
+ }
+- /* reset mutex and interrupts */
+- driver_running = 0;
+- local_irq_restore(flags);
++
++ entered--;
+ return IRQ_HANDLED;
+ }
+Index: linux-2.6.18/arch/m68k/kernel/setup.c
+===================================================================
+--- linux-2.6.18.orig/arch/m68k/kernel/setup.c 2007-01-11 20:39:49.000000000 +1100
++++ linux-2.6.18/arch/m68k/kernel/setup.c 2007-01-11 20:41:01.000000000 +1100
+@@ -513,3 +513,13 @@ void check_bugs(void)
+ }
+ #endif /* !CONFIG_M68KFPU_EMU */
+ }
++
++#ifdef CONFIG_ADB
++static int __init adb_probe_sync_enable (char *str) {
++ extern int __adb_probe_sync;
++ __adb_probe_sync = 1;
++ return 1;
++}
++
++__setup("adb_sync", adb_probe_sync_enable);
++#endif /* CONFIG_ADB */
+-
+To unsubscribe from this list: send the line "unsubscribe linux-m68k" in
+the body of a message to majordomo at vger.kernel.org
+More majordomo info at http://vger.kernel.org/majordomo-info.html
Added: dists/sid/linux-2.6/debian/patches/m68k-mac-mace-fix.patch
==============================================================================
--- (empty file)
+++ dists/sid/linux-2.6/debian/patches/m68k-mac-mace-fix.patch Sun Jan 14 23:38:38 2007
@@ -0,0 +1,516 @@
+Fix a race condition in the transmit code, where the dma interrupt could
+update the free tx buffer count concurrently and wedge the tx queue.
+
+Fix the misuse of the rx frame status and rx frame length registers: no
+more "fifo overrun" errors caused by the OFLOW bit being tested in the
+frame length register, and no more missed packets due to incorrect length
+taken from status register.
+
+Fix a panic (skb_over_panic BUG) caused by allocating and then copying an
+incoming packet while the packet length register was changing.
+
+Cut-and-paste the reset code from the powermac mace driver (mace.c), so
+the NIC functions when MacOS does not initialise it (important for anyone
+wanting to use the Emile boot loader).
+
+Cut-and-paste the error counting and timeout recovery code from mace.c.
+
+Fix a race condition in the PSC interrupt dispatch code where the
+interrupt flag was cleared after the handler ran (same bug that was fixed
+recently in the VIA2 interrupt dispatcher).
+
+Fix over allocation of rx buffer memory (page order, not page count).
+
+Converted to driver model.
+
+Converted to DMA API.
+
+Since I've run out of ways to make it fail, and since it performs well
+now, promote the driver from EXPERIMENTAL status. Tested on both quadra
+840av and 660av.
+
+Signed-off-by: Finn Thain <fthain at telegraphics.com.au>
+
+diff -urN linux-2.6.18.orig/drivers/net/macmace.c linux-2.6.18/drivers/net/macmace.c
+--- linux-2.6.18.orig/drivers/net/macmace.c 2007-01-14 21:24:25.000000000 +0100
++++ linux-2.6.18/drivers/net/macmace.c 2007-01-14 21:20:15.000000000 +0100
+@@ -22,8 +22,9 @@
+ #include <linux/delay.h>
+ #include <linux/string.h>
+ #include <linux/crc32.h>
++#include <linux/dma-mapping.h>
++#include <linux/platform_device.h>
+ #include <asm/io.h>
+-#include <asm/pgtable.h>
+ #include <asm/irq.h>
+ #include <asm/macintosh.h>
+ #include <asm/macints.h>
+@@ -31,16 +32,23 @@
+ #include <asm/page.h>
+ #include "mace.h"
+
+-#define N_TX_RING 1
+-#define N_RX_RING 8
+-#define N_RX_PAGES ((N_RX_RING * 0x0800 + PAGE_SIZE - 1) / PAGE_SIZE)
++static char mac_mace_string[] = "macmace";
++static struct platform_device *mac_mace_device;
++
++#define N_TX_BUFF_ORDER 0
++#define N_TX_RING (1 << N_TX_BUFF_ORDER)
++#define N_RX_BUFF_ORDER 3
++#define N_RX_RING (1 << N_RX_BUFF_ORDER)
++
+ #define TX_TIMEOUT HZ
+
+ /* Chip rev needs workaround on HW & multicast addr change */
+ #define BROKEN_ADDRCHG_REV 0x0941
+
+-/* Bits in transmit DMA status */
+-#define TX_DMA_ERR 0x80
++#define MACE_BUFF_SIZE 0x800
++
++/* Chip rev needs workaround on HW & multicast addr change */
++#define BROKEN_ADDRCHG_REV 0x0941
+
+ /* The MACE is simply wired down on a Mac68K box */
+
+@@ -49,15 +57,16 @@
+
+ struct mace_data {
+ volatile struct mace *mace;
+- volatile unsigned char *tx_ring;
+- volatile unsigned char *tx_ring_phys;
+- volatile unsigned char *rx_ring;
+- volatile unsigned char *rx_ring_phys;
++ unsigned char *tx_ring;
++ dma_addr_t tx_ring_phys;
++ unsigned char *rx_ring;
++ dma_addr_t rx_ring_phys;
+ int dma_intr;
+ struct net_device_stats stats;
+ int rx_slot, rx_tail;
+ int tx_slot, tx_sloti, tx_count;
+ int chipid;
++ struct device *device;
+ };
+
+ struct mace_frame {
+@@ -77,8 +86,6 @@
+
+ #define PRIV_BYTES sizeof(struct mace_data)
+
+-extern void psc_debug_dump(void);
+-
+ static int mace_open(struct net_device *dev);
+ static int mace_close(struct net_device *dev);
+ static int mace_xmit_start(struct sk_buff *skb, struct net_device *dev);
+@@ -93,7 +100,7 @@
+
+ /* Bit-reverse one byte of an ethernet hardware address. */
+
+-static int bitrev(int b)
++static inline int bitrev(int b)
+ {
+ int d = 0, i;
+
+@@ -110,8 +117,8 @@
+
+ static void mace_load_rxdma_base(struct net_device *dev, int set)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
+-
++ struct mace_data *mp = netdev_priv(dev);
++
+ psc_write_word(PSC_ENETRD_CMD + set, 0x0100);
+ psc_write_long(PSC_ENETRD_ADDR + set, (u32) mp->rx_ring_phys);
+ psc_write_long(PSC_ENETRD_LEN + set, N_RX_RING);
+@@ -125,7 +132,7 @@
+
+ static void mace_rxdma_reset(struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mace = mp->mace;
+ u8 maccc = mace->maccc;
+
+@@ -152,7 +159,7 @@
+
+ static void mace_txdma_reset(struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mace = mp->mace;
+ u8 maccc;
+
+@@ -190,7 +197,7 @@
+ * model of Macintrash has a MACE (AV macintoshes)
+ */
+
+-struct net_device *mace_probe(int unit)
++static int __devinit mace_probe(struct platform_device *pdev)
+ {
+ int j;
+ struct mace_data *mp;
+@@ -201,18 +208,20 @@
+ int err;
+
+ if (found || macintosh_config->ether_type != MAC_ETHER_MACE)
+- return ERR_PTR(-ENODEV);
++ return -ENODEV;
+
+ found = 1; /* prevent 'finding' one on every device probe */
+
+ dev = alloc_etherdev(PRIV_BYTES);
+ if (!dev)
+- return ERR_PTR(-ENOMEM);
++ return -ENOMEM;
+
+- if (unit >= 0)
+- sprintf(dev->name, "eth%d", unit);
++ mp = netdev_priv(dev);
++
++ mp->device = &pdev->dev;
++ SET_NETDEV_DEV(dev, &pdev->dev);
++ SET_MODULE_OWNER(dev);
+
+- mp = (struct mace_data *) dev->priv;
+ dev->base_addr = (u32)MACE_BASE;
+ mp->mace = (volatile struct mace *) MACE_BASE;
+
+@@ -241,7 +250,7 @@
+
+ if (checksum != 0xFF) {
+ free_netdev(dev);
+- return ERR_PTR(-ENODEV);
++ return -ENODEV;
+ }
+
+ memset(&mp->stats, 0, sizeof(mp->stats));
+@@ -261,10 +270,10 @@
+
+ err = register_netdev(dev);
+ if (!err)
+- return dev;
++ return 0;
+
+ free_netdev(dev);
+- return ERR_PTR(err);
++ return err;
+ }
+
+ /*
+@@ -298,7 +307,8 @@
+
+ mb->biucc = XMTSP_64;
+ mb->utr = RTRD;
+- mb->fifocc = XMTFW_16 | RCVFW_64 | XMTFWU | RCVFWU | XMTBRST | RCVBRST;
++ mb->fifocc = XMTFW_8 | RCVFW_64 | XMTFWU | RCVFWU;
++
+ mb->xmtfc = AUTO_PAD_XMIT; /* auto-pad short frames */
+ mb->rcvfc = 0;
+
+@@ -330,7 +340,7 @@
+
+ static void __mace_set_address(struct net_device *dev, void *addr)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mb = mp->mace;
+ unsigned char *p = addr;
+ int i;
+@@ -377,7 +387,7 @@
+
+ static int mace_open(struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mb = mp->mace;
+
+ /* reset the chip */
+@@ -395,26 +405,22 @@
+
+ /* Allocate the DMA ring buffers */
+
+- mp->rx_ring = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, N_RX_PAGES);
+- mp->tx_ring = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, 0);
+-
+- if (mp->tx_ring==NULL || mp->rx_ring==NULL) {
+- if (mp->rx_ring) free_pages((u32) mp->rx_ring, N_RX_PAGES);
+- if (mp->tx_ring) free_pages((u32) mp->tx_ring, 0);
+- free_irq(dev->irq, dev);
+- free_irq(mp->dma_intr, dev);
+- printk(KERN_ERR "%s: unable to allocate DMA buffers\n", dev->name);
+- return -ENOMEM;
++ mp->tx_ring = dma_alloc_coherent(mp->device,
++ N_TX_RING * MACE_BUFF_SIZE,
++ &mp->tx_ring_phys, GFP_KERNEL);
++ if (mp->tx_ring == NULL) {
++ printk(KERN_ERR "%s: unable to allocate DMA tx buffers\n", dev->name);
++ goto out1;
++ }
++
++ mp->rx_ring = dma_alloc_coherent(mp->device,
++ N_RX_RING * MACE_BUFF_SIZE,
++ &mp->rx_ring_phys, GFP_KERNEL);
++ if (mp->rx_ring == NULL) {
++ printk(KERN_ERR "%s: unable to allocate DMA rx buffers\n", dev->name);
++ goto out2;
+ }
+-
+- mp->rx_ring_phys = (unsigned char *) virt_to_bus((void *)mp->rx_ring);
+- mp->tx_ring_phys = (unsigned char *) virt_to_bus((void *)mp->tx_ring);
+-
+- /* We want the Rx buffer to be uncached and the Tx buffer to be writethrough */
+-
+- kernel_set_cachemode((void *)mp->rx_ring, N_RX_PAGES * PAGE_SIZE, IOMAP_NOCACHE_NONSER);
+- kernel_set_cachemode((void *)mp->tx_ring, PAGE_SIZE, IOMAP_WRITETHROUGH);
+-
++
+ mace_dma_off(dev);
+
+ /* Not sure what these do */
+@@ -433,6 +439,14 @@
+ mb->imr = RCVINT;
+
+ return 0;
++
++out2:
++ dma_free_coherent(mp->device, N_TX_RING * MACE_BUFF_SIZE,
++ mp->tx_ring, mp->tx_ring_phys);
++out1:
++ free_irq(dev->irq, dev);
++ free_irq(mp->dma_intr, dev);
++ return -ENOMEM;
+ }
+
+ /*
+@@ -441,19 +455,13 @@
+
+ static int mace_close(struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mb = mp->mace;
+
+ mb->maccc = 0; /* disable rx and tx */
+ mb->imr = 0xFF; /* disable all irqs */
+ mace_dma_off(dev); /* disable rx and tx dma */
+
+- free_irq(dev->irq, dev);
+- free_irq(IRQ_MAC_MACE_DMA, dev);
+-
+- free_pages((u32) mp->rx_ring, N_RX_PAGES);
+- free_pages((u32) mp->tx_ring, 0);
+-
+ return 0;
+ }
+
+@@ -463,17 +471,17 @@
+
+ static int mace_xmit_start(struct sk_buff *skb, struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ unsigned long flags;
+
+- /* Stop the queue if the buffer is full */
++ /* Stop the queue since there's only the one buffer */
+
+ local_irq_save(flags);
++ netif_stop_queue(dev);
+ if (!mp->tx_count) {
+- netif_stop_queue(dev);
++ printk(KERN_ERR "macmace: tx queue running but no free buffers.\n");
+ local_irq_restore(flags);
+ return NETDEV_TX_BUSY;
+-
+ }
+ mp->tx_count--;
+ local_irq_restore(flags);
+@@ -494,19 +502,20 @@
+ mp->tx_slot ^= 0x10;
+
+ dev_kfree_skb(skb);
+-
+- return 0;
++
++ dev->trans_start = jiffies;
++ return NETDEV_TX_OK;
+ }
+
+ static struct net_device_stats *mace_stats(struct net_device *dev)
+ {
+- struct mace_data *p = (struct mace_data *) dev->priv;
+- return &p->stats;
++ struct mace_data *mp = netdev_priv(dev);
++ return &mp->stats;
+ }
+
+ static void mace_set_multicast(struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mb = mp->mace;
+ int i, j;
+ u32 crc;
+@@ -592,15 +601,15 @@
+ intr = mb->ir; /* read interrupt register */
+ mace_handle_misc_intrs(mp, intr);
+
+- if (mb->pr & XMTSV) {
+- fs = mb->xmtfs;
+- if ((fs & XMTSV) == 0) {
+- printk(KERN_ERR "macmace: xmtfs not valid! (fs=%x)\n", fs);
+- mace_reset(dev);
+- /*
+- * XXX mace likes to hang the machine after a xmtfs error.
+- * This is hard to reproduce, reseting *may* help
+- */
++ if (intr & XMTINT) {
++ fs = mb->xmtfs;
++ if ((fs & XMTSV) == 0) {
++ printk(KERN_ERR "macmace: xmtfs not valid! (fs=%x)\n", fs);
++ mace_reset(dev);
++ /*
++ * XXX mace likes to hang the machine after a xmtfs error.
++ * This is hard to reproduce, reseting *may* help
++ */
+ }
+ /* dma should have finished */
+ if (!mp->tx_count) {
+@@ -636,7 +645,7 @@
+
+ static void mace_tx_timeout(struct net_device *dev)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ volatile struct mace *mb = mp->mace;
+ unsigned long flags;
+
+@@ -668,7 +677,7 @@
+
+ static void mace_dma_rx_frame(struct net_device *dev, struct mace_frame *mf)
+ {
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ struct sk_buff *skb;
+ unsigned int frame_status = mf->rcvsts;
+
+@@ -712,7 +721,7 @@
+ static irqreturn_t mace_dma_intr(int irq, void *dev_id, struct pt_regs *regs)
+ {
+ struct net_device *dev = (struct net_device *) dev_id;
+- struct mace_data *mp = (struct mace_data *) dev->priv;
++ struct mace_data *mp = netdev_priv(dev);
+ int left, head;
+ u16 status;
+ u32 baka;
+@@ -739,7 +748,8 @@
+ /* Loop through the ring buffer and process new packages */
+
+ while (mp->rx_tail < head) {
+- mace_dma_rx_frame(dev, (struct mace_frame *) (mp->rx_ring + (mp->rx_tail * 0x0800)));
++ mace_dma_rx_frame(dev, (struct mace_frame *) (mp->rx_ring +
++ (mp->rx_tail * MACE_BUFF_SIZE)));
+ mp->rx_tail++;
+ }
+
+@@ -766,9 +776,76 @@
+ psc_write_word(PSC_ENETWR_CMD + mp->tx_sloti, 0x0100);
+ mp->tx_sloti ^= 0x10;
+ mp->tx_count++;
+- netif_wake_queue(dev);
+ }
+ return IRQ_HANDLED;
+ }
+
+ MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("Macintosh MACE ethernet driver");
++
++static int __devexit mac_mace_device_remove (struct platform_device *pdev)
++{
++ struct net_device *dev = platform_get_drvdata(pdev);
++ struct mace_data *mp = netdev_priv(dev);
++
++ unregister_netdev(dev);
++
++ free_irq(dev->irq, dev);
++ free_irq(IRQ_MAC_MACE_DMA, dev);
++
++ dma_free_coherent(mp->device, N_RX_RING * MACE_BUFF_SIZE,
++ mp->rx_ring, mp->rx_ring_phys);
++ dma_free_coherent(mp->device, N_TX_RING * MACE_BUFF_SIZE,
++ mp->tx_ring, mp->tx_ring_phys);
++
++ free_netdev(dev);
++
++ return 0;
++}
++
++static struct platform_driver mac_mace_driver = {
++ .probe = mace_probe,
++ .remove = __devexit_p(mac_mace_device_remove),
++ .driver = {
++ .name = mac_mace_string,
++ },
++};
++
++static int __init mac_mace_init_module(void)
++{
++ int err;
++
++ if ((err = platform_driver_register(&mac_mace_driver))) {
++ printk(KERN_ERR "Driver registration failed\n");
++ return err;
++ }
++
++ mac_mace_device = platform_device_alloc(mac_mace_string, 0);
++ if (!mac_mace_device)
++ goto out_unregister;
++
++ if (platform_device_add(mac_mace_device)) {
++ platform_device_put(mac_mace_device);
++ mac_mace_device = NULL;
++ }
++
++ return 0;
++
++out_unregister:
++ platform_driver_unregister(&mac_mace_driver);
++
++ return -ENOMEM;
++}
++
++static void __exit mac_mace_cleanup_module(void)
++{
++ platform_driver_unregister(&mac_mace_driver);
++
++ if (mac_mace_device) {
++ platform_device_unregister(mac_mace_device);
++ mac_mace_device = NULL;
++ }
++ }
++
++module_init(mac_mace_init_module);
++module_exit(mac_mace_cleanup_module);
+diff -urN linux-2.6.18.orig/drivers/net/Space.c linux-2.6.18/drivers/net/Space.c
+--- linux-2.6.18.orig/drivers/net/Space.c 2007-01-14 21:24:24.000000000 +0100
++++ linux-2.6.18/drivers/net/Space.c 2007-01-14 21:21:07.000000000 +0100
+@@ -87,7 +87,6 @@
+ extern struct net_device *mvme147lance_probe(int unit);
+ extern struct net_device *tc515_probe(int unit);
+ extern struct net_device *lance_probe(int unit);
+-extern struct net_device *mace_probe(int unit);
+ extern struct net_device *mac8390_probe(int unit);
+ extern struct net_device *mac89x0_probe(int unit);
+ extern struct net_device *mc32_probe(int unit);
+@@ -287,9 +286,6 @@
+ #ifdef CONFIG_MVME147_NET /* MVME147 internal Ethernet */
+ {mvme147lance_probe, 0},
+ #endif
+-#ifdef CONFIG_MACMACE /* Mac 68k Quadra AV builtin Ethernet */
+- {mace_probe, 0},
+-#endif
+ #ifdef CONFIG_MAC8390 /* NuBus NS8390-based cards */
+ {mac8390_probe, 0},
+ #endif
More information about the Kernel-svn-changes
mailing list