| /** |
| * |
| * Name: sdiobus.c |
| * Project: Wireless LAN, Bus driver for SDIO interface |
| * Version: $Revision: 1.1 $ |
| * Date: $Date: 2007/01/18 09:21:35 $ |
| * Purpose: Bus driver for SDIO interface |
| * |
| * Copyright (C) 2003-2009, Marvell International Ltd. |
| * |
| * This software file (the "File") is distributed by Marvell International |
| * Ltd. under the terms of the GNU General Public License Version 2, June 1991 |
| * (the "License"). You may use, redistribute and/or modify this File in |
| * accordance with the terms and conditions of the License, a copy of which |
| * is available by writing to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the |
| * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. |
| * |
| * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE |
| * ARE EXPRESSLY DISCLAIMED. The License provides additional details about |
| * this warranty disclaimer. |
| * |
| */ |
| |
| /****************************************************************************** |
| * |
| * History: |
| * |
| * $Log: sdiobus.c,v $ |
| * Revision 1.1 2007/01/18 09:21:35 pweber |
| * Put under CVS control |
| * |
| * Revision 1.2 2005/12/08 12:01:00 ebauer |
| * Driver ckecks AND update voltage registry value if not correct |
| * |
| * Revision 1.1 2005/10/07 08:43:47 jschmalz |
| * Put SDIO with FPGA under CVS control |
| * |
| * |
| ******************************************************************************/ |
| #ifndef _lint |
| static const char SysKonnectFileId[] = "@(#)" __FILE__ " (C) Marvell "; |
| #endif /* !_lint */ |
| |
| #include "diagvers.h" /* diag version control */ |
| |
| #include "h/skdrv1st.h" |
| #include "h/skdrv2nd.h" |
| |
| #include <linux/proc_fs.h> // proc filesystem |
| |
| #ifdef DBG |
| SK_U32 stdDebugLevel = DBG_DEFAULT; |
| #endif // #ifdef DBG |
| |
| #define USE_DEBOUNCE_CARD_IN |
| /*--- mmoser 12/21/2006 ---*/ |
| #define MAX_DEBOUNCE_TIME 100 |
| |
| DECLARE_MUTEX(sd_if_sema); |
| DECLARE_MUTEX(sd_client_sema); |
| |
| static int sdio_major = 0; |
| |
| int mrvlsdio_open(struct inode *inode, struct file *filp); |
| int mrvlsdio_release(struct inode *inode, struct file *filp); |
| int SDIOBus_IoCtl(struct inode *inode, struct file *filp, |
| unsigned int cmd, unsigned long arg); |
| |
| static void call_client_probe(PSD_DEVICE_DATA pDev, int fn); |
| // |
| // Module parameters |
| // |
| |
| static int bus_type = SDIO_BUS_TYPE; |
| static int bus_width = SDIO_1_BIT; |
| int block_size = SD_BLOCK_SIZE; |
| int dma_support = 1; |
| static int clock_speed = 0; |
| static int gpi_0_mode = 1; // edge triggered |
| static int gpi_0_level = 1; // high->low |
| static int gpi_1_mode = 1; // edge triggered |
| static int gpi_1_level = 1; // high-->low |
| #define INTMODE_SDIO 0 |
| #define INTMODE_GPIO 1 |
| int intmode = 0; // GPIO intmode enabled |
| int gpiopin = 0; // GPIO pin number for SDIO alternative IRQ |
| EXPORT_SYMBOL(intmode); |
| EXPORT_SYMBOL(gpiopin); |
| |
| //static int debug_flags = 0; |
| static int debug_flags = 0x0c; |
| |
| static int sdio_voltage = FPGA_POWER_REG_3_3_V; |
| |
| DECLARE_WAIT_QUEUE_HEAD(add_remove_queue); |
| |
| // kernel 2.6.x |
| module_param(bus_type, int, S_IRUGO); |
| module_param(bus_width, int, S_IRUGO); |
| module_param(block_size, int, S_IRUGO); |
| module_param(clock_speed, int, S_IRUGO); |
| module_param(dma_support, int, S_IRUGO); |
| module_param(debug_flags, int, S_IRUGO); |
| module_param(sdio_voltage, int, S_IRUGO); |
| module_param(gpi_0_mode, int, S_IRUGO); // 0 = level triggered 1 = edge |
| // triggered |
| module_param(gpi_0_level, int, S_IRUGO); // 0 = low->high or low 1 = |
| // high->low or high |
| module_param(gpi_1_mode, int, S_IRUGO); // 0 = level triggered 1 = edge |
| // triggered |
| module_param(gpi_1_level, int, S_IRUGO); // 0 = low->high or low 1 = |
| // high->low or high |
| module_param(intmode, int, S_IRUGO); |
| module_param(gpiopin, int, S_IRUGO); |
| |
| // prototypes |
| // for filling the "/proc/mrvsdio" entry |
| int mrvlsdio_read_procmem(char *buf, char **start, off_t offset, int count, |
| int *eof, void *data); |
| int sd_match_device(sd_driver * drv, PSD_DEVICE_DATA dev); |
| |
| // static PSD_DEVICE_DATA gSD_dev_data = NULL; |
| |
| struct list_head sd_dev_list; |
| spinlock_t sd_dev_list_lock; |
| unsigned long sd_dev_list_lock_flags; |
| |
| struct list_head sd_client_list; |
| spinlock_t sd_client_list_lock; |
| unsigned long sd_client_list_lock_flags; |
| |
| static int SDIOThread(void *data); |
| |
| static int probe(struct pci_dev *dev, const struct pci_device_id *id); |
| static void remove(struct pci_dev *dev); |
| |
| static DECLARE_COMPLETION(on_exit); |
| |
| // kernel 2.6 |
| |
| static struct pci_device_id ids[] = { |
| {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x8000),}, |
| {0,} |
| }; |
| |
| MODULE_DEVICE_TABLE(pci, ids); |
| |
| /* |
| * The fops |
| */ |
| |
| struct file_operations mrvlsdio_fops = { |
| llseek:NULL, |
| read:NULL, |
| write:NULL, |
| ioctl:SDIOBus_IoCtl, |
| mmap:NULL, |
| open:mrvlsdio_open, |
| release:mrvlsdio_release, |
| }; |
| |
| /* |
| * Open and close |
| */ |
| |
| int |
| mrvlsdio_open(struct inode *inode, struct file *filp) |
| { |
| ENTER(); |
| |
| if (list_empty(&sd_dev_list)) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "mrvlsdio_open: sd_dev_list is empty -> Adapter not in CardBus slot!\n")); |
| return -ENODEV; |
| } |
| |
| filp->f_op = &mrvlsdio_fops; |
| |
| // Pointer to first device in list |
| // This works ONLY with one CardBus slot and one SDIO2PCI Adapter !!! |
| // With more SDIO2PCI Adapter we need to implement virtual devices |
| filp->private_data = sd_dev_list.next; |
| |
| LEAVE(); |
| return 0; /* success */ |
| } |
| |
| int |
| mrvlsdio_release(struct inode *inode, struct file *filp) |
| { |
| ENTER(); |
| LEAVE(); |
| return 0; |
| } |
| |
| /* |
| * The ioctl() implementation |
| */ |
| |
| int |
| SDIOBus_IoCtl(struct inode *inode, struct file *filp, |
| unsigned int cmd, unsigned long arg) |
| { |
| int ret = 0; |
| UCHAR ucValue; |
| ULONG ulValue; |
| ULONG cnt; |
| PSD_DEVICE_DATA sd_dev; |
| |
| ENTER(); |
| |
| sd_dev = (SD_DEVICE_DATA *) filp->private_data; |
| if (sd_dev == NULL) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "SDIOBus_IoCtl : sd_dev= 0x%p !!!!!!!!!!!!!!!!\n", |
| sd_dev)); |
| return -ENOTTY; |
| } |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : sd_dev= 0x%p sd_dev->IOBase[0]= 0x%p\n", sd_dev, |
| sd_dev->IOBase[0])); |
| |
| switch (cmd) { |
| case IOCTL_SDIOBUSENUM_SET_VOLTAGE: |
| { |
| ret = get_user(ucValue, (int *) arg); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : IOCTL_SDIOBUSENUM_SET_VOLTAGE: 0x%2.02X\n", |
| ucValue)); |
| MEM_WRITE_UCHAR(sd_dev, SK_SLOT_0, FPGA_POWER_REG_DATA, ucValue); |
| MEM_WRITE_UCHAR(sd_dev, SK_SLOT_0, FPGA_POWER_REG_CMD, |
| FPGA_POWER_REG_CMD_START); |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "wait for stable voltage\n")); |
| cnt = 0; |
| do { |
| MEM_READ_UCHAR(sd_dev, SK_SLOT_0, FPGA_POWER_REG_STATUS, |
| &ucValue); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "PowerRegulatorControl: 0x%x\n", ucValue)); |
| } while (++cnt < 10000 && (ucValue & FPGA_POWER_REG_STABLE) == 0); |
| DBGPRINT(DBG_LOAD, |
| ("IOCTL_SDIOBUSENUM_SET_VOLTAGE: cnt=%d\n", cnt)); |
| break; |
| } |
| case IOCTL_SDIOBUSENUM_GET_BOARDREV: |
| { |
| MEM_READ_ULONG(sd_dev, SK_SLOT_0, FPGA_CARD_REVISION, &ulValue); |
| |
| ret = put_user(ulValue, (int *) arg); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : IOCTL_SDIOBUSENUM_GET_BOARDREV 0x%8.08X\n", |
| ulValue)); |
| break; |
| } |
| case IOCTL_SDIOBUSENUM_GET_JUMPER: |
| { |
| DBGPRINT(DBG_LOAD, ("IOCTL_SDIOBUSENUM_GET_JUMPER\n")); |
| MEM_READ_ULONG(sd_dev, SK_SLOT_0, FPGA_CARD_REVISION, &ulValue); |
| ret = put_user(ulValue, (int *) arg); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : IOCTL_SDIOBUSENUM_GET_JUMPER 0x%8.08X\n", |
| ulValue)); |
| break; |
| } |
| |
| case IOCTL_SDIOBUSENUM_SET_BUSTYPE: |
| { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : IOCTL_SDIOBUSENUM_SET_BUSTYPE --> IGNORED!\n")); |
| break; |
| } |
| case IOCTL_SDIOBUSENUM_SET_BUSWIDTH: |
| { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : IOCTL_SDIOBUSENUM_SET_BUSWIDTH --> IGNORED!\n")); |
| break; |
| } |
| case IOCTL_SDIOBUSENUM_SET_CLKSPEED: |
| { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "SDIOBus_IoCtl : IOCTL_SDIOBUSENUM_SET_CLKSPEED --> IGNORED!\n")); |
| break; |
| } |
| default: |
| { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "SDIOBus_IoCtl : invalid cmd=%d (0x%8.08X)!\n", |
| cmd, cmd)); |
| return -ENOTTY; |
| } |
| } |
| |
| LEAVE(); |
| return ret; |
| |
| } |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) |
| static void |
| card_out_work(PSD_DEVICE_DATA pDev) |
| #else |
| static void |
| card_out_work(struct work_struct *work) |
| #endif |
| { |
| int j; |
| |
| #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19) |
| PSD_DEVICE_DATA pDev = container_of(work, SD_DEVICE_DATA, card_out_work); |
| #endif |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s: CARD_REMOVE_EVENT received.\n", __FUNCTION__)); |
| for (j = 1; j <= pDev->number_of_functions; j++) { |
| if (down_interruptible(&sd_client_sema)) |
| return; |
| if (pDev->sd_dev[j].drv != NULL && pDev->sd_dev[j].drv->remove != NULL) { |
| if (pDev->sd_dev[j].remove_called == 0) { |
| DBGPRINT(DBG_LOAD | DBG_ERROR, |
| (KERN_DEBUG "%s: call remove() handler on fn=%d\n", |
| __FUNCTION__, j)); |
| |
| pDev->sd_dev[j].probe_called = 0; |
| pDev->sd_dev[j].remove_called = 1; |
| pDev->sd_dev[j].dev = NULL; |
| pDev->sd_dev[j].drv->remove(&pDev->sd_dev[j]); |
| } |
| } else { |
| // If we have no remove() handler at this point, we will never get |
| // one. |
| // So discard the CARD_REMOVE_EVENT to avoid an endless loop. |
| // This situation is considered a bug in the client driver !!!! |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "%s: no remove() handler installed for fn=%d! Revise client driver!!!\n", |
| __FUNCTION__, j)); |
| } |
| up(&sd_client_sema); |
| } |
| |
| } |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) |
| static void |
| card_irq_work(PSD_DEVICE_DATA pDev) |
| #else |
| static void |
| card_irq_work(struct work_struct *work) |
| #endif |
| { |
| SK_U32 irq_handler_called; |
| SK_U8 int_pending; |
| SK_U32 ix; |
| |
| #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19) |
| PSD_DEVICE_DATA pDev = container_of(work, SD_DEVICE_DATA, irq_work); |
| #endif |
| |
| irq_handler_called = 0; |
| |
| // Read function specific interrupt information |
| GET_IF_SEMA_NO_RC(); |
| if (SDHost_CMD52_Read(pDev, INT_PENDING_REG, 0, &int_pending)) { |
| REL_IF_SEMA(); |
| DBGPRINT(DBG_IRQ, |
| (KERN_DEBUG "INT Pending = 0x%2.02X\n ", int_pending)); |
| |
| for (ix = 1; ix <= 7; ix++) { |
| if (int_pending & INT(ix)) { |
| // Function ix interrupt is pending and enabled |
| if (pDev->irq_device_cache[ix] != NULL) { |
| DBGPRINT(DBG_IRQ, |
| (KERN_DEBUG |
| "Call registered interrupt handler for function %d.\n", |
| ix)); |
| irq_handler_called++; |
| if (pDev->irq_device_cache[ix]->functions[ix].int_handler != |
| NULL) { |
| pDev->irq_device_cache[ix]->functions[ix]. |
| int_handler(pDev->irq_device_cache[ix], |
| pDev->irq_device_cache[ix]-> |
| pCurrent_Ids, |
| pDev->irq_device_cache[ix]-> |
| functions[ix].context); |
| } |
| } |
| } |
| } |
| } else |
| REL_IF_SEMA(); |
| |
| if (irq_handler_called == 0) { |
| DBGPRINT(DBG_IRQ, |
| (KERN_DEBUG "No interrupt handler registered. (sd_dev=%p)\n", |
| pDev)); |
| SDHost_EnableInterrupt(pDev, pDev->lastIRQSignalMask); |
| } |
| |
| } |
| |
| static struct pci_driver mrvlsdio = { |
| .name = "mrvlsdio", |
| .id_table = ids, |
| .probe = probe, |
| .remove = remove, |
| }; |
| |
| static int |
| probe(struct pci_dev *dev, const struct pci_device_id *id) |
| { |
| int i, ret; |
| SK_U8 ucValue; |
| SK_U32 mem; |
| SK_U32 ulValue; |
| PSD_DEVICE_DATA pTmpDev; |
| |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "mrvlsdio : probe()\n")); |
| |
| if (pci_enable_device(dev)) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: pci_enable_device() failed\n")); |
| return -EIO; |
| } |
| if (pci_set_dma_mask(dev, 0xffffffff)) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: 32-bit PCI DMA not supported")); |
| pci_disable_device(dev); |
| return -EIO; |
| } |
| pci_set_master(dev); |
| |
| /*--- mmoser 6/21/2007 ---*/ |
| pTmpDev = (PSD_DEVICE_DATA) kmalloc(sizeof(SD_DEVICE_DATA), GFP_KERNEL); |
| |
| if (pTmpDev == NULL) { |
| return -ENOMEM; |
| } |
| #ifdef SDIO_MEM_TRACE |
| printk(">>> kmalloc(SD_DEVICE_DATA)\n"); |
| #endif |
| |
| memset(pTmpDev, 0, sizeof(SD_DEVICE_DATA)); |
| |
| pTmpDev->IOBaseIx = 0; |
| /*--- mmoser 10/11/2006 ---*/ |
| pTmpDev->dev = dev; |
| pTmpDev->workqueue = create_workqueue("MRVL-SDIO"); |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) |
| INIT_WORK(&pTmpDev->irq_work, (void (*)(void *)) card_irq_work, pTmpDev); |
| INIT_WORK(&pTmpDev->card_out_work, (void (*)(void *)) card_out_work, |
| pTmpDev); |
| #else |
| INIT_WORK(&pTmpDev->irq_work, card_irq_work); |
| INIT_WORK(&pTmpDev->card_out_work, card_out_work); |
| #endif |
| |
| if (pci_request_regions(dev, "MRVL-SDIO")) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: pci_request_regions() failed.\n")); |
| pci_disable_device(dev); |
| return -EIO; |
| } |
| |
| for (i = 0; i < 5; i++) { |
| mem = pci_resource_start(dev, i); |
| |
| if (mem != 0) { |
| if (IORESOURCE_MEM & pci_resource_flags(dev, i)) { |
| pTmpDev->IOBaseLength[pTmpDev->IOBaseIx] = |
| pci_resource_end(dev, i) - mem + 1; |
| pTmpDev->IOBase[pTmpDev->IOBaseIx] = |
| ioremap_nocache(mem, |
| pTmpDev->IOBaseLength[pTmpDev->IOBaseIx]); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "mrvlsdio: IOBase[%d] = 0x%8.08X IOBaseLength = %u\n", |
| i, (SK_U32) pTmpDev->IOBase[pTmpDev->IOBaseIx], |
| pTmpDev->IOBaseLength[pTmpDev->IOBaseIx])); |
| pTmpDev->IOBaseIx++; |
| if (pTmpDev->IOBaseIx >= 2) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "mrvlsdio : Too many memory address ranges!\n")); |
| pTmpDev->IOBaseIx = 0; |
| } |
| } |
| } |
| } |
| |
| // Dummy read. Function return SUCCESS but value is messy !!! |
| pci_read_config_byte(dev, PCI_INTERRUPT_LINE, |
| (SK_U8 *) & pTmpDev->Interrupt); |
| |
| for (i = 0; i < 3; i++) { |
| ret = |
| pci_read_config_byte(dev, PCI_INTERRUPT_LINE, |
| (SK_U8 *) & pTmpDev->Interrupt); |
| if (ret) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "mrvlsdio: Failed to retrieve Interrupt Line (%d) %d ret=%d\n", |
| i, pTmpDev->Interrupt, ret)); |
| UDELAY(100); |
| continue; |
| } else { |
| break; |
| } |
| } |
| if (i >= 3) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "mrvlsdio: Failed to retrieve Interrupt Line (%d) ret=%d\n", |
| i, ret)); |
| return -ENODEV; |
| } |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: Interrupt Line = %d (%d)\n", |
| pTmpDev->Interrupt, i)); |
| |
| MEM_READ_UCHAR(pTmpDev, SK_SLOT_0, FPGA_CARD_REVISION, &ucValue); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: CardRevision: 0x%X (sd_dev_data=0x%p)\n", |
| ucValue, &pTmpDev)); |
| |
| pTmpDev->bus_type = bus_type; |
| pTmpDev->bus_width = bus_width; |
| pTmpDev->ClockSpeed = clock_speed; |
| pTmpDev->debug_flags = debug_flags; |
| pTmpDev->sdio_voltage = sdio_voltage; |
| |
| pci_read_config_byte(dev, 0x0c, &ucValue); |
| |
| if (ucValue == 0) |
| pci_write_config_byte(dev, 0x0c, 2); |
| |
| pci_read_config_byte(dev, 0x0c, &ucValue); |
| // printk("config[0x0c]=0x%2.02X\n",ucValue); |
| pci_read_config_byte(dev, 0x0d, &ucValue); |
| // printk("config[0x0d]=0x%2.02X\n",ucValue); |
| printk("debug_flags=0x%8.08X\n", debug_flags); |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: bus_type : SDIO%s\n", |
| bus_type == SDIO_BUS_TYPE ? "" : "/SPI")); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: bus_width : %s\n", |
| bus_width == SDIO_4_BIT ? "4-bit" : "1-bit")); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: block_size : %d\n", block_size)); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: clock_speed : %d\n", clock_speed)); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: debug_flags : 0x%8.08X\n", debug_flags)); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: sdio_voltage : %d\n", sdio_voltage)); |
| |
| /*--- mmoser 3/12/2007 ---*/ |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: gpi_0_mode : %s triggered\n", |
| gpi_0_mode == 0 ? "level" : "edge")); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: gpi_0_level : %s\n", |
| gpi_0_level == 0 ? (gpi_0_mode == |
| 0 ? "low" : "low->high") : (gpi_0_mode == |
| 0 ? "high" : |
| "high->low"))); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: gpi_1_mode : %s triggered\n", |
| gpi_1_mode == 0 ? "level" : "edge")); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: gpi_1_level : %s\n", |
| gpi_1_level == 0 ? (gpi_1_mode == |
| 0 ? "low" : "low->high") : (gpi_1_mode == |
| 0 ? "high" : |
| "high->low"))); |
| |
| // mmoser 2005-11-29 |
| atomic_set(&pTmpDev->card_add_event, 0); |
| atomic_set(&pTmpDev->card_remove_event, 0); |
| |
| /*--- mmoser 8/29/2006 ---*/ |
| init_waitqueue_head(&pTmpDev->trans_complete_evt.wq); |
| init_waitqueue_head(&pTmpDev->cmd_complete_evt.wq); |
| init_waitqueue_head(&pTmpDev->thread_started_evt.wq); |
| |
| /*--- mmoser 3/12/2007 ---*/ |
| MEM_READ_ULONG(pTmpDev, SK_SLOT_0, 0x200, &ulValue); |
| ulValue &= 0x0FFFFFFF; |
| ulValue |= |
| ((gpi_1_mode << 3 | gpi_1_level << 2 | gpi_0_mode << 1 | gpi_0_level) << |
| 28); |
| // printk("mrvlsdio: ulValue = 0x%8.08X\n",ulValue); |
| MEM_WRITE_ULONG(pTmpDev, SK_SLOT_0, 0x200, ulValue); |
| |
| // printk("mrvlsdio: reg[0x200] = 0x%8.08X\n",ulValue); |
| |
| spin_lock_init(&pTmpDev->sd_dev_lock); |
| |
| spin_lock_irqsave(&sd_dev_list_lock, sd_dev_list_lock_flags); |
| list_add_tail((struct list_head *) pTmpDev, &sd_dev_list); |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "%s@%d: sd_dev_list=%p sd_dev_list.prev=%p sd_dev_list.next=%p pTmpDev=%p\n", |
| __FUNCTION__, __LINE__, &sd_dev_list, sd_dev_list.prev, |
| sd_dev_list.next, pTmpDev)); |
| |
| spin_unlock_irqrestore(&sd_dev_list_lock, sd_dev_list_lock_flags); |
| |
| SDHost_Init(pTmpDev); |
| |
| // mmoser 2005-11-29 |
| if (0 != request_irq(pTmpDev->Interrupt, |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) |
| SDIOBus_Isr, SA_SHIRQ, |
| #else |
| (irq_handler_t) SDIOBus_Isr, IRQF_SHARED, |
| #endif |
| MRVL_DEVICE_NAME, (PVOID) pTmpDev) |
| ) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "mrvlsdio: Failed to register interrupt handler\n")); |
| return -ENODEV; |
| } |
| |
| if (SDHost_isCardPresent(pTmpDev) == SK_TRUE) { |
| if (SDIOBus_CardPluggedIn(pTmpDev) == SK_TRUE) { |
| pTmpDev->CardIn = SK_TRUE; |
| } |
| SDHost_EnableInterrupt(pTmpDev, (STDHOST_NORMAL_IRQ_CARD_OUT_SIG_ENA | |
| STDHOST_NORMAL_IRQ_CARD_IN_SIG_ENA)); |
| } |
| #ifdef SYSKT_DMA_MALIGN_TEST |
| pTmpDev->dma_tx_malign = 0; |
| pTmpDev->dma_rx_malign = 0; |
| // pTmpDev->dma_start_malign = 4096 - 32; |
| pTmpDev->dma_start_malign = 0; |
| #endif |
| |
| // mmoser 2005-11-22 start the thread as the last action |
| |
| // mmoser 2005-11-21 |
| pTmpDev->stop_thread = SK_FALSE; |
| |
| pTmpDev->thread_id = kernel_thread(SDIOThread, |
| pTmpDev, |
| (CLONE_FS | CLONE_FILES | |
| CLONE_SIGHAND)); |
| |
| if (pTmpDev->thread_id == 0) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "mrvlsdio: Failed to start kernel thread!\n")); |
| return -1; |
| } else { |
| |
| if (SDHost_wait_event(pTmpDev, &pTmpDev->thread_started_evt, 1000)) { |
| pTmpDev->stop_thread = SK_TRUE; |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) |
| kill_pid(find_get_pid(pTmpDev->thread_id), SIGTERM, 1); |
| #else |
| kill_proc(pTmpDev->thread_id, SIGTERM, 1); |
| #endif |
| pTmpDev->thread_id = 0; |
| DBGPRINT(DBG_ERROR, |
| (KERN_DEBUG |
| "%s @ %d: Wait SDIOThread started ---> FAILED !\n", |
| __FUNCTION__, __LINE__)); |
| return 0; |
| } |
| |
| } |
| |
| return 0; |
| } |
| |
| static void |
| remove(struct pci_dev *dev) |
| { |
| struct list_head *pTmp; |
| struct list_head *pNext; |
| PSD_DEVICE_DATA pTmpDev; |
| int j; |
| SK_U8 ucValue; |
| SK_U32 cnt; |
| |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "remove mrvlsdio ... \n")); |
| |
| /* clean up any allocated resources and stuff here. like call |
| release_region(); */ |
| |
| /* |
| * iterate through the device list |
| * call remove() for each client driver |
| * remove device from list |
| * free allocated memory |
| */ |
| if (!list_empty(&sd_dev_list)) { |
| pTmp = sd_dev_list.next; |
| |
| while (pTmp != &sd_dev_list) { |
| pNext = pTmp->next; |
| pTmpDev = (PSD_DEVICE_DATA) pTmp; |
| if (pTmpDev->dev == dev) { |
| pTmpDev->isRemoving = SK_TRUE; |
| for (j = 1; j <= pTmpDev->number_of_functions; j++) { |
| if (down_interruptible(&sd_client_sema)) |
| return; |
| if (pTmpDev->sd_dev[j].drv != NULL && |
| pTmpDev->sd_dev[j].drv->remove != NULL) { |
| if (pTmpDev->sd_dev[j].remove_called == 0) { |
| pTmpDev->sd_dev[j].probe_called = 0; |
| pTmpDev->sd_dev[j].remove_called = 1; |
| pTmpDev->sd_dev[j].dev = NULL; |
| pTmpDev->sd_dev[j].drv->remove(&pTmpDev->sd_dev[j]); |
| } |
| } |
| up(&sd_client_sema); |
| } |
| |
| if (pTmpDev->thread_id) { |
| pTmpDev->stop_thread = SK_TRUE; |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) |
| kill_pid(find_get_pid(pTmpDev->thread_id), SIGTERM, 1); |
| #else |
| kill_proc(pTmpDev->thread_id, SIGTERM, 1); |
| #endif |
| wait_for_completion(&on_exit); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s: SDIOThread killed ... \n", |
| __FUNCTION__)); |
| } |
| // Send I/O Card Reset |
| SDHost_CMD52_Write((PSD_DEVICE_DATA) pTmp, IO_ABORT_REG, FN0, |
| RES); |
| SDHost_DisableInterrupt((PSD_DEVICE_DATA) pTmp, |
| STDHOST_NORMAL_IRQ_ALL_SIG_ENA); |
| SDHost_SetClock((PSD_DEVICE_DATA) pTmp, 0); |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) |
| cancel_delayed_work(&pTmpDev->card_out_work); |
| cancel_delayed_work(&pTmpDev->irq_work); |
| #endif |
| flush_scheduled_work(); |
| destroy_workqueue(pTmpDev->workqueue); |
| pTmpDev->workqueue = NULL; |
| |
| // set host power voltage as low as possible |
| // (still need despite "turn off host power" below, b/c |
| // hotplug can reactivate host power independently in HW) |
| MEM_WRITE_UCHAR((PSD_DEVICE_DATA) pTmp, SK_SLOT_0, |
| FPGA_POWER_REG_DATA, FPGA_POWER_REG_0_7_V); |
| MEM_WRITE_UCHAR((PSD_DEVICE_DATA) pTmp, SK_SLOT_0, |
| FPGA_POWER_REG_CMD, FPGA_POWER_REG_CMD_START); |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "wait for stable voltage\n")); |
| cnt = 0; |
| do { |
| MEM_READ_UCHAR((PSD_DEVICE_DATA) pTmp, SK_SLOT_0, |
| FPGA_POWER_REG_STATUS, &ucValue); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "PowerRegulatorControl: 0x%x\n", |
| ucValue)); |
| } while (++cnt < 10000 && |
| (ucValue & FPGA_POWER_REG_STABLE) == 0); |
| DBGPRINT(DBG_LOAD, ("REMOVE_SET_VOLTAGE: cnt=%d\n", cnt)); |
| |
| // turn off host power |
| MEM_READ_UCHAR((PSD_DEVICE_DATA) pTmp, SK_SLOT_0, |
| STDHOST_POWER_CTRL, &ucValue); |
| MEM_WRITE_UCHAR((PSD_DEVICE_DATA) pTmp, SK_SLOT_0, |
| STDHOST_POWER_CTRL, |
| ucValue & ~STDHOST_POWER_ON); |
| |
| // give some time for host power off to settle |
| mdelay(200); |
| |
| free_irq(pTmpDev->Interrupt, pTmpDev); |
| for (j = 0; j < pTmpDev->IOBaseIx; j++) |
| iounmap(pTmpDev->IOBase[j]); |
| /*--- mmoser 10/11/2006 ---*/ |
| pci_release_regions(pTmpDev->dev); |
| |
| list_del((struct list_head *) pTmpDev); |
| kfree(pTmpDev); |
| |
| #ifdef SDIO_MEM_TRACE |
| printk("<<< kfree(SD_DEVICE_DATA)\n"); |
| #endif |
| |
| return; |
| } |
| pTmp = pNext; |
| } |
| } |
| |
| } |
| |
| BOOLEAN |
| SDIOBus_CardRemoved(PSD_DEVICE_DATA SdData) |
| { |
| SK_U32 ulVal; |
| |
| ENTER(); |
| |
| #ifdef USE_DEBOUNCE_CARD_IN |
| |
| /*--- mmoser 12/21/2006 ---*/ |
| mdelay(MAX_DEBOUNCE_TIME); |
| |
| // Read present state register to check whether a SD card is present |
| MEM_READ_ULONG(SdData, SK_SLOT_0, STDHOST_PRESENT_STATE, &ulVal); |
| if ((ulVal & STDHOST_STATE_CARD_INSERTED) == 1) { |
| // There is probably still a card in the socket |
| DBGPRINT(DBG_W528D, |
| (KERN_DEBUG |
| "SDHost_isCardPresent(): Card is present. (%8.08X)\n", |
| ulVal)); |
| return SK_FALSE; |
| } |
| #endif // USE_DEBOUNCE_CARD_IN |
| |
| SdData->CardIn = SK_FALSE; |
| |
| // mmoser 2005-11-29 |
| queue_work(SdData->workqueue, &SdData->card_out_work); |
| |
| LEAVE(); |
| return SK_TRUE; |
| } |
| |
| BOOLEAN |
| SDIOBus_CardPluggedIn(PSD_DEVICE_DATA SdData) |
| { |
| SK_U32 ulVal; |
| |
| ENTER(); |
| |
| #ifdef USE_DEBOUNCE_CARD_IN |
| |
| /*--- mmoser 12/21/2006 ---*/ |
| mdelay(MAX_DEBOUNCE_TIME); |
| |
| // Read present state register to check whether a SD card is present |
| MEM_READ_ULONG(SdData, SK_SLOT_0, STDHOST_PRESENT_STATE, &ulVal); |
| if ((ulVal & STDHOST_STATE_CARD_INSERTED) == 0) { |
| // There is probably no card in the socket |
| DBGPRINT(DBG_W528D, |
| (KERN_DEBUG |
| "SDHost_isCardPresent(): Card is NOT present. (%8.08X)\n", |
| ulVal)); |
| return SK_FALSE; |
| } |
| #endif // USE_DEBOUNCE_CARD_IN |
| |
| SDHost_Init(SdData); |
| |
| if (!SDHost_InitializeCard(SdData)) { |
| SDHost_EnableInterrupt(SdData, SdData->lastIRQSignalMask); |
| return SK_FALSE; |
| } |
| SdData->CardIn = SK_TRUE; |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "Device Name : %s\n", SdData->DeviceName)); |
| |
| // mmoser 2005-11-29 |
| atomic_inc(&SdData->card_add_event); |
| LEAVE(); |
| return SK_TRUE; |
| } |
| |
| static int |
| SDIOThread(void *data) |
| { |
| SK_U16 usVal; |
| SK_U32 card_in = 0; |
| SK_U32 card_out = 0; |
| PSD_DEVICE_DATA pDev; |
| int clients_found; |
| int fn = 0; |
| int j; |
| struct list_head *pTmp; |
| PSD_CLIENT pClientTmp; |
| int fn_mask; |
| u8 attached_fn[MAX_SDIO_FUNCTIONS]; |
| |
| daemonize("SDIOThread"); |
| allow_signal(SIGTERM); |
| |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "SDIOThread() started ... \n")); |
| |
| if (data == NULL) { |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "SDIOThread() data == NULL !\n")); |
| complete_and_exit(&on_exit, 0); |
| return 1; |
| } |
| pDev = (PSD_DEVICE_DATA) data; |
| |
| LED_OFF(4); |
| |
| if (!test_and_set_bit(0, &pDev->thread_started_evt.event)) { |
| wake_up(&pDev->thread_started_evt.wq); |
| } |
| |
| while (pDev != NULL && !pDev->stop_thread) { |
| LED_ON(4); |
| |
| // mmoser 2005-11-21 |
| // Read the Host Controller Version to check if SD Host adapter is |
| // available |
| MEM_READ_USHORT(pDev, SK_SLOT_0, STDHOST_HOST_CONTROLLER_VERSION, |
| &usVal); |
| if (usVal == 0xFFFF) { |
| // There is probably no SD Host Adapter available |
| printk("%s: SD Host Adapter is NOT present.\n", __FUNCTION__); |
| pDev->SurpriseRemoved = SK_TRUE; |
| pDev->CardIn = SK_FALSE; |
| pDev->thread_id = 0; |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "SDIOThread terminated ... \n")); |
| complete_and_exit(&on_exit, 0); |
| return -ENODEV; |
| } |
| // mmoser 2005-11-29 |
| card_in = atomic_read(&pDev->card_add_event); |
| card_out = atomic_read(&pDev->card_remove_event); |
| |
| if (card_in == 0 && card_out == 0) { |
| LED_OFF(4); |
| /*--- mmoser 6/21/2006 ---*/ |
| set_current_state(TASK_INTERRUPTIBLE); |
| schedule_timeout(10); |
| continue; |
| } |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s: card_in=%d card_out=%d\n", __FUNCTION__, |
| card_in, card_out)); |
| |
| // mmoser 2005-11-29 |
| if (card_in > 0) { |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s: CARD_ADD_EVENT received.\n", |
| __FUNCTION__)); |
| |
| // Check whether we have a client driver in the global list for |
| // this device |
| if (!list_empty(&sd_client_list)) { |
| spin_lock_irqsave(&sd_client_list_lock, |
| sd_client_list_lock_flags); |
| |
| fn = pDev->number_of_functions + 1; |
| |
| clients_found = 0; |
| |
| // walk through the list of client drivers |
| list_for_each(pTmp, &sd_client_list) { |
| pClientTmp = (PSD_CLIENT) pTmp; |
| if ((fn_mask = sd_match_device(pClientTmp->drv, pDev)) > 0) { |
| // Matching client driver found |
| // Assign the client driver to the lowest supported |
| // function |
| for (fn = 1; fn <= pDev->number_of_functions; fn++) { |
| if ((fn_mask & (1 << fn)) != 0) { |
| pDev->sd_dev[fn].drv = pClientTmp->drv; |
| pDev->sd_dev[fn].supported_functions = fn_mask; |
| pDev->sd_dev[fn].cisptr = &pDev->cisptr[0]; |
| pDev->sd_dev[fn].sd_bus = pDev; // Backpointer |
| // to bus |
| // driver's |
| // device |
| // structure |
| pDev->sd_dev[fn].dev = &pDev->dev->dev; // Generic |
| // device |
| // interface |
| // for |
| // hotplug |
| attached_fn[clients_found] = fn; |
| clients_found++; |
| break; |
| } |
| } |
| } |
| } |
| |
| spin_unlock_irqrestore(&sd_client_list_lock, |
| sd_client_list_lock_flags); |
| |
| if (clients_found) { |
| // Call probe() for each previously attached client driver |
| for (j = 0; j < clients_found; j++) { |
| fn = attached_fn[j]; |
| if (pDev->sd_dev[fn].drv->probe != NULL) { |
| if (pDev->sd_dev[fn].probe_called == 0) { |
| DBGPRINT(DBG_LOAD | DBG_ERROR, |
| (KERN_DEBUG |
| "%s: call probe() handler on fn=%d\n", |
| __FUNCTION__, fn)); |
| |
| pDev->SurpriseRemoved = 0; |
| pDev->sd_dev[fn].probe_called = 1; |
| pDev->sd_dev[fn].remove_called = 0; |
| call_client_probe(pDev, fn); |
| } |
| } else { |
| // If we have no probe() handler at this point, we |
| // will never get one. |
| // So discard the CARD_ADD_EVENT to avoid an |
| // endless loop. |
| // This situation is considered a bug in the client |
| // driver !!!! |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "%s@%d: no probe() handler installed for fn=%d! Revise client driver!!!\n", |
| __FUNCTION__, __LINE__, fn)); |
| } |
| } |
| } else { |
| // There is at least one client driver registered with our |
| // bus driver |
| // but the sd_device_ids of this driver does not match the |
| // ids of the inserted card. |
| // We have to wait until a matching driver will be |
| // installed. |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "%s@%d: no matching client driver installed.\n", |
| __FUNCTION__, __LINE__)); |
| } |
| } else { |
| // Until there is no client driver registered with our bus |
| // driver. |
| |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s@%d: no client driver installed.\n", |
| __FUNCTION__, __LINE__)); |
| } |
| |
| // We can reset the card event here since the association with a |
| // matching client driver |
| // is already done or will be done in sd_register_driver() |
| atomic_set(&pDev->card_add_event, 0); |
| |
| } |
| // mmoser 2005-11-29 |
| else if (card_out > 0) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s: CARD_REMOVE_EVENT received.\n", |
| __FUNCTION__)); |
| for (j = 1; j <= pDev->number_of_functions; j++) { |
| if (down_interruptible(&sd_client_sema)) |
| return 0; |
| if (pDev->sd_dev[j].drv != NULL && |
| pDev->sd_dev[j].drv->remove != NULL) { |
| if (pDev->sd_dev[j].remove_called == 0) { |
| DBGPRINT(DBG_LOAD | DBG_ERROR, |
| (KERN_DEBUG |
| "%s: call remove() handler on fn=%d\n", |
| __FUNCTION__, j)); |
| |
| pDev->sd_dev[j].probe_called = 0; |
| pDev->sd_dev[j].remove_called = 1; |
| pDev->sd_dev[j].dev = NULL; |
| pDev->sd_dev[j].drv->remove(&pDev->sd_dev[j]); |
| } |
| } else { |
| // If we have no remove() handler at this point, we will |
| // never get one. |
| // So discard the CARD_REMOVE_EVENT to avoid an endless |
| // loop. |
| // This situation is considered a bug in the client driver |
| // !!!! |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "%s: no remove() handler installed for fn=%d! Revise client driver!!!\n", |
| __FUNCTION__, j)); |
| } |
| up(&sd_client_sema); |
| } |
| atomic_set(&pDev->card_remove_event, 0); |
| } else { |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "SDIOThread terminated ... \n")); |
| pDev->thread_id = 0; |
| complete_and_exit(&on_exit, 0); |
| return 1; |
| } |
| } |
| |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "SDIOThread terminated ... \n")); |
| |
| if (pDev != NULL) { |
| pDev->thread_id = 0; |
| } |
| |
| complete_and_exit(&on_exit, 0); |
| |
| return 0; |
| } |
| |
| /************************* New SDIO Bus Driver API ************************/ |
| |
| /** |
| * @brief This function matches a client driver with a SDIO device |
| * @param drv pointer to client drivers device IDs |
| * @param dev pointer to SDIO device |
| * @return mask with supported functions -> 0 means no match found |
| * |
| * 76543210 |
| * ||||||+-- fn 1 supported |
| * |||||+--- fn 2 supported |
| * ||||+---- fn 3 supported |
| * |||+----- fn 4 supported |
| * ||+------ fn 5 supported |
| * |+------- fn 6 supported |
| * +-------- fn 7 supported |
| * |
| * 0x02 -> fn 1 supported |
| * 0x06 -> fn 1 and 2 supported |
| * 0x12 -> fn 1 and 4 supported |
| */ |
| int |
| sd_match_device(sd_driver * drv, PSD_DEVICE_DATA dev) |
| { |
| psd_device_id pIds; |
| int i; |
| int matched_fn = 0; |
| int fn_mask = 0; |
| |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG |
| "%s: drv-name: %s device: vendor=0x%4.04X device=0x%4.04X\n", |
| __FUNCTION__, drv->name, dev->sd_ids[0].vendor, |
| dev->sd_ids[0].device)); |
| |
| for (pIds = drv->ids; pIds->device != 0 || |
| pIds->vendor != 0 || pIds->class != 0 || pIds->fn != 0; pIds++) { |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG |
| "vendor=0x%4.04X device=0x%4.04X class=0x%4.04X fn=0x%4.04X\n", |
| pIds->vendor, pIds->device, pIds->class, pIds->fn)); |
| if ((pIds->vendor != SD_VENDOR_ANY) && |
| (pIds->vendor != dev->sd_ids[0].vendor)) { |
| continue; |
| } |
| if (pIds->device != SD_DEVICE_ANY) { |
| matched_fn = 0; |
| for (i = 0; i <= dev->number_of_functions; i++) { |
| if (pIds->device == dev->sd_ids[i].device) { |
| matched_fn = i; |
| fn_mask |= (1 << matched_fn); |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG "driver matches with function %d\n", |
| i)); |
| break; |
| } |
| } |
| if (matched_fn == 0) { |
| continue; |
| } |
| } |
| if (pIds->class != SD_CLASS_ANY) { |
| matched_fn = 0; |
| for (i = 1; i <= dev->number_of_functions; i++) { |
| // printk("fn[%d] class-id=0x%4.04X\n",i,dev->sd_ids[i].class); |
| if (pIds->class == dev->sd_ids[i].class) { |
| matched_fn = i; |
| fn_mask |= (1 << matched_fn); |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG "driver matches with function %d\n", |
| i)); |
| break; |
| } |
| } |
| if (matched_fn == 0) { |
| continue; |
| } |
| } else { |
| // At this point vendor==ANY && device==ANY && class==ANY |
| // Now we have to check whether the card supports the desired |
| // function number |
| if (pIds->fn > 0 && pIds->fn <= dev->number_of_functions) { |
| matched_fn = pIds->fn; |
| fn_mask |= (1 << matched_fn); |
| } |
| } |
| |
| if ((pIds->fn != SD_FUNCTION_ANY) && (pIds->fn != matched_fn)) { |
| continue; |
| } |
| } |
| |
| printk("%s: supported function mask = 0x%2.02X\n", __FUNCTION__, fn_mask); |
| return (fn_mask); |
| } |
| |
| /** |
| * @brief This function registers a client driver with the bus driver using device IDs |
| * @param drv pointer to client drivers device IDs and call backs |
| * @return 0 : Success < 0: Failed |
| */ |
| int |
| sd_driver_register(sd_driver * drv) |
| { |
| struct list_head *pTmp; |
| PSD_CLIENT pClientTmp; |
| PSD_DEVICE_DATA pDevTmp; |
| int fn_mask; |
| int fn; |
| |
| GET_IF_SEMA(); |
| |
| ENTER(); |
| |
| pClientTmp = (PSD_CLIENT) kmalloc(sizeof(SD_CLIENT), GFP_KERNEL); |
| |
| if (pClientTmp == NULL) { |
| REL_IF_SEMA(); |
| LEAVE(); |
| return -ENOMEM; |
| } |
| #ifdef SDIO_MEM_TRACE |
| printk(">>> kmalloc(SD_CLIENT)\n"); |
| #endif |
| |
| memset(pClientTmp, 0, sizeof(SD_CLIENT)); |
| |
| pClientTmp->drv = drv; |
| |
| // Check whether there is a SDIO device available |
| if (!list_empty(&sd_dev_list)) { |
| list_for_each(pTmp, &sd_dev_list) { |
| pDevTmp = (PSD_DEVICE_DATA) pTmp; |
| |
| spin_lock_irqsave(&pDevTmp->sd_dev_lock, |
| pDevTmp->sd_dev_lock_flags); |
| if ((fn_mask = sd_match_device(drv, pDevTmp)) > 0) { |
| // Assign the client driver to the lowest supported function |
| for (fn = 1; fn <= pDevTmp->number_of_functions; fn++) { |
| if ((fn_mask & (1 << fn)) != 0) { |
| break; |
| } |
| } |
| if (fn <= |
| MIN(pDevTmp->number_of_functions, MAX_SDIO_FUNCTIONS - 1)) { |
| if (pDevTmp->sd_dev[fn].drv == NULL) { |
| pDevTmp->sd_dev[fn].drv = drv; |
| pDevTmp->sd_dev[fn].supported_functions = fn_mask; |
| pDevTmp->sd_dev[fn].cisptr = &pDevTmp->cisptr[0]; |
| pDevTmp->sd_dev[fn].sd_bus = pDevTmp; // Backpointer |
| // to bus |
| // driver's |
| // device |
| // structure |
| pDevTmp->sd_dev[fn].dev = &pDevTmp->dev->dev; // Generic |
| // device |
| // interface |
| // for |
| // hotplug |
| |
| spin_unlock_irqrestore(&pDevTmp->sd_dev_lock, |
| pDevTmp->sd_dev_lock_flags); |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG |
| "%s: Driver registered: %s for functions 0x%2.02X\n", |
| __FUNCTION__, pDevTmp->sd_dev[fn].drv->name, |
| fn_mask)); |
| |
| if (pDevTmp->sd_dev[fn].drv->probe != NULL) { |
| pDevTmp->sd_dev[fn].probe_called = 1; |
| pDevTmp->sd_dev[fn].remove_called = 0; |
| |
| DBGPRINT(DBG_LOAD | DBG_ERROR, |
| (KERN_DEBUG |
| "%s: call probe() handler on fn=%d\n", |
| __FUNCTION__, fn)); |
| REL_IF_SEMA(); |
| call_client_probe(pDevTmp, fn); |
| GET_IF_SEMA(); |
| } else { |
| // If we have no probe() handler at this point, we |
| // will never get one. |
| // This situation is considered a bug in the client |
| // driver !!!! |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG |
| "%s@%d: no probe() handler installed for fn=%d! Revise client driver!!!\n", |
| __FUNCTION__, __LINE__, fn)); |
| } |
| break; |
| } else { |
| spin_unlock_irqrestore(&pDevTmp->sd_dev_lock, |
| pDevTmp->sd_dev_lock_flags); |
| continue; |
| } |
| } |
| } else { |
| spin_unlock_irqrestore(&pDevTmp->sd_dev_lock, |
| pDevTmp->sd_dev_lock_flags); |
| continue; |
| } |
| |
| } |
| DBGPRINT(DBG_API, |
| (KERN_ERR |
| "%s: There are already drivers registered for all devices!\n", |
| __FUNCTION__)); |
| } |
| // Add driver to global client list |
| spin_lock_irqsave(&sd_client_list_lock, sd_client_list_lock_flags); |
| list_add_tail((struct list_head *) pClientTmp, &sd_client_list); |
| spin_unlock_irqrestore(&sd_client_list_lock, sd_client_list_lock_flags); |
| |
| REL_IF_SEMA(); |
| LEAVE(); |
| return 0; |
| } |
| |
| /** |
| * @brief This function unregisters a client driver from the bus driver |
| * @param drv pointer to client drivers device IDs and call backs |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_driver_unregister(sd_driver * drv) |
| { |
| struct list_head *pTmp; |
| PSD_CLIENT pClientTmp; |
| PSD_DEVICE_DATA pDevTmp; |
| int j; |
| |
| ENTER(); |
| |
| if (drv == NULL) { |
| printk("%s INVALID ARGS: drv==NULL!\n", __FUNCTION__); |
| LEAVE(); |
| return -1; |
| } |
| |
| if (down_interruptible(&sd_client_sema)) |
| return 0; |
| // Delete any association with this client driver |
| spin_lock_irqsave(&sd_dev_list_lock, sd_dev_list_lock_flags); |
| if (!list_empty(&sd_dev_list)) { |
| list_for_each(pTmp, &sd_dev_list) { |
| pDevTmp = (PSD_DEVICE_DATA) pTmp; |
| spin_unlock_irqrestore(&sd_dev_list_lock, sd_dev_list_lock_flags); |
| for (j = 0; j < MAX_SDIO_FUNCTIONS; j++) { |
| if (pDevTmp->sd_dev[j].drv == drv) { |
| |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG |
| "%s: Driver unregistered: %s on fn = %d\n", |
| __FUNCTION__, pDevTmp->sd_dev[j].drv->name, j)); |
| |
| if (drv != NULL && drv->remove != NULL) { |
| if (pDevTmp->sd_dev[j].remove_called == 0) { |
| pDevTmp->sd_dev[j].probe_called = 0; |
| pDevTmp->sd_dev[j].remove_called = 1; |
| if (pDevTmp->SurpriseRemoved == SK_TRUE) |
| pDevTmp->sd_dev[j].dev = NULL; |
| pDevTmp->sd_dev[j].drv->remove(&pDevTmp->sd_dev[j]); |
| } |
| } |
| |
| spin_lock_irqsave(&pDevTmp->sd_dev_lock, |
| pDevTmp->sd_dev_lock_flags); |
| pDevTmp->sd_dev[j].drv = NULL; |
| spin_unlock_irqrestore(&pDevTmp->sd_dev_lock, |
| pDevTmp->sd_dev_lock_flags); |
| } |
| } |
| } |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: Driver %s is not registered!\n", __FUNCTION__, |
| drv->name)); |
| } else { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: SDIO Device List is empty!\n", __FUNCTION__)); |
| spin_unlock_irqrestore(&sd_dev_list_lock, sd_dev_list_lock_flags); |
| } |
| up(&sd_client_sema); |
| |
| GET_IF_SEMA(); |
| // Remove the client driver from global client list |
| if (!list_empty(&sd_client_list)) { |
| spin_lock_irqsave(&sd_client_list_lock, sd_client_list_lock_flags); |
| |
| list_for_each(pTmp, &sd_client_list) { |
| pClientTmp = (PSD_CLIENT) pTmp; |
| if (pClientTmp->drv != drv) { |
| continue; |
| } |
| |
| list_del(pTmp); |
| kfree(pClientTmp); |
| |
| #ifdef SDIO_MEM_TRACE |
| printk("<<< kfree(SD_CLIENT)\n"); |
| #endif |
| |
| break; |
| } |
| |
| spin_unlock_irqrestore(&sd_client_list_lock, sd_client_list_lock_flags); |
| } else { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: SDIO Client Driver List is empty!\n", |
| __FUNCTION__)); |
| REL_IF_SEMA(); |
| LEAVE(); |
| return -1; |
| } |
| |
| REL_IF_SEMA(); |
| LEAVE(); |
| return 0; |
| } |
| |
| /** |
| * @brief Register an interrupt handler with a card function |
| * @param dev bus driver's device structure |
| * @param id sd_device_ids (contains function number) |
| * @param function interrupt handler |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_request_int(sd_device * dev, sd_device_id * id, sd_function * function) |
| { |
| PSD_DEVICE_DATA pDev; |
| |
| if (dev == NULL || id == NULL || function == NULL) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: missing parameters: dev=%p id=%p function=%p\n", |
| __FUNCTION__, dev, id, function)); |
| return -1; |
| } |
| |
| if (id->fn < 1 || id->fn > 7) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: illegal function number: %d\n", __FUNCTION__, |
| id->fn)); |
| return -1; |
| } |
| if (dev->functions[id->fn].int_handler != NULL) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR |
| "%s: There is already an interrupt handler registered with function %d\n", |
| __FUNCTION__, id->fn)); |
| return -1; |
| } |
| |
| GET_IF_SEMA(); |
| |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG "%s: FN%d handler=%p context=%p\n", __FUNCTION__, |
| id->fn, function->int_handler, function->context)); |
| |
| pDev = (PSD_DEVICE_DATA) dev->sd_bus; |
| |
| SDHost_DisableInterrupt((PSD_DEVICE_DATA) dev->sd_bus, |
| STDHOST_NORMAL_IRQ_CARD_ALL_ENA); |
| dev->functions[id->fn].int_handler = function->int_handler; |
| dev->functions[id->fn].context = function->context; |
| |
| // cache the device to speed up irq response |
| pDev->irq_device_cache[id->fn] = dev; |
| SDHost_EnableInterrupt((PSD_DEVICE_DATA) dev->sd_bus, |
| pDev->lastIRQSignalMask); |
| |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Remove an interrupt handler from a card function |
| * @param dev bus driver's device structure |
| * @param id sd_device_ids (contains function number) |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_release_int(sd_device * dev, sd_device_id * id) |
| { |
| PSD_DEVICE_DATA pDev; |
| |
| if (dev == NULL || id == NULL) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: missing parameters: dev=%p id=%p\n", |
| __FUNCTION__, dev, id)); |
| return -1; |
| } |
| if (id->fn < 1 || id->fn > 7) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: illegal function number: %d\n", __FUNCTION__, |
| id->fn)); |
| return -1; |
| } |
| |
| GET_IF_SEMA(); |
| |
| pDev = (PSD_DEVICE_DATA) dev->sd_bus; |
| |
| DBGPRINT(DBG_API, (KERN_DEBUG "%s: FN%d\n", __FUNCTION__, id->fn)); |
| |
| SDHost_DisableInterrupt((PSD_DEVICE_DATA) dev->sd_bus, |
| STDHOST_NORMAL_IRQ_CARD_ALL_ENA); |
| dev->functions[id->fn].int_handler = NULL; |
| dev->functions[id->fn].context = NULL; |
| |
| pDev->irq_device_cache[id->fn] = NULL; |
| SDHost_EnableInterrupt((PSD_DEVICE_DATA) dev->sd_bus, |
| pDev->lastIRQSignalMask); |
| |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Enable interrupt of function id->fn |
| * @param dev bus driver's device structure |
| * @param id sd_device_ids (contains function number) |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_unmask(sd_device * dev, sd_device_id * id) |
| { |
| PSD_DEVICE_DATA pDev; |
| if (dev == NULL || id == NULL) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: missing parameters: dev=%p id=%p\n", |
| __FUNCTION__, dev, id)); |
| return 1; |
| } |
| if (id->fn < 1 || id->fn > 7) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: illegal function number: %d\n", __FUNCTION__, |
| id->fn)); |
| return -1; |
| } |
| |
| GET_IF_SEMA(); |
| |
| pDev = dev->sd_bus; |
| SDHost_EnableInterrupt(pDev, STDHOST_NORMAL_IRQ_CARD_ALL_ENA); |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Enable interrupt of function id->fn |
| * @param dev bus driver's device structure |
| * @param id sd_device_ids (contains function number) |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_enable_int(sd_device * dev, sd_device_id * id) |
| { |
| PSD_DEVICE_DATA pDev; |
| SK_U8 R; |
| |
| if (dev == NULL || id == NULL) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: missing parameters: dev=%p id=%p\n", |
| __FUNCTION__, dev, id)); |
| return 1; |
| } |
| if (id->fn < 1 || id->fn > 7) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: illegal function number: %d\n", __FUNCTION__, |
| id->fn)); |
| return -1; |
| } |
| |
| GET_IF_SEMA(); |
| |
| pDev = dev->sd_bus; |
| |
| // Set global interrupt enable |
| if (!SDHost_CMD52_Read(pDev, INT_ENABLE_REG, 0, &R)) { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| R |= (1 << id->fn); |
| if (SDHost_CMD52_Write(pDev, INT_ENABLE_REG, 0, R)) { |
| if (!SDHost_CMD52_Read(pDev, INT_ENABLE_REG, 0, &R)) { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG "%s:FN0 : INT Enable Register: 0x%2.02X\n", |
| __FUNCTION__, R)); |
| } else { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| SDHost_EnableInterrupt(pDev, STDHOST_NORMAL_IRQ_CARD_ALL_ENA); |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Disable interrupt of function id->fn |
| * @param dev bus driver's device structure |
| * @param id sd_device_ids (contains function number) |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_disable_int(sd_device * dev, sd_device_id * id) |
| { |
| PSD_DEVICE_DATA pDev; |
| SK_U8 R; |
| |
| if (dev == NULL || id == NULL) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: missing parameters: dev=%p id=%p\n", |
| __FUNCTION__, dev, id)); |
| return -1; |
| } |
| if (id->fn < 1 || id->fn > 7) { |
| DBGPRINT(DBG_API, |
| (KERN_ERR "%s: illegal function number: %d\n", __FUNCTION__, |
| id->fn)); |
| return -1; |
| } |
| |
| GET_IF_SEMA(); |
| |
| pDev = dev->sd_bus; |
| |
| // Set global interrupt enable |
| if (!SDHost_CMD52_Read(pDev, INT_ENABLE_REG, 0, &R)) { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| R &= ~(1 << id->fn); |
| if (SDHost_CMD52_Write(pDev, INT_ENABLE_REG, 0, R)) { |
| if (!SDHost_CMD52_Read(pDev, INT_ENABLE_REG, 0, &R)) { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| DBGPRINT(DBG_API, |
| (KERN_DEBUG "%s:FN0 : INT Disable Register: 0x%2.02X\n", |
| __FUNCTION__, R)); |
| } else { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Set SDIO bus width |
| * @param dev bus driver's device structure |
| * @param with SDIO bus with 1 or 4 |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_set_buswidth(sd_device * dev, int width) |
| { |
| SK_BOOL rc; |
| GET_IF_SEMA(); |
| |
| if (width == 1 || width == 4) { |
| DBGPRINT(DBG_API, (KERN_DEBUG "%s: width = %d\n", __FUNCTION__, width)); |
| rc = SDHost_SetBusWidth((PSD_DEVICE_DATA) dev->sd_bus, width); |
| REL_IF_SEMA(); |
| return (rc ? 0 : -1); |
| } else { |
| REL_IF_SEMA(); |
| return -1; |
| } |
| } |
| |
| /** |
| * @brief Set GPO on or off |
| * @param dev bus driver's device structure |
| * @param on 1: turn GPO on 0: turn GPO off |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_set_gpo(sd_device * dev, int on) |
| { |
| SK_BOOL rc; |
| |
| GET_IF_SEMA(); |
| DBGPRINT(DBG_API, (KERN_DEBUG "%s: on = %d\n", __FUNCTION__, on)); |
| rc = SDHost_SetGPO((PSD_DEVICE_DATA) dev->sd_bus, on); |
| |
| REL_IF_SEMA(); |
| return (rc ? 0 : -1); |
| } |
| |
| /** |
| * @brief Set SDIO bus clock on |
| * @param dev bus driver's device structure |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_start_clock(sd_device * dev) |
| { |
| GET_IF_SEMA(); |
| DBGPRINT(DBG_API, (KERN_DEBUG "%s\n", __FUNCTION__)); |
| SDHost_SetClock((PSD_DEVICE_DATA) dev->sd_bus, 1); |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Set SDIO bus clock on |
| * @param dev bus driver's device structure |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_stop_clock(sd_device * dev) |
| { |
| GET_IF_SEMA(); |
| DBGPRINT(DBG_API, (KERN_DEBUG "%s\n", __FUNCTION__)); |
| SDHost_SetClock((PSD_DEVICE_DATA) dev->sd_bus, 0); |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Set SDIO bus clock |
| * @param dev bus driver's device structure |
| * @param clock SDIO bus clock frequency |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sd_set_busclock(sd_device * dev, int clock) |
| { |
| GET_IF_SEMA(); |
| DBGPRINT(DBG_API, (KERN_DEBUG "%s: clock = %d\n", __FUNCTION__, clock)); |
| SDHost_SetClockSpeed((PSD_DEVICE_DATA) dev->sd_bus, clock); |
| REL_IF_SEMA(); |
| return 0; |
| } |
| |
| /** |
| * @brief Read a byte from SDIO device |
| * @param dev bus driver's device structure |
| * @param fn function number 0..7 |
| * @param reg register offset |
| * @param dat pointer to return value |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sdio_read_ioreg(sd_device * dev, u8 fn, u32 reg, u8 * dat) |
| { |
| GET_IF_SEMA(); |
| if (SDHost_CMD52_Read((PSD_DEVICE_DATA) dev->sd_bus, reg, fn, dat)) { |
| // printk("%s: dev=%p fn=%d reg=0x%8.08X dat=0x%2.02x\n",__FUNCTION__,dev,fn,reg,*dat); |
| REL_IF_SEMA(); |
| return 0; |
| } else { |
| printk("%s: dev=%p fn=%d reg=0x%8.08X FAILED!\n", __FUNCTION__, dev, fn, |
| reg); |
| REL_IF_SEMA(); |
| return -1; |
| } |
| |
| } |
| |
| /** |
| * @brief Write a byte to SDIO device |
| * @param dev bus driver's device structure |
| * @param fn function number 0..7 |
| * @param reg register offset |
| * @param dat value |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sdio_write_ioreg(sd_device * dev, u8 fn, u32 reg, u8 dat) |
| { |
| GET_IF_SEMA(); |
| if (SDHost_CMD52_Write((PSD_DEVICE_DATA) dev->sd_bus, reg, fn, dat)) { |
| // printk("%s: dev=%p fn=%d reg=0x%8.08X dat=0x%2.02x\n",__FUNCTION__,dev,fn,reg,dat); |
| REL_IF_SEMA(); |
| return 0; |
| } else { |
| printk("%s: dev=%p fn=%d reg=0x%8.08X FAILED!\n", __FUNCTION__, dev, fn, |
| reg); |
| REL_IF_SEMA(); |
| return -1; |
| } |
| } |
| |
| /** |
| * @brief Read multiple bytes from SDIO device |
| * @param dev bus driver's device structure |
| * @param fn function number 0..7 |
| * @param address offset |
| * @param blkmode block or byte mode |
| * @param opcode fixed or auto-inc address |
| * @param blkcnt number of bytes or blocks (depends on blkmode) |
| * @param blksz size of block |
| * @param buffer pointer to data buffer |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sdio_read_iomem(sd_device * dev, u8 fn, u32 address, u8 blkmode, u8 opcode, |
| u32 blkcnt, u32 blksz, u8 * buffer) |
| { |
| // printk("%s: dev=%p fn=%d address=0x%8.08X blockcnt=%d blocksize=%d\n",__FUNCTION__,dev,fn,address,blkcnt,blksz); |
| |
| GET_IF_SEMA(); |
| if (SDHost_CMD53_ReadEx |
| ((PSD_DEVICE_DATA) dev->sd_bus, address, fn, blkmode, opcode, buffer, |
| blkcnt, blksz)) { |
| REL_IF_SEMA(); |
| return 0; |
| } else { |
| printk("%s: dev=%p fn=%d FAILED!\n", __FUNCTION__, dev, fn); |
| REL_IF_SEMA(); |
| return -1; |
| } |
| } |
| |
| /** |
| * @brief Write multiple bytes to SDIO device |
| * @param dev bus driver's device structure |
| * @param fn function number 0..7 |
| * @param address offset |
| * @param blkmode block or byte mode |
| * @param opcode fixed or auto-inc address |
| * @param blkcnt number of bytes or blocks (depends on blkmode) |
| * @param blksz size of block |
| * @param buffer pointer to data buffer |
| * @return 0 : Success -1: Failed |
| */ |
| int |
| sdio_write_iomem(sd_device * dev, u8 fn, u32 address, u8 blkmode, u8 opcode, |
| u32 blkcnt, u32 blksz, u8 * buffer) |
| { |
| // printk("%s: dev=%p fn=%d address=0x%8.08X blockcnt=%d blocksize=%d\n",__FUNCTION__,dev,fn,address,blkcnt,blksz); |
| GET_IF_SEMA(); |
| if (SDHost_CMD53_WriteEx |
| ((PSD_DEVICE_DATA) dev->sd_bus, address, fn, blkmode, opcode, buffer, |
| blkcnt, blksz)) { |
| REL_IF_SEMA(); |
| return 0; |
| } else { |
| printk("%s: dev=%p fn=%d FAILED!\n", __FUNCTION__, dev, fn); |
| REL_IF_SEMA(); |
| return -1; |
| } |
| } |
| |
| // for filling the "/proc/mrvsdio" entry |
| int |
| mrvlsdio_read_procmem(char *buf, |
| char **start, |
| off_t offset, int count, int *eof, void *data) |
| { |
| PSD_DEVICE_DATA pDevTmp; |
| int len = 0; |
| |
| if (!list_empty(&sd_dev_list)) { |
| pDevTmp = (PSD_DEVICE_DATA) sd_dev_list.next; |
| |
| // after probe-event, we have "good" data in /proc/mrvsdio |
| len = |
| sprintf(buf, |
| "mrvlsdio is running with:\nbus_type = 0x%x\nbus_with = 0x%x\nclock_speed = 0x%x\ndebug_flags = 0x%x\nsdio_voltage = 0x%x\n", |
| pDevTmp->bus_type, pDevTmp->bus_width, pDevTmp->ClockSpeed, |
| pDevTmp->debug_flags, pDevTmp->sdio_voltage); |
| } else { |
| // not probed yet |
| len = sprintf(buf, "mrvlsdio is up and waiting for card\n"); |
| } |
| |
| *eof = 1; |
| return (len); |
| } |
| |
| static void |
| call_client_probe(PSD_DEVICE_DATA pDev, int fn) |
| { |
| |
| if (down_interruptible(&sd_client_sema)) |
| return; |
| if (pDev->sd_dev[fn].drv->probe != NULL) { |
| pDev->sd_dev[fn].drv->probe(&pDev->sd_dev[fn], &pDev->sd_ids[fn]); |
| } |
| up(&sd_client_sema); |
| } |
| |
| static int |
| mrvlsdio_init_module(void) |
| { |
| int ret; |
| |
| ENTER(); |
| |
| // generate /proc/ entry |
| create_proc_read_entry("mrvlsdio", // entry in "/proc/mrvlsdio" |
| 0, // file attributes |
| NULL, // parent dir |
| mrvlsdio_read_procmem, // name of function |
| NULL); // client data |
| |
| DBGPRINT(DBG_ALL, ("*** mrvlsdio ***\n")); |
| DBGPRINT(DBG_ALL, ("*** multifunction API ***\n")); |
| DBGPRINT(DBG_ALL, ("*** Built on %s %s ***\n", __DATE__, __TIME__)); |
| |
| /*--- mmoser 6/21/2007 ---*/ |
| INIT_LIST_HEAD(&sd_dev_list); |
| spin_lock_init(&sd_dev_list_lock); |
| |
| INIT_LIST_HEAD(&sd_client_list); |
| spin_lock_init(&sd_client_list_lock); |
| |
| ret = register_chrdev(sdio_major, "mrvlsdio", &mrvlsdio_fops); |
| if (ret < 0) { |
| DBGPRINT(DBG_LOAD, |
| (KERN_WARNING "mrvlsdio: can't get major %d ret=%d\n", |
| sdio_major, ret)); |
| } else { |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "mrvlsdio: major %d\n", ret)); |
| } |
| if (sdio_major == 0) |
| sdio_major = ret; /* dynamic */ |
| |
| /** from 2.4 kernel source: |
| * pci_register_driver - register a new pci driver |
| * |
| * Adds the driver structure to the list of registered drivers |
| * Returns the number of pci devices which were claimed by the driver |
| * during registration. The driver remains registered even if the |
| * return value is zero. |
| */ |
| |
| ret = pci_register_driver(&mrvlsdio); |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s: pci_register_driver with %d\n", __FILE__, ret)); |
| |
| LEAVE(); |
| // return (ret); |
| return 0; |
| } |
| |
| static void |
| mrvlsdio_exit_module(void) |
| { |
| PSD_DEVICE_DATA pTmpDev; |
| PSD_CLIENT pTmpClient; |
| |
| // remove proc entry |
| remove_proc_entry("mrvlsdio", NULL); |
| DBGPRINT(DBG_LOAD, (KERN_DEBUG "Module mrvlsdio exit\n")); |
| |
| unregister_chrdev(sdio_major, "mrvlsdio"); |
| pci_unregister_driver(&mrvlsdio); |
| |
| // Clean up device list |
| |
| while (!list_empty(&sd_dev_list)) { |
| pTmpDev = (PSD_DEVICE_DATA) sd_dev_list.next; |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s@%d: pTmpDev=%p\n", __FUNCTION__, __LINE__, |
| pTmpDev)); |
| list_del((struct list_head *) pTmpDev); |
| kfree(pTmpDev); |
| |
| #ifdef SDIO_MEM_TRACE |
| printk("<<< kfree(SD_DEVICE_DATA)\n"); |
| #endif |
| |
| } |
| |
| // Clean up client list |
| while (!list_empty(&sd_client_list)) { |
| pTmpClient = (PSD_CLIENT) sd_client_list.next; |
| DBGPRINT(DBG_LOAD, |
| (KERN_DEBUG "%s@%d: pTmpClient=%p\n", __FUNCTION__, __LINE__, |
| pTmpClient)); |
| list_del((struct list_head *) pTmpClient); |
| kfree(pTmpClient); |
| #ifdef SDIO_MEM_TRACE |
| printk("<<< kfree(SD_CLIENT)\n"); |
| #endif |
| |
| } |
| } |
| |
| module_init(mrvlsdio_init_module); |
| module_exit(mrvlsdio_exit_module); |
| |
| EXPORT_SYMBOL(sd_driver_register); |
| EXPORT_SYMBOL(sd_driver_unregister); |
| EXPORT_SYMBOL(sd_request_int); |
| EXPORT_SYMBOL(sd_release_int); |
| EXPORT_SYMBOL(sd_unmask); |
| EXPORT_SYMBOL(sd_enable_int); |
| EXPORT_SYMBOL(sd_disable_int); |
| EXPORT_SYMBOL(sd_set_buswidth); |
| EXPORT_SYMBOL(sd_set_busclock); |
| EXPORT_SYMBOL(sd_start_clock); |
| EXPORT_SYMBOL(sd_stop_clock); |
| EXPORT_SYMBOL(sd_set_gpo); |
| EXPORT_SYMBOL(sdio_read_ioreg); |
| EXPORT_SYMBOL(sdio_write_ioreg); |
| EXPORT_SYMBOL(sdio_read_iomem); |
| EXPORT_SYMBOL(sdio_write_iomem); |
| |
| MODULE_DESCRIPTION("Marvell SDIO Bus Driver"); |
| MODULE_AUTHOR("Marvell International Ltd."); |
| MODULE_LICENSE("GPL"); |
