fix i4l patches

[openwrt.git] / package / linux / kernel-source / drivers / pcmcia / bcm4710_generic.c

/*
 *
 * bcm47xx pcmcia driver
 *
 * Copyright 2004, Broadcom Corporation
 * All Rights Reserved.
 * 
 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
 *
 * Based on sa1100_generic.c from www.handhelds.org,
 *      and au1000_generic.c from oss.sgi.com.
 *
 * $Id$
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/config.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/tqueue.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/version.h>
#include <linux/types.h>
#include <linux/vmalloc.h>

#include <pcmcia/version.h>
#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
#include <pcmcia/ss.h>
#include <pcmcia/bulkmem.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/bus_ops.h>
#include "cs_internal.h"

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/system.h>

#include <typedefs.h>
#include <bcm4710.h>
#include <sbextif.h>

#include "bcm4710pcmcia.h"

#ifdef PCMCIA_DEBUG
static int pc_debug = PCMCIA_DEBUG;
#endif

MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm47xx Socket Controller");

/* This structure maintains housekeeping state for each socket, such
 * as the last known values of the card detect pins, or the Card Services
 * callback value associated with the socket:
 */
static struct bcm47xx_pcmcia_socket *pcmcia_socket;
static int socket_count;


/* Returned by the low-level PCMCIA interface: */
static struct pcmcia_low_level *pcmcia_low_level;

/* Event poll timer structure */
static struct timer_list poll_timer;


/* Prototypes for routines which are used internally: */

static int  bcm47xx_pcmcia_driver_init(void);
static void bcm47xx_pcmcia_driver_shutdown(void);
static void bcm47xx_pcmcia_task_handler(void *data);
static void bcm47xx_pcmcia_poll_event(unsigned long data);
static void bcm47xx_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs);
static struct tq_struct bcm47xx_pcmcia_task;

#ifdef CONFIG_PROC_FS
static int bcm47xx_pcmcia_proc_status(char *buf, char **start, 
                off_t pos, int count, int *eof, void *data);
#endif


/* Prototypes for operations which are exported to the
 * in-kernel PCMCIA core:
 */

static int bcm47xx_pcmcia_init(unsigned int sock);
static int bcm47xx_pcmcia_suspend(unsigned int sock);
static int bcm47xx_pcmcia_register_callback(unsigned int sock, 
                void (*handler)(void *, unsigned int), void *info);
static int bcm47xx_pcmcia_inquire_socket(unsigned int sock, socket_cap_t *cap);
static int bcm47xx_pcmcia_get_status(unsigned int sock, u_int *value);
static int bcm47xx_pcmcia_get_socket(unsigned int sock, socket_state_t *state);
static int bcm47xx_pcmcia_set_socket(unsigned int sock, socket_state_t *state);
static int bcm47xx_pcmcia_get_io_map(unsigned int sock, struct pccard_io_map *io);
static int bcm47xx_pcmcia_set_io_map(unsigned int sock, struct pccard_io_map *io);
static int bcm47xx_pcmcia_get_mem_map(unsigned int sock, struct pccard_mem_map *mem);
static int bcm47xx_pcmcia_set_mem_map(unsigned int sock, struct pccard_mem_map *mem);
#ifdef CONFIG_PROC_FS
static void bcm47xx_pcmcia_proc_setup(unsigned int sock, struct proc_dir_entry *base);
#endif

static struct pccard_operations bcm47xx_pcmcia_operations = {
        bcm47xx_pcmcia_init,
        bcm47xx_pcmcia_suspend,
        bcm47xx_pcmcia_register_callback,
        bcm47xx_pcmcia_inquire_socket,
        bcm47xx_pcmcia_get_status,
        bcm47xx_pcmcia_get_socket,
        bcm47xx_pcmcia_set_socket,
        bcm47xx_pcmcia_get_io_map,
        bcm47xx_pcmcia_set_io_map,
        bcm47xx_pcmcia_get_mem_map,
        bcm47xx_pcmcia_set_mem_map,
#ifdef CONFIG_PROC_FS
        bcm47xx_pcmcia_proc_setup
#endif
};


/*
 * bcm47xx_pcmcia_driver_init()
 *
 * This routine performs a basic sanity check to ensure that this
 * kernel has been built with the appropriate board-specific low-level
 * PCMCIA support, performs low-level PCMCIA initialization, registers
 * this socket driver with Card Services, and then spawns the daemon
 * thread which is the real workhorse of the socket driver.
 *
 * Please see linux/Documentation/arm/SA1100/PCMCIA for more information
 * on the low-level kernel interface.
 *
 * Returns: 0 on success, -1 on error
 */
static int __init bcm47xx_pcmcia_driver_init(void)
{
        servinfo_t info;
        struct pcmcia_init pcmcia_init;
        struct pcmcia_state state;
        unsigned int i;
        unsigned long tmp;


        printk("\nBCM47XX PCMCIA (CS release %s)\n", CS_RELEASE);

        CardServices(GetCardServicesInfo, &info);

        if (info.Revision != CS_RELEASE_CODE) {
                printk(KERN_ERR "Card Services release codes do not match\n");
                return -1;
        }

#ifdef CONFIG_BCM4710
        pcmcia_low_level=&bcm4710_pcmcia_ops;
#else
#error Unsupported Broadcom BCM47XX board.
#endif

        pcmcia_init.handler=bcm47xx_pcmcia_interrupt;

        if ((socket_count = pcmcia_low_level->init(&pcmcia_init)) < 0) {
                printk(KERN_ERR "Unable to initialize PCMCIA service.\n");
                return -EIO;
        } else {
                printk("\t%d PCMCIA sockets initialized.\n", socket_count);
        }

        pcmcia_socket = 
                kmalloc(sizeof(struct bcm47xx_pcmcia_socket) * socket_count, 
                                GFP_KERNEL);
        memset(pcmcia_socket, 0, 
                        sizeof(struct bcm47xx_pcmcia_socket) * socket_count);
        if (!pcmcia_socket) {
                printk(KERN_ERR "Card Services can't get memory \n");
                return -1;
        }
                        
        for (i = 0; i < socket_count; i++) {
                if (pcmcia_low_level->socket_state(i, &state) < 0) {
                        printk(KERN_ERR "Unable to get PCMCIA status\n");
                        return -EIO;
                }
                pcmcia_socket[i].k_state = state;
                pcmcia_socket[i].cs_state.csc_mask = SS_DETECT;
                
                if (i == 0) {
                        pcmcia_socket[i].virt_io =
                                (unsigned long)ioremap_nocache(EXTIF_PCMCIA_IOBASE(BCM4710_EXTIF), 0x1000);
                        /* Substract ioport base which gets added by in/out */
                        pcmcia_socket[i].virt_io -= mips_io_port_base;
                        pcmcia_socket[i].phys_attr =
                                (unsigned long)EXTIF_PCMCIA_CFGBASE(BCM4710_EXTIF);
                        pcmcia_socket[i].phys_mem =
                                (unsigned long)EXTIF_PCMCIA_MEMBASE(BCM4710_EXTIF);
                } else  {
                        printk(KERN_ERR "bcm4710: socket 1 not supported\n");
                        return 1;
                }
        }

        /* Only advertise as many sockets as we can detect: */
        if (register_ss_entry(socket_count, &bcm47xx_pcmcia_operations) < 0) {
                printk(KERN_ERR "Unable to register socket service routine\n");
                return -ENXIO;
        }

        /* Start the event poll timer.  
         * It will reschedule by itself afterwards. 
         */
        bcm47xx_pcmcia_poll_event(0);

        DEBUG(1, "bcm4710: initialization complete\n");
        return 0;

}

module_init(bcm47xx_pcmcia_driver_init);


/*
 * bcm47xx_pcmcia_driver_shutdown()
 *
 * Invokes the low-level kernel service to free IRQs associated with this
 * socket controller and reset GPIO edge detection.
 */
static void __exit bcm47xx_pcmcia_driver_shutdown(void)
{
        int i;

        del_timer_sync(&poll_timer);
        unregister_ss_entry(&bcm47xx_pcmcia_operations);
        pcmcia_low_level->shutdown();
        flush_scheduled_tasks();
        for (i = 0; i < socket_count; i++) {
                if (pcmcia_socket[i].virt_io) 
                        iounmap((void *)pcmcia_socket[i].virt_io);
                if (pcmcia_socket[i].phys_attr) 
                        iounmap((void *)pcmcia_socket[i].phys_attr);
                if (pcmcia_socket[i].phys_mem) 
                        iounmap((void *)pcmcia_socket[i].phys_mem);
        }
        DEBUG(1, "bcm4710: shutdown complete\n");
}

module_exit(bcm47xx_pcmcia_driver_shutdown);

/*
 * bcm47xx_pcmcia_init()
 * We perform all of the interesting initialization tasks in 
 * bcm47xx_pcmcia_driver_init().
 *
 * Returns: 0
 */
static int bcm47xx_pcmcia_init(unsigned int sock)
{
        DEBUG(1, "%s(): initializing socket %u\n", __FUNCTION__, sock);

        return 0;
}

/*
 * bcm47xx_pcmcia_suspend()
 *
 * We don't currently perform any actions on a suspend.
 *
 * Returns: 0
 */
static int bcm47xx_pcmcia_suspend(unsigned int sock)
{
        DEBUG(1, "%s(): suspending socket %u\n", __FUNCTION__, sock);

        return 0;
}


/*
 * bcm47xx_pcmcia_events()
 *
 * Helper routine to generate a Card Services event mask based on
 * state information obtained from the kernel low-level PCMCIA layer
 * in a recent (and previous) sampling. Updates `prev_state'.
 *
 * Returns: an event mask for the given socket state.
 */
static inline unsigned 
bcm47xx_pcmcia_events(struct pcmcia_state *state, 
                struct pcmcia_state *prev_state, 
                unsigned int mask, unsigned int flags)
{
        unsigned int events=0;

        if (state->bvd1 != prev_state->bvd1) {

                DEBUG(3, "%s(): card BVD1 value %u\n", __FUNCTION__, state->bvd1);

                events |= mask & (flags & SS_IOCARD) ? SS_STSCHG : SS_BATDEAD;
        }

        if (state->bvd2 != prev_state->bvd2) {

                DEBUG(3, "%s(): card BVD2 value %u\n", __FUNCTION__, state->bvd2);

                events |= mask & (flags & SS_IOCARD) ? 0 : SS_BATWARN;
        }

        if (state->detect != prev_state->detect) {

                DEBUG(3, "%s(): card detect value %u\n", __FUNCTION__, state->detect);

                events |= mask & SS_DETECT;
        }


        if (state->ready != prev_state->ready) {

                DEBUG(3, "%s(): card ready value %u\n", __FUNCTION__, state->ready);

                events |= mask & ((flags & SS_IOCARD) ? 0 : SS_READY);
        }

        if (events != 0) {
                DEBUG(2, "events: %s%s%s%s%s\n",
                      (events & SS_DETECT) ? "DETECT " : "",
                      (events & SS_READY) ? "READY " : "",
                      (events & SS_BATDEAD) ? "BATDEAD " : "",
                      (events & SS_BATWARN) ? "BATWARN " : "",
                      (events & SS_STSCHG) ? "STSCHG " : "");
        }

        *prev_state=*state;
        return events;
}


/* 
 * bcm47xx_pcmcia_task_handler()
 *
 * Processes serviceable socket events using the "eventd" thread context.
 *
 * Event processing (specifically, the invocation of the Card Services event
 * callback) occurs in this thread rather than in the actual interrupt
 * handler due to the use of scheduling operations in the PCMCIA core.
 */
static void bcm47xx_pcmcia_task_handler(void *data) 
{
        struct pcmcia_state state;
        int i, events, irq_status;

        DEBUG(4, "%s(): entering PCMCIA monitoring thread\n", __FUNCTION__);

        for (i = 0; i < socket_count; i++)  {
                if ((irq_status = pcmcia_low_level->socket_state(i, &state)) < 0)
                        printk(KERN_ERR "Error in kernel low-level PCMCIA service.\n");

                events = bcm47xx_pcmcia_events(&state, 
                                               &pcmcia_socket[i].k_state, 
                                               pcmcia_socket[i].cs_state.csc_mask, 
                                               pcmcia_socket[i].cs_state.flags);

                if (pcmcia_socket[i].handler != NULL) {
                        pcmcia_socket[i].handler(pcmcia_socket[i].handler_info,
                                                 events);
                }
        }
}

static struct tq_struct bcm47xx_pcmcia_task = {
        routine: bcm47xx_pcmcia_task_handler
};


/*
 * bcm47xx_pcmcia_poll_event()
 *
 * Let's poll for events in addition to IRQs since IRQ only is unreliable...
 */
static void bcm47xx_pcmcia_poll_event(unsigned long dummy)
{
        DEBUG(4, "%s(): polling for events\n", __FUNCTION__);

        poll_timer.function = bcm47xx_pcmcia_poll_event;
        poll_timer.expires = jiffies + BCM47XX_PCMCIA_POLL_PERIOD;
        add_timer(&poll_timer);
        schedule_task(&bcm47xx_pcmcia_task);
}


/* 
 * bcm47xx_pcmcia_interrupt()
 *
 * Service routine for socket driver interrupts (requested by the
 * low-level PCMCIA init() operation via bcm47xx_pcmcia_thread()).
 *
 * The actual interrupt-servicing work is performed by
 * bcm47xx_pcmcia_task(), largely because the Card Services event-
 * handling code performs scheduling operations which cannot be
 * executed from within an interrupt context.
 */
static void 
bcm47xx_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
{
        DEBUG(3, "%s(): servicing IRQ %d\n", __FUNCTION__, irq);
        schedule_task(&bcm47xx_pcmcia_task);
}


/*
 * bcm47xx_pcmcia_register_callback()
 *
 * Implements the register_callback() operation for the in-kernel
 * PCMCIA service (formerly SS_RegisterCallback in Card Services). If 
 * the function pointer `handler' is not NULL, remember the callback 
 * location in the state for `sock', and increment the usage counter 
 * for the driver module. (The callback is invoked from the interrupt
 * service routine, bcm47xx_pcmcia_interrupt(), to notify Card Services
 * of interesting events.) Otherwise, clear the callback pointer in the
 * socket state and decrement the module usage count.
 *
 * Returns: 0
 */
static int 
bcm47xx_pcmcia_register_callback(unsigned int sock, 
                void (*handler)(void *, unsigned int), void *info)
{
        if (handler == NULL) {
                pcmcia_socket[sock].handler = NULL;
                MOD_DEC_USE_COUNT;
        } else {
                MOD_INC_USE_COUNT;
                pcmcia_socket[sock].handler = handler;
                pcmcia_socket[sock].handler_info = info;
        }
        return 0;
}


/*
 * bcm47xx_pcmcia_inquire_socket()
 *
 * Implements the inquire_socket() operation for the in-kernel PCMCIA
 * service (formerly SS_InquireSocket in Card Services). Of note is
 * the setting of the SS_CAP_PAGE_REGS bit in the `features' field of
 * `cap' to "trick" Card Services into tolerating large "I/O memory" 
 * addresses. Also set is SS_CAP_STATIC_MAP, which disables the memory
 * resource database check. (Mapped memory is set up within the socket
 * driver itself.)
 *
 * In conjunction with the STATIC_MAP capability is a new field,
 * `io_offset', recommended by David Hinds. Rather than go through
 * the SetIOMap interface (which is not quite suited for communicating
 * window locations up from the socket driver), we just pass up
 * an offset which is applied to client-requested base I/O addresses
 * in alloc_io_space().
 *
 * Returns: 0 on success, -1 if no pin has been configured for `sock'
 */
static int
bcm47xx_pcmcia_inquire_socket(unsigned int sock, socket_cap_t *cap)
{
        struct pcmcia_irq_info irq_info;

        if (sock >= socket_count) {
                printk(KERN_ERR "bcm47xx: socket %u not configured\n", sock);
                return -1;
        }

        /* SS_CAP_PAGE_REGS: used by setup_cis_mem() in cistpl.c to set the
         *   force_low argument to validate_mem() in rsrc_mgr.c -- since in
         *   general, the mapped * addresses of the PCMCIA memory regions
         *   will not be within 0xffff, setting force_low would be
         *   undesirable.
         *
         * SS_CAP_STATIC_MAP: don't bother with the (user-configured) memory
         *   resource database; we instead pass up physical address ranges
         *   and allow other parts of Card Services to deal with remapping.
         *
         * SS_CAP_PCCARD: we can deal with 16-bit PCMCIA & CF cards, but
         *   not 32-bit CardBus devices.
         */
        cap->features = (SS_CAP_PAGE_REGS  | SS_CAP_STATIC_MAP | SS_CAP_PCCARD);

        irq_info.sock = sock;
        irq_info.irq = -1;

        if (pcmcia_low_level->get_irq_info(&irq_info) < 0) {
                printk(KERN_ERR "Error obtaining IRQ info socket %u\n", sock);
                return -1;
        }

        cap->irq_mask = 0;
        cap->map_size = PAGE_SIZE;
        cap->pci_irq = irq_info.irq;
        cap->io_offset = pcmcia_socket[sock].virt_io;

        return 0;
}


/*
 * bcm47xx_pcmcia_get_status()
 *
 * Implements the get_status() operation for the in-kernel PCMCIA
 * service (formerly SS_GetStatus in Card Services). Essentially just
 * fills in bits in `status' according to internal driver state or
 * the value of the voltage detect chipselect register.
 *
 * As a debugging note, during card startup, the PCMCIA core issues
 * three set_socket() commands in a row the first with RESET deasserted,
 * the second with RESET asserted, and the last with RESET deasserted
 * again. Following the third set_socket(), a get_status() command will
 * be issued. The kernel is looking for the SS_READY flag (see
 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 *
 * Returns: 0
 */
static int 
bcm47xx_pcmcia_get_status(unsigned int sock, unsigned int *status)
{
        struct pcmcia_state state;


        if ((pcmcia_low_level->socket_state(sock, &state)) < 0) {
                printk(KERN_ERR "Unable to get PCMCIA status from kernel.\n");
                return -1;
        }

        pcmcia_socket[sock].k_state = state;

        *status = state.detect ? SS_DETECT : 0;

        *status |= state.ready ? SS_READY : 0;

        /* The power status of individual sockets is not available
         * explicitly from the hardware, so we just remember the state
         * and regurgitate it upon request:
         */
        *status |= pcmcia_socket[sock].cs_state.Vcc ? SS_POWERON : 0;

        if (pcmcia_socket[sock].cs_state.flags & SS_IOCARD)
                *status |= state.bvd1 ? SS_STSCHG : 0;
        else {
                if (state.bvd1 == 0)
                        *status |= SS_BATDEAD;
                else if (state.bvd2 == 0)
                        *status |= SS_BATWARN;
        }

        *status |= state.vs_3v ? SS_3VCARD : 0;

        *status |= state.vs_Xv ? SS_XVCARD : 0;

        DEBUG(2, "\tstatus: %s%s%s%s%s%s%s%s\n",
              (*status&SS_DETECT)?"DETECT ":"",
              (*status&SS_READY)?"READY ":"", 
              (*status&SS_BATDEAD)?"BATDEAD ":"",
              (*status&SS_BATWARN)?"BATWARN ":"",
              (*status&SS_POWERON)?"POWERON ":"",
              (*status&SS_STSCHG)?"STSCHG ":"",
              (*status&SS_3VCARD)?"3VCARD ":"",
              (*status&SS_XVCARD)?"XVCARD ":"");

        return 0;
}


/*
 * bcm47xx_pcmcia_get_socket()
 *
 * Implements the get_socket() operation for the in-kernel PCMCIA
 * service (formerly SS_GetSocket in Card Services). Not a very 
 * exciting routine.
 *
 * Returns: 0
 */
static int 
bcm47xx_pcmcia_get_socket(unsigned int sock, socket_state_t *state)
{
        DEBUG(2, "%s() for sock %u\n", __FUNCTION__, sock);

        /* This information was given to us in an earlier call to set_socket(),
         * so we're just regurgitating it here:
         */
        *state = pcmcia_socket[sock].cs_state;
        return 0;
}


/*
 * bcm47xx_pcmcia_set_socket()
 *
 * Implements the set_socket() operation for the in-kernel PCMCIA
 * service (formerly SS_SetSocket in Card Services). We more or
 * less punt all of this work and let the kernel handle the details
 * of power configuration, reset, &c. We also record the value of
 * `state' in order to regurgitate it to the PCMCIA core later.
 *
 * Returns: 0
 */
static int 
bcm47xx_pcmcia_set_socket(unsigned int sock, socket_state_t *state)
{
        struct pcmcia_configure configure;

        DEBUG(2, "\tmask:  %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n"
              "\tVcc %d  Vpp %d  irq %d\n",
              (state->csc_mask == 0) ? "<NONE>" : "",
              (state->csc_mask & SS_DETECT) ? "DETECT " : "",
              (state->csc_mask & SS_READY) ? "READY " : "",
              (state->csc_mask & SS_BATDEAD) ? "BATDEAD " : "",
              (state->csc_mask & SS_BATWARN) ? "BATWARN " : "",
              (state->csc_mask & SS_STSCHG) ? "STSCHG " : "",
              (state->flags == 0) ? "<NONE>" : "",
              (state->flags & SS_PWR_AUTO) ? "PWR_AUTO " : "",
              (state->flags & SS_IOCARD) ? "IOCARD " : "",
              (state->flags & SS_RESET) ? "RESET " : "",
              (state->flags & SS_SPKR_ENA) ? "SPKR_ENA " : "",
              (state->flags & SS_OUTPUT_ENA) ? "OUTPUT_ENA " : "",
              state->Vcc, state->Vpp, state->io_irq);

        configure.sock = sock;
        configure.vcc = state->Vcc;
        configure.vpp = state->Vpp;
        configure.output = (state->flags & SS_OUTPUT_ENA) ? 1 : 0;
        configure.speaker = (state->flags & SS_SPKR_ENA) ? 1 : 0;
        configure.reset = (state->flags & SS_RESET) ? 1 : 0;

        if (pcmcia_low_level->configure_socket(&configure) < 0) {
                printk(KERN_ERR "Unable to configure socket %u\n", sock);
                return -1;
        }

        pcmcia_socket[sock].cs_state = *state;
        return 0;
}


/*
 * bcm47xx_pcmcia_get_io_map()
 *
 * Implements the get_io_map() operation for the in-kernel PCMCIA
 * service (formerly SS_GetIOMap in Card Services). Just returns an
 * I/O map descriptor which was assigned earlier by a set_io_map().
 *
 * Returns: 0 on success, -1 if the map index was out of range
 */
static int 
bcm47xx_pcmcia_get_io_map(unsigned int sock, struct pccard_io_map *map)
{
        DEBUG(2, "bcm47xx_pcmcia_get_io_map: sock %d\n", sock);

        if (map->map >= MAX_IO_WIN) {
                printk(KERN_ERR "%s(): map (%d) out of range\n", 
                       __FUNCTION__, map->map);
                return -1;
        }

        *map = pcmcia_socket[sock].io_map[map->map];
        return 0;
}


/*
 * bcm47xx_pcmcia_set_io_map()
 *
 * Implements the set_io_map() operation for the in-kernel PCMCIA
 * service (formerly SS_SetIOMap in Card Services). We configure
 * the map speed as requested, but override the address ranges
 * supplied by Card Services.
 *
 * Returns: 0 on success, -1 on error
 */
int 
bcm47xx_pcmcia_set_io_map(unsigned int sock, struct pccard_io_map *map)
{
        unsigned int speed;
        unsigned long start;

        DEBUG(2, "\tmap %u  speed %u\n\tstart 0x%08lx  stop 0x%08lx\n"
              "\tflags: %s%s%s%s%s%s%s%s\n",
              map->map, map->speed, map->start, map->stop,
              (map->flags == 0) ? "<NONE>" : "",
              (map->flags & MAP_ACTIVE) ? "ACTIVE " : "",
              (map->flags & MAP_16BIT) ? "16BIT " : "",
              (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "",
              (map->flags & MAP_0WS) ? "0WS " : "",
              (map->flags & MAP_WRPROT) ? "WRPROT " : "",
              (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "",
              (map->flags & MAP_PREFETCH) ? "PREFETCH " : "");

        if (map->map >= MAX_IO_WIN) {
                printk(KERN_ERR "%s(): map (%d) out of range\n", 
                                __FUNCTION__, map->map);
                return -1;
        }

        if (map->flags & MAP_ACTIVE) {
                speed = (map->speed > 0) ? map->speed : BCM47XX_PCMCIA_IO_SPEED;
                pcmcia_socket[sock].speed_io = speed;
        }

        start = map->start;

        if (map->stop == 1) {
                map->stop = PAGE_SIZE - 1;
        }

        map->start = pcmcia_socket[sock].virt_io;
        map->stop = map->start + (map->stop - start);
        pcmcia_socket[sock].io_map[map->map] = *map;
        DEBUG(2, "set_io_map %d start %x stop %x\n", 
              map->map, map->start, map->stop);
        return 0;
}


/*
 * bcm47xx_pcmcia_get_mem_map()
 *
 * Implements the get_mem_map() operation for the in-kernel PCMCIA
 * service (formerly SS_GetMemMap in Card Services). Just returns a
 *  memory map descriptor which was assigned earlier by a
 *  set_mem_map() request.
 *
 * Returns: 0 on success, -1 if the map index was out of range
 */
static int 
bcm47xx_pcmcia_get_mem_map(unsigned int sock, struct pccard_mem_map *map)
{
        DEBUG(2, "%s() for sock %u\n", __FUNCTION__, sock);

        if (map->map >= MAX_WIN) {
                printk(KERN_ERR "%s(): map (%d) out of range\n", 
                       __FUNCTION__, map->map);
                return -1;
        }

        *map = pcmcia_socket[sock].mem_map[map->map];
        return 0;
}


/*
 * bcm47xx_pcmcia_set_mem_map()
 *
 * Implements the set_mem_map() operation for the in-kernel PCMCIA
 * service (formerly SS_SetMemMap in Card Services). We configure
 * the map speed as requested, but override the address ranges
 * supplied by Card Services.
 *
 * Returns: 0 on success, -1 on error
 */
static int 
bcm47xx_pcmcia_set_mem_map(unsigned int sock, struct pccard_mem_map *map)
{
        unsigned int speed;
        unsigned long start;
        u_long flags;

        if (map->map >= MAX_WIN) {
                printk(KERN_ERR "%s(): map (%d) out of range\n", 
                       __FUNCTION__, map->map);
                return -1;
        }

        DEBUG(2, "\tmap %u  speed %u\n\tsys_start  %#lx\n"
              "\tsys_stop   %#lx\n\tcard_start %#x\n"
              "\tflags: %s%s%s%s%s%s%s%s\n",
              map->map, map->speed, map->sys_start, map->sys_stop,
              map->card_start, (map->flags == 0) ? "<NONE>" : "",
              (map->flags & MAP_ACTIVE) ? "ACTIVE " : "",
              (map->flags & MAP_16BIT) ? "16BIT " : "",
              (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "",
              (map->flags & MAP_0WS) ? "0WS " : "",
              (map->flags & MAP_WRPROT) ? "WRPROT " : "",
              (map->flags & MAP_ATTRIB) ? "ATTRIB " : "",
              (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "");

        if (map->flags & MAP_ACTIVE) {
                /* When clients issue RequestMap, the access speed is not always
                 * properly configured:
                 */
                speed = (map->speed > 0) ? map->speed : BCM47XX_PCMCIA_MEM_SPEED;

                /* TBD */
                if (map->flags & MAP_ATTRIB) {
                        pcmcia_socket[sock].speed_attr = speed;
                } else {
                        pcmcia_socket[sock].speed_mem = speed;
                }
        }

        save_flags(flags);
        cli();
        start = map->sys_start;

        if (map->sys_stop == 0)
                map->sys_stop = PAGE_SIZE - 1;

        if (map->flags & MAP_ATTRIB) {
                map->sys_start = pcmcia_socket[sock].phys_attr + 
                        map->card_start;
        } else {
                map->sys_start = pcmcia_socket[sock].phys_mem + 
                        map->card_start;
        }

        map->sys_stop = map->sys_start + (map->sys_stop - start);
        pcmcia_socket[sock].mem_map[map->map] = *map;
        restore_flags(flags);
        DEBUG(2, "set_mem_map %d start %x stop %x card_start %x\n", 
                        map->map, map->sys_start, map->sys_stop, 
                        map->card_start);
        return 0;
}


#if defined(CONFIG_PROC_FS)

/*
 * bcm47xx_pcmcia_proc_setup()
 *
 * Implements the proc_setup() operation for the in-kernel PCMCIA
 * service (formerly SS_ProcSetup in Card Services).
 *
 * Returns: 0 on success, -1 on error
 */
static void 
bcm47xx_pcmcia_proc_setup(unsigned int sock, struct proc_dir_entry *base)
{
        struct proc_dir_entry *entry;

        if ((entry = create_proc_entry("status", 0, base)) == NULL) {
                printk(KERN_ERR "Unable to install \"status\" procfs entry\n");
                return;
        }

        entry->read_proc = bcm47xx_pcmcia_proc_status;
        entry->data = (void *)sock;
}


/*
 * bcm47xx_pcmcia_proc_status()
 *
 * Implements the /proc/bus/pccard/??/status file.
 *
 * Returns: the number of characters added to the buffer
 */
static int 
bcm47xx_pcmcia_proc_status(char *buf, char **start, off_t pos, 
                           int count, int *eof, void *data)
{
        char *p = buf;
        unsigned int sock = (unsigned int)data;

        p += sprintf(p, "k_flags  : %s%s%s%s%s%s%s\n", 
                     pcmcia_socket[sock].k_state.detect ? "detect " : "",
                     pcmcia_socket[sock].k_state.ready ? "ready " : "",
                     pcmcia_socket[sock].k_state.bvd1 ? "bvd1 " : "",
                     pcmcia_socket[sock].k_state.bvd2 ? "bvd2 " : "",
                     pcmcia_socket[sock].k_state.wrprot ? "wrprot " : "",
                     pcmcia_socket[sock].k_state.vs_3v ? "vs_3v " : "",
                     pcmcia_socket[sock].k_state.vs_Xv ? "vs_Xv " : "");

        p += sprintf(p, "status   : %s%s%s%s%s%s%s%s%s\n",
                     pcmcia_socket[sock].k_state.detect ? "SS_DETECT " : "",
                     pcmcia_socket[sock].k_state.ready ? "SS_READY " : "",
                     pcmcia_socket[sock].cs_state.Vcc ? "SS_POWERON " : "",
                     pcmcia_socket[sock].cs_state.flags & SS_IOCARD ? "SS_IOCARD " : "",
                     (pcmcia_socket[sock].cs_state.flags & SS_IOCARD &&
                      pcmcia_socket[sock].k_state.bvd1) ? "SS_STSCHG " : "",
                     ((pcmcia_socket[sock].cs_state.flags & SS_IOCARD) == 0 &&
                      (pcmcia_socket[sock].k_state.bvd1 == 0)) ? "SS_BATDEAD " : "",
                     ((pcmcia_socket[sock].cs_state.flags & SS_IOCARD) == 0 &&
                      (pcmcia_socket[sock].k_state.bvd2 == 0)) ? "SS_BATWARN " : "",
                     pcmcia_socket[sock].k_state.vs_3v ? "SS_3VCARD " : "",
                     pcmcia_socket[sock].k_state.vs_Xv ? "SS_XVCARD " : "");

        p += sprintf(p, "mask     : %s%s%s%s%s\n",
                     pcmcia_socket[sock].cs_state.csc_mask & SS_DETECT ? "SS_DETECT " : "",
                     pcmcia_socket[sock].cs_state.csc_mask & SS_READY ? "SS_READY " : "",
                     pcmcia_socket[sock].cs_state.csc_mask & SS_BATDEAD ? "SS_BATDEAD " : "",
                     pcmcia_socket[sock].cs_state.csc_mask & SS_BATWARN ? "SS_BATWARN " : "",
                     pcmcia_socket[sock].cs_state.csc_mask & SS_STSCHG ? "SS_STSCHG " : "");

        p += sprintf(p, "cs_flags : %s%s%s%s%s\n",
                     pcmcia_socket[sock].cs_state.flags & SS_PWR_AUTO ?
                        "SS_PWR_AUTO " : "",
                     pcmcia_socket[sock].cs_state.flags & SS_IOCARD ?
                        "SS_IOCARD " : "",
                     pcmcia_socket[sock].cs_state.flags & SS_RESET ?
                        "SS_RESET " : "",
                     pcmcia_socket[sock].cs_state.flags & SS_SPKR_ENA ?
                        "SS_SPKR_ENA " : "",
                     pcmcia_socket[sock].cs_state.flags & SS_OUTPUT_ENA ?
                        "SS_OUTPUT_ENA " : "");

        p += sprintf(p, "Vcc      : %d\n", pcmcia_socket[sock].cs_state.Vcc);
        p += sprintf(p, "Vpp      : %d\n", pcmcia_socket[sock].cs_state.Vpp);
        p += sprintf(p, "irq      : %d\n", pcmcia_socket[sock].cs_state.io_irq);
        p += sprintf(p, "I/O      : %u\n", pcmcia_socket[sock].speed_io);
        p += sprintf(p, "attribute: %u\n", pcmcia_socket[sock].speed_attr);
        p += sprintf(p, "common   : %u\n", pcmcia_socket[sock].speed_mem);
        return p-buf;
}


#endif  /* defined(CONFIG_PROC_FS) */