File:
[DragonFly] /
src /
sys /
dev /
raid /
amr /
amr.c
Revision
1.9:
download - view:
text,
annotated -
select for diffs
Thu May 13 23:49:18 2004 UTC (9 years ago) by
dillon
Branches:
MAIN
CVS tags:
HEAD
device switch 1/many: Remove d_autoq, add d_clone (where d_autoq was).
d_autoq was used to allow the device port dispatch to mix old-style synchronous
calls with new style messaging calls within a particular device. It was never
used for that purpose.
d_clone will be more fully implemented as work continues. We are going to
install d_port in the dev_t (struct specinfo) structure itself and d_clone
will be needed to allow devices to 'revector' the port on a minor-number
by minor-number basis, in particular allowing minor numbers to be directly
dispatched to distinct threads. This is something we will be needing later
on.
1: /*-
2: * Copyright (c) 1999,2000 Michael Smith
3: * Copyright (c) 2000 BSDi
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
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 AND CONTRIBUTORS ``AS IS'' AND
16: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: * SUCH DAMAGE.
26: *
27: * Copyright (c) 2002 Eric Moore
28: * Copyright (c) 2002 LSI Logic Corporation
29: * All rights reserved.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. The party using or redistributing the source code and binary forms
40: * agrees to the disclaimer below and the terms and conditions set forth
41: * herein.
42: *
43: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
44: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53: * SUCH DAMAGE.
54: *
55: * $FreeBSD: src/sys/dev/amr/amr.c,v 1.7.2.13 2003/01/15 13:41:18 emoore Exp $
56: * $DragonFly: src/sys/dev/raid/amr/amr.c,v 1.9 2004/05/13 23:49:18 dillon Exp $
57: */
58:
59: /*
60: * Driver for the AMI MegaRaid family of controllers.
61: */
62:
63: #include <sys/param.h>
64: #include <sys/systm.h>
65: #include <sys/malloc.h>
66: #include <sys/kernel.h>
67:
68: #include "amr_compat.h"
69: #include <sys/bus.h>
70: #include <sys/conf.h>
71: #include <sys/devicestat.h>
72: #include <sys/disk.h>
73: #include <sys/stat.h>
74:
75: #include <machine/bus_memio.h>
76: #include <machine/bus_pio.h>
77: #include <machine/bus.h>
78: #include <machine/resource.h>
79: #include <sys/rman.h>
80:
81: #include <bus/pci/pcireg.h>
82: #include <bus/pci/pcivar.h>
83:
84: #include "amrio.h"
85: #include "amrreg.h"
86: #include "amrvar.h"
87: #define AMR_DEFINE_TABLES
88: #include "amr_tables.h"
89:
90: #define AMR_CDEV_MAJOR 132
91:
92: static d_open_t amr_open;
93: static d_close_t amr_close;
94: static d_ioctl_t amr_ioctl;
95:
96: static struct cdevsw amr_cdevsw = {
97: /* name */ "amr",
98: /* maj */ AMR_CDEV_MAJOR,
99: /* flags */ 0,
100: /* port */ NULL,
101: /* clone */ NULL,
102:
103: /* open */ amr_open,
104: /* close */ amr_close,
105: /* read */ noread,
106: /* write */ nowrite,
107: /* ioctl */ amr_ioctl,
108: /* poll */ nopoll,
109: /* mmap */ nommap,
110: /* strategy */ nostrategy,
111: /* dump */ nodump,
112: /* psize */ nopsize
113: };
114:
115: /*
116: * Initialisation, bus interface.
117: */
118: static void amr_startup(void *arg);
119:
120: /*
121: * Command wrappers
122: */
123: static int amr_query_controller(struct amr_softc *sc);
124: static void *amr_enquiry(struct amr_softc *sc, size_t bufsize,
125: u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual);
126: static void amr_completeio(struct amr_command *ac);
127: static int amr_support_ext_cdb(struct amr_softc *sc);
128:
129: /*
130: * Command buffer allocation.
131: */
132: static void amr_alloccmd_cluster(struct amr_softc *sc);
133: static void amr_freecmd_cluster(struct amr_command_cluster *acc);
134:
135: /*
136: * Command processing.
137: */
138: static int amr_bio_command(struct amr_softc *sc, struct amr_command **acp);
139: static int amr_wait_command(struct amr_command *ac);
140: static int amr_getslot(struct amr_command *ac);
141: static void amr_mapcmd(struct amr_command *ac);
142: static void amr_unmapcmd(struct amr_command *ac);
143: static int amr_start(struct amr_command *ac);
144: static void amr_complete(void *context, int pending);
145:
146: /*
147: * Status monitoring
148: */
149: static void amr_periodic(void *data);
150:
151: /*
152: * Interface-specific shims
153: */
154: static int amr_quartz_submit_command(struct amr_softc *sc);
155: static int amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave);
156: static int amr_quartz_poll_command(struct amr_command *ac);
157:
158: static int amr_std_submit_command(struct amr_softc *sc);
159: static int amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave);
160: static int amr_std_poll_command(struct amr_command *ac);
161: static void amr_std_attach_mailbox(struct amr_softc *sc);
162:
163: #ifdef AMR_BOARD_INIT
164: static int amr_quartz_init(struct amr_softc *sc);
165: static int amr_std_init(struct amr_softc *sc);
166: #endif
167:
168: /*
169: * Debugging
170: */
171: static void amr_describe_controller(struct amr_softc *sc);
172: #ifdef AMR_DEBUG
173: #if 0
174: static void amr_printcommand(struct amr_command *ac);
175: #endif
176: #endif
177:
178: DECLARE_DUMMY_MODULE(amr);
179:
180: /********************************************************************************
181: ********************************************************************************
182: Inline Glue
183: ********************************************************************************
184: ********************************************************************************/
185:
186: /********************************************************************************
187: ********************************************************************************
188: Public Interfaces
189: ********************************************************************************
190: ********************************************************************************/
191:
192: /********************************************************************************
193: * Initialise the controller and softc.
194: */
195: int
196: amr_attach(struct amr_softc *sc)
197: {
198:
199: debug_called(1);
200:
201: /*
202: * Initialise per-controller queues.
203: */
204: TAILQ_INIT(&sc->amr_completed);
205: TAILQ_INIT(&sc->amr_freecmds);
206: TAILQ_INIT(&sc->amr_cmd_clusters);
207: TAILQ_INIT(&sc->amr_ready);
208: bioq_init(&sc->amr_bioq);
209:
210: #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
211: /*
212: * Initialise command-completion task.
213: */
214: TASK_INIT(&sc->amr_task_complete, 0, amr_complete, sc);
215: #endif
216:
217: debug(2, "queue init done");
218:
219: /*
220: * Configure for this controller type.
221: */
222: if (AMR_IS_QUARTZ(sc)) {
223: sc->amr_submit_command = amr_quartz_submit_command;
224: sc->amr_get_work = amr_quartz_get_work;
225: sc->amr_poll_command = amr_quartz_poll_command;
226: } else {
227: sc->amr_submit_command = amr_std_submit_command;
228: sc->amr_get_work = amr_std_get_work;
229: sc->amr_poll_command = amr_std_poll_command;
230: amr_std_attach_mailbox(sc);;
231: }
232:
233: #ifdef AMR_BOARD_INIT
234: if ((AMR_IS_QUARTZ(sc) ? amr_quartz_init(sc) : amr_std_init(sc))))
235: return(ENXIO);
236: #endif
237:
238: /*
239: * Quiz controller for features and limits.
240: */
241: if (amr_query_controller(sc))
242: return(ENXIO);
243:
244: debug(2, "controller query complete");
245:
246: /*
247: * Attach our 'real' SCSI channels to CAM.
248: */
249: if (amr_cam_attach(sc))
250: return(ENXIO);
251: debug(2, "CAM attach done");
252:
253: /*
254: * Create the control device.
255: */
256: sc->amr_dev_t = make_dev(&amr_cdevsw, device_get_unit(sc->amr_dev), UID_ROOT, GID_OPERATOR,
257: S_IRUSR | S_IWUSR, "amr%d", device_get_unit(sc->amr_dev));
258: sc->amr_dev_t->si_drv1 = sc;
259:
260: /*
261: * Schedule ourselves to bring the controller up once interrupts are
262: * available.
263: */
264: bzero(&sc->amr_ich, sizeof(struct intr_config_hook));
265: sc->amr_ich.ich_func = amr_startup;
266: sc->amr_ich.ich_arg = sc;
267: if (config_intrhook_establish(&sc->amr_ich) != 0) {
268: device_printf(sc->amr_dev, "can't establish configuration hook\n");
269: return(ENOMEM);
270: }
271:
272: /*
273: * Print a little information about the controller.
274: */
275: amr_describe_controller(sc);
276:
277: debug(2, "attach complete");
278: return(0);
279: }
280:
281: /********************************************************************************
282: * Locate disk resources and attach children to them.
283: */
284: static void
285: amr_startup(void *arg)
286: {
287: struct amr_softc *sc = (struct amr_softc *)arg;
288: struct amr_logdrive *dr;
289: int i, error;
290:
291: debug_called(1);
292:
293: /* pull ourselves off the intrhook chain */
294: config_intrhook_disestablish(&sc->amr_ich);
295:
296: /* get up-to-date drive information */
297: if (amr_query_controller(sc)) {
298: device_printf(sc->amr_dev, "can't scan controller for drives\n");
299: return;
300: }
301:
302: /* iterate over available drives */
303: for (i = 0, dr = &sc->amr_drive[0]; (i < AMR_MAXLD) && (dr->al_size != 0xffffffff); i++, dr++) {
304: /* are we already attached to this drive? */
305: if (dr->al_disk == 0) {
306: /* generate geometry information */
307: if (dr->al_size > 0x200000) { /* extended translation? */
308: dr->al_heads = 255;
309: dr->al_sectors = 63;
310: } else {
311: dr->al_heads = 64;
312: dr->al_sectors = 32;
313: }
314: dr->al_cylinders = dr->al_size / (dr->al_heads * dr->al_sectors);
315:
316: dr->al_disk = device_add_child(sc->amr_dev, NULL, -1);
317: if (dr->al_disk == 0)
318: device_printf(sc->amr_dev, "device_add_child failed\n");
319: device_set_ivars(dr->al_disk, dr);
320: }
321: }
322:
323: if ((error = bus_generic_attach(sc->amr_dev)) != 0)
324: device_printf(sc->amr_dev, "bus_generic_attach returned %d\n", error);
325:
326: /* mark controller back up */
327: sc->amr_state &= ~AMR_STATE_SHUTDOWN;
328:
329: /* interrupts will be enabled before we do anything more */
330: sc->amr_state |= AMR_STATE_INTEN;
331:
332: /*
333: * Start the timeout routine.
334: */
335: /* sc->amr_timeout = timeout(amr_periodic, sc, hz);*/
336:
337: return;
338: }
339:
340: /*******************************************************************************
341: * Free resources associated with a controller instance
342: */
343: void
344: amr_free(struct amr_softc *sc)
345: {
346: struct amr_command_cluster *acc;
347:
348: /* detach from CAM */
349: amr_cam_detach(sc);
350:
351: /* cancel status timeout */
352: untimeout(amr_periodic, sc, sc->amr_timeout);
353:
354: /* throw away any command buffers */
355: while ((acc = TAILQ_FIRST(&sc->amr_cmd_clusters)) != NULL) {
356: TAILQ_REMOVE(&sc->amr_cmd_clusters, acc, acc_link);
357: amr_freecmd_cluster(acc);
358: }
359:
360: /* destroy control device */
361: if( sc->amr_dev_t != (dev_t)NULL)
362: destroy_dev(sc->amr_dev_t);
363: }
364:
365: /*******************************************************************************
366: * Receive a bio structure from a child device and queue it on a particular
367: * disk resource, then poke the disk resource to start as much work as it can.
368: */
369: int
370: amr_submit_bio(struct amr_softc *sc, struct bio *bio)
371: {
372: debug_called(2);
373:
374: amr_enqueue_bio(sc, bio);
375: amr_startio(sc);
376: return(0);
377: }
378:
379: /********************************************************************************
380: * Accept an open operation on the control device.
381: */
382: static int
383: amr_open(dev_t dev, int flags, int fmt, d_thread_t *td)
384: {
385: int unit = minor(dev);
386: struct amr_softc *sc = devclass_get_softc(devclass_find("amr"), unit);
387:
388: debug_called(1);
389:
390: sc->amr_state |= AMR_STATE_OPEN;
391: return(0);
392: }
393:
394: /********************************************************************************
395: * Accept the last close on the control device.
396: */
397: static int
398: amr_close(dev_t dev, int flags, int fmt, d_thread_t *td)
399: {
400: int unit = minor(dev);
401: struct amr_softc *sc = devclass_get_softc(devclass_find("amr"), unit);
402:
403: debug_called(1);
404:
405: sc->amr_state &= ~AMR_STATE_OPEN;
406: return (0);
407: }
408:
409: /********************************************************************************
410: * Handle controller-specific control operations.
411: */
412: static int
413: amr_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, d_thread_t *td)
414: {
415: struct amr_softc *sc = (struct amr_softc *)dev->si_drv1;
416: int *arg = (int *)addr;
417: struct amr_user_ioctl *au = (struct amr_user_ioctl *)addr;
418: struct amr_command *ac;
419: struct amr_mailbox_ioctl *mbi;
420: struct amr_passthrough *ap;
421: void *dp;
422: int error;
423:
424: debug_called(1);
425:
426: error = 0;
427: dp = NULL;
428: ap = NULL;
429: ac = NULL;
430: switch(cmd) {
431:
432: case AMR_IO_VERSION:
433: debug(1, "AMR_IO_VERSION");
434: *arg = AMR_IO_VERSION_NUMBER;
435: break;
436:
437: case AMR_IO_COMMAND:
438: debug(1, "AMR_IO_COMMAND 0x%x", au->au_cmd[0]);
439: /* handle inbound data buffer */
440: if (au->au_length != 0) {
441: if ((dp = malloc(au->au_length, M_DEVBUF, M_WAITOK)) == NULL) {
442: error = ENOMEM;
443: break;
444: }
445: if ((error = copyin(au->au_buffer, dp, au->au_length)) != 0)
446: break;
447: debug(2, "copyin %ld bytes from %p -> %p", au->au_length, au->au_buffer, dp);
448: }
449:
450: if ((ac = amr_alloccmd(sc)) == NULL) {
451: error = ENOMEM;
452: break;
453: }
454:
455: /* handle SCSI passthrough command */
456: if (au->au_cmd[0] == AMR_CMD_PASS) {
457: if ((ap = malloc(sizeof(*ap), M_DEVBUF, M_WAITOK | M_ZERO)) == NULL) {
458: error = ENOMEM;
459: break;
460: }
461:
462: /* copy cdb */
463: ap->ap_cdb_length = au->au_cmd[2];
464: bcopy(&au->au_cmd[3], &ap->ap_cdb[0], ap->ap_cdb_length);
465:
466: /* build passthrough */
467: ap->ap_timeout = au->au_cmd[ap->ap_cdb_length + 3] & 0x07;
468: ap->ap_ars = (au->au_cmd[ap->ap_cdb_length + 3] & 0x08) ? 1 : 0;
469: ap->ap_islogical = (au->au_cmd[ap->ap_cdb_length + 3] & 0x80) ? 1 : 0;
470: ap->ap_logical_drive_no = au->au_cmd[ap->ap_cdb_length + 4];
471: ap->ap_channel = au->au_cmd[ap->ap_cdb_length + 5];
472: ap->ap_scsi_id = au->au_cmd[ap->ap_cdb_length + 6];
473: ap->ap_request_sense_length = 14;
474: ap->ap_data_transfer_length = au->au_length;
475: /* XXX what about the request-sense area? does the caller want it? */
476:
477: /* build command */
478: ac->ac_data = ap;
479: ac->ac_length = sizeof(*ap);
480: ac->ac_flags |= AMR_CMD_DATAOUT;
481: ac->ac_ccb_data = dp;
482: ac->ac_ccb_length = au->au_length;
483: if (au->au_direction & AMR_IO_READ)
484: ac->ac_flags |= AMR_CMD_CCB_DATAIN;
485: if (au->au_direction & AMR_IO_WRITE)
486: ac->ac_flags |= AMR_CMD_CCB_DATAOUT;
487:
488: ac->ac_mailbox.mb_command = AMR_CMD_PASS;
489:
490: } else {
491: /* direct command to controller */
492: mbi = (struct amr_mailbox_ioctl *)&ac->ac_mailbox;
493:
494: /* copy pertinent mailbox items */
495: mbi->mb_command = au->au_cmd[0];
496: mbi->mb_channel = au->au_cmd[1];
497: mbi->mb_param = au->au_cmd[2];
498: mbi->mb_pad[0] = au->au_cmd[3];
499: mbi->mb_drive = au->au_cmd[4];
500:
501: /* build the command */
502: ac->ac_data = dp;
503: ac->ac_length = au->au_length;
504: if (au->au_direction & AMR_IO_READ)
505: ac->ac_flags |= AMR_CMD_DATAIN;
506: if (au->au_direction & AMR_IO_WRITE)
507: ac->ac_flags |= AMR_CMD_DATAOUT;
508: }
509:
510: /* run the command */
511: if ((error = amr_wait_command(ac)) != 0)
512: break;
513:
514: /* copy out data and set status */
515: if (au->au_length != 0)
516: error = copyout(dp, au->au_buffer, au->au_length);
517: debug(2, "copyout %ld bytes from %p -> %p", au->au_length, dp, au->au_buffer);
518: if (dp != NULL)
519: debug(2, "%16d", (int)dp);
520: au->au_status = ac->ac_status;
521: break;
522:
523: default:
524: debug(1, "unknown ioctl 0x%lx", cmd);
525: error = ENOIOCTL;
526: break;
527: }
528:
529: if (dp != NULL)
530: free(dp, M_DEVBUF);
531: if (ap != NULL)
532: free(ap, M_DEVBUF);
533: if (ac != NULL)
534: amr_releasecmd(ac);
535: return(error);
536: }
537:
538: /********************************************************************************
539: ********************************************************************************
540: Status Monitoring
541: ********************************************************************************
542: ********************************************************************************/
543:
544: /********************************************************************************
545: * Perform a periodic check of the controller status
546: */
547: static void
548: amr_periodic(void *data)
549: {
550: struct amr_softc *sc = (struct amr_softc *)data;
551:
552: debug_called(2);
553:
554: /* XXX perform periodic status checks here */
555:
556: /* compensate for missed interrupts */
557: amr_done(sc);
558:
559: /* reschedule */
560: sc->amr_timeout = timeout(amr_periodic, sc, hz);
561: }
562:
563: /********************************************************************************
564: ********************************************************************************
565: Command Wrappers
566: ********************************************************************************
567: ********************************************************************************/
568:
569: /********************************************************************************
570: * Interrogate the controller for the operational parameters we require.
571: */
572: static int
573: amr_query_controller(struct amr_softc *sc)
574: {
575: struct amr_enquiry3 *aex;
576: struct amr_prodinfo *ap;
577: struct amr_enquiry *ae;
578: int ldrv;
579:
580: /*
581: * If we haven't found the real limit yet, let us have a couple of commands in
582: * order to be able to probe.
583: */
584: if (sc->amr_maxio == 0)
585: sc->amr_maxio = 2;
586:
587: /*
588: * Greater than 10 byte cdb support
589: */
590: sc->support_ext_cdb = amr_support_ext_cdb(sc);
591:
592: if(sc->support_ext_cdb) {
593: debug(2,"supports extended CDBs.");
594: }
595:
596: /*
597: * Try to issue an ENQUIRY3 command
598: */
599: if ((aex = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_ENQ3,
600: AMR_CONFIG_ENQ3_SOLICITED_FULL)) != NULL) {
601:
602: /*
603: * Fetch current state of logical drives.
604: */
605: for (ldrv = 0; ldrv < aex->ae_numldrives; ldrv++) {
606: sc->amr_drive[ldrv].al_size = aex->ae_drivesize[ldrv];
607: sc->amr_drive[ldrv].al_state = aex->ae_drivestate[ldrv];
608: sc->amr_drive[ldrv].al_properties = aex->ae_driveprop[ldrv];
609: debug(2, " drive %d: %d state %x properties %x\n", ldrv, sc->amr_drive[ldrv].al_size,
610: sc->amr_drive[ldrv].al_state, sc->amr_drive[ldrv].al_properties);
611: }
612: free(aex, M_DEVBUF);
613:
614: /*
615: * Get product info for channel count.
616: */
617: if ((ap = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0)) == NULL) {
618: device_printf(sc->amr_dev, "can't obtain product data from controller\n");
619: return(1);
620: }
621: sc->amr_maxdrives = 40;
622: sc->amr_maxchan = ap->ap_nschan;
623: sc->amr_maxio = ap->ap_maxio;
624: sc->amr_type |= AMR_TYPE_40LD;
625: free(ap, M_DEVBUF);
626:
627: } else {
628:
629: /* failed, try the 8LD ENQUIRY commands */
630: if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_EXT_ENQUIRY2, 0, 0)) == NULL) {
631: if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0)) == NULL) {
632: device_printf(sc->amr_dev, "can't obtain configuration data from controller\n");
633: return(1);
634: }
635: ae->ae_signature = 0;
636: }
637:
638: /*
639: * Fetch current state of logical drives.
640: */
641: for (ldrv = 0; ldrv < ae->ae_ldrv.al_numdrives; ldrv++) {
642: sc->amr_drive[ldrv].al_size = ae->ae_ldrv.al_size[ldrv];
643: sc->amr_drive[ldrv].al_state = ae->ae_ldrv.al_state[ldrv];
644: sc->amr_drive[ldrv].al_properties = ae->ae_ldrv.al_properties[ldrv];
645: debug(2, " drive %d: %d state %x properties %x\n", ldrv, sc->amr_drive[ldrv].al_size,
646: sc->amr_drive[ldrv].al_state, sc->amr_drive[ldrv].al_properties);
647: }
648:
649: sc->amr_maxdrives = 8;
650: sc->amr_maxchan = ae->ae_adapter.aa_channels;
651: sc->amr_maxio = ae->ae_adapter.aa_maxio;
652: free(ae, M_DEVBUF);
653: }
654:
655: /*
656: * Mark remaining drives as unused.
657: */
658: for (; ldrv < AMR_MAXLD; ldrv++)
659: sc->amr_drive[ldrv].al_size = 0xffffffff;
660:
661: /*
662: * Cap the maximum number of outstanding I/Os. AMI's Linux driver doesn't trust
663: * the controller's reported value, and lockups have been seen when we do.
664: */
665: sc->amr_maxio = imin(sc->amr_maxio, AMR_LIMITCMD);
666:
667: return(0);
668: }
669:
670: /********************************************************************************
671: * Run a generic enquiry-style command.
672: */
673: static void *
674: amr_enquiry(struct amr_softc *sc, size_t bufsize, u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual)
675: {
676: struct amr_command *ac;
677: void *result;
678: u_int8_t *mbox;
679: int error;
680:
681: debug_called(1);
682:
683: error = 1;
684: result = NULL;
685:
686: /* get ourselves a command buffer */
687: if ((ac = amr_alloccmd(sc)) == NULL)
688: goto out;
689: /* allocate the response structure */
690: if ((result = malloc(bufsize, M_DEVBUF, M_NOWAIT)) == NULL)
691: goto out;
692: /* set command flags */
693: ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
694:
695: /* point the command at our data */
696: ac->ac_data = result;
697: ac->ac_length = bufsize;
698:
699: /* build the command proper */
700: mbox = (u_int8_t *)&ac->ac_mailbox; /* XXX want a real structure for this? */
701: mbox[0] = cmd;
702: mbox[2] = cmdsub;
703: mbox[3] = cmdqual;
704:
705: /* can't assume that interrupts are going to work here, so play it safe */
706: if (sc->amr_poll_command(ac))
707: goto out;
708: error = ac->ac_status;
709:
710: out:
711: if (ac != NULL)
712: amr_releasecmd(ac);
713: if ((error != 0) && (result != NULL)) {
714: free(result, M_DEVBUF);
715: result = NULL;
716: }
717: return(result);
718: }
719:
720: /********************************************************************************
721: * Flush the controller's internal cache, return status.
722: */
723: int
724: amr_flush(struct amr_softc *sc)
725: {
726: struct amr_command *ac;
727: int error;
728:
729: /* get ourselves a command buffer */
730: error = 1;
731: if ((ac = amr_alloccmd(sc)) == NULL)
732: goto out;
733: /* set command flags */
734: ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
735:
736: /* build the command proper */
737: ac->ac_mailbox.mb_command = AMR_CMD_FLUSH;
738:
739: /* we have to poll, as the system may be going down or otherwise damaged */
740: if (sc->amr_poll_command(ac))
741: goto out;
742: error = ac->ac_status;
743:
744: out:
745: if (ac != NULL)
746: amr_releasecmd(ac);
747: return(error);
748: }
749:
750: /********************************************************************************
751: * Detect extented cdb >> greater than 10 byte cdb support
752: * returns '1' means this support exist
753: * returns '0' means this support doesn't exist
754: */
755: static int
756: amr_support_ext_cdb(struct amr_softc *sc)
757: {
758: struct amr_command *ac;
759: u_int8_t *mbox;
760: int error;
761:
762: /* get ourselves a command buffer */
763: error = 0;
764: if ((ac = amr_alloccmd(sc)) == NULL)
765: goto out;
766: /* set command flags */
767: ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
768:
769: /* build the command proper */
770: mbox = (u_int8_t *)&ac->ac_mailbox; /* XXX want a real structure for this? */
771: mbox[0] = 0xA4;
772: mbox[2] = 0x16;
773:
774:
775: /* we have to poll, as the system may be going down or otherwise damaged */
776: if (sc->amr_poll_command(ac))
777: goto out;
778: if( ac->ac_status == AMR_STATUS_SUCCESS ) {
779: error = 1;
780: }
781:
782: out:
783: if (ac != NULL)
784: amr_releasecmd(ac);
785: return(error);
786: }
787:
788: /********************************************************************************
789: * Try to find I/O work for the controller from one or more of the work queues.
790: *
791: * We make the assumption that if the controller is not ready to take a command
792: * at some given time, it will generate an interrupt at some later time when
793: * it is.
794: */
795: void
796: amr_startio(struct amr_softc *sc)
797: {
798: struct amr_command *ac;
799:
800: /* spin until something prevents us from doing any work */
801: for (;;) {
802:
803: /* try to get a ready command */
804: ac = amr_dequeue_ready(sc);
805:
806: /* if that failed, build a command from a bio */
807: if (ac == NULL)
808: (void)amr_bio_command(sc, &ac);
809:
810: /* if that failed, build a command from a ccb */
811: if (ac == NULL)
812: (void)amr_cam_command(sc, &ac);
813:
814: /* if we don't have anything to do, give up */
815: if (ac == NULL)
816: break;
817:
818: /* try to give the command to the controller; if this fails save it for later and give up */
819: if (amr_start(ac)) {
820: debug(2, "controller busy, command deferred");
821: amr_requeue_ready(ac); /* XXX schedule retry very soon? */
822: break;
823: }
824: }
825: }
826:
827: /********************************************************************************
828: * Handle completion of an I/O command.
829: */
830: static void
831: amr_completeio(struct amr_command *ac)
832: {
833: struct amr_softc *sc = ac->ac_sc;
834:
835: if (ac->ac_status != AMR_STATUS_SUCCESS) { /* could be more verbose here? */
836: ac->ac_bio->bio_error = EIO;
837: ac->ac_bio->bio_flags |= BIO_ERROR;
838:
839: device_printf(sc->amr_dev, "I/O error - 0x%x\n", ac->ac_status);
840: /* amr_printcommand(ac);*/
841: }
842: amrd_intr(ac->ac_bio);
843: amr_releasecmd(ac);
844: }
845:
846: /********************************************************************************
847: ********************************************************************************
848: Command Processing
849: ********************************************************************************
850: ********************************************************************************/
851:
852: /********************************************************************************
853: * Convert a bio off the top of the bio queue into a command.
854: */
855: static int
856: amr_bio_command(struct amr_softc *sc, struct amr_command **acp)
857: {
858: struct amr_command *ac;
859: struct amrd_softc *amrd;
860: struct bio *bio;
861: int error;
862: int blkcount;
863: int driveno;
864: int cmd;
865:
866: ac = NULL;
867: error = 0;
868:
869: /* get a bio to work on */
870: if ((bio = amr_dequeue_bio(sc)) == NULL)
871: goto out;
872:
873: /* get a command */
874: if ((ac = amr_alloccmd(sc)) == NULL) {
875: error = ENOMEM;
876: goto out;
877: }
878:
879: /* connect the bio to the command */
880: ac->ac_complete = amr_completeio;
881: ac->ac_bio = bio;
882: ac->ac_data = bio->bio_data;
883: ac->ac_length = bio->bio_bcount;
884: if (BIO_IS_READ(bio)) {
885: ac->ac_flags |= AMR_CMD_DATAIN;
886: cmd = AMR_CMD_LREAD;
887: } else {
888: ac->ac_flags |= AMR_CMD_DATAOUT;
889: cmd = AMR_CMD_LWRITE;
890: }
891: amrd = (struct amrd_softc *)bio->bio_dev->si_drv1;
892: driveno = amrd->amrd_drive - sc->amr_drive;
893: blkcount = (bio->bio_bcount + AMR_BLKSIZE - 1) / AMR_BLKSIZE;
894:
895: ac->ac_mailbox.mb_command = cmd;
896: ac->ac_mailbox.mb_blkcount = blkcount;
897: ac->ac_mailbox.mb_lba = bio->bio_pblkno;
898: ac->ac_mailbox.mb_drive = driveno;
899: /* we fill in the s/g related data when the command is mapped */
900:
901: if ((bio->bio_pblkno + blkcount) > sc->amr_drive[driveno].al_size)
902: device_printf(sc->amr_dev, "I/O beyond end of unit (%lld,%d > %lu)\n",
903: (long long)bio->bio_pblkno, blkcount,
904: (u_long)sc->amr_drive[driveno].al_size);
905:
906: out:
907: if (error != 0) {
908: if (ac != NULL)
909: amr_releasecmd(ac);
910: if (bio != NULL) /* this breaks ordering... */
911: amr_enqueue_bio(sc, bio);
912: }
913: *acp = ac;
914: return(error);
915: }
916:
917: /********************************************************************************
918: * Take a command, submit it to the controller and sleep until it completes
919: * or fails. Interrupts must be enabled, returns nonzero on error.
920: */
921: static int
922: amr_wait_command(struct amr_command *ac)
923: {
924: int error, count;
925:
926: debug_called(1);
927:
928: ac->ac_complete = NULL;
929: ac->ac_flags |= AMR_CMD_SLEEP;
930: if ((error = amr_start(ac)) != 0)
931: return(error);
932:
933: count = 0;
934: /* XXX better timeout? */
935: while ((ac->ac_flags & AMR_CMD_BUSY) && (count < 30)) {
936: tsleep(ac, PCATCH, "amrwcmd", hz);
937: }
938: return(0);
939: }
940:
941: /********************************************************************************
942: * Take a command, submit it to the controller and busy-wait for it to return.
943: * Returns nonzero on error. Can be safely called with interrupts enabled.
944: */
945: static int
946: amr_std_poll_command(struct amr_command *ac)
947: {
948: struct amr_softc *sc = ac->ac_sc;
949: int error, count;
950:
951: debug_called(2);
952:
953: ac->ac_complete = NULL;
954: if ((error = amr_start(ac)) != 0)
955: return(error);
956:
957: count = 0;
958: do {
959: /*
960: * Poll for completion, although the interrupt handler may beat us to it.
961: * Note that the timeout here is somewhat arbitrary.
962: */
963: amr_done(sc);
964: DELAY(1000);
965: } while ((ac->ac_flags & AMR_CMD_BUSY) && (count++ < 1000));
966: if (!(ac->ac_flags & AMR_CMD_BUSY)) {
967: error = 0;
968: } else {
969: /* XXX the slot is now marked permanently busy */
970: error = EIO;
971: device_printf(sc->amr_dev, "polled command timeout\n");
972: }
973: return(error);
974: }
975:
976: /********************************************************************************
977: * Take a command, submit it to the controller and busy-wait for it to return.
978: * Returns nonzero on error. Can be safely called with interrupts enabled.
979: */
980: static int
981: amr_quartz_poll_command(struct amr_command *ac)
982: {
983: struct amr_softc *sc = ac->ac_sc;
984: int s;
985: int error,count;
986:
987: debug_called(2);
988:
989: /* now we have a slot, we can map the command (unmapped in amr_complete) */
990: amr_mapcmd(ac);
991:
992: s = splbio();
993:
994: if (sc->amr_state & AMR_STATE_INTEN) {
995: count=0;
996: while (sc->amr_busyslots) {
997: tsleep(sc, PCATCH, "amrpoll", hz);
998: if(count++>10) {
999: break;
1000: }
1001: }
1002:
1003: if(sc->amr_busyslots) {
1004: device_printf(sc->amr_dev, "adapter is busy\n");
1005: splx(s);
1006: amr_unmapcmd(ac);
1007: ac->ac_status=0;
1008: return(1);
1009: }
1010: }
1011:
1012: bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, AMR_MBOX_CMDSIZE);
1013:
1014: /* clear the poll/ack fields in the mailbox */
1015: sc->amr_mailbox->mb_ident = 0xFE;
1016: sc->amr_mailbox->mb_nstatus = 0xFF;
1017: sc->amr_mailbox->mb_status = 0xFF;
1018: sc->amr_mailbox->mb_poll = 0;
1019: sc->amr_mailbox->mb_ack = 0;
1020: sc->amr_mailbox->mb_busy = 1;
1021:
1022: AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT);
1023:
1024: while(sc->amr_mailbox->mb_nstatus == 0xFF);
1025: while(sc->amr_mailbox->mb_status == 0xFF);
1026: ac->ac_status=sc->amr_mailbox->mb_status;
1027: error = (ac->ac_status !=AMR_STATUS_SUCCESS) ? 1:0;
1028: while(sc->amr_mailbox->mb_poll != 0x77);
1029: sc->amr_mailbox->mb_poll = 0;
1030: sc->amr_mailbox->mb_ack = 0x77;
1031:
1032: /* acknowledge that we have the commands */
1033: AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_ACK);
1034: while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK);
1035:
1036: splx(s);
1037:
1038: /* unmap the command's data buffer */
1039: amr_unmapcmd(ac);
1040:
1041: return(error);
1042: }
1043:
1044: /********************************************************************************
1045: * Get a free command slot for a command if it doesn't already have one.
1046: *
1047: * May be safely called multiple times for a given command.
1048: */
1049: static int
1050: amr_getslot(struct amr_command *ac)
1051: {
1052: struct amr_softc *sc = ac->ac_sc;
1053: int s, slot, limit, error;
1054:
1055: debug_called(3);
1056:
1057: /* if the command already has a slot, don't try to give it another one */
1058: if (ac->ac_slot != 0)
1059: return(0);
1060:
1061: /* enforce slot usage limit */
1062: limit = (ac->ac_flags & AMR_CMD_PRIORITY) ? sc->amr_maxio : sc->amr_maxio - 4;
1063: if (sc->amr_busyslots > limit)
1064: return(EBUSY);
1065:
1066: /*
1067: * Allocate a slot. XXX linear scan is slow
1068: */
1069: error = EBUSY;
1070: s = splbio();
1071: for (slot = 0; slot < sc->amr_maxio; slot++) {
1072: if (sc->amr_busycmd[slot] == NULL) {
1073: sc->amr_busycmd[slot] = ac;
1074: sc->amr_busyslots++;
1075: ac->ac_slot = slot;
1076: error = 0;
1077: break;
1078: }
1079: }
1080: splx(s);
1081:
1082: return(error);
1083: }
1084:
1085: /********************************************************************************
1086: * Map/unmap (ac)'s data in the controller's addressable space as required.
1087: *
1088: * These functions may be safely called multiple times on a given command.
1089: */
1090: static void
1091: amr_setup_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1092: {
1093: struct amr_command *ac = (struct amr_command *)arg;
1094: struct amr_softc *sc = ac->ac_sc;
1095: struct amr_sgentry *sg;
1096: int i;
1097: u_int8_t *sgc;
1098:
1099: debug_called(3);
1100:
1101: /* get base address of s/g table */
1102: sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1103:
1104: /* save data physical address */
1105: ac->ac_dataphys = segs[0].ds_addr;
1106:
1107: /* for AMR_CMD_CONFIG the s/g count goes elsewhere */
1108: if (ac->ac_mailbox.mb_command == AMR_CMD_CONFIG) {
1109: sgc = &(((struct amr_mailbox_ioctl *)&ac->ac_mailbox)->mb_param);
1110: } else {
1111: sgc = &ac->ac_mailbox.mb_nsgelem;
1112: }
1113:
1114: /* decide whether we need to populate the s/g table */
1115: if (nsegments < 2) {
1116: *sgc = 0;
1117: ac->ac_mailbox.mb_nsgelem = 0;
1118: ac->ac_mailbox.mb_physaddr = ac->ac_dataphys;
1119: } else {
1120: ac->ac_mailbox.mb_nsgelem = nsegments;
1121: *sgc = nsegments;
1122: ac->ac_mailbox.mb_physaddr = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1123: for (i = 0; i < nsegments; i++, sg++) {
1124: sg->sg_addr = segs[i].ds_addr;
1125: sg->sg_count = segs[i].ds_len;
1126: }
1127: }
1128: }
1129:
1130: static void
1131: amr_setup_ccbmap(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1132: {
1133: struct amr_command *ac = (struct amr_command *)arg;
1134: struct amr_softc *sc = ac->ac_sc;
1135: struct amr_sgentry *sg;
1136: struct amr_passthrough *ap = (struct amr_passthrough *)ac->ac_data;
1137: struct amr_ext_passthrough *aep = (struct amr_ext_passthrough *)ac->ac_data;
1138: int i;
1139:
1140: /* get base address of s/g table */
1141: sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1142:
1143: /* decide whether we need to populate the s/g table */
1144: if( ac->ac_mailbox.mb_command == AMR_CMD_EXTPASS ) {
1145: if (nsegments < 2) {
1146: aep->ap_no_sg_elements = 0;
1147: aep->ap_data_transfer_address = segs[0].ds_addr;
1148: } else {
1149: /* save s/g table information in passthrough */
1150: aep->ap_no_sg_elements = nsegments;
1151: aep->ap_data_transfer_address = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1152: /* populate s/g table (overwrites previous call which mapped the passthrough) */
1153: for (i = 0; i < nsegments; i++, sg++) {
1154: sg->sg_addr = segs[i].ds_addr;
1155: sg->sg_count = segs[i].ds_len;
1156: debug(3, " %d: 0x%x/%d", i, sg->sg_addr, sg->sg_count);
1157: }
1158: }
1159: debug(3, "slot %d %d segments at 0x%x, passthrough at 0x%x", ac->ac_slot,
1160: aep->ap_no_sg_elements, aep->ap_data_transfer_address, ac->ac_dataphys);
1161: } else {
1162: if (nsegments < 2) {
1163: ap->ap_no_sg_elements = 0;
1164: ap->ap_data_transfer_address = segs[0].ds_addr;
1165: } else {
1166: /* save s/g table information in passthrough */
1167: ap->ap_no_sg_elements = nsegments;
1168: ap->ap_data_transfer_address = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry));
1169: /* populate s/g table (overwrites previous call which mapped the passthrough) */
1170: for (i = 0; i < nsegments; i++, sg++) {
1171: sg->sg_addr = segs[i].ds_addr;
1172: sg->sg_count = segs[i].ds_len;
1173: debug(3, " %d: 0x%x/%d", i, sg->sg_addr, sg->sg_count);
1174: }
1175: }
1176: debug(3, "slot %d %d segments at 0x%x, passthrough at 0x%x", ac->ac_slot,
1177: ap->ap_no_sg_elements, ap->ap_data_transfer_address, ac->ac_dataphys);
1178: }
1179: }
1180:
1181: static void
1182: amr_mapcmd(struct amr_command *ac)
1183: {
1184: struct amr_softc *sc = ac->ac_sc;
1185:
1186: debug_called(3);
1187:
1188: /* if the command involves data at all, and hasn't been mapped */
1189: if (!(ac->ac_flags & AMR_CMD_MAPPED)) {
1190:
1191: if (ac->ac_data != NULL) {
1192: /* map the data buffers into bus space and build the s/g list */
1193: bus_dmamap_load(sc->amr_buffer_dmat, ac->ac_dmamap, ac->ac_data, ac->ac_length,
1194: amr_setup_dmamap, ac, 0);
1195: if (ac->ac_flags & AMR_CMD_DATAIN)
1196: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_PREREAD);
1197: if (ac->ac_flags & AMR_CMD_DATAOUT)
1198: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_PREWRITE);
1199: }
1200:
1201: if (ac->ac_ccb_data != NULL) {
1202: bus_dmamap_load(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, ac->ac_ccb_data, ac->ac_ccb_length,
1203: amr_setup_ccbmap, ac, 0);
1204: if (ac->ac_flags & AMR_CMD_CCB_DATAIN)
1205: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_PREREAD);
1206: if (ac->ac_flags & AMR_CMD_CCB_DATAOUT)
1207: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_PREWRITE);
1208: }
1209: ac->ac_flags |= AMR_CMD_MAPPED;
1210: }
1211: }
1212:
1213: static void
1214: amr_unmapcmd(struct amr_command *ac)
1215: {
1216: struct amr_softc *sc = ac->ac_sc;
1217:
1218: debug_called(3);
1219:
1220: /* if the command involved data at all and was mapped */
1221: if (ac->ac_flags & AMR_CMD_MAPPED) {
1222:
1223: if (ac->ac_data != NULL) {
1224: if (ac->ac_flags & AMR_CMD_DATAIN)
1225: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_POSTREAD);
1226: if (ac->ac_flags & AMR_CMD_DATAOUT)
1227: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_POSTWRITE);
1228: bus_dmamap_unload(sc->amr_buffer_dmat, ac->ac_dmamap);
1229: }
1230:
1231: if (ac->ac_ccb_data != NULL) {
1232: if (ac->ac_flags & AMR_CMD_CCB_DATAIN)
1233: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_POSTREAD);
1234: if (ac->ac_flags & AMR_CMD_CCB_DATAOUT)
1235: bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_ccb_dmamap, BUS_DMASYNC_POSTWRITE);
1236: bus_dmamap_unload(sc->amr_buffer_dmat, ac->ac_ccb_dmamap);
1237: }
1238: ac->ac_flags &= ~AMR_CMD_MAPPED;
1239: }
1240: }
1241:
1242: /********************************************************************************
1243: * Take a command and give it to the controller, returns 0 if successful, or
1244: * EBUSY if the command should be retried later.
1245: */
1246: static int
1247: amr_start(struct amr_command *ac)
1248: {
1249: struct amr_softc *sc = ac->ac_sc;
1250: int done, s, i;
1251:
1252: debug_called(3);
1253:
1254: /* mark command as busy so that polling consumer can tell */
1255: ac->ac_flags |= AMR_CMD_BUSY;
1256:
1257: /* get a command slot (freed in amr_done) */
1258: if (amr_getslot(ac))
1259: return(EBUSY);
1260:
1261: /* now we have a slot, we can map the command (unmapped in amr_complete) */
1262: amr_mapcmd(ac);
1263:
1264: /* mark the new mailbox we are going to copy in as busy */
1265: ac->ac_mailbox.mb_busy = 1;
1266:
1267: /* clear the poll/ack fields in the mailbox */
1268: sc->amr_mailbox->mb_poll = 0;
1269: sc->amr_mailbox->mb_ack = 0;
1270:
1271: /*
1272: * Save the slot number so that we can locate this command when complete.
1273: * Note that ident = 0 seems to be special, so we don't use it.
1274: */
1275: ac->ac_mailbox.mb_ident = ac->ac_slot + 1;
1276:
1277: /*
1278: * Spin waiting for the mailbox, give up after ~1 second. We expect the
1279: * controller to be able to handle our I/O.
1280: *
1281: * XXX perhaps we should wait for less time, and count on the deferred command
1282: * handling to deal with retries?
1283: */
1284: debug(4, "wait for mailbox");
1285: for (i = 10000, done = 0; (i > 0) && !done; i--) {
1286: s = splbio();
1287:
1288: /* is the mailbox free? */
1289: if (sc->amr_mailbox->mb_busy == 0) {
1290: debug(4, "got mailbox");
1291: sc->amr_mailbox64->mb64_segment = 0;
1292: bcopy(&ac->ac_mailbox, (void *)(uintptr_t)(volatile void *)sc->amr_mailbox, AMR_MBOX_CMDSIZE);
1293: done = 1;
1294:
1295: /* not free, spin waiting */
1296: } else {
1297: debug(4, "busy flag %x\n", sc->amr_mailbox->mb_busy);
1298: /* this is somewhat ugly */
1299: DELAY(100);
1300: }
1301: splx(s); /* drop spl to allow completion interrupts */
1302: }
1303:
1304: /*
1305: * Now give the command to the controller
1306: */
1307: if (done) {
1308: if (sc->amr_submit_command(sc)) {
1309: /* the controller wasn't ready to take the command, forget that we tried to post it */
1310: sc->amr_mailbox->mb_busy = 0;
1311: return(EBUSY);
1312: }
1313: debug(3, "posted command");
1314: return(0);
1315: }
1316:
1317: /*
1318: * The controller wouldn't take the command. Return the command as busy
1319: * so that it is retried later.
1320: */
1321: return(EBUSY);
1322: }
1323:
1324: /********************************************************************************
1325: * Extract one or more completed commands from the controller (sc)
1326: *
1327: * Returns nonzero if any commands on the work queue were marked as completed.
1328: */
1329: int
1330: amr_done(struct amr_softc *sc)
1331: {
1332: struct amr_command *ac;
1333: struct amr_mailbox mbox;
1334: int i, idx, result;
1335:
1336: debug_called(3);
1337:
1338: /* See if there's anything for us to do */
1339: result = 0;
1340:
1341: /* loop collecting completed commands */
1342: for (;;) {
1343: /* poll for a completed command's identifier and status */
1344: if (sc->amr_get_work(sc, &mbox)) {
1345: result = 1;
1346:
1347: /* iterate over completed commands in this result */
1348: for (i = 0; i < mbox.mb_nstatus; i++) {
1349: /* get pointer to busy command */
1350: idx = mbox.mb_completed[i] - 1;
1351: ac = sc->amr_busycmd[idx];
1352:
1353: /* really a busy command? */
1354: if (ac != NULL) {
1355:
1356: /* pull the command from the busy index */
1357: sc->amr_busycmd[idx] = NULL;
1358: sc->amr_busyslots--;
1359:
1360: /* save status for later use */
1361: ac->ac_status = mbox.mb_status;
1362: amr_enqueue_completed(ac);
1363: debug(3, "completed command with status %x", mbox.mb_status);
1364: } else {
1365: device_printf(sc->amr_dev, "bad slot %d completed\n", idx);
1366: }
1367: }
1368: } else {
1369: break; /* no work */
1370: }
1371: }
1372:
1373: /* if we've completed any commands, try posting some more */
1374: if (result)
1375: amr_startio(sc);
1376:
1377: /* handle completion and timeouts */
1378: #if defined(__FreeBSD__) && __FreeBSD_version >= 500005
1379: if (sc->amr_state & AMR_STATE_INTEN)
1380: taskqueue_enqueue(taskqueue_swi, &sc->amr_task_complete);
1381: else
1382: #endif
1383: amr_complete(sc, 0);
1384:
1385: return(result);
1386: }
1387:
1388: /********************************************************************************
1389: * Do completion processing on done commands on (sc)
1390: */
1391: static void
1392: amr_complete(void *context, int pending)
1393: {
1394: struct amr_softc *sc = (struct amr_softc *)context;
1395: struct amr_command *ac;
1396:
1397: debug_called(3);
1398:
1399: /* pull completed commands off the queue */
1400: for (;;) {
1401: ac = amr_dequeue_completed(sc);
1402: if (ac == NULL)
1403: break;
1404:
1405: /* unmap the command's data buffer */
1406: amr_unmapcmd(ac);
1407:
1408: /* unbusy the command */
1409: ac->ac_flags &= ~AMR_CMD_BUSY;
1410:
1411: /*
1412: * Is there a completion handler?
1413: */
1414: if (ac->ac_complete != NULL) {
1415: ac->ac_complete(ac);
1416:
1417: /*
1418: * Is someone sleeping on this one?
1419: */
1420: } else if (ac->ac_flags & AMR_CMD_SLEEP) {
1421: wakeup(ac);
1422: }
1423:
1424: if(!sc->amr_busyslots) {
1425: wakeup(sc);
1426: }
1427: }
1428: }
1429:
1430: /********************************************************************************
1431: ********************************************************************************
1432: Command Buffer Management
1433: ********************************************************************************
1434: ********************************************************************************/
1435:
1436: /********************************************************************************
1437: * Get a new command buffer.
1438: *
1439: * This may return NULL in low-memory cases.
1440: *
1441: * If possible, we recycle a command buffer that's been used before.
1442: */
1443: struct amr_command *
1444: amr_alloccmd(struct amr_softc *sc)
1445: {
1446: struct amr_command *ac;
1447:
1448: debug_called(3);
1449:
1450: ac = amr_dequeue_free(sc);
1451: if (ac == NULL) {
1452: amr_alloccmd_cluster(sc);
1453: ac = amr_dequeue_free(sc);
1454: }
1455: if (ac == NULL)
1456: return(NULL);
1457:
1458: /* clear out significant fields */
1459: ac->ac_slot = 0;
1460: ac->ac_status = 0;
1461: bzero(&ac->ac_mailbox, sizeof(struct amr_mailbox));
1462: ac->ac_flags = 0;
1463: ac->ac_bio = NULL;
1464: ac->ac_data = NULL;
1465: ac->ac_ccb_data = NULL;
1466: ac->ac_complete = NULL;
1467: return(ac);
1468: }
1469:
1470: /********************************************************************************
1471: * Release a command buffer for recycling.
1472: */
1473: void
1474: amr_releasecmd(struct amr_command *ac)
1475: {
1476: debug_called(3);
1477:
1478: amr_enqueue_free(ac);
1479: }
1480:
1481: /********************************************************************************
1482: * Allocate a new command cluster and initialise it.
1483: */
1484: static void
1485: amr_alloccmd_cluster(struct amr_softc *sc)
1486: {
1487: struct amr_command_cluster *acc;
1488: struct amr_command *ac;
1489: int s, i;
1490:
1491: acc = malloc(AMR_CMD_CLUSTERSIZE, M_DEVBUF, M_NOWAIT);
1492: if (acc != NULL) {
1493: s = splbio();
1494: TAILQ_INSERT_TAIL(&sc->amr_cmd_clusters, acc, acc_link);
1495: splx(s);
1496: for (i = 0; i < AMR_CMD_CLUSTERCOUNT; i++) {
1497: ac = &acc->acc_command[i];
1498: bzero(ac, sizeof(*ac));
1499: ac->ac_sc = sc;
1500: if (!bus_dmamap_create(sc->amr_buffer_dmat, 0, &ac->ac_dmamap) &&
1501: !bus_dmamap_create(sc->amr_buffer_dmat, 0, &ac->ac_ccb_dmamap))
1502: amr_releasecmd(ac);
1503: }
1504: }
1505: }
1506:
1507: /********************************************************************************
1508: * Free a command cluster
1509: */
1510: static void
1511: amr_freecmd_cluster(struct amr_command_cluster *acc)
1512: {
1513: struct amr_softc *sc = acc->acc_command[0].ac_sc;
1514: int i;
1515:
1516: for (i = 0; i < AMR_CMD_CLUSTERCOUNT; i++)
1517: bus_dmamap_destroy(sc->amr_buffer_dmat, acc->acc_command[i].ac_dmamap);
1518: free(acc, M_DEVBUF);
1519: }
1520:
1521: /********************************************************************************
1522: ********************************************************************************
1523: Interface-specific Shims
1524: ********************************************************************************
1525: ********************************************************************************/
1526:
1527: /********************************************************************************
1528: * Tell the controller that the mailbox contains a valid command
1529: */
1530: static int
1531: amr_quartz_submit_command(struct amr_softc *sc)
1532: {
1533: debug_called(3);
1534:
1535: if (AMR_QGET_IDB(sc) & AMR_QIDB_SUBMIT)
1536: return(EBUSY);
1537: AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT);
1538: return(0);
1539: }
1540:
1541: static int
1542: amr_std_submit_command(struct amr_softc *sc)
1543: {
1544: debug_called(3);
1545:
1546: if (AMR_SGET_MBSTAT(sc) & AMR_SMBOX_BUSYFLAG)
1547: return(EBUSY);
1548: AMR_SPOST_COMMAND(sc);
1549: return(0);
1550: }
1551:
1552: /********************************************************************************
1553: * Claim any work that the controller has completed; acknowledge completion,
1554: * save details of the completion in (mbsave)
1555: */
1556: static int
1557: amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave)
1558: {
1559: int s, worked;
1560: u_int32_t outd;
1561:
1562: debug_called(3);
1563:
1564: worked = 0;
1565: s = splbio();
1566:
1567: /* work waiting for us? */
1568: if ((outd = AMR_QGET_ODB(sc)) == AMR_QODB_READY) {
1569:
1570: /* save mailbox, which contains a list of completed commands */
1571: bcopy((void *)(uintptr_t)(volatile void *)sc->amr_mailbox, mbsave, sizeof(*mbsave));
1572:
1573: /* acknowledge interrupt */
1574: AMR_QPUT_ODB(sc, AMR_QODB_READY);
1575:
1576: /* acknowledge that we have the commands */
1577: AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_ACK);
1578:
1579: #ifndef AMR_QUARTZ_GOFASTER
1580: /*
1581: * This waits for the controller to notice that we've taken the
1582: * command from it. It's very inefficient, and we shouldn't do it,
1583: * but if we remove this code, we stop completing commands under
1584: * load.
1585: *
1586: * Peter J says we shouldn't do this. The documentation says we
1587: * should. Who is right?
1588: */
1589: while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK)
1590: ; /* XXX aiee! what if it dies? */
1591: #endif
1592:
1593: worked = 1; /* got some work */
1594: }
1595:
1596: splx(s);
1597: return(worked);
1598: }
1599:
1600: static int
1601: amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave)
1602: {
1603: int s, worked;
1604: u_int8_t istat;
1605:
1606: debug_called(3);
1607:
1608: worked = 0;
1609: s = splbio();
1610:
1611: /* check for valid interrupt status */
1612: istat = AMR_SGET_ISTAT(sc);
1613: if ((istat & AMR_SINTR_VALID) != 0) {
1614: AMR_SPUT_ISTAT(sc, istat); /* ack interrupt status */
1615:
1616: /* save mailbox, which contains a list of completed commands */
1617: bcopy((void *)(uintptr_t)(volatile void *)sc->amr_mailbox, mbsave, sizeof(*mbsave));
1618:
1619: AMR_SACK_INTERRUPT(sc); /* acknowledge we have the mailbox */
1620: worked = 1;
1621: }
1622:
1623: splx(s);
1624: return(worked);
1625: }
1626:
1627: /********************************************************************************
1628: * Notify the controller of the mailbox location.
1629: */
1630: static void
1631: amr_std_attach_mailbox(struct amr_softc *sc)
1632: {
1633:
1634: /* program the mailbox physical address */
1635: AMR_SBYTE_SET(sc, AMR_SMBOX_0, sc->amr_mailboxphys & 0xff);
1636: AMR_SBYTE_SET(sc, AMR_SMBOX_1, (sc->amr_mailboxphys >> 8) & 0xff);
1637: AMR_SBYTE_SET(sc, AMR_SMBOX_2, (sc->amr_mailboxphys >> 16) & 0xff);
1638: AMR_SBYTE_SET(sc, AMR_SMBOX_3, (sc->amr_mailboxphys >> 24) & 0xff);
1639: AMR_SBYTE_SET(sc, AMR_SMBOX_ENABLE, AMR_SMBOX_ADDR);
1640:
1641: /* clear any outstanding interrupt and enable interrupts proper */
1642: AMR_SACK_INTERRUPT(sc);
1643: AMR_SENABLE_INTR(sc);
1644: }
1645:
1646: #ifdef AMR_BOARD_INIT
1647: /********************************************************************************
1648: * Initialise the controller
1649: */
1650: static int
1651: amr_quartz_init(struct amr_softc *sc)
1652: {
1653: int status, ostatus;
1654:
1655: device_printf(sc->amr_dev, "initial init status %x\n", AMR_QGET_INITSTATUS(sc));
1656:
1657: AMR_QRESET(sc);
1658:
1659: ostatus = 0xff;
1660: while ((status = AMR_QGET_INITSTATUS(sc)) != AMR_QINIT_DONE) {
1661: if (status != ostatus) {
1662: device_printf(sc->amr_dev, "(%x) %s\n", status, amr_describe_code(amr_table_qinit, status));
1663: ostatus = status;
1664: }
1665: switch (status) {
1666: case AMR_QINIT_NOMEM:
1667: return(ENOMEM);
1668:
1669: case AMR_QINIT_SCAN:
1670: /* XXX we could print channel/target here */
1671: break;
1672: }
1673: }
1674: return(0);
1675: }
1676:
1677: static int
1678: amr_std_init(struct amr_softc *sc)
1679: {
1680: int status, ostatus;
1681:
1682: device_printf(sc->amr_dev, "initial init status %x\n", AMR_SGET_INITSTATUS(sc));
1683:
1684: AMR_SRESET(sc);
1685:
1686: ostatus = 0xff;
1687: while ((status = AMR_SGET_INITSTATUS(sc)) != AMR_SINIT_DONE) {
1688: if (status != ostatus) {
1689: device_printf(sc->amr_dev, "(%x) %s\n", status, amr_describe_code(amr_table_sinit, status));
1690: ostatus = status;
1691: }
1692: switch (status) {
1693: case AMR_SINIT_NOMEM:
1694: return(ENOMEM);
1695:
1696: case AMR_SINIT_INPROG:
1697: /* XXX we could print channel/target here? */
1698: break;
1699: }
1700: }
1701: return(0);
1702: }
1703: #endif
1704:
1705: /********************************************************************************
1706: ********************************************************************************
1707: Debugging
1708: ********************************************************************************
1709: ********************************************************************************/
1710:
1711: /********************************************************************************
1712: * Identify the controller and print some information about it.
1713: */
1714: static void
1715: amr_describe_controller(struct amr_softc *sc)
1716: {
1717: struct amr_prodinfo *ap;
1718: struct amr_enquiry *ae;
1719: char *prod;
1720:
1721: /*
1722: * Try to get 40LD product info, which tells us what the card is labelled as.
1723: */
1724: if ((ap = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODUCT_INFO, 0)) != NULL) {
1725: device_printf(sc->amr_dev, "<LSILogic %.80s> Firmware %.16s, BIOS %.16s, %dMB RAM\n",
1726: ap->ap_product, ap->ap_firmware, ap->ap_bios,
1727: ap->ap_memsize);
1728:
1729: free(ap, M_DEVBUF);
1730: return;
1731: }
1732:
1733: /*
1734: * Try 8LD extended ENQUIRY to get controller signature, and use lookup table.
1735: */
1736: if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_EXT_ENQUIRY2, 0, 0)) != NULL) {
1737: prod = amr_describe_code(amr_table_adaptertype, ae->ae_signature);
1738:
1739: } else if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0)) != NULL) {
1740:
1741: /*
1742: * Try to work it out based on the PCI signatures.
1743: */
1744: switch (pci_get_device(sc->amr_dev)) {
1745: case 0x9010:
1746: prod = "Series 428";
1747: break;
1748: case 0x9060:
1749: prod = "Series 434";
1750: break;
1751: default:
1752: prod = "unknown controller";
1753: break;
1754: }
1755: } else {
1756: prod = "unsupported controller";
1757: }
1758:
1759: /*
1760: * HP NetRaid controllers have a special encoding of the firmware and
1761: * BIOS versions. The AMI version seems to have it as strings whereas
1762: * the HP version does it with a leading uppercase character and two
1763: * binary numbers.
1764: */
1765:
1766: if(ae->ae_adapter.aa_firmware[2] >= 'A' &&
1767: ae->ae_adapter.aa_firmware[2] <= 'Z' &&
1768: ae->ae_adapter.aa_firmware[1] < ' ' &&
1769: ae->ae_adapter.aa_firmware[0] < ' ' &&
1770: ae->ae_adapter.aa_bios[2] >= 'A' &&
1771: ae->ae_adapter.aa_bios[2] <= 'Z' &&
1772: ae->ae_adapter.aa_bios[1] < ' ' &&
1773: ae->ae_adapter.aa_bios[0] < ' ') {
1774:
1775: /* this looks like we have an HP NetRaid version of the MegaRaid */
1776:
1777: if(ae->ae_signature == AMR_SIG_438) {
1778: /* the AMI 438 is a NetRaid 3si in HP-land */
1779: prod = "HP NetRaid 3si";
1780: }
1781:
1782: device_printf(sc->amr_dev, "<%s> Firmware %c.%02d.%02d, BIOS %c.%02d.%02d, %dMB RAM\n",
1783: prod, ae->ae_adapter.aa_firmware[2],
1784: ae->ae_adapter.aa_firmware[1],
1785: ae->ae_adapter.aa_firmware[0],
1786: ae->ae_adapter.aa_bios[2],
1787: ae->ae_adapter.aa_bios[1],
1788: ae->ae_adapter.aa_bios[0],
1789: ae->ae_adapter.aa_memorysize);
1790: } else {
1791: device_printf(sc->amr_dev, "<%s> Firmware %.4s, BIOS %.4s, %dMB RAM\n",
1792: prod, ae->ae_adapter.aa_firmware, ae->ae_adapter.aa_bios,
1793: ae->ae_adapter.aa_memorysize);
1794: }
1795: free(ae, M_DEVBUF);
1796: }
1797:
1798: int
1799: amr_dump_blocks(struct amr_softc *sc, int unit, u_int32_t lba, void *data, int blks)
1800: {
1801:
1802: struct amr_command *ac;
1803: int error = 1;
1804:
1805: debug_called(1);
1806:
1807: sc->amr_state &= ~AMR_STATE_INTEN;
1808:
1809: /* get ourselves a command buffer */
1810: if ((ac = amr_alloccmd(sc)) == NULL)
1811: goto out;
1812: /* set command flags */
1813: ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT;
1814:
1815: /* point the command at our data */
1816: ac->ac_data = data;
1817: ac->ac_length = blks * AMR_BLKSIZE;
1818:
1819: /* build the command proper */
1820: ac->ac_mailbox.mb_command = AMR_CMD_LWRITE;
1821: ac->ac_mailbox.mb_blkcount = blks;
1822: ac->ac_mailbox.mb_lba = lba;
1823: ac->ac_mailbox.mb_drive = unit;
1824:
1825: /* can't assume that interrupts are going to work here, so play it safe */
1826: if (sc->amr_poll_command(ac))
1827: goto out;
1828: error = ac->ac_status;
1829:
1830: out:
1831: if (ac != NULL)
1832: amr_releasecmd(ac);
1833:
1834: sc->amr_state |= AMR_STATE_INTEN;
1835:
1836: return (error);
1837: }
1838:
1839:
1840: #ifdef AMR_DEBUG
1841: /********************************************************************************
1842: * Print the command (ac) in human-readable format
1843: */
1844: #if 0
1845: static void
1846: amr_printcommand(struct amr_command *ac)
1847: {
1848: struct amr_softc *sc = ac->ac_sc;
1849: struct amr_sgentry *sg;
1850: int i;
1851:
1852: device_printf(sc->amr_dev, "cmd %x ident %d drive %d\n",
1853: ac->ac_mailbox.mb_command, ac->ac_mailbox.mb_ident, ac->ac_mailbox.mb_drive);
1854: device_printf(sc->amr_dev, "blkcount %d lba %d\n",
1855: ac->ac_mailbox.mb_blkcount, ac->ac_mailbox.mb_lba);
1856: device_printf(sc->amr_dev, "virtaddr %p length %lu\n", ac->ac_data, (unsigned long)ac->ac_length);
1857: device_printf(sc->amr_dev, "sg physaddr %08x nsg %d\n",
1858: ac->ac_mailbox.mb_physaddr, ac->ac_mailbox.mb_nsgelem);
1859: device_printf(sc->amr_dev, "ccb %p bio %p\n", ac->ac_ccb_data, ac->ac_bio);
1860:
1861: /* get base address of s/g table */
1862: sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG);
1863: for (i = 0; i < ac->ac_mailbox.mb_nsgelem; i++, sg++)
1864: device_printf(sc->amr_dev, " %x/%d\n", sg->sg_addr, sg->sg_count);
1865: }
1866: #endif
1867: #endif
![[BACK]](/icons//back.gif){kind=icon}
Return to amr.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / sys / dev / raid / amr