/* * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "cs_internal.h" #include #include #include #include #include #include #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) ? "" : "", (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) ? "" : "", (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) ? "" : "", (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) ? "" : "", (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) */