File: | dev/ic/ami.c |
Warning: | line 523, column 2 8th function call argument is an uninitialized value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: ami.c,v 1.261 2022/01/09 05:42:38 jsg Exp $ */ | |||
2 | ||||
3 | /* | |||
4 | * Copyright (c) 2001 Michael Shalayeff | |||
5 | * Copyright (c) 2005 Marco Peereboom | |||
6 | * Copyright (c) 2006 David Gwynne | |||
7 | * All rights reserved. | |||
8 | * | |||
9 | * The SCSI emulation layer is derived from gdt(4) driver, | |||
10 | * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved. | |||
11 | * | |||
12 | * Redistribution and use in source and binary forms, with or without | |||
13 | * modification, are permitted provided that the following conditions | |||
14 | * are met: | |||
15 | * 1. Redistributions of source code must retain the above copyright | |||
16 | * notice, this list of conditions and the following disclaimer. | |||
17 | * 2. Redistributions in binary form must reproduce the above copyright | |||
18 | * notice, this list of conditions and the following disclaimer in the | |||
19 | * documentation and/or other materials provided with the distribution. | |||
20 | * | |||
21 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR | |||
22 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |||
23 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |||
24 | * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT, | |||
25 | * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |||
26 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |||
27 | * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |||
29 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |||
30 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | |||
31 | * THE POSSIBILITY OF SUCH DAMAGE. | |||
32 | */ | |||
33 | /* | |||
34 | * American Megatrends Inc. MegaRAID controllers driver | |||
35 | * | |||
36 | * This driver was made because these ppl and organizations | |||
37 | * donated hardware and provided documentation: | |||
38 | * | |||
39 | * - 428 model card | |||
40 | * John Kerbawy, Stephan Matis, Mark Stovall; | |||
41 | * | |||
42 | * - 467 and 475 model cards, docs | |||
43 | * American Megatrends Inc.; | |||
44 | * | |||
45 | * - uninterruptible electric power for cvs | |||
46 | * Theo de Raadt. | |||
47 | */ | |||
48 | ||||
49 | #include "bio.h" | |||
50 | ||||
51 | /* #define AMI_DEBUG */ | |||
52 | ||||
53 | #include <sys/param.h> | |||
54 | #include <sys/systm.h> | |||
55 | #include <sys/buf.h> | |||
56 | #include <sys/ioctl.h> | |||
57 | #include <sys/device.h> | |||
58 | #include <sys/kernel.h> | |||
59 | #include <sys/malloc.h> | |||
60 | #include <sys/rwlock.h> | |||
61 | #include <sys/pool.h> | |||
62 | #include <sys/sensors.h> | |||
63 | ||||
64 | #include <machine/bus.h> | |||
65 | ||||
66 | #include <scsi/scsi_all.h> | |||
67 | #include <scsi/scsi_disk.h> | |||
68 | #include <scsi/scsiconf.h> | |||
69 | ||||
70 | #include <dev/biovar.h> | |||
71 | #include <dev/ic/amireg.h> | |||
72 | #include <dev/ic/amivar.h> | |||
73 | ||||
74 | #ifdef AMI_DEBUG | |||
75 | #define AMI_DPRINTF(m,a) do { if (ami_debug & (m)) printf a; } while (0) | |||
76 | #define AMI_D_CMD 0x0001 | |||
77 | #define AMI_D_INTR 0x0002 | |||
78 | #define AMI_D_MISC 0x0004 | |||
79 | #define AMI_D_DMA 0x0008 | |||
80 | #define AMI_D_IOCTL 0x0010 | |||
81 | int ami_debug = 0 | |||
82 | /* | AMI_D_CMD */ | |||
83 | /* | AMI_D_INTR */ | |||
84 | /* | AMI_D_MISC */ | |||
85 | /* | AMI_D_DMA */ | |||
86 | /* | AMI_D_IOCTL */ | |||
87 | ; | |||
88 | #else | |||
89 | #define AMI_DPRINTF(m,a) /* m, a */ | |||
90 | #endif | |||
91 | ||||
92 | struct cfdriver ami_cd = { | |||
93 | NULL((void *)0), "ami", DV_DULL | |||
94 | }; | |||
95 | ||||
96 | void ami_scsi_cmd(struct scsi_xfer *); | |||
97 | int ami_scsi_ioctl(struct scsi_link *, u_long, caddr_t, int); | |||
98 | ||||
99 | struct scsi_adapter ami_switch = { | |||
100 | ami_scsi_cmd, NULL((void *)0), NULL((void *)0), NULL((void *)0), ami_scsi_ioctl | |||
101 | }; | |||
102 | ||||
103 | void ami_scsi_raw_cmd(struct scsi_xfer *); | |||
104 | ||||
105 | struct scsi_adapter ami_raw_switch = { | |||
106 | ami_scsi_raw_cmd, NULL((void *)0), NULL((void *)0), NULL((void *)0), NULL((void *)0) | |||
107 | }; | |||
108 | ||||
109 | void * ami_get_ccb(void *); | |||
110 | void ami_put_ccb(void *, void *); | |||
111 | ||||
112 | u_int32_t ami_read(struct ami_softc *, bus_size_t); | |||
113 | void ami_write(struct ami_softc *, bus_size_t, u_int32_t); | |||
114 | ||||
115 | void ami_copyhds(struct ami_softc *, const u_int32_t *, | |||
116 | const u_int8_t *, const u_int8_t *); | |||
117 | struct ami_mem *ami_allocmem(struct ami_softc *, size_t); | |||
118 | void ami_freemem(struct ami_softc *, struct ami_mem *); | |||
119 | int ami_alloc_ccbs(struct ami_softc *, int); | |||
120 | ||||
121 | int ami_poll(struct ami_softc *, struct ami_ccb *); | |||
122 | void ami_start(struct ami_softc *, struct ami_ccb *); | |||
123 | void ami_complete(struct ami_softc *, struct ami_ccb *, int); | |||
124 | void ami_runqueue_tick(void *); | |||
125 | void ami_runqueue(struct ami_softc *); | |||
126 | ||||
127 | void ami_start_xs(struct ami_softc *sc, struct ami_ccb *, | |||
128 | struct scsi_xfer *); | |||
129 | void ami_done_xs(struct ami_softc *, struct ami_ccb *); | |||
130 | void ami_done_pt(struct ami_softc *, struct ami_ccb *); | |||
131 | void ami_done_flush(struct ami_softc *, struct ami_ccb *); | |||
132 | void ami_done_sysflush(struct ami_softc *, struct ami_ccb *); | |||
133 | ||||
134 | void ami_done_dummy(struct ami_softc *, struct ami_ccb *); | |||
135 | void ami_done_ioctl(struct ami_softc *, struct ami_ccb *); | |||
136 | void ami_done_init(struct ami_softc *, struct ami_ccb *); | |||
137 | ||||
138 | int ami_load_ptmem(struct ami_softc*, struct ami_ccb *, | |||
139 | void *, size_t, int, int); | |||
140 | ||||
141 | #if NBIO1 > 0 | |||
142 | int ami_mgmt(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t, | |||
143 | u_int8_t, size_t, void *); | |||
144 | int ami_drv_pt(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t *, | |||
145 | int, int, void *); | |||
146 | int ami_drv_readcap(struct ami_softc *, u_int8_t, u_int8_t, | |||
147 | daddr_t *); | |||
148 | int ami_drv_inq(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t, | |||
149 | void *); | |||
150 | int ami_ioctl(struct device *, u_long, caddr_t); | |||
151 | int ami_ioctl_inq(struct ami_softc *, struct bioc_inq *); | |||
152 | int ami_vol(struct ami_softc *, struct bioc_vol *, | |||
153 | struct ami_big_diskarray *); | |||
154 | int ami_disk(struct ami_softc *, struct bioc_disk *, | |||
155 | struct ami_big_diskarray *); | |||
156 | int ami_ioctl_vol(struct ami_softc *, struct bioc_vol *); | |||
157 | int ami_ioctl_disk(struct ami_softc *, struct bioc_disk *); | |||
158 | int ami_ioctl_alarm(struct ami_softc *, struct bioc_alarm *); | |||
159 | int ami_ioctl_setstate(struct ami_softc *, struct bioc_setstate *); | |||
160 | ||||
161 | #ifndef SMALL_KERNEL | |||
162 | int ami_create_sensors(struct ami_softc *); | |||
163 | void ami_refresh_sensors(void *); | |||
164 | #endif | |||
165 | #endif /* NBIO > 0 */ | |||
166 | ||||
167 | #define DEVNAME(_s)((_s)->sc_dev.dv_xname) ((_s)->sc_dev.dv_xname) | |||
168 | ||||
169 | void * | |||
170 | ami_get_ccb(void *xsc) | |||
171 | { | |||
172 | struct ami_softc *sc = xsc; | |||
173 | struct ami_ccb *ccb; | |||
174 | ||||
175 | mtx_enter(&sc->sc_ccb_freeq_mtx); | |||
176 | ccb = TAILQ_FIRST(&sc->sc_ccb_freeq)((&sc->sc_ccb_freeq)->tqh_first); | |||
177 | if (ccb != NULL((void *)0)) { | |||
178 | TAILQ_REMOVE(&sc->sc_ccb_freeq, ccb, ccb_link)do { if (((ccb)->ccb_link.tqe_next) != ((void *)0)) (ccb)-> ccb_link.tqe_next->ccb_link.tqe_prev = (ccb)->ccb_link. tqe_prev; else (&sc->sc_ccb_freeq)->tqh_last = (ccb )->ccb_link.tqe_prev; *(ccb)->ccb_link.tqe_prev = (ccb) ->ccb_link.tqe_next; ((ccb)->ccb_link.tqe_prev) = ((void *)-1); ((ccb)->ccb_link.tqe_next) = ((void *)-1); } while (0); | |||
179 | ccb->ccb_state = AMI_CCB_READY; | |||
180 | } | |||
181 | mtx_leave(&sc->sc_ccb_freeq_mtx); | |||
182 | ||||
183 | return (ccb); | |||
184 | } | |||
185 | ||||
186 | void | |||
187 | ami_put_ccb(void *xsc, void *xccb) | |||
188 | { | |||
189 | struct ami_softc *sc = xsc; | |||
190 | struct ami_ccb *ccb = xccb; | |||
191 | ||||
192 | ccb->ccb_state = AMI_CCB_FREE; | |||
193 | ccb->ccb_xs = NULL((void *)0); | |||
194 | ccb->ccb_flags = 0; | |||
195 | ccb->ccb_done = NULL((void *)0); | |||
196 | ||||
197 | mtx_enter(&sc->sc_ccb_freeq_mtx); | |||
198 | TAILQ_INSERT_TAIL(&sc->sc_ccb_freeq, ccb, ccb_link)do { (ccb)->ccb_link.tqe_next = ((void *)0); (ccb)->ccb_link .tqe_prev = (&sc->sc_ccb_freeq)->tqh_last; *(&sc ->sc_ccb_freeq)->tqh_last = (ccb); (&sc->sc_ccb_freeq )->tqh_last = &(ccb)->ccb_link.tqe_next; } while (0 ); | |||
199 | mtx_leave(&sc->sc_ccb_freeq_mtx); | |||
200 | } | |||
201 | ||||
202 | u_int32_t | |||
203 | ami_read(struct ami_softc *sc, bus_size_t r) | |||
204 | { | |||
205 | u_int32_t rv; | |||
206 | ||||
207 | bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4, | |||
208 | BUS_SPACE_BARRIER_READ0x01); | |||
209 | rv = bus_space_read_4(sc->sc_iot, sc->sc_ioh, r)((sc->sc_iot)->read_4((sc->sc_ioh), (r))); | |||
210 | ||||
211 | AMI_DPRINTF(AMI_D_CMD, ("ari 0x%lx 0x08%x ", r, rv)); | |||
212 | return (rv); | |||
213 | } | |||
214 | ||||
215 | void | |||
216 | ami_write(struct ami_softc *sc, bus_size_t r, u_int32_t v) | |||
217 | { | |||
218 | AMI_DPRINTF(AMI_D_CMD, ("awo 0x%lx 0x%08x ", r, v)); | |||
219 | ||||
220 | bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v)((sc->sc_iot)->write_4((sc->sc_ioh), (r), (v))); | |||
221 | bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4, | |||
222 | BUS_SPACE_BARRIER_WRITE0x02); | |||
223 | } | |||
224 | ||||
225 | struct ami_mem * | |||
226 | ami_allocmem(struct ami_softc *sc, size_t size) | |||
227 | { | |||
228 | struct ami_mem *am; | |||
229 | int nsegs; | |||
230 | ||||
231 | am = malloc(sizeof(struct ami_mem), M_DEVBUF2, M_NOWAIT0x0002|M_ZERO0x0008); | |||
232 | if (am == NULL((void *)0)) | |||
233 | return (NULL((void *)0)); | |||
234 | ||||
235 | am->am_size = size; | |||
236 | ||||
237 | if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), (size ), (1), (size), (0), (0x0001 | 0x0002), (&am->am_map)) | |||
238 | BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &am->am_map)(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), (size ), (1), (size), (0), (0x0001 | 0x0002), (&am->am_map)) != 0) | |||
239 | goto amfree; | |||
240 | ||||
241 | if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &am->am_seg, 1,(*(sc->sc_dmat)->_dmamem_alloc)((sc->sc_dmat), (size ), ((1 << 12)), (0), (&am->am_seg), (1), (&nsegs ), (0x0001 | 0x1000)) | |||
242 | &nsegs, BUS_DMA_NOWAIT | BUS_DMA_ZERO)(*(sc->sc_dmat)->_dmamem_alloc)((sc->sc_dmat), (size ), ((1 << 12)), (0), (&am->am_seg), (1), (&nsegs ), (0x0001 | 0x1000)) != 0) | |||
243 | goto destroy; | |||
244 | ||||
245 | if (bus_dmamem_map(sc->sc_dmat, &am->am_seg, nsegs, size, &am->am_kva,(*(sc->sc_dmat)->_dmamem_map)((sc->sc_dmat), (&am ->am_seg), (nsegs), (size), (&am->am_kva), (0x0001) ) | |||
246 | BUS_DMA_NOWAIT)(*(sc->sc_dmat)->_dmamem_map)((sc->sc_dmat), (&am ->am_seg), (nsegs), (size), (&am->am_kva), (0x0001) ) != 0) | |||
247 | goto free; | |||
248 | ||||
249 | if (bus_dmamap_load(sc->sc_dmat, am->am_map, am->am_kva, size, NULL,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (am-> am_map), (am->am_kva), (size), (((void *)0)), (0x0001)) | |||
250 | BUS_DMA_NOWAIT)(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (am-> am_map), (am->am_kva), (size), (((void *)0)), (0x0001)) != 0) | |||
251 | goto unmap; | |||
252 | ||||
253 | return (am); | |||
254 | ||||
255 | unmap: | |||
256 | bus_dmamem_unmap(sc->sc_dmat, am->am_kva, size)(*(sc->sc_dmat)->_dmamem_unmap)((sc->sc_dmat), (am-> am_kva), (size)); | |||
257 | free: | |||
258 | bus_dmamem_free(sc->sc_dmat, &am->am_seg, 1)(*(sc->sc_dmat)->_dmamem_free)((sc->sc_dmat), (& am->am_seg), (1)); | |||
259 | destroy: | |||
260 | bus_dmamap_destroy(sc->sc_dmat, am->am_map)(*(sc->sc_dmat)->_dmamap_destroy)((sc->sc_dmat), (am ->am_map)); | |||
261 | amfree: | |||
262 | free(am, M_DEVBUF2, sizeof *am); | |||
263 | ||||
264 | return (NULL((void *)0)); | |||
265 | } | |||
266 | ||||
267 | void | |||
268 | ami_freemem(struct ami_softc *sc, struct ami_mem *am) | |||
269 | { | |||
270 | bus_dmamap_unload(sc->sc_dmat, am->am_map)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (am-> am_map)); | |||
271 | bus_dmamem_unmap(sc->sc_dmat, am->am_kva, am->am_size)(*(sc->sc_dmat)->_dmamem_unmap)((sc->sc_dmat), (am-> am_kva), (am->am_size)); | |||
272 | bus_dmamem_free(sc->sc_dmat, &am->am_seg, 1)(*(sc->sc_dmat)->_dmamem_free)((sc->sc_dmat), (& am->am_seg), (1)); | |||
273 | bus_dmamap_destroy(sc->sc_dmat, am->am_map)(*(sc->sc_dmat)->_dmamap_destroy)((sc->sc_dmat), (am ->am_map)); | |||
274 | free(am, M_DEVBUF2, sizeof *am); | |||
275 | } | |||
276 | ||||
277 | void | |||
278 | ami_copyhds(struct ami_softc *sc, const u_int32_t *sizes, | |||
279 | const u_int8_t *props, const u_int8_t *stats) | |||
280 | { | |||
281 | int i; | |||
282 | ||||
283 | for (i = 0; i < sc->sc_nunits; i++) { | |||
284 | sc->sc_hdr[i].hd_present = 1; | |||
285 | sc->sc_hdr[i].hd_is_logdrv = 1; | |||
286 | sc->sc_hdr[i].hd_size = letoh32(sizes[i])((__uint32_t)(sizes[i])); | |||
287 | sc->sc_hdr[i].hd_prop = props[i]; | |||
288 | sc->sc_hdr[i].hd_stat = stats[i]; | |||
289 | } | |||
290 | } | |||
291 | ||||
292 | int | |||
293 | ami_alloc_ccbs(struct ami_softc *sc, int nccbs) | |||
294 | { | |||
295 | struct ami_ccb *ccb; | |||
296 | struct ami_ccbmem *ccbmem, *mem; | |||
297 | int i, error; | |||
298 | ||||
299 | sc->sc_ccbs = mallocarray(nccbs, sizeof(struct ami_ccb), | |||
300 | M_DEVBUF2, M_NOWAIT0x0002); | |||
301 | if (sc->sc_ccbs == NULL((void *)0)) { | |||
302 | printf(": unable to allocate ccbs\n"); | |||
303 | return (1); | |||
304 | } | |||
305 | ||||
306 | sc->sc_ccbmem_am = ami_allocmem(sc, sizeof(struct ami_ccbmem) * nccbs); | |||
307 | if (sc->sc_ccbmem_am == NULL((void *)0)) { | |||
308 | printf(": unable to allocate ccb dmamem\n"); | |||
309 | goto free_ccbs; | |||
310 | } | |||
311 | ccbmem = AMIMEM_KVA(sc->sc_ccbmem_am)((void *)(sc->sc_ccbmem_am)->am_kva); | |||
312 | ||||
313 | TAILQ_INIT(&sc->sc_ccb_freeq)do { (&sc->sc_ccb_freeq)->tqh_first = ((void *)0); ( &sc->sc_ccb_freeq)->tqh_last = &(&sc->sc_ccb_freeq )->tqh_first; } while (0); | |||
314 | mtx_init(&sc->sc_ccb_freeq_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sc-> sc_ccb_freeq_mtx), ((((0x6)) > 0x0 && ((0x6)) < 0x9) ? 0x9 : ((0x6)))); } while (0); | |||
315 | TAILQ_INIT(&sc->sc_ccb_preq)do { (&sc->sc_ccb_preq)->tqh_first = ((void *)0); ( &sc->sc_ccb_preq)->tqh_last = &(&sc->sc_ccb_preq )->tqh_first; } while (0); | |||
316 | TAILQ_INIT(&sc->sc_ccb_runq)do { (&sc->sc_ccb_runq)->tqh_first = ((void *)0); ( &sc->sc_ccb_runq)->tqh_last = &(&sc->sc_ccb_runq )->tqh_first; } while (0); | |||
317 | timeout_set(&sc->sc_run_tmo, ami_runqueue_tick, sc); | |||
318 | ||||
319 | scsi_iopool_init(&sc->sc_iopool, sc, ami_get_ccb, ami_put_ccb); | |||
320 | ||||
321 | for (i = 0; i < nccbs; i++) { | |||
322 | ccb = &sc->sc_ccbs[i]; | |||
323 | mem = &ccbmem[i]; | |||
324 | ||||
325 | error = bus_dmamap_create(sc->sc_dmat, AMI_MAXFER,(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), ((26 * (1 << 12))), (26), ((26 * (1 << 12))), (0), (0x0001 | 0x0002), (&ccb->ccb_dmamap)) | |||
326 | AMI_MAXOFFSETS, AMI_MAXFER, 0,(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), ((26 * (1 << 12))), (26), ((26 * (1 << 12))), (0), (0x0001 | 0x0002), (&ccb->ccb_dmamap)) | |||
327 | BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_create)((sc->sc_dmat), ((26 * (1 << 12))), (26), ((26 * (1 << 12))), (0), (0x0001 | 0x0002), (&ccb->ccb_dmamap)); | |||
328 | if (error) { | |||
329 | printf(": cannot create ccb dmamap (%d)\n", error); | |||
330 | goto free_list; | |||
331 | } | |||
332 | ||||
333 | ccb->ccb_sc = sc; | |||
334 | ||||
335 | ccb->ccb_cmd.acc_id = i + 1; | |||
336 | ccb->ccb_offset = sizeof(struct ami_ccbmem) * i; | |||
337 | ||||
338 | ccb->ccb_pt = &mem->cd_pt; | |||
339 | ccb->ccb_ptpa = htole32(AMIMEM_DVA(sc->sc_ccbmem_am) +((__uint32_t)(((sc->sc_ccbmem_am)->am_map->dm_segs[0 ].ds_addr) + ccb->ccb_offset)) | |||
340 | ccb->ccb_offset)((__uint32_t)(((sc->sc_ccbmem_am)->am_map->dm_segs[0 ].ds_addr) + ccb->ccb_offset)); | |||
341 | ||||
342 | ccb->ccb_sglist = mem->cd_sg; | |||
343 | ccb->ccb_sglistpa = htole32(AMIMEM_DVA(sc->sc_ccbmem_am) +((__uint32_t)(((sc->sc_ccbmem_am)->am_map->dm_segs[0 ].ds_addr) + ccb->ccb_offset + sizeof(struct ami_passthrough ))) | |||
344 | ccb->ccb_offset + sizeof(struct ami_passthrough))((__uint32_t)(((sc->sc_ccbmem_am)->am_map->dm_segs[0 ].ds_addr) + ccb->ccb_offset + sizeof(struct ami_passthrough ))); | |||
345 | ||||
346 | /* override last command for management */ | |||
347 | if (i == nccbs - 1) { | |||
348 | ccb->ccb_cmd.acc_id = 0xfe; | |||
349 | sc->sc_mgmtccb = ccb; | |||
350 | } else { | |||
351 | ami_put_ccb(sc, ccb); | |||
352 | } | |||
353 | } | |||
354 | ||||
355 | return (0); | |||
356 | ||||
357 | free_list: | |||
358 | while ((ccb = ami_get_ccb(sc)) != NULL((void *)0)) | |||
359 | bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_destroy)((sc->sc_dmat), (ccb ->ccb_dmamap)); | |||
360 | ||||
361 | ami_freemem(sc, sc->sc_ccbmem_am); | |||
362 | free_ccbs: | |||
363 | free(sc->sc_ccbs, M_DEVBUF2, 0); | |||
364 | ||||
365 | return (1); | |||
366 | } | |||
367 | ||||
368 | int | |||
369 | ami_attach(struct ami_softc *sc) | |||
370 | { | |||
371 | struct scsibus_attach_args saa; | |||
372 | struct ami_rawsoftc *rsc; | |||
373 | struct ami_ccb iccb; | |||
374 | struct ami_iocmd *cmd; | |||
375 | struct ami_mem *am; | |||
376 | struct ami_inquiry *inq; | |||
377 | struct ami_fc_einquiry *einq; | |||
378 | struct ami_fc_prodinfo *pi; | |||
379 | const char *p; | |||
| ||||
380 | paddr_t pa; | |||
381 | ||||
382 | mtx_init(&sc->sc_cmd_mtx, IPL_BIO)do { (void)(((void *)0)); (void)(0); __mtx_init((&sc-> sc_cmd_mtx), ((((0x6)) > 0x0 && ((0x6)) < 0x9) ? 0x9 : ((0x6)))); } while (0); | |||
383 | ||||
384 | am = ami_allocmem(sc, NBPG(1 << 12)); | |||
385 | if (am
| |||
386 | printf(": unable to allocate init data\n"); | |||
387 | return (1); | |||
388 | } | |||
389 | pa = htole32(AMIMEM_DVA(am))((__uint32_t)(((am)->am_map->dm_segs[0].ds_addr))); | |||
390 | ||||
391 | sc->sc_mbox_am = ami_allocmem(sc, sizeof(struct ami_iocmd)); | |||
392 | if (sc->sc_mbox_am
| |||
393 | printf(": unable to allocate mbox\n"); | |||
394 | goto free_idata; | |||
395 | } | |||
396 | sc->sc_mbox = (volatile struct ami_iocmd *)AMIMEM_KVA(sc->sc_mbox_am)((void *)(sc->sc_mbox_am)->am_kva); | |||
397 | sc->sc_mbox_pa = htole32(AMIMEM_DVA(sc->sc_mbox_am))((__uint32_t)(((sc->sc_mbox_am)->am_map->dm_segs[0]. ds_addr))); | |||
398 | AMI_DPRINTF(AMI_D_CMD, ("mbox=%p ", sc->sc_mbox)); | |||
399 | AMI_DPRINTF(AMI_D_CMD, ("mbox_pa=0x%llx ", (long long)sc->sc_mbox_pa)); | |||
400 | ||||
401 | /* create a spartan ccb for use with ami_poll */ | |||
402 | bzero(&iccb, sizeof(iccb))__builtin_bzero((&iccb), (sizeof(iccb))); | |||
403 | iccb.ccb_sc = sc; | |||
404 | iccb.ccb_done = ami_done_init; | |||
405 | cmd = &iccb.ccb_cmd; | |||
406 | ||||
407 | (sc->sc_init)(sc); | |||
408 | ||||
409 | /* try FC inquiry first */ | |||
410 | cmd->acc_cmd = AMI_FCOP0xa1; | |||
411 | cmd->acc_io_._ami_io.aio_channel = AMI_FC_EINQ30x0f; | |||
412 | cmd->acc_io_._ami_io.aio_param = AMI_FC_EINQ3_SOLICITED_FULL0x02; | |||
413 | cmd->acc_io_._ami_io.aio_data = pa; | |||
414 | if (ami_poll(sc, &iccb) == 0) { | |||
415 | einq = AMIMEM_KVA(am)((void *)(am)->am_kva); | |||
416 | pi = AMIMEM_KVA(am)((void *)(am)->am_kva); | |||
417 | ||||
418 | sc->sc_nunits = einq->ain_nlogdrv; | |||
419 | sc->sc_drvinscnt = einq->ain_drvinscnt + 1; /* force scan */ | |||
420 | ami_copyhds(sc, einq->ain_ldsize, einq->ain_ldprop, | |||
421 | einq->ain_ldstat); | |||
422 | ||||
423 | cmd->acc_cmd = AMI_FCOP0xa1; | |||
424 | cmd->acc_io_._ami_io.aio_channel = AMI_FC_PRODINF0x0e; | |||
425 | cmd->acc_io_._ami_io.aio_param = 0; | |||
426 | cmd->acc_io_._ami_io.aio_data = pa; | |||
427 | if (ami_poll(sc, &iccb) == 0) { | |||
428 | sc->sc_maxunits = AMI_BIG_MAX_LDRIVES40; | |||
429 | ||||
430 | bcopy (pi->api_fwver, sc->sc_fwver, 16); | |||
431 | sc->sc_fwver[15] = '\0'; | |||
432 | bcopy (pi->api_biosver, sc->sc_biosver, 16); | |||
433 | sc->sc_biosver[15] = '\0'; | |||
434 | sc->sc_channels = pi->api_channels; | |||
435 | sc->sc_targets = pi->api_fcloops; | |||
436 | sc->sc_memory = letoh16(pi->api_ramsize)((__uint16_t)(pi->api_ramsize)); | |||
437 | sc->sc_maxcmds = pi->api_maxcmd; | |||
438 | p = "FC loop"; | |||
439 | } | |||
440 | } | |||
441 | ||||
442 | if (sc->sc_maxunits == 0) { | |||
443 | inq = AMIMEM_KVA(am)((void *)(am)->am_kva); | |||
444 | ||||
445 | cmd->acc_cmd = AMI_EINQUIRY0x04; | |||
446 | cmd->acc_io_._ami_io.aio_channel = 0; | |||
447 | cmd->acc_io_._ami_io.aio_param = 0; | |||
448 | cmd->acc_io_._ami_io.aio_data = pa; | |||
449 | if (ami_poll(sc, &iccb) != 0) { | |||
450 | cmd->acc_cmd = AMI_INQUIRY0x05; | |||
451 | cmd->acc_io_._ami_io.aio_channel = 0; | |||
452 | cmd->acc_io_._ami_io.aio_param = 0; | |||
453 | cmd->acc_io_._ami_io.aio_data = pa; | |||
454 | if (ami_poll(sc, &iccb) != 0) { | |||
455 | printf(": cannot do inquiry\n"); | |||
456 | goto free_mbox; | |||
457 | } | |||
458 | } | |||
459 | ||||
460 | sc->sc_maxunits = AMI_MAX_LDRIVES8; | |||
461 | sc->sc_nunits = inq->ain_nlogdrv; | |||
462 | ami_copyhds(sc, inq->ain_ldsize, inq->ain_ldprop, | |||
463 | inq->ain_ldstat); | |||
464 | ||||
465 | bcopy (inq->ain_fwver, sc->sc_fwver, 4); | |||
466 | sc->sc_fwver[4] = '\0'; | |||
467 | bcopy (inq->ain_biosver, sc->sc_biosver, 4); | |||
468 | sc->sc_biosver[4] = '\0'; | |||
469 | sc->sc_channels = inq->ain_channels; | |||
470 | sc->sc_targets = inq->ain_targets; | |||
471 | sc->sc_memory = inq->ain_ramsize; | |||
472 | sc->sc_maxcmds = inq->ain_maxcmd; | |||
473 | sc->sc_drvinscnt = inq->ain_drvinscnt + 1; /* force scan */ | |||
474 | p = "target"; | |||
475 | } | |||
476 | ||||
477 | if (sc->sc_flags & AMI_BROKEN0x0002) { | |||
478 | sc->sc_maxcmds = 1; | |||
479 | sc->sc_maxunits = 1; | |||
480 | } else { | |||
481 | sc->sc_maxunits = AMI_BIG_MAX_LDRIVES40; | |||
482 | if (sc->sc_maxcmds > AMI_MAXCMDS126) | |||
483 | sc->sc_maxcmds = AMI_MAXCMDS126; | |||
484 | /* | |||
485 | * Reserve ccb's for ioctl's and raw commands to | |||
486 | * processors/enclosures by lowering the number of | |||
487 | * openings available for logical units. | |||
488 | */ | |||
489 | sc->sc_maxcmds -= AMI_MAXIOCTLCMDS1 + AMI_MAXPROCS2 * | |||
490 | AMI_MAXRAWCMDS2 * sc->sc_channels; | |||
491 | } | |||
492 | ||||
493 | if (ami_alloc_ccbs(sc, AMI_MAXCMDS126 + 1) != 0) { | |||
494 | /* error already printed */ | |||
495 | goto free_mbox; | |||
496 | } | |||
497 | ||||
498 | ami_freemem(sc, am); | |||
499 | ||||
500 | /* hack for hp netraid version encoding */ | |||
501 | if ('A' <= sc->sc_fwver[2] && sc->sc_fwver[2] <= 'Z' && | |||
502 | sc->sc_fwver[1] < ' ' && sc->sc_fwver[0] < ' ' && | |||
503 | 'A' <= sc->sc_biosver[2] && sc->sc_biosver[2] <= 'Z' && | |||
504 | sc->sc_biosver[1] < ' ' && sc->sc_biosver[0] < ' ') { | |||
505 | ||||
506 | snprintf(sc->sc_fwver, sizeof sc->sc_fwver, "%c.%02d.%02d", | |||
507 | sc->sc_fwver[2], sc->sc_fwver[1], sc->sc_fwver[0]); | |||
508 | snprintf(sc->sc_biosver, sizeof sc->sc_biosver, "%c.%02d.%02d", | |||
509 | sc->sc_biosver[2], sc->sc_biosver[1], sc->sc_biosver[0]); | |||
510 | } | |||
511 | ||||
512 | /* TODO: fetch & print cache strategy */ | |||
513 | /* TODO: fetch & print scsi and raid info */ | |||
514 | ||||
515 | #ifdef AMI_DEBUG | |||
516 | printf(", FW %s, BIOS v%s, %dMB RAM\n" | |||
517 | "%s: %d channels, %d %ss, %d logical drives, " | |||
518 | "max commands %d, quirks: %04x\n", | |||
519 | sc->sc_fwver, sc->sc_biosver, sc->sc_memory, DEVNAME(sc)((sc)->sc_dev.dv_xname), | |||
520 | sc->sc_channels, sc->sc_targets, p, sc->sc_nunits, | |||
521 | sc->sc_maxcmds, sc->sc_flags); | |||
522 | #else | |||
523 | printf(", FW %s, BIOS v%s, %dMB RAM\n" | |||
| ||||
524 | "%s: %d channels, %d %ss, %d logical drives\n", | |||
525 | sc->sc_fwver, sc->sc_biosver, sc->sc_memory, DEVNAME(sc)((sc)->sc_dev.dv_xname), | |||
526 | sc->sc_channels, sc->sc_targets, p, sc->sc_nunits); | |||
527 | #endif /* AMI_DEBUG */ | |||
528 | ||||
529 | if (sc->sc_flags & AMI_BROKEN0x0002 && sc->sc_nunits > 1) | |||
530 | printf("%s: firmware buggy, limiting access to first logical " | |||
531 | "disk\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
532 | ||||
533 | /* lock around ioctl requests */ | |||
534 | rw_init(&sc->sc_lock, NULL)_rw_init_flags(&sc->sc_lock, ((void *)0), 0, ((void *) 0)); | |||
535 | ||||
536 | saa.saa_adapter_softc = sc; | |||
537 | saa.saa_adapter = &ami_switch; | |||
538 | saa.saa_adapter_target = SDEV_NO_ADAPTER_TARGET0xffff; | |||
539 | saa.saa_adapter_buswidth = sc->sc_maxunits; | |||
540 | saa.saa_luns = 8; | |||
541 | saa.saa_openings = sc->sc_maxcmds; | |||
542 | saa.saa_pool = &sc->sc_iopool; | |||
543 | saa.saa_quirks = saa.saa_flags = 0; | |||
544 | saa.saa_wwpn = saa.saa_wwnn = 0; | |||
545 | ||||
546 | sc->sc_scsibus = (struct scsibus_softc *)config_found(&sc->sc_dev, &saa,config_found_sm((&sc->sc_dev), (&saa), (scsiprint) , ((void *)0)) | |||
547 | scsiprint)config_found_sm((&sc->sc_dev), (&saa), (scsiprint) , ((void *)0)); | |||
548 | ||||
549 | /* can't do bioctls, sensors, or pass-through on broken devices */ | |||
550 | if (sc->sc_flags & AMI_BROKEN0x0002) | |||
551 | return (0); | |||
552 | ||||
553 | #if NBIO1 > 0 | |||
554 | if (bio_register(&sc->sc_dev, ami_ioctl) != 0) | |||
555 | printf("%s: controller registration failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
556 | else | |||
557 | sc->sc_ioctl = ami_ioctl; | |||
558 | ||||
559 | #ifndef SMALL_KERNEL | |||
560 | if (ami_create_sensors(sc) != 0) | |||
561 | printf("%s: unable to create sensors\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
562 | #endif | |||
563 | #endif | |||
564 | ||||
565 | rsc = mallocarray(sc->sc_channels, sizeof(struct ami_rawsoftc), | |||
566 | M_DEVBUF2, M_NOWAIT0x0002|M_ZERO0x0008); | |||
567 | if (!rsc) { | |||
568 | printf("%s: no memory for raw interface\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
569 | return (0); | |||
570 | } | |||
571 | ||||
572 | for (sc->sc_rawsoftcs = rsc; | |||
573 | rsc < &sc->sc_rawsoftcs[sc->sc_channels]; rsc++) { | |||
574 | ||||
575 | struct scsibus_softc *ptbus; | |||
576 | struct scsi_link *proclink; | |||
577 | struct device *procdev; | |||
578 | ||||
579 | rsc->sc_softc = sc; | |||
580 | rsc->sc_channel = rsc - sc->sc_rawsoftcs; | |||
581 | rsc->sc_proctarget = -1; | |||
582 | ||||
583 | /* TODO fetch adapter_target from the controller */ | |||
584 | ||||
585 | saa.saa_adapter_softc = rsc; | |||
586 | saa.saa_adapter = &ami_raw_switch; | |||
587 | saa.saa_adapter_target = SDEV_NO_ADAPTER_TARGET0xffff; | |||
588 | saa.saa_adapter_buswidth = 16; | |||
589 | saa.saa_luns = 8; | |||
590 | saa.saa_openings = sc->sc_maxcmds; | |||
591 | saa.saa_pool = &sc->sc_iopool; | |||
592 | saa.saa_quirks = saa.saa_flags = 0; | |||
593 | saa.saa_wwpn = saa.saa_wwnn = 0; | |||
594 | ||||
595 | ptbus = (struct scsibus_softc *)config_found(&sc->sc_dev,config_found_sm((&sc->sc_dev), (&saa), (scsiprint) , ((void *)0)) | |||
596 | &saa, scsiprint)config_found_sm((&sc->sc_dev), (&saa), (scsiprint) , ((void *)0)); | |||
597 | ||||
598 | if (ptbus == NULL((void *)0) || rsc->sc_proctarget == -1) | |||
599 | continue; | |||
600 | ||||
601 | proclink = scsi_get_link(ptbus, rsc->sc_proctarget, 0); | |||
602 | if (proclink == NULL((void *)0)) | |||
603 | continue; | |||
604 | ||||
605 | procdev = proclink->device_softc; | |||
606 | strlcpy(rsc->sc_procdev, procdev->dv_xname, | |||
607 | sizeof(rsc->sc_procdev)); | |||
608 | } | |||
609 | ||||
610 | return (0); | |||
611 | ||||
612 | free_mbox: | |||
613 | ami_freemem(sc, sc->sc_mbox_am); | |||
614 | free_idata: | |||
615 | ami_freemem(sc, am); | |||
616 | ||||
617 | return (1); | |||
618 | } | |||
619 | ||||
620 | int | |||
621 | ami_quartz_init(struct ami_softc *sc) | |||
622 | { | |||
623 | ami_write(sc, AMI_QIDB0x20, 0); | |||
624 | ||||
625 | return (0); | |||
626 | } | |||
627 | ||||
628 | int | |||
629 | ami_quartz_exec(struct ami_softc *sc, struct ami_iocmd *cmd) | |||
630 | { | |||
631 | if (sc->sc_mbox->acc_busy) { | |||
632 | AMI_DPRINTF(AMI_D_CMD, ("mbox_busy ")); | |||
633 | return (EBUSY16); | |||
634 | } | |||
635 | ||||
636 | memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16)__builtin_memcpy(((struct ami_iocmd *)sc->sc_mbox), (cmd), (16)); | |||
637 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x04 |0x01)) | |||
638 | sizeof(struct ami_iocmd), BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x04 |0x01)); | |||
639 | ||||
640 | sc->sc_mbox->acc_busy = 1; | |||
641 | sc->sc_mbox->acc_poll = 0; | |||
642 | sc->sc_mbox->acc_ack = 0; | |||
643 | ||||
644 | ami_write(sc, AMI_QIDB0x20, sc->sc_mbox_pa | htole32(AMI_QIDB_EXEC)((__uint32_t)(0x01))); | |||
645 | ||||
646 | return (0); | |||
647 | } | |||
648 | ||||
649 | int | |||
650 | ami_quartz_done(struct ami_softc *sc, struct ami_iocmd *mbox) | |||
651 | { | |||
652 | u_int32_t i, n; | |||
653 | u_int8_t nstat, status; | |||
654 | u_int8_t completed[AMI_MAXSTATACK0x2e]; | |||
655 | ||||
656 | if (ami_read(sc, AMI_QODB0x2c) != AMI_QODB_READY0x10001234) | |||
657 | return (0); /* nothing to do */ | |||
658 | ||||
659 | ami_write(sc, AMI_QODB0x2c, AMI_QODB_READY0x10001234); | |||
660 | ||||
661 | /* | |||
662 | * The following sequence is not supposed to have a timeout clause | |||
663 | * since the firmware has a "guarantee" that all commands will | |||
664 | * complete. The choice is either panic or hoping for a miracle | |||
665 | * and that the IOs will complete much later. | |||
666 | */ | |||
667 | i = 0; | |||
668 | while ((nstat = sc->sc_mbox->acc_nstat) == 0xff) { | |||
669 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x02 )) | |||
670 | sizeof(struct ami_iocmd), BUS_DMASYNC_POSTREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x02 )); | |||
671 | delay(1)(*delay_func)(1); | |||
672 | if (i++ > 1000000) | |||
673 | return (0); /* nothing to do */ | |||
674 | } | |||
675 | sc->sc_mbox->acc_nstat = 0xff; | |||
676 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x08 )) | |||
677 | sizeof(struct ami_iocmd), BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x08 )); | |||
678 | ||||
679 | /* wait until fw wrote out all completions */ | |||
680 | i = 0; | |||
681 | AMI_DPRINTF(AMI_D_CMD, ("aqd %d ", nstat)); | |||
682 | for (n = 0; n < nstat; n++) { | |||
683 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x01 )) | |||
684 | sizeof(struct ami_iocmd), BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x01 )); | |||
685 | while ((completed[n] = sc->sc_mbox->acc_cmplidl[n]) == 0xff) { | |||
686 | delay(1)(*delay_func)(1); | |||
687 | if (i++ > 1000000) | |||
688 | return (0); /* nothing to do */ | |||
689 | } | |||
690 | sc->sc_mbox->acc_cmplidl[n] = 0xff; | |||
691 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x08 )) | |||
692 | sizeof(struct ami_iocmd), BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x08 )); | |||
693 | } | |||
694 | ||||
695 | /* this should never happen, someone screwed up the completion status */ | |||
696 | if ((status = sc->sc_mbox->acc_status) == 0xff) | |||
697 | panic("%s: status 0xff from the firmware", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
698 | ||||
699 | sc->sc_mbox->acc_status = 0xff; | |||
700 | ||||
701 | /* copy mailbox to temporary one and fixup other changed values */ | |||
702 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (16), (0x08)) | |||
703 | BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (16), (0x08)); | |||
704 | memcpy(mbox, (struct ami_iocmd *)sc->sc_mbox, 16)__builtin_memcpy((mbox), ((struct ami_iocmd *)sc->sc_mbox) , (16)); | |||
705 | mbox->acc_nstat = nstat; | |||
706 | mbox->acc_status = status; | |||
707 | for (n = 0; n < nstat; n++) | |||
708 | mbox->acc_cmplidl[n] = completed[n]; | |||
709 | ||||
710 | /* ack interrupt */ | |||
711 | ami_write(sc, AMI_QIDB0x20, AMI_QIDB_ACK0x02); | |||
712 | ||||
713 | return (1); /* ready to complete all IOs in acc_cmplidl */ | |||
714 | } | |||
715 | ||||
716 | int | |||
717 | ami_quartz_poll(struct ami_softc *sc, struct ami_iocmd *cmd) | |||
718 | { | |||
719 | /* struct scsi_xfer *xs = ccb->ccb_xs; */ | |||
720 | u_int32_t i; | |||
721 | u_int8_t status; | |||
722 | ||||
723 | splassert(IPL_BIO)do { if (splassert_ctl > 0) { splassert_check(0x6, __func__ ); } } while (0); | |||
724 | ||||
725 | if (sc->sc_dis_poll) | |||
726 | return (-1); /* fail */ | |||
727 | ||||
728 | i = 0; | |||
729 | while (sc->sc_mbox->acc_busy && (i < AMI_MAX_BUSYWAIT10)) { | |||
730 | delay(1)(*delay_func)(1); | |||
731 | i++; | |||
732 | } | |||
733 | if (sc->sc_mbox->acc_busy) { | |||
734 | AMI_DPRINTF(AMI_D_CMD, ("mbox_busy ")); | |||
735 | return (-1); | |||
736 | } | |||
737 | ||||
738 | memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16)__builtin_memcpy(((struct ami_iocmd *)sc->sc_mbox), (cmd), (16)); | |||
739 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (16), (0x04|0x01)) | |||
740 | BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (16), (0x04|0x01)); | |||
741 | ||||
742 | sc->sc_mbox->acc_id = 0xfe; | |||
743 | sc->sc_mbox->acc_busy = 1; | |||
744 | sc->sc_mbox->acc_poll = 0; | |||
745 | sc->sc_mbox->acc_ack = 0; | |||
746 | sc->sc_mbox->acc_nstat = 0xff; | |||
747 | sc->sc_mbox->acc_status = 0xff; | |||
748 | ||||
749 | /* send command to firmware */ | |||
750 | ami_write(sc, AMI_QIDB0x20, sc->sc_mbox_pa | htole32(AMI_QIDB_EXEC)((__uint32_t)(0x01))); | |||
751 | ||||
752 | i = 0; | |||
753 | while ((sc->sc_mbox->acc_nstat == 0xff) && (i < AMI_MAX_POLLWAIT1000000)) { | |||
754 | delay(1)(*delay_func)(1); | |||
755 | i++; | |||
756 | } | |||
757 | if (i >= AMI_MAX_POLLWAIT1000000) { | |||
758 | printf("%s: command not accepted, polling disabled\n", | |||
759 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
760 | sc->sc_dis_poll = 1; | |||
761 | return (-1); | |||
762 | } | |||
763 | ||||
764 | /* poll firmware */ | |||
765 | i = 0; | |||
766 | while ((sc->sc_mbox->acc_poll != 0x77) && (i < AMI_MAX_POLLWAIT1000000)) { | |||
767 | delay(1)(*delay_func)(1); | |||
768 | i++; | |||
769 | } | |||
770 | if (i >= AMI_MAX_POLLWAIT1000000) { | |||
771 | printf("%s: firmware didn't reply, polling disabled\n", | |||
772 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
773 | sc->sc_dis_poll = 1; | |||
774 | return (-1); | |||
775 | } | |||
776 | ||||
777 | /* ack */ | |||
778 | ami_write(sc, AMI_QIDB0x20, sc->sc_mbox_pa | htole32(AMI_QIDB_ACK)((__uint32_t)(0x02))); | |||
779 | ||||
780 | i = 0; | |||
781 | while((ami_read(sc, AMI_QIDB0x20) & AMI_QIDB_ACK0x02) && | |||
782 | (i < AMI_MAX_POLLWAIT1000000)) { | |||
783 | delay(1)(*delay_func)(1); | |||
784 | i++; | |||
785 | } | |||
786 | if (i >= AMI_MAX_POLLWAIT1000000) { | |||
787 | printf("%s: firmware didn't ack the ack, polling disabled\n", | |||
788 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
789 | sc->sc_dis_poll = 1; | |||
790 | return (-1); | |||
791 | } | |||
792 | ||||
793 | sc->sc_mbox->acc_poll = 0; | |||
794 | sc->sc_mbox->acc_ack = 0x77; | |||
795 | status = sc->sc_mbox->acc_status; | |||
796 | sc->sc_mbox->acc_nstat = 0xff; | |||
797 | sc->sc_mbox->acc_status = 0xff; | |||
798 | ||||
799 | for (i = 0; i < AMI_MAXSTATACK0x2e; i++) | |||
800 | sc->sc_mbox->acc_cmplidl[i] = 0xff; | |||
801 | ||||
802 | return (status); | |||
803 | } | |||
804 | ||||
805 | int | |||
806 | ami_schwartz_init(struct ami_softc *sc) | |||
807 | { | |||
808 | u_int32_t a = (u_int32_t)sc->sc_mbox_pa; | |||
809 | ||||
810 | bus_space_write_4(sc->sc_iot, sc->sc_ioh, AMI_SMBADDR, a)((sc->sc_iot)->write_4((sc->sc_ioh), (0x14), (a))); | |||
811 | /* XXX 40bit address ??? */ | |||
812 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SMBENA, 0)((sc->sc_iot)->write_1((sc->sc_ioh), (0x18), (0))); | |||
813 | ||||
814 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_ACK)((sc->sc_iot)->write_1((sc->sc_ioh), (0x10), (0x08)) ); | |||
815 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SIEM, AMI_SEIM_ENA |((sc->sc_iot)->write_1((sc->sc_ioh), (0x11), (0xc0 | ((sc->sc_iot)->read_1((sc->sc_ioh), (0x11)))))) | |||
816 | bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SIEM))((sc->sc_iot)->write_1((sc->sc_ioh), (0x11), (0xc0 | ((sc->sc_iot)->read_1((sc->sc_ioh), (0x11)))))); | |||
817 | ||||
818 | return (0); | |||
819 | } | |||
820 | ||||
821 | int | |||
822 | ami_schwartz_exec(struct ami_softc *sc, struct ami_iocmd *cmd) | |||
823 | { | |||
824 | if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT)((sc->sc_iot)->read_1((sc->sc_ioh), (0x10))) & | |||
825 | AMI_SMBST_BUSY0x10) { | |||
826 | AMI_DPRINTF(AMI_D_CMD, ("mbox_busy ")); | |||
827 | return (EBUSY16); | |||
828 | } | |||
829 | ||||
830 | memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16)__builtin_memcpy(((struct ami_iocmd *)sc->sc_mbox), (cmd), (16)); | |||
831 | sc->sc_mbox->acc_busy = 1; | |||
832 | sc->sc_mbox->acc_poll = 0; | |||
833 | sc->sc_mbox->acc_ack = 0; | |||
834 | ||||
835 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_EXEC)((sc->sc_iot)->write_1((sc->sc_ioh), (0x10), (0x10)) ); | |||
836 | return (0); | |||
837 | } | |||
838 | ||||
839 | int | |||
840 | ami_schwartz_done(struct ami_softc *sc, struct ami_iocmd *mbox) | |||
841 | { | |||
842 | u_int8_t stat; | |||
843 | ||||
844 | #if 0 | |||
845 | /* do not scramble the busy mailbox */ | |||
846 | if (sc->sc_mbox->acc_busy) | |||
847 | return (0); | |||
848 | #endif | |||
849 | if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT)((sc->sc_iot)->read_1((sc->sc_ioh), (0x10))) & | |||
850 | AMI_SMBST_BUSY0x10) | |||
851 | return (0); | |||
852 | ||||
853 | stat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT)((sc->sc_iot)->read_1((sc->sc_ioh), (0x1a))); | |||
854 | if (stat & AMI_ISTAT_PEND0x40) { | |||
855 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT, stat)((sc->sc_iot)->write_1((sc->sc_ioh), (0x1a), (stat)) ); | |||
856 | ||||
857 | *mbox = *sc->sc_mbox; | |||
858 | AMI_DPRINTF(AMI_D_CMD, ("asd %d ", mbox->acc_nstat)); | |||
859 | ||||
860 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD,((sc->sc_iot)->write_1((sc->sc_ioh), (0x10), (0x08)) ) | |||
861 | AMI_SCMD_ACK)((sc->sc_iot)->write_1((sc->sc_ioh), (0x10), (0x08)) ); | |||
862 | ||||
863 | return (1); | |||
864 | } | |||
865 | ||||
866 | return (0); | |||
867 | } | |||
868 | ||||
869 | int | |||
870 | ami_schwartz_poll(struct ami_softc *sc, struct ami_iocmd *mbox) | |||
871 | { | |||
872 | u_int8_t status; | |||
873 | u_int32_t i; | |||
874 | int rv; | |||
875 | ||||
876 | splassert(IPL_BIO)do { if (splassert_ctl > 0) { splassert_check(0x6, __func__ ); } } while (0); | |||
877 | ||||
878 | if (sc->sc_dis_poll) | |||
879 | return (-1); /* fail */ | |||
880 | ||||
881 | for (i = 0; i < AMI_MAX_POLLWAIT1000000; i++) { | |||
882 | if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT)((sc->sc_iot)->read_1((sc->sc_ioh), (0x10))) & | |||
883 | AMI_SMBST_BUSY0x10)) | |||
884 | break; | |||
885 | delay(1)(*delay_func)(1); | |||
886 | } | |||
887 | if (i >= AMI_MAX_POLLWAIT1000000) { | |||
888 | AMI_DPRINTF(AMI_D_CMD, ("mbox_busy ")); | |||
889 | return (-1); | |||
890 | } | |||
891 | ||||
892 | memcpy((struct ami_iocmd *)sc->sc_mbox, mbox, 16)__builtin_memcpy(((struct ami_iocmd *)sc->sc_mbox), (mbox) , (16)); | |||
893 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (16), (0x04|0x01)) | |||
894 | BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (16), (0x04|0x01)); | |||
895 | ||||
896 | sc->sc_mbox->acc_busy = 1; | |||
897 | sc->sc_mbox->acc_poll = 0; | |||
898 | sc->sc_mbox->acc_ack = 0; | |||
899 | /* send command to firmware */ | |||
900 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_EXEC)((sc->sc_iot)->write_1((sc->sc_ioh), (0x10), (0x10)) ); | |||
901 | ||||
902 | /* wait until no longer busy */ | |||
903 | for (i = 0; i < AMI_MAX_POLLWAIT1000000; i++) { | |||
904 | if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT)((sc->sc_iot)->read_1((sc->sc_ioh), (0x10))) & | |||
905 | AMI_SMBST_BUSY0x10)) | |||
906 | break; | |||
907 | delay(1)(*delay_func)(1); | |||
908 | } | |||
909 | if (i >= AMI_MAX_POLLWAIT1000000) { | |||
910 | printf("%s: command not accepted, polling disabled\n", | |||
911 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
912 | sc->sc_dis_poll = 1; | |||
913 | return (-1); | |||
914 | } | |||
915 | ||||
916 | /* wait for interrupt bit */ | |||
917 | for (i = 0; i < AMI_MAX_POLLWAIT1000000; i++) { | |||
918 | status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT)((sc->sc_iot)->read_1((sc->sc_ioh), (0x1a))); | |||
919 | if (status & AMI_ISTAT_PEND0x40) | |||
920 | break; | |||
921 | delay(1)(*delay_func)(1); | |||
922 | } | |||
923 | if (i >= AMI_MAX_POLLWAIT1000000) { | |||
924 | printf("%s: interrupt didn't arrive, polling disabled\n", | |||
925 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
926 | sc->sc_dis_poll = 1; | |||
927 | return (-1); | |||
928 | } | |||
929 | ||||
930 | /* write ststus back to firmware */ | |||
931 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT, status)((sc->sc_iot)->write_1((sc->sc_ioh), (0x1a), (status ))); | |||
932 | ||||
933 | /* copy mailbox and status back */ | |||
934 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x01 )) | |||
935 | sizeof(struct ami_iocmd), BUS_DMASYNC_PREREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_mbox_am)->am_map)), (0), (sizeof(struct ami_iocmd)), (0x01 )); | |||
936 | *mbox = *sc->sc_mbox; | |||
937 | rv = sc->sc_mbox->acc_status; | |||
938 | ||||
939 | /* ack interrupt */ | |||
940 | bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_ACK)((sc->sc_iot)->write_1((sc->sc_ioh), (0x10), (0x08)) ); | |||
941 | ||||
942 | return (rv); | |||
943 | } | |||
944 | ||||
945 | void | |||
946 | ami_start_xs(struct ami_softc *sc, struct ami_ccb *ccb, struct scsi_xfer *xs) | |||
947 | { | |||
948 | if (xs->flags & SCSI_POLL0x00002) | |||
949 | ami_complete(sc, ccb, xs->timeout); | |||
950 | else | |||
951 | ami_start(sc, ccb); | |||
952 | } | |||
953 | ||||
954 | void | |||
955 | ami_start(struct ami_softc *sc, struct ami_ccb *ccb) | |||
956 | { | |||
957 | mtx_enter(&sc->sc_cmd_mtx); | |||
958 | ccb->ccb_state = AMI_CCB_PREQUEUED; | |||
959 | TAILQ_INSERT_TAIL(&sc->sc_ccb_preq, ccb, ccb_link)do { (ccb)->ccb_link.tqe_next = ((void *)0); (ccb)->ccb_link .tqe_prev = (&sc->sc_ccb_preq)->tqh_last; *(&sc ->sc_ccb_preq)->tqh_last = (ccb); (&sc->sc_ccb_preq )->tqh_last = &(ccb)->ccb_link.tqe_next; } while (0 ); | |||
960 | mtx_leave(&sc->sc_cmd_mtx); | |||
961 | ||||
962 | ami_runqueue(sc); | |||
963 | } | |||
964 | ||||
965 | void | |||
966 | ami_runqueue_tick(void *arg) | |||
967 | { | |||
968 | ami_runqueue(arg); | |||
969 | } | |||
970 | ||||
971 | void | |||
972 | ami_runqueue(struct ami_softc *sc) | |||
973 | { | |||
974 | struct ami_ccb *ccb; | |||
975 | int add = 0; | |||
976 | ||||
977 | mtx_enter(&sc->sc_cmd_mtx); | |||
978 | if (!sc->sc_drainio) { | |||
979 | while ((ccb = TAILQ_FIRST(&sc->sc_ccb_preq)((&sc->sc_ccb_preq)->tqh_first)) != NULL((void *)0)) { | |||
980 | if (sc->sc_exec(sc, &ccb->ccb_cmd) != 0) { | |||
981 | add = 1; | |||
982 | break; | |||
983 | } | |||
984 | ||||
985 | TAILQ_REMOVE(&sc->sc_ccb_preq, ccb, ccb_link)do { if (((ccb)->ccb_link.tqe_next) != ((void *)0)) (ccb)-> ccb_link.tqe_next->ccb_link.tqe_prev = (ccb)->ccb_link. tqe_prev; else (&sc->sc_ccb_preq)->tqh_last = (ccb) ->ccb_link.tqe_prev; *(ccb)->ccb_link.tqe_prev = (ccb)-> ccb_link.tqe_next; ((ccb)->ccb_link.tqe_prev) = ((void *)- 1); ((ccb)->ccb_link.tqe_next) = ((void *)-1); } while (0); | |||
986 | ccb->ccb_state = AMI_CCB_QUEUED; | |||
987 | TAILQ_INSERT_TAIL(&sc->sc_ccb_runq, ccb, ccb_link)do { (ccb)->ccb_link.tqe_next = ((void *)0); (ccb)->ccb_link .tqe_prev = (&sc->sc_ccb_runq)->tqh_last; *(&sc ->sc_ccb_runq)->tqh_last = (ccb); (&sc->sc_ccb_runq )->tqh_last = &(ccb)->ccb_link.tqe_next; } while (0 ); | |||
988 | } | |||
989 | } | |||
990 | mtx_leave(&sc->sc_cmd_mtx); | |||
991 | ||||
992 | if (add) | |||
993 | timeout_add(&sc->sc_run_tmo, 1); | |||
994 | } | |||
995 | ||||
996 | int | |||
997 | ami_poll(struct ami_softc *sc, struct ami_ccb *ccb) | |||
998 | { | |||
999 | int error; | |||
1000 | ||||
1001 | mtx_enter(&sc->sc_cmd_mtx); | |||
1002 | error = sc->sc_poll(sc, &ccb->ccb_cmd); | |||
1003 | if (error == -1) | |||
1004 | ccb->ccb_flags |= AMI_CCB_F_ERR(1<<0); | |||
1005 | mtx_leave(&sc->sc_cmd_mtx); | |||
1006 | ||||
1007 | ccb->ccb_done(sc, ccb); | |||
1008 | ||||
1009 | return (error); | |||
1010 | } | |||
1011 | ||||
1012 | void | |||
1013 | ami_complete(struct ami_softc *sc, struct ami_ccb *ccb, int timeout) | |||
1014 | { | |||
1015 | void (*done)(struct ami_softc *, struct ami_ccb *); | |||
1016 | int ready; | |||
1017 | int i = 0; | |||
1018 | int s; | |||
1019 | ||||
1020 | done = ccb->ccb_done; | |||
1021 | ccb->ccb_done = ami_done_dummy; | |||
1022 | ||||
1023 | /* | |||
1024 | * since exec will return if the mbox is busy we have to busy wait | |||
1025 | * ourselves. once its in, jam it into the runq. | |||
1026 | */ | |||
1027 | mtx_enter(&sc->sc_cmd_mtx); | |||
1028 | while (i < AMI_MAX_BUSYWAIT10) { | |||
1029 | if (sc->sc_exec(sc, &ccb->ccb_cmd) == 0) { | |||
1030 | ccb->ccb_state = AMI_CCB_QUEUED; | |||
1031 | TAILQ_INSERT_TAIL(&sc->sc_ccb_runq, ccb, ccb_link)do { (ccb)->ccb_link.tqe_next = ((void *)0); (ccb)->ccb_link .tqe_prev = (&sc->sc_ccb_runq)->tqh_last; *(&sc ->sc_ccb_runq)->tqh_last = (ccb); (&sc->sc_ccb_runq )->tqh_last = &(ccb)->ccb_link.tqe_next; } while (0 ); | |||
1032 | break; | |||
1033 | } | |||
1034 | DELAY(1000)(*delay_func)(1000); | |||
1035 | i++; | |||
1036 | } | |||
1037 | ready = (ccb->ccb_state == AMI_CCB_QUEUED); | |||
1038 | mtx_leave(&sc->sc_cmd_mtx); | |||
1039 | ||||
1040 | if (!ready) { | |||
1041 | ccb->ccb_flags |= AMI_CCB_F_ERR(1<<0); | |||
1042 | ccb->ccb_state = AMI_CCB_READY; | |||
1043 | goto done; | |||
1044 | } | |||
1045 | ||||
1046 | /* | |||
1047 | * Override timeout for PERC3. The first command triggers a chip | |||
1048 | * reset on the QL12160 chip which causes the firmware to reload. | |||
1049 | * 30000 is slightly less than double of how long it takes for the | |||
1050 | * firmware to be up again. After the first two commands the | |||
1051 | * timeouts are as expected. | |||
1052 | */ | |||
1053 | timeout = MAX(30000, timeout)(((30000)>(timeout))?(30000):(timeout)); /* timeout */ | |||
1054 | ||||
1055 | while (ccb->ccb_state == AMI_CCB_QUEUED) { | |||
1056 | s = splbio()splraise(0x6); /* interrupt handlers are called at their IPL */ | |||
1057 | ready = ami_intr(sc); | |||
1058 | splx(s)spllower(s); | |||
1059 | ||||
1060 | if (ready == 0) { | |||
1061 | if (timeout-- == 0) { | |||
1062 | /* XXX */ | |||
1063 | printf("%s: timeout\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
1064 | return; | |||
1065 | } | |||
1066 | ||||
1067 | delay(1000)(*delay_func)(1000); | |||
1068 | continue; | |||
1069 | } | |||
1070 | } | |||
1071 | ||||
1072 | done: | |||
1073 | done(sc, ccb); | |||
1074 | } | |||
1075 | ||||
1076 | void | |||
1077 | ami_done_pt(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1078 | { | |||
1079 | struct scsi_xfer *xs = ccb->ccb_xs; | |||
1080 | struct scsi_link *link = xs->sc_link; | |||
1081 | struct ami_rawsoftc *rsc = link->bus->sb_adapter_softc; | |||
1082 | u_int8_t target = link->target, type; | |||
1083 | ||||
1084 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)) | |||
1085 | ccb->ccb_offset, sizeof(struct ami_ccbmem),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)) | |||
1086 | BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)); | |||
1087 | ||||
1088 | if (xs->data != NULL((void *)0)) { | |||
1089 | bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)) | |||
1090 | ccb->ccb_dmamap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)) | |||
1091 | (xs->flags & SCSI_DATA_IN) ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)) | |||
1092 | BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)); | |||
1093 | ||||
1094 | bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (ccb ->ccb_dmamap)); | |||
1095 | } | |||
1096 | ||||
1097 | xs->resid = 0; | |||
1098 | ||||
1099 | if (ccb->ccb_flags & AMI_CCB_F_ERR(1<<0)) | |||
1100 | xs->error = XS_DRIVER_STUFFUP2; | |||
1101 | else if (ccb->ccb_status != 0x00) | |||
1102 | xs->error = XS_DRIVER_STUFFUP2; | |||
1103 | else if (xs->flags & SCSI_POLL0x00002 && xs->cmd.opcode == INQUIRY0x12) { | |||
1104 | type = ((struct scsi_inquiry_data *)xs->data)->device & | |||
1105 | SID_TYPE0x1f; | |||
1106 | if (!(type == T_PROCESSOR0x03 || type == T_ENCLOSURE0x0d)) | |||
1107 | xs->error = XS_DRIVER_STUFFUP2; | |||
1108 | else | |||
1109 | rsc->sc_proctarget = target; | |||
1110 | } | |||
1111 | ||||
1112 | scsi_done(xs); | |||
1113 | } | |||
1114 | ||||
1115 | void | |||
1116 | ami_done_xs(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1117 | { | |||
1118 | struct scsi_xfer *xs = ccb->ccb_xs; | |||
1119 | ||||
1120 | if (xs->data != NULL((void *)0)) { | |||
1121 | bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)) | |||
1122 | ccb->ccb_dmamap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)) | |||
1123 | (xs->flags & SCSI_DATA_IN) ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)) | |||
1124 | BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x02 : 0x08)); | |||
1125 | ||||
1126 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)) | |||
1127 | ccb->ccb_offset, sizeof(struct ami_ccbmem),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)) | |||
1128 | BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)); | |||
1129 | ||||
1130 | bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (ccb ->ccb_dmamap)); | |||
1131 | } | |||
1132 | ||||
1133 | xs->resid = 0; | |||
1134 | ||||
1135 | if (ccb->ccb_flags & AMI_CCB_F_ERR(1<<0)) | |||
1136 | xs->error = XS_DRIVER_STUFFUP2; | |||
1137 | ||||
1138 | scsi_done(xs); | |||
1139 | } | |||
1140 | ||||
1141 | void | |||
1142 | ami_done_flush(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1143 | { | |||
1144 | struct scsi_xfer *xs = ccb->ccb_xs; | |||
1145 | struct ami_iocmd *cmd = &ccb->ccb_cmd; | |||
1146 | ||||
1147 | if (ccb->ccb_flags & AMI_CCB_F_ERR(1<<0)) { | |||
1148 | xs->error = XS_DRIVER_STUFFUP2; | |||
1149 | xs->resid = 0; | |||
1150 | ||||
1151 | scsi_done(xs); | |||
1152 | return; | |||
1153 | } | |||
1154 | ||||
1155 | /* reuse the ccb for the sysflush command */ | |||
1156 | ccb->ccb_done = ami_done_sysflush; | |||
1157 | cmd->acc_cmd = AMI_SYSFLUSH0xfe; | |||
1158 | ||||
1159 | ami_start_xs(sc, ccb, xs); | |||
1160 | } | |||
1161 | ||||
1162 | void | |||
1163 | ami_done_sysflush(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1164 | { | |||
1165 | struct scsi_xfer *xs = ccb->ccb_xs; | |||
1166 | ||||
1167 | xs->resid = 0; | |||
1168 | if (ccb->ccb_flags & AMI_CCB_F_ERR(1<<0)) | |||
1169 | xs->error = XS_DRIVER_STUFFUP2; | |||
1170 | ||||
1171 | scsi_done(xs); | |||
1172 | } | |||
1173 | ||||
1174 | void | |||
1175 | ami_done_dummy(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1176 | { | |||
1177 | } | |||
1178 | ||||
1179 | void | |||
1180 | ami_done_ioctl(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1181 | { | |||
1182 | wakeup(ccb); | |||
1183 | } | |||
1184 | ||||
1185 | void | |||
1186 | ami_done_init(struct ami_softc *sc, struct ami_ccb *ccb) | |||
1187 | { | |||
1188 | /* the ccb is going to be reused, so do nothing with it */ | |||
1189 | } | |||
1190 | ||||
1191 | void | |||
1192 | ami_scsi_raw_cmd(struct scsi_xfer *xs) | |||
1193 | { | |||
1194 | struct scsi_link *link = xs->sc_link; | |||
1195 | struct ami_rawsoftc *rsc = link->bus->sb_adapter_softc; | |||
1196 | struct ami_softc *sc = rsc->sc_softc; | |||
1197 | u_int8_t channel = rsc->sc_channel, target = link->target; | |||
1198 | struct ami_ccb *ccb; | |||
1199 | ||||
1200 | AMI_DPRINTF(AMI_D_CMD, ("ami_scsi_raw_cmd ")); | |||
1201 | ||||
1202 | if (xs->cmdlen > AMI_MAX_CDB10) { | |||
1203 | AMI_DPRINTF(AMI_D_CMD, ("CDB too big %p ", xs)); | |||
1204 | bzero(&xs->sense, sizeof(xs->sense))__builtin_bzero((&xs->sense), (sizeof(xs->sense))); | |||
1205 | xs->sense.error_code = SSD_ERRCODE_VALID0x80 | SSD_ERRCODE_CURRENT0x70; | |||
1206 | xs->sense.flags = SKEY_ILLEGAL_REQUEST0x05; | |||
1207 | xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */ | |||
1208 | xs->error = XS_SENSE1; | |||
1209 | scsi_done(xs); | |||
1210 | return; | |||
1211 | } | |||
1212 | ||||
1213 | xs->error = XS_NOERROR0; | |||
1214 | ||||
1215 | ccb = xs->io; | |||
1216 | ||||
1217 | memset(ccb->ccb_pt, 0, sizeof(struct ami_passthrough))__builtin_memset((ccb->ccb_pt), (0), (sizeof(struct ami_passthrough ))); | |||
1218 | ||||
1219 | ccb->ccb_xs = xs; | |||
1220 | ccb->ccb_done = ami_done_pt; | |||
1221 | ||||
1222 | ccb->ccb_cmd.acc_cmd = AMI_PASSTHRU0x03; | |||
1223 | ccb->ccb_cmd.acc_passthru_._ami_passthru.apt_data = ccb->ccb_ptpa; | |||
1224 | ||||
1225 | ccb->ccb_pt->apt_param = AMI_PTPARAM(AMI_TIMEOUT_6,1,0)(((0) << 7) | (((1) & 1) << 3) | ((0) & 3 )); | |||
1226 | ccb->ccb_pt->apt_channel = channel; | |||
1227 | ccb->ccb_pt->apt_target = target; | |||
1228 | bcopy(&xs->cmd, ccb->ccb_pt->apt_cdb, AMI_MAX_CDB10); | |||
1229 | ccb->ccb_pt->apt_ncdb = xs->cmdlen; | |||
1230 | ccb->ccb_pt->apt_nsense = AMI_MAX_SENSE32; | |||
1231 | ccb->ccb_pt->apt_datalen = xs->datalen; | |||
1232 | ccb->ccb_pt->apt_data = 0; | |||
1233 | ||||
1234 | if (ami_load_ptmem(sc, ccb, xs->data, xs->datalen, | |||
1235 | xs->flags & SCSI_DATA_IN0x00800, xs->flags & SCSI_NOSLEEP0x00001) != 0) { | |||
1236 | xs->error = XS_DRIVER_STUFFUP2; | |||
1237 | scsi_done(xs); | |||
1238 | return; | |||
1239 | } | |||
1240 | ||||
1241 | ami_start_xs(sc, ccb, xs); | |||
1242 | } | |||
1243 | ||||
1244 | int | |||
1245 | ami_load_ptmem(struct ami_softc *sc, struct ami_ccb *ccb, void *data, | |||
1246 | size_t len, int read, int nowait) | |||
1247 | { | |||
1248 | bus_dmamap_t dmap = ccb->ccb_dmamap; | |||
1249 | bus_dma_segment_t *sgd; | |||
1250 | int error, i; | |||
1251 | ||||
1252 | if (data != NULL((void *)0)) { | |||
1253 | error = bus_dmamap_load(sc->sc_dmat, dmap, data, len, NULL,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap) , (data), (len), (((void *)0)), (nowait ? 0x0001 : 0x0000)) | |||
1254 | nowait ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK)(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (dmap) , (data), (len), (((void *)0)), (nowait ? 0x0001 : 0x0000)); | |||
1255 | if (error) { | |||
1256 | if (error == EFBIG27) | |||
1257 | printf("more than %d dma segs\n", | |||
1258 | AMI_MAXOFFSETS26); | |||
1259 | else | |||
1260 | printf("error %d loading dma map\n", error); | |||
1261 | ||||
1262 | return (1); | |||
1263 | } | |||
1264 | ||||
1265 | sgd = dmap->dm_segs; | |||
1266 | if (dmap->dm_nsegs > 1) { | |||
1267 | struct ami_sgent *sgl = ccb->ccb_sglist; | |||
1268 | ||||
1269 | ccb->ccb_pt->apt_nsge = dmap->dm_nsegs; | |||
1270 | ccb->ccb_pt->apt_data = ccb->ccb_sglistpa; | |||
1271 | ||||
1272 | for (i = 0; i < dmap->dm_nsegs; i++) { | |||
1273 | sgl[i].asg_addr = htole32(sgd[i].ds_addr)((__uint32_t)(sgd[i].ds_addr)); | |||
1274 | sgl[i].asg_len = htole32(sgd[i].ds_len)((__uint32_t)(sgd[i].ds_len)); | |||
1275 | } | |||
1276 | } else { | |||
1277 | ccb->ccb_pt->apt_nsge = 0; | |||
1278 | ccb->ccb_pt->apt_data = htole32(sgd->ds_addr)((__uint32_t)(sgd->ds_addr)); | |||
1279 | } | |||
1280 | ||||
1281 | bus_dmamap_sync(sc->sc_dmat, dmap, 0, dmap->dm_mapsize,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap) , (0), (dmap->dm_mapsize), (read ? 0x01 : 0x04)) | |||
1282 | read ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (dmap) , (0), (dmap->dm_mapsize), (read ? 0x01 : 0x04)); | |||
1283 | } | |||
1284 | ||||
1285 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x01 | 0x04)) | |||
1286 | ccb->ccb_offset, sizeof(struct ami_ccbmem),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x01 | 0x04)) | |||
1287 | BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x01 | 0x04)); | |||
1288 | ||||
1289 | return (0); | |||
1290 | } | |||
1291 | ||||
1292 | void | |||
1293 | ami_scsi_cmd(struct scsi_xfer *xs) | |||
1294 | { | |||
1295 | struct scsi_link *link = xs->sc_link; | |||
1296 | struct ami_softc *sc = link->bus->sb_adapter_softc; | |||
1297 | struct device *dev = link->device_softc; | |||
1298 | struct ami_ccb *ccb; | |||
1299 | struct ami_iocmd *cmd; | |||
1300 | struct scsi_inquiry_data inq; | |||
1301 | struct scsi_sense_data sd; | |||
1302 | struct scsi_read_cap_data rcd; | |||
1303 | u_int8_t target = link->target; | |||
1304 | u_int32_t blockno, blockcnt; | |||
1305 | struct scsi_rw *rw; | |||
1306 | struct scsi_rw_10 *rw10; | |||
1307 | bus_dma_segment_t *sgd; | |||
1308 | int error; | |||
1309 | int i; | |||
1310 | ||||
1311 | AMI_DPRINTF(AMI_D_CMD, ("ami_scsi_cmd ")); | |||
1312 | ||||
1313 | if (target >= sc->sc_nunits || !sc->sc_hdr[target].hd_present || | |||
1314 | link->lun != 0) { | |||
1315 | AMI_DPRINTF(AMI_D_CMD, ("no target %d ", target)); | |||
1316 | /* XXX should be XS_SENSE and sense filled out */ | |||
1317 | xs->error = XS_DRIVER_STUFFUP2; | |||
1318 | scsi_done(xs); | |||
1319 | return; | |||
1320 | } | |||
1321 | ||||
1322 | xs->error = XS_NOERROR0; | |||
1323 | ||||
1324 | switch (xs->cmd.opcode) { | |||
1325 | case READ_COMMAND0x08: | |||
1326 | case READ_100x28: | |||
1327 | case WRITE_COMMAND0x0a: | |||
1328 | case WRITE_100x2a: | |||
1329 | /* deal with io outside the switch */ | |||
1330 | break; | |||
1331 | ||||
1332 | case SYNCHRONIZE_CACHE0x35: | |||
1333 | ccb = xs->io; | |||
1334 | ||||
1335 | ccb->ccb_xs = xs; | |||
1336 | ccb->ccb_done = ami_done_flush; | |||
1337 | if (xs->timeout < 30000) | |||
1338 | xs->timeout = 30000; /* at least 30sec */ | |||
1339 | ||||
1340 | cmd = &ccb->ccb_cmd; | |||
1341 | cmd->acc_cmd = AMI_FLUSH0x0a; | |||
1342 | ||||
1343 | ami_start_xs(sc, ccb, xs); | |||
1344 | return; | |||
1345 | ||||
1346 | case TEST_UNIT_READY0x00: | |||
1347 | /* save off sd? after autoconf */ | |||
1348 | if (!cold) /* XXX bogus */ | |||
1349 | strlcpy(sc->sc_hdr[target].dev, dev->dv_xname, | |||
1350 | sizeof(sc->sc_hdr[target].dev)); | |||
1351 | case START_STOP0x1b: | |||
1352 | #if 0 | |||
1353 | case VERIFY: | |||
1354 | #endif | |||
1355 | case PREVENT_ALLOW0x1e: | |||
1356 | AMI_DPRINTF(AMI_D_CMD, ("opc %d tgt %d ", xs->cmd.opcode, | |||
1357 | target)); | |||
1358 | xs->error = XS_NOERROR0; | |||
1359 | scsi_done(xs); | |||
1360 | return; | |||
1361 | ||||
1362 | case REQUEST_SENSE0x03: | |||
1363 | AMI_DPRINTF(AMI_D_CMD, ("REQUEST SENSE tgt %d ", target)); | |||
1364 | bzero(&sd, sizeof(sd))__builtin_bzero((&sd), (sizeof(sd))); | |||
1365 | sd.error_code = SSD_ERRCODE_CURRENT0x70; | |||
1366 | sd.segment = 0; | |||
1367 | sd.flags = SKEY_NO_SENSE0x00; | |||
1368 | *(u_int32_t*)sd.info = htole32(0)((__uint32_t)(0)); | |||
1369 | sd.extra_len = 0; | |||
1370 | scsi_copy_internal_data(xs, &sd, sizeof(sd)); | |||
1371 | ||||
1372 | xs->error = XS_NOERROR0; | |||
1373 | scsi_done(xs); | |||
1374 | return; | |||
1375 | ||||
1376 | case INQUIRY0x12: | |||
1377 | if (ISSET(((struct scsi_inquiry *)&xs->cmd)->flags, SI_EVPD)((((struct scsi_inquiry *)&xs->cmd)->flags) & ( 0x01))) { | |||
1378 | xs->error = XS_DRIVER_STUFFUP2; | |||
1379 | scsi_done(xs); | |||
1380 | return; | |||
1381 | } | |||
1382 | ||||
1383 | AMI_DPRINTF(AMI_D_CMD, ("INQUIRY tgt %d ", target)); | |||
1384 | bzero(&inq, sizeof(inq))__builtin_bzero((&inq), (sizeof(inq))); | |||
1385 | inq.device = T_DIRECT0x00; | |||
1386 | inq.dev_qual2 = 0; | |||
1387 | inq.version = SCSI_REV_20x02; | |||
1388 | inq.response_format = SID_SCSI2_RESPONSE0x02; | |||
1389 | inq.additional_length = SID_SCSI2_ALEN31; | |||
1390 | inq.flags |= SID_CmdQue0x02; | |||
1391 | strlcpy(inq.vendor, "AMI ", sizeof(inq.vendor)); | |||
1392 | snprintf(inq.product, sizeof(inq.product), | |||
1393 | "Host drive #%02d", target); | |||
1394 | strlcpy(inq.revision, " ", sizeof(inq.revision)); | |||
1395 | scsi_copy_internal_data(xs, &inq, sizeof(inq)); | |||
1396 | ||||
1397 | xs->error = XS_NOERROR0; | |||
1398 | scsi_done(xs); | |||
1399 | return; | |||
1400 | ||||
1401 | case READ_CAPACITY0x25: | |||
1402 | AMI_DPRINTF(AMI_D_CMD, ("READ CAPACITY tgt %d ", target)); | |||
1403 | bzero(&rcd, sizeof(rcd))__builtin_bzero((&rcd), (sizeof(rcd))); | |||
1404 | _lto4b(sc->sc_hdr[target].hd_size - 1, rcd.addr); | |||
1405 | _lto4b(AMI_SECTOR_SIZE512, rcd.length); | |||
1406 | scsi_copy_internal_data(xs, &rcd, sizeof(rcd)); | |||
1407 | ||||
1408 | xs->error = XS_NOERROR0; | |||
1409 | scsi_done(xs); | |||
1410 | return; | |||
1411 | ||||
1412 | default: | |||
1413 | AMI_DPRINTF(AMI_D_CMD, ("unsupported scsi command %#x tgt %d ", | |||
1414 | xs->cmd.opcode, target)); | |||
1415 | ||||
1416 | xs->error = XS_DRIVER_STUFFUP2; | |||
1417 | scsi_done(xs); | |||
1418 | return; | |||
1419 | } | |||
1420 | ||||
1421 | /* A read or write operation. */ | |||
1422 | if (xs->cmdlen == 6) { | |||
1423 | rw = (struct scsi_rw *)&xs->cmd; | |||
1424 | blockno = _3btol(rw->addr) & (SRW_TOPADDR0x1F << 16 | 0xffff); | |||
1425 | blockcnt = rw->length ? rw->length : 0x100; | |||
1426 | } else { | |||
1427 | rw10 = (struct scsi_rw_10 *)&xs->cmd; | |||
1428 | blockno = _4btol(rw10->addr); | |||
1429 | blockcnt = _2btol(rw10->length); | |||
1430 | } | |||
1431 | ||||
1432 | if (blockno >= sc->sc_hdr[target].hd_size || | |||
1433 | blockno + blockcnt > sc->sc_hdr[target].hd_size) { | |||
1434 | printf("%s: out of bounds %u-%u >= %u\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), | |||
1435 | blockno, blockcnt, sc->sc_hdr[target].hd_size); | |||
1436 | xs->error = XS_DRIVER_STUFFUP2; | |||
1437 | scsi_done(xs); | |||
1438 | return; | |||
1439 | } | |||
1440 | ||||
1441 | ccb = xs->io; | |||
1442 | ||||
1443 | ccb->ccb_xs = xs; | |||
1444 | ccb->ccb_done = ami_done_xs; | |||
1445 | ||||
1446 | cmd = &ccb->ccb_cmd; | |||
1447 | cmd->acc_cmd = (xs->flags & SCSI_DATA_IN0x00800) ? AMI_READ0x01 : AMI_WRITE0x02; | |||
1448 | cmd->acc_mbox_._ami_mbox.amb_nsect = htole16(blockcnt)((__uint16_t)(blockcnt)); | |||
1449 | cmd->acc_mbox_._ami_mbox.amb_lba = htole32(blockno)((__uint32_t)(blockno)); | |||
1450 | cmd->acc_mbox_._ami_mbox.amb_ldn = target; | |||
1451 | ||||
1452 | error = bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (ccb-> ccb_dmamap), (xs->data), (xs->datalen), (((void *)0)), ( (xs->flags & 0x00001) ? 0x0001 : 0x0000)) | |||
1453 | xs->data, xs->datalen, NULL,(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (ccb-> ccb_dmamap), (xs->data), (xs->datalen), (((void *)0)), ( (xs->flags & 0x00001) ? 0x0001 : 0x0000)) | |||
1454 | (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK)(*(sc->sc_dmat)->_dmamap_load)((sc->sc_dmat), (ccb-> ccb_dmamap), (xs->data), (xs->datalen), (((void *)0)), ( (xs->flags & 0x00001) ? 0x0001 : 0x0000)); | |||
1455 | if (error) { | |||
1456 | if (error == EFBIG27) | |||
1457 | printf("more than %d dma segs\n", AMI_MAXOFFSETS26); | |||
1458 | else | |||
1459 | printf("error %d loading dma map\n", error); | |||
1460 | ||||
1461 | xs->error = XS_DRIVER_STUFFUP2; | |||
1462 | scsi_done(xs); | |||
1463 | return; | |||
1464 | } | |||
1465 | ||||
1466 | sgd = ccb->ccb_dmamap->dm_segs; | |||
1467 | if (ccb->ccb_dmamap->dm_nsegs > 1) { | |||
1468 | struct ami_sgent *sgl = ccb->ccb_sglist; | |||
1469 | ||||
1470 | cmd->acc_mbox_._ami_mbox.amb_nsge = ccb->ccb_dmamap->dm_nsegs; | |||
1471 | cmd->acc_mbox_._ami_mbox.amb_data = ccb->ccb_sglistpa; | |||
1472 | ||||
1473 | for (i = 0; i < ccb->ccb_dmamap->dm_nsegs; i++) { | |||
1474 | sgl[i].asg_addr = htole32(sgd[i].ds_addr)((__uint32_t)(sgd[i].ds_addr)); | |||
1475 | sgl[i].asg_len = htole32(sgd[i].ds_len)((__uint32_t)(sgd[i].ds_len)); | |||
1476 | } | |||
1477 | } else { | |||
1478 | cmd->acc_mbox_._ami_mbox.amb_nsge = 0; | |||
1479 | cmd->acc_mbox_._ami_mbox.amb_data = htole32(sgd->ds_addr)((__uint32_t)(sgd->ds_addr)); | |||
1480 | } | |||
1481 | ||||
1482 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x01 | 0x04)) | |||
1483 | ccb->ccb_offset, sizeof(struct ami_ccbmem),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x01 | 0x04)) | |||
1484 | BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x01 | 0x04)); | |||
1485 | ||||
1486 | bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x01 : 0x04)) | |||
1487 | ccb->ccb_dmamap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x01 : 0x04)) | |||
1488 | BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), ((xs-> flags & 0x00800) ? 0x01 : 0x04)); | |||
1489 | ||||
1490 | ami_start_xs(sc, ccb, xs); | |||
1491 | } | |||
1492 | ||||
1493 | int | |||
1494 | ami_intr(void *v) | |||
1495 | { | |||
1496 | struct ami_iocmd mbox; | |||
1497 | struct ami_softc *sc = v; | |||
1498 | struct ami_ccb *ccb; | |||
1499 | int i, rv = 0, ready; | |||
1500 | ||||
1501 | mtx_enter(&sc->sc_cmd_mtx); | |||
1502 | while (!TAILQ_EMPTY(&sc->sc_ccb_runq)(((&sc->sc_ccb_runq)->tqh_first) == ((void *)0)) && sc->sc_done(sc, &mbox)) { | |||
1503 | AMI_DPRINTF(AMI_D_CMD, ("got#%d ", mbox.acc_nstat)); | |||
1504 | for (i = 0; i < mbox.acc_nstat; i++ ) { | |||
1505 | ready = mbox.acc_cmplidl[i] - 1; | |||
1506 | AMI_DPRINTF(AMI_D_CMD, ("ready=%d ", ready)); | |||
1507 | ||||
1508 | ccb = &sc->sc_ccbs[ready]; | |||
1509 | ccb->ccb_status = mbox.acc_status; | |||
1510 | ccb->ccb_state = AMI_CCB_READY; | |||
1511 | TAILQ_REMOVE(&ccb->ccb_sc->sc_ccb_runq, ccb, ccb_link)do { if (((ccb)->ccb_link.tqe_next) != ((void *)0)) (ccb)-> ccb_link.tqe_next->ccb_link.tqe_prev = (ccb)->ccb_link. tqe_prev; else (&ccb->ccb_sc->sc_ccb_runq)->tqh_last = (ccb)->ccb_link.tqe_prev; *(ccb)->ccb_link.tqe_prev = (ccb)->ccb_link.tqe_next; ((ccb)->ccb_link.tqe_prev) = ((void *)-1); ((ccb)->ccb_link.tqe_next) = ((void *)-1); } while (0); | |||
1512 | ||||
1513 | mtx_leave(&sc->sc_cmd_mtx); | |||
1514 | ccb->ccb_done(sc, ccb); | |||
1515 | mtx_enter(&sc->sc_cmd_mtx); | |||
1516 | ||||
1517 | rv = 1; | |||
1518 | } | |||
1519 | } | |||
1520 | ready = (sc->sc_drainio && TAILQ_EMPTY(&sc->sc_ccb_runq)(((&sc->sc_ccb_runq)->tqh_first) == ((void *)0))); | |||
1521 | mtx_leave(&sc->sc_cmd_mtx); | |||
1522 | ||||
1523 | if (ready) | |||
1524 | wakeup(sc); | |||
1525 | else if (rv) | |||
1526 | ami_runqueue(sc); | |||
1527 | ||||
1528 | AMI_DPRINTF(AMI_D_INTR, ("exit ")); | |||
1529 | return (rv); | |||
1530 | } | |||
1531 | ||||
1532 | int | |||
1533 | ami_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag) | |||
1534 | { | |||
1535 | struct ami_softc *sc = link->bus->sb_adapter_softc; | |||
1536 | /* struct device *dev = (struct device *)link->device_softc; */ | |||
1537 | /* u_int8_t target = link->target; */ | |||
1538 | ||||
1539 | if (sc->sc_ioctl) | |||
1540 | return (sc->sc_ioctl(&sc->sc_dev, cmd, addr)); | |||
1541 | else | |||
1542 | return (ENOTTY25); | |||
1543 | } | |||
1544 | ||||
1545 | #if NBIO1 > 0 | |||
1546 | int | |||
1547 | ami_ioctl(struct device *dev, u_long cmd, caddr_t addr) | |||
1548 | { | |||
1549 | struct ami_softc *sc = (struct ami_softc *)dev; | |||
1550 | int error = 0; | |||
1551 | ||||
1552 | AMI_DPRINTF(AMI_D_IOCTL, ("%s: ioctl ", DEVNAME(sc))); | |||
1553 | ||||
1554 | if (sc->sc_flags & AMI_BROKEN0x0002) | |||
1555 | return (ENODEV19); /* can't do this to broken device for now */ | |||
1556 | ||||
1557 | switch (cmd) { | |||
1558 | case BIOCINQ(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct bioc_inq) & 0x1fff) << 16) | ((('B')) << 8) | ((32))): | |||
1559 | AMI_DPRINTF(AMI_D_IOCTL, ("inq ")); | |||
1560 | error = ami_ioctl_inq(sc, (struct bioc_inq *)addr); | |||
1561 | break; | |||
1562 | ||||
1563 | case BIOCVOL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct bioc_vol) & 0x1fff) << 16) | ((('B')) << 8) | ((34))): | |||
1564 | AMI_DPRINTF(AMI_D_IOCTL, ("vol ")); | |||
1565 | error = ami_ioctl_vol(sc, (struct bioc_vol *)addr); | |||
1566 | break; | |||
1567 | ||||
1568 | case BIOCDISK(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct bioc_disk) & 0x1fff) << 16) | ((('B')) << 8) | ((33))): | |||
1569 | AMI_DPRINTF(AMI_D_IOCTL, ("disk ")); | |||
1570 | error = ami_ioctl_disk(sc, (struct bioc_disk *)addr); | |||
1571 | break; | |||
1572 | ||||
1573 | case BIOCALARM(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct bioc_alarm) & 0x1fff) << 16) | ((('B')) << 8) | ((35))): | |||
1574 | AMI_DPRINTF(AMI_D_IOCTL, ("alarm ")); | |||
1575 | error = ami_ioctl_alarm(sc, (struct bioc_alarm *)addr); | |||
1576 | break; | |||
1577 | ||||
1578 | case BIOCSETSTATE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct bioc_setstate) & 0x1fff) << 16) | ((('B')) << 8) | ((37))): | |||
1579 | AMI_DPRINTF(AMI_D_IOCTL, ("setstate ")); | |||
1580 | error = ami_ioctl_setstate(sc, (struct bioc_setstate *)addr); | |||
1581 | break; | |||
1582 | ||||
1583 | default: | |||
1584 | AMI_DPRINTF(AMI_D_IOCTL, (" invalid ioctl\n")); | |||
1585 | error = ENOTTY25; | |||
1586 | } | |||
1587 | ||||
1588 | return (error); | |||
1589 | } | |||
1590 | ||||
1591 | int | |||
1592 | ami_drv_pt(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, u_int8_t *cmd, | |||
1593 | int clen, int blen, void *buf) | |||
1594 | { | |||
1595 | struct ami_ccb *ccb; | |||
1596 | struct ami_passthrough *pt; | |||
1597 | int error = 0; | |||
1598 | ||||
1599 | rw_enter_write(&sc->sc_lock); | |||
1600 | ||||
1601 | ccb = scsi_io_get(&sc->sc_iopool, 0); | |||
1602 | if (ccb == NULL((void *)0)) { | |||
1603 | error = ENOMEM12; | |||
1604 | goto err; | |||
1605 | } | |||
1606 | ||||
1607 | ccb->ccb_done = ami_done_ioctl; | |||
1608 | ||||
1609 | ccb->ccb_cmd.acc_cmd = AMI_PASSTHRU0x03; | |||
1610 | ccb->ccb_cmd.acc_passthru_._ami_passthru.apt_data = ccb->ccb_ptpa; | |||
1611 | ||||
1612 | pt = ccb->ccb_pt; | |||
1613 | memset(pt, 0, sizeof *pt)__builtin_memset((pt), (0), (sizeof *pt)); | |||
1614 | pt->apt_channel = ch; | |||
1615 | pt->apt_target = tg; | |||
1616 | pt->apt_ncdb = clen; | |||
1617 | pt->apt_nsense = sizeof(struct scsi_sense_data); | |||
1618 | pt->apt_datalen = blen; | |||
1619 | pt->apt_data = 0; | |||
1620 | ||||
1621 | bcopy(cmd, pt->apt_cdb, clen); | |||
1622 | ||||
1623 | if (ami_load_ptmem(sc, ccb, buf, blen, 1, 0) != 0) { | |||
1624 | error = ENOMEM12; | |||
1625 | goto ptmemerr; | |||
1626 | } | |||
1627 | ||||
1628 | ami_start(sc, ccb); | |||
1629 | ||||
1630 | while (ccb->ccb_state != AMI_CCB_READY) | |||
1631 | tsleep_nsec(ccb, PRIBIO16, "ami_drv_pt", INFSLP0xffffffffffffffffULL); | |||
1632 | ||||
1633 | bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), (0x02) ) | |||
1634 | ccb->ccb_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (ccb-> ccb_dmamap), (0), (ccb->ccb_dmamap->dm_mapsize), (0x02) ); | |||
1635 | bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)) | |||
1636 | ccb->ccb_offset, sizeof(struct ami_ccbmem),(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)) | |||
1637 | BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE)(*(sc->sc_dmat)->_dmamap_sync)((sc->sc_dmat), (((sc-> sc_ccbmem_am)->am_map)), (ccb->ccb_offset), (sizeof(struct ami_ccbmem)), (0x02 | 0x08)); | |||
1638 | bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap)(*(sc->sc_dmat)->_dmamap_unload)((sc->sc_dmat), (ccb ->ccb_dmamap)); | |||
1639 | ||||
1640 | if (ccb->ccb_flags & AMI_CCB_F_ERR(1<<0)) | |||
1641 | error = EIO5; | |||
1642 | else if (pt->apt_scsistat != 0x00) | |||
1643 | error = EIO5; | |||
1644 | ||||
1645 | ptmemerr: | |||
1646 | scsi_io_put(&sc->sc_iopool, ccb); | |||
1647 | ||||
1648 | err: | |||
1649 | rw_exit_write(&sc->sc_lock); | |||
1650 | return (error); | |||
1651 | } | |||
1652 | ||||
1653 | int | |||
1654 | ami_drv_inq(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, u_int8_t page, | |||
1655 | void *inqbuf) | |||
1656 | { | |||
1657 | struct scsi_inquiry_data *inq = inqbuf; | |||
1658 | u_int8_t cdb[6]; | |||
1659 | int error = 0; | |||
1660 | ||||
1661 | bzero(&cdb, sizeof cdb)__builtin_bzero((&cdb), (sizeof cdb)); | |||
1662 | ||||
1663 | cdb[0] = INQUIRY0x12; | |||
1664 | cdb[1] = 0; | |||
1665 | cdb[2] = 0; | |||
1666 | cdb[3] = 0; | |||
1667 | cdb[4] = sizeof(struct scsi_inquiry_data); | |||
1668 | cdb[5] = 0; | |||
1669 | if (page != 0) { | |||
1670 | cdb[1] = SI_EVPD0x01; | |||
1671 | cdb[2] = page; | |||
1672 | } | |||
1673 | ||||
1674 | error = ami_drv_pt(sc, ch, tg, cdb, 6, sizeof *inq, inqbuf); | |||
1675 | if (error) | |||
1676 | return (error); | |||
1677 | ||||
1678 | if ((inq->device & SID_TYPE0x1f) != T_DIRECT0x00) | |||
1679 | error = EINVAL22; | |||
1680 | ||||
1681 | return (error); | |||
1682 | } | |||
1683 | ||||
1684 | int | |||
1685 | ami_drv_readcap(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, daddr_t *sz) | |||
1686 | { | |||
1687 | struct scsi_read_cap_data *rcd = NULL((void *)0); | |||
1688 | struct scsi_read_cap_data_16 *rcd16 = NULL((void *)0); | |||
1689 | u_int8_t cdb[16]; | |||
1690 | u_int32_t blksz; | |||
1691 | daddr_t noblk; | |||
1692 | int error = 0; | |||
1693 | ||||
1694 | bzero(&cdb, sizeof cdb)__builtin_bzero((&cdb), (sizeof cdb)); | |||
1695 | cdb[0] = READ_CAPACITY0x25; | |||
1696 | rcd = dma_alloc(sizeof(*rcd), PR_WAITOK0x0001); | |||
1697 | ||||
1698 | error = ami_drv_pt(sc, ch, tg, cdb, 10, sizeof(*rcd), rcd); | |||
1699 | if (error) | |||
1700 | goto fail; | |||
1701 | ||||
1702 | noblk = _4btol(rcd->addr); | |||
1703 | if (noblk == 0xffffffffllu) { | |||
1704 | /* huge disk */ | |||
1705 | bzero(&cdb, sizeof cdb)__builtin_bzero((&cdb), (sizeof cdb)); | |||
1706 | cdb[0] = READ_CAPACITY_160x9e; | |||
1707 | rcd16 = dma_alloc(sizeof(*rcd16), PR_WAITOK0x0001); | |||
1708 | ||||
1709 | error = ami_drv_pt(sc, ch, tg, cdb, 16, sizeof(*rcd16), rcd16); | |||
1710 | if (error) | |||
1711 | goto fail; | |||
1712 | ||||
1713 | noblk = _8btol(rcd16->addr); | |||
1714 | blksz = _4btol(rcd16->length); | |||
1715 | } else | |||
1716 | blksz = _4btol(rcd->length); | |||
1717 | ||||
1718 | if (blksz == 0) | |||
1719 | blksz = 512; | |||
1720 | *sz = noblk * blksz; | |||
1721 | ||||
1722 | fail: | |||
1723 | if (rcd16) | |||
1724 | dma_free(rcd16, sizeof(*rcd16)); | |||
1725 | dma_free(rcd, sizeof(*rcd)); | |||
1726 | return (error); | |||
1727 | } | |||
1728 | ||||
1729 | int | |||
1730 | ami_mgmt(struct ami_softc *sc, u_int8_t opcode, u_int8_t par1, u_int8_t par2, | |||
1731 | u_int8_t par3, size_t size, void *buffer) | |||
1732 | { | |||
1733 | struct ami_ccb *ccb; | |||
1734 | struct ami_iocmd *cmd; | |||
1735 | struct ami_mem *am = NULL((void *)0); | |||
1736 | char *idata = NULL((void *)0); | |||
1737 | int error = 0; | |||
1738 | ||||
1739 | rw_enter_write(&sc->sc_lock); | |||
1740 | ||||
1741 | if (opcode != AMI_CHSTATE0x06) { | |||
1742 | ccb = scsi_io_get(&sc->sc_iopool, 0); | |||
1743 | if (ccb == NULL((void *)0)) { | |||
1744 | error = ENOMEM12; | |||
1745 | goto err; | |||
1746 | } | |||
1747 | ccb->ccb_done = ami_done_ioctl; | |||
1748 | } else | |||
1749 | ccb = sc->sc_mgmtccb; | |||
1750 | ||||
1751 | if (size) { | |||
1752 | if ((am = ami_allocmem(sc, size)) == NULL((void *)0)) { | |||
1753 | error = ENOMEM12; | |||
1754 | goto memerr; | |||
1755 | } | |||
1756 | idata = AMIMEM_KVA(am)((void *)(am)->am_kva); | |||
1757 | } | |||
1758 | ||||
1759 | cmd = &ccb->ccb_cmd; | |||
1760 | cmd->acc_cmd = opcode; | |||
1761 | ||||
1762 | /* | |||
1763 | * some commands require data to be written to idata before sending | |||
1764 | * command to fw | |||
1765 | */ | |||
1766 | switch (opcode) { | |||
1767 | case AMI_SPEAKER0x51: | |||
1768 | *idata = par1; | |||
1769 | break; | |||
1770 | default: | |||
1771 | cmd->acc_io_._ami_io.aio_channel = par1; | |||
1772 | cmd->acc_io_._ami_io.aio_param = par2; | |||
1773 | cmd->acc_io_._ami_io.aio_pad[0] = par3; | |||
1774 | break; | |||
1775 | }; | |||
1776 | ||||
1777 | cmd->acc_io_._ami_io.aio_data = am ? htole32(AMIMEM_DVA(am))((__uint32_t)(((am)->am_map->dm_segs[0].ds_addr))) : 0; | |||
1778 | ||||
1779 | if (opcode != AMI_CHSTATE0x06) { | |||
1780 | ami_start(sc, ccb); | |||
1781 | mtx_enter(&sc->sc_cmd_mtx); | |||
1782 | while (ccb->ccb_state != AMI_CCB_READY) | |||
1783 | msleep_nsec(ccb, &sc->sc_cmd_mtx, PRIBIO16, "ami_mgmt", | |||
1784 | INFSLP0xffffffffffffffffULL); | |||
1785 | mtx_leave(&sc->sc_cmd_mtx); | |||
1786 | } else { | |||
1787 | /* change state must be run with id 0xfe and MUST be polled */ | |||
1788 | mtx_enter(&sc->sc_cmd_mtx); | |||
1789 | sc->sc_drainio = 1; | |||
1790 | while (!TAILQ_EMPTY(&sc->sc_ccb_runq)(((&sc->sc_ccb_runq)->tqh_first) == ((void *)0))) { | |||
1791 | if (msleep_nsec(sc, &sc->sc_cmd_mtx, PRIBIO16, | |||
1792 | "amimgmt", SEC_TO_NSEC(60)) == EWOULDBLOCK35) { | |||
1793 | printf("%s: drain io timeout\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); | |||
1794 | ccb->ccb_flags |= AMI_CCB_F_ERR(1<<0); | |||
1795 | goto restartio; | |||
1796 | } | |||
1797 | } | |||
1798 | ||||
1799 | error = sc->sc_poll(sc, &ccb->ccb_cmd); | |||
1800 | if (error == -1) | |||
1801 | ccb->ccb_flags |= AMI_CCB_F_ERR(1<<0); | |||
1802 | ||||
1803 | restartio: | |||
1804 | /* restart io */ | |||
1805 | sc->sc_drainio = 0; | |||
1806 | mtx_leave(&sc->sc_cmd_mtx); | |||
1807 | ami_runqueue(sc); | |||
1808 | } | |||
1809 | ||||
1810 | if (ccb->ccb_flags & AMI_CCB_F_ERR(1<<0)) | |||
1811 | error = EIO5; | |||
1812 | else if (buffer && size) | |||
1813 | memcpy(buffer, idata, size)__builtin_memcpy((buffer), (idata), (size)); | |||
1814 | ||||
1815 | if (am) | |||
1816 | ami_freemem(sc, am); | |||
1817 | memerr: | |||
1818 | if (opcode != AMI_CHSTATE0x06) { | |||
1819 | scsi_io_put(&sc->sc_iopool, ccb); | |||
1820 | } else { | |||
1821 | ccb->ccb_flags = 0; | |||
1822 | ccb->ccb_state = AMI_CCB_FREE; | |||
1823 | } | |||
1824 | ||||
1825 | err: | |||
1826 | rw_exit_write(&sc->sc_lock); | |||
1827 | return (error); | |||
1828 | } | |||
1829 | ||||
1830 | int | |||
1831 | ami_ioctl_inq(struct ami_softc *sc, struct bioc_inq *bi) | |||
1832 | { | |||
1833 | struct ami_big_diskarray *p; /* struct too large for stack */ | |||
1834 | struct scsi_inquiry_data *inqbuf; | |||
1835 | struct ami_fc_einquiry einq; | |||
1836 | int ch, tg; | |||
1837 | int i, s, t, off; | |||
1838 | int error = 0, changes = 0; | |||
1839 | ||||
1840 | if ((error = ami_mgmt(sc, AMI_FCOP0xa1, AMI_FC_EINQ30x0f, | |||
1841 | AMI_FC_EINQ3_SOLICITED_FULL0x02, 0, sizeof einq, &einq))) | |||
1842 | return (EINVAL22); | |||
1843 | ||||
1844 | inqbuf = dma_alloc(sizeof(*inqbuf), PR_WAITOK0x0001); | |||
1845 | ||||
1846 | if (einq.ain_drvinscnt == sc->sc_drvinscnt) { | |||
1847 | /* poke existing known drives to make sure they aren't gone */ | |||
1848 | for(i = 0; i < sc->sc_channels * 16; i++) { | |||
1849 | if (sc->sc_plist[i] == 0) | |||
1850 | continue; | |||
1851 | ||||
1852 | ch = (i & 0xf0) >> 4; | |||
1853 | tg = i & 0x0f; | |||
1854 | if (ami_drv_inq(sc, ch, tg, 0, inqbuf)) { | |||
1855 | /* drive is gone, force rescan */ | |||
1856 | changes = 1; | |||
1857 | break; | |||
1858 | } | |||
1859 | } | |||
1860 | if (changes == 0) { | |||
1861 | bcopy(&sc->sc_bi, bi, sizeof *bi); | |||
1862 | goto done; | |||
1863 | } | |||
1864 | } | |||
1865 | ||||
1866 | sc->sc_drvinscnt = einq.ain_drvinscnt; | |||
1867 | ||||
1868 | p = malloc(sizeof *p, M_DEVBUF2, M_NOWAIT0x0002); | |||
1869 | if (!p) { | |||
1870 | error = ENOMEM12; | |||
1871 | goto done; | |||
1872 | } | |||
1873 | ||||
1874 | if ((error = ami_mgmt(sc, AMI_FCOP0xa1, AMI_FC_RDCONF0x04, 0, 0, sizeof *p, | |||
1875 | p))) { | |||
1876 | error = EINVAL22; | |||
1877 | goto bail; | |||
1878 | } | |||
1879 | ||||
1880 | bzero(sc->sc_plist, sizeof sc->sc_plist)__builtin_bzero((sc->sc_plist), (sizeof sc->sc_plist)); | |||
1881 | ||||
1882 | bi->bi_novol = p->ada_nld; | |||
1883 | bi->bi_nodisk = 0; | |||
1884 | strlcpy(bi->bi_dev, DEVNAME(sc)((sc)->sc_dev.dv_xname), sizeof(bi->bi_dev)); | |||
1885 | ||||
1886 | /* count used disks, including failed ones */ | |||
1887 | for (i = 0; i < p->ada_nld; i++) | |||
1888 | for (s = 0; s < p->aldada_ldrv[i].adl_spandepth; s++) | |||
1889 | for (t = 0; t < p->aldada_ldrv[i].adl_nstripes; t++) { | |||
1890 | off = p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_channel * | |||
1891 | AMI_MAX_TARGET16 + | |||
1892 | p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_target; | |||
1893 | ||||
1894 | /* account for multi raid vol on same disk */ | |||
1895 | if (!sc->sc_plist[off]) { | |||
1896 | sc->sc_plist[off] = 1; | |||
1897 | bi->bi_nodisk++; | |||
1898 | } | |||
1899 | } | |||
1900 | ||||
1901 | /* count unused disks */ | |||
1902 | for(i = 0; i < sc->sc_channels * 16; i++) { | |||
1903 | if (sc->sc_plist[i]) | |||
1904 | continue; /* skip claimed drives */ | |||
1905 | ||||
1906 | /* | |||
1907 | * hack to invalidate device type, needed for initiator id | |||
1908 | * on an unconnected channel. | |||
1909 | * XXX find out if we can determine this differently | |||
1910 | */ | |||
1911 | memset(inqbuf, 0xff, sizeof(*inqbuf))__builtin_memset((inqbuf), (0xff), (sizeof(*inqbuf))); | |||
1912 | ||||
1913 | ch = (i & 0xf0) >> 4; | |||
1914 | tg = i & 0x0f; | |||
1915 | if (!ami_drv_inq(sc, ch, tg, 0, inqbuf)) { | |||
1916 | if ((inqbuf->device & SID_TYPE0x1f) != T_DIRECT0x00) | |||
1917 | continue; | |||
1918 | bi->bi_novol++; | |||
1919 | bi->bi_nodisk++; | |||
1920 | sc->sc_plist[i] = 2; | |||
1921 | } else | |||
1922 | sc->sc_plist[i] = 0; | |||
1923 | } | |||
1924 | ||||
1925 | bcopy(bi, &sc->sc_bi, sizeof sc->sc_bi); | |||
1926 | error = 0; | |||
1927 | bail: | |||
1928 | free(p, M_DEVBUF2, sizeof *p); | |||
1929 | done: | |||
1930 | dma_free(inqbuf, sizeof(*inqbuf)); | |||
1931 | return (error); | |||
1932 | } | |||
1933 | ||||
1934 | int | |||
1935 | ami_vol(struct ami_softc *sc, struct bioc_vol *bv, struct ami_big_diskarray *p) | |||
1936 | { | |||
1937 | int i, ld = p->ada_nld, error = EINVAL22; | |||
1938 | ||||
1939 | for(i = 0; i < sc->sc_channels * 16; i++) { | |||
1940 | /* skip claimed/unused drives */ | |||
1941 | if (sc->sc_plist[i] != 2) | |||
1942 | continue; | |||
1943 | ||||
1944 | /* are we it? */ | |||
1945 | if (ld != bv->bv_volid) { | |||
1946 | ld++; | |||
1947 | continue; | |||
1948 | } | |||
1949 | ||||
1950 | bv->bv_status = BIOC_SVONLINE0x00; | |||
1951 | bv->bv_size = (uint64_t)p->apdada_pdrv[i].adp_size * | |||
1952 | (uint64_t)512; | |||
1953 | bv->bv_nodisk = 1; | |||
1954 | strlcpy(bv->bv_dev, | |||
1955 | sc->sc_hdr[bv->bv_volid].dev, | |||
1956 | sizeof(bv->bv_dev)); | |||
1957 | ||||
1958 | if (p->apdada_pdrv[i].adp_ostatus == AMI_PD_HOTSPARE6 | |||
1959 | && p->apdada_pdrv[i].adp_type == 0) | |||
1960 | bv->bv_level = -1; | |||
1961 | else | |||
1962 | bv->bv_level = -2; | |||
1963 | ||||
1964 | error = 0; | |||
1965 | goto bail; | |||
1966 | } | |||
1967 | ||||
1968 | bail: | |||
1969 | return (error); | |||
1970 | } | |||
1971 | ||||
1972 | int | |||
1973 | ami_disk(struct ami_softc *sc, struct bioc_disk *bd, | |||
1974 | struct ami_big_diskarray *p) | |||
1975 | { | |||
1976 | char vend[8+16+4+1], *vendp; | |||
1977 | char ser[32 + 1]; | |||
1978 | struct scsi_inquiry_data *inqbuf; | |||
1979 | struct scsi_vpd_serial *vpdbuf; | |||
1980 | int i, ld = p->ada_nld, error = EINVAL22; | |||
1981 | u_int8_t ch, tg; | |||
1982 | daddr_t sz = 0; | |||
1983 | ||||
1984 | inqbuf = dma_alloc(sizeof(*inqbuf), PR_WAITOK0x0001); | |||
1985 | vpdbuf = dma_alloc(sizeof(*vpdbuf), PR_WAITOK0x0001); | |||
1986 | ||||
1987 | for(i = 0; i < sc->sc_channels * 16; i++) { | |||
1988 | /* skip claimed/unused drives */ | |||
1989 | if (sc->sc_plist[i] != 2) | |||
1990 | continue; | |||
1991 | ||||
1992 | /* are we it? */ | |||
1993 | if (ld != bd->bd_volid) { | |||
1994 | ld++; | |||
1995 | continue; | |||
1996 | } | |||
1997 | ||||
1998 | ch = (i & 0xf0) >> 4; | |||
1999 | tg = i & 0x0f; | |||
2000 | if (ami_drv_inq(sc, ch, tg, 0, inqbuf)) | |||
2001 | goto bail; | |||
2002 | ||||
2003 | vendp = inqbuf->vendor; | |||
2004 | bcopy(vendp, vend, sizeof vend - 1); | |||
2005 | ||||
2006 | vend[sizeof vend - 1] = '\0'; | |||
2007 | strlcpy(bd->bd_vendor, vend, sizeof(bd->bd_vendor)); | |||
2008 | ||||
2009 | if (!ami_drv_inq(sc, ch, tg, 0x80, vpdbuf)) { | |||
2010 | bcopy(vpdbuf->serial, ser, sizeof ser - 1); | |||
2011 | ser[sizeof ser - 1] = '\0'; | |||
2012 | if (_2btol(vpdbuf->hdr.page_length) < sizeof ser) | |||
2013 | ser[_2btol(vpdbuf->hdr.page_length)] = '\0'; | |||
2014 | strlcpy(bd->bd_serial, ser, sizeof(bd->bd_serial)); | |||
2015 | } | |||
2016 | ||||
2017 | error = ami_drv_readcap(sc, ch, tg, &sz); | |||
2018 | if (error) | |||
2019 | goto bail; | |||
2020 | ||||
2021 | bd->bd_size = sz; | |||
2022 | bd->bd_channel = ch; | |||
2023 | bd->bd_target = tg; | |||
2024 | ||||
2025 | strlcpy(bd->bd_procdev, sc->sc_rawsoftcs[ch].sc_procdev, | |||
2026 | sizeof(bd->bd_procdev)); | |||
2027 | ||||
2028 | if (p->apdada_pdrv[i].adp_ostatus == AMI_PD_HOTSPARE6) | |||
2029 | bd->bd_status = BIOC_SDHOTSPARE0x04; | |||
2030 | else | |||
2031 | bd->bd_status = BIOC_SDUNUSED0x05; | |||
2032 | ||||
2033 | #ifdef AMI_DEBUG | |||
2034 | if (p->apdada_pdrv[i].adp_type != 0) | |||
2035 | printf("invalid disk type: %d %d %x inquiry type: %x\n", | |||
2036 | ch, tg, p->apdada_pdrv[i].adp_type, inqbuf->device); | |||
2037 | #endif /* AMI_DEBUG */ | |||
2038 | ||||
2039 | error = 0; | |||
2040 | goto bail; | |||
2041 | } | |||
2042 | ||||
2043 | bail: | |||
2044 | dma_free(inqbuf, sizeof(*inqbuf)); | |||
2045 | dma_free(vpdbuf, sizeof(*vpdbuf)); | |||
2046 | return (error); | |||
2047 | } | |||
2048 | ||||
2049 | int | |||
2050 | ami_ioctl_vol(struct ami_softc *sc, struct bioc_vol *bv) | |||
2051 | { | |||
2052 | struct ami_big_diskarray *p; /* struct too large for stack */ | |||
2053 | int i, s, t, off; | |||
2054 | int error = 0; | |||
2055 | struct ami_progress perc; | |||
2056 | u_int8_t bgi[5]; /* 40 LD, 1 bit per LD if BGI is active */ | |||
2057 | ||||
2058 | p = malloc(sizeof *p, M_DEVBUF2, M_NOWAIT0x0002); | |||
2059 | if (!p) | |||
2060 | return (ENOMEM12); | |||
2061 | ||||
2062 | if ((error = ami_mgmt(sc, AMI_FCOP0xa1, AMI_FC_RDCONF0x04, 0, 0, sizeof *p, p))) | |||
2063 | goto bail; | |||
2064 | ||||
2065 | if (bv->bv_volid >= p->ada_nld) { | |||
2066 | error = ami_vol(sc, bv, p); | |||
2067 | goto bail; | |||
2068 | } | |||
2069 | ||||
2070 | i = bv->bv_volid; | |||
2071 | ||||
2072 | switch (p->aldada_ldrv[i].adl_status) { | |||
2073 | case AMI_RDRV_OFFLINE0: | |||
2074 | bv->bv_status = BIOC_SVOFFLINE0x01; | |||
2075 | break; | |||
2076 | ||||
2077 | case AMI_RDRV_DEGRADED1: | |||
2078 | bv->bv_status = BIOC_SVDEGRADED0x02; | |||
2079 | break; | |||
2080 | ||||
2081 | case AMI_RDRV_OPTIMAL2: | |||
2082 | bv->bv_status = BIOC_SVONLINE0x00; | |||
2083 | bv->bv_percent = -1; | |||
2084 | ||||
2085 | /* get BGI progress here and over-ride status if so */ | |||
2086 | memset(bgi, 0, sizeof bgi)__builtin_memset((bgi), (0), (sizeof bgi)); | |||
2087 | if (ami_mgmt(sc, AMI_MISC0xa4, AMI_GET_BGI0x13, 0, 0, sizeof bgi, &bgi)) | |||
2088 | break; | |||
2089 | ||||
2090 | if ((bgi[i / 8] & (1 << i % 8)) == 0) | |||
2091 | break; | |||
2092 | ||||
2093 | if (!ami_mgmt(sc, AMI_GCHECKPROGR0x19, i, 0, 0, sizeof perc, &perc)) | |||
2094 | if (perc.apr_progress < 100) { | |||
2095 | bv->bv_status = BIOC_SVSCRUB0x04; | |||
2096 | bv->bv_percent = perc.apr_progress >= 100 ? -1 : | |||
2097 | perc.apr_progress; | |||
2098 | } | |||
2099 | break; | |||
2100 | ||||
2101 | default: | |||
2102 | bv->bv_status = BIOC_SVINVALID0xff; | |||
2103 | } | |||
2104 | ||||
2105 | /* over-ride status if a pd is in rebuild status for this ld */ | |||
2106 | for (s = 0; s < p->aldada_ldrv[i].adl_spandepth; s++) | |||
2107 | for (t = 0; t < p->aldada_ldrv[i].adl_nstripes; t++) { | |||
2108 | off = p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_channel * | |||
2109 | AMI_MAX_TARGET16 + | |||
2110 | p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_target; | |||
2111 | ||||
2112 | if (p->apdada_pdrv[off].adp_ostatus != AMI_PD_RBLD5) | |||
2113 | continue; | |||
2114 | ||||
2115 | /* get rebuild progress from pd 0 */ | |||
2116 | bv->bv_status = BIOC_SVREBUILD0x05; | |||
2117 | if (ami_mgmt(sc, AMI_GRBLDPROGR0x18, | |||
2118 | p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_channel, | |||
2119 | p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_target, 0, | |||
2120 | sizeof perc, &perc)) | |||
2121 | bv->bv_percent = -1; | |||
2122 | else | |||
2123 | bv->bv_percent = perc.apr_progress >= 100 ? -1 : | |||
2124 | perc.apr_progress; | |||
2125 | break; | |||
2126 | } | |||
2127 | ||||
2128 | bv->bv_size = 0; | |||
2129 | bv->bv_level = p->aldada_ldrv[i].adl_raidlvl; | |||
2130 | bv->bv_nodisk = 0; | |||
2131 | ||||
2132 | for (s = 0; s < p->aldada_ldrv[i].adl_spandepth; s++) { | |||
2133 | for (t = 0; t < p->aldada_ldrv[i].adl_nstripes; t++) | |||
2134 | bv->bv_nodisk++; | |||
2135 | ||||
2136 | switch (bv->bv_level) { | |||
2137 | case 0: | |||
2138 | bv->bv_size += p->aldada_ldrv[i].aspadl_spans[s].ads_length * | |||
2139 | p->aldada_ldrv[i].adl_nstripes; | |||
2140 | break; | |||
2141 | ||||
2142 | case 1: | |||
2143 | bv->bv_size += p->aldada_ldrv[i].aspadl_spans[s].ads_length; | |||
2144 | break; | |||
2145 | ||||
2146 | case 5: | |||
2147 | bv->bv_size += p->aldada_ldrv[i].aspadl_spans[s].ads_length * | |||
2148 | (p->aldada_ldrv[i].adl_nstripes - 1); | |||
2149 | break; | |||
2150 | } | |||
2151 | } | |||
2152 | ||||
2153 | if (p->aldada_ldrv[i].adl_spandepth > 1) | |||
2154 | bv->bv_level *= 10; | |||
2155 | ||||
2156 | bv->bv_size *= (uint64_t)512; | |||
2157 | ||||
2158 | strlcpy(bv->bv_dev, sc->sc_hdr[i].dev, sizeof(bv->bv_dev)); | |||
2159 | ||||
2160 | bail: | |||
2161 | free(p, M_DEVBUF2, sizeof *p); | |||
2162 | ||||
2163 | return (error); | |||
2164 | } | |||
2165 | ||||
2166 | int | |||
2167 | ami_ioctl_disk(struct ami_softc *sc, struct bioc_disk *bd) | |||
2168 | { | |||
2169 | struct scsi_inquiry_data *inqbuf; | |||
2170 | struct scsi_vpd_serial *vpdbuf; | |||
2171 | struct ami_big_diskarray *p; /* struct too large for stack */ | |||
2172 | int i, s, t, d; | |||
2173 | int off; | |||
2174 | int error = EINVAL22; | |||
2175 | u_int16_t ch, tg; | |||
2176 | char vend[8+16+4+1], *vendp; | |||
2177 | char ser[32 + 1]; | |||
2178 | ||||
2179 | inqbuf = dma_alloc(sizeof(*inqbuf), PR_WAITOK0x0001); | |||
2180 | vpdbuf = dma_alloc(sizeof(*inqbuf), PR_WAITOK0x0001); | |||
2181 | p = malloc(sizeof *p, M_DEVBUF2, M_WAITOK0x0001); | |||
2182 | ||||
2183 | if ((error = ami_mgmt(sc, AMI_FCOP0xa1, AMI_FC_RDCONF0x04, 0, 0, sizeof *p, p))) | |||
2184 | goto bail; | |||
2185 | ||||
2186 | if (bd->bd_volid >= p->ada_nld) { | |||
2187 | error = ami_disk(sc, bd, p); | |||
2188 | goto bail; | |||
2189 | } | |||
2190 | ||||
2191 | i = bd->bd_volid; | |||
2192 | for (s = 0, d = 0; s < p->aldada_ldrv[i].adl_spandepth; s++) | |||
2193 | for (t = 0; t < p->aldada_ldrv[i].adl_nstripes; t++) { | |||
2194 | if (d != bd->bd_diskid) { | |||
2195 | d++; | |||
2196 | continue; | |||
2197 | } | |||
2198 | ||||
2199 | off = p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_channel * | |||
2200 | AMI_MAX_TARGET16 + | |||
2201 | p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_target; | |||
2202 | ||||
2203 | bd->bd_size = (uint64_t)p->apdada_pdrv[off].adp_size * | |||
2204 | (uint64_t)512; | |||
2205 | ||||
2206 | switch (p->apdada_pdrv[off].adp_ostatus) { | |||
2207 | case AMI_PD_UNCNF0: | |||
2208 | bd->bd_status = BIOC_SDUNUSED0x05; | |||
2209 | break; | |||
2210 | ||||
2211 | case AMI_PD_ONLINE3: | |||
2212 | bd->bd_status = BIOC_SDONLINE0x00; | |||
2213 | break; | |||
2214 | ||||
2215 | case AMI_PD_FAILED4: | |||
2216 | bd->bd_status = BIOC_SDFAILED0x02; | |||
2217 | bd->bd_size = 0; | |||
2218 | break; | |||
2219 | ||||
2220 | case AMI_PD_RBLD5: | |||
2221 | bd->bd_status = BIOC_SDREBUILD0x03; | |||
2222 | break; | |||
2223 | ||||
2224 | case AMI_PD_HOTSPARE6: | |||
2225 | bd->bd_status = BIOC_SDHOTSPARE0x04; | |||
2226 | break; | |||
2227 | ||||
2228 | default: | |||
2229 | bd->bd_status = BIOC_SDINVALID0xff; | |||
2230 | bd->bd_size = 0; | |||
2231 | } | |||
2232 | ||||
2233 | ||||
2234 | ch = p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_target >> 4; | |||
2235 | tg = p->aldada_ldrv[i].aspadl_spans[s].advads_devs[t].add_target & 0x0f; | |||
2236 | ||||
2237 | bd->bd_channel = ch; | |||
2238 | bd->bd_target = tg; | |||
2239 | strlcpy(bd->bd_procdev, sc->sc_rawsoftcs[ch].sc_procdev, | |||
2240 | sizeof(bd->bd_procdev)); | |||
2241 | ||||
2242 | /* if we are failed don't query drive */ | |||
2243 | if (bd->bd_size == 0) { | |||
2244 | bzero(&bd->bd_vendor, sizeof(bd->bd_vendor))__builtin_bzero((&bd->bd_vendor), (sizeof(bd->bd_vendor ))); | |||
2245 | bzero(&bd->bd_serial, sizeof(bd->bd_serial))__builtin_bzero((&bd->bd_serial), (sizeof(bd->bd_serial ))); | |||
2246 | goto done; | |||
2247 | } | |||
2248 | ||||
2249 | if (!ami_drv_inq(sc, ch, tg, 0, inqbuf)) { | |||
2250 | vendp = inqbuf->vendor; | |||
2251 | bcopy(vendp, vend, sizeof vend - 1); | |||
2252 | vend[sizeof vend - 1] = '\0'; | |||
2253 | strlcpy(bd->bd_vendor, vend, | |||
2254 | sizeof(bd->bd_vendor)); | |||
2255 | } | |||
2256 | ||||
2257 | if (!ami_drv_inq(sc, ch, tg, 0x80, vpdbuf)) { | |||
2258 | bcopy(vpdbuf->serial, ser, sizeof ser - 1); | |||
2259 | ser[sizeof ser - 1] = '\0'; | |||
2260 | if (_2btol(vpdbuf->hdr.page_length) < | |||
2261 | sizeof(ser)) | |||
2262 | ser[_2btol(vpdbuf->hdr.page_length)] = | |||
2263 | '\0'; | |||
2264 | strlcpy(bd->bd_serial, ser, | |||
2265 | sizeof(bd->bd_serial)); | |||
2266 | } | |||
2267 | goto done; | |||
2268 | } | |||
2269 | ||||
2270 | done: | |||
2271 | error = 0; | |||
2272 | bail: | |||
2273 | free(p, M_DEVBUF2, sizeof *p); | |||
2274 | dma_free(vpdbuf, sizeof(*vpdbuf)); | |||
2275 | dma_free(inqbuf, sizeof(*inqbuf)); | |||
2276 | ||||
2277 | return (error); | |||
2278 | } | |||
2279 | ||||
2280 | int ami_ioctl_alarm(struct ami_softc *sc, struct bioc_alarm *ba) | |||
2281 | { | |||
2282 | int error = 0; | |||
2283 | u_int8_t func, ret; | |||
2284 | ||||
2285 | switch(ba->ba_opcode) { | |||
2286 | case BIOC_SADISABLE0x00: | |||
2287 | func = AMI_SPKR_OFF0; | |||
2288 | break; | |||
2289 | ||||
2290 | case BIOC_SAENABLE0x01: | |||
2291 | func = AMI_SPKR_ON1; | |||
2292 | break; | |||
2293 | ||||
2294 | case BIOC_SASILENCE0x02: | |||
2295 | func = AMI_SPKR_SHUT2; | |||
2296 | break; | |||
2297 | ||||
2298 | case BIOC_GASTATUS0x03: | |||
2299 | func = AMI_SPKR_GVAL3; | |||
2300 | break; | |||
2301 | ||||
2302 | case BIOC_SATEST0x04: | |||
2303 | func = AMI_SPKR_TEST4; | |||
2304 | break; | |||
2305 | ||||
2306 | default: | |||
2307 | AMI_DPRINTF(AMI_D_IOCTL, ("%s: biocalarm invalid opcode %x\n", | |||
2308 | DEVNAME(sc), ba->ba_opcode)); | |||
2309 | return (EINVAL22); | |||
2310 | } | |||
2311 | ||||
2312 | if (!(error = ami_mgmt(sc, AMI_SPEAKER0x51, func, 0, 0, sizeof ret, | |||
2313 | &ret))) { | |||
2314 | if (ba->ba_opcode == BIOC_GASTATUS0x03) | |||
2315 | ba->ba_status = ret; | |||
2316 | else | |||
2317 | ba->ba_status = 0; | |||
2318 | } | |||
2319 | ||||
2320 | return (error); | |||
2321 | } | |||
2322 | ||||
2323 | int | |||
2324 | ami_ioctl_setstate(struct ami_softc *sc, struct bioc_setstate *bs) | |||
2325 | { | |||
2326 | struct scsi_inquiry_data *inqbuf; | |||
2327 | int func, error = 0; | |||
2328 | ||||
2329 | inqbuf = dma_alloc(sizeof(*inqbuf), PR_WAITOK0x0001); | |||
2330 | ||||
2331 | switch (bs->bs_status) { | |||
2332 | case BIOC_SSONLINE0x00: | |||
2333 | func = AMI_STATE_ON3; | |||
2334 | break; | |||
2335 | ||||
2336 | case BIOC_SSOFFLINE0x01: | |||
2337 | func = AMI_STATE_FAIL4; | |||
2338 | break; | |||
2339 | ||||
2340 | case BIOC_SSHOTSPARE0x02: | |||
2341 | if (ami_drv_inq(sc, bs->bs_channel, bs->bs_target, 0, | |||
2342 | inqbuf)) { | |||
2343 | error = EINVAL22; | |||
2344 | goto done; | |||
2345 | } | |||
2346 | ||||
2347 | func = AMI_STATE_SPARE6; | |||
2348 | break; | |||
2349 | ||||
2350 | default: | |||
2351 | AMI_DPRINTF(AMI_D_IOCTL, ("%s: biocsetstate invalid opcode %x\n" | |||
2352 | , DEVNAME(sc), bs->bs_status)); | |||
2353 | error = EINVAL22; | |||
2354 | goto done; | |||
2355 | } | |||
2356 | ||||
2357 | if ((error = ami_mgmt(sc, AMI_CHSTATE0x06, bs->bs_channel, bs->bs_target, | |||
2358 | func, 0, NULL((void *)0)))) | |||
2359 | goto done; | |||
2360 | ||||
2361 | done: | |||
2362 | dma_free(inqbuf, sizeof(*inqbuf)); | |||
2363 | return (error); | |||
2364 | } | |||
2365 | ||||
2366 | #ifndef SMALL_KERNEL | |||
2367 | int | |||
2368 | ami_create_sensors(struct ami_softc *sc) | |||
2369 | { | |||
2370 | struct device *dev; | |||
2371 | struct scsibus_softc *ssc = NULL((void *)0); | |||
2372 | struct scsi_link *link; | |||
2373 | int i; | |||
2374 | ||||
2375 | TAILQ_FOREACH(dev, &alldevs, dv_list)for((dev) = ((&alldevs)->tqh_first); (dev) != ((void * )0); (dev) = ((dev)->dv_list.tqe_next)) { | |||
2376 | if (dev->dv_parent != &sc->sc_dev) | |||
2377 | continue; | |||
2378 | ||||
2379 | /* check if this is the scsibus for the logical disks */ | |||
2380 | ssc = (struct scsibus_softc *)dev; | |||
2381 | if (ssc == sc->sc_scsibus) | |||
2382 | break; | |||
2383 | } | |||
2384 | ||||
2385 | if (ssc == NULL((void *)0)) | |||
2386 | return (1); | |||
2387 | ||||
2388 | sc->sc_sensors = mallocarray(sc->sc_nunits, sizeof(struct ksensor), | |||
2389 | M_DEVBUF2, M_WAITOK0x0001|M_CANFAIL0x0004|M_ZERO0x0008); | |||
2390 | if (sc->sc_sensors == NULL((void *)0)) | |||
2391 | return (1); | |||
2392 | ||||
2393 | strlcpy(sc->sc_sensordev.xname, DEVNAME(sc)((sc)->sc_dev.dv_xname), | |||
2394 | sizeof(sc->sc_sensordev.xname)); | |||
2395 | ||||
2396 | for (i = 0; i < sc->sc_nunits; i++) { | |||
2397 | link = scsi_get_link(ssc, i, 0); | |||
2398 | if (link == NULL((void *)0)) | |||
2399 | goto bad; | |||
2400 | ||||
2401 | dev = link->device_softc; | |||
2402 | ||||
2403 | sc->sc_sensors[i].type = SENSOR_DRIVE; | |||
2404 | sc->sc_sensors[i].status = SENSOR_S_UNKNOWN; | |||
2405 | ||||
2406 | strlcpy(sc->sc_sensors[i].desc, dev->dv_xname, | |||
2407 | sizeof(sc->sc_sensors[i].desc)); | |||
2408 | ||||
2409 | sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i]); | |||
2410 | } | |||
2411 | ||||
2412 | sc->sc_bd = malloc(sizeof(*sc->sc_bd), M_DEVBUF2, M_WAITOK0x0001|M_CANFAIL0x0004); | |||
2413 | if (sc->sc_bd == NULL((void *)0)) | |||
2414 | goto bad; | |||
2415 | ||||
2416 | if (sensor_task_register(sc, ami_refresh_sensors, 10) == NULL((void *)0)) | |||
2417 | goto freebd; | |||
2418 | ||||
2419 | sensordev_install(&sc->sc_sensordev); | |||
2420 | ||||
2421 | return (0); | |||
2422 | ||||
2423 | freebd: | |||
2424 | free(sc->sc_bd, M_DEVBUF2, sizeof(*sc->sc_bd)); | |||
2425 | bad: | |||
2426 | free(sc->sc_sensors, M_DEVBUF2, sc->sc_nunits * sizeof(struct ksensor)); | |||
2427 | ||||
2428 | return (1); | |||
2429 | } | |||
2430 | ||||
2431 | void | |||
2432 | ami_refresh_sensors(void *arg) | |||
2433 | { | |||
2434 | struct ami_softc *sc = arg; | |||
2435 | int i; | |||
2436 | ||||
2437 | if (ami_mgmt(sc, AMI_FCOP0xa1, AMI_FC_RDCONF0x04, 0, 0, sizeof(*sc->sc_bd), | |||
2438 | sc->sc_bd)) { | |||
2439 | for (i = 0; i < sc->sc_nunits; i++) { | |||
2440 | sc->sc_sensors[i].value = 0; /* unknown */ | |||
2441 | sc->sc_sensors[i].status = SENSOR_S_UNKNOWN; | |||
2442 | } | |||
2443 | return; | |||
2444 | } | |||
2445 | ||||
2446 | for (i = 0; i < sc->sc_nunits; i++) { | |||
2447 | switch (sc->sc_bd->aldada_ldrv[i].adl_status) { | |||
2448 | case AMI_RDRV_OFFLINE0: | |||
2449 | sc->sc_sensors[i].value = SENSOR_DRIVE_FAIL9; | |||
2450 | sc->sc_sensors[i].status = SENSOR_S_CRIT; | |||
2451 | break; | |||
2452 | ||||
2453 | case AMI_RDRV_DEGRADED1: | |||
2454 | sc->sc_sensors[i].value = SENSOR_DRIVE_PFAIL10; | |||
2455 | sc->sc_sensors[i].status = SENSOR_S_WARN; | |||
2456 | break; | |||
2457 | ||||
2458 | case AMI_RDRV_OPTIMAL2: | |||
2459 | sc->sc_sensors[i].value = SENSOR_DRIVE_ONLINE4; | |||
2460 | sc->sc_sensors[i].status = SENSOR_S_OK; | |||
2461 | break; | |||
2462 | ||||
2463 | default: | |||
2464 | sc->sc_sensors[i].value = 0; /* unknown */ | |||
2465 | sc->sc_sensors[i].status = SENSOR_S_UNKNOWN; | |||
2466 | } | |||
2467 | } | |||
2468 | } | |||
2469 | #endif /* SMALL_KERNEL */ | |||
2470 | #endif /* NBIO > 0 */ | |||
2471 | ||||
2472 | #ifdef AMI_DEBUG | |||
2473 | void | |||
2474 | ami_print_mbox(struct ami_iocmd *mbox) | |||
2475 | { | |||
2476 | int i; | |||
2477 | ||||
2478 | printf("acc_cmd: %d aac_id: %d acc_busy: %d acc_nstat: %d ", | |||
2479 | mbox->acc_cmd, mbox->acc_id, mbox->acc_busy, mbox->acc_nstat); | |||
2480 | printf("acc_status: %d acc_poll: %d acc_ack: %d\n", | |||
2481 | mbox->acc_status, mbox->acc_poll, mbox->acc_ack); | |||
2482 | ||||
2483 | printf("acc_cmplidl: "); | |||
2484 | for (i = 0; i < AMI_MAXSTATACK0x2e; i++) { | |||
2485 | printf("[%d] = %d ", i, mbox->acc_cmplidl[i]); | |||
2486 | } | |||
2487 | ||||
2488 | printf("\n"); | |||
2489 | } | |||
2490 | #endif /* AMI_DEBUG */ |