Merge from vendor branch LESS:
[dragonfly.git] / sys / dev / raid / aac / aac_disk.c
1 /*-
2  * Copyright (c) 2000 Michael Smith
3  * Copyright (c) 2001 Scott Long
4  * Copyright (c) 2000 BSDi
5  * Copyright (c) 2001 Adaptec, Inc.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *      $FreeBSD: src/sys/dev/aac/aac_disk.c,v 1.3.2.8 2003/01/11 18:39:39 scottl Exp $
30  *      $DragonFly: src/sys/dev/raid/aac/aac_disk.c,v 1.18 2007/06/17 23:50:16 dillon Exp $
31  */
32
33 #include "opt_aac.h"
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/sysctl.h>
39
40 #include "aac_compat.h"
41 #include <sys/bus.h>
42 #include <sys/conf.h>
43 #include <sys/devicestat.h>
44 #include <sys/disk.h>
45 #include <sys/dtype.h>
46 #include <sys/rman.h>
47
48 #include <vm/vm.h>
49 #include <vm/pmap.h>
50
51 #include <machine/md_var.h>
52
53 #include "aacreg.h"
54 #include "aac_ioctl.h"
55 #include "aacvar.h"
56
57 /*
58  * Interface to parent.
59  */
60 static int aac_disk_probe(device_t dev);
61 static int aac_disk_attach(device_t dev);
62 static int aac_disk_detach(device_t dev);
63
64 /*
65  * Interface to the device switch.
66  */
67 static  d_open_t        aac_disk_open;
68 static  d_close_t       aac_disk_close;
69 static  d_strategy_t    aac_disk_strategy;
70 static  d_dump_t        aac_disk_dump;
71
72 #define AAC_DISK_CDEV_MAJOR     151
73
74 static struct dev_ops aac_disk_ops = {
75         { "aacd", AAC_DISK_CDEV_MAJOR, D_DISK },
76         .d_open =               aac_disk_open,
77         .d_close =              aac_disk_close,
78         .d_read =               physread,
79         .d_write =              physwrite,
80         .d_strategy =           aac_disk_strategy,
81         .d_dump =               aac_disk_dump,
82 };
83
84 devclass_t              aac_disk_devclass;
85
86 static device_method_t aac_disk_methods[] = {
87         DEVMETHOD(device_probe, aac_disk_probe),
88         DEVMETHOD(device_attach,        aac_disk_attach),
89         DEVMETHOD(device_detach,        aac_disk_detach),
90         { 0, 0 }
91 };
92
93 static driver_t aac_disk_driver = {
94         "aacd",
95         aac_disk_methods,
96         sizeof(struct aac_disk)
97 };
98
99 #define AAC_MAXIO       65536
100
101 DRIVER_MODULE(aacd, aac, aac_disk_driver, aac_disk_devclass, 0, 0);
102
103 /* sysctl tunables */
104 static unsigned int aac_iosize_max = AAC_MAXIO; /* due to limits of the card */
105 TUNABLE_INT("hw.aac.iosize_max", &aac_iosize_max);
106
107 SYSCTL_DECL(_hw_aac);
108 SYSCTL_UINT(_hw_aac, OID_AUTO, iosize_max, CTLFLAG_RD, &aac_iosize_max, 0,
109             "Max I/O size per transfer to an array");
110
111 /*
112  * Handle open from generic layer.
113  *
114  * This is called by the diskslice code on first open in order to get the 
115  * basic device geometry paramters.
116  */
117 static int
118 aac_disk_open(struct dev_open_args *ap)
119 {
120         cdev_t dev = ap->a_head.a_dev;
121         struct aac_disk *sc;
122         struct disk_info info;
123
124         debug_called(0);
125
126         sc = (struct aac_disk *)dev->si_drv1;
127         
128         if (sc == NULL) {
129                 kprintf("aac_disk_open: No Softc\n");
130                 return (ENXIO);
131         }
132
133         /* check that the controller is up and running */
134         if (sc->ad_controller->aac_state & AAC_STATE_SUSPEND) {
135                 kprintf("Controller Suspended controller state = 0x%x\n",
136                        sc->ad_controller->aac_state);
137                 return(ENXIO);
138         }
139
140         /* build synthetic label */
141         bzero(&info, sizeof(info));
142         info.d_media_blksize= AAC_BLOCK_SIZE;           /* mandatory */
143         info.d_media_blocks = sc->ad_size;
144
145         info.d_type = DTYPE_ESDI;                       /* optional */
146         info.d_secpertrack   = sc->ad_sectors;
147         info.d_nheads   = sc->ad_heads;
148         info.d_ncylinders = sc->ad_cylinders;
149         info.d_secpercyl  = sc->ad_sectors * sc->ad_heads;
150
151         disk_setdiskinfo(&sc->ad_disk, &info);
152         sc->ad_flags |= AAC_DISK_OPEN;
153         return (0);
154 }
155
156 /*
157  * Handle last close of the disk device.
158  */
159 static int
160 aac_disk_close(struct dev_close_args *ap)
161 {
162         cdev_t dev = ap->a_head.a_dev;
163         struct aac_disk *sc;
164
165         debug_called(0);
166
167         sc = (struct aac_disk *)dev->si_drv1;
168         
169         if (sc == NULL)
170                 return (ENXIO);
171
172         sc->ad_flags &= ~AAC_DISK_OPEN;
173         return (0);
174 }
175
176 /*
177  * Handle an I/O request.
178  */
179 static int
180 aac_disk_strategy(struct dev_strategy_args *ap)
181 {
182         cdev_t dev = ap->a_head.a_dev;
183         struct bio *bio = ap->a_bio;
184         struct buf *bp = bio->bio_buf;
185         struct aac_disk *sc;
186
187         debug_called(4);
188
189         sc = (struct aac_disk *)dev->si_drv1;
190
191         /* bogus disk? */
192         if (sc == NULL) {
193                 bp->b_flags |= B_ERROR;
194                 bp->b_error = EINVAL;
195                 biodone(bio);
196                 return(0);
197         }
198
199         /* do-nothing operation? */
200         if (bp->b_bcount == 0) {
201                 bp->b_resid = bp->b_bcount;
202                 biodone(bio);
203                 return(0);
204         }
205
206         /* perform accounting */
207         devstat_start_transaction(&sc->ad_stats);
208
209         /* pass the bio to the controller - it can work out who we are */
210         aac_submit_bio(sc, bio);
211         return(0);
212 }
213
214 /*
215  * Dump memory out to an array
216  *
217  * This queues blocks of memory of size AAC_MAXIO to the controller and waits
218  * for the controller to complete the requests.
219  */
220 static int
221 aac_disk_dump(struct dev_dump_args *ap)
222 {
223         cdev_t dev = ap->a_head.a_dev;
224         struct aac_disk *ad;
225         struct aac_softc *sc;
226         vm_offset_t addr;
227         long blkcnt;
228         int dumppages;
229         int i, error;
230
231         ad = dev->si_drv1;
232         addr = 0;
233         dumppages = AAC_MAXIO / PAGE_SIZE;
234
235         if (ad == NULL)
236                 return (ENXIO);
237
238         sc= ad->ad_controller;
239
240         blkcnt = howmany(PAGE_SIZE, ap->a_secsize);
241
242         while (ap->a_count > 0) {
243                 caddr_t va = NULL;
244
245                 if ((ap->a_count / blkcnt) < dumppages)
246                         dumppages = ap->a_count / blkcnt;
247
248                 for (i = 0; i < dumppages; ++i) {
249                         vm_offset_t a = addr + (i * PAGE_SIZE);
250                         if (is_physical_memory(a)) {
251                                 va = pmap_kenter_temporary(trunc_page(a), i);
252                         } else {
253                                 va = pmap_kenter_temporary(trunc_page(0), i);
254                         }
255                 }
256
257 retry:
258                 /*
259                  * Queue the block to the controller.  If the queue is full,
260                  * EBUSY will be returned.
261                  */
262                 error = aac_dump_enqueue(ad, ap->a_blkno, va, dumppages);
263                 if (error && (error != EBUSY))
264                         return (error);
265
266                 if (!error) {
267                         if (dumpstatus(addr, (off_t)(ap->a_count * DEV_BSIZE)) < 0)
268                         return (EINTR);
269
270                         ap->a_blkno += blkcnt * dumppages;
271                         ap->a_count -= blkcnt * dumppages;
272                         addr += PAGE_SIZE * dumppages;
273                         if (ap->a_count > 0)
274                         continue;
275                 }
276
277                 /*
278                  * Either the queue was full on the last attemp, or we have no
279                  * more data to dump.  Let the queue drain out and retry the
280                  * block if the queue was full.
281                  */
282                 aac_dump_complete(sc);
283
284                 if (error == EBUSY)
285                         goto retry;
286         }
287
288         return (0);
289 }
290
291 /*
292  * Handle completion of an I/O request.
293  */
294 void
295 aac_biodone(struct bio *bio, const char *code)
296 {
297         struct buf *bp = bio->bio_buf;
298         struct aac_disk *sc;
299
300         debug_called(4);
301
302         sc = (struct aac_disk *)bio->bio_driver_info;
303
304         devstat_end_transaction_buf(&sc->ad_stats, bp);
305         if (bp->b_flags & B_ERROR) {
306                 diskerr(bio, sc->ad_dev_t,
307                         code, 0, 0);
308         }
309         biodone(bio);
310 }
311
312 /*
313  * Stub only.
314  */
315 static int
316 aac_disk_probe(device_t dev)
317 {
318
319         debug_called(2);
320
321         return (0);
322 }
323
324 /*
325  * Attach a unit to the controller.
326  */
327 static int
328 aac_disk_attach(device_t dev)
329 {
330         struct aac_disk *sc;
331         
332         debug_called(0);
333
334         sc = (struct aac_disk *)device_get_softc(dev);
335
336         /* initialise our softc */
337         sc->ad_controller =
338             (struct aac_softc *)device_get_softc(device_get_parent(dev));
339         sc->ad_container = device_get_ivars(dev);
340         sc->ad_dev = dev;
341
342         /*
343          * require that extended translation be enabled - other drivers read the
344          * disk!
345          */
346         sc->ad_size = sc->ad_container->co_mntobj.Capacity;
347         if (sc->ad_size >= (2 * 1024 * 1024)) {         /* 2GB */
348                 sc->ad_heads = 255;
349                 sc->ad_sectors = 63;
350         } else if (sc->ad_size >= (1 * 1024 * 1024)) {  /* 1GB */
351                 sc->ad_heads = 128;
352                 sc->ad_sectors = 32;
353         } else {
354                 sc->ad_heads = 64;
355                 sc->ad_sectors = 32;
356         }
357         sc->ad_cylinders = (sc->ad_size / (sc->ad_heads * sc->ad_sectors));
358
359         device_printf(dev, "%uMB (%u sectors)\n",
360                       sc->ad_size / ((1024 * 1024) / AAC_BLOCK_SIZE),
361                       sc->ad_size);
362
363         devstat_add_entry(&sc->ad_stats, "aacd", device_get_unit(dev),
364                           AAC_BLOCK_SIZE, DEVSTAT_NO_ORDERED_TAGS,
365                           DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER, 
366                           DEVSTAT_PRIORITY_ARRAY);
367
368         /* attach a generic disk device to ourselves */
369         sc->ad_dev_t = disk_create(device_get_unit(dev), &sc->ad_disk,
370                                    &aac_disk_ops);
371         sc->ad_dev_t->si_drv1 = sc;
372
373         sc->ad_dev_t->si_iosize_max = aac_iosize_max;
374         sc->unit = device_get_unit(dev);
375
376         return (0);
377 }
378
379 /*
380  * Disconnect ourselves from the system.
381  */
382 static int
383 aac_disk_detach(device_t dev)
384 {
385         struct aac_disk *sc;
386
387         debug_called(2);
388
389         sc = (struct aac_disk *)device_get_softc(dev);
390
391         if (sc->ad_flags & AAC_DISK_OPEN)
392                 return(EBUSY);
393
394         devstat_remove_entry(&sc->ad_stats);
395         disk_destroy(&sc->ad_disk);
396         return(0);
397 }