f625a217c4c49317ba41a23d66ee22a939a60124
[dragonfly.git] / sys / dev / disk / nata / atapi-tape.c
1 /*-
2  * Copyright (c) 1998 - 2006 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  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/ata/atapi-tape.c,v 1.101 2006/01/05 21:27:19 sos Exp $
27  * $DragonFly: src/sys/dev/disk/nata/atapi-tape.c,v 1.4 2008/08/30 02:56:11 dillon Exp $
28  */
29
30 #include "opt_ata.h"
31
32 #include <sys/param.h>
33 #include <sys/bio.h>
34 #include <sys/buf.h>
35 #include <sys/bus.h>
36 #include <sys/conf.h>
37 #include <sys/device.h>
38 #include <sys/devicestat.h>
39 #include <sys/disk.h>
40 #include <sys/kernel.h>
41 #include <sys/libkern.h>
42 #include <sys/malloc.h>
43 #include <sys/module.h>
44 #include <sys/mtio.h>
45 #include <sys/nata.h>
46 #include <sys/systm.h>
47
48 #include "ata-all.h"
49 #include "atapi-tape.h"
50 #include "ata_if.h"
51
52 /* device structure */
53 static  d_open_t        ast_open;
54 static  d_close_t       ast_close;
55 static  d_ioctl_t       ast_ioctl;
56 static  d_strategy_t    ast_strategy;
57 static struct dev_ops ast_ops = {
58         { "ast", 119, D_TAPE | D_TRACKCLOSE },
59         .d_open =       ast_open,
60         .d_close =      ast_close,
61         .d_read =       physread,
62         .d_write =      physwrite,
63         .d_ioctl =      ast_ioctl,
64         .d_strategy =   ast_strategy
65 };
66
67 /* prototypes */
68 static int ast_sense(device_t);
69 static void ast_describe(device_t);
70 static void ast_done(struct ata_request *);
71 static int ast_mode_sense(device_t, int, void *, int); 
72 static int ast_mode_select(device_t, void *, int);
73 static int ast_write_filemark(device_t, u_int8_t);
74 static int ast_read_position(device_t, int, struct ast_readposition *);
75 static int ast_space(device_t, u_int8_t, int32_t);
76 static int ast_locate(device_t, int, u_int32_t);
77 static int ast_prevent_allow(device_t, int);
78 static int ast_load_unload(device_t, u_int8_t);
79 static int ast_rewind(device_t);
80 static int ast_erase(device_t);
81 static int ast_test_ready(device_t);
82 static int ast_wait_dsc(device_t, int);
83
84 /* internal vars */
85 static u_int64_t ast_total = 0;
86 static MALLOC_DEFINE(M_AST, "ast_driver", "ATAPI tape driver buffers");
87
88 static int
89 ast_probe(device_t dev)
90 {
91     struct ata_device *atadev = device_get_softc(dev);
92
93     if ((atadev->param.config & ATA_PROTO_ATAPI) &&
94         (atadev->param.config & ATA_ATAPI_TYPE_MASK) == ATA_ATAPI_TYPE_TAPE)
95         return 0;
96     else
97         return ENXIO;
98 }
99
100 static int
101 ast_attach(device_t dev)
102 {
103     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
104     struct ata_device *atadev = device_get_softc(dev);
105     struct ast_softc *stp;
106     struct ast_readposition position;
107     cdev_t cdev;
108
109     stp = kmalloc(sizeof(struct ast_softc), M_AST, M_WAITOK | M_ZERO);
110     device_set_ivars(dev, stp);
111     ATA_SETMODE(device_get_parent(dev), dev);
112
113     if (ast_sense(dev)) {
114         device_set_ivars(dev, NULL);
115         kfree(stp, M_AST);
116         return ENXIO;
117     }
118     if (!strcmp(atadev->param.model, "OnStream DI-30")) {
119         struct ast_transferpage transfer;
120         struct ast_identifypage identify;
121
122         stp->flags |= F_ONSTREAM;
123         bzero(&transfer, sizeof(struct ast_transferpage));
124         ast_mode_sense(dev, ATAPI_TAPE_TRANSFER_PAGE,
125                        &transfer, sizeof(transfer));
126         bzero(&identify, sizeof(struct ast_identifypage));
127         ast_mode_sense(dev, ATAPI_TAPE_IDENTIFY_PAGE,
128                        &identify, sizeof(identify));
129         strncpy(identify.ident, "FBSD", 4);
130         ast_mode_select(dev, &identify, sizeof(identify));
131         ast_read_position(dev, 0, &position);
132     }
133
134     devstat_add_entry(&stp->stats, "ast", device_get_unit(dev), DEV_BSIZE,
135                       DEVSTAT_NO_ORDERED_TAGS,
136                       DEVSTAT_TYPE_SEQUENTIAL | DEVSTAT_TYPE_IF_IDE,
137                       DEVSTAT_PRIORITY_TAPE);
138     dev_ops_add(&ast_ops, dkunitmask(), dkmakeunit(device_get_unit(dev)));
139     cdev = make_dev(&ast_ops, 2 * device_get_unit(dev), UID_ROOT, GID_OPERATOR,
140                     0640, "ast%d", device_get_unit(dev));
141     reference_dev(cdev);
142     cdev->si_drv1 = dev;
143     if (ch->dma)
144         cdev->si_iosize_max = ch->dma->max_iosize;
145     else
146         cdev->si_iosize_max = DFLTPHYS;
147     stp->cdev1 = cdev;
148     cdev = make_dev(&ast_ops, 2 * device_get_unit(dev) + 1, UID_ROOT,
149                     GID_OPERATOR, 0640, "nast%d", device_get_unit(dev));
150     reference_dev(cdev);
151     cdev->si_drv1 = dev;
152     if (ch->dma)
153         cdev->si_iosize_max = ch->dma->max_iosize;
154     else
155         cdev->si_iosize_max = DFLTPHYS;
156     stp->cdev2 = cdev;
157
158     /* announce we are here and ready */
159     ast_describe(dev);
160     return 0;
161 }
162
163 static int      
164 ast_detach(device_t dev)
165 {   
166     struct ast_softc *stp = device_get_ivars(dev);
167     
168     /* detroy devices from the system so we dont get any further requests */
169     destroy_dev(stp->cdev1);
170     destroy_dev(stp->cdev2);
171
172     /* fail requests on the queue and any thats "in flight" for this device */
173     ata_fail_requests(dev);
174
175     /* dont leave anything behind */
176     kprintf("devfs: Please check that only the right ata tape device was removed!!!\n");
177     dev_ops_remove_minor(&ast_ops, /*dkunitmask(), */dkmakeunit(device_get_unit(dev)));
178     devstat_remove_entry(&stp->stats);
179     device_set_ivars(dev, NULL);
180     kfree(stp, M_AST);
181     return 0;
182 }
183
184 static void
185 ast_shutdown(device_t dev)
186 {
187     struct ata_device *atadev = device_get_softc(dev);
188
189     if (atadev->param.support.command2 & ATA_SUPPORT_FLUSHCACHE)
190         ata_controlcmd(dev, ATA_FLUSHCACHE, 0, 0, 0);
191 }
192
193 static int
194 ast_reinit(device_t dev)
195 {
196     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
197     struct ata_device *atadev = device_get_softc(dev);
198     struct ast_softc *stp = device_get_ivars(dev);
199
200     if (((atadev->unit == ATA_MASTER) && !(ch->devices & ATA_ATAPI_MASTER)) ||
201         ((atadev->unit == ATA_SLAVE) && !(ch->devices & ATA_ATAPI_SLAVE))) {
202         device_set_ivars(dev, NULL);
203         kfree(stp, M_AST);
204         return 1;
205     }
206     ATA_SETMODE(device_get_parent(dev), dev);
207     return 0;
208 }
209
210 static int
211 ast_open(struct dev_open_args *ap)
212 {
213     device_t dev = ap->a_head.a_dev->si_drv1;
214     struct ata_device *atadev = device_get_softc(dev);
215     struct ast_softc *stp = device_get_ivars(dev);
216
217     if (!stp)
218         return ENXIO;
219     if (!device_is_attached(dev))
220         return EBUSY;
221
222     ast_test_ready(dev);
223     if (stp->cap.lock)
224         ast_prevent_allow(dev, 1);
225     if (ast_sense(dev))
226         device_printf(dev, "sense media type failed\n");
227
228     atadev->flags &= ~ATA_D_MEDIA_CHANGED;
229     stp->flags &= ~(F_DATA_WRITTEN | F_FM_WRITTEN);
230     ast_total = 0;
231     return 0;
232 }
233
234 static int 
235 ast_close(struct dev_close_args *ap)
236 {
237     device_t dev = ap->a_head.a_dev->si_drv1;
238     struct ast_softc *stp = device_get_ivars(dev);
239     cdev_t cdev = ap->a_head.a_dev;
240
241     /* flush buffers, some drives fail here, they should report ctl = 0 */
242     if (stp->cap.ctl && (stp->flags & F_DATA_WRITTEN))
243         ast_write_filemark(dev, 0);
244
245     /* write filemark if data written to tape */
246     if (!(stp->flags & F_ONSTREAM) &&
247         (stp->flags & (F_DATA_WRITTEN | F_FM_WRITTEN)) == F_DATA_WRITTEN)
248         ast_write_filemark(dev, ATAPI_WF_WRITE);
249
250     /* if minor is even rewind on close */
251     if (!(minor(cdev) & 0x01))
252         ast_rewind(dev);
253
254     if (stp->cap.lock && count_dev(cdev) == 1)
255         ast_prevent_allow(dev, 0);
256
257     stp->flags &= ~F_CTL_WARN;
258 #ifdef AST_DEBUG
259     device_printf(dev, "%llu total bytes transferred\n",
260                   (unsigned long long)ast_total);
261 #endif
262     return 0;
263 }
264
265 static int 
266 ast_ioctl(struct dev_ioctl_args *ap)
267 {
268     device_t dev = ap->a_head.a_dev->si_drv1;
269     struct ast_softc *stp = device_get_ivars(dev);
270     int error = 0;
271
272     switch (ap->a_cmd) {
273     case MTIOCGET:
274         {
275             struct mtget *g = (struct mtget *)ap->a_data;
276
277             bzero(g, sizeof(struct mtget));
278             g->mt_type = 7;
279             g->mt_density = 1;
280             g->mt_blksiz = stp->blksize;
281             g->mt_comp = stp->cap.compress;
282             g->mt_density0 = 0; g->mt_density1 = 0;
283             g->mt_density2 = 0; g->mt_density3 = 0;
284             g->mt_blksiz0 = 0; g->mt_blksiz1 = 0;
285             g->mt_blksiz2 = 0; g->mt_blksiz3 = 0;
286             g->mt_comp0 = 0; g->mt_comp1 = 0;
287             g->mt_comp2 = 0; g->mt_comp3 = 0;
288         }
289         break;   
290
291     case MTIOCTOP:
292         {       
293             int i;
294             struct mtop *mt = (struct mtop *)ap->a_data;
295
296             switch ((int16_t) (mt->mt_op)) {
297
298             case MTWEOF:
299                 for (i=0; i < mt->mt_count && !error; i++)
300                     error = ast_write_filemark(dev, ATAPI_WF_WRITE);
301                 break;
302
303             case MTFSF:
304                 if (mt->mt_count)
305                     error = ast_space(dev, ATAPI_SP_FM, mt->mt_count);
306                 break;
307
308             case MTBSF:
309                 if (mt->mt_count)
310                     error = ast_space(dev, ATAPI_SP_FM, -(mt->mt_count));
311                 break;
312
313             case MTREW:
314                 error = ast_rewind(dev);
315                 break;
316
317             case MTOFFL:
318                 error = ast_load_unload(dev, ATAPI_SS_EJECT);
319                 break;
320
321             case MTNOP:
322                 error = ast_write_filemark(dev, 0);
323                 break;
324
325             case MTERASE:
326                 error = ast_erase(dev);
327                 break;
328
329             case MTEOD:
330                 error = ast_space(dev, ATAPI_SP_EOD, 0);
331                 break;
332
333             case MTRETENS:
334                 error = ast_load_unload(dev, ATAPI_SS_RETENSION|ATAPI_SS_LOAD);
335                 break;
336
337             case MTFSR:         
338             case MTBSR:
339             case MTCACHE:
340             case MTNOCACHE:
341             case MTSETBSIZ:
342             case MTSETDNSTY:
343             case MTCOMP:
344             default:
345                 error = EINVAL;
346             }
347         }
348         break;
349
350     case MTIOCRDSPOS:
351         {
352             struct ast_readposition position;
353
354             if ((error = ast_read_position(dev, 0, &position)))
355                 break;
356             *(u_int32_t *)ap->a_data = position.tape;
357         }
358         break;
359
360     case MTIOCRDHPOS:
361         {
362             struct ast_readposition position;
363
364             if ((error = ast_read_position(dev, 1, &position)))
365                 break;
366             *(u_int32_t *)ap->a_data = position.tape;
367         }
368         break;
369
370     case MTIOCSLOCATE:
371         error = ast_locate(dev, 0, *(u_int32_t *)ap->a_data);
372         break;
373
374     case MTIOCHLOCATE:
375         error = ast_locate(dev, 1, *(u_int32_t *)ap->a_data);
376         break;
377
378     default:
379         error = ata_device_ioctl(dev, ap->a_cmd, ap->a_data);
380     }
381     return error;
382 }
383
384 static int
385 ast_strategy(struct dev_strategy_args *ap)
386 {
387     device_t dev = ap->a_head.a_dev->si_drv1;
388     struct bio *bp = ap->a_bio;
389     struct buf *bbp = bp->bio_buf;
390     struct ata_device *atadev = device_get_softc(dev);
391     struct ast_softc *stp = device_get_ivars(dev);
392     struct ata_request *request;
393     u_int32_t blkcount;
394     int8_t ccb[16];
395
396     /* if it's a null transfer, return immediatly. */
397     if (bbp->b_bcount == 0) {
398         bbp->b_resid = 0;
399         biodone(bp);
400         return 0;
401     }
402     if (!(bbp->b_cmd == BUF_CMD_READ) && (stp->flags & F_WRITEPROTECT)) {
403         bbp->b_flags |= B_ERROR;
404         bbp->b_error = EPERM;
405         biodone(bp);
406         return 0;
407     }
408     if (bbp->b_cmd != BUF_CMD_READ && bbp->b_cmd != BUF_CMD_WRITE) {
409         bbp->b_flags |= B_ERROR;
410         bbp->b_error = EIO;
411         biodone(bp);
412         return 0;
413     }
414         
415     /* check for != blocksize requests */
416     if (bbp->b_bcount % stp->blksize) {
417         device_printf(dev, "transfers must be multiple of %d\n", stp->blksize);
418         bbp->b_flags |= B_ERROR;
419         bbp->b_error = EIO;
420         biodone(bp);
421         return 0;
422     }
423
424     /* warn about transfers bigger than the device suggests */
425     if (bbp->b_bcount > stp->blksize * stp->cap.ctl) {  
426         if ((stp->flags & F_CTL_WARN) == 0) {
427             device_printf(dev, "WARNING: CTL exceeded %d>%d\n",
428                           bbp->b_bcount, stp->blksize * stp->cap.ctl);
429             stp->flags |= F_CTL_WARN;
430         }
431     }
432
433     bzero(ccb, sizeof(ccb));
434
435     if (bbp->b_cmd == BUF_CMD_READ)
436         ccb[0] = ATAPI_READ;
437     else
438         ccb[0] = ATAPI_WRITE;
439     
440     blkcount = bbp->b_bcount / stp->blksize;
441
442     ccb[1] = 1;
443     ccb[2] = blkcount >> 16;
444     ccb[3] = blkcount >> 8;
445     ccb[4] = blkcount;
446
447     if (!(request = ata_alloc_request())) {
448         bbp->b_flags |= B_ERROR;
449         bbp->b_error = ENOMEM;
450         biodone(bp);
451         return 0;
452     }
453     request->dev = dev;
454     request->bio = bp;
455     bcopy(ccb, request->u.atapi.ccb,
456           (atadev->param.config & ATA_PROTO_MASK) == 
457           ATA_PROTO_ATAPI_12 ? 16 : 12);
458     request->data = bbp->b_data;
459     request->bytecount = blkcount * stp->blksize;
460     request->transfersize = min(request->bytecount, 65534);
461     request->timeout = (ccb[0] == ATAPI_WRITE_BIG) ? 180 : 120;
462     request->retries = 2;
463     request->callback = ast_done;
464
465     switch (bbp->b_cmd) {
466     case BUF_CMD_READ:
467         request->flags |= (ATA_R_ATAPI | ATA_R_READ);
468         break;
469     case BUF_CMD_WRITE:
470         request->flags |= (ATA_R_ATAPI | ATA_R_WRITE);
471         break;
472     default:
473         panic("bbp->b_cmd");
474     }
475     devstat_start_transaction(&stp->stats);
476     ata_queue_request(request);
477     return 0;
478 }
479
480 static void 
481 ast_done(struct ata_request *request)
482 {
483     struct ast_softc *stp = device_get_ivars(request->dev);
484     struct bio *bp = request->bio;
485     struct buf *bbp = bp->bio_buf;
486
487     /* finish up transfer */
488     if ((bbp->b_error = request->result))
489         bbp->b_flags |= B_ERROR;
490     if (bbp->b_cmd == BUF_CMD_WRITE)
491         stp->flags |= F_DATA_WRITTEN;
492     bbp->b_resid = bbp->b_bcount - request->donecount;
493     ast_total += (bbp->b_bcount - bbp->b_resid);
494     devstat_end_transaction_buf(&stp->stats, bbp);
495     biodone(bp);
496     ata_free_request(request);
497 }
498
499 static int
500 ast_sense(device_t dev)
501 {
502     struct ast_softc *stp = device_get_ivars(dev);
503     int count;
504
505     /* get drive capabilities, some bugridden drives needs this repeated */
506     for (count = 0 ; count < 5 ; count++) {
507         if (!ast_mode_sense(dev, ATAPI_TAPE_CAP_PAGE,
508                             &stp->cap, sizeof(stp->cap)) &&
509             stp->cap.page_code == ATAPI_TAPE_CAP_PAGE) {
510             if (stp->cap.blk32k)
511                 stp->blksize = 32768;
512             if (stp->cap.blk1024)
513                 stp->blksize = 1024;
514             if (stp->cap.blk512)
515                 stp->blksize = 512;
516             if (!stp->blksize)
517                 continue;
518             stp->cap.max_speed = ntohs(stp->cap.max_speed);
519             stp->cap.max_defects = ntohs(stp->cap.max_defects);
520             stp->cap.ctl = ntohs(stp->cap.ctl);
521             stp->cap.speed = ntohs(stp->cap.speed);
522             stp->cap.buffer_size = ntohs(stp->cap.buffer_size);
523             return 0;
524         }
525     }
526     return 1;
527 }
528
529 static int
530 ast_mode_sense(device_t dev, int page, void *pagebuf, int pagesize)
531 {
532     int8_t ccb[16] = { ATAPI_MODE_SENSE, 0x08, page, pagesize>>8, pagesize,
533                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
534     int error;
535  
536     error = ata_atapicmd(dev, ccb, pagebuf, pagesize, ATA_R_READ, 10);
537     return error;
538 }
539
540 static int       
541 ast_mode_select(device_t dev, void *pagebuf, int pagesize)
542 {
543     int8_t ccb[16] = { ATAPI_MODE_SELECT, 0x10, 0, pagesize>>8, pagesize,
544                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
545      
546     return ata_atapicmd(dev, ccb, pagebuf, pagesize, 0, 10);
547 }
548
549 static int
550 ast_write_filemark(device_t dev, u_int8_t function)
551 {
552     struct ast_softc *stp = device_get_ivars(dev);
553     int8_t ccb[16] = { ATAPI_WEOF, 0x01, 0, 0, function, 0, 0, 0,
554                        0, 0, 0, 0, 0, 0, 0, 0 };
555     int error;
556
557     if (stp->flags & F_ONSTREAM)
558         ccb[4] = 0x00;          /* only flush buffers supported */
559     else {
560         if (function) {
561             if (stp->flags & F_FM_WRITTEN)
562                 stp->flags &= ~F_DATA_WRITTEN;
563             else
564                 stp->flags |= F_FM_WRITTEN;
565         }
566     }
567     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
568     if (error)
569         return error;
570     return ast_wait_dsc(dev, 10*60);
571 }
572
573 static int
574 ast_read_position(device_t dev, int hard, struct ast_readposition *position)
575 {
576     int8_t ccb[16] = { ATAPI_READ_POSITION, (hard ? 0x01 : 0), 0, 0, 0, 0, 0, 0,
577                        0, 0, 0, 0, 0, 0, 0, 0 };
578     int error;
579
580     error = ata_atapicmd(dev, ccb, (caddr_t)position, 
581                          sizeof(struct ast_readposition), ATA_R_READ, 10);
582     position->tape = ntohl(position->tape);
583     position->host = ntohl(position->host);
584     return error;
585 }
586
587 static int
588 ast_space(device_t dev, u_int8_t function, int32_t count)
589 {
590     int8_t ccb[16] = { ATAPI_SPACE, function, count>>16, count>>8, count,
591                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
592
593     return ata_atapicmd(dev, ccb, NULL, 0, 0, 60*60);
594 }
595
596 static int
597 ast_locate(device_t dev, int hard, u_int32_t pos)
598 {
599     int8_t ccb[16] = { ATAPI_LOCATE, 0x01 | (hard ? 0x4 : 0), 0,
600                        pos>>24, pos>>16, pos>>8, pos,
601                        0, 0, 0, 0, 0, 0, 0, 0, 0 };
602     int error;
603
604     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
605     if (error)
606         return error;
607     return ast_wait_dsc(dev, 60*60);
608 }
609
610 static int
611 ast_prevent_allow(device_t dev, int lock)
612 {
613     int8_t ccb[16] = { ATAPI_PREVENT_ALLOW, 0, 0, 0, lock,
614                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
615
616     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
617 }
618
619 static int
620 ast_load_unload(device_t dev, u_int8_t function)
621 {
622     struct ast_softc *stp = device_get_ivars(dev);
623     int8_t ccb[16] = { ATAPI_START_STOP, 0x01, 0, 0, function, 0, 0, 0,
624                        0, 0, 0, 0, 0, 0, 0, 0 };
625     int error;
626
627     if ((function & ATAPI_SS_EJECT) && !stp->cap.eject)
628         return 0;
629     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
630     if (error)
631         return error;
632     tsleep((caddr_t)&error, 0, "astlu", 1 * hz);
633     if (function == ATAPI_SS_EJECT)
634         return 0;
635     return ast_wait_dsc(dev, 60*60);
636 }
637
638 static int
639 ast_rewind(device_t dev)
640 {
641     int8_t ccb[16] = { ATAPI_REZERO, 0x01, 0, 0, 0, 0, 0, 0,
642                        0, 0, 0, 0, 0, 0, 0, 0 };
643     int error;
644
645     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
646     if (error)
647         return error;
648     return ast_wait_dsc(dev, 60*60);
649 }
650
651 static int
652 ast_erase(device_t dev)
653 {
654     int8_t ccb[16] = { ATAPI_ERASE, 3, 0, 0, 0, 0, 0, 0,
655                        0, 0, 0, 0, 0, 0, 0, 0 };
656     int error;
657
658     if ((error = ast_rewind(dev)))
659         return error;
660
661     return ata_atapicmd(dev, ccb, NULL, 0, 0, 60*60);
662 }
663
664 static int
665 ast_test_ready(device_t dev)
666 {
667     int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
668                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
669
670     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
671 }
672
673 static int
674 ast_wait_dsc(device_t dev, int timeout)
675 {
676     int error = 0;
677     int8_t ccb[16] = { ATAPI_POLL_DSC, 0, 0, 0, 0,
678                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
679
680     timeout *= hz;
681     while (timeout > 0) {
682         error = ata_atapicmd(dev, ccb, NULL, 0, 0, 0);
683         if (error != EBUSY)
684             break;
685         tsleep(&error, 0, "atpwt", hz / 2);
686         timeout -= (hz / 2);
687     }
688     return error;
689 }
690
691 static void 
692 ast_describe(device_t dev)
693 {
694     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
695     struct ata_device *atadev = device_get_softc(dev);
696     struct ast_softc *stp = device_get_ivars(dev);
697
698     if (bootverbose) {
699         device_printf(dev, "<%.40s/%.8s> tape drive at ata%d as %s\n",
700                       atadev->param.model, atadev->param.revision,
701                       device_get_unit(ch->dev),
702                       (atadev->unit == ATA_MASTER) ? "master" : "slave");
703         device_printf(dev, "%dKB/s, ", stp->cap.max_speed);
704         kprintf("transfer limit %d blk%s, ",
705                stp->cap.ctl, (stp->cap.ctl > 1) ? "s" : "");
706         kprintf("%dKB buffer, ", (stp->cap.buffer_size * DEV_BSIZE) / 1024);
707         kprintf("%s\n", ata_mode2str(atadev->mode));
708         device_printf(dev, "Medium: ");
709         switch (stp->cap.medium_type) {
710             case 0x00:
711                 kprintf("none"); break;
712             case 0x17:
713                 kprintf("Travan 1 (400 Mbyte)"); break;
714             case 0xb6:
715                 kprintf("Travan 4 (4 Gbyte)"); break;
716             case 0xda:
717                 kprintf("OnStream ADR (15Gyte)"); break;
718             default:
719                 kprintf("unknown (0x%x)", stp->cap.medium_type);
720         }
721         if (stp->cap.readonly) kprintf(", readonly");
722         if (stp->cap.reverse) kprintf(", reverse");
723         if (stp->cap.eformat) kprintf(", eformat");
724         if (stp->cap.qfa) kprintf(", qfa");
725         if (stp->cap.lock) kprintf(", lock");
726         if (stp->cap.locked) kprintf(", locked");
727         if (stp->cap.prevent) kprintf(", prevent");
728         if (stp->cap.eject) kprintf(", eject");
729         if (stp->cap.disconnect) kprintf(", disconnect");
730         if (stp->cap.ecc) kprintf(", ecc");
731         if (stp->cap.compress) kprintf(", compress");
732         if (stp->cap.blk512) kprintf(", 512b");
733         if (stp->cap.blk1024) kprintf(", 1024b");
734         if (stp->cap.blk32k) kprintf(", 32kb");
735         kprintf("\n");
736     }
737     else {
738         device_printf(dev, "TAPE <%.40s/%.8s> at ata%d-%s %s\n",
739                       atadev->param.model, atadev->param.revision,
740                       device_get_unit(ch->dev),
741                       (atadev->unit == ATA_MASTER) ? "master" : "slave",
742                       ata_mode2str(atadev->mode));
743     }
744 }
745
746 static device_method_t ast_methods[] = {
747     /* device interface */
748     DEVMETHOD(device_probe,     ast_probe),
749     DEVMETHOD(device_attach,    ast_attach),
750     DEVMETHOD(device_detach,    ast_detach),
751     DEVMETHOD(device_shutdown,  ast_shutdown),
752                            
753     /* ATA methods */
754     DEVMETHOD(ata_reinit,       ast_reinit),
755
756     { 0, 0 }
757 };
758             
759 static driver_t ast_driver = {
760     "ast",
761     ast_methods,
762     0,
763 };
764
765 static devclass_t ast_devclass;
766
767 DRIVER_MODULE(ast, ata, ast_driver, ast_devclass, NULL, NULL);
768 MODULE_VERSION(ast, 1);
769 MODULE_DEPEND(ast, ata, 1, 1, 1);