2 * Copyright (c) 2000, 2001 Michael Smith
3 * Copyright (c) 2000 BSDi
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
27 * $FreeBSD: src/sys/dev/mly/mly.c,v 1.50 2010/01/28 08:41:30 mav Exp $
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/malloc.h>
33 #include <sys/kernel.h>
36 #include <sys/device.h>
37 #include <sys/ctype.h>
40 #include <sys/thread2.h>
42 #include <bus/cam/cam.h>
43 #include <bus/cam/cam_ccb.h>
44 #include <bus/cam/cam_periph.h>
45 #include <bus/cam/cam_sim.h>
46 #include <bus/cam/cam_xpt_periph.h>
47 #include <bus/cam/cam_xpt_sim.h>
48 #include <bus/cam/scsi/scsi_all.h>
49 #include <bus/cam/scsi/scsi_message.h>
51 #include <bus/pci/pcireg.h>
52 #include <bus/pci/pcivar.h>
54 #include <dev/raid/mly/mlyreg.h>
55 #include <dev/raid/mly/mlyio.h>
56 #include <dev/raid/mly/mlyvar.h>
57 #include <dev/raid/mly/mly_tables.h>
59 static int mly_probe(device_t dev
);
60 static int mly_attach(device_t dev
);
61 static int mly_pci_attach(struct mly_softc
*sc
);
62 static int mly_detach(device_t dev
);
63 static int mly_shutdown(device_t dev
);
64 static void mly_intr(void *arg
);
66 static int mly_sg_map(struct mly_softc
*sc
);
67 static void mly_sg_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
);
68 static int mly_mmbox_map(struct mly_softc
*sc
);
69 static void mly_mmbox_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
);
70 static void mly_free(struct mly_softc
*sc
);
72 static int mly_get_controllerinfo(struct mly_softc
*sc
);
73 static void mly_scan_devices(struct mly_softc
*sc
);
74 static void mly_rescan_btl(struct mly_softc
*sc
, int bus
, int target
);
75 static void mly_complete_rescan(struct mly_command
*mc
);
76 static int mly_get_eventstatus(struct mly_softc
*sc
);
77 static int mly_enable_mmbox(struct mly_softc
*sc
);
78 static int mly_flush(struct mly_softc
*sc
);
79 static int mly_ioctl(struct mly_softc
*sc
, struct mly_command_ioctl
*ioctl
, void **data
,
80 size_t datasize
, u_int8_t
*status
, void *sense_buffer
, size_t *sense_length
);
81 static void mly_check_event(struct mly_softc
*sc
);
82 static void mly_fetch_event(struct mly_softc
*sc
);
83 static void mly_complete_event(struct mly_command
*mc
);
84 static void mly_process_event(struct mly_softc
*sc
, struct mly_event
*me
);
85 static void mly_periodic(void *data
);
87 static int mly_immediate_command(struct mly_command
*mc
);
88 static int mly_start(struct mly_command
*mc
);
89 static void mly_done(struct mly_softc
*sc
);
90 static void mly_complete(void *context
, int pending
);
92 static int mly_alloc_command(struct mly_softc
*sc
, struct mly_command
**mcp
);
93 static void mly_release_command(struct mly_command
*mc
);
94 static void mly_alloc_commands_map(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
);
95 static int mly_alloc_commands(struct mly_softc
*sc
);
96 static void mly_release_commands(struct mly_softc
*sc
);
97 static void mly_map_command(struct mly_command
*mc
);
98 static void mly_unmap_command(struct mly_command
*mc
);
100 static int mly_cam_attach(struct mly_softc
*sc
);
101 static void mly_cam_detach(struct mly_softc
*sc
);
102 static void mly_cam_rescan_btl(struct mly_softc
*sc
, int bus
, int target
);
103 static void mly_cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
);
104 static void mly_cam_action(struct cam_sim
*sim
, union ccb
*ccb
);
105 static int mly_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
);
106 static void mly_cam_poll(struct cam_sim
*sim
);
107 static void mly_cam_complete(struct mly_command
*mc
);
108 static struct cam_periph
*mly_find_periph(struct mly_softc
*sc
, int bus
, int target
);
109 static int mly_name_device(struct mly_softc
*sc
, int bus
, int target
);
111 static int mly_fwhandshake(struct mly_softc
*sc
);
113 static void mly_describe_controller(struct mly_softc
*sc
);
115 static void mly_printstate(struct mly_softc
*sc
);
116 static void mly_print_command(struct mly_command
*mc
);
117 static void mly_print_packet(struct mly_command
*mc
);
118 static void mly_panic(struct mly_softc
*sc
, char *reason
);
119 static int mly_timeout(struct mly_softc
*sc
);
121 void mly_print_controller(int controller
);
124 static d_open_t mly_user_open
;
125 static d_close_t mly_user_close
;
126 static d_ioctl_t mly_user_ioctl
;
127 static int mly_user_command(struct mly_softc
*sc
, struct mly_user_command
*uc
);
128 static int mly_user_health(struct mly_softc
*sc
, struct mly_user_health
*uh
);
130 #define MLY_CMD_TIMEOUT 20
132 static device_method_t mly_methods
[] = {
133 /* Device interface */
134 DEVMETHOD(device_probe
, mly_probe
),
135 DEVMETHOD(device_attach
, mly_attach
),
136 DEVMETHOD(device_detach
, mly_detach
),
137 DEVMETHOD(device_shutdown
, mly_shutdown
),
141 static driver_t mly_pci_driver
= {
144 sizeof(struct mly_softc
)
147 static devclass_t mly_devclass
;
148 DRIVER_MODULE(mly
, pci
, mly_pci_driver
, mly_devclass
, NULL
, NULL
);
149 MODULE_DEPEND(mly
, pci
, 1, 1, 1);
150 MODULE_DEPEND(mly
, cam
, 1, 1, 1);
152 static struct dev_ops mly_ops
= {
154 .d_open
= mly_user_open
,
155 .d_close
= mly_user_close
,
156 .d_ioctl
= mly_user_ioctl
,
159 /********************************************************************************
160 ********************************************************************************
162 ********************************************************************************
163 ********************************************************************************/
165 static struct mly_ident
173 } mly_identifiers
[] = {
174 {0x1069, 0xba56, 0x1069, 0x0040, MLY_HWIF_STRONGARM
, "Mylex eXtremeRAID 2000"},
175 {0x1069, 0xba56, 0x1069, 0x0030, MLY_HWIF_STRONGARM
, "Mylex eXtremeRAID 3000"},
176 {0x1069, 0x0050, 0x1069, 0x0050, MLY_HWIF_I960RX
, "Mylex AcceleRAID 352"},
177 {0x1069, 0x0050, 0x1069, 0x0052, MLY_HWIF_I960RX
, "Mylex AcceleRAID 170"},
178 {0x1069, 0x0050, 0x1069, 0x0054, MLY_HWIF_I960RX
, "Mylex AcceleRAID 160"},
182 /********************************************************************************
183 * Compare the provided PCI device with the list we support.
186 mly_probe(device_t dev
)
192 for (m
= mly_identifiers
; m
->vendor
!= 0; m
++) {
193 if ((m
->vendor
== pci_get_vendor(dev
)) &&
194 (m
->device
== pci_get_device(dev
)) &&
195 ((m
->subvendor
== 0) || ((m
->subvendor
== pci_get_subvendor(dev
)) &&
196 (m
->subdevice
== pci_get_subdevice(dev
))))) {
198 device_set_desc(dev
, m
->desc
);
199 return(BUS_PROBE_DEFAULT
); /* allow room to be overridden */
205 /********************************************************************************
206 * Initialise the controller and softc
209 mly_attach(device_t dev
)
211 struct mly_softc
*sc
= device_get_softc(dev
);
219 if (device_get_unit(sc
->mly_dev
) == 0)
224 * Do PCI-specific initialisation.
226 if ((error
= mly_pci_attach(sc
)) != 0)
229 callout_init(&sc
->mly_periodic
);
230 callout_init(&sc
->mly_timeout
);
233 * Initialise per-controller queues.
237 mly_initq_complete(sc
);
240 * Initialise command-completion task.
242 TASK_INIT(&sc
->mly_task_complete
, 0, mly_complete
, sc
);
244 /* disable interrupts before we start talking to the controller */
245 MLY_MASK_INTERRUPTS(sc
);
248 * Wait for the controller to come ready, handshake with the firmware if required.
249 * This is typically only necessary on platforms where the controller BIOS does not
252 if ((error
= mly_fwhandshake(sc
)))
256 * Allocate initial command buffers.
258 if ((error
= mly_alloc_commands(sc
)))
262 * Obtain controller feature information
264 if ((error
= mly_get_controllerinfo(sc
)))
268 * Reallocate command buffers now we know how many we want.
270 mly_release_commands(sc
);
271 if ((error
= mly_alloc_commands(sc
)))
275 * Get the current event counter for health purposes, populate the initial
276 * health status buffer.
278 if ((error
= mly_get_eventstatus(sc
)))
282 * Enable memory-mailbox mode.
284 if ((error
= mly_enable_mmbox(sc
)))
290 if ((error
= mly_cam_attach(sc
)))
294 * Print a little information about the controller
296 mly_describe_controller(sc
);
299 * Mark all attached devices for rescan.
301 mly_scan_devices(sc
);
304 * Instigate the first status poll immediately. Rescan completions won't
305 * happen until interrupts are enabled, which should still be before
306 * the SCSI subsystem gets to us, courtesy of the "SCSI settling delay".
311 * Create the control device.
313 sc
->mly_dev_t
= make_dev(&mly_ops
, device_get_unit(sc
->mly_dev
),
314 UID_ROOT
, GID_OPERATOR
, S_IRUSR
| S_IWUSR
,
315 "mly%d", device_get_unit(sc
->mly_dev
));
316 sc
->mly_dev_t
->si_drv1
= sc
;
318 /* enable interrupts now */
319 MLY_UNMASK_INTERRUPTS(sc
);
322 callout_reset(&sc
->mly_timeout
, MLY_CMD_TIMEOUT
* hz
,
323 (timeout_t
*)mly_timeout
, sc
);
332 /********************************************************************************
333 * Perform PCI-specific initialisation.
336 mly_pci_attach(struct mly_softc
*sc
)
343 /* assume failure is 'not configured' */
347 * Verify that the adapter is correctly set up in PCI space.
349 * XXX we shouldn't do this; the PCI code should.
351 command
= pci_read_config(sc
->mly_dev
, PCIR_COMMAND
, 2);
352 command
|= PCIM_CMD_BUSMASTEREN
;
353 pci_write_config(sc
->mly_dev
, PCIR_COMMAND
, command
, 2);
354 command
= pci_read_config(sc
->mly_dev
, PCIR_COMMAND
, 2);
355 if (!(command
& PCIM_CMD_BUSMASTEREN
)) {
356 mly_printf(sc
, "can't enable busmaster feature\n");
359 if ((command
& PCIM_CMD_MEMEN
) == 0) {
360 mly_printf(sc
, "memory window not available\n");
365 * Allocate the PCI register window.
367 sc
->mly_regs_rid
= PCIR_BAR(0); /* first base address register */
368 if ((sc
->mly_regs_resource
= bus_alloc_resource_any(sc
->mly_dev
,
369 SYS_RES_MEMORY
, &sc
->mly_regs_rid
, RF_ACTIVE
)) == NULL
) {
370 mly_printf(sc
, "can't allocate register window\n");
373 sc
->mly_btag
= rman_get_bustag(sc
->mly_regs_resource
);
374 sc
->mly_bhandle
= rman_get_bushandle(sc
->mly_regs_resource
);
377 * Allocate and connect our interrupt.
380 if ((sc
->mly_irq
= bus_alloc_resource_any(sc
->mly_dev
, SYS_RES_IRQ
,
381 &sc
->mly_irq_rid
, RF_SHAREABLE
| RF_ACTIVE
)) == NULL
) {
382 mly_printf(sc
, "can't allocate interrupt\n");
385 error
= bus_setup_intr(sc
->mly_dev
, sc
->mly_irq
, 0,
386 mly_intr
, sc
, &sc
->mly_intr
, NULL
);
388 mly_printf(sc
, "can't set up interrupt\n");
392 /* assume failure is 'out of memory' */
396 * Allocate the parent bus DMA tag appropriate for our PCI interface.
398 * Note that all of these controllers are 64-bit capable.
400 if (bus_dma_tag_create(NULL
, /* parent */
401 1, 0, /* alignment, boundary */
402 BUS_SPACE_MAXADDR_32BIT
, /* lowaddr */
403 BUS_SPACE_MAXADDR
, /* highaddr */
404 MAXBSIZE
, MLY_MAX_SGENTRIES
, /* maxsize, nsegments */
405 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
406 BUS_DMA_ALLOCNOW
, /* flags */
407 &sc
->mly_parent_dmat
)) {
408 mly_printf(sc
, "can't allocate parent DMA tag\n");
413 * Create DMA tag for mapping buffers into controller-addressable space.
415 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
416 1, 0, /* alignment, boundary */
417 BUS_SPACE_MAXADDR
, /* lowaddr */
418 BUS_SPACE_MAXADDR
, /* highaddr */
419 MAXBSIZE
, MLY_MAX_SGENTRIES
, /* maxsize, nsegments */
420 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
422 &sc
->mly_buffer_dmat
)) {
423 mly_printf(sc
, "can't allocate buffer DMA tag\n");
428 * Initialise the DMA tag for command packets.
430 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
431 1, 0, /* alignment, boundary */
432 BUS_SPACE_MAXADDR
, /* lowaddr */
433 BUS_SPACE_MAXADDR
, /* highaddr */
434 sizeof(union mly_command_packet
) * MLY_MAX_COMMANDS
, 1, /* maxsize, nsegments */
435 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
436 BUS_DMA_ALLOCNOW
, /* flags */
437 &sc
->mly_packet_dmat
)) {
438 mly_printf(sc
, "can't allocate command packet DMA tag\n");
443 * Detect the hardware interface version
445 for (i
= 0; mly_identifiers
[i
].vendor
!= 0; i
++) {
446 if ((mly_identifiers
[i
].vendor
== pci_get_vendor(sc
->mly_dev
)) &&
447 (mly_identifiers
[i
].device
== pci_get_device(sc
->mly_dev
))) {
448 sc
->mly_hwif
= mly_identifiers
[i
].hwif
;
449 switch(sc
->mly_hwif
) {
450 case MLY_HWIF_I960RX
:
451 debug(1, "set hardware up for i960RX");
452 sc
->mly_doorbell_true
= 0x00;
453 sc
->mly_command_mailbox
= MLY_I960RX_COMMAND_MAILBOX
;
454 sc
->mly_status_mailbox
= MLY_I960RX_STATUS_MAILBOX
;
455 sc
->mly_idbr
= MLY_I960RX_IDBR
;
456 sc
->mly_odbr
= MLY_I960RX_ODBR
;
457 sc
->mly_error_status
= MLY_I960RX_ERROR_STATUS
;
458 sc
->mly_interrupt_status
= MLY_I960RX_INTERRUPT_STATUS
;
459 sc
->mly_interrupt_mask
= MLY_I960RX_INTERRUPT_MASK
;
461 case MLY_HWIF_STRONGARM
:
462 debug(1, "set hardware up for StrongARM");
463 sc
->mly_doorbell_true
= 0xff; /* doorbell 'true' is 0 */
464 sc
->mly_command_mailbox
= MLY_STRONGARM_COMMAND_MAILBOX
;
465 sc
->mly_status_mailbox
= MLY_STRONGARM_STATUS_MAILBOX
;
466 sc
->mly_idbr
= MLY_STRONGARM_IDBR
;
467 sc
->mly_odbr
= MLY_STRONGARM_ODBR
;
468 sc
->mly_error_status
= MLY_STRONGARM_ERROR_STATUS
;
469 sc
->mly_interrupt_status
= MLY_STRONGARM_INTERRUPT_STATUS
;
470 sc
->mly_interrupt_mask
= MLY_STRONGARM_INTERRUPT_MASK
;
478 * Create the scatter/gather mappings.
480 if ((error
= mly_sg_map(sc
)))
484 * Allocate and map the memory mailbox
486 if ((error
= mly_mmbox_map(sc
)))
495 /********************************************************************************
496 * Shut the controller down and detach all our resources.
499 mly_detach(device_t dev
)
503 if ((error
= mly_shutdown(dev
)) != 0)
506 mly_free(device_get_softc(dev
));
510 /********************************************************************************
511 * Bring the controller to a state where it can be safely left alone.
513 * Note that it should not be necessary to wait for any outstanding commands,
514 * as they should be completed prior to calling here.
516 * XXX this applies for I/O, but not status polls; we should beware of
517 * the case where a status command is running while we detach.
520 mly_shutdown(device_t dev
)
522 struct mly_softc
*sc
= device_get_softc(dev
);
526 if (sc
->mly_state
& MLY_STATE_OPEN
)
529 /* kill the periodic event */
530 callout_stop(&sc
->mly_periodic
);
532 /* flush controller */
533 mly_printf(sc
, "flushing cache...");
534 kprintf("%s\n", mly_flush(sc
) ? "failed" : "done");
536 MLY_MASK_INTERRUPTS(sc
);
541 /*******************************************************************************
542 * Take an interrupt, or be poked by other code to look for interrupt-worthy
548 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
555 /********************************************************************************
556 ********************************************************************************
557 Bus-dependant Resource Management
558 ********************************************************************************
559 ********************************************************************************/
561 /********************************************************************************
562 * Allocate memory for the scatter/gather tables
565 mly_sg_map(struct mly_softc
*sc
)
572 * Create a single tag describing a region large enough to hold all of
573 * the s/g lists we will need.
575 segsize
= sizeof(struct mly_sg_entry
) * MLY_MAX_COMMANDS
*MLY_MAX_SGENTRIES
;
576 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
577 1, 0, /* alignment,boundary */
578 BUS_SPACE_MAXADDR
, /* lowaddr */
579 BUS_SPACE_MAXADDR
, /* highaddr */
580 segsize
, 1, /* maxsize, nsegments */
581 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
582 BUS_DMA_ALLOCNOW
, /* flags */
584 mly_printf(sc
, "can't allocate scatter/gather DMA tag\n");
589 * Allocate enough s/g maps for all commands and permanently map them into
590 * controller-visible space.
592 * XXX this assumes we can get enough space for all the s/g maps in one
595 if (bus_dmamem_alloc(sc
->mly_sg_dmat
, (void **)&sc
->mly_sg_table
,
596 BUS_DMA_NOWAIT
, &sc
->mly_sg_dmamap
)) {
597 mly_printf(sc
, "can't allocate s/g table\n");
600 if (bus_dmamap_load(sc
->mly_sg_dmat
, sc
->mly_sg_dmamap
, sc
->mly_sg_table
,
601 segsize
, mly_sg_map_helper
, sc
, BUS_DMA_NOWAIT
) != 0)
606 /********************************************************************************
607 * Save the physical address of the base of the s/g table.
610 mly_sg_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
612 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
616 /* save base of s/g table's address in bus space */
617 sc
->mly_sg_busaddr
= segs
->ds_addr
;
620 /********************************************************************************
621 * Allocate memory for the memory-mailbox interface
624 mly_mmbox_map(struct mly_softc
*sc
)
628 * Create a DMA tag for a single contiguous region large enough for the
629 * memory mailbox structure.
631 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
632 1, 0, /* alignment,boundary */
633 BUS_SPACE_MAXADDR
, /* lowaddr */
634 BUS_SPACE_MAXADDR
, /* highaddr */
635 sizeof(struct mly_mmbox
), 1, /* maxsize, nsegments */
636 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
637 BUS_DMA_ALLOCNOW
, /* flags */
638 &sc
->mly_mmbox_dmat
)) {
639 mly_printf(sc
, "can't allocate memory mailbox DMA tag\n");
644 * Allocate the buffer
646 if (bus_dmamem_alloc(sc
->mly_mmbox_dmat
, (void **)&sc
->mly_mmbox
, BUS_DMA_NOWAIT
, &sc
->mly_mmbox_dmamap
)) {
647 mly_printf(sc
, "can't allocate memory mailbox\n");
650 if (bus_dmamap_load(sc
->mly_mmbox_dmat
, sc
->mly_mmbox_dmamap
, sc
->mly_mmbox
,
651 sizeof(struct mly_mmbox
), mly_mmbox_map_helper
, sc
,
652 BUS_DMA_NOWAIT
) != 0)
654 bzero(sc
->mly_mmbox
, sizeof(*sc
->mly_mmbox
));
659 /********************************************************************************
660 * Save the physical address of the memory mailbox
663 mly_mmbox_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
665 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
669 sc
->mly_mmbox_busaddr
= segs
->ds_addr
;
672 /********************************************************************************
673 * Free all of the resources associated with (sc)
675 * Should not be called if the controller is active.
678 mly_free(struct mly_softc
*sc
)
683 /* Remove the management device */
684 destroy_dev(sc
->mly_dev_t
);
686 /* detach from CAM */
689 /* release command memory */
690 mly_release_commands(sc
);
692 /* throw away the controllerinfo structure */
693 if (sc
->mly_controllerinfo
!= NULL
)
694 kfree(sc
->mly_controllerinfo
, M_DEVBUF
);
696 /* throw away the controllerparam structure */
697 if (sc
->mly_controllerparam
!= NULL
)
698 kfree(sc
->mly_controllerparam
, M_DEVBUF
);
700 /* destroy data-transfer DMA tag */
701 if (sc
->mly_buffer_dmat
)
702 bus_dma_tag_destroy(sc
->mly_buffer_dmat
);
704 /* free and destroy DMA memory and tag for s/g lists */
705 if (sc
->mly_sg_table
) {
706 bus_dmamap_unload(sc
->mly_sg_dmat
, sc
->mly_sg_dmamap
);
707 bus_dmamem_free(sc
->mly_sg_dmat
, sc
->mly_sg_table
, sc
->mly_sg_dmamap
);
710 bus_dma_tag_destroy(sc
->mly_sg_dmat
);
712 /* free and destroy DMA memory and tag for memory mailbox */
714 bus_dmamap_unload(sc
->mly_mmbox_dmat
, sc
->mly_mmbox_dmamap
);
715 bus_dmamem_free(sc
->mly_mmbox_dmat
, sc
->mly_mmbox
, sc
->mly_mmbox_dmamap
);
717 if (sc
->mly_mmbox_dmat
)
718 bus_dma_tag_destroy(sc
->mly_mmbox_dmat
);
720 /* disconnect the interrupt handler */
722 bus_teardown_intr(sc
->mly_dev
, sc
->mly_irq
, sc
->mly_intr
);
723 if (sc
->mly_irq
!= NULL
)
724 bus_release_resource(sc
->mly_dev
, SYS_RES_IRQ
, sc
->mly_irq_rid
, sc
->mly_irq
);
726 /* destroy the parent DMA tag */
727 if (sc
->mly_parent_dmat
)
728 bus_dma_tag_destroy(sc
->mly_parent_dmat
);
730 /* release the register window mapping */
731 if (sc
->mly_regs_resource
!= NULL
)
732 bus_release_resource(sc
->mly_dev
, SYS_RES_MEMORY
, sc
->mly_regs_rid
, sc
->mly_regs_resource
);
735 /********************************************************************************
736 ********************************************************************************
738 ********************************************************************************
739 ********************************************************************************/
741 /********************************************************************************
742 * Fill in the mly_controllerinfo and mly_controllerparam fields in the softc.
745 mly_get_controllerinfo(struct mly_softc
*sc
)
747 struct mly_command_ioctl mci
;
753 if (sc
->mly_controllerinfo
!= NULL
)
754 kfree(sc
->mly_controllerinfo
, M_DEVBUF
);
756 /* build the getcontrollerinfo ioctl and send it */
757 bzero(&mci
, sizeof(mci
));
758 sc
->mly_controllerinfo
= NULL
;
759 mci
.sub_ioctl
= MDACIOCTL_GETCONTROLLERINFO
;
760 if ((error
= mly_ioctl(sc
, &mci
, (void **)&sc
->mly_controllerinfo
, sizeof(*sc
->mly_controllerinfo
),
761 &status
, NULL
, NULL
)))
766 if (sc
->mly_controllerparam
!= NULL
)
767 kfree(sc
->mly_controllerparam
, M_DEVBUF
);
769 /* build the getcontrollerparameter ioctl and send it */
770 bzero(&mci
, sizeof(mci
));
771 sc
->mly_controllerparam
= NULL
;
772 mci
.sub_ioctl
= MDACIOCTL_GETCONTROLLERPARAMETER
;
773 if ((error
= mly_ioctl(sc
, &mci
, (void **)&sc
->mly_controllerparam
, sizeof(*sc
->mly_controllerparam
),
774 &status
, NULL
, NULL
)))
782 /********************************************************************************
783 * Schedule all possible devices for a rescan.
787 mly_scan_devices(struct mly_softc
*sc
)
794 * Clear any previous BTL information.
796 bzero(&sc
->mly_btl
, sizeof(sc
->mly_btl
));
799 * Mark all devices as requiring a rescan, and let the next
800 * periodic scan collect them.
802 for (bus
= 0; bus
< sc
->mly_cam_channels
; bus
++)
803 if (MLY_BUS_IS_VALID(sc
, bus
))
804 for (target
= 0; target
< MLY_MAX_TARGETS
; target
++)
805 sc
->mly_btl
[bus
][target
].mb_flags
= MLY_BTL_RESCAN
;
809 /********************************************************************************
810 * Rescan a device, possibly as a consequence of getting an event which suggests
811 * that it may have changed.
813 * If we suffer resource starvation, we can abandon the rescan as we'll be
817 mly_rescan_btl(struct mly_softc
*sc
, int bus
, int target
)
819 struct mly_command
*mc
;
820 struct mly_command_ioctl
*mci
;
824 /* check that this bus is valid */
825 if (!MLY_BUS_IS_VALID(sc
, bus
))
829 if (mly_alloc_command(sc
, &mc
))
832 /* set up the data buffer */
833 mc
->mc_data
= kmalloc(sizeof(union mly_devinfo
), M_DEVBUF
, M_INTWAIT
| M_ZERO
);
834 mc
->mc_flags
|= MLY_CMD_DATAIN
;
835 mc
->mc_complete
= mly_complete_rescan
;
840 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
841 mci
->opcode
= MDACMD_IOCTL
;
842 mci
->addr
.phys
.controller
= 0;
843 mci
->timeout
.value
= 30;
844 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
845 if (MLY_BUS_IS_VIRTUAL(sc
, bus
)) {
846 mc
->mc_length
= mci
->data_size
= sizeof(struct mly_ioctl_getlogdevinfovalid
);
847 mci
->sub_ioctl
= MDACIOCTL_GETLOGDEVINFOVALID
;
848 mci
->addr
.log
.logdev
= MLY_LOGDEV_ID(sc
, bus
, target
);
849 debug(1, "logical device %d", mci
->addr
.log
.logdev
);
851 mc
->mc_length
= mci
->data_size
= sizeof(struct mly_ioctl_getphysdevinfovalid
);
852 mci
->sub_ioctl
= MDACIOCTL_GETPHYSDEVINFOVALID
;
853 mci
->addr
.phys
.lun
= 0;
854 mci
->addr
.phys
.target
= target
;
855 mci
->addr
.phys
.channel
= bus
;
856 debug(1, "physical device %d:%d", mci
->addr
.phys
.channel
, mci
->addr
.phys
.target
);
860 * Dispatch the command. If we successfully send the command, clear the rescan
863 if (mly_start(mc
) != 0) {
864 mly_release_command(mc
);
866 sc
->mly_btl
[bus
][target
].mb_flags
&= ~MLY_BTL_RESCAN
; /* success */
870 /********************************************************************************
871 * Handle the completion of a rescan operation
874 mly_complete_rescan(struct mly_command
*mc
)
876 struct mly_softc
*sc
= mc
->mc_sc
;
877 struct mly_ioctl_getlogdevinfovalid
*ldi
;
878 struct mly_ioctl_getphysdevinfovalid
*pdi
;
879 struct mly_command_ioctl
*mci
;
880 struct mly_btl btl
, *btlp
;
881 int bus
, target
, rescan
;
886 * Recover the bus and target from the command. We need these even in
887 * the case where we don't have a useful response.
889 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
890 if (mci
->sub_ioctl
== MDACIOCTL_GETLOGDEVINFOVALID
) {
891 bus
= MLY_LOGDEV_BUS(sc
, mci
->addr
.log
.logdev
);
892 target
= MLY_LOGDEV_TARGET(sc
, mci
->addr
.log
.logdev
);
894 bus
= mci
->addr
.phys
.channel
;
895 target
= mci
->addr
.phys
.target
;
897 /* XXX validate bus/target? */
899 /* the default result is 'no device' */
900 bzero(&btl
, sizeof(btl
));
902 /* if the rescan completed OK, we have possibly-new BTL data */
903 if (mc
->mc_status
== 0) {
904 if (mc
->mc_length
== sizeof(*ldi
)) {
905 ldi
= (struct mly_ioctl_getlogdevinfovalid
*)mc
->mc_data
;
906 if ((MLY_LOGDEV_BUS(sc
, ldi
->logical_device_number
) != bus
) ||
907 (MLY_LOGDEV_TARGET(sc
, ldi
->logical_device_number
) != target
)) {
908 mly_printf(sc
, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
909 bus
, target
, MLY_LOGDEV_BUS(sc
, ldi
->logical_device_number
),
910 MLY_LOGDEV_TARGET(sc
, ldi
->logical_device_number
));
911 /* XXX what can we do about this? */
913 btl
.mb_flags
= MLY_BTL_LOGICAL
;
914 btl
.mb_type
= ldi
->raid_level
;
915 btl
.mb_state
= ldi
->state
;
916 debug(1, "BTL rescan for %d returns %s, %s", ldi
->logical_device_number
,
917 mly_describe_code(mly_table_device_type
, ldi
->raid_level
),
918 mly_describe_code(mly_table_device_state
, ldi
->state
));
919 } else if (mc
->mc_length
== sizeof(*pdi
)) {
920 pdi
= (struct mly_ioctl_getphysdevinfovalid
*)mc
->mc_data
;
921 if ((pdi
->channel
!= bus
) || (pdi
->target
!= target
)) {
922 mly_printf(sc
, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
923 bus
, target
, pdi
->channel
, pdi
->target
);
924 /* XXX what can we do about this? */
926 btl
.mb_flags
= MLY_BTL_PHYSICAL
;
927 btl
.mb_type
= MLY_DEVICE_TYPE_PHYSICAL
;
928 btl
.mb_state
= pdi
->state
;
929 btl
.mb_speed
= pdi
->speed
;
930 btl
.mb_width
= pdi
->width
;
931 if (pdi
->state
!= MLY_DEVICE_STATE_UNCONFIGURED
)
932 sc
->mly_btl
[bus
][target
].mb_flags
|= MLY_BTL_PROTECTED
;
933 debug(1, "BTL rescan for %d:%d returns %s", bus
, target
,
934 mly_describe_code(mly_table_device_state
, pdi
->state
));
936 mly_printf(sc
, "BTL rescan result invalid\n");
940 kfree(mc
->mc_data
, M_DEVBUF
);
941 mly_release_command(mc
);
944 * Decide whether we need to rescan the device.
948 /* device type changes (usually between 'nothing' and 'something') */
949 btlp
= &sc
->mly_btl
[bus
][target
];
950 if (btl
.mb_flags
!= btlp
->mb_flags
) {
951 debug(1, "flags changed, rescanning");
955 /* XXX other reasons? */
958 * Update BTL information.
963 * Perform CAM rescan if required.
966 mly_cam_rescan_btl(sc
, bus
, target
);
969 /********************************************************************************
970 * Get the current health status and set the 'next event' counter to suit.
973 mly_get_eventstatus(struct mly_softc
*sc
)
975 struct mly_command_ioctl mci
;
976 struct mly_health_status
*mh
;
980 /* build the gethealthstatus ioctl and send it */
981 bzero(&mci
, sizeof(mci
));
983 mci
.sub_ioctl
= MDACIOCTL_GETHEALTHSTATUS
;
985 if ((error
= mly_ioctl(sc
, &mci
, (void **)&mh
, sizeof(*mh
), &status
, NULL
, NULL
)))
990 /* get the event counter */
991 sc
->mly_event_change
= mh
->change_counter
;
992 sc
->mly_event_waiting
= mh
->next_event
;
993 sc
->mly_event_counter
= mh
->next_event
;
995 /* save the health status into the memory mailbox */
996 bcopy(mh
, &sc
->mly_mmbox
->mmm_health
.status
, sizeof(*mh
));
998 debug(1, "initial change counter %d, event counter %d", mh
->change_counter
, mh
->next_event
);
1000 kfree(mh
, M_DEVBUF
);
1004 /********************************************************************************
1005 * Enable the memory mailbox mode.
1008 mly_enable_mmbox(struct mly_softc
*sc
)
1010 struct mly_command_ioctl mci
;
1011 u_int8_t
*sp
, status
;
1016 /* build the ioctl and send it */
1017 bzero(&mci
, sizeof(mci
));
1018 mci
.sub_ioctl
= MDACIOCTL_SETMEMORYMAILBOX
;
1019 /* set buffer addresses */
1020 mci
.param
.setmemorymailbox
.command_mailbox_physaddr
=
1021 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_command
);
1022 mci
.param
.setmemorymailbox
.status_mailbox_physaddr
=
1023 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_status
);
1024 mci
.param
.setmemorymailbox
.health_buffer_physaddr
=
1025 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_health
);
1027 /* set buffer sizes - abuse of data_size field is revolting */
1028 sp
= (u_int8_t
*)&mci
.data_size
;
1029 sp
[0] = ((sizeof(union mly_command_packet
) * MLY_MMBOX_COMMANDS
) / 1024);
1030 sp
[1] = (sizeof(union mly_status_packet
) * MLY_MMBOX_STATUS
) / 1024;
1031 mci
.param
.setmemorymailbox
.health_buffer_size
= sizeof(union mly_health_region
) / 1024;
1033 debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc
->mly_mmbox
,
1034 mci
.param
.setmemorymailbox
.command_mailbox_physaddr
, sp
[0],
1035 mci
.param
.setmemorymailbox
.status_mailbox_physaddr
, sp
[1],
1036 mci
.param
.setmemorymailbox
.health_buffer_physaddr
,
1037 mci
.param
.setmemorymailbox
.health_buffer_size
);
1039 if ((error
= mly_ioctl(sc
, &mci
, NULL
, 0, &status
, NULL
, NULL
)))
1043 sc
->mly_state
|= MLY_STATE_MMBOX_ACTIVE
;
1044 debug(1, "memory mailbox active");
1048 /********************************************************************************
1049 * Flush all pending I/O from the controller.
1052 mly_flush(struct mly_softc
*sc
)
1054 struct mly_command_ioctl mci
;
1060 /* build the ioctl */
1061 bzero(&mci
, sizeof(mci
));
1062 mci
.sub_ioctl
= MDACIOCTL_FLUSHDEVICEDATA
;
1063 mci
.param
.deviceoperation
.operation_device
= MLY_OPDEVICE_PHYSICAL_CONTROLLER
;
1065 /* pass it off to the controller */
1066 if ((error
= mly_ioctl(sc
, &mci
, NULL
, 0, &status
, NULL
, NULL
)))
1069 return((status
== 0) ? 0 : EIO
);
1072 /********************************************************************************
1073 * Perform an ioctl command.
1075 * If (data) is not NULL, the command requires data transfer. If (*data) is NULL
1076 * the command requires data transfer from the controller, and we will allocate
1077 * a buffer for it. If (*data) is not NULL, the command requires data transfer
1078 * to the controller.
1080 * XXX passing in the whole ioctl structure is ugly. Better ideas?
1082 * XXX we don't even try to handle the case where datasize > 4k. We should.
1085 mly_ioctl(struct mly_softc
*sc
, struct mly_command_ioctl
*ioctl
, void **data
, size_t datasize
,
1086 u_int8_t
*status
, void *sense_buffer
, size_t *sense_length
)
1088 struct mly_command
*mc
;
1089 struct mly_command_ioctl
*mci
;
1095 if (mly_alloc_command(sc
, &mc
)) {
1100 /* copy the ioctl structure, but save some important fields and then fixup */
1101 mci
= &mc
->mc_packet
->ioctl
;
1102 ioctl
->sense_buffer_address
= mci
->sense_buffer_address
;
1103 ioctl
->maximum_sense_size
= mci
->maximum_sense_size
;
1105 mci
->opcode
= MDACMD_IOCTL
;
1106 mci
->timeout
.value
= 30;
1107 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
1109 /* handle the data buffer */
1111 if (*data
== NULL
) {
1112 /* allocate data buffer */
1113 mc
->mc_data
= kmalloc(datasize
, M_DEVBUF
, M_INTWAIT
);
1114 mc
->mc_flags
|= MLY_CMD_DATAIN
;
1116 mc
->mc_data
= *data
;
1117 mc
->mc_flags
|= MLY_CMD_DATAOUT
;
1119 mc
->mc_length
= datasize
;
1120 mc
->mc_packet
->generic
.data_size
= datasize
;
1123 /* run the command */
1124 if ((error
= mly_immediate_command(mc
)))
1127 /* clean up and return any data */
1128 *status
= mc
->mc_status
;
1129 if ((mc
->mc_sense
> 0) && (sense_buffer
!= NULL
)) {
1130 bcopy(mc
->mc_packet
, sense_buffer
, mc
->mc_sense
);
1131 *sense_length
= mc
->mc_sense
;
1135 /* should we return a data pointer? */
1136 if ((data
!= NULL
) && (*data
== NULL
))
1137 *data
= mc
->mc_data
;
1139 /* command completed OK */
1144 /* do we need to free a data buffer we allocated? */
1145 if (error
&& (mc
->mc_data
!= NULL
) && (*data
== NULL
))
1146 kfree(mc
->mc_data
, M_DEVBUF
);
1147 mly_release_command(mc
);
1152 /********************************************************************************
1153 * Check for event(s) outstanding in the controller.
1156 mly_check_event(struct mly_softc
*sc
)
1160 * The controller may have updated the health status information,
1161 * so check for it here. Note that the counters are all in host memory,
1162 * so this check is very cheap. Also note that we depend on checking on
1165 if (sc
->mly_mmbox
->mmm_health
.status
.change_counter
!= sc
->mly_event_change
) {
1166 sc
->mly_event_change
= sc
->mly_mmbox
->mmm_health
.status
.change_counter
;
1167 debug(1, "event change %d, event status update, %d -> %d", sc
->mly_event_change
,
1168 sc
->mly_event_waiting
, sc
->mly_mmbox
->mmm_health
.status
.next_event
);
1169 sc
->mly_event_waiting
= sc
->mly_mmbox
->mmm_health
.status
.next_event
;
1171 /* wake up anyone that might be interested in this */
1172 wakeup(&sc
->mly_event_change
);
1174 if (sc
->mly_event_counter
!= sc
->mly_event_waiting
)
1175 mly_fetch_event(sc
);
1178 /********************************************************************************
1179 * Fetch one event from the controller.
1181 * If we fail due to resource starvation, we'll be retried the next time a
1182 * command completes.
1185 mly_fetch_event(struct mly_softc
*sc
)
1187 struct mly_command
*mc
;
1188 struct mly_command_ioctl
*mci
;
1194 if (mly_alloc_command(sc
, &mc
))
1197 /* set up the data buffer */
1198 mc
->mc_data
= kmalloc(sizeof(struct mly_event
), M_DEVBUF
, M_INTWAIT
|M_ZERO
);
1199 mc
->mc_length
= sizeof(struct mly_event
);
1200 mc
->mc_flags
|= MLY_CMD_DATAIN
;
1201 mc
->mc_complete
= mly_complete_event
;
1204 * Get an event number to fetch. It's possible that we've raced with another
1205 * context for the last event, in which case there will be no more events.
1208 if (sc
->mly_event_counter
== sc
->mly_event_waiting
) {
1209 mly_release_command(mc
);
1213 event
= sc
->mly_event_counter
++;
1219 * At this point we are committed to sending this request, as it
1220 * will be the only one constructed for this particular event number.
1222 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
1223 mci
->opcode
= MDACMD_IOCTL
;
1224 mci
->data_size
= sizeof(struct mly_event
);
1225 mci
->addr
.phys
.lun
= (event
>> 16) & 0xff;
1226 mci
->addr
.phys
.target
= (event
>> 24) & 0xff;
1227 mci
->addr
.phys
.channel
= 0;
1228 mci
->addr
.phys
.controller
= 0;
1229 mci
->timeout
.value
= 30;
1230 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
1231 mci
->sub_ioctl
= MDACIOCTL_GETEVENT
;
1232 mci
->param
.getevent
.sequence_number_low
= event
& 0xffff;
1234 debug(1, "fetch event %u", event
);
1237 * Submit the command.
1239 * Note that failure of mly_start() will result in this event never being
1242 if (mly_start(mc
) != 0) {
1243 mly_printf(sc
, "couldn't fetch event %u\n", event
);
1244 mly_release_command(mc
);
1248 /********************************************************************************
1249 * Handle the completion of an event poll.
1252 mly_complete_event(struct mly_command
*mc
)
1254 struct mly_softc
*sc
= mc
->mc_sc
;
1255 struct mly_event
*me
= (struct mly_event
*)mc
->mc_data
;
1260 * If the event was successfully fetched, process it.
1262 if (mc
->mc_status
== SCSI_STATUS_OK
) {
1263 mly_process_event(sc
, me
);
1264 kfree(me
, M_DEVBUF
);
1266 mly_release_command(mc
);
1269 * Check for another event.
1271 mly_check_event(sc
);
1274 /********************************************************************************
1275 * Process a controller event.
1278 mly_process_event(struct mly_softc
*sc
, struct mly_event
*me
)
1280 struct scsi_sense_data
*ssd
= (struct scsi_sense_data
*)&me
->sense
[0];
1282 int bus
, target
, event
, class, action
;
1285 * Errors can be reported using vendor-unique sense data. In this case, the
1286 * event code will be 0x1c (Request sense data present), the sense key will
1287 * be 0x09 (vendor specific), the MSB of the ASC will be set, and the
1288 * actual event code will be a 16-bit value comprised of the ASCQ (low byte)
1289 * and low seven bits of the ASC (low seven bits of the high byte).
1291 if ((me
->code
== 0x1c) &&
1292 ((ssd
->flags
& SSD_KEY
) == SSD_KEY_Vendor_Specific
) &&
1293 (ssd
->add_sense_code
& 0x80)) {
1294 event
= ((int)(ssd
->add_sense_code
& ~0x80) << 8) + ssd
->add_sense_code_qual
;
1299 /* look up event, get codes */
1300 fp
= mly_describe_code(mly_table_event
, event
);
1302 debug(1, "Event %d code 0x%x", me
->sequence_number
, me
->code
);
1306 if (isupper(class) && bootverbose
)
1307 class = tolower(class);
1309 /* get action code, text string */
1314 * Print some information about the event.
1316 * This code uses a table derived from the corresponding portion of the Linux
1317 * driver, and thus the parser is very similar.
1320 case 'p': /* error on physical device */
1321 mly_printf(sc
, "physical device %d:%d %s\n", me
->channel
, me
->target
, tp
);
1323 sc
->mly_btl
[me
->channel
][me
->target
].mb_flags
|= MLY_BTL_RESCAN
;
1325 case 'l': /* error on logical unit */
1326 case 'm': /* message about logical unit */
1327 bus
= MLY_LOGDEV_BUS(sc
, me
->lun
);
1328 target
= MLY_LOGDEV_TARGET(sc
, me
->lun
);
1329 mly_name_device(sc
, bus
, target
);
1330 mly_printf(sc
, "logical device %d (%s) %s\n", me
->lun
, sc
->mly_btl
[bus
][target
].mb_name
, tp
);
1332 sc
->mly_btl
[bus
][target
].mb_flags
|= MLY_BTL_RESCAN
;
1334 case 's': /* report of sense data */
1335 if (((ssd
->flags
& SSD_KEY
) == SSD_KEY_NO_SENSE
) ||
1336 (((ssd
->flags
& SSD_KEY
) == SSD_KEY_NOT_READY
) &&
1337 (ssd
->add_sense_code
== 0x04) &&
1338 ((ssd
->add_sense_code_qual
== 0x01) || (ssd
->add_sense_code_qual
== 0x02))))
1339 break; /* ignore NO_SENSE or NOT_READY in one case */
1341 mly_printf(sc
, "physical device %d:%d %s\n", me
->channel
, me
->target
, tp
);
1342 mly_printf(sc
, " sense key %d asc %02x ascq %02x\n",
1343 ssd
->flags
& SSD_KEY
, ssd
->add_sense_code
, ssd
->add_sense_code_qual
);
1344 mly_printf(sc
, " info %s csi %s\n", hexncpy(ssd
->info
, 4, hexstr
[0], 12, NULL
),
1345 hexncpy(ssd
->cmd_spec_info
, 4, hexstr
[1], 12, NULL
));
1347 sc
->mly_btl
[me
->channel
][me
->target
].mb_flags
|= MLY_BTL_RESCAN
;
1350 mly_printf(sc
, tp
, me
->target
, me
->lun
);
1354 mly_printf(sc
, "controller %s\n", tp
);
1357 mly_printf(sc
, "%s - %d\n", tp
, me
->code
);
1359 default: /* probably a 'noisy' event being ignored */
1364 /********************************************************************************
1365 * Perform periodic activities.
1368 mly_periodic(void *data
)
1370 struct mly_softc
*sc
= (struct mly_softc
*)data
;
1378 for (bus
= 0; bus
< sc
->mly_cam_channels
; bus
++) {
1379 if (MLY_BUS_IS_VALID(sc
, bus
)) {
1380 for (target
= 0; target
< MLY_MAX_TARGETS
; target
++) {
1382 /* ignore the controller in this scan */
1383 if (target
== sc
->mly_controllerparam
->initiator_id
)
1386 /* perform device rescan? */
1387 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_RESCAN
)
1388 mly_rescan_btl(sc
, bus
, target
);
1393 /* check for controller events */
1394 mly_check_event(sc
);
1396 /* reschedule ourselves */
1397 callout_reset(&sc
->mly_periodic
, MLY_PERIODIC_INTERVAL
* hz
, mly_periodic
, sc
);
1400 /********************************************************************************
1401 ********************************************************************************
1403 ********************************************************************************
1404 ********************************************************************************/
1406 /********************************************************************************
1407 * Run a command and wait for it to complete.
1411 mly_immediate_command(struct mly_command
*mc
)
1413 struct mly_softc
*sc
= mc
->mc_sc
;
1418 /* spinning at splcam is ugly, but we're only used during controller init */
1420 if ((error
= mly_start(mc
))) {
1425 if (sc
->mly_state
& MLY_STATE_INTERRUPTS_ON
) {
1426 /* sleep on the command */
1427 while(!(mc
->mc_flags
& MLY_CMD_COMPLETE
)) {
1428 tsleep(mc
, 0, "mlywait", 0);
1431 /* spin and collect status while we do */
1432 while(!(mc
->mc_flags
& MLY_CMD_COMPLETE
)) {
1433 mly_done(mc
->mc_sc
);
1440 /********************************************************************************
1441 * Deliver a command to the controller.
1443 * XXX it would be good to just queue commands that we can't submit immediately
1444 * and send them later, but we probably want a wrapper for that so that
1445 * we don't hang on a failed submission for an immediate command.
1448 mly_start(struct mly_command
*mc
)
1450 struct mly_softc
*sc
= mc
->mc_sc
;
1451 union mly_command_packet
*pkt
;
1456 * Set the command up for delivery to the controller.
1458 mly_map_command(mc
);
1459 mc
->mc_packet
->generic
.command_id
= mc
->mc_slot
;
1462 mc
->mc_timestamp
= time_uptime
;
1468 * Do we have to use the hardware mailbox?
1470 if (!(sc
->mly_state
& MLY_STATE_MMBOX_ACTIVE
)) {
1472 * Check to see if the controller is ready for us.
1474 if (MLY_IDBR_TRUE(sc
, MLY_HM_CMDSENT
)) {
1478 mc
->mc_flags
|= MLY_CMD_BUSY
;
1481 * It's ready, send the command.
1483 MLY_SET_MBOX(sc
, sc
->mly_command_mailbox
, &mc
->mc_packetphys
);
1484 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_CMDSENT
);
1486 } else { /* use memory-mailbox mode */
1488 pkt
= &sc
->mly_mmbox
->mmm_command
[sc
->mly_mmbox_command_index
];
1490 /* check to see if the next index is free yet */
1491 if (pkt
->mmbox
.flag
!= 0) {
1495 mc
->mc_flags
|= MLY_CMD_BUSY
;
1497 /* copy in new command */
1498 bcopy(mc
->mc_packet
->mmbox
.data
, pkt
->mmbox
.data
, sizeof(pkt
->mmbox
.data
));
1499 /* barrier to ensure completion of previous write before we write the flag */
1500 bus_space_barrier(sc
->mly_btag
, sc
->mly_bhandle
, 0, 0,
1501 BUS_SPACE_BARRIER_WRITE
);
1502 /* copy flag last */
1503 pkt
->mmbox
.flag
= mc
->mc_packet
->mmbox
.flag
;
1504 /* barrier to ensure completion of previous write before we notify the controller */
1505 bus_space_barrier(sc
->mly_btag
, sc
->mly_bhandle
, 0, 0,
1506 BUS_SPACE_BARRIER_WRITE
);
1508 /* signal controller, update index */
1509 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_AM_CMDSENT
);
1510 sc
->mly_mmbox_command_index
= (sc
->mly_mmbox_command_index
+ 1) % MLY_MMBOX_COMMANDS
;
1513 mly_enqueue_busy(mc
);
1518 /********************************************************************************
1519 * Pick up command status from the controller, schedule a completion event
1522 mly_done(struct mly_softc
*sc
)
1524 struct mly_command
*mc
;
1525 union mly_status_packet
*sp
;
1532 /* pick up hardware-mailbox commands */
1533 if (MLY_ODBR_TRUE(sc
, MLY_HM_STSREADY
)) {
1534 slot
= MLY_GET_REG2(sc
, sc
->mly_status_mailbox
);
1535 if (slot
< MLY_SLOT_MAX
) {
1536 mc
= &sc
->mly_command
[slot
- MLY_SLOT_START
];
1537 mc
->mc_status
= MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 2);
1538 mc
->mc_sense
= MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 3);
1539 mc
->mc_resid
= MLY_GET_REG4(sc
, sc
->mly_status_mailbox
+ 4);
1540 mly_remove_busy(mc
);
1541 mc
->mc_flags
&= ~MLY_CMD_BUSY
;
1542 mly_enqueue_complete(mc
);
1545 /* slot 0xffff may mean "extremely bogus command" */
1546 mly_printf(sc
, "got HM completion for illegal slot %u\n", slot
);
1548 /* unconditionally acknowledge status */
1549 MLY_SET_REG(sc
, sc
->mly_odbr
, MLY_HM_STSREADY
);
1550 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_STSACK
);
1553 /* pick up memory-mailbox commands */
1554 if (MLY_ODBR_TRUE(sc
, MLY_AM_STSREADY
)) {
1556 sp
= &sc
->mly_mmbox
->mmm_status
[sc
->mly_mmbox_status_index
];
1558 /* check for more status */
1559 if (sp
->mmbox
.flag
== 0)
1562 /* get slot number */
1563 slot
= sp
->status
.command_id
;
1564 if (slot
< MLY_SLOT_MAX
) {
1565 mc
= &sc
->mly_command
[slot
- MLY_SLOT_START
];
1566 mc
->mc_status
= sp
->status
.status
;
1567 mc
->mc_sense
= sp
->status
.sense_length
;
1568 mc
->mc_resid
= sp
->status
.residue
;
1569 mly_remove_busy(mc
);
1570 mc
->mc_flags
&= ~MLY_CMD_BUSY
;
1571 mly_enqueue_complete(mc
);
1574 /* slot 0xffff may mean "extremely bogus command" */
1575 mly_printf(sc
, "got AM completion for illegal slot %u at %d\n",
1576 slot
, sc
->mly_mmbox_status_index
);
1579 /* clear and move to next index */
1581 sc
->mly_mmbox_status_index
= (sc
->mly_mmbox_status_index
+ 1) % MLY_MMBOX_STATUS
;
1583 /* acknowledge that we have collected status value(s) */
1584 MLY_SET_REG(sc
, sc
->mly_odbr
, MLY_AM_STSREADY
);
1589 if (sc
->mly_state
& MLY_STATE_INTERRUPTS_ON
)
1590 taskqueue_enqueue(taskqueue_swi
, &sc
->mly_task_complete
);
1592 mly_complete(sc
, 0);
1596 /********************************************************************************
1597 * Process completed commands
1600 mly_complete(void *context
, int pending
)
1602 struct mly_softc
*sc
= (struct mly_softc
*)context
;
1603 struct mly_command
*mc
;
1604 void (* mc_complete
)(struct mly_command
*mc
);
1610 * Spin pulling commands off the completed queue and processing them.
1612 while ((mc
= mly_dequeue_complete(sc
)) != NULL
) {
1615 * Free controller resources, mark command complete.
1617 * Note that as soon as we mark the command complete, it may be freed
1618 * out from under us, so we need to save the mc_complete field in
1619 * order to later avoid dereferencing mc. (We would not expect to
1620 * have a polling/sleeping consumer with mc_complete != NULL).
1622 mly_unmap_command(mc
);
1623 mc_complete
= mc
->mc_complete
;
1624 mc
->mc_flags
|= MLY_CMD_COMPLETE
;
1627 * Call completion handler or wake up sleeping consumer.
1629 if (mc_complete
!= NULL
) {
1637 * XXX if we are deferring commands due to controller-busy status, we should
1638 * retry submitting them here.
1642 /********************************************************************************
1643 ********************************************************************************
1644 Command Buffer Management
1645 ********************************************************************************
1646 ********************************************************************************/
1648 /********************************************************************************
1649 * Allocate a command.
1652 mly_alloc_command(struct mly_softc
*sc
, struct mly_command
**mcp
)
1654 struct mly_command
*mc
;
1658 if ((mc
= mly_dequeue_free(sc
)) == NULL
) {
1659 *mcp
= NULL
; /* avoid gcc warning */
1667 /********************************************************************************
1668 * Release a command back to the freelist.
1671 mly_release_command(struct mly_command
*mc
)
1676 * Fill in parts of the command that may cause confusion if
1677 * a consumer doesn't when we are later allocated.
1681 mc
->mc_complete
= NULL
;
1682 mc
->mc_private
= NULL
;
1685 * By default, we set up to overwrite the command packet with
1686 * sense information.
1688 mc
->mc_packet
->generic
.sense_buffer_address
= mc
->mc_packetphys
;
1689 mc
->mc_packet
->generic
.maximum_sense_size
= sizeof(union mly_command_packet
);
1691 mly_enqueue_free(mc
);
1694 /********************************************************************************
1695 * Map helper for command allocation.
1698 mly_alloc_commands_map(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1700 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
1704 sc
->mly_packetphys
= segs
[0].ds_addr
;
1707 /********************************************************************************
1708 * Allocate and initialise command and packet structures.
1710 * If the controller supports fewer than MLY_MAX_COMMANDS commands, limit our
1711 * allocation to that number. If we don't yet know how many commands the
1712 * controller supports, allocate a very small set (suitable for initialisation
1716 mly_alloc_commands(struct mly_softc
*sc
)
1718 struct mly_command
*mc
;
1721 if (sc
->mly_controllerinfo
== NULL
) {
1724 ncmd
= min(MLY_MAX_COMMANDS
, sc
->mly_controllerinfo
->maximum_parallel_commands
);
1728 * Allocate enough space for all the command packets in one chunk and
1729 * map them permanently into controller-visible space.
1731 if (bus_dmamem_alloc(sc
->mly_packet_dmat
, (void **)&sc
->mly_packet
,
1732 BUS_DMA_NOWAIT
, &sc
->mly_packetmap
)) {
1735 if (bus_dmamap_load(sc
->mly_packet_dmat
, sc
->mly_packetmap
, sc
->mly_packet
,
1736 ncmd
* sizeof(union mly_command_packet
),
1737 mly_alloc_commands_map
, sc
, BUS_DMA_NOWAIT
) != 0)
1740 for (i
= 0; i
< ncmd
; i
++) {
1741 mc
= &sc
->mly_command
[i
];
1742 bzero(mc
, sizeof(*mc
));
1744 mc
->mc_slot
= MLY_SLOT_START
+ i
;
1745 mc
->mc_packet
= sc
->mly_packet
+ i
;
1746 mc
->mc_packetphys
= sc
->mly_packetphys
+ (i
* sizeof(union mly_command_packet
));
1747 if (!bus_dmamap_create(sc
->mly_buffer_dmat
, 0, &mc
->mc_datamap
))
1748 mly_release_command(mc
);
1753 /********************************************************************************
1754 * Free all the storage held by commands.
1756 * Must be called with all commands on the free list.
1759 mly_release_commands(struct mly_softc
*sc
)
1761 struct mly_command
*mc
;
1763 /* throw away command buffer DMA maps */
1764 while (mly_alloc_command(sc
, &mc
) == 0)
1765 bus_dmamap_destroy(sc
->mly_buffer_dmat
, mc
->mc_datamap
);
1767 /* release the packet storage */
1768 if (sc
->mly_packet
!= NULL
) {
1769 bus_dmamap_unload(sc
->mly_packet_dmat
, sc
->mly_packetmap
);
1770 bus_dmamem_free(sc
->mly_packet_dmat
, sc
->mly_packet
, sc
->mly_packetmap
);
1771 sc
->mly_packet
= NULL
;
1776 /********************************************************************************
1777 * Command-mapping helper function - populate this command's s/g table
1778 * with the s/g entries for its data.
1781 mly_map_command_sg(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1783 struct mly_command
*mc
= (struct mly_command
*)arg
;
1784 struct mly_softc
*sc
= mc
->mc_sc
;
1785 struct mly_command_generic
*gen
= &(mc
->mc_packet
->generic
);
1786 struct mly_sg_entry
*sg
;
1791 /* can we use the transfer structure directly? */
1793 sg
= &gen
->transfer
.direct
.sg
[0];
1794 gen
->command_control
.extended_sg_table
= 0;
1796 tabofs
= ((mc
->mc_slot
- MLY_SLOT_START
) * MLY_MAX_SGENTRIES
);
1797 sg
= sc
->mly_sg_table
+ tabofs
;
1798 gen
->transfer
.indirect
.entries
[0] = nseg
;
1799 gen
->transfer
.indirect
.table_physaddr
[0] = sc
->mly_sg_busaddr
+ (tabofs
* sizeof(struct mly_sg_entry
));
1800 gen
->command_control
.extended_sg_table
= 1;
1803 /* copy the s/g table */
1804 for (i
= 0; i
< nseg
; i
++) {
1805 sg
[i
].physaddr
= segs
[i
].ds_addr
;
1806 sg
[i
].length
= segs
[i
].ds_len
;
1812 /********************************************************************************
1813 * Command-mapping helper function - save the cdb's physical address.
1815 * We don't support 'large' SCSI commands at this time, so this is unused.
1818 mly_map_command_cdb(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1820 struct mly_command
*mc
= (struct mly_command
*)arg
;
1824 /* XXX can we safely assume that a CDB will never cross a page boundary? */
1825 if ((segs
[0].ds_addr
% PAGE_SIZE
) >
1826 ((segs
[0].ds_addr
+ mc
->mc_packet
->scsi_large
.cdb_length
) % PAGE_SIZE
))
1827 panic("cdb crosses page boundary");
1829 /* fix up fields in the command packet */
1830 mc
->mc_packet
->scsi_large
.cdb_physaddr
= segs
[0].ds_addr
;
1834 /********************************************************************************
1835 * Map a command into controller-visible space
1838 mly_map_command(struct mly_command
*mc
)
1840 struct mly_softc
*sc
= mc
->mc_sc
;
1844 /* don't map more than once */
1845 if (mc
->mc_flags
& MLY_CMD_MAPPED
)
1848 /* does the command have a data buffer? */
1849 if (mc
->mc_data
!= NULL
) {
1850 bus_dmamap_load(sc
->mly_buffer_dmat
, mc
->mc_datamap
, mc
->mc_data
, mc
->mc_length
,
1851 mly_map_command_sg
, mc
, 0);
1853 if (mc
->mc_flags
& MLY_CMD_DATAIN
)
1854 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_PREREAD
);
1855 if (mc
->mc_flags
& MLY_CMD_DATAOUT
)
1856 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_PREWRITE
);
1858 mc
->mc_flags
|= MLY_CMD_MAPPED
;
1861 /********************************************************************************
1862 * Unmap a command from controller-visible space
1865 mly_unmap_command(struct mly_command
*mc
)
1867 struct mly_softc
*sc
= mc
->mc_sc
;
1871 if (!(mc
->mc_flags
& MLY_CMD_MAPPED
))
1874 /* does the command have a data buffer? */
1875 if (mc
->mc_data
!= NULL
) {
1876 if (mc
->mc_flags
& MLY_CMD_DATAIN
)
1877 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_POSTREAD
);
1878 if (mc
->mc_flags
& MLY_CMD_DATAOUT
)
1879 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_POSTWRITE
);
1881 bus_dmamap_unload(sc
->mly_buffer_dmat
, mc
->mc_datamap
);
1883 mc
->mc_flags
&= ~MLY_CMD_MAPPED
;
1887 /********************************************************************************
1888 ********************************************************************************
1890 ********************************************************************************
1891 ********************************************************************************/
1893 /********************************************************************************
1894 * Attach the physical and virtual SCSI busses to CAM.
1896 * Physical bus numbering starts from 0, virtual bus numbering from one greater
1897 * than the highest physical bus. Physical busses are only registered if
1898 * the kernel environment variable "hw.mly.register_physical_channels" is set.
1900 * When we refer to a "bus", we are referring to the bus number registered with
1901 * the SIM, wheras a "channel" is a channel number given to the adapter. In order
1902 * to keep things simple, we map these 1:1, so "bus" and "channel" may be used
1906 mly_cam_attach(struct mly_softc
*sc
)
1908 struct cam_devq
*devq
;
1914 * Allocate a devq for all our channels combined.
1916 if ((devq
= cam_simq_alloc(sc
->mly_controllerinfo
->maximum_parallel_commands
)) == NULL
) {
1917 mly_printf(sc
, "can't allocate CAM SIM queue\n");
1922 * If physical channel registration has been requested, register these first.
1923 * Note that we enable tagged command queueing for physical channels.
1925 if (ktestenv("hw.mly.register_physical_channels")) {
1927 for (i
= 0; i
< sc
->mly_controllerinfo
->physical_channels_present
; i
++, chn
++) {
1929 if ((sc
->mly_cam_sim
[chn
] = cam_sim_alloc(mly_cam_action
, mly_cam_poll
, "mly", sc
,
1930 device_get_unit(sc
->mly_dev
),
1932 sc
->mly_controllerinfo
->maximum_parallel_commands
,
1933 1, devq
)) == NULL
) {
1936 if (xpt_bus_register(sc
->mly_cam_sim
[chn
], chn
)) {
1937 mly_printf(sc
, "CAM XPT physical channel registration failed\n");
1940 debug(1, "registered physical channel %d", chn
);
1945 * Register our virtual channels, with bus numbers matching channel numbers.
1947 chn
= sc
->mly_controllerinfo
->physical_channels_present
;
1948 for (i
= 0; i
< sc
->mly_controllerinfo
->virtual_channels_present
; i
++, chn
++) {
1949 if ((sc
->mly_cam_sim
[chn
] = cam_sim_alloc(mly_cam_action
, mly_cam_poll
, "mly", sc
,
1950 device_get_unit(sc
->mly_dev
),
1952 sc
->mly_controllerinfo
->maximum_parallel_commands
,
1953 0, devq
)) == NULL
) {
1956 if (xpt_bus_register(sc
->mly_cam_sim
[chn
], chn
)) {
1957 mly_printf(sc
, "CAM XPT virtual channel registration failed\n");
1960 debug(1, "registered virtual channel %d", chn
);
1964 * This is the total number of channels that (might have been) registered with
1965 * CAM. Some may not have been; check the mly_cam_sim array to be certain.
1967 sc
->mly_cam_channels
= sc
->mly_controllerinfo
->physical_channels_present
+
1968 sc
->mly_controllerinfo
->virtual_channels_present
;
1973 /********************************************************************************
1977 mly_cam_detach(struct mly_softc
*sc
)
1983 for (i
= 0; i
< sc
->mly_cam_channels
; i
++) {
1984 if (sc
->mly_cam_sim
[i
] != NULL
) {
1985 xpt_bus_deregister(cam_sim_path(sc
->mly_cam_sim
[i
]));
1986 cam_sim_free(sc
->mly_cam_sim
[i
]);
1989 if (sc
->mly_cam_devq
!= NULL
)
1990 cam_simq_release(sc
->mly_cam_devq
);
1993 /************************************************************************
1997 mly_cam_rescan_btl(struct mly_softc
*sc
, int bus
, int target
)
2003 if ((ccb
= xpt_alloc_ccb()) == NULL
) {
2004 mly_printf(sc
, "rescan failed (can't allocate CCB)\n");
2007 if (xpt_create_path(&ccb
->ccb_h
.path
, xpt_periph
,
2008 cam_sim_path(sc
->mly_cam_sim
[bus
]), target
, 0) != CAM_REQ_CMP
) {
2009 mly_printf(sc
, "rescan failed (can't create path)\n");
2010 xpt_free_ccb(&ccb
->ccb_h
);
2014 xpt_setup_ccb(&ccb
->ccb_h
, ccb
->ccb_h
.path
, 5/*priority (low)*/);
2015 ccb
->ccb_h
.func_code
= XPT_SCAN_LUN
;
2016 ccb
->ccb_h
.cbfcnp
= mly_cam_rescan_callback
;
2017 ccb
->crcn
.flags
= CAM_FLAG_NONE
;
2018 debug(1, "rescan target %d:%d", bus
, target
);
2023 mly_cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
)
2025 xpt_free_ccb(&ccb
->ccb_h
);
2028 /********************************************************************************
2029 * Handle an action requested by CAM
2032 mly_cam_action(struct cam_sim
*sim
, union ccb
*ccb
)
2034 struct mly_softc
*sc
= cam_sim_softc(sim
);
2038 switch (ccb
->ccb_h
.func_code
) {
2040 /* perform SCSI I/O */
2042 if (!mly_cam_action_io(sim
, (struct ccb_scsiio
*)&ccb
->csio
))
2046 /* perform geometry calculations */
2047 case XPT_CALC_GEOMETRY
:
2049 struct ccb_calc_geometry
*ccg
= &ccb
->ccg
;
2050 u_int32_t secs_per_cylinder
;
2052 debug(2, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim
), ccb
->ccb_h
.target_id
, ccb
->ccb_h
.target_lun
);
2054 if (sc
->mly_controllerparam
->bios_geometry
== MLY_BIOSGEOM_8G
) {
2056 ccg
->secs_per_track
= 63;
2057 } else { /* MLY_BIOSGEOM_2G */
2059 ccg
->secs_per_track
= 32;
2061 secs_per_cylinder
= ccg
->heads
* ccg
->secs_per_track
;
2062 ccg
->cylinders
= ccg
->volume_size
/ secs_per_cylinder
;
2063 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2067 /* handle path attribute inquiry */
2070 struct ccb_pathinq
*cpi
= &ccb
->cpi
;
2072 debug(2, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim
), ccb
->ccb_h
.target_id
, ccb
->ccb_h
.target_lun
);
2074 cpi
->version_num
= 1;
2075 cpi
->hba_inquiry
= PI_TAG_ABLE
; /* XXX extra flags for physical channels? */
2076 cpi
->target_sprt
= 0;
2078 cpi
->max_target
= MLY_MAX_TARGETS
- 1;
2079 cpi
->max_lun
= MLY_MAX_LUNS
- 1;
2080 cpi
->initiator_id
= sc
->mly_controllerparam
->initiator_id
;
2081 strncpy(cpi
->sim_vid
, "FreeBSD", SIM_IDLEN
);
2082 strncpy(cpi
->hba_vid
, "FreeBSD", HBA_IDLEN
);
2083 strncpy(cpi
->dev_name
, cam_sim_name(sim
), DEV_IDLEN
);
2084 cpi
->unit_number
= cam_sim_unit(sim
);
2085 cpi
->bus_id
= cam_sim_bus(sim
);
2086 cpi
->base_transfer_speed
= 132 * 1024; /* XXX what to set this to? */
2087 cpi
->transport
= XPORT_SPI
;
2088 cpi
->transport_version
= 2;
2089 cpi
->protocol
= PROTO_SCSI
;
2090 cpi
->protocol_version
= SCSI_REV_2
;
2091 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2095 case XPT_GET_TRAN_SETTINGS
:
2097 struct ccb_trans_settings
*cts
= &ccb
->cts
;
2099 struct ccb_trans_settings_scsi
*scsi
= &cts
->proto_specific
.scsi
;
2100 struct ccb_trans_settings_spi
*spi
= &cts
->xport_specific
.spi
;
2102 cts
->protocol
= PROTO_SCSI
;
2103 cts
->protocol_version
= SCSI_REV_2
;
2104 cts
->transport
= XPORT_SPI
;
2105 cts
->transport_version
= 2;
2112 bus
= cam_sim_bus(sim
);
2113 target
= cts
->ccb_h
.target_id
;
2114 debug(2, "XPT_GET_TRAN_SETTINGS %d:%d", bus
, target
);
2115 /* logical device? */
2116 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2117 /* nothing special for these */
2118 /* physical device? */
2119 } else if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PHYSICAL
) {
2120 /* allow CAM to try tagged transactions */
2121 scsi
->flags
|= CTS_SCSI_FLAGS_TAG_ENB
;
2122 scsi
->valid
|= CTS_SCSI_VALID_TQ
;
2124 /* convert speed (MHz) to usec */
2125 if (sc
->mly_btl
[bus
][target
].mb_speed
== 0) {
2126 spi
->sync_period
= 1000000 / 5;
2128 spi
->sync_period
= 1000000 / sc
->mly_btl
[bus
][target
].mb_speed
;
2131 /* convert bus width to CAM internal encoding */
2132 switch (sc
->mly_btl
[bus
][target
].mb_width
) {
2134 spi
->bus_width
= MSG_EXT_WDTR_BUS_32_BIT
;
2137 spi
->bus_width
= MSG_EXT_WDTR_BUS_16_BIT
;
2141 spi
->bus_width
= MSG_EXT_WDTR_BUS_8_BIT
;
2144 spi
->valid
|= CTS_SPI_VALID_SYNC_RATE
| CTS_SPI_VALID_BUS_WIDTH
;
2146 /* not a device, bail out */
2148 cts
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2152 /* disconnect always OK */
2153 spi
->flags
|= CTS_SPI_FLAGS_DISC_ENB
;
2154 spi
->valid
|= CTS_SPI_VALID_DISC
;
2156 cts
->ccb_h
.status
= CAM_REQ_CMP
;
2160 default: /* we can't do this */
2161 debug(2, "unsupported func_code = 0x%x", ccb
->ccb_h
.func_code
);
2162 ccb
->ccb_h
.status
= CAM_REQ_INVALID
;
2169 /********************************************************************************
2170 * Handle an I/O operation requested by CAM
2173 mly_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
)
2175 struct mly_softc
*sc
= cam_sim_softc(sim
);
2176 struct mly_command
*mc
;
2177 struct mly_command_scsi_small
*ss
;
2181 bus
= cam_sim_bus(sim
);
2182 target
= csio
->ccb_h
.target_id
;
2184 debug(2, "XPT_SCSI_IO %d:%d:%d", bus
, target
, csio
->ccb_h
.target_lun
);
2186 /* validate bus number */
2187 if (!MLY_BUS_IS_VALID(sc
, bus
)) {
2188 debug(0, " invalid bus %d", bus
);
2189 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2192 /* check for I/O attempt to a protected device */
2193 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PROTECTED
) {
2194 debug(2, " device protected");
2195 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2198 /* check for I/O attempt to nonexistent device */
2199 if (!(sc
->mly_btl
[bus
][target
].mb_flags
& (MLY_BTL_LOGICAL
| MLY_BTL_PHYSICAL
))) {
2200 debug(2, " device %d:%d does not exist", bus
, target
);
2201 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2204 /* XXX increase if/when we support large SCSI commands */
2205 if (csio
->cdb_len
> MLY_CMD_SCSI_SMALL_CDB
) {
2206 debug(0, " command too large (%d > %d)", csio
->cdb_len
, MLY_CMD_SCSI_SMALL_CDB
);
2207 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2210 /* check that the CDB pointer is not to a physical address */
2211 if ((csio
->ccb_h
.flags
& CAM_CDB_POINTER
) && (csio
->ccb_h
.flags
& CAM_CDB_PHYS
)) {
2212 debug(0, " CDB pointer is to physical address");
2213 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2216 /* if there is data transfer, it must be to/from a virtual address */
2217 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) != CAM_DIR_NONE
) {
2218 if (csio
->ccb_h
.flags
& CAM_DATA_PHYS
) { /* we can't map it */
2219 debug(0, " data pointer is to physical address");
2220 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2222 if (csio
->ccb_h
.flags
& CAM_SCATTER_VALID
) { /* we want to do the s/g setup */
2223 debug(0, " data has premature s/g setup");
2224 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2228 /* abandon aborted ccbs or those that have failed validation */
2229 if ((csio
->ccb_h
.status
& CAM_STATUS_MASK
) != CAM_REQ_INPROG
) {
2230 debug(2, "abandoning CCB due to abort/validation failure");
2235 * Get a command, or push the ccb back to CAM and freeze the queue.
2237 if ((error
= mly_alloc_command(sc
, &mc
))) {
2239 xpt_freeze_simq(sim
, 1);
2240 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2241 sc
->mly_qfrzn_cnt
++;
2246 /* build the command */
2247 mc
->mc_data
= csio
->data_ptr
;
2248 mc
->mc_length
= csio
->dxfer_len
;
2249 mc
->mc_complete
= mly_cam_complete
;
2250 mc
->mc_private
= csio
;
2252 /* save the bus number in the ccb for later recovery XXX should be a better way */
2253 csio
->ccb_h
.sim_priv
.entries
[0].field
= bus
;
2255 /* build the packet for the controller */
2256 ss
= &mc
->mc_packet
->scsi_small
;
2257 ss
->opcode
= MDACMD_SCSI
;
2258 if (csio
->ccb_h
.flags
& CAM_DIS_DISCONNECT
)
2259 ss
->command_control
.disable_disconnect
= 1;
2260 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) == CAM_DIR_OUT
)
2261 ss
->command_control
.data_direction
= MLY_CCB_WRITE
;
2262 ss
->data_size
= csio
->dxfer_len
;
2263 ss
->addr
.phys
.lun
= csio
->ccb_h
.target_lun
;
2264 ss
->addr
.phys
.target
= csio
->ccb_h
.target_id
;
2265 ss
->addr
.phys
.channel
= bus
;
2266 if (csio
->ccb_h
.timeout
< (60 * 1000)) {
2267 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ 1000;
2268 ss
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
2269 } else if (csio
->ccb_h
.timeout
< (60 * 60 * 1000)) {
2270 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ (60 * 1000);
2271 ss
->timeout
.scale
= MLY_TIMEOUT_MINUTES
;
2273 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ (60 * 60 * 1000); /* overflow? */
2274 ss
->timeout
.scale
= MLY_TIMEOUT_HOURS
;
2276 ss
->maximum_sense_size
= csio
->sense_len
;
2277 ss
->cdb_length
= csio
->cdb_len
;
2278 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2279 bcopy(csio
->cdb_io
.cdb_ptr
, ss
->cdb
, csio
->cdb_len
);
2281 bcopy(csio
->cdb_io
.cdb_bytes
, ss
->cdb
, csio
->cdb_len
);
2284 /* give the command to the controller */
2285 if ((error
= mly_start(mc
))) {
2287 xpt_freeze_simq(sim
, 1);
2288 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2289 sc
->mly_qfrzn_cnt
++;
2297 /********************************************************************************
2298 * Check for possibly-completed commands.
2301 mly_cam_poll(struct cam_sim
*sim
)
2303 struct mly_softc
*sc
= cam_sim_softc(sim
);
2310 /********************************************************************************
2311 * Handle completion of a command - pass results back through the CCB
2314 mly_cam_complete(struct mly_command
*mc
)
2316 struct mly_softc
*sc
= mc
->mc_sc
;
2317 struct ccb_scsiio
*csio
= (struct ccb_scsiio
*)mc
->mc_private
;
2318 struct scsi_inquiry_data
*inq
= (struct scsi_inquiry_data
*)csio
->data_ptr
;
2319 struct mly_btl
*btl
;
2325 csio
->scsi_status
= mc
->mc_status
;
2326 switch(mc
->mc_status
) {
2327 case SCSI_STATUS_OK
:
2329 * In order to report logical device type and status, we overwrite
2330 * the result of the INQUIRY command to logical devices.
2332 bus
= csio
->ccb_h
.sim_priv
.entries
[0].field
;
2333 target
= csio
->ccb_h
.target_id
;
2334 /* XXX validate bus/target? */
2335 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2336 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2337 cmd
= *csio
->cdb_io
.cdb_ptr
;
2339 cmd
= csio
->cdb_io
.cdb_bytes
[0];
2341 if (cmd
== INQUIRY
) {
2342 btl
= &sc
->mly_btl
[bus
][target
];
2343 padstr(inq
->vendor
, mly_describe_code(mly_table_device_type
, btl
->mb_type
), 8);
2344 padstr(inq
->product
, mly_describe_code(mly_table_device_state
, btl
->mb_state
), 16);
2345 padstr(inq
->revision
, "MYLX", 4);
2349 debug(2, "SCSI_STATUS_OK");
2350 csio
->ccb_h
.status
= CAM_REQ_CMP
;
2353 case SCSI_STATUS_CHECK_COND
:
2354 debug(1, "SCSI_STATUS_CHECK_COND sense %d resid %d", mc
->mc_sense
, mc
->mc_resid
);
2355 csio
->ccb_h
.status
= CAM_SCSI_STATUS_ERROR
;
2356 bzero(&csio
->sense_data
, SSD_FULL_SIZE
);
2357 bcopy(mc
->mc_packet
, &csio
->sense_data
, mc
->mc_sense
);
2358 csio
->sense_len
= mc
->mc_sense
;
2359 csio
->ccb_h
.status
|= CAM_AUTOSNS_VALID
;
2360 csio
->resid
= mc
->mc_resid
; /* XXX this is a signed value... */
2363 case SCSI_STATUS_BUSY
:
2364 debug(1, "SCSI_STATUS_BUSY");
2365 csio
->ccb_h
.status
= CAM_SCSI_BUSY
;
2369 debug(1, "unknown status 0x%x", csio
->scsi_status
);
2370 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2375 if (sc
->mly_qfrzn_cnt
) {
2376 csio
->ccb_h
.status
|= CAM_RELEASE_SIMQ
;
2377 sc
->mly_qfrzn_cnt
--;
2381 xpt_done((union ccb
*)csio
);
2382 mly_release_command(mc
);
2385 /********************************************************************************
2386 * Find a peripheral attahed at (bus),(target)
2388 static struct cam_periph
*
2389 mly_find_periph(struct mly_softc
*sc
, int bus
, int target
)
2391 struct cam_periph
*periph
;
2392 struct cam_path
*path
;
2395 status
= xpt_create_path(&path
, NULL
, cam_sim_path(sc
->mly_cam_sim
[bus
]), target
, 0);
2396 if (status
== CAM_REQ_CMP
) {
2397 periph
= cam_periph_find(path
, NULL
);
2398 xpt_free_path(path
);
2405 /********************************************************************************
2406 * Name the device at (bus)(target)
2409 mly_name_device(struct mly_softc
*sc
, int bus
, int target
)
2411 struct cam_periph
*periph
;
2413 if ((periph
= mly_find_periph(sc
, bus
, target
)) != NULL
) {
2414 ksprintf(sc
->mly_btl
[bus
][target
].mb_name
, "%s%d", periph
->periph_name
, periph
->unit_number
);
2417 sc
->mly_btl
[bus
][target
].mb_name
[0] = 0;
2421 /********************************************************************************
2422 ********************************************************************************
2424 ********************************************************************************
2425 ********************************************************************************/
2427 /********************************************************************************
2428 * Handshake with the firmware while the card is being initialised.
2431 mly_fwhandshake(struct mly_softc
*sc
)
2433 u_int8_t error
, param0
, param1
;
2438 /* set HM_STSACK and let the firmware initialise */
2439 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_STSACK
);
2440 DELAY(1000); /* too short? */
2442 /* if HM_STSACK is still true, the controller is initialising */
2443 if (!MLY_IDBR_TRUE(sc
, MLY_HM_STSACK
))
2445 mly_printf(sc
, "controller initialisation started\n");
2447 /* spin waiting for initialisation to finish, or for a message to be delivered */
2448 while (MLY_IDBR_TRUE(sc
, MLY_HM_STSACK
)) {
2449 /* check for a message */
2450 if (MLY_ERROR_VALID(sc
)) {
2451 error
= MLY_GET_REG(sc
, sc
->mly_error_status
) & ~MLY_MSG_EMPTY
;
2452 param0
= MLY_GET_REG(sc
, sc
->mly_command_mailbox
);
2453 param1
= MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 1);
2456 case MLY_MSG_SPINUP
:
2458 mly_printf(sc
, "drive spinup in progress\n");
2459 spinup
= 1; /* only print this once (should print drive being spun?) */
2462 case MLY_MSG_RACE_RECOVERY_FAIL
:
2463 mly_printf(sc
, "mirror race recovery failed, one or more drives offline\n");
2465 case MLY_MSG_RACE_IN_PROGRESS
:
2466 mly_printf(sc
, "mirror race recovery in progress\n");
2468 case MLY_MSG_RACE_ON_CRITICAL
:
2469 mly_printf(sc
, "mirror race recovery on a critical drive\n");
2471 case MLY_MSG_PARITY_ERROR
:
2472 mly_printf(sc
, "FATAL MEMORY PARITY ERROR\n");
2475 mly_printf(sc
, "unknown initialisation code 0x%x\n", error
);
2482 /********************************************************************************
2483 ********************************************************************************
2484 Debugging and Diagnostics
2485 ********************************************************************************
2486 ********************************************************************************/
2488 /********************************************************************************
2489 * Print some information about the controller.
2492 mly_describe_controller(struct mly_softc
*sc
)
2494 struct mly_ioctl_getcontrollerinfo
*mi
= sc
->mly_controllerinfo
;
2496 mly_printf(sc
, "%16s, %d channel%s, firmware %d.%02d-%d-%02d (%02d%02d%02d%02d), %dMB RAM\n",
2497 mi
->controller_name
, mi
->physical_channels_present
, (mi
->physical_channels_present
) > 1 ? "s" : "",
2498 mi
->fw_major
, mi
->fw_minor
, mi
->fw_turn
, mi
->fw_build
, /* XXX turn encoding? */
2499 mi
->fw_century
, mi
->fw_year
, mi
->fw_month
, mi
->fw_day
,
2503 mly_printf(sc
, "%s %s (%x), %dMHz %d-bit %.16s\n",
2504 mly_describe_code(mly_table_oemname
, mi
->oem_information
),
2505 mly_describe_code(mly_table_controllertype
, mi
->controller_type
), mi
->controller_type
,
2506 mi
->interface_speed
, mi
->interface_width
, mi
->interface_name
);
2507 mly_printf(sc
, "%dMB %dMHz %d-bit %s%s%s, cache %dMB\n",
2508 mi
->memory_size
, mi
->memory_speed
, mi
->memory_width
,
2509 mly_describe_code(mly_table_memorytype
, mi
->memory_type
),
2510 mi
->memory_parity
? "+parity": "",mi
->memory_ecc
? "+ECC": "",
2512 mly_printf(sc
, "CPU: %s @ %dMHz\n",
2513 mly_describe_code(mly_table_cputype
, mi
->cpu
[0].type
), mi
->cpu
[0].speed
);
2514 if (mi
->l2cache_size
!= 0)
2515 mly_printf(sc
, "%dKB L2 cache\n", mi
->l2cache_size
);
2516 if (mi
->exmemory_size
!= 0)
2517 mly_printf(sc
, "%dMB %dMHz %d-bit private %s%s%s\n",
2518 mi
->exmemory_size
, mi
->exmemory_speed
, mi
->exmemory_width
,
2519 mly_describe_code(mly_table_memorytype
, mi
->exmemory_type
),
2520 mi
->exmemory_parity
? "+parity": "",mi
->exmemory_ecc
? "+ECC": "");
2521 mly_printf(sc
, "battery backup %s\n", mi
->bbu_present
? "present" : "not installed");
2522 mly_printf(sc
, "maximum data transfer %d blocks, maximum sg entries/command %d\n",
2523 mi
->maximum_block_count
, mi
->maximum_sg_entries
);
2524 mly_printf(sc
, "logical devices present/critical/offline %d/%d/%d\n",
2525 mi
->logical_devices_present
, mi
->logical_devices_critical
, mi
->logical_devices_offline
);
2526 mly_printf(sc
, "physical devices present %d\n",
2527 mi
->physical_devices_present
);
2528 mly_printf(sc
, "physical disks present/offline %d/%d\n",
2529 mi
->physical_disks_present
, mi
->physical_disks_offline
);
2530 mly_printf(sc
, "%d physical channel%s, %d virtual channel%s of %d possible\n",
2531 mi
->physical_channels_present
, mi
->physical_channels_present
== 1 ? "" : "s",
2532 mi
->virtual_channels_present
, mi
->virtual_channels_present
== 1 ? "" : "s",
2533 mi
->virtual_channels_possible
);
2534 mly_printf(sc
, "%d parallel commands supported\n", mi
->maximum_parallel_commands
);
2535 mly_printf(sc
, "%dMB flash ROM, %d of %d maximum cycles\n",
2536 mi
->flash_size
, mi
->flash_age
, mi
->flash_maximum_age
);
2541 /********************************************************************************
2542 * Print some controller state
2545 mly_printstate(struct mly_softc
*sc
)
2547 mly_printf(sc
, "IDBR %02x ODBR %02x ERROR %02x (%x %x %x)\n",
2548 MLY_GET_REG(sc
, sc
->mly_idbr
),
2549 MLY_GET_REG(sc
, sc
->mly_odbr
),
2550 MLY_GET_REG(sc
, sc
->mly_error_status
),
2553 sc
->mly_error_status
);
2554 mly_printf(sc
, "IMASK %02x ISTATUS %02x\n",
2555 MLY_GET_REG(sc
, sc
->mly_interrupt_mask
),
2556 MLY_GET_REG(sc
, sc
->mly_interrupt_status
));
2557 mly_printf(sc
, "COMMAND %02x %02x %02x %02x %02x %02x %02x %02x\n",
2558 MLY_GET_REG(sc
, sc
->mly_command_mailbox
),
2559 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 1),
2560 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 2),
2561 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 3),
2562 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 4),
2563 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 5),
2564 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 6),
2565 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 7));
2566 mly_printf(sc
, "STATUS %02x %02x %02x %02x %02x %02x %02x %02x\n",
2567 MLY_GET_REG(sc
, sc
->mly_status_mailbox
),
2568 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 1),
2569 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 2),
2570 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 3),
2571 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 4),
2572 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 5),
2573 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 6),
2574 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 7));
2575 mly_printf(sc
, " %04x %08x\n",
2576 MLY_GET_REG2(sc
, sc
->mly_status_mailbox
),
2577 MLY_GET_REG4(sc
, sc
->mly_status_mailbox
+ 4));
2580 struct mly_softc
*mly_softc0
= NULL
;
2582 mly_printstate0(void)
2584 if (mly_softc0
!= NULL
)
2585 mly_printstate(mly_softc0
);
2588 /********************************************************************************
2592 mly_print_command(struct mly_command
*mc
)
2594 struct mly_softc
*sc
= mc
->mc_sc
;
2596 mly_printf(sc
, "COMMAND @ %p\n", mc
);
2597 mly_printf(sc
, " slot %d\n", mc
->mc_slot
);
2598 mly_printf(sc
, " status 0x%x\n", mc
->mc_status
);
2599 mly_printf(sc
, " sense len %d\n", mc
->mc_sense
);
2600 mly_printf(sc
, " resid %d\n", mc
->mc_resid
);
2601 mly_printf(sc
, " packet %p/0x%llx\n", mc
->mc_packet
, mc
->mc_packetphys
);
2602 if (mc
->mc_packet
!= NULL
)
2603 mly_print_packet(mc
);
2604 mly_printf(sc
, " data %p/%d\n", mc
->mc_data
, mc
->mc_length
);
2605 mly_printf(sc
, " flags %pb%i\n",
2606 "\20\1busy\2complete\3slotted\4mapped\5datain\6dataout\n",
2608 mly_printf(sc
, " complete %p\n", mc
->mc_complete
);
2609 mly_printf(sc
, " private %p\n", mc
->mc_private
);
2612 /********************************************************************************
2613 * Print a command packet
2616 mly_print_packet(struct mly_command
*mc
)
2618 struct mly_softc
*sc
= mc
->mc_sc
;
2619 struct mly_command_generic
*ge
= (struct mly_command_generic
*)mc
->mc_packet
;
2620 struct mly_command_scsi_small
*ss
= (struct mly_command_scsi_small
*)mc
->mc_packet
;
2621 struct mly_command_scsi_large
*sl
= (struct mly_command_scsi_large
*)mc
->mc_packet
;
2622 struct mly_command_ioctl
*io
= (struct mly_command_ioctl
*)mc
->mc_packet
;
2624 char hexstr
[HEX_NCPYLEN(MLY_CMD_SCSI_SMALL_CDB
)];
2626 mly_printf(sc
, " command_id %d\n", ge
->command_id
);
2627 mly_printf(sc
, " opcode %d\n", ge
->opcode
);
2628 mly_printf(sc
, " command_control fua %d dpo %d est %d dd %s nas %d ddis %d\n",
2629 ge
->command_control
.force_unit_access
,
2630 ge
->command_control
.disable_page_out
,
2631 ge
->command_control
.extended_sg_table
,
2632 (ge
->command_control
.data_direction
== MLY_CCB_WRITE
) ? "WRITE" : "READ",
2633 ge
->command_control
.no_auto_sense
,
2634 ge
->command_control
.disable_disconnect
);
2635 mly_printf(sc
, " data_size %d\n", ge
->data_size
);
2636 mly_printf(sc
, " sense_buffer_address 0x%llx\n", ge
->sense_buffer_address
);
2637 mly_printf(sc
, " lun %d\n", ge
->addr
.phys
.lun
);
2638 mly_printf(sc
, " target %d\n", ge
->addr
.phys
.target
);
2639 mly_printf(sc
, " channel %d\n", ge
->addr
.phys
.channel
);
2640 mly_printf(sc
, " logical device %d\n", ge
->addr
.log
.logdev
);
2641 mly_printf(sc
, " controller %d\n", ge
->addr
.phys
.controller
);
2642 mly_printf(sc
, " timeout %d %s\n",
2644 (ge
->timeout
.scale
== MLY_TIMEOUT_SECONDS
) ? "seconds" :
2645 ((ge
->timeout
.scale
== MLY_TIMEOUT_MINUTES
) ? "minutes" : "hours"));
2646 mly_printf(sc
, " maximum_sense_size %d\n", ge
->maximum_sense_size
);
2647 switch(ge
->opcode
) {
2650 mly_printf(sc
, " cdb length %d\n", ss
->cdb_length
);
2651 mly_printf(sc
, " cdb %s\n",
2652 hexncpy(ss
->cdb
, ss
->cdb_length
, hexstr
, HEX_NCPYLEN(ss
->cdb_length
), " "));
2656 case MDACMD_SCSILCPT
:
2657 mly_printf(sc
, " cdb length %d\n", sl
->cdb_length
);
2658 mly_printf(sc
, " cdb 0x%llx\n", sl
->cdb_physaddr
);
2662 mly_printf(sc
, " sub_ioctl 0x%x\n", io
->sub_ioctl
);
2663 switch(io
->sub_ioctl
) {
2664 case MDACIOCTL_SETMEMORYMAILBOX
:
2665 mly_printf(sc
, " health_buffer_size %d\n",
2666 io
->param
.setmemorymailbox
.health_buffer_size
);
2667 mly_printf(sc
, " health_buffer_phys 0x%llx\n",
2668 io
->param
.setmemorymailbox
.health_buffer_physaddr
);
2669 mly_printf(sc
, " command_mailbox 0x%llx\n",
2670 io
->param
.setmemorymailbox
.command_mailbox_physaddr
);
2671 mly_printf(sc
, " status_mailbox 0x%llx\n",
2672 io
->param
.setmemorymailbox
.status_mailbox_physaddr
);
2676 case MDACIOCTL_SETREALTIMECLOCK
:
2677 case MDACIOCTL_GETHEALTHSTATUS
:
2678 case MDACIOCTL_GETCONTROLLERINFO
:
2679 case MDACIOCTL_GETLOGDEVINFOVALID
:
2680 case MDACIOCTL_GETPHYSDEVINFOVALID
:
2681 case MDACIOCTL_GETPHYSDEVSTATISTICS
:
2682 case MDACIOCTL_GETLOGDEVSTATISTICS
:
2683 case MDACIOCTL_GETCONTROLLERSTATISTICS
:
2684 case MDACIOCTL_GETBDT_FOR_SYSDRIVE
:
2685 case MDACIOCTL_CREATENEWCONF
:
2686 case MDACIOCTL_ADDNEWCONF
:
2687 case MDACIOCTL_GETDEVCONFINFO
:
2688 case MDACIOCTL_GETFREESPACELIST
:
2689 case MDACIOCTL_MORE
:
2690 case MDACIOCTL_SETPHYSDEVPARAMETER
:
2691 case MDACIOCTL_GETPHYSDEVPARAMETER
:
2692 case MDACIOCTL_GETLOGDEVPARAMETER
:
2693 case MDACIOCTL_SETLOGDEVPARAMETER
:
2694 mly_printf(sc
, " param %10D\n", io
->param
.data
.param
, " ");
2698 case MDACIOCTL_GETEVENT
:
2699 mly_printf(sc
, " event %d\n",
2700 io
->param
.getevent
.sequence_number_low
+ ((u_int32_t
)io
->addr
.log
.logdev
<< 16));
2704 case MDACIOCTL_SETRAIDDEVSTATE
:
2705 mly_printf(sc
, " state %d\n", io
->param
.setraiddevstate
.state
);
2709 case MDACIOCTL_XLATEPHYSDEVTORAIDDEV
:
2710 mly_printf(sc
, " raid_device %d\n", io
->param
.xlatephysdevtoraiddev
.raid_device
);
2711 mly_printf(sc
, " controller %d\n", io
->param
.xlatephysdevtoraiddev
.controller
);
2712 mly_printf(sc
, " channel %d\n", io
->param
.xlatephysdevtoraiddev
.channel
);
2713 mly_printf(sc
, " target %d\n", io
->param
.xlatephysdevtoraiddev
.target
);
2714 mly_printf(sc
, " lun %d\n", io
->param
.xlatephysdevtoraiddev
.lun
);
2718 case MDACIOCTL_GETGROUPCONFINFO
:
2719 mly_printf(sc
, " group %d\n", io
->param
.getgroupconfinfo
.group
);
2723 case MDACIOCTL_GET_SUBSYSTEM_DATA
:
2724 case MDACIOCTL_SET_SUBSYSTEM_DATA
:
2725 case MDACIOCTL_STARTDISOCVERY
:
2726 case MDACIOCTL_INITPHYSDEVSTART
:
2727 case MDACIOCTL_INITPHYSDEVSTOP
:
2728 case MDACIOCTL_INITRAIDDEVSTART
:
2729 case MDACIOCTL_INITRAIDDEVSTOP
:
2730 case MDACIOCTL_REBUILDRAIDDEVSTART
:
2731 case MDACIOCTL_REBUILDRAIDDEVSTOP
:
2732 case MDACIOCTL_MAKECONSISTENTDATASTART
:
2733 case MDACIOCTL_MAKECONSISTENTDATASTOP
:
2734 case MDACIOCTL_CONSISTENCYCHECKSTART
:
2735 case MDACIOCTL_CONSISTENCYCHECKSTOP
:
2736 case MDACIOCTL_RESETDEVICE
:
2737 case MDACIOCTL_FLUSHDEVICEDATA
:
2738 case MDACIOCTL_PAUSEDEVICE
:
2739 case MDACIOCTL_UNPAUSEDEVICE
:
2740 case MDACIOCTL_LOCATEDEVICE
:
2741 case MDACIOCTL_SETMASTERSLAVEMODE
:
2742 case MDACIOCTL_DELETERAIDDEV
:
2743 case MDACIOCTL_REPLACEINTERNALDEV
:
2744 case MDACIOCTL_CLEARCONF
:
2745 case MDACIOCTL_GETCONTROLLERPARAMETER
:
2746 case MDACIOCTL_SETCONTRLLERPARAMETER
:
2747 case MDACIOCTL_CLEARCONFSUSPMODE
:
2748 case MDACIOCTL_STOREIMAGE
:
2749 case MDACIOCTL_READIMAGE
:
2750 case MDACIOCTL_FLASHIMAGES
:
2751 case MDACIOCTL_RENAMERAIDDEV
:
2752 default: /* no idea what to print */
2758 case MDACMD_IOCTLCHECK
:
2759 case MDACMD_MEMCOPY
:
2762 break; /* print nothing */
2765 if (ge
->command_control
.extended_sg_table
) {
2766 mly_printf(sc
, " sg table 0x%llx/%d\n",
2767 ge
->transfer
.indirect
.table_physaddr
[0], ge
->transfer
.indirect
.entries
[0]);
2769 mly_printf(sc
, " 0000 0x%llx/%lld\n",
2770 ge
->transfer
.direct
.sg
[0].physaddr
, ge
->transfer
.direct
.sg
[0].length
);
2771 mly_printf(sc
, " 0001 0x%llx/%lld\n",
2772 ge
->transfer
.direct
.sg
[1].physaddr
, ge
->transfer
.direct
.sg
[1].length
);
2777 /********************************************************************************
2778 * Panic in a slightly informative fashion
2781 mly_panic(struct mly_softc
*sc
, char *reason
)
2787 /********************************************************************************
2788 * Print queue statistics, callable from DDB.
2791 mly_print_controller(int controller
)
2793 struct mly_softc
*sc
;
2795 if ((sc
= devclass_get_softc(devclass_find("mly"), controller
)) == NULL
) {
2796 kprintf("mly: controller %d invalid\n", controller
);
2798 device_printf(sc
->mly_dev
, "queue curr max\n");
2799 device_printf(sc
->mly_dev
, "free %04d/%04d\n",
2800 sc
->mly_qstat
[MLYQ_FREE
].q_length
, sc
->mly_qstat
[MLYQ_FREE
].q_max
);
2801 device_printf(sc
->mly_dev
, "busy %04d/%04d\n",
2802 sc
->mly_qstat
[MLYQ_BUSY
].q_length
, sc
->mly_qstat
[MLYQ_BUSY
].q_max
);
2803 device_printf(sc
->mly_dev
, "complete %04d/%04d\n",
2804 sc
->mly_qstat
[MLYQ_COMPLETE
].q_length
, sc
->mly_qstat
[MLYQ_COMPLETE
].q_max
);
2810 /********************************************************************************
2811 ********************************************************************************
2812 Control device interface
2813 ********************************************************************************
2814 ********************************************************************************/
2816 /********************************************************************************
2817 * Accept an open operation on the control device.
2820 mly_user_open(struct dev_open_args
*ap
)
2822 cdev_t dev
= ap
->a_head
.a_dev
;
2823 int unit
= minor(dev
);
2824 struct mly_softc
*sc
= devclass_get_softc(devclass_find("mly"), unit
);
2826 sc
->mly_state
|= MLY_STATE_OPEN
;
2830 /********************************************************************************
2831 * Accept the last close on the control device.
2834 mly_user_close(struct dev_close_args
*ap
)
2836 cdev_t dev
= ap
->a_head
.a_dev
;
2837 int unit
= minor(dev
);
2838 struct mly_softc
*sc
= devclass_get_softc(devclass_find("mly"), unit
);
2840 sc
->mly_state
&= ~MLY_STATE_OPEN
;
2844 /********************************************************************************
2845 * Handle controller-specific control operations.
2848 mly_user_ioctl(struct dev_ioctl_args
*ap
)
2850 cdev_t dev
= ap
->a_head
.a_dev
;
2851 caddr_t addr
= ap
->a_data
;
2852 u_long cmd
= ap
->a_cmd
;
2853 struct mly_softc
*sc
= (struct mly_softc
*)dev
->si_drv1
;
2854 struct mly_user_command
*uc
= (struct mly_user_command
*)addr
;
2855 struct mly_user_health
*uh
= (struct mly_user_health
*)addr
;
2859 return(mly_user_command(sc
, uc
));
2861 return(mly_user_health(sc
, uh
));
2867 /********************************************************************************
2868 * Execute a command passed in from userspace.
2870 * The control structure contains the actual command for the controller, as well
2871 * as the user-space data pointer and data size, and an optional sense buffer
2872 * size/pointer. On completion, the data size is adjusted to the command
2873 * residual, and the sense buffer size to the size of the returned sense data.
2877 mly_user_command(struct mly_softc
*sc
, struct mly_user_command
*uc
)
2879 struct mly_command
*mc
;
2882 /* allocate a command */
2883 if (mly_alloc_command(sc
, &mc
)) {
2885 goto out
; /* XXX Linux version will wait for a command */
2888 /* handle data size/direction */
2889 mc
->mc_length
= (uc
->DataTransferLength
>= 0) ? uc
->DataTransferLength
: -uc
->DataTransferLength
;
2890 if (mc
->mc_length
> 0)
2891 mc
->mc_data
= kmalloc(mc
->mc_length
, M_DEVBUF
, M_INTWAIT
);
2892 if (uc
->DataTransferLength
> 0) {
2893 mc
->mc_flags
|= MLY_CMD_DATAIN
;
2894 bzero(mc
->mc_data
, mc
->mc_length
);
2896 if (uc
->DataTransferLength
< 0) {
2897 mc
->mc_flags
|= MLY_CMD_DATAOUT
;
2898 if ((error
= copyin(uc
->DataTransferBuffer
, mc
->mc_data
, mc
->mc_length
)) != 0)
2902 /* copy the controller command */
2903 bcopy(&uc
->CommandMailbox
, mc
->mc_packet
, sizeof(uc
->CommandMailbox
));
2905 /* clear command completion handler so that we get woken up */
2906 mc
->mc_complete
= NULL
;
2908 /* execute the command */
2909 if ((error
= mly_start(mc
)) != 0)
2912 while (!(mc
->mc_flags
& MLY_CMD_COMPLETE
))
2913 tsleep(mc
, 0, "mlyioctl", 0);
2916 /* return the data to userspace */
2917 if (uc
->DataTransferLength
> 0)
2918 if ((error
= copyout(mc
->mc_data
, uc
->DataTransferBuffer
, mc
->mc_length
)) != 0)
2921 /* return the sense buffer to userspace */
2922 if ((uc
->RequestSenseLength
> 0) && (mc
->mc_sense
> 0)) {
2923 if ((error
= copyout(mc
->mc_packet
, uc
->RequestSenseBuffer
,
2924 min(uc
->RequestSenseLength
, mc
->mc_sense
))) != 0)
2928 /* return command results to userspace (caller will copy out) */
2929 uc
->DataTransferLength
= mc
->mc_resid
;
2930 uc
->RequestSenseLength
= min(uc
->RequestSenseLength
, mc
->mc_sense
);
2931 uc
->CommandStatus
= mc
->mc_status
;
2935 if (mc
->mc_data
!= NULL
)
2936 kfree(mc
->mc_data
, M_DEVBUF
);
2938 mly_release_command(mc
);
2942 /********************************************************************************
2943 * Return health status to userspace. If the health change index in the user
2944 * structure does not match that currently exported by the controller, we
2945 * return the current status immediately. Otherwise, we block until either
2946 * interrupted or new status is delivered.
2949 mly_user_health(struct mly_softc
*sc
, struct mly_user_health
*uh
)
2951 struct mly_health_status mh
;
2954 /* fetch the current health status from userspace */
2955 if ((error
= copyin(uh
->HealthStatusBuffer
, &mh
, sizeof(mh
))) != 0)
2958 /* spin waiting for a status update */
2960 error
= EWOULDBLOCK
;
2961 while ((error
!= 0) && (sc
->mly_event_change
== mh
.change_counter
))
2962 error
= tsleep(&sc
->mly_event_change
, PCATCH
, "mlyhealth", 0);
2965 /* copy the controller's health status buffer out (there is a race here if it changes again) */
2966 error
= copyout(&sc
->mly_mmbox
->mmm_health
.status
, uh
->HealthStatusBuffer
,
2967 sizeof(uh
->HealthStatusBuffer
));
2973 mly_timeout(struct mly_softc
*sc
)
2975 struct mly_command
*mc
;
2978 deadline
= time_uptime
- MLY_CMD_TIMEOUT
;
2979 TAILQ_FOREACH(mc
, &sc
->mly_busy
, mc_link
) {
2980 if ((mc
->mc_timestamp
< deadline
)) {
2981 device_printf(sc
->mly_dev
,
2982 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", mc
,
2983 (int)(time_uptime
- mc
->mc_timestamp
));
2987 callout_reset(&sc
->mly_timeout
, MLY_CMD_TIMEOUT
* hz
,
2988 (timeout_t
*)mly_timeout
, sc
);