int wlan_setup()
{
int ret;
scratch_reg = 0x34;
ret = sdio_enable_func(1);
if(ret)
{
bufferPrintf("wlan: cannot enable function\r\n");
return -1;
}
ret = sdio_claim_irq(1, wlan_interrupt, 0);
if(ret)
{
bufferPrintf("wlan: cannot claim irq\r\n");
return -1;
}
ioport = sdio_readb(1, 0x0, &ret);
if(ret)
{
bufferPrintf("wlan: cannot read ioport\r\n");
return -1;
}
ioport |= sdio_readb(1, 0x1, &ret) << 8;
if(ret)
{
bufferPrintf("wlan: cannot read ioport\r\n");
return -1;
}
ioport |= sdio_readb(1, 0x2, &ret) << 16;
if(ret)
{
bufferPrintf("wlan: cannot read ioport\r\n");
return -1;
}
bufferPrintf("wlan: ioport = 0x%x\r\n", ioport);
uint16_t scratch = wlan_read_scratch(&ret);
if(ret)
{
bufferPrintf("wlan: cannot read scratch register\r\n");
return -1;
}
bufferPrintf("wlan: firmware status = 0x%x\r\n", scratch);
return 0;
}
/*
* This function registers the SDIO device.
*
* SDIO IRQ is claimed, block size is set and driver data is initialized.
*/
static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
{
int ret = 0;
struct sdio_mmc_card *card = adapter->card;
struct sdio_func *func = card->func;
/* save adapter pointer in card */
card->adapter = adapter;
sdio_claim_host(func);
/* Request the SDIO IRQ */
ret = sdio_claim_irq(func, mwifiex_sdio_interrupt);
if (ret) {
pr_err("claim irq failed: ret=%d\n", ret);
goto disable_func;
}
/* Set block size */
ret = sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
if (ret) {
pr_err("cannot set SDIO block size\n");
ret = -1;
goto release_irq;
}
sdio_release_host(func);
sdio_set_drvdata(func, card);
adapter->dev = &func->dev;
switch (func->device) {
case SDIO_DEVICE_ID_MARVELL_8786:
strcpy(adapter->fw_name, SD8786_DEFAULT_FW_NAME);
break;
case SDIO_DEVICE_ID_MARVELL_8797:
strcpy(adapter->fw_name, SD8797_DEFAULT_FW_NAME);
break;
case SDIO_DEVICE_ID_MARVELL_8787:
default:
strcpy(adapter->fw_name, SD8787_DEFAULT_FW_NAME);
break;
}
return 0;
release_irq:
sdio_release_irq(func);
disable_func:
sdio_disable_func(func);
sdio_release_host(func);
adapter->card = NULL;
return -1;
}
/*----------------------------------------------------------------------------*/
INT_32
glBusSetIrq (
PVOID pvData,
PVOID pfnIsr,
PVOID pvCookie
)
{
int ret = 0;
#if (MTK_WCN_HIF_SDIO == 0)
struct net_device *prNetDevice = NULL;
P_GLUE_INFO_T prGlueInfo = NULL;
P_GL_HIF_INFO_T prHifInfo = NULL;
ASSERT(pvData);
if (!pvData) {
return -1;
}
prNetDevice = (struct net_device *) pvData;
prGlueInfo = (P_GLUE_INFO_T) pvCookie;
ASSERT(prGlueInfo);
if (!prGlueInfo) {
return -1;
}
prHifInfo = &prGlueInfo->rHifInfo;
sdio_claim_host(prHifInfo->func);
ret = sdio_claim_irq(prHifInfo->func, mtk_sdio_interrupt);
sdio_release_host(prHifInfo->func);
#else
/* hif_sdio case */
struct net_device *prNetDevice = NULL;
P_GLUE_INFO_T prGlueInfo = NULL;
ASSERT(pvData);
if (!pvData) {
return -1;
}
prNetDevice = (struct net_device *) pvData;
prGlueInfo = (P_GLUE_INFO_T) pvCookie;
ASSERT(prGlueInfo);
if (!prGlueInfo) {
return -1;
}
mtk_wcn_hif_sdio_enable_irq(prGlueInfo->rHifInfo.cltCtx, MTK_WCN_BOOL_TRUE);
#endif
return ret;
} /* end of glBusSetIrq() */
/* Configure callback to client when we recieve client interrupt */
SDIOH_API_RC sdioh_interrupt_register(sdioh_info_t *sd, sdioh_cb_fn_t fn, void *argh)
{
if (fn == NULL)
{
return SDIOH_API_RC_FAIL;
}
sd->intr_handler = fn;//dhdsdio_isr
sd->intr_handler_arg = argh;
sd->intr_handler_valid = TRUE;
/* register and unmask irq */
if (gInstance->func[2])
{
sdio_claim_irq(gInstance->func[2], IRQHandlerF2);
}
if (gInstance->func[1])
{
sdio_claim_irq(gInstance->func[1], IRQHandler);
}
return SDIOH_API_RC_SUCCESS;
}
static int cw1200_sdio_irq_subscribe(struct hwbus_priv *self)
{
int ret = 0;
pr_debug("SW IRQ subscribe\n");
sdio_claim_host(self->func);
if (self->pdata->irq)
ret = cw1200_request_irq(self);
else
ret = sdio_claim_irq(self->func, cw1200_sdio_irq_handler);
sdio_release_host(self->func);
return ret;
}
void
HIFUnMaskInterrupt(HIF_DEVICE *device)
{
int ret;;
AR_DEBUG_ASSERT(device != NULL);
AR_DEBUG_ASSERT(device->func != NULL);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: HIFUnMaskInterrupt\n"));
/* Register the IRQ Handler */
sdio_claim_host(device->func);
ret = sdio_claim_irq(device->func, hifIRQHandler);
sdio_release_host(device->func);
AR_DEBUG_ASSERT(ret == 0);
}
int enable_sdio_interrupt(void)
{
int ret = 0;
#ifndef WILC_SDIO_IRQ_GPIO
sdio_claim_host(local_sdio_func);
ret = sdio_claim_irq(local_sdio_func, wilc_sdio_interrupt);
sdio_release_host(local_sdio_func);
if (ret < 0) {
PRINT_ER("can't claim sdio_irq, err(%d)\n", ret);
ret = -EIO;
}
#endif
return ret;
}
int enable_sdio_interrupt(isr_handler_t p_isr_handler){
int ret = 0;
#ifndef ATWILC_SDIO_IRQ_GPIO
sdio_intr_lock = ATWILC_SDIO_HOST_NO_TAKEN;
sdio_claim_host(local_sdio_func);
ret = sdio_claim_irq(local_sdio_func, atwilc_sdio_interrupt);
sdio_release_host(local_sdio_func);
if (ret < 0) {
PRINT_ER("can't claim sdio_irq, err(%d)\n", ret);
ret = -EIO;
}
isr_handler = p_isr_handler;
#endif
return ret;
}
/**
* @brief This function registers the device
*
* @param handle A pointer to moal_handle structure
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
woal_register_dev(moal_handle *handle)
{
int ret = MLAN_STATUS_SUCCESS;
struct sdio_mmc_card *card = handle->card;
struct sdio_func *func;
ENTER();
func = card->func;
sdio_claim_host(func);
/* Request the SDIO IRQ */
ret = sdio_claim_irq(func, woal_sdio_interrupt);
if (ret) {
PRINTM(MFATAL, "sdio_claim_irq failed: ret=%d\n", ret);
goto release_host;
}
/* Set block size */
ret = sdio_set_block_size(card->func, MLAN_SDIO_BLOCK_SIZE);
if (ret) {
PRINTM(MERROR,
"sdio_set_block_seize(): cannot set SDIO block size\n");
ret = MLAN_STATUS_FAILURE;
goto release_irq;
}
sdio_release_host(func);
sdio_set_drvdata(func, card);
handle->hotplug_device = &func->dev;
LEAVE();
return MLAN_STATUS_SUCCESS;
release_irq:
sdio_release_irq(func);
release_host:
sdio_release_host(func);
handle->card = NULL;
LEAVE();
return MLAN_STATUS_FAILURE;
}
static void sd_intf_start(PADAPTER padapter)
{
struct dvobj_priv *psddev;
struct sdio_func *func;
int err;
if (padapter == NULL) goto exit;
psddev = &padapter->dvobjpriv;
func = psddev->intf_data.func;
//os/intf dep
if (func) {
sdio_claim_host(func);
//according to practice, this is needed...
err = sdio_set_block_size(func, 512);
if (err) {
DBG_871X(KERN_CRIT "%s: sdio_set_block_size FAIL(%d)!\n", __func__, err);
goto release_host;
}
err = sdio_claim_irq(func, &sd_sync_int_hdl);
if (err) {
DBG_871X(KERN_CRIT "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err);
goto release_host;
}
release_host:
sdio_release_host(func);
}
//hal dep
if (padapter->HalFunc.enable_interrupt)
padapter->HalFunc.enable_interrupt(padapter);
else {
DBG_871X("%s HalFunc.enable_interrupt is %p\n", __FUNCTION__, padapter->HalFunc.enable_interrupt);
goto exit;
}
exit:
return;
}
/*
* This function registers the SDIO device.
*
* SDIO IRQ is claimed, block size is set and driver data is initialized.
*/
static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
{
int ret = 0;
struct sdio_mmc_card *card = adapter->card;
struct sdio_func *func = card->func;
/* save adapter pointer in card */
card->adapter = adapter;
sdio_claim_host(func);
/* Request the SDIO IRQ */
ret = sdio_claim_irq(func, mwifiex_sdio_interrupt);
if (ret) {
pr_err("claim irq failed: ret=%d\n", ret);
goto disable_func;
}
/* Set block size */
ret = sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
if (ret) {
pr_err("cannot set SDIO block size\n");
ret = -1;
goto release_irq;
}
sdio_release_host(func);
sdio_set_drvdata(func, card);
adapter->dev = &func->dev;
return 0;
release_irq:
sdio_release_irq(func);
disable_func:
sdio_disable_func(func);
sdio_release_host(func);
adapter->card = NULL;
return -1;
}
void sif_enable_irq(struct esp_pub *epub)
{
int err;
struct esp_sdio_ctrl *sctrl = NULL;
sctrl = (struct esp_sdio_ctrl *)epub->sif;
sdio_claim_host(sctrl->func);
err = sdio_claim_irq(sctrl->func, sif_dsr);
if (err)
esp_dbg(ESP_DBG_ERROR, "sif %s failed\n", __func__);
atomic_set(&epub->sip->state, SIP_BOOT);
atomic_set(&sctrl->irq_installed, 1);
sdio_release_host(sctrl->func);
}
int bcmsdio_register_intr_handler(int func, sdio_irq_handler_t * handler)
{
struct sdio_func *function = func_data[func]->func;
int ret;
if (function == NULL) {
BCM_DEBUG_PRINT(ERROR_LEVEL, KERN_ALERT " ***Error: %s %d ***\n", __func__, __LINE__);
return -ENON_INTF_ERR;
}
sdio_claim_host(function);
ret = sdio_claim_irq(function, handler);
if (ret < 0)
BCM_DEBUG_PRINT(debuglevel, KERN_ERR "Func-%d ISR Registration failed\n", func);
sdio_release_host(function);
return ret;
}
/* Bus ops */
static int if_sdio_enable(struct iwm_priv *iwm)
{
struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
int ret;
sdio_claim_host(hw->func);
ret = sdio_enable_func(hw->func);
if (ret) {
IWM_ERR(iwm, "Couldn't enable the device: is TOP driver "
"loaded and functional?\n");
goto release_host;
}
iwm_reset(iwm);
ret = sdio_claim_irq(hw->func, iwm_sdio_isr);
if (ret) {
IWM_ERR(iwm, "Failed to claim irq: %d\n", ret);
goto release_host;
}
sdio_writeb(hw->func, 1, IWM_SDIO_INTR_ENABLE_ADDR, &ret);
if (ret < 0) {
IWM_ERR(iwm, "Couldn't enable INTR: %d\n", ret);
goto release_irq;
}
sdio_release_host(hw->func);
IWM_DBG_SDIO(iwm, INFO, "IWM SDIO enable\n");
return 0;
release_irq:
sdio_release_irq(hw->func);
release_host:
sdio_release_host(hw->func);
return ret;
}
static int mtlte_sys_sdio_setup_irq(struct sdio_func *sdiofunc)
{
int ret = 0 ;
KAL_RAWPRINT(("[PROBE] =======> mtlte_sys_sdio_setup_irq\n"));
sdio_claim_host(sdiofunc);
ret = sdio_claim_irq(sdiofunc, mtlte_sys_lte_sdio_isr);
sdio_release_host(sdiofunc);
if (ret){
KAL_RAWPRINT(("[PROBE] XXXXXX mtlte_sys_sdio_setup_irq fail, %d \n", ret ));
return (ret);
}
mtlte_hif_enable_interrupt_at_probe();
lte_sdio_enable_eirq();
KAL_RAWPRINT(("[PROBE] <======= mtlte_sys_sdio_setup_irq\n"));
return 0 ;
}
/*
* Setup SDIO RX
*
* Hooks up the IRQ handler and then enables IRQs.
*/
int i2400ms_rx_setup(struct i2400ms *i2400ms)
{
int result;
struct sdio_func *func = i2400ms->func;
struct device *dev = &func->dev;
struct i2400m *i2400m = &i2400ms->i2400m;
d_fnstart(5, dev, "(i2400ms %p)\n", i2400ms);
init_waitqueue_head(&i2400ms->bm_wfa_wq);
spin_lock(&i2400m->rx_lock);
i2400ms->bm_wait_result = -EINPROGRESS;
/*
* Before we are about to enable the RX interrupt, make sure
* bm_ack_size is cleared to -EINPROGRESS which indicates
* no RX interrupt happened yet or the previous interrupt
* has been handled, we are ready to take the new interrupt
*/
i2400ms->bm_ack_size = -EINPROGRESS;
spin_unlock(&i2400m->rx_lock);
sdio_claim_host(func);
result = sdio_claim_irq(func, i2400ms_irq);
if (result < 0) {
dev_err(dev, "Cannot claim IRQ: %d\n", result);
goto error_irq_claim;
}
result = 0;
sdio_writeb(func, 1, I2400MS_INTR_ENABLE_ADDR, &result);
if (result < 0) {
sdio_release_irq(func);
dev_err(dev, "Failed to enable interrupts %d\n", result);
}
error_irq_claim:
sdio_release_host(func);
d_fnend(5, dev, "(i2400ms %p) = %d\n", i2400ms, result);
return result;
}
/*
* Setup SDIO RX
*
* Hooks up the IRQ handler and then enables IRQs.
*/
int i2400ms_rx_setup(struct i2400ms *i2400ms)
{
int result;
struct sdio_func *func = i2400ms->func;
struct device *dev = &func->dev;
d_fnstart(5, dev, "(i2400ms %p)\n", i2400ms);
sdio_claim_host(func);
result = sdio_claim_irq(func, i2400ms_irq);
if (result < 0) {
dev_err(dev, "Cannot claim IRQ: %d\n", result);
goto error_irq_claim;
}
result = 0;
sdio_writeb(func, 1, I2400MS_INTR_ENABLE_ADDR, &result);
if (result < 0) {
sdio_release_irq(func);
dev_err(dev, "Failed to enable interrupts %d\n", result);
}
error_irq_claim:
sdio_release_host(func);
d_fnend(5, dev, "(i2400ms %p) = %d\n", i2400ms, result);
return result;
}
int brcmf_sdiod_intr_register(struct brcmf_sdio_dev *sdiodev)
{
struct brcmfmac_sdio_pd *pdata;
int ret = 0;
u8 data;
u32 addr, gpiocontrol;
pdata = &sdiodev->settings->bus.sdio;
if (pdata->oob_irq_supported) {
brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n",
pdata->oob_irq_nr);
spin_lock_init(&sdiodev->irq_en_lock);
sdiodev->irq_en = true;
ret = request_irq(pdata->oob_irq_nr, brcmf_sdiod_oob_irqhandler,
pdata->oob_irq_flags, "brcmf_oob_intr",
&sdiodev->func1->dev);
if (ret != 0) {
brcmf_err("request_irq failed %d\n", ret);
return ret;
}
sdiodev->oob_irq_requested = true;
ret = enable_irq_wake(pdata->oob_irq_nr);
if (ret != 0) {
brcmf_err("enable_irq_wake failed %d\n", ret);
return ret;
}
sdiodev->irq_wake = true;
sdio_claim_host(sdiodev->func1);
if (sdiodev->bus_if->chip == BRCM_CC_43362_CHIP_ID) {
/* assign GPIO to SDIO core */
addr = CORE_CC_REG(SI_ENUM_BASE, gpiocontrol);
gpiocontrol = brcmf_sdiod_readl(sdiodev, addr, &ret);
gpiocontrol |= 0x2;
brcmf_sdiod_writel(sdiodev, addr, gpiocontrol, &ret);
brcmf_sdiod_writeb(sdiodev, SBSDIO_GPIO_SELECT,
0xf, &ret);
brcmf_sdiod_writeb(sdiodev, SBSDIO_GPIO_OUT, 0, &ret);
brcmf_sdiod_writeb(sdiodev, SBSDIO_GPIO_EN, 0x2, &ret);
}
/* must configure SDIO_CCCR_IENx to enable irq */
data = brcmf_sdiod_func0_rb(sdiodev, SDIO_CCCR_IENx, &ret);
data |= SDIO_CCCR_IEN_FUNC1 | SDIO_CCCR_IEN_FUNC2 |
SDIO_CCCR_IEN_FUNC0;
brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_IENx, data, &ret);
/* redirect, configure and enable io for interrupt signal */
data = SDIO_CCCR_BRCM_SEPINT_MASK | SDIO_CCCR_BRCM_SEPINT_OE;
if (pdata->oob_irq_flags & IRQF_TRIGGER_HIGH)
data |= SDIO_CCCR_BRCM_SEPINT_ACT_HI;
brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_BRCM_SEPINT,
data, &ret);
sdio_release_host(sdiodev->func1);
} else {
brcmf_dbg(SDIO, "Entering\n");
sdio_claim_host(sdiodev->func1);
sdio_claim_irq(sdiodev->func1, brcmf_sdiod_ib_irqhandler);
sdio_claim_irq(sdiodev->func2, brcmf_sdiod_dummy_irqhandler);
sdio_release_host(sdiodev->func1);
sdiodev->sd_irq_requested = true;
}
return 0;
}
static int ks7010_sdio_probe(struct sdio_func *func,
const struct sdio_device_id *device)
{
struct ks_wlan_private *priv;
struct ks_sdio_card *card;
struct net_device *netdev;
unsigned char byte;
int ret;
priv = NULL;
netdev = NULL;
card = kzalloc(sizeof(*card), GFP_KERNEL);
if (!card)
return -ENOMEM;
card->func = func;
sdio_claim_host(func);
ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n",
func->card->cccr.multi_block, func->cur_blksize, ret);
ret = sdio_enable_func(func);
DPRINTK(5, "sdio_enable_func() %d\n", ret);
if (ret)
goto err_free_card;
/* interrupt disable */
sdio_writeb(func, 0, INT_ENABLE, &ret);
if (ret)
goto err_free_card;
sdio_writeb(func, 0xff, INT_PENDING, &ret);
if (ret)
goto err_disable_func;
/* setup interrupt handler */
ret = sdio_claim_irq(func, ks_sdio_interrupt);
if (ret)
goto err_disable_func;
sdio_release_host(func);
sdio_set_drvdata(func, card);
DPRINTK(5, "class = 0x%X, vendor = 0x%X, device = 0x%X\n",
func->class, func->vendor, func->device);
/* private memory allocate */
netdev = alloc_etherdev(sizeof(*priv));
if (!netdev) {
dev_err(&card->func->dev, "ks7010 : Unable to alloc new net device\n");
goto err_release_irq;
}
if (dev_alloc_name(netdev, "wlan%d") < 0) {
dev_err(&card->func->dev,
"ks7010 : Couldn't get name!\n");
goto err_free_netdev;
}
priv = netdev_priv(netdev);
card->priv = priv;
SET_NETDEV_DEV(netdev, &card->func->dev); /* for create sysfs symlinks */
/* private memory initialize */
priv->ks_sdio_card = card;
priv->dev_state = DEVICE_STATE_PREBOOT;
priv->net_dev = netdev;
priv->firmware_version[0] = '\0';
priv->version_size = 0;
priv->last_doze = jiffies;
priv->last_wakeup = jiffies;
memset(&priv->nstats, 0, sizeof(priv->nstats));
memset(&priv->wstats, 0, sizeof(priv->wstats));
/* sleep mode */
atomic_set(&priv->sleepstatus.doze_request, 0);
atomic_set(&priv->sleepstatus.wakeup_request, 0);
atomic_set(&priv->sleepstatus.wakeup_request, 0);
trx_device_init(priv);
hostif_init(priv);
ks_wlan_net_start(netdev);
ks7010_init_defaults(priv);
ret = ks7010_upload_firmware(card);
if (ret) {
dev_err(&card->func->dev,
"ks7010: firmware load failed !! return code = %d\n",
ret);
goto err_free_netdev;
}
/* interrupt setting */
/* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
sdio_claim_host(func);
ret = ks7010_sdio_writeb(priv, INT_PENDING, 0xff);
sdio_release_host(func);
if (ret)
DPRINTK(1, " error : INT_PENDING\n");
/* enable ks7010sdio interrupt */
byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
sdio_claim_host(func);
ret = ks7010_sdio_writeb(priv, INT_ENABLE, byte);
sdio_release_host(func);
if (ret)
DPRINTK(1, " err : INT_ENABLE\n");
DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", byte);
priv->dev_state = DEVICE_STATE_BOOT;
priv->wq = create_workqueue("wq");
if (!priv->wq) {
DPRINTK(1, "create_workqueue failed !!\n");
goto err_free_netdev;
}
INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function);
ks7010_card_init(priv);
ret = register_netdev(priv->net_dev);
if (ret)
goto err_free_netdev;
return 0;
err_free_netdev:
free_netdev(priv->net_dev);
card->priv = NULL;
err_release_irq:
sdio_claim_host(func);
sdio_release_irq(func);
err_disable_func:
sdio_disable_func(func);
err_free_card:
sdio_release_host(func);
sdio_set_drvdata(func, NULL);
kfree(card);
return -ENODEV;
}
static int smssdio_probe(struct sdio_func *func,
const struct sdio_device_id *id)
{
int ret;
int board_id;
struct smssdio_device *smsdev;
struct smsdevice_params_t params;
board_id = id->driver_data;
smsdev = kzalloc(sizeof(struct smssdio_device), GFP_KERNEL);
if (!smsdev)
return -ENOMEM;
smsdev->func = func;
memset(¶ms, 0, sizeof(struct smsdevice_params_t));
params.device = &func->dev;
params.buffer_size = 0x5000; /* ?? */
params.num_buffers = 22; /* ?? */
params.context = smsdev;
snprintf(params.devpath, sizeof(params.devpath),
"sdio\\%s", sdio_func_id(func));
params.sendrequest_handler = smssdio_sendrequest;
params.device_type = sms_get_board(board_id)->type;
if (params.device_type != SMS_STELLAR)
params.flags |= SMS_DEVICE_FAMILY2;
else {
/*
* FIXME: Stellar needs special handling...
*/
ret = -ENODEV;
goto free;
}
ret = smscore_register_device(¶ms, &smsdev->coredev);
if (ret < 0)
goto free;
smscore_set_board_id(smsdev->coredev, board_id);
sdio_claim_host(func);
ret = sdio_enable_func(func);
if (ret)
goto release;
ret = sdio_set_block_size(func, 128);
if (ret)
goto disable;
ret = sdio_claim_irq(func, smssdio_interrupt);
if (ret)
goto disable;
sdio_set_drvdata(func, smsdev);
sdio_release_host(func);
ret = smscore_start_device(smsdev->coredev);
if (ret < 0)
goto reclaim;
return 0;
reclaim:
sdio_claim_host(func);
sdio_release_irq(func);
disable:
sdio_disable_func(func);
release:
sdio_release_host(func);
smscore_unregister_device(smsdev->coredev);
free:
kfree(smsdev);
return ret;
}
static int iwmct_probe(struct sdio_func *func,
const struct sdio_device_id *id)
{
struct iwmct_priv *priv;
int ret;
int val = 1;
int addr = IWMC_SDIO_INTR_ENABLE_ADDR;
dev_dbg(&func->dev, "enter iwmct_probe\n");
dev_dbg(&func->dev, "IRQ polling period id %u msecs, HZ is %d\n",
jiffies_to_msecs(2147483647), HZ);
priv = kzalloc(sizeof(struct iwmct_priv), GFP_KERNEL);
if (!priv) {
dev_err(&func->dev, "kzalloc error\n");
return -ENOMEM;
}
priv->func = func;
sdio_set_drvdata(func, priv);
/* create drivers work queue */
priv->wq = create_workqueue(DRV_NAME "_wq");
priv->bus_rescan_wq = create_workqueue(DRV_NAME "_rescan_wq");
INIT_WORK(&priv->bus_rescan_worker, iwmct_rescan_worker);
INIT_WORK(&priv->isr_worker, iwmct_irq_read_worker);
init_waitqueue_head(&priv->wait_q);
sdio_claim_host(func);
/* FIXME: Remove after it is fixed in the Boot ROM upgrade */
func->enable_timeout = 10;
/* In our HW, setting the block size also wakes up the boot rom. */
ret = sdio_set_block_size(func, priv->dbg.block_size);
if (ret) {
LOG_ERROR(priv, INIT,
"sdio_set_block_size() failure: %d\n", ret);
goto error_sdio_enable;
}
ret = sdio_enable_func(func);
if (ret) {
LOG_ERROR(priv, INIT, "sdio_enable_func() failure: %d\n", ret);
goto error_sdio_enable;
}
/* init reset and dev_sync states */
atomic_set(&priv->reset, 0);
atomic_set(&priv->dev_sync, 0);
/* init read req queue */
INIT_LIST_HEAD(&priv->read_req_list);
/* process configurable parameters */
iwmct_dbg_init_params(priv);
ret = sysfs_create_group(&func->dev.kobj, &iwmct_attribute_group);
if (ret) {
LOG_ERROR(priv, INIT, "Failed to register attributes and "
"initialize module_params\n");
goto error_dev_attrs;
}
iwmct_dbgfs_register(priv, DRV_NAME);
if (!priv->dbg.direct && priv->dbg.download_trans_blks > 8) {
LOG_INFO(priv, INIT,
"Reducing transaction to 8 blocks = 2K (from %d)\n",
priv->dbg.download_trans_blks);
priv->dbg.download_trans_blks = 8;
}
priv->trans_len = priv->dbg.download_trans_blks * priv->dbg.block_size;
LOG_INFO(priv, INIT, "Transaction length = %d\n", priv->trans_len);
ret = sdio_claim_irq(func, iwmct_irq);
if (ret) {
LOG_ERROR(priv, INIT, "sdio_claim_irq() failure: %d\n", ret);
goto error_claim_irq;
}
/* Enable function's interrupt */
sdio_writeb(priv->func, val, addr, &ret);
if (ret) {
LOG_ERROR(priv, INIT, "Failure writing to "
"Interrupt Enable Register (%d): %d\n", addr, ret);
goto error_enable_int;
}
sdio_release_host(func);
LOG_INFO(priv, INIT, "exit iwmct_probe\n");
return ret;
error_enable_int:
sdio_release_irq(func);
error_claim_irq:
sdio_disable_func(func);
error_dev_attrs:
iwmct_dbgfs_unregister(priv->dbgfs);
sysfs_remove_group(&func->dev.kobj, &iwmct_attribute_group);
error_sdio_enable:
sdio_release_host(func);
return ret;
}
/**
* @brief This function registers the device.
*
* @param priv A pointer to bt_private structure
* @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
*/
int
sbi_register_dev(bt_private * priv)
{
int ret = BT_STATUS_SUCCESS;
u8 reg;
u8 chiprev;
struct sdio_mmc_card *card = priv->bt_dev.card;
struct sdio_func *func;
ENTER();
if (!card || !card->func) {
PRINTM(ERROR, "BT: Error: card or function is NULL!\n");
goto failed;
}
func = card->func;
priv->hotplug_device = &func->dev;
if (fw_name == NULL)
fw_name = DEFAULT_FW_NAME;
/* Initialize the private structure */
strncpy(priv->bt_dev.name, "bt_sdio0", sizeof(priv->bt_dev.name));
priv->bt_dev.ioport = 0;
priv->bt_dev.fn = func->num;
sdio_claim_host(func);
ret = sdio_claim_irq(func, sd_interrupt);
if (ret) {
PRINTM(FATAL, "BT: sdio_claim_irq failed: ret=%d\n", ret);
goto release_host;
}
ret = sdio_set_block_size(card->func, SD_BLOCK_SIZE);
if (ret) {
PRINTM(FATAL, "BT: %s: cannot set SDIO block size\n", __FUNCTION__);
goto release_irq;
}
/* read Revision Register to get the chip revision number */
chiprev = sdio_readb(func, CARD_REVISION_REG, &ret);
if (ret) {
PRINTM(FATAL, "BT: cannot read CARD_REVISION_REG\n");
goto release_irq;
}
priv->adapter->chip_rev = chiprev;
PRINTM(INFO, "revision=%#x\n", chiprev);
/*
* Read the HOST_INTSTATUS_REG for ACK the first interrupt got
* from the bootloader. If we don't do this we get a interrupt
* as soon as we register the irq.
*/
reg = sdio_readb(func, HOST_INTSTATUS_REG, &ret);
if (ret < 0)
goto release_irq;
/* Read the IO port */
reg = sdio_readb(func, IO_PORT_0_REG, &ret);
if (ret < 0)
goto release_irq;
else
priv->bt_dev.ioport |= reg;
reg = sdio_readb(func, IO_PORT_1_REG, &ret);
if (ret < 0)
goto release_irq;
else
priv->bt_dev.ioport |= (reg << 8);
reg = sdio_readb(func, IO_PORT_2_REG, &ret);
if (ret < 0)
goto release_irq;
else
priv->bt_dev.ioport |= (reg << 16);
PRINTM(INFO, "BT: SDIO FUNC%d IO port: 0x%x\n", priv->bt_dev.fn,
priv->bt_dev.ioport);
#define SDIO_INT_MASK 0x3F
/* Set Host interrupt reset to read to clear */
reg = sdio_readb(func, HOST_INT_RSR_REG, &ret);
if (ret < 0)
goto release_irq;
sdio_writeb(func, reg | SDIO_INT_MASK, HOST_INT_RSR_REG, &ret);
if (ret < 0)
goto release_irq;
/* Set auto re-enable */
reg = sdio_readb(func, CARD_MISC_CFG_REG, &ret);
if (ret < 0)
goto release_irq;
sdio_writeb(func, reg | AUTO_RE_ENABLE_INT, CARD_MISC_CFG_REG, &ret);
if (ret < 0)
goto release_irq;
sdio_set_drvdata(func, card);
sdio_release_host(func);
LEAVE();
return BT_STATUS_SUCCESS;
release_irq:
sdio_release_irq(func);
release_host:
sdio_release_host(func);
failed:
LEAVE();
return BT_STATUS_FAILURE;
}
int adapter_probe(struct sdio_func *func, const struct sdio_device_id *id)
{
struct net_adapter *adapter;
struct net_device *net;
u_char charName[32];
int nRes = -ENOMEM;
u_long idx = 0;
struct wimax732_platform_data *pdata;
dump_debug("Probe!!!!!!!!!");
pdata = (struct wimax732_platform_data *) id->driver_data;
net = alloc_etherdev(sizeof(struct net_adapter));
if (!net) {
dump_debug("adapter_probe: "
"error can't allocate device");
goto alloceth_fail;
}
adapter = netdev_priv(net);
memset(adapter, 0, sizeof(struct net_adapter));
g_adapter = adapter;
adapter->pdata = (struct wimax732_platform_data *) id->driver_data;
adapter->pdata->g_cfg->card_removed = false;
adapter->pdata->g_cfg->powerup_done = false;
/* Initialize control */
control_init(adapter);
/* initialize hardware */
nRes = hw_init(adapter);
if (nRes) {
dump_debug("adapter_probe: error can't"
"allocate receive buffer");
goto hwInit_fail;
}
strcpy(net->name, "uwbr%d");
adapter->func = func;
adapter->net = net;
net->netdev_ops = &wimax_net_ops;
net->watchdog_timeo = ADAPTER_TIMEOUT;
net->mtu = WIMAX_MTU_SIZE;
adapter->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
| NETIF_MSG_PROBE | NETIF_MSG_LINK);
ether_setup(net);
net->flags |= IFF_NOARP;
adapter->media_state = MEDIA_DISCONNECTED;
adapter->ready = FALSE;
adapter->halted = FALSE;
adapter->downloading = TRUE;
adapter->removed = FALSE;
adapter->mac_ready = FALSE;
sdio_set_drvdata(func, adapter);
SET_NETDEV_DEV(net, &func->dev);
nRes = register_netdev(net);
if (nRes)
goto regdev_fail;
netif_carrier_off(net);
netif_tx_stop_all_queues(net);
sdio_claim_host(adapter->func);
nRes = sdio_enable_func(adapter->func);
if (nRes < 0) {
dump_debug("sdio_enable func error = %d", nRes);
goto sdioen_fail;
}
nRes = sdio_claim_irq(adapter->func, adapter_interrupt);
if (nRes < 0) {
dump_debug("sdio_claim_irq = %d", nRes);
goto sdioirq_fail;
}
sdio_set_block_size(adapter->func, 512);
sdio_release_host(adapter->func);
memset(charName, 0x00, sizeof(charName));
create_char_name(charName, idx);
if (misc_register(&uwibro_dev) != 0) {
dump_debug("adapter_probe: misc_register() failed");
goto regchar_fail;
}
/* Dummy value for "ifconfig up" for 2.6.24 */
random_ether_addr(node_id);
memcpy(net->dev_addr, node_id, sizeof(node_id));
/* sangam dbg */
INIT_WORK(&adapter->receive_work, rx_process_data);
INIT_WORK(&adapter->transmit_work, hw_transmit_thread);
INIT_WORK(&adapter->wimax_reset, cmc7xx_sdio_reset);
if (hw_start(adapter)) {
/* Free the resources and stop the driver processing */
misc_deregister(&uwibro_dev);
dump_debug("hw_start failed");
goto regchar_fail;
}
adapter->ready = TRUE;
return 0;
regchar_fail:
sdio_claim_host(adapter->func);
sdio_release_irq(adapter->func);
sdioirq_fail:
sdio_disable_func(adapter->func);
sdioen_fail:
sdio_release_host(adapter->func);
unregister_netdev(adapter->net);
regdev_fail:
sdio_set_drvdata(func, NULL);
hw_remove(adapter);
hwInit_fail:
free_netdev(net);
alloceth_fail:
pdata->g_cfg->card_removed = true;
pdata->g_cfg->powerup_done = true;
pdata->power(0);
return nRes;
}
/**
* @brief This function registers the device.
*
* @param priv A pointer to bt_private structure
* @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
*/
int
sbi_register_dev(bt_private *priv)
{
int ret = BT_STATUS_SUCCESS;
u8 reg;
u8 chiprev;
struct sdio_mmc_card *card = priv->bt_dev.card;
struct sdio_func *func;
u8 host_intstatus_reg = HOST_INTSTATUS_REG;
u8 card_revision_reg = CARD_REVISION_REG;
u8 io_port_0_reg = IO_PORT_0_REG;
u8 io_port_1_reg = IO_PORT_1_REG;
u8 io_port_2_reg = IO_PORT_2_REG;
ENTER();
if (!card || !card->func) {
PRINTM(ERROR, "BT: Error: card or function is NULL!\n");
goto failed;
}
func = card->func;
priv->hotplug_device = &func->dev;
/* Initialize the private structure */
strncpy(priv->bt_dev.name, "bt_sdio0", sizeof(priv->bt_dev.name));
priv->bt_dev.ioport = 0;
priv->bt_dev.fn = func->num;
sdio_claim_host(func);
ret = sdio_claim_irq(func, sd_interrupt);
if (ret) {
PRINTM(FATAL, ": sdio_claim_irq failed: ret=%d\n", ret);
goto release_host;
}
ret = sdio_set_block_size(card->func, SD_BLOCK_SIZE);
if (ret) {
PRINTM(FATAL, ": %s: cannot set SDIO block size\n", __func__);
goto release_irq;
}
/* read Revision Register to get the chip revision number */
chiprev = sdio_readb(func, card_revision_reg, &ret);
if (ret) {
PRINTM(FATAL, ": cannot read CARD_REVISION_REG\n");
goto release_irq;
}
priv->adapter->chip_rev = chiprev;
PRINTM(INFO, "revision=%#x\n", chiprev);
/*
* Read the HOST_INTSTATUS_REG for ACK the first interrupt got
* from the bootloader. If we don't do this we get a interrupt
* as soon as we register the irq.
*/
reg = sdio_readb(func, host_intstatus_reg, &ret);
if (ret < 0)
goto release_irq;
/* Read the IO port */
reg = sdio_readb(func, io_port_0_reg, &ret);
if (ret < 0)
goto release_irq;
else
priv->bt_dev.ioport |= reg;
reg = sdio_readb(func, io_port_1_reg, &ret);
if (ret < 0)
goto release_irq;
else
priv->bt_dev.ioport |= (reg << 8);
reg = sdio_readb(func, io_port_2_reg, &ret);
if (ret < 0)
goto release_irq;
else
priv->bt_dev.ioport |= (reg << 16);
PRINTM(INFO, ": SDIO FUNC%d IO port: 0x%x\n", priv->bt_dev.fn,
priv->bt_dev.ioport);
sdio_set_drvdata(func, card);
sdio_release_host(func);
LEAVE();
return BT_STATUS_SUCCESS;
release_irq:
sdio_release_irq(func);
release_host:
sdio_release_host(func);
failed:
LEAVE();
return BT_STATUS_FAILURE;
}
