/*
|
* 'Standard' SDIO HOST CONTROLLER driver - linux portion
|
*
|
* Copyright (C) 2020, Broadcom.
|
*
|
* Unless you and Broadcom execute a separate written software license
|
* agreement governing use of this software, this software is licensed to you
|
* under the terms of the GNU General Public License version 2 (the "GPL"),
|
* available at http://www.broadcom.com/licenses/GPLv2.php, with the
|
* following added to such license:
|
*
|
* As a special exception, the copyright holders of this software give you
|
* permission to link this software with independent modules, and to copy and
|
* distribute the resulting executable under terms of your choice, provided that
|
* you also meet, for each linked independent module, the terms and conditions of
|
* the license of that module. An independent module is a module which is not
|
* derived from this software. The special exception does not apply to any
|
* modifications of the software.
|
*
|
*
|
* <<Broadcom-WL-IPTag/Open:>>
|
*
|
* $Id$
|
*/
|
|
#include <linux/sched.h> /* request_irq() */
|
#include <typedefs.h>
|
#include <pcicfg.h>
|
#include <bcmutils.h>
|
#include <sdio.h> /* SDIO Device and Protocol Specs */
|
#include <sdioh.h> /* SDIO Host Controller Spec header file */
|
#include <bcmsdbus.h> /* bcmsdh to/from specific controller APIs */
|
#include <sdiovar.h> /* to get msglevel bit values */
|
#include <bcmsdstd.h>
|
#include <bcmdevs.h>
|
|
extern void* bcmsdh_probe(osl_t *osh, void *dev, void *sdioh, void *adapter_info, uint bus_type,
|
uint bus_num, uint slot_num);
|
extern int bcmsdh_remove(bcmsdh_info_t *bcmsdh);
|
|
/* Extern functions for sdio power save */
|
extern uint8 sdstd_turn_on_clock(sdioh_info_t *sd);
|
extern uint8 sdstd_turn_off_clock(sdioh_info_t *sd);
|
/* Extern variable for sdio power save. This is enabled or disabled using the IOCTL call */
|
extern uint sd_3_power_save;
|
|
struct sdos_info {
|
sdioh_info_t *sd;
|
spinlock_t lock;
|
wait_queue_head_t intr_wait_queue;
|
timer_list_compat_t tuning_timer;
|
int tuning_timer_exp;
|
atomic_t timer_enab;
|
struct tasklet_struct tuning_tasklet;
|
};
|
|
#define SDSTD_WAITBITS_TIMEOUT (5 * HZ) /* seconds * HZ */
|
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
|
#define BLOCKABLE() (!in_atomic())
|
#else
|
#define BLOCKABLE() (!in_interrupt()) /* XXX Doesn't handle CONFIG_PREEMPT? */
|
#endif
|
|
static void
|
sdstd_3_ostasklet(ulong data);
|
static void
|
sdstd_3_tuning_timer(ulong data);
|
|
/* Interrupt handler */
|
static irqreturn_t
|
sdstd_isr(int irq, void *dev_id
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
|
, struct pt_regs *ptregs
|
#endif
|
)
|
{
|
sdioh_info_t *sd;
|
struct sdos_info *sdos;
|
bool ours;
|
|
unsigned long flags;
|
sd = (sdioh_info_t *)dev_id;
|
sdos = (struct sdos_info *)sd->sdos_info;
|
|
if (!sd->card_init_done) {
|
sd_err(("%s: Hey Bogus intr...not even initted: irq %d\n", __FUNCTION__, irq));
|
return IRQ_RETVAL(FALSE);
|
} else {
|
if (sdstd_3_is_retuning_int_set(sd)) {
|
/* for 3.0 host, retuning request might come in this path */
|
/* * disable ISR's */
|
local_irq_save(flags);
|
|
if (sdstd_3_check_and_set_retuning(sd))
|
tasklet_schedule(&sdos->tuning_tasklet);
|
|
/* * enable back ISR's */
|
local_irq_restore(flags);
|
|
/* * disable tuning isr signaling */
|
sdstd_3_disable_retuning_int(sd);
|
/* * note: check_client_intr() checks for intmask also to
|
wakeup. so be careful to use sd->intmask to disable
|
re-tuning ISR.
|
*/
|
}
|
ours = check_client_intr(sd);
|
|
/* For local interrupts, wake the waiting process */
|
if (ours && sd->got_hcint) {
|
sd_trace(("INTR->WAKE\n"));
|
/* sdos = (struct sdos_info *)sd->sdos_info; */
|
wake_up_interruptible(&sdos->intr_wait_queue);
|
}
|
return IRQ_RETVAL(ours);
|
}
|
}
|
|
/* Register with Linux for interrupts */
|
int
|
sdstd_register_irq(sdioh_info_t *sd, uint irq)
|
{
|
sd_trace(("Entering %s: irq == %d\n", __FUNCTION__, irq));
|
if (request_irq(irq, sdstd_isr, IRQF_SHARED, "bcmsdstd", sd) < 0) {
|
sd_err(("%s: request_irq() failed\n", __FUNCTION__));
|
return ERROR;
|
}
|
return SUCCESS;
|
}
|
|
/* Free Linux irq */
|
void
|
sdstd_free_irq(uint irq, sdioh_info_t *sd)
|
{
|
free_irq(irq, sd);
|
}
|
|
/* Map Host controller registers */
|
|
uint32 *
|
sdstd_reg_map(osl_t *osh, dmaaddr_t addr, int size)
|
{
|
return (uint32 *)REG_MAP(addr, size);
|
}
|
|
void
|
sdstd_reg_unmap(osl_t *osh, dmaaddr_t addr, int size)
|
{
|
REG_UNMAP((void*)(uintptr)addr);
|
}
|
|
int
|
sdstd_osinit(sdioh_info_t *sd)
|
{
|
struct sdos_info *sdos;
|
|
sdos = (struct sdos_info*)MALLOC(sd->osh, sizeof(struct sdos_info));
|
sd->sdos_info = (void*)sdos;
|
if (sdos == NULL)
|
return BCME_NOMEM;
|
|
sdos->sd = sd;
|
spin_lock_init(&sdos->lock);
|
atomic_set(&sdos->timer_enab, FALSE);
|
init_waitqueue_head(&sdos->intr_wait_queue);
|
return BCME_OK;
|
}
|
|
/* initilize tuning related OS structures */
|
void
|
sdstd_3_osinit_tuning(sdioh_info_t *sd)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)sd->sdos_info;
|
uint8 timer_count = sdstd_3_get_tuning_exp(sdos->sd);
|
|
sd_trace(("%s Enter\n", __FUNCTION__));
|
|
init_timer_compat(&sdos->tuning_timer, sdstd_3_tuning_timer, sdos);
|
if (timer_count == CAP3_RETUNING_TC_DISABLED || timer_count > CAP3_RETUNING_TC_1024S) {
|
sdos->tuning_timer_exp = 0;
|
} else {
|
sdos->tuning_timer_exp = 1 << (timer_count - 1);
|
}
|
tasklet_init(&sdos->tuning_tasklet, sdstd_3_ostasklet, (ulong)sdos);
|
if (sdos->tuning_timer_exp) {
|
timer_expires(&sdos->tuning_timer) = jiffies + sdos->tuning_timer_exp * HZ;
|
add_timer(&sdos->tuning_timer);
|
atomic_set(&sdos->timer_enab, TRUE);
|
}
|
}
|
|
/* finalize tuning related OS structures */
|
void
|
sdstd_3_osclean_tuning(sdioh_info_t *sd)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)sd->sdos_info;
|
if (atomic_read(&sdos->timer_enab) == TRUE) {
|
/* disable timer if it was running */
|
del_timer_sync(&sdos->tuning_timer);
|
atomic_set(&sdos->timer_enab, FALSE);
|
}
|
tasklet_kill(&sdos->tuning_tasklet);
|
}
|
|
static void
|
sdstd_3_ostasklet(ulong data)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)data;
|
int tune_state = sdstd_3_get_tune_state(sdos->sd);
|
int data_state = sdstd_3_get_data_state(sdos->sd);
|
if ((tune_state == TUNING_START) || (tune_state == TUNING_ONGOING) ||
|
(tune_state == TUNING_START_AFTER_DAT)) {
|
return;
|
}
|
else if (data_state == DATA_TRANSFER_IDLE)
|
sdstd_3_set_tune_state(sdos->sd, TUNING_START);
|
else if (data_state == DATA_TRANSFER_ONGOING)
|
sdstd_3_set_tune_state(sdos->sd, TUNING_START_AFTER_DAT);
|
}
|
|
static void
|
sdstd_3_tuning_timer(ulong data)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)data;
|
/* uint8 timeout = 0; */
|
unsigned long int_flags;
|
|
sd_trace(("%s: enter\n", __FUNCTION__));
|
/* schedule tasklet */
|
/* * disable ISR's */
|
local_irq_save(int_flags);
|
if (sdstd_3_check_and_set_retuning(sdos->sd))
|
tasklet_schedule(&sdos->tuning_tasklet);
|
|
/* * enable back ISR's */
|
local_irq_restore(int_flags);
|
}
|
|
void sdstd_3_start_tuning(sdioh_info_t *sd)
|
{
|
int tune_state;
|
unsigned long int_flags = 0;
|
unsigned int timer_enab;
|
struct sdos_info *sdos = (struct sdos_info *)sd->sdos_info;
|
sd_trace(("%s: enter\n", __FUNCTION__));
|
/* * disable ISR's */
|
local_irq_save(int_flags);
|
timer_enab = atomic_read(&sdos->timer_enab);
|
|
tune_state = sdstd_3_get_tune_state(sd);
|
|
if (tune_state == TUNING_ONGOING) {
|
/* do nothing */
|
local_irq_restore(int_flags);
|
goto exit;
|
}
|
/* change state */
|
sdstd_3_set_tune_state(sd, TUNING_ONGOING);
|
/* * enable ISR's */
|
local_irq_restore(int_flags);
|
sdstd_3_clk_tuning(sd, sdstd_3_get_uhsi_clkmode(sd));
|
#ifdef BCMSDIOH_STD_TUNING_WAR
|
/*
|
* Observed intermittent SDIO command error after re-tuning done
|
* successfully. Re-tuning twice is giving much reliable results.
|
*/
|
sdstd_3_clk_tuning(sd, sdstd_3_get_uhsi_clkmode(sd));
|
#endif /* BCMSDIOH_STD_TUNING_WAR */
|
/* * disable ISR's */
|
local_irq_save(int_flags);
|
sdstd_3_set_tune_state(sd, TUNING_IDLE);
|
/* * enable ISR's */
|
local_irq_restore(int_flags);
|
|
/* enable retuning intrrupt */
|
sdstd_3_enable_retuning_int(sd);
|
|
/* start retuning timer if enabled */
|
if ((sdos->tuning_timer_exp) && (timer_enab)) {
|
if (sd->sd3_tuning_reqd) {
|
timer_expires(&sdos->tuning_timer) = jiffies + sdos->tuning_timer_exp * HZ;
|
mod_timer(&sdos->tuning_timer, timer_expires(&sdos->tuning_timer));
|
}
|
}
|
exit:
|
return;
|
|
}
|
|
void
|
sdstd_osfree(sdioh_info_t *sd)
|
{
|
struct sdos_info *sdos;
|
ASSERT(sd && sd->sdos_info);
|
|
sdos = (struct sdos_info *)sd->sdos_info;
|
MFREE(sd->osh, sdos, sizeof(struct sdos_info));
|
}
|
|
/* Interrupt enable/disable */
|
SDIOH_API_RC
|
sdioh_interrupt_set(sdioh_info_t *sd, bool enable)
|
{
|
ulong flags;
|
struct sdos_info *sdos;
|
|
sd_trace(("%s: %s\n", __FUNCTION__, enable ? "Enabling" : "Disabling"));
|
|
sdos = (struct sdos_info *)sd->sdos_info;
|
ASSERT(sdos);
|
|
if (!(sd->host_init_done && sd->card_init_done)) {
|
sd_err(("%s: Card & Host are not initted - bailing\n", __FUNCTION__));
|
return SDIOH_API_RC_FAIL;
|
}
|
|
if (enable && !(sd->intr_handler && sd->intr_handler_arg)) {
|
sd_err(("%s: no handler registered, will not enable\n", __FUNCTION__));
|
return SDIOH_API_RC_FAIL;
|
}
|
|
/* Ensure atomicity for enable/disable calls */
|
spin_lock_irqsave(&sdos->lock, flags);
|
|
sd->client_intr_enabled = enable;
|
if (enable && !sd->lockcount)
|
sdstd_devintr_on(sd);
|
else
|
sdstd_devintr_off(sd);
|
|
spin_unlock_irqrestore(&sdos->lock, flags);
|
|
return SDIOH_API_RC_SUCCESS;
|
}
|
|
/* Protect against reentrancy (disable device interrupts while executing) */
|
void
|
sdstd_lock(sdioh_info_t *sd)
|
{
|
ulong flags;
|
struct sdos_info *sdos;
|
int wait_count = 0;
|
|
sdos = (struct sdos_info *)sd->sdos_info;
|
ASSERT(sdos);
|
|
sd_trace(("%s: %d\n", __FUNCTION__, sd->lockcount));
|
|
spin_lock_irqsave(&sdos->lock, flags);
|
while (sd->lockcount)
|
{
|
spin_unlock_irqrestore(&sdos->lock, flags);
|
yield();
|
spin_lock_irqsave(&sdos->lock, flags);
|
if (++wait_count == 25000) {
|
if (!(sd->lockcount == 0)) {
|
sd_err(("%s: ERROR: sd->lockcount == 0\n", __FUNCTION__));
|
}
|
}
|
}
|
/* PR86684: Add temporary debugging print */
|
if (wait_count)
|
printk("sdstd_lock: wait count = %d\n", wait_count);
|
sdstd_devintr_off(sd);
|
sd->lockcount++;
|
spin_unlock_irqrestore(&sdos->lock, flags);
|
if ((sd->controller_type == SDIOH_TYPE_RICOH_R5C822) && (sd->version == HOST_CONTR_VER_3))
|
sdstd_turn_on_clock(sd);
|
}
|
|
/* Enable client interrupt */
|
void
|
sdstd_unlock(sdioh_info_t *sd)
|
{
|
ulong flags;
|
struct sdos_info *sdos;
|
|
sd_trace(("%s: %d, %d\n", __FUNCTION__, sd->lockcount, sd->client_intr_enabled));
|
ASSERT(sd->lockcount > 0);
|
|
sdos = (struct sdos_info *)sd->sdos_info;
|
ASSERT(sdos);
|
|
spin_lock_irqsave(&sdos->lock, flags);
|
if (--sd->lockcount == 0 && sd->client_intr_enabled) {
|
sdstd_devintr_on(sd);
|
}
|
spin_unlock_irqrestore(&sdos->lock, flags);
|
if (sd_3_power_save)
|
{
|
if ((sd->controller_type == SDIOH_TYPE_RICOH_R5C822) &&
|
(sd->version == HOST_CONTR_VER_3))
|
sdstd_turn_off_clock(sd);
|
}
|
}
|
|
void
|
sdstd_os_lock_irqsave(sdioh_info_t *sd, ulong* flags)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)sd->sdos_info;
|
spin_lock_irqsave(&sdos->lock, *flags);
|
}
|
void
|
sdstd_os_unlock_irqrestore(sdioh_info_t *sd, ulong* flags)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)sd->sdos_info;
|
spin_unlock_irqrestore(&sdos->lock, *flags);
|
}
|
|
void
|
sdstd_waitlockfree(sdioh_info_t *sd)
|
{
|
if (sd->lockcount) {
|
printk("wait lock free\n");
|
while (sd->lockcount)
|
{
|
yield();
|
}
|
}
|
}
|
|
#ifdef BCMQT
|
void
|
sdstd_os_yield(sdioh_info_t *sd)
|
{
|
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 29))
|
/*
|
* FC4/11 issue on QT if driver hogs > 10s of CPU causing:
|
* BUG: soft lockup detected on CPU#0!
|
*
|
* XXX Hack: For now, interleave yielding of CPU when we're spinning waiting for
|
* XXX register status
|
*/
|
yield();
|
#endif
|
}
|
#endif /* BCMQT */
|
|
/* Returns 0 for success, -1 for interrupted, -2 for timeout */
|
int
|
sdstd_waitbits(sdioh_info_t *sd, uint16 norm, uint16 err, bool local_yield, uint16 *bits)
|
{
|
struct sdos_info *sdos;
|
int rc = 0;
|
|
sdos = (struct sdos_info *)sd->sdos_info;
|
|
#ifndef BCMSDYIELD
|
ASSERT(!local_yield);
|
#endif
|
sd_trace(("%s: int 0x%02x err 0x%02x yield %d canblock %d\n",
|
__FUNCTION__, norm, err, local_yield, BLOCKABLE()));
|
|
/* Clear the "interrupt happened" flag and last intrstatus */
|
sd->got_hcint = FALSE;
|
sd->last_intrstatus = 0;
|
|
#ifdef BCMSDYIELD
|
if (local_yield && BLOCKABLE()) {
|
/* Enable interrupts, wait for the indication, then disable */
|
sdstd_intrs_on(sd, norm, err);
|
rc = wait_event_interruptible_timeout(sdos->intr_wait_queue,
|
(sd->got_hcint),
|
SDSTD_WAITBITS_TIMEOUT);
|
if (rc < 0)
|
rc = -1; /* interrupted */
|
else if (rc == 0)
|
rc = -2; /* timeout */
|
else
|
rc = 0; /* success */
|
sdstd_intrs_off(sd, norm, err);
|
} else
|
#endif /* BCMSDYIELD */
|
{
|
sdstd_spinbits(sd, norm, err);
|
}
|
|
sd_trace(("%s: last_intrstatus 0x%04x\n", __FUNCTION__, sd->last_intrstatus));
|
|
*bits = sd->last_intrstatus;
|
|
return rc;
|
}
|
|
#ifdef DHD_DEBUG
|
void sdstd_enable_disable_periodic_timer(sdioh_info_t *sd, uint val)
|
{
|
struct sdos_info *sdos = (struct sdos_info *)sd->sdos_info;
|
|
if (val == SD_DHD_ENABLE_PERIODIC_TUNING) {
|
/* start of tuning timer */
|
timer_expires(&sdos->tuning_timer) = jiffies + sdos->tuning_timer_exp * HZ;
|
mod_timer(&sdos->tuning_timer, timer_expires(&sdos->tuning_timer));
|
}
|
if (val == SD_DHD_DISABLE_PERIODIC_TUNING) {
|
/* stop periodic timer */
|
del_timer_sync(&sdos->tuning_timer);
|
}
|
}
|
#endif /* debugging purpose */
|
|
/* forward declarations for PCI probe and remove functions. */
|
static int __devinit bcmsdh_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
|
static void __devexit bcmsdh_pci_remove(struct pci_dev *pdev);
|
|
/**
|
* pci id table
|
*/
|
static struct pci_device_id bcmsdh_pci_devid[] __devinitdata = {
|
{ vendor: PCI_ANY_ID,
|
device: PCI_ANY_ID,
|
subvendor: PCI_ANY_ID,
|
subdevice: PCI_ANY_ID,
|
class: 0,
|
class_mask: 0,
|
driver_data: 0,
|
},
|
{ 0, 0, 0, 0, 0, 0, 0}
|
};
|
MODULE_DEVICE_TABLE(pci, bcmsdh_pci_devid);
|
|
/**
|
* SDIO Host Controller pci driver info
|
*/
|
static struct pci_driver bcmsdh_pci_driver = {
|
node: {&(bcmsdh_pci_driver.node), &(bcmsdh_pci_driver.node)},
|
name: "bcmsdh",
|
id_table: bcmsdh_pci_devid,
|
probe: bcmsdh_pci_probe,
|
remove: bcmsdh_pci_remove,
|
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0))
|
save_state: NULL,
|
#endif
|
suspend: NULL,
|
resume: NULL,
|
};
|
|
extern uint sd_pci_slot; /* Force detection to a particular PCI */
|
/* slot only . Allows for having multiple */
|
/* WL devices at once in a PC */
|
/* Only one instance of dhd will be */
|
/* usable at a time */
|
/* Upper word is bus number, */
|
/* lower word is slot number */
|
/* Default value of 0xffffffff turns this */
|
/* off */
|
module_param(sd_pci_slot, uint, 0);
|
|
/**
|
* Detect supported SDIO Host Controller and attach if found.
|
*
|
* Determine if the device described by pdev is a supported SDIO Host
|
* Controller. If so, attach to it and attach to the target device.
|
*/
|
static int __devinit
|
bcmsdh_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
{
|
osl_t *osh = NULL;
|
sdioh_info_t *sdioh = NULL;
|
int rc;
|
|
if (sd_pci_slot != 0xFFFFffff) {
|
if (pdev->bus->number != (sd_pci_slot>>16) ||
|
PCI_SLOT(pdev->devfn) != (sd_pci_slot&0xffff)) {
|
sd_err(("%s: %s: bus %X, slot %X, vend %X, dev %X\n",
|
__FUNCTION__,
|
bcmsdh_chipmatch(pdev->vendor, pdev->device)
|
?"Found compatible SDIOHC"
|
:"Probing unknown device",
|
pdev->bus->number, PCI_SLOT(pdev->devfn), pdev->vendor,
|
pdev->device));
|
return -ENODEV;
|
}
|
sd_err(("%s: %s: bus %X, slot %X, vendor %X, device %X (good PCI location)\n",
|
__FUNCTION__,
|
bcmsdh_chipmatch(pdev->vendor, pdev->device)
|
?"Using compatible SDIOHC"
|
:"WARNING, forced use of unkown device",
|
pdev->bus->number, PCI_SLOT(pdev->devfn), pdev->vendor, pdev->device));
|
}
|
|
if ((pdev->vendor == VENDOR_TI) && ((pdev->device == PCIXX21_FLASHMEDIA_ID) ||
|
(pdev->device == PCIXX21_FLASHMEDIA0_ID))) {
|
uint32 config_reg;
|
|
sd_err(("%s: Disabling TI FlashMedia Controller.\n", __FUNCTION__));
|
if (!(osh = osl_attach(pdev, SDIO_BUS, TRUE))) {
|
sd_err(("%s: osl_attach failed\n", __FUNCTION__));
|
goto err;
|
}
|
|
config_reg = OSL_PCI_READ_CONFIG(osh, 0x4c, 4);
|
|
/*
|
* Set MMC_SD_DIS bit in FlashMedia Controller.
|
* Disbling the SD/MMC Controller in the FlashMedia Controller
|
* allows the Standard SD Host Controller to take over control
|
* of the SD Slot.
|
*/
|
config_reg |= 0x02;
|
OSL_PCI_WRITE_CONFIG(osh, 0x4c, 4, config_reg);
|
osl_detach(osh);
|
}
|
/* match this pci device with what we support */
|
/* we can't solely rely on this to believe it is our SDIO Host Controller! */
|
if (!bcmsdh_chipmatch(pdev->vendor, pdev->device)) {
|
if (pdev->vendor == VENDOR_BROADCOM) {
|
sd_err(("%s: Unknown Broadcom device (vendor: %#x, device: %#x).\n",
|
__FUNCTION__, pdev->vendor, pdev->device));
|
}
|
return -ENODEV;
|
}
|
|
/* this is a pci device we might support */
|
sd_err(("%s: Found possible SDIO Host Controller: bus %d slot %d func %d irq %d\n",
|
__FUNCTION__,
|
pdev->bus->number, PCI_SLOT(pdev->devfn),
|
PCI_FUNC(pdev->devfn), pdev->irq));
|
|
/* use bcmsdh_query_device() to get the vendor ID of the target device so
|
* it will eventually appear in the Broadcom string on the console
|
*/
|
|
/* allocate SDIO Host Controller state info */
|
if (!(osh = osl_attach(pdev, SDIO_BUS, TRUE))) {
|
sd_err(("%s: osl_attach failed\n", __FUNCTION__));
|
goto err;
|
}
|
|
/* map to address where host can access */
|
pci_set_master(pdev);
|
rc = pci_enable_device(pdev);
|
if (rc) {
|
sd_err(("%s: Cannot enable PCI device\n", __FUNCTION__));
|
goto err;
|
}
|
|
sdioh = sdioh_attach(osh, (void *)(ulong)pci_resource_start(pdev, 0), pdev->irq);
|
if (sdioh == NULL) {
|
sd_err(("%s: sdioh_attach failed\n", __FUNCTION__));
|
goto err;
|
}
|
sdioh->bcmsdh = bcmsdh_probe(osh, &pdev->dev, sdioh, NULL, PCI_BUS, -1, -1);
|
if (sdioh->bcmsdh == NULL) {
|
sd_err(("%s: bcmsdh_probe failed\n", __FUNCTION__));
|
goto err;
|
}
|
|
pci_set_drvdata(pdev, sdioh);
|
return 0;
|
|
err:
|
if (sdioh != NULL)
|
sdioh_detach(osh, sdioh);
|
if (osh != NULL)
|
osl_detach(osh);
|
return -ENOMEM;
|
}
|
|
/**
|
* Detach from target devices and SDIO Host Controller
|
*/
|
static void __devexit
|
bcmsdh_pci_remove(struct pci_dev *pdev)
|
{
|
sdioh_info_t *sdioh;
|
osl_t *osh;
|
|
sdioh = pci_get_drvdata(pdev);
|
if (sdioh == NULL) {
|
sd_err(("%s: error, no sdioh handler found\n", __FUNCTION__));
|
return;
|
}
|
|
osh = sdioh->osh;
|
bcmsdh_remove(sdioh->bcmsdh);
|
sdioh_detach(osh, sdioh);
|
osl_detach(osh);
|
}
|
|
int bcmsdh_register_client_driver(void)
|
{
|
return pci_module_init(&bcmsdh_pci_driver);
|
}
|
|
void bcmsdh_unregister_client_driver(void)
|
{
|
pci_unregister_driver(&bcmsdh_pci_driver);
|
}
|
