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