1 /*-
2 * Copyright (c) 2003-04 3ware, Inc.
3 * Copyright (c) 2000 Michael Smith
4 * Copyright (c) 2000 BSDi
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: releng/5.3/sys/dev/twa/twa_freebsd.c 134297 2004-08-25 17:15:26Z vkashyap $
29 */
30
31 /*
32 * 3ware driver for 9000 series storage controllers.
33 *
34 * Author: Vinod Kashyap
35 */
36
37
38 #include <dev/twa/twa_includes.h>
39
40 static void twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs,
41 int nsegments, int error);
42 static void twa_setup_request_dmamap(void *arg, bus_dma_segment_t *segs,
43 int nsegments, int error);
44
45 MALLOC_DEFINE(TWA_MALLOC_CLASS, "twa commands", "twa commands");
46
47
48 static d_open_t twa_open;
49 static d_close_t twa_close;
50 static d_ioctl_t twa_ioctl_wrapper;
51
52 static struct cdevsw twa_cdevsw = {
53 .d_version = D_VERSION,
54 .d_flags = D_NEEDGIANT,
55 .d_open = twa_open,
56 .d_close = twa_close,
57 .d_ioctl = twa_ioctl_wrapper,
58 .d_name = "twa",
59 };
60
61 static devclass_t twa_devclass;
62
63
64 /*
65 * Function name: twa_open
66 * Description: Called when the controller is opened.
67 * Simply marks the controller as open.
68 *
69 * Input: dev -- control device corresponding to the ctlr
70 * flags -- mode of open
71 * fmt -- device type (character/block etc.)
72 * proc -- current process
73 * Output: None
74 * Return value: 0 -- success
75 * non-zero-- failure
76 */
77 static int
78 twa_open(struct cdev *dev, int flags, int fmt, d_thread_t *proc)
79 {
80 int unit = minor(dev);
81 struct twa_softc *sc = devclass_get_softc(twa_devclass, unit);
82
83 sc->twa_state |= TWA_STATE_OPEN;
84 return(0);
85 }
86
87
88
89 /*
90 * Function name: twa_close
91 * Description: Called when the controller is closed.
92 * Simply marks the controller as not open.
93 *
94 * Input: dev -- control device corresponding to the ctlr
95 * flags -- mode of corresponding open
96 * fmt -- device type (character/block etc.)
97 * proc -- current process
98 * Output: None
99 * Return value: 0 -- success
100 * non-zero-- failure
101 */
102 static int
103 twa_close(struct cdev *dev, int flags, int fmt, d_thread_t *proc)
104 {
105 int unit = minor(dev);
106 struct twa_softc *sc = devclass_get_softc(twa_devclass, unit);
107
108 sc->twa_state &= ~TWA_STATE_OPEN;
109 return(0);
110 }
111
112
113
114 /*
115 * Function name: twa_ioctl_wrapper
116 * Description: Called when an ioctl is posted to the controller.
117 * Simply calls the ioctl handler.
118 *
119 * Input: dev -- control device corresponding to the ctlr
120 * cmd -- ioctl cmd
121 * buf -- ptr to buffer in kernel memory, which is
122 * a copy of the input buffer in user-space
123 * flags -- mode of corresponding open
124 * proc -- current process
125 * Output: buf -- ptr to buffer in kernel memory, which will
126 * be copied to the output buffer in user-space
127 * Return value: 0 -- success
128 * non-zero-- failure
129 */
130 static int
131 twa_ioctl_wrapper(struct cdev *dev, u_long cmd, caddr_t buf,
132 int flags, d_thread_t *proc)
133 {
134 struct twa_softc *sc = (struct twa_softc *)(dev->si_drv1);
135
136 return(twa_ioctl(sc, cmd, buf));
137 }
138
139
140
141 static int twa_probe (device_t dev);
142 static int twa_attach (device_t dev);
143 static void twa_free (struct twa_softc *sc);
144 static int twa_detach (device_t dev);
145 static int twa_shutdown (device_t dev);
146 static int twa_suspend (device_t dev);
147 static int twa_resume (device_t dev);
148 static void twa_pci_intr(void *arg);
149 static void twa_intrhook (void *arg);
150
151 static device_method_t twa_methods[] = {
152 /* Device interface */
153 DEVMETHOD(device_probe, twa_probe),
154 DEVMETHOD(device_attach, twa_attach),
155 DEVMETHOD(device_detach, twa_detach),
156 DEVMETHOD(device_shutdown, twa_shutdown),
157 DEVMETHOD(device_suspend, twa_suspend),
158 DEVMETHOD(device_resume, twa_resume),
159
160 DEVMETHOD(bus_print_child, bus_generic_print_child),
161 DEVMETHOD(bus_driver_added, bus_generic_driver_added),
162 {0, 0}
163 };
164
165 static driver_t twa_pci_driver = {
166 "twa",
167 twa_methods,
168 sizeof(struct twa_softc)
169 };
170
171 DRIVER_MODULE(twa, pci, twa_pci_driver, twa_devclass, 0, 0);
172
173
174
175 /*
176 * Function name: twa_probe
177 * Description: Called at driver load time. Claims 9000 ctlrs.
178 *
179 * Input: dev -- bus device corresponding to the ctlr
180 * Output: None
181 * Return value: <= 0 -- success
182 * > 0 -- failure
183 */
184 static int
185 twa_probe(device_t dev)
186 {
187 static u_int8_t first_ctlr = 1;
188
189 twa_dbg_print(3, "entered");
190
191 if ((pci_get_vendor(dev) == TWA_VENDOR_ID) &&
192 (pci_get_device(dev) == TWA_DEVICE_ID_9K)) {
193 device_set_desc(dev, TWA_DEVICE_NAME);
194 /* Print the driver version only once. */
195 if (first_ctlr) {
196 printf("3ware device driver for 9000 series storage controllers, version: %s\n",
197 TWA_DRIVER_VERSION_STRING);
198 first_ctlr = 0;
199 }
200 return(0);
201 }
202 return(ENXIO);
203 }
204
205
206
207 /*
208 * Function name: twa_attach
209 * Description: Allocates pci resources; updates sc; adds a node to the
210 * sysctl tree to expose the driver version; makes calls
211 * to initialize ctlr, and to attach to CAM.
212 *
213 * Input: dev -- bus device corresponding to the ctlr
214 * Output: None
215 * Return value: 0 -- success
216 * non-zero-- failure
217 */
218 static int
219 twa_attach(device_t dev)
220 {
221 struct twa_softc *sc = device_get_softc(dev);
222 u_int32_t command;
223 int res_id;
224 int error;
225
226 twa_dbg_dprint_enter(3, sc);
227
228 /* Initialize the softc structure. */
229 sc->twa_bus_dev = dev;
230
231 sysctl_ctx_init(&sc->twa_sysctl_ctx);
232 sc->twa_sysctl_tree = SYSCTL_ADD_NODE(&sc->twa_sysctl_ctx,
233 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
234 device_get_nameunit(dev), CTLFLAG_RD, 0, "");
235 if (sc->twa_sysctl_tree == NULL) {
236 twa_printf(sc, "Cannot add sysctl tree node.\n");
237 return(ENXIO);
238 }
239 SYSCTL_ADD_STRING(&sc->twa_sysctl_ctx, SYSCTL_CHILDREN(sc->twa_sysctl_tree),
240 OID_AUTO, "driver_version", CTLFLAG_RD,
241 TWA_DRIVER_VERSION_STRING, 0, "TWA driver version");
242
243 /* Make sure we are going to be able to talk to this board. */
244 command = pci_read_config(dev, PCIR_COMMAND, 2);
245 if ((command & PCIM_CMD_PORTEN) == 0) {
246 twa_printf(sc, "Register window not available.\n");
247 return(ENXIO);
248 }
249
250 /* Force the busmaster enable bit on, in case the BIOS forgot. */
251 command |= PCIM_CMD_BUSMASTEREN;
252 pci_write_config(dev, PCIR_COMMAND, command, 2);
253
254 /* Allocate the PCI register window. */
255 res_id = TWA_IO_CONFIG_REG;
256 if ((sc->twa_io_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &res_id,
257 0, ~0, 1, RF_ACTIVE)) == NULL) {
258 twa_printf(sc, "can't allocate register window.\n");
259 twa_free(sc);
260 return(ENXIO);
261 }
262 sc->twa_bus_tag = rman_get_bustag(sc->twa_io_res);
263 sc->twa_bus_handle = rman_get_bushandle(sc->twa_io_res);
264
265 /* Allocate and connect our interrupt. */
266 res_id = 0;
267 if ((sc->twa_irq_res = bus_alloc_resource(sc->twa_bus_dev, SYS_RES_IRQ,
268 &res_id, 0, ~0, 1,
269 RF_SHAREABLE | RF_ACTIVE)) == NULL) {
270 twa_printf(sc, "Can't allocate interrupt.\n");
271 twa_free(sc);
272 return(ENXIO);
273 }
274 if (bus_setup_intr(sc->twa_bus_dev, sc->twa_irq_res, INTR_TYPE_CAM,
275 twa_pci_intr, sc, &sc->twa_intr_handle)) {
276 twa_printf(sc, "Can't set up interrupt.\n");
277 twa_free(sc);
278 return(ENXIO);
279 }
280
281 /* Initialize the driver for this controller. */
282 if ((error = twa_setup(sc))) {
283 twa_free(sc);
284 return(error);
285 }
286
287 /* Print some information about the controller and configuration. */
288 twa_describe_controller(sc);
289
290 /* Create the control device. */
291 sc->twa_ctrl_dev = make_dev(&twa_cdevsw, device_get_unit(sc->twa_bus_dev),
292 UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
293 "twa%d", device_get_unit(sc->twa_bus_dev));
294 sc->twa_ctrl_dev->si_drv1 = sc;
295
296 /*
297 * Schedule ourselves to bring the controller up once interrupts are
298 * available. This isn't strictly necessary, since we disable
299 * interrupts while probing the controller, but it is more in keeping
300 * with common practice for other disk devices.
301 */
302 sc->twa_ich.ich_func = twa_intrhook;
303 sc->twa_ich.ich_arg = sc;
304 if (config_intrhook_establish(&sc->twa_ich) != 0) {
305 twa_printf(sc, "Can't establish configuration hook.\n");
306 twa_free(sc);
307 return(ENXIO);
308 }
309
310 if ((error = twa_cam_setup(sc))) {
311 twa_free(sc);
312 return(error);
313 }
314 return(0);
315 }
316
317
318
319 /*
320 * Function name: twa_free
321 * Description: Performs clean-up at the time of going down.
322 *
323 * Input: sc -- ptr to per ctlr structure
324 * Output: None
325 * Return value: None
326 */
327 static void
328 twa_free(struct twa_softc *sc)
329 {
330 struct twa_request *tr;
331
332 twa_dbg_dprint_enter(3, sc);
333
334 /* Detach from CAM */
335 twa_cam_detach(sc);
336
337 /* Destroy dma handles. */
338
339 bus_dmamap_unload(sc->twa_dma_tag, sc->twa_cmd_map);
340 while ((tr = twa_dequeue_free(sc)) != NULL)
341 bus_dmamap_destroy(sc->twa_dma_tag, tr->tr_dma_map);
342
343 /* Free all memory allocated so far. */
344 if (sc->twa_req_buf)
345 free(sc->twa_req_buf, TWA_MALLOC_CLASS);
346 if (sc->twa_cmd_pkt_buf)
347 bus_dmamem_free(sc->twa_dma_tag, sc->twa_cmd_pkt_buf,
348 sc->twa_cmd_map);
349 if (sc->twa_aen_queue[0])
350 free (sc->twa_aen_queue[0], M_DEVBUF);
351
352 /* Destroy the data-transfer DMA tag. */
353 if (sc->twa_dma_tag)
354 bus_dma_tag_destroy(sc->twa_dma_tag);
355
356 /* Disconnect the interrupt handler. */
357 if (sc->twa_intr_handle)
358 bus_teardown_intr(sc->twa_bus_dev, sc->twa_irq_res,
359 sc->twa_intr_handle);
360 if (sc->twa_irq_res != NULL)
361 bus_release_resource(sc->twa_bus_dev, SYS_RES_IRQ,
362 0, sc->twa_irq_res);
363
364 /* Release the register window mapping. */
365 if (sc->twa_io_res != NULL)
366 bus_release_resource(sc->twa_bus_dev, SYS_RES_IOPORT,
367 TWA_IO_CONFIG_REG, sc->twa_io_res);
368
369 /* Destroy the control device. */
370 if (sc->twa_ctrl_dev != (struct cdev *)NULL)
371 destroy_dev(sc->twa_ctrl_dev);
372
373 sysctl_ctx_free(&sc->twa_sysctl_ctx);
374 }
375
376
377
378 /*
379 * Function name: twa_detach
380 * Description: Called when the controller is being detached from
381 * the pci bus.
382 *
383 * Input: dev -- bus device corresponding to the ctlr
384 * Output: None
385 * Return value: 0 -- success
386 * non-zero-- failure
387 */
388 static int
389 twa_detach(device_t dev)
390 {
391 struct twa_softc *sc = device_get_softc(dev);
392 int s;
393 int error;
394
395 twa_dbg_dprint_enter(3, sc);
396
397 error = EBUSY;
398 s = splcam();
399 if (sc->twa_state & TWA_STATE_OPEN)
400 goto out;
401
402 /* Shut the controller down. */
403 if ((error = twa_shutdown(dev)))
404 goto out;
405
406 /* Free all resources associated with this controller. */
407 twa_free(sc);
408 error = 0;
409
410 out:
411 splx(s);
412 return(error);
413 }
414
415
416
417 /*
418 * Function name: twa_shutdown
419 * Description: Called at unload/shutdown time. Lets the controller
420 * know that we are going down.
421 *
422 * Input: dev -- bus device corresponding to the ctlr
423 * Output: None
424 * Return value: 0 -- success
425 * non-zero-- failure
426 */
427 static int
428 twa_shutdown(device_t dev)
429 {
430 struct twa_softc *sc = device_get_softc(dev);
431 int s;
432 int error = 0;
433
434 twa_dbg_dprint_enter(3, sc);
435
436 s = splcam();
437
438 /* Disconnect from the controller. */
439 error = twa_deinit_ctlr(sc);
440
441 splx(s);
442 return(error);
443 }
444
445
446
447 /*
448 * Function name: twa_suspend
449 * Description: Called to suspend I/O before hot-swapping PCI ctlrs.
450 * Doesn't do much as of now.
451 *
452 * Input: dev -- bus device corresponding to the ctlr
453 * Output: None
454 * Return value: 0 -- success
455 * non-zero-- failure
456 */
457 static int
458 twa_suspend(device_t dev)
459 {
460 struct twa_softc *sc = device_get_softc(dev);
461 int s;
462
463 twa_dbg_dprint_enter(3, sc);
464
465 s = splcam();
466 sc->twa_state |= TWA_STATE_SUSPEND;
467
468 twa_disable_interrupts(sc);
469 splx(s);
470
471 return(1);
472 }
473
474
475
476 /*
477 * Function name: twa_resume
478 * Description: Called to resume I/O after hot-swapping PCI ctlrs.
479 * Doesn't do much as of now.
480 *
481 * Input: dev -- bus device corresponding to the ctlr
482 * Output: None
483 * Return value: 0 -- success
484 * non-zero-- failure
485 */
486 static int
487 twa_resume(device_t dev)
488 {
489 struct twa_softc *sc = device_get_softc(dev);
490
491 twa_dbg_dprint_enter(3, sc);
492
493 sc->twa_state &= ~TWA_STATE_SUSPEND;
494 twa_enable_interrupts(sc);
495
496 return(1);
497 }
498
499
500
501 /*
502 * Function name: twa_pci_intr
503 * Description: Interrupt handler. Wrapper for twa_interrupt.
504 *
505 * Input: arg -- ptr to per ctlr structure
506 * Output: None
507 * Return value: None
508 */
509 static void
510 twa_pci_intr(void *arg)
511 {
512 struct twa_softc *sc = (struct twa_softc *)arg;
513
514 twa_interrupt(sc);
515 }
516
517
518
519 /*
520 * Function name: twa_intrhook
521 * Description: Callback for us to enable interrupts.
522 *
523 * Input: arg -- ptr to per ctlr structure
524 * Output: None
525 * Return value: None
526 */
527 static void
528 twa_intrhook(void *arg)
529 {
530 struct twa_softc *sc = (struct twa_softc *)arg;
531
532 twa_dbg_dprint(4, sc, "twa_intrhook Entered");
533
534 /* Pull ourselves off the intrhook chain. */
535 config_intrhook_disestablish(&sc->twa_ich);
536
537 /* Enable interrupts. */
538 twa_enable_interrupts(sc);
539 }
540
541
542
543 /*
544 * Function name: twa_write_pci_config
545 * Description: Writes to the PCI config space.
546 *
547 * Input: sc -- ptr to per ctlr structure
548 * value -- value to be written
549 * size -- # of bytes to be written
550 * Output: None
551 * Return value: None
552 */
553 void
554 twa_write_pci_config(struct twa_softc *sc, u_int32_t value, int size)
555 {
556 pci_write_config(sc->twa_bus_dev, PCIR_STATUS, value, size);
557 }
558
559
560
561 /*
562 * Function name: twa_alloc_req_pkts
563 * Description: Allocates memory for, and initializes request pkts,
564 * and queues them in the free queue.
565 *
566 * Input: sc -- ptr to per ctlr structure
567 * num_reqs-- # of request pkts to allocate and initialize.
568 * Output: None
569 * Return value: 0 -- success
570 * non-zero-- failure
571 */
572 int
573 twa_alloc_req_pkts(struct twa_softc *sc, int num_reqs)
574 {
575 struct twa_request *tr;
576 int i;
577
578 if ((sc->twa_req_buf = malloc(num_reqs * sizeof(struct twa_request),
579 TWA_MALLOC_CLASS, M_NOWAIT)) == NULL)
580 return(ENOMEM);
581
582 /* Allocate the bus DMA tag appropriate for PCI. */
583 if (bus_dma_tag_create(NULL, /* parent */
584 TWA_ALIGNMENT, /* alignment */
585 0, /* boundary */
586 BUS_SPACE_MAXADDR, /* lowaddr */
587 BUS_SPACE_MAXADDR, /* highaddr */
588 NULL, NULL, /* filter, filterarg */
589 TWA_Q_LENGTH *
590 (sizeof(struct twa_command_packet)),/* maxsize */
591 TWA_MAX_SG_ELEMENTS, /* nsegments */
592 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
593 BUS_DMA_ALLOCNOW, /* flags */
594 busdma_lock_mutex, /* lockfunc */
595 &Giant, /* lockfuncarg */
596 &sc->twa_dma_tag /* tag */)) {
597 twa_printf(sc, "Can't allocate DMA tag.\n");
598 return(ENOMEM);
599 }
600
601 /* Allocate memory for cmd pkts. */
602 if (bus_dmamem_alloc(sc->twa_dma_tag,
603 (void *)(&(sc->twa_cmd_pkt_buf)),
604 BUS_DMA_WAITOK, &(sc->twa_cmd_map)))
605 return(ENOMEM);
606
607 bus_dmamap_load(sc->twa_dma_tag, sc->twa_cmd_map,
608 sc->twa_cmd_pkt_buf,
609 num_reqs * sizeof(struct twa_command_packet),
610 twa_setup_request_dmamap, sc, 0);
611 bzero(sc->twa_req_buf, num_reqs * sizeof(struct twa_request));
612 bzero(sc->twa_cmd_pkt_buf,
613 num_reqs * sizeof(struct twa_command_packet));
614
615 for (i = 0; i < num_reqs; i++) {
616 tr = &(sc->twa_req_buf[i]);
617 tr->tr_command = &(sc->twa_cmd_pkt_buf[i]);
618 tr->tr_cmd_phys = sc->twa_cmd_pkt_phys +
619 (i * sizeof(struct twa_command_packet));
620 tr->tr_request_id = i;
621 tr->tr_sc = sc;
622 sc->twa_lookup[i] = tr;
623
624 /*
625 * Create a map for data buffers. maxsize (256 * 1024) used in
626 * bus_dma_tag_create above should suffice the bounce page needs
627 * for data buffers, since the max I/O size we support is 128KB.
628 * If we supported I/O's bigger than 256KB, we would have to
629 * create a second dma_tag, with the appropriate maxsize.
630 */
631 if (bus_dmamap_create(sc->twa_dma_tag, 0,
632 &tr->tr_dma_map))
633 return(ENOMEM);
634
635 /* Insert request into the free queue. */
636 twa_release_request(tr);
637 }
638 return(0);
639 }
640
641
642
643 /*
644 * Function name: twa_fillin_sgl
645 * Description: Fills in the scatter/gather list.
646 *
647 * Input: sgl -- ptr to sg list
648 * segs -- ptr to fill the sg list from
649 * nsegments--# of segments
650 * Output: None
651 * Return value: None
652 */
653 static void
654 twa_fillin_sgl(struct twa_sg *sgl, bus_dma_segment_t *segs, int nsegments)
655 {
656 int i;
657
658 for (i = 0; i < nsegments; i++) {
659 sgl[i].address = segs[i].ds_addr;
660 sgl[i].length = (u_int32_t)(segs[i].ds_len);
661 }
662 }
663
664
665
666 /*
667 * Function name: twa_setup_data_dmamap
668 * Description: Callback of bus_dmamap_load for the buffer associated
669 * with data. Updates the cmd pkt (size/sgl_entries
670 * fields, as applicable) to reflect the number of sg
671 * elements.
672 *
673 * Input: arg -- ptr to request pkt
674 * segs -- ptr to a list of segment descriptors
675 * nsegments--# of segments
676 * error -- 0 if no errors encountered before callback,
677 * non-zero if errors were encountered
678 * Output: None
679 * Return value: None
680 */
681 static void
682 twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs,
683 int nsegments, int error)
684 {
685 struct twa_request *tr = (struct twa_request *)arg;
686 struct twa_command_packet *cmdpkt = tr->tr_command;
687 struct twa_command_9k *cmd9k;
688 union twa_command_7k *cmd7k;
689 u_int8_t sgl_offset;
690
691 twa_dbg_dprint_enter(10, tr->tr_sc);
692
693 if ((tr->tr_flags & TWA_CMD_IN_PROGRESS) &&
694 (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL))
695 twa_allow_new_requests(tr->tr_sc, (void *)(tr->tr_private));
696
697 if (error == EFBIG) {
698 tr->tr_error = error;
699 goto out;
700 }
701
702 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) {
703 cmd9k = &(cmdpkt->command.cmd_pkt_9k);
704 twa_fillin_sgl(&(cmd9k->sg_list[0]), segs, nsegments);
705 cmd9k->sgl_entries += nsegments - 1;
706 } else {
707 /* It's a 7000 command packet. */
708 cmd7k = &(cmdpkt->command.cmd_pkt_7k);
709 if ((sgl_offset = cmdpkt->command.cmd_pkt_7k.generic.sgl_offset))
710 twa_fillin_sgl((struct twa_sg *)
711 (((u_int32_t *)cmd7k) + sgl_offset),
712 segs, nsegments);
713 /* Modify the size field, based on sg address size. */
714 cmd7k->generic.size +=
715 ((TWA_64BIT_ADDRESSES ? 3 : 2) * nsegments);
716 }
717
718 if (tr->tr_flags & TWA_CMD_DATA_IN)
719 bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map,
720 BUS_DMASYNC_PREREAD);
721 if (tr->tr_flags & TWA_CMD_DATA_OUT) {
722 /*
723 * If we're using an alignment buffer, and we're
724 * writing data, copy the real data out.
725 */
726 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED)
727 bcopy(tr->tr_real_data, tr->tr_data, tr->tr_real_length);
728 bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map,
729 BUS_DMASYNC_PREWRITE);
730 }
731 error = twa_submit_io(tr);
732
733 out:
734 if (error) {
735 twa_unmap_request(tr);
736 /*
737 * If the caller had been returned EINPROGRESS, and he has
738 * registered a callback for handling completion, the callback
739 * will never get called because we were unable to submit the
740 * request. So, free up the request right here.
741 */
742 if ((tr->tr_flags & TWA_CMD_IN_PROGRESS) && (tr->tr_callback))
743 twa_release_request(tr);
744 }
745 }
746
747
748
749 /*
750 * Function name: twa_setup_request_dmamap
751 * Description: Callback of bus_dmamap_load for the buffer associated
752 * with a cmd pkt.
753 *
754 * Input: arg -- ptr to request pkt
755 * segs -- ptr to a list of segment descriptors
756 * nsegments--# of segments
757 * error -- 0 if no errors encountered before callback,
758 * non-zero if errors were encountered
759 * Output: None
760 * Return value: None
761 */
762 static void
763 twa_setup_request_dmamap(void *arg, bus_dma_segment_t *segs,
764 int nsegments, int error)
765 {
766 struct twa_softc *sc = (struct twa_softc *)arg;
767
768 twa_dbg_dprint_enter(10, sc);
769
770 sc->twa_cmd_pkt_phys = segs[0].ds_addr;
771 }
772
773
774
775 /*
776 * Function name: twa_map_request
777 * Description: Maps a cmd pkt and data associated with it, into
778 * DMA'able memory.
779 *
780 * Input: tr -- ptr to request pkt
781 * Output: None
782 * Return value: 0 -- success
783 * non-zero-- failure
784 */
785 int
786 twa_map_request(struct twa_request *tr)
787 {
788 struct twa_softc *sc = tr->tr_sc;
789 int error = 0;
790
791 twa_dbg_dprint_enter(10, sc);
792
793 /* If the command involves data, map that too. */
794 if (tr->tr_data != NULL) {
795 /*
796 * It's sufficient for the data pointer to be 4-byte aligned
797 * to work with 9000. However, if 4-byte aligned addresses
798 * are passed to bus_dmamap_load, we can get back sg elements
799 * that are not 512-byte multiples in size. So, we will let
800 * only those buffers that are 512-byte aligned to pass
801 * through, and bounce the rest, so as to make sure that we
802 * always get back sg elements that are 512-byte multiples
803 * in size.
804 */
805 if (((vm_offset_t)tr->tr_data % 512) || (tr->tr_length % 512)) {
806 tr->tr_flags |= TWA_CMD_DATA_COPY_NEEDED;
807 tr->tr_real_data = tr->tr_data; /* save original data pointer */
808 tr->tr_real_length = tr->tr_length; /* save original data length */
809 tr->tr_length = (tr->tr_length + 511) & ~511;
810 tr->tr_data = malloc(tr->tr_length, TWA_MALLOC_CLASS, M_NOWAIT);
811 if (tr->tr_data == NULL) {
812 twa_printf(sc, "%s: malloc failed\n", __func__);
813 tr->tr_data = tr->tr_real_data; /* restore original data pointer */
814 tr->tr_length = tr->tr_real_length; /* restore original data length */
815 return(ENOMEM);
816 }
817 }
818
819 /*
820 * Map the data buffer into bus space and build the s/g list.
821 */
822 if ((error = bus_dmamap_load(sc->twa_dma_tag, tr->tr_dma_map,
823 tr->tr_data, tr->tr_length,
824 twa_setup_data_dmamap, tr,
825 BUS_DMA_WAITOK))) {
826 if (error == EINPROGRESS) {
827 tr->tr_flags |= TWA_CMD_IN_PROGRESS;
828 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
829 twa_disallow_new_requests(sc);
830 error = 0;
831 } else {
832 /* Free alignment buffer if it was used. */
833 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) {
834 free(tr->tr_data, TWA_MALLOC_CLASS);
835 tr->tr_data = tr->tr_real_data; /* restore 'real' data pointer */
836 tr->tr_length = tr->tr_real_length;/* restore 'real' data length */
837 }
838 }
839 } else
840 error = tr->tr_error;
841
842 } else
843 if ((error = twa_submit_io(tr)))
844 twa_unmap_request(tr);
845
846 return(error);
847 }
848
849
850
851 /*
852 * Function name: twa_unmap_request
853 * Description: Undoes the mapping done by twa_map_request.
854 *
855 * Input: tr -- ptr to request pkt
856 * Output: None
857 * Return value: None
858 */
859 void
860 twa_unmap_request(struct twa_request *tr)
861 {
862 struct twa_softc *sc = tr->tr_sc;
863 u_int8_t cmd_status;
864
865 twa_dbg_dprint_enter(10, sc);
866
867 /* If the command involved data, unmap that too. */
868 if (tr->tr_data != NULL) {
869 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K)
870 cmd_status = tr->tr_command->command.cmd_pkt_9k.status;
871 else
872 cmd_status = tr->tr_command->command.cmd_pkt_7k.generic.status;
873
874 if (tr->tr_flags & TWA_CMD_DATA_IN) {
875 bus_dmamap_sync(sc->twa_dma_tag,
876 tr->tr_dma_map, BUS_DMASYNC_POSTREAD);
877
878 /*
879 * If we are using a bounce buffer, and we are reading
880 * data, copy the real data in.
881 */
882 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED)
883 if (cmd_status == 0)
884 bcopy(tr->tr_data, tr->tr_real_data,
885 tr->tr_real_length);
886 }
887 if (tr->tr_flags & TWA_CMD_DATA_OUT)
888 bus_dmamap_sync(sc->twa_dma_tag, tr->tr_dma_map,
889 BUS_DMASYNC_POSTWRITE);
890
891 bus_dmamap_unload(sc->twa_dma_tag, tr->tr_dma_map);
892 }
893
894 /* Free alignment buffer if it was used. */
895 if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) {
896 free(tr->tr_data, TWA_MALLOC_CLASS);
897 tr->tr_data = tr->tr_real_data; /* restore 'real' data pointer */
898 tr->tr_length = tr->tr_real_length;/* restore 'real' data length */
899 }
900 }
901
902
903
904 #ifdef TWA_DEBUG
905 void twa_report(void);
906 void twa_reset_stats(void);
907 void twa_print_request(struct twa_request *tr, int req_type);
908
909
910
911 /*
912 * Function name: twa_report
913 * Description: For being called from ddb. Prints controller stats,
914 * and requests, if any, that are in the wrong queue.
915 *
916 * Input: None
917 * Output: None
918 * Return value: None
919 */
920 void
921 twa_report(void)
922 {
923 struct twa_softc *sc;
924 struct twa_request *tr;
925 int s;
926 int i;
927
928 s = splcam();
929 for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
930 twa_print_controller(sc);
931 TAILQ_FOREACH(tr, &sc->twa_busy, tr_link)
932 twa_print_request(tr, TWA_CMD_BUSY);
933 TAILQ_FOREACH(tr, &sc->twa_complete, tr_link)
934 twa_print_request(tr, TWA_CMD_COMPLETE);
935 }
936 splx(s);
937 }
938
939
940
941 /*
942 * Function name: twa_reset_stats
943 * Description: For being called from ddb.
944 * Resets some controller stats.
945 *
946 * Input: None
947 * Output: None
948 * Return value: None
949 */
950 void
951 twa_reset_stats(void)
952 {
953 struct twa_softc *sc;
954 int s;
955 int i;
956
957 s = splcam();
958 for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
959 sc->twa_qstats[TWAQ_FREE].q_max = 0;
960 sc->twa_qstats[TWAQ_BUSY].q_max = 0;
961 sc->twa_qstats[TWAQ_PENDING].q_max = 0;
962 sc->twa_qstats[TWAQ_COMPLETE].q_max = 0;
963 }
964 splx(s);
965 }
966
967
968
969 /*
970 * Function name: twa_print_request
971 * Description: Prints a given request if it's in the wrong queue.
972 *
973 * Input: tr -- ptr to request pkt
974 * req_type-- expected status of the given request
975 * Output: None
976 * Return value: None
977 */
978 void
979 twa_print_request(struct twa_request *tr, int req_type)
980 {
981 struct twa_softc *sc = tr->tr_sc;
982 struct twa_command_packet *cmdpkt = tr->tr_command;
983 struct twa_command_9k *cmd9k;
984 union twa_command_7k *cmd7k;
985 u_int8_t *cdb;
986 int cmd_phys_addr;
987
988 if (tr->tr_status != req_type) {
989 twa_printf(sc, "Invalid %s request %p in queue! req_type = %x, queue_type = %x\n",
990 (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ? "INTERNAL" : "EXTERNAL",
991 tr, tr->tr_status, req_type);
992
993 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) {
994 cmd9k = &(cmdpkt->command.cmd_pkt_9k);
995 cmd_phys_addr = cmd9k->sg_list[0].address;
996 twa_printf(sc, "9K cmd = %x %x %x %x %x %x %x %x %jx\n",
997 cmd9k->command.opcode,
998 cmd9k->command.reserved,
999 cmd9k->unit,
1000 cmd9k->request_id,
1001 cmd9k->status,
1002 cmd9k->sgl_offset,
1003 cmd9k->sgl_entries,
1004 cmd_phys_addr,
1005 (uintmax_t)cmd9k->sg_list[0].length);
1006 cdb = (u_int8_t *)(cmdpkt->command.cmd_pkt_9k.cdb);
1007 twa_printf(sc, "cdb = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n",
1008 cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7],
1009 cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]);
1010 } else {
1011 cmd7k = &(cmdpkt->command.cmd_pkt_7k);
1012 twa_printf(sc, "7K cmd = %x %x %x %x %x %x %x %x %x\n",
1013 cmd7k->generic.opcode,
1014 cmd7k->generic.sgl_offset,
1015 cmd7k->generic.size,
1016 cmd7k->generic.request_id,
1017 cmd7k->generic.unit,
1018 cmd7k->generic.host_id,
1019 cmd7k->generic.status,
1020 cmd7k->generic.flags,
1021 cmd7k->generic.count);
1022 }
1023
1024 cmd_phys_addr = (int)(tr->tr_cmd_phys);
1025 twa_printf(sc, "cmdphys=0x%x data=%p length=0x%jx\n",
1026 cmd_phys_addr, tr->tr_data, (uintmax_t)tr->tr_length);
1027 twa_printf(sc, "req_id=0x%x flags=0x%x callback=%p private=%p\n",
1028 tr->tr_request_id, tr->tr_flags,
1029 tr->tr_callback, tr->tr_private);
1030 }
1031 }
1032 #endif
Cache object: 82247db715c9b43a1cba03b17b3d4abf
|