AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-24 12:00:58 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

macintosh/via-macii, macintosh/adb-iop: Clean up whitespace

Browse Source 
Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
This commit is contained in:
Finn Thain 2018-09-11 20:18:44 -04:00 committed by Michael Ellerman
parent 351e5ad327
commit 47fd206066
2 changed files with 179 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
drivers/macintosh/adb-iop.c
View File

@ -20,13 +20,13 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <asm/macintosh.h> #include <asm/macintosh.h>
#include <asm/macints.h> #include <asm/macints.h>
#include <asm/mac_iop.h> #include <asm/mac_iop.h>
#include <asm/mac_oss.h> #include <asm/mac_oss.h>
#include <asm/adb_iop.h> #include <asm/adb_iop.h>
#include <linux/adb.h> #include <linux/adb.h>
/*#define DEBUG_ADB_IOP*/ /*#define DEBUG_ADB_IOP*/
@ -38,9 +38,9 @@ static unsigned char *reply_ptr;
#endif #endif
static enum adb_iop_state { static enum adb_iop_state {
idle, idle,
sending, sending,
awaiting_reply awaiting_reply
} adb_iop_state; } adb_iop_state;
static void adb_iop_start(void); static void adb_iop_start(void);
@ -66,7 +66,8 @@ static void adb_iop_end_req(struct adb_request *req, int state)
{ {
req->complete = 1; req->complete = 1;
current_req = req->next; current_req = req->next;
if (req->done) (*req->done)(req); if (req->done)
(*req->done)(req);
adb_iop_state = state; adb_iop_state = state;
} }
@ -100,7 +101,7 @@ static void adb_iop_complete(struct iop_msg *msg)
static void adb_iop_listen(struct iop_msg *msg) static void adb_iop_listen(struct iop_msg *msg)
{ {
struct adb_iopmsg *amsg = (struct adb_iopmsg *) msg->message; struct adb_iopmsg *amsg = (struct adb_iopmsg *)msg->message;
struct adb_request *req; struct adb_request *req;
unsigned long flags; unsigned long flags;
#ifdef DEBUG_ADB_IOP #ifdef DEBUG_ADB_IOP
@ -113,9 +114,9 @@ static void adb_iop_listen(struct iop_msg *msg)
#ifdef DEBUG_ADB_IOP #ifdef DEBUG_ADB_IOP
printk("adb_iop_listen %p: rcvd packet, %d bytes: %02X %02X", req, printk("adb_iop_listen %p: rcvd packet, %d bytes: %02X %02X", req,
(uint) amsg->count + 2, (uint) amsg->flags, (uint) amsg->cmd); (uint)amsg->count + 2, (uint)amsg->flags, (uint)amsg->cmd);
for (i = 0; i < amsg->count; i++) for (i = 0; i < amsg->count; i++)
printk(" %02X", (uint) amsg->data[i]); printk(" %02X", (uint)amsg->data[i]);
printk("\n"); printk("\n");
#endif #endif
@ -168,14 +169,15 @@ static void adb_iop_start(void)
/* get the packet to send */ /* get the packet to send */
req = current_req; req = current_req;
if (!req) return; if (!req)
return;
local_irq_save(flags); local_irq_save(flags);
#ifdef DEBUG_ADB_IOP #ifdef DEBUG_ADB_IOP
printk("adb_iop_start %p: sending packet, %d bytes:", req, req->nbytes); printk("adb_iop_start %p: sending packet, %d bytes:", req, req->nbytes);
for (i = 0 ; i < req->nbytes ; i++) for (i = 0; i < req->nbytes; i++)
printk(" %02X", (uint) req->data[i]); printk(" %02X", (uint)req->data[i]);
printk("\n"); printk("\n");
#endif #endif
@ -196,13 +198,14 @@ static void adb_iop_start(void)
/* Now send it. The IOP manager will call adb_iop_complete */ /* Now send it. The IOP manager will call adb_iop_complete */
/* when the packet has been sent. */ /* when the packet has been sent. */
iop_send_message(ADB_IOP, ADB_CHAN, req, iop_send_message(ADB_IOP, ADB_CHAN, req, sizeof(amsg), (__u8 *)&amsg,
sizeof(amsg), (__u8 *) &amsg, adb_iop_complete); adb_iop_complete);
} }
int adb_iop_probe(void) int adb_iop_probe(void)
{ {
if (!iop_ism_present) return -ENODEV; if (!iop_ism_present)
return -ENODEV;
return 0; return 0;
} }
@ -218,10 +221,12 @@ int adb_iop_send_request(struct adb_request *req, int sync)
int err; int err;
err = adb_iop_write(req); err = adb_iop_write(req);
if (err) return err; if (err)
return err;
if (sync) { if (sync) {
while (!req->complete) adb_iop_poll(); while (!req->complete)
adb_iop_poll();
} }
return 0; return 0;
} }
@ -251,7 +256,9 @@ static int adb_iop_write(struct adb_request *req)
} }
local_irq_restore(flags); local_irq_restore(flags);
if (adb_iop_state == idle) adb_iop_start();
if (adb_iop_state == idle)
adb_iop_start();
return 0; return 0;
} }
@ -263,7 +270,8 @@ int adb_iop_autopoll(int devs)
void adb_iop_poll(void) void adb_iop_poll(void)
{ {
if (adb_iop_state == idle) adb_iop_start(); if (adb_iop_state == idle)
adb_iop_start();
iop_ism_irq_poll(ADB_IOP); iop_ism_irq_poll(ADB_IOP);
} }

296
drivers/macintosh/via-macii.c
View File

@ -12,7 +12,7 @@
* *
* 1999-08-02 (jmt) - Initial rewrite for Unified ADB. * 1999-08-02 (jmt) - Initial rewrite for Unified ADB.
* 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org> * 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org>
* - Big overhaul, should actually work now. * - Big overhaul, should actually work now.
* 2006-12-31 Finn Thain - Another overhaul. * 2006-12-31 Finn Thain - Another overhaul.
* *
* Suggested reading: * Suggested reading:
@ -23,7 +23,7 @@
* Apple's "ADB Analyzer" bus sniffer is invaluable: * Apple's "ADB Analyzer" bus sniffer is invaluable:
* ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/ * ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/
*/ */
#include <stdarg.h> #include <stdarg.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/errno.h> #include <linux/errno.h>
@ -77,7 +77,7 @@ static volatile unsigned char *via;
#define ST_ODD 0x20 /* ADB state: odd data byte */ #define ST_ODD 0x20 /* ADB state: odd data byte */
#define ST_IDLE 0x30 /* ADB state: idle, nothing to send */ #define ST_IDLE 0x30 /* ADB state: idle, nothing to send */
static int macii_init_via(void); static int macii_init_via(void);
static void macii_start(void); static void macii_start(void);
static irqreturn_t macii_interrupt(int irq, void *arg); static irqreturn_t macii_interrupt(int irq, void *arg);
static void macii_queue_poll(void); static void macii_queue_poll(void);
@ -123,7 +123,8 @@ static int autopoll_devs; /* bits set are device addresses to be polled */
/* Check for MacII style ADB */ /* Check for MacII style ADB */
static int macii_probe(void) static int macii_probe(void)
{ {
if (macintosh_config->adb_type != MAC_ADB_II) return -ENODEV; if (macintosh_config->adb_type != MAC_ADB_II)
return -ENODEV;
via = via1; via = via1;
@ -136,15 +137,17 @@ int macii_init(void)
{ {
unsigned long flags; unsigned long flags;
int err; int err;
local_irq_save(flags); local_irq_save(flags);
err = macii_init_via(); err = macii_init_via();
if (err) goto out; if (err)
goto out;
err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB", err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB",
macii_interrupt); macii_interrupt);
if (err) goto out; if (err)
goto out;
macii_state = idle; macii_state = idle;
out: out:
@ -152,7 +155,7 @@ int macii_init(void)
return err; return err;
} }
/* initialize the hardware */ /* initialize the hardware */
static int macii_init_via(void) static int macii_init_via(void)
{ {
unsigned char x; unsigned char x;
@ -162,7 +165,7 @@ static int macii_init_via(void)
/* Set up state: idle */ /* Set up state: idle */
via[B] |= ST_IDLE; via[B] |= ST_IDLE;
last_status = via[B] & (ST_MASK|CTLR_IRQ); last_status = via[B] & (ST_MASK | CTLR_IRQ);
/* Shift register on input */ /* Shift register on input */
via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT; via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT;
@ -188,7 +191,8 @@ static void macii_queue_poll(void)
int next_device; int next_device;
static struct adb_request req; static struct adb_request req;
if (!autopoll_devs) return; if (!autopoll_devs)
return;
device_mask = (1 << (((command_byte & 0xF0) >> 4) + 1)) - 1; device_mask = (1 << (((command_byte & 0xF0) >> 4) + 1)) - 1;
if (autopoll_devs & ~device_mask) if (autopoll_devs & ~device_mask)
@ -196,8 +200,7 @@ static void macii_queue_poll(void)
else else
next_device = ffs(autopoll_devs) - 1; next_device = ffs(autopoll_devs) - 1;
adb_request(&req, NULL, ADBREQ_NOSEND, 1, adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_READREG(next_device, 0));
ADB_READREG(next_device, 0));
req.sent = 0; req.sent = 0;
req.complete = 0; req.complete = 0;
@ -237,7 +240,7 @@ static int macii_write(struct adb_request *req)
req->complete = 1; req->complete = 1;
return -EINVAL; return -EINVAL;
} }
req->next = NULL; req->next = NULL;
req->sent = 0; req->sent = 0;
req->complete = 0; req->complete = 0;
@ -251,7 +254,8 @@ static int macii_write(struct adb_request *req)
} else { } else {
current_req = req; current_req = req;
last_req = req; last_req = req;
if (macii_state == idle) macii_start(); if (macii_state == idle)
macii_start();
} }
local_irq_restore(flags); local_irq_restore(flags);
@ -269,7 +273,8 @@ static int macii_autopoll(int devs)
/* bit 1 == device 1, and so on. */ /* bit 1 == device 1, and so on. */
autopoll_devs = devs & 0xFFFE; autopoll_devs = devs & 0xFFFE;
if (!autopoll_devs) return 0; if (!autopoll_devs)
return 0;
local_irq_save(flags); local_irq_save(flags);
@ -286,7 +291,8 @@ static int macii_autopoll(int devs)
return err; return err;
} }
static inline int need_autopoll(void) { static inline int need_autopoll(void)
{
/* Was the last command Talk Reg 0 /* Was the last command Talk Reg 0
* and is the target on the autopoll list? * and is the target on the autopoll list?
*/ */
@ -306,7 +312,7 @@ static void macii_poll(void)
static int macii_reset_bus(void) static int macii_reset_bus(void)
{ {
static struct adb_request req; static struct adb_request req;
/* Command = 0, Address = ignored */ /* Command = 0, Address = ignored */
adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_BUSRESET); adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_BUSRESET);
macii_send_request(&req, 1); macii_send_request(&req, 1);
@ -349,7 +355,7 @@ static void macii_start(void)
* to be activity on the ADB bus. The chip will poll to achieve this. * 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 * 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. * by Alan Cox, which was based on the CUDA driver for PowerMac.
* The syntax of the ADB status lines is totally different on MacII, * The syntax of the ADB status lines is totally different on MacII,
* though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle
* for sending and Idle -> Even -> Odd -> Even ->...-> Idle for receiving. * for sending and Idle -> Even -> Odd -> Even ->...-> Idle for receiving.
@ -377,147 +383,147 @@ static irqreturn_t macii_interrupt(int irq, void *arg)
} }
last_status = status; last_status = status;
status = via[B] & (ST_MASK|CTLR_IRQ); status = via[B] & (ST_MASK | CTLR_IRQ);
switch (macii_state) { switch (macii_state) {
case idle: case idle:
if (reading_reply) { if (reading_reply) {
reply_ptr = current_req->reply; reply_ptr = current_req->reply;
} else { } else {
WARN_ON(current_req); WARN_ON(current_req);
reply_ptr = reply_buf; reply_ptr = reply_buf;
} }
x = via[SR]; x = via[SR];
if ((status & CTLR_IRQ) && (x == 0xFF)) { if ((status & CTLR_IRQ) && (x == 0xFF)) {
/* Bus timeout without SRQ sequence: /* Bus timeout without SRQ sequence:
* data is "FF" while CTLR_IRQ is "H" * data is "FF" while CTLR_IRQ is "H"
*/
reply_len = 0;
srq_asserted = 0;
macii_state = read_done;
} else {
macii_state = reading;
*reply_ptr = x;
reply_len = 1;
}
/* 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) {
req->sent = 1;
macii_state = idle;
if (req->reply_expected) {
reading_reply = 1;
} else {
req->complete = 1;
current_req = req->next;
if (req->done) (*req->done)(req);
if (current_req)
macii_start();
else
if (need_autopoll())
macii_autopoll(autopoll_devs);
}
if (macii_state == idle) {
/* 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++];
if ( (via[B] & ST_MASK) == ST_CMD ) {
/* just sent the command byte, set to EVEN */
via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
} else {
/* invert state bits, toggle ODD/EVEN */
via[B] ^= ST_MASK;
}
}
break;
case reading:
x = via[SR];
WARN_ON((status & ST_MASK) == ST_CMD ||
(status & ST_MASK) == ST_IDLE);
/* Bus timeout with SRQ sequence:
* data is "XX FF" while CTLR_IRQ is "L L"
* End of packet without SRQ sequence:
* data is "XX...YY 00" while CTLR_IRQ is "L...H L"
* End of packet SRQ sequence:
* data is "XX...YY 00" while CTLR_IRQ is "L...L L"
* (where XX is the first response byte and
* YY is the last byte of valid response data.)
*/ */
reply_len = 0;
srq_asserted = 0; srq_asserted = 0;
if (!(status & CTLR_IRQ)) { macii_state = read_done;
if (x == 0xFF) { } else {
if (!(last_status & CTLR_IRQ)) { macii_state = reading;
macii_state = read_done; *reply_ptr = x;
reply_len = 0; reply_len = 1;
srq_asserted = 1; }
}
} else if (x == 0x00) {
macii_state = read_done;
if (!(last_status & CTLR_IRQ))
srq_asserted = 1;
}
}
if (macii_state == reading && /* set ADB state = even for first data byte */
reply_len < ARRAY_SIZE(reply_buf)) { via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
reply_ptr++; break;
*reply_ptr = x;
reply_len++;
}
/* invert state bits, toggle ODD/EVEN */
via[B] ^= ST_MASK;
break;
case read_done:
x = via[SR];
if (reading_reply) {
reading_reply = 0;
req = current_req;
req->reply_len = reply_len;
req->complete = 1;
current_req = req->next;
if (req->done) (*req->done)(req);
} else if (reply_len && autopoll_devs)
adb_input(reply_buf, reply_len, 0);
case sending:
req = current_req;
if (data_index >= req->nbytes) {
req->sent = 1;
macii_state = idle; macii_state = idle;
/* SRQ seen before, initiate poll now */ if (req->reply_expected) {
if (srq_asserted) reading_reply = 1;
macii_queue_poll(); } else {
req->complete = 1;
current_req = req->next;
if (req->done)
(*req->done)(req);
if (current_req) if (current_req)
macii_start(); macii_start();
else else if (need_autopoll())
if (need_autopoll())
macii_autopoll(autopoll_devs); macii_autopoll(autopoll_devs);
}
if (macii_state == idle) if (macii_state == idle) {
/* 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; via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
break; }
} else {
via[SR] = req->data[data_index++];
default: if ((via[B] & ST_MASK) == ST_CMD) {
/* just sent the command byte, set to EVEN */
via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
} else {
/* invert state bits, toggle ODD/EVEN */
via[B] ^= ST_MASK;
}
}
break;
case reading:
x = via[SR];
WARN_ON((status & ST_MASK) == ST_CMD ||
(status & ST_MASK) == ST_IDLE);
/* Bus timeout with SRQ sequence:
* data is "XX FF" while CTLR_IRQ is "L L"
* End of packet without SRQ sequence:
* data is "XX...YY 00" while CTLR_IRQ is "L...H L"
* End of packet SRQ sequence:
* data is "XX...YY 00" while CTLR_IRQ is "L...L L"
* (where XX is the first response byte and
* YY is the last byte of valid response data.)
*/
srq_asserted = 0;
if (!(status & CTLR_IRQ)) {
if (x == 0xFF) {
if (!(last_status & CTLR_IRQ)) {
macii_state = read_done;
reply_len = 0;
srq_asserted = 1;
}
} else if (x == 0x00) {
macii_state = read_done;
if (!(last_status & CTLR_IRQ))
srq_asserted = 1;
}
}
if (macii_state == reading &&
reply_len < ARRAY_SIZE(reply_buf)) {
reply_ptr++;
*reply_ptr = x;
reply_len++;
}
/* invert state bits, toggle ODD/EVEN */
via[B] ^= ST_MASK;
break;
case read_done:
x = via[SR];
if (reading_reply) {
reading_reply = 0;
req = current_req;
req->reply_len = reply_len;
req->complete = 1;
current_req = req->next;
if (req->done)
(*req->done)(req);
} else if (reply_len && autopoll_devs)
adb_input(reply_buf, reply_len, 0);
macii_state = idle;
/* SRQ seen before, initiate poll now */
if (srq_asserted)
macii_queue_poll();
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; break;
} }