Synchronize various changes from FreeBSD. This is not exhaustive but gets
[dragonfly.git] / sys / dev / disk / nata / ata-disk.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/ata-disk.c,v 1.199 2006/09/14 19:12:29 sos Exp $
27  * $DragonFly: src/sys/dev/disk/nata/ata-disk.c,v 1.7 2008/03/24 06:41:56 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/device.h>
37 #include <sys/devicestat.h>
38 #include <sys/disk.h>
39 #include <sys/libkern.h>
40 #include <sys/malloc.h>
41 #include <sys/module.h>
42 #include <sys/nata.h>
43 #include <sys/systm.h>
44
45 #include <vm/pmap.h>
46
47 #include <machine/md_var.h>
48
49 #include "ata-all.h"
50 #include "ata-disk.h"
51 #include "ata_if.h"
52
53 /* device structure */
54 static  d_open_t        ad_open;
55 static  d_close_t       ad_close;
56 static  d_ioctl_t       ad_ioctl;
57 static  d_strategy_t    ad_strategy;
58 static  d_dump_t        ad_dump;
59 static struct dev_ops ad_ops = {
60         { "ad", 116, D_DISK },
61         .d_open =       ad_open,
62         .d_close =      ad_close,
63         .d_read =       physread,
64         .d_write =      physwrite,
65         .d_ioctl =      ad_ioctl,
66         .d_strategy =   ad_strategy,
67         .d_dump =       ad_dump,
68 };
69
70 /* prototypes */
71 static void ad_init(device_t);
72 static void ad_done(struct ata_request *);
73 static void ad_describe(device_t dev);
74 static int ad_version(u_int16_t);
75
76 /* local vars */
77 static MALLOC_DEFINE(M_AD, "ad_driver", "ATA disk driver");
78
79 static int
80 ad_probe(device_t dev)
81 {
82     struct ata_device *atadev = device_get_softc(dev);
83
84     if (!(atadev->param.config & ATA_PROTO_ATAPI) ||
85         (atadev->param.config == ATA_CFA_MAGIC1) ||
86         (atadev->param.config == ATA_CFA_MAGIC2) ||
87         (atadev->param.config == ATA_CFA_MAGIC3))
88         return 0;
89     else
90         return ENXIO;
91 }
92
93 static int
94 ad_attach(device_t dev)
95 {
96     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
97     struct ata_device *atadev = device_get_softc(dev);
98     struct disk_info info;
99     struct ad_softc *adp;
100     cdev_t cdev;
101     u_int32_t lbasize;
102     u_int64_t lbasize48;
103
104     /* check that we have a virgin disk to attach */
105     if (device_get_ivars(dev))
106         return EEXIST;
107
108     adp = kmalloc(sizeof(struct ad_softc), M_AD, M_INTWAIT | M_ZERO);
109     device_set_ivars(dev, adp);
110
111     if ((atadev->param.atavalid & ATA_FLAG_54_58) &&
112         atadev->param.current_heads && atadev->param.current_sectors) {
113         adp->heads = atadev->param.current_heads;
114         adp->sectors = atadev->param.current_sectors;
115         adp->total_secs = (u_int32_t)atadev->param.current_size_1 |
116                           ((u_int32_t)atadev->param.current_size_2 << 16);
117     }
118     else {
119         adp->heads = atadev->param.heads;
120         adp->sectors = atadev->param.sectors;
121         adp->total_secs = atadev->param.cylinders * adp->heads * adp->sectors;  
122     }
123     lbasize = (u_int32_t)atadev->param.lba_size_1 |
124               ((u_int32_t)atadev->param.lba_size_2 << 16);
125
126     /* does this device need oldstyle CHS addressing */
127     if (!ad_version(atadev->param.version_major) || !lbasize)
128         atadev->flags |= ATA_D_USE_CHS;
129
130     /* use the 28bit LBA size if valid or bigger than the CHS mapping */
131     if (atadev->param.cylinders == 16383 || adp->total_secs < lbasize)
132         adp->total_secs = lbasize;
133
134     /* use the 48bit LBA size if valid */
135     lbasize48 = ((u_int64_t)atadev->param.lba_size48_1) |
136                 ((u_int64_t)atadev->param.lba_size48_2 << 16) |
137                 ((u_int64_t)atadev->param.lba_size48_3 << 32) |
138                 ((u_int64_t)atadev->param.lba_size48_4 << 48);
139     if ((atadev->param.support.command2 & ATA_SUPPORT_ADDRESS48) &&
140         lbasize48 > ATA_MAX_28BIT_LBA)
141         adp->total_secs = lbasize48;
142
143     /* init device parameters */
144     ad_init(dev);
145
146     /* create the disk device */
147     /* XXX TGEN Maybe use DEVSTAT_ALL_SUPPORTED, DEVSTAT_TYPE_DIRECT,
148        DEVSTAT_PRIORITY_MAX. */
149     devstat_add_entry(&adp->stats, "ad", device_get_unit(dev), DEV_BSIZE,
150                       DEVSTAT_NO_ORDERED_TAGS,
151                       DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_IDE,
152                       DEVSTAT_PRIORITY_DISK);
153     cdev = disk_create(device_get_unit(dev), &adp->disk, &ad_ops);
154     cdev->si_drv1 = dev;
155     if (ch->dma)
156         cdev->si_iosize_max = ch->dma->max_iosize;
157     else
158         cdev->si_iosize_max = DFLTPHYS;
159     adp->cdev = cdev;
160
161     bzero(&info, sizeof(info));
162     info.d_media_blksize = DEV_BSIZE;           /* mandatory */
163     info.d_media_blocks = adp->total_secs;
164
165     info.d_secpertrack = adp->sectors;          /* optional */
166     info.d_nheads = adp->heads;
167     info.d_ncylinders = adp->total_secs/(adp->heads*adp->sectors);
168     info.d_secpercyl = adp->sectors * adp->heads;
169
170     device_add_child(dev, "subdisk", device_get_unit(dev));
171     bus_generic_attach(dev);
172
173     /* announce we are here */
174     ad_describe(dev);
175
176     disk_setdiskinfo(&adp->disk, &info);
177
178     return 0;
179 }
180
181 static int
182 ad_detach(device_t dev)
183 {
184     struct ad_softc *adp = device_get_ivars(dev);
185     device_t *children;
186     int nchildren, i;
187
188     /* check that we have a valid disk to detach */
189     if (!adp)
190         return ENXIO;
191
192 #if 0 /* XXX TGEN Probably useless, we fail the queue below. */
193     /* check that the disk is closed */
194     if (adp->ad_flags & AD_DISK_OPEN)
195         return EBUSY;
196 #endif /* 0 */
197     
198     /* detach & delete all children */
199     if (!device_get_children(dev, &children, &nchildren)) {
200         for (i = 0; i < nchildren; i++)
201             if (children[i])
202                 device_delete_child(dev, children[i]);
203         kfree(children, M_TEMP);
204     }
205
206     /* detroy disk from the system so we dont get any further requests */
207     disk_invalidate(&adp->disk);
208     disk_destroy(&adp->disk);
209
210     /* fail requests on the queue and any thats "in flight" for this device */
211     ata_fail_requests(dev);
212
213     /* dont leave anything behind */
214     /* disk_destroy() already took care of the dev_ops */
215     devstat_remove_entry(&adp->stats);
216     device_set_ivars(dev, NULL);
217     kfree(adp, M_AD);
218     return 0;
219 }
220
221 static void
222 ad_shutdown(device_t dev)
223 {
224     struct ata_device *atadev = device_get_softc(dev);
225
226     if (atadev->param.support.command2 & ATA_SUPPORT_FLUSHCACHE)
227         ata_controlcmd(dev, ATA_FLUSHCACHE, 0, 0, 0);
228 }
229
230 static int
231 ad_reinit(device_t dev)
232 {
233     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
234     struct ata_device *atadev = device_get_softc(dev);
235
236     /* if detach pending, return error */
237     if (((atadev->unit == ATA_MASTER) && !(ch->devices & ATA_ATA_MASTER)) ||
238         ((atadev->unit == ATA_SLAVE) && !(ch->devices & ATA_ATA_SLAVE))) {
239         return 1;
240     }
241     ad_init(dev);
242     return 0;
243 }
244
245 static int
246 ad_open(struct dev_open_args *ap)
247 {
248     device_t dev = ap->a_head.a_dev->si_drv1;
249     struct ad_softc *adp = device_get_ivars(dev);
250
251     if (!adp || adp->cdev == NULL)
252         return ENXIO;
253     if(!device_is_attached(dev))
254         return EBUSY;
255
256 #if 0 /* XXX TGEN Probably useless, queue will be failed on detach. */
257     adp->ad_flags &= AD_DISK_OPEN;
258 #endif /* 0 */
259     return 0;
260 }
261
262 static int
263 ad_close(struct dev_close_args *ap)
264 {
265 #if 0 /* XXX TGEN Probably useless, queue will be failed on detach. */
266     device_t dev = ap->a_head.a_dev->si_drv1;
267     struct ad_softc *adp = device_get_ivars(dev);
268     adp->ad_flags |= AD_DISK_OPEN;
269 #endif /* 0 */
270     return 0;
271 }
272
273 static int
274 ad_ioctl(struct dev_ioctl_args *ap)
275 {
276     return ata_device_ioctl(ap->a_head.a_dev->si_drv1, ap->a_cmd, ap->a_data);
277 }
278
279 static int
280 ad_strategy(struct dev_strategy_args *ap)
281 {
282     device_t dev =  ap->a_head.a_dev->si_drv1;
283     struct bio *bp = ap->a_bio;
284     struct buf *bbp = bp->bio_buf;
285     struct ata_device *atadev = device_get_softc(dev);
286     struct ata_request *request;
287     struct ad_softc *adp = device_get_ivars(dev);
288
289     if (!(request = ata_alloc_request())) {
290         device_printf(dev, "FAILURE - out of memory in strategy\n");
291         bbp->b_flags |= B_ERROR;
292         bbp->b_error = ENOMEM;
293         biodone(bp);
294         return(0);
295     }
296
297     /* setup request */
298     request->dev = dev;
299     request->bio = bp;
300     request->callback = ad_done;
301     request->timeout = 5;
302     request->retries = 2;
303     request->data = bbp->b_data;
304     request->bytecount = bbp->b_bcount;
305     /* lba is block granularity, convert byte granularity bio_offset */
306     request->u.ata.lba = (u_int64_t)(bp->bio_offset >> DEV_BSHIFT);
307     request->u.ata.count = request->bytecount / DEV_BSIZE;
308     request->transfersize = min(bbp->b_bcount, atadev->max_iosize);
309
310     switch (bbp->b_cmd) {
311     case BUF_CMD_READ:
312         request->flags = ATA_R_READ;
313         if (atadev->mode >= ATA_DMA) {
314             request->u.ata.command = ATA_READ_DMA;
315             request->flags |= ATA_R_DMA;
316         }
317         else if (request->transfersize > DEV_BSIZE)
318             request->u.ata.command = ATA_READ_MUL;
319         else
320             request->u.ata.command = ATA_READ;
321         break;
322     case BUF_CMD_WRITE:
323         request->flags = ATA_R_WRITE;
324         if (atadev->mode >= ATA_DMA) {
325             request->u.ata.command = ATA_WRITE_DMA;
326             request->flags |= ATA_R_DMA;
327         }
328         else if (request->transfersize > DEV_BSIZE)
329             request->u.ata.command = ATA_WRITE_MUL;
330         else
331             request->u.ata.command = ATA_WRITE;
332         break;
333 #if 0   /* NOT YET */
334     case BUF_CMD_FLUSH:
335         request->u.ata.lba = 0;
336         request->u.ata.count = 0;
337         request->u.ata.feature = 0;
338         request->bytecount = 0;
339         request->transfersize = 0;
340         request->flags = ATA_R_CONTROL;
341         request->u.ata.command = ATA_FLUSHCACHE;
342         break;
343 #endif
344     default:
345         device_printf(dev, "FAILURE - unknown BUF operation\n");
346         ata_free_request(request);
347         bbp->b_flags |= B_ERROR;
348         bbp->b_error = EIO;
349         biodone(bp);
350         return(0);
351     }
352     request->flags |= ATA_R_ORDERED;
353     devstat_start_transaction(&adp->stats);
354     ata_queue_request(request);
355     return(0);
356 }
357
358 static void
359 ad_done(struct ata_request *request)
360 {
361     struct ad_softc *adp = device_get_ivars(request->dev);
362     struct bio *bp = request->bio;
363     struct buf *bbp = bp->bio_buf;
364
365     /* finish up transfer */
366     if ((bbp->b_error = request->result))
367         bbp->b_flags |= B_ERROR;
368     bbp->b_resid = bbp->b_bcount - request->donecount;
369     devstat_end_transaction_buf(&adp->stats, bbp);
370     biodone(bp);
371     ata_free_request(request);
372 }
373
374 static int
375 ad_dump(struct dev_dump_args *ap)
376 {
377     device_t dev = ap->a_head.a_dev->si_drv1;
378     struct ata_device *atadev = device_get_softc(dev);
379     struct ata_request request;
380     vm_paddr_t addr = 0;
381     long blkcnt;
382     int dumppages = MAXDUMPPGS;
383     int error = 0;
384     int i;
385
386     blkcnt = howmany(PAGE_SIZE, ap->a_secsize);
387
388     while (ap->a_count > 0) {
389         caddr_t va = NULL;
390
391         if ((ap->a_count /blkcnt) < dumppages)
392             dumppages = ap->a_count / blkcnt;
393
394         for (i = 0; i < dumppages; ++i) {
395             vm_paddr_t a = addr + (i * PAGE_SIZE);
396             if (is_physical_memory(a))
397                 va = pmap_kenter_temporary(trunc_page(a), i);
398             else
399                 va = pmap_kenter_temporary(trunc_page(0), i);
400         }
401
402         bzero(&request, sizeof(struct ata_request));
403         request.dev = dev;
404         /* request.bio = NULL; */
405         request.timeout = 5;
406         request.retries = 2;
407         request.data = va;
408         request.bytecount = dumppages * PAGE_SIZE;
409         request.u.ata.lba = ap->a_blkno;
410         request.u.ata.count = request.bytecount / DEV_BSIZE;
411         request.transfersize = min(request.bytecount, atadev->max_iosize);
412         request.flags = ATA_R_WRITE | ATA_R_AT_HEAD;
413         if (atadev->mode >= ATA_DMA) {
414             request.u.ata.command = ATA_WRITE_DMA;
415             request.flags |= ATA_DMA;
416         } else if (request.transfersize > DEV_BSIZE)
417             request.u.ata.command = ATA_WRITE_MUL;
418         else
419             request.u.ata.command = ATA_WRITE;
420         ata_queue_request(&request);
421         if (request.result)
422             return request.result;
423
424         if (dumpstatus(addr, (off_t)ap->a_count * DEV_BSIZE) < 0)
425             return EINTR;
426
427         ap->a_blkno += blkcnt * dumppages;
428         ap->a_count -= blkcnt * dumppages;
429         addr += PAGE_SIZE * dumppages;
430     }
431
432     /* flush buffers to media */
433     if (atadev->param.support.command2 & ATA_SUPPORT_FLUSHCACHE)
434         error = ata_controlcmd(dev, ATA_FLUSHCACHE, 0, 0, 0);
435     return error;
436 }
437
438 static void
439 ad_init(device_t dev)
440 {
441     struct ata_device *atadev = device_get_softc(dev);
442
443     ATA_SETMODE(device_get_parent(dev), dev);
444
445     /* enable readahead caching */
446     if (atadev->param.support.command1 & ATA_SUPPORT_LOOKAHEAD)
447         ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_ENAB_RCACHE, 0, 0);
448
449     /* enable write caching if supported and configured */
450     if (atadev->param.support.command1 & ATA_SUPPORT_WRITECACHE) {
451         if (ata_wc)
452             ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_ENAB_WCACHE, 0, 0);
453         else
454             ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_DIS_WCACHE, 0, 0);
455     }
456
457     /* use multiple sectors/interrupt if device supports it */
458     if (ad_version(atadev->param.version_major)) {
459         int secsperint = max(1, min(atadev->param.sectors_intr, 16));
460
461         if (!ata_controlcmd(dev, ATA_SET_MULTI, 0, 0, secsperint))
462             atadev->max_iosize = secsperint * DEV_BSIZE;
463     }
464     else
465         atadev->max_iosize = DEV_BSIZE;
466 }
467
468 void
469 ad_describe(device_t dev)
470 {
471     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
472     struct ata_device *atadev = device_get_softc(dev);
473     struct ad_softc *adp = device_get_ivars(dev);
474     u_int8_t *marker, vendor[64], product[64];
475
476     /* try to seperate the ATA model string into vendor and model parts */
477     if ((marker = index(atadev->param.model, ' ')) ||
478         (marker = index(atadev->param.model, '-'))) {
479         int len = (marker - atadev->param.model);
480
481         strncpy(vendor, atadev->param.model, len);
482         vendor[len++] = 0;
483         strcat(vendor, " ");
484         strncpy(product, atadev->param.model + len, 40 - len);
485         vendor[40 - len] = 0;
486     }
487     else {
488         if (!strncmp(atadev->param.model, "ST", 2))
489             strcpy(vendor, "Seagate ");
490         else if (!strncmp(atadev->param.model, "HDS", 3))
491             strcpy(vendor, "Hitachi ");
492         else
493             strcpy(vendor, "");
494         strncpy(product, atadev->param.model, 40);
495     }
496
497     device_printf(dev, "%lluMB <%s%s %.8s> at ata%d-%s %s%s\n",
498                   (unsigned long long)(adp->total_secs / (1048576 / DEV_BSIZE)),
499                   vendor, product, atadev->param.revision,
500                   device_get_unit(ch->dev),
501                   (atadev->unit == ATA_MASTER) ? "master" : "slave",
502                   (adp->flags & AD_F_TAG_ENABLED) ? "tagged " : "",
503                   ata_mode2str(atadev->mode));
504     if (bootverbose) {
505         device_printf(dev, "%llu sectors [%lluC/%dH/%dS] "
506                       "%d sectors/interrupt %d depth queue\n",
507                       (unsigned long long)adp->total_secs,(unsigned long long)(
508                       adp->total_secs / (adp->heads * adp->sectors)),
509                       adp->heads, adp->sectors, atadev->max_iosize / DEV_BSIZE,
510                       adp->num_tags + 1);
511     }
512 }
513
514 static int
515 ad_version(u_int16_t version)
516 {
517     int bit;
518
519     if (version == 0xffff)
520         return 0;
521     for (bit = 15; bit >= 0; bit--)
522         if (version & (1<<bit))
523             return bit;
524     return 0;
525 }
526
527 static device_method_t ad_methods[] = {
528     /* device interface */
529     DEVMETHOD(device_probe,     ad_probe),
530     DEVMETHOD(device_attach,    ad_attach),
531     DEVMETHOD(device_detach,    ad_detach),
532     DEVMETHOD(device_shutdown,  ad_shutdown),
533
534     /* ATA methods */
535     DEVMETHOD(ata_reinit,       ad_reinit),
536
537     { 0, 0 }
538 };
539
540 static driver_t ad_driver = {
541     "ad",
542     ad_methods,
543     0,
544 };
545
546 devclass_t ad_devclass;
547
548 DRIVER_MODULE(ad, ata, ad_driver, ad_devclass, NULL, NULL);
549 MODULE_VERSION(ad, 1);
550 MODULE_DEPEND(ad, ata, 1, 1, 1);