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.3.2.3 2001/03/05 20:17:24 msmith Exp $
28 * $DragonFly: src/sys/dev/raid/mly/mly.c,v 1.19 2008/01/21 02:27:37 pavalos Exp $
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/malloc.h>
34 #include <sys/kernel.h>
37 #include <sys/device.h>
38 #include <sys/ctype.h>
39 #include <sys/ioccom.h>
42 #include <sys/thread2.h>
44 #include <bus/cam/cam.h>
45 #include <bus/cam/cam_ccb.h>
46 #include <bus/cam/cam_periph.h>
47 #include <bus/cam/cam_sim.h>
48 #include <bus/cam/cam_xpt_sim.h>
49 #include <bus/cam/scsi/scsi_all.h>
50 #include <bus/cam/scsi/scsi_message.h>
52 #include <bus/pci/pcireg.h>
53 #include <bus/pci/pcivar.h>
58 #include "mly_tables.h"
60 static int mly_probe(device_t dev
);
61 static int mly_attach(device_t dev
);
62 static int mly_pci_attach(struct mly_softc
*sc
);
63 static int mly_detach(device_t dev
);
64 static int mly_shutdown(device_t dev
);
65 static void mly_intr(void *arg
);
67 static int mly_sg_map(struct mly_softc
*sc
);
68 static void mly_sg_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
);
69 static int mly_mmbox_map(struct mly_softc
*sc
);
70 static void mly_mmbox_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
);
71 static void mly_free(struct mly_softc
*sc
);
73 static int mly_get_controllerinfo(struct mly_softc
*sc
);
74 static void mly_scan_devices(struct mly_softc
*sc
);
75 static void mly_rescan_btl(struct mly_softc
*sc
, int bus
, int target
);
76 static void mly_complete_rescan(struct mly_command
*mc
);
77 static int mly_get_eventstatus(struct mly_softc
*sc
);
78 static int mly_enable_mmbox(struct mly_softc
*sc
);
79 static int mly_flush(struct mly_softc
*sc
);
80 static int mly_ioctl(struct mly_softc
*sc
, struct mly_command_ioctl
*ioctl
, void **data
,
81 size_t datasize
, u_int8_t
*status
, void *sense_buffer
, size_t *sense_length
);
82 static void mly_check_event(struct mly_softc
*sc
);
83 static void mly_fetch_event(struct mly_softc
*sc
);
84 static void mly_complete_event(struct mly_command
*mc
);
85 static void mly_process_event(struct mly_softc
*sc
, struct mly_event
*me
);
86 static void mly_periodic(void *data
);
88 static int mly_immediate_command(struct mly_command
*mc
);
89 static int mly_start(struct mly_command
*mc
);
90 static void mly_done(struct mly_softc
*sc
);
91 static void mly_complete(void *context
, int pending
);
93 static int mly_alloc_command(struct mly_softc
*sc
, struct mly_command
**mcp
);
94 static void mly_release_command(struct mly_command
*mc
);
95 static void mly_alloc_commands_map(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
);
96 static int mly_alloc_commands(struct mly_softc
*sc
);
97 static void mly_release_commands(struct mly_softc
*sc
);
98 static void mly_map_command(struct mly_command
*mc
);
99 static void mly_unmap_command(struct mly_command
*mc
);
101 static int mly_cam_attach(struct mly_softc
*sc
);
102 static void mly_cam_detach(struct mly_softc
*sc
);
103 static void mly_cam_rescan_btl(struct mly_softc
*sc
, int bus
, int target
);
104 static void mly_cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
);
105 static void mly_cam_action(struct cam_sim
*sim
, union ccb
*ccb
);
106 static int mly_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
);
107 static void mly_cam_poll(struct cam_sim
*sim
);
108 static void mly_cam_complete(struct mly_command
*mc
);
109 static struct cam_periph
*mly_find_periph(struct mly_softc
*sc
, int bus
, int target
);
110 static int mly_name_device(struct mly_softc
*sc
, int bus
, int target
);
112 static int mly_fwhandshake(struct mly_softc
*sc
);
114 static void mly_describe_controller(struct mly_softc
*sc
);
116 static void mly_printstate(struct mly_softc
*sc
);
117 static void mly_print_command(struct mly_command
*mc
);
118 static void mly_print_packet(struct mly_command
*mc
);
119 static void mly_panic(struct mly_softc
*sc
, char *reason
);
121 void mly_print_controller(int controller
);
122 static int mly_timeout(struct mly_softc
*sc
);
125 static d_open_t mly_user_open
;
126 static d_close_t mly_user_close
;
127 static d_ioctl_t mly_user_ioctl
;
128 static int mly_user_command(struct mly_softc
*sc
, struct mly_user_command
*uc
);
129 static int mly_user_health(struct mly_softc
*sc
, struct mly_user_health
*uh
);
131 #define MLY_CMD_TIMEOUT 20
133 static device_method_t mly_methods
[] = {
134 /* Device interface */
135 DEVMETHOD(device_probe
, mly_probe
),
136 DEVMETHOD(device_attach
, mly_attach
),
137 DEVMETHOD(device_detach
, mly_detach
),
138 DEVMETHOD(device_shutdown
, mly_shutdown
),
142 static driver_t mly_pci_driver
= {
145 sizeof(struct mly_softc
)
148 static devclass_t mly_devclass
;
149 DRIVER_MODULE(mly
, pci
, mly_pci_driver
, mly_devclass
, 0, 0);
151 #define MLY_CDEV_MAJOR 158
153 static struct dev_ops mly_ops
= {
154 { "mly", MLY_CDEV_MAJOR
, 0 },
155 .d_open
= mly_user_open
,
156 .d_close
= mly_user_close
,
157 .d_ioctl
= mly_user_ioctl
,
160 /********************************************************************************
161 ********************************************************************************
163 ********************************************************************************
164 ********************************************************************************/
166 static struct mly_ident
174 } mly_identifiers
[] = {
175 {0x1069, 0xba56, 0x1069, 0x0040, MLY_HWIF_STRONGARM
, "Mylex eXtremeRAID 2000"},
176 {0x1069, 0xba56, 0x1069, 0x0030, MLY_HWIF_STRONGARM
, "Mylex eXtremeRAID 3000"},
177 {0x1069, 0x0050, 0x1069, 0x0050, MLY_HWIF_I960RX
, "Mylex AcceleRAID 352"},
178 {0x1069, 0x0050, 0x1069, 0x0052, MLY_HWIF_I960RX
, "Mylex AcceleRAID 170"},
179 {0x1069, 0x0050, 0x1069, 0x0054, MLY_HWIF_I960RX
, "Mylex AcceleRAID 160"},
183 /********************************************************************************
184 * Compare the provided PCI device with the list we support.
187 mly_probe(device_t dev
)
193 for (m
= mly_identifiers
; m
->vendor
!= 0; m
++) {
194 if ((m
->vendor
== pci_get_vendor(dev
)) &&
195 (m
->device
== pci_get_device(dev
)) &&
196 ((m
->subvendor
== 0) || ((m
->subvendor
== pci_get_subvendor(dev
)) &&
197 (m
->subdevice
== pci_get_subdevice(dev
))))) {
199 device_set_desc(dev
, m
->desc
);
200 return(BUS_PROBE_DEFAULT
); /* allow room to be overridden */
206 /********************************************************************************
207 * Initialise the controller and softc
210 mly_attach(device_t dev
)
212 struct mly_softc
*sc
= device_get_softc(dev
);
220 if (device_get_unit(sc
->mly_dev
) == 0)
225 * Do PCI-specific initialisation.
227 if ((error
= mly_pci_attach(sc
)) != 0)
230 callout_init(&sc
->mly_periodic
);
231 callout_init(&sc
->mly_timeout
);
234 * Initialise per-controller queues.
238 mly_initq_complete(sc
);
241 * Initialise command-completion task.
243 TASK_INIT(&sc
->mly_task_complete
, 0, mly_complete
, sc
);
245 /* disable interrupts before we start talking to the controller */
246 MLY_MASK_INTERRUPTS(sc
);
249 * Wait for the controller to come ready, handshake with the firmware if required.
250 * This is typically only necessary on platforms where the controller BIOS does not
253 if ((error
= mly_fwhandshake(sc
)))
257 * Allocate initial command buffers.
259 if ((error
= mly_alloc_commands(sc
)))
263 * Obtain controller feature information
265 if ((error
= mly_get_controllerinfo(sc
)))
269 * Reallocate command buffers now we know how many we want.
271 mly_release_commands(sc
);
272 if ((error
= mly_alloc_commands(sc
)))
276 * Get the current event counter for health purposes, populate the initial
277 * health status buffer.
279 if ((error
= mly_get_eventstatus(sc
)))
283 * Enable memory-mailbox mode.
285 if ((error
= mly_enable_mmbox(sc
)))
291 if ((error
= mly_cam_attach(sc
)))
295 * Print a little information about the controller
297 mly_describe_controller(sc
);
300 * Mark all attached devices for rescan.
302 mly_scan_devices(sc
);
305 * Instigate the first status poll immediately. Rescan completions won't
306 * happen until interrupts are enabled, which should still be before
307 * the SCSI subsystem gets to us, courtesy of the "SCSI settling delay".
309 mly_periodic((void *)sc
);
312 * Create the control device.
314 dev_ops_add(&mly_ops
, -1, device_get_unit(sc
->mly_dev
));
315 sc
->mly_dev_t
= make_dev(&mly_ops
, device_get_unit(sc
->mly_dev
),
316 UID_ROOT
, GID_OPERATOR
, S_IRUSR
| S_IWUSR
,
317 "mly%d", device_get_unit(sc
->mly_dev
));
318 sc
->mly_dev_t
->si_drv1
= sc
;
320 /* enable interrupts now */
321 MLY_UNMASK_INTERRUPTS(sc
);
324 callout_reset(&sc
->mly_timeout
, MLY_CMD_TIMEOUT
* hz
,
325 (timeout_t
*)mly_timeout
, sc
);
334 /********************************************************************************
335 * Perform PCI-specific initialisation.
338 mly_pci_attach(struct mly_softc
*sc
)
345 /* assume failure is 'not configured' */
349 * Verify that the adapter is correctly set up in PCI space.
351 * XXX we shouldn't do this; the PCI code should.
353 command
= pci_read_config(sc
->mly_dev
, PCIR_COMMAND
, 2);
354 command
|= PCIM_CMD_BUSMASTEREN
;
355 pci_write_config(sc
->mly_dev
, PCIR_COMMAND
, command
, 2);
356 command
= pci_read_config(sc
->mly_dev
, PCIR_COMMAND
, 2);
357 if (!(command
& PCIM_CMD_BUSMASTEREN
)) {
358 mly_printf(sc
, "can't enable busmaster feature\n");
361 if ((command
& PCIM_CMD_MEMEN
) == 0) {
362 mly_printf(sc
, "memory window not available\n");
367 * Allocate the PCI register window.
369 sc
->mly_regs_rid
= PCIR_BAR(0); /* first base address register */
370 if ((sc
->mly_regs_resource
= bus_alloc_resource_any(sc
->mly_dev
,
371 SYS_RES_MEMORY
, &sc
->mly_regs_rid
, RF_ACTIVE
)) == NULL
) {
372 mly_printf(sc
, "can't allocate register window\n");
375 sc
->mly_btag
= rman_get_bustag(sc
->mly_regs_resource
);
376 sc
->mly_bhandle
= rman_get_bushandle(sc
->mly_regs_resource
);
379 * Allocate and connect our interrupt.
382 if ((sc
->mly_irq
= bus_alloc_resource_any(sc
->mly_dev
, SYS_RES_IRQ
,
383 &sc
->mly_irq_rid
, RF_SHAREABLE
| RF_ACTIVE
)) == NULL
) {
384 mly_printf(sc
, "can't allocate interrupt\n");
387 error
= bus_setup_intr(sc
->mly_dev
, sc
->mly_irq
, 0,
388 mly_intr
, sc
, &sc
->mly_intr
, NULL
);
390 mly_printf(sc
, "can't set up interrupt\n");
394 /* assume failure is 'out of memory' */
398 * Allocate the parent bus DMA tag appropriate for our PCI interface.
400 * Note that all of these controllers are 64-bit capable.
402 if (bus_dma_tag_create(NULL
, /* parent */
403 1, 0, /* alignment, boundary */
404 BUS_SPACE_MAXADDR_32BIT
, /* lowaddr */
405 BUS_SPACE_MAXADDR
, /* highaddr */
406 NULL
, NULL
, /* filter, filterarg */
407 MAXBSIZE
, MLY_MAX_SGENTRIES
, /* maxsize, nsegments */
408 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
409 BUS_DMA_ALLOCNOW
, /* flags */
410 &sc
->mly_parent_dmat
)) {
411 mly_printf(sc
, "can't allocate parent DMA tag\n");
416 * Create DMA tag for mapping buffers into controller-addressable space.
418 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
419 1, 0, /* alignment, boundary */
420 BUS_SPACE_MAXADDR
, /* lowaddr */
421 BUS_SPACE_MAXADDR
, /* highaddr */
422 NULL
, NULL
, /* filter, filterarg */
423 MAXBSIZE
, MLY_MAX_SGENTRIES
, /* maxsize, nsegments */
424 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
426 &sc
->mly_buffer_dmat
)) {
427 mly_printf(sc
, "can't allocate buffer DMA tag\n");
432 * Initialise the DMA tag for command packets.
434 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
435 1, 0, /* alignment, boundary */
436 BUS_SPACE_MAXADDR
, /* lowaddr */
437 BUS_SPACE_MAXADDR
, /* highaddr */
438 NULL
, NULL
, /* filter, filterarg */
439 sizeof(union mly_command_packet
) * MLY_MAX_COMMANDS
, 1, /* maxsize, nsegments */
440 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
441 BUS_DMA_ALLOCNOW
, /* flags */
442 &sc
->mly_packet_dmat
)) {
443 mly_printf(sc
, "can't allocate command packet DMA tag\n");
448 * Detect the hardware interface version
450 for (i
= 0; mly_identifiers
[i
].vendor
!= 0; i
++) {
451 if ((mly_identifiers
[i
].vendor
== pci_get_vendor(sc
->mly_dev
)) &&
452 (mly_identifiers
[i
].device
== pci_get_device(sc
->mly_dev
))) {
453 sc
->mly_hwif
= mly_identifiers
[i
].hwif
;
454 switch(sc
->mly_hwif
) {
455 case MLY_HWIF_I960RX
:
456 debug(1, "set hardware up for i960RX");
457 sc
->mly_doorbell_true
= 0x00;
458 sc
->mly_command_mailbox
= MLY_I960RX_COMMAND_MAILBOX
;
459 sc
->mly_status_mailbox
= MLY_I960RX_STATUS_MAILBOX
;
460 sc
->mly_idbr
= MLY_I960RX_IDBR
;
461 sc
->mly_odbr
= MLY_I960RX_ODBR
;
462 sc
->mly_error_status
= MLY_I960RX_ERROR_STATUS
;
463 sc
->mly_interrupt_status
= MLY_I960RX_INTERRUPT_STATUS
;
464 sc
->mly_interrupt_mask
= MLY_I960RX_INTERRUPT_MASK
;
466 case MLY_HWIF_STRONGARM
:
467 debug(1, "set hardware up for StrongARM");
468 sc
->mly_doorbell_true
= 0xff; /* doorbell 'true' is 0 */
469 sc
->mly_command_mailbox
= MLY_STRONGARM_COMMAND_MAILBOX
;
470 sc
->mly_status_mailbox
= MLY_STRONGARM_STATUS_MAILBOX
;
471 sc
->mly_idbr
= MLY_STRONGARM_IDBR
;
472 sc
->mly_odbr
= MLY_STRONGARM_ODBR
;
473 sc
->mly_error_status
= MLY_STRONGARM_ERROR_STATUS
;
474 sc
->mly_interrupt_status
= MLY_STRONGARM_INTERRUPT_STATUS
;
475 sc
->mly_interrupt_mask
= MLY_STRONGARM_INTERRUPT_MASK
;
483 * Create the scatter/gather mappings.
485 if ((error
= mly_sg_map(sc
)))
489 * Allocate and map the memory mailbox
491 if ((error
= mly_mmbox_map(sc
)))
500 /********************************************************************************
501 * Shut the controller down and detach all our resources.
504 mly_detach(device_t dev
)
508 if ((error
= mly_shutdown(dev
)) != 0)
511 mly_free(device_get_softc(dev
));
515 /********************************************************************************
516 * Bring the controller to a state where it can be safely left alone.
518 * Note that it should not be necessary to wait for any outstanding commands,
519 * as they should be completed prior to calling here.
521 * XXX this applies for I/O, but not status polls; we should beware of
522 * the case where a status command is running while we detach.
525 mly_shutdown(device_t dev
)
527 struct mly_softc
*sc
= device_get_softc(dev
);
531 if (sc
->mly_state
& MLY_STATE_OPEN
)
534 /* kill the periodic event */
535 callout_stop(&sc
->mly_periodic
);
537 /* flush controller */
538 mly_printf(sc
, "flushing cache...");
539 kprintf("%s\n", mly_flush(sc
) ? "failed" : "done");
541 MLY_MASK_INTERRUPTS(sc
);
546 /*******************************************************************************
547 * Take an interrupt, or be poked by other code to look for interrupt-worthy
553 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
560 /********************************************************************************
561 ********************************************************************************
562 Bus-dependant Resource Management
563 ********************************************************************************
564 ********************************************************************************/
566 /********************************************************************************
567 * Allocate memory for the scatter/gather tables
570 mly_sg_map(struct mly_softc
*sc
)
577 * Create a single tag describing a region large enough to hold all of
578 * the s/g lists we will need.
580 segsize
= sizeof(struct mly_sg_entry
) * MLY_MAX_COMMANDS
*MLY_MAX_SGENTRIES
;
581 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
582 1, 0, /* alignment,boundary */
583 BUS_SPACE_MAXADDR
, /* lowaddr */
584 BUS_SPACE_MAXADDR
, /* highaddr */
585 NULL
, NULL
, /* filter, filterarg */
586 segsize
, 1, /* maxsize, nsegments */
587 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
588 BUS_DMA_ALLOCNOW
, /* flags */
590 mly_printf(sc
, "can't allocate scatter/gather DMA tag\n");
595 * Allocate enough s/g maps for all commands and permanently map them into
596 * controller-visible space.
598 * XXX this assumes we can get enough space for all the s/g maps in one
601 if (bus_dmamem_alloc(sc
->mly_sg_dmat
, (void **)&sc
->mly_sg_table
,
602 BUS_DMA_NOWAIT
, &sc
->mly_sg_dmamap
)) {
603 mly_printf(sc
, "can't allocate s/g table\n");
606 if (bus_dmamap_load(sc
->mly_sg_dmat
, sc
->mly_sg_dmamap
, sc
->mly_sg_table
,
607 segsize
, mly_sg_map_helper
, sc
, BUS_DMA_NOWAIT
) != 0)
612 /********************************************************************************
613 * Save the physical address of the base of the s/g table.
616 mly_sg_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
618 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
622 /* save base of s/g table's address in bus space */
623 sc
->mly_sg_busaddr
= segs
->ds_addr
;
626 /********************************************************************************
627 * Allocate memory for the memory-mailbox interface
630 mly_mmbox_map(struct mly_softc
*sc
)
634 * Create a DMA tag for a single contiguous region large enough for the
635 * memory mailbox structure.
637 if (bus_dma_tag_create(sc
->mly_parent_dmat
, /* parent */
638 1, 0, /* alignment,boundary */
639 BUS_SPACE_MAXADDR
, /* lowaddr */
640 BUS_SPACE_MAXADDR
, /* highaddr */
641 NULL
, NULL
, /* filter, filterarg */
642 sizeof(struct mly_mmbox
), 1, /* maxsize, nsegments */
643 BUS_SPACE_MAXSIZE_32BIT
, /* maxsegsize */
644 BUS_DMA_ALLOCNOW
, /* flags */
645 &sc
->mly_mmbox_dmat
)) {
646 mly_printf(sc
, "can't allocate memory mailbox DMA tag\n");
651 * Allocate the buffer
653 if (bus_dmamem_alloc(sc
->mly_mmbox_dmat
, (void **)&sc
->mly_mmbox
, BUS_DMA_NOWAIT
, &sc
->mly_mmbox_dmamap
)) {
654 mly_printf(sc
, "can't allocate memory mailbox\n");
657 if (bus_dmamap_load(sc
->mly_mmbox_dmat
, sc
->mly_mmbox_dmamap
, sc
->mly_mmbox
,
658 sizeof(struct mly_mmbox
), mly_mmbox_map_helper
, sc
,
659 BUS_DMA_NOWAIT
) != 0)
661 bzero(sc
->mly_mmbox
, sizeof(*sc
->mly_mmbox
));
666 /********************************************************************************
667 * Save the physical address of the memory mailbox
670 mly_mmbox_map_helper(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
672 struct mly_softc
*sc
= (struct mly_softc
*)arg
;
676 sc
->mly_mmbox_busaddr
= segs
->ds_addr
;
679 /********************************************************************************
680 * Free all of the resources associated with (sc)
682 * Should not be called if the controller is active.
685 mly_free(struct mly_softc
*sc
)
690 /* Remove the management device */
691 destroy_dev(sc
->mly_dev_t
);
693 /* detach from CAM */
696 /* release command memory */
697 mly_release_commands(sc
);
699 /* throw away the controllerinfo structure */
700 if (sc
->mly_controllerinfo
!= NULL
)
701 kfree(sc
->mly_controllerinfo
, M_DEVBUF
);
703 /* throw away the controllerparam structure */
704 if (sc
->mly_controllerparam
!= NULL
)
705 kfree(sc
->mly_controllerparam
, M_DEVBUF
);
707 /* destroy data-transfer DMA tag */
708 if (sc
->mly_buffer_dmat
)
709 bus_dma_tag_destroy(sc
->mly_buffer_dmat
);
711 /* free and destroy DMA memory and tag for s/g lists */
712 if (sc
->mly_sg_table
) {
713 bus_dmamap_unload(sc
->mly_sg_dmat
, sc
->mly_sg_dmamap
);
714 bus_dmamem_free(sc
->mly_sg_dmat
, sc
->mly_sg_table
, sc
->mly_sg_dmamap
);
717 bus_dma_tag_destroy(sc
->mly_sg_dmat
);
719 /* free and destroy DMA memory and tag for memory mailbox */
721 bus_dmamap_unload(sc
->mly_mmbox_dmat
, sc
->mly_mmbox_dmamap
);
722 bus_dmamem_free(sc
->mly_mmbox_dmat
, sc
->mly_mmbox
, sc
->mly_mmbox_dmamap
);
724 if (sc
->mly_mmbox_dmat
)
725 bus_dma_tag_destroy(sc
->mly_mmbox_dmat
);
727 /* disconnect the interrupt handler */
729 bus_teardown_intr(sc
->mly_dev
, sc
->mly_irq
, sc
->mly_intr
);
730 if (sc
->mly_irq
!= NULL
)
731 bus_release_resource(sc
->mly_dev
, SYS_RES_IRQ
, sc
->mly_irq_rid
, sc
->mly_irq
);
733 /* destroy the parent DMA tag */
734 if (sc
->mly_parent_dmat
)
735 bus_dma_tag_destroy(sc
->mly_parent_dmat
);
737 /* release the register window mapping */
738 if (sc
->mly_regs_resource
!= NULL
)
739 bus_release_resource(sc
->mly_dev
, SYS_RES_MEMORY
, sc
->mly_regs_rid
, sc
->mly_regs_resource
);
742 /********************************************************************************
743 ********************************************************************************
745 ********************************************************************************
746 ********************************************************************************/
748 /********************************************************************************
749 * Fill in the mly_controllerinfo and mly_controllerparam fields in the softc.
752 mly_get_controllerinfo(struct mly_softc
*sc
)
754 struct mly_command_ioctl mci
;
760 if (sc
->mly_controllerinfo
!= NULL
)
761 kfree(sc
->mly_controllerinfo
, M_DEVBUF
);
763 /* build the getcontrollerinfo ioctl and send it */
764 bzero(&mci
, sizeof(mci
));
765 sc
->mly_controllerinfo
= NULL
;
766 mci
.sub_ioctl
= MDACIOCTL_GETCONTROLLERINFO
;
767 if ((error
= mly_ioctl(sc
, &mci
, (void **)&sc
->mly_controllerinfo
, sizeof(*sc
->mly_controllerinfo
),
768 &status
, NULL
, NULL
)))
773 if (sc
->mly_controllerparam
!= NULL
)
774 kfree(sc
->mly_controllerparam
, M_DEVBUF
);
776 /* build the getcontrollerparameter ioctl and send it */
777 bzero(&mci
, sizeof(mci
));
778 sc
->mly_controllerparam
= NULL
;
779 mci
.sub_ioctl
= MDACIOCTL_GETCONTROLLERPARAMETER
;
780 if ((error
= mly_ioctl(sc
, &mci
, (void **)&sc
->mly_controllerparam
, sizeof(*sc
->mly_controllerparam
),
781 &status
, NULL
, NULL
)))
789 /********************************************************************************
790 * Schedule all possible devices for a rescan.
794 mly_scan_devices(struct mly_softc
*sc
)
801 * Clear any previous BTL information.
803 bzero(&sc
->mly_btl
, sizeof(sc
->mly_btl
));
806 * Mark all devices as requiring a rescan, and let the next
807 * periodic scan collect them.
809 for (bus
= 0; bus
< sc
->mly_cam_channels
; bus
++)
810 if (MLY_BUS_IS_VALID(sc
, bus
))
811 for (target
= 0; target
< MLY_MAX_TARGETS
; target
++)
812 sc
->mly_btl
[bus
][target
].mb_flags
= MLY_BTL_RESCAN
;
816 /********************************************************************************
817 * Rescan a device, possibly as a consequence of getting an event which suggests
818 * that it may have changed.
820 * If we suffer resource starvation, we can abandon the rescan as we'll be
824 mly_rescan_btl(struct mly_softc
*sc
, int bus
, int target
)
826 struct mly_command
*mc
;
827 struct mly_command_ioctl
*mci
;
831 /* check that this bus is valid */
832 if (!MLY_BUS_IS_VALID(sc
, bus
))
836 if (mly_alloc_command(sc
, &mc
))
839 /* set up the data buffer */
840 mc
->mc_data
= kmalloc(sizeof(union mly_devinfo
), M_DEVBUF
, M_INTWAIT
| M_ZERO
);
841 mc
->mc_flags
|= MLY_CMD_DATAIN
;
842 mc
->mc_complete
= mly_complete_rescan
;
847 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
848 mci
->opcode
= MDACMD_IOCTL
;
849 mci
->addr
.phys
.controller
= 0;
850 mci
->timeout
.value
= 30;
851 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
852 if (MLY_BUS_IS_VIRTUAL(sc
, bus
)) {
853 mc
->mc_length
= mci
->data_size
= sizeof(struct mly_ioctl_getlogdevinfovalid
);
854 mci
->sub_ioctl
= MDACIOCTL_GETLOGDEVINFOVALID
;
855 mci
->addr
.log
.logdev
= MLY_LOGDEV_ID(sc
, bus
, target
);
856 debug(1, "logical device %d", mci
->addr
.log
.logdev
);
858 mc
->mc_length
= mci
->data_size
= sizeof(struct mly_ioctl_getphysdevinfovalid
);
859 mci
->sub_ioctl
= MDACIOCTL_GETPHYSDEVINFOVALID
;
860 mci
->addr
.phys
.lun
= 0;
861 mci
->addr
.phys
.target
= target
;
862 mci
->addr
.phys
.channel
= bus
;
863 debug(1, "physical device %d:%d", mci
->addr
.phys
.channel
, mci
->addr
.phys
.target
);
867 * Dispatch the command. If we successfully send the command, clear the rescan
870 if (mly_start(mc
) != 0) {
871 mly_release_command(mc
);
873 sc
->mly_btl
[bus
][target
].mb_flags
&= ~MLY_BTL_RESCAN
; /* success */
877 /********************************************************************************
878 * Handle the completion of a rescan operation
881 mly_complete_rescan(struct mly_command
*mc
)
883 struct mly_softc
*sc
= mc
->mc_sc
;
884 struct mly_ioctl_getlogdevinfovalid
*ldi
;
885 struct mly_ioctl_getphysdevinfovalid
*pdi
;
886 struct mly_command_ioctl
*mci
;
887 struct mly_btl btl
, *btlp
;
888 int bus
, target
, rescan
;
893 * Recover the bus and target from the command. We need these even in
894 * the case where we don't have a useful response.
896 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
897 if (mci
->sub_ioctl
== MDACIOCTL_GETLOGDEVINFOVALID
) {
898 bus
= MLY_LOGDEV_BUS(sc
, mci
->addr
.log
.logdev
);
899 target
= MLY_LOGDEV_TARGET(sc
, mci
->addr
.log
.logdev
);
901 bus
= mci
->addr
.phys
.channel
;
902 target
= mci
->addr
.phys
.target
;
904 /* XXX validate bus/target? */
906 /* the default result is 'no device' */
907 bzero(&btl
, sizeof(btl
));
909 /* if the rescan completed OK, we have possibly-new BTL data */
910 if (mc
->mc_status
== 0) {
911 if (mc
->mc_length
== sizeof(*ldi
)) {
912 ldi
= (struct mly_ioctl_getlogdevinfovalid
*)mc
->mc_data
;
913 if ((MLY_LOGDEV_BUS(sc
, ldi
->logical_device_number
) != bus
) ||
914 (MLY_LOGDEV_TARGET(sc
, ldi
->logical_device_number
) != target
)) {
915 mly_printf(sc
, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
916 bus
, target
, MLY_LOGDEV_BUS(sc
, ldi
->logical_device_number
),
917 MLY_LOGDEV_TARGET(sc
, ldi
->logical_device_number
));
918 /* XXX what can we do about this? */
920 btl
.mb_flags
= MLY_BTL_LOGICAL
;
921 btl
.mb_type
= ldi
->raid_level
;
922 btl
.mb_state
= ldi
->state
;
923 debug(1, "BTL rescan for %d returns %s, %s", ldi
->logical_device_number
,
924 mly_describe_code(mly_table_device_type
, ldi
->raid_level
),
925 mly_describe_code(mly_table_device_state
, ldi
->state
));
926 } else if (mc
->mc_length
== sizeof(*pdi
)) {
927 pdi
= (struct mly_ioctl_getphysdevinfovalid
*)mc
->mc_data
;
928 if ((pdi
->channel
!= bus
) || (pdi
->target
!= target
)) {
929 mly_printf(sc
, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
930 bus
, target
, pdi
->channel
, pdi
->target
);
931 /* XXX what can we do about this? */
933 btl
.mb_flags
= MLY_BTL_PHYSICAL
;
934 btl
.mb_type
= MLY_DEVICE_TYPE_PHYSICAL
;
935 btl
.mb_state
= pdi
->state
;
936 btl
.mb_speed
= pdi
->speed
;
937 btl
.mb_width
= pdi
->width
;
938 if (pdi
->state
!= MLY_DEVICE_STATE_UNCONFIGURED
)
939 sc
->mly_btl
[bus
][target
].mb_flags
|= MLY_BTL_PROTECTED
;
940 debug(1, "BTL rescan for %d:%d returns %s", bus
, target
,
941 mly_describe_code(mly_table_device_state
, pdi
->state
));
943 mly_printf(sc
, "BTL rescan result invalid\n");
947 kfree(mc
->mc_data
, M_DEVBUF
);
948 mly_release_command(mc
);
951 * Decide whether we need to rescan the device.
955 /* device type changes (usually between 'nothing' and 'something') */
956 btlp
= &sc
->mly_btl
[bus
][target
];
957 if (btl
.mb_flags
!= btlp
->mb_flags
) {
958 debug(1, "flags changed, rescanning");
962 /* XXX other reasons? */
965 * Update BTL information.
970 * Perform CAM rescan if required.
973 mly_cam_rescan_btl(sc
, bus
, target
);
976 /********************************************************************************
977 * Get the current health status and set the 'next event' counter to suit.
980 mly_get_eventstatus(struct mly_softc
*sc
)
982 struct mly_command_ioctl mci
;
983 struct mly_health_status
*mh
;
987 /* build the gethealthstatus ioctl and send it */
988 bzero(&mci
, sizeof(mci
));
990 mci
.sub_ioctl
= MDACIOCTL_GETHEALTHSTATUS
;
992 if ((error
= mly_ioctl(sc
, &mci
, (void **)&mh
, sizeof(*mh
), &status
, NULL
, NULL
)))
997 /* get the event counter */
998 sc
->mly_event_change
= mh
->change_counter
;
999 sc
->mly_event_waiting
= mh
->next_event
;
1000 sc
->mly_event_counter
= mh
->next_event
;
1002 /* save the health status into the memory mailbox */
1003 bcopy(mh
, &sc
->mly_mmbox
->mmm_health
.status
, sizeof(*mh
));
1005 debug(1, "initial change counter %d, event counter %d", mh
->change_counter
, mh
->next_event
);
1007 kfree(mh
, M_DEVBUF
);
1011 /********************************************************************************
1012 * Enable the memory mailbox mode.
1015 mly_enable_mmbox(struct mly_softc
*sc
)
1017 struct mly_command_ioctl mci
;
1018 u_int8_t
*sp
, status
;
1023 /* build the ioctl and send it */
1024 bzero(&mci
, sizeof(mci
));
1025 mci
.sub_ioctl
= MDACIOCTL_SETMEMORYMAILBOX
;
1026 /* set buffer addresses */
1027 mci
.param
.setmemorymailbox
.command_mailbox_physaddr
=
1028 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_command
);
1029 mci
.param
.setmemorymailbox
.status_mailbox_physaddr
=
1030 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_status
);
1031 mci
.param
.setmemorymailbox
.health_buffer_physaddr
=
1032 sc
->mly_mmbox_busaddr
+ offsetof(struct mly_mmbox
, mmm_health
);
1034 /* set buffer sizes - abuse of data_size field is revolting */
1035 sp
= (u_int8_t
*)&mci
.data_size
;
1036 sp
[0] = ((sizeof(union mly_command_packet
) * MLY_MMBOX_COMMANDS
) / 1024);
1037 sp
[1] = (sizeof(union mly_status_packet
) * MLY_MMBOX_STATUS
) / 1024;
1038 mci
.param
.setmemorymailbox
.health_buffer_size
= sizeof(union mly_health_region
) / 1024;
1040 debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc
->mly_mmbox
,
1041 mci
.param
.setmemorymailbox
.command_mailbox_physaddr
, sp
[0],
1042 mci
.param
.setmemorymailbox
.status_mailbox_physaddr
, sp
[1],
1043 mci
.param
.setmemorymailbox
.health_buffer_physaddr
,
1044 mci
.param
.setmemorymailbox
.health_buffer_size
);
1046 if ((error
= mly_ioctl(sc
, &mci
, NULL
, 0, &status
, NULL
, NULL
)))
1050 sc
->mly_state
|= MLY_STATE_MMBOX_ACTIVE
;
1051 debug(1, "memory mailbox active");
1055 /********************************************************************************
1056 * Flush all pending I/O from the controller.
1059 mly_flush(struct mly_softc
*sc
)
1061 struct mly_command_ioctl mci
;
1067 /* build the ioctl */
1068 bzero(&mci
, sizeof(mci
));
1069 mci
.sub_ioctl
= MDACIOCTL_FLUSHDEVICEDATA
;
1070 mci
.param
.deviceoperation
.operation_device
= MLY_OPDEVICE_PHYSICAL_CONTROLLER
;
1072 /* pass it off to the controller */
1073 if ((error
= mly_ioctl(sc
, &mci
, NULL
, 0, &status
, NULL
, NULL
)))
1076 return((status
== 0) ? 0 : EIO
);
1079 /********************************************************************************
1080 * Perform an ioctl command.
1082 * If (data) is not NULL, the command requires data transfer. If (*data) is NULL
1083 * the command requires data transfer from the controller, and we will allocate
1084 * a buffer for it. If (*data) is not NULL, the command requires data transfer
1085 * to the controller.
1087 * XXX passing in the whole ioctl structure is ugly. Better ideas?
1089 * XXX we don't even try to handle the case where datasize > 4k. We should.
1092 mly_ioctl(struct mly_softc
*sc
, struct mly_command_ioctl
*ioctl
, void **data
, size_t datasize
,
1093 u_int8_t
*status
, void *sense_buffer
, size_t *sense_length
)
1095 struct mly_command
*mc
;
1096 struct mly_command_ioctl
*mci
;
1102 if (mly_alloc_command(sc
, &mc
)) {
1107 /* copy the ioctl structure, but save some important fields and then fixup */
1108 mci
= &mc
->mc_packet
->ioctl
;
1109 ioctl
->sense_buffer_address
= mci
->sense_buffer_address
;
1110 ioctl
->maximum_sense_size
= mci
->maximum_sense_size
;
1112 mci
->opcode
= MDACMD_IOCTL
;
1113 mci
->timeout
.value
= 30;
1114 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
1116 /* handle the data buffer */
1118 if (*data
== NULL
) {
1119 /* allocate data buffer */
1120 mc
->mc_data
= kmalloc(datasize
, M_DEVBUF
, M_INTWAIT
);
1121 mc
->mc_flags
|= MLY_CMD_DATAIN
;
1123 mc
->mc_data
= *data
;
1124 mc
->mc_flags
|= MLY_CMD_DATAOUT
;
1126 mc
->mc_length
= datasize
;
1127 mc
->mc_packet
->generic
.data_size
= datasize
;
1130 /* run the command */
1131 if ((error
= mly_immediate_command(mc
)))
1134 /* clean up and return any data */
1135 *status
= mc
->mc_status
;
1136 if ((mc
->mc_sense
> 0) && (sense_buffer
!= NULL
)) {
1137 bcopy(mc
->mc_packet
, sense_buffer
, mc
->mc_sense
);
1138 *sense_length
= mc
->mc_sense
;
1142 /* should we return a data pointer? */
1143 if ((data
!= NULL
) && (*data
== NULL
))
1144 *data
= mc
->mc_data
;
1146 /* command completed OK */
1151 /* do we need to free a data buffer we allocated? */
1152 if (error
&& (mc
->mc_data
!= NULL
) && (*data
== NULL
))
1153 kfree(mc
->mc_data
, M_DEVBUF
);
1154 mly_release_command(mc
);
1159 /********************************************************************************
1160 * Check for event(s) outstanding in the controller.
1163 mly_check_event(struct mly_softc
*sc
)
1167 * The controller may have updated the health status information,
1168 * so check for it here. Note that the counters are all in host memory,
1169 * so this check is very cheap. Also note that we depend on checking on
1172 if (sc
->mly_mmbox
->mmm_health
.status
.change_counter
!= sc
->mly_event_change
) {
1173 sc
->mly_event_change
= sc
->mly_mmbox
->mmm_health
.status
.change_counter
;
1174 debug(1, "event change %d, event status update, %d -> %d", sc
->mly_event_change
,
1175 sc
->mly_event_waiting
, sc
->mly_mmbox
->mmm_health
.status
.next_event
);
1176 sc
->mly_event_waiting
= sc
->mly_mmbox
->mmm_health
.status
.next_event
;
1178 /* wake up anyone that might be interested in this */
1179 wakeup(&sc
->mly_event_change
);
1181 if (sc
->mly_event_counter
!= sc
->mly_event_waiting
)
1182 mly_fetch_event(sc
);
1185 /********************************************************************************
1186 * Fetch one event from the controller.
1188 * If we fail due to resource starvation, we'll be retried the next time a
1189 * command completes.
1192 mly_fetch_event(struct mly_softc
*sc
)
1194 struct mly_command
*mc
;
1195 struct mly_command_ioctl
*mci
;
1201 if (mly_alloc_command(sc
, &mc
))
1204 /* set up the data buffer */
1205 mc
->mc_data
= kmalloc(sizeof(struct mly_event
), M_DEVBUF
, M_INTWAIT
|M_ZERO
);
1206 mc
->mc_length
= sizeof(struct mly_event
);
1207 mc
->mc_flags
|= MLY_CMD_DATAIN
;
1208 mc
->mc_complete
= mly_complete_event
;
1211 * Get an event number to fetch. It's possible that we've raced with another
1212 * context for the last event, in which case there will be no more events.
1215 if (sc
->mly_event_counter
== sc
->mly_event_waiting
) {
1216 mly_release_command(mc
);
1220 event
= sc
->mly_event_counter
++;
1226 * At this point we are committed to sending this request, as it
1227 * will be the only one constructed for this particular event number.
1229 mci
= (struct mly_command_ioctl
*)&mc
->mc_packet
->ioctl
;
1230 mci
->opcode
= MDACMD_IOCTL
;
1231 mci
->data_size
= sizeof(struct mly_event
);
1232 mci
->addr
.phys
.lun
= (event
>> 16) & 0xff;
1233 mci
->addr
.phys
.target
= (event
>> 24) & 0xff;
1234 mci
->addr
.phys
.channel
= 0;
1235 mci
->addr
.phys
.controller
= 0;
1236 mci
->timeout
.value
= 30;
1237 mci
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
1238 mci
->sub_ioctl
= MDACIOCTL_GETEVENT
;
1239 mci
->param
.getevent
.sequence_number_low
= event
& 0xffff;
1241 debug(1, "fetch event %u", event
);
1244 * Submit the command.
1246 * Note that failure of mly_start() will result in this event never being
1249 if (mly_start(mc
) != 0) {
1250 mly_printf(sc
, "couldn't fetch event %u\n", event
);
1251 mly_release_command(mc
);
1255 /********************************************************************************
1256 * Handle the completion of an event poll.
1259 mly_complete_event(struct mly_command
*mc
)
1261 struct mly_softc
*sc
= mc
->mc_sc
;
1262 struct mly_event
*me
= (struct mly_event
*)mc
->mc_data
;
1267 * If the event was successfully fetched, process it.
1269 if (mc
->mc_status
== SCSI_STATUS_OK
) {
1270 mly_process_event(sc
, me
);
1271 kfree(me
, M_DEVBUF
);
1273 mly_release_command(mc
);
1276 * Check for another event.
1278 mly_check_event(sc
);
1281 /********************************************************************************
1282 * Process a controller event.
1285 mly_process_event(struct mly_softc
*sc
, struct mly_event
*me
)
1287 struct scsi_sense_data
*ssd
= (struct scsi_sense_data
*)&me
->sense
[0];
1289 int bus
, target
, event
, class, action
;
1292 * Errors can be reported using vendor-unique sense data. In this case, the
1293 * event code will be 0x1c (Request sense data present), the sense key will
1294 * be 0x09 (vendor specific), the MSB of the ASC will be set, and the
1295 * actual event code will be a 16-bit value comprised of the ASCQ (low byte)
1296 * and low seven bits of the ASC (low seven bits of the high byte).
1298 if ((me
->code
== 0x1c) &&
1299 ((ssd
->flags
& SSD_KEY
) == SSD_KEY_Vendor_Specific
) &&
1300 (ssd
->add_sense_code
& 0x80)) {
1301 event
= ((int)(ssd
->add_sense_code
& ~0x80) << 8) + ssd
->add_sense_code_qual
;
1306 /* look up event, get codes */
1307 fp
= mly_describe_code(mly_table_event
, event
);
1309 debug(1, "Event %d code 0x%x", me
->sequence_number
, me
->code
);
1313 if (isupper(class) && bootverbose
)
1314 class = tolower(class);
1316 /* get action code, text string */
1321 * Print some information about the event.
1323 * This code uses a table derived from the corresponding portion of the Linux
1324 * driver, and thus the parser is very similar.
1327 case 'p': /* error on physical device */
1328 mly_printf(sc
, "physical device %d:%d %s\n", me
->channel
, me
->target
, tp
);
1330 sc
->mly_btl
[me
->channel
][me
->target
].mb_flags
|= MLY_BTL_RESCAN
;
1332 case 'l': /* error on logical unit */
1333 case 'm': /* message about logical unit */
1334 bus
= MLY_LOGDEV_BUS(sc
, me
->lun
);
1335 target
= MLY_LOGDEV_TARGET(sc
, me
->lun
);
1336 mly_name_device(sc
, bus
, target
);
1337 mly_printf(sc
, "logical device %d (%s) %s\n", me
->lun
, sc
->mly_btl
[bus
][target
].mb_name
, tp
);
1339 sc
->mly_btl
[bus
][target
].mb_flags
|= MLY_BTL_RESCAN
;
1342 case 's': /* report of sense data */
1343 if (((ssd
->flags
& SSD_KEY
) == SSD_KEY_NO_SENSE
) ||
1344 (((ssd
->flags
& SSD_KEY
) == SSD_KEY_NOT_READY
) &&
1345 (ssd
->add_sense_code
== 0x04) &&
1346 ((ssd
->add_sense_code_qual
== 0x01) || (ssd
->add_sense_code_qual
== 0x02))))
1347 break; /* ignore NO_SENSE or NOT_READY in one case */
1349 mly_printf(sc
, "physical device %d:%d %s\n", me
->channel
, me
->target
, tp
);
1350 mly_printf(sc
, " sense key %d asc %02x ascq %02x\n",
1351 ssd
->flags
& SSD_KEY
, ssd
->add_sense_code
, ssd
->add_sense_code_qual
);
1352 mly_printf(sc
, " info %4D csi %4D\n", ssd
->info
, "", ssd
->cmd_spec_info
, "");
1354 sc
->mly_btl
[me
->channel
][me
->target
].mb_flags
|= MLY_BTL_RESCAN
;
1357 mly_printf(sc
, tp
, me
->target
, me
->lun
);
1361 mly_printf(sc
, "controller %s\n", tp
);
1364 mly_printf(sc
, "%s - %d\n", tp
, me
->code
);
1366 default: /* probably a 'noisy' event being ignored */
1371 /********************************************************************************
1372 * Perform periodic activities.
1375 mly_periodic(void *data
)
1377 struct mly_softc
*sc
= (struct mly_softc
*)data
;
1385 for (bus
= 0; bus
< sc
->mly_cam_channels
; bus
++) {
1386 if (MLY_BUS_IS_VALID(sc
, bus
)) {
1387 for (target
= 0; target
< MLY_MAX_TARGETS
; target
++) {
1389 /* ignore the controller in this scan */
1390 if (target
== sc
->mly_controllerparam
->initiator_id
)
1393 /* perform device rescan? */
1394 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_RESCAN
)
1395 mly_rescan_btl(sc
, bus
, target
);
1400 /* check for controller events */
1401 mly_check_event(sc
);
1403 /* reschedule ourselves */
1404 callout_reset(&sc
->mly_periodic
, MLY_PERIODIC_INTERVAL
* hz
, mly_periodic
, sc
);
1407 /********************************************************************************
1408 ********************************************************************************
1410 ********************************************************************************
1411 ********************************************************************************/
1413 /********************************************************************************
1414 * Run a command and wait for it to complete.
1418 mly_immediate_command(struct mly_command
*mc
)
1420 struct mly_softc
*sc
= mc
->mc_sc
;
1425 /* spinning at splcam is ugly, but we're only used during controller init */
1427 if ((error
= mly_start(mc
))) {
1432 if (sc
->mly_state
& MLY_STATE_INTERRUPTS_ON
) {
1433 /* sleep on the command */
1434 while(!(mc
->mc_flags
& MLY_CMD_COMPLETE
)) {
1435 tsleep(mc
, 0, "mlywait", 0);
1438 /* spin and collect status while we do */
1439 while(!(mc
->mc_flags
& MLY_CMD_COMPLETE
)) {
1440 mly_done(mc
->mc_sc
);
1447 /********************************************************************************
1448 * Deliver a command to the controller.
1450 * XXX it would be good to just queue commands that we can't submit immediately
1451 * and send them later, but we probably want a wrapper for that so that
1452 * we don't hang on a failed submission for an immediate command.
1455 mly_start(struct mly_command
*mc
)
1457 struct mly_softc
*sc
= mc
->mc_sc
;
1458 union mly_command_packet
*pkt
;
1463 * Set the command up for delivery to the controller.
1465 mly_map_command(mc
);
1466 mc
->mc_packet
->generic
.command_id
= mc
->mc_slot
;
1469 mc
->mc_timestamp
= time_second
;
1475 * Do we have to use the hardware mailbox?
1477 if (!(sc
->mly_state
& MLY_STATE_MMBOX_ACTIVE
)) {
1479 * Check to see if the controller is ready for us.
1481 if (MLY_IDBR_TRUE(sc
, MLY_HM_CMDSENT
)) {
1485 mc
->mc_flags
|= MLY_CMD_BUSY
;
1488 * It's ready, send the command.
1490 MLY_SET_MBOX(sc
, sc
->mly_command_mailbox
, &mc
->mc_packetphys
);
1491 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_CMDSENT
);
1493 } else { /* use memory-mailbox mode */
1495 pkt
= &sc
->mly_mmbox
->mmm_command
[sc
->mly_mmbox_command_index
];
1497 /* check to see if the next index is free yet */
1498 if (pkt
->mmbox
.flag
!= 0) {
1502 mc
->mc_flags
|= MLY_CMD_BUSY
;
1504 /* copy in new command */
1505 bcopy(mc
->mc_packet
->mmbox
.data
, pkt
->mmbox
.data
, sizeof(pkt
->mmbox
.data
));
1506 /* barrier to ensure completion of previous write before we write the flag */
1507 bus_space_barrier(sc
->mly_btag
, sc
->mly_bhandle
, 0, 0,
1508 BUS_SPACE_BARRIER_WRITE
);
1509 /* copy flag last */
1510 pkt
->mmbox
.flag
= mc
->mc_packet
->mmbox
.flag
;
1511 /* barrier to ensure completion of previous write before we notify the controller */
1512 bus_space_barrier(sc
->mly_btag
, sc
->mly_bhandle
, 0, 0,
1513 BUS_SPACE_BARRIER_WRITE
);
1515 /* signal controller, update index */
1516 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_AM_CMDSENT
);
1517 sc
->mly_mmbox_command_index
= (sc
->mly_mmbox_command_index
+ 1) % MLY_MMBOX_COMMANDS
;
1520 mly_enqueue_busy(mc
);
1525 /********************************************************************************
1526 * Pick up command status from the controller, schedule a completion event
1529 mly_done(struct mly_softc
*sc
)
1531 struct mly_command
*mc
;
1532 union mly_status_packet
*sp
;
1539 /* pick up hardware-mailbox commands */
1540 if (MLY_ODBR_TRUE(sc
, MLY_HM_STSREADY
)) {
1541 slot
= MLY_GET_REG2(sc
, sc
->mly_status_mailbox
);
1542 if (slot
< MLY_SLOT_MAX
) {
1543 mc
= &sc
->mly_command
[slot
- MLY_SLOT_START
];
1544 mc
->mc_status
= MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 2);
1545 mc
->mc_sense
= MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 3);
1546 mc
->mc_resid
= MLY_GET_REG4(sc
, sc
->mly_status_mailbox
+ 4);
1547 mly_remove_busy(mc
);
1548 mc
->mc_flags
&= ~MLY_CMD_BUSY
;
1549 mly_enqueue_complete(mc
);
1552 /* slot 0xffff may mean "extremely bogus command" */
1553 mly_printf(sc
, "got HM completion for illegal slot %u\n", slot
);
1555 /* unconditionally acknowledge status */
1556 MLY_SET_REG(sc
, sc
->mly_odbr
, MLY_HM_STSREADY
);
1557 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_STSACK
);
1560 /* pick up memory-mailbox commands */
1561 if (MLY_ODBR_TRUE(sc
, MLY_AM_STSREADY
)) {
1563 sp
= &sc
->mly_mmbox
->mmm_status
[sc
->mly_mmbox_status_index
];
1565 /* check for more status */
1566 if (sp
->mmbox
.flag
== 0)
1569 /* get slot number */
1570 slot
= sp
->status
.command_id
;
1571 if (slot
< MLY_SLOT_MAX
) {
1572 mc
= &sc
->mly_command
[slot
- MLY_SLOT_START
];
1573 mc
->mc_status
= sp
->status
.status
;
1574 mc
->mc_sense
= sp
->status
.sense_length
;
1575 mc
->mc_resid
= sp
->status
.residue
;
1576 mly_remove_busy(mc
);
1577 mc
->mc_flags
&= ~MLY_CMD_BUSY
;
1578 mly_enqueue_complete(mc
);
1581 /* slot 0xffff may mean "extremely bogus command" */
1582 mly_printf(sc
, "got AM completion for illegal slot %u at %d\n",
1583 slot
, sc
->mly_mmbox_status_index
);
1586 /* clear and move to next index */
1588 sc
->mly_mmbox_status_index
= (sc
->mly_mmbox_status_index
+ 1) % MLY_MMBOX_STATUS
;
1590 /* acknowledge that we have collected status value(s) */
1591 MLY_SET_REG(sc
, sc
->mly_odbr
, MLY_AM_STSREADY
);
1596 if (sc
->mly_state
& MLY_STATE_INTERRUPTS_ON
)
1597 taskqueue_enqueue(taskqueue_swi
, &sc
->mly_task_complete
);
1599 mly_complete(sc
, 0);
1603 /********************************************************************************
1604 * Process completed commands
1607 mly_complete(void *context
, int pending
)
1609 struct mly_softc
*sc
= (struct mly_softc
*)context
;
1610 struct mly_command
*mc
;
1611 void (* mc_complete
)(struct mly_command
*mc
);
1617 * Spin pulling commands off the completed queue and processing them.
1619 while ((mc
= mly_dequeue_complete(sc
)) != NULL
) {
1622 * Free controller resources, mark command complete.
1624 * Note that as soon as we mark the command complete, it may be freed
1625 * out from under us, so we need to save the mc_complete field in
1626 * order to later avoid dereferencing mc. (We would not expect to
1627 * have a polling/sleeping consumer with mc_complete != NULL).
1629 mly_unmap_command(mc
);
1630 mc_complete
= mc
->mc_complete
;
1631 mc
->mc_flags
|= MLY_CMD_COMPLETE
;
1634 * Call completion handler or wake up sleeping consumer.
1636 if (mc_complete
!= NULL
) {
1644 * XXX if we are deferring commands due to controller-busy status, we should
1645 * retry submitting them here.
1649 /********************************************************************************
1650 ********************************************************************************
1651 Command Buffer Management
1652 ********************************************************************************
1653 ********************************************************************************/
1655 /********************************************************************************
1656 * Allocate a command.
1659 mly_alloc_command(struct mly_softc
*sc
, struct mly_command
**mcp
)
1661 struct mly_command
*mc
;
1665 if ((mc
= mly_dequeue_free(sc
)) == NULL
)
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
),
1936 sc
->mly_controllerinfo
->maximum_parallel_commands
,
1937 1, devq
)) == NULL
) {
1940 if (xpt_bus_register(sc
->mly_cam_sim
[chn
], chn
)) {
1941 mly_printf(sc
, "CAM XPT phsyical channel registration failed\n");
1944 debug(1, "registered physical channel %d", chn
);
1949 * Register our virtual channels, with bus numbers matching channel numbers.
1951 chn
= sc
->mly_controllerinfo
->physical_channels_present
;
1952 for (i
= 0; i
< sc
->mly_controllerinfo
->virtual_channels_present
; i
++, chn
++) {
1953 if ((sc
->mly_cam_sim
[chn
] = cam_sim_alloc(mly_cam_action
, mly_cam_poll
, "mly", sc
,
1954 device_get_unit(sc
->mly_dev
),
1955 sc
->mly_controllerinfo
->maximum_parallel_commands
,
1956 0, devq
)) == NULL
) {
1959 if (xpt_bus_register(sc
->mly_cam_sim
[chn
], chn
)) {
1960 mly_printf(sc
, "CAM XPT virtual channel registration failed\n");
1963 debug(1, "registered virtual channel %d", chn
);
1967 * This is the total number of channels that (might have been) registered with
1968 * CAM. Some may not have been; check the mly_cam_sim array to be certain.
1970 sc
->mly_cam_channels
= sc
->mly_controllerinfo
->physical_channels_present
+
1971 sc
->mly_controllerinfo
->virtual_channels_present
;
1976 /********************************************************************************
1980 mly_cam_detach(struct mly_softc
*sc
)
1986 for (i
= 0; i
< sc
->mly_cam_channels
; i
++) {
1987 if (sc
->mly_cam_sim
[i
] != NULL
) {
1988 xpt_bus_deregister(cam_sim_path(sc
->mly_cam_sim
[i
]));
1989 cam_sim_free(sc
->mly_cam_sim
[i
]);
1992 if (sc
->mly_cam_devq
!= NULL
)
1993 cam_simq_release(sc
->mly_cam_devq
);
1996 /************************************************************************
2000 mly_cam_rescan_btl(struct mly_softc
*sc
, int bus
, int target
)
2006 ccb
= kmalloc(sizeof(union ccb
), M_TEMP
, M_WAITOK
| M_ZERO
);
2008 if (xpt_create_path(&sc
->mly_cam_path
, xpt_periph
,
2009 cam_sim_path(sc
->mly_cam_sim
[bus
]), target
, 0) != CAM_REQ_CMP
) {
2010 mly_printf(sc
, "rescan failed (can't create path)\n");
2014 xpt_setup_ccb(&ccb
->ccb_h
, sc
->mly_cam_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
)
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 #ifdef CAM_NEW_TRAN_CODE
2088 cpi
->transport
= XPORT_SPI
;
2089 cpi
->transport_version
= 2;
2090 cpi
->protocol
= PROTO_SCSI
;
2091 cpi
->protocol_version
= SCSI_REV_2
;
2093 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
2097 case XPT_GET_TRAN_SETTINGS
:
2099 struct ccb_trans_settings
*cts
= &ccb
->cts
;
2101 #ifdef CAM_NEW_TRAN_CODE
2102 struct ccb_trans_settings_scsi
*scsi
= &cts
->proto_specific
.scsi
;
2103 struct ccb_trans_settings_spi
*spi
= &cts
->xport_specific
.spi
;
2105 cts
->protocol
= PROTO_SCSI
;
2106 cts
->protocol_version
= SCSI_REV_2
;
2107 cts
->transport
= XPORT_SPI
;
2108 cts
->transport_version
= 2;
2115 bus
= cam_sim_bus(sim
);
2116 target
= cts
->ccb_h
.target_id
;
2117 debug(2, "XPT_GET_TRAN_SETTINGS %d:%d", bus
, target
);
2118 /* logical device? */
2119 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2120 /* nothing special for these */
2121 /* physical device? */
2122 } else if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PHYSICAL
) {
2123 /* allow CAM to try tagged transactions */
2124 scsi
->flags
|= CTS_SCSI_FLAGS_TAG_ENB
;
2125 scsi
->valid
|= CTS_SCSI_VALID_TQ
;
2127 /* convert speed (MHz) to usec */
2128 if (sc
->mly_btl
[bus
][target
].mb_speed
== 0) {
2129 spi
->sync_period
= 1000000 / 5;
2131 spi
->sync_period
= 1000000 / sc
->mly_btl
[bus
][target
].mb_speed
;
2134 /* convert bus width to CAM internal encoding */
2135 switch (sc
->mly_btl
[bus
][target
].mb_width
) {
2137 spi
->bus_width
= MSG_EXT_WDTR_BUS_32_BIT
;
2140 spi
->bus_width
= MSG_EXT_WDTR_BUS_16_BIT
;
2144 spi
->bus_width
= MSG_EXT_WDTR_BUS_8_BIT
;
2147 spi
->valid
|= CTS_SPI_VALID_SYNC_RATE
| CTS_SPI_VALID_BUS_WIDTH
;
2149 /* not a device, bail out */
2151 cts
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2155 /* disconnect always OK */
2156 spi
->flags
|= CTS_SPI_FLAGS_DISC_ENB
;
2157 spi
->valid
|= CTS_SPI_VALID_DISC
;
2161 bus
= cam_sim_bus(sim
);
2162 target
= cts
->ccb_h
.target_id
;
2163 /* XXX validate bus/target? */
2165 debug(2, "XPT_GET_TRAN_SETTINGS %d:%d", bus
, target
);
2167 /* logical device? */
2168 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2169 /* nothing special for these */
2171 /* physical device? */
2172 } else if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PHYSICAL
) {
2173 /* allow CAM to try tagged transactions */
2174 cts
->flags
|= CCB_TRANS_TAG_ENB
;
2175 cts
->valid
|= CCB_TRANS_TQ_VALID
;
2177 /* convert speed (MHz) to usec */
2178 if (sc
->mly_btl
[bus
][target
].mb_speed
== 0) {
2179 cts
->sync_period
= 1000000 / 5;
2181 cts
->sync_period
= 1000000 / sc
->mly_btl
[bus
][target
].mb_speed
;
2184 /* convert bus width to CAM internal encoding */
2185 switch (sc
->mly_btl
[bus
][target
].mb_width
) {
2187 cts
->bus_width
= MSG_EXT_WDTR_BUS_32_BIT
;
2190 cts
->bus_width
= MSG_EXT_WDTR_BUS_16_BIT
;
2194 cts
->bus_width
= MSG_EXT_WDTR_BUS_8_BIT
;
2197 cts
->valid
|= CCB_TRANS_SYNC_RATE_VALID
| CCB_TRANS_BUS_WIDTH_VALID
;
2199 /* not a device, bail out */
2201 cts
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2205 /* disconnect always OK */
2206 cts
->flags
|= CCB_TRANS_DISC_ENB
;
2207 cts
->valid
|= CCB_TRANS_DISC_VALID
;
2210 cts
->ccb_h
.status
= CAM_REQ_CMP
;
2214 default: /* we can't do this */
2215 debug(2, "unsupported func_code = 0x%x", ccb
->ccb_h
.func_code
);
2216 ccb
->ccb_h
.status
= CAM_REQ_INVALID
;
2223 /********************************************************************************
2224 * Handle an I/O operation requested by CAM
2227 mly_cam_action_io(struct cam_sim
*sim
, struct ccb_scsiio
*csio
)
2229 struct mly_softc
*sc
= cam_sim_softc(sim
);
2230 struct mly_command
*mc
;
2231 struct mly_command_scsi_small
*ss
;
2235 bus
= cam_sim_bus(sim
);
2236 target
= csio
->ccb_h
.target_id
;
2238 debug(2, "XPT_SCSI_IO %d:%d:%d", bus
, target
, csio
->ccb_h
.target_lun
);
2240 /* validate bus number */
2241 if (!MLY_BUS_IS_VALID(sc
, bus
)) {
2242 debug(0, " invalid bus %d", bus
);
2243 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2246 /* check for I/O attempt to a protected device */
2247 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_PROTECTED
) {
2248 debug(2, " device protected");
2249 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2252 /* check for I/O attempt to nonexistent device */
2253 if (!(sc
->mly_btl
[bus
][target
].mb_flags
& (MLY_BTL_LOGICAL
| MLY_BTL_PHYSICAL
))) {
2254 debug(2, " device %d:%d does not exist", bus
, target
);
2255 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2258 /* XXX increase if/when we support large SCSI commands */
2259 if (csio
->cdb_len
> MLY_CMD_SCSI_SMALL_CDB
) {
2260 debug(0, " command too large (%d > %d)", csio
->cdb_len
, MLY_CMD_SCSI_SMALL_CDB
);
2261 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2264 /* check that the CDB pointer is not to a physical address */
2265 if ((csio
->ccb_h
.flags
& CAM_CDB_POINTER
) && (csio
->ccb_h
.flags
& CAM_CDB_PHYS
)) {
2266 debug(0, " CDB pointer is to physical address");
2267 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2270 /* if there is data transfer, it must be to/from a virtual address */
2271 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) != CAM_DIR_NONE
) {
2272 if (csio
->ccb_h
.flags
& CAM_DATA_PHYS
) { /* we can't map it */
2273 debug(0, " data pointer is to physical address");
2274 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2276 if (csio
->ccb_h
.flags
& CAM_SCATTER_VALID
) { /* we want to do the s/g setup */
2277 debug(0, " data has premature s/g setup");
2278 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2282 /* abandon aborted ccbs or those that have failed validation */
2283 if ((csio
->ccb_h
.status
& CAM_STATUS_MASK
) != CAM_REQ_INPROG
) {
2284 debug(2, "abandoning CCB due to abort/validation failure");
2289 * Get a command, or push the ccb back to CAM and freeze the queue.
2291 if ((error
= mly_alloc_command(sc
, &mc
))) {
2293 xpt_freeze_simq(sim
, 1);
2294 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2295 sc
->mly_qfrzn_cnt
++;
2300 /* build the command */
2301 mc
->mc_data
= csio
->data_ptr
;
2302 mc
->mc_length
= csio
->dxfer_len
;
2303 mc
->mc_complete
= mly_cam_complete
;
2304 mc
->mc_private
= csio
;
2306 /* save the bus number in the ccb for later recovery XXX should be a better way */
2307 csio
->ccb_h
.sim_priv
.entries
[0].field
= bus
;
2309 /* build the packet for the controller */
2310 ss
= &mc
->mc_packet
->scsi_small
;
2311 ss
->opcode
= MDACMD_SCSI
;
2312 if (csio
->ccb_h
.flags
& CAM_DIS_DISCONNECT
)
2313 ss
->command_control
.disable_disconnect
= 1;
2314 if ((csio
->ccb_h
.flags
& CAM_DIR_MASK
) == CAM_DIR_OUT
)
2315 ss
->command_control
.data_direction
= MLY_CCB_WRITE
;
2316 ss
->data_size
= csio
->dxfer_len
;
2317 ss
->addr
.phys
.lun
= csio
->ccb_h
.target_lun
;
2318 ss
->addr
.phys
.target
= csio
->ccb_h
.target_id
;
2319 ss
->addr
.phys
.channel
= bus
;
2320 if (csio
->ccb_h
.timeout
< (60 * 1000)) {
2321 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ 1000;
2322 ss
->timeout
.scale
= MLY_TIMEOUT_SECONDS
;
2323 } else if (csio
->ccb_h
.timeout
< (60 * 60 * 1000)) {
2324 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ (60 * 1000);
2325 ss
->timeout
.scale
= MLY_TIMEOUT_MINUTES
;
2327 ss
->timeout
.value
= csio
->ccb_h
.timeout
/ (60 * 60 * 1000); /* overflow? */
2328 ss
->timeout
.scale
= MLY_TIMEOUT_HOURS
;
2330 ss
->maximum_sense_size
= csio
->sense_len
;
2331 ss
->cdb_length
= csio
->cdb_len
;
2332 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2333 bcopy(csio
->cdb_io
.cdb_ptr
, ss
->cdb
, csio
->cdb_len
);
2335 bcopy(csio
->cdb_io
.cdb_bytes
, ss
->cdb
, csio
->cdb_len
);
2338 /* give the command to the controller */
2339 if ((error
= mly_start(mc
))) {
2341 xpt_freeze_simq(sim
, 1);
2342 csio
->ccb_h
.status
|= CAM_REQUEUE_REQ
;
2343 sc
->mly_qfrzn_cnt
++;
2351 /********************************************************************************
2352 * Check for possibly-completed commands.
2355 mly_cam_poll(struct cam_sim
*sim
)
2357 struct mly_softc
*sc
= cam_sim_softc(sim
);
2364 /********************************************************************************
2365 * Handle completion of a command - pass results back through the CCB
2368 mly_cam_complete(struct mly_command
*mc
)
2370 struct mly_softc
*sc
= mc
->mc_sc
;
2371 struct ccb_scsiio
*csio
= (struct ccb_scsiio
*)mc
->mc_private
;
2372 struct scsi_inquiry_data
*inq
= (struct scsi_inquiry_data
*)csio
->data_ptr
;
2373 struct mly_btl
*btl
;
2379 csio
->scsi_status
= mc
->mc_status
;
2380 switch(mc
->mc_status
) {
2381 case SCSI_STATUS_OK
:
2383 * In order to report logical device type and status, we overwrite
2384 * the result of the INQUIRY command to logical devices.
2386 bus
= csio
->ccb_h
.sim_priv
.entries
[0].field
;
2387 target
= csio
->ccb_h
.target_id
;
2388 /* XXX validate bus/target? */
2389 if (sc
->mly_btl
[bus
][target
].mb_flags
& MLY_BTL_LOGICAL
) {
2390 if (csio
->ccb_h
.flags
& CAM_CDB_POINTER
) {
2391 cmd
= *csio
->cdb_io
.cdb_ptr
;
2393 cmd
= csio
->cdb_io
.cdb_bytes
[0];
2395 if (cmd
== INQUIRY
) {
2396 btl
= &sc
->mly_btl
[bus
][target
];
2397 padstr(inq
->vendor
, mly_describe_code(mly_table_device_type
, btl
->mb_type
), 8);
2398 padstr(inq
->product
, mly_describe_code(mly_table_device_state
, btl
->mb_state
), 16);
2399 padstr(inq
->revision
, "", 4);
2403 debug(2, "SCSI_STATUS_OK");
2404 csio
->ccb_h
.status
= CAM_REQ_CMP
;
2407 case SCSI_STATUS_CHECK_COND
:
2408 debug(1, "SCSI_STATUS_CHECK_COND sense %d resid %d", mc
->mc_sense
, mc
->mc_resid
);
2409 csio
->ccb_h
.status
= CAM_SCSI_STATUS_ERROR
;
2410 bzero(&csio
->sense_data
, SSD_FULL_SIZE
);
2411 bcopy(mc
->mc_packet
, &csio
->sense_data
, mc
->mc_sense
);
2412 csio
->sense_len
= mc
->mc_sense
;
2413 csio
->ccb_h
.status
|= CAM_AUTOSNS_VALID
;
2414 csio
->resid
= mc
->mc_resid
; /* XXX this is a signed value... */
2417 case SCSI_STATUS_BUSY
:
2418 debug(1, "SCSI_STATUS_BUSY");
2419 csio
->ccb_h
.status
= CAM_SCSI_BUSY
;
2423 debug(1, "unknown status 0x%x", csio
->scsi_status
);
2424 csio
->ccb_h
.status
= CAM_REQ_CMP_ERR
;
2429 if (sc
->mly_qfrzn_cnt
) {
2430 csio
->ccb_h
.status
|= CAM_RELEASE_SIMQ
;
2431 sc
->mly_qfrzn_cnt
--;
2435 xpt_done((union ccb
*)csio
);
2436 mly_release_command(mc
);
2439 /********************************************************************************
2440 * Find a peripheral attahed at (bus),(target)
2442 static struct cam_periph
*
2443 mly_find_periph(struct mly_softc
*sc
, int bus
, int target
)
2445 struct cam_periph
*periph
;
2446 struct cam_path
*path
;
2449 status
= xpt_create_path(&path
, NULL
, cam_sim_path(sc
->mly_cam_sim
[bus
]), target
, 0);
2450 if (status
== CAM_REQ_CMP
) {
2451 periph
= cam_periph_find(path
, NULL
);
2452 xpt_free_path(path
);
2459 /********************************************************************************
2460 * Name the device at (bus)(target)
2463 mly_name_device(struct mly_softc
*sc
, int bus
, int target
)
2465 struct cam_periph
*periph
;
2467 if ((periph
= mly_find_periph(sc
, bus
, target
)) != NULL
) {
2468 ksprintf(sc
->mly_btl
[bus
][target
].mb_name
, "%s%d", periph
->periph_name
, periph
->unit_number
);
2471 sc
->mly_btl
[bus
][target
].mb_name
[0] = 0;
2475 /********************************************************************************
2476 ********************************************************************************
2478 ********************************************************************************
2479 ********************************************************************************/
2481 /********************************************************************************
2482 * Handshake with the firmware while the card is being initialised.
2485 mly_fwhandshake(struct mly_softc
*sc
)
2487 u_int8_t error
, param0
, param1
;
2492 /* set HM_STSACK and let the firmware initialise */
2493 MLY_SET_REG(sc
, sc
->mly_idbr
, MLY_HM_STSACK
);
2494 DELAY(1000); /* too short? */
2496 /* if HM_STSACK is still true, the controller is initialising */
2497 if (!MLY_IDBR_TRUE(sc
, MLY_HM_STSACK
))
2499 mly_printf(sc
, "controller initialisation started\n");
2501 /* spin waiting for initialisation to finish, or for a message to be delivered */
2502 while (MLY_IDBR_TRUE(sc
, MLY_HM_STSACK
)) {
2503 /* check for a message */
2504 if (MLY_ERROR_VALID(sc
)) {
2505 error
= MLY_GET_REG(sc
, sc
->mly_error_status
) & ~MLY_MSG_EMPTY
;
2506 param0
= MLY_GET_REG(sc
, sc
->mly_command_mailbox
);
2507 param1
= MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 1);
2510 case MLY_MSG_SPINUP
:
2512 mly_printf(sc
, "drive spinup in progress\n");
2513 spinup
= 1; /* only print this once (should print drive being spun?) */
2516 case MLY_MSG_RACE_RECOVERY_FAIL
:
2517 mly_printf(sc
, "mirror race recovery failed, one or more drives offline\n");
2519 case MLY_MSG_RACE_IN_PROGRESS
:
2520 mly_printf(sc
, "mirror race recovery in progress\n");
2522 case MLY_MSG_RACE_ON_CRITICAL
:
2523 mly_printf(sc
, "mirror race recovery on a critical drive\n");
2525 case MLY_MSG_PARITY_ERROR
:
2526 mly_printf(sc
, "FATAL MEMORY PARITY ERROR\n");
2529 mly_printf(sc
, "unknown initialisation code 0x%x\n", error
);
2536 /********************************************************************************
2537 ********************************************************************************
2538 Debugging and Diagnostics
2539 ********************************************************************************
2540 ********************************************************************************/
2542 /********************************************************************************
2543 * Print some information about the controller.
2546 mly_describe_controller(struct mly_softc
*sc
)
2548 struct mly_ioctl_getcontrollerinfo
*mi
= sc
->mly_controllerinfo
;
2550 mly_printf(sc
, "%16s, %d channel%s, firmware %d.%02d-%d-%02d (%02d%02d%02d%02d), %dMB RAM\n",
2551 mi
->controller_name
, mi
->physical_channels_present
, (mi
->physical_channels_present
) > 1 ? "s" : "",
2552 mi
->fw_major
, mi
->fw_minor
, mi
->fw_turn
, mi
->fw_build
, /* XXX turn encoding? */
2553 mi
->fw_century
, mi
->fw_year
, mi
->fw_month
, mi
->fw_day
,
2557 mly_printf(sc
, "%s %s (%x), %dMHz %d-bit %.16s\n",
2558 mly_describe_code(mly_table_oemname
, mi
->oem_information
),
2559 mly_describe_code(mly_table_controllertype
, mi
->controller_type
), mi
->controller_type
,
2560 mi
->interface_speed
, mi
->interface_width
, mi
->interface_name
);
2561 mly_printf(sc
, "%dMB %dMHz %d-bit %s%s%s, cache %dMB\n",
2562 mi
->memory_size
, mi
->memory_speed
, mi
->memory_width
,
2563 mly_describe_code(mly_table_memorytype
, mi
->memory_type
),
2564 mi
->memory_parity
? "+parity": "",mi
->memory_ecc
? "+ECC": "",
2566 mly_printf(sc
, "CPU: %s @ %dMHZ\n",
2567 mly_describe_code(mly_table_cputype
, mi
->cpu
[0].type
), mi
->cpu
[0].speed
);
2568 if (mi
->l2cache_size
!= 0)
2569 mly_printf(sc
, "%dKB L2 cache\n", mi
->l2cache_size
);
2570 if (mi
->exmemory_size
!= 0)
2571 mly_printf(sc
, "%dMB %dMHz %d-bit private %s%s%s\n",
2572 mi
->exmemory_size
, mi
->exmemory_speed
, mi
->exmemory_width
,
2573 mly_describe_code(mly_table_memorytype
, mi
->exmemory_type
),
2574 mi
->exmemory_parity
? "+parity": "",mi
->exmemory_ecc
? "+ECC": "");
2575 mly_printf(sc
, "battery backup %s\n", mi
->bbu_present
? "present" : "not installed");
2576 mly_printf(sc
, "maximum data transfer %d blocks, maximum sg entries/command %d\n",
2577 mi
->maximum_block_count
, mi
->maximum_sg_entries
);
2578 mly_printf(sc
, "logical devices present/critical/offline %d/%d/%d\n",
2579 mi
->logical_devices_present
, mi
->logical_devices_critical
, mi
->logical_devices_offline
);
2580 mly_printf(sc
, "physical devices present %d\n",
2581 mi
->physical_devices_present
);
2582 mly_printf(sc
, "physical disks present/offline %d/%d\n",
2583 mi
->physical_disks_present
, mi
->physical_disks_offline
);
2584 mly_printf(sc
, "%d physical channel%s, %d virtual channel%s of %d possible\n",
2585 mi
->physical_channels_present
, mi
->physical_channels_present
== 1 ? "" : "s",
2586 mi
->virtual_channels_present
, mi
->virtual_channels_present
== 1 ? "" : "s",
2587 mi
->virtual_channels_possible
);
2588 mly_printf(sc
, "%d parallel commands supported\n", mi
->maximum_parallel_commands
);
2589 mly_printf(sc
, "%dMB flash ROM, %d of %d maximum cycles\n",
2590 mi
->flash_size
, mi
->flash_age
, mi
->flash_maximum_age
);
2595 /********************************************************************************
2596 * Print some controller state
2599 mly_printstate(struct mly_softc
*sc
)
2601 mly_printf(sc
, "IDBR %02x ODBR %02x ERROR %02x (%x %x %x)\n",
2602 MLY_GET_REG(sc
, sc
->mly_idbr
),
2603 MLY_GET_REG(sc
, sc
->mly_odbr
),
2604 MLY_GET_REG(sc
, sc
->mly_error_status
),
2607 sc
->mly_error_status
);
2608 mly_printf(sc
, "IMASK %02x ISTATUS %02x\n",
2609 MLY_GET_REG(sc
, sc
->mly_interrupt_mask
),
2610 MLY_GET_REG(sc
, sc
->mly_interrupt_status
));
2611 mly_printf(sc
, "COMMAND %02x %02x %02x %02x %02x %02x %02x %02x\n",
2612 MLY_GET_REG(sc
, sc
->mly_command_mailbox
),
2613 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 1),
2614 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 2),
2615 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 3),
2616 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 4),
2617 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 5),
2618 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 6),
2619 MLY_GET_REG(sc
, sc
->mly_command_mailbox
+ 7));
2620 mly_printf(sc
, "STATUS %02x %02x %02x %02x %02x %02x %02x %02x\n",
2621 MLY_GET_REG(sc
, sc
->mly_status_mailbox
),
2622 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 1),
2623 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 2),
2624 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 3),
2625 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 4),
2626 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 5),
2627 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 6),
2628 MLY_GET_REG(sc
, sc
->mly_status_mailbox
+ 7));
2629 mly_printf(sc
, " %04x %08x\n",
2630 MLY_GET_REG2(sc
, sc
->mly_status_mailbox
),
2631 MLY_GET_REG4(sc
, sc
->mly_status_mailbox
+ 4));
2634 struct mly_softc
*mly_softc0
= NULL
;
2636 mly_printstate0(void)
2638 if (mly_softc0
!= NULL
)
2639 mly_printstate(mly_softc0
);
2642 /********************************************************************************
2646 mly_print_command(struct mly_command
*mc
)
2648 struct mly_softc
*sc
= mc
->mc_sc
;
2650 mly_printf(sc
, "COMMAND @ %p\n", mc
);
2651 mly_printf(sc
, " slot %d\n", mc
->mc_slot
);
2652 mly_printf(sc
, " status 0x%x\n", mc
->mc_status
);
2653 mly_printf(sc
, " sense len %d\n", mc
->mc_sense
);
2654 mly_printf(sc
, " resid %d\n", mc
->mc_resid
);
2655 mly_printf(sc
, " packet %p/0x%llx\n", mc
->mc_packet
, mc
->mc_packetphys
);
2656 if (mc
->mc_packet
!= NULL
)
2657 mly_print_packet(mc
);
2658 mly_printf(sc
, " data %p/%d\n", mc
->mc_data
, mc
->mc_length
);
2659 mly_printf(sc
, " flags %b\n", mc
->mc_flags
, "\20\1busy\2complete\3slotted\4mapped\5datain\6dataout\n");
2660 mly_printf(sc
, " complete %p\n", mc
->mc_complete
);
2661 mly_printf(sc
, " private %p\n", mc
->mc_private
);
2664 /********************************************************************************
2665 * Print a command packet
2668 mly_print_packet(struct mly_command
*mc
)
2670 struct mly_softc
*sc
= mc
->mc_sc
;
2671 struct mly_command_generic
*ge
= (struct mly_command_generic
*)mc
->mc_packet
;
2672 struct mly_command_scsi_small
*ss
= (struct mly_command_scsi_small
*)mc
->mc_packet
;
2673 struct mly_command_scsi_large
*sl
= (struct mly_command_scsi_large
*)mc
->mc_packet
;
2674 struct mly_command_ioctl
*io
= (struct mly_command_ioctl
*)mc
->mc_packet
;
2677 mly_printf(sc
, " command_id %d\n", ge
->command_id
);
2678 mly_printf(sc
, " opcode %d\n", ge
->opcode
);
2679 mly_printf(sc
, " command_control fua %d dpo %d est %d dd %s nas %d ddis %d\n",
2680 ge
->command_control
.force_unit_access
,
2681 ge
->command_control
.disable_page_out
,
2682 ge
->command_control
.extended_sg_table
,
2683 (ge
->command_control
.data_direction
== MLY_CCB_WRITE
) ? "WRITE" : "READ",
2684 ge
->command_control
.no_auto_sense
,
2685 ge
->command_control
.disable_disconnect
);
2686 mly_printf(sc
, " data_size %d\n", ge
->data_size
);
2687 mly_printf(sc
, " sense_buffer_address 0x%llx\n", ge
->sense_buffer_address
);
2688 mly_printf(sc
, " lun %d\n", ge
->addr
.phys
.lun
);
2689 mly_printf(sc
, " target %d\n", ge
->addr
.phys
.target
);
2690 mly_printf(sc
, " channel %d\n", ge
->addr
.phys
.channel
);
2691 mly_printf(sc
, " logical device %d\n", ge
->addr
.log
.logdev
);
2692 mly_printf(sc
, " controller %d\n", ge
->addr
.phys
.controller
);
2693 mly_printf(sc
, " timeout %d %s\n",
2695 (ge
->timeout
.scale
== MLY_TIMEOUT_SECONDS
) ? "seconds" :
2696 ((ge
->timeout
.scale
== MLY_TIMEOUT_MINUTES
) ? "minutes" : "hours"));
2697 mly_printf(sc
, " maximum_sense_size %d\n", ge
->maximum_sense_size
);
2698 switch(ge
->opcode
) {
2701 mly_printf(sc
, " cdb length %d\n", ss
->cdb_length
);
2702 mly_printf(sc
, " cdb %*D\n", ss
->cdb_length
, ss
->cdb
, " ");
2706 case MDACMD_SCSILCPT
:
2707 mly_printf(sc
, " cdb length %d\n", sl
->cdb_length
);
2708 mly_printf(sc
, " cdb 0x%llx\n", sl
->cdb_physaddr
);
2712 mly_printf(sc
, " sub_ioctl 0x%x\n", io
->sub_ioctl
);
2713 switch(io
->sub_ioctl
) {
2714 case MDACIOCTL_SETMEMORYMAILBOX
:
2715 mly_printf(sc
, " health_buffer_size %d\n",
2716 io
->param
.setmemorymailbox
.health_buffer_size
);
2717 mly_printf(sc
, " health_buffer_phys 0x%llx\n",
2718 io
->param
.setmemorymailbox
.health_buffer_physaddr
);
2719 mly_printf(sc
, " command_mailbox 0x%llx\n",
2720 io
->param
.setmemorymailbox
.command_mailbox_physaddr
);
2721 mly_printf(sc
, " status_mailbox 0x%llx\n",
2722 io
->param
.setmemorymailbox
.status_mailbox_physaddr
);
2726 case MDACIOCTL_SETREALTIMECLOCK
:
2727 case MDACIOCTL_GETHEALTHSTATUS
:
2728 case MDACIOCTL_GETCONTROLLERINFO
:
2729 case MDACIOCTL_GETLOGDEVINFOVALID
:
2730 case MDACIOCTL_GETPHYSDEVINFOVALID
:
2731 case MDACIOCTL_GETPHYSDEVSTATISTICS
:
2732 case MDACIOCTL_GETLOGDEVSTATISTICS
:
2733 case MDACIOCTL_GETCONTROLLERSTATISTICS
:
2734 case MDACIOCTL_GETBDT_FOR_SYSDRIVE
:
2735 case MDACIOCTL_CREATENEWCONF
:
2736 case MDACIOCTL_ADDNEWCONF
:
2737 case MDACIOCTL_GETDEVCONFINFO
:
2738 case MDACIOCTL_GETFREESPACELIST
:
2739 case MDACIOCTL_MORE
:
2740 case MDACIOCTL_SETPHYSDEVPARAMETER
:
2741 case MDACIOCTL_GETPHYSDEVPARAMETER
:
2742 case MDACIOCTL_GETLOGDEVPARAMETER
:
2743 case MDACIOCTL_SETLOGDEVPARAMETER
:
2744 mly_printf(sc
, " param %10D\n", io
->param
.data
.param
, " ");
2748 case MDACIOCTL_GETEVENT
:
2749 mly_printf(sc
, " event %d\n",
2750 io
->param
.getevent
.sequence_number_low
+ ((u_int32_t
)io
->addr
.log
.logdev
<< 16));
2754 case MDACIOCTL_SETRAIDDEVSTATE
:
2755 mly_printf(sc
, " state %d\n", io
->param
.setraiddevstate
.state
);
2759 case MDACIOCTL_XLATEPHYSDEVTORAIDDEV
:
2760 mly_printf(sc
, " raid_device %d\n", io
->param
.xlatephysdevtoraiddev
.raid_device
);
2761 mly_printf(sc
, " controller %d\n", io
->param
.xlatephysdevtoraiddev
.controller
);
2762 mly_printf(sc
, " channel %d\n", io
->param
.xlatephysdevtoraiddev
.channel
);
2763 mly_printf(sc
, " target %d\n", io
->param
.xlatephysdevtoraiddev
.target
);
2764 mly_printf(sc
, " lun %d\n", io
->param
.xlatephysdevtoraiddev
.lun
);
2768 case MDACIOCTL_GETGROUPCONFINFO
:
2769 mly_printf(sc
, " group %d\n", io
->param
.getgroupconfinfo
.group
);
2773 case MDACIOCTL_GET_SUBSYSTEM_DATA
:
2774 case MDACIOCTL_SET_SUBSYSTEM_DATA
:
2775 case MDACIOCTL_STARTDISOCVERY
:
2776 case MDACIOCTL_INITPHYSDEVSTART
:
2777 case MDACIOCTL_INITPHYSDEVSTOP
:
2778 case MDACIOCTL_INITRAIDDEVSTART
:
2779 case MDACIOCTL_INITRAIDDEVSTOP
:
2780 case MDACIOCTL_REBUILDRAIDDEVSTART
:
2781 case MDACIOCTL_REBUILDRAIDDEVSTOP
:
2782 case MDACIOCTL_MAKECONSISTENTDATASTART
:
2783 case MDACIOCTL_MAKECONSISTENTDATASTOP
:
2784 case MDACIOCTL_CONSISTENCYCHECKSTART
:
2785 case MDACIOCTL_CONSISTENCYCHECKSTOP
:
2786 case MDACIOCTL_RESETDEVICE
:
2787 case MDACIOCTL_FLUSHDEVICEDATA
:
2788 case MDACIOCTL_PAUSEDEVICE
:
2789 case MDACIOCTL_UNPAUSEDEVICE
:
2790 case MDACIOCTL_LOCATEDEVICE
:
2791 case MDACIOCTL_SETMASTERSLAVEMODE
:
2792 case MDACIOCTL_DELETERAIDDEV
:
2793 case MDACIOCTL_REPLACEINTERNALDEV
:
2794 case MDACIOCTL_CLEARCONF
:
2795 case MDACIOCTL_GETCONTROLLERPARAMETER
:
2796 case MDACIOCTL_SETCONTRLLERPARAMETER
:
2797 case MDACIOCTL_CLEARCONFSUSPMODE
:
2798 case MDACIOCTL_STOREIMAGE
:
2799 case MDACIOCTL_READIMAGE
:
2800 case MDACIOCTL_FLASHIMAGES
:
2801 case MDACIOCTL_RENAMERAIDDEV
:
2802 default: /* no idea what to print */
2808 case MDACMD_IOCTLCHECK
:
2809 case MDACMD_MEMCOPY
:
2812 break; /* print nothing */
2815 if (ge
->command_control
.extended_sg_table
) {
2816 mly_printf(sc
, " sg table 0x%llx/%d\n",
2817 ge
->transfer
.indirect
.table_physaddr
[0], ge
->transfer
.indirect
.entries
[0]);
2819 mly_printf(sc
, " 0000 0x%llx/%lld\n",
2820 ge
->transfer
.direct
.sg
[0].physaddr
, ge
->transfer
.direct
.sg
[0].length
);
2821 mly_printf(sc
, " 0001 0x%llx/%lld\n",
2822 ge
->transfer
.direct
.sg
[1].physaddr
, ge
->transfer
.direct
.sg
[1].length
);
2827 /********************************************************************************
2828 * Panic in a slightly informative fashion
2831 mly_panic(struct mly_softc
*sc
, char *reason
)
2837 /********************************************************************************
2838 * Print queue statistics, callable from DDB.
2841 mly_print_controller(int controller
)
2843 struct mly_softc
*sc
;
2845 if ((sc
= devclass_get_softc(devclass_find("mly"), controller
)) == NULL
) {
2846 kprintf("mly: controller %d invalid\n", controller
);
2848 device_printf(sc
->mly_dev
, "queue curr max\n");
2849 device_printf(sc
->mly_dev
, "free %04d/%04d\n",
2850 sc
->mly_qstat
[MLYQ_FREE
].q_length
, sc
->mly_qstat
[MLYQ_FREE
].q_max
);
2851 device_printf(sc
->mly_dev
, "busy %04d/%04d\n",
2852 sc
->mly_qstat
[MLYQ_BUSY
].q_length
, sc
->mly_qstat
[MLYQ_BUSY
].q_max
);
2853 device_printf(sc
->mly_dev
, "complete %04d/%04d\n",
2854 sc
->mly_qstat
[MLYQ_COMPLETE
].q_length
, sc
->mly_qstat
[MLYQ_COMPLETE
].q_max
);
2860 /********************************************************************************
2861 ********************************************************************************
2862 Control device interface
2863 ********************************************************************************
2864 ********************************************************************************/
2866 /********************************************************************************
2867 * Accept an open operation on the control device.
2870 mly_user_open(struct dev_open_args
*ap
)
2872 cdev_t dev
= ap
->a_head
.a_dev
;
2873 int unit
= minor(dev
);
2874 struct mly_softc
*sc
= devclass_get_softc(devclass_find("mly"), unit
);
2876 sc
->mly_state
|= MLY_STATE_OPEN
;
2880 /********************************************************************************
2881 * Accept the last close on the control device.
2884 mly_user_close(struct dev_close_args
*ap
)
2886 cdev_t dev
= ap
->a_head
.a_dev
;
2887 int unit
= minor(dev
);
2888 struct mly_softc
*sc
= devclass_get_softc(devclass_find("mly"), unit
);
2890 sc
->mly_state
&= ~MLY_STATE_OPEN
;
2894 /********************************************************************************
2895 * Handle controller-specific control operations.
2898 mly_user_ioctl(struct dev_ioctl_args
*ap
)
2900 cdev_t dev
= ap
->a_head
.a_dev
;
2901 struct mly_softc
*sc
= (struct mly_softc
*)dev
->si_drv1
;
2902 struct mly_user_command
*uc
= (struct mly_user_command
*)ap
->a_data
;
2903 struct mly_user_health
*uh
= (struct mly_user_health
*)ap
->a_data
;
2907 return(mly_user_command(sc
, uc
));
2909 return(mly_user_health(sc
, uh
));
2915 /********************************************************************************
2916 * Execute a command passed in from userspace.
2918 * The control structure contains the actual command for the controller, as well
2919 * as the user-space data pointer and data size, and an optional sense buffer
2920 * size/pointer. On completion, the data size is adjusted to the command
2921 * residual, and the sense buffer size to the size of the returned sense data.
2925 mly_user_command(struct mly_softc
*sc
, struct mly_user_command
*uc
)
2927 struct mly_command
*mc
;
2930 /* allocate a command */
2931 if (mly_alloc_command(sc
, &mc
)) {
2933 goto out
; /* XXX Linux version will wait for a command */
2936 /* handle data size/direction */
2937 mc
->mc_length
= (uc
->DataTransferLength
>= 0) ? uc
->DataTransferLength
: -uc
->DataTransferLength
;
2938 if (mc
->mc_length
> 0)
2939 mc
->mc_data
= kmalloc(mc
->mc_length
, M_DEVBUF
, M_INTWAIT
);
2940 if (uc
->DataTransferLength
> 0) {
2941 mc
->mc_flags
|= MLY_CMD_DATAIN
;
2942 bzero(mc
->mc_data
, mc
->mc_length
);
2944 if (uc
->DataTransferLength
< 0) {
2945 mc
->mc_flags
|= MLY_CMD_DATAOUT
;
2946 if ((error
= copyin(uc
->DataTransferBuffer
, mc
->mc_data
, mc
->mc_length
)) != 0)
2950 /* copy the controller command */
2951 bcopy(&uc
->CommandMailbox
, mc
->mc_packet
, sizeof(uc
->CommandMailbox
));
2953 /* clear command completion handler so that we get woken up */
2954 mc
->mc_complete
= NULL
;
2956 /* execute the command */
2957 if ((error
= mly_start(mc
)) != 0)
2960 while (!(mc
->mc_flags
& MLY_CMD_COMPLETE
))
2961 tsleep(mc
, 0, "mlyioctl", 0);
2964 /* return the data to userspace */
2965 if (uc
->DataTransferLength
> 0)
2966 if ((error
= copyout(mc
->mc_data
, uc
->DataTransferBuffer
, mc
->mc_length
)) != 0)
2969 /* return the sense buffer to userspace */
2970 if ((uc
->RequestSenseLength
> 0) && (mc
->mc_sense
> 0)) {
2971 if ((error
= copyout(mc
->mc_packet
, uc
->RequestSenseBuffer
,
2972 min(uc
->RequestSenseLength
, mc
->mc_sense
))) != 0)
2976 /* return command results to userspace (caller will copy out) */
2977 uc
->DataTransferLength
= mc
->mc_resid
;
2978 uc
->RequestSenseLength
= min(uc
->RequestSenseLength
, mc
->mc_sense
);
2979 uc
->CommandStatus
= mc
->mc_status
;
2983 if (mc
->mc_data
!= NULL
)
2984 kfree(mc
->mc_data
, M_DEVBUF
);
2986 mly_release_command(mc
);
2990 /********************************************************************************
2991 * Return health status to userspace. If the health change index in the user
2992 * structure does not match that currently exported by the controller, we
2993 * return the current status immediately. Otherwise, we block until either
2994 * interrupted or new status is delivered.
2997 mly_user_health(struct mly_softc
*sc
, struct mly_user_health
*uh
)
2999 struct mly_health_status mh
;
3002 /* fetch the current health status from userspace */
3003 if ((error
= copyin(uh
->HealthStatusBuffer
, &mh
, sizeof(mh
))) != 0)
3006 /* spin waiting for a status update */
3008 error
= EWOULDBLOCK
;
3009 while ((error
!= 0) && (sc
->mly_event_change
== mh
.change_counter
))
3010 error
= tsleep(&sc
->mly_event_change
, PCATCH
, "mlyhealth", 0);
3013 /* copy the controller's health status buffer out (there is a race here if it changes again) */
3014 error
= copyout(&sc
->mly_mmbox
->mmm_health
.status
, uh
->HealthStatusBuffer
,
3015 sizeof(uh
->HealthStatusBuffer
));
3020 mly_timeout(struct mly_softc
*sc
)
3022 struct mly_command
*mc
;
3025 deadline
= time_second
- MLY_CMD_TIMEOUT
;
3026 TAILQ_FOREACH(mc
, &sc
->mly_busy
, mc_link
) {
3027 if ((mc
->mc_timestamp
< deadline
)) {
3028 device_printf(sc
->mly_dev
,
3029 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", mc
,
3030 (int)(time_second
- mc
->mc_timestamp
));
3034 callout_reset(&sc
->mly_timeout
, MLY_CMD_TIMEOUT
* hz
,
3035 (timeout_t
*)mly_timeout
, sc
);