1 /* $NetBSD: icp.c,v 1.37 2022/04/10 09:50:45 andvar Exp $ */
2
3 /*-
4 * Copyright (c) 2002, 2003 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Doran, and by Jason R. Thorpe of Wasabi Systems, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 * 3. All advertising materials mentioning features or use of this software
44 * must display the following acknowledgement:
45 * This product includes software developed by Niklas Hallqvist.
46 * 4. The name of the author may not be used to endorse or promote products
47 * derived from this software without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
50 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
51 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
52 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
53 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
54 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
55 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
56 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
57 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
58 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 *
60 * from OpenBSD: gdt_common.c,v 1.12 2001/07/04 06:43:18 niklas Exp
61 */
62
63 /*
64 * This driver would not have written if it was not for the hardware donations
65 * from both ICP-Vortex and �ko.neT. I want to thank them for their support.
66 *
67 * Re-worked for NetBSD by Andrew Doran. Test hardware kindly supplied by
68 * Intel.
69 *
70 * Support for the ICP-Vortex management tools added by
71 * Jason R. Thorpe of Wasabi Systems, Inc., based on code
72 * provided by Achim Leubner <achim.leubner@intel.com>.
73 *
74 * Additional support for dynamic rescan of cacheservice drives by
75 * Jason R. Thorpe of Wasabi Systems, Inc.
76 */
77
78 #include <sys/cdefs.h>
79 __KERNEL_RCSID(0, "$NetBSD: icp.c,v 1.37 2022/04/10 09:50:45 andvar Exp $");
80
81 #include <sys/param.h>
82 #include <sys/systm.h>
83 #include <sys/kernel.h>
84 #include <sys/device.h>
85 #include <sys/queue.h>
86 #include <sys/proc.h>
87 #include <sys/buf.h>
88 #include <sys/endian.h>
89 #include <sys/malloc.h>
90 #include <sys/disk.h>
91
92 #include <sys/bswap.h>
93 #include <sys/bus.h>
94
95 #include <dev/pci/pcireg.h>
96 #include <dev/pci/pcivar.h>
97 #include <dev/pci/pcidevs.h>
98
99 #include <dev/ic/icpreg.h>
100 #include <dev/ic/icpvar.h>
101
102 #include <dev/scsipi/scsipi_all.h>
103 #include <dev/scsipi/scsiconf.h>
104
105 #include "locators.h"
106
107 int icp_async_event(struct icp_softc *, int);
108 void icp_ccb_submit(struct icp_softc *icp, struct icp_ccb *ic);
109 void icp_chain(struct icp_softc *);
110 int icp_print(void *, const char *);
111 void icp_watchdog(void *);
112 void icp_ucmd_intr(struct icp_ccb *);
113 void icp_recompute_openings(struct icp_softc *);
114
115 int icp_count; /* total # of controllers, for ioctl interface */
116
117 /*
118 * Statistics for the ioctl interface to query.
119 *
120 * XXX Global. They should probably be made per-controller
121 * XXX at some point.
122 */
123 gdt_statist_t icp_stats;
124
125 int
icp_init(struct icp_softc * icp,const char * intrstr)126 icp_init(struct icp_softc *icp, const char *intrstr)
127 {
128 struct icp_attach_args icpa;
129 struct icp_binfo binfo;
130 struct icp_ccb *ic;
131 u_int16_t cdev_cnt;
132 int i, j, state, feat, nsegs, rv;
133 int locs[ICPCF_NLOCS];
134
135 state = 0;
136
137 if (intrstr != NULL)
138 aprint_normal_dev(icp->icp_dv, "interrupting at %s\n",
139 intrstr);
140
141 SIMPLEQ_INIT(&icp->icp_ccb_queue);
142 SIMPLEQ_INIT(&icp->icp_ccb_freelist);
143 SIMPLEQ_INIT(&icp->icp_ucmd_queue);
144 callout_init(&icp->icp_wdog_callout, 0);
145
146 /*
147 * Allocate a scratch area.
148 */
149 if (bus_dmamap_create(icp->icp_dmat, ICP_SCRATCH_SIZE, 1,
150 ICP_SCRATCH_SIZE, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
151 &icp->icp_scr_dmamap) != 0) {
152 aprint_error_dev(icp->icp_dv, "cannot create scratch dmamap\n");
153 return (1);
154 }
155 state++;
156
157 if (bus_dmamem_alloc(icp->icp_dmat, ICP_SCRATCH_SIZE, PAGE_SIZE, 0,
158 icp->icp_scr_seg, 1, &nsegs, BUS_DMA_NOWAIT) != 0) {
159 aprint_error_dev(icp->icp_dv, "cannot alloc scratch dmamem\n");
160 goto bail_out;
161 }
162 state++;
163
164 if (bus_dmamem_map(icp->icp_dmat, icp->icp_scr_seg, nsegs,
165 ICP_SCRATCH_SIZE, &icp->icp_scr, 0)) {
166 aprint_error_dev(icp->icp_dv, "cannot map scratch dmamem\n");
167 goto bail_out;
168 }
169 state++;
170
171 if (bus_dmamap_load(icp->icp_dmat, icp->icp_scr_dmamap, icp->icp_scr,
172 ICP_SCRATCH_SIZE, NULL, BUS_DMA_NOWAIT)) {
173 aprint_error_dev(icp->icp_dv, "cannot load scratch dmamap\n");
174 goto bail_out;
175 }
176 state++;
177
178 /*
179 * Allocate and initialize the command control blocks.
180 */
181 ic = malloc(sizeof(*ic) * ICP_NCCBS, M_DEVBUF, M_WAITOK | M_ZERO);
182 icp->icp_ccbs = ic;
183 state++;
184
185 for (i = 0; i < ICP_NCCBS; i++, ic++) {
186 /*
187 * The first two command indexes have special meanings, so
188 * we can't use them.
189 */
190 ic->ic_ident = i + 2;
191 rv = bus_dmamap_create(icp->icp_dmat, ICP_MAX_XFER,
192 ICP_MAXSG, ICP_MAX_XFER, 0,
193 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
194 &ic->ic_xfer_map);
195 if (rv != 0)
196 break;
197 icp->icp_nccbs++;
198 icp_ccb_free(icp, ic);
199 }
200 #ifdef DIAGNOSTIC
201 if (icp->icp_nccbs != ICP_NCCBS)
202 aprint_error_dev(icp->icp_dv, "%d/%d CCBs usable\n",
203 icp->icp_nccbs, ICP_NCCBS);
204 #endif
205
206 /*
207 * Initialize the controller.
208 */
209 if (!icp_cmd(icp, ICP_SCREENSERVICE, ICP_INIT, 0, 0, 0)) {
210 aprint_error_dev(icp->icp_dv, "screen service init error %d\n",
211 icp->icp_status);
212 goto bail_out;
213 }
214
215 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_INIT, ICP_LINUX_OS, 0, 0)) {
216 aprint_error_dev(icp->icp_dv, "cache service init error %d\n",
217 icp->icp_status);
218 goto bail_out;
219 }
220
221 icp_cmd(icp, ICP_CACHESERVICE, ICP_UNFREEZE_IO, 0, 0, 0);
222
223 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_MOUNT, 0xffff, 1, 0)) {
224 aprint_error_dev(icp->icp_dv, "cache service mount error %d\n",
225 icp->icp_status);
226 goto bail_out;
227 }
228
229 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_INIT, ICP_LINUX_OS, 0, 0)) {
230 aprint_error_dev(icp->icp_dv, "cache service post-mount init error %d\n",
231 icp->icp_status);
232 goto bail_out;
233 }
234 cdev_cnt = (u_int16_t)icp->icp_info;
235 icp->icp_fw_vers = icp->icp_service;
236
237 if (!icp_cmd(icp, ICP_SCSIRAWSERVICE, ICP_INIT, 0, 0, 0)) {
238 aprint_error_dev(icp->icp_dv, "raw service init error %d\n",
239 icp->icp_status);
240 goto bail_out;
241 }
242
243 /*
244 * Set/get raw service features (scatter/gather).
245 */
246 feat = 0;
247 if (icp_cmd(icp, ICP_SCSIRAWSERVICE, ICP_SET_FEAT, ICP_SCATTER_GATHER,
248 0, 0))
249 if (icp_cmd(icp, ICP_SCSIRAWSERVICE, ICP_GET_FEAT, 0, 0, 0))
250 feat = icp->icp_info;
251
252 if ((feat & ICP_SCATTER_GATHER) == 0) {
253 #ifdef DIAGNOSTIC
254 aprint_normal_dev(icp->icp_dv,
255 "scatter/gather not supported (raw service)\n");
256 #endif
257 } else
258 icp->icp_features |= ICP_FEAT_RAWSERVICE;
259
260 /*
261 * Set/get cache service features (scatter/gather).
262 */
263 feat = 0;
264 if (icp_cmd(icp, ICP_CACHESERVICE, ICP_SET_FEAT, 0,
265 ICP_SCATTER_GATHER, 0))
266 if (icp_cmd(icp, ICP_CACHESERVICE, ICP_GET_FEAT, 0, 0, 0))
267 feat = icp->icp_info;
268
269 if ((feat & ICP_SCATTER_GATHER) == 0) {
270 #ifdef DIAGNOSTIC
271 aprint_normal_dev(icp->icp_dv,
272 "scatter/gather not supported (cache service)\n");
273 #endif
274 } else
275 icp->icp_features |= ICP_FEAT_CACHESERVICE;
276
277 /*
278 * Pull some information from the board and dump.
279 */
280 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_IOCTL, ICP_BOARD_INFO,
281 ICP_INVALID_CHANNEL, sizeof(struct icp_binfo))) {
282 aprint_error_dev(icp->icp_dv, "unable to retrieve board info\n");
283 goto bail_out;
284 }
285 memcpy(&binfo, icp->icp_scr, sizeof(binfo));
286
287 aprint_normal_dev(icp->icp_dv,
288 "model <%s>, firmware <%s>, %d channel(s), %dMB memory\n",
289 binfo.bi_type_string, binfo.bi_raid_string,
290 binfo.bi_chan_count, le32toh(binfo.bi_memsize) >> 20);
291
292 /*
293 * Determine the number of devices, and number of openings per
294 * device.
295 */
296 if (icp->icp_features & ICP_FEAT_CACHESERVICE) {
297 for (j = 0; j < cdev_cnt && j < ICP_MAX_HDRIVES; j++) {
298 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_INFO, j, 0,
299 0))
300 continue;
301
302 icp->icp_cdr[j].cd_size = icp->icp_info;
303 if (icp->icp_cdr[j].cd_size != 0)
304 icp->icp_ndevs++;
305
306 if (icp_cmd(icp, ICP_CACHESERVICE, ICP_DEVTYPE, j, 0,
307 0))
308 icp->icp_cdr[j].cd_type = icp->icp_info;
309 }
310 }
311
312 if (icp->icp_features & ICP_FEAT_RAWSERVICE) {
313 icp->icp_nchan = binfo.bi_chan_count;
314 icp->icp_ndevs += icp->icp_nchan;
315 }
316
317 icp_recompute_openings(icp);
318
319 /*
320 * Attach SCSI channels.
321 */
322 if (icp->icp_features & ICP_FEAT_RAWSERVICE) {
323 struct icp_ioc_version *iv;
324 struct icp_rawioc *ri;
325 struct icp_getch *gc;
326
327 iv = (struct icp_ioc_version *)icp->icp_scr;
328 iv->iv_version = htole32(ICP_IOC_NEWEST);
329 iv->iv_listents = ICP_MAXBUS;
330 iv->iv_firstchan = 0;
331 iv->iv_lastchan = ICP_MAXBUS - 1;
332 iv->iv_listoffset = htole32(sizeof(*iv));
333
334 if (icp_cmd(icp, ICP_CACHESERVICE, ICP_IOCTL,
335 ICP_IOCHAN_RAW_DESC, ICP_INVALID_CHANNEL,
336 sizeof(*iv) + ICP_MAXBUS * sizeof(*ri))) {
337 ri = (struct icp_rawioc *)(iv + 1);
338 for (j = 0; j < binfo.bi_chan_count; j++, ri++)
339 icp->icp_bus_id[j] = ri->ri_procid;
340 } else {
341 /*
342 * Fall back to the old method.
343 */
344 gc = (struct icp_getch *)icp->icp_scr;
345
346 for (j = 0; j < binfo.bi_chan_count; j++) {
347 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_IOCTL,
348 ICP_SCSI_CHAN_CNT | ICP_L_CTRL_PATTERN,
349 ICP_IO_CHANNEL | ICP_INVALID_CHANNEL,
350 sizeof(*gc))) {
351 aprint_error_dev(icp->icp_dv,
352 "unable to get chan info");
353 goto bail_out;
354 }
355 icp->icp_bus_id[j] = gc->gc_scsiid;
356 }
357 }
358
359 for (j = 0; j < binfo.bi_chan_count; j++) {
360 if (icp->icp_bus_id[j] > ICP_MAXID_FC)
361 icp->icp_bus_id[j] = ICP_MAXID_FC;
362
363 icpa.icpa_unit = j + ICPA_UNIT_SCSI;
364
365 locs[ICPCF_UNIT] = j + ICPA_UNIT_SCSI;
366
367 icp->icp_children[icpa.icpa_unit] =
368 config_found(icp->icp_dv, &icpa, icp_print,
369 CFARGS(.submatch = config_stdsubmatch,
370 .locators = locs));
371 }
372 }
373
374 /*
375 * Attach cache devices.
376 */
377 if (icp->icp_features & ICP_FEAT_CACHESERVICE) {
378 for (j = 0; j < cdev_cnt && j < ICP_MAX_HDRIVES; j++) {
379 if (icp->icp_cdr[j].cd_size == 0)
380 continue;
381
382 icpa.icpa_unit = j;
383
384 locs[ICPCF_UNIT] = j;
385
386 icp->icp_children[icpa.icpa_unit] =
387 config_found(icp->icp_dv, &icpa, icp_print,
388 CFARGS(.submatch = config_stdsubmatch,
389 .locators = locs));
390 }
391 }
392
393 /*
394 * Start the watchdog.
395 */
396 icp_watchdog(icp);
397
398 /*
399 * Count the controller, and we're done!
400 */
401 if (icp_count++ == 0)
402 mutex_init(&icp_ioctl_mutex, MUTEX_DEFAULT, IPL_NONE);
403
404 return (0);
405
406 bail_out:
407 if (state > 4)
408 for (j = 0; j < i; j++)
409 bus_dmamap_destroy(icp->icp_dmat,
410 icp->icp_ccbs[j].ic_xfer_map);
411 if (state > 3)
412 free(icp->icp_ccbs, M_DEVBUF);
413 if (state > 2)
414 bus_dmamap_unload(icp->icp_dmat, icp->icp_scr_dmamap);
415 if (state > 1)
416 bus_dmamem_unmap(icp->icp_dmat, icp->icp_scr,
417 ICP_SCRATCH_SIZE);
418 if (state > 0)
419 bus_dmamem_free(icp->icp_dmat, icp->icp_scr_seg, nsegs);
420 bus_dmamap_destroy(icp->icp_dmat, icp->icp_scr_dmamap);
421
422 return (1);
423 }
424
425 void
icp_register_servicecb(struct icp_softc * icp,int unit,const struct icp_servicecb * cb)426 icp_register_servicecb(struct icp_softc *icp, int unit,
427 const struct icp_servicecb *cb)
428 {
429
430 icp->icp_servicecb[unit] = cb;
431 }
432
433 void
icp_rescan(struct icp_softc * icp,int unit)434 icp_rescan(struct icp_softc *icp, int unit)
435 {
436 struct icp_attach_args icpa;
437 u_int newsize, newtype;
438 int locs[ICPCF_NLOCS];
439
440 /*
441 * NOTE: It is very important that the queue be frozen and not
442 * commands running when this is called. The ioctl mutex must
443 * also be held.
444 */
445
446 KASSERT(icp->icp_qfreeze != 0);
447 KASSERT(icp->icp_running == 0);
448 KASSERT(unit < ICP_MAX_HDRIVES);
449
450 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_INFO, unit, 0, 0)) {
451 #ifdef ICP_DEBUG
452 printf("%s: rescan: unit %d ICP_INFO failed -> 0x%04x\n",
453 device_xname(icp->icp_dv), unit, icp->icp_status);
454 #endif
455 goto gone;
456 }
457 if ((newsize = icp->icp_info) == 0) {
458 #ifdef ICP_DEBUG
459 printf("%s: rescan: unit %d has zero size\n",
460 device_xname(icp->icp_dv), unit);
461 #endif
462 gone:
463 /*
464 * Host drive is no longer present; detach if a child
465 * is currently there.
466 */
467 if (icp->icp_cdr[unit].cd_size != 0)
468 icp->icp_ndevs--;
469 icp->icp_cdr[unit].cd_size = 0;
470 if (icp->icp_children[unit] != NULL) {
471 (void) config_detach(icp->icp_children[unit],
472 DETACH_FORCE);
473 icp->icp_children[unit] = NULL;
474 }
475 return;
476 }
477
478 if (icp_cmd(icp, ICP_CACHESERVICE, ICP_DEVTYPE, unit, 0, 0))
479 newtype = icp->icp_info;
480 else {
481 #ifdef ICP_DEBUG
482 printf("%s: rescan: unit %d ICP_DEVTYPE failed\n",
483 device_xname(icp->icp_dv), unit);
484 #endif
485 newtype = 0; /* XXX? */
486 }
487
488 #ifdef ICP_DEBUG
489 printf("%s: rescan: unit %d old %u/%u, new %u/%u\n",
490 device_xname(icp->icp_dv), unit, icp->icp_cdr[unit].cd_size,
491 icp->icp_cdr[unit].cd_type, newsize, newtype);
492 #endif
493
494 /*
495 * If the type or size changed, detach any old child (if it exists)
496 * and attach a new one.
497 */
498 if (icp->icp_children[unit] == NULL ||
499 newsize != icp->icp_cdr[unit].cd_size ||
500 newtype != icp->icp_cdr[unit].cd_type) {
501 if (icp->icp_cdr[unit].cd_size == 0)
502 icp->icp_ndevs++;
503 icp->icp_cdr[unit].cd_size = newsize;
504 icp->icp_cdr[unit].cd_type = newtype;
505 if (icp->icp_children[unit] != NULL)
506 (void) config_detach(icp->icp_children[unit],
507 DETACH_FORCE);
508
509 icpa.icpa_unit = unit;
510
511 locs[ICPCF_UNIT] = unit;
512
513 icp->icp_children[unit] =
514 config_found(icp->icp_dv, &icpa, icp_print,
515 CFARGS(.submatch = config_stdsubmatch,
516 .locators = locs));
517 }
518
519 icp_recompute_openings(icp);
520 }
521
522 void
icp_rescan_all(struct icp_softc * icp)523 icp_rescan_all(struct icp_softc *icp)
524 {
525 int unit;
526 u_int16_t cdev_cnt;
527
528 /*
529 * This is the old method of rescanning the host drives. We
530 * start by reinitializing the cache service.
531 */
532 if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_INIT, ICP_LINUX_OS, 0, 0)) {
533 printf("%s: unable to re-initialize cache service for rescan\n",
534 device_xname(icp->icp_dv));
535 return;
536 }
537 cdev_cnt = (u_int16_t) icp->icp_info;
538
539 /* For each host drive, do the new-style rescan. */
540 for (unit = 0; unit < cdev_cnt && unit < ICP_MAX_HDRIVES; unit++)
541 icp_rescan(icp, unit);
542
543 /* Now detach anything in the slots after cdev_cnt. */
544 for (; unit < ICP_MAX_HDRIVES; unit++) {
545 if (icp->icp_cdr[unit].cd_size != 0) {
546 #ifdef ICP_DEBUG
547 printf("%s: rescan all: unit %d < new cdev_cnt (%d)\n",
548 device_xname(icp->icp_dv), unit, cdev_cnt);
549 #endif
550 icp->icp_ndevs--;
551 icp->icp_cdr[unit].cd_size = 0;
552 if (icp->icp_children[unit] != NULL) {
553 (void) config_detach(icp->icp_children[unit],
554 DETACH_FORCE);
555 icp->icp_children[unit] = NULL;
556 }
557 }
558 }
559
560 icp_recompute_openings(icp);
561 }
562
563 void
icp_recompute_openings(struct icp_softc * icp)564 icp_recompute_openings(struct icp_softc *icp)
565 {
566 int unit, openings;
567
568 if (icp->icp_ndevs != 0)
569 openings =
570 (icp->icp_nccbs - ICP_NCCB_RESERVE) / icp->icp_ndevs;
571 else
572 openings = 0;
573 if (openings == icp->icp_openings)
574 return;
575 icp->icp_openings = openings;
576
577 #ifdef ICP_DEBUG
578 printf("%s: %d device%s, %d openings per device\n",
579 device_xname(icp->icp_dv), icp->icp_ndevs,
580 icp->icp_ndevs == 1 ? "" : "s", icp->icp_openings);
581 #endif
582
583 for (unit = 0; unit < ICP_MAX_HDRIVES + ICP_MAXBUS; unit++) {
584 if (icp->icp_children[unit] != NULL)
585 (*icp->icp_servicecb[unit]->iscb_openings)(
586 icp->icp_children[unit], icp->icp_openings);
587 }
588 }
589
590 void
icp_watchdog(void * cookie)591 icp_watchdog(void *cookie)
592 {
593 struct icp_softc *icp;
594 int s;
595
596 icp = cookie;
597
598 s = splbio();
599 icp_intr(icp);
600 if (ICP_HAS_WORK(icp))
601 icp_ccb_enqueue(icp, NULL);
602 splx(s);
603
604 callout_reset(&icp->icp_wdog_callout, hz * ICP_WATCHDOG_FREQ,
605 icp_watchdog, icp);
606 }
607
608 int
icp_print(void * aux,const char * pnp)609 icp_print(void *aux, const char *pnp)
610 {
611 struct icp_attach_args *icpa;
612 const char *str;
613
614 icpa = (struct icp_attach_args *)aux;
615
616 if (pnp != NULL) {
617 if (icpa->icpa_unit < ICPA_UNIT_SCSI)
618 str = "block device";
619 else
620 str = "SCSI channel";
621 aprint_normal("%s at %s", str, pnp);
622 }
623 aprint_normal(" unit %d", icpa->icpa_unit);
624
625 return (UNCONF);
626 }
627
628 int
icp_async_event(struct icp_softc * icp,int service)629 icp_async_event(struct icp_softc *icp, int service)
630 {
631
632 if (service == ICP_SCREENSERVICE) {
633 if (icp->icp_status == ICP_S_MSG_REQUEST) {
634 /* XXX */
635 }
636 } else {
637 if ((icp->icp_fw_vers & 0xff) >= 0x1a) {
638 icp->icp_evt.size = 0;
639 icp->icp_evt.eu.async.ionode =
640 device_unit(icp->icp_dv);
641 icp->icp_evt.eu.async.status = icp->icp_status;
642 /*
643 * Severity and event string are filled in by the
644 * hardware interface interrupt handler.
645 */
646 printf("%s: %s\n", device_xname(icp->icp_dv),
647 icp->icp_evt.event_string);
648 } else {
649 icp->icp_evt.size = sizeof(icp->icp_evt.eu.async);
650 icp->icp_evt.eu.async.ionode =
651 device_unit(icp->icp_dv);
652 icp->icp_evt.eu.async.service = service;
653 icp->icp_evt.eu.async.status = icp->icp_status;
654 icp->icp_evt.eu.async.info = icp->icp_info;
655 /* XXXJRT FIX THIS */
656 *(u_int32_t *) icp->icp_evt.eu.async.scsi_coord =
657 icp->icp_info2;
658 }
659 icp_store_event(icp, GDT_ES_ASYNC, service, &icp->icp_evt);
660 }
661
662 return (0);
663 }
664
665 int
icp_intr(void * cookie)666 icp_intr(void *cookie)
667 {
668 struct icp_softc *icp;
669 struct icp_intr_ctx ctx;
670 struct icp_ccb *ic;
671
672 icp = cookie;
673
674 ctx.istatus = (*icp->icp_get_status)(icp);
675 if (!ctx.istatus) {
676 icp->icp_status = ICP_S_NO_STATUS;
677 return (0);
678 }
679
680 (*icp->icp_intr)(icp, &ctx);
681
682 icp->icp_status = ctx.cmd_status;
683 icp->icp_service = ctx.service;
684 icp->icp_info = ctx.info;
685 icp->icp_info2 = ctx.info2;
686
687 switch (ctx.istatus) {
688 case ICP_ASYNCINDEX:
689 icp_async_event(icp, ctx.service);
690 return (1);
691
692 case ICP_SPEZINDEX:
693 aprint_error_dev(icp->icp_dv, "uninitialized or unknown service (%d/%d)\n",
694 ctx.info, ctx.info2);
695 icp->icp_evt.size = sizeof(icp->icp_evt.eu.driver);
696 icp->icp_evt.eu.driver.ionode = device_unit(icp->icp_dv);
697 icp_store_event(icp, GDT_ES_DRIVER, 4, &icp->icp_evt);
698 return (1);
699 }
700
701 if ((ctx.istatus - 2) > icp->icp_nccbs)
702 panic("icp_intr: bad command index returned");
703
704 ic = &icp->icp_ccbs[ctx.istatus - 2];
705 ic->ic_status = icp->icp_status;
706
707 if ((ic->ic_flags & IC_ALLOCED) == 0) {
708 /* XXX ICP's "iir" driver just sends an event here. */
709 panic("icp_intr: inactive CCB identified");
710 }
711
712 /*
713 * Try to protect ourselves from the running command count already
714 * being 0 (e.g. if a polled command times out).
715 */
716 KDASSERT(icp->icp_running != 0);
717 if (--icp->icp_running == 0 &&
718 (icp->icp_flags & ICP_F_WAIT_FREEZE) != 0) {
719 icp->icp_flags &= ~ICP_F_WAIT_FREEZE;
720 wakeup(&icp->icp_qfreeze);
721 }
722
723 switch (icp->icp_status) {
724 case ICP_S_BSY:
725 #ifdef ICP_DEBUG
726 printf("%s: ICP_S_BSY received\n", device_xname(icp->icp_dv));
727 #endif
728 if (__predict_false((ic->ic_flags & IC_UCMD) != 0))
729 SIMPLEQ_INSERT_HEAD(&icp->icp_ucmd_queue, ic, ic_chain);
730 else
731 SIMPLEQ_INSERT_HEAD(&icp->icp_ccb_queue, ic, ic_chain);
732 break;
733
734 default:
735 ic->ic_flags |= IC_COMPLETE;
736
737 if ((ic->ic_flags & IC_WAITING) != 0)
738 wakeup(ic);
739 else if (ic->ic_intr != NULL)
740 (*ic->ic_intr)(ic);
741
742 if (ICP_HAS_WORK(icp))
743 icp_ccb_enqueue(icp, NULL);
744
745 break;
746 }
747
748 return (1);
749 }
750
751 struct icp_ucmd_ctx {
752 gdt_ucmd_t *iu_ucmd;
753 u_int32_t iu_cnt;
754 };
755
756 void
icp_ucmd_intr(struct icp_ccb * ic)757 icp_ucmd_intr(struct icp_ccb *ic)
758 {
759 struct icp_softc *icp = device_private(ic->ic_dv);
760 struct icp_ucmd_ctx *iu = ic->ic_context;
761 gdt_ucmd_t *ucmd = iu->iu_ucmd;
762
763 ucmd->status = icp->icp_status;
764 ucmd->info = icp->icp_info;
765
766 if (iu->iu_cnt != 0) {
767 bus_dmamap_sync(icp->icp_dmat,
768 icp->icp_scr_dmamap,
769 ICP_SCRATCH_UCMD, iu->iu_cnt,
770 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
771 memcpy(ucmd->data,
772 (char *)icp->icp_scr + ICP_SCRATCH_UCMD, iu->iu_cnt);
773 }
774
775 icp->icp_ucmd_ccb = NULL;
776
777 ic->ic_flags |= IC_COMPLETE;
778 wakeup(ic);
779 }
780
781 /*
782 * NOTE: We assume that it is safe to sleep here!
783 */
784 int
icp_cmd(struct icp_softc * icp,u_int8_t service,u_int16_t opcode,u_int32_t arg1,u_int32_t arg2,u_int32_t arg3)785 icp_cmd(struct icp_softc *icp, u_int8_t service, u_int16_t opcode,
786 u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
787 {
788 struct icp_ioctlcmd *icmd;
789 struct icp_cachecmd *cc;
790 struct icp_rawcmd *rc;
791 int retries, rv;
792 struct icp_ccb *ic;
793
794 retries = ICP_RETRIES;
795
796 do {
797 ic = icp_ccb_alloc_wait(icp);
798 memset(&ic->ic_cmd, 0, sizeof(ic->ic_cmd));
799 ic->ic_cmd.cmd_opcode = htole16(opcode);
800
801 switch (service) {
802 case ICP_CACHESERVICE:
803 if (opcode == ICP_IOCTL) {
804 icmd = &ic->ic_cmd.cmd_packet.ic;
805 icmd->ic_subfunc = htole16(arg1);
806 icmd->ic_channel = htole32(arg2);
807 icmd->ic_bufsize = htole32(arg3);
808 icmd->ic_addr =
809 htole32(icp->icp_scr_seg[0].ds_addr);
810
811 bus_dmamap_sync(icp->icp_dmat,
812 icp->icp_scr_dmamap, 0, arg3,
813 BUS_DMASYNC_PREWRITE |
814 BUS_DMASYNC_PREREAD);
815 } else {
816 cc = &ic->ic_cmd.cmd_packet.cc;
817 cc->cc_deviceno = htole16(arg1);
818 cc->cc_blockno = htole32(arg2);
819 }
820 break;
821
822 case ICP_SCSIRAWSERVICE:
823 rc = &ic->ic_cmd.cmd_packet.rc;
824 rc->rc_direction = htole32(arg1);
825 rc->rc_bus = arg2;
826 rc->rc_target = arg3;
827 rc->rc_lun = arg3 >> 8;
828 break;
829 }
830
831 ic->ic_service = service;
832 ic->ic_cmdlen = sizeof(ic->ic_cmd);
833 rv = icp_ccb_poll(icp, ic, 10000);
834
835 switch (service) {
836 case ICP_CACHESERVICE:
837 if (opcode == ICP_IOCTL) {
838 bus_dmamap_sync(icp->icp_dmat,
839 icp->icp_scr_dmamap, 0, arg3,
840 BUS_DMASYNC_POSTWRITE |
841 BUS_DMASYNC_POSTREAD);
842 }
843 break;
844 }
845
846 icp_ccb_free(icp, ic);
847 } while (rv != 0 && --retries > 0);
848
849 return (icp->icp_status == ICP_S_OK);
850 }
851
852 int
icp_ucmd(struct icp_softc * icp,gdt_ucmd_t * ucmd)853 icp_ucmd(struct icp_softc *icp, gdt_ucmd_t *ucmd)
854 {
855 struct icp_ccb *ic;
856 struct icp_ucmd_ctx iu;
857 u_int32_t cnt;
858 int error;
859
860 if (ucmd->service == ICP_CACHESERVICE) {
861 if (ucmd->command.cmd_opcode == ICP_IOCTL) {
862 cnt = ucmd->command.cmd_packet.ic.ic_bufsize;
863 if (cnt > GDT_SCRATCH_SZ) {
864 aprint_error_dev(icp->icp_dv, "scratch buffer too small (%d/%d)\n",
865 GDT_SCRATCH_SZ, cnt);
866 return (EINVAL);
867 }
868 } else {
869 cnt = ucmd->command.cmd_packet.cc.cc_blockcnt *
870 ICP_SECTOR_SIZE;
871 if (cnt > GDT_SCRATCH_SZ) {
872 aprint_error_dev(icp->icp_dv, "scratch buffer too small (%d/%d)\n",
873 GDT_SCRATCH_SZ, cnt);
874 return (EINVAL);
875 }
876 }
877 } else {
878 cnt = ucmd->command.cmd_packet.rc.rc_sdlen +
879 ucmd->command.cmd_packet.rc.rc_sense_len;
880 if (cnt > GDT_SCRATCH_SZ) {
881 aprint_error_dev(icp->icp_dv, "scratch buffer too small (%d/%d)\n",
882 GDT_SCRATCH_SZ, cnt);
883 return (EINVAL);
884 }
885 }
886
887 iu.iu_ucmd = ucmd;
888 iu.iu_cnt = cnt;
889
890 ic = icp_ccb_alloc_wait(icp);
891 memset(&ic->ic_cmd, 0, sizeof(ic->ic_cmd));
892 ic->ic_cmd.cmd_opcode = htole16(ucmd->command.cmd_opcode);
893
894 if (ucmd->service == ICP_CACHESERVICE) {
895 if (ucmd->command.cmd_opcode == ICP_IOCTL) {
896 struct icp_ioctlcmd *icmd, *uicmd;
897
898 icmd = &ic->ic_cmd.cmd_packet.ic;
899 uicmd = &ucmd->command.cmd_packet.ic;
900
901 icmd->ic_subfunc = htole16(uicmd->ic_subfunc);
902 icmd->ic_channel = htole32(uicmd->ic_channel);
903 icmd->ic_bufsize = htole32(uicmd->ic_bufsize);
904 icmd->ic_addr =
905 htole32(icp->icp_scr_seg[0].ds_addr +
906 ICP_SCRATCH_UCMD);
907 } else {
908 struct icp_cachecmd *cc, *ucc;
909
910 cc = &ic->ic_cmd.cmd_packet.cc;
911 ucc = &ucmd->command.cmd_packet.cc;
912
913 cc->cc_deviceno = htole16(ucc->cc_deviceno);
914 cc->cc_blockno = htole32(ucc->cc_blockno);
915 cc->cc_blockcnt = htole32(ucc->cc_blockcnt);
916 cc->cc_addr = htole32(0xffffffffU);
917 cc->cc_nsgent = htole32(1);
918 cc->cc_sg[0].sg_addr =
919 htole32(icp->icp_scr_seg[0].ds_addr +
920 ICP_SCRATCH_UCMD);
921 cc->cc_sg[0].sg_len = htole32(cnt);
922 }
923 } else {
924 struct icp_rawcmd *rc, *urc;
925
926 rc = &ic->ic_cmd.cmd_packet.rc;
927 urc = &ucmd->command.cmd_packet.rc;
928
929 rc->rc_direction = htole32(urc->rc_direction);
930 rc->rc_sdata = htole32(0xffffffffU);
931 rc->rc_sdlen = htole32(urc->rc_sdlen);
932 rc->rc_clen = htole32(urc->rc_clen);
933 memcpy(rc->rc_cdb, urc->rc_cdb, sizeof(rc->rc_cdb));
934 rc->rc_target = urc->rc_target;
935 rc->rc_lun = urc->rc_lun;
936 rc->rc_bus = urc->rc_bus;
937 rc->rc_sense_len = htole32(urc->rc_sense_len);
938 rc->rc_sense_addr =
939 htole32(icp->icp_scr_seg[0].ds_addr +
940 ICP_SCRATCH_UCMD + urc->rc_sdlen);
941 rc->rc_nsgent = htole32(1);
942 rc->rc_sg[0].sg_addr =
943 htole32(icp->icp_scr_seg[0].ds_addr + ICP_SCRATCH_UCMD);
944 rc->rc_sg[0].sg_len = htole32(cnt - urc->rc_sense_len);
945 }
946
947 ic->ic_service = ucmd->service;
948 ic->ic_cmdlen = sizeof(ic->ic_cmd);
949 ic->ic_context = &iu;
950
951 /*
952 * XXX What units are ucmd->timeout in? Until we know, we
953 * XXX just pull a number out of thin air.
954 */
955 if (__predict_false((error = icp_ccb_wait_user(icp, ic, 30000)) != 0))
956 aprint_error_dev(icp->icp_dv, "error %d waiting for ucmd to complete\n",
957 error);
958
959 /* icp_ucmd_intr() has updated ucmd. */
960 icp_ccb_free(icp, ic);
961
962 return (error);
963 }
964
965 struct icp_ccb *
icp_ccb_alloc(struct icp_softc * icp)966 icp_ccb_alloc(struct icp_softc *icp)
967 {
968 struct icp_ccb *ic;
969 int s;
970
971 s = splbio();
972 if (__predict_false((ic =
973 SIMPLEQ_FIRST(&icp->icp_ccb_freelist)) == NULL)) {
974 splx(s);
975 return (NULL);
976 }
977 SIMPLEQ_REMOVE_HEAD(&icp->icp_ccb_freelist, ic_chain);
978 splx(s);
979
980 ic->ic_flags = IC_ALLOCED;
981 return (ic);
982 }
983
984 struct icp_ccb *
icp_ccb_alloc_wait(struct icp_softc * icp)985 icp_ccb_alloc_wait(struct icp_softc *icp)
986 {
987 struct icp_ccb *ic;
988 int s;
989
990 s = splbio();
991 while ((ic = SIMPLEQ_FIRST(&icp->icp_ccb_freelist)) == NULL) {
992 icp->icp_flags |= ICP_F_WAIT_CCB;
993 (void) tsleep(&icp->icp_ccb_freelist, PRIBIO, "icpccb", 0);
994 }
995 SIMPLEQ_REMOVE_HEAD(&icp->icp_ccb_freelist, ic_chain);
996 splx(s);
997
998 ic->ic_flags = IC_ALLOCED;
999 return (ic);
1000 }
1001
1002 void
icp_ccb_free(struct icp_softc * icp,struct icp_ccb * ic)1003 icp_ccb_free(struct icp_softc *icp, struct icp_ccb *ic)
1004 {
1005 int s;
1006
1007 s = splbio();
1008 ic->ic_flags = 0;
1009 ic->ic_intr = NULL;
1010 SIMPLEQ_INSERT_HEAD(&icp->icp_ccb_freelist, ic, ic_chain);
1011 if (__predict_false((icp->icp_flags & ICP_F_WAIT_CCB) != 0)) {
1012 icp->icp_flags &= ~ICP_F_WAIT_CCB;
1013 wakeup(&icp->icp_ccb_freelist);
1014 }
1015 splx(s);
1016 }
1017
1018 void
icp_ccb_enqueue(struct icp_softc * icp,struct icp_ccb * ic)1019 icp_ccb_enqueue(struct icp_softc *icp, struct icp_ccb *ic)
1020 {
1021 int s;
1022
1023 s = splbio();
1024
1025 if (ic != NULL) {
1026 if (__predict_false((ic->ic_flags & IC_UCMD) != 0))
1027 SIMPLEQ_INSERT_TAIL(&icp->icp_ucmd_queue, ic, ic_chain);
1028 else
1029 SIMPLEQ_INSERT_TAIL(&icp->icp_ccb_queue, ic, ic_chain);
1030 }
1031
1032 for (; icp->icp_qfreeze == 0;) {
1033 if (__predict_false((ic =
1034 SIMPLEQ_FIRST(&icp->icp_ucmd_queue)) != NULL)) {
1035 struct icp_ucmd_ctx *iu = ic->ic_context;
1036 gdt_ucmd_t *ucmd = iu->iu_ucmd;
1037
1038 /*
1039 * All user-generated commands share the same
1040 * scratch space, so if one is already running,
1041 * we have to stall the command queue.
1042 */
1043 if (icp->icp_ucmd_ccb != NULL)
1044 break;
1045 if ((*icp->icp_test_busy)(icp))
1046 break;
1047 icp->icp_ucmd_ccb = ic;
1048
1049 if (iu->iu_cnt != 0) {
1050 memcpy((char *)icp->icp_scr + ICP_SCRATCH_UCMD,
1051 ucmd->data, iu->iu_cnt);
1052 bus_dmamap_sync(icp->icp_dmat,
1053 icp->icp_scr_dmamap,
1054 ICP_SCRATCH_UCMD, iu->iu_cnt,
1055 BUS_DMASYNC_PREREAD |
1056 BUS_DMASYNC_PREWRITE);
1057 }
1058 } else if (__predict_true((ic =
1059 SIMPLEQ_FIRST(&icp->icp_ccb_queue)) != NULL)) {
1060 if ((*icp->icp_test_busy)(icp))
1061 break;
1062 } else {
1063 /* no command found */
1064 break;
1065 }
1066 icp_ccb_submit(icp, ic);
1067 if (__predict_false((ic->ic_flags & IC_UCMD) != 0))
1068 SIMPLEQ_REMOVE_HEAD(&icp->icp_ucmd_queue, ic_chain);
1069 else
1070 SIMPLEQ_REMOVE_HEAD(&icp->icp_ccb_queue, ic_chain);
1071 }
1072
1073 splx(s);
1074 }
1075
1076 int
icp_ccb_map(struct icp_softc * icp,struct icp_ccb * ic,void * data,int size,int dir)1077 icp_ccb_map(struct icp_softc *icp, struct icp_ccb *ic, void *data, int size,
1078 int dir)
1079 {
1080 struct icp_sg *sg;
1081 int nsegs, i, rv;
1082 bus_dmamap_t xfer;
1083
1084 xfer = ic->ic_xfer_map;
1085
1086 rv = bus_dmamap_load(icp->icp_dmat, xfer, data, size, NULL,
1087 BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
1088 ((dir & IC_XFER_IN) ? BUS_DMA_READ : BUS_DMA_WRITE));
1089 if (rv != 0)
1090 return (rv);
1091
1092 nsegs = xfer->dm_nsegs;
1093 ic->ic_xfer_size = size;
1094 ic->ic_nsgent = nsegs;
1095 ic->ic_flags |= dir;
1096 sg = ic->ic_sg;
1097
1098 if (sg != NULL) {
1099 for (i = 0; i < nsegs; i++, sg++) {
1100 sg->sg_addr = htole32(xfer->dm_segs[i].ds_addr);
1101 sg->sg_len = htole32(xfer->dm_segs[i].ds_len);
1102 }
1103 } else if (nsegs > 1)
1104 panic("icp_ccb_map: no SG list specified, but nsegs > 1");
1105
1106 if ((dir & IC_XFER_OUT) != 0)
1107 i = BUS_DMASYNC_PREWRITE;
1108 else /* if ((dir & IC_XFER_IN) != 0) */
1109 i = BUS_DMASYNC_PREREAD;
1110
1111 bus_dmamap_sync(icp->icp_dmat, xfer, 0, ic->ic_xfer_size, i);
1112 return (0);
1113 }
1114
1115 void
icp_ccb_unmap(struct icp_softc * icp,struct icp_ccb * ic)1116 icp_ccb_unmap(struct icp_softc *icp, struct icp_ccb *ic)
1117 {
1118 int i;
1119
1120 if ((ic->ic_flags & IC_XFER_OUT) != 0)
1121 i = BUS_DMASYNC_POSTWRITE;
1122 else /* if ((ic->ic_flags & IC_XFER_IN) != 0) */
1123 i = BUS_DMASYNC_POSTREAD;
1124
1125 bus_dmamap_sync(icp->icp_dmat, ic->ic_xfer_map, 0, ic->ic_xfer_size, i);
1126 bus_dmamap_unload(icp->icp_dmat, ic->ic_xfer_map);
1127 }
1128
1129 int
icp_ccb_poll(struct icp_softc * icp,struct icp_ccb * ic,int timo)1130 icp_ccb_poll(struct icp_softc *icp, struct icp_ccb *ic, int timo)
1131 {
1132 int s, rv;
1133
1134 s = splbio();
1135
1136 for (timo = ICP_BUSY_WAIT_MS * 100; timo != 0; timo--) {
1137 if (!(*icp->icp_test_busy)(icp))
1138 break;
1139 DELAY(10);
1140 }
1141 if (timo == 0) {
1142 printf("%s: submit: busy\n", device_xname(icp->icp_dv));
1143 return (EAGAIN);
1144 }
1145
1146 icp_ccb_submit(icp, ic);
1147
1148 if (cold) {
1149 for (timo *= 10; timo != 0; timo--) {
1150 DELAY(100);
1151 icp_intr(icp);
1152 if ((ic->ic_flags & IC_COMPLETE) != 0)
1153 break;
1154 }
1155 } else {
1156 ic->ic_flags |= IC_WAITING;
1157 while ((ic->ic_flags & IC_COMPLETE) == 0) {
1158 if ((rv = tsleep(ic, PRIBIO, "icpwccb",
1159 mstohz(timo))) != 0) {
1160 timo = 0;
1161 break;
1162 }
1163 }
1164 }
1165
1166 if (timo != 0) {
1167 if (ic->ic_status != ICP_S_OK) {
1168 #ifdef ICP_DEBUG
1169 printf("%s: request failed; status=0x%04x\n",
1170 device_xname(icp->icp_dv), ic->ic_status);
1171 #endif
1172 rv = EIO;
1173 } else
1174 rv = 0;
1175 } else {
1176 aprint_error_dev(icp->icp_dv, "command timed out\n");
1177 rv = EIO;
1178 }
1179
1180 while ((*icp->icp_test_busy)(icp) != 0)
1181 DELAY(10);
1182
1183 splx(s);
1184
1185 return (rv);
1186 }
1187
1188 int
icp_ccb_wait(struct icp_softc * icp,struct icp_ccb * ic,int timo)1189 icp_ccb_wait(struct icp_softc *icp, struct icp_ccb *ic, int timo)
1190 {
1191 int s, rv;
1192
1193 ic->ic_flags |= IC_WAITING;
1194
1195 s = splbio();
1196 icp_ccb_enqueue(icp, ic);
1197 while ((ic->ic_flags & IC_COMPLETE) == 0) {
1198 if ((rv = tsleep(ic, PRIBIO, "icpwccb", mstohz(timo))) != 0) {
1199 splx(s);
1200 return (rv);
1201 }
1202 }
1203 splx(s);
1204
1205 if (ic->ic_status != ICP_S_OK) {
1206 aprint_error_dev(icp->icp_dv, "command failed; status=%x\n",
1207 ic->ic_status);
1208 return (EIO);
1209 }
1210
1211 return (0);
1212 }
1213
1214 int
icp_ccb_wait_user(struct icp_softc * icp,struct icp_ccb * ic,int timo)1215 icp_ccb_wait_user(struct icp_softc *icp, struct icp_ccb *ic, int timo)
1216 {
1217 int s, rv;
1218
1219 ic->ic_dv = icp->icp_dv;
1220 ic->ic_intr = icp_ucmd_intr;
1221 ic->ic_flags |= IC_UCMD;
1222
1223 s = splbio();
1224 icp_ccb_enqueue(icp, ic);
1225 while ((ic->ic_flags & IC_COMPLETE) == 0) {
1226 if ((rv = tsleep(ic, PRIBIO, "icpwuccb", mstohz(timo))) != 0) {
1227 splx(s);
1228 return (rv);
1229 }
1230 }
1231 splx(s);
1232
1233 return (0);
1234 }
1235
1236 void
icp_ccb_submit(struct icp_softc * icp,struct icp_ccb * ic)1237 icp_ccb_submit(struct icp_softc *icp, struct icp_ccb *ic)
1238 {
1239
1240 ic->ic_cmdlen = (ic->ic_cmdlen + 3) & ~3;
1241
1242 (*icp->icp_set_sema0)(icp);
1243 DELAY(10);
1244
1245 ic->ic_cmd.cmd_boardnode = htole32(ICP_LOCALBOARD);
1246 ic->ic_cmd.cmd_cmdindex = htole32(ic->ic_ident);
1247
1248 icp->icp_running++;
1249
1250 (*icp->icp_copy_cmd)(icp, ic);
1251 (*icp->icp_release_event)(icp, ic);
1252 }
1253
1254 int
icp_freeze(struct icp_softc * icp)1255 icp_freeze(struct icp_softc *icp)
1256 {
1257 int s, error = 0;
1258
1259 s = splbio();
1260 if (icp->icp_qfreeze++ == 0) {
1261 while (icp->icp_running != 0) {
1262 icp->icp_flags |= ICP_F_WAIT_FREEZE;
1263 error = tsleep(&icp->icp_qfreeze, PRIBIO|PCATCH,
1264 "icpqfrz", 0);
1265 if (error != 0 && --icp->icp_qfreeze == 0 &&
1266 ICP_HAS_WORK(icp)) {
1267 icp_ccb_enqueue(icp, NULL);
1268 break;
1269 }
1270 }
1271 }
1272 splx(s);
1273
1274 return (error);
1275 }
1276
1277 void
icp_unfreeze(struct icp_softc * icp)1278 icp_unfreeze(struct icp_softc *icp)
1279 {
1280 int s;
1281
1282 s = splbio();
1283 KDASSERT(icp->icp_qfreeze != 0);
1284 if (--icp->icp_qfreeze == 0 && ICP_HAS_WORK(icp))
1285 icp_ccb_enqueue(icp, NULL);
1286 splx(s);
1287 }
1288
1289 /* XXX Global - should be per-controller? XXX */
1290 static gdt_evt_str icp_event_buffer[ICP_MAX_EVENTS];
1291 static int icp_event_oldidx;
1292 static int icp_event_lastidx;
1293
1294 gdt_evt_str *
icp_store_event(struct icp_softc * icp,u_int16_t source,u_int16_t idx,gdt_evt_data * evt)1295 icp_store_event(struct icp_softc *icp, u_int16_t source, u_int16_t idx,
1296 gdt_evt_data *evt)
1297 {
1298 gdt_evt_str *e;
1299
1300 /* no source == no event */
1301 if (source == 0)
1302 return (NULL);
1303
1304 e = &icp_event_buffer[icp_event_lastidx];
1305 if (e->event_source == source && e->event_idx == idx &&
1306 ((evt->size != 0 && e->event_data.size != 0 &&
1307 memcmp(&e->event_data.eu, &evt->eu, evt->size) == 0) ||
1308 (evt->size == 0 && e->event_data.size == 0 &&
1309 strcmp((char *) e->event_data.event_string,
1310 (char *) evt->event_string) == 0))) {
1311 e->last_stamp = time_second;
1312 e->same_count++;
1313 } else {
1314 if (icp_event_buffer[icp_event_lastidx].event_source != 0) {
1315 icp_event_lastidx++;
1316 if (icp_event_lastidx == ICP_MAX_EVENTS)
1317 icp_event_lastidx = 0;
1318 if (icp_event_lastidx == icp_event_oldidx) {
1319 icp_event_oldidx++;
1320 if (icp_event_oldidx == ICP_MAX_EVENTS)
1321 icp_event_oldidx = 0;
1322 }
1323 }
1324 e = &icp_event_buffer[icp_event_lastidx];
1325 e->event_source = source;
1326 e->event_idx = idx;
1327 e->first_stamp = e->last_stamp = time_second;
1328 e->same_count = 1;
1329 e->event_data = *evt;
1330 e->application = 0;
1331 }
1332 return (e);
1333 }
1334
1335 int
icp_read_event(struct icp_softc * icp,int handle,gdt_evt_str * estr)1336 icp_read_event(struct icp_softc *icp, int handle, gdt_evt_str *estr)
1337 {
1338 gdt_evt_str *e;
1339 int eindex, s;
1340
1341 s = splbio();
1342
1343 if (handle == -1)
1344 eindex = icp_event_oldidx;
1345 else
1346 eindex = handle;
1347
1348 estr->event_source = 0;
1349
1350 if (eindex < 0 || eindex >= ICP_MAX_EVENTS) {
1351 splx(s);
1352 return (eindex);
1353 }
1354
1355 e = &icp_event_buffer[eindex];
1356 if (e->event_source != 0) {
1357 if (eindex != icp_event_lastidx) {
1358 eindex++;
1359 if (eindex == ICP_MAX_EVENTS)
1360 eindex = 0;
1361 } else
1362 eindex = -1;
1363 memcpy(estr, e, sizeof(gdt_evt_str));
1364 }
1365
1366 splx(s);
1367
1368 return (eindex);
1369 }
1370
1371 void
icp_readapp_event(struct icp_softc * icp,u_int8_t application,gdt_evt_str * estr)1372 icp_readapp_event(struct icp_softc *icp, u_int8_t application,
1373 gdt_evt_str *estr)
1374 {
1375 gdt_evt_str *e;
1376 int found = 0, eindex, s;
1377
1378 s = splbio();
1379
1380 eindex = icp_event_oldidx;
1381 for (;;) {
1382 e = &icp_event_buffer[eindex];
1383 if (e->event_source == 0)
1384 break;
1385 if ((e->application & application) == 0) {
1386 e->application |= application;
1387 found = 1;
1388 break;
1389 }
1390 if (eindex == icp_event_lastidx)
1391 break;
1392 eindex++;
1393 if (eindex == ICP_MAX_EVENTS)
1394 eindex = 0;
1395 }
1396 if (found)
1397 memcpy(estr, e, sizeof(gdt_evt_str));
1398 else
1399 estr->event_source = 0;
1400
1401 splx(s);
1402 }
1403
1404 void
icp_clear_events(struct icp_softc * icp)1405 icp_clear_events(struct icp_softc *icp)
1406 {
1407 int s;
1408
1409 s = splbio();
1410 icp_event_oldidx = icp_event_lastidx = 0;
1411 memset(icp_event_buffer, 0, sizeof(icp_event_buffer));
1412 splx(s);
1413 }
1414