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 NULL
, NULL
, /* filter, filterarg */
405 MAXBSIZE
, MLY_MAX_SGENTRIES
, /* maxsize, nsegments */
406 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
407 BUS_DMA_ALLOCNOW
, /* flags */
408 &sc
->mly_parent_dmat
)) {
409 mly_printf(sc
, "can't allocate parent DMA tag\n");
414 * Create DMA tag for mapping buffers into controller-addressable space.
416 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
417 1, 0, /* alignment, boundary */
418 BUS_SPACE_MAXADDR
, /* lowaddr */
419 BUS_SPACE_MAXADDR
, /* highaddr */
420 NULL
, NULL
, /* filter, filterarg */
421 MAXBSIZE
, MLY_MAX_SGENTRIES
, /* maxsize, nsegments */
422 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
424 &sc
->mly_buffer_dmat
)) {
425 mly_printf(sc
, "can't allocate buffer DMA tag\n");
430 * Initialise the DMA tag for command packets.
432 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
433 1, 0, /* alignment, boundary */
434 BUS_SPACE_MAXADDR
, /* lowaddr */
435 BUS_SPACE_MAXADDR
, /* highaddr */
436 NULL
, NULL
, /* filter, filterarg */
437 sizeof(union mly_command_packet
) * MLY_MAX_COMMANDS
, 1, /* maxsize, nsegments */
438 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
439 BUS_DMA_ALLOCNOW
, /* flags */
440 &sc
->mly_packet_dmat
)) {
441 mly_printf(sc
, "can't allocate command packet DMA tag\n");
446 * Detect the hardware interface version
448 for (i
= 0; mly_identifiers
[i
].vendor
!= 0; i
++) {
449 if ((mly_identifiers
[i
].vendor
== pci_get_vendor(sc
->mly_dev
)) &&
450 (mly_identifiers
[i
].device
== pci_get_device(sc
->mly_dev
))) {
451 sc
->mly_hwif
= mly_identifiers
[i
].hwif
;
452 switch(sc
->mly_hwif
) {
453 case MLY_HWIF_I960RX
:
454 debug(1, "set hardware up for i960RX");
455 sc
->mly_doorbell_true
= 0x00;
456 sc
->mly_command_mailbox
= MLY_I960RX_COMMAND_MAILBOX
;
457 sc
->mly_status_mailbox
= MLY_I960RX_STATUS_MAILBOX
;
458 sc
->mly_idbr
= MLY_I960RX_IDBR
;
459 sc
->mly_odbr
= MLY_I960RX_ODBR
;
460 sc
->mly_error_status
= MLY_I960RX_ERROR_STATUS
;
461 sc
->mly_interrupt_status
= MLY_I960RX_INTERRUPT_STATUS
;
462 sc
->mly_interrupt_mask
= MLY_I960RX_INTERRUPT_MASK
;
464 case MLY_HWIF_STRONGARM
:
465 debug(1, "set hardware up for StrongARM");
466 sc
->mly_doorbell_true
= 0xff; /* doorbell 'true' is 0 */
467 sc
->mly_command_mailbox
= MLY_STRONGARM_COMMAND_MAILBOX
;
468 sc
->mly_status_mailbox
= MLY_STRONGARM_STATUS_MAILBOX
;
469 sc
->mly_idbr
= MLY_STRONGARM_IDBR
;
470 sc
->mly_odbr
= MLY_STRONGARM_ODBR
;
471 sc
->mly_error_status
= MLY_STRONGARM_ERROR_STATUS
;
472 sc
->mly_interrupt_status
= MLY_STRONGARM_INTERRUPT_STATUS
;
473 sc
->mly_interrupt_mask
= MLY_STRONGARM_INTERRUPT_MASK
;
481 * Create the scatter/gather mappings.
483 if ((error
= mly_sg_map(sc
)))
487 * Allocate and map the memory mailbox
489 if ((error
= mly_mmbox_map(sc
)))
498 /********************************************************************************
499 * Shut the controller down and detach all our resources.
502 mly_detach(device_t dev
)
506 if ((error
= mly_shutdown(dev
)) != 0)
509 mly_free(device_get_softc(dev
));
513 /********************************************************************************
514 * Bring the controller to a state where it can be safely left alone.
516 * Note that it should not be necessary to wait for any outstanding commands,
517 * as they should be completed prior to calling here.
519 * XXX this applies for I/O, but not status polls; we should beware of
520 * the case where a status command is running while we detach.
523 mly_shutdown(device_t dev
)
525 struct mly_softc
*sc
= device_get_softc(dev
);
529 if (sc
->mly_state
& MLY_STATE_OPEN
)
532 /* kill the periodic event */
533 callout_stop(&sc
->mly_periodic
);
535 /* flush controller */
536 mly_printf(sc
, "flushing cache...");
537 kprintf("%s\n", mly_flush(sc
) ? "failed" : "done");
539 MLY_MASK_INTERRUPTS(sc
);
544 /*******************************************************************************
545 * Take an interrupt, or be poked by other code to look for interrupt-worthy
551 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
558 /********************************************************************************
559 ********************************************************************************
560 Bus-dependant Resource Management
561 ********************************************************************************
562 ********************************************************************************/
564 /********************************************************************************
565 * Allocate memory for the scatter/gather tables
568 mly_sg_map(struct mly_softc
*sc
)
575 * Create a single tag describing a region large enough to hold all of
576 * the s/g lists we will need.
578 segsize
= sizeof(struct mly_sg_entry
) * MLY_MAX_COMMANDS
*MLY_MAX_SGENTRIES
;
579 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
580 1, 0, /* alignment,boundary */
581 BUS_SPACE_MAXADDR
, /* lowaddr */
582 BUS_SPACE_MAXADDR
, /* highaddr */
583 NULL
, NULL
, /* filter, filterarg */
584 segsize
, 1, /* maxsize, nsegments */
585 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
586 BUS_DMA_ALLOCNOW
, /* flags */
588 mly_printf(sc
, "can't allocate scatter/gather DMA tag\n");
593 * Allocate enough s/g maps for all commands and permanently map them into
594 * controller-visible space.
596 * XXX this assumes we can get enough space for all the s/g maps in one
599 if (bus_dmamem_alloc(sc
->mly_sg_dmat
, (void **)&sc
->mly_sg_table
,
600 BUS_DMA_NOWAIT
, &sc
->mly_sg_dmamap
)) {
601 mly_printf(sc
, "can't allocate s/g table\n");
604 if (bus_dmamap_load(sc
->mly_sg_dmat
, sc
->mly_sg_dmamap
, sc
->mly_sg_table
,
605 segsize
, mly_sg_map_helper
, sc
, BUS_DMA_NOWAIT
) != 0)
610 /********************************************************************************
611 * Save the physical address of the base of the s/g table.
614 mly_sg_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
616 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
620 /* save base of s/g table's address in bus space */
621 sc
->mly_sg_busaddr
= segs
->ds_addr
;
624 /********************************************************************************
625 * Allocate memory for the memory-mailbox interface
628 mly_mmbox_map(struct mly_softc
*sc
)
632 * Create a DMA tag for a single contiguous region large enough for the
633 * memory mailbox structure.
635 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
636 1, 0, /* alignment,boundary */
637 BUS_SPACE_MAXADDR
, /* lowaddr */
638 BUS_SPACE_MAXADDR
, /* highaddr */
639 NULL
, NULL
, /* filter, filterarg */
640 sizeof(struct mly_mmbox
), 1, /* maxsize, nsegments */
641 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
642 BUS_DMA_ALLOCNOW
, /* flags */
643 &sc
->mly_mmbox_dmat
)) {
644 mly_printf(sc
, "can't allocate memory mailbox DMA tag\n");
649 * Allocate the buffer
651 if (bus_dmamem_alloc(sc
->mly_mmbox_dmat
, (void **)&sc
->mly_mmbox
, BUS_DMA_NOWAIT
, &sc
->mly_mmbox_dmamap
)) {
652 mly_printf(sc
, "can't allocate memory mailbox\n");
655 if (bus_dmamap_load(sc
->mly_mmbox_dmat
, sc
->mly_mmbox_dmamap
, sc
->mly_mmbox
,
656 sizeof(struct mly_mmbox
), mly_mmbox_map_helper
, sc
,
657 BUS_DMA_NOWAIT
) != 0)
659 bzero(sc
->mly_mmbox
, sizeof(*sc
->mly_mmbox
));
664 /********************************************************************************
665 * Save the physical address of the memory mailbox
668 mly_mmbox_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
670 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
674 sc
->mly_mmbox_busaddr
= segs
->ds_addr
;
677 /********************************************************************************
678 * Free all of the resources associated with (sc)
680 * Should not be called if the controller is active.
683 mly_free(struct mly_softc
*sc
)
688 /* Remove the management device */
689 destroy_dev(sc
->mly_dev_t
);
691 /* detach from CAM */
694 /* release command memory */
695 mly_release_commands(sc
);
697 /* throw away the controllerinfo structure */
698 if (sc
->mly_controllerinfo
!= NULL
)
699 kfree(sc
->mly_controllerinfo
, M_DEVBUF
);
701 /* throw away the controllerparam structure */
702 if (sc
->mly_controllerparam
!= NULL
)
703 kfree(sc
->mly_controllerparam
, M_DEVBUF
);
705 /* destroy data-transfer DMA tag */
706 if (sc
->mly_buffer_dmat
)
707 bus_dma_tag_destroy(sc
->mly_buffer_dmat
);
709 /* free and destroy DMA memory and tag for s/g lists */
710 if (sc
->mly_sg_table
) {
711 bus_dmamap_unload(sc
->mly_sg_dmat
, sc
->mly_sg_dmamap
);
712 bus_dmamem_free(sc
->mly_sg_dmat
, sc
->mly_sg_table
, sc
->mly_sg_dmamap
);
715 bus_dma_tag_destroy(sc
->mly_sg_dmat
);
717 /* free and destroy DMA memory and tag for memory mailbox */
719 bus_dmamap_unload(sc
->mly_mmbox_dmat
, sc
->mly_mmbox_dmamap
);
720 bus_dmamem_free(sc
->mly_mmbox_dmat
, sc
->mly_mmbox
, sc
->mly_mmbox_dmamap
);
722 if (sc
->mly_mmbox_dmat
)
723 bus_dma_tag_destroy(sc
->mly_mmbox_dmat
);
725 /* disconnect the interrupt handler */
727 bus_teardown_intr(sc
->mly_dev
, sc
->mly_irq
, sc
->mly_intr
);
728 if (sc
->mly_irq
!= NULL
)
729 bus_release_resource(sc
->mly_dev
, SYS_RES_IRQ
, sc
->mly_irq_rid
, sc
->mly_irq
);
731 /* destroy the parent DMA tag */
732 if (sc
->mly_parent_dmat
)
733 bus_dma_tag_destroy(sc
->mly_parent_dmat
);
735 /* release the register window mapping */
736 if (sc
->mly_regs_resource
!= NULL
)
737 bus_release_resource(sc
->mly_dev
, SYS_RES_MEMORY
, sc
->mly_regs_rid
, sc
->mly_regs_resource
);
740 /********************************************************************************
741 ********************************************************************************
743 ********************************************************************************
744 ********************************************************************************/
746 /********************************************************************************
747 * Fill in the mly_controllerinfo and mly_controllerparam fields in the softc.
750 mly_get_controllerinfo(struct mly_softc
*sc
)
752 struct mly_command_ioctl mci
;
758 if (sc
->mly_controllerinfo
!= NULL
)
759 kfree(sc
->mly_controllerinfo
, M_DEVBUF
);
761 /* build the getcontrollerinfo ioctl and send it */
762 bzero(&mci
, sizeof(mci
));
763 sc
->mly_controllerinfo
= NULL
;
764 mci
.sub_ioctl
= MDACIOCTL_GETCONTROLLERINFO
;
765 if ((error
= mly_ioctl(sc
, &mci
, (void **)&sc
->mly_controllerinfo
, sizeof(*sc
->mly_controllerinfo
),
766 &status
, NULL
, NULL
)))
771 if (sc
->mly_controllerparam
!= NULL
)
772 kfree(sc
->mly_controllerparam
, M_DEVBUF
);
774 /* build the getcontrollerparameter ioctl and send it */
775 bzero(&mci
, sizeof(mci
));
776 sc
->mly_controllerparam
= NULL
;
777 mci
.sub_ioctl
= MDACIOCTL_GETCONTROLLERPARAMETER
;
778 if ((error
= mly_ioctl(sc
, &mci
, (void **)&sc
->mly_controllerparam
, sizeof(*sc
->mly_controllerparam
),
779 &status
, NULL
, NULL
)))
787 /********************************************************************************
788 * Schedule all possible devices for a rescan.
792 mly_scan_devices(struct mly_softc
*sc
)
799 * Clear any previous BTL information.
801 bzero(&sc
->mly_btl
, sizeof(sc
->mly_btl
));
804 * Mark all devices as requiring a rescan, and let the next
805 * periodic scan collect them.
807 for (bus
= 0; bus
< sc
->mly_cam_channels
; bus
++)
808 if (MLY_BUS_IS_VALID(sc
, bus
))
809 for (target
= 0; target
< MLY_MAX_TARGETS
; target
++)
810 sc
->mly_btl
[bus
][target
].mb_flags
= MLY_BTL_RESCAN
;
814 /********************************************************************************
815 * Rescan a device, possibly as a consequence of getting an event which suggests
816 * that it may have changed.
818 * If we suffer resource starvation, we can abandon the rescan as we'll be
822 mly_rescan_btl(struct mly_softc
*sc
, int bus
, int target
)
824 struct mly_command
*mc
;
825 struct mly_command_ioctl
*mci
;
829 /* check that this bus is valid */
830 if (!MLY_BUS_IS_VALID(sc
, bus
))
834 if (mly_alloc_command(sc
, &mc
))
837 /* set up the data buffer */
838 mc
->mc_data
= kmalloc(sizeof(union mly_devinfo
), M_DEVBUF
, M_INTWAIT
| M_ZERO
);
839 mc
->mc_flags
|= MLY_CMD_DATAIN
;
840 mc
->mc_complete
= mly_complete_rescan
;
845 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
846 mci
->opcode
= MDACMD_IOCTL
;
847 mci
->addr
.phys
.controller
= 0;
848 mci
->timeout
.value
= 30;
849 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
850 if (MLY_BUS_IS_VIRTUAL(sc
, bus
)) {
851 mc
->mc_length
= mci
->data_size
= sizeof(struct mly_ioctl_getlogdevinfovalid
);
852 mci
->sub_ioctl
= MDACIOCTL_GETLOGDEVINFOVALID
;
853 mci
->addr
.log
.logdev
= MLY_LOGDEV_ID(sc
, bus
, target
);
854 debug(1, "logical device %d", mci
->addr
.log
.logdev
);
856 mc
->mc_length
= mci
->data_size
= sizeof(struct mly_ioctl_getphysdevinfovalid
);
857 mci
->sub_ioctl
= MDACIOCTL_GETPHYSDEVINFOVALID
;
858 mci
->addr
.phys
.lun
= 0;
859 mci
->addr
.phys
.target
= target
;
860 mci
->addr
.phys
.channel
= bus
;
861 debug(1, "physical device %d:%d", mci
->addr
.phys
.channel
, mci
->addr
.phys
.target
);
865 * Dispatch the command. If we successfully send the command, clear the rescan
868 if (mly_start(mc
) != 0) {
869 mly_release_command(mc
);
871 sc
->mly_btl
[bus
][target
].mb_flags
&= ~MLY_BTL_RESCAN
; /* success */
875 /********************************************************************************
876 * Handle the completion of a rescan operation
879 mly_complete_rescan(struct mly_command
*mc
)
881 struct mly_softc
*sc
= mc
->mc_sc
;
882 struct mly_ioctl_getlogdevinfovalid
*ldi
;
883 struct mly_ioctl_getphysdevinfovalid
*pdi
;
884 struct mly_command_ioctl
*mci
;
885 struct mly_btl btl
, *btlp
;
886 int bus
, target
, rescan
;
891 * Recover the bus and target from the command. We need these even in
892 * the case where we don't have a useful response.
894 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
895 if (mci
->sub_ioctl
== MDACIOCTL_GETLOGDEVINFOVALID
) {
896 bus
= MLY_LOGDEV_BUS(sc
, mci
->addr
.log
.logdev
);
897 target
= MLY_LOGDEV_TARGET(sc
, mci
->addr
.log
.logdev
);
899 bus
= mci
->addr
.phys
.channel
;
900 target
= mci
->addr
.phys
.target
;
902 /* XXX validate bus/target? */
904 /* the default result is 'no device' */
905 bzero(&btl
, sizeof(btl
));
907 /* if the rescan completed OK, we have possibly-new BTL data */
908 if (mc
->mc_status
== 0) {
909 if (mc
->mc_length
== sizeof(*ldi
)) {
910 ldi
= (struct mly_ioctl_getlogdevinfovalid
*)mc
->mc_data
;
911 if ((MLY_LOGDEV_BUS(sc
, ldi
->logical_device_number
) != bus
) ||
912 (MLY_LOGDEV_TARGET(sc
, ldi
->logical_device_number
) != target
)) {
913 mly_printf(sc
, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
914 bus
, target
, MLY_LOGDEV_BUS(sc
, ldi
->logical_device_number
),
915 MLY_LOGDEV_TARGET(sc
, ldi
->logical_device_number
));
916 /* XXX what can we do about this? */
918 btl
.mb_flags
= MLY_BTL_LOGICAL
;
919 btl
.mb_type
= ldi
->raid_level
;
920 btl
.mb_state
= ldi
->state
;
921 debug(1, "BTL rescan for %d returns %s, %s", ldi
->logical_device_number
,
922 mly_describe_code(mly_table_device_type
, ldi
->raid_level
),
923 mly_describe_code(mly_table_device_state
, ldi
->state
));
924 } else if (mc
->mc_length
== sizeof(*pdi
)) {
925 pdi
= (struct mly_ioctl_getphysdevinfovalid
*)mc
->mc_data
;
926 if ((pdi
->channel
!= bus
) || (pdi
->target
!= target
)) {
927 mly_printf(sc
, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
928 bus
, target
, pdi
->channel
, pdi
->target
);
929 /* XXX what can we do about this? */
931 btl
.mb_flags
= MLY_BTL_PHYSICAL
;
932 btl
.mb_type
= MLY_DEVICE_TYPE_PHYSICAL
;
933 btl
.mb_state
= pdi
->state
;
934 btl
.mb_speed
= pdi
->speed
;
935 btl
.mb_width
= pdi
->width
;
936 if (pdi
->state
!= MLY_DEVICE_STATE_UNCONFIGURED
)
937 sc
->mly_btl
[bus
][target
].mb_flags
|= MLY_BTL_PROTECTED
;
938 debug(1, "BTL rescan for %d:%d returns %s", bus
, target
,
939 mly_describe_code(mly_table_device_state
, pdi
->state
));
941 mly_printf(sc
, "BTL rescan result invalid\n");
945 kfree(mc
->mc_data
, M_DEVBUF
);
946 mly_release_command(mc
);
949 * Decide whether we need to rescan the device.
953 /* device type changes (usually between 'nothing' and 'something') */
954 btlp
= &sc
->mly_btl
[bus
][target
];
955 if (btl
.mb_flags
!= btlp
->mb_flags
) {
956 debug(1, "flags changed, rescanning");
960 /* XXX other reasons? */
963 * Update BTL information.
968 * Perform CAM rescan if required.
971 mly_cam_rescan_btl(sc
, bus
, target
);
974 /********************************************************************************
975 * Get the current health status and set the 'next event' counter to suit.
978 mly_get_eventstatus(struct mly_softc
*sc
)
980 struct mly_command_ioctl mci
;
981 struct mly_health_status
*mh
;
985 /* build the gethealthstatus ioctl and send it */
986 bzero(&mci
, sizeof(mci
));
988 mci
.sub_ioctl
= MDACIOCTL_GETHEALTHSTATUS
;
990 if ((error
= mly_ioctl(sc
, &mci
, (void **)&mh
, sizeof(*mh
), &status
, NULL
, NULL
)))
995 /* get the event counter */
996 sc
->mly_event_change
= mh
->change_counter
;
997 sc
->mly_event_waiting
= mh
->next_event
;
998 sc
->mly_event_counter
= mh
->next_event
;
1000 /* save the health status into the memory mailbox */
1001 bcopy(mh
, &sc
->mly_mmbox
->mmm_health
.status
, sizeof(*mh
));
1003 debug(1, "initial change counter %d, event counter %d", mh
->change_counter
, mh
->next_event
);
1005 kfree(mh
, M_DEVBUF
);
1009 /********************************************************************************
1010 * Enable the memory mailbox mode.
1013 mly_enable_mmbox(struct mly_softc
*sc
)
1015 struct mly_command_ioctl mci
;
1016 u_int8_t
*sp
, status
;
1021 /* build the ioctl and send it */
1022 bzero(&mci
, sizeof(mci
));
1023 mci
.sub_ioctl
= MDACIOCTL_SETMEMORYMAILBOX
;
1024 /* set buffer addresses */
1025 mci
.param
.setmemorymailbox
.command_mailbox_physaddr
=
1026 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_command
);
1027 mci
.param
.setmemorymailbox
.status_mailbox_physaddr
=
1028 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_status
);
1029 mci
.param
.setmemorymailbox
.health_buffer_physaddr
=
1030 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_health
);
1032 /* set buffer sizes - abuse of data_size field is revolting */
1033 sp
= (u_int8_t
*)&mci
.data_size
;
1034 sp
[0] = ((sizeof(union mly_command_packet
) * MLY_MMBOX_COMMANDS
) / 1024);
1035 sp
[1] = (sizeof(union mly_status_packet
) * MLY_MMBOX_STATUS
) / 1024;
1036 mci
.param
.setmemorymailbox
.health_buffer_size
= sizeof(union mly_health_region
) / 1024;
1038 debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc
->mly_mmbox
,
1039 mci
.param
.setmemorymailbox
.command_mailbox_physaddr
, sp
[0],
1040 mci
.param
.setmemorymailbox
.status_mailbox_physaddr
, sp
[1],
1041 mci
.param
.setmemorymailbox
.health_buffer_physaddr
,
1042 mci
.param
.setmemorymailbox
.health_buffer_size
);
1044 if ((error
= mly_ioctl(sc
, &mci
, NULL
, 0, &status
, NULL
, NULL
)))
1048 sc
->mly_state
|= MLY_STATE_MMBOX_ACTIVE
;
1049 debug(1, "memory mailbox active");
1053 /********************************************************************************
1054 * Flush all pending I/O from the controller.
1057 mly_flush(struct mly_softc
*sc
)
1059 struct mly_command_ioctl mci
;
1065 /* build the ioctl */
1066 bzero(&mci
, sizeof(mci
));
1067 mci
.sub_ioctl
= MDACIOCTL_FLUSHDEVICEDATA
;
1068 mci
.param
.deviceoperation
.operation_device
= MLY_OPDEVICE_PHYSICAL_CONTROLLER
;
1070 /* pass it off to the controller */
1071 if ((error
= mly_ioctl(sc
, &mci
, NULL
, 0, &status
, NULL
, NULL
)))
1074 return((status
== 0) ? 0 : EIO
);
1077 /********************************************************************************
1078 * Perform an ioctl command.
1080 * If (data) is not NULL, the command requires data transfer. If (*data) is NULL
1081 * the command requires data transfer from the controller, and we will allocate
1082 * a buffer for it. If (*data) is not NULL, the command requires data transfer
1083 * to the controller.
1085 * XXX passing in the whole ioctl structure is ugly. Better ideas?
1087 * XXX we don't even try to handle the case where datasize > 4k. We should.
1090 mly_ioctl(struct mly_softc
*sc
, struct mly_command_ioctl
*ioctl
, void **data
, size_t datasize
,
1091 u_int8_t
*status
, void *sense_buffer
, size_t *sense_length
)
1093 struct mly_command
*mc
;
1094 struct mly_command_ioctl
*mci
;
1100 if (mly_alloc_command(sc
, &mc
)) {
1105 /* copy the ioctl structure, but save some important fields and then fixup */
1106 mci
= &mc
->mc_packet
->ioctl
;
1107 ioctl
->sense_buffer_address
= mci
->sense_buffer_address
;
1108 ioctl
->maximum_sense_size
= mci
->maximum_sense_size
;
1110 mci
->opcode
= MDACMD_IOCTL
;
1111 mci
->timeout
.value
= 30;
1112 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
1114 /* handle the data buffer */
1116 if (*data
== NULL
) {
1117 /* allocate data buffer */
1118 mc
->mc_data
= kmalloc(datasize
, M_DEVBUF
, M_INTWAIT
);
1119 mc
->mc_flags
|= MLY_CMD_DATAIN
;
1121 mc
->mc_data
= *data
;
1122 mc
->mc_flags
|= MLY_CMD_DATAOUT
;
1124 mc
->mc_length
= datasize
;
1125 mc
->mc_packet
->generic
.data_size
= datasize
;
1128 /* run the command */
1129 if ((error
= mly_immediate_command(mc
)))
1132 /* clean up and return any data */
1133 *status
= mc
->mc_status
;
1134 if ((mc
->mc_sense
> 0) && (sense_buffer
!= NULL
)) {
1135 bcopy(mc
->mc_packet
, sense_buffer
, mc
->mc_sense
);
1136 *sense_length
= mc
->mc_sense
;
1140 /* should we return a data pointer? */
1141 if ((data
!= NULL
) && (*data
== NULL
))
1142 *data
= mc
->mc_data
;
1144 /* command completed OK */
1149 /* do we need to free a data buffer we allocated? */
1150 if (error
&& (mc
->mc_data
!= NULL
) && (*data
== NULL
))
1151 kfree(mc
->mc_data
, M_DEVBUF
);
1152 mly_release_command(mc
);
1157 /********************************************************************************
1158 * Check for event(s) outstanding in the controller.
1161 mly_check_event(struct mly_softc
*sc
)
1165 * The controller may have updated the health status information,
1166 * so check for it here. Note that the counters are all in host memory,
1167 * so this check is very cheap. Also note that we depend on checking on
1170 if (sc
->mly_mmbox
->mmm_health
.status
.change_counter
!= sc
->mly_event_change
) {
1171 sc
->mly_event_change
= sc
->mly_mmbox
->mmm_health
.status
.change_counter
;
1172 debug(1, "event change %d, event status update, %d -> %d", sc
->mly_event_change
,
1173 sc
->mly_event_waiting
, sc
->mly_mmbox
->mmm_health
.status
.next_event
);
1174 sc
->mly_event_waiting
= sc
->mly_mmbox
->mmm_health
.status
.next_event
;
1176 /* wake up anyone that might be interested in this */
1177 wakeup(&sc
->mly_event_change
);
1179 if (sc
->mly_event_counter
!= sc
->mly_event_waiting
)
1180 mly_fetch_event(sc
);
1183 /********************************************************************************
1184 * Fetch one event from the controller.
1186 * If we fail due to resource starvation, we'll be retried the next time a
1187 * command completes.
1190 mly_fetch_event(struct mly_softc
*sc
)
1192 struct mly_command
*mc
;
1193 struct mly_command_ioctl
*mci
;
1199 if (mly_alloc_command(sc
, &mc
))
1202 /* set up the data buffer */
1203 mc
->mc_data
= kmalloc(sizeof(struct mly_event
), M_DEVBUF
, M_INTWAIT
|M_ZERO
);
1204 mc
->mc_length
= sizeof(struct mly_event
);
1205 mc
->mc_flags
|= MLY_CMD_DATAIN
;
1206 mc
->mc_complete
= mly_complete_event
;
1209 * Get an event number to fetch. It's possible that we've raced with another
1210 * context for the last event, in which case there will be no more events.
1213 if (sc
->mly_event_counter
== sc
->mly_event_waiting
) {
1214 mly_release_command(mc
);
1218 event
= sc
->mly_event_counter
++;
1224 * At this point we are committed to sending this request, as it
1225 * will be the only one constructed for this particular event number.
1227 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
1228 mci
->opcode
= MDACMD_IOCTL
;
1229 mci
->data_size
= sizeof(struct mly_event
);
1230 mci
->addr
.phys
.lun
= (event
>> 16) & 0xff;
1231 mci
->addr
.phys
.target
= (event
>> 24) & 0xff;
1232 mci
->addr
.phys
.channel
= 0;
1233 mci
->addr
.phys
.controller
= 0;
1234 mci
->timeout
.value
= 30;
1235 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
1236 mci
->sub_ioctl
= MDACIOCTL_GETEVENT
;
1237 mci
->param
.getevent
.sequence_number_low
= event
& 0xffff;
1239 debug(1, "fetch event %u", event
);
1242 * Submit the command.
1244 * Note that failure of mly_start() will result in this event never being
1247 if (mly_start(mc
) != 0) {
1248 mly_printf(sc
, "couldn't fetch event %u\n", event
);
1249 mly_release_command(mc
);
1253 /********************************************************************************
1254 * Handle the completion of an event poll.
1257 mly_complete_event(struct mly_command
*mc
)
1259 struct mly_softc
*sc
= mc
->mc_sc
;
1260 struct mly_event
*me
= (struct mly_event
*)mc
->mc_data
;
1265 * If the event was successfully fetched, process it.
1267 if (mc
->mc_status
== SCSI_STATUS_OK
) {
1268 mly_process_event(sc
, me
);
1269 kfree(me
, M_DEVBUF
);
1271 mly_release_command(mc
);
1274 * Check for another event.
1276 mly_check_event(sc
);
1279 /********************************************************************************
1280 * Process a controller event.
1283 mly_process_event(struct mly_softc
*sc
, struct mly_event
*me
)
1285 struct scsi_sense_data
*ssd
= (struct scsi_sense_data
*)&me
->sense
[0];
1287 int bus
, target
, event
, class, action
;
1290 * Errors can be reported using vendor-unique sense data. In this case, the
1291 * event code will be 0x1c (Request sense data present), the sense key will
1292 * be 0x09 (vendor specific), the MSB of the ASC will be set, and the
1293 * actual event code will be a 16-bit value comprised of the ASCQ (low byte)
1294 * and low seven bits of the ASC (low seven bits of the high byte).
1296 if ((me
->code
== 0x1c) &&
1297 ((ssd
->flags
& SSD_KEY
) == SSD_KEY_Vendor_Specific
) &&
1298 (ssd
->add_sense_code
& 0x80)) {
1299 event
= ((int)(ssd
->add_sense_code
& ~0x80) << 8) + ssd
->add_sense_code_qual
;
1304 /* look up event, get codes */
1305 fp
= mly_describe_code(mly_table_event
, event
);
1307 debug(1, "Event %d code 0x%x", me
->sequence_number
, me
->code
);
1311 if (isupper(class) && bootverbose
)
1312 class = tolower(class);
1314 /* get action code, text string */
1319 * Print some information about the event.
1321 * This code uses a table derived from the corresponding portion of the Linux
1322 * driver, and thus the parser is very similar.
1325 case 'p': /* error on physical device */
1326 mly_printf(sc
, "physical device %d:%d %s\n", me
->channel
, me
->target
, tp
);
1328 sc
->mly_btl
[me
->channel
][me
->target
].mb_flags
|= MLY_BTL_RESCAN
;
1330 case 'l': /* error on logical unit */
1331 case 'm': /* message about logical unit */
1332 bus
= MLY_LOGDEV_BUS(sc
, me
->lun
);
1333 target
= MLY_LOGDEV_TARGET(sc
, me
->lun
);
1334 mly_name_device(sc
, bus
, target
);
1335 mly_printf(sc
, "logical device %d (%s) %s\n", me
->lun
, sc
->mly_btl
[bus
][target
].mb_name
, tp
);
1337 sc
->mly_btl
[bus
][target
].mb_flags
|= MLY_BTL_RESCAN
;
1339 case 's': /* report of sense data */
1340 if (((ssd
->flags
& SSD_KEY
) == SSD_KEY_NO_SENSE
) ||
1341 (((ssd
->flags
& SSD_KEY
) == SSD_KEY_NOT_READY
) &&
1342 (ssd
->add_sense_code
== 0x04) &&
1343 ((ssd
->add_sense_code_qual
== 0x01) || (ssd
->add_sense_code_qual
== 0x02))))
1344 break; /* ignore NO_SENSE or NOT_READY in one case */
1346 mly_printf(sc
, "physical device %d:%d %s\n", me
->channel
, me
->target
, tp
);
1347 mly_printf(sc
, " sense key %d asc %02x ascq %02x\n",
1348 ssd
->flags
& SSD_KEY
, ssd
->add_sense_code
, ssd
->add_sense_code_qual
);
1349 mly_printf(sc
, " info %s csi %s\n", hexncpy(ssd
->info
, 4, hexstr
[0], 12, NULL
),
1350 hexncpy(ssd
->cmd_spec_info
, 4, hexstr
[1], 12, NULL
));
1352 sc
->mly_btl
[me
->channel
][me
->target
].mb_flags
|= MLY_BTL_RESCAN
;
1355 mly_printf(sc
, tp
, me
->target
, me
->lun
);
1359 mly_printf(sc
, "controller %s\n", tp
);
1362 mly_printf(sc
, "%s - %d\n", tp
, me
->code
);
1364 default: /* probably a 'noisy' event being ignored */
1369 /********************************************************************************
1370 * Perform periodic activities.
1373 mly_periodic(void *data
)
1375 struct mly_softc
*sc
= (struct mly_softc
*)data
;
1383 for (bus
= 0; bus
< sc
->mly_cam_channels
; bus
++) {
1384 if (MLY_BUS_IS_VALID(sc
, bus
)) {
1385 for (target
= 0; target
< MLY_MAX_TARGETS
; target
++) {
1387 /* ignore the controller in this scan */
1388 if (target
== sc
->mly_controllerparam
->initiator_id
)
1391 /* perform device rescan? */
1392 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_RESCAN
)
1393 mly_rescan_btl(sc
, bus
, target
);
1398 /* check for controller events */
1399 mly_check_event(sc
);
1401 /* reschedule ourselves */
1402 callout_reset(&sc
->mly_periodic
, MLY_PERIODIC_INTERVAL
* hz
, mly_periodic
, sc
);
1405 /********************************************************************************
1406 ********************************************************************************
1408 ********************************************************************************
1409 ********************************************************************************/
1411 /********************************************************************************
1412 * Run a command and wait for it to complete.
1416 mly_immediate_command(struct mly_command
*mc
)
1418 struct mly_softc
*sc
= mc
->mc_sc
;
1423 /* spinning at splcam is ugly, but we're only used during controller init */
1425 if ((error
= mly_start(mc
))) {
1430 if (sc
->mly_state
& MLY_STATE_INTERRUPTS_ON
) {
1431 /* sleep on the command */
1432 while(!(mc
->mc_flags
& MLY_CMD_COMPLETE
)) {
1433 tsleep(mc
, 0, "mlywait", 0);
1436 /* spin and collect status while we do */
1437 while(!(mc
->mc_flags
& MLY_CMD_COMPLETE
)) {
1438 mly_done(mc
->mc_sc
);
1445 /********************************************************************************
1446 * Deliver a command to the controller.
1448 * XXX it would be good to just queue commands that we can't submit immediately
1449 * and send them later, but we probably want a wrapper for that so that
1450 * we don't hang on a failed submission for an immediate command.
1453 mly_start(struct mly_command
*mc
)
1455 struct mly_softc
*sc
= mc
->mc_sc
;
1456 union mly_command_packet
*pkt
;
1461 * Set the command up for delivery to the controller.
1463 mly_map_command(mc
);
1464 mc
->mc_packet
->generic
.command_id
= mc
->mc_slot
;
1467 mc
->mc_timestamp
= time_uptime
;
1473 * Do we have to use the hardware mailbox?
1475 if (!(sc
->mly_state
& MLY_STATE_MMBOX_ACTIVE
)) {
1477 * Check to see if the controller is ready for us.
1479 if (MLY_IDBR_TRUE(sc
, MLY_HM_CMDSENT
)) {
1483 mc
->mc_flags
|= MLY_CMD_BUSY
;
1486 * It's ready, send the command.
1488 MLY_SET_MBOX(sc
, sc
->mly_command_mailbox
, &mc
->mc_packetphys
);
1489 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_CMDSENT
);
1491 } else { /* use memory-mailbox mode */
1493 pkt
= &sc
->mly_mmbox
->mmm_command
[sc
->mly_mmbox_command_index
];
1495 /* check to see if the next index is free yet */
1496 if (pkt
->mmbox
.flag
!= 0) {
1500 mc
->mc_flags
|= MLY_CMD_BUSY
;
1502 /* copy in new command */
1503 bcopy(mc
->mc_packet
->mmbox
.data
, pkt
->mmbox
.data
, sizeof(pkt
->mmbox
.data
));
1504 /* barrier to ensure completion of previous write before we write the flag */
1505 bus_space_barrier(sc
->mly_btag
, sc
->mly_bhandle
, 0, 0,
1506 BUS_SPACE_BARRIER_WRITE
);
1507 /* copy flag last */
1508 pkt
->mmbox
.flag
= mc
->mc_packet
->mmbox
.flag
;
1509 /* barrier to ensure completion of previous write before we notify the controller */
1510 bus_space_barrier(sc
->mly_btag
, sc
->mly_bhandle
, 0, 0,
1511 BUS_SPACE_BARRIER_WRITE
);
1513 /* signal controller, update index */
1514 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_AM_CMDSENT
);
1515 sc
->mly_mmbox_command_index
= (sc
->mly_mmbox_command_index
+ 1) % MLY_MMBOX_COMMANDS
;
1518 mly_enqueue_busy(mc
);
1523 /********************************************************************************
1524 * Pick up command status from the controller, schedule a completion event
1527 mly_done(struct mly_softc
*sc
)
1529 struct mly_command
*mc
;
1530 union mly_status_packet
*sp
;
1537 /* pick up hardware-mailbox commands */
1538 if (MLY_ODBR_TRUE(sc
, MLY_HM_STSREADY
)) {
1539 slot
= MLY_GET_REG2(sc
, sc
->mly_status_mailbox
);
1540 if (slot
< MLY_SLOT_MAX
) {
1541 mc
= &sc
->mly_command
[slot
- MLY_SLOT_START
];
1542 mc
->mc_status
= MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 2);
1543 mc
->mc_sense
= MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 3);
1544 mc
->mc_resid
= MLY_GET_REG4(sc
, sc
->mly_status_mailbox
+ 4);
1545 mly_remove_busy(mc
);
1546 mc
->mc_flags
&= ~MLY_CMD_BUSY
;
1547 mly_enqueue_complete(mc
);
1550 /* slot 0xffff may mean "extremely bogus command" */
1551 mly_printf(sc
, "got HM completion for illegal slot %u\n", slot
);
1553 /* unconditionally acknowledge status */
1554 MLY_SET_REG(sc
, sc
->mly_odbr
, MLY_HM_STSREADY
);
1555 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_STSACK
);
1558 /* pick up memory-mailbox commands */
1559 if (MLY_ODBR_TRUE(sc
, MLY_AM_STSREADY
)) {
1561 sp
= &sc
->mly_mmbox
->mmm_status
[sc
->mly_mmbox_status_index
];
1563 /* check for more status */
1564 if (sp
->mmbox
.flag
== 0)
1567 /* get slot number */
1568 slot
= sp
->status
.command_id
;
1569 if (slot
< MLY_SLOT_MAX
) {
1570 mc
= &sc
->mly_command
[slot
- MLY_SLOT_START
];
1571 mc
->mc_status
= sp
->status
.status
;
1572 mc
->mc_sense
= sp
->status
.sense_length
;
1573 mc
->mc_resid
= sp
->status
.residue
;
1574 mly_remove_busy(mc
);
1575 mc
->mc_flags
&= ~MLY_CMD_BUSY
;
1576 mly_enqueue_complete(mc
);
1579 /* slot 0xffff may mean "extremely bogus command" */
1580 mly_printf(sc
, "got AM completion for illegal slot %u at %d\n",
1581 slot
, sc
->mly_mmbox_status_index
);
1584 /* clear and move to next index */
1586 sc
->mly_mmbox_status_index
= (sc
->mly_mmbox_status_index
+ 1) % MLY_MMBOX_STATUS
;
1588 /* acknowledge that we have collected status value(s) */
1589 MLY_SET_REG(sc
, sc
->mly_odbr
, MLY_AM_STSREADY
);
1594 if (sc
->mly_state
& MLY_STATE_INTERRUPTS_ON
)
1595 taskqueue_enqueue(taskqueue_swi
, &sc
->mly_task_complete
);
1597 mly_complete(sc
, 0);
1601 /********************************************************************************
1602 * Process completed commands
1605 mly_complete(void *context
, int pending
)
1607 struct mly_softc
*sc
= (struct mly_softc
*)context
;
1608 struct mly_command
*mc
;
1609 void (* mc_complete
)(struct mly_command
*mc
);
1615 * Spin pulling commands off the completed queue and processing them.
1617 while ((mc
= mly_dequeue_complete(sc
)) != NULL
) {
1620 * Free controller resources, mark command complete.
1622 * Note that as soon as we mark the command complete, it may be freed
1623 * out from under us, so we need to save the mc_complete field in
1624 * order to later avoid dereferencing mc. (We would not expect to
1625 * have a polling/sleeping consumer with mc_complete != NULL).
1627 mly_unmap_command(mc
);
1628 mc_complete
= mc
->mc_complete
;
1629 mc
->mc_flags
|= MLY_CMD_COMPLETE
;
1632 * Call completion handler or wake up sleeping consumer.
1634 if (mc_complete
!= NULL
) {
1642 * XXX if we are deferring commands due to controller-busy status, we should
1643 * retry submitting them here.
1647 /********************************************************************************
1648 ********************************************************************************
1649 Command Buffer Management
1650 ********************************************************************************
1651 ********************************************************************************/
1653 /********************************************************************************
1654 * Allocate a command.
1657 mly_alloc_command(struct mly_softc
*sc
, struct mly_command
**mcp
)
1659 struct mly_command
*mc
;
1663 if ((mc
= mly_dequeue_free(sc
)) == NULL
) {
1664 *mcp
= NULL
; /* avoid gcc warning */
1672 /********************************************************************************
1673 * Release a command back to the freelist.
1676 mly_release_command(struct mly_command
*mc
)
1681 * Fill in parts of the command that may cause confusion if
1682 * a consumer doesn't when we are later allocated.
1686 mc
->mc_complete
= NULL
;
1687 mc
->mc_private
= NULL
;
1690 * By default, we set up to overwrite the command packet with
1691 * sense information.
1693 mc
->mc_packet
->generic
.sense_buffer_address
= mc
->mc_packetphys
;
1694 mc
->mc_packet
->generic
.maximum_sense_size
= sizeof(union mly_command_packet
);
1696 mly_enqueue_free(mc
);
1699 /********************************************************************************
1700 * Map helper for command allocation.
1703 mly_alloc_commands_map(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1705 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
1709 sc
->mly_packetphys
= segs
[0].ds_addr
;
1712 /********************************************************************************
1713 * Allocate and initialise command and packet structures.
1715 * If the controller supports fewer than MLY_MAX_COMMANDS commands, limit our
1716 * allocation to that number. If we don't yet know how many commands the
1717 * controller supports, allocate a very small set (suitable for initialisation
1721 mly_alloc_commands(struct mly_softc
*sc
)
1723 struct mly_command
*mc
;
1726 if (sc
->mly_controllerinfo
== NULL
) {
1729 ncmd
= min(MLY_MAX_COMMANDS
, sc
->mly_controllerinfo
->maximum_parallel_commands
);
1733 * Allocate enough space for all the command packets in one chunk and
1734 * map them permanently into controller-visible space.
1736 if (bus_dmamem_alloc(sc
->mly_packet_dmat
, (void **)&sc
->mly_packet
,
1737 BUS_DMA_NOWAIT
, &sc
->mly_packetmap
)) {
1740 if (bus_dmamap_load(sc
->mly_packet_dmat
, sc
->mly_packetmap
, sc
->mly_packet
,
1741 ncmd
* sizeof(union mly_command_packet
),
1742 mly_alloc_commands_map
, sc
, BUS_DMA_NOWAIT
) != 0)
1745 for (i
= 0; i
< ncmd
; i
++) {
1746 mc
= &sc
->mly_command
[i
];
1747 bzero(mc
, sizeof(*mc
));
1749 mc
->mc_slot
= MLY_SLOT_START
+ i
;
1750 mc
->mc_packet
= sc
->mly_packet
+ i
;
1751 mc
->mc_packetphys
= sc
->mly_packetphys
+ (i
* sizeof(union mly_command_packet
));
1752 if (!bus_dmamap_create(sc
->mly_buffer_dmat
, 0, &mc
->mc_datamap
))
1753 mly_release_command(mc
);
1758 /********************************************************************************
1759 * Free all the storage held by commands.
1761 * Must be called with all commands on the free list.
1764 mly_release_commands(struct mly_softc
*sc
)
1766 struct mly_command
*mc
;
1768 /* throw away command buffer DMA maps */
1769 while (mly_alloc_command(sc
, &mc
) == 0)
1770 bus_dmamap_destroy(sc
->mly_buffer_dmat
, mc
->mc_datamap
);
1772 /* release the packet storage */
1773 if (sc
->mly_packet
!= NULL
) {
1774 bus_dmamap_unload(sc
->mly_packet_dmat
, sc
->mly_packetmap
);
1775 bus_dmamem_free(sc
->mly_packet_dmat
, sc
->mly_packet
, sc
->mly_packetmap
);
1776 sc
->mly_packet
= NULL
;
1781 /********************************************************************************
1782 * Command-mapping helper function - populate this command's s/g table
1783 * with the s/g entries for its data.
1786 mly_map_command_sg(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1788 struct mly_command
*mc
= (struct mly_command
*)arg
;
1789 struct mly_softc
*sc
= mc
->mc_sc
;
1790 struct mly_command_generic
*gen
= &(mc
->mc_packet
->generic
);
1791 struct mly_sg_entry
*sg
;
1796 /* can we use the transfer structure directly? */
1798 sg
= &gen
->transfer
.direct
.sg
[0];
1799 gen
->command_control
.extended_sg_table
= 0;
1801 tabofs
= ((mc
->mc_slot
- MLY_SLOT_START
) * MLY_MAX_SGENTRIES
);
1802 sg
= sc
->mly_sg_table
+ tabofs
;
1803 gen
->transfer
.indirect
.entries
[0] = nseg
;
1804 gen
->transfer
.indirect
.table_physaddr
[0] = sc
->mly_sg_busaddr
+ (tabofs
* sizeof(struct mly_sg_entry
));
1805 gen
->command_control
.extended_sg_table
= 1;
1808 /* copy the s/g table */
1809 for (i
= 0; i
< nseg
; i
++) {
1810 sg
[i
].physaddr
= segs
[i
].ds_addr
;
1811 sg
[i
].length
= segs
[i
].ds_len
;
1817 /********************************************************************************
1818 * Command-mapping helper function - save the cdb's physical address.
1820 * We don't support 'large' SCSI commands at this time, so this is unused.
1823 mly_map_command_cdb(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
1825 struct mly_command
*mc
= (struct mly_command
*)arg
;
1829 /* XXX can we safely assume that a CDB will never cross a page boundary? */
1830 if ((segs
[0].ds_addr
% PAGE_SIZE
) >
1831 ((segs
[0].ds_addr
+ mc
->mc_packet
->scsi_large
.cdb_length
) % PAGE_SIZE
))
1832 panic("cdb crosses page boundary");
1834 /* fix up fields in the command packet */
1835 mc
->mc_packet
->scsi_large
.cdb_physaddr
= segs
[0].ds_addr
;
1839 /********************************************************************************
1840 * Map a command into controller-visible space
1843 mly_map_command(struct mly_command
*mc
)
1845 struct mly_softc
*sc
= mc
->mc_sc
;
1849 /* don't map more than once */
1850 if (mc
->mc_flags
& MLY_CMD_MAPPED
)
1853 /* does the command have a data buffer? */
1854 if (mc
->mc_data
!= NULL
) {
1855 bus_dmamap_load(sc
->mly_buffer_dmat
, mc
->mc_datamap
, mc
->mc_data
, mc
->mc_length
,
1856 mly_map_command_sg
, mc
, 0);
1858 if (mc
->mc_flags
& MLY_CMD_DATAIN
)
1859 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_PREREAD
);
1860 if (mc
->mc_flags
& MLY_CMD_DATAOUT
)
1861 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_PREWRITE
);
1863 mc
->mc_flags
|= MLY_CMD_MAPPED
;
1866 /********************************************************************************
1867 * Unmap a command from controller-visible space
1870 mly_unmap_command(struct mly_command
*mc
)
1872 struct mly_softc
*sc
= mc
->mc_sc
;
1876 if (!(mc
->mc_flags
& MLY_CMD_MAPPED
))
1879 /* does the command have a data buffer? */
1880 if (mc
->mc_data
!= NULL
) {
1881 if (mc
->mc_flags
& MLY_CMD_DATAIN
)
1882 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_POSTREAD
);
1883 if (mc
->mc_flags
& MLY_CMD_DATAOUT
)
1884 bus_dmamap_sync(sc
->mly_buffer_dmat
, mc
->mc_datamap
, BUS_DMASYNC_POSTWRITE
);
1886 bus_dmamap_unload(sc
->mly_buffer_dmat
, mc
->mc_datamap
);
1888 mc
->mc_flags
&= ~MLY_CMD_MAPPED
;
1892 /********************************************************************************
1893 ********************************************************************************
1895 ********************************************************************************
1896 ********************************************************************************/
1898 /********************************************************************************
1899 * Attach the physical and virtual SCSI busses to CAM.
1901 * Physical bus numbering starts from 0, virtual bus numbering from one greater
1902 * than the highest physical bus. Physical busses are only registered if
1903 * the kernel environment variable "hw.mly.register_physical_channels" is set.
1905 * When we refer to a "bus", we are referring to the bus number registered with
1906 * the SIM, wheras a "channel" is a channel number given to the adapter. In order
1907 * to keep things simple, we map these 1:1, so "bus" and "channel" may be used
1911 mly_cam_attach(struct mly_softc
*sc
)
1913 struct cam_devq
*devq
;
1919 * Allocate a devq for all our channels combined.
1921 if ((devq
= cam_simq_alloc(sc
->mly_controllerinfo
->maximum_parallel_commands
)) == NULL
) {
1922 mly_printf(sc
, "can't allocate CAM SIM queue\n");
1927 * If physical channel registration has been requested, register these first.
1928 * Note that we enable tagged command queueing for physical channels.
1930 if (ktestenv("hw.mly.register_physical_channels")) {
1932 for (i
= 0; i
< sc
->mly_controllerinfo
->physical_channels_present
; i
++, chn
++) {
1934 if ((sc
->mly_cam_sim
[chn
] = cam_sim_alloc(mly_cam_action
, mly_cam_poll
, "mly", sc
,
1935 device_get_unit(sc
->mly_dev
),
1937 sc
->mly_controllerinfo
->maximum_parallel_commands
,
1938 1, devq
)) == NULL
) {
1941 if (xpt_bus_register(sc
->mly_cam_sim
[chn
], chn
)) {
1942 mly_printf(sc
, "CAM XPT physical channel registration failed\n");
1945 debug(1, "registered physical channel %d", chn
);
1950 * Register our virtual channels, with bus numbers matching channel numbers.
1952 chn
= sc
->mly_controllerinfo
->physical_channels_present
;
1953 for (i
= 0; i
< sc
->mly_controllerinfo
->virtual_channels_present
; i
++, chn
++) {
1954 if ((sc
->mly_cam_sim
[chn
] = cam_sim_alloc(mly_cam_action
, mly_cam_poll
, "mly", sc
,
1955 device_get_unit(sc
->mly_dev
),
1957 sc
->mly_controllerinfo
->maximum_parallel_commands
,
1958 0, devq
)) == NULL
) {
1961 if (xpt_bus_register(sc
->mly_cam_sim
[chn
], chn
)) {
1962 mly_printf(sc
, "CAM XPT virtual channel registration failed\n");
1965 debug(1, "registered virtual channel %d", chn
);
1969 * This is the total number of channels that (might have been) registered with
1970 * CAM. Some may not have been; check the mly_cam_sim array to be certain.
1972 sc
->mly_cam_channels
= sc
->mly_controllerinfo
->physical_channels_present
+
1973 sc
->mly_controllerinfo
->virtual_channels_present
;
1978 /********************************************************************************
1982 mly_cam_detach(struct mly_softc
*sc
)
1988 for (i
= 0; i
< sc
->mly_cam_channels
; i
++) {
1989 if (sc
->mly_cam_sim
[i
] != NULL
) {
1990 xpt_bus_deregister(cam_sim_path(sc
->mly_cam_sim
[i
]));
1991 cam_sim_free(sc
->mly_cam_sim
[i
]);
1994 if (sc
->mly_cam_devq
!= NULL
)
1995 cam_simq_release(sc
->mly_cam_devq
);
1998 /************************************************************************
2002 mly_cam_rescan_btl(struct mly_softc
*sc
, int bus
, int target
)
2008 if ((ccb
= xpt_alloc_ccb()) == NULL
) {
2009 mly_printf(sc
, "rescan failed (can't allocate CCB)\n");
2012 if (xpt_create_path(&ccb
->ccb_h
.path
, xpt_periph
,
2013 cam_sim_path(sc
->mly_cam_sim
[bus
]), target
, 0) != CAM_REQ_CMP
) {
2014 mly_printf(sc
, "rescan failed (can't create path)\n");
2019 xpt_setup_ccb(&ccb
->ccb_h
, ccb
->ccb_h
.path
, 5/*priority (low)*/);
2020 ccb
->ccb_h
.func_code
= XPT_SCAN_LUN
;
2021 ccb
->ccb_h
.cbfcnp
= mly_cam_rescan_callback
;
2022 ccb
->crcn
.flags
= CAM_FLAG_NONE
;
2023 debug(1, "rescan target %d:%d", bus
, target
);
2028 mly_cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
)
2033 /********************************************************************************
2034 * Handle an action requested by CAM
2037 mly_cam_action(struct cam_sim
*sim
, union ccb
*ccb
)
2039 struct mly_softc
*sc
= cam_sim_softc(sim
);
2043 switch (ccb
->ccb_h
.func_code
) {
2045 /* perform SCSI I/O */
2047 if (!mly_cam_action_io(sim
, (struct ccb_scsiio
*)&ccb
->csio
))
2051 /* perform geometry calculations */
2052 case XPT_CALC_GEOMETRY
:
2054 struct ccb_calc_geometry
*ccg
= &ccb
->ccg
;
2055 u_int32_t secs_per_cylinder
;
2057 debug(2, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim
), ccb
->ccb_h
.target_id
, ccb
->ccb_h
.target_lun
);
2059 if (sc
->mly_controllerparam
->bios_geometry
== MLY_BIOSGEOM_8G
) {
2061 ccg
->secs_per_track
= 63;
2062 } else { /* MLY_BIOSGEOM_2G */
2064 ccg
->secs_per_track
= 32;
2066 secs_per_cylinder
= ccg
->heads
* ccg
->secs_per_track
;
2067 ccg
->cylinders
= ccg
->volume_size
/ secs_per_cylinder
;
2068 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2072 /* handle path attribute inquiry */
2075 struct ccb_pathinq
*cpi
= &ccb
->cpi
;
2077 debug(2, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim
), ccb
->ccb_h
.target_id
, ccb
->ccb_h
.target_lun
);
2079 cpi
->version_num
= 1;
2080 cpi
->hba_inquiry
= PI_TAG_ABLE
; /* XXX extra flags for physical channels? */
2081 cpi
->target_sprt
= 0;
2083 cpi
->max_target
= MLY_MAX_TARGETS
- 1;
2084 cpi
->max_lun
= MLY_MAX_LUNS
- 1;
2085 cpi
->initiator_id
= sc
->mly_controllerparam
->initiator_id
;
2086 strncpy(cpi
->sim_vid
, "FreeBSD", SIM_IDLEN
);
2087 strncpy(cpi
->hba_vid
, "FreeBSD", HBA_IDLEN
);
2088 strncpy(cpi
->dev_name
, cam_sim_name(sim
), DEV_IDLEN
);
2089 cpi
->unit_number
= cam_sim_unit(sim
);
2090 cpi
->bus_id
= cam_sim_bus(sim
);
2091 cpi
->base_transfer_speed
= 132 * 1024; /* XXX what to set this to? */
2092 cpi
->transport
= XPORT_SPI
;
2093 cpi
->transport_version
= 2;
2094 cpi
->protocol
= PROTO_SCSI
;
2095 cpi
->protocol_version
= SCSI_REV_2
;
2096 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2100 case XPT_GET_TRAN_SETTINGS
:
2102 struct ccb_trans_settings
*cts
= &ccb
->cts
;
2104 struct ccb_trans_settings_scsi
*scsi
= &cts
->proto_specific
.scsi
;
2105 struct ccb_trans_settings_spi
*spi
= &cts
->xport_specific
.spi
;
2107 cts
->protocol
= PROTO_SCSI
;
2108 cts
->protocol_version
= SCSI_REV_2
;
2109 cts
->transport
= XPORT_SPI
;
2110 cts
->transport_version
= 2;
2117 bus
= cam_sim_bus(sim
);
2118 target
= cts
->ccb_h
.target_id
;
2119 debug(2, "XPT_GET_TRAN_SETTINGS %d:%d", bus
, target
);
2120 /* logical device? */
2121 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2122 /* nothing special for these */
2123 /* physical device? */
2124 } else if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PHYSICAL
) {
2125 /* allow CAM to try tagged transactions */
2126 scsi
->flags
|= CTS_SCSI_FLAGS_TAG_ENB
;
2127 scsi
->valid
|= CTS_SCSI_VALID_TQ
;
2129 /* convert speed (MHz) to usec */
2130 if (sc
->mly_btl
[bus
][target
].mb_speed
== 0) {
2131 spi
->sync_period
= 1000000 / 5;
2133 spi
->sync_period
= 1000000 / sc
->mly_btl
[bus
][target
].mb_speed
;
2136 /* convert bus width to CAM internal encoding */
2137 switch (sc
->mly_btl
[bus
][target
].mb_width
) {
2139 spi
->bus_width
= MSG_EXT_WDTR_BUS_32_BIT
;
2142 spi
->bus_width
= MSG_EXT_WDTR_BUS_16_BIT
;
2146 spi
->bus_width
= MSG_EXT_WDTR_BUS_8_BIT
;
2149 spi
->valid
|= CTS_SPI_VALID_SYNC_RATE
| CTS_SPI_VALID_BUS_WIDTH
;
2151 /* not a device, bail out */
2153 cts
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2157 /* disconnect always OK */
2158 spi
->flags
|= CTS_SPI_FLAGS_DISC_ENB
;
2159 spi
->valid
|= CTS_SPI_VALID_DISC
;
2161 cts
->ccb_h
.status
= CAM_REQ_CMP
;
2165 default: /* we can't do this */
2166 debug(2, "unsupported func_code = 0x%x", ccb
->ccb_h
.func_code
);
2167 ccb
->ccb_h
.status
= CAM_REQ_INVALID
;
2174 /********************************************************************************
2175 * Handle an I/O operation requested by CAM
2178 mly_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
)
2180 struct mly_softc
*sc
= cam_sim_softc(sim
);
2181 struct mly_command
*mc
;
2182 struct mly_command_scsi_small
*ss
;
2186 bus
= cam_sim_bus(sim
);
2187 target
= csio
->ccb_h
.target_id
;
2189 debug(2, "XPT_SCSI_IO %d:%d:%d", bus
, target
, csio
->ccb_h
.target_lun
);
2191 /* validate bus number */
2192 if (!MLY_BUS_IS_VALID(sc
, bus
)) {
2193 debug(0, " invalid bus %d", bus
);
2194 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2197 /* check for I/O attempt to a protected device */
2198 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PROTECTED
) {
2199 debug(2, " device protected");
2200 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2203 /* check for I/O attempt to nonexistent device */
2204 if (!(sc
->mly_btl
[bus
][target
].mb_flags
& (MLY_BTL_LOGICAL
| MLY_BTL_PHYSICAL
))) {
2205 debug(2, " device %d:%d does not exist", bus
, target
);
2206 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2209 /* XXX increase if/when we support large SCSI commands */
2210 if (csio
->cdb_len
> MLY_CMD_SCSI_SMALL_CDB
) {
2211 debug(0, " command too large (%d > %d)", csio
->cdb_len
, MLY_CMD_SCSI_SMALL_CDB
);
2212 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2215 /* check that the CDB pointer is not to a physical address */
2216 if ((csio
->ccb_h
.flags
& CAM_CDB_POINTER
) && (csio
->ccb_h
.flags
& CAM_CDB_PHYS
)) {
2217 debug(0, " CDB pointer is to physical address");
2218 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2221 /* if there is data transfer, it must be to/from a virtual address */
2222 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) != CAM_DIR_NONE
) {
2223 if (csio
->ccb_h
.flags
& CAM_DATA_PHYS
) { /* we can't map it */
2224 debug(0, " data pointer is to physical address");
2225 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2227 if (csio
->ccb_h
.flags
& CAM_SCATTER_VALID
) { /* we want to do the s/g setup */
2228 debug(0, " data has premature s/g setup");
2229 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2233 /* abandon aborted ccbs or those that have failed validation */
2234 if ((csio
->ccb_h
.status
& CAM_STATUS_MASK
) != CAM_REQ_INPROG
) {
2235 debug(2, "abandoning CCB due to abort/validation failure");
2240 * Get a command, or push the ccb back to CAM and freeze the queue.
2242 if ((error
= mly_alloc_command(sc
, &mc
))) {
2244 xpt_freeze_simq(sim
, 1);
2245 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2246 sc
->mly_qfrzn_cnt
++;
2251 /* build the command */
2252 mc
->mc_data
= csio
->data_ptr
;
2253 mc
->mc_length
= csio
->dxfer_len
;
2254 mc
->mc_complete
= mly_cam_complete
;
2255 mc
->mc_private
= csio
;
2257 /* save the bus number in the ccb for later recovery XXX should be a better way */
2258 csio
->ccb_h
.sim_priv
.entries
[0].field
= bus
;
2260 /* build the packet for the controller */
2261 ss
= &mc
->mc_packet
->scsi_small
;
2262 ss
->opcode
= MDACMD_SCSI
;
2263 if (csio
->ccb_h
.flags
& CAM_DIS_DISCONNECT
)
2264 ss
->command_control
.disable_disconnect
= 1;
2265 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) == CAM_DIR_OUT
)
2266 ss
->command_control
.data_direction
= MLY_CCB_WRITE
;
2267 ss
->data_size
= csio
->dxfer_len
;
2268 ss
->addr
.phys
.lun
= csio
->ccb_h
.target_lun
;
2269 ss
->addr
.phys
.target
= csio
->ccb_h
.target_id
;
2270 ss
->addr
.phys
.channel
= bus
;
2271 if (csio
->ccb_h
.timeout
< (60 * 1000)) {
2272 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ 1000;
2273 ss
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
2274 } else if (csio
->ccb_h
.timeout
< (60 * 60 * 1000)) {
2275 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ (60 * 1000);
2276 ss
->timeout
.scale
= MLY_TIMEOUT_MINUTES
;
2278 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ (60 * 60 * 1000); /* overflow? */
2279 ss
->timeout
.scale
= MLY_TIMEOUT_HOURS
;
2281 ss
->maximum_sense_size
= csio
->sense_len
;
2282 ss
->cdb_length
= csio
->cdb_len
;
2283 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2284 bcopy(csio
->cdb_io
.cdb_ptr
, ss
->cdb
, csio
->cdb_len
);
2286 bcopy(csio
->cdb_io
.cdb_bytes
, ss
->cdb
, csio
->cdb_len
);
2289 /* give the command to the controller */
2290 if ((error
= mly_start(mc
))) {
2292 xpt_freeze_simq(sim
, 1);
2293 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2294 sc
->mly_qfrzn_cnt
++;
2302 /********************************************************************************
2303 * Check for possibly-completed commands.
2306 mly_cam_poll(struct cam_sim
*sim
)
2308 struct mly_softc
*sc
= cam_sim_softc(sim
);
2315 /********************************************************************************
2316 * Handle completion of a command - pass results back through the CCB
2319 mly_cam_complete(struct mly_command
*mc
)
2321 struct mly_softc
*sc
= mc
->mc_sc
;
2322 struct ccb_scsiio
*csio
= (struct ccb_scsiio
*)mc
->mc_private
;
2323 struct scsi_inquiry_data
*inq
= (struct scsi_inquiry_data
*)csio
->data_ptr
;
2324 struct mly_btl
*btl
;
2330 csio
->scsi_status
= mc
->mc_status
;
2331 switch(mc
->mc_status
) {
2332 case SCSI_STATUS_OK
:
2334 * In order to report logical device type and status, we overwrite
2335 * the result of the INQUIRY command to logical devices.
2337 bus
= csio
->ccb_h
.sim_priv
.entries
[0].field
;
2338 target
= csio
->ccb_h
.target_id
;
2339 /* XXX validate bus/target? */
2340 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2341 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2342 cmd
= *csio
->cdb_io
.cdb_ptr
;
2344 cmd
= csio
->cdb_io
.cdb_bytes
[0];
2346 if (cmd
== INQUIRY
) {
2347 btl
= &sc
->mly_btl
[bus
][target
];
2348 padstr(inq
->vendor
, mly_describe_code(mly_table_device_type
, btl
->mb_type
), 8);
2349 padstr(inq
->product
, mly_describe_code(mly_table_device_state
, btl
->mb_state
), 16);
2350 padstr(inq
->revision
, "MYLX", 4);
2354 debug(2, "SCSI_STATUS_OK");
2355 csio
->ccb_h
.status
= CAM_REQ_CMP
;
2358 case SCSI_STATUS_CHECK_COND
:
2359 debug(1, "SCSI_STATUS_CHECK_COND sense %d resid %d", mc
->mc_sense
, mc
->mc_resid
);
2360 csio
->ccb_h
.status
= CAM_SCSI_STATUS_ERROR
;
2361 bzero(&csio
->sense_data
, SSD_FULL_SIZE
);
2362 bcopy(mc
->mc_packet
, &csio
->sense_data
, mc
->mc_sense
);
2363 csio
->sense_len
= mc
->mc_sense
;
2364 csio
->ccb_h
.status
|= CAM_AUTOSNS_VALID
;
2365 csio
->resid
= mc
->mc_resid
; /* XXX this is a signed value... */
2368 case SCSI_STATUS_BUSY
:
2369 debug(1, "SCSI_STATUS_BUSY");
2370 csio
->ccb_h
.status
= CAM_SCSI_BUSY
;
2374 debug(1, "unknown status 0x%x", csio
->scsi_status
);
2375 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2380 if (sc
->mly_qfrzn_cnt
) {
2381 csio
->ccb_h
.status
|= CAM_RELEASE_SIMQ
;
2382 sc
->mly_qfrzn_cnt
--;
2386 xpt_done((union ccb
*)csio
);
2387 mly_release_command(mc
);
2390 /********************************************************************************
2391 * Find a peripheral attahed at (bus),(target)
2393 static struct cam_periph
*
2394 mly_find_periph(struct mly_softc
*sc
, int bus
, int target
)
2396 struct cam_periph
*periph
;
2397 struct cam_path
*path
;
2400 status
= xpt_create_path(&path
, NULL
, cam_sim_path(sc
->mly_cam_sim
[bus
]), target
, 0);
2401 if (status
== CAM_REQ_CMP
) {
2402 periph
= cam_periph_find(path
, NULL
);
2403 xpt_free_path(path
);
2410 /********************************************************************************
2411 * Name the device at (bus)(target)
2414 mly_name_device(struct mly_softc
*sc
, int bus
, int target
)
2416 struct cam_periph
*periph
;
2418 if ((periph
= mly_find_periph(sc
, bus
, target
)) != NULL
) {
2419 ksprintf(sc
->mly_btl
[bus
][target
].mb_name
, "%s%d", periph
->periph_name
, periph
->unit_number
);
2422 sc
->mly_btl
[bus
][target
].mb_name
[0] = 0;
2426 /********************************************************************************
2427 ********************************************************************************
2429 ********************************************************************************
2430 ********************************************************************************/
2432 /********************************************************************************
2433 * Handshake with the firmware while the card is being initialised.
2436 mly_fwhandshake(struct mly_softc
*sc
)
2438 u_int8_t error
, param0
, param1
;
2443 /* set HM_STSACK and let the firmware initialise */
2444 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_STSACK
);
2445 DELAY(1000); /* too short? */
2447 /* if HM_STSACK is still true, the controller is initialising */
2448 if (!MLY_IDBR_TRUE(sc
, MLY_HM_STSACK
))
2450 mly_printf(sc
, "controller initialisation started\n");
2452 /* spin waiting for initialisation to finish, or for a message to be delivered */
2453 while (MLY_IDBR_TRUE(sc
, MLY_HM_STSACK
)) {
2454 /* check for a message */
2455 if (MLY_ERROR_VALID(sc
)) {
2456 error
= MLY_GET_REG(sc
, sc
->mly_error_status
) & ~MLY_MSG_EMPTY
;
2457 param0
= MLY_GET_REG(sc
, sc
->mly_command_mailbox
);
2458 param1
= MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 1);
2461 case MLY_MSG_SPINUP
:
2463 mly_printf(sc
, "drive spinup in progress\n");
2464 spinup
= 1; /* only print this once (should print drive being spun?) */
2467 case MLY_MSG_RACE_RECOVERY_FAIL
:
2468 mly_printf(sc
, "mirror race recovery failed, one or more drives offline\n");
2470 case MLY_MSG_RACE_IN_PROGRESS
:
2471 mly_printf(sc
, "mirror race recovery in progress\n");
2473 case MLY_MSG_RACE_ON_CRITICAL
:
2474 mly_printf(sc
, "mirror race recovery on a critical drive\n");
2476 case MLY_MSG_PARITY_ERROR
:
2477 mly_printf(sc
, "FATAL MEMORY PARITY ERROR\n");
2480 mly_printf(sc
, "unknown initialisation code 0x%x\n", error
);
2487 /********************************************************************************
2488 ********************************************************************************
2489 Debugging and Diagnostics
2490 ********************************************************************************
2491 ********************************************************************************/
2493 /********************************************************************************
2494 * Print some information about the controller.
2497 mly_describe_controller(struct mly_softc
*sc
)
2499 struct mly_ioctl_getcontrollerinfo
*mi
= sc
->mly_controllerinfo
;
2501 mly_printf(sc
, "%16s, %d channel%s, firmware %d.%02d-%d-%02d (%02d%02d%02d%02d), %dMB RAM\n",
2502 mi
->controller_name
, mi
->physical_channels_present
, (mi
->physical_channels_present
) > 1 ? "s" : "",
2503 mi
->fw_major
, mi
->fw_minor
, mi
->fw_turn
, mi
->fw_build
, /* XXX turn encoding? */
2504 mi
->fw_century
, mi
->fw_year
, mi
->fw_month
, mi
->fw_day
,
2508 mly_printf(sc
, "%s %s (%x), %dMHz %d-bit %.16s\n",
2509 mly_describe_code(mly_table_oemname
, mi
->oem_information
),
2510 mly_describe_code(mly_table_controllertype
, mi
->controller_type
), mi
->controller_type
,
2511 mi
->interface_speed
, mi
->interface_width
, mi
->interface_name
);
2512 mly_printf(sc
, "%dMB %dMHz %d-bit %s%s%s, cache %dMB\n",
2513 mi
->memory_size
, mi
->memory_speed
, mi
->memory_width
,
2514 mly_describe_code(mly_table_memorytype
, mi
->memory_type
),
2515 mi
->memory_parity
? "+parity": "",mi
->memory_ecc
? "+ECC": "",
2517 mly_printf(sc
, "CPU: %s @ %dMHz\n",
2518 mly_describe_code(mly_table_cputype
, mi
->cpu
[0].type
), mi
->cpu
[0].speed
);
2519 if (mi
->l2cache_size
!= 0)
2520 mly_printf(sc
, "%dKB L2 cache\n", mi
->l2cache_size
);
2521 if (mi
->exmemory_size
!= 0)
2522 mly_printf(sc
, "%dMB %dMHz %d-bit private %s%s%s\n",
2523 mi
->exmemory_size
, mi
->exmemory_speed
, mi
->exmemory_width
,
2524 mly_describe_code(mly_table_memorytype
, mi
->exmemory_type
),
2525 mi
->exmemory_parity
? "+parity": "",mi
->exmemory_ecc
? "+ECC": "");
2526 mly_printf(sc
, "battery backup %s\n", mi
->bbu_present
? "present" : "not installed");
2527 mly_printf(sc
, "maximum data transfer %d blocks, maximum sg entries/command %d\n",
2528 mi
->maximum_block_count
, mi
->maximum_sg_entries
);
2529 mly_printf(sc
, "logical devices present/critical/offline %d/%d/%d\n",
2530 mi
->logical_devices_present
, mi
->logical_devices_critical
, mi
->logical_devices_offline
);
2531 mly_printf(sc
, "physical devices present %d\n",
2532 mi
->physical_devices_present
);
2533 mly_printf(sc
, "physical disks present/offline %d/%d\n",
2534 mi
->physical_disks_present
, mi
->physical_disks_offline
);
2535 mly_printf(sc
, "%d physical channel%s, %d virtual channel%s of %d possible\n",
2536 mi
->physical_channels_present
, mi
->physical_channels_present
== 1 ? "" : "s",
2537 mi
->virtual_channels_present
, mi
->virtual_channels_present
== 1 ? "" : "s",
2538 mi
->virtual_channels_possible
);
2539 mly_printf(sc
, "%d parallel commands supported\n", mi
->maximum_parallel_commands
);
2540 mly_printf(sc
, "%dMB flash ROM, %d of %d maximum cycles\n",
2541 mi
->flash_size
, mi
->flash_age
, mi
->flash_maximum_age
);
2546 /********************************************************************************
2547 * Print some controller state
2550 mly_printstate(struct mly_softc
*sc
)
2552 mly_printf(sc
, "IDBR %02x ODBR %02x ERROR %02x (%x %x %x)\n",
2553 MLY_GET_REG(sc
, sc
->mly_idbr
),
2554 MLY_GET_REG(sc
, sc
->mly_odbr
),
2555 MLY_GET_REG(sc
, sc
->mly_error_status
),
2558 sc
->mly_error_status
);
2559 mly_printf(sc
, "IMASK %02x ISTATUS %02x\n",
2560 MLY_GET_REG(sc
, sc
->mly_interrupt_mask
),
2561 MLY_GET_REG(sc
, sc
->mly_interrupt_status
));
2562 mly_printf(sc
, "COMMAND %02x %02x %02x %02x %02x %02x %02x %02x\n",
2563 MLY_GET_REG(sc
, sc
->mly_command_mailbox
),
2564 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 1),
2565 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 2),
2566 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 3),
2567 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 4),
2568 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 5),
2569 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 6),
2570 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 7));
2571 mly_printf(sc
, "STATUS %02x %02x %02x %02x %02x %02x %02x %02x\n",
2572 MLY_GET_REG(sc
, sc
->mly_status_mailbox
),
2573 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 1),
2574 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 2),
2575 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 3),
2576 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 4),
2577 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 5),
2578 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 6),
2579 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 7));
2580 mly_printf(sc
, " %04x %08x\n",
2581 MLY_GET_REG2(sc
, sc
->mly_status_mailbox
),
2582 MLY_GET_REG4(sc
, sc
->mly_status_mailbox
+ 4));
2585 struct mly_softc
*mly_softc0
= NULL
;
2587 mly_printstate0(void)
2589 if (mly_softc0
!= NULL
)
2590 mly_printstate(mly_softc0
);
2593 /********************************************************************************
2597 mly_print_command(struct mly_command
*mc
)
2599 struct mly_softc
*sc
= mc
->mc_sc
;
2601 mly_printf(sc
, "COMMAND @ %p\n", mc
);
2602 mly_printf(sc
, " slot %d\n", mc
->mc_slot
);
2603 mly_printf(sc
, " status 0x%x\n", mc
->mc_status
);
2604 mly_printf(sc
, " sense len %d\n", mc
->mc_sense
);
2605 mly_printf(sc
, " resid %d\n", mc
->mc_resid
);
2606 mly_printf(sc
, " packet %p/0x%llx\n", mc
->mc_packet
, mc
->mc_packetphys
);
2607 if (mc
->mc_packet
!= NULL
)
2608 mly_print_packet(mc
);
2609 mly_printf(sc
, " data %p/%d\n", mc
->mc_data
, mc
->mc_length
);
2610 mly_printf(sc
, " flags %pb%i\n",
2611 "\20\1busy\2complete\3slotted\4mapped\5datain\6dataout\n",
2613 mly_printf(sc
, " complete %p\n", mc
->mc_complete
);
2614 mly_printf(sc
, " private %p\n", mc
->mc_private
);
2617 /********************************************************************************
2618 * Print a command packet
2621 mly_print_packet(struct mly_command
*mc
)
2623 struct mly_softc
*sc
= mc
->mc_sc
;
2624 struct mly_command_generic
*ge
= (struct mly_command_generic
*)mc
->mc_packet
;
2625 struct mly_command_scsi_small
*ss
= (struct mly_command_scsi_small
*)mc
->mc_packet
;
2626 struct mly_command_scsi_large
*sl
= (struct mly_command_scsi_large
*)mc
->mc_packet
;
2627 struct mly_command_ioctl
*io
= (struct mly_command_ioctl
*)mc
->mc_packet
;
2629 char hexstr
[HEX_NCPYLEN(MLY_CMD_SCSI_SMALL_CDB
)];
2631 mly_printf(sc
, " command_id %d\n", ge
->command_id
);
2632 mly_printf(sc
, " opcode %d\n", ge
->opcode
);
2633 mly_printf(sc
, " command_control fua %d dpo %d est %d dd %s nas %d ddis %d\n",
2634 ge
->command_control
.force_unit_access
,
2635 ge
->command_control
.disable_page_out
,
2636 ge
->command_control
.extended_sg_table
,
2637 (ge
->command_control
.data_direction
== MLY_CCB_WRITE
) ? "WRITE" : "READ",
2638 ge
->command_control
.no_auto_sense
,
2639 ge
->command_control
.disable_disconnect
);
2640 mly_printf(sc
, " data_size %d\n", ge
->data_size
);
2641 mly_printf(sc
, " sense_buffer_address 0x%llx\n", ge
->sense_buffer_address
);
2642 mly_printf(sc
, " lun %d\n", ge
->addr
.phys
.lun
);
2643 mly_printf(sc
, " target %d\n", ge
->addr
.phys
.target
);
2644 mly_printf(sc
, " channel %d\n", ge
->addr
.phys
.channel
);
2645 mly_printf(sc
, " logical device %d\n", ge
->addr
.log
.logdev
);
2646 mly_printf(sc
, " controller %d\n", ge
->addr
.phys
.controller
);
2647 mly_printf(sc
, " timeout %d %s\n",
2649 (ge
->timeout
.scale
== MLY_TIMEOUT_SECONDS
) ? "seconds" :
2650 ((ge
->timeout
.scale
== MLY_TIMEOUT_MINUTES
) ? "minutes" : "hours"));
2651 mly_printf(sc
, " maximum_sense_size %d\n", ge
->maximum_sense_size
);
2652 switch(ge
->opcode
) {
2655 mly_printf(sc
, " cdb length %d\n", ss
->cdb_length
);
2656 mly_printf(sc
, " cdb %s\n",
2657 hexncpy(ss
->cdb
, ss
->cdb_length
, hexstr
, HEX_NCPYLEN(ss
->cdb_length
), " "));
2661 case MDACMD_SCSILCPT
:
2662 mly_printf(sc
, " cdb length %d\n", sl
->cdb_length
);
2663 mly_printf(sc
, " cdb 0x%llx\n", sl
->cdb_physaddr
);
2667 mly_printf(sc
, " sub_ioctl 0x%x\n", io
->sub_ioctl
);
2668 switch(io
->sub_ioctl
) {
2669 case MDACIOCTL_SETMEMORYMAILBOX
:
2670 mly_printf(sc
, " health_buffer_size %d\n",
2671 io
->param
.setmemorymailbox
.health_buffer_size
);
2672 mly_printf(sc
, " health_buffer_phys 0x%llx\n",
2673 io
->param
.setmemorymailbox
.health_buffer_physaddr
);
2674 mly_printf(sc
, " command_mailbox 0x%llx\n",
2675 io
->param
.setmemorymailbox
.command_mailbox_physaddr
);
2676 mly_printf(sc
, " status_mailbox 0x%llx\n",
2677 io
->param
.setmemorymailbox
.status_mailbox_physaddr
);
2681 case MDACIOCTL_SETREALTIMECLOCK
:
2682 case MDACIOCTL_GETHEALTHSTATUS
:
2683 case MDACIOCTL_GETCONTROLLERINFO
:
2684 case MDACIOCTL_GETLOGDEVINFOVALID
:
2685 case MDACIOCTL_GETPHYSDEVINFOVALID
:
2686 case MDACIOCTL_GETPHYSDEVSTATISTICS
:
2687 case MDACIOCTL_GETLOGDEVSTATISTICS
:
2688 case MDACIOCTL_GETCONTROLLERSTATISTICS
:
2689 case MDACIOCTL_GETBDT_FOR_SYSDRIVE
:
2690 case MDACIOCTL_CREATENEWCONF
:
2691 case MDACIOCTL_ADDNEWCONF
:
2692 case MDACIOCTL_GETDEVCONFINFO
:
2693 case MDACIOCTL_GETFREESPACELIST
:
2694 case MDACIOCTL_MORE
:
2695 case MDACIOCTL_SETPHYSDEVPARAMETER
:
2696 case MDACIOCTL_GETPHYSDEVPARAMETER
:
2697 case MDACIOCTL_GETLOGDEVPARAMETER
:
2698 case MDACIOCTL_SETLOGDEVPARAMETER
:
2699 mly_printf(sc
, " param %10D\n", io
->param
.data
.param
, " ");
2703 case MDACIOCTL_GETEVENT
:
2704 mly_printf(sc
, " event %d\n",
2705 io
->param
.getevent
.sequence_number_low
+ ((u_int32_t
)io
->addr
.log
.logdev
<< 16));
2709 case MDACIOCTL_SETRAIDDEVSTATE
:
2710 mly_printf(sc
, " state %d\n", io
->param
.setraiddevstate
.state
);
2714 case MDACIOCTL_XLATEPHYSDEVTORAIDDEV
:
2715 mly_printf(sc
, " raid_device %d\n", io
->param
.xlatephysdevtoraiddev
.raid_device
);
2716 mly_printf(sc
, " controller %d\n", io
->param
.xlatephysdevtoraiddev
.controller
);
2717 mly_printf(sc
, " channel %d\n", io
->param
.xlatephysdevtoraiddev
.channel
);
2718 mly_printf(sc
, " target %d\n", io
->param
.xlatephysdevtoraiddev
.target
);
2719 mly_printf(sc
, " lun %d\n", io
->param
.xlatephysdevtoraiddev
.lun
);
2723 case MDACIOCTL_GETGROUPCONFINFO
:
2724 mly_printf(sc
, " group %d\n", io
->param
.getgroupconfinfo
.group
);
2728 case MDACIOCTL_GET_SUBSYSTEM_DATA
:
2729 case MDACIOCTL_SET_SUBSYSTEM_DATA
:
2730 case MDACIOCTL_STARTDISOCVERY
:
2731 case MDACIOCTL_INITPHYSDEVSTART
:
2732 case MDACIOCTL_INITPHYSDEVSTOP
:
2733 case MDACIOCTL_INITRAIDDEVSTART
:
2734 case MDACIOCTL_INITRAIDDEVSTOP
:
2735 case MDACIOCTL_REBUILDRAIDDEVSTART
:
2736 case MDACIOCTL_REBUILDRAIDDEVSTOP
:
2737 case MDACIOCTL_MAKECONSISTENTDATASTART
:
2738 case MDACIOCTL_MAKECONSISTENTDATASTOP
:
2739 case MDACIOCTL_CONSISTENCYCHECKSTART
:
2740 case MDACIOCTL_CONSISTENCYCHECKSTOP
:
2741 case MDACIOCTL_RESETDEVICE
:
2742 case MDACIOCTL_FLUSHDEVICEDATA
:
2743 case MDACIOCTL_PAUSEDEVICE
:
2744 case MDACIOCTL_UNPAUSEDEVICE
:
2745 case MDACIOCTL_LOCATEDEVICE
:
2746 case MDACIOCTL_SETMASTERSLAVEMODE
:
2747 case MDACIOCTL_DELETERAIDDEV
:
2748 case MDACIOCTL_REPLACEINTERNALDEV
:
2749 case MDACIOCTL_CLEARCONF
:
2750 case MDACIOCTL_GETCONTROLLERPARAMETER
:
2751 case MDACIOCTL_SETCONTRLLERPARAMETER
:
2752 case MDACIOCTL_CLEARCONFSUSPMODE
:
2753 case MDACIOCTL_STOREIMAGE
:
2754 case MDACIOCTL_READIMAGE
:
2755 case MDACIOCTL_FLASHIMAGES
:
2756 case MDACIOCTL_RENAMERAIDDEV
:
2757 default: /* no idea what to print */
2763 case MDACMD_IOCTLCHECK
:
2764 case MDACMD_MEMCOPY
:
2767 break; /* print nothing */
2770 if (ge
->command_control
.extended_sg_table
) {
2771 mly_printf(sc
, " sg table 0x%llx/%d\n",
2772 ge
->transfer
.indirect
.table_physaddr
[0], ge
->transfer
.indirect
.entries
[0]);
2774 mly_printf(sc
, " 0000 0x%llx/%lld\n",
2775 ge
->transfer
.direct
.sg
[0].physaddr
, ge
->transfer
.direct
.sg
[0].length
);
2776 mly_printf(sc
, " 0001 0x%llx/%lld\n",
2777 ge
->transfer
.direct
.sg
[1].physaddr
, ge
->transfer
.direct
.sg
[1].length
);
2782 /********************************************************************************
2783 * Panic in a slightly informative fashion
2786 mly_panic(struct mly_softc
*sc
, char *reason
)
2792 /********************************************************************************
2793 * Print queue statistics, callable from DDB.
2796 mly_print_controller(int controller
)
2798 struct mly_softc
*sc
;
2800 if ((sc
= devclass_get_softc(devclass_find("mly"), controller
)) == NULL
) {
2801 kprintf("mly: controller %d invalid\n", controller
);
2803 device_printf(sc
->mly_dev
, "queue curr max\n");
2804 device_printf(sc
->mly_dev
, "free %04d/%04d\n",
2805 sc
->mly_qstat
[MLYQ_FREE
].q_length
, sc
->mly_qstat
[MLYQ_FREE
].q_max
);
2806 device_printf(sc
->mly_dev
, "busy %04d/%04d\n",
2807 sc
->mly_qstat
[MLYQ_BUSY
].q_length
, sc
->mly_qstat
[MLYQ_BUSY
].q_max
);
2808 device_printf(sc
->mly_dev
, "complete %04d/%04d\n",
2809 sc
->mly_qstat
[MLYQ_COMPLETE
].q_length
, sc
->mly_qstat
[MLYQ_COMPLETE
].q_max
);
2815 /********************************************************************************
2816 ********************************************************************************
2817 Control device interface
2818 ********************************************************************************
2819 ********************************************************************************/
2821 /********************************************************************************
2822 * Accept an open operation on the control device.
2825 mly_user_open(struct dev_open_args
*ap
)
2827 cdev_t dev
= ap
->a_head
.a_dev
;
2828 int unit
= minor(dev
);
2829 struct mly_softc
*sc
= devclass_get_softc(devclass_find("mly"), unit
);
2831 sc
->mly_state
|= MLY_STATE_OPEN
;
2835 /********************************************************************************
2836 * Accept the last close on the control device.
2839 mly_user_close(struct dev_close_args
*ap
)
2841 cdev_t dev
= ap
->a_head
.a_dev
;
2842 int unit
= minor(dev
);
2843 struct mly_softc
*sc
= devclass_get_softc(devclass_find("mly"), unit
);
2845 sc
->mly_state
&= ~MLY_STATE_OPEN
;
2849 /********************************************************************************
2850 * Handle controller-specific control operations.
2853 mly_user_ioctl(struct dev_ioctl_args
*ap
)
2855 cdev_t dev
= ap
->a_head
.a_dev
;
2856 caddr_t addr
= ap
->a_data
;
2857 u_long cmd
= ap
->a_cmd
;
2858 struct mly_softc
*sc
= (struct mly_softc
*)dev
->si_drv1
;
2859 struct mly_user_command
*uc
= (struct mly_user_command
*)addr
;
2860 struct mly_user_health
*uh
= (struct mly_user_health
*)addr
;
2864 return(mly_user_command(sc
, uc
));
2866 return(mly_user_health(sc
, uh
));
2872 /********************************************************************************
2873 * Execute a command passed in from userspace.
2875 * The control structure contains the actual command for the controller, as well
2876 * as the user-space data pointer and data size, and an optional sense buffer
2877 * size/pointer. On completion, the data size is adjusted to the command
2878 * residual, and the sense buffer size to the size of the returned sense data.
2882 mly_user_command(struct mly_softc
*sc
, struct mly_user_command
*uc
)
2884 struct mly_command
*mc
;
2887 /* allocate a command */
2888 if (mly_alloc_command(sc
, &mc
)) {
2890 goto out
; /* XXX Linux version will wait for a command */
2893 /* handle data size/direction */
2894 mc
->mc_length
= (uc
->DataTransferLength
>= 0) ? uc
->DataTransferLength
: -uc
->DataTransferLength
;
2895 if (mc
->mc_length
> 0)
2896 mc
->mc_data
= kmalloc(mc
->mc_length
, M_DEVBUF
, M_INTWAIT
);
2897 if (uc
->DataTransferLength
> 0) {
2898 mc
->mc_flags
|= MLY_CMD_DATAIN
;
2899 bzero(mc
->mc_data
, mc
->mc_length
);
2901 if (uc
->DataTransferLength
< 0) {
2902 mc
->mc_flags
|= MLY_CMD_DATAOUT
;
2903 if ((error
= copyin(uc
->DataTransferBuffer
, mc
->mc_data
, mc
->mc_length
)) != 0)
2907 /* copy the controller command */
2908 bcopy(&uc
->CommandMailbox
, mc
->mc_packet
, sizeof(uc
->CommandMailbox
));
2910 /* clear command completion handler so that we get woken up */
2911 mc
->mc_complete
= NULL
;
2913 /* execute the command */
2914 if ((error
= mly_start(mc
)) != 0)
2917 while (!(mc
->mc_flags
& MLY_CMD_COMPLETE
))
2918 tsleep(mc
, 0, "mlyioctl", 0);
2921 /* return the data to userspace */
2922 if (uc
->DataTransferLength
> 0)
2923 if ((error
= copyout(mc
->mc_data
, uc
->DataTransferBuffer
, mc
->mc_length
)) != 0)
2926 /* return the sense buffer to userspace */
2927 if ((uc
->RequestSenseLength
> 0) && (mc
->mc_sense
> 0)) {
2928 if ((error
= copyout(mc
->mc_packet
, uc
->RequestSenseBuffer
,
2929 min(uc
->RequestSenseLength
, mc
->mc_sense
))) != 0)
2933 /* return command results to userspace (caller will copy out) */
2934 uc
->DataTransferLength
= mc
->mc_resid
;
2935 uc
->RequestSenseLength
= min(uc
->RequestSenseLength
, mc
->mc_sense
);
2936 uc
->CommandStatus
= mc
->mc_status
;
2940 if (mc
->mc_data
!= NULL
)
2941 kfree(mc
->mc_data
, M_DEVBUF
);
2943 mly_release_command(mc
);
2947 /********************************************************************************
2948 * Return health status to userspace. If the health change index in the user
2949 * structure does not match that currently exported by the controller, we
2950 * return the current status immediately. Otherwise, we block until either
2951 * interrupted or new status is delivered.
2954 mly_user_health(struct mly_softc
*sc
, struct mly_user_health
*uh
)
2956 struct mly_health_status mh
;
2959 /* fetch the current health status from userspace */
2960 if ((error
= copyin(uh
->HealthStatusBuffer
, &mh
, sizeof(mh
))) != 0)
2963 /* spin waiting for a status update */
2965 error
= EWOULDBLOCK
;
2966 while ((error
!= 0) && (sc
->mly_event_change
== mh
.change_counter
))
2967 error
= tsleep(&sc
->mly_event_change
, PCATCH
, "mlyhealth", 0);
2970 /* copy the controller's health status buffer out (there is a race here if it changes again) */
2971 error
= copyout(&sc
->mly_mmbox
->mmm_health
.status
, uh
->HealthStatusBuffer
,
2972 sizeof(uh
->HealthStatusBuffer
));
2978 mly_timeout(struct mly_softc
*sc
)
2980 struct mly_command
*mc
;
2983 deadline
= time_uptime
- MLY_CMD_TIMEOUT
;
2984 TAILQ_FOREACH(mc
, &sc
->mly_busy
, mc_link
) {
2985 if ((mc
->mc_timestamp
< deadline
)) {
2986 device_printf(sc
->mly_dev
,
2987 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", mc
,
2988 (int)(time_uptime
- mc
->mc_timestamp
));
2992 callout_reset(&sc
->mly_timeout
, MLY_CMD_TIMEOUT
* hz
,
2993 (timeout_t
*)mly_timeout
, sc
);