d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
69fdce865d
freebsd-skq/sys/dev/cardbus/cardbus.c

1258 lines
34 KiB
C
Raw Normal View History

Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
/*
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
* Copyright (c) 2000,2001 Jonathan Chen.
* All rights reserved.
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
* notice, this list of conditions, and the following disclaimer,
* without modification, immediately at the beginning of the file.
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
* 2. Redistributions in binary form must reproduce the above copyright
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
*
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
*
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
* $FreeBSD$
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
*/
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/*
* Cardbus Bus Driver
*
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
* much of the bus code was stolen directly from sys/pci/pci.c
* (Copyright (c) 1997, Stefan Esser <se@freebsd.org>)
*
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
* Written by Jonathan Chen <jon@freebsd.org>
*/
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
Implement hw.cardbus.debug and hw.cardbus.cis_debug to help debug some of the cardbus problems that people may start seeing.
2002-03-07 08:10:42 +00:00
#include <sys/sysctl.h>
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
#include <sys/bus.h>
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
#include <machine/bus.h>
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
#include <sys/rman.h>
#include <machine/resource.h>
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Use the pci.c code wherever possible, rather than copying all the pci code into cardbus and s/pci/cardbus. This exposes a few pci_* functions that are now static. This work is similar to work Justin posted to the mobile list about a year or two ago, which I have neglected since then. This is a subset of his current work with the multiple inheritance newbus architecutre. When completed, that will eliminate the need for pci/pci_private.h. Similar work is needed for the cardbus_cis and pccard_cis code as well.
2002-02-27 05:09:14 +00:00
#include <sys/pciio.h>
Part two of this NEWCARD update: Briefly, the significant changes include: * Way better resource management in pccbb, pccard and cardbus. * pccard hot-removal now appears to work. * support pre-fetchable memory in cardbus. * update cardbus to support new pci bus interface functions. * Fix CIS reading to no longer use rman_get_virtual(). What's not there, but in the works: * pccard needs to do interrupt properly and not read the ISR on single function cards. * real resource management for pccard * a complete implementation of CIS parsing * need to look into how to correctly use mutex in pccbb
2001-08-27 00:09:42 +00:00
#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
#include <dev/cardbus/cardbusreg.h>
#include <dev/cardbus/cardbusvar.h>
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
#include <dev/cardbus/cardbus_cis.h>
Make oldcard and newcard kernel module work.
2002-05-30 17:38:00 +00:00
#include <dev/pccard/pccardvar.h>
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
#include "power_if.h"
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
#include "pcib_if.h"
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Implement hw.cardbus.debug and hw.cardbus.cis_debug to help debug some of the cardbus problems that people may start seeing.
2002-03-07 08:10:42 +00:00
/* sysctl vars */
SYSCTL_NODE(_hw, OID_AUTO, cardbus, CTLFLAG_RD, 0, "CardBus parameters");
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
int cardbus_debug = 0;
Implement hw.cardbus.debug and hw.cardbus.cis_debug to help debug some of the cardbus problems that people may start seeing.
2002-03-07 08:10:42 +00:00
TUNABLE_INT("hw.cardbus.debug", &cardbus_debug);
SYSCTL_INT(_hw_cardbus, OID_AUTO, debug, CTLFLAG_RW,
&cardbus_debug, 0,
"CardBus debug");
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
int cardbus_cis_debug = 0;
Implement hw.cardbus.debug and hw.cardbus.cis_debug to help debug some of the cardbus problems that people may start seeing.
2002-03-07 08:10:42 +00:00
TUNABLE_INT("hw.cardbus.cis_debug", &cardbus_cis_debug);
SYSCTL_INT(_hw_cardbus, OID_AUTO, cis_debug, CTLFLAG_RW,
&cardbus_cis_debug, 0,
"CardBus CIS debug");
#define DPRINTF(a) if (cardbus_debug) printf a
#define DEVPRINTF(x) if (cardbus_debug) device_printf x
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static struct resource *cardbus_alloc_resource(device_t cbdev, device_t child,
int type, int *rid, u_long start, u_long end, u_long count,
u_int flags);
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
static int cardbus_attach(device_t cbdev);
static int cardbus_attach_card(device_t cbdev);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static int cardbus_child_location_str(device_t cbdev, device_t child,
char *, size_t len);
static int cardbus_child_pnpinfo_str(device_t cbdev, device_t child,
char *, size_t len);
static __inline void cardbus_clear_command_bit(device_t cbdev, device_t child,
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint16_t bit);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static void cardbus_delete_resource(device_t cbdev, device_t child,
int type, int rid);
static void cardbus_delete_resource_method(device_t cbdev, device_t child,
int type, int rid);
static int cardbus_detach(device_t cbdev);
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
static int cardbus_detach_card(device_t cbdev);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static void cardbus_device_setup_regs(device_t brdev, int b, int s, int f,
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
pcicfgregs *cfg);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static void cardbus_disable_busmaster_method(device_t cbdev, device_t child);
static void cardbus_disable_io_method(device_t cbdev, device_t child,
int space);
static void cardbus_driver_added(device_t cbdev, driver_t *driver);
static void cardbus_enable_busmaster_method(device_t cbdev, device_t child);
static void cardbus_enable_io_method(device_t cbdev, device_t child,
int space);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static int cardbus_freecfg(struct cardbus_devinfo *dinfo);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static int cardbus_get_powerstate_method(device_t cbdev, device_t child);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static int cardbus_get_resource(device_t cbdev, device_t child, int type,
int rid, u_long *startp, u_long *countp);
static int cardbus_get_resource_method(device_t cbdev, device_t child,
int type, int rid, u_long *startp, u_long *countp);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static void cardbus_hdrtypedata(device_t brdev, int b, int s, int f,
pcicfgregs *cfg);
static int cardbus_print_child(device_t cbdev, device_t child);
static int cardbus_print_resources(struct resource_list *rl,
const char *name, int type, const char *format);
static void cardbus_print_verbose(struct cardbus_devinfo *dinfo);
static int cardbus_probe(device_t cbdev);
static void cardbus_probe_nomatch(device_t cbdev, device_t child);
static struct cardbus_devinfo *cardbus_read_device(device_t brdev, int b,
int s, int f);
static void cardbus_read_extcap(device_t cbdev, pcicfgregs *cfg);
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
static uint32_t cardbus_read_config_method(device_t cbdev,
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
device_t child, int reg, int width);
static int cardbus_read_ivar(device_t cbdev, device_t child, int which,
u_long *result);
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
static void cardbus_release_all_resources(device_t cbdev,
Part two of this NEWCARD update: Briefly, the significant changes include: * Way better resource management in pccbb, pccard and cardbus. * pccard hot-removal now appears to work. * support pre-fetchable memory in cardbus. * update cardbus to support new pci bus interface functions. * Fix CIS reading to no longer use rman_get_virtual(). What's not there, but in the works: * pccard needs to do interrupt properly and not read the ISR on single function cards. * real resource management for pccard * a complete implementation of CIS parsing * need to look into how to correctly use mutex in pccbb
2001-08-27 00:09:42 +00:00
struct cardbus_devinfo *dinfo);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static int cardbus_release_resource(device_t cbdev, device_t child,
int type, int rid, struct resource *r);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static __inline void cardbus_set_command_bit(device_t cbdev, device_t child,
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint16_t bit);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static int cardbus_set_powerstate_method(device_t cbdev, device_t child,
int state);
static int cardbus_set_resource(device_t cbdev, device_t child, int type,
int rid, u_long start, u_long count, struct resource *res);
static int cardbus_set_resource_method(device_t cbdev, device_t child,
int type, int rid, u_long start, u_long count);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static int cardbus_setup_intr(device_t cbdev, device_t child,
struct resource *irq, int flags, driver_intr_t *intr,
void *arg, void **cookiep);
static int cardbus_teardown_intr(device_t cbdev, device_t child,
struct resource *irq, void *cookie);
static void cardbus_write_config_method(device_t cbdev, device_t child,
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
int reg, uint32_t val, int width);
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static int cardbus_write_ivar(device_t cbdev, device_t child, int which,
uintptr_t value);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/************************************************************************/
/* Probe/Attach */
/************************************************************************/
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
static int
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
cardbus_probe(device_t cbdev)
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
{
Add support for suspending/resuming CardBus bridges. We really should have and use power state information, but none exists today. Submitted by: YAMAMOTO Shigeru-san <shigeru@iij.ad.jp>
2001-12-15 05:58:28 +00:00
device_set_desc(cbdev, "CardBus bus");
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
return 0;
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
}
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
static int
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
cardbus_attach(device_t cbdev)
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
{
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
return 0;
}
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
static int
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
cardbus_detach(device_t cbdev)
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
{
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
cardbus_detach_card(cbdev);
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
return 0;
}
Add support for suspending/resuming CardBus bridges. We really should have and use power state information, but none exists today. Submitted by: YAMAMOTO Shigeru-san <shigeru@iij.ad.jp>
2001-12-15 05:58:28 +00:00
static int
cardbus_suspend(device_t self)
{
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
cardbus_detach_card(self);
Add support for suspending/resuming CardBus bridges. We really should have and use power state information, but none exists today. Submitted by: YAMAMOTO Shigeru-san <shigeru@iij.ad.jp>
2001-12-15 05:58:28 +00:00
return (0);
}
static int
cardbus_resume(device_t self)
{
return (0);
}
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/************************************************************************/
/* Attach/Detach card */
/************************************************************************/
static void
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
cardbus_device_setup_regs(device_t brdev, int b, int s, int f, pcicfgregs *cfg)
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
{
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_INTLINE,
pci_get_irq(device_get_parent(brdev)), 1);
cfg->intline = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_INTLINE, 1);
1) When mucking with mapping registers, it is best to *not* have io or memory space access enabled. This patch defers the setting of these bits until after all of the mapping registers are probed. It might be even better to defer this until a particular mapping is activated and to disable that type of access when a new register is activated. 2) The PCI spec is very explicit about how mapping registers and the expansion ROM mapping register should be probed. This patch makes cardbus_add_map() follow the spec. 3) The PCI spec allows a device to use the same address decoder for expansion ROM access as is used for memory mapped register access. This patch carefully enables and disables ROM access along with resource (de)activiation. This doesn't include the prefetching detection stuff (maybe later when code is written to actually turn on prefetching). It also does not use the PCI definitions (yet, I'll try to put this in all at once later) Submitted by: Justin T. Gibbs
2000-11-28 00:52:40 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_CACHELNSZ, 0x08, 1);
cfg->cachelnsz = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_CACHELNSZ, 1);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_LATTIMER, 0xa8, 1);
cfg->lattimer = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_LATTIMER, 1);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_MINGNT, 0x14, 1);
cfg->mingnt = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_MINGNT, 1);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
PCIB_WRITE_CONFIG(brdev, b, s, f, PCIR_MAXLAT, 0x14, 1);
cfg->maxlat = PCIB_READ_CONFIG(brdev, b, s, f, PCIR_MAXLAT, 1);
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
}
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
static int
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
cardbus_attach_card(device_t cbdev)
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
{
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
device_t brdev = device_get_parent(cbdev);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
int cardattached = 0;
static int curr_bus_number = 2; /* XXX EVILE BAD (see below) */
int bus, slot, func;
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
cardbus_detach_card(cbdev); /* detach existing cards */
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
POWER_ENABLE_SOCKET(brdev, cbdev);
bus = pcib_get_bus(cbdev);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
if (bus == 0) {
/*
* XXX EVILE BAD XXX
* Not all BIOSes initialize the secondary bus number properly,
* so if the default is bad, we just put one in and hope it
* works.
*/
bus = curr_bus_number;
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
pci_write_config(brdev, PCIR_SECBUS_2, curr_bus_number, 1);
pci_write_config(brdev, PCIR_SUBBUS_2, curr_bus_number + 2, 1);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
curr_bus_number += 3;
}
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
/* For each function, set it up and try to attach a driver to it */
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
for (slot = 0; slot <= CARDBUS_SLOTMAX; slot++) {
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
int cardbusfunchigh = 0;
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
for (func = 0; func <= cardbusfunchigh; func++) {
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
struct cardbus_devinfo *dinfo =
cardbus_read_device(brdev, bus, slot, func);
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
if (dinfo == NULL)
continue;
Use the pci.c code wherever possible, rather than copying all the pci code into cardbus and s/pci/cardbus. This exposes a few pci_* functions that are now static. This work is similar to work Justin posted to the mobile list about a year or two ago, which I have neglected since then. This is a subset of his current work with the multiple inheritance newbus architecutre. When completed, that will eliminate the need for pci/pci_private.h. Similar work is needed for the cardbus_cis and pccard_cis code as well.
2002-02-27 05:09:14 +00:00
if (dinfo->pci.cfg.mfdev)
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
cardbusfunchigh = CARDBUS_FUNCMAX;
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
cardbus_device_setup_regs(brdev, bus, slot, func,
&dinfo->pci.cfg);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
cardbus_print_verbose(dinfo);
dinfo->pci.cfg.dev = device_add_child(cbdev, NULL, -1);
if (!dinfo->pci.cfg.dev) {
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
DEVPRINTF((cbdev, "Cannot add child!\n"));
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
cardbus_freecfg(dinfo);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
continue;
}
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
resource_list_init(&dinfo->pci.resources);
device_set_ivars(dinfo->pci.cfg.dev, dinfo);
cardbus_do_cis(cbdev, dinfo->pci.cfg.dev);
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
if (device_probe_and_attach(dinfo->pci.cfg.dev) != 0)
Part two of this NEWCARD update: Briefly, the significant changes include: * Way better resource management in pccbb, pccard and cardbus. * pccard hot-removal now appears to work. * support pre-fetchable memory in cardbus. * update cardbus to support new pci bus interface functions. * Fix CIS reading to no longer use rman_get_virtual(). What's not there, but in the works: * pccard needs to do interrupt properly and not read the ISR on single function cards. * real resource management for pccard * a complete implementation of CIS parsing * need to look into how to correctly use mutex in pccbb
2001-08-27 00:09:42 +00:00
cardbus_release_all_resources(cbdev, dinfo);
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
else
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
cardattached++;
}
}
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
if (cardattached > 0)
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
return (0);
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
POWER_DISABLE_SOCKET(brdev, cbdev);
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
return (ENOENT);
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
}
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
static int
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
cardbus_detach_card(device_t cbdev)
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
{
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
int numdevs;
device_t *devlist;
int tmp;
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
int err = 0;
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
device_get_children(cbdev, &devlist, &numdevs);
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
if (numdevs == 0) {
Fix memory leaks with dev_get_children(). Submitted by: Jeroen Ruigrok/Asmodai <asmodai@wxs.nl>
2001-02-08 21:47:45 +00:00
free(devlist, M_TEMP);
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
return (ENOENT);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
}
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
for (tmp = 0; tmp < numdevs; tmp++) {
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
struct cardbus_devinfo *dinfo = device_get_ivars(devlist[tmp]);
int status = device_get_state(devlist[tmp]);
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
MFp4: o Add a diagnostic for an 'impossible' condition. o Collapse common code.
2002-11-14 05:12:02 +00:00
if (dinfo->pci.cfg.dev != devlist[tmp])
device_printf(cbdev, "devinfo dev mismatch\n");
if (status == DS_ATTACHED || status == DS_BUSY)
device_detach(devlist[tmp]);
cardbus_release_all_resources(cbdev, dinfo);
device_delete_child(cbdev, devlist[tmp]);
cardbus_freecfg(dinfo);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
}
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
POWER_DISABLE_SOCKET(device_get_parent(cbdev), cbdev);
Fix memory leaks with dev_get_children(). Submitted by: Jeroen Ruigrok/Asmodai <asmodai@wxs.nl>
2001-02-08 21:47:45 +00:00
free(devlist, M_TEMP);
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
return (err);
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
}
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
static void
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
cardbus_driver_added(device_t cbdev, driver_t *driver)
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
{
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
int numdevs;
device_t *devlist;
Don't turn off the power of cards when new drivers are added unconditionally. kldloading a cardbus driver was shooting down other attached devices because most drivers assume that one cannot power-cycle cards w/o the driver knowning about it. Submitted by: simokawa-san
2003-02-11 05:31:35 +00:00
device_t dev;
int i;
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
struct cardbus_devinfo *dinfo;
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
Non-functional changes to NEWCARD stuff. This is the first part of a two-part update to NEWCARD. Changes in this commit are non-functional, and includes the following: * indentation and other changes to meet style(9). * other minor style consistancy changes * addition of comments * renaming of device_t variables to be consistant across all of NEWCARD. (note that not all style violations are fixed in this commit -- those that aren't will be clobbered by the next commit.)
2001-08-26 23:55:34 +00:00
DEVICE_IDENTIFY(driver, cbdev);
Don't turn off the power of cards when new drivers are added unconditionally. kldloading a cardbus driver was shooting down other attached devices because most drivers assume that one cannot power-cycle cards w/o the driver knowning about it. Submitted by: simokawa-san
2003-02-11 05:31:35 +00:00
device_get_children(cbdev, &devlist, &numdevs);
for (i = 0; i < numdevs; i++) {
dev = devlist[i];
if (device_get_state(dev) != DS_NOTPRESENT)
continue;
dinfo = device_get_ivars(dev);
cardbus_print_verbose(dinfo);
resource_list_init(&dinfo->pci.resources);
cardbus_do_cis(cbdev, dev);
if (device_probe_and_attach(dev) != 0)
cardbus_release_all_resources(cbdev, dinfo);
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
}
Fix memory leaks with dev_get_children(). Submitted by: Jeroen Ruigrok/Asmodai <asmodai@wxs.nl>
2001-02-08 21:47:45 +00:00
free(devlist, M_TEMP);
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
}
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
/************************************************************************/
/* PCI-Like config reading (copied from pci.c */
/************************************************************************/
/* read configuration header into pcicfgrect structure */
static void
cardbus_read_extcap(device_t cbdev, pcicfgregs *cfg)
{
#define REG(n, w) PCIB_READ_CONFIG(cbdev, cfg->bus, cfg->slot, cfg->func, n, w)
int ptr, nextptr, ptrptr;
switch (cfg->hdrtype) {
case 0:
ptrptr = 0x34;
break;
case 2:
ptrptr = 0x14;
break;
default:
return; /* no extended capabilities support */
}
nextptr = REG(ptrptr, 1); /* sanity check? */
/*
* Read capability entries.
*/
while (nextptr != 0) {
/* Sanity check */
if (nextptr > 255) {
printf("illegal PCI extended capability offset %d\n",
nextptr);
return;
}
/* Find the next entry */
ptr = nextptr;
nextptr = REG(ptr + 1, 1);
/* Process this entry */
switch (REG(ptr, 1)) {
case 0x01: /* PCI power management */
if (cfg->pp_cap == 0) {
cfg->pp_cap = REG(ptr + PCIR_POWER_CAP, 2);
cfg->pp_status = ptr + PCIR_POWER_STATUS;
cfg->pp_pmcsr = ptr + PCIR_POWER_PMCSR;
if ((nextptr - ptr) > PCIR_POWER_DATA)
cfg->pp_data = ptr + PCIR_POWER_DATA;
}
break;
default:
break;
}
}
#undef REG
}
/* extract header type specific config data */
static void
cardbus_hdrtypedata(device_t brdev, int b, int s, int f, pcicfgregs *cfg)
{
#define REG(n, w) PCIB_READ_CONFIG(brdev, b, s, f, n, w)
switch (cfg->hdrtype) {
case 0:
cfg->subvendor = REG(PCIR_SUBVEND_0, 2);
cfg->subdevice = REG(PCIR_SUBDEV_0, 2);
cfg->nummaps = PCI_MAXMAPS_0;
break;
case 1:
cfg->subvendor = REG(PCIR_SUBVEND_1, 2);
cfg->subdevice = REG(PCIR_SUBDEV_1, 2);
cfg->nummaps = PCI_MAXMAPS_1;
break;
case 2:
cfg->subvendor = REG(PCIR_SUBVEND_2, 2);
cfg->subdevice = REG(PCIR_SUBDEV_2, 2);
cfg->nummaps = PCI_MAXMAPS_2;
break;
}
#undef REG
}
static struct cardbus_devinfo *
cardbus_read_device(device_t brdev, int b, int s, int f)
{
#define REG(n, w) PCIB_READ_CONFIG(brdev, b, s, f, n, w)
pcicfgregs *cfg = NULL;
struct cardbus_devinfo *devlist_entry = NULL;
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
if (REG(PCIR_DEVVENDOR, 4) != 0xffffffff) {
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
devlist_entry = malloc(sizeof(struct cardbus_devinfo),
Remove M_TRYWAIT/M_WAITOK/M_WAIT. Callers should use 0. Merge M_NOWAIT/M_DONTWAIT into a single flag M_NOWAIT.
2003-01-21 08:56:16 +00:00
M_DEVBUF, M_ZERO);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
if (devlist_entry == NULL)
return (NULL);
cfg = &devlist_entry->pci.cfg;
cfg->bus = b;
cfg->slot = s;
cfg->func = f;
cfg->vendor = REG(PCIR_VENDOR, 2);
cfg->device = REG(PCIR_DEVICE, 2);
cfg->cmdreg = REG(PCIR_COMMAND, 2);
cfg->statreg = REG(PCIR_STATUS, 2);
cfg->baseclass = REG(PCIR_CLASS, 1);
cfg->subclass = REG(PCIR_SUBCLASS, 1);
cfg->progif = REG(PCIR_PROGIF, 1);
cfg->revid = REG(PCIR_REVID, 1);
cfg->hdrtype = REG(PCIR_HEADERTYPE, 1);
cfg->cachelnsz = REG(PCIR_CACHELNSZ, 1);
cfg->lattimer = REG(PCIR_LATTIMER, 1);
cfg->intpin = REG(PCIR_INTPIN, 1);
cfg->intline = REG(PCIR_INTLINE, 1);
cfg->mingnt = REG(PCIR_MINGNT, 1);
cfg->maxlat = REG(PCIR_MAXLAT, 1);
cfg->mfdev = (cfg->hdrtype & PCIM_MFDEV) != 0;
cfg->hdrtype &= ~PCIM_MFDEV;
cardbus_hdrtypedata(brdev, b, s, f, cfg);
if (REG(PCIR_STATUS, 2) & PCIM_STATUS_CAPPRESENT)
cardbus_read_extcap(brdev, cfg);
devlist_entry->pci.conf.pc_sel.pc_bus = cfg->bus;
devlist_entry->pci.conf.pc_sel.pc_dev = cfg->slot;
devlist_entry->pci.conf.pc_sel.pc_func = cfg->func;
devlist_entry->pci.conf.pc_hdr = cfg->hdrtype;
devlist_entry->pci.conf.pc_subvendor = cfg->subvendor;
devlist_entry->pci.conf.pc_subdevice = cfg->subdevice;
devlist_entry->pci.conf.pc_vendor = cfg->vendor;
devlist_entry->pci.conf.pc_device = cfg->device;
devlist_entry->pci.conf.pc_class = cfg->baseclass;
devlist_entry->pci.conf.pc_subclass = cfg->subclass;
devlist_entry->pci.conf.pc_progif = cfg->progif;
devlist_entry->pci.conf.pc_revid = cfg->revid;
}
return (devlist_entry);
#undef REG
}
/* free pcicfgregs structure and all depending data structures */
static int
cardbus_freecfg(struct cardbus_devinfo *dinfo)
{
free(dinfo, M_DEVBUF);
return (0);
}
static void
cardbus_print_verbose(struct cardbus_devinfo *dinfo)
{
MFp4: o Always release the resources on device detach. o Attach resources the same with driver added as we do we do in the insert case (maybe this should be a routine). o signal the wakeup of the thread on resume instead of trying to force an interrupt. o Minor debug hacks. o use 0xffffffff instead of -1 for uint32_t items. o Don't complain when we're asked to detach no cards. This is normal. o Eliminate the now worthless second parameter to card_detach_card. o minor style(9)isms Some of these patches may be from: iwasaki-san, jhb, iadowse
2002-11-02 23:00:28 +00:00
if (bootverbose || cardbus_debug > 0)
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
{
pcicfgregs *cfg = &dinfo->pci.cfg;
printf("found->\tvendor=0x%04x, dev=0x%04x, revid=0x%02x\n",
cfg->vendor, cfg->device, cfg->revid);
printf("\tclass=%02x-%02x-%02x, hdrtype=0x%02x, mfdev=%d\n",
cfg->baseclass, cfg->subclass, cfg->progif,
cfg->hdrtype, cfg->mfdev);
printf("\tcmdreg=0x%04x, statreg=0x%04x, "
"cachelnsz=%d (dwords)\n",
cfg->cmdreg, cfg->statreg, cfg->cachelnsz);
printf("\tlattimer=0x%02x (%d ns), mingnt=0x%02x (%d ns), "
"maxlat=0x%02x (%d ns)\n",
cfg->lattimer, cfg->lattimer * 30,
cfg->mingnt, cfg->mingnt * 250, cfg->maxlat,
cfg->maxlat * 250);
if (cfg->intpin > 0)
printf("\tintpin=%c, irq=%d\n",
cfg->intpin + 'a' - 1, cfg->intline);
}
}
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/************************************************************************/
/* Resources */
/************************************************************************/
Raw import of newconfig cardbus code. This is effectively an import, so the code doesn't compile. I added $FreeBSD$ headers.
1999-11-18 07:21:51 +00:00
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static int
cardbus_set_resource(device_t cbdev, device_t child, int type, int rid,
u_long start, u_long count, struct resource *res)
{
struct cardbus_devinfo *dinfo;
struct resource_list *rl;
struct resource_list_entry *rle;
if (device_get_parent(child) != cbdev)
return ENOENT;
dinfo = device_get_ivars(child);
rl = &dinfo->pci.resources;
rle = resource_list_find(rl, type, rid);
if (rle == NULL) {
resource_list_add(rl, type, rid, start, start + count - 1,
count);
if (res != NULL) {
rle = resource_list_find(rl, type, rid);
rle->res = res;
}
} else {
if (rle->res == NULL) {
MFp4: Don't reach inside of rman to r_dev. Use rman_get_device instead.
2003-02-12 05:54:22 +00:00
} else if (rman_get_device(rle->res) == cbdev &&
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
(!(rman_get_flags(rle->res) & RF_ACTIVE))) {
int f;
f = rman_get_flags(rle->res);
bus_release_resource(cbdev, type, rid, res);
rle->res = bus_alloc_resource(cbdev, type, &rid,
start, start + count - 1,
count, f);
} else {
device_printf(cbdev, "set_resource: resource busy\n");
return EBUSY;
}
rle->start = start;
rle->end = start + count - 1;
rle->count = count;
if (res != NULL)
rle->res = res;
}
if (device_get_parent(child) == cbdev)
pci_write_config(child, rid, start, 4);
return 0;
}
static int
cardbus_get_resource(device_t cbdev, device_t child, int type, int rid,
u_long *startp, u_long *countp)
{
struct cardbus_devinfo *dinfo;
struct resource_list *rl;
struct resource_list_entry *rle;
if (device_get_parent(child) != cbdev)
return ENOENT;
dinfo = device_get_ivars(child);
rl = &dinfo->pci.resources;
rle = resource_list_find(rl, type, rid);
if (!rle)
return ENOENT;
if (startp)
*startp = rle->start;
if (countp)
*countp = rle->count;
return 0;
}
static void
cardbus_delete_resource(device_t cbdev, device_t child, int type, int rid)
{
struct cardbus_devinfo *dinfo;
struct resource_list *rl;
struct resource_list_entry *rle;
if (device_get_parent(child) != cbdev)
return;
dinfo = device_get_ivars(child);
rl = &dinfo->pci.resources;
rle = resource_list_find(rl, type, rid);
if (rle) {
if (rle->res) {
MFp4: Don't reach inside of rman to r_dev. Use rman_get_device instead.
2003-02-12 05:54:22 +00:00
if (rman_get_device(rle->res) != cbdev ||
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
rman_get_flags(rle->res) & RF_ACTIVE) {
device_printf(cbdev, "delete_resource: "
"Resource still owned by child, oops. "
"(type=%d, rid=%d, addr=%lx)\n",
rle->type, rle->rid,
rman_get_start(rle->res));
return;
}
bus_release_resource(cbdev, type, rid, rle->res);
}
resource_list_delete(rl, type, rid);
}
if (device_get_parent(child) == cbdev)
pci_write_config(child, rid, 0, 4);
}
static int
cardbus_set_resource_method(device_t cbdev, device_t child, int type, int rid,
u_long start, u_long count)
{
int ret;
ret = cardbus_set_resource(cbdev, child, type, rid, start, count, NULL);
if (ret != 0)
return ret;
return BUS_SET_RESOURCE(device_get_parent(cbdev), child, type, rid,
start, count);
}
static int
cardbus_get_resource_method(device_t cbdev, device_t child, int type, int rid,
u_long *startp, u_long *countp)
{
int ret;
ret = cardbus_get_resource(cbdev, child, type, rid, startp, countp);
if (ret != 0)
return ret;
return BUS_GET_RESOURCE(device_get_parent(cbdev), child, type, rid,
startp, countp);
}
static void
cardbus_delete_resource_method(device_t cbdev, device_t child,
int type, int rid)
{
cardbus_delete_resource(cbdev, child, type, rid);
BUS_DELETE_RESOURCE(device_get_parent(cbdev), child, type, rid);
}
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
static void
Part two of this NEWCARD update: Briefly, the significant changes include: * Way better resource management in pccbb, pccard and cardbus. * pccard hot-removal now appears to work. * support pre-fetchable memory in cardbus. * update cardbus to support new pci bus interface functions. * Fix CIS reading to no longer use rman_get_virtual(). What's not there, but in the works: * pccard needs to do interrupt properly and not read the ISR on single function cards. * real resource management for pccard * a complete implementation of CIS parsing * need to look into how to correctly use mutex in pccbb
2001-08-27 00:09:42 +00:00
cardbus_release_all_resources(device_t cbdev, struct cardbus_devinfo *dinfo)
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
{
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
struct resource_list_entry *rle;
/* Free all allocated resources */
SLIST_FOREACH(rle, &dinfo->pci.resources, link) {
if (rle->res) {
MFp4: Don't reach inside of rman to r_dev. Use rman_get_device instead.
2003-02-12 05:54:22 +00:00
if (rman_get_device(rle->res) != cbdev)
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
device_printf(cbdev, "release_all_resource: "
"Resource still owned by child, oops. "
"(type=%d, rid=%d, addr=%lx)\n",
rle->type, rle->rid,
rman_get_start(rle->res));
BUS_RELEASE_RESOURCE(device_get_parent(cbdev),
MFp4: Don't reach inside of rman to r_dev. Use rman_get_device instead.
2003-02-12 05:54:22 +00:00
cbdev, rle->type, rle->rid, rle->res);
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
rle->res = NULL;
/*
* zero out config so the card won't acknowledge
* access to the space anymore
*/
pci_write_config(dinfo->pci.cfg.dev, rle->rid, 0, 4);
}
}
Use the pci.c code wherever possible, rather than copying all the pci code into cardbus and s/pci/cardbus. This exposes a few pci_* functions that are now static. This work is similar to work Justin posted to the mobile list about a year or two ago, which I have neglected since then. This is a subset of his current work with the multiple inheritance newbus architecutre. When completed, that will eliminate the need for pci/pci_private.h. Similar work is needed for the cardbus_cis and pccard_cis code as well.
2002-02-27 05:09:14 +00:00
resource_list_free(&dinfo->pci.resources);
Part two of this NEWCARD update: Briefly, the significant changes include: * Way better resource management in pccbb, pccard and cardbus. * pccard hot-removal now appears to work. * support pre-fetchable memory in cardbus. * update cardbus to support new pci bus interface functions. * Fix CIS reading to no longer use rman_get_virtual(). What's not there, but in the works: * pccard needs to do interrupt properly and not read the ISR on single function cards. * real resource management for pccard * a complete implementation of CIS parsing * need to look into how to correctly use mutex in pccbb
2001-08-27 00:09:42 +00:00
}
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static struct resource *
cardbus_alloc_resource(device_t cbdev, device_t child, int type,
int *rid, u_long start, u_long end, u_long count, u_int flags)
{
struct cardbus_devinfo *dinfo;
struct resource_list_entry *rle = 0;
int passthrough = (device_get_parent(child) != cbdev);
if (passthrough) {
return (BUS_ALLOC_RESOURCE(device_get_parent(cbdev), child,
type, rid, start, end, count, flags));
}
dinfo = device_get_ivars(child);
rle = resource_list_find(&dinfo->pci.resources, type, *rid);
if (!rle)
return NULL; /* no resource of that type/rid */
if (!rle->res) {
device_printf(cbdev, "WARNING: Resource not reserved by bus\n");
return NULL;
} else {
/* Release the cardbus hold on the resource */
MFp4: Don't reach inside of rman to r_dev. Use rman_get_device instead.
2003-02-12 05:54:22 +00:00
if (rman_get_device(rle->res) != cbdev)
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
return NULL;
bus_release_resource(cbdev, type, *rid, rle->res);
rle->res = NULL;
switch (type) {
case SYS_RES_IOPORT:
case SYS_RES_MEMORY:
if (!(flags & RF_ALIGNMENT_MASK))
flags |= rman_make_alignment_flags(rle->count);
break;
case SYS_RES_IRQ:
flags |= RF_SHAREABLE;
break;
}
/* Allocate the resource to the child */
return resource_list_alloc(&dinfo->pci.resources, cbdev, child,
type, rid, rle->start, rle->end, rle->count, flags);
}
}
static int
cardbus_release_resource(device_t cbdev, device_t child, int type, int rid,
struct resource *r)
{
struct cardbus_devinfo *dinfo;
int passthrough = (device_get_parent(child) != cbdev);
struct resource_list_entry *rle = 0;
int flags;
int ret;
if (passthrough) {
return BUS_RELEASE_RESOURCE(device_get_parent(cbdev), child,
type, rid, r);
}
dinfo = device_get_ivars(child);
/*
* According to the PCI 2.2 spec, devices may share an address
* decoder between memory mapped ROM access and memory
* mapped register access. To be safe, disable ROM access
* whenever it is released.
*/
if (rid == CARDBUS_ROM_REG) {
uint32_t rom_reg;
rom_reg = pci_read_config(child, rid, 4);
rom_reg &= ~CARDBUS_ROM_ENABLE;
pci_write_config(child, rid, rom_reg, 4);
}
rle = resource_list_find(&dinfo->pci.resources, type, rid);
if (!rle) {
device_printf(cbdev, "Allocated resource not found\n");
return ENOENT;
}
if (!rle->res) {
device_printf(cbdev, "Allocated resource not recorded\n");
return ENOENT;
}
ret = BUS_RELEASE_RESOURCE(device_get_parent(cbdev), child,
type, rid, r);
switch (type) {
case SYS_RES_IOPORT:
case SYS_RES_MEMORY:
flags = rman_make_alignment_flags(rle->count);
break;
case SYS_RES_IRQ:
flags = RF_SHAREABLE;
break;
default:
flags = 0;
}
/* Restore cardbus hold on the resource */
rle->res = bus_alloc_resource(cbdev, type, &rid,
rle->start, rle->end, rle->count, flags);
if (rle->res == NULL)
device_printf(cbdev, "release_resource: "
"unable to reacquire resource\n");
return ret;
}
static int
cardbus_setup_intr(device_t cbdev, device_t child, struct resource *irq,
int flags, driver_intr_t *intr, void *arg, void **cookiep)
{
int ret;
device_t cdev;
struct cardbus_devinfo *dinfo;
ret = bus_generic_setup_intr(cbdev, child, irq, flags, intr, arg,
cookiep);
if (ret != 0)
return ret;
for (cdev = child; cbdev != device_get_parent(cdev);
cdev = device_get_parent(cdev))
/* NOTHING */;
dinfo = device_get_ivars(cdev);
return 0;
}
static int
cardbus_teardown_intr(device_t cbdev, device_t child, struct resource *irq,
void *cookie)
{
int ret;
device_t cdev;
struct cardbus_devinfo *dinfo;
ret = bus_generic_teardown_intr(cbdev, child, irq, cookie);
if (ret != 0)
return ret;
for (cdev = child; cbdev != device_get_parent(cdev);
cdev = device_get_parent(cdev))
/* NOTHING */;
dinfo = device_get_ivars(cdev);
return (0);
}
/************************************************************************/
/* Other Bus Methods */
/************************************************************************/
static int
cardbus_print_resources(struct resource_list *rl, const char *name,
int type, const char *format)
{
struct resource_list_entry *rle;
int printed, retval;
printed = 0;
retval = 0;
/* Yes, this is kinda cheating */
SLIST_FOREACH(rle, rl, link) {
if (rle->type == type) {
if (printed == 0)
retval += printf(" %s ", name);
else if (printed > 0)
retval += printf(",");
printed++;
retval += printf(format, rle->start);
if (rle->count > 1) {
retval += printf("-");
retval += printf(format, rle->start +
rle->count - 1);
}
}
}
return retval;
}
static int
cardbus_print_child(device_t cbdev, device_t child)
{
struct cardbus_devinfo *dinfo;
struct resource_list *rl;
pcicfgregs *cfg;
int retval = 0;
dinfo = device_get_ivars(child);
cfg = &dinfo->pci.cfg;
rl = &dinfo->pci.resources;
retval += bus_print_child_header(cbdev, child);
retval += cardbus_print_resources(rl, "port", SYS_RES_IOPORT, "%#lx");
retval += cardbus_print_resources(rl, "mem", SYS_RES_MEMORY, "%#lx");
retval += cardbus_print_resources(rl, "irq", SYS_RES_IRQ, "%ld");
if (device_get_flags(cbdev))
retval += printf(" flags %#x", device_get_flags(cbdev));
retval += printf(" at device %d.%d", pci_get_slot(child),
pci_get_function(child));
retval += bus_print_child_footer(cbdev, child);
return (retval);
}
static void
cardbus_probe_nomatch(device_t cbdev, device_t child)
{
struct cardbus_devinfo *dinfo;
pcicfgregs *cfg;
dinfo = device_get_ivars(child);
cfg = &dinfo->pci.cfg;
device_printf(cbdev, "<unknown card>");
printf(" (vendor=0x%04x, dev=0x%04x)", cfg->vendor, cfg->device);
printf(" at %d.%d", pci_get_slot(child), pci_get_function(child));
if (cfg->intpin > 0 && cfg->intline != 255) {
printf(" irq %d", cfg->intline);
}
printf("\n");
return;
}
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
static int
cardbus_child_location_str(device_t cbdev, device_t child, char *buf,
size_t buflen)
{
struct cardbus_devinfo *dinfo;
pcicfgregs *cfg;
dinfo = device_get_ivars(child);
cfg = &dinfo->pci.cfg;
snprintf(buf, buflen, "slot=%d function=%d", pci_get_slot(child),
pci_get_function(child));
return (0);
}
static int
cardbus_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
size_t buflen)
{
struct cardbus_devinfo *dinfo;
pcicfgregs *cfg;
dinfo = device_get_ivars(child);
cfg = &dinfo->pci.cfg;
snprintf(buf, buflen, "vendor=0x%04x device=0x%04x subvendor=0x%04x "
"subdevice=0x%04x", cfg->vendor, cfg->device, cfg->subvendor,
cfg->subdevice);
return (0);
}
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
static int
cardbus_read_ivar(device_t cbdev, device_t child, int which, u_long *result)
{
struct cardbus_devinfo *dinfo;
pcicfgregs *cfg;
dinfo = device_get_ivars(child);
cfg = &dinfo->pci.cfg;
switch (which) {
Implement PCI_IVAR_ETHADDR. Cardbus has the MAC addr in the CIS, sometimes, so return it when requested and it does. Also a little more infrastructure for a few other things. Submitted by: sam Approved by: re (blanket for NEWCARD)
2002-11-27 06:56:29 +00:00
case PCI_IVAR_ETHADDR:
/*
* The generic accessor doesn't deal with failure, so
* we set the return value, then return an error.
*/
Need more parens here. Approved by: re (blanket)
2002-11-27 17:30:41 +00:00
if ((dinfo->fepresent & (1 << TPL_FUNCE_LAN_NID)) == 0) {
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
*((uint8_t **) result) = NULL;
Implement PCI_IVAR_ETHADDR. Cardbus has the MAC addr in the CIS, sometimes, so return it when requested and it does. Also a little more infrastructure for a few other things. Submitted by: sam Approved by: re (blanket for NEWCARD)
2002-11-27 06:56:29 +00:00
return (EINVAL);
}
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
*((uint8_t **) result) = dinfo->funce.lan.nid;
Implement PCI_IVAR_ETHADDR. Cardbus has the MAC addr in the CIS, sometimes, so return it when requested and it does. Also a little more infrastructure for a few other things. Submitted by: sam Approved by: re (blanket for NEWCARD)
2002-11-27 06:56:29 +00:00
break;
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
case PCI_IVAR_SUBVENDOR:
*result = cfg->subvendor;
break;
case PCI_IVAR_SUBDEVICE:
*result = cfg->subdevice;
break;
case PCI_IVAR_VENDOR:
*result = cfg->vendor;
break;
case PCI_IVAR_DEVICE:
*result = cfg->device;
break;
case PCI_IVAR_DEVID:
*result = (cfg->device << 16) | cfg->vendor;
break;
case PCI_IVAR_CLASS:
*result = cfg->baseclass;
break;
case PCI_IVAR_SUBCLASS:
*result = cfg->subclass;
break;
case PCI_IVAR_PROGIF:
*result = cfg->progif;
break;
case PCI_IVAR_REVID:
*result = cfg->revid;
break;
case PCI_IVAR_INTPIN:
*result = cfg->intpin;
break;
case PCI_IVAR_IRQ:
*result = cfg->intline;
break;
case PCI_IVAR_BUS:
*result = cfg->bus;
break;
case PCI_IVAR_SLOT:
*result = cfg->slot;
break;
case PCI_IVAR_FUNCTION:
*result = cfg->func;
break;
default:
return ENOENT;
}
return 0;
}
static int
cardbus_write_ivar(device_t cbdev, device_t child, int which, uintptr_t value)
{
struct cardbus_devinfo *dinfo;
pcicfgregs *cfg;
dinfo = device_get_ivars(child);
cfg = &dinfo->pci.cfg;
switch (which) {
Implement PCI_IVAR_ETHADDR. Cardbus has the MAC addr in the CIS, sometimes, so return it when requested and it does. Also a little more infrastructure for a few other things. Submitted by: sam Approved by: re (blanket for NEWCARD)
2002-11-27 06:56:29 +00:00
case PCI_IVAR_ETHADDR:
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
case PCI_IVAR_SUBVENDOR:
case PCI_IVAR_SUBDEVICE:
case PCI_IVAR_VENDOR:
case PCI_IVAR_DEVICE:
case PCI_IVAR_DEVID:
case PCI_IVAR_CLASS:
case PCI_IVAR_SUBCLASS:
case PCI_IVAR_PROGIF:
case PCI_IVAR_REVID:
case PCI_IVAR_INTPIN:
case PCI_IVAR_IRQ:
case PCI_IVAR_BUS:
case PCI_IVAR_SLOT:
case PCI_IVAR_FUNCTION:
return EINVAL; /* disallow for now */
default:
return ENOENT;
}
return 0;
}
/************************************************************************/
/* Compatibility with PCI bus (XXX: Do we need this?) */
/************************************************************************/
/*
* PCI power manangement
*/
static int
cardbus_set_powerstate_method(device_t cbdev, device_t child, int state)
{
struct cardbus_devinfo *dinfo = device_get_ivars(child);
pcicfgregs *cfg = &dinfo->pci.cfg;
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint16_t status;
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
int result;
if (cfg->pp_cap != 0) {
status = PCI_READ_CONFIG(cbdev, child, cfg->pp_status, 2)
& ~PCIM_PSTAT_DMASK;
result = 0;
switch (state) {
case PCI_POWERSTATE_D0:
status |= PCIM_PSTAT_D0;
break;
case PCI_POWERSTATE_D1:
if (cfg->pp_cap & PCIM_PCAP_D1SUPP) {
status |= PCIM_PSTAT_D1;
} else {
result = EOPNOTSUPP;
}
break;
case PCI_POWERSTATE_D2:
if (cfg->pp_cap & PCIM_PCAP_D2SUPP) {
status |= PCIM_PSTAT_D2;
} else {
result = EOPNOTSUPP;
}
break;
case PCI_POWERSTATE_D3:
status |= PCIM_PSTAT_D3;
break;
default:
result = EINVAL;
}
if (result == 0)
PCI_WRITE_CONFIG(cbdev, child, cfg->pp_status,
status, 2);
} else {
result = ENXIO;
}
return (result);
}
static int
cardbus_get_powerstate_method(device_t cbdev, device_t child)
{
struct cardbus_devinfo *dinfo = device_get_ivars(child);
pcicfgregs *cfg = &dinfo->pci.cfg;
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint16_t status;
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
int result;
if (cfg->pp_cap != 0) {
status = PCI_READ_CONFIG(cbdev, child, cfg->pp_status, 2);
switch (status & PCIM_PSTAT_DMASK) {
case PCIM_PSTAT_D0:
result = PCI_POWERSTATE_D0;
break;
case PCIM_PSTAT_D1:
result = PCI_POWERSTATE_D1;
break;
case PCIM_PSTAT_D2:
result = PCI_POWERSTATE_D2;
break;
case PCIM_PSTAT_D3:
result = PCI_POWERSTATE_D3;
break;
default:
result = PCI_POWERSTATE_UNKNOWN;
break;
}
} else {
/* No support, device is always at D0 */
result = PCI_POWERSTATE_D0;
}
return (result);
}
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
static uint32_t
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
cardbus_read_config_method(device_t cbdev, device_t child, int reg, int width)
{
struct cardbus_devinfo *dinfo = device_get_ivars(child);
pcicfgregs *cfg = &dinfo->pci.cfg;
return PCIB_READ_CONFIG(device_get_parent(cbdev),
cfg->bus, cfg->slot, cfg->func, reg, width);
}
static void
cardbus_write_config_method(device_t cbdev, device_t child, int reg,
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint32_t val, int width)
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
{
struct cardbus_devinfo *dinfo = device_get_ivars(child);
pcicfgregs *cfg = &dinfo->pci.cfg;
PCIB_WRITE_CONFIG(device_get_parent(cbdev),
cfg->bus, cfg->slot, cfg->func, reg, val, width);
}
static __inline void
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
cardbus_set_command_bit(device_t cbdev, device_t child, uint16_t bit)
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
{
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint16_t command;
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
command = PCI_READ_CONFIG(cbdev, child, PCIR_COMMAND, 2);
command |= bit;
PCI_WRITE_CONFIG(cbdev, child, PCIR_COMMAND, command, 2);
}
static __inline void
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
cardbus_clear_command_bit(device_t cbdev, device_t child, uint16_t bit)
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
{
MFp4: u_int*_t -> uint*_t to conform more closely with C99.
2003-01-27 05:47:01 +00:00
uint16_t command;
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
command = PCI_READ_CONFIG(cbdev, child, PCIR_COMMAND, 2);
command &= ~bit;
PCI_WRITE_CONFIG(cbdev, child, PCIR_COMMAND, command, 2);
}
static void
cardbus_enable_busmaster_method(device_t cbdev, device_t child)
{
cardbus_set_command_bit(cbdev, child, PCIM_CMD_BUSMASTEREN);
}
static void
cardbus_disable_busmaster_method(device_t cbdev, device_t child)
{
cardbus_clear_command_bit(cbdev, child, PCIM_CMD_BUSMASTEREN);
}
static void
cardbus_enable_io_method(device_t cbdev, device_t child, int space)
{
switch (space) {
case SYS_RES_IOPORT:
cardbus_set_command_bit(cbdev, child, PCIM_CMD_PORTEN);
break;
case SYS_RES_MEMORY:
cardbus_set_command_bit(cbdev, child, PCIM_CMD_MEMEN);
break;
}
}
static void
cardbus_disable_io_method(device_t cbdev, device_t child, int space)
{
switch (space) {
case SYS_RES_IOPORT:
cardbus_clear_command_bit(cbdev, child, PCIM_CMD_PORTEN);
break;
case SYS_RES_MEMORY:
cardbus_clear_command_bit(cbdev, child, PCIM_CMD_MEMEN);
break;
}
}
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
static device_method_t cardbus_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, cardbus_probe),
DEVMETHOD(device_attach, cardbus_attach),
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
DEVMETHOD(device_detach, cardbus_detach),
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
DEVMETHOD(device_shutdown, bus_generic_shutdown),
Add support for suspending/resuming CardBus bridges. We really should have and use power state information, but none exists today. Submitted by: YAMAMOTO Shigeru-san <shigeru@iij.ad.jp>
2001-12-15 05:58:28 +00:00
DEVMETHOD(device_suspend, cardbus_suspend),
DEVMETHOD(device_resume, cardbus_resume),
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/* Bus interface */
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
DEVMETHOD(bus_print_child, cardbus_print_child),
DEVMETHOD(bus_probe_nomatch, cardbus_probe_nomatch),
DEVMETHOD(bus_read_ivar, cardbus_read_ivar),
DEVMETHOD(bus_write_ivar, cardbus_write_ivar),
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
DEVMETHOD(bus_driver_added, cardbus_driver_added),
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
DEVMETHOD(bus_alloc_resource, cardbus_alloc_resource),
DEVMETHOD(bus_release_resource, cardbus_release_resource),
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
DEVMETHOD(bus_setup_intr, cardbus_setup_intr),
DEVMETHOD(bus_teardown_intr, cardbus_teardown_intr),
DEVMETHOD(bus_set_resource, cardbus_set_resource_method),
DEVMETHOD(bus_get_resource, cardbus_get_resource_method),
DEVMETHOD(bus_delete_resource, cardbus_delete_resource_method),
o Add routines to return the location and pnpinfo for this card. Note, we return the PCI pnp info, but in fact that's wrong to do since that data is not defined for CardBus cards. CardBus says that these registers are undefined and one should use the CIS to do device matching. To date, all CardBus cards have had these registered defined, no doubt because they are using common silicon to produce both the PCI cards and the CardBus cards. However, it isn't any worse than the rest of the system, so just note it in passing and move on. o Also sort prototypes while I'm here.
2002-10-07 23:00:51 +00:00
DEVMETHOD(bus_child_pnpinfo_str, cardbus_child_pnpinfo_str),
DEVMETHOD(bus_child_location_str, cardbus_child_location_str),
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/* Card Interface */
DEVMETHOD(card_attach_card, cardbus_attach_card),
DEVMETHOD(card_detach_card, cardbus_detach_card),
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
DEVMETHOD(card_cis_read, cardbus_cis_read),
DEVMETHOD(card_cis_free, cardbus_cis_free),
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
/* Cardbus/PCI interface */
Revert most of the recent PCI merge. This has proven to be too unstable for the coming DP1 release. Instead, I'll develop that on the IMP_CB_MERGE branch until it is more stable.
2002-03-15 06:41:01 +00:00
DEVMETHOD(pci_read_config, cardbus_read_config_method),
DEVMETHOD(pci_write_config, cardbus_write_config_method),
DEVMETHOD(pci_enable_busmaster, cardbus_enable_busmaster_method),
DEVMETHOD(pci_disable_busmaster, cardbus_disable_busmaster_method),
DEVMETHOD(pci_enable_io, cardbus_enable_io_method),
DEVMETHOD(pci_disable_io, cardbus_disable_io_method),
DEVMETHOD(pci_get_powerstate, cardbus_get_powerstate_method),
DEVMETHOD(pci_set_powerstate, cardbus_set_powerstate_method),
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
{0,0}
};
static driver_t cardbus_driver = {
"cardbus",
cardbus_methods,
0 /* no softc */
};
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
static devclass_t cardbus_devclass;
Initial commit of NEWCARD cardbus side (that actually compiles and works) Files: dev/cardbus/cardbus.c dev/cardbus/cardbusreg.h dev/cardbus/cardbusvar.h dev/cardbus/cardbus_cis.c dev/cardbus/cardbus_cis.h dev/pccbb/pccbb.c dev/pccbb/pccbbreg.h dev/pccbb/pccbbvar.h dev/pccbb/pccbb_if.m This should support: - cardbus controllers: * TI 113X * TI 12XX * TI 14XX * Ricoh 47X * Ricoh 46X * ToPIC 95 * ToPIC 97 * ToPIC 100 * Cirrus Logic CLPD683x - cardbus cards * 3c575BT * 3c575CT * Xircom X3201 (includes IBM, Xircom and, Intel cards) [ 3com support already in kernel, Xircom will be committed real soon now] This doesn't work with 16bit pccards under NEWCARD. Enable in your config by having "device pccbb" and "device cardbus". (A "device pccard" will attach a pccard bus, but it means you system have a high chance of panicing when a 16bit card is inserted) It should be fairly simple to make a driver attach to cardbus under NEWCARD -- simply add an entry for attaching to cardbus on a new DRIVER_MODULE and add new device IDs as necessary. You should also make sure the card can be detached nicely without the interrupt routine doing something weird, like going into an infinite loop. Usually that should entail adding an additional check when a pci register or the bus space is read to check if it equals 0xffffffff. Any problems, please let me know. Reviewed by: imp
2000-10-18 03:25:13 +00:00
pccbb -> cbb
2002-08-15 08:02:23 +00:00
DRIVER_MODULE(cardbus, cbb, cardbus_driver, cardbus_devclass, 0, 0);
Make oldcard and newcard kernel module work.
2002-05-30 17:38:00 +00:00
MODULE_VERSION(cardbus, 1);
MODULE_DEPEND(cardbus, exca, 1, 1, 1);
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
/*
A bunch of newcard/cardbus changes that's been sitting in my tree for a while: - Make pccbb/cardbus kld loadable and unloadable. - Make pccbb/cardbus use the power interface from pccard instead of inventing its own. - some other minor fixes
2000-11-28 00:05:20 +00:00
MODULE_DEPEND(cardbus, pccbb, 1, 1, 1);
* Better kld support in pccbb/cardbus - pccbb no longer needs to remember whether a card is inserted. - pccbb reissues insertion on load of cardbus/pccard modules. - got rid of unnecessary delays in power functions. - Cardbus children are no longer deleted if probe/attach fails. - non-attached child devices are reprobed at driver_added. * CARD interface to read CIS - added card_cis_read/card_cis_free interface to read arbitrary CIS data. This currently is only implemented in cardbus. * pccard begins to work - pccard can now use higher memory space (and uses it by default). - set_memory_offset interface changed. - fixed ccr access, which was broken at multiple locations. - implement an interrupt handler - pccard can now share interrupts. - resource alloc/release/activate/deactivate functions gutted: some resources are allocated by the bridge before the child device is probed or attached. Thus the resource "belongs" to the bridge, and the pccard_*_resource functions need to fudge the owner/rid. - changed some error conditions to panics to speed debugging. * Mutex fix - Giant is entered at the beginning of thread
2001-01-06 18:04:55 +00:00
*/
Reference in New Issue Copy Permalink