FreeBSD/Linux Kernel Cross Reference
sys/dev/isp/isp_pci.c
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
5 * Copyright (c) 1997-2008 by Matthew Jacob
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice immediately at the beginning of the file, without modification,
13 * this list of conditions, and the following disclaimer.
14 * 2. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29 /*
30 * PCI specific probe and attach routines for Qlogic ISP SCSI adapters.
31 * FreeBSD Version.
32 */
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/module.h>
40 #include <sys/linker.h>
41 #include <sys/firmware.h>
42 #include <sys/bus.h>
43 #include <sys/stdint.h>
44 #include <dev/pci/pcireg.h>
45 #include <dev/pci/pcivar.h>
46 #include <machine/bus.h>
47 #include <machine/resource.h>
48 #include <sys/rman.h>
49 #include <sys/malloc.h>
50 #include <sys/uio.h>
51 #include <dev/isp/isp_freebsd.h>
52
53 static uint32_t isp_pci_rd_reg_2400(ispsoftc_t *, int);
54 static void isp_pci_wr_reg_2400(ispsoftc_t *, int, uint32_t);
55 static uint32_t isp_pci_rd_reg_2600(ispsoftc_t *, int);
56 static void isp_pci_wr_reg_2600(ispsoftc_t *, int, uint32_t);
57 static void isp_pci_run_isr_2400(ispsoftc_t *);
58 static int isp_pci_mbxdma(ispsoftc_t *);
59 static void isp_pci_mbxdmafree(ispsoftc_t *);
60 static int isp_pci_irqsetup(ispsoftc_t *);
61
62 static struct ispmdvec mdvec_2400 = {
63 isp_pci_run_isr_2400,
64 isp_pci_rd_reg_2400,
65 isp_pci_wr_reg_2400,
66 isp_pci_mbxdma,
67 isp_send_cmd,
68 isp_pci_irqsetup,
69 NULL
70 };
71
72 static struct ispmdvec mdvec_2500 = {
73 isp_pci_run_isr_2400,
74 isp_pci_rd_reg_2400,
75 isp_pci_wr_reg_2400,
76 isp_pci_mbxdma,
77 isp_send_cmd,
78 isp_pci_irqsetup,
79 NULL
80 };
81
82 static struct ispmdvec mdvec_2600 = {
83 isp_pci_run_isr_2400,
84 isp_pci_rd_reg_2600,
85 isp_pci_wr_reg_2600,
86 isp_pci_mbxdma,
87 isp_send_cmd,
88 isp_pci_irqsetup,
89 NULL
90 };
91
92 static struct ispmdvec mdvec_2700 = {
93 isp_pci_run_isr_2400,
94 isp_pci_rd_reg_2600,
95 isp_pci_wr_reg_2600,
96 isp_pci_mbxdma,
97 isp_send_cmd,
98 isp_pci_irqsetup,
99 NULL
100 };
101
102 #ifndef PCIM_CMD_INVEN
103 #define PCIM_CMD_INVEN 0x10
104 #endif
105 #ifndef PCIM_CMD_BUSMASTEREN
106 #define PCIM_CMD_BUSMASTEREN 0x0004
107 #endif
108 #ifndef PCIM_CMD_PERRESPEN
109 #define PCIM_CMD_PERRESPEN 0x0040
110 #endif
111 #ifndef PCIM_CMD_SEREN
112 #define PCIM_CMD_SEREN 0x0100
113 #endif
114 #ifndef PCIM_CMD_INTX_DISABLE
115 #define PCIM_CMD_INTX_DISABLE 0x0400
116 #endif
117
118 #ifndef PCIR_COMMAND
119 #define PCIR_COMMAND 0x04
120 #endif
121
122 #ifndef PCIR_CACHELNSZ
123 #define PCIR_CACHELNSZ 0x0c
124 #endif
125
126 #ifndef PCIR_LATTIMER
127 #define PCIR_LATTIMER 0x0d
128 #endif
129
130 #ifndef PCIR_ROMADDR
131 #define PCIR_ROMADDR 0x30
132 #endif
133
134 #define PCI_VENDOR_QLOGIC 0x1077
135
136 #define PCI_PRODUCT_QLOGIC_ISP2422 0x2422
137 #define PCI_PRODUCT_QLOGIC_ISP2432 0x2432
138 #define PCI_PRODUCT_QLOGIC_ISP2532 0x2532
139 #define PCI_PRODUCT_QLOGIC_ISP5432 0x5432
140 #define PCI_PRODUCT_QLOGIC_ISP2031 0x2031
141 #define PCI_PRODUCT_QLOGIC_ISP8031 0x8031
142 #define PCI_PRODUCT_QLOGIC_ISP2684 0x2171
143 #define PCI_PRODUCT_QLOGIC_ISP2692 0x2b61
144 #define PCI_PRODUCT_QLOGIC_ISP2714 0x2071
145 #define PCI_PRODUCT_QLOGIC_ISP2722 0x2261
146
147 #define PCI_QLOGIC_ISP2422 \
148 ((PCI_PRODUCT_QLOGIC_ISP2422 << 16) | PCI_VENDOR_QLOGIC)
149 #define PCI_QLOGIC_ISP2432 \
150 ((PCI_PRODUCT_QLOGIC_ISP2432 << 16) | PCI_VENDOR_QLOGIC)
151 #define PCI_QLOGIC_ISP2532 \
152 ((PCI_PRODUCT_QLOGIC_ISP2532 << 16) | PCI_VENDOR_QLOGIC)
153 #define PCI_QLOGIC_ISP5432 \
154 ((PCI_PRODUCT_QLOGIC_ISP5432 << 16) | PCI_VENDOR_QLOGIC)
155 #define PCI_QLOGIC_ISP2031 \
156 ((PCI_PRODUCT_QLOGIC_ISP2031 << 16) | PCI_VENDOR_QLOGIC)
157 #define PCI_QLOGIC_ISP8031 \
158 ((PCI_PRODUCT_QLOGIC_ISP8031 << 16) | PCI_VENDOR_QLOGIC)
159 #define PCI_QLOGIC_ISP2684 \
160 ((PCI_PRODUCT_QLOGIC_ISP2684 << 16) | PCI_VENDOR_QLOGIC)
161 #define PCI_QLOGIC_ISP2692 \
162 ((PCI_PRODUCT_QLOGIC_ISP2692 << 16) | PCI_VENDOR_QLOGIC)
163 #define PCI_QLOGIC_ISP2714 \
164 ((PCI_PRODUCT_QLOGIC_ISP2714 << 16) | PCI_VENDOR_QLOGIC)
165 #define PCI_QLOGIC_ISP2722 \
166 ((PCI_PRODUCT_QLOGIC_ISP2722 << 16) | PCI_VENDOR_QLOGIC)
167
168 #define PCI_DFLT_LTNCY 0x40
169 #define PCI_DFLT_LNSZ 0x10
170
171 static int isp_pci_probe (device_t);
172 static int isp_pci_attach (device_t);
173 static int isp_pci_detach (device_t);
174
175
176 struct isp_pcisoftc {
177 ispsoftc_t pci_isp;
178 struct resource * regs;
179 struct resource * regs1;
180 struct resource * regs2;
181 struct {
182 int iqd;
183 struct resource * irq;
184 void * ih;
185 } irq[ISP_MAX_IRQS];
186 int rtp;
187 int rgd;
188 int rtp1;
189 int rgd1;
190 int rtp2;
191 int rgd2;
192 bus_dma_tag_t dmat;
193 int msicount;
194 };
195
196
197 static device_method_t isp_pci_methods[] = {
198 /* Device interface */
199 DEVMETHOD(device_probe, isp_pci_probe),
200 DEVMETHOD(device_attach, isp_pci_attach),
201 DEVMETHOD(device_detach, isp_pci_detach),
202 { 0, 0 }
203 };
204
205 static driver_t isp_pci_driver = {
206 "isp", isp_pci_methods, sizeof (struct isp_pcisoftc)
207 };
208
209 DRIVER_MODULE(isp, pci, isp_pci_driver, 0, 0);
210 MODULE_DEPEND(isp, cam, 1, 1, 1);
211 MODULE_DEPEND(isp, firmware, 1, 1, 1);
212 static int isp_nvports = 0;
213
214 static int
215 isp_pci_probe(device_t dev)
216 {
217 switch ((pci_get_device(dev) << 16) | (pci_get_vendor(dev))) {
218 case PCI_QLOGIC_ISP2422:
219 device_set_desc(dev, "Qlogic ISP 2422 PCI FC-AL Adapter");
220 break;
221 case PCI_QLOGIC_ISP2432:
222 device_set_desc(dev, "Qlogic ISP 2432 PCI FC-AL Adapter");
223 break;
224 case PCI_QLOGIC_ISP2532:
225 device_set_desc(dev, "Qlogic ISP 2532 PCI FC-AL Adapter");
226 break;
227 case PCI_QLOGIC_ISP5432:
228 device_set_desc(dev, "Qlogic ISP 5432 PCI FC-AL Adapter");
229 break;
230 case PCI_QLOGIC_ISP2031:
231 device_set_desc(dev, "Qlogic ISP 2031 PCI FC-AL Adapter");
232 break;
233 case PCI_QLOGIC_ISP8031:
234 device_set_desc(dev, "Qlogic ISP 8031 PCI FCoE Adapter");
235 break;
236 case PCI_QLOGIC_ISP2684:
237 device_set_desc(dev, "Qlogic ISP 2684 PCI FC Adapter");
238 break;
239 case PCI_QLOGIC_ISP2692:
240 device_set_desc(dev, "Qlogic ISP 2692 PCI FC Adapter");
241 break;
242 case PCI_QLOGIC_ISP2714:
243 device_set_desc(dev, "Qlogic ISP 2714 PCI FC Adapter");
244 break;
245 case PCI_QLOGIC_ISP2722:
246 device_set_desc(dev, "Qlogic ISP 2722 PCI FC Adapter");
247 break;
248 default:
249 return (ENXIO);
250 }
251 if (isp_announced == 0 && bootverbose) {
252 printf("Qlogic ISP Driver, FreeBSD Version %d.%d, "
253 "Core Version %d.%d\n",
254 ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR,
255 ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR);
256 isp_announced++;
257 }
258 /*
259 * XXXX: Here is where we might load the f/w module
260 * XXXX: (or increase a reference count to it).
261 */
262 return (BUS_PROBE_DEFAULT);
263 }
264
265 static void
266 isp_get_generic_options(device_t dev, ispsoftc_t *isp)
267 {
268 int tval;
269
270 tval = 0;
271 if (resource_int_value(device_get_name(dev), device_get_unit(dev), "fwload_disable", &tval) == 0 && tval != 0) {
272 isp->isp_confopts |= ISP_CFG_NORELOAD;
273 }
274 tval = 0;
275 if (resource_int_value(device_get_name(dev), device_get_unit(dev), "ignore_nvram", &tval) == 0 && tval != 0) {
276 isp->isp_confopts |= ISP_CFG_NONVRAM;
277 }
278 tval = 0;
279 (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "debug", &tval);
280 if (tval) {
281 isp->isp_dblev = tval;
282 } else {
283 isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR;
284 }
285 if (bootverbose) {
286 isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO;
287 }
288 tval = -1;
289 (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "vports", &tval);
290 if (tval > 0 && tval <= 254) {
291 isp_nvports = tval;
292 }
293 tval = 7;
294 (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "quickboot_time", &tval);
295 isp_quickboot_time = tval;
296 }
297
298 static void
299 isp_get_specific_options(device_t dev, int chan, ispsoftc_t *isp)
300 {
301 const char *sptr;
302 int tval = 0;
303 char prefix[12], name[16];
304
305 if (chan == 0)
306 prefix[0] = 0;
307 else
308 snprintf(prefix, sizeof(prefix), "chan%d.", chan);
309 snprintf(name, sizeof(name), "%siid", prefix);
310 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
311 name, &tval)) {
312 ISP_FC_PC(isp, chan)->default_id = 109 - chan;
313 } else {
314 ISP_FC_PC(isp, chan)->default_id = tval - chan;
315 isp->isp_confopts |= ISP_CFG_OWNLOOPID;
316 }
317
318 tval = -1;
319 snprintf(name, sizeof(name), "%srole", prefix);
320 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
321 name, &tval) == 0) {
322 switch (tval) {
323 case ISP_ROLE_NONE:
324 case ISP_ROLE_INITIATOR:
325 case ISP_ROLE_TARGET:
326 case ISP_ROLE_BOTH:
327 device_printf(dev, "Chan %d setting role to 0x%x\n", chan, tval);
328 break;
329 default:
330 tval = -1;
331 break;
332 }
333 }
334 if (tval == -1) {
335 tval = ISP_DEFAULT_ROLES;
336 }
337 ISP_FC_PC(isp, chan)->def_role = tval;
338
339 tval = 0;
340 snprintf(name, sizeof(name), "%sfullduplex", prefix);
341 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
342 name, &tval) == 0 && tval != 0) {
343 isp->isp_confopts |= ISP_CFG_FULL_DUPLEX;
344 }
345 sptr = NULL;
346 snprintf(name, sizeof(name), "%stopology", prefix);
347 if (resource_string_value(device_get_name(dev), device_get_unit(dev),
348 name, (const char **) &sptr) == 0 && sptr != NULL) {
349 if (strcmp(sptr, "lport") == 0) {
350 isp->isp_confopts |= ISP_CFG_LPORT;
351 } else if (strcmp(sptr, "nport") == 0) {
352 isp->isp_confopts |= ISP_CFG_NPORT;
353 } else if (strcmp(sptr, "lport-only") == 0) {
354 isp->isp_confopts |= ISP_CFG_LPORT_ONLY;
355 } else if (strcmp(sptr, "nport-only") == 0) {
356 isp->isp_confopts |= ISP_CFG_NPORT_ONLY;
357 }
358 }
359
360 #ifdef ISP_FCTAPE_OFF
361 isp->isp_confopts |= ISP_CFG_NOFCTAPE;
362 #else
363 isp->isp_confopts |= ISP_CFG_FCTAPE;
364 #endif
365
366 tval = 0;
367 snprintf(name, sizeof(name), "%snofctape", prefix);
368 (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
369 name, &tval);
370 if (tval) {
371 isp->isp_confopts &= ~ISP_CFG_FCTAPE;
372 isp->isp_confopts |= ISP_CFG_NOFCTAPE;
373 }
374
375 tval = 0;
376 snprintf(name, sizeof(name), "%sfctape", prefix);
377 (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
378 name, &tval);
379 if (tval) {
380 isp->isp_confopts &= ~ISP_CFG_NOFCTAPE;
381 isp->isp_confopts |= ISP_CFG_FCTAPE;
382 }
383
384
385 /*
386 * Because the resource_*_value functions can neither return
387 * 64 bit integer values, nor can they be directly coerced
388 * to interpret the right hand side of the assignment as
389 * you want them to interpret it, we have to force WWN
390 * hint replacement to specify WWN strings with a leading
391 * 'w' (e..g w50000000aaaa0001). Sigh.
392 */
393 sptr = NULL;
394 snprintf(name, sizeof(name), "%sportwwn", prefix);
395 tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
396 name, (const char **) &sptr);
397 if (tval == 0 && sptr != NULL && *sptr++ == 'w') {
398 char *eptr = NULL;
399 ISP_FC_PC(isp, chan)->def_wwpn = strtouq(sptr, &eptr, 16);
400 if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwpn == -1) {
401 device_printf(dev, "mangled portwwn hint '%s'\n", sptr);
402 ISP_FC_PC(isp, chan)->def_wwpn = 0;
403 }
404 }
405
406 sptr = NULL;
407 snprintf(name, sizeof(name), "%snodewwn", prefix);
408 tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
409 name, (const char **) &sptr);
410 if (tval == 0 && sptr != NULL && *sptr++ == 'w') {
411 char *eptr = NULL;
412 ISP_FC_PC(isp, chan)->def_wwnn = strtouq(sptr, &eptr, 16);
413 if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwnn == 0) {
414 device_printf(dev, "mangled nodewwn hint '%s'\n", sptr);
415 ISP_FC_PC(isp, chan)->def_wwnn = 0;
416 }
417 }
418
419 tval = -1;
420 snprintf(name, sizeof(name), "%sloop_down_limit", prefix);
421 (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
422 name, &tval);
423 if (tval >= 0 && tval < 0xffff) {
424 ISP_FC_PC(isp, chan)->loop_down_limit = tval;
425 } else {
426 ISP_FC_PC(isp, chan)->loop_down_limit = isp_loop_down_limit;
427 }
428
429 tval = -1;
430 snprintf(name, sizeof(name), "%sgone_device_time", prefix);
431 (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
432 name, &tval);
433 if (tval >= 0 && tval < 0xffff) {
434 ISP_FC_PC(isp, chan)->gone_device_time = tval;
435 } else {
436 ISP_FC_PC(isp, chan)->gone_device_time = isp_gone_device_time;
437 }
438 }
439
440 static int
441 isp_pci_attach(device_t dev)
442 {
443 struct isp_pcisoftc *pcs = device_get_softc(dev);
444 ispsoftc_t *isp = &pcs->pci_isp;
445 int i;
446 uint32_t data, cmd, linesz, did;
447 size_t psize, xsize;
448 char fwname[32];
449
450 isp->isp_dev = dev;
451 isp->isp_nchan = 1;
452 mtx_init(&isp->isp_lock, "isp", NULL, MTX_DEF);
453
454 /*
455 * Get Generic Options
456 */
457 isp_nvports = 0;
458 isp_get_generic_options(dev, isp);
459
460 linesz = PCI_DFLT_LNSZ;
461 pcs->regs = pcs->regs2 = NULL;
462 pcs->rgd = pcs->rtp = 0;
463
464 isp->isp_nchan += isp_nvports;
465 switch (pci_get_devid(dev)) {
466 case PCI_QLOGIC_ISP2422:
467 case PCI_QLOGIC_ISP2432:
468 did = 0x2400;
469 isp->isp_mdvec = &mdvec_2400;
470 isp->isp_type = ISP_HA_FC_2400;
471 break;
472 case PCI_QLOGIC_ISP2532:
473 did = 0x2500;
474 isp->isp_mdvec = &mdvec_2500;
475 isp->isp_type = ISP_HA_FC_2500;
476 break;
477 case PCI_QLOGIC_ISP5432:
478 did = 0x2500;
479 isp->isp_mdvec = &mdvec_2500;
480 isp->isp_type = ISP_HA_FC_2500;
481 break;
482 case PCI_QLOGIC_ISP2031:
483 case PCI_QLOGIC_ISP8031:
484 did = 0x2600;
485 isp->isp_mdvec = &mdvec_2600;
486 isp->isp_type = ISP_HA_FC_2600;
487 break;
488 case PCI_QLOGIC_ISP2684:
489 case PCI_QLOGIC_ISP2692:
490 case PCI_QLOGIC_ISP2714:
491 case PCI_QLOGIC_ISP2722:
492 did = 0x2700;
493 isp->isp_mdvec = &mdvec_2700;
494 isp->isp_type = ISP_HA_FC_2700;
495 break;
496 default:
497 device_printf(dev, "unknown device type\n");
498 goto bad;
499 break;
500 }
501 isp->isp_revision = pci_get_revid(dev);
502
503 if (IS_26XX(isp)) {
504 pcs->rtp = SYS_RES_MEMORY;
505 pcs->rgd = PCIR_BAR(0);
506 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
507 RF_ACTIVE);
508 pcs->rtp1 = SYS_RES_MEMORY;
509 pcs->rgd1 = PCIR_BAR(2);
510 pcs->regs1 = bus_alloc_resource_any(dev, pcs->rtp1, &pcs->rgd1,
511 RF_ACTIVE);
512 pcs->rtp2 = SYS_RES_MEMORY;
513 pcs->rgd2 = PCIR_BAR(4);
514 pcs->regs2 = bus_alloc_resource_any(dev, pcs->rtp2, &pcs->rgd2,
515 RF_ACTIVE);
516 } else {
517 pcs->rtp = SYS_RES_MEMORY;
518 pcs->rgd = PCIR_BAR(1);
519 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
520 RF_ACTIVE);
521 if (pcs->regs == NULL) {
522 pcs->rtp = SYS_RES_IOPORT;
523 pcs->rgd = PCIR_BAR(0);
524 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp,
525 &pcs->rgd, RF_ACTIVE);
526 }
527 }
528 if (pcs->regs == NULL) {
529 device_printf(dev, "Unable to map any ports\n");
530 goto bad;
531 }
532 if (bootverbose) {
533 device_printf(dev, "Using %s space register mapping\n",
534 (pcs->rtp == SYS_RES_IOPORT)? "I/O" : "Memory");
535 }
536 isp->isp_regs = pcs->regs;
537 isp->isp_regs2 = pcs->regs2;
538
539 psize = sizeof(fcparam) * isp->isp_nchan;
540 xsize = sizeof(struct isp_fc) * isp->isp_nchan;
541 isp->isp_param = malloc(psize, M_DEVBUF, M_NOWAIT | M_ZERO);
542 if (isp->isp_param == NULL) {
543 device_printf(dev, "cannot allocate parameter data\n");
544 goto bad;
545 }
546 isp->isp_osinfo.fc = malloc(xsize, M_DEVBUF, M_NOWAIT | M_ZERO);
547 if (isp->isp_osinfo.fc == NULL) {
548 device_printf(dev, "cannot allocate parameter data\n");
549 goto bad;
550 }
551
552 /*
553 * Now that we know who we are (roughly) get/set specific options
554 */
555 for (i = 0; i < isp->isp_nchan; i++) {
556 isp_get_specific_options(dev, i, isp);
557 }
558
559 isp->isp_osinfo.fw = NULL;
560 if (isp->isp_osinfo.fw == NULL) {
561 snprintf(fwname, sizeof (fwname), "isp_%04x", did);
562 isp->isp_osinfo.fw = firmware_get(fwname);
563 }
564 if (isp->isp_osinfo.fw != NULL) {
565 isp_prt(isp, ISP_LOGCONFIG, "loaded firmware %s", fwname);
566 isp->isp_mdvec->dv_ispfw = isp->isp_osinfo.fw->data;
567 }
568
569 /*
570 * Make sure that SERR, PERR, WRITE INVALIDATE and BUSMASTER are set.
571 */
572 cmd = pci_read_config(dev, PCIR_COMMAND, 2);
573 cmd |= PCIM_CMD_SEREN | PCIM_CMD_PERRESPEN | PCIM_CMD_BUSMASTEREN | PCIM_CMD_INVEN;
574 cmd &= ~PCIM_CMD_INTX_DISABLE;
575 pci_write_config(dev, PCIR_COMMAND, cmd, 2);
576
577 /*
578 * Make sure the Cache Line Size register is set sensibly.
579 */
580 data = pci_read_config(dev, PCIR_CACHELNSZ, 1);
581 if (data == 0 || (linesz != PCI_DFLT_LNSZ && data != linesz)) {
582 isp_prt(isp, ISP_LOGDEBUG0, "set PCI line size to %d from %d", linesz, data);
583 data = linesz;
584 pci_write_config(dev, PCIR_CACHELNSZ, data, 1);
585 }
586
587 /*
588 * Make sure the Latency Timer is sane.
589 */
590 data = pci_read_config(dev, PCIR_LATTIMER, 1);
591 if (data < PCI_DFLT_LTNCY) {
592 data = PCI_DFLT_LTNCY;
593 isp_prt(isp, ISP_LOGDEBUG0, "set PCI latency to %d", data);
594 pci_write_config(dev, PCIR_LATTIMER, data, 1);
595 }
596
597 /*
598 * Make sure we've disabled the ROM.
599 */
600 data = pci_read_config(dev, PCIR_ROMADDR, 4);
601 data &= ~1;
602 pci_write_config(dev, PCIR_ROMADDR, data, 4);
603
604 /*
605 * Last minute checks...
606 */
607 isp->isp_port = pci_get_function(dev);
608
609 /*
610 * Make sure we're in reset state.
611 */
612 ISP_LOCK(isp);
613 if (isp_reinit(isp, 1) != 0) {
614 ISP_UNLOCK(isp);
615 goto bad;
616 }
617 ISP_UNLOCK(isp);
618 if (isp_attach(isp)) {
619 ISP_LOCK(isp);
620 isp_shutdown(isp);
621 ISP_UNLOCK(isp);
622 goto bad;
623 }
624 return (0);
625
626 bad:
627 if (isp->isp_osinfo.fw == NULL && !IS_26XX(isp)) {
628 /*
629 * Failure to attach at boot time might have been caused
630 * by a missing ispfw(4). Except for 16Gb adapters,
631 * there's no loadable firmware for them.
632 */
633 isp_prt(isp, ISP_LOGWARN, "See the ispfw(4) man page on "
634 "how to load known good firmware at boot time");
635 }
636 for (i = 0; i < isp->isp_nirq; i++) {
637 (void) bus_teardown_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih);
638 (void) bus_release_resource(dev, SYS_RES_IRQ, pcs->irq[i].iqd,
639 pcs->irq[0].irq);
640 }
641 if (pcs->msicount) {
642 pci_release_msi(dev);
643 }
644 if (pcs->regs)
645 (void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
646 if (pcs->regs1)
647 (void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
648 if (pcs->regs2)
649 (void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
650 if (pcs->pci_isp.isp_param) {
651 free(pcs->pci_isp.isp_param, M_DEVBUF);
652 pcs->pci_isp.isp_param = NULL;
653 }
654 if (pcs->pci_isp.isp_osinfo.fc) {
655 free(pcs->pci_isp.isp_osinfo.fc, M_DEVBUF);
656 pcs->pci_isp.isp_osinfo.fc = NULL;
657 }
658 mtx_destroy(&isp->isp_lock);
659 return (ENXIO);
660 }
661
662 static int
663 isp_pci_detach(device_t dev)
664 {
665 struct isp_pcisoftc *pcs = device_get_softc(dev);
666 ispsoftc_t *isp = &pcs->pci_isp;
667 int i, status;
668
669 status = isp_detach(isp);
670 if (status)
671 return (status);
672 ISP_LOCK(isp);
673 isp_shutdown(isp);
674 ISP_UNLOCK(isp);
675 for (i = 0; i < isp->isp_nirq; i++) {
676 (void) bus_teardown_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih);
677 (void) bus_release_resource(dev, SYS_RES_IRQ, pcs->irq[i].iqd,
678 pcs->irq[i].irq);
679 }
680 if (pcs->msicount)
681 pci_release_msi(dev);
682 (void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
683 if (pcs->regs1)
684 (void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
685 if (pcs->regs2)
686 (void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
687 isp_pci_mbxdmafree(isp);
688 if (pcs->pci_isp.isp_param) {
689 free(pcs->pci_isp.isp_param, M_DEVBUF);
690 pcs->pci_isp.isp_param = NULL;
691 }
692 if (pcs->pci_isp.isp_osinfo.fc) {
693 free(pcs->pci_isp.isp_osinfo.fc, M_DEVBUF);
694 pcs->pci_isp.isp_osinfo.fc = NULL;
695 }
696 mtx_destroy(&isp->isp_lock);
697 return (0);
698 }
699
700 #define BXR2(isp, off) bus_read_2((isp)->isp_regs, (off))
701 #define BXW2(isp, off, v) bus_write_2((isp)->isp_regs, (off), (v))
702 #define BXR4(isp, off) bus_read_4((isp)->isp_regs, (off))
703 #define BXW4(isp, off, v) bus_write_4((isp)->isp_regs, (off), (v))
704 #define B2R4(isp, off) bus_read_4((isp)->isp_regs2, (off))
705 #define B2W4(isp, off, v) bus_write_4((isp)->isp_regs2, (off), (v))
706
707 static void
708 isp_pci_run_isr_2400(ispsoftc_t *isp)
709 {
710 uint32_t r2hisr;
711 uint16_t isr, info;
712
713 r2hisr = BXR4(isp, BIU2400_R2HSTS);
714 isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
715 if ((r2hisr & BIU_R2HST_INTR) == 0)
716 return;
717 isr = r2hisr & BIU_R2HST_ISTAT_MASK;
718 info = (r2hisr >> 16);
719 switch (isr) {
720 case ISPR2HST_ROM_MBX_OK:
721 case ISPR2HST_ROM_MBX_FAIL:
722 case ISPR2HST_MBX_OK:
723 case ISPR2HST_MBX_FAIL:
724 isp_intr_mbox(isp, info);
725 break;
726 case ISPR2HST_ASYNC_EVENT:
727 isp_intr_async(isp, info);
728 break;
729 case ISPR2HST_RSPQ_UPDATE:
730 isp_intr_respq(isp);
731 break;
732 case ISPR2HST_RSPQ_UPDATE2:
733 #ifdef ISP_TARGET_MODE
734 case ISPR2HST_ATIO_RSPQ_UPDATE:
735 #endif
736 isp_intr_respq(isp);
737 /* FALLTHROUGH */
738 #ifdef ISP_TARGET_MODE
739 case ISPR2HST_ATIO_UPDATE:
740 case ISPR2HST_ATIO_UPDATE2:
741 isp_intr_atioq(isp);
742 #endif
743 break;
744 default:
745 isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n", r2hisr);
746 }
747 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
748 }
749
750 static uint32_t
751 isp_pci_rd_reg_2400(ispsoftc_t *isp, int regoff)
752 {
753 int block = regoff & _BLK_REG_MASK;
754
755 switch (block) {
756 case BIU_BLOCK:
757 return (BXR4(isp, regoff));
758 case MBOX_BLOCK:
759 return (BXR2(isp, regoff));
760 }
761 isp_prt(isp, ISP_LOGERR, "unknown block read at 0x%x", regoff);
762 return (0xffffffff);
763 }
764
765 static void
766 isp_pci_wr_reg_2400(ispsoftc_t *isp, int regoff, uint32_t val)
767 {
768 int block = regoff & _BLK_REG_MASK;
769
770 switch (block) {
771 case BIU_BLOCK:
772 BXW4(isp, regoff, val);
773 #ifdef MEMORYBARRIERW
774 if (regoff == BIU2400_REQINP ||
775 regoff == BIU2400_RSPOUTP ||
776 regoff == BIU2400_PRI_REQINP ||
777 regoff == BIU2400_ATIO_RSPOUTP)
778 MEMORYBARRIERW(isp, SYNC_REG, regoff, 4, -1)
779 else
780 #endif
781 MEMORYBARRIER(isp, SYNC_REG, regoff, 4, -1);
782 return;
783 case MBOX_BLOCK:
784 BXW2(isp, regoff, val);
785 MEMORYBARRIER(isp, SYNC_REG, regoff, 2, -1);
786 return;
787 }
788 isp_prt(isp, ISP_LOGERR, "unknown block write at 0x%x", regoff);
789 }
790
791 static uint32_t
792 isp_pci_rd_reg_2600(ispsoftc_t *isp, int regoff)
793 {
794 uint32_t rv;
795
796 switch (regoff) {
797 case BIU2400_PRI_REQINP:
798 case BIU2400_PRI_REQOUTP:
799 isp_prt(isp, ISP_LOGERR, "unknown register read at 0x%x",
800 regoff);
801 rv = 0xffffffff;
802 break;
803 case BIU2400_REQINP:
804 rv = B2R4(isp, 0x00);
805 break;
806 case BIU2400_REQOUTP:
807 rv = B2R4(isp, 0x04);
808 break;
809 case BIU2400_RSPINP:
810 rv = B2R4(isp, 0x08);
811 break;
812 case BIU2400_RSPOUTP:
813 rv = B2R4(isp, 0x0c);
814 break;
815 case BIU2400_ATIO_RSPINP:
816 rv = B2R4(isp, 0x10);
817 break;
818 case BIU2400_ATIO_RSPOUTP:
819 rv = B2R4(isp, 0x14);
820 break;
821 default:
822 rv = isp_pci_rd_reg_2400(isp, regoff);
823 break;
824 }
825 return (rv);
826 }
827
828 static void
829 isp_pci_wr_reg_2600(ispsoftc_t *isp, int regoff, uint32_t val)
830 {
831 int off;
832
833 switch (regoff) {
834 case BIU2400_PRI_REQINP:
835 case BIU2400_PRI_REQOUTP:
836 isp_prt(isp, ISP_LOGERR, "unknown register write at 0x%x",
837 regoff);
838 return;
839 case BIU2400_REQINP:
840 off = 0x00;
841 break;
842 case BIU2400_REQOUTP:
843 off = 0x04;
844 break;
845 case BIU2400_RSPINP:
846 off = 0x08;
847 break;
848 case BIU2400_RSPOUTP:
849 off = 0x0c;
850 break;
851 case BIU2400_ATIO_RSPINP:
852 off = 0x10;
853 break;
854 case BIU2400_ATIO_RSPOUTP:
855 off = 0x14;
856 break;
857 default:
858 isp_pci_wr_reg_2400(isp, regoff, val);
859 return;
860 }
861 B2W4(isp, off, val);
862 }
863
864
865 struct imush {
866 bus_addr_t maddr;
867 int error;
868 };
869
870 static void
871 imc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
872 {
873 struct imush *imushp = (struct imush *) arg;
874
875 if (!(imushp->error = error))
876 imushp->maddr = segs[0].ds_addr;
877 }
878
879 static int
880 isp_pci_mbxdma(ispsoftc_t *isp)
881 {
882 bus_dma_tag_t ptag;
883 caddr_t base;
884 uint32_t len;
885 int i, error, cmap;
886 bus_size_t slim; /* segment size */
887 struct imush im;
888 #ifdef ISP_TARGET_MODE
889 isp_ecmd_t *ecmd;
890 #endif
891
892 /* Already been here? If so, leave... */
893 if (isp->isp_xflist != NULL)
894 return (0);
895 if (isp->isp_rquest != NULL && isp->isp_maxcmds == 0)
896 return (0);
897 ISP_UNLOCK(isp);
898
899 ptag = bus_get_dma_tag(isp->isp_osinfo.dev);
900 if (sizeof (bus_size_t) > 4)
901 slim = (bus_size_t) (1ULL << 32);
902 else
903 slim = (bus_size_t) (1UL << 31);
904
905 if (isp->isp_rquest != NULL)
906 goto gotmaxcmds;
907
908 /*
909 * Allocate and map the request queue.
910 */
911 len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
912 if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
913 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
914 len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.reqdmat)) {
915 isp_prt(isp, ISP_LOGERR, "cannot create request DMA tag");
916 goto bad;
917 }
918 if (bus_dmamem_alloc(isp->isp_osinfo.reqdmat, (void **)&base,
919 BUS_DMA_COHERENT, &isp->isp_osinfo.reqmap) != 0) {
920 isp_prt(isp, ISP_LOGERR, "cannot allocate request DMA memory");
921 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
922 goto bad;
923 }
924 isp->isp_rquest = base;
925 im.error = 0;
926 if (bus_dmamap_load(isp->isp_osinfo.reqdmat, isp->isp_osinfo.reqmap,
927 base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
928 isp_prt(isp, ISP_LOGERR, "error loading request DMA map %d", im.error);
929 goto bad;
930 }
931 isp_prt(isp, ISP_LOGDEBUG0, "request area @ 0x%jx/0x%jx",
932 (uintmax_t)im.maddr, (uintmax_t)len);
933 isp->isp_rquest_dma = im.maddr;
934
935 #ifdef ISP_TARGET_MODE
936 /*
937 * Allocate region for external DMA addressable command/status structures.
938 */
939 len = N_XCMDS * XCMD_SIZE;
940 if (bus_dma_tag_create(ptag, XCMD_SIZE, slim,
941 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
942 len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.ecmd_dmat)) {
943 isp_prt(isp, ISP_LOGERR, "cannot create ECMD DMA tag");
944 goto bad;
945 }
946 if (bus_dmamem_alloc(isp->isp_osinfo.ecmd_dmat, (void **)&base,
947 BUS_DMA_COHERENT, &isp->isp_osinfo.ecmd_map) != 0) {
948 isp_prt(isp, ISP_LOGERR, "cannot allocate ECMD DMA memory");
949 bus_dma_tag_destroy(isp->isp_osinfo.ecmd_dmat);
950 goto bad;
951 }
952 isp->isp_osinfo.ecmd_base = (isp_ecmd_t *)base;
953 im.error = 0;
954 if (bus_dmamap_load(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_map,
955 base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
956 isp_prt(isp, ISP_LOGERR, "error loading ECMD DMA map %d", im.error);
957 goto bad;
958 }
959 isp_prt(isp, ISP_LOGDEBUG0, "ecmd area @ 0x%jx/0x%jx",
960 (uintmax_t)im.maddr, (uintmax_t)len);
961
962 isp->isp_osinfo.ecmd_dma = im.maddr;
963 isp->isp_osinfo.ecmd_free = (isp_ecmd_t *)base;
964 for (ecmd = isp->isp_osinfo.ecmd_free;
965 ecmd < &isp->isp_osinfo.ecmd_free[N_XCMDS]; ecmd++) {
966 if (ecmd == &isp->isp_osinfo.ecmd_free[N_XCMDS - 1])
967 ecmd->next = NULL;
968 else
969 ecmd->next = ecmd + 1;
970 }
971 #endif
972
973 /*
974 * Allocate and map the result queue.
975 */
976 len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
977 if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
978 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
979 len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.respdmat)) {
980 isp_prt(isp, ISP_LOGERR, "cannot create response DMA tag");
981 goto bad;
982 }
983 if (bus_dmamem_alloc(isp->isp_osinfo.respdmat, (void **)&base,
984 BUS_DMA_COHERENT, &isp->isp_osinfo.respmap) != 0) {
985 isp_prt(isp, ISP_LOGERR, "cannot allocate response DMA memory");
986 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
987 goto bad;
988 }
989 isp->isp_result = base;
990 im.error = 0;
991 if (bus_dmamap_load(isp->isp_osinfo.respdmat, isp->isp_osinfo.respmap,
992 base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
993 isp_prt(isp, ISP_LOGERR, "error loading response DMA map %d", im.error);
994 goto bad;
995 }
996 isp_prt(isp, ISP_LOGDEBUG0, "response area @ 0x%jx/0x%jx",
997 (uintmax_t)im.maddr, (uintmax_t)len);
998 isp->isp_result_dma = im.maddr;
999
1000 #ifdef ISP_TARGET_MODE
1001 /*
1002 * Allocate and map ATIO queue.
1003 */
1004 len = ISP_QUEUE_SIZE(ATIO_QUEUE_LEN(isp));
1005 if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
1006 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1007 len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.atiodmat)) {
1008 isp_prt(isp, ISP_LOGERR, "cannot create ATIO DMA tag");
1009 goto bad;
1010 }
1011 if (bus_dmamem_alloc(isp->isp_osinfo.atiodmat, (void **)&base,
1012 BUS_DMA_COHERENT, &isp->isp_osinfo.atiomap) != 0) {
1013 isp_prt(isp, ISP_LOGERR, "cannot allocate ATIO DMA memory");
1014 bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
1015 goto bad;
1016 }
1017 isp->isp_atioq = base;
1018 im.error = 0;
1019 if (bus_dmamap_load(isp->isp_osinfo.atiodmat, isp->isp_osinfo.atiomap,
1020 base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
1021 isp_prt(isp, ISP_LOGERR, "error loading ATIO DMA map %d", im.error);
1022 goto bad;
1023 }
1024 isp_prt(isp, ISP_LOGDEBUG0, "ATIO area @ 0x%jx/0x%jx",
1025 (uintmax_t)im.maddr, (uintmax_t)len);
1026 isp->isp_atioq_dma = im.maddr;
1027 #endif
1028
1029 if (bus_dma_tag_create(ptag, 64, slim,
1030 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1031 2*QENTRY_LEN, 1, 2*QENTRY_LEN, 0, NULL, NULL,
1032 &isp->isp_osinfo.iocbdmat)) {
1033 goto bad;
1034 }
1035 if (bus_dmamem_alloc(isp->isp_osinfo.iocbdmat,
1036 (void **)&base, BUS_DMA_COHERENT, &isp->isp_osinfo.iocbmap) != 0)
1037 goto bad;
1038 isp->isp_iocb = base;
1039 im.error = 0;
1040 if (bus_dmamap_load(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap,
1041 base, 2*QENTRY_LEN, imc, &im, BUS_DMA_NOWAIT) || im.error)
1042 goto bad;
1043 isp->isp_iocb_dma = im.maddr;
1044
1045 if (bus_dma_tag_create(ptag, 64, slim,
1046 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1047 ISP_FC_SCRLEN, 1, ISP_FC_SCRLEN, 0, NULL, NULL,
1048 &isp->isp_osinfo.scdmat))
1049 goto bad;
1050 for (cmap = 0; cmap < isp->isp_nchan; cmap++) {
1051 struct isp_fc *fc = ISP_FC_PC(isp, cmap);
1052 if (bus_dmamem_alloc(isp->isp_osinfo.scdmat,
1053 (void **)&base, BUS_DMA_COHERENT, &fc->scmap) != 0)
1054 goto bad;
1055 FCPARAM(isp, cmap)->isp_scratch = base;
1056 im.error = 0;
1057 if (bus_dmamap_load(isp->isp_osinfo.scdmat, fc->scmap,
1058 base, ISP_FC_SCRLEN, imc, &im, BUS_DMA_NOWAIT) ||
1059 im.error) {
1060 bus_dmamem_free(isp->isp_osinfo.scdmat,
1061 base, fc->scmap);
1062 FCPARAM(isp, cmap)->isp_scratch = NULL;
1063 goto bad;
1064 }
1065 FCPARAM(isp, cmap)->isp_scdma = im.maddr;
1066 for (i = 0; i < INITIAL_NEXUS_COUNT; i++) {
1067 struct isp_nexus *n = malloc(sizeof (struct isp_nexus), M_DEVBUF, M_NOWAIT | M_ZERO);
1068 if (n == NULL) {
1069 while (fc->nexus_free_list) {
1070 n = fc->nexus_free_list;
1071 fc->nexus_free_list = n->next;
1072 free(n, M_DEVBUF);
1073 }
1074 goto bad;
1075 }
1076 n->next = fc->nexus_free_list;
1077 fc->nexus_free_list = n;
1078 }
1079 }
1080
1081 if (isp->isp_maxcmds == 0) {
1082 ISP_LOCK(isp);
1083 return (0);
1084 }
1085
1086 gotmaxcmds:
1087 if (bus_dma_tag_create(ptag, 1, slim,
1088 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1089 (ISP_NSEG64_MAX - 1) * PAGE_SIZE, ISP_NSEG64_MAX,
1090 (ISP_NSEG64_MAX - 1) * PAGE_SIZE, 0,
1091 busdma_lock_mutex, &isp->isp_lock, &isp->isp_osinfo.dmat))
1092 goto bad;
1093 len = isp->isp_maxcmds * sizeof (struct isp_pcmd);
1094 isp->isp_osinfo.pcmd_pool = (struct isp_pcmd *)
1095 malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1096 for (i = 0; i < isp->isp_maxcmds; i++) {
1097 struct isp_pcmd *pcmd = &isp->isp_osinfo.pcmd_pool[i];
1098 error = bus_dmamap_create(isp->isp_osinfo.dmat, 0, &pcmd->dmap);
1099 if (error) {
1100 isp_prt(isp, ISP_LOGERR, "error %d creating per-cmd DMA maps", error);
1101 while (--i >= 0) {
1102 bus_dmamap_destroy(isp->isp_osinfo.dmat,
1103 isp->isp_osinfo.pcmd_pool[i].dmap);
1104 }
1105 goto bad;
1106 }
1107 callout_init_mtx(&pcmd->wdog, &isp->isp_lock, 0);
1108 if (i == isp->isp_maxcmds-1)
1109 pcmd->next = NULL;
1110 else
1111 pcmd->next = &isp->isp_osinfo.pcmd_pool[i+1];
1112 }
1113 isp->isp_osinfo.pcmd_free = &isp->isp_osinfo.pcmd_pool[0];
1114
1115 len = sizeof(isp_hdl_t) * ISP_HANDLE_NUM(isp);
1116 isp->isp_xflist = (isp_hdl_t *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1117 for (len = 0; len < ISP_HANDLE_NUM(isp) - 1; len++)
1118 isp->isp_xflist[len].cmd = &isp->isp_xflist[len+1];
1119 isp->isp_xffree = isp->isp_xflist;
1120
1121 ISP_LOCK(isp);
1122 return (0);
1123
1124 bad:
1125 isp_pci_mbxdmafree(isp);
1126 ISP_LOCK(isp);
1127 return (1);
1128 }
1129
1130 static void
1131 isp_pci_mbxdmafree(ispsoftc_t *isp)
1132 {
1133 int i;
1134
1135 if (isp->isp_xflist != NULL) {
1136 free(isp->isp_xflist, M_DEVBUF);
1137 isp->isp_xflist = NULL;
1138 }
1139 if (isp->isp_osinfo.pcmd_pool != NULL) {
1140 for (i = 0; i < isp->isp_maxcmds; i++) {
1141 bus_dmamap_destroy(isp->isp_osinfo.dmat,
1142 isp->isp_osinfo.pcmd_pool[i].dmap);
1143 }
1144 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
1145 isp->isp_osinfo.pcmd_pool = NULL;
1146 }
1147 if (isp->isp_osinfo.dmat) {
1148 bus_dma_tag_destroy(isp->isp_osinfo.dmat);
1149 isp->isp_osinfo.dmat = NULL;
1150 }
1151 for (i = 0; i < isp->isp_nchan; i++) {
1152 struct isp_fc *fc = ISP_FC_PC(isp, i);
1153 if (FCPARAM(isp, i)->isp_scdma != 0) {
1154 bus_dmamap_unload(isp->isp_osinfo.scdmat,
1155 fc->scmap);
1156 FCPARAM(isp, i)->isp_scdma = 0;
1157 }
1158 if (FCPARAM(isp, i)->isp_scratch != NULL) {
1159 bus_dmamem_free(isp->isp_osinfo.scdmat,
1160 FCPARAM(isp, i)->isp_scratch, fc->scmap);
1161 FCPARAM(isp, i)->isp_scratch = NULL;
1162 }
1163 while (fc->nexus_free_list) {
1164 struct isp_nexus *n = fc->nexus_free_list;
1165 fc->nexus_free_list = n->next;
1166 free(n, M_DEVBUF);
1167 }
1168 }
1169 if (isp->isp_osinfo.scdmat) {
1170 bus_dma_tag_destroy(isp->isp_osinfo.scdmat);
1171 isp->isp_osinfo.scdmat = NULL;
1172 }
1173 if (isp->isp_iocb_dma != 0) {
1174 bus_dmamap_unload(isp->isp_osinfo.iocbdmat,
1175 isp->isp_osinfo.iocbmap);
1176 isp->isp_iocb_dma = 0;
1177 }
1178 if (isp->isp_iocb != NULL) {
1179 bus_dmamem_free(isp->isp_osinfo.iocbdmat,
1180 isp->isp_iocb, isp->isp_osinfo.iocbmap);
1181 bus_dma_tag_destroy(isp->isp_osinfo.iocbdmat);
1182 }
1183 #ifdef ISP_TARGET_MODE
1184 if (isp->isp_atioq_dma != 0) {
1185 bus_dmamap_unload(isp->isp_osinfo.atiodmat,
1186 isp->isp_osinfo.atiomap);
1187 isp->isp_atioq_dma = 0;
1188 }
1189 if (isp->isp_atioq != NULL) {
1190 bus_dmamem_free(isp->isp_osinfo.atiodmat, isp->isp_atioq,
1191 isp->isp_osinfo.atiomap);
1192 bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
1193 isp->isp_atioq = NULL;
1194 }
1195 #endif
1196 if (isp->isp_result_dma != 0) {
1197 bus_dmamap_unload(isp->isp_osinfo.respdmat,
1198 isp->isp_osinfo.respmap);
1199 isp->isp_result_dma = 0;
1200 }
1201 if (isp->isp_result != NULL) {
1202 bus_dmamem_free(isp->isp_osinfo.respdmat, isp->isp_result,
1203 isp->isp_osinfo.respmap);
1204 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
1205 isp->isp_result = NULL;
1206 }
1207 #ifdef ISP_TARGET_MODE
1208 if (isp->isp_osinfo.ecmd_dma != 0) {
1209 bus_dmamap_unload(isp->isp_osinfo.ecmd_dmat,
1210 isp->isp_osinfo.ecmd_map);
1211 isp->isp_osinfo.ecmd_dma = 0;
1212 }
1213 if (isp->isp_osinfo.ecmd_base != NULL) {
1214 bus_dmamem_free(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_base,
1215 isp->isp_osinfo.ecmd_map);
1216 bus_dma_tag_destroy(isp->isp_osinfo.ecmd_dmat);
1217 isp->isp_osinfo.ecmd_base = NULL;
1218 }
1219 #endif
1220 if (isp->isp_rquest_dma != 0) {
1221 bus_dmamap_unload(isp->isp_osinfo.reqdmat,
1222 isp->isp_osinfo.reqmap);
1223 isp->isp_rquest_dma = 0;
1224 }
1225 if (isp->isp_rquest != NULL) {
1226 bus_dmamem_free(isp->isp_osinfo.reqdmat, isp->isp_rquest,
1227 isp->isp_osinfo.reqmap);
1228 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
1229 isp->isp_rquest = NULL;
1230 }
1231 }
1232
1233 static int
1234 isp_pci_irqsetup(ispsoftc_t *isp)
1235 {
1236 device_t dev = isp->isp_osinfo.dev;
1237 struct isp_pcisoftc *pcs = device_get_softc(dev);
1238 driver_intr_t *f;
1239 int i, max_irq;
1240
1241 /* Allocate IRQs only once. */
1242 if (isp->isp_nirq > 0)
1243 return (0);
1244
1245 ISP_UNLOCK(isp);
1246 if (ISP_CAP_MSIX(isp)) {
1247 max_irq = IS_26XX(isp) ? 3 : (IS_25XX(isp) ? 2 : 0);
1248 resource_int_value(device_get_name(dev),
1249 device_get_unit(dev), "msix", &max_irq);
1250 max_irq = imin(ISP_MAX_IRQS, max_irq);
1251 pcs->msicount = imin(pci_msix_count(dev), max_irq);
1252 if (pcs->msicount > 0 &&
1253 pci_alloc_msix(dev, &pcs->msicount) != 0)
1254 pcs->msicount = 0;
1255 }
1256 if (pcs->msicount == 0) {
1257 max_irq = 1;
1258 resource_int_value(device_get_name(dev),
1259 device_get_unit(dev), "msi", &max_irq);
1260 max_irq = imin(1, max_irq);
1261 pcs->msicount = imin(pci_msi_count(dev), max_irq);
1262 if (pcs->msicount > 0 &&
1263 pci_alloc_msi(dev, &pcs->msicount) != 0)
1264 pcs->msicount = 0;
1265 }
1266 for (i = 0; i < MAX(1, pcs->msicount); i++) {
1267 pcs->irq[i].iqd = i + (pcs->msicount > 0);
1268 pcs->irq[i].irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
1269 &pcs->irq[i].iqd, RF_ACTIVE | RF_SHAREABLE);
1270 if (pcs->irq[i].irq == NULL) {
1271 device_printf(dev, "could not allocate interrupt\n");
1272 break;
1273 }
1274 if (i == 0)
1275 f = isp_platform_intr;
1276 else if (i == 1)
1277 f = isp_platform_intr_resp;
1278 else
1279 f = isp_platform_intr_atio;
1280 if (bus_setup_intr(dev, pcs->irq[i].irq, ISP_IFLAGS, NULL,
1281 f, isp, &pcs->irq[i].ih)) {
1282 device_printf(dev, "could not setup interrupt\n");
1283 (void) bus_release_resource(dev, SYS_RES_IRQ,
1284 pcs->irq[i].iqd, pcs->irq[i].irq);
1285 break;
1286 }
1287 if (pcs->msicount > 1) {
1288 bus_describe_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih,
1289 "%d", i);
1290 }
1291 isp->isp_nirq = i + 1;
1292 }
1293 ISP_LOCK(isp);
1294
1295 return (isp->isp_nirq == 0);
1296 }
Cache object: cf911dece0b3ad17aa60272553c60e34
|