Add signal mask save/restore to the checkpoint code. Reorder the file
[dragonfly.git] / sys / platform / pc32 / isa / atapi.c
1 /*
2  * Device-independent level for ATAPI drivers.
3  *
4  * Copyright (C) 1995 Cronyx Ltd.
5  * Author Serge Vakulenko, <vak@cronyx.ru>
6  *
7  * This software is distributed with NO WARRANTIES, not even the implied
8  * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9  *
10  * Authors grant any other persons or organisations permission to use
11  * or modify this software as long as this message is kept with the software,
12  * all derivative works or modified versions.
13  *
14  * Version 1.9, Mon Oct  9 22:34:47 MSK 1995
15  *
16  * $FreeBSD: src/sys/i386/isa/atapi.c,v 1.36.2.1 2000/04/03 20:13:06 n_hibma Exp $
17  * $DragonFly: src/sys/platform/pc32/isa/Attic/atapi.c,v 1.5 2004/10/14 03:05:54 dillon Exp $
18  */
19
20 /*
21  * The ATAPI level is implemented as a machine-dependent layer
22  * between the device driver and the IDE controller.
23  * All the machine- and controller dependency is isolated inside
24  * the ATAPI level, while all the device dependency is located
25  * in the device subdriver.
26  *
27  * It seems that an ATAPI bus will became popular for medium-speed
28  * storage devices such as CD-ROMs, magneto-optical disks, tape streamers etc.
29  *
30  * To ease the development of new ATAPI drivers, the subdriver
31  * interface was designed to be as simple as possible.
32  *
33  * Three routines are available for the subdriver to access the device:
34  *
35  *      struct atapires atapi_request_wait (ata, unit, cmd, a1, a2, a3, a4, a5,
36  *              a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, addr, count);
37  *      struct atapi *ata;  -- atapi controller descriptor
38  *      int unit;           -- device unit number on the IDE bus
39  *      u_char cmd;         -- ATAPI command code
40  *      u_char a1..a15;     -- ATAPI command arguments
41  *      char *addr;         -- address of the data buffer for i/o
42  *      int count;          -- data length, >0 for read ops, <0 for write ops
43  *
44  * The atapi_request_wait() function puts the op in the queue of ATAPI
45  * commands for the IDE controller, starts the controller, the waits for
46  * operation to be completed (using tsleep).
47  * The function should be called from the user phase only (open(), close(),
48  * ioctl() etc).
49  * Ata and unit args are the values which the subdriver gets from the ATAPI
50  * level via attach() call.
51  * Buffer pointed to by *addr should be placed in core memory, static
52  * or dynamic, but not in stack.
53  * The function returns the error code structure, which consists of:
54  * - atapi driver code value
55  * - controller status port value
56  * - controller error port value
57  *
58  *      struct atapires atapi_request_immediate (ata, unit, cmd, a1, a2, a3,
59  *              a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
60  *              addr, count);
61  *
62  * The atapi_request_immediate() function is similar to atapi_request_wait(),
63  * but it does not use interrupts for performing the request.
64  * It should be used during an attach phase to get parameters from the device.
65  *
66  *      void atapi_request_callback (ata, unit, cmd, a1, a2, a3, a4, a5,
67  *              a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
68  *              addr, count, done, x, y);
69  *      struct atapi *ata;  -- atapi controller descriptor
70  *      int unit;           -- device unit number on the IDE bus
71  *      u_char cmd;         -- ATAPI command code
72  *      u_char a1..a15;     -- ATAPI command arguments
73  *      char *addr;         -- address of the data buffer for i/o
74  *      int count;          -- data length, >0 for read ops, <0 for write ops
75  *      void (*done)();     -- function to call when op finished
76  *      void *x, *y;        -- arguments for done() function
77  *
78  * The atapi_request_callback() function puts the op in the queue of ATAPI
79  * commands for the IDE controller, starts the controller, then returns.
80  * When the operation finishes, then the callback function done()
81  * will be called on the interrupt level.
82  * The function is designed to be callable from the interrupt phase.
83  * The done() functions is called with the following arguments:
84  *      (void) (*done) (x, y, count, errcode)
85  *      void *x, *y;             -- arguments from the atapi_request_callback()
86  *      int count;               -- the data residual count
87  *      struct atapires errcode; -- error code structure, see above
88  *
89  * The new driver could be added in three steps:
90  * 1. Add entries for the new driver to bdevsw and cdevsw tables in conf.c.
91  *    You will need to make at least three routines: open(), close(),
92  *    strategy() and possibly ioctl().
93  * 2. Make attach() routine, which should allocate all the needed data
94  *    structures and print the device description string (see xxxattach()).
95  * 3. Add an appropriate case to the switch in atapi_attach() routine,
96  *    call attach() routine of the new driver here.  Add the appropriate
97  *    #include line at the top of attach.c.
98  * That's all!
99  *
100  * Use #define DEBUG in atapi.c to enable tracing of all i/o operations
101  * on the IDE bus.
102  */
103 #undef DEBUG
104
105 #include "use_wdc.h"
106 #include "use_wcd.h"
107 #include "use_wfd.h"
108 #include "use_wst.h"
109 /* #include "wmd.h" -- add your driver here */
110
111 #if NWDC > 0
112
113 #include <sys/param.h>
114 #include <sys/systm.h>
115 #include <sys/malloc.h>
116
117 #include <machine/clock.h>
118
119 #include <i386/isa/atapi.h>
120
121 /* this code is compiled part of the module */
122
123 #ifdef DEBUG
124 #   define print(s)     printf s
125 #else
126 #   define print(s)     {/*void*/}
127 #endif
128
129 /*
130  * ATAPI packet command phase.
131  */
132 #define PHASE_CMDOUT    (ARS_DRQ | ARI_CMD)
133 #define PHASE_DATAIN    (ARS_DRQ | ARI_IN)
134 #define PHASE_DATAOUT   ARS_DRQ
135 #define PHASE_COMPLETED (ARI_IN | ARI_CMD)
136 #define PHASE_ABORTED   0                       /* nonstandard - for NEC 260 */
137
138 static struct atapi atapitab[NWDC];
139
140 static struct atapi_params *atapi_probe (int port, int unit);
141 static int atapi_wait (int port, u_char bits_wanted);
142 static void atapi_send_cmd (struct atapi *ata, struct atapicmd *ac);
143 static int atapi_io (struct atapi *ata, struct atapicmd *ac);
144 static int atapi_strt_cmd (struct atapi *ata, struct atapicmd *ac);
145 static int atapi_wait_cmd (struct atapi *ata, struct atapicmd *ac);
146
147 extern void wdstart (int ctrlr);
148 extern int acdattach(struct atapi*, int, struct atapi_params*, int);
149 extern int wfdattach(struct atapi*, int, struct atapi_params*, int);
150 extern int wstattach(struct atapi*, int, struct atapi_params*, int);
151
152 /*
153  * Probe the ATAPI device at IDE controller `ctlr', drive `unit'.
154  * Called at splbio().
155  */
156 int atapi_attach (int ctlr, int unit, int port)
157 {
158         struct atapi *ata = atapitab + ctlr;
159         struct atapi_params *ap;
160         char buf [sizeof(ap->model) + 1];
161         char revbuf [sizeof(ap->revision) + 1];
162         struct atapicmd *ac;
163
164         print (("atapi%d.%d at 0x%x: attach called\n", ctlr, unit, port));
165         ap = atapi_probe (port, unit);
166         if (! ap)
167                 return (0);
168
169         bcopy (ap->model, buf, sizeof(buf)-1);
170         buf[sizeof(buf)-1] = 0;
171
172         bcopy (ap->revision, revbuf, sizeof(revbuf)-1);
173         revbuf[sizeof(revbuf)-1] = 0;
174
175         printf ("wdc%d: unit %d (atapi): <%s/%s>", ctlr, unit, buf, revbuf);
176
177         /* device is removable */
178         if (ap->removable)
179                 printf (", removable");
180
181         /* packet command size */
182         switch (ap->cmdsz) {
183         case AT_PSIZE_12: break;
184         case AT_PSIZE_16: printf (", cmd16"); ata->cmd16 = 1; break;
185         default:          printf (", cmd%d", ap->cmdsz);
186         }
187
188         /* DRQ type */
189         switch (ap->drqtype) {
190         case AT_DRQT_MPROC: ata->slow = 1; break;
191         case AT_DRQT_INTR:  printf (", intr"); ata->intrcmd = 1; break;
192         case AT_DRQT_ACCEL: printf (", accel"); ata->accel = 1; break;
193         default:            printf (", drq%d", ap->drqtype);
194         }
195         if (ata->slow)
196                 ata->intrcmd = 0;
197
198         /* 
199          * If we have two devices, one supporting INTR and one ACCEL, we
200          * have to pessimise - clear INTR and set slow.
201          */
202         if (ata->accel && ata->intrcmd) {
203         ata->intrcmd = 0;
204         ata->slow = 1;
205         }
206
207         /* overlap operation supported */
208         if (ap->ovlapflag)
209                 printf (", ovlap");
210
211         /* interleaved DMA supported */
212         if (ap->idmaflag)
213                 printf (", idma");
214         /* DMA supported */
215         else if (ap->dmaflag)
216                 printf (", dma");
217
218         /* IORDY can be disabled */
219         if (ap->iordydis)
220                 printf (", iordis");
221         /* IORDY supported */
222         else if (ap->iordyflag)
223                 printf (", iordy");
224
225         printf ("\n");
226
227         ata->port = port;
228         ata->ctrlr = ctlr;
229         ata->attached[unit] = 0;
230 #ifdef DEBUG
231         ata->debug = 1;
232 #else
233         ata->debug = 0;
234 #endif
235         /* Initialize free queue. */
236         ata->cmdrq[15].next = 0;
237         for (ac = ata->cmdrq+14; ac >= ata->cmdrq; --ac)
238                 ac->next = ac+1;
239         ata->free = ata->cmdrq;
240
241         if (ap->proto != AT_PROTO_ATAPI) {
242                 printf ("wdc%d: unit %d: unknown ATAPI protocol=%d\n",
243                         ctlr, unit, ap->proto);
244                 free (ap, M_TEMP);
245                 return (0);
246         }
247         switch (ap->devtype) {
248         default:
249                 /* unknown ATAPI device */
250                 printf ("wdc%d: unit %d: unknown ATAPI type=%d\n",
251                         ctlr, unit, ap->devtype);
252                 break;
253
254         case AT_TYPE_DIRECT:            /* direct-access */
255 #if NWFD > 0
256                 /* ATAPI Floppy(LS-120) */
257                 if (wfdattach (ata, unit, ap, ata->debug) < 0)
258                         break;
259                         /* Device attached successfully. */
260                 ata->attached[unit] = 1;
261                 return (1);
262 #else
263                 printf ("wdc%d: ATAPI Floppies not configured\n", ctlr);
264                 break;
265 #endif
266         case AT_TYPE_CDROM:             /* CD-ROM device */
267 #if NWCD > 0
268                 /* ATAPI CD-ROM & CD-R/RW drives */
269                 if (acdattach (ata, unit, ap, ata->debug) < 0)
270                         break;
271                 ata->attached[unit] = 1;
272                 return (1);
273 #else
274                 printf ("wdc%d: ATAPI CD-ROMs not configured\n", ctlr);
275                 break;
276 #endif
277
278         case AT_TYPE_TAPE:              /* streaming tape */
279 #if NWST > 0
280                 /* ATAPI Streaming Tape */
281                 if (wstattach (ata, unit, ap, ata->debug) < 0)
282                         break;
283                 /* Device attached successfully. */
284                 ata->attached[unit] = 1;
285                 return (1);
286 #else
287                 printf ("wdc%d: ATAPI streaming tapes not configured\n", ctlr);
288 #endif
289                 break;
290
291         case AT_TYPE_OPTICAL:           /* optical disk */
292 #if NWMD > 0
293                 /* Add your driver here */
294 #else
295                 printf ("wdc%d: ATAPI optical disks not supported yet\n", ctlr);
296 #endif
297                 break;
298         }
299         /* Attach failed. */
300         free (ap, M_TEMP);
301         return (0);
302 }
303
304 static char *cmdname (u_char cmd)
305 {
306         static char buf[8];
307
308         switch (cmd) {
309         case 0x00: return ("TEST_UNIT_READY");
310         case 0x01: return ("REZERO_UNIT");
311         case 0x03: return ("REQUEST_SENSE");
312         case 0x04: return ("FORMAT_UNIT");
313         case 0x1b: return ("START_STOP");
314         case 0x1e: return ("PREVENT_ALLOW");
315         case 0x25: return ("READ_CAPACITY");
316         case 0x28: return ("READ_BIG");
317         case 0x2a: return ("WRITE_BIG");
318         case 0x35: return ("SYNCHRONIZE_CACHE");
319         case 0x42: return ("READ_SUBCHANNEL");
320         case 0x43: return ("READ_TOC");
321         case 0x51: return ("READ_DISC_INFO");
322         case 0x52: return ("READ_TRACK_INFO");
323         case 0x53: return ("RESERVE_TRACK");
324         case 0x54: return ("SEND_OPC_INFO");
325         case 0x55: return ("MODE_SELECT");
326         case 0x58: return ("REPAIR_TRACK");
327         case 0x59: return ("READ_MASTER_CUE");
328         case 0x5a: return ("MODE_SENSE");
329         case 0x5b: return ("CLOSE_TRACK/SESSION");
330         case 0x5c: return ("READ_BUFFER_CAPACITY");
331         case 0x5d: return ("SEND_CUE_SHEET");
332         case 0x47: return ("PLAY_MSF");
333         case 0x4b: return ("PAUSE");
334         case 0x48: return ("PLAY_TRACK");
335         case 0xa1: return ("BLANK_CMD");
336         case 0xa5: return ("PLAY_BIG");
337         case 0xb4: return ("PLAY_CD");
338         case 0xbd: return ("ATAPI_MECH_STATUS"); 
339         case 0xbe: return ("READ_CD");
340         }
341         snprintf (buf, sizeof(buf), "[0x%x]", cmd);
342         return (buf);
343 }
344
345 static void bswap (char *buf, int len)
346 {
347         u_short *p = (u_short*) (buf + len);
348         while (--p >= (u_short*) buf)
349                 *p = ntohs (*p);
350 }
351
352 static void btrim (char *buf, int len)
353 {
354         char *p;
355
356         /* Remove the trailing spaces. */
357         for (p=buf; p<buf+len; ++p)
358                 if (! *p)
359                         *p = ' ';
360         for (p=buf+len-1; p>=buf && *p==' '; --p)
361                 *p = 0;
362 }
363
364 /*
365  * Issue IDENTIFY command to ATAPI drive to ask it what it is.
366  */
367 static struct atapi_params *atapi_probe (int port, int unit)
368 {
369         struct atapi_params *ap;
370         char tb [DEV_BSIZE];
371
372         /* Wait for controller not busy. */
373         outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0);
374         if (atapi_wait (port, 0) < 0) {
375                 print (("atapiX.%d at 0x%x: controller busy, status=%b\n",
376                         unit, port, inb (port + AR_STATUS), ARS_BITS));
377                 return (0);
378         }
379
380         /* Issue ATAPI IDENTIFY command. */
381         outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0);
382         outb (port + AR_COMMAND, ATAPIC_IDENTIFY);
383
384         /* Check that device is present. */
385         if (inb (port + AR_STATUS) == 0xff) {
386                 print (("atapiX.%d at 0x%x: no device\n", unit, port));
387                 if (unit == 1)
388                         /* Select unit 0. */
389                         outb (port + AR_DRIVE, ARD_DRIVE0);
390                 return (0);
391         }
392
393         /* Wait for data ready. */
394         if (atapi_wait (port, ARS_DRQ) != 0) {
395                 print (("atapiX.%d at 0x%x: identify not ready, status=%b\n",
396                         unit, port, inb (port + AR_STATUS), ARS_BITS));
397                 if (unit == 1)
398                         /* Select unit 0. */
399                         outb (port + AR_DRIVE, ARD_DRIVE0);
400                 return (0);
401         }
402
403         /* check that DRQ isn't a fake */
404         if (inb (port + AR_STATUS) == 0xff) {
405                 print (("atapiX.%d at 0x%x: no device\n", unit, port));
406                 if (unit == 1)
407                         /* Select unit 0. */
408                         outb (port + AR_DRIVE, ARD_DRIVE0);
409                 return (0);
410         }
411
412         /* Obtain parameters. */
413         insw (port + AR_DATA, tb, sizeof(tb) / sizeof(short));
414
415         ap = malloc (sizeof *ap, M_TEMP, M_INTWAIT);
416         if (! ap)
417                 return (0);
418         bcopy (tb, ap, sizeof *ap);
419
420         /*
421          * Shuffle string byte order.
422          * Mitsumi and NEC drives don't need this.
423          */
424         if (! ((ap->model[0] == 'N' && ap->model[1] == 'E') ||
425             (ap->model[0] == 'F' && ap->model[1] == 'X')))
426                 bswap (ap->model, sizeof(ap->model));
427         bswap (ap->serial, sizeof(ap->serial));
428         bswap (ap->revision, sizeof(ap->revision));
429
430         /* Clean up the model name, serial and revision numbers. */
431         btrim (ap->model, sizeof(ap->model));
432         btrim (ap->serial, sizeof(ap->serial));
433         btrim (ap->revision, sizeof(ap->revision));
434         return (ap);
435 }
436
437 /*
438  * Wait uninterruptibly until controller is not busy and certain
439  * status bits are set.
440  * The wait is usually short unless it is for the controller to process
441  * an entire critical command.
442  * Return 1 for (possibly stale) controller errors, -1 for timeout errors,
443  * or 0 for no errors.
444  */
445 static int atapi_wait (int port, u_char bits_wanted)
446 {
447         int cnt;
448         u_char s;
449
450         /* Wait 5 sec for BUSY deassert. */
451         for (cnt=500000; cnt>0; --cnt) {
452                 s = inb (port + AR_STATUS);
453                 if (! (s & ARS_BSY))
454                         break;
455                 DELAY (10);
456         }
457         if (cnt <= 0)
458                 return (-1);
459         if (! bits_wanted)
460                 return (s & ARS_CHECK);
461
462         /* Wait 50 msec for bits wanted. */
463         for (cnt=5000; cnt>0; --cnt) {
464                 s = inb (port + AR_STATUS);
465                 if ((s & bits_wanted) == bits_wanted)
466                         return (s & ARS_CHECK);
467                 DELAY (10);
468         }
469         return (-1);
470 }
471
472 void atapi_debug (struct atapi *ata, int on)
473 {
474         ata->debug = on;
475 }
476
477 static struct atapicmd *atapi_alloc (struct atapi *ata)
478 {
479         struct atapicmd *ac;
480
481         while (! ata->free)
482                 tsleep ((caddr_t)ata, 0, "atacmd", 100);
483         ac = ata->free;
484         ata->free = ac->next;
485         ac->busy = 1;
486         return (ac);
487 }
488
489 static void atapi_free (struct atapi *ata, struct atapicmd *ac)
490 {
491         if (! ata->free)
492                 wakeup ((caddr_t)ata);
493         ac->busy = 0;
494         ac->next = ata->free;
495         ata->free = ac;
496 }
497
498 /*
499  * Add new command request to the end of the queue.
500  */
501 static void atapi_enqueue (struct atapi *ata, struct atapicmd *ac)
502 {
503         ac->next = 0;
504         if (ata->tail)
505                 ata->tail->next = ac;
506         else
507                 ata->queue = ac;
508         ata->tail = ac;
509 }
510
511 static void atapi_done (struct atapi *ata)
512 {
513         struct atapicmd *ac = ata->queue;
514
515         if (! ac)
516                 return; /* cannot happen */
517
518         ata->queue = ac->next;
519         if (! ata->queue)
520                 ata->tail = 0;
521
522         if (ac->callback) {
523                 (*ac->callback) (ac->cbarg1, ac->cbarg2, ac->count, ac->result);
524                 atapi_free (ata, ac);
525         } else
526                 wakeup ((caddr_t)ac);
527 }
528
529 /*
530  * Start new packet op.  Called from wdstart().
531  * Return 1 if op started, and we are waiting for interrupt.
532  * Return 0 when idle.
533  */
534 int atapi_strt (int ctrlr)
535 {
536         struct atapi *ata = atapitab + ctrlr;
537         struct atapicmd *ac;
538 again:
539         ac = ata->queue;
540         if (! ac)
541                 return (0);
542
543         /* Start packet command. */
544         if (atapi_strt_cmd (ata, ac) < 0) {
545                 atapi_done (ata);
546                 goto again;
547         }
548
549         if (ata->intrcmd)
550                 /* Wait for interrupt before sending packet command */
551                 return (1);
552
553         /* Wait for DRQ. */
554         if (atapi_wait_cmd (ata, ac) < 0) {
555                 atapi_done (ata);
556                 goto again;
557         }
558
559         /* Send packet command. */
560         atapi_send_cmd (ata, ac);
561         return (1);
562 }
563
564 /*
565  * Start new packet op. Returns -1 on errors.
566  */
567 int atapi_strt_cmd (struct atapi *ata, struct atapicmd *ac)
568 {
569         ac->result.error = 0;
570         ac->result.status = 0;
571
572         outb (ata->port + AR_DRIVE, ac->unit ? ARD_DRIVE1 : ARD_DRIVE0);
573         if (atapi_wait (ata->port, 0) < 0) {
574                 printf ("atapi%d.%d: controller not ready for cmd\n",
575                         ata->ctrlr, ac->unit);
576                 ac->result.code = RES_NOTRDY;
577                 return (-1);
578         }
579
580         /* Set up the controller registers. */
581         outb (ata->port + AR_FEATURES, 0);
582         outb (ata->port + AR_IREASON, 0);
583         outb (ata->port + AR_TAG, 0);
584         outb (ata->port + AR_CNTLO, ac->count & 0xff);
585         outb (ata->port + AR_CNTHI, ac->count >> 8);
586         outb (ata->port + AR_COMMAND, ATAPIC_PACKET);
587
588         if (ata->debug)
589                 printf ("atapi%d.%d: start\n", ata->ctrlr, ac->unit);
590         return (0);
591 }
592
593 /*
594  * Wait for DRQ before sending packet cmd. Returns -1 on errors.
595  */
596 int atapi_wait_cmd (struct atapi *ata, struct atapicmd *ac)
597 {
598         /* Wait for DRQ from 100 usec to 3 msec for slow devices */
599         int cnt = ata->intrcmd ? 10000 : ata->slow ? 3000 : 100;
600         int ireason = 0, phase = 0;
601
602         /* Wait for command phase. */
603         for (; cnt>0; cnt-=10) {
604                 ireason = inb (ata->port + AR_IREASON);
605                 ac->result.status = inb (ata->port + AR_STATUS);
606                 phase = (ireason & (ARI_CMD | ARI_IN)) |
607                         (ac->result.status & (ARS_DRQ | ARS_BSY));
608                 if (phase == PHASE_CMDOUT)
609                         break;
610                 DELAY (10);
611         }
612
613         if (phase != PHASE_CMDOUT) {
614                 ac->result.code = RES_NODRQ;
615                 ac->result.error = inb (ata->port + AR_ERROR);
616                 printf ("atapi%d.%d: invalid command phase, ireason=0x%x, status=%b, error=%b\n",
617                         ata->ctrlr, ac->unit, ireason,
618                         ac->result.status, ARS_BITS,
619                         ac->result.error, AER_BITS);
620                 return (-1);
621         }
622         return (0);
623 }
624
625 /*
626  * Send packet cmd.
627  */
628 void atapi_send_cmd (struct atapi *ata, struct atapicmd *ac)
629 {
630         outsw (ata->port + AR_DATA, ac->cmd, ata->cmd16 ? 8 : 6);
631         if (ata->debug)
632                 printf ("atapi%d.%d: send cmd %s %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x\n",
633                         ata->ctrlr, ac->unit, cmdname (ac->cmd[0]), ac->cmd[0],
634                         ac->cmd[1], ac->cmd[2], ac->cmd[3], ac->cmd[4],
635                         ac->cmd[5], ac->cmd[6], ac->cmd[7], ac->cmd[8],
636                         ac->cmd[9], ac->cmd[10], ac->cmd[11], ac->cmd[12],
637                         ac->cmd[13], ac->cmd[14], ac->cmd[15]);
638 }
639
640 /*
641  * Interrupt routine for the controller.  Called from wdintr().
642  * Finish the started op, wakeup wait-type commands,
643  * run callbacks for callback-type commands, then return.
644  * Do not start new op here, it will be done by wdstart,
645  * which is called just after us.
646  * Return 1 if op continues, and we are waiting for new interrupt.
647  * Return 0 when idle.
648  */
649 int atapi_intr (int ctrlr)
650 {
651         struct atapi *ata = atapitab + ctrlr;
652         struct atapicmd *ac = ata->queue;
653
654         if (! ac) {
655                 printf ("atapi%d: stray interrupt\n", ata->ctrlr);
656                 return (0);
657         }
658         if (atapi_io (ata, ac) > 0)
659                 return (1);
660         atapi_done (ata);
661         return (0);
662 }
663
664 /*
665  * Process the i/o phase, transferring the command/data to/from the device.
666  * Return 1 if op continues, and we are waiting for new interrupt.
667  * Return 0 when idle.
668  */
669 int atapi_io (struct atapi *ata, struct atapicmd *ac)
670 {
671         u_char ireason;
672         u_short len, i;
673
674         if (atapi_wait (ata->port, 0) < 0) {
675                 ac->result.status = inb (ata->port + AR_STATUS);
676                 ac->result.error = inb (ata->port + AR_ERROR);
677                 ac->result.code = RES_NOTRDY;
678                 printf ("atapi%d.%d: controller not ready, status=%b, error=%b\n",
679                         ata->ctrlr, ac->unit, ac->result.status, ARS_BITS,
680                         ac->result.error, AER_BITS);
681                 return (0);
682         }
683
684         ac->result.status = inb (ata->port + AR_STATUS);
685         ac->result.error = inb (ata->port + AR_ERROR);
686         len = inb (ata->port + AR_CNTLO);
687         len |= inb (ata->port + AR_CNTHI) << 8;
688         ireason = inb (ata->port + AR_IREASON);
689
690         if (ata->debug) {
691                 printf ("atapi%d.%d: intr ireason=0x%x, len=%d, status=%b, error=%b\n",
692                         ata->ctrlr, ac->unit, ireason, len,
693                         ac->result.status, ARS_BITS,
694                         ac->result.error, AER_BITS);
695         }
696         switch ((ireason & (ARI_CMD | ARI_IN)) | (ac->result.status & ARS_DRQ)) {
697         default:
698                 printf ("atapi%d.%d: unknown phase\n", ata->ctrlr, ac->unit);
699                 ac->result.code = RES_ERR;
700                 break;
701
702         case PHASE_CMDOUT:
703                 /* Send packet command. */
704                 if (! (ac->result.status & ARS_DRQ)) {
705                         printf ("atapi%d.%d: no cmd drq\n",
706                                 ata->ctrlr, ac->unit);
707                         ac->result.code = RES_NODRQ;
708                         break;
709                 }
710                 atapi_send_cmd (ata, ac);
711                 return (1);
712
713         case PHASE_DATAOUT:
714                 /* Write data */
715                 if (ac->count > 0) {
716                         printf ("atapi%d.%d: invalid data direction\n",
717                                 ata->ctrlr, ac->unit);
718                         ac->result.code = RES_INVDIR;
719                         break;
720                 }
721                 if (-ac->count < len) {
722                         print (("atapi%d.%d: send data underrun, %d bytes left\n",
723                                 ata->ctrlr, ac->unit, -ac->count));
724                         ac->result.code = RES_UNDERRUN;
725                         outsw (ata->port + AR_DATA, ac->addr,
726                                 -ac->count / sizeof(short));
727                         for (i= -ac->count; i<len; i+=sizeof(short))
728                                 outw (ata->port + AR_DATA, 0);
729                 } else
730                         outsw (ata->port + AR_DATA, ac->addr,
731                                 len / sizeof(short));
732                 ac->addr += len;
733                 ac->count += len;
734                 return (1);
735
736         case PHASE_DATAIN:
737                 /* Read data */
738                 if (ac->count < 0) {
739                         printf ("atapi%d.%d: invalid data direction\n",
740                                 ata->ctrlr, ac->unit);
741                         ac->result.code = RES_INVDIR;
742                         break;
743                 }
744                 if (ac->count < len) {
745                         print (("atapi%d.%d: recv data overrun, %d bytes left\n",
746                                 ata->ctrlr, ac->unit, ac->count));
747                         ac->result.code = RES_OVERRUN;
748                         insw (ata->port + AR_DATA, ac->addr,
749                                 ac->count / sizeof(short));
750                         for (i=ac->count; i<len; i+=sizeof(short))
751                                 inw (ata->port + AR_DATA);
752                 } else
753                         insw (ata->port + AR_DATA, ac->addr,
754                                 len / sizeof(short));
755                 ac->addr += len;
756                 ac->count -= len;
757                 return (1);
758
759         case PHASE_ABORTED:
760         case PHASE_COMPLETED:
761                 if (ac->result.status & (ARS_CHECK | ARS_DF))
762                         ac->result.code = RES_ERR;
763                 else if (ac->count < 0) {
764                         print (("atapi%d.%d: send data overrun, %d bytes left\n",
765                                 ata->ctrlr, ac->unit, -ac->count));
766                         ac->result.code = RES_OVERRUN;
767                 } else if (ac->count > 0) {
768                         print (("atapi%d.%d: recv data underrun, %d bytes left\n",
769                                 ata->ctrlr, ac->unit, ac->count));
770                         ac->result.code = RES_UNDERRUN;
771                         bzero (ac->addr, ac->count);
772                 } else
773                         ac->result.code = RES_OK;
774                 break;
775         }
776         return (0);
777 }
778
779 /*
780  * Queue new packet request, then call wdstart().
781  * Called on splbio().
782  */
783 void atapi_request_callback (struct atapi *ata, int unit,
784         u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
785         u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
786         u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
787         char *addr, int count, atapi_callback_t *done, void *x, void *y)
788 {
789         struct atapicmd *ac;
790
791         ac = atapi_alloc (ata);
792         ac->cmd[0] = cmd;       ac->cmd[1] = a1;
793         ac->cmd[2] = a2;        ac->cmd[3] = a3;
794         ac->cmd[4] = a4;        ac->cmd[5] = a5;
795         ac->cmd[6] = a6;        ac->cmd[7] = a7;
796         ac->cmd[8] = a8;        ac->cmd[9] = a9;
797         ac->cmd[10] = a10;      ac->cmd[11] = a11;
798         ac->cmd[12] = a12;      ac->cmd[13] = a13;
799         ac->cmd[14] = a14;      ac->cmd[15] = a15;
800         ac->unit = unit;
801         ac->addr = addr;
802         ac->count = count;
803         ac->callback = done;
804         ac->cbarg1 = x;
805         ac->cbarg2 = y;
806
807         if (ata->debug)
808                 printf ("atapi%d.%d: req cb %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x len=%d\n",
809                         ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
810                         ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
811                         ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
812                         ac->cmd[10], ac->cmd[11], ac->cmd[12],
813                         ac->cmd[13], ac->cmd[14], ac->cmd[15], count);
814         atapi_enqueue (ata, ac);
815         wdstart (ata->ctrlr);
816 }
817
818 /*
819  * Queue new packet request, then call wdstart().
820  * Wait until the request is finished.
821  * Called on spl0().
822  * Return atapi error.
823  * Buffer pointed to by *addr should be placed in core memory, not in stack!
824  */
825 struct atapires atapi_request_wait (struct atapi *ata, int unit,
826         u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
827         u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
828         u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
829         char *addr, int count)
830 {
831         struct atapicmd *ac;
832         int x = splbio ();
833         struct atapires result;
834
835         ac = atapi_alloc (ata);
836         ac->cmd[0] = cmd;       ac->cmd[1] = a1;
837         ac->cmd[2] = a2;        ac->cmd[3] = a3;
838         ac->cmd[4] = a4;        ac->cmd[5] = a5;
839         ac->cmd[6] = a6;        ac->cmd[7] = a7;
840         ac->cmd[8] = a8;        ac->cmd[9] = a9;
841         ac->cmd[10] = a10;      ac->cmd[11] = a11;
842         ac->cmd[12] = a12;      ac->cmd[13] = a13;
843         ac->cmd[14] = a14;      ac->cmd[15] = a15;
844         ac->unit = unit;
845         ac->addr = addr;
846         ac->count = count;
847         ac->callback = 0;
848         ac->cbarg1 = 0;
849         ac->cbarg2 = 0;
850
851         if (ata->debug)
852                 printf ("atapi%d.%d: req w %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x len=%d\n",
853                         ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
854                         ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
855                         ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
856                         ac->cmd[10], ac->cmd[11], ac->cmd[12],
857                         ac->cmd[13], ac->cmd[14], ac->cmd[15], count);
858         atapi_enqueue (ata, ac);
859         wdstart (ata->ctrlr);
860         if (ata->tail == ac)
861                 tsleep ((caddr_t)ac, 0, "atareq", 0);
862
863         result = ac->result;
864         atapi_free (ata, ac);
865         splx (x);
866         return (result);
867 }
868
869 /*
870  * Perform a packet command on the device.
871  * Should be called on splbio().
872  * Return atapi error.
873  */
874 struct atapires atapi_request_immediate (struct atapi *ata, int unit,
875         u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
876         u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
877         u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
878         char *addr, int count)
879 {
880         struct atapicmd cmdbuf, *ac = &cmdbuf;
881         int cnt;
882
883         ac->cmd[0] = cmd;       ac->cmd[1] = a1;
884         ac->cmd[2] = a2;        ac->cmd[3] = a3;
885         ac->cmd[4] = a4;        ac->cmd[5] = a5;
886         ac->cmd[6] = a6;        ac->cmd[7] = a7;
887         ac->cmd[8] = a8;        ac->cmd[9] = a9;
888         ac->cmd[10] = a10;      ac->cmd[11] = a11;
889         ac->cmd[12] = a12;      ac->cmd[13] = a13;
890         ac->cmd[14] = a14;      ac->cmd[15] = a15;
891         ac->unit = unit;
892         ac->addr = addr;
893         ac->count = count;
894         ac->callback = 0;
895         ac->cbarg1 = 0;
896         ac->cbarg2 = 0;
897
898         if (ata->debug)
899                 printf ("atapi%d.%d: req im %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x len=%d\n",
900                         ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
901                         ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
902                         ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
903                         ac->cmd[10], ac->cmd[11], ac->cmd[12],
904                         ac->cmd[13], ac->cmd[14], ac->cmd[15], count);
905
906         /* Start packet command, wait for DRQ. */
907         if (atapi_strt_cmd (ata, ac) >= 0 && atapi_wait_cmd (ata, ac) >= 0) {
908                 /* Send packet command. */
909                 atapi_send_cmd (ata, ac);
910
911                 /* Wait for data i/o phase. */
912                 for (cnt=20000; cnt>0; --cnt)
913                         if (((inb (ata->port + AR_IREASON) & (ARI_CMD | ARI_IN)) |
914                             (inb (ata->port + AR_STATUS) & ARS_DRQ)) != PHASE_CMDOUT)
915                                 break;
916
917                 /* Do all needed i/o. */
918                 while (atapi_io (ata, ac))
919                         /* Wait for DRQ deassert. */
920                         for (cnt=2000; cnt>0; --cnt) {
921                                 if (! (inb (ata->port + AR_STATUS) & ARS_DRQ))
922                                         break;
923                                 DELAY(10);
924                         }
925         }
926         return (ac->result);
927 }
928
929 #endif /* NWDC */