mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
![Axel Lin](/assets/img/avatar_default.png)
Convert static struct pci_device_id *[] to static DEFINE_PCI_DEVICE_TABLE tables. Also convert to use PCI_DEVICE macro for better readablity. Signed-off-by: Axel Lin <axel.lin@gmail.com> Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
537 lines
13 KiB
C
537 lines
13 KiB
C
/*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
* for more details.
|
|
*
|
|
* Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/gpio.h>
|
|
|
|
#include <bcm63xx_regs.h>
|
|
#include <bcm63xx_io.h>
|
|
#include "bcm63xx_pcmcia.h"
|
|
|
|
#define PFX "bcm63xx_pcmcia: "
|
|
|
|
#ifdef CONFIG_CARDBUS
|
|
/* if cardbus is used, platform device needs reference to actual pci
|
|
* device */
|
|
static struct pci_dev *bcm63xx_cb_dev;
|
|
#endif
|
|
|
|
/*
|
|
* read/write helper for pcmcia regs
|
|
*/
|
|
static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off)
|
|
{
|
|
return bcm_readl(skt->base + off);
|
|
}
|
|
|
|
static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt,
|
|
u32 val, u32 off)
|
|
{
|
|
bcm_writel(val, skt->base + off);
|
|
}
|
|
|
|
/*
|
|
* This callback should (re-)initialise the socket, turn on status
|
|
* interrupts and PCMCIA bus, and wait for power to stabilise so that
|
|
* the card status signals report correctly.
|
|
*
|
|
* Hardware cannot do that.
|
|
*/
|
|
static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This callback should remove power on the socket, disable IRQs from
|
|
* the card, turn off status interrupts, and disable the PCMCIA bus.
|
|
*
|
|
* Hardware cannot do that.
|
|
*/
|
|
static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock,
|
|
socket_state_t *state)
|
|
{
|
|
struct bcm63xx_pcmcia_socket *skt;
|
|
unsigned long flags;
|
|
u32 val;
|
|
|
|
skt = sock->driver_data;
|
|
|
|
spin_lock_irqsave(&skt->lock, flags);
|
|
|
|
/* note: hardware cannot control socket power, so we will
|
|
* always report SS_POWERON */
|
|
|
|
/* apply socket reset */
|
|
val = pcmcia_readl(skt, PCMCIA_C1_REG);
|
|
if (state->flags & SS_RESET)
|
|
val |= PCMCIA_C1_RESET_MASK;
|
|
else
|
|
val &= ~PCMCIA_C1_RESET_MASK;
|
|
|
|
/* reverse reset logic for cardbus card */
|
|
if (skt->card_detected && (skt->card_type & CARD_CARDBUS))
|
|
val ^= PCMCIA_C1_RESET_MASK;
|
|
|
|
pcmcia_writel(skt, val, PCMCIA_C1_REG);
|
|
|
|
/* keep requested state for event reporting */
|
|
skt->requested_state = *state;
|
|
|
|
spin_unlock_irqrestore(&skt->lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* identity cardtype from VS[12] input, CD[12] input while only VS2 is
|
|
* floating, and CD[12] input while only VS1 is floating
|
|
*/
|
|
enum {
|
|
IN_VS1 = (1 << 0),
|
|
IN_VS2 = (1 << 1),
|
|
IN_CD1_VS2H = (1 << 2),
|
|
IN_CD2_VS2H = (1 << 3),
|
|
IN_CD1_VS1H = (1 << 4),
|
|
IN_CD2_VS1H = (1 << 5),
|
|
};
|
|
|
|
static const u8 vscd_to_cardtype[] = {
|
|
|
|
/* VS1 float, VS2 float */
|
|
[IN_VS1 | IN_VS2] = (CARD_PCCARD | CARD_5V),
|
|
|
|
/* VS1 grounded, VS2 float */
|
|
[IN_VS2] = (CARD_PCCARD | CARD_5V | CARD_3V),
|
|
|
|
/* VS1 grounded, VS2 grounded */
|
|
[0] = (CARD_PCCARD | CARD_5V | CARD_3V | CARD_XV),
|
|
|
|
/* VS1 tied to CD1, VS2 float */
|
|
[IN_VS1 | IN_VS2 | IN_CD1_VS1H] = (CARD_CARDBUS | CARD_3V),
|
|
|
|
/* VS1 grounded, VS2 tied to CD2 */
|
|
[IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V | CARD_XV),
|
|
|
|
/* VS1 tied to CD2, VS2 grounded */
|
|
[IN_VS1 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_3V | CARD_XV | CARD_YV),
|
|
|
|
/* VS1 float, VS2 grounded */
|
|
[IN_VS1] = (CARD_PCCARD | CARD_XV),
|
|
|
|
/* VS1 float, VS2 tied to CD2 */
|
|
[IN_VS1 | IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V),
|
|
|
|
/* VS1 float, VS2 tied to CD1 */
|
|
[IN_VS1 | IN_VS2 | IN_CD1_VS2H] = (CARD_CARDBUS | CARD_XV | CARD_YV),
|
|
|
|
/* VS1 tied to CD2, VS2 float */
|
|
[IN_VS1 | IN_VS2 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_YV),
|
|
|
|
/* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */
|
|
[IN_VS1 | IN_CD1_VS1H] = 0, /* ignore cardbay */
|
|
};
|
|
|
|
/*
|
|
* poll hardware to check card insertion status
|
|
*/
|
|
static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt)
|
|
{
|
|
unsigned int stat;
|
|
u32 val;
|
|
|
|
stat = 0;
|
|
|
|
/* check CD for card presence */
|
|
val = pcmcia_readl(skt, PCMCIA_C1_REG);
|
|
|
|
if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK))
|
|
stat |= SS_DETECT;
|
|
|
|
/* if new insertion, detect cardtype */
|
|
if ((stat & SS_DETECT) && !skt->card_detected) {
|
|
unsigned int stat = 0;
|
|
|
|
/* float VS1, float VS2 */
|
|
val |= PCMCIA_C1_VS1OE_MASK;
|
|
val |= PCMCIA_C1_VS2OE_MASK;
|
|
pcmcia_writel(skt, val, PCMCIA_C1_REG);
|
|
|
|
/* wait for output to stabilize and read VS[12] */
|
|
udelay(10);
|
|
val = pcmcia_readl(skt, PCMCIA_C1_REG);
|
|
stat |= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0;
|
|
stat |= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0;
|
|
|
|
/* drive VS1 low, float VS2 */
|
|
val &= ~PCMCIA_C1_VS1OE_MASK;
|
|
val |= PCMCIA_C1_VS2OE_MASK;
|
|
pcmcia_writel(skt, val, PCMCIA_C1_REG);
|
|
|
|
/* wait for output to stabilize and read CD[12] */
|
|
udelay(10);
|
|
val = pcmcia_readl(skt, PCMCIA_C1_REG);
|
|
stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0;
|
|
stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0;
|
|
|
|
/* float VS1, drive VS2 low */
|
|
val |= PCMCIA_C1_VS1OE_MASK;
|
|
val &= ~PCMCIA_C1_VS2OE_MASK;
|
|
pcmcia_writel(skt, val, PCMCIA_C1_REG);
|
|
|
|
/* wait for output to stabilize and read CD[12] */
|
|
udelay(10);
|
|
val = pcmcia_readl(skt, PCMCIA_C1_REG);
|
|
stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0;
|
|
stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0;
|
|
|
|
/* guess cardtype from all this */
|
|
skt->card_type = vscd_to_cardtype[stat];
|
|
if (!skt->card_type)
|
|
dev_err(&skt->socket.dev, "unsupported card type\n");
|
|
|
|
/* drive both VS pin to 0 again */
|
|
val &= ~(PCMCIA_C1_VS1OE_MASK | PCMCIA_C1_VS2OE_MASK);
|
|
|
|
/* enable correct logic */
|
|
val &= ~(PCMCIA_C1_EN_PCMCIA_MASK | PCMCIA_C1_EN_CARDBUS_MASK);
|
|
if (skt->card_type & CARD_PCCARD)
|
|
val |= PCMCIA_C1_EN_PCMCIA_MASK;
|
|
else
|
|
val |= PCMCIA_C1_EN_CARDBUS_MASK;
|
|
|
|
pcmcia_writel(skt, val, PCMCIA_C1_REG);
|
|
}
|
|
skt->card_detected = (stat & SS_DETECT) ? 1 : 0;
|
|
|
|
/* report card type/voltage */
|
|
if (skt->card_type & CARD_CARDBUS)
|
|
stat |= SS_CARDBUS;
|
|
if (skt->card_type & CARD_3V)
|
|
stat |= SS_3VCARD;
|
|
if (skt->card_type & CARD_XV)
|
|
stat |= SS_XVCARD;
|
|
stat |= SS_POWERON;
|
|
|
|
if (gpio_get_value(skt->pd->ready_gpio))
|
|
stat |= SS_READY;
|
|
|
|
return stat;
|
|
}
|
|
|
|
/*
|
|
* core request to get current socket status
|
|
*/
|
|
static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock,
|
|
unsigned int *status)
|
|
{
|
|
struct bcm63xx_pcmcia_socket *skt;
|
|
|
|
skt = sock->driver_data;
|
|
|
|
spin_lock_bh(&skt->lock);
|
|
*status = __get_socket_status(skt);
|
|
spin_unlock_bh(&skt->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* socket polling timer callback
|
|
*/
|
|
static void bcm63xx_pcmcia_poll(unsigned long data)
|
|
{
|
|
struct bcm63xx_pcmcia_socket *skt;
|
|
unsigned int stat, events;
|
|
|
|
skt = (struct bcm63xx_pcmcia_socket *)data;
|
|
|
|
spin_lock_bh(&skt->lock);
|
|
|
|
stat = __get_socket_status(skt);
|
|
|
|
/* keep only changed bits, and mask with required one from the
|
|
* core */
|
|
events = (stat ^ skt->old_status) & skt->requested_state.csc_mask;
|
|
skt->old_status = stat;
|
|
spin_unlock_bh(&skt->lock);
|
|
|
|
if (events)
|
|
pcmcia_parse_events(&skt->socket, events);
|
|
|
|
mod_timer(&skt->timer,
|
|
jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
|
|
}
|
|
|
|
static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock,
|
|
struct pccard_io_map *map)
|
|
{
|
|
/* this doesn't seem to be called by pcmcia layer if static
|
|
* mapping is used */
|
|
return 0;
|
|
}
|
|
|
|
static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock,
|
|
struct pccard_mem_map *map)
|
|
{
|
|
struct bcm63xx_pcmcia_socket *skt;
|
|
struct resource *res;
|
|
|
|
skt = sock->driver_data;
|
|
if (map->flags & MAP_ATTRIB)
|
|
res = skt->attr_res;
|
|
else
|
|
res = skt->common_res;
|
|
|
|
map->static_start = res->start + map->card_start;
|
|
return 0;
|
|
}
|
|
|
|
static struct pccard_operations bcm63xx_pcmcia_operations = {
|
|
.init = bcm63xx_pcmcia_sock_init,
|
|
.suspend = bcm63xx_pcmcia_suspend,
|
|
.get_status = bcm63xx_pcmcia_get_status,
|
|
.set_socket = bcm63xx_pcmcia_set_socket,
|
|
.set_io_map = bcm63xx_pcmcia_set_io_map,
|
|
.set_mem_map = bcm63xx_pcmcia_set_mem_map,
|
|
};
|
|
|
|
/*
|
|
* register pcmcia socket to core
|
|
*/
|
|
static int __devinit bcm63xx_drv_pcmcia_probe(struct platform_device *pdev)
|
|
{
|
|
struct bcm63xx_pcmcia_socket *skt;
|
|
struct pcmcia_socket *sock;
|
|
struct resource *res, *irq_res;
|
|
unsigned int regmem_size = 0, iomem_size = 0;
|
|
u32 val;
|
|
int ret;
|
|
|
|
skt = kzalloc(sizeof(*skt), GFP_KERNEL);
|
|
if (!skt)
|
|
return -ENOMEM;
|
|
spin_lock_init(&skt->lock);
|
|
sock = &skt->socket;
|
|
sock->driver_data = skt;
|
|
|
|
/* make sure we have all resources we need */
|
|
skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
|
skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
|
|
irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
|
|
skt->pd = pdev->dev.platform_data;
|
|
if (!skt->common_res || !skt->attr_res || !irq_res || !skt->pd) {
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
/* remap pcmcia registers */
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
regmem_size = resource_size(res);
|
|
if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) {
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
skt->reg_res = res;
|
|
|
|
skt->base = ioremap(res->start, regmem_size);
|
|
if (!skt->base) {
|
|
ret = -ENOMEM;
|
|
goto err;
|
|
}
|
|
|
|
/* remap io registers */
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
|
|
iomem_size = resource_size(res);
|
|
skt->io_base = ioremap(res->start, iomem_size);
|
|
if (!skt->io_base) {
|
|
ret = -ENOMEM;
|
|
goto err;
|
|
}
|
|
|
|
/* resources are static */
|
|
sock->resource_ops = &pccard_static_ops;
|
|
sock->ops = &bcm63xx_pcmcia_operations;
|
|
sock->owner = THIS_MODULE;
|
|
sock->dev.parent = &pdev->dev;
|
|
sock->features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
|
|
sock->io_offset = (unsigned long)skt->io_base;
|
|
sock->pci_irq = irq_res->start;
|
|
|
|
#ifdef CONFIG_CARDBUS
|
|
sock->cb_dev = bcm63xx_cb_dev;
|
|
if (bcm63xx_cb_dev)
|
|
sock->features |= SS_CAP_CARDBUS;
|
|
#endif
|
|
|
|
/* assume common & attribute memory have the same size */
|
|
sock->map_size = resource_size(skt->common_res);
|
|
|
|
/* initialize polling timer */
|
|
setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt);
|
|
|
|
/* initialize pcmcia control register, drive VS[12] to 0,
|
|
* leave CB IDSEL to the old value since it is set by the PCI
|
|
* layer */
|
|
val = pcmcia_readl(skt, PCMCIA_C1_REG);
|
|
val &= PCMCIA_C1_CBIDSEL_MASK;
|
|
val |= PCMCIA_C1_EN_PCMCIA_GPIO_MASK;
|
|
pcmcia_writel(skt, val, PCMCIA_C1_REG);
|
|
|
|
/*
|
|
* Hardware has only one set of timings registers, not one for
|
|
* each memory access type, so we configure them for the
|
|
* slowest one: attribute memory.
|
|
*/
|
|
val = PCMCIA_C2_DATA16_MASK;
|
|
val |= 10 << PCMCIA_C2_RWCOUNT_SHIFT;
|
|
val |= 6 << PCMCIA_C2_INACTIVE_SHIFT;
|
|
val |= 3 << PCMCIA_C2_SETUP_SHIFT;
|
|
val |= 3 << PCMCIA_C2_HOLD_SHIFT;
|
|
pcmcia_writel(skt, val, PCMCIA_C2_REG);
|
|
|
|
ret = pcmcia_register_socket(sock);
|
|
if (ret)
|
|
goto err;
|
|
|
|
/* start polling socket */
|
|
mod_timer(&skt->timer,
|
|
jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
|
|
|
|
platform_set_drvdata(pdev, skt);
|
|
return 0;
|
|
|
|
err:
|
|
if (skt->io_base)
|
|
iounmap(skt->io_base);
|
|
if (skt->base)
|
|
iounmap(skt->base);
|
|
if (skt->reg_res)
|
|
release_mem_region(skt->reg_res->start, regmem_size);
|
|
kfree(skt);
|
|
return ret;
|
|
}
|
|
|
|
static int __devexit bcm63xx_drv_pcmcia_remove(struct platform_device *pdev)
|
|
{
|
|
struct bcm63xx_pcmcia_socket *skt;
|
|
struct resource *res;
|
|
|
|
skt = platform_get_drvdata(pdev);
|
|
del_timer_sync(&skt->timer);
|
|
iounmap(skt->base);
|
|
iounmap(skt->io_base);
|
|
res = skt->reg_res;
|
|
release_mem_region(res->start, resource_size(res));
|
|
kfree(skt);
|
|
return 0;
|
|
}
|
|
|
|
struct platform_driver bcm63xx_pcmcia_driver = {
|
|
.probe = bcm63xx_drv_pcmcia_probe,
|
|
.remove = __devexit_p(bcm63xx_drv_pcmcia_remove),
|
|
.driver = {
|
|
.name = "bcm63xx_pcmcia",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
};
|
|
|
|
#ifdef CONFIG_CARDBUS
|
|
static int __devinit bcm63xx_cb_probe(struct pci_dev *dev,
|
|
const struct pci_device_id *id)
|
|
{
|
|
/* keep pci device */
|
|
bcm63xx_cb_dev = dev;
|
|
return platform_driver_register(&bcm63xx_pcmcia_driver);
|
|
}
|
|
|
|
static void __devexit bcm63xx_cb_exit(struct pci_dev *dev)
|
|
{
|
|
platform_driver_unregister(&bcm63xx_pcmcia_driver);
|
|
bcm63xx_cb_dev = NULL;
|
|
}
|
|
|
|
static DEFINE_PCI_DEVICE_TABLE(bcm63xx_cb_table) = {
|
|
{
|
|
.vendor = PCI_VENDOR_ID_BROADCOM,
|
|
.device = BCM6348_CPU_ID,
|
|
.subvendor = PCI_VENDOR_ID_BROADCOM,
|
|
.subdevice = PCI_ANY_ID,
|
|
.class = PCI_CLASS_BRIDGE_CARDBUS << 8,
|
|
.class_mask = ~0,
|
|
},
|
|
|
|
{
|
|
.vendor = PCI_VENDOR_ID_BROADCOM,
|
|
.device = BCM6358_CPU_ID,
|
|
.subvendor = PCI_VENDOR_ID_BROADCOM,
|
|
.subdevice = PCI_ANY_ID,
|
|
.class = PCI_CLASS_BRIDGE_CARDBUS << 8,
|
|
.class_mask = ~0,
|
|
},
|
|
|
|
{ },
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table);
|
|
|
|
static struct pci_driver bcm63xx_cardbus_driver = {
|
|
.name = "bcm63xx_cardbus",
|
|
.id_table = bcm63xx_cb_table,
|
|
.probe = bcm63xx_cb_probe,
|
|
.remove = __devexit_p(bcm63xx_cb_exit),
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
* if cardbus support is enabled, register our platform device after
|
|
* our fake cardbus bridge has been registered
|
|
*/
|
|
static int __init bcm63xx_pcmcia_init(void)
|
|
{
|
|
#ifdef CONFIG_CARDBUS
|
|
return pci_register_driver(&bcm63xx_cardbus_driver);
|
|
#else
|
|
return platform_driver_register(&bcm63xx_pcmcia_driver);
|
|
#endif
|
|
}
|
|
|
|
static void __exit bcm63xx_pcmcia_exit(void)
|
|
{
|
|
#ifdef CONFIG_CARDBUS
|
|
return pci_unregister_driver(&bcm63xx_cardbus_driver);
|
|
#else
|
|
platform_driver_unregister(&bcm63xx_pcmcia_driver);
|
|
#endif
|
|
}
|
|
|
|
module_init(bcm63xx_pcmcia_init);
|
|
module_exit(bcm63xx_pcmcia_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>");
|
|
MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller");
|