1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Driver for the ADB controller in the Mac I/O (Hydra) chip. 4 */ 5 #include <linux/types.h> 6 #include <linux/errno.h> 7 #include <linux/kernel.h> 8 #include <linux/delay.h> 9 #include <linux/spinlock.h> 10 #include <linux/interrupt.h> 11 #include <linux/pgtable.h> 12 #include <linux/of.h> 13 #include <linux/of_address.h> 14 #include <linux/of_irq.h> 15 #include <linux/adb.h> 16 17 #include <asm/io.h> 18 #include <asm/hydra.h> 19 #include <asm/irq.h> 20 #include <linux/init.h> 21 #include <linux/ioport.h> 22 23 struct preg { 24 unsigned char r; 25 char pad[15]; 26 }; 27 28 struct adb_regs { 29 struct preg intr; 30 struct preg data[9]; 31 struct preg intr_enb; 32 struct preg dcount; 33 struct preg error; 34 struct preg ctrl; 35 struct preg autopoll; 36 struct preg active_hi; 37 struct preg active_lo; 38 struct preg test; 39 }; 40 41 /* Bits in intr and intr_enb registers */ 42 #define DFB 1 /* data from bus */ 43 #define TAG 2 /* transfer access grant */ 44 45 /* Bits in dcount register */ 46 #define HMB 0x0f /* how many bytes */ 47 #define APD 0x10 /* auto-poll data */ 48 49 /* Bits in error register */ 50 #define NRE 1 /* no response error */ 51 #define DLE 2 /* data lost error */ 52 53 /* Bits in ctrl register */ 54 #define TAR 1 /* transfer access request */ 55 #define DTB 2 /* data to bus */ 56 #define CRE 4 /* command response expected */ 57 #define ADB_RST 8 /* ADB reset */ 58 59 /* Bits in autopoll register */ 60 #define APE 1 /* autopoll enable */ 61 62 static volatile struct adb_regs __iomem *adb; 63 static struct adb_request *current_req, *last_req; 64 static DEFINE_SPINLOCK(macio_lock); 65 66 static int macio_probe(void); 67 static int macio_init(void); 68 static irqreturn_t macio_adb_interrupt(int irq, void *arg); 69 static int macio_send_request(struct adb_request *req, int sync); 70 static int macio_adb_autopoll(int devs); 71 static void macio_adb_poll(void); 72 static int macio_adb_reset_bus(void); 73 74 struct adb_driver macio_adb_driver = { 75 .name = "MACIO", 76 .probe = macio_probe, 77 .init = macio_init, 78 .send_request = macio_send_request, 79 .autopoll = macio_adb_autopoll, 80 .poll = macio_adb_poll, 81 .reset_bus = macio_adb_reset_bus, 82 }; 83 macio_probe(void)84 int macio_probe(void) 85 { 86 struct device_node *np; 87 88 np = of_find_compatible_node(NULL, "adb", "chrp,adb0"); 89 if (np) { 90 of_node_put(np); 91 return 0; 92 } 93 return -ENODEV; 94 } 95 macio_init(void)96 int macio_init(void) 97 { 98 struct device_node *adbs; 99 struct resource r; 100 unsigned int irq; 101 102 adbs = of_find_compatible_node(NULL, "adb", "chrp,adb0"); 103 if (!adbs) 104 return -ENXIO; 105 106 if (of_address_to_resource(adbs, 0, &r)) { 107 of_node_put(adbs); 108 return -ENXIO; 109 } 110 adb = ioremap(r.start, sizeof(struct adb_regs)); 111 if (!adb) { 112 of_node_put(adbs); 113 return -ENOMEM; 114 } 115 116 out_8(&adb->ctrl.r, 0); 117 out_8(&adb->intr.r, 0); 118 out_8(&adb->error.r, 0); 119 out_8(&adb->active_hi.r, 0xff); /* for now, set all devices active */ 120 out_8(&adb->active_lo.r, 0xff); 121 out_8(&adb->autopoll.r, APE); 122 123 irq = irq_of_parse_and_map(adbs, 0); 124 of_node_put(adbs); 125 if (request_irq(irq, macio_adb_interrupt, 0, "ADB", (void *)0)) { 126 printk(KERN_ERR "ADB: can't get irq %d\n", irq); 127 return -EAGAIN; 128 } 129 out_8(&adb->intr_enb.r, DFB | TAG); 130 131 printk("adb: mac-io driver 1.0 for unified ADB\n"); 132 133 return 0; 134 } 135 macio_adb_autopoll(int devs)136 static int macio_adb_autopoll(int devs) 137 { 138 unsigned long flags; 139 140 spin_lock_irqsave(&macio_lock, flags); 141 out_8(&adb->active_hi.r, devs >> 8); 142 out_8(&adb->active_lo.r, devs); 143 out_8(&adb->autopoll.r, devs? APE: 0); 144 spin_unlock_irqrestore(&macio_lock, flags); 145 return 0; 146 } 147 macio_adb_reset_bus(void)148 static int macio_adb_reset_bus(void) 149 { 150 unsigned long flags; 151 int timeout = 1000000; 152 153 /* Hrm... we may want to not lock interrupts for so 154 * long ... oh well, who uses that chip anyway ? :) 155 * That function will be seldom used during boot 156 * on rare machines, so... 157 */ 158 spin_lock_irqsave(&macio_lock, flags); 159 out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | ADB_RST); 160 while ((in_8(&adb->ctrl.r) & ADB_RST) != 0) { 161 if (--timeout == 0) { 162 out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) & ~ADB_RST); 163 spin_unlock_irqrestore(&macio_lock, flags); 164 return -1; 165 } 166 } 167 spin_unlock_irqrestore(&macio_lock, flags); 168 return 0; 169 } 170 171 /* Send an ADB command */ macio_send_request(struct adb_request * req,int sync)172 static int macio_send_request(struct adb_request *req, int sync) 173 { 174 unsigned long flags; 175 int i; 176 177 if (req->data[0] != ADB_PACKET) 178 return -EINVAL; 179 180 for (i = 0; i < req->nbytes - 1; ++i) 181 req->data[i] = req->data[i+1]; 182 --req->nbytes; 183 184 req->next = NULL; 185 req->sent = 0; 186 req->complete = 0; 187 req->reply_len = 0; 188 189 spin_lock_irqsave(&macio_lock, flags); 190 if (current_req) { 191 last_req->next = req; 192 last_req = req; 193 } else { 194 current_req = last_req = req; 195 out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | TAR); 196 } 197 spin_unlock_irqrestore(&macio_lock, flags); 198 199 if (sync) { 200 while (!req->complete) 201 macio_adb_poll(); 202 } 203 204 return 0; 205 } 206 macio_adb_interrupt(int irq,void * arg)207 static irqreturn_t macio_adb_interrupt(int irq, void *arg) 208 { 209 int i, n, err; 210 struct adb_request *req = NULL; 211 unsigned char ibuf[16]; 212 int ibuf_len = 0; 213 int complete = 0; 214 int autopoll = 0; 215 int handled = 0; 216 217 spin_lock(&macio_lock); 218 if (in_8(&adb->intr.r) & TAG) { 219 handled = 1; 220 req = current_req; 221 if (req) { 222 /* put the current request in */ 223 for (i = 0; i < req->nbytes; ++i) 224 out_8(&adb->data[i].r, req->data[i]); 225 out_8(&adb->dcount.r, req->nbytes & HMB); 226 req->sent = 1; 227 if (req->reply_expected) { 228 out_8(&adb->ctrl.r, DTB + CRE); 229 } else { 230 out_8(&adb->ctrl.r, DTB); 231 current_req = req->next; 232 complete = 1; 233 if (current_req) 234 out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | TAR); 235 } 236 } 237 out_8(&adb->intr.r, 0); 238 } 239 240 if (in_8(&adb->intr.r) & DFB) { 241 handled = 1; 242 err = in_8(&adb->error.r); 243 if (current_req && current_req->sent) { 244 /* this is the response to a command */ 245 req = current_req; 246 if (err == 0) { 247 req->reply_len = in_8(&adb->dcount.r) & HMB; 248 for (i = 0; i < req->reply_len; ++i) 249 req->reply[i] = in_8(&adb->data[i].r); 250 } 251 current_req = req->next; 252 complete = 1; 253 if (current_req) 254 out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | TAR); 255 } else if (err == 0) { 256 /* autopoll data */ 257 n = in_8(&adb->dcount.r) & HMB; 258 for (i = 0; i < n; ++i) 259 ibuf[i] = in_8(&adb->data[i].r); 260 ibuf_len = n; 261 autopoll = (in_8(&adb->dcount.r) & APD) != 0; 262 } 263 out_8(&adb->error.r, 0); 264 out_8(&adb->intr.r, 0); 265 } 266 spin_unlock(&macio_lock); 267 if (complete && req) { 268 void (*done)(struct adb_request *) = req->done; 269 mb(); 270 req->complete = 1; 271 /* Here, we assume that if the request has a done member, the 272 * struct request will survive to setting req->complete to 1 273 */ 274 if (done) 275 (*done)(req); 276 } 277 if (ibuf_len) 278 adb_input(ibuf, ibuf_len, autopoll); 279 280 return IRQ_RETVAL(handled); 281 } 282 macio_adb_poll(void)283 static void macio_adb_poll(void) 284 { 285 unsigned long flags; 286 287 local_irq_save(flags); 288 if (in_8(&adb->intr.r) != 0) 289 macio_adb_interrupt(0, NULL); 290 local_irq_restore(flags); 291 } 292