1
0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-05 09:14:03 +00:00
freebsd/sys/pccard/pccard.c

694 lines
17 KiB
C
Raw Normal View History

/*
* pccard.c - Interface code for PC-CARD controllers.
*
* June 1995, Andrew McRae (andrew@mega.com.au)
*-------------------------------------------------------------------------
*
2001-05-25 18:03:07 +00:00
* Copyright (c) 2001 M. Warner Losh. All rights reserved.
* Copyright (c) 1995 Andrew McRae. All rights reserved.
*
* 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
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
*
1999-08-28 01:08:13 +00:00
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/sysctl.h>
#include <sys/conf.h>
#include <sys/uio.h>
1997-09-14 03:19:42 +00:00
#include <sys/poll.h>
#include <sys/bus.h>
#include <sys/proc.h>
#include <machine/bus.h>
#include <pccard/cardinfo.h>
#include <pccard/driver.h>
1995-11-14 20:49:24 +00:00
#include <pccard/slot.h>
#include <pccard/pccard_nbk.h>
1995-11-14 20:49:24 +00:00
#include <machine/md_var.h>
#define MIN(a,b) ((a)<(b)?(a):(b))
static int allocate_driver(struct slot *, struct dev_desc *);
static void inserted(void *);
static void disable_slot(struct slot *);
2000-02-21 06:52:20 +00:00
static void disable_slot_to(struct slot *);
static void power_off_slot(void *);
/*
* The driver interface for read/write uses a block
* of memory in the ISA I/O memory space allocated via
* an ioctl setting.
2001-07-06 05:52:59 +00:00
*
* Now that we have different bus attachments, we should really
* use a better algorythm to allocate memory.
*/
static unsigned long pccard_mem; /* Physical memory */
static unsigned char *pccard_kmem; /* Kernel virtual address */
static struct resource *pccard_mem_res;
static int pccard_mem_rid;
static d_open_t crdopen;
static d_close_t crdclose;
static d_read_t crdread;
static d_write_t crdwrite;
static d_ioctl_t crdioctl;
1997-09-14 03:19:42 +00:00
static d_poll_t crdpoll;
#define CDEV_MAJOR 50
static struct cdevsw crd_cdevsw = {
/* open */ crdopen,
/* close */ crdclose,
/* read */ crdread,
/* write */ crdwrite,
/* ioctl */ crdioctl,
/* poll */ crdpoll,
/* mmap */ nommap,
/* strategy */ nostrategy,
/* name */ "crd",
/* maj */ CDEV_MAJOR,
/* dump */ nodump,
/* psize */ nopsize,
/* flags */ 0,
};
/*
* Power off the slot.
* (doing it immediately makes the removal of some cards unstable)
*/
static void
power_off_slot(void *arg)
{
struct slot *slt = (struct slot *)arg;
int s;
/*
* The following will generate an interrupt. So, to hold off
* the interrupt unitl after disable runs so that we can get rid
* rid of the interrupt before it becomes unsafe to touch the
* device.
2001-07-09 16:06:06 +00:00
*
* XXX In current, the spl stuff is a nop.
*/
s = splhigh();
/* Power off the slot. */
slt->pwr_off_pending = 0;
slt->ctrl->disable(slt);
splx(s);
}
/*
* disable_slot - Disables the slot by removing
* the power and unmapping the I/O
*/
static void
disable_slot(struct slot *slt)
{
device_t pccarddev;
device_t *kids;
int nkids;
int i;
int ret;
/*
* Note that a race condition is possible here; if a
* driver is accessing the device and it is removed, then
* all bets are off...
*/
pccarddev = slt->dev;
device_get_children(pccarddev, &kids, &nkids);
for (i = 0; i < nkids; i++) {
if ((ret = device_delete_child(pccarddev, kids[i])) != 0)
printf("pccard: delete of %s failed: %d\n",
device_get_nameunit(kids[i]), ret);
}
free(kids, M_TEMP);
/* Power off the slot 1/2 second after removal of the card */
slt->poff_ch = timeout(power_off_slot, (caddr_t)slt, hz / 2);
slt->pwr_off_pending = 1;
}
static void
2000-02-21 06:52:20 +00:00
disable_slot_to(struct slot *slt)
{
disable_slot(slt);
if (slt->state == empty)
printf("pccard: card removed, slot %d\n", slt->slotnum);
else
printf("pccard: card deactivated, slot %d\n", slt->slotnum);
pccard_remove_beep();
selwakeup(&slt->selp);
}
/*
* pccard_init_slot - Initialize the slot controller and attach various
* things to it. We also make the device for it. We create the device that
* will be exported to devfs.
*/
struct slot *
pccard_init_slot(device_t dev, struct slot_ctrl *ctrl)
{
int slotno;
struct slot *slt;
slt = PCCARD_DEVICE2SOFTC(dev);
slotno = device_get_unit(dev);
slt->dev = dev;
slt->d = make_dev(&crd_cdevsw, slotno, 0, 0, 0600, "card%d", slotno);
slt->d->si_drv1 = slt;
slt->ctrl = ctrl;
slt->slotnum = slotno;
callout_handle_init(&slt->insert_ch);
callout_handle_init(&slt->poff_ch);
return (slt);
}
/*
* allocate_driver - Create a new device entry for this
* slot, and attach a driver to it.
*/
static int
allocate_driver(struct slot *slt, struct dev_desc *desc)
{
struct pccard_devinfo *devi;
device_t pccarddev;
int err, irq = 0;
device_t child;
device_t *devs;
int count;
pccarddev = slt->dev;
err = device_get_children(pccarddev, &devs, &count);
if (err != 0)
return (err);
free(devs, M_TEMP);
if (count) {
device_printf(pccarddev,
"Can not attach more than one child.\n");
return (EIO);
}
irq = ffs(desc->irqmask) - 1;
MALLOC(devi, struct pccard_devinfo *, sizeof(*devi), M_DEVBUF,
M_WAITOK | M_ZERO);
strcpy(devi->name, desc->name);
/*
* Create an entry for the device under this slot.
*/
devi->running = 1;
devi->slt = slt;
bcopy(desc->misc, devi->misc, sizeof(desc->misc));
devi->manufacturer = desc->manufacturer;
devi->product = desc->product;
devi->prodext = desc->prodext;
resource_list_init(&devi->resources);
child = device_add_child(pccarddev, devi->name, desc->unit);
if (child == NULL) {
if (desc->unit != -1)
device_printf(pccarddev,
"Unit %d failed for %s, try a different unit\n",
desc->unit, devi->name);
else
device_printf(pccarddev,
"No units available for %s. Impossible?\n",
devi->name);
return (EIO);
}
device_set_flags(child, desc->flags);
device_set_ivars(child, devi);
if (bootverbose) {
device_printf(pccarddev,
"Assigning %s: io 0x%x-0x%x irq %d mem 0x%lx-0x%lx\n",
device_get_nameunit(child),
desc->iobase, desc->iobase + desc->iosize - 1,
irq, desc->mem, desc->mem + desc->memsize - 1);
}
err = bus_set_resource(child, SYS_RES_IOPORT, 0, desc->iobase,
desc->iosize);
if (err)
goto err;
if (irq)
err = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
if (err)
goto err;
if (desc->memsize) {
err = bus_set_resource(child, SYS_RES_MEMORY, 0, desc->mem,
desc->memsize);
if (err)
goto err;
}
err = device_probe_and_attach(child);
/*
* XXX We unwisely assume that the detach code won't run while the
* XXX the attach code is attaching. Someone should put some
* XXX interlock code. This can happen if probe/attach takes a while
* XXX and the user ejects the card, which causes the detach
* XXX function to be called.
*/
strncpy(desc->name, device_get_nameunit(child), sizeof(desc->name));
desc->name[sizeof(desc->name) - 1] = '\0';
err:
if (err)
device_delete_child(pccarddev, child);
return (err);
}
/*
* card insert routine - Called from a timeout to debounce
* insertion events.
*/
static void
inserted(void *arg)
{
struct slot *slt = arg;
slt->state = filled;
/*
* Disable any pending timeouts for this slot, and explicitly
* power it off right now. Then, re-enable the power using
* the (possibly new) power settings.
*/
untimeout(power_off_slot, (caddr_t)slt, slt->poff_ch);
power_off_slot(slt);
What: o ToPIC is happy with two cards now, even when the two cards are modems. o Fix (all?) hangs on boot when power is applied to the card. I suspect that this will make the Ricoh bridges happier and also make a lot of VAIO owners happy (confirm to me in private email please :-). o All Cardbus bridges should now support 3.3V, X.XV and Y.YV cards, to the extent that the underlying hardware supports such cards. (X.X and Y.Y haven't been assigned values yet :-). o Better 3.3V support for Ricoh ISA bridges. How: o Don't mess with the power register when scanning the cards. It is unnecessary and causes BADVcc conditions on many chipsets. These in turn can cause an interrupt storm. o Make pcic_disable reset the slot's voltage. o Move initializing voltage for the slot until after it has been disabled. o Fix a lot of issues with the pcic_cardbus_power routine. We now properly enable the card and take it out of reset after a power change. o When detecting the card's voltage, if we're in a BadVcc state, direct the bridge to rescan the card for what it supports. (we might need to in the future set the power register to 0 before doing this). o Don't preserve CLKSTOP. need to revisit this. o Better support for Ricoh ISA bridges for 3.3V cards. o Don't write to PCIC_POWER directly as offten, but instead go through the pcic_power interface. o All cardbus bridges now default to use cardbus power control. o Add misc register definitions. o remove some (now) bogus comments. Extra Special Thanks To: Scott Lamber for his kind and generous loan of a Toshiba laptop with a ToPIC 100 in it for my use.
2002-06-23 01:55:10 +00:00
/*
* Enable 5V to the card so that the CIS can be read. Well,
* enable the most natural voltage so that the CIS can be read.
*/
slt->pwr.vcc = -1;
slt->pwr.vpp = -1;
slt->ctrl->power(slt);
printf("pccard: card inserted, slot %d\n", slt->slotnum);
pccard_insert_beep();
slt->ctrl->reset(slt);
}
/*
* Card event callback. Called at splhigh to prevent
* device interrupts from interceding.
*/
void
pccard_event(struct slot *slt, enum card_event event)
{
if (slt->insert_seq) {
slt->insert_seq = 0;
untimeout(inserted, (void *)slt, slt->insert_ch);
}
switch(event) {
case card_removed:
case card_deactivated:
if (slt->state == filled || slt->state == inactive) {
if (event == card_removed)
slt->state = empty;
else
slt->state = inactive;
2000-02-21 06:52:20 +00:00
disable_slot_to(slt);
}
break;
case card_inserted:
slt->insert_seq = 1;
slt->insert_ch = timeout(inserted, (void *)slt, hz/4);
break;
}
}
/*
* Device driver interface.
*/
static int
crdopen(dev_t dev, int oflags, int devtype, d_thread_t *td)
{
struct slot *slt = PCCARD_DEV2SOFTC(dev);
if (slt == NULL)
return (ENXIO);
if (slt->rwmem == 0)
slt->rwmem = MDF_ATTR;
return (0);
}
/*
* Close doesn't de-allocate any resources, since
* slots may be assigned to drivers already.
*/
static int
crdclose(dev_t dev, int fflag, int devtype, d_thread_t *td)
{
return (0);
}
/*
* read interface. Map memory at lseek offset,
* then transfer to user space.
*/
static int
crdread(dev_t dev, struct uio *uio, int ioflag)
{
struct slot *slt = PCCARD_DEV2SOFTC(dev);
struct mem_desc *mp, oldmap;
unsigned char *p;
unsigned int offs;
int error = 0, win, count;
if (slt == 0 || slt->state != filled)
return (ENXIO);
if (pccard_mem == 0)
return (ENOMEM);
for (win = 0; win < slt->ctrl->maxmem; win++)
if ((slt->mem[win].flags & MDF_ACTIVE) == 0)
break;
if (win >= slt->ctrl->maxmem)
return (EBUSY);
mp = &slt->mem[win];
oldmap = *mp;
2001-07-01 23:40:19 +00:00
mp->flags = slt->rwmem | MDF_ACTIVE;
while (uio->uio_resid && error == 0) {
mp->card = uio->uio_offset;
mp->size = PCCARD_MEMSIZE;
mp->start = (caddr_t)(void *)(uintptr_t)pccard_mem;
if ((error = slt->ctrl->mapmem(slt, win)) != 0)
break;
offs = (unsigned int)uio->uio_offset & (PCCARD_MEMSIZE - 1);
p = pccard_kmem + offs;
count = MIN(PCCARD_MEMSIZE - offs, uio->uio_resid);
error = uiomove(p, count, uio);
}
/*
* Restore original map.
*/
*mp = oldmap;
slt->ctrl->mapmem(slt, win);
return (error);
}
/*
* crdwrite - Write data to card memory.
* Handles wrap around so that only one memory
* window is used.
*/
static int
crdwrite(dev_t dev, struct uio *uio, int ioflag)
{
struct slot *slt = PCCARD_DEV2SOFTC(dev);
struct mem_desc *mp, oldmap;
unsigned char *p;
unsigned int offs;
int error = 0, win, count;
if (slt == 0 || slt->state != filled)
return (ENXIO);
if (pccard_mem == 0)
return (ENOMEM);
for (win = 0; win < slt->ctrl->maxmem; win++)
if ((slt->mem[win].flags & MDF_ACTIVE) == 0)
break;
if (win >= slt->ctrl->maxmem)
return (EBUSY);
mp = &slt->mem[win];
oldmap = *mp;
2001-06-04 03:13:45 +00:00
mp->flags = slt->rwmem | MDF_ACTIVE;
while (uio->uio_resid && error == 0) {
mp->card = uio->uio_offset;
mp->size = PCCARD_MEMSIZE;
mp->start = (caddr_t)(void *)(uintptr_t)pccard_mem;
if ((error = slt->ctrl->mapmem(slt, win)) != 0)
break;
offs = (unsigned int)uio->uio_offset & (PCCARD_MEMSIZE - 1);
p = pccard_kmem + offs;
count = MIN(PCCARD_MEMSIZE - offs, uio->uio_resid);
error = uiomove(p, count, uio);
}
/*
* Restore original map.
*/
*mp = oldmap;
slt->ctrl->mapmem(slt, win);
return (error);
}
/*
* ioctl calls - allows setting/getting of memory and I/O
* descriptors, and assignment of drivers.
*/
static int
crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, d_thread_t *td)
{
u_int32_t addr;
int err;
struct io_desc *ip;
struct mem_desc *mp;
device_t pccarddev;
int pwval;
int s;
struct slot *slt = PCCARD_DEV2SOFTC(dev);
if (slt == 0 && cmd != PIOCRWMEM)
return (ENXIO);
switch(cmd) {
default:
if (slt->ctrl->ioctl)
return (slt->ctrl->ioctl(slt, cmd, data));
return (ENOTTY);
/*
* Get slot state.
*/
case PIOCGSTATE:
s = splhigh();
((struct slotstate *)data)->state = slt->state;
((struct slotstate *)data)->laststate = slt->laststate;
slt->laststate = slt->state;
splx(s);
((struct slotstate *)data)->maxmem = slt->ctrl->maxmem;
((struct slotstate *)data)->maxio = slt->ctrl->maxio;
((struct slotstate *)data)->irqs = 0;
break;
/*
* Get memory context.
*/
case PIOCGMEM:
s = ((struct mem_desc *)data)->window;
if (s < 0 || s >= slt->ctrl->maxmem)
return (EINVAL);
mp = &slt->mem[s];
((struct mem_desc *)data)->flags = mp->flags;
((struct mem_desc *)data)->start = mp->start;
((struct mem_desc *)data)->size = mp->size;
((struct mem_desc *)data)->card = mp->card;
break;
/*
* Set memory context. If context already active, then unmap it.
* It is hard to see how the parameters can be checked.
* At the very least, we only allow root to set the context.
*/
case PIOCSMEM:
if (suser(td))
return (EPERM);
if (slt->state != filled)
return (ENXIO);
s = ((struct mem_desc *)data)->window;
if (s < 0 || s >= slt->ctrl->maxmem)
return (EINVAL);
slt->mem[s] = *((struct mem_desc *)data);
return (slt->ctrl->mapmem(slt, s));
/*
* Get I/O port context.
*/
case PIOCGIO:
s = ((struct io_desc *)data)->window;
if (s < 0 || s >= slt->ctrl->maxio)
return (EINVAL);
ip = &slt->io[s];
((struct io_desc *)data)->flags = ip->flags;
((struct io_desc *)data)->start = ip->start;
((struct io_desc *)data)->size = ip->size;
break;
/*
* Set I/O port context.
*/
case PIOCSIO:
if (suser(td))
return (EPERM);
if (slt->state != filled)
return (ENXIO);
s = ((struct io_desc *)data)->window;
if (s < 0 || s >= slt->ctrl->maxio)
return (EINVAL);
slt->io[s] = *((struct io_desc *)data);
/* XXX Don't actually map */
return (0);
break;
/*
* Set memory window flags for read/write interface.
*/
case PIOCRWFLAG:
slt->rwmem = *(int *)data;
break;
/*
* Set the memory window to be used for the read/write interface.
*/
case PIOCRWMEM:
if (*(unsigned long *)data == 0) {
*(unsigned long *)data = pccard_mem;
break;
}
if (suser(td))
return (EPERM);
/*
* Validate the memory by checking it against the I/O
* memory range. It must also start on an aligned block size.
*/
if (*(unsigned long *)data & (PCCARD_MEMSIZE-1))
return (EINVAL);
pccarddev = PCCARD_DEV2SOFTC(dev)->dev;
pccard_mem_rid = 0;
addr = *(unsigned long *)data;
if (pccard_mem_res)
bus_release_resource(pccarddev, SYS_RES_MEMORY,
pccard_mem_rid, pccard_mem_res);
pccard_mem_res = bus_alloc_resource(pccarddev, SYS_RES_MEMORY,
&pccard_mem_rid, addr, addr, PCCARD_MEMSIZE,
RF_ACTIVE | rman_make_alignment_flags(PCCARD_MEMSIZE));
if (pccard_mem_res == NULL)
return (EINVAL);
pccard_mem = rman_get_start(pccard_mem_res);
pccard_kmem = rman_get_virtual(pccard_mem_res);
break;
/*
* Set power values.
*/
case PIOCSPOW:
slt->pwr = *(struct power *)data;
return (slt->ctrl->power(slt));
/*
* Allocate a driver to this slot.
*/
case PIOCSDRV:
if (suser(td))
return (EPERM);
err = allocate_driver(slt, (struct dev_desc *)data);
if (!err)
pccard_success_beep();
else
pccard_failure_beep();
return (err);
1999-12-02 05:46:22 +00:00
/*
* Virtual removal/insertion
*/
case PIOCSVIR:
pwval = *(int *)data;
if (!pwval) {
if (slt->state != filled)
return (EINVAL);
pccard_event(slt, card_deactivated);
1999-12-02 05:46:22 +00:00
} else {
if (slt->state != empty && slt->state != inactive)
return (EINVAL);
pccard_event(slt, card_inserted);
1999-12-02 05:46:22 +00:00
}
break;
case PIOCSBEEP:
if (pccard_beep_select(*(int *)data)) {
return (EINVAL);
}
break;
}
return (0);
}
/*
1997-09-14 03:19:42 +00:00
* poll - Poll on exceptions will return true
* when a change in card status occurs.
*/
static int
crdpoll(dev_t dev, int events, d_thread_t *td)
{
int revents = 0;
int s;
struct slot *slt = PCCARD_DEV2SOFTC(dev);
1997-09-14 03:19:42 +00:00
if (events & (POLLIN | POLLRDNORM))
revents |= events & (POLLIN | POLLRDNORM);
if (events & (POLLOUT | POLLWRNORM))
revents |= events & (POLLIN | POLLRDNORM);
s = splhigh();
/*
* select for exception - card event.
*/
1997-09-14 03:19:42 +00:00
if (events & POLLRDBAND)
if (slt == 0 || slt->laststate != slt->state)
1997-09-14 03:19:42 +00:00
revents |= POLLRDBAND;
if (revents == 0)
selrecord(td, &slt->selp);
1997-09-14 03:19:42 +00:00
splx(s);
return (revents);
}
/*
* APM hooks for suspending and resuming.
*/
int
pccard_suspend(device_t dev)
{
struct slot *slt = PCCARD_DEVICE2SOFTC(dev);
/* This code stolen from pccard_event:card_removed */
if (slt->state == filled) {
int s = splhigh(); /* nop on current */
disable_slot(slt);
slt->laststate = suspend; /* for pccardd */
slt->state = empty;
splx(s);
printf("pccard: card disabled, slot %d\n", slt->slotnum);
}
/*
* Disable any pending timeouts for this slot since we're
* powering it down/disabling now.
*/
untimeout(power_off_slot, (caddr_t)slt, slt->poff_ch);
slt->ctrl->disable(slt);
return (0);
}
int
pccard_resume(device_t dev)
{
struct slot *slt = PCCARD_DEVICE2SOFTC(dev);
slt->ctrl->resume(slt);
return (0);
}