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