xref: /freebsd/sys/dev/mpt/mpt_pci.c (revision 019717e0534842151bff194e72d5fb6457a2f4a0)
19b631363SMatt Jacob /* $FreeBSD$ */
29b631363SMatt Jacob /*
39b631363SMatt Jacob  * PCI specific probe and attach routines for LSI '909 FC  adapters.
49b631363SMatt Jacob  * FreeBSD Version.
59b631363SMatt Jacob  *
69b631363SMatt Jacob  * Copyright (c)  2000, 2001 by Greg Ansley
79b631363SMatt Jacob  * Partially derived from Matt Jacob's ISP driver.
89b631363SMatt Jacob  *
99b631363SMatt Jacob  * Redistribution and use in source and binary forms, with or without
109b631363SMatt Jacob  * modification, are permitted provided that the following conditions
119b631363SMatt Jacob  * are met:
129b631363SMatt Jacob  * 1. Redistributions of source code must retain the above copyright
139b631363SMatt Jacob  *    notice immediately at the beginning of the file, without modification,
149b631363SMatt Jacob  *    this list of conditions, and the following disclaimer.
159b631363SMatt Jacob  * 2. The name of the author may not be used to endorse or promote products
169b631363SMatt Jacob  *    derived from this software without specific prior written permission.
179b631363SMatt Jacob  *
189b631363SMatt Jacob  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
199b631363SMatt Jacob  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
209b631363SMatt Jacob  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
219b631363SMatt Jacob  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
229b631363SMatt Jacob  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
239b631363SMatt Jacob  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
249b631363SMatt Jacob  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
259b631363SMatt Jacob  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
269b631363SMatt Jacob  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
279b631363SMatt Jacob  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
289b631363SMatt Jacob  * SUCH DAMAGE.
299b631363SMatt Jacob  */
309b631363SMatt Jacob /*
319b631363SMatt Jacob  * Additional Copyright (c) 2002 by Matthew Jacob under same license.
329b631363SMatt Jacob  */
339b631363SMatt Jacob 
349b631363SMatt Jacob #include <sys/param.h>
359b631363SMatt Jacob #include <sys/systm.h>
369b631363SMatt Jacob #include <sys/kernel.h>
379b631363SMatt Jacob #include <sys/module.h>
387104aeefSMatt Jacob #include <sys/bus.h>
397104aeefSMatt Jacob 
409b631363SMatt Jacob #include <pci/pcireg.h>
419b631363SMatt Jacob #include <pci/pcivar.h>
429b631363SMatt Jacob 
439b631363SMatt Jacob #include <machine/bus_memio.h>
449b631363SMatt Jacob #include <machine/bus_pio.h>
459b631363SMatt Jacob #include <machine/bus.h>
469b631363SMatt Jacob #include <machine/resource.h>
479b631363SMatt Jacob #include <sys/rman.h>
487104aeefSMatt Jacob #include <sys/malloc.h>
499b631363SMatt Jacob 
509b631363SMatt Jacob #include <dev/mpt/mpt_freebsd.h>
519b631363SMatt Jacob 
529b631363SMatt Jacob #ifndef	PCI_VENDOR_LSI
539b631363SMatt Jacob #define	PCI_VENDOR_LSI			0x1000
549b631363SMatt Jacob #endif
559b631363SMatt Jacob 
569b631363SMatt Jacob #ifndef	PCI_PRODUCT_LSI_FC909
579b631363SMatt Jacob #define	PCI_PRODUCT_LSI_FC909		0x0620
589b631363SMatt Jacob #endif
599b631363SMatt Jacob 
609b631363SMatt Jacob #ifndef	PCI_PRODUCT_LSI_FC929
619b631363SMatt Jacob #define	PCI_PRODUCT_LSI_FC929		0x0622
629b631363SMatt Jacob #endif
639b631363SMatt Jacob 
649b631363SMatt Jacob #ifndef	PCI_PRODUCT_LSI_1030
659b631363SMatt Jacob #define	PCI_PRODUCT_LSI_1030		0x0030
669b631363SMatt Jacob #endif
679b631363SMatt Jacob 
68019717e0SMatt Jacob #ifndef	PCIM_CMD_SERRESPEN
69019717e0SMatt Jacob #define	PCIM_CMD_SERRESPEN	0x0100
70019717e0SMatt Jacob #endif
71019717e0SMatt Jacob 
729b631363SMatt Jacob 
739b631363SMatt Jacob 
749b631363SMatt Jacob #define	MEM_MAP_REG	0x14
759b631363SMatt Jacob #define	MEM_MAP_SRAM	0x1C
769b631363SMatt Jacob 
779b631363SMatt Jacob static int mpt_probe(device_t);
789b631363SMatt Jacob static int mpt_attach(device_t);
797104aeefSMatt Jacob static void mpt_free_bus_resources(mpt_softc_t *mpt);
809b631363SMatt Jacob static int mpt_detach(device_t);
819b631363SMatt Jacob static int mpt_shutdown(device_t);
827104aeefSMatt Jacob static int mpt_dma_mem_alloc(mpt_softc_t *mpt);
837104aeefSMatt Jacob static void mpt_dma_mem_free(mpt_softc_t *mpt);
847104aeefSMatt Jacob static void mpt_read_config_regs(mpt_softc_t *mpt);
857104aeefSMatt Jacob static void mpt_pci_intr(void *);
869b631363SMatt Jacob 
879b631363SMatt Jacob static device_method_t mpt_methods[] = {
889b631363SMatt Jacob 	/* Device interface */
899b631363SMatt Jacob 	DEVMETHOD(device_probe,		mpt_probe),
909b631363SMatt Jacob 	DEVMETHOD(device_attach,	mpt_attach),
919b631363SMatt Jacob 	DEVMETHOD(device_detach,	mpt_detach),
929b631363SMatt Jacob 	DEVMETHOD(device_shutdown,	mpt_shutdown),
939b631363SMatt Jacob 	{ 0, 0 }
949b631363SMatt Jacob };
959b631363SMatt Jacob 
969b631363SMatt Jacob static driver_t mpt_driver = {
977104aeefSMatt Jacob 	"mpt", mpt_methods, sizeof (mpt_softc_t)
989b631363SMatt Jacob };
999b631363SMatt Jacob static devclass_t mpt_devclass;
1009b631363SMatt Jacob DRIVER_MODULE(mpt, pci, mpt_driver, mpt_devclass, 0, 0);
1019b631363SMatt Jacob MODULE_VERSION(mpt, 1);
1029b631363SMatt Jacob 
1039b631363SMatt Jacob int
1049b631363SMatt Jacob mpt_intr(void *dummy)
1059b631363SMatt Jacob {
1069b631363SMatt Jacob 	u_int32_t reply;
1077104aeefSMatt Jacob 	mpt_softc_t *mpt = (mpt_softc_t *)dummy;
1089b631363SMatt Jacob 
1099b631363SMatt Jacob 	reply = mpt_pop_reply_queue(mpt);
1109b631363SMatt Jacob 	while (reply != MPT_REPLY_EMPTY) {
1119b631363SMatt Jacob 		if (mpt->verbose > 1) {
1129b631363SMatt Jacob 			if ((reply & MPT_CONTEXT_REPLY) != 0)  {
1139b631363SMatt Jacob 				/* Address reply; IOC has something to say */
1149b631363SMatt Jacob 				mpt_print_reply(MPT_REPLY_PTOV(mpt, reply));
1159b631363SMatt Jacob 			} else {
1169b631363SMatt Jacob 				/* Context reply ; all went well */
1179b631363SMatt Jacob 				device_printf(mpt->dev,
1189b631363SMatt Jacob 				    "context %u reply OK\n", reply);
1199b631363SMatt Jacob 			}
1209b631363SMatt Jacob 		}
1219b631363SMatt Jacob 		mpt_done(mpt, reply);
1229b631363SMatt Jacob 		reply = mpt_pop_reply_queue(mpt);
1239b631363SMatt Jacob 	}
1249b631363SMatt Jacob 	return 0;
1259b631363SMatt Jacob }
1269b631363SMatt Jacob 
1279b631363SMatt Jacob static int
1289b631363SMatt Jacob mpt_probe(device_t dev)
1299b631363SMatt Jacob {
1309b631363SMatt Jacob 	char *desc;
1319b631363SMatt Jacob 
1329b631363SMatt Jacob 	if (pci_get_vendor(dev) != PCI_VENDOR_LSI)
1339b631363SMatt Jacob 		return (ENXIO);
1349b631363SMatt Jacob 
1359b631363SMatt Jacob 	switch ((pci_get_device(dev) & ~1)) {
1369b631363SMatt Jacob 	case PCI_PRODUCT_LSI_FC909:
1379b631363SMatt Jacob 		desc = "LSILogic FC909 FC Adapter";
1389b631363SMatt Jacob 		break;
1399b631363SMatt Jacob 	case PCI_PRODUCT_LSI_FC929:
1409b631363SMatt Jacob 		desc = "LSILogic FC929 FC Adapter";
1419b631363SMatt Jacob 		break;
1429b631363SMatt Jacob 	case PCI_PRODUCT_LSI_1030:
1439b631363SMatt Jacob 		desc = "LSILogic 1030 Ultra4 Adapter";
1449b631363SMatt Jacob 		break;
1459b631363SMatt Jacob 	default:
1469b631363SMatt Jacob 		return (ENXIO);
1479b631363SMatt Jacob 	}
1489b631363SMatt Jacob 
1499b631363SMatt Jacob 	device_set_desc(dev, desc);
1509b631363SMatt Jacob 	return (0);
1519b631363SMatt Jacob }
1529b631363SMatt Jacob 
1539b631363SMatt Jacob #ifdef	RELENG_4
1549b631363SMatt Jacob static void
1557104aeefSMatt Jacob mpt_set_options(mpt_softc_t *mpt)
1569b631363SMatt Jacob {
1579b631363SMatt Jacob 	int bitmap;
1589b631363SMatt Jacob 
1599b631363SMatt Jacob 	bitmap = 0;
1609b631363SMatt Jacob 	if (getenv_int("mpt_disable", &bitmap)) {
1619b631363SMatt Jacob 		if (bitmap & (1 << mpt->unit)) {
1629b631363SMatt Jacob 			mpt->disabled = 1;
1639b631363SMatt Jacob 		}
1649b631363SMatt Jacob 	}
1659b631363SMatt Jacob 
1669b631363SMatt Jacob 	bitmap = 0;
1679b631363SMatt Jacob 	if (getenv_int("mpt_debug", &bitmap)) {
1689b631363SMatt Jacob 		if (bitmap & (1 << mpt->unit)) {
1699b631363SMatt Jacob 			mpt->verbose = 2;
1709b631363SMatt Jacob 		}
1719b631363SMatt Jacob 	}
1729b631363SMatt Jacob 
1739b631363SMatt Jacob }
1749b631363SMatt Jacob #else
1759b631363SMatt Jacob static void
1767104aeefSMatt Jacob mpt_set_options(mpt_softc_t *mpt)
1779b631363SMatt Jacob {
1789b631363SMatt Jacob 	int tval;
1799b631363SMatt Jacob 
1809b631363SMatt Jacob 	tval = 0;
1819b631363SMatt Jacob 	if (resource_int_value(device_get_name(mpt->dev),
1829b631363SMatt Jacob 	    device_get_unit(mpt->dev), "disable", &tval) == 0 && tval != 0) {
1839b631363SMatt Jacob 		mpt->disabled = 1;
1849b631363SMatt Jacob 	}
1859b631363SMatt Jacob 	tval = 0;
1869b631363SMatt Jacob 	if (resource_int_value(device_get_name(mpt->dev),
1879b631363SMatt Jacob 	    device_get_unit(mpt->dev), "debug", &tval) == 0 && tval != 0) {
1889b631363SMatt Jacob 		mpt->verbose += tval;
1899b631363SMatt Jacob 	}
1909b631363SMatt Jacob }
1919b631363SMatt Jacob #endif
1929b631363SMatt Jacob 
1939b631363SMatt Jacob 
194019717e0SMatt Jacob static void
195019717e0SMatt Jacob mpt_link_peer(mpt_softc_t *mpt)
196019717e0SMatt Jacob {
197019717e0SMatt Jacob 	mpt_softc_t *mpt2;
198019717e0SMatt Jacob 
199019717e0SMatt Jacob 	if (mpt->unit == 0) {
200019717e0SMatt Jacob 		return;
201019717e0SMatt Jacob 	}
202019717e0SMatt Jacob 
203019717e0SMatt Jacob 	/*
204019717e0SMatt Jacob 	 * XXX: depends on probe order
205019717e0SMatt Jacob 	 */
206019717e0SMatt Jacob 	mpt2 = (mpt_softc_t *) devclass_get_softc(mpt_devclass, mpt->unit-1);
207019717e0SMatt Jacob 
208019717e0SMatt Jacob 	if (mpt2 == NULL) {
209019717e0SMatt Jacob 		return;
210019717e0SMatt Jacob 	}
211019717e0SMatt Jacob 	if (pci_get_vendor(mpt2->dev) != pci_get_vendor(mpt->dev)) {
212019717e0SMatt Jacob 		return;
213019717e0SMatt Jacob 	}
214019717e0SMatt Jacob 	if (pci_get_device(mpt2->dev) != pci_get_device(mpt->dev)) {
215019717e0SMatt Jacob 		return;
216019717e0SMatt Jacob 	}
217019717e0SMatt Jacob 	mpt->mpt2 = mpt2;
218019717e0SMatt Jacob 	mpt2->mpt2 = mpt;
219019717e0SMatt Jacob 	if (mpt->verbose) {
220019717e0SMatt Jacob 		device_printf(mpt->dev, "linking with peer (mpt%d)\n",
221019717e0SMatt Jacob 		    device_get_unit(mpt2->dev));
222019717e0SMatt Jacob 	}
223019717e0SMatt Jacob }
224019717e0SMatt Jacob 
225019717e0SMatt Jacob 
2269b631363SMatt Jacob static int
2279b631363SMatt Jacob mpt_attach(device_t dev)
2289b631363SMatt Jacob {
2299b631363SMatt Jacob 	int iqd;
2309b631363SMatt Jacob 	u_int32_t data, cmd;
2317104aeefSMatt Jacob 	mpt_softc_t *mpt;
2329b631363SMatt Jacob 
2339b631363SMatt Jacob 	/* Allocate the softc structure */
2347104aeefSMatt Jacob 	mpt  = (mpt_softc_t*) device_get_softc(dev);
2359b631363SMatt Jacob 	if (mpt == NULL) {
2369b631363SMatt Jacob 		device_printf(dev, "cannot allocate softc\n");
2379b631363SMatt Jacob 		return (ENOMEM);
2389b631363SMatt Jacob 	}
2397104aeefSMatt Jacob 	bzero(mpt, sizeof (mpt_softc_t));
2409b631363SMatt Jacob 	switch ((pci_get_device(dev) & ~1)) {
2419b631363SMatt Jacob 	case PCI_PRODUCT_LSI_FC909:
2429b631363SMatt Jacob 	case PCI_PRODUCT_LSI_FC929:
2439b631363SMatt Jacob 		mpt->is_fc = 1;
2449b631363SMatt Jacob 		break;
2459b631363SMatt Jacob 	default:
2469b631363SMatt Jacob 		break;
2479b631363SMatt Jacob 	}
2489b631363SMatt Jacob 	mpt->dev = dev;
2499b631363SMatt Jacob 	mpt->unit = device_get_unit(dev);
2509b631363SMatt Jacob 	mpt_set_options(mpt);
2519b631363SMatt Jacob 	mpt->verbose += (bootverbose != 0)? 1 : 0;
2529b631363SMatt Jacob 
2539b631363SMatt Jacob 	/* Make sure memory access decoders are enabled */
2549b631363SMatt Jacob 	cmd = pci_read_config(dev, PCIR_COMMAND, 2);
2559b631363SMatt Jacob 	if ((cmd & PCIM_CMD_MEMEN) == 0) {
2569b631363SMatt Jacob 		device_printf(dev, "Memory accesses disabled");
2579b631363SMatt Jacob 		goto bad;
2589b631363SMatt Jacob 	}
2599b631363SMatt Jacob 
2609b631363SMatt Jacob 	/*
2619b631363SMatt Jacob 	 * Make sure that SERR, PERR, WRITE INVALIDATE and BUSMASTER are set.
2629b631363SMatt Jacob 	 */
2639b631363SMatt Jacob 	cmd |=
2649b631363SMatt Jacob 	    PCIM_CMD_SERRESPEN | PCIM_CMD_PERRESPEN |
2659b631363SMatt Jacob 	    PCIM_CMD_BUSMASTEREN | PCIM_CMD_MWRICEN;
2669b631363SMatt Jacob 	pci_write_config(dev, PCIR_COMMAND, cmd, 2);
2679b631363SMatt Jacob 
2689b631363SMatt Jacob 	/*
2699b631363SMatt Jacob 	 * Make sure we've disabled the ROM.
2709b631363SMatt Jacob 	 */
2719b631363SMatt Jacob 	data = pci_read_config(dev, PCIR_BIOS, 4);
2729b631363SMatt Jacob 	data &= ~1;
2739b631363SMatt Jacob 	pci_write_config(dev, PCIR_BIOS, data, 4);
2749b631363SMatt Jacob 
2759b631363SMatt Jacob 
276019717e0SMatt Jacob 	/*
277019717e0SMatt Jacob 	 * Is this part a dual?
278019717e0SMatt Jacob 	 * If so, link with our partner (around yet)
279019717e0SMatt Jacob 	 */
280019717e0SMatt Jacob 	if ((pci_get_device(dev) & ~1) == PCI_PRODUCT_LSI_FC929 ||
281019717e0SMatt Jacob 	    (pci_get_device(dev) & ~1) == PCI_PRODUCT_LSI_1030) {
282019717e0SMatt Jacob 		mpt_link_peer(mpt);
2839b631363SMatt Jacob 	}
2849b631363SMatt Jacob 
2859b631363SMatt Jacob 	/* Set up the memory regions */
2869b631363SMatt Jacob 	/* Allocate kernel virtual memory for the 9x9's Mem0 region */
2879b631363SMatt Jacob 	mpt->pci_reg_id = MEM_MAP_REG;
2889b631363SMatt Jacob 	mpt->pci_reg = bus_alloc_resource(dev, SYS_RES_MEMORY,
2899b631363SMatt Jacob 			&mpt->pci_reg_id, 0, ~0, 0, RF_ACTIVE);
2909b631363SMatt Jacob 	if (mpt->pci_reg == NULL) {
2919b631363SMatt Jacob 		device_printf(dev, "unable to map any ports\n");
2929b631363SMatt Jacob 		goto bad;
2939b631363SMatt Jacob 	}
2949b631363SMatt Jacob 	mpt->pci_st = rman_get_bustag(mpt->pci_reg);
2959b631363SMatt Jacob 	mpt->pci_sh = rman_get_bushandle(mpt->pci_reg);
2969b631363SMatt Jacob 	/*   Get the Physical Address */
2979b631363SMatt Jacob 	mpt->pci_pa = rman_get_start(mpt->pci_reg);
2989b631363SMatt Jacob 
2999b631363SMatt Jacob 	/* Get a handle to the interrupt */
3009b631363SMatt Jacob 	iqd = 0;
3019b631363SMatt Jacob 	mpt->pci_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &iqd, 0, ~0,
3029b631363SMatt Jacob 	    1, RF_ACTIVE | RF_SHAREABLE);
3039b631363SMatt Jacob 	if (mpt->pci_irq == NULL) {
3049b631363SMatt Jacob 		device_printf(dev, "could not allocate interrupt\n");
3059b631363SMatt Jacob 		goto bad;
3069b631363SMatt Jacob 	}
3079b631363SMatt Jacob 
3089b631363SMatt Jacob 	/* Register the interrupt handler */
3097104aeefSMatt Jacob 	if (bus_setup_intr(dev, mpt->pci_irq, MPT_IFLAGS, mpt_pci_intr,
3109b631363SMatt Jacob 	    mpt, &mpt->ih)) {
3119b631363SMatt Jacob 		device_printf(dev, "could not setup interrupt\n");
3129b631363SMatt Jacob 		goto bad;
3139b631363SMatt Jacob 	}
3149b631363SMatt Jacob 
3157104aeefSMatt Jacob 	MPT_LOCK_SETUP(mpt);
3167104aeefSMatt Jacob 
3179b631363SMatt Jacob 	/* Disable interrupts at the part */
3189b631363SMatt Jacob 	mpt_disable_ints(mpt);
3199b631363SMatt Jacob 
3209b631363SMatt Jacob 	/* Allocate dma memory */
3219b631363SMatt Jacob 	if (mpt_dma_mem_alloc(mpt)) {
3229b631363SMatt Jacob 		device_printf(dev, "Could not allocate DMA memory\n");
3239b631363SMatt Jacob 		goto bad;
3249b631363SMatt Jacob 	}
3259b631363SMatt Jacob 
3267104aeefSMatt Jacob 	/*
3277104aeefSMatt Jacob 	 * Save the PCI config register values
3287104aeefSMatt Jacob  	 *
3297104aeefSMatt Jacob 	 * Hard resets are known to screw up the BAR for diagnostic
3307104aeefSMatt Jacob 	 * memory accesses (Mem1).
3317104aeefSMatt Jacob 	 *
3327104aeefSMatt Jacob 	 * Using Mem1 is known to make the chip stop responding to
3337104aeefSMatt Jacob 	 * configuration space transfers, so we need to save it now
3347104aeefSMatt Jacob 	 */
3359b631363SMatt Jacob 
3369b631363SMatt Jacob 	mpt_read_config_regs(mpt);
3379b631363SMatt Jacob 
3389b631363SMatt Jacob 	/* Initialize the hardware */
3399b631363SMatt Jacob 	if (mpt->disabled == 0) {
3407104aeefSMatt Jacob 		MPT_LOCK(mpt);
3417104aeefSMatt Jacob 		if (mpt_init(mpt, MPT_DB_INIT_HOST) != 0) {
3427104aeefSMatt Jacob 			MPT_UNLOCK(mpt);
3439b631363SMatt Jacob 			goto bad;
3449b631363SMatt Jacob 		}
3459b631363SMatt Jacob 
3467104aeefSMatt Jacob 		/*
3477104aeefSMatt Jacob 		 *  Attach to CAM
3487104aeefSMatt Jacob 		 */
3497104aeefSMatt Jacob 		MPTLOCK_2_CAMLOCK(mpt);
3507104aeefSMatt Jacob 		mpt_cam_attach(mpt);
3517104aeefSMatt Jacob 		CAMLOCK_2_MPTLOCK(mpt);
3527104aeefSMatt Jacob 		MPT_UNLOCK(mpt);
3537104aeefSMatt Jacob 	}
3547104aeefSMatt Jacob 
3559b631363SMatt Jacob 	return (0);
3569b631363SMatt Jacob 
3579b631363SMatt Jacob bad:
3589b631363SMatt Jacob 	mpt_dma_mem_free(mpt);
3599b631363SMatt Jacob 	mpt_free_bus_resources(mpt);
3609b631363SMatt Jacob 
3619b631363SMatt Jacob 	/*
3629b631363SMatt Jacob 	 * but return zero to preserve unit numbering
3639b631363SMatt Jacob 	 */
3649b631363SMatt Jacob 	return (0);
3659b631363SMatt Jacob }
3669b631363SMatt Jacob 
3677104aeefSMatt Jacob /*
3689b631363SMatt Jacob  * Free bus resources
3699b631363SMatt Jacob  */
3709b631363SMatt Jacob static void
3717104aeefSMatt Jacob mpt_free_bus_resources(mpt_softc_t *mpt)
3729b631363SMatt Jacob {
3739b631363SMatt Jacob 	if (mpt->ih) {
3749b631363SMatt Jacob 		bus_teardown_intr(mpt->dev, mpt->pci_irq, mpt->ih);
3759b631363SMatt Jacob 		mpt->ih = 0;
3769b631363SMatt Jacob 	}
3779b631363SMatt Jacob 
3789b631363SMatt Jacob 	if (mpt->pci_irq) {
3799b631363SMatt Jacob 		bus_release_resource(mpt->dev, SYS_RES_IRQ, 0, mpt->pci_irq);
3809b631363SMatt Jacob 		mpt->pci_irq = 0;
3819b631363SMatt Jacob 	}
3829b631363SMatt Jacob 
3839b631363SMatt Jacob 	if (mpt->pci_reg) {
3849b631363SMatt Jacob 		bus_release_resource(mpt->dev, SYS_RES_MEMORY, mpt->pci_reg_id,
3859b631363SMatt Jacob 			mpt->pci_reg);
3869b631363SMatt Jacob 		mpt->pci_reg = 0;
3879b631363SMatt Jacob 	}
3887104aeefSMatt Jacob 	MPT_LOCK_DESTROY(mpt);
3899b631363SMatt Jacob }
3909b631363SMatt Jacob 
3919b631363SMatt Jacob 
3927104aeefSMatt Jacob /*
3939b631363SMatt Jacob  * Disconnect ourselves from the system.
3949b631363SMatt Jacob  */
3959b631363SMatt Jacob static int
3969b631363SMatt Jacob mpt_detach(device_t dev)
3979b631363SMatt Jacob {
3987104aeefSMatt Jacob 	mpt_softc_t *mpt;
3997104aeefSMatt Jacob 	mpt  = (mpt_softc_t*) device_get_softc(dev);
4009b631363SMatt Jacob 
4019b631363SMatt Jacob 	device_printf(mpt->dev,"mpt_detach!\n");
4029b631363SMatt Jacob 
4039b631363SMatt Jacob 	if (mpt) {
4049b631363SMatt Jacob 		mpt_disable_ints(mpt);
4059b631363SMatt Jacob 		mpt_cam_detach(mpt);
4069b631363SMatt Jacob 		mpt_reset(mpt);
4079b631363SMatt Jacob 		mpt_dma_mem_free(mpt);
4089b631363SMatt Jacob 		mpt_free_bus_resources(mpt);
4099b631363SMatt Jacob 	}
4109b631363SMatt Jacob 	return(0);
4119b631363SMatt Jacob }
4129b631363SMatt Jacob 
4139b631363SMatt Jacob 
4147104aeefSMatt Jacob /*
4159b631363SMatt Jacob  * Disable the hardware
4169b631363SMatt Jacob  */
4179b631363SMatt Jacob static int
4189b631363SMatt Jacob mpt_shutdown(device_t dev)
4199b631363SMatt Jacob {
4207104aeefSMatt Jacob 	mpt_softc_t *mpt;
4217104aeefSMatt Jacob 	mpt  = (mpt_softc_t*) device_get_softc(dev);
4229b631363SMatt Jacob 
4239b631363SMatt Jacob 	if (mpt) {
4249b631363SMatt Jacob 		mpt_reset(mpt);
4259b631363SMatt Jacob 	}
4269b631363SMatt Jacob 	return(0);
4279b631363SMatt Jacob }
4289b631363SMatt Jacob 
4299b631363SMatt Jacob 
4309b631363SMatt Jacob struct imush {
4317104aeefSMatt Jacob 	mpt_softc_t *mpt;
4329b631363SMatt Jacob 	int error;
4339b631363SMatt Jacob 	u_int32_t phys;
4349b631363SMatt Jacob };
4359b631363SMatt Jacob 
4369b631363SMatt Jacob static void
4379b631363SMatt Jacob mpt_map_rquest(void *arg, bus_dma_segment_t *segs, int nseg, int error)
4389b631363SMatt Jacob {
4399b631363SMatt Jacob 	struct imush *imushp = (struct imush *) arg;
4409b631363SMatt Jacob 	imushp->error = error;
4419b631363SMatt Jacob 	imushp->phys = segs->ds_addr;
4429b631363SMatt Jacob }
4439b631363SMatt Jacob 
4449b631363SMatt Jacob 
4459b631363SMatt Jacob static int
4467104aeefSMatt Jacob mpt_dma_mem_alloc(mpt_softc_t *mpt)
4479b631363SMatt Jacob {
4489b631363SMatt Jacob 	int i, error;
4499b631363SMatt Jacob 	u_char *vptr;
4509b631363SMatt Jacob 	u_int32_t pptr, end;
4519b631363SMatt Jacob 	struct imush im;
4529b631363SMatt Jacob 	device_t dev = mpt->dev;
4539b631363SMatt Jacob 
4549b631363SMatt Jacob 	/* Check if we alreay have allocated the reply memory */
4559b631363SMatt Jacob 	if (mpt->reply_phys != NULL)
4569b631363SMatt Jacob 		return 0;
4579b631363SMatt Jacob 
4589b631363SMatt Jacob 	/*
4599b631363SMatt Jacob 	 * Create a dma tag for this device
4609b631363SMatt Jacob 	 *
4619b631363SMatt Jacob 	 * Align at page boundaries, limit to 32-bit addressing
4629b631363SMatt Jacob 	 * (The chip supports 64-bit addressing, but this driver doesn't)
4639b631363SMatt Jacob 	 */
4649b631363SMatt Jacob 	if (bus_dma_tag_create(NULL, PAGE_SIZE, 0, BUS_SPACE_MAXADDR_32BIT,
4659b631363SMatt Jacob 	    BUS_SPACE_MAXADDR, NULL, NULL, BUS_SPACE_MAXSIZE_32BIT,
4669b631363SMatt Jacob 	    BUS_SPACE_MAXSIZE_32BIT, BUS_SPACE_UNRESTRICTED, 0,
4679b631363SMatt Jacob 	    &mpt->parent_dmat) != 0) {
4689b631363SMatt Jacob 		device_printf(dev, "cannot create parent dma tag\n");
4699b631363SMatt Jacob 		return (1);
4709b631363SMatt Jacob 	}
4719b631363SMatt Jacob 
4729b631363SMatt Jacob 	/* Create a child tag for reply buffers */
4739b631363SMatt Jacob 	if (bus_dma_tag_create(mpt->parent_dmat, PAGE_SIZE,
4749b631363SMatt Jacob 	    0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
4759b631363SMatt Jacob 	    NULL, NULL, PAGE_SIZE, 1, BUS_SPACE_MAXSIZE_32BIT, 0,
4769b631363SMatt Jacob 	    &mpt->reply_dmat) != 0) {
4779b631363SMatt Jacob 		device_printf(dev, "cannot create a dma tag for replies\n");
4789b631363SMatt Jacob 		return (1);
4799b631363SMatt Jacob 	}
4809b631363SMatt Jacob 
4819b631363SMatt Jacob 	/* Allocate some DMA accessable memory for replies */
4829b631363SMatt Jacob 	if (bus_dmamem_alloc(mpt->reply_dmat, (void **)&mpt->reply,
4839b631363SMatt Jacob 	    BUS_DMA_NOWAIT, &mpt->reply_dmap) != 0) {
4849b631363SMatt Jacob 		device_printf(dev, "cannot allocate %d bytes of reply memory\n",
4859b631363SMatt Jacob 		     PAGE_SIZE);
4869b631363SMatt Jacob 		return (1);
4879b631363SMatt Jacob 	}
4889b631363SMatt Jacob 
4899b631363SMatt Jacob 	im.mpt = mpt;
4909b631363SMatt Jacob 	im.error = 0;
4919b631363SMatt Jacob 
4929b631363SMatt Jacob 	/* Load and lock it into "bus space" */
4939b631363SMatt Jacob 	bus_dmamap_load(mpt->reply_dmat, mpt->reply_dmap, mpt->reply,
4949b631363SMatt Jacob 	    PAGE_SIZE, mpt_map_rquest, &im, 0);
4959b631363SMatt Jacob 
4969b631363SMatt Jacob 	if (im.error) {
4979b631363SMatt Jacob 		device_printf(dev,
4989b631363SMatt Jacob 		    "error %d loading dma map for DMA reply queue\n", im.error);
4999b631363SMatt Jacob 		return (1);
5009b631363SMatt Jacob 	}
5019b631363SMatt Jacob 	mpt->reply_phys = im.phys;
5029b631363SMatt Jacob 
5039b631363SMatt Jacob 	/* Create a child tag for data buffers */
5049b631363SMatt Jacob 	if (bus_dma_tag_create(mpt->parent_dmat, PAGE_SIZE,
5059b631363SMatt Jacob 	    0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
5069b631363SMatt Jacob 	    NULL, NULL, MAXBSIZE, MPT_SGL_MAX, BUS_SPACE_MAXSIZE_32BIT, 0,
5079b631363SMatt Jacob 	    &mpt->buffer_dmat) != 0) {
5089b631363SMatt Jacob 		device_printf(dev,
5099b631363SMatt Jacob 		    "cannot create a dma tag for data buffers\n");
5109b631363SMatt Jacob 		return (1);
5119b631363SMatt Jacob 	}
5129b631363SMatt Jacob 
5139b631363SMatt Jacob 	/* Create a child tag for request buffers */
5149b631363SMatt Jacob 	if (bus_dma_tag_create(mpt->parent_dmat, PAGE_SIZE,
5159b631363SMatt Jacob 	    0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
5169b631363SMatt Jacob 	    NULL, NULL, MPT_REQ_MEM_SIZE, 1, BUS_SPACE_MAXSIZE_32BIT, 0,
5179b631363SMatt Jacob 	    &mpt->request_dmat) != 0) {
5189b631363SMatt Jacob 		device_printf(dev, "cannot create a dma tag for requests\n");
5199b631363SMatt Jacob 		return (1);
5209b631363SMatt Jacob 	}
5219b631363SMatt Jacob 
5229b631363SMatt Jacob 	/* Allocate some DMA accessable memory for requests */
5239b631363SMatt Jacob 	if (bus_dmamem_alloc(mpt->request_dmat, (void **)&mpt->request,
5249b631363SMatt Jacob 	    BUS_DMA_NOWAIT, &mpt->request_dmap) != 0) {
5259b631363SMatt Jacob 		device_printf(dev,
5269b631363SMatt Jacob 		    "cannot allocate %d bytes of request memory\n",
5279b631363SMatt Jacob 		    MPT_REQ_MEM_SIZE);
5289b631363SMatt Jacob 		return (1);
5299b631363SMatt Jacob 	}
5309b631363SMatt Jacob 
5319b631363SMatt Jacob 	im.mpt = mpt;
5329b631363SMatt Jacob 	im.error = 0;
5339b631363SMatt Jacob 
5349b631363SMatt Jacob 	/* Load and lock it into "bus space" */
5359b631363SMatt Jacob         bus_dmamap_load(mpt->request_dmat, mpt->request_dmap, mpt->request,
5369b631363SMatt Jacob 	    MPT_REQ_MEM_SIZE, mpt_map_rquest, &im, 0);
5379b631363SMatt Jacob 
5389b631363SMatt Jacob 	if (im.error) {
5399b631363SMatt Jacob 		device_printf(dev,
5409b631363SMatt Jacob 		    "error %d loading dma map for DMA request queue\n",
5419b631363SMatt Jacob 		    im.error);
5429b631363SMatt Jacob 		return (1);
5439b631363SMatt Jacob 	}
5449b631363SMatt Jacob 	mpt->request_phys = im.phys;
5459b631363SMatt Jacob 
5469b631363SMatt Jacob 	i = 0;
5479b631363SMatt Jacob 	pptr =  mpt->request_phys;
5489b631363SMatt Jacob 	vptr =  mpt->request;
5499b631363SMatt Jacob 	end = pptr + MPT_REQ_MEM_SIZE;
5509b631363SMatt Jacob 	while(pptr < end) {
5519b631363SMatt Jacob 		request_t *req = &mpt->requests[i];
5529b631363SMatt Jacob 		req->index = i++;
5539b631363SMatt Jacob 
5549b631363SMatt Jacob 		/* Store location of Request Data */
5559b631363SMatt Jacob 		req->req_pbuf = pptr;
5569b631363SMatt Jacob 		req->req_vbuf = vptr;
5579b631363SMatt Jacob 
5589b631363SMatt Jacob 		pptr += MPT_REQUEST_AREA;
5599b631363SMatt Jacob 		vptr += MPT_REQUEST_AREA;
5609b631363SMatt Jacob 
5619b631363SMatt Jacob 		req->sense_pbuf = (pptr - MPT_SENSE_SIZE);
5629b631363SMatt Jacob 		req->sense_vbuf = (vptr - MPT_SENSE_SIZE);
5639b631363SMatt Jacob 
5649b631363SMatt Jacob 		error = bus_dmamap_create(mpt->buffer_dmat, 0, &req->dmap);
5659b631363SMatt Jacob 		if (error) {
5669b631363SMatt Jacob 			device_printf(dev,
5679b631363SMatt Jacob 			     "error %d creating per-cmd DMA maps\n", error);
5689b631363SMatt Jacob 			return (1);
5699b631363SMatt Jacob 		}
5709b631363SMatt Jacob 	}
5719b631363SMatt Jacob 	return (0);
5729b631363SMatt Jacob }
5739b631363SMatt Jacob 
5749b631363SMatt Jacob 
5759b631363SMatt Jacob 
5769b631363SMatt Jacob /* Deallocate memory that was allocated by mpt_dma_mem_alloc
5779b631363SMatt Jacob  */
5789b631363SMatt Jacob static void
5797104aeefSMatt Jacob mpt_dma_mem_free(mpt_softc_t *mpt)
5809b631363SMatt Jacob {
5819b631363SMatt Jacob 	int i;
5829b631363SMatt Jacob 
5839b631363SMatt Jacob         /* Make sure we aren't double destroying */
5849b631363SMatt Jacob         if (mpt->reply_dmat == 0) {
5859b631363SMatt Jacob 		if (mpt->verbose)
5869b631363SMatt Jacob 			device_printf(mpt->dev,"Already released dma memory\n");
5879b631363SMatt Jacob 		return;
5889b631363SMatt Jacob         }
5899b631363SMatt Jacob 
5909b631363SMatt Jacob 	for (i = 0; i < MPT_MAX_REQUESTS; i++) {
5919b631363SMatt Jacob 		bus_dmamap_destroy(mpt->buffer_dmat, mpt->requests[i].dmap);
5929b631363SMatt Jacob 	}
5939b631363SMatt Jacob 	bus_dmamap_unload(mpt->request_dmat, mpt->request_dmap);
5949b631363SMatt Jacob 	bus_dmamem_free(mpt->request_dmat, mpt->request, mpt->request_dmap);
5959b631363SMatt Jacob 	bus_dma_tag_destroy(mpt->request_dmat);
5969b631363SMatt Jacob 	bus_dma_tag_destroy(mpt->buffer_dmat);
5979b631363SMatt Jacob 	bus_dmamap_unload(mpt->reply_dmat, mpt->reply_dmap);
5989b631363SMatt Jacob 	bus_dmamem_free(mpt->reply_dmat, mpt->reply, mpt->reply_dmap);
5999b631363SMatt Jacob 	bus_dma_tag_destroy(mpt->reply_dmat);
6009b631363SMatt Jacob 	bus_dma_tag_destroy(mpt->parent_dmat);
6019b631363SMatt Jacob 	mpt->reply_dmat = 0;
6029b631363SMatt Jacob 
6039b631363SMatt Jacob }
6049b631363SMatt Jacob 
6059b631363SMatt Jacob 
6069b631363SMatt Jacob 
6079b631363SMatt Jacob /* Reads modifiable (via PCI transactions) config registers */
6089b631363SMatt Jacob static void
6097104aeefSMatt Jacob mpt_read_config_regs(mpt_softc_t *mpt)
6109b631363SMatt Jacob {
6119b631363SMatt Jacob 	mpt->pci_cfg.Command = pci_read_config(mpt->dev, PCIR_COMMAND, 2);
6129b631363SMatt Jacob 	mpt->pci_cfg.LatencyTimer_LineSize =
6139b631363SMatt Jacob 	    pci_read_config(mpt->dev, PCIR_CACHELNSZ, 2);
6149b631363SMatt Jacob 	mpt->pci_cfg.IO_BAR = pci_read_config(mpt->dev, PCIR_MAPS, 4);
6159b631363SMatt Jacob 	mpt->pci_cfg.Mem0_BAR[0] = pci_read_config(mpt->dev, PCIR_MAPS+0x4, 4);
6169b631363SMatt Jacob 	mpt->pci_cfg.Mem0_BAR[1] = pci_read_config(mpt->dev, PCIR_MAPS+0x8, 4);
6179b631363SMatt Jacob 	mpt->pci_cfg.Mem1_BAR[0] = pci_read_config(mpt->dev, PCIR_MAPS+0xC, 4);
6189b631363SMatt Jacob 	mpt->pci_cfg.Mem1_BAR[1] = pci_read_config(mpt->dev, PCIR_MAPS+0x10, 4);
6199b631363SMatt Jacob 	mpt->pci_cfg.ROM_BAR = pci_read_config(mpt->dev, PCIR_BIOS, 4);
6209b631363SMatt Jacob 	mpt->pci_cfg.IntLine = pci_read_config(mpt->dev, PCIR_INTLINE, 1);
6219b631363SMatt Jacob 	mpt->pci_cfg.PMCSR = pci_read_config(mpt->dev, 0x44, 4);
6229b631363SMatt Jacob }
6239b631363SMatt Jacob 
6249b631363SMatt Jacob /* Sets modifiable config registers */
6259b631363SMatt Jacob void
6267104aeefSMatt Jacob mpt_set_config_regs(mpt_softc_t *mpt)
6279b631363SMatt Jacob {
6289b631363SMatt Jacob 	u_int32_t val;
6299b631363SMatt Jacob 
6309b631363SMatt Jacob #define MPT_CHECK(reg, offset, size)					\
6319b631363SMatt Jacob 	val = pci_read_config(mpt->dev, offset, size);			\
6329b631363SMatt Jacob 	if (mpt->pci_cfg.reg != val) {					\
6339b631363SMatt Jacob 		device_printf(mpt->dev,					\
6349b631363SMatt Jacob 		    "Restoring " #reg " to 0x%X from 0x%X\n",		\
6359b631363SMatt Jacob 		    mpt->pci_cfg.reg, val);				\
6369b631363SMatt Jacob 	}
6379b631363SMatt Jacob 
6389b631363SMatt Jacob 	if (mpt->verbose) {
6399b631363SMatt Jacob 		MPT_CHECK(Command, PCIR_COMMAND, 2);
6409b631363SMatt Jacob 		MPT_CHECK(LatencyTimer_LineSize, PCIR_CACHELNSZ, 2);
6419b631363SMatt Jacob 		MPT_CHECK(IO_BAR, PCIR_MAPS, 4);
6429b631363SMatt Jacob 		MPT_CHECK(Mem0_BAR[0], PCIR_MAPS+0x4, 4);
6439b631363SMatt Jacob 		MPT_CHECK(Mem0_BAR[1], PCIR_MAPS+0x8, 4);
6449b631363SMatt Jacob 		MPT_CHECK(Mem1_BAR[0], PCIR_MAPS+0xC, 4);
6459b631363SMatt Jacob 		MPT_CHECK(Mem1_BAR[1], PCIR_MAPS+0x10, 4);
6469b631363SMatt Jacob 		MPT_CHECK(ROM_BAR, PCIR_BIOS, 4);
6479b631363SMatt Jacob 		MPT_CHECK(IntLine, PCIR_INTLINE, 1);
6489b631363SMatt Jacob 		MPT_CHECK(PMCSR, 0x44, 4);
6499b631363SMatt Jacob 	}
6509b631363SMatt Jacob #undef MPT_CHECK
6519b631363SMatt Jacob 
6529b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_COMMAND, mpt->pci_cfg.Command, 2);
6539b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_CACHELNSZ,
6549b631363SMatt Jacob 	    mpt->pci_cfg.LatencyTimer_LineSize, 2);
6559b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_MAPS, mpt->pci_cfg.IO_BAR, 4);
6569b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_MAPS+0x4, mpt->pci_cfg.Mem0_BAR[0], 4);
6579b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_MAPS+0x8, mpt->pci_cfg.Mem0_BAR[1], 4);
6589b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_MAPS+0xC, mpt->pci_cfg.Mem1_BAR[0], 4);
6599b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_MAPS+0x10, mpt->pci_cfg.Mem1_BAR[1], 4);
6609b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_BIOS, mpt->pci_cfg.ROM_BAR, 4);
6619b631363SMatt Jacob 	pci_write_config(mpt->dev, PCIR_INTLINE, mpt->pci_cfg.IntLine, 1);
6629b631363SMatt Jacob 	pci_write_config(mpt->dev, 0x44, mpt->pci_cfg.PMCSR, 4);
6639b631363SMatt Jacob }
6647104aeefSMatt Jacob 
6657104aeefSMatt Jacob static void
6667104aeefSMatt Jacob mpt_pci_intr(void *arg)
6677104aeefSMatt Jacob {
6687104aeefSMatt Jacob 	mpt_softc_t *mpt = arg;
6697104aeefSMatt Jacob 	MPT_LOCK(mpt);
6707104aeefSMatt Jacob 	mpt_intr(mpt);
6717104aeefSMatt Jacob 	MPT_UNLOCK(mpt);
6727104aeefSMatt Jacob }
673