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