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