[linux.git] / drivers / macintosh / adb-iop.c

/*
 * I/O Processor (IOP) ADB Driver
 * Written and (C) 1999 by Joshua M. Thompson ([email protected])
 * Based on via-cuda.c by Paul Mackerras.
 *
 * 1999-07-01 (jmt) - First implementation for new driver architecture.
 *
 * 1999-07-31 (jmt) - First working version.
 *
 * TODO:
 *
 * o Implement SRQ handling.
 */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/proc_fs.h>

#include <asm/macintosh.h> 
#include <asm/macints.h> 
#include <asm/mac_iop.h>
#include <asm/mac_oss.h>
#include <asm/adb_iop.h>

#include <linux/adb.h> 

/*#define DEBUG_ADB_IOP*/

extern void iop_ism_irq(int, void *);

static struct adb_request *current_req;
static struct adb_request *last_req;
#if 0
static unsigned char reply_buff[16];
static unsigned char *reply_ptr;
#endif

static enum adb_iop_state {
    idle,
    sending,
    awaiting_reply
} adb_iop_state;

static void adb_iop_start(void);
static int adb_iop_probe(void);
static int adb_iop_init(void);
static int adb_iop_send_request(struct adb_request *, int);
static int adb_iop_write(struct adb_request *);
static int adb_iop_autopoll(int);
static void adb_iop_poll(void);
static int adb_iop_reset_bus(void);

struct adb_driver adb_iop_driver = {
	"ISM IOP",
	adb_iop_probe,
	adb_iop_init,
	adb_iop_send_request,
	adb_iop_autopoll,
	adb_iop_poll,
	adb_iop_reset_bus
};

static void adb_iop_end_req(struct adb_request *req, int state)
{
	req->complete = 1;
	current_req = req->next;
	if (req->done) (*req->done)(req);
	adb_iop_state = state;
}

/*
 * Completion routine for ADB commands sent to the IOP.
 *
 * This will be called when a packet has been successfully sent.
 */

static void adb_iop_complete(struct iop_msg *msg)
{
	struct adb_request *req;
	uint flags;

	local_irq_save(flags);

	req = current_req;
	if ((adb_iop_state == sending) && req && req->reply_expected) {
		adb_iop_state = awaiting_reply;
	}

	local_irq_restore(flags);
}

/*
 * Listen for ADB messages from the IOP.
 *
 * This will be called when unsolicited messages (usually replies to TALK
 * commands or autopoll packets) are received.
 */

static void adb_iop_listen(struct iop_msg *msg)
{
	struct adb_iopmsg *amsg = (struct adb_iopmsg *) msg->message;
	struct adb_request *req;
	uint flags;
#ifdef DEBUG_ADB_IOP
	int i;
#endif

	local_irq_save(flags);

	req = current_req;

#ifdef DEBUG_ADB_IOP
	printk("adb_iop_listen %p: rcvd packet, %d bytes: %02X %02X", req,
		(uint) amsg->count + 2, (uint) amsg->flags, (uint) amsg->cmd);
	for (i = 0; i < amsg->count; i++)
		printk(" %02X", (uint) amsg->data[i]);
	printk("\n");
#endif

	/* Handle a timeout. Timeout packets seem to occur even after */
	/* we've gotten a valid reply to a TALK, so I'm assuming that */
	/* a "timeout" is actually more like an "end-of-data" signal. */
	/* We need to send back a timeout packet to the IOP to shut   */
	/* it up, plus complete the current request, if any.          */

	if (amsg->flags & ADB_IOP_TIMEOUT) {
		msg->reply[0] = ADB_IOP_TIMEOUT | ADB_IOP_AUTOPOLL;
		msg->reply[1] = 0;
		msg->reply[2] = 0;
		if (req && (adb_iop_state != idle)) {
			adb_iop_end_req(req, idle);
		}
	} else {
		/* TODO: is it possible for more than one chunk of data  */
		/*       to arrive before the timeout? If so we need to */
		/*       use reply_ptr here like the other drivers do.  */
		if ((adb_iop_state == awaiting_reply) &&
		    (amsg->flags & ADB_IOP_EXPLICIT)) {
			req->reply_len = amsg->count + 1;
			memcpy(req->reply, &amsg->cmd, req->reply_len);
		} else {
			adb_input(&amsg->cmd, amsg->count + 1,
				  amsg->flags & ADB_IOP_AUTOPOLL);
		}
		memcpy(msg->reply, msg->message, IOP_MSG_LEN);
	}
	iop_complete_message(msg);
	local_irq_restore(flags);
}

/*
 * Start sending an ADB packet, IOP style
 *
 * There isn't much to do other than hand the packet over to the IOP
 * after encapsulating it in an adb_iopmsg.
 */

static void adb_iop_start(void)
{
	unsigned long flags;
	struct adb_request *req;
	struct adb_iopmsg amsg;
#ifdef DEBUG_ADB_IOP
	int i;
#endif

	/* get the packet to send */
	req = current_req;
	if (!req) return;

	local_irq_save(flags);

#ifdef DEBUG_ADB_IOP
	printk("adb_iop_start %p: sending packet, %d bytes:", req, req->nbytes);
	for (i = 0 ; i < req->nbytes ; i++)
		printk(" %02X", (uint) req->data[i]);
	printk("\n");
#endif

	/* The IOP takes MacII-style packets, so */
	/* strip the initial ADB_PACKET byte.    */

	amsg.flags = ADB_IOP_EXPLICIT;
	amsg.count = req->nbytes - 2;

	/* amsg.data immediately follows amsg.cmd, effectively making */
	/* amsg.cmd a pointer to the beginning of a full ADB packet.  */
	memcpy(&amsg.cmd, req->data + 1, req->nbytes - 1);

	req->sent = 1;
	adb_iop_state = sending;
	local_irq_restore(flags);

	/* Now send it. The IOP manager will call adb_iop_complete */
	/* when the packet has been sent.                          */

	iop_send_message(ADB_IOP, ADB_CHAN, req,
			 sizeof(amsg), (__u8 *) &amsg, adb_iop_complete);
}

int adb_iop_probe(void)
{
	if (!iop_ism_present) return -ENODEV;
	return 0;
}

int adb_iop_init(void)
{
	printk("adb: IOP ISM driver v0.4 for Unified ADB.\n");
	iop_listen(ADB_IOP, ADB_CHAN, adb_iop_listen, "ADB");
	return 0;
}

int adb_iop_send_request(struct adb_request *req, int sync)
{
	int err;

	err = adb_iop_write(req);
	if (err) return err;

	if (sync) {
		while (!req->complete) adb_iop_poll();
	}
	return 0;
}

static int adb_iop_write(struct adb_request *req)
{
	unsigned long flags;

	if ((req->nbytes < 2) || (req->data[0] != ADB_PACKET)) {
		req->complete = 1;
		return -EINVAL;
	}

	local_irq_save(flags);

	req->next = NULL;
	req->sent = 0;
	req->complete = 0;
	req->reply_len = 0;

	if (current_req != 0) {
		last_req->next = req;
		last_req = req;
	} else {
		current_req = req;
		last_req = req;
	}

	local_irq_restore(flags);
	if (adb_iop_state == idle) adb_iop_start();
	return 0;
}

int adb_iop_autopoll(int devs)
{
	/* TODO: how do we enable/disable autopoll? */
	return 0;
}

void adb_iop_poll(void)
{
	if (adb_iop_state == idle) adb_iop_start();
	iop_ism_irq(0, (void *) ADB_IOP);
}

int adb_iop_reset_bus(void)
{
	struct adb_request req = {
		.reply_expected = 0,
		.nbytes = 2,
		.data = { ADB_PACKET, 0 },
	};

	adb_iop_write(&req);
	while (!req.complete) {
		adb_iop_poll();
		schedule();
	}

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* I/O Processor (IOP) ADB Driver
	3	* Written and (C) 1999 by Joshua M. Thompson ([email protected])
	4	* Based on via-cuda.c by Paul Mackerras.
	5	*
	6	* 1999-07-01 (jmt) - First implementation for new driver architecture.
	7	*
	8	* 1999-07-31 (jmt) - First working version.
	9	*
	10	* TODO:
	11	*
	12	* o Implement SRQ handling.
	13	*/
	14
	15	#include <linux/types.h>
	16	#include <linux/kernel.h>
	17	#include <linux/mm.h>
	18	#include <linux/delay.h>
	19	#include <linux/init.h>
	20	#include <linux/proc_fs.h>
	21
1da177e4 LT	22	#include <asm/macintosh.h>
	23	#include <asm/macints.h>
	24	#include <asm/mac_iop.h>
	25	#include <asm/mac_oss.h>
	26	#include <asm/adb_iop.h>
	27
	28	#include <linux/adb.h>
	29
	30	/#define DEBUG_ADB_IOP/
	31
7d12e780	32	extern void iop_ism_irq(int, void *);
1da177e4 LT	33
	34	static struct adb_request *current_req;
	35	static struct adb_request *last_req;
	36	#if 0
	37	static unsigned char reply_buff[16];
	38	static unsigned char *reply_ptr;
	39	#endif
	40
	41	static enum adb_iop_state {
	42	idle,
	43	sending,
	44	awaiting_reply
	45	} adb_iop_state;
	46
	47	static void adb_iop_start(void);
	48	static int adb_iop_probe(void);
	49	static int adb_iop_init(void);
	50	static int adb_iop_send_request(struct adb_request *, int);
	51	static int adb_iop_write(struct adb_request *);
	52	static int adb_iop_autopoll(int);
	53	static void adb_iop_poll(void);
	54	static int adb_iop_reset_bus(void);
	55
	56	struct adb_driver adb_iop_driver = {
	57	"ISM IOP",
	58	adb_iop_probe,
	59	adb_iop_init,
	60	adb_iop_send_request,
	61	adb_iop_autopoll,
	62	adb_iop_poll,
	63	adb_iop_reset_bus
	64	};
	65
	66	static void adb_iop_end_req(struct adb_request *req, int state)
	67	{
	68	req->complete = 1;
	69	current_req = req->next;
	70	if (req->done) (*req->done)(req);
	71	adb_iop_state = state;
	72	}
	73
	74	/*
	75	* Completion routine for ADB commands sent to the IOP.
	76	*
	77	* This will be called when a packet has been successfully sent.
	78	*/
	79
7d12e780	80	static void adb_iop_complete(struct iop_msg *msg)
1da177e4 LT	81	{
	82	struct adb_request *req;
	83	uint flags;
	84
	85	local_irq_save(flags);
	86
	87	req = current_req;
	88	if ((adb_iop_state == sending) && req && req->reply_expected) {
	89	adb_iop_state = awaiting_reply;
	90	}
	91
	92	local_irq_restore(flags);
	93	}
	94
	95	/*
	96	* Listen for ADB messages from the IOP.
	97	*
	98	* This will be called when unsolicited messages (usually replies to TALK
	99	* commands or autopoll packets) are received.
	100	*/
	101
7d12e780	102	static void adb_iop_listen(struct iop_msg *msg)
1da177e4 LT	103	{
	104	struct adb_iopmsg amsg = (struct adb_iopmsg ) msg->message;
	105	struct adb_request *req;
	106	uint flags;
	107	#ifdef DEBUG_ADB_IOP
	108	int i;
	109	#endif
	110
	111	local_irq_save(flags);
	112
	113	req = current_req;
	114
	115	#ifdef DEBUG_ADB_IOP
	116	printk("adb_iop_listen %p: rcvd packet, %d bytes: %02X %02X", req,
	117	(uint) amsg->count + 2, (uint) amsg->flags, (uint) amsg->cmd);
	118	for (i = 0; i < amsg->count; i++)
	119	printk(" %02X", (uint) amsg->data[i]);
	120	printk("\n");
	121	#endif
	122
	123	/* Handle a timeout. Timeout packets seem to occur even after */
	124	/* we've gotten a valid reply to a TALK, so I'm assuming that */
	125	/* a "timeout" is actually more like an "end-of-data" signal. */
	126	/* We need to send back a timeout packet to the IOP to shut */
	127	/* it up, plus complete the current request, if any. */
	128
	129	if (amsg->flags & ADB_IOP_TIMEOUT) {
	130	msg->reply[0] = ADB_IOP_TIMEOUT \| ADB_IOP_AUTOPOLL;
	131	msg->reply[1] = 0;
	132	msg->reply[2] = 0;
	133	if (req && (adb_iop_state != idle)) {
	134	adb_iop_end_req(req, idle);
	135	}
	136	} else {
	137	/* TODO: is it possible for more than one chunk of data */
	138	/* to arrive before the timeout? If so we need to */
	139	/* use reply_ptr here like the other drivers do. */
	140	if ((adb_iop_state == awaiting_reply) &&
	141	(amsg->flags & ADB_IOP_EXPLICIT)) {
	142	req->reply_len = amsg->count + 1;
	143	memcpy(req->reply, &amsg->cmd, req->reply_len);
	144	} else {
7d12e780	145	adb_input(&amsg->cmd, amsg->count + 1,
1da177e4 LT	146	amsg->flags & ADB_IOP_AUTOPOLL);
	147	}
	148	memcpy(msg->reply, msg->message, IOP_MSG_LEN);
	149	}
	150	iop_complete_message(msg);
	151	local_irq_restore(flags);
	152	}
	153
	154	/*
	155	* Start sending an ADB packet, IOP style
	156	*
	157	* There isn't much to do other than hand the packet over to the IOP
	158	* after encapsulating it in an adb_iopmsg.
	159	*/
	160
	161	static void adb_iop_start(void)
	162	{
	163	unsigned long flags;
	164	struct adb_request *req;
	165	struct adb_iopmsg amsg;
	166	#ifdef DEBUG_ADB_IOP
	167	int i;
	168	#endif
	169
	170	/* get the packet to send */
	171	req = current_req;
	172	if (!req) return;
	173
	174	local_irq_save(flags);
	175
	176	#ifdef DEBUG_ADB_IOP
	177	printk("adb_iop_start %p: sending packet, %d bytes:", req, req->nbytes);
	178	for (i = 0 ; i < req->nbytes ; i++)
	179	printk(" %02X", (uint) req->data[i]);
	180	printk("\n");
	181	#endif
	182
	183	/* The IOP takes MacII-style packets, so */
	184	/* strip the initial ADB_PACKET byte. */
	185
	186	amsg.flags = ADB_IOP_EXPLICIT;
	187	amsg.count = req->nbytes - 2;
	188
	189	/* amsg.data immediately follows amsg.cmd, effectively making */
	190	/* amsg.cmd a pointer to the beginning of a full ADB packet. */
	191	memcpy(&amsg.cmd, req->data + 1, req->nbytes - 1);
	192
	193	req->sent = 1;
	194	adb_iop_state = sending;
	195	local_irq_restore(flags);
	196
	197	/* Now send it. The IOP manager will call adb_iop_complete */
	198	/* when the packet has been sent. */
	199
	200	iop_send_message(ADB_IOP, ADB_CHAN, req,
	201	sizeof(amsg), (__u8 *) &amsg, adb_iop_complete);
	202	}
	203
	204	int adb_iop_probe(void)
	205	{
	206	if (!iop_ism_present) return -ENODEV;
	207	return 0;
	208	}
	209
210	int adb_iop_init(void)
211	{
212	printk("adb: IOP ISM driver v0.4 for Unified ADB.\n");
213	iop_listen(ADB_IOP, ADB_CHAN, adb_iop_listen, "ADB");
214	return 0;
215	}
216
217	int adb_iop_send_request(struct adb_request *req, int sync)
218	{
219	int err;
220
221	err = adb_iop_write(req);
222	if (err) return err;
223
224	if (sync) {
225	while (!req->complete) adb_iop_poll();
226	}
227	return 0;
228	}
229
230	static int adb_iop_write(struct adb_request *req)
231	{
232	unsigned long flags;
233
234	if ((req->nbytes < 2) \|\| (req->data[0] != ADB_PACKET)) {
235	req->complete = 1;
236	return -EINVAL;
237	}
238
239	local_irq_save(flags);
240
a5d361fc	241	req->next = NULL;
1da177e4 LT	242	req->sent = 0;
	243	req->complete = 0;
	244	req->reply_len = 0;
	245
	246	if (current_req != 0) {
	247	last_req->next = req;
	248	last_req = req;
	249	} else {
	250	current_req = req;
	251	last_req = req;
	252	}
	253
	254	local_irq_restore(flags);
	255	if (adb_iop_state == idle) adb_iop_start();
	256	return 0;
	257	}
	258
	259	int adb_iop_autopoll(int devs)
	260	{
	261	/* TODO: how do we enable/disable autopoll? */
	262	return 0;
	263	}
	264
	265	void adb_iop_poll(void)
	266	{
	267	if (adb_iop_state == idle) adb_iop_start();
2850bc27	268	iop_ism_irq(0, (void *) ADB_IOP);
1da177e4 LT	269	}
	270
	271	int adb_iop_reset_bus(void)
	272	{
	273	struct adb_request req = {
	274	.reply_expected = 0,
	275	.nbytes = 2,
	276	.data = { ADB_PACKET, 0 },
	277	};
	278
	279	adb_iop_write(&req);
	280	while (!req.complete) {
	281	adb_iop_poll();
	282	schedule();
	283	}
	284
	285	return 0;
	286	}