Add the MPIPE subsystem. This subsystem is used for 'pipelining' fixed-size
[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.5 2003/11/30 20:14:18 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_WAITOK | 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             ata_dmafree(atadev->channel, request->dmatab);
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     request = malloc(sizeof(struct atapi_request), M_ATAPI, M_NOWAIT|M_ZERO);
183     if (request == NULL) {
184         printf("WARNNIG: atapi_queue_cmd: malloc() would block\n");
185         request = malloc(sizeof(struct atapi_request), M_ATAPI, M_WAITOK|M_ZERO);
186     }
187
188     request->device = atadev;
189     request->data = data;
190     request->bytecount = count;
191     request->flags = flags;
192     request->error = EINPROGRESS;
193     request->timeout = timeout * hz;
194     request->ccbsize = atadev->param->packet_size ? 16 : 12;
195     bcopy(ccb, request->ccb, request->ccbsize);
196     if (callback) {
197         request->callback = callback;
198         request->driver = driver;
199     }
200     if (atadev->mode >= ATA_DMA) {
201         request->dmatab = ata_dmaalloc(atadev->channel, atadev->unit, M_NOWAIT);
202         if (request->dmatab == NULL) {
203             printf("WARNING: atapi_queue_cmd: ata_dmaalloc() would block\n");
204             request->dmatab = ata_dmaalloc(atadev->channel,
205                                         atadev->unit, M_WAITOK);
206         }
207     }
208
209 #ifdef ATAPI_DEBUG
210     ata_prtdev(atadev, "queueing %s ", atapi_cmd2str(request->ccb[0]));
211     atapi_dump("ccb = ", &request->ccb[0], sizeof(request->ccb));
212 #endif
213     /* append onto controller queue and try to start controller */
214     s = splbio();
215     if (flags & ATPR_F_AT_HEAD)
216         TAILQ_INSERT_HEAD(&atadev->channel->atapi_queue, request, chain);
217     else
218         TAILQ_INSERT_TAIL(&atadev->channel->atapi_queue, request, chain);
219     ata_start(atadev->channel);
220
221     /* if callback used, then just return, gets called from interrupt context */
222     if (callback) {
223         splx(s);
224         return 0;
225     }
226
227     /* only sleep when command is in progress */
228     if (request->error == EINPROGRESS)
229         tsleep((caddr_t)request, 0, "atprq", 0);
230     splx(s);
231     error = request->error;
232     if (error)
233          bcopy(&request->sense, atadev->result, sizeof(struct atapi_reqsense));
234     if (request->dmatab)
235         ata_dmafree(atadev->channel, request->dmatab);
236     free(request, M_ATAPI);
237     return error;
238 }
239     
240 void
241 atapi_start(struct ata_device *atadev)
242 {
243     switch (atadev->param->type) {
244 #if NATAPICD > 0
245     case ATAPI_TYPE_CDROM:
246         acd_start(atadev);
247         break; 
248 #endif
249 #if NATAPIFD > 0
250     case ATAPI_TYPE_DIRECT:
251         afd_start(atadev);
252         break; 
253 #endif
254 #if NATAPIST > 0
255     case ATAPI_TYPE_TAPE:
256         ast_start(atadev);
257         break; 
258 #endif
259     default:
260         return;
261     }
262 }
263
264 int
265 atapi_transfer(struct atapi_request *request)
266 {
267     struct ata_device *atadev = request->device;
268     int timout;
269     u_int8_t reason;
270
271 #ifdef ATAPI_DEBUG
272     ata_prtdev(atadev, "starting %s ", atapi_cmd2str(request->ccb[0]));
273     atapi_dump("ccb = ", &request->ccb[0], sizeof(request->ccb));
274 #endif
275     /* is this just a POLL DSC command ? */
276     if (request->ccb[0] == ATAPI_POLL_DSC) {
277         ATA_OUTB(atadev->channel->r_io, ATA_DRIVE, ATA_D_IBM | atadev->unit);
278         DELAY(10);
279         if (ATA_INB(atadev->channel->r_altio, ATA_ALTSTAT) & ATA_S_DSC)
280             request->error = 0;
281         else
282             request->error = EBUSY;
283         atapi_finish(request);
284         return ATA_OP_FINISHED;
285     }
286
287     /* start timeout for this command */
288     request->timeout_handle = timeout((timeout_t *)atapi_timeout, 
289                                       request, request->timeout);
290
291     if (!(request->flags & ATPR_F_INTERNAL))
292         atadev->cmd = request->ccb[0];
293
294     /* if DMA enabled setup DMA hardware */
295     request->flags &= ~ATPR_F_DMA_USED; 
296     if ((atadev->mode >= ATA_DMA) &&
297         (request->ccb[0] == ATAPI_READ || 
298          request->ccb[0] == ATAPI_READ_BIG ||
299          request->ccb[0] == ATAPI_READ_CD ||
300          ((request->ccb[0] == ATAPI_WRITE ||
301            request->ccb[0] == ATAPI_WRITE_BIG) &&
302           !(atadev->channel->flags & ATA_ATAPI_DMA_RO))) &&
303         !ata_dmasetup(atadev->channel, atadev->unit, request->dmatab,
304                       (void *)request->data, request->bytecount)) {
305         request->flags |= ATPR_F_DMA_USED;
306     }
307
308     /* start ATAPI operation */
309     if (ata_command(atadev, ATA_C_PACKET_CMD, 
310                     min(request->bytecount, 65534) << 8, 0,
311                     (request->flags & ATPR_F_DMA_USED) ? ATA_F_DMA : 0,
312                     ATA_IMMEDIATE))
313         ata_prtdev(atadev, "failure to send ATAPI packet command\n");
314
315     if (request->flags & ATPR_F_DMA_USED)
316         ata_dmastart(atadev->channel, atadev->unit, 
317                      request->dmatab, request->flags & ATPR_F_READ);
318
319     /* command interrupt device ? just return */
320     if (atadev->param->drq_type == ATAPI_DRQT_INTR)
321         return ATA_OP_CONTINUES;
322
323     /* ready to write ATAPI command */
324     timout = 5000; /* might be less for fast devices */
325     while (timout--) {
326         reason = ATA_INB(atadev->channel->r_io, ATA_IREASON);
327         atadev->channel->status = ATA_INB(atadev->channel->r_io, ATA_STATUS);
328         if (((reason & (ATA_I_CMD | ATA_I_IN)) |
329              (atadev->channel->status&(ATA_S_DRQ|ATA_S_BUSY)))==ATAPI_P_CMDOUT)
330             break;
331         DELAY(20);
332     }
333     if (timout <= 0) {
334         ata_prtdev(atadev, "failure to execute ATAPI packet command\n");
335         untimeout((timeout_t *)atapi_timeout, request, request->timeout_handle);
336         request->error = EIO;
337         atapi_finish(request);  
338         return ATA_OP_FINISHED;
339     }
340
341     /* this seems to be needed for some (slow) devices */
342     DELAY(10);
343
344     /* send actual command */
345     ATA_OUTSW(atadev->channel->r_io, ATA_DATA, (int16_t *)request->ccb,
346               request->ccbsize / sizeof(int16_t));
347     return ATA_OP_CONTINUES;
348 }
349
350 int
351 atapi_interrupt(struct atapi_request *request)
352 {
353     struct ata_device *atadev = request->device;
354     int reason, dma_stat = 0;
355
356     reason = (ATA_INB(atadev->channel->r_io, ATA_IREASON)&(ATA_I_CMD|ATA_I_IN))|
357              (atadev->channel->status & ATA_S_DRQ);
358
359     if (reason == ATAPI_P_CMDOUT) {
360         if (!(atadev->channel->status & ATA_S_DRQ)) {
361             ata_prtdev(atadev, "command interrupt without DRQ\n");
362             untimeout((timeout_t *)atapi_timeout,
363                       request, request->timeout_handle);
364             request->error = EIO;
365             atapi_finish(request);      
366             return ATA_OP_FINISHED;
367         }
368         ATA_OUTSW(atadev->channel->r_io, ATA_DATA, (int16_t *)request->ccb,
369                   request->ccbsize / sizeof(int16_t));
370         return ATA_OP_CONTINUES;
371     }
372
373     if (request->flags & ATPR_F_DMA_USED) {
374         dma_stat = ata_dmadone(atadev->channel);
375         if ((atadev->channel->status & (ATA_S_ERROR | ATA_S_DWF)) ||
376             dma_stat & ATA_BMSTAT_ERROR) {
377             request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
378         }
379         else {
380             request->result = 0;
381             request->donecount = request->bytecount;
382             request->bytecount = 0;
383         }
384     }
385     else {
386         int length = ATA_INB(atadev->channel->r_io, ATA_CYL_LSB) |
387                      ATA_INB(atadev->channel->r_io, ATA_CYL_MSB) << 8;
388
389         switch (reason) {
390         case ATAPI_P_WRITE:
391             if (request->flags & ATPR_F_READ) {
392                 request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
393                 ata_prtdev(atadev, "%s trying to write on read buffer\n",
394                            atapi_cmd2str(atadev->cmd));
395                 break;
396             }
397             atapi_write(request, length);
398             return ATA_OP_CONTINUES;
399         
400         case ATAPI_P_READ:
401             if (!(request->flags & ATPR_F_READ)) {
402                 request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
403                 ata_prtdev(atadev, "%s trying to read on write buffer\n",
404                            atapi_cmd2str(atadev->cmd));
405                 break;
406             }
407             atapi_read(request, length);
408             return ATA_OP_CONTINUES;
409
410         case ATAPI_P_DONEDRQ:
411             ata_prtdev(atadev, "%s DONEDRQ\n", atapi_cmd2str(atadev->cmd));
412             if (request->flags & ATPR_F_READ)
413                 atapi_read(request, length);
414             else
415                 atapi_write(request, length);
416             /* FALLTHROUGH */
417
418         case ATAPI_P_ABORT:
419         case ATAPI_P_DONE:
420             if (atadev->channel->status & (ATA_S_ERROR | ATA_S_DWF))
421                 request->result = ATA_INB(atadev->channel->r_io, ATA_ERROR);
422             else 
423                 if (!(request->flags & ATPR_F_INTERNAL))
424                     request->result = 0;
425             break;
426
427         default:
428             ata_prtdev(atadev, "unknown transfer phase %d\n", reason);
429         }
430     }
431     untimeout((timeout_t *)atapi_timeout, request, request->timeout_handle);
432
433     /* check for error, if valid sense key, queue a request sense cmd */
434     if ((request->result & ATAPI_SK_MASK) && 
435         request->ccb[0] != ATAPI_REQUEST_SENSE) {
436         bzero(request->ccb, request->ccbsize);
437         request->ccb[0] = ATAPI_REQUEST_SENSE;
438         request->ccb[4] = sizeof(struct atapi_reqsense);
439         request->bytecount = sizeof(struct atapi_reqsense);
440         request->flags &= ATPR_F_QUIET;
441         request->flags |= ATPR_F_READ | ATPR_F_INTERNAL;
442         TAILQ_INSERT_HEAD(&atadev->channel->atapi_queue, request, chain);
443     }
444     else {
445         if (request->result) {
446             switch ((request->result & ATAPI_SK_MASK)) {
447             case ATAPI_SK_NO_SENSE:
448                 request->error = 0;
449                 break;
450
451             case ATAPI_SK_RECOVERED_ERROR:
452                 ata_prtdev(atadev, "%s - recovered error\n",
453                            atapi_cmd2str(atadev->cmd));
454                 request->error = 0;
455                 break;
456
457             case ATAPI_SK_NOT_READY:
458                 request->error = EBUSY;
459                 break;
460
461             case ATAPI_SK_UNIT_ATTENTION:
462                 atadev->flags |= ATA_D_MEDIA_CHANGED;
463                 request->error = EIO;
464                 break;
465
466             default: 
467                 request->error = EIO;
468
469                 if (request->flags & ATPR_F_QUIET)
470                     break;
471
472                 ata_prtdev(atadev, "%s - %s asc=0x%02x ascq=0x%02x ",
473                            atapi_cmd2str(atadev->cmd), 
474                            atapi_skey2str(request->sense.sense_key), 
475                            request->sense.asc, request->sense.ascq);
476                 if (request->sense.sksv)
477                     printf("sks=0x%02x 0x%02x 0x%02x ",
478                            request->sense.sk_specific,
479                            request->sense.sk_specific1,
480                            request->sense.sk_specific2);
481                 printf("error=0x%02x\n", request->result & ATAPI_E_MASK);
482             }
483         }
484         else
485             request->error = 0;
486         atapi_finish(request);  
487     }
488     return ATA_OP_FINISHED;
489 }
490
491 void
492 atapi_reinit(struct ata_device *atadev)
493 {
494     /* reinit device parameters */
495      if (atadev->mode >= ATA_DMA)
496         ata_dmainit(atadev->channel, atadev->unit,
497                     (ata_pmode(atadev->param) < 0) ?
498                     (atadev->param->support_dma ? 4:0):ata_pmode(atadev->param),
499                     (ata_wmode(atadev->param) < 0) ? 
500                     (atadev->param->support_dma ? 2:0):ata_wmode(atadev->param),
501                     ata_umode(atadev->param));
502     else
503         ata_dmainit(atadev->channel, atadev->unit,
504                     ata_pmode(atadev->param)<0 ? 0 : ata_pmode(atadev->param),
505                     -1, -1);
506 }
507
508 int
509 atapi_test_ready(struct ata_device *atadev)
510 {
511     int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
512                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
513         
514     return atapi_queue_cmd(atadev, ccb, NULL, 0, 0, 30, NULL, NULL);
515 }
516         
517 int
518 atapi_wait_dsc(struct ata_device *atadev, int timeout)
519 {
520     int error = 0;
521     int8_t ccb[16] = { ATAPI_POLL_DSC, 0, 0, 0, 0,
522                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
523
524     timeout *= hz;
525     while (timeout > 0) {
526         error = atapi_queue_cmd(atadev, ccb, NULL, 0, 0, 0, NULL, NULL);
527         if (error != EBUSY)
528             break;
529         tsleep((caddr_t)&error, 0, "atpwt", hz / 2);
530         timeout -= (hz / 2);
531     }
532     return error;
533 }
534
535 void
536 atapi_dump(char *label, void *data, int len)
537 {
538     u_int8_t *p = data;
539
540     printf("%s %02x", label, *p++);
541     while (--len > 0) 
542         printf ("-%02x", *p++);
543     printf("\n");
544 }
545
546 static void
547 atapi_read(struct atapi_request *request, int length)
548 {
549     int8_t **buffer = (int8_t **)&request->data;
550     int size = min(request->bytecount, length);
551     struct ata_channel *ch = request->device->channel;
552     int resid;
553
554     if (request->flags & ATPR_F_INTERNAL)
555         *buffer = (int8_t *)&request->sense;
556
557     if (ch->flags & ATA_USE_16BIT || (size % sizeof(int32_t)))
558         ATA_INSW(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer), 
559                  size / sizeof(int16_t));
560     else
561         ATA_INSL(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
562                  size / sizeof(int32_t));
563
564     if (request->bytecount < length) {
565         ata_prtdev(request->device, "read data overrun %d/%d\n",
566                    length, request->bytecount);
567         for (resid=request->bytecount; resid<length; resid+=sizeof(int16_t))
568              ATA_INW(ch->r_io, ATA_DATA);
569     }
570     *buffer += size;
571     request->bytecount -= size;
572     request->donecount += size;
573 }
574
575 static void
576 atapi_write(struct atapi_request *request, int length)
577 {
578     int8_t **buffer = (int8_t **)&request->data;
579     int size = min(request->bytecount, length);
580     struct ata_channel *ch = request->device->channel;
581     int resid;
582
583     if (request->flags & ATPR_F_INTERNAL)
584         *buffer = (int8_t *)&request->sense;
585
586     if (ch->flags & ATA_USE_16BIT || (size % sizeof(int32_t)))
587         ATA_OUTSW(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
588                   size / sizeof(int16_t));
589     else
590         ATA_OUTSL(ch->r_io, ATA_DATA, (void *)((uintptr_t)*buffer),
591                   size / sizeof(int32_t));
592
593     if (request->bytecount < length) {
594         ata_prtdev(request->device, "write data underrun %d/%d\n",
595                    length, request->bytecount);
596         for (resid=request->bytecount; resid<length; resid+=sizeof(int16_t))
597             ATA_OUTW(ch->r_io, ATA_DATA, 0);
598     }
599     *buffer += size;
600     request->bytecount -= size;
601     request->donecount += size;
602 }
603
604 static void
605 atapi_finish(struct atapi_request *request)
606 {
607 #ifdef ATAPI_DEBUG
608     ata_prtdev(request->device, "finished %s%s\n",
609                request->callback ? "callback " : "",
610                atapi_cmd2str(request->ccb[0]));
611 #endif
612     if (request->callback) {
613         if (!((request->callback)(request))) {
614             if (request->dmatab)
615                 ata_dmafree(request->device->channel, request->dmatab);
616             free(request, M_ATAPI);
617         }
618     }
619     else 
620         wakeup((caddr_t)request);       
621 }
622
623 static void 
624 atapi_timeout(struct atapi_request *request)
625 {
626     struct ata_device *atadev = request->device;
627
628     atadev->channel->running = NULL;
629     ata_prtdev(atadev, "%s command timeout - resetting\n", 
630                atapi_cmd2str(request->ccb[0]));
631
632     if (request->flags & ATPR_F_DMA_USED) {
633         ata_dmadone(atadev->channel);
634         if (request->retries == ATAPI_MAX_RETRIES) {
635             ata_dmainit(atadev->channel, atadev->unit,
636                         (ata_pmode(atadev->param) < 0) ? 0 :
637                          ata_pmode(atadev->param), -1, -1);
638             ata_prtdev(atadev, "trying fallback to PIO mode\n");
639             request->retries = 0;
640         }
641     }
642
643     /* if retries still permit, reinject this request */
644     if (request->retries++ < ATAPI_MAX_RETRIES) {
645         TAILQ_INSERT_HEAD(&atadev->channel->atapi_queue, request, chain);
646     }
647     else {
648         /* retries all used up, return error */
649         request->error = EIO;
650         wakeup((caddr_t)request);
651     } 
652     ata_reinit(atadev->channel);
653 }
654
655 static char *
656 atapi_cmd2str(u_int8_t cmd)
657 {
658     switch (cmd) {
659     case 0x00: return ("TEST_UNIT_READY");
660     case 0x01: return ("REZERO");
661     case 0x03: return ("REQUEST_SENSE");
662     case 0x04: return ("FORMAT_UNIT");
663     case 0x08: return ("READ");
664     case 0x0a: return ("WRITE");
665     case 0x10: return ("WEOF");
666     case 0x11: return ("SPACE");
667     case 0x15: return ("MODE_SELECT");
668     case 0x19: return ("ERASE");
669     case 0x1a: return ("MODE_SENSE");
670     case 0x1b: return ("START_STOP");
671     case 0x1e: return ("PREVENT_ALLOW");
672     case 0x25: return ("READ_CAPACITY");
673     case 0x28: return ("READ_BIG");
674     case 0x2a: return ("WRITE_BIG");
675     case 0x2b: return ("LOCATE");
676     case 0x34: return ("READ_POSITION");
677     case 0x35: return ("SYNCHRONIZE_CACHE");
678     case 0x3b: return ("WRITE_BUFFER");
679     case 0x3c: return ("READ_BUFFER");
680     case 0x42: return ("READ_SUBCHANNEL");
681     case 0x43: return ("READ_TOC");
682     case 0x45: return ("PLAY_10");
683     case 0x47: return ("PLAY_MSF");
684     case 0x48: return ("PLAY_TRACK");
685     case 0x4b: return ("PAUSE");
686     case 0x51: return ("READ_DISK_INFO");
687     case 0x52: return ("READ_TRACK_INFO");
688     case 0x53: return ("RESERVE_TRACK");
689     case 0x54: return ("SEND_OPC_INFO");
690     case 0x55: return ("MODE_SELECT_BIG");
691     case 0x58: return ("REPAIR_TRACK");
692     case 0x59: return ("READ_MASTER_CUE");
693     case 0x5a: return ("MODE_SENSE_BIG");
694     case 0x5b: return ("CLOSE_TRACK/SESSION");
695     case 0x5c: return ("READ_BUFFER_CAPACITY");
696     case 0x5d: return ("SEND_CUE_SHEET");
697     case 0xa1: return ("BLANK_CMD");
698     case 0xa3: return ("SEND_KEY");
699     case 0xa4: return ("REPORT_KEY");
700     case 0xa5: return ("PLAY_12");
701     case 0xa6: return ("LOAD_UNLOAD");
702     case 0xad: return ("READ_DVD_STRUCTURE");
703     case 0xb4: return ("PLAY_CD");
704     case 0xbb: return ("SET_SPEED");
705     case 0xbd: return ("MECH_STATUS");
706     case 0xbe: return ("READ_CD");
707     case 0xff: return ("POLL_DSC");
708     default: {
709         static char buffer[20];
710         sprintf(buffer, "unknown CMD (0x%02x)", cmd);
711         return buffer;
712         }
713     }
714 }
715
716 static char *
717 atapi_skey2str(u_int8_t skey)
718 {
719     switch (skey) {
720     case 0x00: return ("NO SENSE");
721     case 0x01: return ("RECOVERED ERROR");
722     case 0x02: return ("NOT READY");
723     case 0x03: return ("MEDIUM ERROR");
724     case 0x04: return ("HARDWARE ERROR");
725     case 0x05: return ("ILLEGAL REQUEST");
726     case 0x06: return ("UNIT ATTENTION");
727     case 0x07: return ("DATA PROTECT");
728     case 0x08: return ("BLANK CHECK");
729     case 0x09: return ("VENDOR SPECIFIC");
730     case 0x0a: return ("COPY ABORTED");
731     case 0x0b: return ("ABORTED COMMAND");
732     case 0x0c: return ("EQUAL");
733     case 0x0d: return ("VOLUME OVERFLOW");
734     case 0x0e: return ("MISCOMPARE");
735     case 0x0f: return ("RESERVED");
736     default: return("UNKNOWN");
737     }
738 }