/usr/src/sys/dev/pci/mfii.c

Bug Summary

File:	dev/pci/mfii.c
Warning:	line 3201, column 17 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name mfii.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/mfii.c
1/* $OpenBSD: mfii.c,v 1.89 2023/07/06 10:17:43 visa Exp $ */

3/*
* Copyright (c) 2012 David Gwynne <dlg@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

19#include "bio.h"

21#include <sys/param.h>
22#include <sys/systm.h>
23#include <sys/malloc.h>
24#include <sys/device.h>
25#include <sys/dkio.h>
26#include <sys/pool.h>
27#include <sys/task.h>
28#include <sys/atomic.h>
29#include <sys/sensors.h>
30#include <sys/rwlock.h>
31#include <sys/syslog.h>
32#include <sys/smr.h>

34#include <dev/biovar.h>
35#include <dev/pci/pcidevs.h>
36#include <dev/pci/pcivar.h>

38#include <machine/bus.h>

40#include <scsi/scsi_all.h>
41#include <scsi/scsi_disk.h>
42#include <scsi/scsiconf.h>

44#include <dev/ic/mfireg.h>
45#include <dev/pci/mpiireg.h>

47#define	MFII_BAR0x14		0x14
48#define MFII_BAR_350x10		0x10
49#define	MFII_PCI_MEMSIZE0x2000	0x2000 /* 8k */

51#define MFII_OSTS_INTR_VALID0x00000009	0x00000009
52#define MFII_RPI0x6c		0x6c /* reply post host index */
53#define MFII_OSP20xb4		0xb4 /* outbound scratch pad 2 */
54#define MFII_OSP30xb8		0xb8 /* outbound scratch pad 3 */

56#define MFII_REQ_TYPE_SCSI(0x00)	MPII_REQ_DESCR_SCSI_IO(0x00)
57#define MFII_REQ_TYPE_LDIO(0x7 << 1)	(0x7 << 1)
58#define MFII_REQ_TYPE_MFA(0x1 << 1)	(0x1 << 1)
59#define MFII_REQ_TYPE_NO_LOCK(0x2 << 1)	(0x2 << 1)
60#define MFII_REQ_TYPE_HI_PRI(0x6 << 1)	(0x6 << 1)

62#define MFII_REQ_MFA(_a)((__uint64_t)((_a) | (0x1 << 1)))	htole64((_a) | MFII_REQ_TYPE_MFA)((__uint64_t)((_a) | (0x1 << 1)))

64#define MFII_FUNCTION_PASSTHRU_IO(0xf0)			(0xf0)
65#define MFII_FUNCTION_LDIO_REQUEST(0xf1)			(0xf1)

67#define MFII_MAX_CHAIN_UNIT0x00400000	0x00400000
68#define MFII_MAX_CHAIN_MASK0x000003E0	0x000003E0
69#define MFII_MAX_CHAIN_SHIFT5	5

71#define MFII_256K_IO128		128
72#define MFII_1MB_IO(128 * 4)		(MFII_256K_IO128 * 4)

74#define MFII_CHAIN_FRAME_MIN1024	1024

76struct mfii_request_descr {
u_int8_t	flags;
u_int8_t	msix_index;
u_int16_t	smid;

u_int16_t	lmid;
u_int16_t	dev_handle;
83} __packed__attribute__((__packed__));

85#define MFII_RAID_CTX_IO_TYPE_SYSPD(0x1 << 4)	(0x1 << 4)
86#define MFII_RAID_CTX_TYPE_CUDA(0x2 << 4)		(0x2 << 4)

88struct mfii_raid_context {
u_int8_t	type_nseg;
u_int8_t	_reserved1;
u_int16_t	timeout_value;

u_int16_t	reg_lock_flags;
94#define MFII_RAID_CTX_RL_FLAGS_SEQNO_EN(0x08)	(0x08)
95#define MFII_RAID_CTX_RL_FLAGS_CPU0(0x00)	(0x00)
96#define MFII_RAID_CTX_RL_FLAGS_CPU1(0x10)	(0x10)
97#define MFII_RAID_CTX_RL_FLAGS_CUDA(0x80)	(0x80)

99#define MFII_RAID_CTX_ROUTING_FLAGS_SQN(1 << 4)	(1 << 4)
100#define MFII_RAID_CTX_ROUTING_FLAGS_CPU00 0
u_int16_t	virtual_disk_target_id;

u_int64_t	reg_lock_row_lba;

u_int32_t	reg_lock_length;

u_int16_t	next_lm_id;
u_int8_t	ex_status;
u_int8_t	status;

u_int8_t	raid_flags;
u_int8_t	num_sge;
u_int16_t	config_seq_num;

u_int8_t	span_arm;
u_int8_t	_reserved3[3];
117} __packed__attribute__((__packed__));

119struct mfii_sge {
u_int64_t	sg_addr;
u_int32_t	sg_len;
u_int16_t	_reserved;
u_int8_t	sg_next_chain_offset;
u_int8_t	sg_flags;
125} __packed__attribute__((__packed__));

127#define MFII_SGE_ADDR_MASK(0x03)		(0x03)
128#define MFII_SGE_ADDR_SYSTEM(0x00)		(0x00)
129#define MFII_SGE_ADDR_IOCDDR(0x01)		(0x01)
130#define MFII_SGE_ADDR_IOCPLB(0x02)		(0x02)
131#define MFII_SGE_ADDR_IOCPLBNTA(0x03)		(0x03)
132#define MFII_SGE_END_OF_LIST(0x40)		(0x40)
133#define MFII_SGE_CHAIN_ELEMENT(0x80)		(0x80)

135#define MFII_REQUEST_SIZE256	256

137#define MR_DCMD_LD_MAP_GET_INFO0x0300e101			0x0300e101

139#define MFII_MAX_ROW32		32
140#define MFII_MAX_ARRAY128		128

142struct mfii_array_map {
uint16_t		mam_pd[MFII_MAX_ROW32];
144} __packed__attribute__((__packed__));

146struct mfii_dev_handle {
uint16_t		mdh_cur_handle;
uint8_t			mdh_valid;
uint8_t			mdh_reserved;
uint16_t		mdh_handle[2];
151} __packed__attribute__((__packed__));

153struct mfii_ld_map {
uint32_t		mlm_total_size;
uint32_t		mlm_reserved1[5];
uint32_t		mlm_num_lds;
uint32_t		mlm_reserved2;
uint8_t			mlm_tgtid_to_ld[2 * MFI_MAX_LD64];
uint8_t			mlm_pd_timeout;
uint8_t			mlm_reserved3[7];
struct mfii_array_map	mlm_am[MFII_MAX_ARRAY128];
struct mfii_dev_handle	mlm_dev_handle[MFI_MAX_PD256];
163} __packed__attribute__((__packed__));

165struct mfii_task_mgmt {
union {
uint8_t			request[128];
struct mpii_msg_scsi_task_request
			mpii_request;
} __packed__attribute__((__packed__)) __aligned(8)__attribute__((__aligned__(8)));

union {
uint8_t			reply[128];
uint32_t		flags;
175#define MFII_TASK_MGMT_FLAGS_LD(1 << 0)				(1 << 0)
176#define MFII_TASK_MGMT_FLAGS_PD(1 << 1)				(1 << 1)
struct mpii_msg_scsi_task_reply
			mpii_reply;
} __packed__attribute__((__packed__)) __aligned(8)__attribute__((__aligned__(8)));
180} __packed__attribute__((__packed__)) __aligned(8)__attribute__((__aligned__(8)));

182struct mfii_dmamem {
bus_dmamap_t		mdm_map;
bus_dma_segment_t	mdm_seg;
size_t			mdm_size;
caddr_t			mdm_kva;
187};
188#define MFII_DMA_MAP(_mdm)((_mdm)->mdm_map)	((_mdm)->mdm_map)
189#define MFII_DMA_LEN(_mdm)((_mdm)->mdm_size)	((_mdm)->mdm_size)
190#define MFII_DMA_DVA(_mdm)((u_int64_t)(_mdm)->mdm_map->dm_segs[0].ds_addr)	((u_int64_t)(_mdm)->mdm_map->dm_segs[0].ds_addr)
191#define MFII_DMA_KVA(_mdm)((void *)(_mdm)->mdm_kva)	((void *)(_mdm)->mdm_kva)

193struct mfii_softc;

195struct mfii_ccb {
void			*ccb_request;
u_int64_t		ccb_request_dva;
bus_addr_t		ccb_request_offset;

void			*ccb_mfi;
u_int64_t		ccb_mfi_dva;
bus_addr_t		ccb_mfi_offset;

struct mfi_sense	*ccb_sense;
u_int64_t		ccb_sense_dva;
bus_addr_t		ccb_sense_offset;

struct mfii_sge		*ccb_sgl;
u_int64_t		ccb_sgl_dva;
bus_addr_t		ccb_sgl_offset;
u_int			ccb_sgl_len;

struct mfii_request_descr ccb_req;

bus_dmamap_t		ccb_dmamap;

/* data for sgl */
void			*ccb_data;
size_t			ccb_len;

int			ccb_direction;
222#define MFII_DATA_NONE0			0
223#define MFII_DATA_IN1			1
224#define MFII_DATA_OUT2			2

void			*ccb_cookie;
void			(*ccb_done)(struct mfii_softc *,
		    struct mfii_ccb *);

u_int32_t		ccb_flags;
231#define MFI_CCB_F_ERR(1<<0)			(1<<0)
u_int			ccb_smid;
u_int			ccb_refcnt;
SIMPLEQ_ENTRY(mfii_ccb)struct { struct mfii_ccb *sqe_next; }	ccb_link;
235};
236SIMPLEQ_HEAD(mfii_ccb_list, mfii_ccb)struct mfii_ccb_list { struct mfii_ccb *sqh_first; struct mfii_ccb
 **sqh_last; };

238struct mfii_pd_dev_handles {
struct smr_entry	pd_smr;
uint16_t		pd_handles[MFI_MAX_PD256];
241};

243struct mfii_pd_softc {
struct scsibus_softc	*pd_scsibus;
struct mfii_pd_dev_handles *pd_dev_handles;
uint8_t			pd_timeout;
247};

249struct mfii_iop {
int bar;
int num_sge_loc;
252#define MFII_IOP_NUM_SGE_LOC_ORIG0	0
253#define MFII_IOP_NUM_SGE_LOC_351		1
u_int16_t ldio_ctx_reg_lock_flags;
u_int8_t ldio_req_type;
u_int8_t ldio_ctx_type_nseg;
u_int8_t sge_flag_chain;
u_int8_t sge_flag_eol;
259};

261struct mfii_softc {
struct device		sc_dev;
const struct mfii_iop	*sc_iop;

pci_chipset_tag_t	sc_pc;
pcitag_t		sc_tag;

bus_space_tag_t		sc_iot;
bus_space_handle_t	sc_ioh;
bus_size_t		sc_ios;
bus_dma_tag_t		sc_dmat;

void			*sc_ih;

struct mutex		sc_ccb_mtx;
struct mutex		sc_post_mtx;

u_int			sc_max_fw_cmds;
u_int			sc_max_cmds;
u_int			sc_max_sgl;

u_int			sc_reply_postq_depth;
u_int			sc_reply_postq_index;
struct mutex		sc_reply_postq_mtx;
struct mfii_dmamem	*sc_reply_postq;

struct mfii_dmamem	*sc_requests;
struct mfii_dmamem	*sc_mfi;
struct mfii_dmamem	*sc_sense;
struct mfii_dmamem	*sc_sgl;

struct mfii_ccb		*sc_ccb;
struct mfii_ccb_list	sc_ccb_freeq;

struct mfii_ccb		*sc_aen_ccb;
struct task		sc_aen_task;

struct mutex		sc_abort_mtx;
struct mfii_ccb_list	sc_abort_list;
struct task		sc_abort_task;

struct scsibus_softc	*sc_scsibus;
struct mfii_pd_softc	*sc_pd;
struct scsi_iopool	sc_iopool;

/* save some useful information for logical drives that is missing
* in sc_ld_list
*/
struct {
char		ld_dev[16];	/* device name sd? */
}			sc_ld[MFI_MAX_LD64];
int			sc_target_lds[MFI_MAX_LD64];

/* scsi ioctl from sd device */
int			(*sc_ioctl)(struct device *, u_long, caddr_t);

/* bio */
struct mfi_conf		*sc_cfg;
struct mfi_ctrl_info	sc_info;
struct mfi_ld_list	sc_ld_list;
struct mfi_ld_details	*sc_ld_details; /* array to all logical disks */
int			sc_no_pd; /* used physical disks */
int			sc_ld_sz; /* sizeof sc_ld_details */

/* mgmt lock */
struct rwlock		sc_lock;

/* sensors */
struct ksensordev	sc_sensordev;
struct ksensor		*sc_bbu;
struct ksensor		*sc_bbu_status;
struct ksensor		*sc_sensors;
333};

335#ifdef MFII_DEBUG
336#define DPRINTF(x...)		do { if (mfii_debug) printf(x); } while(0)
337#define DNPRINTF(n,x...)	do { if (mfii_debug & n) printf(x); } while(0)
338#define	MFII_D_CMD		0x0001
339#define	MFII_D_INTR		0x0002
340#define	MFII_D_MISC		0x0004
341#define	MFII_D_DMA		0x0008
342#define	MFII_D_IOCTL		0x0010
343#define	MFII_D_RW		0x0020
344#define	MFII_D_MEM		0x0040
345#define	MFII_D_CCB		0x0080
346uint32_t	mfii_debug = 0
347/*		    | MFII_D_CMD */
348/*		    | MFII_D_INTR */
    | MFII_D_MISC
350/*		    | MFII_D_DMA */
351/*		    | MFII_D_IOCTL */
352/*		    | MFII_D_RW */
353/*		    | MFII_D_MEM */
354/*		    | MFII_D_CCB */
;
356#else
357#define DPRINTF(x...)
358#define DNPRINTF(n,x...)
359#endif

361int		mfii_match(struct device *, void *, void *);
362void		mfii_attach(struct device *, struct device *, void *);
363int		mfii_detach(struct device *, int);
364int		mfii_activate(struct device *, int);

366const struct cfattach mfii_ca = {
sizeof(struct mfii_softc),
mfii_match,
mfii_attach,
mfii_detach,
mfii_activate,
372};

374struct cfdriver mfii_cd = {
NULL((void *)0),
"mfii",
DV_DULL
378};

380void		mfii_scsi_cmd(struct scsi_xfer *);
381void		mfii_scsi_cmd_done(struct mfii_softc *, struct mfii_ccb *);
382int		mfii_scsi_ioctl(struct scsi_link *, u_long, caddr_t, int);
383int		mfii_ioctl_cache(struct scsi_link *, u_long, struct dk_cache *);

385const struct scsi_adapter mfii_switch = {
mfii_scsi_cmd, NULL((void *)0), NULL((void *)0), NULL((void *)0), mfii_scsi_ioctl
387};

389void		mfii_pd_scsi_cmd(struct scsi_xfer *);
390int		mfii_pd_scsi_probe(struct scsi_link *);

392const struct scsi_adapter mfii_pd_switch = {
mfii_pd_scsi_cmd, NULL((void *)0), mfii_pd_scsi_probe, NULL((void *)0), NULL((void *)0),
394};

396#define DEVNAME(_sc)((_sc)->sc_dev.dv_xname)		((_sc)->sc_dev.dv_xname)

398u_int32_t		mfii_read(struct mfii_softc *, bus_size_t);
399void			mfii_write(struct mfii_softc *, bus_size_t, u_int32_t);

401struct mfii_dmamem *	mfii_dmamem_alloc(struct mfii_softc *, size_t);
402void			mfii_dmamem_free(struct mfii_softc *,
	    struct mfii_dmamem *);

405void *			mfii_get_ccb(void *);
406void			mfii_put_ccb(void *, void *);
407int			mfii_init_ccb(struct mfii_softc *);
408void			mfii_scrub_ccb(struct mfii_ccb *);

410int			mfii_reset_hard(struct mfii_softc *);
411int			mfii_transition_firmware(struct mfii_softc *);
412int			mfii_initialise_firmware(struct mfii_softc *);
413int			mfii_get_info(struct mfii_softc *);
414int			mfii_syspd(struct mfii_softc *);

416void			mfii_start(struct mfii_softc *, struct mfii_ccb *);
417void			mfii_done(struct mfii_softc *, struct mfii_ccb *);
418int			mfii_poll(struct mfii_softc *, struct mfii_ccb *);
419void			mfii_poll_done(struct mfii_softc *, struct mfii_ccb *);
420int			mfii_exec(struct mfii_softc *, struct mfii_ccb *);
421void			mfii_exec_done(struct mfii_softc *, struct mfii_ccb *);
422int			mfii_my_intr(struct mfii_softc *);
423int			mfii_intr(void *);
424void			mfii_postq(struct mfii_softc *);

426int			mfii_load_ccb(struct mfii_softc *, struct mfii_ccb *,
	    void *, int);
428int			mfii_load_mfa(struct mfii_softc *, struct mfii_ccb *,
	    void *, int);

431int			mfii_mfa_poll(struct mfii_softc *, struct mfii_ccb *);

433int			mfii_mgmt(struct mfii_softc *, uint32_t,
	    const union mfi_mbox *, void *, size_t, int);
435int			mfii_do_mgmt(struct mfii_softc *, struct mfii_ccb *,
	    uint32_t, const union mfi_mbox *, void *, size_t,
	    int);
438void			mfii_empty_done(struct mfii_softc *, struct mfii_ccb *);

440int			mfii_scsi_cmd_io(struct mfii_softc *,
	    struct scsi_xfer *);
442int			mfii_scsi_cmd_cdb(struct mfii_softc *,
	    struct scsi_xfer *);
444int			mfii_pd_scsi_cmd_cdb(struct mfii_softc *,
	    struct scsi_xfer *);
446void			mfii_scsi_cmd_tmo(void *);

448int			mfii_dev_handles_update(struct mfii_softc *sc);
449void			mfii_dev_handles_smr(void *pd_arg);

451void			mfii_abort_task(void *);
452void			mfii_abort(struct mfii_softc *, struct mfii_ccb *,
	    uint16_t, uint16_t, uint8_t, uint32_t);
454void			mfii_scsi_cmd_abort_done(struct mfii_softc *,
	    struct mfii_ccb *);

457int			mfii_aen_register(struct mfii_softc *);
458void			mfii_aen_start(struct mfii_softc *, struct mfii_ccb *,
	    struct mfii_dmamem *, uint32_t);
460void			mfii_aen_done(struct mfii_softc *, struct mfii_ccb *);
461void			mfii_aen(void *);
462void			mfii_aen_unregister(struct mfii_softc *);

464void			mfii_aen_pd_insert(struct mfii_softc *,
	    const struct mfi_evtarg_pd_address *);
466void			mfii_aen_pd_remove(struct mfii_softc *,
	    const struct mfi_evtarg_pd_address *);
468void			mfii_aen_pd_state_change(struct mfii_softc *,
	    const struct mfi_evtarg_pd_state *);
470void			mfii_aen_ld_update(struct mfii_softc *);

472#if NBIO1 > 0
473int		mfii_ioctl(struct device *, u_long, caddr_t);
474int		mfii_bio_getitall(struct mfii_softc *);
475int		mfii_ioctl_inq(struct mfii_softc *, struct bioc_inq *);
476int		mfii_ioctl_vol(struct mfii_softc *, struct bioc_vol *);
477int		mfii_ioctl_disk(struct mfii_softc *, struct bioc_disk *);
478int		mfii_ioctl_alarm(struct mfii_softc *, struct bioc_alarm *);
479int		mfii_ioctl_blink(struct mfii_softc *sc, struct bioc_blink *);
480int		mfii_ioctl_setstate(struct mfii_softc *,
    struct bioc_setstate *);
482int		mfii_ioctl_patrol(struct mfii_softc *sc, struct bioc_patrol *);
483int		mfii_bio_hs(struct mfii_softc *, int, int, void *);

485#ifndef SMALL_KERNEL
486static const char *mfi_bbu_indicators[] = {
"pack missing",
"voltage low",
"temp high",
"charge active",
"discharge active",
"learn cycle req'd",
"learn cycle active",
"learn cycle failed",
"learn cycle timeout",
"I2C errors",
"replace pack",
"low capacity",
"periodic learn req'd"
500};

502void		mfii_init_ld_sensor(struct mfii_softc *, int);
503void		mfii_refresh_ld_sensor(struct mfii_softc *, int);
504int		mfii_create_sensors(struct mfii_softc *);
505void		mfii_refresh_sensors(void *);
506void		mfii_bbu(struct mfii_softc *);
507#endif /* SMALL_KERNEL */
508#endif /* NBIO > 0 */

510/*
* mfii boards support asynchronous (and non-polled) completion of
* dcmds by proxying them through a passthru mpii command that points
* at a dcmd frame. since the passthru command is submitted like
* the scsi commands using an SMID in the request descriptor,
* ccb_request memory * must contain the passthru command because
* that is what the SMID refers to. this means ccb_request cannot
* contain the dcmd. rather than allocating separate dma memory to
* hold the dcmd, we reuse the sense memory buffer for it.
*/

521void			mfii_dcmd_start(struct mfii_softc *,
	    struct mfii_ccb *);

524static inline void
525mfii_dcmd_scrub(struct mfii_ccb *ccb)
526{
memset(ccb->ccb_sense, 0, sizeof(*ccb->ccb_sense))__builtin_memset((ccb->ccb_sense), (0), (sizeof(*ccb->ccb_sense
)));
528}

530static inline struct mfi_dcmd_frame *
531mfii_dcmd_frame(struct mfii_ccb *ccb)
532{
CTASSERT(sizeof(struct mfi_dcmd_frame) <= sizeof(*ccb->ccb_sense))extern char _ctassert[(sizeof(struct mfi_dcmd_frame) <= sizeof
(*ccb->ccb_sense)) ? 1 : -1 ] __attribute__((__unused__));
return ((struct mfi_dcmd_frame *)ccb->ccb_sense);
535}

537static inline void
538mfii_dcmd_sync(struct mfii_softc *sc, struct mfii_ccb *ccb, int flags)
539{
bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_sense),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sense)->mdm_map)), (ccb->ccb_sense_offset), (sizeof(
*ccb->ccb_sense)), (flags))
   ccb->ccb_sense_offset, sizeof(*ccb->ccb_sense), flags)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sense)->mdm_map)), (ccb->ccb_sense_offset), (sizeof(
*ccb->ccb_sense)), (flags));
542}

544#define mfii_fw_state(_sc)mfii_read((_sc), 0xb0) mfii_read((_sc), MFI_OSP0xb0)

546const struct mfii_iop mfii_iop_thunderbolt = {
MFII_BAR0x14,
MFII_IOP_NUM_SGE_LOC_ORIG0,
0,
MFII_REQ_TYPE_LDIO(0x7 << 1),
0,
MFII_SGE_CHAIN_ELEMENT(0x80) | MFII_SGE_ADDR_IOCPLBNTA(0x03),
0
554};

556/*
* a lot of these values depend on us not implementing fastpath yet.
*/
559const struct mfii_iop mfii_iop_25 = {
MFII_BAR0x14,
MFII_IOP_NUM_SGE_LOC_ORIG0,
MFII_RAID_CTX_RL_FLAGS_CPU0(0x00), /* | MFII_RAID_CTX_RL_FLAGS_SEQNO_EN */
MFII_REQ_TYPE_NO_LOCK(0x2 << 1),
MFII_RAID_CTX_TYPE_CUDA(0x2 << 4) | 0x1,
MFII_SGE_CHAIN_ELEMENT(0x80),
MFII_SGE_END_OF_LIST(0x40)
567};

569const struct mfii_iop mfii_iop_35 = {
MFII_BAR_350x10,
MFII_IOP_NUM_SGE_LOC_351,
MFII_RAID_CTX_ROUTING_FLAGS_CPU00, /* | MFII_RAID_CTX_ROUTING_FLAGS_SQN */
MFII_REQ_TYPE_NO_LOCK(0x2 << 1),
MFII_RAID_CTX_TYPE_CUDA(0x2 << 4) | 0x1,
MFII_SGE_CHAIN_ELEMENT(0x80),
MFII_SGE_END_OF_LIST(0x40)
577};

579struct mfii_device {
pcireg_t		mpd_vendor;
pcireg_t		mpd_product;
const struct mfii_iop	*mpd_iop;
583};

585const struct mfii_device mfii_devices[] = {
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_22080x005b,
   &mfii_iop_thunderbolt },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_30080x005f,
   &mfii_iop_25 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_31080x005d,
   &mfii_iop_25 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_34040x001c,
   &mfii_iop_35 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_35040x001b,
   &mfii_iop_35 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_34080x0017,
   &mfii_iop_35 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_35080x0016,
   &mfii_iop_35 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_34160x0015,
   &mfii_iop_35 },
{ PCI_VENDOR_SYMBIOS0x1000,	PCI_PRODUCT_SYMBIOS_MEGARAID_35160x0014,
   &mfii_iop_35 }
604};

606const struct mfii_iop *mfii_find_iop(struct pci_attach_args *);

608const struct mfii_iop *
609mfii_find_iop(struct pci_attach_args *pa)
610{
const struct mfii_device *mpd;
int i;

for (i = 0; i < nitems(mfii_devices)(sizeof((mfii_devices)) / sizeof((mfii_devices)[0])); i++) {
mpd = &mfii_devices[i];

if (mpd->mpd_vendor == PCI_VENDOR(pa->pa_id)(((pa->pa_id) >> 0) & 0xffff) &&
    mpd->mpd_product == PCI_PRODUCT(pa->pa_id)(((pa->pa_id) >> 16) & 0xffff))
	return (mpd->mpd_iop);
}

return (NULL((void *)0));
623}

625int
626mfii_match(struct device *parent, void *match, void *aux)
627{
return ((mfii_find_iop(aux) != NULL((void *)0)) ? 1 : 0);
629}

631void
632mfii_attach(struct device *parent, struct device *self, void *aux)
633{
struct mfii_softc *sc = (struct mfii_softc *)self;
struct pci_attach_args *pa = aux;
pcireg_t memtype;
pci_intr_handle_t ih;
struct scsibus_attach_args saa;
u_int32_t status, scpad2, scpad3;
int chain_frame_sz, nsge_in_io, nsge_in_chain, i;

/* init sc */
sc->sc_iop = mfii_find_iop(aux);
sc->sc_dmat = pa->pa_dmat;
SIMPLEQ_INIT(&sc->sc_ccb_freeq)do { (&sc->sc_ccb_freeq)->sqh_first = ((void *)0); (
&sc->sc_ccb_freeq)->sqh_last = &(&sc->sc_ccb_freeq
)->sqh_first; } while (0);
mtx_init(&sc->sc_ccb_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sc->
sc_ccb_mtx), ((((0x3)) > 0x0 && ((0x3)) < 0x9) ?
 0x9 : ((0x3)))); } while (0);
mtx_init(&sc->sc_post_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sc->
sc_post_mtx), ((((0x3)) > 0x0 && ((0x3)) < 0x9)
 ? 0x9 : ((0x3)))); } while (0);
mtx_init(&sc->sc_reply_postq_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sc->
sc_reply_postq_mtx), ((((0x3)) > 0x0 && ((0x3)) <
 0x9) ? 0x9 : ((0x3)))); } while (0);
scsi_iopool_init(&sc->sc_iopool, sc, mfii_get_ccb, mfii_put_ccb);

rw_init(&sc->sc_lock, "mfii_lock")_rw_init_flags(&sc->sc_lock, "mfii_lock", 0, ((void *)
0));

sc->sc_aen_ccb = NULL((void *)0);
task_set(&sc->sc_aen_task, mfii_aen, sc);

mtx_init(&sc->sc_abort_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sc->
sc_abort_mtx), ((((0x3)) > 0x0 && ((0x3)) < 0x9
) ? 0x9 : ((0x3)))); } while (0);
SIMPLEQ_INIT(&sc->sc_abort_list)do { (&sc->sc_abort_list)->sqh_first = ((void *)0);
 (&sc->sc_abort_list)->sqh_last = &(&sc->
sc_abort_list)->sqh_first; } while (0);
task_set(&sc->sc_abort_task, mfii_abort_task, sc);

/* wire up the bus shizz */
memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, sc->sc_iop->bar);
if (pci_mapreg_map(pa, sc->sc_iop->bar, memtype, 0,
   &sc->sc_iot, &sc->sc_ioh, NULL((void *)0), &sc->sc_ios, MFII_PCI_MEMSIZE0x2000)) {
printf(": unable to map registers\n");
return;
}

/* disable interrupts */
mfii_write(sc, MFI_OMSK0x34, 0xffffffff);

if (pci_intr_map_msi(pa, &ih) != 0 && pci_intr_map(pa, &ih) != 0) {
printf(": unable to map interrupt\n");
goto pci_unmap;
}
printf(": %s\n", pci_intr_string(pa->pa_pc, ih));

/* lets get started */
if (mfii_transition_firmware(sc))
goto pci_unmap;

/* determine max_cmds (refer to the Linux megaraid_sas driver) */
scpad3 = mfii_read(sc, MFII_OSP30xb8);
status = mfii_fw_state(sc)mfii_read((sc), 0xb0);
sc->sc_max_fw_cmds = scpad3 & MFI_STATE_MAXCMD_MASK0x0000ffff;
if (sc->sc_max_fw_cmds == 0)
sc->sc_max_fw_cmds = status & MFI_STATE_MAXCMD_MASK0x0000ffff;
/*
* reduce max_cmds by 1 to ensure that the reply queue depth does not
* exceed FW supplied max_fw_cmds.
*/
sc->sc_max_cmds = min(sc->sc_max_fw_cmds, 1024) - 1;

/* determine max_sgl (refer to the Linux megaraid_sas driver) */
scpad2 = mfii_read(sc, MFII_OSP20xb4);
chain_frame_sz =
((scpad2 & MFII_MAX_CHAIN_MASK0x000003E0) >> MFII_MAX_CHAIN_SHIFT5) *
((scpad2 & MFII_MAX_CHAIN_UNIT0x00400000) ? MFII_1MB_IO(128 * 4) : MFII_256K_IO128);
if (chain_frame_sz < MFII_CHAIN_FRAME_MIN1024)
chain_frame_sz = MFII_CHAIN_FRAME_MIN1024;

nsge_in_io = (MFII_REQUEST_SIZE256 -
sizeof(struct mpii_msg_scsi_io) -
sizeof(struct mfii_raid_context)) / sizeof(struct mfii_sge);
nsge_in_chain = chain_frame_sz / sizeof(struct mfii_sge);

/* round down to nearest power of two */
sc->sc_max_sgl = 1;
while ((sc->sc_max_sgl << 1) <= (nsge_in_io + nsge_in_chain))
sc->sc_max_sgl <<= 1;

DNPRINTF(MFII_D_MISC, "%s: OSP 0x%08x, OSP2 0x%08x, OSP3 0x%08x\n",
   DEVNAME(sc), status, scpad2, scpad3);
DNPRINTF(MFII_D_MISC, "%s: max_fw_cmds %d, max_cmds %d\n",
   DEVNAME(sc), sc->sc_max_fw_cmds, sc->sc_max_cmds);
DNPRINTF(MFII_D_MISC, "%s: nsge_in_io %d, nsge_in_chain %d, "
   "max_sgl %d\n", DEVNAME(sc), nsge_in_io, nsge_in_chain,
   sc->sc_max_sgl);

/* sense memory */
CTASSERT(sizeof(struct mfi_sense) == MFI_SENSE_SIZE)extern char _ctassert[(sizeof(struct mfi_sense) == 128) ? 1 :
 -1 ] __attribute__((__unused__));
sc->sc_sense = mfii_dmamem_alloc(sc, sc->sc_max_cmds * MFI_SENSE_SIZE128);
if (sc->sc_sense == NULL((void *)0)) {
printf("%s: unable to allocate sense memory\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto pci_unmap;
}

/* reply post queue */
sc->sc_reply_postq_depth = roundup(sc->sc_max_fw_cmds, 16)((((sc->sc_max_fw_cmds)+((16)-1))/(16))*(16));

sc->sc_reply_postq = mfii_dmamem_alloc(sc,
   sc->sc_reply_postq_depth * sizeof(struct mpii_reply_descr));
if (sc->sc_reply_postq == NULL((void *)0))
goto free_sense;

memset(MFII_DMA_KVA(sc->sc_reply_postq), 0xff,__builtin_memset((((void *)(sc->sc_reply_postq)->mdm_kva
)), (0xff), (((sc->sc_reply_postq)->mdm_size)))
   MFII_DMA_LEN(sc->sc_reply_postq))__builtin_memset((((void *)(sc->sc_reply_postq)->mdm_kva
)), (0xff), (((sc->sc_reply_postq)->mdm_size)));

/* MPII request frame array */
sc->sc_requests = mfii_dmamem_alloc(sc,
   MFII_REQUEST_SIZE256 * (sc->sc_max_cmds + 1));
if (sc->sc_requests == NULL((void *)0))
goto free_reply_postq;

/* MFI command frame array */
sc->sc_mfi = mfii_dmamem_alloc(sc, sc->sc_max_cmds * MFI_FRAME_SIZE64);
if (sc->sc_mfi == NULL((void *)0))
goto free_requests;

/* MPII SGL array */
sc->sc_sgl = mfii_dmamem_alloc(sc, sc->sc_max_cmds *
   sizeof(struct mfii_sge) * sc->sc_max_sgl);
if (sc->sc_sgl == NULL((void *)0))
goto free_mfi;

if (mfii_init_ccb(sc) != 0) {
printf("%s: could not init ccb list\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto free_sgl;
}

/* kickstart firmware with all addresses and pointers */
if (mfii_initialise_firmware(sc) != 0) {
printf("%s: could not initialize firmware\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto free_sgl;
}

if (mfii_get_info(sc) != 0) {
printf("%s: could not retrieve controller information\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto free_sgl;
}

printf("%s: \"%s\", firmware %s", DEVNAME(sc)((sc)->sc_dev.dv_xname),
   sc->sc_info.mci_product_name, sc->sc_info.mci_package_version);
if (letoh16(sc->sc_info.mci_memory_size)((__uint16_t)(sc->sc_info.mci_memory_size)) > 0)
printf(", %uMB cache", letoh16(sc->sc_info.mci_memory_size)((__uint16_t)(sc->sc_info.mci_memory_size)));
printf("\n");

sc->sc_ih = pci_intr_establish(sc->sc_pc, ih, IPL_BIO0x3,
   mfii_intr, sc, DEVNAME(sc)((sc)->sc_dev.dv_xname));
if (sc->sc_ih == NULL((void *)0))
goto free_sgl;

saa.saa_adapter_softc = sc;
saa.saa_adapter = &mfii_switch;
saa.saa_adapter_target = SDEV_NO_ADAPTER_TARGET0xffff;
saa.saa_adapter_buswidth = sc->sc_info.mci_max_lds;
saa.saa_luns = 8;
saa.saa_openings = sc->sc_max_cmds;
saa.saa_pool = &sc->sc_iopool;
saa.saa_quirks = saa.saa_flags = 0;
saa.saa_wwpn = saa.saa_wwnn = 0;

sc->sc_scsibus = (struct scsibus_softc *)config_found(&sc->sc_dev, &saa,config_found_sm((&sc->sc_dev), (&saa), (scsiprint)
, ((void *)0))
   scsiprint)config_found_sm((&sc->sc_dev), (&saa), (scsiprint)
, ((void *)0));

mfii_syspd(sc);

if (mfii_aen_register(sc) != 0) {
/* error printed by mfii_aen_register */
goto intr_disestablish;
}

if (mfii_mgmt(sc, MR_DCMD_LD_GET_LIST0x03010000, NULL((void *)0), &sc->sc_ld_list,
   sizeof(sc->sc_ld_list), SCSI_DATA_IN0x00800) != 0) {
printf("%s: getting list of logical disks failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
goto intr_disestablish;
}
memset(sc->sc_target_lds, -1, sizeof(sc->sc_target_lds))__builtin_memset((sc->sc_target_lds), (-1), (sizeof(sc->
sc_target_lds)));
for (i = 0; i < sc->sc_ld_list.mll_no_ld; i++) {
int target = sc->sc_ld_list.mll_list[i].mll_ld.mld_target;
sc->sc_target_lds[target] = i;
}

/* enable interrupts */
mfii_write(sc, MFI_OSTS0x30, 0xffffffff);
mfii_write(sc, MFI_OMSK0x34, ~MFII_OSTS_INTR_VALID0x00000009);

818#if NBIO1 > 0
if (bio_register(&sc->sc_dev, mfii_ioctl) != 0)
panic("%s: controller registration failed", DEVNAME(sc)((sc)->sc_dev.dv_xname));
else
sc->sc_ioctl = mfii_ioctl;

824#ifndef SMALL_KERNEL
if (mfii_create_sensors(sc) != 0)
printf("%s: unable to create sensors\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
827#endif
828#endif /* NBIO > 0 */

return;
831intr_disestablish:
pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
833free_sgl:
mfii_dmamem_free(sc, sc->sc_sgl);
835free_mfi:
mfii_dmamem_free(sc, sc->sc_mfi);
837free_requests:
mfii_dmamem_free(sc, sc->sc_requests);
839free_reply_postq:
mfii_dmamem_free(sc, sc->sc_reply_postq);
841free_sense:
mfii_dmamem_free(sc, sc->sc_sense);
843pci_unmap:
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
845}

847static inline uint16_t
848mfii_dev_handle(struct mfii_softc *sc, uint16_t target)
849{
struct mfii_pd_dev_handles *handles;
uint16_t handle;

smr_read_enter();
handles = SMR_PTR_GET(&sc->sc_pd->pd_dev_handles)({ typeof(*&sc->sc_pd->pd_dev_handles) __tmp = *(volatile
 typeof(*&sc->sc_pd->pd_dev_handles) *)&(*&
sc->sc_pd->pd_dev_handles); membar_datadep_consumer(); __tmp
; });
handle = handles->pd_handles[target];
smr_read_leave();

return (handle);
859}

861void
862mfii_dev_handles_smr(void *pd_arg)
863{
struct mfii_pd_dev_handles *handles = pd_arg;

free(handles, M_DEVBUF2, sizeof(*handles));
867}

869int
870mfii_dev_handles_update(struct mfii_softc *sc)
871{
struct mfii_ld_map *lm;
struct mfii_pd_dev_handles *handles, *old_handles;
int i;
int rv = 0;

lm = malloc(sizeof(*lm), M_TEMP127, M_WAITOK0x0001|M_ZERO0x0008);

rv = mfii_mgmt(sc, MR_DCMD_LD_MAP_GET_INFO0x0300e101, NULL((void *)0), lm, sizeof(*lm),
   SCSI_DATA_IN0x00800|SCSI_NOSLEEP0x00001);

if (rv != 0) {
rv = EIO5;
goto free_lm;
}

handles = malloc(sizeof(*handles), M_DEVBUF2, M_WAITOK0x0001);
smr_init(&handles->pd_smr);
for (i = 0; i < MFI_MAX_PD256; i++)
handles->pd_handles[i] = lm->mlm_dev_handle[i].mdh_cur_handle;

/* commit the updated info */
sc->sc_pd->pd_timeout = lm->mlm_pd_timeout;
old_handles = SMR_PTR_GET_LOCKED(&sc->sc_pd->pd_dev_handles)(*(&sc->sc_pd->pd_dev_handles));
SMR_PTR_SET_LOCKED(&sc->sc_pd->pd_dev_handles, handles)do { do { __asm volatile("" ::: "memory"); } while (0); ({ typeof
(*&sc->sc_pd->pd_dev_handles) __tmp = (handles); *(
volatile typeof(*&sc->sc_pd->pd_dev_handles) *)&
(*&sc->sc_pd->pd_dev_handles) = __tmp; __tmp; }); }
 while (0);

if (old_handles != NULL((void *)0))
smr_call(&old_handles->pd_smr, mfii_dev_handles_smr, old_handles)smr_call_impl(&old_handles->pd_smr, mfii_dev_handles_smr
, old_handles, 0);

900free_lm:
free(lm, M_TEMP127, sizeof(*lm));

return (rv);
904}

906int
907mfii_syspd(struct mfii_softc *sc)
908{
struct scsibus_attach_args saa;

sc->sc_pd = malloc(sizeof(*sc->sc_pd), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
if (sc->sc_pd == NULL((void *)0))
return (1);

if (mfii_dev_handles_update(sc) != 0)
goto free_pdsc;

saa.saa_adapter =  &mfii_pd_switch;
saa.saa_adapter_softc = sc;
saa.saa_adapter_buswidth = MFI_MAX_PD256;
saa.saa_adapter_target = SDEV_NO_ADAPTER_TARGET0xffff;
saa.saa_luns = 8;
saa.saa_openings = sc->sc_max_cmds - 1;
saa.saa_pool = &sc->sc_iopool;
saa.saa_quirks = saa.saa_flags = 0;
saa.saa_wwpn = saa.saa_wwnn = 0;

sc->sc_pd->pd_scsibus = (struct scsibus_softc *)
   config_found(&sc->sc_dev, &saa, scsiprint)config_found_sm((&sc->sc_dev), (&saa), (scsiprint)
, ((void *)0));

return (0);

933free_pdsc:
free(sc->sc_pd, M_DEVBUF2, sizeof(*sc->sc_pd));
return (1);
936}

938int
939mfii_detach(struct device *self, int flags)
940{
struct mfii_softc *sc = (struct mfii_softc *)self;

if (sc->sc_ih == NULL((void *)0))
return (0);

946#ifndef SMALL_KERNEL
if (sc->sc_sensors) {
sensordev_deinstall(&sc->sc_sensordev);
free(sc->sc_sensors, M_DEVBUF2,
    MFI_MAX_LD64 * sizeof(struct ksensor));
}

if (sc->sc_bbu) {
free(sc->sc_bbu, M_DEVBUF2, 4 * sizeof(*sc->sc_bbu));
}

if (sc->sc_bbu_status) {
free(sc->sc_bbu_status, M_DEVBUF2,
    sizeof(*sc->sc_bbu_status) * sizeof(mfi_bbu_indicators));
}
961#endif /* SMALL_KERNEL */

mfii_aen_unregister(sc);
pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
mfii_dmamem_free(sc, sc->sc_sgl);
mfii_dmamem_free(sc, sc->sc_mfi);
mfii_dmamem_free(sc, sc->sc_requests);
mfii_dmamem_free(sc, sc->sc_reply_postq);
mfii_dmamem_free(sc, sc->sc_sense);
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);

return (0);
973}

975static void
976mfii_flush_cache(struct mfii_softc *sc, struct mfii_ccb *ccb)
977{
978#if 0
union mfi_mbox mbox = {
.b[0] = MR_FLUSH_CTRL_CACHE0x01 | MR_FLUSH_DISK_CACHE0x02,
};
int rv;

mfii_scrub_ccb(ccb);
rv = mfii_do_mgmt(sc, ccb, MR_DCMD_CTRL_CACHE_FLUSH0x01101000, &mbox,
   NULL((void *)0), 0, SCSI_NOSLEEP0x00001);
if (rv != 0) {
printf("%s: unable to flush cache\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return;
}
991#endif
992}

994static void
995mfii_shutdown(struct mfii_softc *sc, struct mfii_ccb *ccb)
996{
997#if 0
int rv;

mfii_scrub_ccb(ccb);
rv = mfii_do_mgmt(sc, ccb, MR_DCMD_CTRL_SHUTDOWN0x01050000, NULL((void *)0),
   NULL((void *)0), 0, SCSI_POLL0x00002);
if (rv != 0) {
printf("%s: unable to shutdown controller\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return;
}
1007#endif
1008}

1010static void
1011mfii_powerdown(struct mfii_softc *sc)
1012{
struct mfii_ccb *ccb;

ccb = scsi_io_get(&sc->sc_iopool, SCSI_NOSLEEP0x00001);
if (ccb == NULL((void *)0)) {
printf("%s: unable to allocate ccb for shutdown\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
return;
}

mfii_flush_cache(sc, ccb);
mfii_shutdown(sc, ccb);
scsi_io_put(&sc->sc_iopool, ccb);
1025}

1027int
1028mfii_activate(struct device *self, int act)
1029{
struct mfii_softc *sc = (struct mfii_softc *)self;
int rv;

switch (act) {
case DVACT_POWERDOWN6:
rv = config_activate_children(&sc->sc_dev, act);
mfii_powerdown(sc);
break;
default:
rv = config_activate_children(&sc->sc_dev, act);
break;
}

return (rv);
1044}

1046u_int32_t
1047mfii_read(struct mfii_softc *sc, bus_size_t r)
1048{
bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
   BUS_SPACE_BARRIER_READ0x01);
return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, r)((sc->sc_iot)->read_4((sc->sc_ioh), (r))));
1052}

1054void
1055mfii_write(struct mfii_softc *sc, bus_size_t r, u_int32_t v)
1056{
bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v)((sc->sc_iot)->write_4((sc->sc_ioh), (r), (v)));
bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
   BUS_SPACE_BARRIER_WRITE0x02);
1060}

1062struct mfii_dmamem *
1063mfii_dmamem_alloc(struct mfii_softc *sc, size_t size)
1064{
struct mfii_dmamem *m;
int nsegs;

m = malloc(sizeof(*m), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (m == NULL((void *)0))
return (NULL((void *)0));

m->mdm_size = size;

if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), (size
), (1), (size), (0), (0x0001 | 0x0002), (&m->mdm_map))
   BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &m->mdm_map)(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), (size
), (1), (size), (0), (0x0001 | 0x0002), (&m->mdm_map)) != 0)
goto mdmfree;

if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &m->mdm_seg, 1,(*(sc->sc_dmat)->_dmamem_alloc)((sc->sc_dmat), (size
), ((1 << 12)), (0), (&m->mdm_seg), (1), (&nsegs
), (0x0001 | 0x1000))
   &nsegs, BUS_DMA_NOWAIT | BUS_DMA_ZERO)(*(sc->sc_dmat)->_dmamem_alloc)((sc->sc_dmat), (size
), ((1 << 12)), (0), (&m->mdm_seg), (1), (&nsegs
), (0x0001 | 0x1000)) != 0)
goto destroy;

if (bus_dmamem_map(sc->sc_dmat, &m->mdm_seg, nsegs, size, &m->mdm_kva,(*(sc->sc_dmat)->_dmamem_map)((sc->sc_dmat), (&m
->mdm_seg), (nsegs), (size), (&m->mdm_kva), (0x0001
))
   BUS_DMA_NOWAIT)(*(sc->sc_dmat)->_dmamem_map)((sc->sc_dmat), (&m
->mdm_seg), (nsegs), (size), (&m->mdm_kva), (0x0001
)) != 0)
goto free;

if (bus_dmamap_load(sc->sc_dmat, m->mdm_map, m->mdm_kva, size, NULL,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (m->
mdm_map), (m->mdm_kva), (size), (((void *)0)), (0x0001))
   BUS_DMA_NOWAIT)(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (m->
mdm_map), (m->mdm_kva), (size), (((void *)0)), (0x0001)) != 0)
goto unmap;

return (m);

1092unmap:
bus_dmamem_unmap(sc->sc_dmat, m->mdm_kva, m->mdm_size)(*(sc->sc_dmat)->_dmamem_unmap)((sc->sc_dmat), (m->
mdm_kva), (m->mdm_size));
1094free:
bus_dmamem_free(sc->sc_dmat, &m->mdm_seg, 1)(*(sc->sc_dmat)->_dmamem_free)((sc->sc_dmat), (&
m->mdm_seg), (1));
1096destroy:
bus_dmamap_destroy(sc->sc_dmat, m->mdm_map)(*(sc->sc_dmat)->_dmamap_destroy)((sc->sc_dmat), (m->
mdm_map));
1098mdmfree:
free(m, M_DEVBUF2, sizeof *m);

return (NULL((void *)0));
1102}

1104void
1105mfii_dmamem_free(struct mfii_softc *sc, struct mfii_dmamem *m)
1106{
bus_dmamap_unload(sc->sc_dmat, m->mdm_map)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (m->
mdm_map));
bus_dmamem_unmap(sc->sc_dmat, m->mdm_kva, m->mdm_size)(*(sc->sc_dmat)->_dmamem_unmap)((sc->sc_dmat), (m->
mdm_kva), (m->mdm_size));
bus_dmamem_free(sc->sc_dmat, &m->mdm_seg, 1)(*(sc->sc_dmat)->_dmamem_free)((sc->sc_dmat), (&
m->mdm_seg), (1));
bus_dmamap_destroy(sc->sc_dmat, m->mdm_map)(*(sc->sc_dmat)->_dmamap_destroy)((sc->sc_dmat), (m->
mdm_map));
free(m, M_DEVBUF2, sizeof *m);
1112}

1114void
1115mfii_dcmd_start(struct mfii_softc *sc, struct mfii_ccb *ccb)
1116{
struct mpii_msg_scsi_io *io = ccb->ccb_request;
struct mfii_raid_context *ctx = (struct mfii_raid_context *)(io + 1);
struct mfii_sge *sge = (struct mfii_sge *)(ctx + 1);

io->function = MFII_FUNCTION_PASSTHRU_IO(0xf0);
io->sgl_offset0 = (uint32_t *)sge - (uint32_t *)io;
io->chain_offset = io->sgl_offset0 / 4;

htolem64(&sge->sg_addr, ccb->ccb_sense_dva)(*(__uint64_t *)(&sge->sg_addr) = ((__uint64_t)(ccb->
ccb_sense_dva)));
htolem32(&sge->sg_len, sizeof(*ccb->ccb_sense))(*(__uint32_t *)(&sge->sg_len) = ((__uint32_t)(sizeof(
*ccb->ccb_sense))));
sge->sg_flags = MFII_SGE_CHAIN_ELEMENT(0x80) | MFII_SGE_ADDR_IOCPLBNTA(0x03);

ccb->ccb_req.flags = MFII_REQ_TYPE_SCSI(0x00);
ccb->ccb_req.smid = letoh16(ccb->ccb_smid)((__uint16_t)(ccb->ccb_smid));

mfii_start(sc, ccb);
1133}

1135int
1136mfii_aen_register(struct mfii_softc *sc)
1137{
struct mfi_evt_log_info mel;
struct mfii_ccb *ccb;
struct mfii_dmamem *mdm;
int rv;

ccb = scsi_io_get(&sc->sc_iopool, SCSI_NOSLEEP0x00001);
if (ccb == NULL((void *)0)) {
printf("%s: unable to allocate ccb for aen\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (ENOMEM12);
}

memset(&mel, 0, sizeof(mel))__builtin_memset((&mel), (0), (sizeof(mel)));
mfii_scrub_ccb(ccb);

rv = mfii_do_mgmt(sc, ccb, MR_DCMD_CTRL_EVENT_GET_INFO0x01040100, NULL((void *)0),
   &mel, sizeof(mel), SCSI_DATA_IN0x00800|SCSI_NOSLEEP0x00001);
if (rv != 0) {
scsi_io_put(&sc->sc_iopool, ccb);
printf("%s: unable to get event info\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (EIO5);
}

mdm = mfii_dmamem_alloc(sc, sizeof(struct mfi_evt_detail));
if (mdm == NULL((void *)0)) {
scsi_io_put(&sc->sc_iopool, ccb);
printf("%s: unable to allocate event data\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (ENOMEM12);
}

/* replay all the events from boot */
mfii_aen_start(sc, ccb, mdm, lemtoh32(&mel.mel_boot_seq_num)((__uint32_t)(*(__uint32_t *)(&mel.mel_boot_seq_num))));

return (0);
1171}

1173void
1174mfii_aen_start(struct mfii_softc *sc, struct mfii_ccb *ccb,
  struct mfii_dmamem *mdm, uint32_t seq)
1176{
struct mfi_dcmd_frame *dcmd = mfii_dcmd_frame(ccb);
struct mfi_frame_header *hdr = &dcmd->mdf_header;
union mfi_sgl *sgl = &dcmd->mdf_sgl;
union mfi_evt_class_locale mec;

mfii_scrub_ccb(ccb);
mfii_dcmd_scrub(ccb);
memset(MFII_DMA_KVA(mdm), 0, MFII_DMA_LEN(mdm))__builtin_memset((((void *)(mdm)->mdm_kva)), (0), (((mdm)->
mdm_size)));

ccb->ccb_cookie = mdm;
ccb->ccb_done = mfii_aen_done;
sc->sc_aen_ccb = ccb;

mec.mec_members.class = MFI_EVT_CLASS_DEBUG;
mec.mec_members.reserved = 0;
mec.mec_members.locale = htole16(MFI_EVT_LOCALE_ALL)((__uint16_t)(MFI_EVT_LOCALE_ALL));

hdr->mfh_cmd = MFI_CMD_DCMD0x05;
hdr->mfh_sg_count = 1;
hdr->mfh_flags = htole16(MFI_FRAME_DIR_READ | MFI_FRAME_SGL64)((__uint16_t)(0x0010 | 0x0002));
htolem32(&hdr->mfh_data_len, MFII_DMA_LEN(mdm))(*(__uint32_t *)(&hdr->mfh_data_len) = ((__uint32_t)((
(mdm)->mdm_size))));
dcmd->mdf_opcode = htole32(MR_DCMD_CTRL_EVENT_WAIT)((__uint32_t)(0x01040500));
htolem32(&dcmd->mdf_mbox.w[0], seq)(*(__uint32_t *)(&dcmd->mdf_mbox.w[0]) = ((__uint32_t)
(seq)));
htolem32(&dcmd->mdf_mbox.w[1], mec.mec_word)(*(__uint32_t *)(&dcmd->mdf_mbox.w[1]) = ((__uint32_t)
(mec.mec_word)));
htolem64(&sgl->sg64[0].addr, MFII_DMA_DVA(mdm))(*(__uint64_t *)(&sgl->sg64[0].addr) = ((__uint64_t)((
(u_int64_t)(mdm)->mdm_map->dm_segs[0].ds_addr))));
htolem32(&sgl->sg64[0].len, MFII_DMA_LEN(mdm))(*(__uint32_t *)(&sgl->sg64[0].len) = ((__uint32_t)(((
mdm)->mdm_size))));

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(mdm),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((mdm
)->mdm_map)), (0), (((mdm)->mdm_size)), (0x01))
   0, MFII_DMA_LEN(mdm), BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((mdm
)->mdm_map)), (0), (((mdm)->mdm_size)), (0x01));

mfii_dcmd_sync(sc, ccb, BUS_DMASYNC_PREREAD0x01|BUS_DMASYNC_PREWRITE0x04);
mfii_dcmd_start(sc, ccb);
1209}

1211void
1212mfii_aen_done(struct mfii_softc *sc, struct mfii_ccb *ccb)
1213{
KASSERT(sc->sc_aen_ccb == ccb)((sc->sc_aen_ccb == ccb) ? (void)0 : __assert("diagnostic "
, "/usr/src/sys/dev/pci/mfii.c", 1214, "sc->sc_aen_ccb == ccb"
));

/* defer to a thread with KERNEL_LOCK so we can run autoconf */
task_add(systq, &sc->sc_aen_task);
1218}

1220void
1221mfii_aen(void *arg)
1222{
struct mfii_softc *sc = arg;
struct mfii_ccb *ccb = sc->sc_aen_ccb;
struct mfii_dmamem *mdm = ccb->ccb_cookie;
const struct mfi_evt_detail *med = MFII_DMA_KVA(mdm)((void *)(mdm)->mdm_kva);
uint32_t code;

mfii_dcmd_sync(sc, ccb,
   BUS_DMASYNC_POSTREAD0x02|BUS_DMASYNC_POSTWRITE0x08);
bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(mdm),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((mdm
)->mdm_map)), (0), (((mdm)->mdm_size)), (0x02))
   0, MFII_DMA_LEN(mdm), BUS_DMASYNC_POSTREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((mdm
)->mdm_map)), (0), (((mdm)->mdm_size)), (0x02));

code = lemtoh32(&med->med_code)((__uint32_t)(*(__uint32_t *)(&med->med_code)));

1236#if 0
log(LOG_DEBUG7, "%s (seq %u, code %08x) %s\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
   lemtoh32(&med->med_seq_num)((__uint32_t)(*(__uint32_t *)(&med->med_seq_num))), code, med->med_description);
1239#endif

switch (code) {
case MFI_EVT_PD_INSERTED_EXT0x00f7:
if (med->med_arg_type != MFI_EVT_ARGS_PD_ADDRESS0x1d)
	break;

mfii_aen_pd_insert(sc, &med->args.pd_address);
break;
case MFI_EVT_PD_REMOVED_EXT0x00f8:
if (med->med_arg_type != MFI_EVT_ARGS_PD_ADDRESS0x1d)
	break;

mfii_aen_pd_remove(sc, &med->args.pd_address);
break;

case MFI_EVT_PD_STATE_CHANGE0x0072:
if (med->med_arg_type != MFI_EVT_ARGS_PD_STATE0x0f)
	break;

mfii_aen_pd_state_change(sc, &med->args.pd_state);
break;

case MFI_EVT_LD_CREATED0x008a:
case MFI_EVT_LD_DELETED0x008b:
mfii_aen_ld_update(sc);
break;

default:
break;
}

mfii_aen_start(sc, ccb, mdm, lemtoh32(&med->med_seq_num)((__uint32_t)(*(__uint32_t *)(&med->med_seq_num))) + 1);
1272}

1274void
1275mfii_aen_pd_insert(struct mfii_softc *sc,
  const struct mfi_evtarg_pd_address *pd)
1277{
1278#if 0
printf("%s: pd inserted ext\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
printf("%s:  device_id %04x encl_id: %04x type %x\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
   lemtoh16(&pd->device_id)((__uint16_t)(*(__uint16_t *)(&pd->device_id))), lemtoh16(&pd->encl_id)((__uint16_t)(*(__uint16_t *)(&pd->encl_id))),
   pd->scsi_dev_type);
printf("%s:  connected %02x addrs %016llx %016llx\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
   pd->connected.port_bitmap, lemtoh64(&pd->sas_addr[0])((__uint64_t)(*(__uint64_t *)(&pd->sas_addr[0]))),
   lemtoh64(&pd->sas_addr[1])((__uint64_t)(*(__uint64_t *)(&pd->sas_addr[1]))));
1286#endif

if (mfii_dev_handles_update(sc) != 0) /* refresh map */
return;

scsi_probe_target(sc->sc_pd->pd_scsibus, lemtoh16(&pd->device_id)((__uint16_t)(*(__uint16_t *)(&pd->device_id))));
1292}

1294void
1295mfii_aen_pd_remove(struct mfii_softc *sc,
  const struct mfi_evtarg_pd_address *pd)
1297{
1298#if 0
printf("%s: pd removed ext\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
printf("%s:  device_id %04x encl_id: %04x type %u\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
   lemtoh16(&pd->device_id)((__uint16_t)(*(__uint16_t *)(&pd->device_id))), lemtoh16(&pd->encl_id)((__uint16_t)(*(__uint16_t *)(&pd->encl_id))),
   pd->scsi_dev_type);
printf("%s:  connected %02x addrs %016llx %016llx\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
   pd->connected.port_bitmap, lemtoh64(&pd->sas_addr[0])((__uint64_t)(*(__uint64_t *)(&pd->sas_addr[0]))),
   lemtoh64(&pd->sas_addr[1])((__uint64_t)(*(__uint64_t *)(&pd->sas_addr[1]))));
1306#endif
uint16_t target = lemtoh16(&pd->device_id)((__uint16_t)(*(__uint16_t *)(&pd->device_id)));

scsi_activate(sc->sc_pd->pd_scsibus, target, -1, DVACT_DEACTIVATE1);

/* the firmware will abort outstanding commands for us */

scsi_detach_target(sc->sc_pd->pd_scsibus, target, DETACH_FORCE0x01);
1314}

1316void
1317mfii_aen_pd_state_change(struct mfii_softc *sc,
  const struct mfi_evtarg_pd_state *state)
1319{
uint16_t target = lemtoh16(&state->pd.mep_device_id)((__uint16_t)(*(__uint16_t *)(&state->pd.mep_device_id
)));

if (state->prev_state == htole32(MFI_PD_SYSTEM)((__uint32_t)(0x40)) &&
   state->new_state != htole32(MFI_PD_SYSTEM)((__uint32_t)(0x40))) {
/* it's been pulled or configured for raid */

scsi_activate(sc->sc_pd->pd_scsibus, target, -1,
    DVACT_DEACTIVATE1);
/* outstanding commands will simply complete or get aborted */
scsi_detach_target(sc->sc_pd->pd_scsibus, target,
    DETACH_FORCE0x01);

} else if (state->prev_state == htole32(MFI_PD_UNCONFIG_GOOD)((__uint32_t)(0x00)) &&
   state->new_state == htole32(MFI_PD_SYSTEM)((__uint32_t)(0x40))) {
/* the firmware is handing the disk over */

scsi_probe_target(sc->sc_pd->pd_scsibus, target);
}
1338}

1340void
1341mfii_aen_ld_update(struct mfii_softc *sc)
1342{
int i, state, target, old, nld;
int newlds[MFI_MAX_LD64];

if (mfii_mgmt(sc, MR_DCMD_LD_GET_LIST0x03010000, NULL((void *)0), &sc->sc_ld_list,
   sizeof(sc->sc_ld_list), SCSI_DATA_IN0x00800) != 0) {
DNPRINTF(MFII_D_MISC, "%s: getting list of logical disks failed\n",
    DEVNAME(sc));
return;
}

memset(newlds, -1, sizeof(newlds))__builtin_memset((newlds), (-1), (sizeof(newlds)));

for (i = 0; i < sc->sc_ld_list.mll_no_ld; i++) {
state = sc->sc_ld_list.mll_list[i].mll_state;
target = sc->sc_ld_list.mll_list[i].mll_ld.mld_target;
DNPRINTF(MFII_D_MISC, "%s: target %d: state %d\n",
    DEVNAME(sc), target, state);
newlds[target] = i;
}

for (i = 0; i < MFI_MAX_LD64; i++) {
old = sc->sc_target_lds[i];
nld = newlds[i];

if (old == -1 && nld != -1) {
	DNPRINTF(MFII_D_MISC, "%s: attaching target %d\n",
	    DEVNAME(sc), i);

	scsi_probe_target(sc->sc_scsibus, i);

1373#ifndef SMALL_KERNEL
	mfii_init_ld_sensor(sc, nld);
	sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i]);
1376#endif
} else if (nld == -1 && old != -1) {
	DNPRINTF(MFII_D_MISC, "%s: detaching target %d\n",
	    DEVNAME(sc), i);

	scsi_activate(sc->sc_scsibus, i, -1,
	    DVACT_DEACTIVATE1);
	scsi_detach_target(sc->sc_scsibus, i,
	    DETACH_FORCE0x01);
1385#ifndef SMALL_KERNEL
	sensor_detach(&sc->sc_sensordev, &sc->sc_sensors[i]);
1387#endif
}
}

memcpy(sc->sc_target_lds, newlds, sizeof(sc->sc_target_lds))__builtin_memcpy((sc->sc_target_lds), (newlds), (sizeof(sc
->sc_target_lds)));
1392}

1394void
1395mfii_aen_unregister(struct mfii_softc *sc)
1396{
/* XXX */
1398}

1400int
1401mfii_reset_hard(struct mfii_softc *sc)
1402{
u_int16_t		i;

mfii_write(sc, MFI_OSTS0x30, 0);

/* enable diagnostic register */
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_FLUSH(0x00));
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_1(0x0f));
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_2(0x04));
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_3(0x0b));
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_4(0x02));
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_5(0x07));
mfii_write(sc, MPII_WRITESEQ(0x04), MPII_WRITESEQ_6(0x0d));

delay(100)(*delay_func)(100);

if ((mfii_read(sc, MPII_HOSTDIAG(0x08)) & MPII_HOSTDIAG_DWRE(1<<7)) == 0) {
printf("%s: failed to enable diagnostic read/write\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
return(1);
}

/* reset ioc */
mfii_write(sc, MPII_HOSTDIAG(0x08), MPII_HOSTDIAG_RESET_ADAPTER(1<<2));

/* 240 milliseconds */
delay(240000)(*delay_func)(240000);

for (i = 0; i < 30000; i++) {
if ((mfii_read(sc, MPII_HOSTDIAG(0x08)) &
    MPII_HOSTDIAG_RESET_ADAPTER(1<<2)) == 0)
	break;
delay(10000)(*delay_func)(10000);
}
if (i >= 30000) {
printf("%s: failed to reset device\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (1);
}

/* disable diagnostic register */
mfii_write(sc, MPII_WRITESEQ(0x04), 0xff);

return(0);
1445}

1447int
1448mfii_transition_firmware(struct mfii_softc *sc)
1449{
int32_t			fw_state, cur_state;
int			max_wait, i, reset_on_fault = 1;

fw_state = mfii_fw_state(sc)mfii_read((sc), 0xb0) & MFI_STATE_MASK0xf0000000;

while (fw_state != MFI_STATE_READY0xb0000000) {
cur_state = fw_state;
switch (fw_state) {
case MFI_STATE_FAULT0xf0000000:
	if (!reset_on_fault) {
		printf("%s: firmware fault\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
		return (1);
	}
	printf("%s: firmware fault; attempting full device "
	    "reset, this can take some time\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	if (mfii_reset_hard(sc))
		return (1);
	max_wait = 20;
	reset_on_fault = 0;
	break;
case MFI_STATE_WAIT_HANDSHAKE0x60000000:
	mfii_write(sc, MFI_SKINNY_IDB0x00,
	    MFI_INIT_CLEAR_HANDSHAKE0x00000008);
	max_wait = 2;
	break;
case MFI_STATE_OPERATIONAL0xc0000000:
	mfii_write(sc, MFI_SKINNY_IDB0x00, MFI_INIT_READY0x00000002);
	max_wait = 10;
	break;
case MFI_STATE_BB_INIT0x10000000:
	max_wait = 20;
	break;
case MFI_STATE_UNDEFINED0x00000000:
case MFI_STATE_FW_INIT0x40000000:
case MFI_STATE_FW_INIT_20x70000000:
case MFI_STATE_DEVICE_SCAN0x80000000:
case MFI_STATE_FLUSH_CACHE0xa0000000:
	max_wait = 40;
	break;
case MFI_STATE_BOOT_MESSAGE_PENDING0x90000000:
	mfii_write(sc, MFI_SKINNY_IDB0x00, MFI_INIT_HOTPLUG0x00000010);
	max_wait = 10;
	break;
default:
	printf("%s: unknown firmware state %#x\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), fw_state);
	return (1);
}
for (i = 0; i < (max_wait * 10); i++) {
	fw_state = mfii_fw_state(sc)mfii_read((sc), 0xb0) & MFI_STATE_MASK0xf0000000;
	if (fw_state == cur_state)
		DELAY(100000)(*delay_func)(100000);
	else
		break;
}
if (fw_state == cur_state) {
	printf("%s: firmware stuck in state %#x\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), fw_state);
	return (1);
} else {
	DPRINTF("%s: firmware state change %#x -> %#x after "
	    "%d iterations\n",
	    DEVNAME(sc), cur_state, fw_state, i);
}
}

return (0);
1517}

1519int
1520mfii_get_info(struct mfii_softc *sc)
1521{
int i, rv;

rv = mfii_mgmt(sc, MR_DCMD_CTRL_GET_INFO0x01010000, NULL((void *)0), &sc->sc_info,
   sizeof(sc->sc_info), SCSI_DATA_IN0x00800|SCSI_NOSLEEP0x00001);

if (rv != 0)
return (rv);

for (i = 0; i < sc->sc_info.mci_image_component_count; i++) {
DPRINTF("%s: active FW %s Version %s date %s time %s\n",
    DEVNAME(sc),
    sc->sc_info.mci_image_component[i].mic_name,
    sc->sc_info.mci_image_component[i].mic_version,
    sc->sc_info.mci_image_component[i].mic_build_date,
    sc->sc_info.mci_image_component[i].mic_build_time);
}

for (i = 0; i < sc->sc_info.mci_pending_image_component_count; i++) {
DPRINTF("%s: pending FW %s Version %s date %s time %s\n",
    DEVNAME(sc),
    sc->sc_info.mci_pending_image_component[i].mic_name,
    sc->sc_info.mci_pending_image_component[i].mic_version,
    sc->sc_info.mci_pending_image_component[i].mic_build_date,
    sc->sc_info.mci_pending_image_component[i].mic_build_time);
}

DPRINTF("%s: max_arms %d max_spans %d max_arrs %d max_lds %d name %s\n",
   DEVNAME(sc),
   sc->sc_info.mci_max_arms,
   sc->sc_info.mci_max_spans,
   sc->sc_info.mci_max_arrays,
   sc->sc_info.mci_max_lds,
   sc->sc_info.mci_product_name);

DPRINTF("%s: serial %s present %#x fw time %d max_cmds %d max_sg %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_serial_number,
   sc->sc_info.mci_hw_present,
   sc->sc_info.mci_current_fw_time,
   sc->sc_info.mci_max_cmds,
   sc->sc_info.mci_max_sg_elements);

DPRINTF("%s: max_rq %d lds_pres %d lds_deg %d lds_off %d pd_pres %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_max_request_size,
   sc->sc_info.mci_lds_present,
   sc->sc_info.mci_lds_degraded,
   sc->sc_info.mci_lds_offline,
   sc->sc_info.mci_pd_present);

DPRINTF("%s: pd_dsk_prs %d pd_dsk_pred_fail %d pd_dsk_fail %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_pd_disks_present,
   sc->sc_info.mci_pd_disks_pred_failure,
   sc->sc_info.mci_pd_disks_failed);

DPRINTF("%s: nvram %d mem %d flash %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_nvram_size,
   sc->sc_info.mci_memory_size,
   sc->sc_info.mci_flash_size);

DPRINTF("%s: ram_cor %d ram_uncor %d clus_all %d clus_act %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_ram_correctable_errors,
   sc->sc_info.mci_ram_uncorrectable_errors,
   sc->sc_info.mci_cluster_allowed,
   sc->sc_info.mci_cluster_active);

DPRINTF("%s: max_strps_io %d raid_lvl %#x adapt_ops %#x ld_ops %#x\n",
   DEVNAME(sc),
   sc->sc_info.mci_max_strips_per_io,
   sc->sc_info.mci_raid_levels,
   sc->sc_info.mci_adapter_ops,
   sc->sc_info.mci_ld_ops);

DPRINTF("%s: strp_sz_min %d strp_sz_max %d pd_ops %#x pd_mix %#x\n",
   DEVNAME(sc),
   sc->sc_info.mci_stripe_sz_ops.min,
   sc->sc_info.mci_stripe_sz_ops.max,
   sc->sc_info.mci_pd_ops,
   sc->sc_info.mci_pd_mix_support);

DPRINTF("%s: ecc_bucket %d pckg_prop %s\n",
   DEVNAME(sc),
   sc->sc_info.mci_ecc_bucket_count,
   sc->sc_info.mci_package_version);

DPRINTF("%s: sq_nm %d prd_fail_poll %d intr_thrtl %d intr_thrtl_to %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_properties.mcp_seq_num,
   sc->sc_info.mci_properties.mcp_pred_fail_poll_interval,
   sc->sc_info.mci_properties.mcp_intr_throttle_cnt,
   sc->sc_info.mci_properties.mcp_intr_throttle_timeout);

DPRINTF("%s: rbld_rate %d patr_rd_rate %d bgi_rate %d cc_rate %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_properties.mcp_rebuild_rate,
   sc->sc_info.mci_properties.mcp_patrol_read_rate,
   sc->sc_info.mci_properties.mcp_bgi_rate,
   sc->sc_info.mci_properties.mcp_cc_rate);

DPRINTF("%s: rc_rate %d ch_flsh %d spin_cnt %d spin_dly %d clus_en %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_properties.mcp_recon_rate,
   sc->sc_info.mci_properties.mcp_cache_flush_interval,
   sc->sc_info.mci_properties.mcp_spinup_drv_cnt,
   sc->sc_info.mci_properties.mcp_spinup_delay,
   sc->sc_info.mci_properties.mcp_cluster_enable);

DPRINTF("%s: coerc %d alarm %d dis_auto_rbld %d dis_bat_wrn %d ecc %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_properties.mcp_coercion_mode,
   sc->sc_info.mci_properties.mcp_alarm_enable,
   sc->sc_info.mci_properties.mcp_disable_auto_rebuild,
   sc->sc_info.mci_properties.mcp_disable_battery_warn,
   sc->sc_info.mci_properties.mcp_ecc_bucket_size);

DPRINTF("%s: ecc_leak %d rest_hs %d exp_encl_dev %d\n",
   DEVNAME(sc),
   sc->sc_info.mci_properties.mcp_ecc_bucket_leak_rate,
   sc->sc_info.mci_properties.mcp_restore_hotspare_on_insertion,
   sc->sc_info.mci_properties.mcp_expose_encl_devices);

DPRINTF("%s: vendor %#x device %#x subvendor %#x subdevice %#x\n",
   DEVNAME(sc),
   sc->sc_info.mci_pci.mip_vendor,
   sc->sc_info.mci_pci.mip_device,
   sc->sc_info.mci_pci.mip_subvendor,
   sc->sc_info.mci_pci.mip_subdevice);

DPRINTF("%s: type %#x port_count %d port_addr ",
   DEVNAME(sc),
   sc->sc_info.mci_host.mih_type,
   sc->sc_info.mci_host.mih_port_count);

for (i = 0; i < 8; i++)
DPRINTF("%.0llx ", sc->sc_info.mci_host.mih_port_addr[i]);
DPRINTF("\n");

DPRINTF("%s: type %.x port_count %d port_addr ",
   DEVNAME(sc),
   sc->sc_info.mci_device.mid_type,
   sc->sc_info.mci_device.mid_port_count);

for (i = 0; i < 8; i++)
DPRINTF("%.0llx ", sc->sc_info.mci_device.mid_port_addr[i]);
DPRINTF("\n");

return (0);
1672}

1674int
1675mfii_mfa_poll(struct mfii_softc *sc, struct mfii_ccb *ccb)
1676{
struct mfi_frame_header	*hdr = ccb->ccb_request;
u_int64_t r;
int to = 0, rv = 0;

1681#ifdef DIAGNOSTIC1
if (ccb->ccb_cookie != NULL((void *)0) || ccb->ccb_done != NULL((void *)0))
panic("mfii_mfa_poll called with cookie or done set");
1684#endif

hdr->mfh_context = ccb->ccb_smid;
hdr->mfh_cmd_status = MFI_STAT_INVALID_STATUS;
hdr->mfh_flags |= htole16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE)((__uint16_t)(0x0001));

r = MFII_REQ_MFA(ccb->ccb_request_dva)((__uint64_t)((ccb->ccb_request_dva) | (0x1 << 1)));
memcpy(&ccb->ccb_req, &r, sizeof(ccb->ccb_req))__builtin_memcpy((&ccb->ccb_req), (&r), (sizeof(ccb
->ccb_req)));

mfii_start(sc, ccb);

for (;;) {
bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_requests),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x02 | 0x08))
    ccb->ccb_request_offset, MFII_REQUEST_SIZE,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x02 | 0x08))
    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x02 | 0x08));

if (hdr->mfh_cmd_status != MFI_STAT_INVALID_STATUS)
	break;

if (to++ > 5000) { /* XXX 5 seconds busywait sucks */
	printf("%s: timeout on ccb %d\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
	    ccb->ccb_smid);
	ccb->ccb_flags |= MFI_CCB_F_ERR(1<<0);
	rv = 1;
	break;
}

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_requests),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x01 | 0x04))
    ccb->ccb_request_offset, MFII_REQUEST_SIZE,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x01 | 0x04))
    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x01 | 0x04));

delay(1000)(*delay_func)(1000);
}

if (ccb->ccb_len > 0) {
bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08))
    0, ccb->ccb_dmamap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08))
    (ccb->ccb_direction == MFII_DATA_IN) ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08))
    BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08));

bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (ccb
->ccb_dmamap));
}

return (rv);
1728}

1730int
1731mfii_poll(struct mfii_softc *sc, struct mfii_ccb *ccb)
1732{
void (*done)(struct mfii_softc *, struct mfii_ccb *);
void *cookie;
int rv = 1;

done = ccb->ccb_done;
cookie = ccb->ccb_cookie;

ccb->ccb_done = mfii_poll_done;
ccb->ccb_cookie = &rv;

mfii_start(sc, ccb);

do {
delay(10)(*delay_func)(10);
mfii_postq(sc);
} while (rv == 1);

ccb->ccb_cookie = cookie;
done(sc, ccb);

return (0);
1754}

1756void
1757mfii_poll_done(struct mfii_softc *sc, struct mfii_ccb *ccb)
1758{
int *rv = ccb->ccb_cookie;

*rv = 0;
1762}

1764int
1765mfii_exec(struct mfii_softc *sc, struct mfii_ccb *ccb)
1766{
struct mutex m;

mtx_init(&m, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&m), (((
(0x3)) > 0x0 && ((0x3)) < 0x9) ? 0x9 : ((0x3)))
); } while (0);

1771#ifdef DIAGNOSTIC1
if (ccb->ccb_cookie != NULL((void *)0) || ccb->ccb_done != NULL((void *)0))
panic("mfii_exec called with cookie or done set");
1774#endif

ccb->ccb_cookie = &m;
ccb->ccb_done = mfii_exec_done;

mfii_start(sc, ccb);

mtx_enter(&m);
while (ccb->ccb_cookie != NULL((void *)0))
msleep_nsec(ccb, &m, PRIBIO16, "mfiiexec", INFSLP0xffffffffffffffffULL);
mtx_leave(&m);

return (0);
1787}

1789void
1790mfii_exec_done(struct mfii_softc *sc, struct mfii_ccb *ccb)
1791{
struct mutex *m = ccb->ccb_cookie;

mtx_enter(m);
ccb->ccb_cookie = NULL((void *)0);
wakeup_one(ccb)wakeup_n((ccb), 1);
mtx_leave(m);
1798}

1800int
1801mfii_mgmt(struct mfii_softc *sc, uint32_t opc, const union mfi_mbox *mbox,
  void *buf, size_t len, int flags)
1803{
struct mfii_ccb *ccb;
int rv;

ccb = scsi_io_get(&sc->sc_iopool, flags);
if (ccb == NULL((void *)0))
13
←
Assuming 'ccb' is not equal to NULL→
14
←
Taking false branch→
return (ENOMEM12);

mfii_scrub_ccb(ccb);
rv = mfii_do_mgmt(sc, ccb, opc, mbox, buf, len, flags);
15
←
Calling 'mfii_do_mgmt'→
36
←
Returning from 'mfii_do_mgmt'→
scsi_io_put(&sc->sc_iopool, ccb);

return (rv);
37
←
Returning without writing to 'buf->mpd_enc_idx'→
1816}

1818int
1819mfii_do_mgmt(struct mfii_softc *sc, struct mfii_ccb *ccb, uint32_t opc,
  const union mfi_mbox *mbox, void *buf, size_t len, int flags)
1821{
struct mpii_msg_scsi_io *io = ccb->ccb_request;
struct mfii_raid_context *ctx = (struct mfii_raid_context *)(io + 1);
struct mfii_sge *sge = (struct mfii_sge *)(ctx + 1);
struct mfi_dcmd_frame *dcmd = ccb->ccb_mfi;
struct mfi_frame_header *hdr = &dcmd->mdf_header;
u_int8_t *dma_buf = NULL((void *)0);
int rv = EIO5;

if (cold)
16
←
Assuming 'cold' is 0→
17
←
Taking false branch→
flags |= SCSI_NOSLEEP0x00001;

if (buf != NULL((void *)0)) {
18
←
Assuming 'buf' is not equal to NULL→
19
←
Taking true branch→
dma_buf = dma_alloc(len, PR_WAITOK0x0001);
if (dma_buf == NULL((void *)0))
20
←
Assuming 'dma_buf' is not equal to NULL→
21
←
Taking false branch→
	return (ENOMEM12);
}

ccb->ccb_data = dma_buf;
ccb->ccb_len = len;
switch (flags & (SCSI_DATA_IN0x00800 | SCSI_DATA_OUT0x01000)) {
22
←
Control jumps to 'case 2048:'  at line 1842→
case SCSI_DATA_IN0x00800:
ccb->ccb_direction = MFII_DATA_IN1;
hdr->mfh_flags = htole16(MFI_FRAME_DIR_READ)((__uint16_t)(0x0010));
break;
case SCSI_DATA_OUT0x01000:
ccb->ccb_direction = MFII_DATA_OUT2;
hdr->mfh_flags = htole16(MFI_FRAME_DIR_WRITE)((__uint16_t)(0x0008));
memcpy(dma_buf, buf, len)__builtin_memcpy((dma_buf), (buf), (len));
break;
case 0:
ccb->ccb_direction = MFII_DATA_NONE0;
hdr->mfh_flags = htole16(MFI_FRAME_DIR_NONE)((__uint16_t)(0x0000));
break;
}

if (mfii_load_mfa(sc, ccb, &dcmd->mdf_sgl,
23
←
 Execution continues on line 1857→
24
←
Assuming the condition is false→
25
←
Taking false branch→
   ISSET(flags, SCSI_NOSLEEP)((flags) & (0x00001))) != 0) {
rv = ENOMEM12;
goto done;
}

hdr->mfh_cmd = MFI_CMD_DCMD0x05;
hdr->mfh_context = ccb->ccb_smid;
hdr->mfh_data_len = htole32(len)((__uint32_t)(len));
hdr->mfh_sg_count = len25.1
'len' is 512
 ? ccb->ccb_dmamap->dm_nsegs : 0;
26
←
'?' condition is true→

dcmd->mdf_opcode = opc;
/* handle special opcodes */
if (mbox26.1
'mbox' is not equal to NULL
 != NULL((void *)0))
27
←
Taking true branch→
memcpy(&dcmd->mdf_mbox, mbox, sizeof(dcmd->mdf_mbox))__builtin_memcpy((&dcmd->mdf_mbox), (mbox), (sizeof(dcmd
->mdf_mbox)));

io->function = MFII_FUNCTION_PASSTHRU_IO(0xf0);

if (len27.1
'len' is 512
) {
28
←
Taking true branch→
io->sgl_offset0 = ((u_int8_t *)sge - (u_int8_t *)io) / 4;
io->chain_offset = ((u_int8_t *)sge - (u_int8_t *)io) / 16;
htolem64(&sge->sg_addr, ccb->ccb_mfi_dva)(*(__uint64_t *)(&sge->sg_addr) = ((__uint64_t)(ccb->
ccb_mfi_dva)));
htolem32(&sge->sg_len, MFI_FRAME_SIZE)(*(__uint32_t *)(&sge->sg_len) = ((__uint32_t)(64)));
sge->sg_flags =
    MFII_SGE_CHAIN_ELEMENT(0x80) | MFII_SGE_ADDR_IOCPLBNTA(0x03);
}

ccb->ccb_req.flags = MFII_REQ_TYPE_SCSI(0x00);
ccb->ccb_req.smid = letoh16(ccb->ccb_smid)((__uint16_t)(ccb->ccb_smid));

if (ISSET(flags, SCSI_NOSLEEP)((flags) & (0x00001))) {
29
←
Taking false branch→
ccb->ccb_done = mfii_empty_done;
mfii_poll(sc, ccb);
} else
mfii_exec(sc, ccb);

if (hdr->mfh_cmd_status == MFI_STAT_OK) {
30
←
Assuming field 'mfh_cmd_status' is equal to MFI_STAT_OK→
31
←
Taking true branch→
rv = 0;

if (ccb->ccb_direction == MFII_DATA_IN1)
32
←
Assuming field 'ccb_direction' is not equal to MFII_DATA_IN→
33
←
Taking false branch→
	memcpy(buf, dma_buf, len)__builtin_memcpy((buf), (dma_buf), (len));
}

1900done:
if (buf33.1
'buf' is not equal to NULL
 != NULL((void *)0))
34
←
Taking true branch→
dma_free(dma_buf, len);

return (rv);
35
←
Returning without writing to '->mpd_enc_idx'→
1905}

1907void
1908mfii_empty_done(struct mfii_softc *sc, struct mfii_ccb *ccb)
1909{
return;
1911}

1913int
1914mfii_load_mfa(struct mfii_softc *sc, struct mfii_ccb *ccb,
  void *sglp, int nosleep)
1916{
union mfi_sgl *sgl = sglp;
bus_dmamap_t dmap = ccb->ccb_dmamap;
int error;
int i;

if (ccb->ccb_len == 0)
return (0);

error = bus_dmamap_load(sc->sc_dmat, dmap,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap)
, (ccb->ccb_data), (ccb->ccb_len), (((void *)0)), (nosleep
 ? 0x0001 : 0x0000))
   ccb->ccb_data, ccb->ccb_len, NULL,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap)
, (ccb->ccb_data), (ccb->ccb_len), (((void *)0)), (nosleep
 ? 0x0001 : 0x0000))
   nosleep ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK)(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap)
, (ccb->ccb_data), (ccb->ccb_len), (((void *)0)), (nosleep
 ? 0x0001 : 0x0000));
if (error) {
printf("%s: error %d loading dmamap\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), error);
return (1);
}

for (i = 0; i < dmap->dm_nsegs; i++) {
sgl->sg32[i].addr = htole32(dmap->dm_segs[i].ds_addr)((__uint32_t)(dmap->dm_segs[i].ds_addr));
sgl->sg32[i].len = htole32(dmap->dm_segs[i].ds_len)((__uint32_t)(dmap->dm_segs[i].ds_len));
}

bus_dmamap_sync(sc->sc_dmat, dmap, 0, dmap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap)
, (0), (dmap->dm_mapsize), (ccb->ccb_direction == 2 ? 0x04
 : 0x01))
   ccb->ccb_direction == MFII_DATA_OUT ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap)
, (0), (dmap->dm_mapsize), (ccb->ccb_direction == 2 ? 0x04
 : 0x01))
   BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap)
, (0), (dmap->dm_mapsize), (ccb->ccb_direction == 2 ? 0x04
 : 0x01));

return (0);
1943}

1945void
1946mfii_start(struct mfii_softc *sc, struct mfii_ccb *ccb)
1947{
u_long *r = (u_long *)&ccb->ccb_req;

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_requests),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x01 | 0x04))
   ccb->ccb_request_offset, MFII_REQUEST_SIZE,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x01 | 0x04))
   BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x01 | 0x04));

1954#if defined(__LP64__1)
bus_space_write_raw_8(sc->sc_iot, sc->sc_ioh, MFI_IQPL, *r)((sc->sc_iot)->write_8((sc->sc_ioh), (0x000000c0), (
*r)));
1956#else
mtx_enter(&sc->sc_post_mtx);
bus_space_write_raw_4(sc->sc_iot, sc->sc_ioh, MFI_IQPL, r[0])((sc->sc_iot)->write_4((sc->sc_ioh), (0x000000c0), (
r[0])));
bus_space_barrier(sc->sc_iot, sc->sc_ioh,
   MFI_IQPL0x000000c0, 8, BUS_SPACE_BARRIER_WRITE0x02);

bus_space_write_raw_4(sc->sc_iot, sc->sc_ioh, MFI_IQPH, r[1])((sc->sc_iot)->write_4((sc->sc_ioh), (0x000000c4), (
r[1])));
bus_space_barrier(sc->sc_iot, sc->sc_ioh,
   MFI_IQPH0x000000c4, 8, BUS_SPACE_BARRIER_WRITE0x02);
mtx_leave(&sc->sc_post_mtx);
1966#endif
1967}

1969void
1970mfii_done(struct mfii_softc *sc, struct mfii_ccb *ccb)
1971{
bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_requests),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x02 | 0x08))
   ccb->ccb_request_offset, MFII_REQUEST_SIZE,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x02 | 0x08))
   BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_requests)->mdm_map)), (ccb->ccb_request_offset), (256
), (0x02 | 0x08));

if (ccb->ccb_sgl_len > 0) {
bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_sgl),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sgl)->mdm_map)), (ccb->ccb_sgl_offset), (ccb->ccb_sgl_len
), (0x08))
    ccb->ccb_sgl_offset, ccb->ccb_sgl_len,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sgl)->mdm_map)), (ccb->ccb_sgl_offset), (ccb->ccb_sgl_len
), (0x08))
    BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sgl)->mdm_map)), (ccb->ccb_sgl_offset), (ccb->ccb_sgl_len
), (0x08));
}

if (ccb->ccb_len > 0) {
bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08))
    0, ccb->ccb_dmamap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08))
    (ccb->ccb_direction == MFII_DATA_IN) ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08))
    BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb->
ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((ccb->
ccb_direction == 1) ? 0x02 : 0x08));

bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (ccb
->ccb_dmamap));
}

ccb->ccb_done(sc, ccb);
1992}

1994int
1995mfii_initialise_firmware(struct mfii_softc *sc)
1996{
struct mpii_msg_iocinit_request *iiq;
struct mfii_dmamem *m;
struct mfii_ccb *ccb;
struct mfi_init_frame *init;
int rv;

m = mfii_dmamem_alloc(sc, sizeof(*iiq));
if (m == NULL((void *)0))
return (1);

iiq = MFII_DMA_KVA(m)((void *)(m)->mdm_kva);
memset(iiq, 0, sizeof(*iiq))__builtin_memset((iiq), (0), (sizeof(*iiq)));

iiq->function = MPII_FUNCTION_IOC_INIT(0x02);
iiq->whoinit = MPII_WHOINIT_HOST_DRIVER(0x04);

iiq->msg_version_maj = 0x02;
iiq->msg_version_min = 0x00;
iiq->hdr_version_unit = 0x10;
iiq->hdr_version_dev = 0x0;

iiq->system_request_frame_size = htole16(MFII_REQUEST_SIZE / 4)((__uint16_t)(256 / 4));

iiq->reply_descriptor_post_queue_depth =
   htole16(sc->sc_reply_postq_depth)((__uint16_t)(sc->sc_reply_postq_depth));
iiq->reply_free_queue_depth = htole16(0)((__uint16_t)(0));

htolem32(&iiq->sense_buffer_address_high,(*(__uint32_t *)(&iiq->sense_buffer_address_high) = ((
__uint32_t)(((u_int64_t)(sc->sc_sense)->mdm_map->dm_segs
[0].ds_addr) >> 32)))
   MFII_DMA_DVA(sc->sc_sense) >> 32)(*(__uint32_t *)(&iiq->sense_buffer_address_high) = ((
__uint32_t)(((u_int64_t)(sc->sc_sense)->mdm_map->dm_segs
[0].ds_addr) >> 32)));

htolem32(&iiq->reply_descriptor_post_queue_address_lo,(*(__uint32_t *)(&iiq->reply_descriptor_post_queue_address_lo
) = ((__uint32_t)(((u_int64_t)(sc->sc_reply_postq)->mdm_map
->dm_segs[0].ds_addr))))
   MFII_DMA_DVA(sc->sc_reply_postq))(*(__uint32_t *)(&iiq->reply_descriptor_post_queue_address_lo
) = ((__uint32_t)(((u_int64_t)(sc->sc_reply_postq)->mdm_map
->dm_segs[0].ds_addr))));
htolem32(&iiq->reply_descriptor_post_queue_address_hi,(*(__uint32_t *)(&iiq->reply_descriptor_post_queue_address_hi
) = ((__uint32_t)(((u_int64_t)(sc->sc_reply_postq)->mdm_map
->dm_segs[0].ds_addr) >> 32)))
   MFII_DMA_DVA(sc->sc_reply_postq) >> 32)(*(__uint32_t *)(&iiq->reply_descriptor_post_queue_address_hi
) = ((__uint32_t)(((u_int64_t)(sc->sc_reply_postq)->mdm_map
->dm_segs[0].ds_addr) >> 32)));

htolem32(&iiq->system_request_frame_base_address_lo,(*(__uint32_t *)(&iiq->system_request_frame_base_address_lo
) = ((__uint32_t)(((u_int64_t)(sc->sc_requests)->mdm_map
->dm_segs[0].ds_addr))))
   MFII_DMA_DVA(sc->sc_requests))(*(__uint32_t *)(&iiq->system_request_frame_base_address_lo
) = ((__uint32_t)(((u_int64_t)(sc->sc_requests)->mdm_map
->dm_segs[0].ds_addr))));
htolem32(&iiq->system_request_frame_base_address_hi,(*(__uint32_t *)(&iiq->system_request_frame_base_address_hi
) = ((__uint32_t)(((u_int64_t)(sc->sc_requests)->mdm_map
->dm_segs[0].ds_addr) >> 32)))
   MFII_DMA_DVA(sc->sc_requests) >> 32)(*(__uint32_t *)(&iiq->system_request_frame_base_address_hi
) = ((__uint32_t)(((u_int64_t)(sc->sc_requests)->mdm_map
->dm_segs[0].ds_addr) >> 32)));

iiq->timestamp = htole64(getuptime())((__uint64_t)(getuptime()));

ccb = scsi_io_get(&sc->sc_iopool, SCSI_NOSLEEP0x00001);
if (ccb == NULL((void *)0)) {
/* shouldn't ever run out of ccbs during attach */
return (1);
}
mfii_scrub_ccb(ccb);
init = ccb->ccb_request;

init->mif_header.mfh_cmd = MFI_CMD_INIT0x00;
init->mif_header.mfh_data_len = htole32(sizeof(*iiq))((__uint32_t)(sizeof(*iiq)));
init->mif_qinfo_new_addr = htole64(MFII_DMA_DVA(m))((__uint64_t)(((u_int64_t)(m)->mdm_map->dm_segs[0].ds_addr
)));

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_reply_postq),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x01))
   0, MFII_DMA_LEN(sc->sc_reply_postq),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x01))
   BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x01));

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(m),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((m)->
mdm_map)), (0), (sizeof(*iiq)), (0x01))
   0, sizeof(*iiq), BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((m)->
mdm_map)), (0), (sizeof(*iiq)), (0x01));

rv = mfii_mfa_poll(sc, ccb);

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(m),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((m)->
mdm_map)), (0), (sizeof(*iiq)), (0x02))
   0, sizeof(*iiq), BUS_DMASYNC_POSTREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((m)->
mdm_map)), (0), (sizeof(*iiq)), (0x02));

scsi_io_put(&sc->sc_iopool, ccb);
mfii_dmamem_free(sc, m);

return (rv);
2067}

2069int
2070mfii_my_intr(struct mfii_softc *sc)
2071{
u_int32_t status;

status = mfii_read(sc, MFI_OSTS0x30);
if (ISSET(status, 0x1)((status) & (0x1))) {
mfii_write(sc, MFI_OSTS0x30, status);
return (1);
}

return (ISSET(status, MFII_OSTS_INTR_VALID)((status) & (0x00000009)) ? 1 : 0);
2081}

2083int
2084mfii_intr(void *arg)
2085{
struct mfii_softc *sc = arg;

if (!mfii_my_intr(sc))
return (0);

mfii_postq(sc);

return (1);
2094}

2096void
2097mfii_postq(struct mfii_softc *sc)
2098{
struct mfii_ccb_list ccbs = SIMPLEQ_HEAD_INITIALIZER(ccbs){ ((void *)0), &(ccbs).sqh_first };
struct mpii_reply_descr *postq = MFII_DMA_KVA(sc->sc_reply_postq)((void *)(sc->sc_reply_postq)->mdm_kva);
struct mpii_reply_descr *rdp;
struct mfii_ccb *ccb;
int rpi = 0;

mtx_enter(&sc->sc_reply_postq_mtx);

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_reply_postq),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x02))
   0, MFII_DMA_LEN(sc->sc_reply_postq),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x02))
   BUS_DMASYNC_POSTREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x02));

for (;;) {
rdp = &postq[sc->sc_reply_postq_index];
if ((rdp->reply_flags & MPII_REPLY_DESCR_TYPE_MASK(0x0f)) ==
    MPII_REPLY_DESCR_UNUSED(0x0f))
	break;
if (rdp->data == 0xffffffff) {
	/*
	 * ioc is still writing to the reply post queue
	 * race condition - bail!
	 */
	break;
}

ccb = &sc->sc_ccb[letoh16(rdp->smid)((__uint16_t)(rdp->smid)) - 1];
SIMPLEQ_INSERT_TAIL(&ccbs, ccb, ccb_link)do { (ccb)->ccb_link.sqe_next = ((void *)0); *(&ccbs)->
sqh_last = (ccb); (&ccbs)->sqh_last = &(ccb)->ccb_link
.sqe_next; } while (0);
memset(rdp, 0xff, sizeof(*rdp))__builtin_memset((rdp), (0xff), (sizeof(*rdp)));

sc->sc_reply_postq_index++;
sc->sc_reply_postq_index %= sc->sc_reply_postq_depth;
rpi = 1;
}

bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_reply_postq),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x01))
   0, MFII_DMA_LEN(sc->sc_reply_postq),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x01))
   BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_reply_postq)->mdm_map)), (0), (((sc->sc_reply_postq)
->mdm_size)), (0x01));

if (rpi)
mfii_write(sc, MFII_RPI0x6c, sc->sc_reply_postq_index);

mtx_leave(&sc->sc_reply_postq_mtx);

while ((ccb = SIMPLEQ_FIRST(&ccbs)((&ccbs)->sqh_first)) != NULL((void *)0)) {
SIMPLEQ_REMOVE_HEAD(&ccbs, ccb_link)do { if (((&ccbs)->sqh_first = (&ccbs)->sqh_first
->ccb_link.sqe_next) == ((void *)0)) (&ccbs)->sqh_last
 = &(&ccbs)->sqh_first; } while (0);
mfii_done(sc, ccb);
}
2146}

2148void
2149mfii_scsi_cmd(struct scsi_xfer *xs)
2150{
struct scsi_link *link = xs->sc_link;
struct mfii_softc *sc = link->bus->sb_adapter_softc;
struct mfii_ccb *ccb = xs->io;

mfii_scrub_ccb(ccb);
ccb->ccb_cookie = xs;
ccb->ccb_done = mfii_scsi_cmd_done;
ccb->ccb_data = xs->data;
ccb->ccb_len = xs->datalen;

timeout_set(&xs->stimeout, mfii_scsi_cmd_tmo, xs);

switch (xs->cmd.opcode) {
case READ_COMMAND0x08:
case READ_100x28:
case READ_120xa8:
case READ_160x88:
case WRITE_COMMAND0x0a:
case WRITE_100x2a:
case WRITE_120xaa:
case WRITE_160x8a:
if (mfii_scsi_cmd_io(sc, xs) != 0)
	goto stuffup;

break;

default:
if (mfii_scsi_cmd_cdb(sc, xs) != 0)
	goto stuffup;
break;
}

xs->error = XS_NOERROR0;
xs->resid = 0;

if (ISSET(xs->flags, SCSI_POLL)((xs->flags) & (0x00002))) {
if (mfii_poll(sc, ccb) != 0)
	goto stuffup;
return;
}

ccb->ccb_refcnt = 2; /* one for the chip, one for the timeout */
timeout_add_msec(&xs->stimeout, xs->timeout);
mfii_start(sc, ccb);

return;

2198stuffup:
xs->error = XS_DRIVER_STUFFUP2;
scsi_done(xs);
2201}

2203void
2204mfii_scsi_cmd_done(struct mfii_softc *sc, struct mfii_ccb *ccb)
2205{
struct scsi_xfer *xs = ccb->ccb_cookie;
struct mpii_msg_scsi_io *io = ccb->ccb_request;
struct mfii_raid_context *ctx = (struct mfii_raid_context *)(io + 1);
u_int refs = 1;

if (timeout_del(&xs->stimeout))
refs = 2;

switch (ctx->status) {
case MFI_STAT_OK:
break;

case MFI_STAT_SCSI_DONE_WITH_ERROR:
xs->error = XS_SENSE1;
memset(&xs->sense, 0, sizeof(xs->sense))__builtin_memset((&xs->sense), (0), (sizeof(xs->sense
)));
memcpy(&xs->sense, ccb->ccb_sense, sizeof(xs->sense))__builtin_memcpy((&xs->sense), (ccb->ccb_sense), (sizeof
(xs->sense)));
break;

case MFI_STAT_LD_OFFLINE:
case MFI_STAT_DEVICE_NOT_FOUND:
xs->error = XS_SELTIMEOUT3;
break;

default:
xs->error = XS_DRIVER_STUFFUP2;
break;
}

if (atomic_sub_int_nv(&ccb->ccb_refcnt, refs)_atomic_sub_int_nv(&ccb->ccb_refcnt, refs) == 0)
scsi_done(xs);
2236}

2238int
2239mfii_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag)
2240{
struct mfii_softc	*sc = link->bus->sb_adapter_softc;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_scsi_ioctl\n", DEVNAME(sc));

switch (cmd) {
case DIOCGCACHE((unsigned long)0x40000000 | ((sizeof(struct dk_cache) & 0x1fff
) << 16) | ((('d')) << 8) | ((117))):
case DIOCSCACHE((unsigned long)0x80000000 | ((sizeof(struct dk_cache) & 0x1fff
) << 16) | ((('d')) << 8) | ((118))):
return (mfii_ioctl_cache(link, cmd, (struct dk_cache *)addr));
break;

default:
if (sc->sc_ioctl)
	return (sc->sc_ioctl(&sc->sc_dev, cmd, addr));
break;
}

return (ENOTTY25);
2258}

2260int
2261mfii_ioctl_cache(struct scsi_link *link, u_long cmd,  struct dk_cache *dc)
2262{
struct mfii_softc	*sc = link->bus->sb_adapter_softc;
int			 rv, wrenable, rdenable;
struct mfi_ld_prop	 ldp;
union mfi_mbox		 mbox;

if (mfii_get_info(sc)) {
rv = EIO5;
goto done;
}

if (sc->sc_target_lds[link->target] == -1) {
rv = EIO5;
goto done;
}

memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.b[0] = link->target;
rv = mfii_mgmt(sc, MR_DCMD_LD_GET_PROPERTIES0x03030000, &mbox, &ldp, sizeof(ldp),
   SCSI_DATA_IN0x00800);
if (rv != 0)
goto done;

if (sc->sc_info.mci_memory_size > 0) {
wrenable = ISSET(ldp.mlp_cur_cache_policy,((ldp.mlp_cur_cache_policy) & (0x20))
    MR_LD_CACHE_ALLOW_WRITE_CACHE)((ldp.mlp_cur_cache_policy) & (0x20))? 1 : 0;
rdenable = ISSET(ldp.mlp_cur_cache_policy,((ldp.mlp_cur_cache_policy) & (0x40))
    MR_LD_CACHE_ALLOW_READ_CACHE)((ldp.mlp_cur_cache_policy) & (0x40))? 1 : 0;
} else {
wrenable = ISSET(ldp.mlp_diskcache_policy,((ldp.mlp_diskcache_policy) & (0x01))
    MR_LD_DISK_CACHE_ENABLE)((ldp.mlp_diskcache_policy) & (0x01))? 1 : 0;
rdenable = 0;
}

if (cmd == DIOCGCACHE((unsigned long)0x40000000 | ((sizeof(struct dk_cache) & 0x1fff
) << 16) | ((('d')) << 8) | ((117)))) {
dc->wrcache = wrenable;
dc->rdcache = rdenable;
goto done;
} /* else DIOCSCACHE */

if (((dc->wrcache) ? 1 : 0) == wrenable &&
   ((dc->rdcache) ? 1 : 0) == rdenable)
goto done;

memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.b[0] = ldp.mlp_ld.mld_target;
mbox.b[1] = ldp.mlp_ld.mld_res;
mbox.s[1] = ldp.mlp_ld.mld_seq;

if (sc->sc_info.mci_memory_size > 0) {
if (dc->rdcache)
	SET(ldp.mlp_cur_cache_policy,((ldp.mlp_cur_cache_policy) |= (0x40))
	    MR_LD_CACHE_ALLOW_READ_CACHE)((ldp.mlp_cur_cache_policy) |= (0x40));
else
	CLR(ldp.mlp_cur_cache_policy,((ldp.mlp_cur_cache_policy) &= ~(0x40))
	    MR_LD_CACHE_ALLOW_READ_CACHE)((ldp.mlp_cur_cache_policy) &= ~(0x40));
if (dc->wrcache)
	SET(ldp.mlp_cur_cache_policy,((ldp.mlp_cur_cache_policy) |= (0x20))
	    MR_LD_CACHE_ALLOW_WRITE_CACHE)((ldp.mlp_cur_cache_policy) |= (0x20));
else
	CLR(ldp.mlp_cur_cache_policy,((ldp.mlp_cur_cache_policy) &= ~(0x20))
	    MR_LD_CACHE_ALLOW_WRITE_CACHE)((ldp.mlp_cur_cache_policy) &= ~(0x20));
} else {
if (dc->rdcache) {
	rv = EOPNOTSUPP45;
	goto done;
}
if (dc->wrcache)
	ldp.mlp_diskcache_policy = MR_LD_DISK_CACHE_ENABLE0x01;
else
	ldp.mlp_diskcache_policy = MR_LD_DISK_CACHE_DISABLE0x02;
}

rv = mfii_mgmt(sc, MR_DCMD_LD_SET_PROPERTIES0x03040000, &mbox, &ldp, sizeof(ldp),
   SCSI_DATA_OUT0x01000);
2337done:
return (rv);
2339}

2341int
2342mfii_scsi_cmd_io(struct mfii_softc *sc, struct scsi_xfer *xs)
2343{
struct scsi_link *link = xs->sc_link;
struct mfii_ccb *ccb = xs->io;
struct mpii_msg_scsi_io *io = ccb->ccb_request;
struct mfii_raid_context *ctx = (struct mfii_raid_context *)(io + 1);
int segs;

io->dev_handle = htole16(link->target)((__uint16_t)(link->target));
io->function = MFII_FUNCTION_LDIO_REQUEST(0xf1);
io->sense_buffer_low_address = htole32(ccb->ccb_sense_dva)((__uint32_t)(ccb->ccb_sense_dva));
io->sgl_flags = htole16(0x02)((__uint16_t)(0x02)); /* XXX */
io->sense_buffer_length = sizeof(xs->sense);
io->sgl_offset0 = (sizeof(*io) + sizeof(*ctx)) / 4;
io->data_length = htole32(xs->datalen)((__uint32_t)(xs->datalen));
io->io_flags = htole16(xs->cmdlen)((__uint16_t)(xs->cmdlen));
switch (xs->flags & (SCSI_DATA_IN0x00800 | SCSI_DATA_OUT0x01000)) {
case SCSI_DATA_IN0x00800:
ccb->ccb_direction = MFII_DATA_IN1;
io->direction = MPII_SCSIIO_DIR_READ(0x2);
break;
case SCSI_DATA_OUT0x01000:
ccb->ccb_direction = MFII_DATA_OUT2;
io->direction = MPII_SCSIIO_DIR_WRITE(0x1);
break;
default:
ccb->ccb_direction = MFII_DATA_NONE0;
io->direction = MPII_SCSIIO_DIR_NONE(0x0);
break;
}
memcpy(io->cdb, &xs->cmd, xs->cmdlen)__builtin_memcpy((io->cdb), (&xs->cmd), (xs->cmdlen
));

ctx->type_nseg = sc->sc_iop->ldio_ctx_type_nseg;
ctx->timeout_value = htole16(0x14)((__uint16_t)(0x14)); /* XXX */
ctx->reg_lock_flags = htole16(sc->sc_iop->ldio_ctx_reg_lock_flags)((__uint16_t)(sc->sc_iop->ldio_ctx_reg_lock_flags));
ctx->virtual_disk_target_id = htole16(link->target)((__uint16_t)(link->target));

if (mfii_load_ccb(sc, ccb, ctx + 1,
   ISSET(xs->flags, SCSI_NOSLEEP)((xs->flags) & (0x00001))) != 0)
return (1);

segs = (ccb->ccb_len == 0) ? 0 : ccb->ccb_dmamap->dm_nsegs;
switch (sc->sc_iop->num_sge_loc) {
case MFII_IOP_NUM_SGE_LOC_ORIG0:
ctx->num_sge = segs;
break;
case MFII_IOP_NUM_SGE_LOC_351:
/* 12 bit field, but we're only using the lower 8 */
ctx->span_arm = segs;
break;
}

ccb->ccb_req.flags = sc->sc_iop->ldio_req_type;
ccb->ccb_req.smid = letoh16(ccb->ccb_smid)((__uint16_t)(ccb->ccb_smid));

return (0);
2398}

2400int
2401mfii_scsi_cmd_cdb(struct mfii_softc *sc, struct scsi_xfer *xs)
2402{
struct scsi_link *link = xs->sc_link;
struct mfii_ccb *ccb = xs->io;
struct mpii_msg_scsi_io *io = ccb->ccb_request;
struct mfii_raid_context *ctx = (struct mfii_raid_context *)(io + 1);

io->dev_handle = htole16(link->target)((__uint16_t)(link->target));
io->function = MFII_FUNCTION_LDIO_REQUEST(0xf1);
io->sense_buffer_low_address = htole32(ccb->ccb_sense_dva)((__uint32_t)(ccb->ccb_sense_dva));
io->sgl_flags = htole16(0x02)((__uint16_t)(0x02)); /* XXX */
io->sense_buffer_length = sizeof(xs->sense);
io->sgl_offset0 = (sizeof(*io) + sizeof(*ctx)) / 4;
io->data_length = htole32(xs->datalen)((__uint32_t)(xs->datalen));
io->io_flags = htole16(xs->cmdlen)((__uint16_t)(xs->cmdlen));
io->lun[0] = htobe16(link->lun)(__uint16_t)(__builtin_constant_p(link->lun) ? (__uint16_t
)(((__uint16_t)(link->lun) & 0xffU) << 8 | ((__uint16_t
)(link->lun) & 0xff00U) >> 8) : __swap16md(link->
lun));
switch (xs->flags & (SCSI_DATA_IN0x00800 | SCSI_DATA_OUT0x01000)) {
case SCSI_DATA_IN0x00800:
ccb->ccb_direction = MFII_DATA_IN1;
io->direction = MPII_SCSIIO_DIR_READ(0x2);
break;
case SCSI_DATA_OUT0x01000:
ccb->ccb_direction = MFII_DATA_OUT2;
io->direction = MPII_SCSIIO_DIR_WRITE(0x1);
break;
default:
ccb->ccb_direction = MFII_DATA_NONE0;
io->direction = MPII_SCSIIO_DIR_NONE(0x0);
break;
}
memcpy(io->cdb, &xs->cmd, xs->cmdlen)__builtin_memcpy((io->cdb), (&xs->cmd), (xs->cmdlen
));

ctx->virtual_disk_target_id = htole16(link->target)((__uint16_t)(link->target));

if (mfii_load_ccb(sc, ccb, ctx + 1,
   ISSET(xs->flags, SCSI_NOSLEEP)((xs->flags) & (0x00001))) != 0)
return (1);

ctx->num_sge = (ccb->ccb_len == 0) ? 0 : ccb->ccb_dmamap->dm_nsegs;

ccb->ccb_req.flags = MFII_REQ_TYPE_SCSI(0x00);
ccb->ccb_req.smid = letoh16(ccb->ccb_smid)((__uint16_t)(ccb->ccb_smid));

return (0);
2445}

2447void
2448mfii_pd_scsi_cmd(struct scsi_xfer *xs)
2449{
struct scsi_link *link = xs->sc_link;
struct mfii_softc *sc = link->bus->sb_adapter_softc;
struct mfii_ccb *ccb = xs->io;

mfii_scrub_ccb(ccb);
ccb->ccb_cookie = xs;
ccb->ccb_done = mfii_scsi_cmd_done;
ccb->ccb_data = xs->data;
ccb->ccb_len = xs->datalen;

timeout_set(&xs->stimeout, mfii_scsi_cmd_tmo, xs);

xs->error = mfii_pd_scsi_cmd_cdb(sc, xs);
if (xs->error != XS_NOERROR0)
goto done;

xs->resid = 0;

if (ISSET(xs->flags, SCSI_POLL)((xs->flags) & (0x00002))) {
if (mfii_poll(sc, ccb) != 0)
	goto stuffup;
return;
}

ccb->ccb_refcnt = 2; /* one for the chip, one for the timeout */
timeout_add_msec(&xs->stimeout, xs->timeout);
mfii_start(sc, ccb);

return;

2480stuffup:
xs->error = XS_DRIVER_STUFFUP2;
2482done:
scsi_done(xs);
2484}

2486int
2487mfii_pd_scsi_probe(struct scsi_link *link)
2488{
struct mfii_softc *sc = link->bus->sb_adapter_softc;
struct mfi_pd_details mpd;
union mfi_mbox mbox;
int rv;

if (link->lun > 0)
return (0);

memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.s[0] = htole16(link->target)((__uint16_t)(link->target));

rv = mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, &mpd, sizeof(mpd),
   SCSI_DATA_IN0x00800|SCSI_NOSLEEP0x00001);
if (rv != 0)
return (EIO5);

if (mpd.mpd_fw_state != htole16(MFI_PD_SYSTEM)((__uint16_t)(0x40)))
return (ENXIO6);

return (0);
2509}

2511int
2512mfii_pd_scsi_cmd_cdb(struct mfii_softc *sc, struct scsi_xfer *xs)
2513{
struct scsi_link *link = xs->sc_link;
struct mfii_ccb *ccb = xs->io;
struct mpii_msg_scsi_io *io = ccb->ccb_request;
struct mfii_raid_context *ctx = (struct mfii_raid_context *)(io + 1);
uint16_t dev_handle;

dev_handle = mfii_dev_handle(sc, link->target);
if (dev_handle == htole16(0xffff)((__uint16_t)(0xffff)))
return (XS_SELTIMEOUT3);

io->dev_handle = dev_handle;
io->function = 0;
io->sense_buffer_low_address = htole32(ccb->ccb_sense_dva)((__uint32_t)(ccb->ccb_sense_dva));
io->sgl_flags = htole16(0x02)((__uint16_t)(0x02)); /* XXX */
io->sense_buffer_length = sizeof(xs->sense);
io->sgl_offset0 = (sizeof(*io) + sizeof(*ctx)) / 4;
io->data_length = htole32(xs->datalen)((__uint32_t)(xs->datalen));
io->io_flags = htole16(xs->cmdlen)((__uint16_t)(xs->cmdlen));
io->lun[0] = htobe16(link->lun)(__uint16_t)(__builtin_constant_p(link->lun) ? (__uint16_t
)(((__uint16_t)(link->lun) & 0xffU) << 8 | ((__uint16_t
)(link->lun) & 0xff00U) >> 8) : __swap16md(link->
lun));
switch (xs->flags & (SCSI_DATA_IN0x00800 | SCSI_DATA_OUT0x01000)) {
case SCSI_DATA_IN0x00800:
ccb->ccb_direction = MFII_DATA_IN1;
io->direction = MPII_SCSIIO_DIR_READ(0x2);
break;
case SCSI_DATA_OUT0x01000:
ccb->ccb_direction = MFII_DATA_OUT2;
io->direction = MPII_SCSIIO_DIR_WRITE(0x1);
break;
default:
ccb->ccb_direction = MFII_DATA_NONE0;
io->direction = MPII_SCSIIO_DIR_NONE(0x0);
break;
}
memcpy(io->cdb, &xs->cmd, xs->cmdlen)__builtin_memcpy((io->cdb), (&xs->cmd), (xs->cmdlen
));

ctx->virtual_disk_target_id = htole16(link->target)((__uint16_t)(link->target));
ctx->raid_flags = MFII_RAID_CTX_IO_TYPE_SYSPD(0x1 << 4);
ctx->timeout_value = sc->sc_pd->pd_timeout;

if (mfii_load_ccb(sc, ccb, ctx + 1,
   ISSET(xs->flags, SCSI_NOSLEEP)((xs->flags) & (0x00001))) != 0)
return (XS_DRIVER_STUFFUP2);

ctx->num_sge = (ccb->ccb_len == 0) ? 0 : ccb->ccb_dmamap->dm_nsegs;

ccb->ccb_req.flags = MFII_REQ_TYPE_HI_PRI(0x6 << 1);
ccb->ccb_req.smid = letoh16(ccb->ccb_smid)((__uint16_t)(ccb->ccb_smid));
ccb->ccb_req.dev_handle = dev_handle;

return (XS_NOERROR0);
2564}

2566int
2567mfii_load_ccb(struct mfii_softc *sc, struct mfii_ccb *ccb, void *sglp,
  int nosleep)
2569{
struct mpii_msg_request *req = ccb->ccb_request;
struct mfii_sge *sge = NULL((void *)0), *nsge = sglp;
struct mfii_sge *ce = NULL((void *)0);
bus_dmamap_t dmap = ccb->ccb_dmamap;
u_int space;
int i;

int error;

if (ccb->ccb_len == 0)
return (0);

error = bus_dmamap_load(sc->sc_dmat, dmap,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap)
, (ccb->ccb_data), (ccb->ccb_len), (((void *)0)), (nosleep
 ? 0x0001 : 0x0000))
   ccb->ccb_data, ccb->ccb_len, NULL,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap)
, (ccb->ccb_data), (ccb->ccb_len), (((void *)0)), (nosleep
 ? 0x0001 : 0x0000))
   nosleep ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK)(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap)
, (ccb->ccb_data), (ccb->ccb_len), (((void *)0)), (nosleep
 ? 0x0001 : 0x0000));
if (error) {
printf("%s: error %d loading dmamap\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), error);
return (1);
}

space = (MFII_REQUEST_SIZE256 - ((u_int8_t *)nsge - (u_int8_t *)req)) /
   sizeof(*nsge);
if (dmap->dm_nsegs > space) {
space--;

ccb->ccb_sgl_len = (dmap->dm_nsegs - space) * sizeof(*nsge);
memset(ccb->ccb_sgl, 0, ccb->ccb_sgl_len)__builtin_memset((ccb->ccb_sgl), (0), (ccb->ccb_sgl_len
));

ce = nsge + space;
ce->sg_addr = htole64(ccb->ccb_sgl_dva)((__uint64_t)(ccb->ccb_sgl_dva));
ce->sg_len = htole32(ccb->ccb_sgl_len)((__uint32_t)(ccb->ccb_sgl_len));
ce->sg_flags = sc->sc_iop->sge_flag_chain;

req->chain_offset = ((u_int8_t *)ce - (u_int8_t *)req) / 16;
}

for (i = 0; i < dmap->dm_nsegs; i++) {
if (nsge == ce)
	nsge = ccb->ccb_sgl;

sge = nsge;

sge->sg_addr = htole64(dmap->dm_segs[i].ds_addr)((__uint64_t)(dmap->dm_segs[i].ds_addr));
sge->sg_len = htole32(dmap->dm_segs[i].ds_len)((__uint32_t)(dmap->dm_segs[i].ds_len));
sge->sg_flags = MFII_SGE_ADDR_SYSTEM(0x00);

nsge = sge + 1;
}
sge->sg_flags |= sc->sc_iop->sge_flag_eol;

bus_dmamap_sync(sc->sc_dmat, dmap, 0, dmap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap)
, (0), (dmap->dm_mapsize), (ccb->ccb_direction == 2 ? 0x04
 : 0x01))
   ccb->ccb_direction == MFII_DATA_OUT ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap)
, (0), (dmap->dm_mapsize), (ccb->ccb_direction == 2 ? 0x04
 : 0x01))
   BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap)
, (0), (dmap->dm_mapsize), (ccb->ccb_direction == 2 ? 0x04
 : 0x01));

if (ccb->ccb_sgl_len > 0) {
bus_dmamap_sync(sc->sc_dmat, MFII_DMA_MAP(sc->sc_sgl),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sgl)->mdm_map)), (ccb->ccb_sgl_offset), (ccb->ccb_sgl_len
), (0x04))
    ccb->ccb_sgl_offset, ccb->ccb_sgl_len,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sgl)->mdm_map)), (ccb->ccb_sgl_offset), (ccb->ccb_sgl_len
), (0x04))
    BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc->
sc_sgl)->mdm_map)), (ccb->ccb_sgl_offset), (ccb->ccb_sgl_len
), (0x04));
}

return (0);
2631}

2633void
2634mfii_scsi_cmd_tmo(void *xsp)
2635{
struct scsi_xfer *xs = xsp;
struct scsi_link *link = xs->sc_link;
struct mfii_softc *sc = link->bus->sb_adapter_softc;
struct mfii_ccb *ccb = xs->io;

mtx_enter(&sc->sc_abort_mtx);
SIMPLEQ_INSERT_TAIL(&sc->sc_abort_list, ccb, ccb_link)do { (ccb)->ccb_link.sqe_next = ((void *)0); *(&sc->
sc_abort_list)->sqh_last = (ccb); (&sc->sc_abort_list
)->sqh_last = &(ccb)->ccb_link.sqe_next; } while (0
);
mtx_leave(&sc->sc_abort_mtx);

task_add(systqmp, &sc->sc_abort_task);
2646}

2648void
2649mfii_abort_task(void *scp)
2650{
struct mfii_softc *sc = scp;
struct mfii_ccb *list;

mtx_enter(&sc->sc_abort_mtx);
list = SIMPLEQ_FIRST(&sc->sc_abort_list)((&sc->sc_abort_list)->sqh_first);
SIMPLEQ_INIT(&sc->sc_abort_list)do { (&sc->sc_abort_list)->sqh_first = ((void *)0);
 (&sc->sc_abort_list)->sqh_last = &(&sc->
sc_abort_list)->sqh_first; } while (0);
mtx_leave(&sc->sc_abort_mtx);

while (list != NULL((void *)0)) {
struct mfii_ccb *ccb = list;
struct scsi_xfer *xs = ccb->ccb_cookie;
struct scsi_link *link = xs->sc_link;

uint16_t dev_handle;
struct mfii_ccb *accb;

list = SIMPLEQ_NEXT(ccb, ccb_link)((ccb)->ccb_link.sqe_next);

dev_handle = mfii_dev_handle(sc, link->target);
if (dev_handle == htole16(0xffff)((__uint16_t)(0xffff))) {
	/* device is gone */
	if (atomic_dec_int_nv(&ccb->ccb_refcnt)_atomic_sub_int_nv((&ccb->ccb_refcnt), 1) == 0)
		scsi_done(xs);
	continue;
}

accb = scsi_io_get(&sc->sc_iopool, 0);
mfii_scrub_ccb(accb);
mfii_abort(sc, accb, dev_handle, ccb->ccb_smid,
    MPII_SCSI_TASK_ABORT_TASK(0x01),
    htole32(MFII_TASK_MGMT_FLAGS_PD)((__uint32_t)((1 << 1))));

accb->ccb_cookie = ccb;
accb->ccb_done = mfii_scsi_cmd_abort_done;

mfii_start(sc, accb);
}
2688}

2690void
2691mfii_abort(struct mfii_softc *sc, struct mfii_ccb *accb, uint16_t dev_handle,
  uint16_t smid, uint8_t type, uint32_t flags)
2693{
struct mfii_task_mgmt *msg;
struct mpii_msg_scsi_task_request *req;

msg = accb->ccb_request;
req = &msg->mpii_request;
req->dev_handle = dev_handle;
req->function = MPII_FUNCTION_SCSI_TASK_MGMT(0x01);
req->task_type = type;
htolem16(&req->task_mid, smid)(*(__uint16_t *)(&req->task_mid) = ((__uint16_t)(smid)
));
msg->flags = flags;

accb->ccb_req.flags = MFII_REQ_TYPE_HI_PRI(0x6 << 1);
accb->ccb_req.smid = letoh16(accb->ccb_smid)((__uint16_t)(accb->ccb_smid));
2707}

2709void
2710mfii_scsi_cmd_abort_done(struct mfii_softc *sc, struct mfii_ccb *accb)
2711{
struct mfii_ccb *ccb = accb->ccb_cookie;
struct scsi_xfer *xs = ccb->ccb_cookie;

/* XXX check accb completion? */

scsi_io_put(&sc->sc_iopool, accb);

if (atomic_dec_int_nv(&ccb->ccb_refcnt)_atomic_sub_int_nv((&ccb->ccb_refcnt), 1) == 0)
scsi_done(xs);
2721}

2723void *
2724mfii_get_ccb(void *cookie)
2725{
struct mfii_softc *sc = cookie;
struct mfii_ccb *ccb;

mtx_enter(&sc->sc_ccb_mtx);
ccb = SIMPLEQ_FIRST(&sc->sc_ccb_freeq)((&sc->sc_ccb_freeq)->sqh_first);
if (ccb != NULL((void *)0))
SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_freeq, ccb_link)do { if (((&sc->sc_ccb_freeq)->sqh_first = (&sc
->sc_ccb_freeq)->sqh_first->ccb_link.sqe_next) == ((
void *)0)) (&sc->sc_ccb_freeq)->sqh_last = &(&
sc->sc_ccb_freeq)->sqh_first; } while (0);
mtx_leave(&sc->sc_ccb_mtx);

return (ccb);
2736}

2738void
2739mfii_scrub_ccb(struct mfii_ccb *ccb)
2740{
ccb->ccb_cookie = NULL((void *)0);
ccb->ccb_done = NULL((void *)0);
ccb->ccb_flags = 0;
ccb->ccb_data = NULL((void *)0);
ccb->ccb_direction = 0;
ccb->ccb_len = 0;
ccb->ccb_sgl_len = 0;
ccb->ccb_refcnt = 1;

memset(&ccb->ccb_req, 0, sizeof(ccb->ccb_req))__builtin_memset((&ccb->ccb_req), (0), (sizeof(ccb->
ccb_req)));
memset(ccb->ccb_request, 0, MFII_REQUEST_SIZE)__builtin_memset((ccb->ccb_request), (0), (256));
memset(ccb->ccb_mfi, 0, MFI_FRAME_SIZE)__builtin_memset((ccb->ccb_mfi), (0), (64));
2753}

2755void
2756mfii_put_ccb(void *cookie, void *io)
2757{
struct mfii_softc *sc = cookie;
struct mfii_ccb *ccb = io;

mtx_enter(&sc->sc_ccb_mtx);
SIMPLEQ_INSERT_HEAD(&sc->sc_ccb_freeq, ccb, ccb_link)do { if (((ccb)->ccb_link.sqe_next = (&sc->sc_ccb_freeq
)->sqh_first) == ((void *)0)) (&sc->sc_ccb_freeq)->
sqh_last = &(ccb)->ccb_link.sqe_next; (&sc->sc_ccb_freeq
)->sqh_first = (ccb); } while (0);
mtx_leave(&sc->sc_ccb_mtx);
2764}

2766int
2767mfii_init_ccb(struct mfii_softc *sc)
2768{
struct mfii_ccb *ccb;
u_int8_t *request = MFII_DMA_KVA(sc->sc_requests)((void *)(sc->sc_requests)->mdm_kva);
u_int8_t *mfi = MFII_DMA_KVA(sc->sc_mfi)((void *)(sc->sc_mfi)->mdm_kva);
u_int8_t *sense = MFII_DMA_KVA(sc->sc_sense)((void *)(sc->sc_sense)->mdm_kva);
u_int8_t *sgl = MFII_DMA_KVA(sc->sc_sgl)((void *)(sc->sc_sgl)->mdm_kva);
u_int i;
int error;

sc->sc_ccb = mallocarray(sc->sc_max_cmds, sizeof(struct mfii_ccb),
   M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);

for (i = 0; i < sc->sc_max_cmds; i++) {
ccb = &sc->sc_ccb[i];

/* create a dma map for transfer */
error = bus_dmamap_create(sc->sc_dmat,(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), ((64
 * 1024)), (sc->sc_max_sgl), ((64 * 1024)), (0), (0x0001 |
 0x0002), (&ccb->ccb_dmamap))
    MAXPHYS, sc->sc_max_sgl, MAXPHYS, 0,(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), ((64
 * 1024)), (sc->sc_max_sgl), ((64 * 1024)), (0), (0x0001 |
 0x0002), (&ccb->ccb_dmamap))
    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), ((64
 * 1024)), (sc->sc_max_sgl), ((64 * 1024)), (0), (0x0001 |
 0x0002), (&ccb->ccb_dmamap));
if (error) {
	printf("%s: cannot create ccb dmamap (%d)\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), error);
	goto destroy;
}

/* select i + 1'th request. 0 is reserved for events */
ccb->ccb_smid = i + 1;
ccb->ccb_request_offset = MFII_REQUEST_SIZE256 * (i + 1);
ccb->ccb_request = request + ccb->ccb_request_offset;
ccb->ccb_request_dva = MFII_DMA_DVA(sc->sc_requests)((u_int64_t)(sc->sc_requests)->mdm_map->dm_segs[0].ds_addr
) +
    ccb->ccb_request_offset;

/* select i'th MFI command frame */
ccb->ccb_mfi_offset = MFI_FRAME_SIZE64 * i;
ccb->ccb_mfi = mfi + ccb->ccb_mfi_offset;
ccb->ccb_mfi_dva = MFII_DMA_DVA(sc->sc_mfi)((u_int64_t)(sc->sc_mfi)->mdm_map->dm_segs[0].ds_addr
) +
    ccb->ccb_mfi_offset;

/* select i'th sense */
ccb->ccb_sense_offset = MFI_SENSE_SIZE128 * i;
ccb->ccb_sense = (struct mfi_sense *)(sense +
    ccb->ccb_sense_offset);
ccb->ccb_sense_dva = MFII_DMA_DVA(sc->sc_sense)((u_int64_t)(sc->sc_sense)->mdm_map->dm_segs[0].ds_addr
) +
    ccb->ccb_sense_offset;

/* select i'th sgl */
ccb->ccb_sgl_offset = sizeof(struct mfii_sge) *
    sc->sc_max_sgl * i;
ccb->ccb_sgl = (struct mfii_sge *)(sgl + ccb->ccb_sgl_offset);
ccb->ccb_sgl_dva = MFII_DMA_DVA(sc->sc_sgl)((u_int64_t)(sc->sc_sgl)->mdm_map->dm_segs[0].ds_addr
) +
    ccb->ccb_sgl_offset;

/* add ccb to queue */
mfii_put_ccb(sc, ccb);
}

return (0);

2826destroy:
/* free dma maps and ccb memory */
while ((ccb = mfii_get_ccb(sc)) != NULL((void *)0))
bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_destroy)((sc->sc_dmat), (ccb
->ccb_dmamap));

free(sc->sc_ccb, M_DEVBUF2, 0);

return (1);
2834}

2836#if NBIO1 > 0
2837int
2838mfii_ioctl(struct device *dev, u_long cmd, caddr_t addr)
2839{
struct mfii_softc	*sc = (struct mfii_softc *)dev;
int error = 0;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl ", DEVNAME(sc));

rw_enter_write(&sc->sc_lock);

switch (cmd) {
1
Control jumps to 'case 3274719777:'  at line 2858→
case BIOCINQ(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_inq) & 0x1fff) << 16) | ((('B')) <<
 8) | ((32))):
DNPRINTF(MFII_D_IOCTL, "inq\n");
error = mfii_ioctl_inq(sc, (struct bioc_inq *)addr);
break;

case BIOCVOL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_vol) & 0x1fff) << 16) | ((('B')) <<
 8) | ((34))):
DNPRINTF(MFII_D_IOCTL, "vol\n");
error = mfii_ioctl_vol(sc, (struct bioc_vol *)addr);
break;

case BIOCDISK(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_disk) & 0x1fff) << 16) | ((('B')) <<
 8) | ((33))):
DNPRINTF(MFII_D_IOCTL, "disk\n");
error = mfii_ioctl_disk(sc, (struct bioc_disk *)addr);
2
←
Calling 'mfii_ioctl_disk'→
break;

case BIOCALARM(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_alarm) & 0x1fff) << 16) | ((('B')) <<
 8) | ((35))):
DNPRINTF(MFII_D_IOCTL, "alarm\n");
error = mfii_ioctl_alarm(sc, (struct bioc_alarm *)addr);
break;

case BIOCBLINK(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_blink) & 0x1fff) << 16) | ((('B')) <<
 8) | ((36))):
DNPRINTF(MFII_D_IOCTL, "blink\n");
error = mfii_ioctl_blink(sc, (struct bioc_blink *)addr);
break;

case BIOCSETSTATE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_setstate) & 0x1fff) << 16) | ((('B')) <<
 8) | ((37))):
DNPRINTF(MFII_D_IOCTL, "setstate\n");
error = mfii_ioctl_setstate(sc, (struct bioc_setstate *)addr);
break;

case BIOCPATROL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct bioc_patrol) & 0x1fff) << 16) | ((('B')) <<
 8) | ((42))):
DNPRINTF(MFII_D_IOCTL, "patrol\n");
error = mfii_ioctl_patrol(sc, (struct bioc_patrol *)addr);
break;

default:
DNPRINTF(MFII_D_IOCTL, " invalid ioctl\n");
error = ENOTTY25;
}

rw_exit_write(&sc->sc_lock);

return (error);
2891}

2893int
2894mfii_bio_getitall(struct mfii_softc *sc)
2895{
int			i, d, rv = EINVAL22;
size_t			size;
union mfi_mbox		mbox;
struct mfi_conf		*cfg = NULL((void *)0);
struct mfi_ld_details	*ld_det = NULL((void *)0);

/* get info */
if (mfii_get_info(sc)) {
DNPRINTF(MFII_D_IOCTL, "%s: mfii_get_info failed\n",
    DEVNAME(sc));
goto done;
}

/* send single element command to retrieve size for full structure */
cfg = malloc(sizeof *cfg, M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (cfg == NULL((void *)0))
goto done;
if (mfii_mgmt(sc, MR_DCMD_CONF_GET0x04010000, NULL((void *)0), cfg, sizeof(*cfg),
   SCSI_DATA_IN0x00800)) {
free(cfg, M_DEVBUF2, sizeof *cfg);
goto done;
}

size = cfg->mfc_size;
free(cfg, M_DEVBUF2, sizeof *cfg);

/* memory for read config */
cfg = malloc(size, M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (cfg == NULL((void *)0))
goto done;
if (mfii_mgmt(sc, MR_DCMD_CONF_GET0x04010000, NULL((void *)0), cfg, size, SCSI_DATA_IN0x00800)) {
free(cfg, M_DEVBUF2, size);
goto done;
}

/* replace current pointer with new one */
if (sc->sc_cfg)
free(sc->sc_cfg, M_DEVBUF2, 0);
sc->sc_cfg = cfg;

/* get all ld info */
if (mfii_mgmt(sc, MR_DCMD_LD_GET_LIST0x03010000, NULL((void *)0), &sc->sc_ld_list,
   sizeof(sc->sc_ld_list), SCSI_DATA_IN0x00800))
goto done;

/* get memory for all ld structures */
size = cfg->mfc_no_ld * sizeof(struct mfi_ld_details);
if (sc->sc_ld_sz != size) {
if (sc->sc_ld_details)
	free(sc->sc_ld_details, M_DEVBUF2, 0);

ld_det = malloc(size, M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (ld_det == NULL((void *)0))
	goto done;
sc->sc_ld_sz = size;
sc->sc_ld_details = ld_det;
}

/* find used physical disks */
size = sizeof(struct mfi_ld_details);
for (i = 0, d = 0; i < cfg->mfc_no_ld; i++) {
memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.b[0] = sc->sc_ld_list.mll_list[i].mll_ld.mld_target;
if (mfii_mgmt(sc, MR_DCMD_LD_GET_INFO0x03020000, &mbox, &sc->sc_ld_details[i], size,
    SCSI_DATA_IN0x00800))
	goto done;

d += sc->sc_ld_details[i].mld_cfg.mlc_parm.mpa_no_drv_per_span *
    sc->sc_ld_details[i].mld_cfg.mlc_parm.mpa_span_depth;
}
sc->sc_no_pd = d;

rv = 0;
2969done:
return (rv);
2971}

2973int
2974mfii_ioctl_inq(struct mfii_softc *sc, struct bioc_inq *bi)
2975{
int			rv = EINVAL22;
struct mfi_conf		*cfg = NULL((void *)0);

DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_inq\n", DEVNAME(sc));

if (mfii_bio_getitall(sc)) {
DNPRINTF(MFII_D_IOCTL, "%s: mfii_bio_getitall failed\n",
    DEVNAME(sc));
goto done;
}

/* count unused disks as volumes */
if (sc->sc_cfg == NULL((void *)0))
goto done;
cfg = sc->sc_cfg;

bi->bi_nodisk = sc->sc_info.mci_pd_disks_present;
bi->bi_novol = cfg->mfc_no_ld + cfg->mfc_no_hs;
2994#if notyet
bi->bi_novol = cfg->mfc_no_ld + cfg->mfc_no_hs +
   (bi->bi_nodisk - sc->sc_no_pd);
2997#endif
/* tell bio who we are */
strlcpy(bi->bi_dev, DEVNAME(sc)((sc)->sc_dev.dv_xname), sizeof(bi->bi_dev));

rv = 0;
3002done:
return (rv);
3004}

3006int
3007mfii_ioctl_vol(struct mfii_softc *sc, struct bioc_vol *bv)
3008{
int			i, per, target, rv = EINVAL22;
struct scsi_link	*link;
struct device		*dev;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_vol %#x\n",
   DEVNAME(sc), bv->bv_volid);

/* we really could skip and expect that inq took care of it */
if (mfii_bio_getitall(sc)) {
DNPRINTF(MFII_D_IOCTL, "%s: mfii_bio_getitall failed\n",
    DEVNAME(sc));
goto done;
}

if (bv->bv_volid >= sc->sc_ld_list.mll_no_ld) {
/* go do hotspares & unused disks */
rv = mfii_bio_hs(sc, bv->bv_volid, MFI_MGMT_VD0x01, bv);
goto done;
}

i = bv->bv_volid;
target = sc->sc_ld_list.mll_list[i].mll_ld.mld_target;
link = scsi_get_link(sc->sc_scsibus, target, 0);
if (link == NULL((void *)0)) {
strlcpy(bv->bv_dev, "cache", sizeof(bv->bv_dev));
} else {
dev = link->device_softc;
if (dev == NULL((void *)0))
	goto done;

strlcpy(bv->bv_dev, dev->dv_xname, sizeof(bv->bv_dev));
}

switch(sc->sc_ld_list.mll_list[i].mll_state) {
case MFI_LD_OFFLINE0x00:
bv->bv_status = BIOC_SVOFFLINE0x01;
break;

case MFI_LD_PART_DEGRADED0x01:
case MFI_LD_DEGRADED0x02:
bv->bv_status = BIOC_SVDEGRADED0x02;
break;

case MFI_LD_ONLINE0x03:
bv->bv_status = BIOC_SVONLINE0x00;
break;

default:
bv->bv_status = BIOC_SVINVALID0xff;
DNPRINTF(MFII_D_IOCTL, "%s: invalid logical disk state %#x\n",
    DEVNAME(sc),
    sc->sc_ld_list.mll_list[i].mll_state);
}

/* additional status can modify MFI status */
switch (sc->sc_ld_details[i].mld_progress.mlp_in_prog) {
case MFI_LD_PROG_CC0x01:
bv->bv_status = BIOC_SVSCRUB0x04;
per = (int)sc->sc_ld_details[i].mld_progress.mlp_cc.mp_progress;
bv->bv_percent = (per * 100) / 0xffff;
bv->bv_seconds =
    sc->sc_ld_details[i].mld_progress.mlp_cc.mp_elapsed_seconds;
break;

case MFI_LD_PROG_BGI0x02:
bv->bv_status = BIOC_SVSCRUB0x04;
per = (int)sc->sc_ld_details[i].mld_progress.mlp_bgi.mp_progress;
bv->bv_percent = (per * 100) / 0xffff;
bv->bv_seconds =
    sc->sc_ld_details[i].mld_progress.mlp_bgi.mp_elapsed_seconds;
break;

case MFI_LD_PROG_FGI0x04:
case MFI_LD_PROG_RECONSTRUCT0x08:
/* nothing yet */
break;
}

if (sc->sc_ld_details[i].mld_cfg.mlc_prop.mlp_cur_cache_policy & 0x01)
bv->bv_cache = BIOC_CVWRITEBACK0x01;
else
bv->bv_cache = BIOC_CVWRITETHROUGH0x02;

/*
* The RAID levels are determined per the SNIA DDF spec, this is only
* a subset that is valid for the MFI controller.
*/
bv->bv_level = sc->sc_ld_details[i].mld_cfg.mlc_parm.mpa_pri_raid;
if (sc->sc_ld_details[i].mld_cfg.mlc_parm.mpa_span_depth > 1)
bv->bv_level *= 10;

bv->bv_nodisk = sc->sc_ld_details[i].mld_cfg.mlc_parm.mpa_no_drv_per_span *
   sc->sc_ld_details[i].mld_cfg.mlc_parm.mpa_span_depth;

bv->bv_size = sc->sc_ld_details[i].mld_size * 512; /* bytes per block */

rv = 0;
3106done:
return (rv);
3108}

3110int
3111mfii_ioctl_disk(struct mfii_softc *sc, struct bioc_disk *bd)
3112{
struct mfi_conf		*cfg;
struct mfi_array	*ar;
struct mfi_ld_cfg	*ld;
struct mfi_pd_details	*pd;
struct mfi_pd_list	*pl;
struct mfi_pd_progress	*mfp;
struct mfi_progress	*mp;
struct scsi_inquiry_data *inqbuf;
char			vend[8+16+4+1], *vendp;
int			i, rv = EINVAL22;
int			arr, vol, disk, span;
union mfi_mbox		mbox;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_disk %#x\n",
   DEVNAME(sc), bd->bd_diskid);

/* we really could skip and expect that inq took care of it */
if (mfii_bio_getitall(sc)) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
DNPRINTF(MFII_D_IOCTL, "%s: mfii_bio_getitall failed\n",
    DEVNAME(sc));
return (rv);
}
cfg = sc->sc_cfg;

pd = malloc(sizeof *pd, M_DEVBUF2, M_WAITOK0x0001);
5
←
Uninitialized value stored to field 'mpd_enc_idx'→
pl = malloc(sizeof *pl, M_DEVBUF2, M_WAITOK0x0001);

ar = cfg->mfc_array;
vol = bd->bd_volid;
if (vol >= cfg->mfc_no_ld) {
6
←
Assuming 'vol' is < field 'mfc_no_ld'→
7
←
Taking false branch→
/* do hotspares */
rv = mfii_bio_hs(sc, bd->bd_volid, MFI_MGMT_SD0x02, bd);
goto freeme;
}

/* calculate offset to ld structure */
ld = (struct mfi_ld_cfg *)(
   ((uint8_t *)cfg) + offsetof(struct mfi_conf, mfc_array)__builtin_offsetof(struct mfi_conf, mfc_array) +
   cfg->mfc_array_size * cfg->mfc_no_array);

/* use span 0 only when raid group is not spanned */
if (ld[vol].mlc_parm.mpa_span_depth > 1)
8
←
Assuming field 'mpa_span_depth' is <= 1→
9
←
Taking false branch→
span = bd->bd_diskid / ld[vol].mlc_parm.mpa_no_drv_per_span;
else
span = 0;
arr = ld[vol].mlc_span[span].mls_index;

/* offset disk into pd list */
disk = bd->bd_diskid % ld[vol].mlc_parm.mpa_no_drv_per_span;

if (ar[arr].pd[disk].mar_pd.mfp_id == 0xffffU) {
10
←
Assuming field 'mfp_id' is not equal to 65535→
11
←
Taking false branch→
/* disk is missing but succeed command */
bd->bd_status = BIOC_SDFAILED0x02;
rv = 0;

/* try to find an unused disk for the target to rebuild */
if (mfii_mgmt(sc, MR_DCMD_PD_GET_LIST0x02010000, NULL((void *)0), pl, sizeof(*pl),
    SCSI_DATA_IN0x00800))
	goto freeme;

for (i = 0; i < pl->mpl_no_pd; i++) {
	if (pl->mpl_address[i].mpa_scsi_type != 0)
		continue;

	memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
	mbox.s[0] = pl->mpl_address[i].mpa_pd_id;
	if (mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd),
	    SCSI_DATA_IN0x00800))
		continue;

	if (pd->mpd_fw_state == MFI_PD_UNCONFIG_GOOD0x00 ||
	    pd->mpd_fw_state == MFI_PD_UNCONFIG_BAD0x01)
		break;
}

if (i == pl->mpl_no_pd)
	goto freeme;
} else {
memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.s[0] = ar[arr].pd[disk].mar_pd.mfp_id;
if (mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd),
12
←
Calling 'mfii_mgmt'→
38
←
Returning from 'mfii_mgmt'→
39
←
Taking false branch→
    SCSI_DATA_IN0x00800)) {
	bd->bd_status = BIOC_SDINVALID0xff;
	goto freeme;
}
}

/* get the remaining fields */
bd->bd_channel = pd->mpd_enc_idx;
40
←
Assigned value is garbage or undefined
bd->bd_target = pd->mpd_enc_slot;

/* get status */
switch (pd->mpd_fw_state){
case MFI_PD_UNCONFIG_GOOD0x00:
case MFI_PD_UNCONFIG_BAD0x01:
bd->bd_status = BIOC_SDUNUSED0x05;
break;

case MFI_PD_HOTSPARE0x02: /* XXX dedicated hotspare part of array? */
bd->bd_status = BIOC_SDHOTSPARE0x04;
break;

case MFI_PD_OFFLINE0x10:
bd->bd_status = BIOC_SDOFFLINE0x01;
break;

case MFI_PD_FAILED0x11:
bd->bd_status = BIOC_SDFAILED0x02;
break;

case MFI_PD_REBUILD0x14:
bd->bd_status = BIOC_SDREBUILD0x03;
break;

case MFI_PD_ONLINE0x18:
bd->bd_status = BIOC_SDONLINE0x00;
break;

case MFI_PD_COPYBACK0x20:
case MFI_PD_SYSTEM0x40:
default:
bd->bd_status = BIOC_SDINVALID0xff;
break;
}

bd->bd_size = pd->mpd_size * 512; /* bytes per block */

inqbuf = (struct scsi_inquiry_data *)&pd->mpd_inq_data;
vendp = inqbuf->vendor;
memcpy(vend, vendp, sizeof vend - 1)__builtin_memcpy((vend), (vendp), (sizeof vend - 1));
vend[sizeof vend - 1] = '\0';
strlcpy(bd->bd_vendor, vend, sizeof(bd->bd_vendor));

/* XXX find a way to retrieve serial nr from drive */
/* XXX find a way to get bd_procdev */

mfp = &pd->mpd_progress;
if (mfp->mfp_in_prog & MFI_PD_PROG_PR0x02) {
mp = &mfp->mfp_patrol_read;
bd->bd_patrol.bdp_percent = (mp->mp_progress * 100) / 0xffff;
bd->bd_patrol.bdp_seconds = mp->mp_elapsed_seconds;
}

rv = 0;
3257freeme:
free(pd, M_DEVBUF2, sizeof *pd);
free(pl, M_DEVBUF2, sizeof *pl);

return (rv);
3262}

3264int
3265mfii_ioctl_alarm(struct mfii_softc *sc, struct bioc_alarm *ba)
3266{
uint32_t		opc, flags = 0;
int			rv = 0;
int8_t			ret;

switch(ba->ba_opcode) {
case BIOC_SADISABLE0x00:
opc = MR_DCMD_SPEAKER_DISABLE0x01030300;
break;

case BIOC_SAENABLE0x01:
opc = MR_DCMD_SPEAKER_ENABLE0x01030200;
break;

case BIOC_SASILENCE0x02:
opc = MR_DCMD_SPEAKER_SILENCE0x01030400;
break;

case BIOC_GASTATUS0x03:
opc = MR_DCMD_SPEAKER_GET0x01030100;
flags = SCSI_DATA_IN0x00800;
break;

case BIOC_SATEST0x04:
opc = MR_DCMD_SPEAKER_TEST0x01030500;
break;

default:
DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_alarm biocalarm invalid "
    "opcode %x\n", DEVNAME(sc), ba->ba_opcode);
return (EINVAL22);
}

if (mfii_mgmt(sc, opc, NULL((void *)0), &ret, sizeof(ret), flags))
rv = EINVAL22;
else
if (ba->ba_opcode == BIOC_GASTATUS0x03)
	ba->ba_status = ret;
else
	ba->ba_status = 0;

return (rv);
3308}

3310int
3311mfii_ioctl_blink(struct mfii_softc *sc, struct bioc_blink *bb)
3312{
int			i, found, rv = EINVAL22;
union mfi_mbox		mbox;
uint32_t		cmd;
struct mfi_pd_list	*pd;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_blink %x\n", DEVNAME(sc),
   bb->bb_status);

/* channel 0 means not in an enclosure so can't be blinked */
if (bb->bb_channel == 0)
return (EINVAL22);

pd = malloc(sizeof(*pd), M_DEVBUF2, M_WAITOK0x0001);

if (mfii_mgmt(sc, MR_DCMD_PD_GET_LIST0x02010000, NULL((void *)0), pd, sizeof(*pd), SCSI_DATA_IN0x00800))
goto done;

for (i = 0, found = 0; i < pd->mpl_no_pd; i++)
if (bb->bb_channel == pd->mpl_address[i].mpa_enc_index &&
    bb->bb_target == pd->mpl_address[i].mpa_enc_slot) {
	found = 1;
	break;
}

if (!found)
goto done;

memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.s[0] = pd->mpl_address[i].mpa_pd_id;

switch (bb->bb_status) {
case BIOC_SBUNBLINK0x00:
cmd = MR_DCMD_PD_UNBLINK0x02070200;
break;

case BIOC_SBBLINK0x01:
cmd = MR_DCMD_PD_BLINK0x02070100;
break;

case BIOC_SBALARM0x02:
default:
DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_blink biocblink invalid "
    "opcode %x\n", DEVNAME(sc), bb->bb_status);
goto done;
}


if (mfii_mgmt(sc, cmd, &mbox, NULL((void *)0), 0, 0) == 0)
rv = 0;

3363done:
free(pd, M_DEVBUF2, sizeof *pd);
return (rv);
3366}

3368static int
3369mfii_makegood(struct mfii_softc *sc, uint16_t pd_id)
3370{
struct mfii_foreign_scan_info *fsi;
struct mfi_pd_details	*pd;
union mfi_mbox		mbox;
int			rv;

fsi = malloc(sizeof *fsi, M_DEVBUF2, M_WAITOK0x0001);
pd = malloc(sizeof *pd, M_DEVBUF2, M_WAITOK0x0001);

memset(&mbox, 0, sizeof mbox)__builtin_memset((&mbox), (0), (sizeof mbox));
mbox.s[0] = pd_id;
rv = mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd), SCSI_DATA_IN0x00800);
if (rv != 0)
goto done;

if (pd->mpd_fw_state == MFI_PD_UNCONFIG_BAD0x01) {
mbox.s[0] = pd_id;
mbox.s[1] = pd->mpd_pd.mfp_seq;
mbox.b[4] = MFI_PD_UNCONFIG_GOOD0x00;
rv = mfii_mgmt(sc, MR_DCMD_PD_SET_STATE0x02030100, &mbox, NULL((void *)0), 0, 0);
if (rv != 0)
	goto done;
}

memset(&mbox, 0, sizeof mbox)__builtin_memset((&mbox), (0), (sizeof mbox));
mbox.s[0] = pd_id;
rv = mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd), SCSI_DATA_IN0x00800);
if (rv != 0)
goto done;

if (pd->mpd_ddf_state & MFI_DDF_FOREIGN0x10) {
rv = mfii_mgmt(sc, MR_DCMD_CFG_FOREIGN_SCAN0x04060100, NULL((void *)0), fsi, sizeof(*fsi),
    SCSI_DATA_IN0x00800);
if (rv != 0)
	goto done;

if (fsi->count > 0) {
	rv = mfii_mgmt(sc, MR_DCMD_CFG_FOREIGN_CLEAR0x04060500, NULL((void *)0), NULL((void *)0), 0, 0);
	if (rv != 0)
		goto done;
}
}

memset(&mbox, 0, sizeof mbox)__builtin_memset((&mbox), (0), (sizeof mbox));
mbox.s[0] = pd_id;
rv = mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd), SCSI_DATA_IN0x00800);
if (rv != 0)
goto done;

if (pd->mpd_fw_state != MFI_PD_UNCONFIG_GOOD0x00 ||
   pd->mpd_ddf_state & MFI_DDF_FOREIGN0x10)
rv = ENXIO6;

3423done:
free(fsi, M_DEVBUF2, sizeof *fsi);
free(pd, M_DEVBUF2, sizeof *pd);

return (rv);
3428}

3430static int
3431mfii_makespare(struct mfii_softc *sc, uint16_t pd_id)
3432{
struct mfi_hotspare	*hs;
struct mfi_pd_details	*pd;
union mfi_mbox		mbox;
size_t			size;
int			rv = EINVAL22;

/* we really could skip and expect that inq took care of it */
if (mfii_bio_getitall(sc)) {
DNPRINTF(MFII_D_IOCTL, "%s: mfii_bio_getitall failed\n",
    DEVNAME(sc));
return (rv);
}
size = sizeof *hs + sizeof(uint16_t) * sc->sc_cfg->mfc_no_array;

hs = malloc(size, M_DEVBUF2, M_WAITOK0x0001);
pd = malloc(sizeof *pd, M_DEVBUF2, M_WAITOK0x0001);

memset(&mbox, 0, sizeof mbox)__builtin_memset((&mbox), (0), (sizeof mbox));
mbox.s[0] = pd_id;
rv = mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd),
   SCSI_DATA_IN0x00800);
if (rv != 0)
goto done;

memset(hs, 0, size)__builtin_memset((hs), (0), (size));
hs->mhs_pd.mfp_id = pd->mpd_pd.mfp_id;
hs->mhs_pd.mfp_seq = pd->mpd_pd.mfp_seq;
rv = mfii_mgmt(sc, MR_DCMD_CFG_MAKE_SPARE0x04040000, NULL((void *)0), hs, size, SCSI_DATA_OUT0x01000);

3462done:
free(hs, M_DEVBUF2, size);
free(pd, M_DEVBUF2, sizeof *pd);

return (rv);
3467}

3469int
3470mfii_ioctl_setstate(struct mfii_softc *sc, struct bioc_setstate *bs)
3471{
struct mfi_pd_details	*pd;
struct mfi_pd_list	*pl;
int			i, found, rv = EINVAL22;
union mfi_mbox		mbox;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_setstate %x\n", DEVNAME(sc),
   bs->bs_status);

pd = malloc(sizeof *pd, M_DEVBUF2, M_WAITOK0x0001);
pl = malloc(sizeof *pl, M_DEVBUF2, M_WAITOK0x0001);

if (mfii_mgmt(sc, MR_DCMD_PD_GET_LIST0x02010000, NULL((void *)0), pl, sizeof(*pl), SCSI_DATA_IN0x00800))
goto done;

for (i = 0, found = 0; i < pl->mpl_no_pd; i++)
if (bs->bs_channel == pl->mpl_address[i].mpa_enc_index &&
    bs->bs_target == pl->mpl_address[i].mpa_enc_slot) {
	found = 1;
	break;
}

if (!found)
goto done;

memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.s[0] = pl->mpl_address[i].mpa_pd_id;

if (mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd), SCSI_DATA_IN0x00800))
goto done;

mbox.s[0] = pl->mpl_address[i].mpa_pd_id;
mbox.s[1] = pd->mpd_pd.mfp_seq;

switch (bs->bs_status) {
case BIOC_SSONLINE0x00:
mbox.b[4] = MFI_PD_ONLINE0x18;
break;

case BIOC_SSOFFLINE0x01:
mbox.b[4] = MFI_PD_OFFLINE0x10;
break;

case BIOC_SSHOTSPARE0x02:
mbox.b[4] = MFI_PD_HOTSPARE0x02;
break;

case BIOC_SSREBUILD0x03:
if (pd->mpd_fw_state != MFI_PD_OFFLINE0x10) {
	if ((rv = mfii_makegood(sc,
	    pl->mpl_address[i].mpa_pd_id)))
		goto done;

	if ((rv = mfii_makespare(sc,
	    pl->mpl_address[i].mpa_pd_id)))
		goto done;

	memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
	mbox.s[0] = pl->mpl_address[i].mpa_pd_id;
	rv = mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd),
	    SCSI_DATA_IN0x00800);
	if (rv != 0)
		goto done;

	/* rebuilding might be started by mfii_makespare() */
	if (pd->mpd_fw_state == MFI_PD_REBUILD0x14) {
		rv = 0;
		goto done;
	}

	mbox.s[0] = pl->mpl_address[i].mpa_pd_id;
	mbox.s[1] = pd->mpd_pd.mfp_seq;
}
mbox.b[4] = MFI_PD_REBUILD0x14;
break;

default:
DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_setstate invalid "
    "opcode %x\n", DEVNAME(sc), bs->bs_status);
goto done;
}


rv = mfii_mgmt(sc, MR_DCMD_PD_SET_STATE0x02030100, &mbox, NULL((void *)0), 0, 0);
3555done:
free(pd, M_DEVBUF2, sizeof *pd);
free(pl, M_DEVBUF2, sizeof *pl);
return (rv);
3559}

3561int
3562mfii_ioctl_patrol(struct mfii_softc *sc, struct bioc_patrol *bp)
3563{
uint32_t		opc;
int			rv = 0;
struct mfi_pr_properties prop;
struct mfi_pr_status	status;
uint32_t		time, exec_freq;

switch (bp->bp_opcode) {
case BIOC_SPSTOP0x00:
case BIOC_SPSTART0x01:
if (bp->bp_opcode == BIOC_SPSTART0x01)
	opc = MR_DCMD_PR_START0x01070400;
else
	opc = MR_DCMD_PR_STOP0x01070500;
if (mfii_mgmt(sc, opc, NULL((void *)0), NULL((void *)0), 0, SCSI_DATA_IN0x00800))
	return (EINVAL22);
break;

case BIOC_SPMANUAL0x05:
case BIOC_SPDISABLE0x03:
case BIOC_SPAUTO0x04:
/* Get device's time. */
opc = MR_DCMD_TIME_SECS_GET0x01080201;
if (mfii_mgmt(sc, opc, NULL((void *)0), &time, sizeof(time), SCSI_DATA_IN0x00800))
	return (EINVAL22);

opc = MR_DCMD_PR_GET_PROPERTIES0x01070200;
if (mfii_mgmt(sc, opc, NULL((void *)0), &prop, sizeof(prop), SCSI_DATA_IN0x00800))
	return (EINVAL22);

switch (bp->bp_opcode) {
case BIOC_SPMANUAL0x05:
	prop.op_mode = MFI_PR_OPMODE_MANUAL0x01;
	break;
case BIOC_SPDISABLE0x03:
	prop.op_mode = MFI_PR_OPMODE_DISABLED0x02;
	break;
case BIOC_SPAUTO0x04:
	if (bp->bp_autoival != 0) {
		if (bp->bp_autoival == -1)
			/* continuously */
			exec_freq = 0xffffffffU;
		else if (bp->bp_autoival > 0)
			exec_freq = bp->bp_autoival;
		else
			return (EINVAL22);
		prop.exec_freq = exec_freq;
	}
	if (bp->bp_autonext != 0) {
		if (bp->bp_autonext < 0)
			return (EINVAL22);
		else
			prop.next_exec = time + bp->bp_autonext;
	}
	prop.op_mode = MFI_PR_OPMODE_AUTO0x00;
	break;
}

opc = MR_DCMD_PR_SET_PROPERTIES0x01070300;
if (mfii_mgmt(sc, opc, NULL((void *)0), &prop, sizeof(prop), SCSI_DATA_OUT0x01000))
	return (EINVAL22);

break;

case BIOC_GPSTATUS0x02:
opc = MR_DCMD_PR_GET_PROPERTIES0x01070200;
if (mfii_mgmt(sc, opc, NULL((void *)0), &prop, sizeof(prop), SCSI_DATA_IN0x00800))
	return (EINVAL22);

opc = MR_DCMD_PR_GET_STATUS0x01070100;
if (mfii_mgmt(sc, opc, NULL((void *)0), &status, sizeof(status), SCSI_DATA_IN0x00800))
	return (EINVAL22);

/* Get device's time. */
opc = MR_DCMD_TIME_SECS_GET0x01080201;
if (mfii_mgmt(sc, opc, NULL((void *)0), &time, sizeof(time), SCSI_DATA_IN0x00800))
	return (EINVAL22);

switch (prop.op_mode) {
case MFI_PR_OPMODE_AUTO0x00:
	bp->bp_mode = BIOC_SPMAUTO0x00;
	bp->bp_autoival = prop.exec_freq;
	bp->bp_autonext = prop.next_exec;
	bp->bp_autonow = time;
	break;
case MFI_PR_OPMODE_MANUAL0x01:
	bp->bp_mode = BIOC_SPMMANUAL0x01;
	break;
case MFI_PR_OPMODE_DISABLED0x02:
	bp->bp_mode = BIOC_SPMDISABLED0x02;
	break;
default:
	printf("%s: unknown patrol mode %d\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), prop.op_mode);
	break;
}

switch (status.state) {
case MFI_PR_STATE_STOPPED0:
	bp->bp_status = BIOC_SPSSTOPPED0x00;
	break;
case MFI_PR_STATE_READY1:
	bp->bp_status = BIOC_SPSREADY0x01;
	break;
case MFI_PR_STATE_ACTIVE2:
	bp->bp_status = BIOC_SPSACTIVE0x02;
	break;
case MFI_PR_STATE_ABORTED0xff:
	bp->bp_status = BIOC_SPSABORTED0xff;
	break;
default:
	printf("%s: unknown patrol state %d\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname), status.state);
	break;
}

break;

default:
DNPRINTF(MFII_D_IOCTL, "%s: mfii_ioctl_patrol biocpatrol invalid "
    "opcode %x\n", DEVNAME(sc), bp->bp_opcode);
return (EINVAL22);
}

return (rv);
3688}

3690int
3691mfii_bio_hs(struct mfii_softc *sc, int volid, int type, void *bio_hs)
3692{
struct mfi_conf		*cfg;
struct mfi_hotspare	*hs;
struct mfi_pd_details	*pd;
struct bioc_disk	*sdhs;
struct bioc_vol		*vdhs;
struct scsi_inquiry_data *inqbuf;
char			vend[8+16+4+1], *vendp;
int			i, rv = EINVAL22;
uint32_t		size;
union mfi_mbox		mbox;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_vol_hs %d\n", DEVNAME(sc), volid);

if (!bio_hs)
return (EINVAL22);

pd = malloc(sizeof *pd, M_DEVBUF2, M_WAITOK0x0001);

/* send single element command to retrieve size for full structure */
cfg = malloc(sizeof *cfg, M_DEVBUF2, M_WAITOK0x0001);
if (mfii_mgmt(sc, MR_DCMD_CONF_GET0x04010000, NULL((void *)0), cfg, sizeof(*cfg), SCSI_DATA_IN0x00800))
goto freeme;

size = cfg->mfc_size;
free(cfg, M_DEVBUF2, sizeof *cfg);

/* memory for read config */
cfg = malloc(size, M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
if (mfii_mgmt(sc, MR_DCMD_CONF_GET0x04010000, NULL((void *)0), cfg, size, SCSI_DATA_IN0x00800))
goto freeme;

/* calculate offset to hs structure */
hs = (struct mfi_hotspare *)(
   ((uint8_t *)cfg) + offsetof(struct mfi_conf, mfc_array)__builtin_offsetof(struct mfi_conf, mfc_array) +
   cfg->mfc_array_size * cfg->mfc_no_array +
   cfg->mfc_ld_size * cfg->mfc_no_ld);

if (volid < cfg->mfc_no_ld)
goto freeme; /* not a hotspare */

if (volid > (cfg->mfc_no_ld + cfg->mfc_no_hs))
goto freeme; /* not a hotspare */

/* offset into hotspare structure */
i = volid - cfg->mfc_no_ld;

DNPRINTF(MFII_D_IOCTL, "%s: mfii_vol_hs i %d volid %d no_ld %d no_hs %d "
   "hs %p cfg %p id %02x\n", DEVNAME(sc), i, volid, cfg->mfc_no_ld,
   cfg->mfc_no_hs, hs, cfg, hs[i].mhs_pd.mfp_id);

/* get pd fields */
memset(&mbox, 0, sizeof(mbox))__builtin_memset((&mbox), (0), (sizeof(mbox)));
mbox.s[0] = hs[i].mhs_pd.mfp_id;
if (mfii_mgmt(sc, MR_DCMD_PD_GET_INFO0x02020000, &mbox, pd, sizeof(*pd),
   SCSI_DATA_IN0x00800)) {
DNPRINTF(MFII_D_IOCTL, "%s: mfii_vol_hs illegal PD\n",
    DEVNAME(sc));
goto freeme;
}

switch (type) {
case MFI_MGMT_VD0x01:
vdhs = bio_hs;
vdhs->bv_status = BIOC_SVONLINE0x00;
vdhs->bv_size = pd->mpd_size / 2 * 1024; /* XXX why? */
vdhs->bv_level = -1; /* hotspare */
vdhs->bv_nodisk = 1;
break;

case MFI_MGMT_SD0x02:
sdhs = bio_hs;
sdhs->bd_status = BIOC_SDHOTSPARE0x04;
sdhs->bd_size = pd->mpd_size / 2 * 1024; /* XXX why? */
sdhs->bd_channel = pd->mpd_enc_idx;
sdhs->bd_target = pd->mpd_enc_slot;
inqbuf = (struct scsi_inquiry_data *)&pd->mpd_inq_data;
vendp = inqbuf->vendor;
memcpy(vend, vendp, sizeof vend - 1)__builtin_memcpy((vend), (vendp), (sizeof vend - 1));
vend[sizeof vend - 1] = '\0';
strlcpy(sdhs->bd_vendor, vend, sizeof(sdhs->bd_vendor));
break;

default:
goto freeme;
}

DNPRINTF(MFII_D_IOCTL, "%s: mfii_vol_hs 6\n", DEVNAME(sc));
rv = 0;
3781freeme:
free(pd, M_DEVBUF2, sizeof *pd);
free(cfg, M_DEVBUF2, 0);

return (rv);
3786}

3788#ifndef SMALL_KERNEL

3790#define MFI_BBU_SENSORS4 4

3792void
3793mfii_bbu(struct mfii_softc *sc)
3794{
struct mfi_bbu_status bbu;
u_int32_t status;
u_int32_t mask;
u_int32_t soh_bad;
int i;

if (mfii_mgmt(sc, MR_DCMD_BBU_GET_STATUS0x05010000, NULL((void *)0), &bbu,
   sizeof(bbu), SCSI_DATA_IN0x00800) != 0) {
for (i = 0; i < MFI_BBU_SENSORS4; i++) {
	sc->sc_bbu[i].value = 0;
	sc->sc_bbu[i].status = SENSOR_S_UNKNOWN;
}
for (i = 0; i < nitems(mfi_bbu_indicators)(sizeof((mfi_bbu_indicators)) / sizeof((mfi_bbu_indicators)[0
])); i++) {
	sc->sc_bbu_status[i].value = 0;
	sc->sc_bbu_status[i].status = SENSOR_S_UNKNOWN;
}
return;
}

switch (bbu.battery_type) {
case MFI_BBU_TYPE_IBBU1:
mask = MFI_BBU_STATE_BAD_IBBU( (1 << 0) | (1 << 1) | (1 << 4) | (1 <<
 5) | (1 << 6) | (1 << 10) | (1 << 11));
soh_bad = 0;
break;
case MFI_BBU_TYPE_BBU2:
mask = MFI_BBU_STATE_BAD_BBU( (1 << 0) | (1 << 10) | (1 << 11));
soh_bad = (bbu.detail.bbu.is_SOH_good == 0);
break;

case MFI_BBU_TYPE_NONE0:
default:
sc->sc_bbu[0].value = 0;
sc->sc_bbu[0].status = SENSOR_S_CRIT;
for (i = 1; i < MFI_BBU_SENSORS4; i++) {
	sc->sc_bbu[i].value = 0;
	sc->sc_bbu[i].status = SENSOR_S_UNKNOWN;
}
for (i = 0; i < nitems(mfi_bbu_indicators)(sizeof((mfi_bbu_indicators)) / sizeof((mfi_bbu_indicators)[0
])); i++) {
	sc->sc_bbu_status[i].value = 0;
	sc->sc_bbu_status[i].status = SENSOR_S_UNKNOWN;
}
return;
}

status = letoh32(bbu.fw_status)((__uint32_t)(bbu.fw_status));

sc->sc_bbu[0].value = ((status & mask) || soh_bad) ? 0 : 1;
sc->sc_bbu[0].status = ((status & mask) || soh_bad) ? SENSOR_S_CRIT :
   SENSOR_S_OK;

sc->sc_bbu[1].value = letoh16(bbu.voltage)((__uint16_t)(bbu.voltage)) * 1000;
sc->sc_bbu[2].value = (int16_t)letoh16(bbu.current)((__uint16_t)(bbu.current)) * 1000;
sc->sc_bbu[3].value = letoh16(bbu.temperature)((__uint16_t)(bbu.temperature)) * 1000000 + 273150000;
for (i = 1; i < MFI_BBU_SENSORS4; i++)
sc->sc_bbu[i].status = SENSOR_S_UNSPEC;

for (i = 0; i < nitems(mfi_bbu_indicators)(sizeof((mfi_bbu_indicators)) / sizeof((mfi_bbu_indicators)[0
])); i++) {
sc->sc_bbu_status[i].value = (status & (1 << i)) ? 1 : 0;
sc->sc_bbu_status[i].status = SENSOR_S_UNSPEC;
}
3855}

3857void
3858mfii_refresh_ld_sensor(struct mfii_softc *sc, int ld)
3859{
struct ksensor *sensor;
int target;

target = sc->sc_ld_list.mll_list[ld].mll_ld.mld_target;
sensor = &sc->sc_sensors[target];

switch(sc->sc_ld_list.mll_list[ld].mll_state) {
case MFI_LD_OFFLINE0x00:
sensor->value = SENSOR_DRIVE_FAIL9;
sensor->status = SENSOR_S_CRIT;
break;

case MFI_LD_PART_DEGRADED0x01:
case MFI_LD_DEGRADED0x02:
sensor->value = SENSOR_DRIVE_PFAIL10;
sensor->status = SENSOR_S_WARN;
break;

case MFI_LD_ONLINE0x03:
sensor->value = SENSOR_DRIVE_ONLINE4;
sensor->status = SENSOR_S_OK;
break;

default:
sensor->value = 0; /* unknown */
sensor->status = SENSOR_S_UNKNOWN;
break;
}
3888}

3890void
3891mfii_init_ld_sensor(struct mfii_softc *sc, int ld)
3892{
struct device		*dev;
struct scsi_link	*link;
struct ksensor		*sensor;
int			target;

target = sc->sc_ld_list.mll_list[ld].mll_ld.mld_target;
sensor = &sc->sc_sensors[target];

link = scsi_get_link(sc->sc_scsibus, target, 0);
if (link == NULL((void *)0)) {
strlcpy(sensor->desc, "cache", sizeof(sensor->desc));
} else {
dev = link->device_softc;
if (dev != NULL((void *)0))
	strlcpy(sensor->desc, dev->dv_xname,
	    sizeof(sensor->desc));
}
sensor->type = SENSOR_DRIVE;
mfii_refresh_ld_sensor(sc, ld);
3912}

3914int
3915mfii_create_sensors(struct mfii_softc *sc)
3916{
int			i, target;

strlcpy(sc->sc_sensordev.xname, DEVNAME(sc)((sc)->sc_dev.dv_xname),
   sizeof(sc->sc_sensordev.xname));

if (ISSET(letoh32(sc->sc_info.mci_hw_present), MFI_INFO_HW_BBU)((((__uint32_t)(sc->sc_info.mci_hw_present))) & (0x01)
)) {
sc->sc_bbu = mallocarray(4, sizeof(*sc->sc_bbu),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);

sc->sc_bbu[0].type = SENSOR_INDICATOR;
sc->sc_bbu[0].status = SENSOR_S_UNKNOWN;
strlcpy(sc->sc_bbu[0].desc, "bbu ok",
    sizeof(sc->sc_bbu[0].desc));
sensor_attach(&sc->sc_sensordev, &sc->sc_bbu[0]);

sc->sc_bbu[1].type = SENSOR_VOLTS_DC;
sc->sc_bbu[1].status = SENSOR_S_UNSPEC;
sc->sc_bbu[2].type = SENSOR_AMPS;
sc->sc_bbu[2].status = SENSOR_S_UNSPEC;
sc->sc_bbu[3].type = SENSOR_TEMP;
sc->sc_bbu[3].status = SENSOR_S_UNSPEC;
for (i = 1; i < MFI_BBU_SENSORS4; i++) {
	strlcpy(sc->sc_bbu[i].desc, "bbu",
	    sizeof(sc->sc_bbu[i].desc));
	sensor_attach(&sc->sc_sensordev, &sc->sc_bbu[i]);
}

sc->sc_bbu_status = malloc(sizeof(*sc->sc_bbu_status) *
    sizeof(mfi_bbu_indicators), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);

for (i = 0; i < nitems(mfi_bbu_indicators)(sizeof((mfi_bbu_indicators)) / sizeof((mfi_bbu_indicators)[0
])); i++) {
	sc->sc_bbu_status[i].type = SENSOR_INDICATOR;
	sc->sc_bbu_status[i].status = SENSOR_S_UNSPEC;
	strlcpy(sc->sc_bbu_status[i].desc,
	    mfi_bbu_indicators[i],
	    sizeof(sc->sc_bbu_status[i].desc));

	sensor_attach(&sc->sc_sensordev, &sc->sc_bbu_status[i]);
}
}

sc->sc_sensors = mallocarray(MFI_MAX_LD64, sizeof(struct ksensor),
   M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (sc->sc_sensors == NULL((void *)0))
return (1);

for (i = 0; i < sc->sc_ld_list.mll_no_ld; i++) {
mfii_init_ld_sensor(sc, i);
target = sc->sc_ld_list.mll_list[i].mll_ld.mld_target;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[target]);
}

if (sensor_task_register(sc, mfii_refresh_sensors, 10) == NULL((void *)0))
goto bad;

sensordev_install(&sc->sc_sensordev);

return (0);

3976bad:
free(sc->sc_sensors, M_DEVBUF2,
   MFI_MAX_LD64 * sizeof(struct ksensor));

return (1);
3981}

3983void
3984mfii_refresh_sensors(void *arg)
3985{
struct mfii_softc	*sc = arg;
int			i;

rw_enter_write(&sc->sc_lock);
if (sc->sc_bbu != NULL((void *)0))
mfii_bbu(sc);

mfii_bio_getitall(sc);
rw_exit_write(&sc->sc_lock);

for (i = 0; i < sc->sc_ld_list.mll_no_ld; i++)
mfii_refresh_ld_sensor(sc, i);
3998}
3999#endif /* SMALL_KERNEL */
4000#endif /* NBIO > 0 */