xref: /freebsd/sys/dev/ida/ida.c (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 1999,2000 Jonathan Lemon
5  * All rights reserved.
6  *
7  # Derived from the original IDA Compaq RAID driver, which is
8  * Copyright (c) 1996, 1997, 1998, 1999
9  *    Mark Dawson and David James. All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 /*
35  * Generic driver for Compaq SMART RAID adapters.
36  */
37 
38 #include <sys/param.h>
39 #include <sys/kernel.h>
40 #include <sys/systm.h>
41 #include <sys/lock.h>
42 #include <sys/malloc.h>
43 #include <sys/mutex.h>
44 #include <sys/stat.h>
45 
46 #include <sys/bio.h>
47 #include <sys/bus.h>
48 #include <sys/conf.h>
49 #include <sys/endian.h>
50 
51 #include <machine/bus.h>
52 #include <sys/rman.h>
53 
54 #include <geom/geom_disk.h>
55 
56 #include <dev/ida/idareg.h>
57 #include <dev/ida/idavar.h>
58 #include <dev/ida/idaio.h>
59 
60 /* prototypes */
61 static int ida_alloc_qcbs(struct ida_softc *ida);
62 static void ida_done(struct ida_softc *ida, struct ida_qcb *qcb);
63 static void ida_start(struct ida_softc *ida);
64 static void ida_startio(struct ida_softc *ida);
65 static void ida_startup(void *arg);
66 static void ida_timeout(void *arg);
67 static int ida_wait(struct ida_softc *ida, struct ida_qcb *qcb);
68 
69 static d_ioctl_t ida_ioctl;
70 static struct cdevsw ida_cdevsw = {
71 	.d_version =	D_VERSION,
72 	.d_ioctl =	ida_ioctl,
73 	.d_name =	"ida",
74 };
75 
76 void
77 ida_free(struct ida_softc *ida)
78 {
79 	int i;
80 
81 	if (ida->ih != NULL)
82 		bus_teardown_intr(ida->dev, ida->irq, ida->ih);
83 
84 	mtx_lock(&ida->lock);
85 	callout_stop(&ida->ch);
86 	mtx_unlock(&ida->lock);
87 	callout_drain(&ida->ch);
88 
89 	if (ida->buffer_dmat) {
90 		for (i = 0; i < IDA_QCB_MAX; i++)
91 			bus_dmamap_destroy(ida->buffer_dmat, ida->qcbs[i].dmamap);
92 		bus_dma_tag_destroy(ida->buffer_dmat);
93 	}
94 
95 	if (ida->hwqcb_dmat) {
96 		if (ida->hwqcb_busaddr)
97 			bus_dmamap_unload(ida->hwqcb_dmat, ida->hwqcb_dmamap);
98 		if (ida->hwqcbs)
99 			bus_dmamem_free(ida->hwqcb_dmat, ida->hwqcbs,
100 			    ida->hwqcb_dmamap);
101 		bus_dma_tag_destroy(ida->hwqcb_dmat);
102 	}
103 
104 	if (ida->qcbs != NULL)
105 		free(ida->qcbs, M_DEVBUF);
106 
107 	if (ida->irq != NULL)
108 		bus_release_resource(ida->dev, ida->irq_res_type,
109 		    0, ida->irq);
110 
111 	if (ida->parent_dmat != NULL)
112 		bus_dma_tag_destroy(ida->parent_dmat);
113 
114 	if (ida->regs != NULL)
115 		bus_release_resource(ida->dev, ida->regs_res_type,
116 		    ida->regs_res_id, ida->regs);
117 
118 	mtx_destroy(&ida->lock);
119 }
120 
121 /*
122  * record bus address from bus_dmamap_load
123  */
124 static void
125 ida_dma_map_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
126 {
127 	bus_addr_t *baddr;
128 
129 	baddr = (bus_addr_t *)arg;
130 	*baddr = segs->ds_addr;
131 }
132 
133 static __inline struct ida_qcb *
134 ida_get_qcb(struct ida_softc *ida)
135 {
136 	struct ida_qcb *qcb;
137 
138 	if ((qcb = SLIST_FIRST(&ida->free_qcbs)) != NULL) {
139 		SLIST_REMOVE_HEAD(&ida->free_qcbs, link.sle);
140 		bzero(qcb->hwqcb, sizeof(struct ida_hdr) + sizeof(struct ida_req));
141 	}
142 	return (qcb);
143 }
144 
145 static __inline void
146 ida_free_qcb(struct ida_softc *ida, struct ida_qcb *qcb)
147 {
148 
149 	qcb->state = QCB_FREE;
150 	qcb->buf = NULL;
151 	qcb->error = 0;
152 	SLIST_INSERT_HEAD(&ida->free_qcbs, qcb, link.sle);
153 }
154 
155 static __inline bus_addr_t
156 idahwqcbvtop(struct ida_softc *ida, struct ida_hardware_qcb *hwqcb)
157 {
158 	return (ida->hwqcb_busaddr +
159 	    ((bus_addr_t)hwqcb - (bus_addr_t)ida->hwqcbs));
160 }
161 
162 static __inline struct ida_qcb *
163 idahwqcbptov(struct ida_softc *ida, bus_addr_t hwqcb_addr)
164 {
165 	struct ida_hardware_qcb *hwqcb;
166 
167 	hwqcb = (struct ida_hardware_qcb *)
168 	    ((bus_addr_t)ida->hwqcbs + (hwqcb_addr - ida->hwqcb_busaddr));
169 	return (hwqcb->qcb);
170 }
171 
172 static int
173 ida_alloc_qcbs(struct ida_softc *ida)
174 {
175 	struct ida_qcb *qcb;
176 	int error, i;
177 
178 	for (i = 0; i < IDA_QCB_MAX; i++) {
179 		qcb = &ida->qcbs[i];
180 
181 		error = bus_dmamap_create(ida->buffer_dmat, /*flags*/0, &qcb->dmamap);
182 		if (error != 0)
183 			return (error);
184 
185 		qcb->ida = ida;
186 		qcb->flags = QCB_FREE;
187 		qcb->hwqcb = &ida->hwqcbs[i];
188 		qcb->hwqcb->qcb = qcb;
189 		qcb->hwqcb_busaddr = idahwqcbvtop(ida, qcb->hwqcb);
190 		SLIST_INSERT_HEAD(&ida->free_qcbs, qcb, link.sle);
191 	}
192 	return (0);
193 }
194 
195 int
196 ida_setup(struct ida_softc *ida)
197 {
198 	struct ida_controller_info cinfo;
199 	device_t child;
200 	int error, i, unit;
201 
202 	SLIST_INIT(&ida->free_qcbs);
203 	STAILQ_INIT(&ida->qcb_queue);
204 	bioq_init(&ida->bio_queue);
205 
206 	ida->qcbs = (struct ida_qcb *)
207 	    malloc(IDA_QCB_MAX * sizeof(struct ida_qcb), M_DEVBUF,
208 		M_NOWAIT | M_ZERO);
209 	if (ida->qcbs == NULL)
210 		return (ENOMEM);
211 
212 	/*
213 	 * Create our DMA tags
214 	 */
215 
216 	/* DMA tag for our hardware QCB structures */
217 	error = bus_dma_tag_create(
218 		/* parent	*/ ida->parent_dmat,
219 		/* alignment	*/ 1,
220 		/* boundary	*/ 0,
221 		/* lowaddr	*/ BUS_SPACE_MAXADDR,
222 		/* highaddr	*/ BUS_SPACE_MAXADDR,
223 		/* filter	*/ NULL,
224 		/* filterarg	*/ NULL,
225 		/* maxsize	*/ IDA_QCB_MAX * sizeof(struct ida_hardware_qcb),
226 		/* nsegments	*/ 1,
227 		/* maxsegsz	*/ BUS_SPACE_MAXSIZE_32BIT,
228 		/* flags	*/ 0,
229 		/* lockfunc	*/ NULL,
230 		/* lockarg	*/ NULL,
231 		&ida->hwqcb_dmat);
232 	if (error)
233 		return (ENOMEM);
234 
235 	/* DMA tag for mapping buffers into device space */
236 	error = bus_dma_tag_create(
237 		/* parent 	*/ ida->parent_dmat,
238 		/* alignment	*/ 1,
239 		/* boundary	*/ 0,
240 		/* lowaddr	*/ BUS_SPACE_MAXADDR,
241 		/* highaddr	*/ BUS_SPACE_MAXADDR,
242 		/* filter	*/ NULL,
243 		/* filterarg	*/ NULL,
244 		/* maxsize	*/ DFLTPHYS,
245 		/* nsegments	*/ IDA_NSEG,
246 		/* maxsegsz	*/ BUS_SPACE_MAXSIZE_32BIT,
247 		/* flags	*/ 0,
248 		/* lockfunc	*/ busdma_lock_mutex,
249 		/* lockarg	*/ &ida->lock,
250 		&ida->buffer_dmat);
251 	if (error)
252 		return (ENOMEM);
253 
254 	/* Allocation of hardware QCBs */
255 	/* XXX allocation is rounded to hardware page size */
256 	error = bus_dmamem_alloc(ida->hwqcb_dmat,
257 	    (void **)&ida->hwqcbs, BUS_DMA_NOWAIT, &ida->hwqcb_dmamap);
258 	if (error)
259 		return (ENOMEM);
260 
261 	/* And permanently map them in */
262 	bus_dmamap_load(ida->hwqcb_dmat, ida->hwqcb_dmamap,
263 	    ida->hwqcbs, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb),
264 	    ida_dma_map_cb, &ida->hwqcb_busaddr, /*flags*/0);
265 
266 	bzero(ida->hwqcbs, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb));
267 
268 	error = ida_alloc_qcbs(ida);
269 	if (error)
270 		return (error);
271 
272 	mtx_lock(&ida->lock);
273 	ida->cmd.int_enable(ida, 0);
274 
275 	error = ida_command(ida, CMD_GET_CTRL_INFO, &cinfo, sizeof(cinfo),
276 	    IDA_CONTROLLER, 0, DMA_DATA_IN);
277 	if (error) {
278 		mtx_unlock(&ida->lock);
279 		device_printf(ida->dev, "CMD_GET_CTRL_INFO failed.\n");
280 		return (error);
281 	}
282 
283 	device_printf(ida->dev, "drives=%d firm_rev=%c%c%c%c\n",
284 	    cinfo.num_drvs, cinfo.firm_rev[0], cinfo.firm_rev[1],
285 	    cinfo.firm_rev[2], cinfo.firm_rev[3]);
286 
287 	if (ida->flags & IDA_FIRMWARE) {
288 		int data;
289 
290 		error = ida_command(ida, CMD_START_FIRMWARE,
291 		    &data, sizeof(data), IDA_CONTROLLER, 0, DMA_DATA_IN);
292 		if (error) {
293 			mtx_unlock(&ida->lock);
294 			device_printf(ida->dev, "CMD_START_FIRMWARE failed.\n");
295 			return (error);
296 		}
297 	}
298 
299 	ida->cmd.int_enable(ida, 1);
300 	ida->flags |= IDA_ATTACHED;
301 	mtx_unlock(&ida->lock);
302 
303 	for (i = 0; i < cinfo.num_drvs; i++) {
304 		child = device_add_child(ida->dev, /*"idad"*/NULL, DEVICE_UNIT_ANY);
305 		if (child != NULL)
306 			device_set_ivars(child, (void *)(intptr_t)i);
307 	}
308 
309 	ida->ich.ich_func = ida_startup;
310 	ida->ich.ich_arg = ida;
311 	if (config_intrhook_establish(&ida->ich) != 0) {
312 		device_delete_children(ida->dev);
313 		device_printf(ida->dev, "Cannot establish configuration hook\n");
314 		return (error);
315 	}
316 
317 	unit = device_get_unit(ida->dev);
318 	ida->ida_dev_t = make_dev(&ida_cdevsw, unit,
319 				 UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
320 				 "ida%d", unit);
321 	ida->ida_dev_t->si_drv1 = ida;
322 
323 	return (0);
324 }
325 
326 static void
327 ida_startup(void *arg)
328 {
329 	struct ida_softc *ida;
330 
331 	ida = arg;
332 
333 	config_intrhook_disestablish(&ida->ich);
334 
335 	bus_topo_lock();
336 	bus_attach_children(ida->dev);
337 	bus_topo_unlock();
338 }
339 
340 int
341 ida_detach(device_t dev)
342 {
343 	struct ida_softc *ida;
344 	int error;
345 
346 	ida = (struct ida_softc *)device_get_softc(dev);
347 
348 	error = bus_generic_detach(dev);
349 	if (error)
350 		return (error);
351 	error = device_delete_children(dev);
352 	if (error)
353 		return (error);
354 
355 	/*
356 	 * XXX
357 	 * before detaching, we must make sure that the system is
358 	 * quiescent; nothing mounted, no pending activity.
359 	 */
360 
361 	/*
362 	 * XXX
363 	 * now, how are we supposed to maintain a list of our drives?
364 	 * iterate over our "child devices"?
365 	 */
366 
367 	destroy_dev(ida->ida_dev_t);
368 	ida_free(ida);
369 	return (error);
370 }
371 
372 static void
373 ida_data_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
374 {
375 	struct ida_hardware_qcb *hwqcb;
376 	struct ida_softc *ida;
377 	struct ida_qcb *qcb;
378 	bus_dmasync_op_t op;
379 	int i;
380 
381 	qcb = arg;
382 	ida = qcb->ida;
383 	if (!dumping)
384 		mtx_assert(&ida->lock, MA_OWNED);
385 	if (error) {
386 		qcb->error = error;
387 		ida_done(ida, qcb);
388 		return;
389 	}
390 
391 	hwqcb = qcb->hwqcb;
392 	hwqcb->hdr.size = htole16((sizeof(struct ida_req) +
393 	    sizeof(struct ida_sgb) * IDA_NSEG) >> 2);
394 
395 	for (i = 0; i < nsegments; i++) {
396 		hwqcb->seg[i].addr = htole32(segs[i].ds_addr);
397 		hwqcb->seg[i].length = htole32(segs[i].ds_len);
398 	}
399 	hwqcb->req.sgcount = nsegments;
400 	if (qcb->flags & DMA_DATA_TRANSFER) {
401 		switch (qcb->flags & DMA_DATA_TRANSFER) {
402 		case DMA_DATA_TRANSFER:
403 			op = BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE;
404 			break;
405 		case DMA_DATA_IN:
406 			op = BUS_DMASYNC_PREREAD;
407 			break;
408 		default:
409 			KASSERT((qcb->flags & DMA_DATA_TRANSFER) ==
410 			    DMA_DATA_OUT, ("bad DMA data flags"));
411 			op = BUS_DMASYNC_PREWRITE;
412 			break;
413 		}
414 		bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op);
415 	}
416 	bus_dmamap_sync(ida->hwqcb_dmat, ida->hwqcb_dmamap,
417 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
418 
419 	STAILQ_INSERT_TAIL(&ida->qcb_queue, qcb, link.stqe);
420 	ida_start(ida);
421 	ida->flags &= ~IDA_QFROZEN;
422 }
423 
424 static int
425 ida_map_qcb(struct ida_softc *ida, struct ida_qcb *qcb, void *data,
426     bus_size_t datasize)
427 {
428 	int error, flags;
429 
430 	if (ida->flags & IDA_INTERRUPTS)
431 		flags = BUS_DMA_WAITOK;
432 	else
433 		flags = BUS_DMA_NOWAIT;
434 	error = bus_dmamap_load(ida->buffer_dmat, qcb->dmamap, data, datasize,
435 	    ida_data_cb, qcb, flags);
436 	if (error == EINPROGRESS) {
437 		ida->flags |= IDA_QFROZEN;
438 		error = 0;
439 	}
440 	return (error);
441 }
442 
443 int
444 ida_command(struct ida_softc *ida, int command, void *data, int datasize,
445 	int drive, u_int32_t pblkno, int flags)
446 {
447 	struct ida_hardware_qcb *hwqcb;
448 	struct ida_qcb *qcb;
449 	int error;
450 
451 	if (!dumping)
452 		mtx_assert(&ida->lock, MA_OWNED);
453 	qcb = ida_get_qcb(ida);
454 
455 	if (qcb == NULL) {
456 		device_printf(ida->dev, "out of QCBs\n");
457 		return (EAGAIN);
458 	}
459 
460 	qcb->flags = flags | IDA_COMMAND;
461 	hwqcb = qcb->hwqcb;
462 	hwqcb->hdr.drive = drive;
463 	hwqcb->req.blkno = htole32(pblkno);
464 	hwqcb->req.bcount = htole16(howmany(datasize, DEV_BSIZE));
465 	hwqcb->req.command = command;
466 
467 	error = ida_map_qcb(ida, qcb, data, datasize);
468 	if (error == 0) {
469 		error = ida_wait(ida, qcb);
470 		/* Don't free QCB on a timeout in case it later completes. */
471 		if (error)
472 			return (error);
473 		error = qcb->error;
474 	}
475 
476 	/* XXX should have status returned here? */
477 	/* XXX have "status pointer" area in QCB? */
478 
479 	ida_free_qcb(ida, qcb);
480 	return (error);
481 }
482 
483 void
484 ida_submit_buf(struct ida_softc *ida, struct bio *bp)
485 {
486 	mtx_lock(&ida->lock);
487 	bioq_insert_tail(&ida->bio_queue, bp);
488 	ida_startio(ida);
489 	mtx_unlock(&ida->lock);
490 }
491 
492 static void
493 ida_startio(struct ida_softc *ida)
494 {
495 	struct ida_hardware_qcb *hwqcb;
496 	struct ida_qcb *qcb;
497 	struct idad_softc *drv;
498 	struct bio *bp;
499 	int error;
500 
501 	mtx_assert(&ida->lock, MA_OWNED);
502 	for (;;) {
503 		if (ida->flags & IDA_QFROZEN)
504 			return;
505 		bp = bioq_first(&ida->bio_queue);
506 		if (bp == NULL)
507 			return;				/* no more buffers */
508 
509 		qcb = ida_get_qcb(ida);
510 		if (qcb == NULL)
511 			return;				/* out of resources */
512 
513 		bioq_remove(&ida->bio_queue, bp);
514 		qcb->buf = bp;
515 		qcb->flags = bp->bio_cmd == BIO_READ ? DMA_DATA_IN : DMA_DATA_OUT;
516 
517 		hwqcb = qcb->hwqcb;
518 		drv = bp->bio_driver1;
519 		hwqcb->hdr.drive = drv->drive;
520 		hwqcb->req.blkno = bp->bio_pblkno;
521 		hwqcb->req.bcount = howmany(bp->bio_bcount, DEV_BSIZE);
522 		hwqcb->req.command = bp->bio_cmd == BIO_READ ? CMD_READ : CMD_WRITE;
523 
524 		error = ida_map_qcb(ida, qcb, bp->bio_data, bp->bio_bcount);
525 		if (error) {
526 			qcb->error = error;
527 			ida_done(ida, qcb);
528 		}
529 	}
530 }
531 
532 static void
533 ida_start(struct ida_softc *ida)
534 {
535 	struct ida_qcb *qcb;
536 
537 	if (!dumping)
538 		mtx_assert(&ida->lock, MA_OWNED);
539 	while ((qcb = STAILQ_FIRST(&ida->qcb_queue)) != NULL) {
540 		if (ida->cmd.fifo_full(ida))
541 			break;
542 		STAILQ_REMOVE_HEAD(&ida->qcb_queue, link.stqe);
543 		/*
544 		 * XXX
545 		 * place the qcb on an active list?
546 		 */
547 
548 		/* Set a timeout. */
549 		if (!ida->qactive && !dumping)
550 			callout_reset(&ida->ch, hz * 5, ida_timeout, ida);
551 		ida->qactive++;
552 
553 		qcb->state = QCB_ACTIVE;
554 		ida->cmd.submit(ida, qcb);
555 	}
556 }
557 
558 static int
559 ida_wait(struct ida_softc *ida, struct ida_qcb *qcb)
560 {
561 	struct ida_qcb *qcb_done = NULL;
562 	bus_addr_t completed;
563 	int delay;
564 
565 	if (!dumping)
566 		mtx_assert(&ida->lock, MA_OWNED);
567 	if (ida->flags & IDA_INTERRUPTS) {
568 		if (mtx_sleep(qcb, &ida->lock, PRIBIO, "idacmd", 5 * hz)) {
569 			qcb->state = QCB_TIMEDOUT;
570 			return (ETIMEDOUT);
571 		}
572 		return (0);
573 	}
574 
575 again:
576 	delay = 5 * 1000 * 100;			/* 5 sec delay */
577 	while ((completed = ida->cmd.done(ida)) == 0) {
578 		if (delay-- == 0) {
579 			qcb->state = QCB_TIMEDOUT;
580 			return (ETIMEDOUT);
581 		}
582 		DELAY(10);
583 	}
584 
585 	qcb_done = idahwqcbptov(ida, completed & ~3);
586 	if (qcb_done != qcb)
587 		goto again;
588 	ida_done(ida, qcb);
589 	return (0);
590 }
591 
592 void
593 ida_intr(void *data)
594 {
595 	struct ida_softc *ida;
596 	struct ida_qcb *qcb;
597 	bus_addr_t completed;
598 
599 	ida = (struct ida_softc *)data;
600 
601 	mtx_lock(&ida->lock);
602 	if (ida->cmd.int_pending(ida) == 0) {
603 		mtx_unlock(&ida->lock);
604 		return;				/* not our interrupt */
605 	}
606 
607 	while ((completed = ida->cmd.done(ida)) != 0) {
608 		qcb = idahwqcbptov(ida, completed & ~3);
609 
610 		if (qcb == NULL || qcb->state != QCB_ACTIVE) {
611 			device_printf(ida->dev,
612 			    "ignoring completion %jx\n", (intmax_t)completed);
613 			continue;
614 		}
615 		/* Handle "Bad Command List" errors. */
616 		if ((completed & 3) && (qcb->hwqcb->req.error == 0))
617 			qcb->hwqcb->req.error = CMD_REJECTED;
618 		ida_done(ida, qcb);
619 	}
620 	ida_startio(ida);
621 	mtx_unlock(&ida->lock);
622 }
623 
624 /*
625  * should switch out command type; may be status, not just I/O.
626  */
627 static void
628 ida_done(struct ida_softc *ida, struct ida_qcb *qcb)
629 {
630 	bus_dmasync_op_t op;
631 	int active, error = 0;
632 
633 	/*
634 	 * finish up command
635 	 */
636 	if (!dumping)
637 		mtx_assert(&ida->lock, MA_OWNED);
638 	active = (qcb->state != QCB_FREE);
639 	if (qcb->flags & DMA_DATA_TRANSFER && active) {
640 		switch (qcb->flags & DMA_DATA_TRANSFER) {
641 		case DMA_DATA_TRANSFER:
642 			op = BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE;
643 			break;
644 		case DMA_DATA_IN:
645 			op = BUS_DMASYNC_POSTREAD;
646 			break;
647 		default:
648 			KASSERT((qcb->flags & DMA_DATA_TRANSFER) ==
649 			    DMA_DATA_OUT, ("bad DMA data flags"));
650 			op = BUS_DMASYNC_POSTWRITE;
651 			break;
652 		}
653 		bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op);
654 		bus_dmamap_unload(ida->buffer_dmat, qcb->dmamap);
655 	}
656 	if (active)
657 		bus_dmamap_sync(ida->hwqcb_dmat, ida->hwqcb_dmamap,
658 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
659 
660 	if (qcb->hwqcb->req.error & SOFT_ERROR) {
661 		if (qcb->buf)
662 			device_printf(ida->dev, "soft %s error\n",
663 				qcb->buf->bio_cmd == BIO_READ ?
664 					"read" : "write");
665 		else
666 			device_printf(ida->dev, "soft error\n");
667 	}
668 	if (qcb->hwqcb->req.error & HARD_ERROR) {
669 		error = 1;
670 		if (qcb->buf)
671 			device_printf(ida->dev, "hard %s error\n",
672 				qcb->buf->bio_cmd == BIO_READ ?
673 					"read" : "write");
674 		else
675 			device_printf(ida->dev, "hard error\n");
676 	}
677 	if (qcb->hwqcb->req.error & CMD_REJECTED) {
678 		error = 1;
679 		device_printf(ida->dev, "invalid request\n");
680 	}
681 	if (qcb->error) {
682 		error = 1;
683 		device_printf(ida->dev, "request failed to map: %d\n", qcb->error);
684 	}
685 
686 	if (qcb->flags & IDA_COMMAND) {
687 		if (ida->flags & IDA_INTERRUPTS)
688 			wakeup(qcb);
689 		if (qcb->state == QCB_TIMEDOUT)
690 			ida_free_qcb(ida, qcb);
691 	} else {
692 		KASSERT(qcb->buf != NULL, ("ida_done(): qcb->buf is NULL!"));
693 		if (error)
694 			qcb->buf->bio_flags |= BIO_ERROR;
695 		idad_intr(qcb->buf);
696 		ida_free_qcb(ida, qcb);
697 	}
698 
699 	if (!active)
700 		return;
701 
702 	ida->qactive--;
703 	/* Reschedule or cancel timeout */
704 	if (ida->qactive)
705 		callout_reset(&ida->ch, hz * 5, ida_timeout, ida);
706 	else
707 		callout_stop(&ida->ch);
708 }
709 
710 static void
711 ida_timeout(void *arg)
712 {
713 	struct ida_softc *ida;
714 
715 	ida = (struct ida_softc *)arg;
716 	device_printf(ida->dev, "%s() qactive %d\n", __func__, ida->qactive);
717 
718 	if (ida->flags & IDA_INTERRUPTS)
719 		device_printf(ida->dev, "IDA_INTERRUPTS\n");
720 
721 	device_printf(ida->dev,	"\t   R_CMD_FIFO: %08x\n"
722 				"\t  R_DONE_FIFO: %08x\n"
723 				"\t   R_INT_MASK: %08x\n"
724 				"\t     R_STATUS: %08x\n"
725 				"\tR_INT_PENDING: %08x\n",
726 					ida_inl(ida, R_CMD_FIFO),
727 					ida_inl(ida, R_DONE_FIFO),
728 					ida_inl(ida, R_INT_MASK),
729 					ida_inl(ida, R_STATUS),
730 					ida_inl(ida, R_INT_PENDING));
731 
732 	return;
733 }
734 
735 /*
736  * IOCTL stuff follows.
737  */
738 struct cmd_info {
739 	int	cmd;
740 	int	len;
741 	int	flags;
742 };
743 static struct cmd_info *ida_cmd_lookup(int);
744 
745 static int
746 ida_ioctl (struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td)
747 {
748 	struct ida_softc *sc;
749 	struct ida_user_command *uc;
750 	struct cmd_info *ci;
751 	int len;
752 	int flags;
753 	int error;
754 	int data;
755 	void *daddr;
756 
757 	sc = (struct ida_softc *)dev->si_drv1;
758 	uc = (struct ida_user_command *)addr;
759 	error = 0;
760 
761 	switch (cmd) {
762 	case IDAIO_COMMAND:
763 		ci = ida_cmd_lookup(uc->command);
764 		if (ci == NULL) {
765 			error = EINVAL;
766 			break;
767 		}
768 		len = ci->len;
769 		flags = ci->flags;
770 		if (len)
771 			daddr = &uc->d.buf;
772 		else {
773 			daddr = &data;
774 			len = sizeof(data);
775 		}
776 		mtx_lock(&sc->lock);
777 		error = ida_command(sc, uc->command, daddr, len,
778 				    uc->drive, uc->blkno, flags);
779 		mtx_unlock(&sc->lock);
780 		break;
781 	default:
782 		error = ENOIOCTL;
783 		break;
784 	}
785 	return (error);
786 }
787 
788 static struct cmd_info ci_list[] = {
789 	{ CMD_GET_LOG_DRV_INFO,
790 			sizeof(struct ida_drive_info), DMA_DATA_IN },
791 	{ CMD_GET_CTRL_INFO,
792 			sizeof(struct ida_controller_info), DMA_DATA_IN },
793 	{ CMD_SENSE_DRV_STATUS,
794 			sizeof(struct ida_drive_status), DMA_DATA_IN },
795 	{ CMD_START_RECOVERY,		0, 0 },
796 	{ CMD_GET_PHYS_DRV_INFO,
797 			sizeof(struct ida_phys_drv_info), DMA_DATA_TRANSFER },
798 	{ CMD_BLINK_DRV_LEDS,
799 			sizeof(struct ida_blink_drv_leds), DMA_DATA_OUT },
800 	{ CMD_SENSE_DRV_LEDS,
801 			sizeof(struct ida_blink_drv_leds), DMA_DATA_IN },
802 	{ CMD_GET_LOG_DRV_EXT,
803 			sizeof(struct ida_drive_info_ext), DMA_DATA_IN },
804 	{ CMD_RESET_CTRL,		0, 0 },
805 	{ CMD_GET_CONFIG,		0, 0 },
806 	{ CMD_SET_CONFIG,		0, 0 },
807 	{ CMD_LABEL_LOG_DRV,
808 			sizeof(struct ida_label_logical), DMA_DATA_OUT },
809 	{ CMD_SET_SURFACE_DELAY,	0, 0 },
810 	{ CMD_SENSE_BUS_PARAMS,		0, 0 },
811 	{ CMD_SENSE_SUBSYS_INFO,	0, 0 },
812 	{ CMD_SENSE_SURFACE_ATS,	0, 0 },
813 	{ CMD_PASSTHROUGH,		0, 0 },
814 	{ CMD_RESET_SCSI_DEV,		0, 0 },
815 	{ CMD_PAUSE_BG_ACT,		0, 0 },
816 	{ CMD_RESUME_BG_ACT,		0, 0 },
817 	{ CMD_START_FIRMWARE,		0, 0 },
818 	{ CMD_SENSE_DRV_ERR_LOG,	0, 0 },
819 	{ CMD_START_CPM,		0, 0 },
820 	{ CMD_SENSE_CP,			0, 0 },
821 	{ CMD_STOP_CPM,			0, 0 },
822 	{ CMD_FLUSH_CACHE,		0, 0 },
823 	{ CMD_ACCEPT_MEDIA_EXCH,	0, 0 },
824 	{ 0, 0, 0 }
825 };
826 
827 static struct cmd_info *
828 ida_cmd_lookup (int command)
829 {
830 	struct cmd_info *ci;
831 
832 	ci = ci_list;
833 	while (ci->cmd) {
834 		if (ci->cmd == command)
835 			return (ci);
836 		ci++;
837 	}
838 	return (NULL);
839 }
840