52c69adb07b38020ed933683a2a7bec88c61ba5c
[dragonfly.git] / sys / dev / disk / ata / atapi-all.c
1 /*-
2  * Copyright (c) 1998,1999,2000,2001,2002 Søren Schmidt <sos@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification, immediately at the beginning of the file.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * $FreeBSD: src/sys/dev/ata/atapi-all.c,v 1.46.2.18 2002/10/31 23:10:33 thomas Exp $
29  * $DragonFly: src/sys/dev/disk/ata/atapi-all.c,v 1.4 2003/08/07 21:16:51 dillon Exp $
30  */
31
32 #include "opt_ata.h"
33 #include "use_atapicd.h"
34 #include "use_atapifd.h"
35 #include "use_atapist.h"
36 #include "use_atapicam.h"
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/ata.h>
41 #include <sys/kernel.h>
42 #include <sys/bus.h>
43 #include <sys/malloc.h>
44 #include <sys/buf.h>
45 #include <sys/sysctl.h>
46 #include <machine/bus.h>
47 #include <machine/clock.h>
48 #include <sys/rman.h>
49 #include "ata-all.h"
50 #include "atapi-all.h"
51
52 /* prototypes */
53 static void atapi_read(struct atapi_request *, int);
54 static void atapi_write(struct atapi_request *, int);
55 static void atapi_finish(struct atapi_request *);
56 static void atapi_timeout(struct atapi_request *);
57 static char *atapi_cmd2str(u_int8_t);
58 static char *atapi_skey2str(u_int8_t);
59
60 /* misc defines */
61 #define ATAPI_MAX_RETRIES       3
62
63 /* internal vars */
64 static int atapi_dma = 0;
65 TUNABLE_INT("hw.ata.atapi_dma", &atapi_dma);
66 static MALLOC_DEFINE(M_ATAPI, "ATAPI generic", "ATAPI driver generic layer");
67
68 /* systcl vars */
69 SYSCTL_DECL(_hw_ata);
70 SYSCTL_INT(_hw_ata, OID_AUTO, atapi_dma, CTLFLAG_RD, &atapi_dma, 0,
71            "ATAPI device DMA mode control");
72
73 void
74 atapi_attach(struct ata_device *atadev)
75 {
76     if (bootverbose) 
77         ata_prtdev(atadev, "piomode=%d dmamode=%d udmamode=%d dmaflag=%d\n",
78                    ata_pmode(atadev->param), ata_wmode(atadev->param),
79                    ata_umode(atadev->param), atadev->param->support_dma);
80
81     ATA_SLEEPLOCK_CH(atadev->channel, ATA_CONTROL);
82     if (atapi_dma && !(atadev->param->drq_type == ATAPI_DRQT_INTR)) {
83         ata_dmainit(atadev->channel, atadev->unit,
84                     (ata_pmode(atadev->param) < 0) ? 
85                     (atadev->param->support_dma ? 4:0):ata_pmode(atadev->param),
86                     (ata_wmode(atadev->param) < 0) ? 
87                     (atadev->param->support_dma ? 2:0):ata_wmode(atadev->param),
88                     ata_umode(atadev->param));
89     }
90     else
91         ata_dmainit(atadev->channel, atadev->unit,
92                     ata_pmode(atadev->param) < 0 ? 0 : ata_pmode(atadev->param),
93                     -1, -1);
94     ATA_UNLOCK_CH(atadev->channel);
95
96     if (!(atadev->result = malloc(sizeof(struct atapi_reqsense), M_ATAPI,
97                                   M_NOWAIT | M_ZERO)))
98         ata_prtdev(atadev, "no memory for sense data\n");
99
100     switch (atadev->param->type) {
101 #if NATAPICD > 0
102     case ATAPI_TYPE_CDROM:
103         if (acdattach(atadev))
104             return;
105         break; 
106 #endif
107 #if NATAPIFD > 0
108     case ATAPI_TYPE_DIRECT:
109         if (afdattach(atadev))
110             return;
111         break; 
112 #endif
113 #if NATAPIST > 0
114     case ATAPI_TYPE_TAPE:
115         if (astattach(atadev))
116             return;
117         break; 
118 #endif
119     }
120 #if NATAPICAM == 0
121     ata_prtdev(atadev, "<%.40s/%.8s> - NO DRIVER!\n",
122                atadev->param->model, atadev->param->revision);
123     free(atadev->result, M_ATAPI);
124     atadev->driver = NULL;
125 #endif
126 }
127
128 void
129 atapi_detach(struct ata_device *atadev)
130 {
131     struct atapi_request *request;
132
133     atadev->flags |= ATA_D_DETACHING;
134     ata_prtdev(atadev, "removed from configuration\n");
135     switch (atadev->param->type) {
136 #if NATAPICD > 0
137     case ATAPI_TYPE_CDROM:
138         acddetach(atadev);
139         break; 
140 #endif
141 #if NATAPIFD >0
142     case ATAPI_TYPE_DIRECT:
143         afddetach(atadev);
144         break; 
145 #endif
146 #if NATAPIST >0
147     case ATAPI_TYPE_TAPE:
148         astdetach(atadev);
149         break; 
150 #endif
151     default:
152         return;
153     }
154     TAILQ_FOREACH(request, &atadev->channel->atapi_queue, chain) {
155         if (request->device != atadev)
156             continue;
157         TAILQ_REMOVE(&atadev->channel->atapi_queue, request, chain);
158         if (request->driver) {
159             struct buf *bp = (struct buf *) request->driver;
160             bp->b_flags |= B_ERROR;
161             bp->b_error = ENXIO;
162             biodone(bp);
163         }
164         if (request->dmatab)
165             free(request->dmatab, M_DEVBUF);
166         free(request, M_ATAPI);
167     }
168     free(atadev->result, M_ATAPI);
169     atadev->driver = NULL;
170     atadev->flags = 0;
171
172 }
173
174 int       
175 atapi_queue_cmd(struct ata_device *atadev, int8_t *ccb, caddr_t data, 
176                 int count, int flags, int timeout,
177                 atapi_callback_t callback, void *driver)
178 {
179     struct atapi_request *request;
180     int error, s;
181  
182     if (!(request = malloc(sizeof(struct atapi_request), M_ATAPI,
183                            M_NOWAIT | M_ZERO)))
184         return ENOMEM;
185
186     request->device = atadev;
187     request->data = data;
188     request->bytecount = count;
189     request->flags = flags;
190     request->error = EINPROGRESS;
191     request->timeout = timeout * hz;
192     request->ccbsize = atadev->param->packet_size ? 16 : 12;
193     bcopy(ccb, request->ccb, request->ccbsize);
194     if (callback) {
195         request->callback = callback;
196         request->driver = driver;
197     }
198     if (atadev->mode >= ATA_DMA) {
199         if (!(request->dmatab = ata_dmaalloc(atadev->channel, atadev->unit)))
200             atadev->mode = ATA_PIO;
201     }
202
203 #ifdef ATAPI_DEBUG
204     ata_prtdev(atadev, "queueing %s ", atapi_cmd2str(request->ccb[0]));
205     atapi_dump("ccb = ", &request->ccb[0], sizeof(request->ccb));
206 #endif
207     /* append onto controller queue and try to start controller */
208     s = splbio();
209     if (flags & ATPR_F_AT_HEAD)
210         TAILQ_INSERT_HEAD(&atadev->channel->atapi_queue, request, chain);
211     else
212         TAILQ_INSERT_TAIL(&atadev->channel->atapi_queue, request, chain);
213     ata_start(atadev->channel);
214
215     /* if callback used, then just return, gets called from interrupt context */
216     if (callback) {
217         splx(s);
218         return 0;
219     }
220
221     /* only sleep when command is in progress */
222     if (request->error == EINPROGRESS)
223         tsleep((caddr_t)request, 0, "atprq", 0);
224     splx(s);
225     error = request->error;
226     if (error)
227          bcopy(&request->sense, atadev->result, sizeof(struct atapi_reqsense));
228     if (request->dmatab)
229         free(request->dmatab, M_DEVBUF);
230     free(request, M_ATAPI);
231     return error;
232 }
233     
234 void
235 atapi_start(struct ata_device *atadev)
236 {
237     switch (atadev->param->type) {
238 #if NATAPICD > 0
239     case ATAPI_TYPE_CDROM:
240         acd_start(atadev);
241         break; 
242 #endif
243 #if NATAPIFD > 0
244     case ATAPI_TYPE_DIRECT:
245         afd_start(atadev);
246         break; 
247 #endif
248 #if NATAPIST > 0
249     case ATAPI_TYPE_TAPE:
250         ast_start(atadev);
251         break; 
252 #endif
253     default:
254         return;
255     }
256 }
257
258 int
259 atapi_transfer(struct atapi_request *request)
260 {
261     struct ata_device *atadev = request->device;
262     int timout;
263     u_int8_t reason;
264
265 #ifdef ATAPI_DEBUG
266     ata_prtdev(atadev, "starting %s ", atapi_cmd2str(request->ccb[0]));
267     atapi_dump("ccb = ", &request->ccb[0], sizeof(request->ccb));
268 #endif
269     /* is this just a POLL DSC command ? */
270     if (request->ccb[0] == ATAPI_POLL_DSC) {
271         ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
272         DELAY(10);
273         if (ATA_INB(atadev->channel->r_altio, ATA_ALTSTAT) & ATA_S_DSC)
274             request->error = 0;
275         else
276             request->error = EBUSY;
277         atapi_finish(request);
278         return ATA_OP_FINISHED;
279     }
280
281     /* start timeout for this command */
282     request->timeout_handle = timeout((timeout_t *)atapi_timeout, 
283                                       request, request->timeout);
284
285     if (!(request->flags & ATPR_F_INTERNAL))
286         atadev->cmd = request->ccb[0];
287
288     /* if DMA enabled setup DMA hardware */
289     request->flags &= ~ATPR_F_DMA_USED; 
290     if ((atadev->mode >= ATA_DMA) &&
291         (request->ccb[0] == ATAPI_READ || 
292          request->ccb[0] == ATAPI_READ_BIG ||
293          request->ccb[0] == ATAPI_READ_CD ||
294          ((request->ccb[0] == ATAPI_WRITE ||
295            request->ccb[0] == ATAPI_WRITE_BIG) &&
296           !(atadev->channel->flags & ATA_ATAPI_DMA_RO))) &&
297         !ata_dmasetup(atadev->channel, atadev->unit, request->dmatab,
298                       (void *)request->data, request->bytecount)) {
299         request->flags |= ATPR_F_DMA_USED;
300     }
301
302     /* start ATAPI operation */
303     if (ata_command(atadev, ATA_C_PACKET_CMD, 
304                     min(request->bytecount, 65534) << 8, 0,
305                     (request->flags & ATPR_F_DMA_USED) ? ATA_F_DMA : 0,
306                     ATA_IMMEDIATE))
307         ata_prtdev(atadev, "failure to send ATAPI packet command\n");
308
309     if (request->flags & ATPR_F_DMA_USED)
310         ata_dmastart(atadev->channel, atadev->unit, 
311                      request->dmatab, request->flags & ATPR_F_READ);
312
313     /* command interrupt device ? just return */
314     if (atadev->param->drq_type == ATAPI_DRQT_INTR)
315         return ATA_OP_CONTINUES;
316
317     /* ready to write ATAPI command */
318     timout = 5000; /* might be less for fast devices */
319     while (timout--) {
320         reason = ATA_INB(atadev->channel->r_io, ATA_IREASON);
321         atadev->channel->status = ATA_INB(atadev->channel->r_io, ATA_STATUS);
322         if (((reason & (ATA_I_CMD | ATA_I_IN)) |
323              (atadev->channel->status&(ATA_S_DRQ|ATA_S_BUSY)))==ATAPI_P_CMDOUT)
324             break;
325         DELAY(20);
326     }
327     if (timout <= 0) {
328         ata_prtdev(atadev, "failure to execute ATAPI packet command\n");
329         untimeout((timeout_t *)atapi_timeout, request, request->timeout_handle);
330         request->error = EIO;
331         atapi_finish(request);  
332         return ATA_OP_FINISHED;
333     }
334
335     /* this seems to be needed for some (slow) devices */
336     DELAY(10);
337
338     /* send actual command */
339     ATA_OUTSW(atadev->channel->r_io, ATA_DATA, (int16_t *)request->ccb,
340               request->ccbsize / sizeof(int16_t));
341     return ATA_OP_CONTINUES;
342 }
343
344 int
345 atapi_interrupt(struct atapi_request *request)
346 {
347     struct ata_device *atadev = request->device;
348     int reason, dma_stat = 0;
349
350     reason = (ATA_INB(atadev->channel->r_io, ATA_IREASON)&(ATA_I_CMD|ATA_I_IN))|
351              (atadev->channel->status & ATA_S_DRQ);
352
353     if (reason == ATAPI_P_CMDOUT) {
354         if (!(atadev->channel->status & ATA_S_DRQ)) {
355             ata_prtdev(atadev, "command interrupt without DRQ\n");
356             untimeout((timeout_t *)atapi_timeout,
357                       request, request->timeout_handle);
358             request->error = EIO;
359             atapi_finish(request);      
360             return ATA_OP_FINISHED;
361         }
362         ATA_OUTSW(atadev->channel->r_io, ATA_DATA, (int16_t *)request->ccb,
363                   request->ccbsize / sizeof(int16_t));
364         return ATA_OP_CONTINUES;
365     }
366
367     if (request->flags & ATPR_F_DMA_USED) {
368         dma_stat = ata_dmadone(atadev->channel);
369         if ((atadev->channel->status & (ATA_S_ERROR | ATA_S_DWF)) ||
370             dma_stat & ATA_BMSTAT_ERROR) {
371             request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
372         }
373         else {
374             request->result = 0;
375             request->donecount = request->bytecount;
376             request->bytecount = 0;
377         }
378     }
379     else {
380         int length = ATA_INB(atadev->channel->r_io, ATA_CYL_LSB) |
381                      ATA_INB(atadev->channel->r_io, ATA_CYL_MSB) << 8;
382
383         switch (reason) {
384         case ATAPI_P_WRITE:
385             if (request->flags & ATPR_F_READ) {
386                 request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
387                 ata_prtdev(atadev, "%s trying to write on read buffer\n",
388                            atapi_cmd2str(atadev->cmd));
389                 break;
390             }
391             atapi_write(request, length);
392             return ATA_OP_CONTINUES;
393         
394         case ATAPI_P_READ:
395             if (!(request->flags & ATPR_F_READ)) {
396                 request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
397                 ata_prtdev(atadev, "%s trying to read on write buffer\n",
398                            atapi_cmd2str(atadev->cmd));
399                 break;
400             }
401             atapi_read(request, length);
402             return ATA_OP_CONTINUES;
403
404         case ATAPI_P_DONEDRQ:
405             ata_prtdev(atadev, "%s DONEDRQ\n", atapi_cmd2str(atadev->cmd));
406             if (request->flags & ATPR_F_READ)
407                 atapi_read(request, length);
408             else
409                 atapi_write(request, length);
410             /* FALLTHROUGH */
411
412         case ATAPI_P_ABORT:
413         case ATAPI_P_DONE:
414             if (atadev->channel->status & (ATA_S_ERROR | ATA_S_DWF))
415                 request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
416             else 
417                 if (!(request->flags & ATPR_F_INTERNAL))
418                     request->result = 0;
419             break;
420
421         default:
422             ata_prtdev(atadev, "unknown transfer phase %d\n", reason);
423         }
424     }
425     untimeout((timeout_t *)atapi_timeout, request, request->timeout_handle);
426
427     /* check for error, if valid sense key, queue a request sense cmd */
428     if ((request->result & ATAPI_SK_MASK) && 
429         request->ccb[0] != ATAPI_REQUEST_SENSE) {
430         bzero(request->ccb, request->ccbsize);
431         request->ccb[0] = ATAPI_REQUEST_SENSE;
432         request->ccb[4] = sizeof(struct atapi_reqsense);
433         request->bytecount = sizeof(struct atapi_reqsense);
434         request->flags &= ATPR_F_QUIET;
435         request->flags |= ATPR_F_READ | ATPR_F_INTERNAL;
436         TAILQ_INSERT_HEAD(&atadev->channel->atapi_queue, request, chain);
437     }
438     else {
439         if (request->result) {
440             switch ((request->result & ATAPI_SK_MASK)) {
441             case ATAPI_SK_NO_SENSE:
442                 request->error = 0;
443                 break;
444
445             case ATAPI_SK_RECOVERED_ERROR:
446                 ata_prtdev(atadev, "%s - recovered error\n",
447                            atapi_cmd2str(atadev->cmd));
448                 request->error = 0;
449                 break;
450
451             case ATAPI_SK_NOT_READY:
452                 request->error = EBUSY;
453                 break;
454
455             case ATAPI_SK_UNIT_ATTENTION:
456                 atadev->flags |= ATA_D_MEDIA_CHANGED;
457                 request->error = EIO;
458                 break;
459
460             default: 
461                 request->error = EIO;
462
463                 if (request->flags & ATPR_F_QUIET)
464                     break;
465
466                 ata_prtdev(atadev, "%s - %s asc=0x%02x ascq=0x%02x ",
467                            atapi_cmd2str(atadev->cmd), 
468                            atapi_skey2str(request->sense.sense_key), 
469                            request->sense.asc, request->sense.ascq);
470                 if (request->sense.sksv)
471                     printf("sks=0x%02x 0x%02x 0x%02x ",
472                            request->sense.sk_specific,
473                            request->sense.sk_specific1,
474                            request->sense.sk_specific2);
475                 printf("error=0x%02x\n", request->result & ATAPI_E_MASK);
476             }
477         }
478         else
479             request->error = 0;
480         atapi_finish(request);  
481     }
482     return ATA_OP_FINISHED;
483 }
484
485 void
486 atapi_reinit(struct ata_device *atadev)
487 {
488     /* reinit device parameters */
489      if (atadev->mode >= ATA_DMA)
490         ata_dmainit(atadev->channel, atadev->unit,
491                     (ata_pmode(atadev->param) < 0) ?
492                     (atadev->param->support_dma ? 4:0):ata_pmode(atadev->param),
493                     (ata_wmode(atadev->param) < 0) ? 
494                     (atadev->param->support_dma ? 2:0):ata_wmode(atadev->param),
495                     ata_umode(atadev->param));
496     else
497         ata_dmainit(atadev->channel, atadev->unit,
498                     ata_pmode(atadev->param)<0 ? 0 : ata_pmode(atadev->param),
499                     -1, -1);
500 }
501
502 int
503 atapi_test_ready(struct ata_device *atadev)
504 {
505     int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
506                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
507         
508     return atapi_queue_cmd(atadev, ccb, NULL, 0, 0, 30, NULL, NULL);
509 }
510         
511 int
512 atapi_wait_dsc(struct ata_device *atadev, int timeout)
513 {
514     int error = 0;
515     int8_t ccb[16] = { ATAPI_POLL_DSC, 0, 0, 0, 0,
516                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
517
518     timeout *= hz;
519     while (timeout > 0) {
520         error = atapi_queue_cmd(atadev, ccb, NULL, 0, 0, 0, NULL, NULL);
521         if (error != EBUSY)
522             break;
523         tsleep((caddr_t)&error, 0, "atpwt", hz / 2);
524         timeout -= (hz / 2);
525     }
526     return error;
527 }
528
529 void
530 atapi_dump(char *label, void *data, int len)
531 {
532     u_int8_t *p = data;
533
534     printf("%s %02x", label, *p++);
535     while (--len > 0) 
536         printf ("-%02x", *p++);
537     printf("\n");
538 }
539
540 static void
541 atapi_read(struct atapi_request *request, int length)
542 {
543     int8_t **buffer = (int8_t **)&request->data;
544     int size = min(request->bytecount, length);
545     struct ata_channel *ch = request->device->channel;
546     int resid;
547
548     if (request->flags & ATPR_F_INTERNAL)
549         *buffer = (int8_t *)&request->sense;
550
551     if (ch->flags & ATA_USE_16BIT || (size % sizeof(int32_t)))
552         ATA_INSW(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer), 
553                  size / sizeof(int16_t));
554     else
555         ATA_INSL(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
556                  size / sizeof(int32_t));
557
558     if (request->bytecount < length) {
559         ata_prtdev(request->device, "read data overrun %d/%d\n",
560                    length, request->bytecount);
561         for (resid=request->bytecount; resid<length; resid+=sizeof(int16_t))
562              ATA_INW(ch->r_io, ATA_DATA);
563     }
564     *buffer += size;
565     request->bytecount -= size;
566     request->donecount += size;
567 }
568
569 static void
570 atapi_write(struct atapi_request *request, int length)
571 {
572     int8_t **buffer = (int8_t **)&request->data;
573     int size = min(request->bytecount, length);
574     struct ata_channel *ch = request->device->channel;
575     int resid;
576
577     if (request->flags & ATPR_F_INTERNAL)
578         *buffer = (int8_t *)&request->sense;
579
580     if (ch->flags & ATA_USE_16BIT || (size % sizeof(int32_t)))
581         ATA_OUTSW(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
582                   size / sizeof(int16_t));
583     else
584         ATA_OUTSL(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
585                   size / sizeof(int32_t));
586
587     if (request->bytecount < length) {
588         ata_prtdev(request->device, "write data underrun %d/%d\n",
589                    length, request->bytecount);
590         for (resid=request->bytecount; resid<length; resid+=sizeof(int16_t))
591             ATA_OUTW(ch->r_io, ATA_DATA, 0);
592     }
593     *buffer += size;
594     request->bytecount -= size;
595     request->donecount += size;
596 }
597
598 static void
599 atapi_finish(struct atapi_request *request)
600 {
601 #ifdef ATAPI_DEBUG
602     ata_prtdev(request->device, "finished %s%s\n",
603                request->callback ? "callback " : "",
604                atapi_cmd2str(request->ccb[0]));
605 #endif
606     if (request->callback) {
607         if (!((request->callback)(request))) {
608             if (request->dmatab)
609                 free(request->dmatab, M_DEVBUF);
610             free(request, M_ATAPI);
611         }
612     }
613     else 
614         wakeup((caddr_t)request);       
615 }
616
617 static void 
618 atapi_timeout(struct atapi_request *request)
619 {
620     struct ata_device *atadev = request->device;
621
622     atadev->channel->running = NULL;
623     ata_prtdev(atadev, "%s command timeout - resetting\n", 
624                atapi_cmd2str(request->ccb[0]));
625
626     if (request->flags & ATPR_F_DMA_USED) {
627         ata_dmadone(atadev->channel);
628         if (request->retries == ATAPI_MAX_RETRIES) {
629             ata_dmainit(atadev->channel, atadev->unit,
630                         (ata_pmode(atadev->param) < 0) ? 0 :
631                          ata_pmode(atadev->param), -1, -1);
632             ata_prtdev(atadev, "trying fallback to PIO mode\n");
633             request->retries = 0;
634         }
635     }
636
637     /* if retries still permit, reinject this request */
638     if (request->retries++ < ATAPI_MAX_RETRIES) {
639         TAILQ_INSERT_HEAD(&atadev->channel->atapi_queue, request, chain);
640     }
641     else {
642         /* retries all used up, return error */
643         request->error = EIO;
644         wakeup((caddr_t)request);
645     } 
646     ata_reinit(atadev->channel);
647 }
648
649 static char *
650 atapi_cmd2str(u_int8_t cmd)
651 {
652     switch (cmd) {
653     case 0x00: return ("TEST_UNIT_READY");
654     case 0x01: return ("REZERO");
655     case 0x03: return ("REQUEST_SENSE");
656     case 0x04: return ("FORMAT_UNIT");
657     case 0x08: return ("READ");
658     case 0x0a: return ("WRITE");
659     case 0x10: return ("WEOF");
660     case 0x11: return ("SPACE");
661     case 0x15: return ("MODE_SELECT");
662     case 0x19: return ("ERASE");
663     case 0x1a: return ("MODE_SENSE");
664     case 0x1b: return ("START_STOP");
665     case 0x1e: return ("PREVENT_ALLOW");
666     case 0x25: return ("READ_CAPACITY");
667     case 0x28: return ("READ_BIG");
668     case 0x2a: return ("WRITE_BIG");
669     case 0x2b: return ("LOCATE");
670     case 0x34: return ("READ_POSITION");
671     case 0x35: return ("SYNCHRONIZE_CACHE");
672     case 0x3b: return ("WRITE_BUFFER");
673     case 0x3c: return ("READ_BUFFER");
674     case 0x42: return ("READ_SUBCHANNEL");
675     case 0x43: return ("READ_TOC");
676     case 0x45: return ("PLAY_10");
677     case 0x47: return ("PLAY_MSF");
678     case 0x48: return ("PLAY_TRACK");
679     case 0x4b: return ("PAUSE");
680     case 0x51: return ("READ_DISK_INFO");
681     case 0x52: return ("READ_TRACK_INFO");
682     case 0x53: return ("RESERVE_TRACK");
683     case 0x54: return ("SEND_OPC_INFO");
684     case 0x55: return ("MODE_SELECT_BIG");
685     case 0x58: return ("REPAIR_TRACK");
686     case 0x59: return ("READ_MASTER_CUE");
687     case 0x5a: return ("MODE_SENSE_BIG");
688     case 0x5b: return ("CLOSE_TRACK/SESSION");
689     case 0x5c: return ("READ_BUFFER_CAPACITY");
690     case 0x5d: return ("SEND_CUE_SHEET");
691     case 0xa1: return ("BLANK_CMD");
692     case 0xa3: return ("SEND_KEY");
693     case 0xa4: return ("REPORT_KEY");
694     case 0xa5: return ("PLAY_12");
695     case 0xa6: return ("LOAD_UNLOAD");
696     case 0xad: return ("READ_DVD_STRUCTURE");
697     case 0xb4: return ("PLAY_CD");
698     case 0xbb: return ("SET_SPEED");
699     case 0xbd: return ("MECH_STATUS");
700     case 0xbe: return ("READ_CD");
701     case 0xff: return ("POLL_DSC");
702     default: {
703         static char buffer[20];
704         sprintf(buffer, "unknown CMD (0x%02x)", cmd);
705         return buffer;
706         }
707     }
708 }
709
710 static char *
711 atapi_skey2str(u_int8_t skey)
712 {
713     switch (skey) {
714     case 0x00: return ("NO SENSE");
715     case 0x01: return ("RECOVERED ERROR");
716     case 0x02: return ("NOT READY");
717     case 0x03: return ("MEDIUM ERROR");
718     case 0x04: return ("HARDWARE ERROR");
719     case 0x05: return ("ILLEGAL REQUEST");
720     case 0x06: return ("UNIT ATTENTION");
721     case 0x07: return ("DATA PROTECT");
722     case 0x08: return ("BLANK CHECK");
723     case 0x09: return ("VENDOR SPECIFIC");
724     case 0x0a: return ("COPY ABORTED");
725     case 0x0b: return ("ABORTED COMMAND");
726     case 0x0c: return ("EQUAL");
727     case 0x0d: return ("VOLUME OVERFLOW");
728     case 0x0e: return ("MISCOMPARE");
729     case 0x0f: return ("RESERVED");
730     default: return("UNKNOWN");
731     }
732 }