mfi.c revision 1.4 1 1.4 bouyer /* $NetBSD: mfi.c,v 1.4 2007/05/01 17:18:55 bouyer Exp $ */
2 1.1 bouyer /* $OpenBSD: mfi.c,v 1.66 2006/11/28 23:59:45 dlg Exp $ */
3 1.1 bouyer /*
4 1.1 bouyer * Copyright (c) 2006 Marco Peereboom <marco (at) peereboom.us>
5 1.1 bouyer *
6 1.1 bouyer * Permission to use, copy, modify, and distribute this software for any
7 1.1 bouyer * purpose with or without fee is hereby granted, provided that the above
8 1.1 bouyer * copyright notice and this permission notice appear in all copies.
9 1.1 bouyer *
10 1.1 bouyer * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 1.1 bouyer * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 1.1 bouyer * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 1.1 bouyer * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 1.1 bouyer * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 1.1 bouyer * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 1.1 bouyer * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 1.1 bouyer */
18 1.1 bouyer
19 1.2 bouyer #include <sys/cdefs.h>
20 1.4 bouyer __KERNEL_RCSID(0, "$NetBSD: mfi.c,v 1.4 2007/05/01 17:18:55 bouyer Exp $");
21 1.2 bouyer
22 1.4 bouyer #include "bio.h"
23 1.1 bouyer
24 1.1 bouyer #include <sys/param.h>
25 1.1 bouyer #include <sys/systm.h>
26 1.1 bouyer #include <sys/buf.h>
27 1.1 bouyer #include <sys/ioctl.h>
28 1.1 bouyer #include <sys/device.h>
29 1.1 bouyer #include <sys/kernel.h>
30 1.1 bouyer #include <sys/malloc.h>
31 1.1 bouyer #include <sys/proc.h>
32 1.1 bouyer
33 1.1 bouyer #include <uvm/uvm_param.h>
34 1.1 bouyer
35 1.1 bouyer #include <machine/bus.h>
36 1.1 bouyer
37 1.1 bouyer #include <dev/scsipi/scsipi_all.h>
38 1.1 bouyer #include <dev/scsipi/scsi_all.h>
39 1.1 bouyer #include <dev/scsipi/scsi_spc.h>
40 1.1 bouyer #include <dev/scsipi/scsipi_disk.h>
41 1.1 bouyer #include <dev/scsipi/scsi_disk.h>
42 1.1 bouyer #include <dev/scsipi/scsiconf.h>
43 1.1 bouyer
44 1.1 bouyer #include <dev/ic/mfireg.h>
45 1.1 bouyer #include <dev/ic/mfivar.h>
46 1.1 bouyer
47 1.1 bouyer #if NBIO > 0
48 1.1 bouyer #include <dev/biovar.h>
49 1.1 bouyer #endif /* NBIO > 0 */
50 1.1 bouyer
51 1.1 bouyer #ifdef MFI_DEBUG
52 1.1 bouyer uint32_t mfi_debug = 0
53 1.1 bouyer /* | MFI_D_CMD */
54 1.1 bouyer /* | MFI_D_INTR */
55 1.1 bouyer /* | MFI_D_MISC */
56 1.1 bouyer /* | MFI_D_DMA */
57 1.1 bouyer | MFI_D_IOCTL
58 1.1 bouyer /* | MFI_D_RW */
59 1.1 bouyer /* | MFI_D_MEM */
60 1.1 bouyer /* | MFI_D_CCB */
61 1.1 bouyer ;
62 1.1 bouyer #endif
63 1.1 bouyer
64 1.1 bouyer void mfi_scsipi_request(struct scsipi_channel *,
65 1.1 bouyer scsipi_adapter_req_t, void *);
66 1.3 christos int mfi_scsi_ioctl(struct scsipi_channel *, u_long, void *, int,
67 1.1 bouyer struct proc *);
68 1.1 bouyer void mfiminphys(struct buf *bp);
69 1.1 bouyer
70 1.1 bouyer struct mfi_ccb *mfi_get_ccb(struct mfi_softc *);
71 1.1 bouyer void mfi_put_ccb(struct mfi_ccb *);
72 1.1 bouyer int mfi_init_ccb(struct mfi_softc *);
73 1.1 bouyer
74 1.1 bouyer struct mfi_mem *mfi_allocmem(struct mfi_softc *, size_t);
75 1.1 bouyer void mfi_freemem(struct mfi_softc *, struct mfi_mem *);
76 1.1 bouyer
77 1.1 bouyer int mfi_transition_firmware(struct mfi_softc *);
78 1.1 bouyer int mfi_initialize_firmware(struct mfi_softc *);
79 1.1 bouyer int mfi_get_info(struct mfi_softc *);
80 1.1 bouyer uint32_t mfi_read(struct mfi_softc *, bus_size_t);
81 1.1 bouyer void mfi_write(struct mfi_softc *, bus_size_t, uint32_t);
82 1.1 bouyer int mfi_poll(struct mfi_ccb *);
83 1.1 bouyer int mfi_despatch_cmd(struct mfi_ccb *);
84 1.1 bouyer int mfi_create_sgl(struct mfi_ccb *, int);
85 1.1 bouyer
86 1.1 bouyer /* commands */
87 1.1 bouyer int mfi_scsi_ld(struct mfi_ccb *, struct scsipi_xfer *);
88 1.1 bouyer int mfi_scsi_io(struct mfi_ccb *, struct scsipi_xfer *, uint32_t,
89 1.1 bouyer uint32_t);
90 1.1 bouyer void mfi_scsi_xs_done(struct mfi_ccb *);
91 1.1 bouyer int mfi_mgmt(struct mfi_softc *, uint32_t, uint32_t, uint32_t,
92 1.1 bouyer void *, uint8_t *);
93 1.1 bouyer void mfi_mgmt_done(struct mfi_ccb *);
94 1.1 bouyer
95 1.1 bouyer #if NBIO > 0
96 1.3 christos int mfi_ioctl(struct device *, u_long, void *);
97 1.1 bouyer int mfi_ioctl_inq(struct mfi_softc *, struct bioc_inq *);
98 1.1 bouyer int mfi_ioctl_vol(struct mfi_softc *, struct bioc_vol *);
99 1.1 bouyer int mfi_ioctl_disk(struct mfi_softc *, struct bioc_disk *);
100 1.1 bouyer int mfi_ioctl_alarm(struct mfi_softc *, struct bioc_alarm *);
101 1.1 bouyer int mfi_ioctl_blink(struct mfi_softc *sc, struct bioc_blink *);
102 1.1 bouyer int mfi_ioctl_setstate(struct mfi_softc *, struct bioc_setstate *);
103 1.1 bouyer int mfi_bio_hs(struct mfi_softc *, int, int, void *);
104 1.1 bouyer int mfi_create_sensors(struct mfi_softc *);
105 1.4 bouyer int mfi_sensor_gtredata(struct sysmon_envsys *,
106 1.4 bouyer struct envsys_tre_data *);
107 1.4 bouyer int mfi_sensor_streinfo(struct sysmon_envsys *,
108 1.4 bouyer struct envsys_basic_info *);
109 1.1 bouyer #endif /* NBIO > 0 */
110 1.1 bouyer
111 1.1 bouyer struct mfi_ccb *
112 1.1 bouyer mfi_get_ccb(struct mfi_softc *sc)
113 1.1 bouyer {
114 1.1 bouyer struct mfi_ccb *ccb;
115 1.1 bouyer int s;
116 1.1 bouyer
117 1.1 bouyer s = splbio();
118 1.1 bouyer ccb = TAILQ_FIRST(&sc->sc_ccb_freeq);
119 1.1 bouyer if (ccb) {
120 1.1 bouyer TAILQ_REMOVE(&sc->sc_ccb_freeq, ccb, ccb_link);
121 1.1 bouyer ccb->ccb_state = MFI_CCB_READY;
122 1.1 bouyer }
123 1.1 bouyer splx(s);
124 1.1 bouyer
125 1.1 bouyer DNPRINTF(MFI_D_CCB, "%s: mfi_get_ccb: %p\n", DEVNAME(sc), ccb);
126 1.1 bouyer
127 1.1 bouyer return (ccb);
128 1.1 bouyer }
129 1.1 bouyer
130 1.1 bouyer void
131 1.1 bouyer mfi_put_ccb(struct mfi_ccb *ccb)
132 1.1 bouyer {
133 1.1 bouyer struct mfi_softc *sc = ccb->ccb_sc;
134 1.1 bouyer int s;
135 1.1 bouyer
136 1.1 bouyer DNPRINTF(MFI_D_CCB, "%s: mfi_put_ccb: %p\n", DEVNAME(sc), ccb);
137 1.1 bouyer
138 1.1 bouyer s = splbio();
139 1.1 bouyer ccb->ccb_state = MFI_CCB_FREE;
140 1.1 bouyer ccb->ccb_xs = NULL;
141 1.1 bouyer ccb->ccb_flags = 0;
142 1.1 bouyer ccb->ccb_done = NULL;
143 1.1 bouyer ccb->ccb_direction = 0;
144 1.1 bouyer ccb->ccb_frame_size = 0;
145 1.1 bouyer ccb->ccb_extra_frames = 0;
146 1.1 bouyer ccb->ccb_sgl = NULL;
147 1.1 bouyer ccb->ccb_data = NULL;
148 1.1 bouyer ccb->ccb_len = 0;
149 1.1 bouyer TAILQ_INSERT_TAIL(&sc->sc_ccb_freeq, ccb, ccb_link);
150 1.1 bouyer splx(s);
151 1.1 bouyer }
152 1.1 bouyer
153 1.1 bouyer int
154 1.1 bouyer mfi_init_ccb(struct mfi_softc *sc)
155 1.1 bouyer {
156 1.1 bouyer struct mfi_ccb *ccb;
157 1.1 bouyer uint32_t i;
158 1.1 bouyer int error;
159 1.1 bouyer
160 1.1 bouyer DNPRINTF(MFI_D_CCB, "%s: mfi_init_ccb\n", DEVNAME(sc));
161 1.1 bouyer
162 1.1 bouyer sc->sc_ccb = malloc(sizeof(struct mfi_ccb) * sc->sc_max_cmds,
163 1.1 bouyer M_DEVBUF, M_WAITOK);
164 1.1 bouyer memset(sc->sc_ccb, 0, sizeof(struct mfi_ccb) * sc->sc_max_cmds);
165 1.1 bouyer
166 1.1 bouyer for (i = 0; i < sc->sc_max_cmds; i++) {
167 1.1 bouyer ccb = &sc->sc_ccb[i];
168 1.1 bouyer
169 1.1 bouyer ccb->ccb_sc = sc;
170 1.1 bouyer
171 1.1 bouyer /* select i'th frame */
172 1.1 bouyer ccb->ccb_frame = (union mfi_frame *)
173 1.1 bouyer ((char*)MFIMEM_KVA(sc->sc_frames) + sc->sc_frames_size * i);
174 1.1 bouyer ccb->ccb_pframe =
175 1.1 bouyer MFIMEM_DVA(sc->sc_frames) + sc->sc_frames_size * i;
176 1.1 bouyer ccb->ccb_frame->mfr_header.mfh_context = i;
177 1.1 bouyer
178 1.1 bouyer /* select i'th sense */
179 1.1 bouyer ccb->ccb_sense = (struct mfi_sense *)
180 1.1 bouyer ((char*)MFIMEM_KVA(sc->sc_sense) + MFI_SENSE_SIZE * i);
181 1.1 bouyer ccb->ccb_psense =
182 1.1 bouyer (MFIMEM_DVA(sc->sc_sense) + MFI_SENSE_SIZE * i);
183 1.1 bouyer
184 1.1 bouyer /* create a dma map for transfer */
185 1.1 bouyer error = bus_dmamap_create(sc->sc_dmat,
186 1.1 bouyer MAXPHYS, sc->sc_max_sgl, MAXPHYS, 0,
187 1.1 bouyer BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->ccb_dmamap);
188 1.1 bouyer if (error) {
189 1.1 bouyer printf("%s: cannot create ccb dmamap (%d)\n",
190 1.1 bouyer DEVNAME(sc), error);
191 1.1 bouyer goto destroy;
192 1.1 bouyer }
193 1.1 bouyer
194 1.1 bouyer DNPRINTF(MFI_D_CCB,
195 1.4 bouyer "ccb(%d): %p frame: %#lx (%#lx) sense: %#lx (%#lx) map: %#lx\n",
196 1.1 bouyer ccb->ccb_frame->mfr_header.mfh_context, ccb,
197 1.4 bouyer (u_long)ccb->ccb_frame, (u_long)ccb->ccb_pframe,
198 1.4 bouyer (u_long)ccb->ccb_sense, (u_long)ccb->ccb_psense,
199 1.4 bouyer (u_long)ccb->ccb_dmamap);
200 1.1 bouyer
201 1.1 bouyer /* add ccb to queue */
202 1.1 bouyer mfi_put_ccb(ccb);
203 1.1 bouyer }
204 1.1 bouyer
205 1.1 bouyer return (0);
206 1.1 bouyer destroy:
207 1.1 bouyer /* free dma maps and ccb memory */
208 1.1 bouyer while (i) {
209 1.1 bouyer ccb = &sc->sc_ccb[i];
210 1.1 bouyer bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap);
211 1.1 bouyer i--;
212 1.1 bouyer }
213 1.1 bouyer
214 1.1 bouyer free(sc->sc_ccb, M_DEVBUF);
215 1.1 bouyer
216 1.1 bouyer return (1);
217 1.1 bouyer }
218 1.1 bouyer
219 1.1 bouyer uint32_t
220 1.1 bouyer mfi_read(struct mfi_softc *sc, bus_size_t r)
221 1.1 bouyer {
222 1.1 bouyer uint32_t rv;
223 1.1 bouyer
224 1.1 bouyer bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
225 1.1 bouyer BUS_SPACE_BARRIER_READ);
226 1.1 bouyer rv = bus_space_read_4(sc->sc_iot, sc->sc_ioh, r);
227 1.1 bouyer
228 1.4 bouyer DNPRINTF(MFI_D_RW, "%s: mr 0x%lx 0x08%x ", DEVNAME(sc), (u_long)r, rv);
229 1.1 bouyer return (rv);
230 1.1 bouyer }
231 1.1 bouyer
232 1.1 bouyer void
233 1.1 bouyer mfi_write(struct mfi_softc *sc, bus_size_t r, uint32_t v)
234 1.1 bouyer {
235 1.4 bouyer DNPRINTF(MFI_D_RW, "%s: mw 0x%lx 0x%08x", DEVNAME(sc), (u_long)r, v);
236 1.1 bouyer
237 1.1 bouyer bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
238 1.1 bouyer bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
239 1.1 bouyer BUS_SPACE_BARRIER_WRITE);
240 1.1 bouyer }
241 1.1 bouyer
242 1.1 bouyer struct mfi_mem *
243 1.1 bouyer mfi_allocmem(struct mfi_softc *sc, size_t size)
244 1.1 bouyer {
245 1.1 bouyer struct mfi_mem *mm;
246 1.1 bouyer int nsegs;
247 1.1 bouyer
248 1.4 bouyer DNPRINTF(MFI_D_MEM, "%s: mfi_allocmem: %ld\n", DEVNAME(sc),
249 1.4 bouyer (long)size);
250 1.1 bouyer
251 1.1 bouyer mm = malloc(sizeof(struct mfi_mem), M_DEVBUF, M_NOWAIT);
252 1.1 bouyer if (mm == NULL)
253 1.1 bouyer return (NULL);
254 1.1 bouyer
255 1.1 bouyer memset(mm, 0, sizeof(struct mfi_mem));
256 1.1 bouyer mm->am_size = size;
257 1.1 bouyer
258 1.1 bouyer if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
259 1.1 bouyer BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &mm->am_map) != 0)
260 1.1 bouyer goto amfree;
261 1.1 bouyer
262 1.1 bouyer if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &mm->am_seg, 1,
263 1.1 bouyer &nsegs, BUS_DMA_NOWAIT) != 0)
264 1.1 bouyer goto destroy;
265 1.1 bouyer
266 1.1 bouyer if (bus_dmamem_map(sc->sc_dmat, &mm->am_seg, nsegs, size, &mm->am_kva,
267 1.1 bouyer BUS_DMA_NOWAIT) != 0)
268 1.1 bouyer goto free;
269 1.1 bouyer
270 1.1 bouyer if (bus_dmamap_load(sc->sc_dmat, mm->am_map, mm->am_kva, size, NULL,
271 1.1 bouyer BUS_DMA_NOWAIT) != 0)
272 1.1 bouyer goto unmap;
273 1.1 bouyer
274 1.1 bouyer DNPRINTF(MFI_D_MEM, " kva: %p dva: %p map: %p\n",
275 1.4 bouyer mm->am_kva, (void *)mm->am_map->dm_segs[0].ds_addr, mm->am_map);
276 1.1 bouyer
277 1.1 bouyer memset(mm->am_kva, 0, size);
278 1.1 bouyer return (mm);
279 1.1 bouyer
280 1.1 bouyer unmap:
281 1.1 bouyer bus_dmamem_unmap(sc->sc_dmat, mm->am_kva, size);
282 1.1 bouyer free:
283 1.1 bouyer bus_dmamem_free(sc->sc_dmat, &mm->am_seg, 1);
284 1.1 bouyer destroy:
285 1.1 bouyer bus_dmamap_destroy(sc->sc_dmat, mm->am_map);
286 1.1 bouyer amfree:
287 1.1 bouyer free(mm, M_DEVBUF);
288 1.1 bouyer
289 1.1 bouyer return (NULL);
290 1.1 bouyer }
291 1.1 bouyer
292 1.1 bouyer void
293 1.1 bouyer mfi_freemem(struct mfi_softc *sc, struct mfi_mem *mm)
294 1.1 bouyer {
295 1.1 bouyer DNPRINTF(MFI_D_MEM, "%s: mfi_freemem: %p\n", DEVNAME(sc), mm);
296 1.1 bouyer
297 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, mm->am_map);
298 1.1 bouyer bus_dmamem_unmap(sc->sc_dmat, mm->am_kva, mm->am_size);
299 1.1 bouyer bus_dmamem_free(sc->sc_dmat, &mm->am_seg, 1);
300 1.1 bouyer bus_dmamap_destroy(sc->sc_dmat, mm->am_map);
301 1.1 bouyer free(mm, M_DEVBUF);
302 1.1 bouyer }
303 1.1 bouyer
304 1.1 bouyer int
305 1.1 bouyer mfi_transition_firmware(struct mfi_softc *sc)
306 1.1 bouyer {
307 1.1 bouyer int32_t fw_state, cur_state;
308 1.1 bouyer int max_wait, i;
309 1.1 bouyer
310 1.1 bouyer fw_state = mfi_read(sc, MFI_OMSG0) & MFI_STATE_MASK;
311 1.1 bouyer
312 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_transition_firmware: %#x\n", DEVNAME(sc),
313 1.1 bouyer fw_state);
314 1.1 bouyer
315 1.1 bouyer while (fw_state != MFI_STATE_READY) {
316 1.1 bouyer DNPRINTF(MFI_D_MISC,
317 1.1 bouyer "%s: waiting for firmware to become ready\n",
318 1.1 bouyer DEVNAME(sc));
319 1.1 bouyer cur_state = fw_state;
320 1.1 bouyer switch (fw_state) {
321 1.1 bouyer case MFI_STATE_FAULT:
322 1.1 bouyer printf("%s: firmware fault\n", DEVNAME(sc));
323 1.1 bouyer return (1);
324 1.1 bouyer case MFI_STATE_WAIT_HANDSHAKE:
325 1.1 bouyer mfi_write(sc, MFI_IDB, MFI_INIT_CLEAR_HANDSHAKE);
326 1.1 bouyer max_wait = 2;
327 1.1 bouyer break;
328 1.1 bouyer case MFI_STATE_OPERATIONAL:
329 1.1 bouyer mfi_write(sc, MFI_IDB, MFI_INIT_READY);
330 1.1 bouyer max_wait = 10;
331 1.1 bouyer break;
332 1.1 bouyer case MFI_STATE_UNDEFINED:
333 1.1 bouyer case MFI_STATE_BB_INIT:
334 1.1 bouyer max_wait = 2;
335 1.1 bouyer break;
336 1.1 bouyer case MFI_STATE_FW_INIT:
337 1.1 bouyer case MFI_STATE_DEVICE_SCAN:
338 1.1 bouyer case MFI_STATE_FLUSH_CACHE:
339 1.1 bouyer max_wait = 20;
340 1.1 bouyer break;
341 1.1 bouyer default:
342 1.1 bouyer printf("%s: unknown firmware state %d\n",
343 1.1 bouyer DEVNAME(sc), fw_state);
344 1.1 bouyer return (1);
345 1.1 bouyer }
346 1.1 bouyer for (i = 0; i < (max_wait * 10); i++) {
347 1.1 bouyer fw_state = mfi_read(sc, MFI_OMSG0) & MFI_STATE_MASK;
348 1.1 bouyer if (fw_state == cur_state)
349 1.1 bouyer DELAY(100000);
350 1.1 bouyer else
351 1.1 bouyer break;
352 1.1 bouyer }
353 1.1 bouyer if (fw_state == cur_state) {
354 1.1 bouyer printf("%s: firmware stuck in state %#x\n",
355 1.1 bouyer DEVNAME(sc), fw_state);
356 1.1 bouyer return (1);
357 1.1 bouyer }
358 1.1 bouyer }
359 1.1 bouyer
360 1.1 bouyer return (0);
361 1.1 bouyer }
362 1.1 bouyer
363 1.1 bouyer int
364 1.1 bouyer mfi_initialize_firmware(struct mfi_softc *sc)
365 1.1 bouyer {
366 1.1 bouyer struct mfi_ccb *ccb;
367 1.1 bouyer struct mfi_init_frame *init;
368 1.1 bouyer struct mfi_init_qinfo *qinfo;
369 1.1 bouyer
370 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: mfi_initialize_firmware\n", DEVNAME(sc));
371 1.1 bouyer
372 1.1 bouyer if ((ccb = mfi_get_ccb(sc)) == NULL)
373 1.1 bouyer return (1);
374 1.1 bouyer
375 1.1 bouyer init = &ccb->ccb_frame->mfr_init;
376 1.1 bouyer qinfo = (struct mfi_init_qinfo *)((uint8_t *)init + MFI_FRAME_SIZE);
377 1.1 bouyer
378 1.1 bouyer memset(qinfo, 0, sizeof *qinfo);
379 1.1 bouyer qinfo->miq_rq_entries = sc->sc_max_cmds + 1;
380 1.1 bouyer qinfo->miq_rq_addr_lo = htole32(MFIMEM_DVA(sc->sc_pcq) +
381 1.1 bouyer offsetof(struct mfi_prod_cons, mpc_reply_q));
382 1.1 bouyer qinfo->miq_pi_addr_lo = htole32(MFIMEM_DVA(sc->sc_pcq) +
383 1.1 bouyer offsetof(struct mfi_prod_cons, mpc_producer));
384 1.1 bouyer qinfo->miq_ci_addr_lo = htole32(MFIMEM_DVA(sc->sc_pcq) +
385 1.1 bouyer offsetof(struct mfi_prod_cons, mpc_consumer));
386 1.1 bouyer
387 1.1 bouyer init->mif_header.mfh_cmd = MFI_CMD_INIT;
388 1.1 bouyer init->mif_header.mfh_data_len = sizeof *qinfo;
389 1.1 bouyer init->mif_qinfo_new_addr_lo = htole32(ccb->ccb_pframe + MFI_FRAME_SIZE);
390 1.1 bouyer
391 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: entries: %#x rq: %#x pi: %#x ci: %#x\n",
392 1.1 bouyer DEVNAME(sc),
393 1.1 bouyer qinfo->miq_rq_entries, qinfo->miq_rq_addr_lo,
394 1.1 bouyer qinfo->miq_pi_addr_lo, qinfo->miq_ci_addr_lo);
395 1.1 bouyer
396 1.1 bouyer if (mfi_poll(ccb)) {
397 1.1 bouyer printf("%s: mfi_initialize_firmware failed\n", DEVNAME(sc));
398 1.1 bouyer return (1);
399 1.1 bouyer }
400 1.1 bouyer
401 1.1 bouyer mfi_put_ccb(ccb);
402 1.1 bouyer
403 1.1 bouyer return (0);
404 1.1 bouyer }
405 1.1 bouyer
406 1.1 bouyer int
407 1.1 bouyer mfi_get_info(struct mfi_softc *sc)
408 1.1 bouyer {
409 1.1 bouyer #ifdef MFI_DEBUG
410 1.1 bouyer int i;
411 1.1 bouyer #endif
412 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: mfi_get_info\n", DEVNAME(sc));
413 1.1 bouyer
414 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_CTRL_GET_INFO, MFI_DATA_IN,
415 1.1 bouyer sizeof(sc->sc_info), &sc->sc_info, NULL))
416 1.1 bouyer return (1);
417 1.1 bouyer
418 1.1 bouyer #ifdef MFI_DEBUG
419 1.1 bouyer
420 1.1 bouyer for (i = 0; i < sc->sc_info.mci_image_component_count; i++) {
421 1.1 bouyer printf("%s: active FW %s Version %s date %s time %s\n",
422 1.1 bouyer DEVNAME(sc),
423 1.1 bouyer sc->sc_info.mci_image_component[i].mic_name,
424 1.1 bouyer sc->sc_info.mci_image_component[i].mic_version,
425 1.1 bouyer sc->sc_info.mci_image_component[i].mic_build_date,
426 1.1 bouyer sc->sc_info.mci_image_component[i].mic_build_time);
427 1.1 bouyer }
428 1.1 bouyer
429 1.1 bouyer for (i = 0; i < sc->sc_info.mci_pending_image_component_count; i++) {
430 1.1 bouyer printf("%s: pending FW %s Version %s date %s time %s\n",
431 1.1 bouyer DEVNAME(sc),
432 1.1 bouyer sc->sc_info.mci_pending_image_component[i].mic_name,
433 1.1 bouyer sc->sc_info.mci_pending_image_component[i].mic_version,
434 1.1 bouyer sc->sc_info.mci_pending_image_component[i].mic_build_date,
435 1.1 bouyer sc->sc_info.mci_pending_image_component[i].mic_build_time);
436 1.1 bouyer }
437 1.1 bouyer
438 1.1 bouyer printf("%s: max_arms %d max_spans %d max_arrs %d max_lds %d name %s\n",
439 1.1 bouyer DEVNAME(sc),
440 1.1 bouyer sc->sc_info.mci_max_arms,
441 1.1 bouyer sc->sc_info.mci_max_spans,
442 1.1 bouyer sc->sc_info.mci_max_arrays,
443 1.1 bouyer sc->sc_info.mci_max_lds,
444 1.1 bouyer sc->sc_info.mci_product_name);
445 1.1 bouyer
446 1.1 bouyer printf("%s: serial %s present %#x fw time %d max_cmds %d max_sg %d\n",
447 1.1 bouyer DEVNAME(sc),
448 1.1 bouyer sc->sc_info.mci_serial_number,
449 1.1 bouyer sc->sc_info.mci_hw_present,
450 1.1 bouyer sc->sc_info.mci_current_fw_time,
451 1.1 bouyer sc->sc_info.mci_max_cmds,
452 1.1 bouyer sc->sc_info.mci_max_sg_elements);
453 1.1 bouyer
454 1.1 bouyer printf("%s: max_rq %d lds_pres %d lds_deg %d lds_off %d pd_pres %d\n",
455 1.1 bouyer DEVNAME(sc),
456 1.1 bouyer sc->sc_info.mci_max_request_size,
457 1.1 bouyer sc->sc_info.mci_lds_present,
458 1.1 bouyer sc->sc_info.mci_lds_degraded,
459 1.1 bouyer sc->sc_info.mci_lds_offline,
460 1.1 bouyer sc->sc_info.mci_pd_present);
461 1.1 bouyer
462 1.1 bouyer printf("%s: pd_dsk_prs %d pd_dsk_pred_fail %d pd_dsk_fail %d\n",
463 1.1 bouyer DEVNAME(sc),
464 1.1 bouyer sc->sc_info.mci_pd_disks_present,
465 1.1 bouyer sc->sc_info.mci_pd_disks_pred_failure,
466 1.1 bouyer sc->sc_info.mci_pd_disks_failed);
467 1.1 bouyer
468 1.1 bouyer printf("%s: nvram %d mem %d flash %d\n",
469 1.1 bouyer DEVNAME(sc),
470 1.1 bouyer sc->sc_info.mci_nvram_size,
471 1.1 bouyer sc->sc_info.mci_memory_size,
472 1.1 bouyer sc->sc_info.mci_flash_size);
473 1.1 bouyer
474 1.1 bouyer printf("%s: ram_cor %d ram_uncor %d clus_all %d clus_act %d\n",
475 1.1 bouyer DEVNAME(sc),
476 1.1 bouyer sc->sc_info.mci_ram_correctable_errors,
477 1.1 bouyer sc->sc_info.mci_ram_uncorrectable_errors,
478 1.1 bouyer sc->sc_info.mci_cluster_allowed,
479 1.1 bouyer sc->sc_info.mci_cluster_active);
480 1.1 bouyer
481 1.1 bouyer printf("%s: max_strps_io %d raid_lvl %#x adapt_ops %#x ld_ops %#x\n",
482 1.1 bouyer DEVNAME(sc),
483 1.1 bouyer sc->sc_info.mci_max_strips_per_io,
484 1.1 bouyer sc->sc_info.mci_raid_levels,
485 1.1 bouyer sc->sc_info.mci_adapter_ops,
486 1.1 bouyer sc->sc_info.mci_ld_ops);
487 1.1 bouyer
488 1.1 bouyer printf("%s: strp_sz_min %d strp_sz_max %d pd_ops %#x pd_mix %#x\n",
489 1.1 bouyer DEVNAME(sc),
490 1.1 bouyer sc->sc_info.mci_stripe_sz_ops.min,
491 1.1 bouyer sc->sc_info.mci_stripe_sz_ops.max,
492 1.1 bouyer sc->sc_info.mci_pd_ops,
493 1.1 bouyer sc->sc_info.mci_pd_mix_support);
494 1.1 bouyer
495 1.1 bouyer printf("%s: ecc_bucket %d pckg_prop %s\n",
496 1.1 bouyer DEVNAME(sc),
497 1.1 bouyer sc->sc_info.mci_ecc_bucket_count,
498 1.1 bouyer sc->sc_info.mci_package_version);
499 1.1 bouyer
500 1.1 bouyer printf("%s: sq_nm %d prd_fail_poll %d intr_thrtl %d intr_thrtl_to %d\n",
501 1.1 bouyer DEVNAME(sc),
502 1.1 bouyer sc->sc_info.mci_properties.mcp_seq_num,
503 1.1 bouyer sc->sc_info.mci_properties.mcp_pred_fail_poll_interval,
504 1.1 bouyer sc->sc_info.mci_properties.mcp_intr_throttle_cnt,
505 1.1 bouyer sc->sc_info.mci_properties.mcp_intr_throttle_timeout);
506 1.1 bouyer
507 1.1 bouyer printf("%s: rbld_rate %d patr_rd_rate %d bgi_rate %d cc_rate %d\n",
508 1.1 bouyer DEVNAME(sc),
509 1.1 bouyer sc->sc_info.mci_properties.mcp_rebuild_rate,
510 1.1 bouyer sc->sc_info.mci_properties.mcp_patrol_read_rate,
511 1.1 bouyer sc->sc_info.mci_properties.mcp_bgi_rate,
512 1.1 bouyer sc->sc_info.mci_properties.mcp_cc_rate);
513 1.1 bouyer
514 1.1 bouyer printf("%s: rc_rate %d ch_flsh %d spin_cnt %d spin_dly %d clus_en %d\n",
515 1.1 bouyer DEVNAME(sc),
516 1.1 bouyer sc->sc_info.mci_properties.mcp_recon_rate,
517 1.1 bouyer sc->sc_info.mci_properties.mcp_cache_flush_interval,
518 1.1 bouyer sc->sc_info.mci_properties.mcp_spinup_drv_cnt,
519 1.1 bouyer sc->sc_info.mci_properties.mcp_spinup_delay,
520 1.1 bouyer sc->sc_info.mci_properties.mcp_cluster_enable);
521 1.1 bouyer
522 1.1 bouyer printf("%s: coerc %d alarm %d dis_auto_rbld %d dis_bat_wrn %d ecc %d\n",
523 1.1 bouyer DEVNAME(sc),
524 1.1 bouyer sc->sc_info.mci_properties.mcp_coercion_mode,
525 1.1 bouyer sc->sc_info.mci_properties.mcp_alarm_enable,
526 1.1 bouyer sc->sc_info.mci_properties.mcp_disable_auto_rebuild,
527 1.1 bouyer sc->sc_info.mci_properties.mcp_disable_battery_warn,
528 1.1 bouyer sc->sc_info.mci_properties.mcp_ecc_bucket_size);
529 1.1 bouyer
530 1.1 bouyer printf("%s: ecc_leak %d rest_hs %d exp_encl_dev %d\n",
531 1.1 bouyer DEVNAME(sc),
532 1.1 bouyer sc->sc_info.mci_properties.mcp_ecc_bucket_leak_rate,
533 1.1 bouyer sc->sc_info.mci_properties.mcp_restore_hotspare_on_insertion,
534 1.1 bouyer sc->sc_info.mci_properties.mcp_expose_encl_devices);
535 1.1 bouyer
536 1.1 bouyer printf("%s: vendor %#x device %#x subvendor %#x subdevice %#x\n",
537 1.1 bouyer DEVNAME(sc),
538 1.1 bouyer sc->sc_info.mci_pci.mip_vendor,
539 1.1 bouyer sc->sc_info.mci_pci.mip_device,
540 1.1 bouyer sc->sc_info.mci_pci.mip_subvendor,
541 1.1 bouyer sc->sc_info.mci_pci.mip_subdevice);
542 1.1 bouyer
543 1.1 bouyer printf("%s: type %#x port_count %d port_addr ",
544 1.1 bouyer DEVNAME(sc),
545 1.1 bouyer sc->sc_info.mci_host.mih_type,
546 1.1 bouyer sc->sc_info.mci_host.mih_port_count);
547 1.1 bouyer
548 1.1 bouyer for (i = 0; i < 8; i++)
549 1.4 bouyer printf("%.0lx ", sc->sc_info.mci_host.mih_port_addr[i]);
550 1.1 bouyer printf("\n");
551 1.1 bouyer
552 1.1 bouyer printf("%s: type %.x port_count %d port_addr ",
553 1.1 bouyer DEVNAME(sc),
554 1.1 bouyer sc->sc_info.mci_device.mid_type,
555 1.1 bouyer sc->sc_info.mci_device.mid_port_count);
556 1.1 bouyer
557 1.1 bouyer for (i = 0; i < 8; i++)
558 1.4 bouyer printf("%.0lx ", sc->sc_info.mci_device.mid_port_addr[i]);
559 1.1 bouyer printf("\n");
560 1.1 bouyer #endif /* MFI_DEBUG */
561 1.1 bouyer
562 1.1 bouyer return (0);
563 1.1 bouyer }
564 1.1 bouyer
565 1.1 bouyer void
566 1.1 bouyer mfiminphys(struct buf *bp)
567 1.1 bouyer {
568 1.1 bouyer DNPRINTF(MFI_D_MISC, "mfiminphys: %d\n", bp->b_bcount);
569 1.1 bouyer
570 1.1 bouyer /* XXX currently using MFI_MAXFER = MAXPHYS */
571 1.1 bouyer if (bp->b_bcount > MFI_MAXFER)
572 1.1 bouyer bp->b_bcount = MFI_MAXFER;
573 1.1 bouyer minphys(bp);
574 1.1 bouyer }
575 1.1 bouyer
576 1.1 bouyer int
577 1.1 bouyer mfi_attach(struct mfi_softc *sc)
578 1.1 bouyer {
579 1.1 bouyer struct scsipi_adapter *adapt = &sc->sc_adapt;
580 1.1 bouyer struct scsipi_channel *chan = &sc->sc_chan;
581 1.1 bouyer uint32_t status, frames;
582 1.1 bouyer int i;
583 1.1 bouyer
584 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: mfi_attach\n", DEVNAME(sc));
585 1.1 bouyer
586 1.1 bouyer if (mfi_transition_firmware(sc))
587 1.1 bouyer return (1);
588 1.1 bouyer
589 1.1 bouyer TAILQ_INIT(&sc->sc_ccb_freeq);
590 1.1 bouyer
591 1.1 bouyer status = mfi_read(sc, MFI_OMSG0);
592 1.1 bouyer sc->sc_max_cmds = status & MFI_STATE_MAXCMD_MASK;
593 1.1 bouyer sc->sc_max_sgl = (status & MFI_STATE_MAXSGL_MASK) >> 16;
594 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: max commands: %u, max sgl: %u\n",
595 1.1 bouyer DEVNAME(sc), sc->sc_max_cmds, sc->sc_max_sgl);
596 1.1 bouyer
597 1.1 bouyer /* consumer/producer and reply queue memory */
598 1.1 bouyer sc->sc_pcq = mfi_allocmem(sc, (sizeof(uint32_t) * sc->sc_max_cmds) +
599 1.1 bouyer sizeof(struct mfi_prod_cons));
600 1.1 bouyer if (sc->sc_pcq == NULL) {
601 1.1 bouyer aprint_error("%s: unable to allocate reply queue memory\n",
602 1.1 bouyer DEVNAME(sc));
603 1.1 bouyer goto nopcq;
604 1.1 bouyer }
605 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_pcq), 0,
606 1.1 bouyer sizeof(uint32_t) * sc->sc_max_cmds + sizeof(struct mfi_prod_cons),
607 1.1 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
608 1.1 bouyer
609 1.1 bouyer /* frame memory */
610 1.1 bouyer /* we are not doing 64 bit IO so only calculate # of 32 bit frames */
611 1.1 bouyer frames = (sizeof(struct mfi_sg32) * sc->sc_max_sgl +
612 1.1 bouyer MFI_FRAME_SIZE - 1) / MFI_FRAME_SIZE + 1;
613 1.1 bouyer sc->sc_frames_size = frames * MFI_FRAME_SIZE;
614 1.1 bouyer sc->sc_frames = mfi_allocmem(sc, sc->sc_frames_size * sc->sc_max_cmds);
615 1.1 bouyer if (sc->sc_frames == NULL) {
616 1.1 bouyer aprint_error("%s: unable to allocate frame memory\n",
617 1.1 bouyer DEVNAME(sc));
618 1.1 bouyer goto noframe;
619 1.1 bouyer }
620 1.1 bouyer /* XXX hack, fix this */
621 1.1 bouyer if (MFIMEM_DVA(sc->sc_frames) & 0x3f) {
622 1.1 bouyer aprint_error("%s: improper frame alignment (%#llx) FIXME\n",
623 1.1 bouyer DEVNAME(sc), (long long int)MFIMEM_DVA(sc->sc_frames));
624 1.1 bouyer goto noframe;
625 1.1 bouyer }
626 1.1 bouyer
627 1.1 bouyer /* sense memory */
628 1.1 bouyer sc->sc_sense = mfi_allocmem(sc, sc->sc_max_cmds * MFI_SENSE_SIZE);
629 1.1 bouyer if (sc->sc_sense == NULL) {
630 1.1 bouyer aprint_error("%s: unable to allocate sense memory\n",
631 1.1 bouyer DEVNAME(sc));
632 1.1 bouyer goto nosense;
633 1.1 bouyer }
634 1.1 bouyer
635 1.1 bouyer /* now that we have all memory bits go initialize ccbs */
636 1.1 bouyer if (mfi_init_ccb(sc)) {
637 1.1 bouyer aprint_error("%s: could not init ccb list\n", DEVNAME(sc));
638 1.1 bouyer goto noinit;
639 1.1 bouyer }
640 1.1 bouyer
641 1.1 bouyer /* kickstart firmware with all addresses and pointers */
642 1.1 bouyer if (mfi_initialize_firmware(sc)) {
643 1.1 bouyer aprint_error("%s: could not initialize firmware\n",
644 1.1 bouyer DEVNAME(sc));
645 1.1 bouyer goto noinit;
646 1.1 bouyer }
647 1.1 bouyer
648 1.1 bouyer if (mfi_get_info(sc)) {
649 1.1 bouyer aprint_error("%s: could not retrieve controller information\n",
650 1.1 bouyer DEVNAME(sc));
651 1.1 bouyer goto noinit;
652 1.1 bouyer }
653 1.1 bouyer
654 1.1 bouyer aprint_normal("%s: logical drives %d, version %s, %dMB RAM\n",
655 1.1 bouyer DEVNAME(sc),
656 1.1 bouyer sc->sc_info.mci_lds_present,
657 1.1 bouyer sc->sc_info.mci_package_version,
658 1.1 bouyer sc->sc_info.mci_memory_size);
659 1.1 bouyer
660 1.1 bouyer sc->sc_ld_cnt = sc->sc_info.mci_lds_present;
661 1.1 bouyer sc->sc_max_ld = sc->sc_ld_cnt;
662 1.1 bouyer for (i = 0; i < sc->sc_ld_cnt; i++)
663 1.1 bouyer sc->sc_ld[i].ld_present = 1;
664 1.1 bouyer
665 1.1 bouyer memset(adapt, 0, sizeof(*adapt));
666 1.1 bouyer adapt->adapt_dev = &sc->sc_dev;
667 1.1 bouyer adapt->adapt_nchannels = 1;
668 1.1 bouyer if (sc->sc_ld_cnt)
669 1.1 bouyer adapt->adapt_openings = sc->sc_max_cmds / sc->sc_ld_cnt;
670 1.1 bouyer else
671 1.1 bouyer adapt->adapt_openings = sc->sc_max_cmds;
672 1.1 bouyer adapt->adapt_max_periph = adapt->adapt_openings;
673 1.1 bouyer adapt->adapt_request = mfi_scsipi_request;
674 1.1 bouyer adapt->adapt_minphys = mfiminphys;
675 1.1 bouyer adapt->adapt_ioctl = mfi_scsi_ioctl;
676 1.1 bouyer
677 1.1 bouyer memset(chan, 0, sizeof(*chan));
678 1.1 bouyer chan->chan_adapter = adapt;
679 1.1 bouyer chan->chan_bustype = &scsi_bustype;
680 1.1 bouyer chan->chan_channel = 0;
681 1.1 bouyer chan->chan_flags = 0;
682 1.1 bouyer chan->chan_nluns = 8;
683 1.1 bouyer chan->chan_ntargets = MFI_MAX_LD;
684 1.1 bouyer chan->chan_id = MFI_MAX_LD;
685 1.1 bouyer
686 1.1 bouyer (void) config_found(&sc->sc_dev, &sc->sc_chan, scsiprint);
687 1.1 bouyer
688 1.1 bouyer /* enable interrupts */
689 1.1 bouyer mfi_write(sc, MFI_OMSK, MFI_ENABLE_INTR);
690 1.1 bouyer
691 1.1 bouyer #if NBIO > 0
692 1.1 bouyer if (bio_register(&sc->sc_dev, mfi_ioctl) != 0)
693 1.1 bouyer panic("%s: controller registration failed", DEVNAME(sc));
694 1.1 bouyer else
695 1.1 bouyer sc->sc_ioctl = mfi_ioctl;
696 1.1 bouyer if (mfi_create_sensors(sc) != 0)
697 1.1 bouyer aprint_error("%s: unable to create sensors\n", DEVNAME(sc));
698 1.1 bouyer #endif /* NBIO > 0 */
699 1.1 bouyer
700 1.1 bouyer return (0);
701 1.1 bouyer noinit:
702 1.1 bouyer mfi_freemem(sc, sc->sc_sense);
703 1.1 bouyer nosense:
704 1.1 bouyer mfi_freemem(sc, sc->sc_frames);
705 1.1 bouyer noframe:
706 1.1 bouyer mfi_freemem(sc, sc->sc_pcq);
707 1.1 bouyer nopcq:
708 1.1 bouyer return (1);
709 1.1 bouyer }
710 1.1 bouyer
711 1.1 bouyer int
712 1.1 bouyer mfi_despatch_cmd(struct mfi_ccb *ccb)
713 1.1 bouyer {
714 1.1 bouyer struct mfi_softc *sc = ccb->ccb_sc;
715 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_despatch_cmd\n", DEVNAME(sc));
716 1.1 bouyer
717 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_frames),
718 1.1 bouyer ccb->ccb_pframe - MFIMEM_DVA(sc->sc_frames),
719 1.1 bouyer sc->sc_frames_size, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
720 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_sense),
721 1.1 bouyer ccb->ccb_psense - MFIMEM_DVA(sc->sc_sense),
722 1.1 bouyer MFI_SENSE_SIZE, BUS_DMASYNC_PREREAD);
723 1.1 bouyer
724 1.1 bouyer mfi_write(ccb->ccb_sc, MFI_IQP, htole32((ccb->ccb_pframe >> 3) |
725 1.1 bouyer ccb->ccb_extra_frames));
726 1.1 bouyer
727 1.1 bouyer return(0);
728 1.1 bouyer }
729 1.1 bouyer
730 1.1 bouyer int
731 1.1 bouyer mfi_poll(struct mfi_ccb *ccb)
732 1.1 bouyer {
733 1.1 bouyer struct mfi_softc *sc = ccb->ccb_sc;
734 1.1 bouyer struct mfi_frame_header *hdr;
735 1.1 bouyer int to = 0;
736 1.1 bouyer
737 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_poll\n", DEVNAME(sc));
738 1.1 bouyer
739 1.1 bouyer hdr = &ccb->ccb_frame->mfr_header;
740 1.1 bouyer hdr->mfh_cmd_status = 0xff;
741 1.1 bouyer hdr->mfh_flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
742 1.1 bouyer
743 1.1 bouyer mfi_despatch_cmd(ccb);
744 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_frames),
745 1.1 bouyer ccb->ccb_pframe - MFIMEM_DVA(sc->sc_frames),
746 1.1 bouyer sc->sc_frames_size, BUS_DMASYNC_POSTREAD);
747 1.1 bouyer
748 1.1 bouyer while (hdr->mfh_cmd_status == 0xff) {
749 1.1 bouyer delay(1000);
750 1.1 bouyer if (to++ > 5000) /* XXX 5 seconds busywait sucks */
751 1.1 bouyer break;
752 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_frames),
753 1.1 bouyer ccb->ccb_pframe - MFIMEM_DVA(sc->sc_frames),
754 1.1 bouyer sc->sc_frames_size, BUS_DMASYNC_POSTREAD);
755 1.1 bouyer }
756 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_frames),
757 1.1 bouyer ccb->ccb_pframe - MFIMEM_DVA(sc->sc_frames),
758 1.1 bouyer sc->sc_frames_size, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
759 1.1 bouyer
760 1.1 bouyer if (ccb->ccb_data != NULL) {
761 1.1 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_mgmt_done sync\n",
762 1.1 bouyer DEVNAME(sc));
763 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
764 1.1 bouyer ccb->ccb_dmamap->dm_mapsize,
765 1.1 bouyer (ccb->ccb_direction & MFI_DATA_IN) ?
766 1.1 bouyer BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
767 1.1 bouyer
768 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
769 1.1 bouyer }
770 1.1 bouyer
771 1.1 bouyer if (hdr->mfh_cmd_status == 0xff) {
772 1.1 bouyer printf("%s: timeout on ccb %d\n", DEVNAME(sc),
773 1.1 bouyer hdr->mfh_context);
774 1.1 bouyer ccb->ccb_flags |= MFI_CCB_F_ERR;
775 1.1 bouyer return (1);
776 1.1 bouyer }
777 1.1 bouyer
778 1.1 bouyer return (0);
779 1.1 bouyer }
780 1.1 bouyer
781 1.1 bouyer int
782 1.1 bouyer mfi_intr(void *arg)
783 1.1 bouyer {
784 1.1 bouyer struct mfi_softc *sc = arg;
785 1.1 bouyer struct mfi_prod_cons *pcq;
786 1.1 bouyer struct mfi_ccb *ccb;
787 1.1 bouyer uint32_t status, producer, consumer, ctx;
788 1.1 bouyer int claimed = 0;
789 1.1 bouyer
790 1.1 bouyer status = mfi_read(sc, MFI_OSTS);
791 1.1 bouyer if ((status & MFI_OSTS_INTR_VALID) == 0)
792 1.1 bouyer return (claimed);
793 1.1 bouyer /* write status back to acknowledge interrupt */
794 1.1 bouyer mfi_write(sc, MFI_OSTS, status);
795 1.1 bouyer
796 1.4 bouyer pcq = MFIMEM_KVA(sc->sc_pcq);
797 1.4 bouyer
798 1.4 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_intr %#lx %#lx\n", DEVNAME(sc),
799 1.4 bouyer (u_long)sc, (u_long)pcq);
800 1.1 bouyer
801 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_pcq), 0,
802 1.1 bouyer sizeof(uint32_t) * sc->sc_max_cmds + sizeof(struct mfi_prod_cons),
803 1.1 bouyer BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
804 1.1 bouyer
805 1.1 bouyer producer = pcq->mpc_producer;
806 1.1 bouyer consumer = pcq->mpc_consumer;
807 1.1 bouyer
808 1.1 bouyer while (consumer != producer) {
809 1.1 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_intr pi %#x ci %#x\n",
810 1.1 bouyer DEVNAME(sc), producer, consumer);
811 1.1 bouyer
812 1.1 bouyer ctx = pcq->mpc_reply_q[consumer];
813 1.1 bouyer pcq->mpc_reply_q[consumer] = MFI_INVALID_CTX;
814 1.1 bouyer if (ctx == MFI_INVALID_CTX)
815 1.1 bouyer printf("%s: invalid context, p: %d c: %d\n",
816 1.1 bouyer DEVNAME(sc), producer, consumer);
817 1.1 bouyer else {
818 1.1 bouyer /* XXX remove from queue and call scsi_done */
819 1.1 bouyer ccb = &sc->sc_ccb[ctx];
820 1.1 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_intr context %#x\n",
821 1.1 bouyer DEVNAME(sc), ctx);
822 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_frames),
823 1.1 bouyer ccb->ccb_pframe - MFIMEM_DVA(sc->sc_frames),
824 1.1 bouyer sc->sc_frames_size,
825 1.1 bouyer BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
826 1.1 bouyer ccb->ccb_done(ccb);
827 1.1 bouyer
828 1.1 bouyer claimed = 1;
829 1.1 bouyer }
830 1.1 bouyer consumer++;
831 1.1 bouyer if (consumer == (sc->sc_max_cmds + 1))
832 1.1 bouyer consumer = 0;
833 1.1 bouyer }
834 1.1 bouyer
835 1.1 bouyer pcq->mpc_consumer = consumer;
836 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_pcq), 0,
837 1.1 bouyer sizeof(uint32_t) * sc->sc_max_cmds + sizeof(struct mfi_prod_cons),
838 1.1 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
839 1.1 bouyer
840 1.1 bouyer return (claimed);
841 1.1 bouyer }
842 1.1 bouyer
843 1.1 bouyer int
844 1.1 bouyer mfi_scsi_io(struct mfi_ccb *ccb, struct scsipi_xfer *xs, uint32_t blockno,
845 1.1 bouyer uint32_t blockcnt)
846 1.1 bouyer {
847 1.1 bouyer struct scsipi_periph *periph = xs->xs_periph;
848 1.1 bouyer struct mfi_io_frame *io;
849 1.1 bouyer
850 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_scsi_io: %d\n",
851 1.1 bouyer periph->periph_channel->chan_adapter->adapt_dev->dv_xname,
852 1.1 bouyer periph->periph_target);
853 1.1 bouyer
854 1.1 bouyer if (!xs->data)
855 1.1 bouyer return (1);
856 1.1 bouyer
857 1.1 bouyer io = &ccb->ccb_frame->mfr_io;
858 1.1 bouyer if (xs->xs_control & XS_CTL_DATA_IN) {
859 1.1 bouyer io->mif_header.mfh_cmd = MFI_CMD_LD_READ;
860 1.1 bouyer ccb->ccb_direction = MFI_DATA_IN;
861 1.1 bouyer } else {
862 1.1 bouyer io->mif_header.mfh_cmd = MFI_CMD_LD_WRITE;
863 1.1 bouyer ccb->ccb_direction = MFI_DATA_OUT;
864 1.1 bouyer }
865 1.1 bouyer io->mif_header.mfh_target_id = periph->periph_target;
866 1.1 bouyer io->mif_header.mfh_timeout = 0;
867 1.1 bouyer io->mif_header.mfh_flags = 0;
868 1.1 bouyer io->mif_header.mfh_sense_len = MFI_SENSE_SIZE;
869 1.1 bouyer io->mif_header.mfh_data_len= blockcnt;
870 1.1 bouyer io->mif_lba_hi = 0;
871 1.1 bouyer io->mif_lba_lo = blockno;
872 1.1 bouyer io->mif_sense_addr_lo = htole32(ccb->ccb_psense);
873 1.1 bouyer io->mif_sense_addr_hi = 0;
874 1.1 bouyer
875 1.1 bouyer ccb->ccb_done = mfi_scsi_xs_done;
876 1.1 bouyer ccb->ccb_xs = xs;
877 1.1 bouyer ccb->ccb_frame_size = MFI_IO_FRAME_SIZE;
878 1.1 bouyer ccb->ccb_sgl = &io->mif_sgl;
879 1.1 bouyer ccb->ccb_data = xs->data;
880 1.1 bouyer ccb->ccb_len = xs->datalen;
881 1.1 bouyer
882 1.1 bouyer if (mfi_create_sgl(ccb, xs->xs_control & XS_CTL_NOSLEEP) ?
883 1.1 bouyer BUS_DMA_NOWAIT : BUS_DMA_WAITOK)
884 1.1 bouyer return (1);
885 1.1 bouyer
886 1.1 bouyer return (0);
887 1.1 bouyer }
888 1.1 bouyer
889 1.1 bouyer void
890 1.1 bouyer mfi_scsi_xs_done(struct mfi_ccb *ccb)
891 1.1 bouyer {
892 1.1 bouyer struct scsipi_xfer *xs = ccb->ccb_xs;
893 1.1 bouyer struct mfi_softc *sc = ccb->ccb_sc;
894 1.1 bouyer struct mfi_frame_header *hdr = &ccb->ccb_frame->mfr_header;
895 1.1 bouyer
896 1.4 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_scsi_xs_done %#lx %#lx\n",
897 1.4 bouyer DEVNAME(sc), (u_long)ccb, (u_long)ccb->ccb_frame);
898 1.1 bouyer
899 1.1 bouyer if (xs->data != NULL) {
900 1.1 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_scsi_xs_done sync\n",
901 1.1 bouyer DEVNAME(sc));
902 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
903 1.1 bouyer ccb->ccb_dmamap->dm_mapsize,
904 1.1 bouyer (xs->xs_control & XS_CTL_DATA_IN) ?
905 1.1 bouyer BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
906 1.1 bouyer
907 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
908 1.1 bouyer }
909 1.1 bouyer
910 1.1 bouyer if (hdr->mfh_cmd_status != MFI_STAT_OK) {
911 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
912 1.1 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_scsi_xs_done stuffup %#x\n",
913 1.1 bouyer DEVNAME(sc), hdr->mfh_cmd_status);
914 1.1 bouyer
915 1.1 bouyer if (hdr->mfh_scsi_status != 0) {
916 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, MFIMEM_MAP(sc->sc_sense),
917 1.1 bouyer ccb->ccb_psense - MFIMEM_DVA(sc->sc_sense),
918 1.1 bouyer MFI_SENSE_SIZE, BUS_DMASYNC_POSTREAD);
919 1.1 bouyer DNPRINTF(MFI_D_INTR,
920 1.4 bouyer "%s: mfi_scsi_xs_done sense %#x %lx %lx\n",
921 1.1 bouyer DEVNAME(sc), hdr->mfh_scsi_status,
922 1.4 bouyer (u_long)&xs->sense, (u_long)ccb->ccb_sense);
923 1.1 bouyer memset(&xs->sense, 0, sizeof(xs->sense));
924 1.1 bouyer memcpy(&xs->sense, ccb->ccb_sense,
925 1.1 bouyer sizeof(struct scsi_sense_data));
926 1.1 bouyer xs->error = XS_SENSE;
927 1.1 bouyer }
928 1.1 bouyer } else {
929 1.1 bouyer xs->error = XS_NOERROR;
930 1.1 bouyer xs->status = SCSI_OK;
931 1.1 bouyer xs->resid = 0;
932 1.1 bouyer }
933 1.1 bouyer
934 1.1 bouyer mfi_put_ccb(ccb);
935 1.1 bouyer scsipi_done(xs);
936 1.1 bouyer }
937 1.1 bouyer
938 1.1 bouyer int
939 1.1 bouyer mfi_scsi_ld(struct mfi_ccb *ccb, struct scsipi_xfer *xs)
940 1.1 bouyer {
941 1.1 bouyer struct mfi_pass_frame *pf;
942 1.1 bouyer struct scsipi_periph *periph = xs->xs_periph;
943 1.1 bouyer
944 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_scsi_ld: %d\n",
945 1.1 bouyer periph->periph_channel->chan_adapter->adapt_dev->dv_xname,
946 1.1 bouyer periph->periph_target);
947 1.1 bouyer
948 1.1 bouyer pf = &ccb->ccb_frame->mfr_pass;
949 1.1 bouyer pf->mpf_header.mfh_cmd = MFI_CMD_LD_SCSI_IO;
950 1.1 bouyer pf->mpf_header.mfh_target_id = periph->periph_target;
951 1.1 bouyer pf->mpf_header.mfh_lun_id = 0;
952 1.1 bouyer pf->mpf_header.mfh_cdb_len = xs->cmdlen;
953 1.1 bouyer pf->mpf_header.mfh_timeout = 0;
954 1.1 bouyer pf->mpf_header.mfh_data_len= xs->datalen; /* XXX */
955 1.1 bouyer pf->mpf_header.mfh_sense_len = MFI_SENSE_SIZE;
956 1.1 bouyer
957 1.1 bouyer pf->mpf_sense_addr_hi = 0;
958 1.1 bouyer pf->mpf_sense_addr_lo = htole32(ccb->ccb_psense);
959 1.1 bouyer
960 1.1 bouyer memset(pf->mpf_cdb, 0, 16);
961 1.1 bouyer memcpy(pf->mpf_cdb, &xs->cmdstore, xs->cmdlen);
962 1.1 bouyer
963 1.1 bouyer ccb->ccb_done = mfi_scsi_xs_done;
964 1.1 bouyer ccb->ccb_xs = xs;
965 1.1 bouyer ccb->ccb_frame_size = MFI_PASS_FRAME_SIZE;
966 1.1 bouyer ccb->ccb_sgl = &pf->mpf_sgl;
967 1.1 bouyer
968 1.1 bouyer if (xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT))
969 1.1 bouyer ccb->ccb_direction = (xs->xs_control & XS_CTL_DATA_IN) ?
970 1.1 bouyer MFI_DATA_IN : MFI_DATA_OUT;
971 1.1 bouyer else
972 1.1 bouyer ccb->ccb_direction = MFI_DATA_NONE;
973 1.1 bouyer
974 1.1 bouyer if (xs->data) {
975 1.1 bouyer ccb->ccb_data = xs->data;
976 1.1 bouyer ccb->ccb_len = xs->datalen;
977 1.1 bouyer
978 1.1 bouyer if (mfi_create_sgl(ccb, xs->xs_control & XS_CTL_NOSLEEP) ?
979 1.1 bouyer BUS_DMA_NOWAIT : BUS_DMA_WAITOK)
980 1.1 bouyer return (1);
981 1.1 bouyer }
982 1.1 bouyer
983 1.1 bouyer return (0);
984 1.1 bouyer }
985 1.1 bouyer
986 1.1 bouyer void
987 1.1 bouyer mfi_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
988 1.1 bouyer void *arg)
989 1.1 bouyer {
990 1.1 bouyer struct scsipi_periph *periph;
991 1.1 bouyer struct scsipi_xfer *xs;
992 1.1 bouyer struct scsipi_adapter *adapt = chan->chan_adapter;
993 1.1 bouyer struct mfi_softc *sc = (void *) adapt->adapt_dev;
994 1.1 bouyer struct mfi_ccb *ccb;
995 1.1 bouyer struct scsi_rw_6 *rw;
996 1.1 bouyer struct scsipi_rw_10 *rwb;
997 1.1 bouyer uint32_t blockno, blockcnt;
998 1.1 bouyer uint8_t target;
999 1.1 bouyer uint8_t mbox[MFI_MBOX_SIZE];
1000 1.1 bouyer int s;
1001 1.1 bouyer
1002 1.1 bouyer switch (req) {
1003 1.1 bouyer case ADAPTER_REQ_GROW_RESOURCES:
1004 1.1 bouyer /* Not supported. */
1005 1.1 bouyer return;
1006 1.1 bouyer case ADAPTER_REQ_SET_XFER_MODE:
1007 1.1 bouyer /* Not supported. */
1008 1.1 bouyer return;
1009 1.1 bouyer case ADAPTER_REQ_RUN_XFER:
1010 1.1 bouyer break;
1011 1.1 bouyer }
1012 1.1 bouyer
1013 1.1 bouyer xs = arg;
1014 1.4 bouyer
1015 1.4 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_scsipi_request req %d opcode: %#x\n",
1016 1.4 bouyer DEVNAME(sc), req, xs->cmd->opcode);
1017 1.4 bouyer
1018 1.1 bouyer periph = xs->xs_periph;
1019 1.1 bouyer target = periph->periph_target;
1020 1.1 bouyer
1021 1.1 bouyer s = splbio();
1022 1.1 bouyer if (target >= MFI_MAX_LD || !sc->sc_ld[target].ld_present ||
1023 1.1 bouyer periph->periph_lun != 0) {
1024 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: invalid target %d\n",
1025 1.1 bouyer DEVNAME(sc), target);
1026 1.1 bouyer xs->error = XS_SELTIMEOUT;
1027 1.1 bouyer scsipi_done(xs);
1028 1.1 bouyer splx(s);
1029 1.1 bouyer return;
1030 1.1 bouyer }
1031 1.1 bouyer
1032 1.1 bouyer if ((ccb = mfi_get_ccb(sc)) == NULL) {
1033 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: mfi_scsipi_request no ccb\n", DEVNAME(sc));
1034 1.1 bouyer xs->error = XS_RESOURCE_SHORTAGE;
1035 1.1 bouyer scsipi_done(xs);
1036 1.1 bouyer splx(s);
1037 1.1 bouyer return;
1038 1.1 bouyer }
1039 1.1 bouyer
1040 1.1 bouyer switch (xs->cmd->opcode) {
1041 1.1 bouyer /* IO path */
1042 1.1 bouyer case READ_10:
1043 1.1 bouyer case WRITE_10:
1044 1.1 bouyer rwb = (struct scsipi_rw_10 *)xs->cmd;
1045 1.1 bouyer blockno = _4btol(rwb->addr);
1046 1.1 bouyer blockcnt = _2btol(rwb->length);
1047 1.1 bouyer if (mfi_scsi_io(ccb, xs, blockno, blockcnt)) {
1048 1.1 bouyer mfi_put_ccb(ccb);
1049 1.1 bouyer goto stuffup;
1050 1.1 bouyer }
1051 1.1 bouyer break;
1052 1.1 bouyer
1053 1.1 bouyer case SCSI_READ_6_COMMAND:
1054 1.1 bouyer case SCSI_WRITE_6_COMMAND:
1055 1.1 bouyer rw = (struct scsi_rw_6 *)xs->cmd;
1056 1.1 bouyer blockno = _3btol(rw->addr) & (SRW_TOPADDR << 16 | 0xffff);
1057 1.1 bouyer blockcnt = rw->length ? rw->length : 0x100;
1058 1.1 bouyer if (mfi_scsi_io(ccb, xs, blockno, blockcnt)) {
1059 1.1 bouyer mfi_put_ccb(ccb);
1060 1.1 bouyer goto stuffup;
1061 1.1 bouyer }
1062 1.1 bouyer break;
1063 1.1 bouyer
1064 1.1 bouyer case SCSI_SYNCHRONIZE_CACHE_10:
1065 1.1 bouyer mfi_put_ccb(ccb); /* we don't need this */
1066 1.1 bouyer
1067 1.1 bouyer mbox[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
1068 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_CTRL_CACHE_FLUSH, MFI_DATA_NONE,
1069 1.1 bouyer 0, NULL, mbox))
1070 1.1 bouyer goto stuffup;
1071 1.1 bouyer xs->error = XS_NOERROR;
1072 1.1 bouyer xs->status = SCSI_OK;
1073 1.1 bouyer xs->resid = 0;
1074 1.1 bouyer scsipi_done(xs);
1075 1.1 bouyer splx(s);
1076 1.1 bouyer return;
1077 1.1 bouyer /* NOTREACHED */
1078 1.1 bouyer
1079 1.1 bouyer /* hand it of to the firmware and let it deal with it */
1080 1.1 bouyer case SCSI_TEST_UNIT_READY:
1081 1.1 bouyer /* save off sd? after autoconf */
1082 1.1 bouyer if (!cold) /* XXX bogus */
1083 1.1 bouyer strlcpy(sc->sc_ld[target].ld_dev, sc->sc_dev.dv_xname,
1084 1.1 bouyer sizeof(sc->sc_ld[target].ld_dev));
1085 1.1 bouyer /* FALLTHROUGH */
1086 1.1 bouyer
1087 1.1 bouyer default:
1088 1.1 bouyer if (mfi_scsi_ld(ccb, xs)) {
1089 1.1 bouyer mfi_put_ccb(ccb);
1090 1.1 bouyer goto stuffup;
1091 1.1 bouyer }
1092 1.1 bouyer break;
1093 1.1 bouyer }
1094 1.1 bouyer
1095 1.1 bouyer DNPRINTF(MFI_D_CMD, "%s: start io %d\n", DEVNAME(sc), target);
1096 1.1 bouyer
1097 1.1 bouyer if (xs->xs_control & XS_CTL_POLL) {
1098 1.1 bouyer if (mfi_poll(ccb)) {
1099 1.1 bouyer /* XXX check for sense in ccb->ccb_sense? */
1100 1.1 bouyer printf("%s: mfi_scsipi_request poll failed\n",
1101 1.1 bouyer DEVNAME(sc));
1102 1.1 bouyer mfi_put_ccb(ccb);
1103 1.1 bouyer bzero(&xs->sense, sizeof(xs->sense));
1104 1.1 bouyer xs->sense.scsi_sense.response_code =
1105 1.1 bouyer SSD_RCODE_VALID | SSD_RCODE_CURRENT;
1106 1.1 bouyer xs->sense.scsi_sense.flags = SKEY_ILLEGAL_REQUEST;
1107 1.1 bouyer xs->sense.scsi_sense.asc = 0x20; /* invalid opcode */
1108 1.1 bouyer xs->error = XS_SENSE;
1109 1.1 bouyer xs->status = SCSI_CHECK;
1110 1.1 bouyer } else {
1111 1.1 bouyer DNPRINTF(MFI_D_DMA,
1112 1.1 bouyer "%s: mfi_scsipi_request poll complete %d\n",
1113 1.1 bouyer DEVNAME(sc), ccb->ccb_dmamap->dm_nsegs);
1114 1.1 bouyer xs->error = XS_NOERROR;
1115 1.1 bouyer xs->status = SCSI_OK;
1116 1.1 bouyer xs->resid = 0;
1117 1.1 bouyer }
1118 1.1 bouyer mfi_put_ccb(ccb);
1119 1.1 bouyer scsipi_done(xs);
1120 1.1 bouyer splx(s);
1121 1.1 bouyer return;
1122 1.1 bouyer }
1123 1.1 bouyer
1124 1.1 bouyer mfi_despatch_cmd(ccb);
1125 1.1 bouyer
1126 1.1 bouyer DNPRINTF(MFI_D_DMA, "%s: mfi_scsipi_request queued %d\n", DEVNAME(sc),
1127 1.1 bouyer ccb->ccb_dmamap->dm_nsegs);
1128 1.1 bouyer
1129 1.1 bouyer splx(s);
1130 1.1 bouyer return;
1131 1.1 bouyer
1132 1.1 bouyer stuffup:
1133 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
1134 1.1 bouyer scsipi_done(xs);
1135 1.1 bouyer splx(s);
1136 1.1 bouyer }
1137 1.1 bouyer
1138 1.1 bouyer int
1139 1.1 bouyer mfi_create_sgl(struct mfi_ccb *ccb, int flags)
1140 1.1 bouyer {
1141 1.1 bouyer struct mfi_softc *sc = ccb->ccb_sc;
1142 1.1 bouyer struct mfi_frame_header *hdr;
1143 1.1 bouyer bus_dma_segment_t *sgd;
1144 1.1 bouyer union mfi_sgl *sgl;
1145 1.1 bouyer int error, i;
1146 1.1 bouyer
1147 1.4 bouyer DNPRINTF(MFI_D_DMA, "%s: mfi_create_sgl %#lx\n", DEVNAME(sc),
1148 1.4 bouyer (u_long)ccb->ccb_data);
1149 1.1 bouyer
1150 1.1 bouyer if (!ccb->ccb_data)
1151 1.1 bouyer return (1);
1152 1.1 bouyer
1153 1.1 bouyer error = bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap,
1154 1.1 bouyer ccb->ccb_data, ccb->ccb_len, NULL, flags);
1155 1.1 bouyer if (error) {
1156 1.1 bouyer if (error == EFBIG)
1157 1.1 bouyer printf("more than %d dma segs\n",
1158 1.1 bouyer sc->sc_max_sgl);
1159 1.1 bouyer else
1160 1.1 bouyer printf("error %d loading dma map\n", error);
1161 1.1 bouyer return (1);
1162 1.1 bouyer }
1163 1.1 bouyer
1164 1.1 bouyer hdr = &ccb->ccb_frame->mfr_header;
1165 1.1 bouyer sgl = ccb->ccb_sgl;
1166 1.1 bouyer sgd = ccb->ccb_dmamap->dm_segs;
1167 1.1 bouyer for (i = 0; i < ccb->ccb_dmamap->dm_nsegs; i++) {
1168 1.1 bouyer sgl->sg32[i].addr = htole32(sgd[i].ds_addr);
1169 1.1 bouyer sgl->sg32[i].len = htole32(sgd[i].ds_len);
1170 1.1 bouyer DNPRINTF(MFI_D_DMA, "%s: addr: %#x len: %#x\n",
1171 1.1 bouyer DEVNAME(sc), sgl->sg32[i].addr, sgl->sg32[i].len);
1172 1.1 bouyer }
1173 1.1 bouyer
1174 1.1 bouyer if (ccb->ccb_direction == MFI_DATA_IN) {
1175 1.1 bouyer hdr->mfh_flags |= MFI_FRAME_DIR_READ;
1176 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1177 1.1 bouyer ccb->ccb_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
1178 1.1 bouyer } else {
1179 1.1 bouyer hdr->mfh_flags |= MFI_FRAME_DIR_WRITE;
1180 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1181 1.1 bouyer ccb->ccb_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);
1182 1.1 bouyer }
1183 1.1 bouyer
1184 1.1 bouyer hdr->mfh_sg_count = ccb->ccb_dmamap->dm_nsegs;
1185 1.1 bouyer /* for 64 bit io make the sizeof a variable to hold whatever sg size */
1186 1.1 bouyer ccb->ccb_frame_size += sizeof(struct mfi_sg32) *
1187 1.1 bouyer ccb->ccb_dmamap->dm_nsegs;
1188 1.1 bouyer ccb->ccb_extra_frames = (ccb->ccb_frame_size - 1) / MFI_FRAME_SIZE;
1189 1.1 bouyer
1190 1.1 bouyer DNPRINTF(MFI_D_DMA, "%s: sg_count: %d frame_size: %d frames_size: %d"
1191 1.1 bouyer " dm_nsegs: %d extra_frames: %d\n",
1192 1.1 bouyer DEVNAME(sc),
1193 1.1 bouyer hdr->mfh_sg_count,
1194 1.1 bouyer ccb->ccb_frame_size,
1195 1.1 bouyer sc->sc_frames_size,
1196 1.1 bouyer ccb->ccb_dmamap->dm_nsegs,
1197 1.1 bouyer ccb->ccb_extra_frames);
1198 1.1 bouyer
1199 1.1 bouyer return (0);
1200 1.1 bouyer }
1201 1.1 bouyer
1202 1.1 bouyer int
1203 1.1 bouyer mfi_mgmt(struct mfi_softc *sc, uint32_t opc, uint32_t dir, uint32_t len,
1204 1.1 bouyer void *buf, uint8_t *mbox)
1205 1.1 bouyer {
1206 1.1 bouyer struct mfi_ccb *ccb;
1207 1.1 bouyer struct mfi_dcmd_frame *dcmd;
1208 1.1 bouyer int rv = 1;
1209 1.1 bouyer
1210 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: mfi_mgmt %#x\n", DEVNAME(sc), opc);
1211 1.1 bouyer
1212 1.1 bouyer if ((ccb = mfi_get_ccb(sc)) == NULL)
1213 1.1 bouyer return (rv);
1214 1.1 bouyer
1215 1.1 bouyer dcmd = &ccb->ccb_frame->mfr_dcmd;
1216 1.1 bouyer memset(dcmd->mdf_mbox, 0, MFI_MBOX_SIZE);
1217 1.1 bouyer dcmd->mdf_header.mfh_cmd = MFI_CMD_DCMD;
1218 1.1 bouyer dcmd->mdf_header.mfh_timeout = 0;
1219 1.1 bouyer
1220 1.1 bouyer dcmd->mdf_opcode = opc;
1221 1.1 bouyer dcmd->mdf_header.mfh_data_len = 0;
1222 1.1 bouyer ccb->ccb_direction = dir;
1223 1.1 bouyer ccb->ccb_done = mfi_mgmt_done;
1224 1.1 bouyer
1225 1.1 bouyer ccb->ccb_frame_size = MFI_DCMD_FRAME_SIZE;
1226 1.1 bouyer
1227 1.1 bouyer /* handle special opcodes */
1228 1.1 bouyer if (mbox)
1229 1.1 bouyer memcpy(dcmd->mdf_mbox, mbox, MFI_MBOX_SIZE);
1230 1.1 bouyer
1231 1.1 bouyer if (dir != MFI_DATA_NONE) {
1232 1.1 bouyer dcmd->mdf_header.mfh_data_len = len;
1233 1.1 bouyer ccb->ccb_data = buf;
1234 1.1 bouyer ccb->ccb_len = len;
1235 1.1 bouyer ccb->ccb_sgl = &dcmd->mdf_sgl;
1236 1.1 bouyer
1237 1.1 bouyer if (mfi_create_sgl(ccb, BUS_DMA_WAITOK))
1238 1.1 bouyer goto done;
1239 1.1 bouyer }
1240 1.1 bouyer
1241 1.1 bouyer if (cold) {
1242 1.1 bouyer if (mfi_poll(ccb))
1243 1.1 bouyer goto done;
1244 1.1 bouyer } else {
1245 1.1 bouyer mfi_despatch_cmd(ccb);
1246 1.1 bouyer
1247 1.1 bouyer DNPRINTF(MFI_D_MISC, "%s: mfi_mgmt sleeping\n", DEVNAME(sc));
1248 1.1 bouyer while (ccb->ccb_state != MFI_CCB_DONE)
1249 1.1 bouyer tsleep(ccb, PRIBIO, "mfi_mgmt", 0);
1250 1.1 bouyer
1251 1.1 bouyer if (ccb->ccb_flags & MFI_CCB_F_ERR)
1252 1.1 bouyer goto done;
1253 1.1 bouyer }
1254 1.1 bouyer
1255 1.1 bouyer rv = 0;
1256 1.1 bouyer
1257 1.1 bouyer done:
1258 1.1 bouyer mfi_put_ccb(ccb);
1259 1.1 bouyer return (rv);
1260 1.1 bouyer }
1261 1.1 bouyer
1262 1.1 bouyer void
1263 1.1 bouyer mfi_mgmt_done(struct mfi_ccb *ccb)
1264 1.1 bouyer {
1265 1.1 bouyer struct mfi_softc *sc = ccb->ccb_sc;
1266 1.1 bouyer struct mfi_frame_header *hdr = &ccb->ccb_frame->mfr_header;
1267 1.1 bouyer
1268 1.4 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_mgmt_done %#lx %#lx\n",
1269 1.4 bouyer DEVNAME(sc), (u_long)ccb, (u_long)ccb->ccb_frame);
1270 1.1 bouyer
1271 1.1 bouyer if (ccb->ccb_data != NULL) {
1272 1.1 bouyer DNPRINTF(MFI_D_INTR, "%s: mfi_mgmt_done sync\n",
1273 1.1 bouyer DEVNAME(sc));
1274 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1275 1.1 bouyer ccb->ccb_dmamap->dm_mapsize,
1276 1.1 bouyer (ccb->ccb_direction & MFI_DATA_IN) ?
1277 1.1 bouyer BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1278 1.1 bouyer
1279 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
1280 1.1 bouyer }
1281 1.1 bouyer
1282 1.1 bouyer if (hdr->mfh_cmd_status != MFI_STAT_OK)
1283 1.1 bouyer ccb->ccb_flags |= MFI_CCB_F_ERR;
1284 1.1 bouyer
1285 1.1 bouyer ccb->ccb_state = MFI_CCB_DONE;
1286 1.1 bouyer
1287 1.1 bouyer wakeup(ccb);
1288 1.1 bouyer }
1289 1.1 bouyer
1290 1.1 bouyer
1291 1.1 bouyer int
1292 1.3 christos mfi_scsi_ioctl(struct scsipi_channel *chan, u_long cmd, void *arg,
1293 1.1 bouyer int flag, struct proc *p)
1294 1.1 bouyer {
1295 1.1 bouyer return (ENOTTY);
1296 1.1 bouyer }
1297 1.1 bouyer
1298 1.1 bouyer #if NBIO > 0
1299 1.1 bouyer int
1300 1.3 christos mfi_ioctl(struct device *dev, u_long cmd, void *addr)
1301 1.1 bouyer {
1302 1.1 bouyer struct mfi_softc *sc = (struct mfi_softc *)dev;
1303 1.1 bouyer int error = 0;
1304 1.1 bouyer
1305 1.4 bouyer int s = splbio();
1306 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl ", DEVNAME(sc));
1307 1.1 bouyer
1308 1.1 bouyer switch (cmd) {
1309 1.1 bouyer case BIOCINQ:
1310 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "inq\n");
1311 1.1 bouyer error = mfi_ioctl_inq(sc, (struct bioc_inq *)addr);
1312 1.1 bouyer break;
1313 1.1 bouyer
1314 1.1 bouyer case BIOCVOL:
1315 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "vol\n");
1316 1.1 bouyer error = mfi_ioctl_vol(sc, (struct bioc_vol *)addr);
1317 1.1 bouyer break;
1318 1.1 bouyer
1319 1.1 bouyer case BIOCDISK:
1320 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "disk\n");
1321 1.1 bouyer error = mfi_ioctl_disk(sc, (struct bioc_disk *)addr);
1322 1.1 bouyer break;
1323 1.1 bouyer
1324 1.1 bouyer case BIOCALARM:
1325 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "alarm\n");
1326 1.1 bouyer error = mfi_ioctl_alarm(sc, (struct bioc_alarm *)addr);
1327 1.1 bouyer break;
1328 1.1 bouyer
1329 1.1 bouyer case BIOCBLINK:
1330 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "blink\n");
1331 1.1 bouyer error = mfi_ioctl_blink(sc, (struct bioc_blink *)addr);
1332 1.1 bouyer break;
1333 1.1 bouyer
1334 1.1 bouyer case BIOCSETSTATE:
1335 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "setstate\n");
1336 1.1 bouyer error = mfi_ioctl_setstate(sc, (struct bioc_setstate *)addr);
1337 1.1 bouyer break;
1338 1.1 bouyer
1339 1.1 bouyer default:
1340 1.1 bouyer DNPRINTF(MFI_D_IOCTL, " invalid ioctl\n");
1341 1.1 bouyer error = EINVAL;
1342 1.1 bouyer }
1343 1.4 bouyer splx(s);
1344 1.4 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl return %x\n", DEVNAME(sc), error);
1345 1.1 bouyer return (error);
1346 1.1 bouyer }
1347 1.1 bouyer
1348 1.1 bouyer int
1349 1.1 bouyer mfi_ioctl_inq(struct mfi_softc *sc, struct bioc_inq *bi)
1350 1.1 bouyer {
1351 1.1 bouyer struct mfi_conf *cfg;
1352 1.1 bouyer int rv = EINVAL;
1353 1.1 bouyer
1354 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_inq\n", DEVNAME(sc));
1355 1.1 bouyer
1356 1.1 bouyer if (mfi_get_info(sc)) {
1357 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_inq failed\n",
1358 1.1 bouyer DEVNAME(sc));
1359 1.1 bouyer return (EIO);
1360 1.1 bouyer }
1361 1.1 bouyer
1362 1.1 bouyer /* get figures */
1363 1.1 bouyer cfg = malloc(sizeof *cfg, M_DEVBUF, M_WAITOK);
1364 1.1 bouyer if (mfi_mgmt(sc, MD_DCMD_CONF_GET, MFI_DATA_IN, sizeof *cfg, cfg, NULL))
1365 1.1 bouyer goto freeme;
1366 1.1 bouyer
1367 1.1 bouyer strlcpy(bi->bi_dev, DEVNAME(sc), sizeof(bi->bi_dev));
1368 1.1 bouyer bi->bi_novol = cfg->mfc_no_ld + cfg->mfc_no_hs;
1369 1.1 bouyer bi->bi_nodisk = sc->sc_info.mci_pd_disks_present;
1370 1.1 bouyer
1371 1.1 bouyer rv = 0;
1372 1.1 bouyer freeme:
1373 1.1 bouyer free(cfg, M_DEVBUF);
1374 1.1 bouyer return (rv);
1375 1.1 bouyer }
1376 1.1 bouyer
1377 1.1 bouyer int
1378 1.1 bouyer mfi_ioctl_vol(struct mfi_softc *sc, struct bioc_vol *bv)
1379 1.1 bouyer {
1380 1.1 bouyer int i, per, rv = EINVAL;
1381 1.1 bouyer uint8_t mbox[MFI_MBOX_SIZE];
1382 1.1 bouyer
1383 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_vol %#x\n",
1384 1.1 bouyer DEVNAME(sc), bv->bv_volid);
1385 1.1 bouyer
1386 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_LD_GET_LIST, MFI_DATA_IN,
1387 1.1 bouyer sizeof(sc->sc_ld_list), &sc->sc_ld_list, NULL))
1388 1.1 bouyer goto done;
1389 1.1 bouyer
1390 1.1 bouyer i = bv->bv_volid;
1391 1.1 bouyer mbox[0] = sc->sc_ld_list.mll_list[i].mll_ld.mld_target;
1392 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_vol target %#x\n",
1393 1.1 bouyer DEVNAME(sc), mbox[0]);
1394 1.1 bouyer
1395 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_LD_GET_INFO, MFI_DATA_IN,
1396 1.1 bouyer sizeof(sc->sc_ld_details), &sc->sc_ld_details, mbox))
1397 1.1 bouyer goto done;
1398 1.1 bouyer
1399 1.1 bouyer if (bv->bv_volid >= sc->sc_ld_list.mll_no_ld) {
1400 1.1 bouyer /* go do hotspares */
1401 1.1 bouyer rv = mfi_bio_hs(sc, bv->bv_volid, MFI_MGMT_VD, bv);
1402 1.1 bouyer goto done;
1403 1.1 bouyer }
1404 1.1 bouyer
1405 1.1 bouyer strlcpy(bv->bv_dev, sc->sc_ld[i].ld_dev, sizeof(bv->bv_dev));
1406 1.1 bouyer
1407 1.1 bouyer switch(sc->sc_ld_list.mll_list[i].mll_state) {
1408 1.1 bouyer case MFI_LD_OFFLINE:
1409 1.1 bouyer bv->bv_status = BIOC_SVOFFLINE;
1410 1.1 bouyer break;
1411 1.1 bouyer
1412 1.1 bouyer case MFI_LD_PART_DEGRADED:
1413 1.1 bouyer case MFI_LD_DEGRADED:
1414 1.1 bouyer bv->bv_status = BIOC_SVDEGRADED;
1415 1.1 bouyer break;
1416 1.1 bouyer
1417 1.1 bouyer case MFI_LD_ONLINE:
1418 1.1 bouyer bv->bv_status = BIOC_SVONLINE;
1419 1.1 bouyer break;
1420 1.1 bouyer
1421 1.1 bouyer default:
1422 1.1 bouyer bv->bv_status = BIOC_SVINVALID;
1423 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: invalid logical disk state %#x\n",
1424 1.1 bouyer DEVNAME(sc),
1425 1.1 bouyer sc->sc_ld_list.mll_list[i].mll_state);
1426 1.1 bouyer }
1427 1.1 bouyer
1428 1.1 bouyer /* additional status can modify MFI status */
1429 1.1 bouyer switch (sc->sc_ld_details.mld_progress.mlp_in_prog) {
1430 1.1 bouyer case MFI_LD_PROG_CC:
1431 1.1 bouyer case MFI_LD_PROG_BGI:
1432 1.1 bouyer bv->bv_status = BIOC_SVSCRUB;
1433 1.1 bouyer per = (int)sc->sc_ld_details.mld_progress.mlp_cc.mp_progress;
1434 1.1 bouyer bv->bv_percent = (per * 100) / 0xffff;
1435 1.1 bouyer bv->bv_seconds =
1436 1.1 bouyer sc->sc_ld_details.mld_progress.mlp_cc.mp_elapsed_seconds;
1437 1.1 bouyer break;
1438 1.1 bouyer
1439 1.1 bouyer case MFI_LD_PROG_FGI:
1440 1.1 bouyer case MFI_LD_PROG_RECONSTRUCT:
1441 1.1 bouyer /* nothing yet */
1442 1.1 bouyer break;
1443 1.1 bouyer }
1444 1.1 bouyer
1445 1.1 bouyer /*
1446 1.1 bouyer * The RAID levels are determined per the SNIA DDF spec, this is only
1447 1.1 bouyer * a subset that is valid for the MFI contrller.
1448 1.1 bouyer */
1449 1.1 bouyer bv->bv_level = sc->sc_ld_details.mld_cfg.mlc_parm.mpa_pri_raid;
1450 1.1 bouyer if (sc->sc_ld_details.mld_cfg.mlc_parm.mpa_sec_raid ==
1451 1.1 bouyer MFI_DDF_SRL_SPANNED)
1452 1.1 bouyer bv->bv_level *= 10;
1453 1.1 bouyer
1454 1.1 bouyer bv->bv_nodisk = sc->sc_ld_details.mld_cfg.mlc_parm.mpa_no_drv_per_span *
1455 1.1 bouyer sc->sc_ld_details.mld_cfg.mlc_parm.mpa_span_depth;
1456 1.1 bouyer
1457 1.1 bouyer bv->bv_size = sc->sc_ld_details.mld_size * 512; /* bytes per block */
1458 1.1 bouyer
1459 1.1 bouyer rv = 0;
1460 1.1 bouyer done:
1461 1.4 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_vol done %x\n",
1462 1.4 bouyer DEVNAME(sc), rv);
1463 1.1 bouyer return (rv);
1464 1.1 bouyer }
1465 1.1 bouyer
1466 1.1 bouyer int
1467 1.1 bouyer mfi_ioctl_disk(struct mfi_softc *sc, struct bioc_disk *bd)
1468 1.1 bouyer {
1469 1.1 bouyer struct mfi_conf *cfg;
1470 1.1 bouyer struct mfi_array *ar;
1471 1.1 bouyer struct mfi_ld_cfg *ld;
1472 1.1 bouyer struct mfi_pd_details *pd;
1473 1.4 bouyer struct scsipi_inquiry_data *inqbuf;
1474 1.1 bouyer char vend[8+16+4+1];
1475 1.1 bouyer int i, rv = EINVAL;
1476 1.1 bouyer int arr, vol, disk;
1477 1.1 bouyer uint32_t size;
1478 1.1 bouyer uint8_t mbox[MFI_MBOX_SIZE];
1479 1.1 bouyer
1480 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_disk %#x\n",
1481 1.1 bouyer DEVNAME(sc), bd->bd_diskid);
1482 1.1 bouyer
1483 1.4 bouyer pd = malloc(sizeof *pd, M_DEVBUF, M_WAITOK | M_ZERO);
1484 1.1 bouyer
1485 1.1 bouyer /* send single element command to retrieve size for full structure */
1486 1.1 bouyer cfg = malloc(sizeof *cfg, M_DEVBUF, M_WAITOK);
1487 1.1 bouyer if (mfi_mgmt(sc, MD_DCMD_CONF_GET, MFI_DATA_IN, sizeof *cfg, cfg, NULL))
1488 1.1 bouyer goto freeme;
1489 1.1 bouyer
1490 1.1 bouyer size = cfg->mfc_size;
1491 1.1 bouyer free(cfg, M_DEVBUF);
1492 1.1 bouyer
1493 1.1 bouyer /* memory for read config */
1494 1.1 bouyer cfg = malloc(size, M_DEVBUF, M_WAITOK);
1495 1.1 bouyer memset(cfg, 0, size);
1496 1.1 bouyer if (mfi_mgmt(sc, MD_DCMD_CONF_GET, MFI_DATA_IN, size, cfg, NULL))
1497 1.1 bouyer goto freeme;
1498 1.1 bouyer
1499 1.1 bouyer ar = cfg->mfc_array;
1500 1.1 bouyer
1501 1.1 bouyer /* calculate offset to ld structure */
1502 1.1 bouyer ld = (struct mfi_ld_cfg *)(
1503 1.1 bouyer ((uint8_t *)cfg) + offsetof(struct mfi_conf, mfc_array) +
1504 1.1 bouyer cfg->mfc_array_size * cfg->mfc_no_array);
1505 1.1 bouyer
1506 1.1 bouyer vol = bd->bd_volid;
1507 1.1 bouyer
1508 1.1 bouyer if (vol >= cfg->mfc_no_ld) {
1509 1.1 bouyer /* do hotspares */
1510 1.1 bouyer rv = mfi_bio_hs(sc, bd->bd_volid, MFI_MGMT_SD, bd);
1511 1.1 bouyer goto freeme;
1512 1.1 bouyer }
1513 1.1 bouyer
1514 1.1 bouyer /* find corresponding array for ld */
1515 1.1 bouyer for (i = 0, arr = 0; i < vol; i++)
1516 1.1 bouyer arr += ld[i].mlc_parm.mpa_span_depth;
1517 1.1 bouyer
1518 1.1 bouyer /* offset disk into pd list */
1519 1.1 bouyer disk = bd->bd_diskid % ld[vol].mlc_parm.mpa_no_drv_per_span;
1520 1.1 bouyer
1521 1.1 bouyer /* offset array index into the next spans */
1522 1.1 bouyer arr += bd->bd_diskid / ld[vol].mlc_parm.mpa_no_drv_per_span;
1523 1.1 bouyer
1524 1.1 bouyer bd->bd_target = ar[arr].pd[disk].mar_enc_slot;
1525 1.1 bouyer switch (ar[arr].pd[disk].mar_pd_state){
1526 1.1 bouyer case MFI_PD_UNCONFIG_GOOD:
1527 1.1 bouyer bd->bd_status = BIOC_SDUNUSED;
1528 1.1 bouyer break;
1529 1.1 bouyer
1530 1.1 bouyer case MFI_PD_HOTSPARE: /* XXX dedicated hotspare part of array? */
1531 1.1 bouyer bd->bd_status = BIOC_SDHOTSPARE;
1532 1.1 bouyer break;
1533 1.1 bouyer
1534 1.1 bouyer case MFI_PD_OFFLINE:
1535 1.1 bouyer bd->bd_status = BIOC_SDOFFLINE;
1536 1.1 bouyer break;
1537 1.1 bouyer
1538 1.1 bouyer case MFI_PD_FAILED:
1539 1.1 bouyer bd->bd_status = BIOC_SDFAILED;
1540 1.1 bouyer break;
1541 1.1 bouyer
1542 1.1 bouyer case MFI_PD_REBUILD:
1543 1.1 bouyer bd->bd_status = BIOC_SDREBUILD;
1544 1.1 bouyer break;
1545 1.1 bouyer
1546 1.1 bouyer case MFI_PD_ONLINE:
1547 1.1 bouyer bd->bd_status = BIOC_SDONLINE;
1548 1.1 bouyer break;
1549 1.1 bouyer
1550 1.1 bouyer case MFI_PD_UNCONFIG_BAD: /* XXX define new state in bio */
1551 1.1 bouyer default:
1552 1.1 bouyer bd->bd_status = BIOC_SDINVALID;
1553 1.1 bouyer break;
1554 1.1 bouyer
1555 1.1 bouyer }
1556 1.1 bouyer
1557 1.1 bouyer /* get the remaining fields */
1558 1.1 bouyer *((uint16_t *)&mbox) = ar[arr].pd[disk].mar_pd.mfp_id;
1559 1.4 bouyer memset(pd, 0, sizeof(*pd));
1560 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_PD_GET_INFO, MFI_DATA_IN,
1561 1.1 bouyer sizeof *pd, pd, mbox))
1562 1.1 bouyer goto freeme;
1563 1.1 bouyer
1564 1.1 bouyer bd->bd_size = pd->mpd_size * 512; /* bytes per block */
1565 1.1 bouyer
1566 1.1 bouyer /* if pd->mpd_enc_idx is 0 then it is not in an enclosure */
1567 1.1 bouyer bd->bd_channel = pd->mpd_enc_idx;
1568 1.1 bouyer
1569 1.4 bouyer inqbuf = (struct scsipi_inquiry_data *)&pd->mpd_inq_data;
1570 1.1 bouyer memcpy(vend, inqbuf->vendor, sizeof vend - 1);
1571 1.1 bouyer vend[sizeof vend - 1] = '\0';
1572 1.1 bouyer strlcpy(bd->bd_vendor, vend, sizeof(bd->bd_vendor));
1573 1.1 bouyer
1574 1.1 bouyer /* XXX find a way to retrieve serial nr from drive */
1575 1.1 bouyer /* XXX find a way to get bd_procdev */
1576 1.1 bouyer
1577 1.1 bouyer rv = 0;
1578 1.1 bouyer freeme:
1579 1.1 bouyer free(pd, M_DEVBUF);
1580 1.1 bouyer free(cfg, M_DEVBUF);
1581 1.1 bouyer
1582 1.1 bouyer return (rv);
1583 1.1 bouyer }
1584 1.1 bouyer
1585 1.1 bouyer int
1586 1.1 bouyer mfi_ioctl_alarm(struct mfi_softc *sc, struct bioc_alarm *ba)
1587 1.1 bouyer {
1588 1.1 bouyer uint32_t opc, dir = MFI_DATA_NONE;
1589 1.1 bouyer int rv = 0;
1590 1.1 bouyer int8_t ret;
1591 1.1 bouyer
1592 1.1 bouyer switch(ba->ba_opcode) {
1593 1.1 bouyer case BIOC_SADISABLE:
1594 1.1 bouyer opc = MR_DCMD_SPEAKER_DISABLE;
1595 1.1 bouyer break;
1596 1.1 bouyer
1597 1.1 bouyer case BIOC_SAENABLE:
1598 1.1 bouyer opc = MR_DCMD_SPEAKER_ENABLE;
1599 1.1 bouyer break;
1600 1.1 bouyer
1601 1.1 bouyer case BIOC_SASILENCE:
1602 1.1 bouyer opc = MR_DCMD_SPEAKER_SILENCE;
1603 1.1 bouyer break;
1604 1.1 bouyer
1605 1.1 bouyer case BIOC_GASTATUS:
1606 1.1 bouyer opc = MR_DCMD_SPEAKER_GET;
1607 1.1 bouyer dir = MFI_DATA_IN;
1608 1.1 bouyer break;
1609 1.1 bouyer
1610 1.1 bouyer case BIOC_SATEST:
1611 1.1 bouyer opc = MR_DCMD_SPEAKER_TEST;
1612 1.1 bouyer break;
1613 1.1 bouyer
1614 1.1 bouyer default:
1615 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_alarm biocalarm invalid "
1616 1.1 bouyer "opcode %x\n", DEVNAME(sc), ba->ba_opcode);
1617 1.1 bouyer return (EINVAL);
1618 1.1 bouyer }
1619 1.1 bouyer
1620 1.1 bouyer if (mfi_mgmt(sc, opc, dir, sizeof(ret), &ret, NULL))
1621 1.1 bouyer rv = EINVAL;
1622 1.1 bouyer else
1623 1.1 bouyer if (ba->ba_opcode == BIOC_GASTATUS)
1624 1.1 bouyer ba->ba_status = ret;
1625 1.1 bouyer else
1626 1.1 bouyer ba->ba_status = 0;
1627 1.1 bouyer
1628 1.1 bouyer return (rv);
1629 1.1 bouyer }
1630 1.1 bouyer
1631 1.1 bouyer int
1632 1.1 bouyer mfi_ioctl_blink(struct mfi_softc *sc, struct bioc_blink *bb)
1633 1.1 bouyer {
1634 1.1 bouyer int i, found, rv = EINVAL;
1635 1.1 bouyer uint8_t mbox[MFI_MBOX_SIZE];
1636 1.1 bouyer uint32_t cmd;
1637 1.1 bouyer struct mfi_pd_list *pd;
1638 1.1 bouyer
1639 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_blink %x\n", DEVNAME(sc),
1640 1.1 bouyer bb->bb_status);
1641 1.1 bouyer
1642 1.1 bouyer /* channel 0 means not in an enclosure so can't be blinked */
1643 1.1 bouyer if (bb->bb_channel == 0)
1644 1.1 bouyer return (EINVAL);
1645 1.1 bouyer
1646 1.1 bouyer pd = malloc(MFI_PD_LIST_SIZE, M_DEVBUF, M_WAITOK);
1647 1.1 bouyer
1648 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_PD_GET_LIST, MFI_DATA_IN,
1649 1.1 bouyer MFI_PD_LIST_SIZE, pd, NULL))
1650 1.1 bouyer goto done;
1651 1.1 bouyer
1652 1.1 bouyer for (i = 0, found = 0; i < pd->mpl_no_pd; i++)
1653 1.1 bouyer if (bb->bb_channel == pd->mpl_address[i].mpa_enc_index &&
1654 1.1 bouyer bb->bb_target == pd->mpl_address[i].mpa_enc_slot) {
1655 1.1 bouyer found = 1;
1656 1.1 bouyer break;
1657 1.1 bouyer }
1658 1.1 bouyer
1659 1.1 bouyer if (!found)
1660 1.1 bouyer goto done;
1661 1.1 bouyer
1662 1.1 bouyer memset(mbox, 0, sizeof mbox);
1663 1.1 bouyer
1664 1.1 bouyer *((uint16_t *)&mbox) = pd->mpl_address[i].mpa_pd_id;;
1665 1.1 bouyer
1666 1.1 bouyer switch (bb->bb_status) {
1667 1.1 bouyer case BIOC_SBUNBLINK:
1668 1.1 bouyer cmd = MR_DCMD_PD_UNBLINK;
1669 1.1 bouyer break;
1670 1.1 bouyer
1671 1.1 bouyer case BIOC_SBBLINK:
1672 1.1 bouyer cmd = MR_DCMD_PD_BLINK;
1673 1.1 bouyer break;
1674 1.1 bouyer
1675 1.1 bouyer case BIOC_SBALARM:
1676 1.1 bouyer default:
1677 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_blink biocblink invalid "
1678 1.1 bouyer "opcode %x\n", DEVNAME(sc), bb->bb_status);
1679 1.1 bouyer goto done;
1680 1.1 bouyer }
1681 1.1 bouyer
1682 1.1 bouyer
1683 1.1 bouyer if (mfi_mgmt(sc, cmd, MFI_DATA_NONE, 0, NULL, mbox))
1684 1.1 bouyer goto done;
1685 1.1 bouyer
1686 1.1 bouyer rv = 0;
1687 1.1 bouyer done:
1688 1.1 bouyer free(pd, M_DEVBUF);
1689 1.1 bouyer return (rv);
1690 1.1 bouyer }
1691 1.1 bouyer
1692 1.1 bouyer int
1693 1.1 bouyer mfi_ioctl_setstate(struct mfi_softc *sc, struct bioc_setstate *bs)
1694 1.1 bouyer {
1695 1.1 bouyer struct mfi_pd_list *pd;
1696 1.1 bouyer int i, found, rv = EINVAL;
1697 1.1 bouyer uint8_t mbox[MFI_MBOX_SIZE];
1698 1.1 bouyer uint32_t cmd;
1699 1.1 bouyer
1700 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_setstate %x\n", DEVNAME(sc),
1701 1.1 bouyer bs->bs_status);
1702 1.1 bouyer
1703 1.1 bouyer pd = malloc(MFI_PD_LIST_SIZE, M_DEVBUF, M_WAITOK);
1704 1.1 bouyer
1705 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_PD_GET_LIST, MFI_DATA_IN,
1706 1.1 bouyer MFI_PD_LIST_SIZE, pd, NULL))
1707 1.1 bouyer goto done;
1708 1.1 bouyer
1709 1.1 bouyer for (i = 0, found = 0; i < pd->mpl_no_pd; i++)
1710 1.1 bouyer if (bs->bs_channel == pd->mpl_address[i].mpa_enc_index &&
1711 1.1 bouyer bs->bs_target == pd->mpl_address[i].mpa_enc_slot) {
1712 1.1 bouyer found = 1;
1713 1.1 bouyer break;
1714 1.1 bouyer }
1715 1.1 bouyer
1716 1.1 bouyer if (!found)
1717 1.1 bouyer goto done;
1718 1.1 bouyer
1719 1.1 bouyer memset(mbox, 0, sizeof mbox);
1720 1.1 bouyer
1721 1.1 bouyer *((uint16_t *)&mbox) = pd->mpl_address[i].mpa_pd_id;;
1722 1.1 bouyer
1723 1.1 bouyer switch (bs->bs_status) {
1724 1.1 bouyer case BIOC_SSONLINE:
1725 1.1 bouyer mbox[2] = MFI_PD_ONLINE;
1726 1.1 bouyer cmd = MD_DCMD_PD_SET_STATE;
1727 1.1 bouyer break;
1728 1.1 bouyer
1729 1.1 bouyer case BIOC_SSOFFLINE:
1730 1.1 bouyer mbox[2] = MFI_PD_OFFLINE;
1731 1.1 bouyer cmd = MD_DCMD_PD_SET_STATE;
1732 1.1 bouyer break;
1733 1.1 bouyer
1734 1.1 bouyer case BIOC_SSHOTSPARE:
1735 1.1 bouyer mbox[2] = MFI_PD_HOTSPARE;
1736 1.1 bouyer cmd = MD_DCMD_PD_SET_STATE;
1737 1.1 bouyer break;
1738 1.1 bouyer /*
1739 1.1 bouyer case BIOC_SSREBUILD:
1740 1.1 bouyer cmd = MD_DCMD_PD_REBUILD;
1741 1.1 bouyer break;
1742 1.1 bouyer */
1743 1.1 bouyer default:
1744 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_ioctl_setstate invalid "
1745 1.1 bouyer "opcode %x\n", DEVNAME(sc), bs->bs_status);
1746 1.1 bouyer goto done;
1747 1.1 bouyer }
1748 1.1 bouyer
1749 1.1 bouyer
1750 1.1 bouyer if (mfi_mgmt(sc, MD_DCMD_PD_SET_STATE, MFI_DATA_NONE, 0, NULL, mbox))
1751 1.1 bouyer goto done;
1752 1.1 bouyer
1753 1.1 bouyer rv = 0;
1754 1.1 bouyer done:
1755 1.1 bouyer free(pd, M_DEVBUF);
1756 1.1 bouyer return (rv);
1757 1.1 bouyer }
1758 1.1 bouyer
1759 1.1 bouyer int
1760 1.1 bouyer mfi_bio_hs(struct mfi_softc *sc, int volid, int type, void *bio_hs)
1761 1.1 bouyer {
1762 1.1 bouyer struct mfi_conf *cfg;
1763 1.1 bouyer struct mfi_hotspare *hs;
1764 1.1 bouyer struct mfi_pd_details *pd;
1765 1.1 bouyer struct bioc_disk *sdhs;
1766 1.1 bouyer struct bioc_vol *vdhs;
1767 1.4 bouyer struct scsipi_inquiry_data *inqbuf;
1768 1.1 bouyer char vend[8+16+4+1];
1769 1.1 bouyer int i, rv = EINVAL;
1770 1.1 bouyer uint32_t size;
1771 1.1 bouyer uint8_t mbox[MFI_MBOX_SIZE];
1772 1.1 bouyer
1773 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_vol_hs %d\n", DEVNAME(sc), volid);
1774 1.1 bouyer
1775 1.1 bouyer if (!bio_hs)
1776 1.1 bouyer return (EINVAL);
1777 1.1 bouyer
1778 1.4 bouyer pd = malloc(sizeof *pd, M_DEVBUF, M_WAITOK | M_ZERO);
1779 1.1 bouyer
1780 1.1 bouyer /* send single element command to retrieve size for full structure */
1781 1.1 bouyer cfg = malloc(sizeof *cfg, M_DEVBUF, M_WAITOK);
1782 1.1 bouyer if (mfi_mgmt(sc, MD_DCMD_CONF_GET, MFI_DATA_IN, sizeof *cfg, cfg, NULL))
1783 1.1 bouyer goto freeme;
1784 1.1 bouyer
1785 1.1 bouyer size = cfg->mfc_size;
1786 1.1 bouyer free(cfg, M_DEVBUF);
1787 1.1 bouyer
1788 1.1 bouyer /* memory for read config */
1789 1.1 bouyer cfg = malloc(size, M_DEVBUF, M_WAITOK);
1790 1.1 bouyer memset(cfg, 0, size);
1791 1.1 bouyer if (mfi_mgmt(sc, MD_DCMD_CONF_GET, MFI_DATA_IN, size, cfg, NULL))
1792 1.1 bouyer goto freeme;
1793 1.1 bouyer
1794 1.1 bouyer /* calculate offset to hs structure */
1795 1.1 bouyer hs = (struct mfi_hotspare *)(
1796 1.1 bouyer ((uint8_t *)cfg) + offsetof(struct mfi_conf, mfc_array) +
1797 1.1 bouyer cfg->mfc_array_size * cfg->mfc_no_array +
1798 1.1 bouyer cfg->mfc_ld_size * cfg->mfc_no_ld);
1799 1.1 bouyer
1800 1.1 bouyer if (volid < cfg->mfc_no_ld)
1801 1.1 bouyer goto freeme; /* not a hotspare */
1802 1.1 bouyer
1803 1.1 bouyer if (volid > (cfg->mfc_no_ld + cfg->mfc_no_hs))
1804 1.1 bouyer goto freeme; /* not a hotspare */
1805 1.1 bouyer
1806 1.1 bouyer /* offset into hotspare structure */
1807 1.1 bouyer i = volid - cfg->mfc_no_ld;
1808 1.1 bouyer
1809 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_vol_hs i %d volid %d no_ld %d no_hs %d "
1810 1.1 bouyer "hs %p cfg %p id %02x\n", DEVNAME(sc), i, volid, cfg->mfc_no_ld,
1811 1.1 bouyer cfg->mfc_no_hs, hs, cfg, hs[i].mhs_pd.mfp_id);
1812 1.1 bouyer
1813 1.1 bouyer /* get pd fields */
1814 1.1 bouyer memset(mbox, 0, sizeof mbox);
1815 1.1 bouyer *((uint16_t *)&mbox) = hs[i].mhs_pd.mfp_id;
1816 1.1 bouyer if (mfi_mgmt(sc, MR_DCMD_PD_GET_INFO, MFI_DATA_IN,
1817 1.1 bouyer sizeof *pd, pd, mbox)) {
1818 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_vol_hs illegal PD\n",
1819 1.1 bouyer DEVNAME(sc));
1820 1.1 bouyer goto freeme;
1821 1.1 bouyer }
1822 1.1 bouyer
1823 1.1 bouyer switch (type) {
1824 1.1 bouyer case MFI_MGMT_VD:
1825 1.1 bouyer vdhs = bio_hs;
1826 1.1 bouyer vdhs->bv_status = BIOC_SVONLINE;
1827 1.1 bouyer vdhs->bv_size = pd->mpd_size / 2; /* XXX why? / 2 */
1828 1.1 bouyer vdhs->bv_level = -1; /* hotspare */
1829 1.1 bouyer vdhs->bv_nodisk = 1;
1830 1.1 bouyer break;
1831 1.1 bouyer
1832 1.1 bouyer case MFI_MGMT_SD:
1833 1.1 bouyer sdhs = bio_hs;
1834 1.1 bouyer sdhs->bd_status = BIOC_SDHOTSPARE;
1835 1.1 bouyer sdhs->bd_size = pd->mpd_size / 2; /* XXX why? / 2 */
1836 1.1 bouyer sdhs->bd_channel = pd->mpd_enc_idx;
1837 1.1 bouyer sdhs->bd_target = pd->mpd_enc_slot;
1838 1.4 bouyer inqbuf = (struct scsipi_inquiry_data *)&pd->mpd_inq_data;
1839 1.4 bouyer memcpy(vend, inqbuf->vendor, sizeof(vend) - 1);
1840 1.1 bouyer vend[sizeof vend - 1] = '\0';
1841 1.1 bouyer strlcpy(sdhs->bd_vendor, vend, sizeof(sdhs->bd_vendor));
1842 1.1 bouyer break;
1843 1.1 bouyer
1844 1.1 bouyer default:
1845 1.1 bouyer goto freeme;
1846 1.1 bouyer }
1847 1.1 bouyer
1848 1.1 bouyer DNPRINTF(MFI_D_IOCTL, "%s: mfi_vol_hs 6\n", DEVNAME(sc));
1849 1.1 bouyer rv = 0;
1850 1.1 bouyer freeme:
1851 1.1 bouyer free(pd, M_DEVBUF);
1852 1.1 bouyer free(cfg, M_DEVBUF);
1853 1.1 bouyer
1854 1.1 bouyer return (rv);
1855 1.1 bouyer }
1856 1.1 bouyer
1857 1.1 bouyer int
1858 1.1 bouyer mfi_create_sensors(struct mfi_softc *sc)
1859 1.1 bouyer {
1860 1.1 bouyer int i;
1861 1.4 bouyer struct envsys_range env_ranges[2];
1862 1.4 bouyer int nsensors = sc->sc_ld_cnt;
1863 1.1 bouyer
1864 1.4 bouyer env_ranges[0].low = 0;
1865 1.4 bouyer env_ranges[0].high = nsensors;
1866 1.4 bouyer env_ranges[0].units = ENVSYS_DRIVE;
1867 1.4 bouyer env_ranges[1].low = 1;
1868 1.4 bouyer env_ranges[1].high = 0;
1869 1.4 bouyer env_ranges[1].units = 0;
1870 1.4 bouyer
1871 1.4 bouyer sc->sc_sensor_data =
1872 1.4 bouyer malloc(sizeof(struct envsys_tre_data) * nsensors,
1873 1.4 bouyer M_DEVBUF, M_NOWAIT | M_ZERO);
1874 1.4 bouyer if (sc->sc_sensor_data == NULL) {
1875 1.4 bouyer aprint_error("%s: can't allocate envsys_tre_data\n",
1876 1.4 bouyer DEVNAME(sc));
1877 1.4 bouyer return(ENOMEM);
1878 1.4 bouyer }
1879 1.4 bouyer sc->sc_sensor_info =
1880 1.4 bouyer malloc(sizeof(struct envsys_basic_info) * nsensors,
1881 1.4 bouyer M_DEVBUF, M_NOWAIT | M_ZERO);
1882 1.4 bouyer if (sc->sc_sensor_info == NULL) {
1883 1.4 bouyer aprint_error("%s: can't allocate envsys_basic_info\n",
1884 1.4 bouyer DEVNAME(sc));
1885 1.4 bouyer return(ENOMEM);
1886 1.1 bouyer }
1887 1.4 bouyer for (i = 0; i < nsensors; i++) {
1888 1.4 bouyer sc->sc_sensor_data[i].sensor = i;
1889 1.4 bouyer sc->sc_sensor_data[i].units = ENVSYS_DRIVE;
1890 1.4 bouyer sc->sc_sensor_data[i].validflags = ENVSYS_FVALID;
1891 1.4 bouyer sc->sc_sensor_data[i].warnflags = ENVSYS_WARN_OK;
1892 1.4 bouyer sc->sc_sensor_info[i].sensor = i;
1893 1.4 bouyer sc->sc_sensor_info[i].units = ENVSYS_DRIVE;
1894 1.4 bouyer sc->sc_sensor_info[i].validflags = ENVSYS_FVALID;
1895 1.4 bouyer /* logical drives */
1896 1.4 bouyer snprintf(sc->sc_sensor_info[i].desc,
1897 1.4 bouyer sizeof(sc->sc_sensor_info[i].desc), "%s:%d",
1898 1.4 bouyer DEVNAME(sc), i);
1899 1.4 bouyer }
1900 1.4 bouyer sc->sc_ranges = env_ranges;
1901 1.4 bouyer sc->sc_envsys.sme_cookie = sc;
1902 1.4 bouyer sc->sc_envsys.sme_gtredata = mfi_sensor_gtredata;
1903 1.4 bouyer sc->sc_envsys.sme_streinfo = mfi_sensor_streinfo;
1904 1.4 bouyer sc->sc_envsys.sme_nsensors = sc->sc_ld_cnt;
1905 1.4 bouyer sc->sc_envsys.sme_envsys_version = 1000;
1906 1.4 bouyer if (sysmon_envsys_register(&sc->sc_envsys)) {
1907 1.4 bouyer printf("%s: unable to register with sysmon\n", DEVNAME(sc));
1908 1.4 bouyer return(1);
1909 1.1 bouyer }
1910 1.1 bouyer return (0);
1911 1.1 bouyer }
1912 1.1 bouyer
1913 1.4 bouyer int
1914 1.4 bouyer mfi_sensor_gtredata(struct sysmon_envsys *sme, struct envsys_tre_data *tred)
1915 1.1 bouyer {
1916 1.4 bouyer struct mfi_softc *sc = sme->sme_cookie;
1917 1.1 bouyer struct bioc_vol bv;
1918 1.4 bouyer int s;
1919 1.1 bouyer
1920 1.4 bouyer if (tred->sensor >= sc->sc_ld_cnt || tred->sensor < 0)
1921 1.4 bouyer return EINVAL;
1922 1.1 bouyer
1923 1.4 bouyer bzero(&bv, sizeof(bv));
1924 1.4 bouyer bv.bv_volid = tred->sensor;
1925 1.4 bouyer s = splbio();
1926 1.4 bouyer if (mfi_ioctl_vol(sc, &bv)) {
1927 1.4 bouyer splx(s);
1928 1.4 bouyer return EIO;
1929 1.4 bouyer }
1930 1.4 bouyer splx(s);
1931 1.1 bouyer
1932 1.4 bouyer switch(bv.bv_status) {
1933 1.4 bouyer case BIOC_SVOFFLINE:
1934 1.4 bouyer tred->cur.data_us = ENVSYS_DRIVE_FAIL;
1935 1.4 bouyer tred->warnflags = ENVSYS_WARN_CRITOVER;
1936 1.4 bouyer break;
1937 1.1 bouyer
1938 1.4 bouyer case BIOC_SVDEGRADED:
1939 1.4 bouyer tred->cur.data_us = ENVSYS_DRIVE_PFAIL;
1940 1.4 bouyer tred->warnflags = ENVSYS_WARN_OVER;
1941 1.4 bouyer break;
1942 1.1 bouyer
1943 1.4 bouyer case BIOC_SVSCRUB:
1944 1.4 bouyer case BIOC_SVONLINE:
1945 1.4 bouyer tred->cur.data_us = ENVSYS_DRIVE_ONLINE;
1946 1.4 bouyer tred->warnflags = ENVSYS_WARN_OK;
1947 1.4 bouyer break;
1948 1.1 bouyer
1949 1.4 bouyer case BIOC_SVINVALID:
1950 1.4 bouyer /* FALLTRHOUGH */
1951 1.4 bouyer default:
1952 1.4 bouyer tred->cur.data_us = 0; /* unknown */
1953 1.4 bouyer tred->warnflags = ENVSYS_WARN_CRITOVER;
1954 1.1 bouyer }
1955 1.4 bouyer tred->validflags = ENVSYS_FVALID | ENVSYS_FCURVALID;
1956 1.4 bouyer tred->units = ENVSYS_DRIVE;
1957 1.4 bouyer return 0;
1958 1.4 bouyer }
1959 1.4 bouyer
1960 1.4 bouyer int
1961 1.4 bouyer mfi_sensor_streinfo(struct sysmon_envsys *sme, struct envsys_basic_info *binfo)
1962 1.4 bouyer {
1963 1.4 bouyer binfo->validflags = 0;
1964 1.4 bouyer return 0;
1965 1.1 bouyer }
1966 1.1 bouyer #endif /* NBIO > 0 */
1967