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