leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[PATCH] mmc: driver for TI FlashMedia card reader - source

Browse Source 
Driver for TI Flash Media card reader.  At present, only MMC/SD cards are
supported.

[akpm@osdl.org: cleanups, build fixes]
Signed-off-by: Alex Dubov <oakad@yahoo.com>
Cc: Daniel Qarras <dqarras@yahoo.com>
Acked-by: Pierre Ossman <drzeus@drzeus.cx>
Cc: Russell King <rmk@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Alex Dubov 2006-10-04 02:15:37 -07:00 committed by Linus Torvalds
parent 856fe98f16
commit 4020f2d7f0
5 changed files with 1805 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
MAINTAINERS
View File

@ -2854,6 +2854,11 @@ M: hlhung3i@gmail.com
W: http://tcp-lp-mod.sourceforge.net/
S: Maintained
TI FLASH MEDIA INTERFACE DRIVER
P: Alex Dubov
M: oakad@yahoo.com
S: Maintained
TI OMAP RANDOM NUMBER GENERATOR SUPPORT
P: Deepak Saxena
M: dsaxena@plexity.net

437
drivers/misc/tifm_7xx1.c Normal file
View File

@ -0,0 +1,437 @@
/*
* tifm_7xx1.c - TI FlashMedia driver
*
* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include <linux/tifm.h>
#include <linux/dma-mapping.h>
#define DRIVER_NAME "tifm_7xx1"
#define DRIVER_VERSION "0.6"
static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock)
{
int cnt;
unsigned long flags;
spin_lock_irqsave(&fm->lock, flags);
if (!fm->inhibit_new_cards) {
for (cnt = 0; cnt < fm->max_sockets; cnt++) {
if (fm->sockets[cnt] == sock) {
fm->remove_mask |= (1 << cnt);
queue_work(fm->wq, &fm->media_remover);
break;
}
}
}
spin_unlock_irqrestore(&fm->lock, flags);
}
static void tifm_7xx1_remove_media(void *adapter)
{
struct tifm_adapter *fm = adapter;
unsigned long flags;
int cnt;
struct tifm_dev *sock;
if (!class_device_get(&fm->cdev))
return;
spin_lock_irqsave(&fm->lock, flags);
for (cnt = 0; cnt < fm->max_sockets; cnt++) {
if (fm->sockets[cnt] && (fm->remove_mask & (1 << cnt))) {
printk(KERN_INFO DRIVER_NAME
": demand removing card from socket %d\n", cnt);
sock = fm->sockets[cnt];
fm->sockets[cnt] = 0;
fm->remove_mask &= ~(1 << cnt);
writel(0x0e00, sock->addr + SOCK_CONTROL);
writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
fm->addr + FM_SET_INTERRUPT_ENABLE);
spin_unlock_irqrestore(&fm->lock, flags);
device_unregister(&sock->dev);
spin_lock_irqsave(&fm->lock, flags);
}
}
spin_unlock_irqrestore(&fm->lock, flags);
class_device_put(&fm->cdev);
}
static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id, struct pt_regs *regs)
{
struct tifm_adapter *fm = dev_id;
unsigned int irq_status;
unsigned int sock_irq_status, cnt;
spin_lock(&fm->lock);
irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);
if (irq_status == 0 || irq_status == (~0)) {
spin_unlock(&fm->lock);
return IRQ_NONE;
}
if (irq_status & TIFM_IRQ_ENABLE) {
writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
for (cnt = 0; cnt < fm->max_sockets; cnt++) {
sock_irq_status = (irq_status >> cnt) &
(TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK);
if (fm->sockets[cnt]) {
if (sock_irq_status &&
fm->sockets[cnt]->signal_irq)
sock_irq_status = fm->sockets[cnt]->
signal_irq(fm->sockets[cnt],
sock_irq_status);
if (irq_status & (1 << cnt))
fm->remove_mask |= 1 << cnt;
} else {
if (irq_status & (1 << cnt))
fm->insert_mask |= 1 << cnt;
}
}
}
writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);
if (!fm->inhibit_new_cards) {
if (!fm->remove_mask && !fm->insert_mask) {
writel(TIFM_IRQ_ENABLE,
fm->addr + FM_SET_INTERRUPT_ENABLE);
} else {
queue_work(fm->wq, &fm->media_remover);
queue_work(fm->wq, &fm->media_inserter);
}
}
spin_unlock(&fm->lock);
return IRQ_HANDLED;
}
static tifm_media_id tifm_7xx1_toggle_sock_power(char *sock_addr, int is_x2)
{
unsigned int s_state;
int cnt;
writel(0x0e00, sock_addr + SOCK_CONTROL);
for (cnt = 0; cnt < 100; cnt++) {
if (!(TIFM_SOCK_STATE_POWERED &
readl(sock_addr + SOCK_PRESENT_STATE)))
break;
msleep(10);
}
s_state = readl(sock_addr + SOCK_PRESENT_STATE);
if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))
return FM_NULL;
if (is_x2) {
writel((s_state & 7) | 0x0c00, sock_addr + SOCK_CONTROL);
} else {
// SmartMedia cards need extra 40 msec
if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7) == 1)
msleep(40);
writel(readl(sock_addr + SOCK_CONTROL) | TIFM_CTRL_LED,
sock_addr + SOCK_CONTROL);
msleep(10);
writel((s_state & 0x7) | 0x0c00 | TIFM_CTRL_LED,
sock_addr + SOCK_CONTROL);
}
for (cnt = 0; cnt < 100; cnt++) {
if ((TIFM_SOCK_STATE_POWERED &
readl(sock_addr + SOCK_PRESENT_STATE)))
break;
msleep(10);
}
if (!is_x2)
writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),
sock_addr + SOCK_CONTROL);
return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
}
inline static char *tifm_7xx1_sock_addr(char *base_addr, unsigned int sock_num)
{
return base_addr + ((sock_num + 1) << 10);
}
static void tifm_7xx1_insert_media(void *adapter)
{
struct tifm_adapter *fm = adapter;
unsigned long flags;
tifm_media_id media_id;
char *card_name = "xx";
int cnt, ok_to_register;
unsigned int insert_mask;
struct tifm_dev *new_sock = 0;
if (!class_device_get(&fm->cdev))
return;
spin_lock_irqsave(&fm->lock, flags);
insert_mask = fm->insert_mask;
fm->insert_mask = 0;
if (fm->inhibit_new_cards) {
spin_unlock_irqrestore(&fm->lock, flags);
class_device_put(&fm->cdev);
return;
}
spin_unlock_irqrestore(&fm->lock, flags);
for (cnt = 0; cnt < fm->max_sockets; cnt++) {
if (!(insert_mask & (1 << cnt)))
continue;
media_id = tifm_7xx1_toggle_sock_power(tifm_7xx1_sock_addr(fm->addr, cnt),
fm->max_sockets == 2);
if (media_id) {
ok_to_register = 0;
new_sock = tifm_alloc_device(fm, cnt);
if (new_sock) {
new_sock->addr = tifm_7xx1_sock_addr(fm->addr,
cnt);
new_sock->media_id = media_id;
switch (media_id) {
case 1:
card_name = "xd";
break;
case 2:
card_name = "ms";
break;
case 3:
card_name = "sd";
break;
default:
break;
}
snprintf(new_sock->dev.bus_id, BUS_ID_SIZE,
"tifm_%s%u:%u", card_name, fm->id, cnt);
printk(KERN_INFO DRIVER_NAME
": %s card detected in socket %d\n",
card_name, cnt);
spin_lock_irqsave(&fm->lock, flags);
if (!fm->sockets[cnt]) {
fm->sockets[cnt] = new_sock;
ok_to_register = 1;
}
spin_unlock_irqrestore(&fm->lock, flags);
if (!ok_to_register ||
device_register(&new_sock->dev)) {
spin_lock_irqsave(&fm->lock, flags);
fm->sockets[cnt] = 0;
spin_unlock_irqrestore(&fm->lock,
flags);
tifm_free_device(&new_sock->dev);
}
}
}
writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
fm->addr + FM_SET_INTERRUPT_ENABLE);
}
writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
class_device_put(&fm->cdev);
}
static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
{
struct tifm_adapter *fm = pci_get_drvdata(dev);
unsigned long flags;
spin_lock_irqsave(&fm->lock, flags);
fm->inhibit_new_cards = 1;
fm->remove_mask = 0xf;
fm->insert_mask = 0;
writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
spin_unlock_irqrestore(&fm->lock, flags);
flush_workqueue(fm->wq);
tifm_7xx1_remove_media(fm);
pci_set_power_state(dev, PCI_D3hot);
pci_disable_device(dev);
pci_save_state(dev);
return 0;
}
static int tifm_7xx1_resume(struct pci_dev *dev)
{
struct tifm_adapter *fm = pci_get_drvdata(dev);
unsigned long flags;
pci_restore_state(dev);
pci_enable_device(dev);
pci_set_power_state(dev, PCI_D0);
pci_set_master(dev);
spin_lock_irqsave(&fm->lock, flags);
fm->inhibit_new_cards = 0;
writel(TIFM_IRQ_SETALL, fm->addr + FM_INTERRUPT_STATUS);
writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SETALLSOCK,
fm->addr + FM_SET_INTERRUPT_ENABLE);
fm->insert_mask = 0xf;
spin_unlock_irqrestore(&fm->lock, flags);
return 0;
}
static int tifm_7xx1_probe(struct pci_dev *dev,
const struct pci_device_id *dev_id)
{
struct tifm_adapter *fm;
int pci_dev_busy = 0;
int rc;
rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
if (rc)
return rc;
rc = pci_enable_device(dev);
if (rc)
return rc;
pci_set_master(dev);
rc = pci_request_regions(dev, DRIVER_NAME);
if (rc) {
pci_dev_busy = 1;
goto err_out;
}
pci_intx(dev, 1);
fm = tifm_alloc_adapter();
if (!fm) {
rc = -ENOMEM;
goto err_out_int;
}
fm->dev = &dev->dev;
fm->max_sockets = (dev->device == 0x803B) ? 2 : 4;
fm->sockets = kzalloc(sizeof(struct tifm_dev*) * fm->max_sockets,
GFP_KERNEL);
if (!fm->sockets)
goto err_out_free;
INIT_WORK(&fm->media_inserter, tifm_7xx1_insert_media, fm);
INIT_WORK(&fm->media_remover, tifm_7xx1_remove_media, fm);
fm->eject = tifm_7xx1_eject;
pci_set_drvdata(dev, fm);
fm->addr = ioremap(pci_resource_start(dev, 0),
pci_resource_len(dev, 0));
if (!fm->addr)
goto err_out_free;
rc = request_irq(dev->irq, tifm_7xx1_isr, SA_SHIRQ, DRIVER_NAME, fm);
if (rc)
goto err_out_unmap;
rc = tifm_add_adapter(fm);
if (rc)
goto err_out_irq;
writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SETALLSOCK,
fm->addr + FM_SET_INTERRUPT_ENABLE);
fm->insert_mask = 0xf;
return 0;
err_out_irq:
free_irq(dev->irq, fm);
err_out_unmap:
iounmap(fm->addr);
err_out_free:
pci_set_drvdata(dev, NULL);
tifm_free_adapter(fm);
err_out_int:
pci_intx(dev, 0);
pci_release_regions(dev);
err_out:
if (!pci_dev_busy)
pci_disable_device(dev);
return rc;
}
static void tifm_7xx1_remove(struct pci_dev *dev)
{
struct tifm_adapter *fm = pci_get_drvdata(dev);
unsigned long flags;
spin_lock_irqsave(&fm->lock, flags);
fm->inhibit_new_cards = 1;
fm->remove_mask = 0xf;
fm->insert_mask = 0;
writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
spin_unlock_irqrestore(&fm->lock, flags);
flush_workqueue(fm->wq);
tifm_7xx1_remove_media(fm);
writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
free_irq(dev->irq, fm);
tifm_remove_adapter(fm);
pci_set_drvdata(dev, 0);
iounmap(fm->addr);
pci_intx(dev, 0);
pci_release_regions(dev);
pci_disable_device(dev);
tifm_free_adapter(fm);
}
static struct pci_device_id tifm_7xx1_pci_tbl [] = {
{ PCI_VENDOR_ID_TI, 0x8033, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
0 }, /* xx21 - the one I have */
{ PCI_VENDOR_ID_TI, 0x803B, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
0 }, /* xx12 - should be also supported */
{ }
};
static struct pci_driver tifm_7xx1_driver = {
.name = DRIVER_NAME,
.id_table = tifm_7xx1_pci_tbl,
.probe = tifm_7xx1_probe,
.remove = tifm_7xx1_remove,
.suspend = tifm_7xx1_suspend,
.resume = tifm_7xx1_resume,
};
static int __init tifm_7xx1_init(void)
{
return pci_register_driver(&tifm_7xx1_driver);
}
static void __exit tifm_7xx1_exit(void)
{
pci_unregister_driver(&tifm_7xx1_driver);
}
MODULE_AUTHOR("Alex Dubov");
MODULE_DESCRIPTION("TI FlashMedia host driver");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl);
MODULE_VERSION(DRIVER_VERSION);
module_init(tifm_7xx1_init);
module_exit(tifm_7xx1_exit);

272
drivers/misc/tifm_core.c Normal file
View File

@ -0,0 +1,272 @@
/*
* tifm_core.c - TI FlashMedia driver
*
* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include <linux/tifm.h>
#include <linux/init.h>
#include <linux/idr.h>
#define DRIVER_NAME "tifm_core"
#define DRIVER_VERSION "0.6"
static DEFINE_IDR(tifm_adapter_idr);
static DEFINE_SPINLOCK(tifm_adapter_lock);
static tifm_media_id *tifm_device_match(tifm_media_id *ids,
struct tifm_dev *dev)
{
while (*ids) {
if (dev->media_id == *ids)
return ids;
ids++;
}
return NULL;
}
static int tifm_match(struct device *dev, struct device_driver *drv)
{
struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
struct tifm_driver *fm_drv;
fm_drv = container_of(drv, struct tifm_driver, driver);
if (!fm_drv->id_table)
return -EINVAL;
if (tifm_device_match(fm_drv->id_table, fm_dev))
return 1;
return -ENODEV;
}
static int tifm_uevent(struct device *dev, char **envp, int num_envp,
char *buffer, int buffer_size)
{
struct tifm_dev *fm_dev;
int i = 0;
int length = 0;
const char *card_type_name[] = {"INV", "SM", "MS", "SD"};
if (!dev || !(fm_dev = container_of(dev, struct tifm_dev, dev)))
return -ENODEV;
if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
"TIFM_CARD_TYPE=%s", card_type_name[fm_dev->media_id]))
return -ENOMEM;
return 0;
}
static struct bus_type tifm_bus_type = {
.name = "tifm",
.match = tifm_match,
.uevent = tifm_uevent,
};
static void tifm_free(struct class_device *cdev)
{
struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);
kfree(fm->sockets);
if (fm->wq)
destroy_workqueue(fm->wq);
kfree(fm);
}
static struct class tifm_adapter_class = {
.name = "tifm_adapter",
.release = tifm_free
};
struct tifm_adapter *tifm_alloc_adapter(void)
{
struct tifm_adapter *fm;
fm = kzalloc(sizeof(struct tifm_adapter), GFP_KERNEL);
if (fm) {
fm->cdev.class = &tifm_adapter_class;
spin_lock_init(&fm->lock);
class_device_initialize(&fm->cdev);
}
return fm;
}
EXPORT_SYMBOL(tifm_alloc_adapter);
void tifm_free_adapter(struct tifm_adapter *fm)
{
class_device_put(&fm->cdev);
}
EXPORT_SYMBOL(tifm_free_adapter);
int tifm_add_adapter(struct tifm_adapter *fm)
{
int rc;
if (!idr_pre_get(&tifm_adapter_idr, GFP_KERNEL))
return -ENOMEM;
spin_lock(&tifm_adapter_lock);
rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id);
spin_unlock(&tifm_adapter_lock);
if (!rc) {
snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);
strncpy(fm->wq_name, fm->cdev.class_id, KOBJ_NAME_LEN);
fm->wq = create_singlethread_workqueue(fm->wq_name);
if (fm->wq)
return class_device_add(&fm->cdev);
spin_lock(&tifm_adapter_lock);
idr_remove(&tifm_adapter_idr, fm->id);
spin_unlock(&tifm_adapter_lock);
rc = -ENOMEM;
}
return rc;
}
EXPORT_SYMBOL(tifm_add_adapter);
void tifm_remove_adapter(struct tifm_adapter *fm)
{
class_device_del(&fm->cdev);
spin_lock(&tifm_adapter_lock);
idr_remove(&tifm_adapter_idr, fm->id);
spin_unlock(&tifm_adapter_lock);
}
EXPORT_SYMBOL(tifm_remove_adapter);
void tifm_free_device(struct device *dev)
{
struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
if (fm_dev->wq)
destroy_workqueue(fm_dev->wq);
kfree(fm_dev);
}
EXPORT_SYMBOL(tifm_free_device);
struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id)
{
struct tifm_dev *dev = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);
if (dev) {
spin_lock_init(&dev->lock);
snprintf(dev->wq_name, KOBJ_NAME_LEN, "tifm%u:%u", fm->id, id);
dev->wq = create_singlethread_workqueue(dev->wq_name);
if (!dev->wq) {
kfree(dev);
return 0;
}
dev->dev.parent = fm->dev;
dev->dev.bus = &tifm_bus_type;
dev->dev.release = tifm_free_device;
}
return dev;
}
EXPORT_SYMBOL(tifm_alloc_device);
void tifm_eject(struct tifm_dev *sock)
{
struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent);
fm->eject(fm, sock);
}
EXPORT_SYMBOL(tifm_eject);
int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
int direction)
{
return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction);
}
EXPORT_SYMBOL(tifm_map_sg);
void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
int direction)
{
pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction);
}
EXPORT_SYMBOL(tifm_unmap_sg);
static int tifm_device_probe(struct device *dev)
{
struct tifm_driver *drv;
struct tifm_dev *fm_dev;
int rc = 0;
const tifm_media_id *id;
drv = container_of(dev->driver, struct tifm_driver, driver);
fm_dev = container_of(dev, struct tifm_dev, dev);
get_device(dev);
if (!fm_dev->drv && drv->probe && drv->id_table) {
rc = -ENODEV;
id = tifm_device_match(drv->id_table, fm_dev);
if (id)
rc = drv->probe(fm_dev);
if (rc >= 0) {
rc = 0;
fm_dev->drv = drv;
}
}
if (rc)
put_device(dev);
return rc;
}
static int tifm_device_remove(struct device *dev)
{
struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
struct tifm_driver *drv = fm_dev->drv;
if (drv) {
if (drv->remove) drv->remove(fm_dev);
fm_dev->drv = 0;
}
put_device(dev);
return 0;
}
int tifm_register_driver(struct tifm_driver *drv)
{
drv->driver.bus = &tifm_bus_type;
drv->driver.probe = tifm_device_probe;
drv->driver.remove = tifm_device_remove;
return driver_register(&drv->driver);
}
EXPORT_SYMBOL(tifm_register_driver);
void tifm_unregister_driver(struct tifm_driver *drv)
{
driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(tifm_unregister_driver);
static int __init tifm_init(void)
{
int rc = bus_register(&tifm_bus_type);
if (!rc) {
rc = class_register(&tifm_adapter_class);
if (rc)
bus_unregister(&tifm_bus_type);
}
return rc;
}
static void __exit tifm_exit(void)
{
class_unregister(&tifm_adapter_class);
bus_unregister(&tifm_bus_type);
}
subsys_initcall(tifm_init);
module_exit(tifm_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Alex Dubov");
MODULE_DESCRIPTION("TI FlashMedia core driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRIVER_VERSION);

933
drivers/mmc/tifm_sd.c Normal file
View File

@ -0,0 +1,933 @@
/*
* tifm_sd.c - TI FlashMedia driver
*
* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include <linux/tifm.h>
#include <linux/mmc/protocol.h>
#include <linux/mmc/host.h>
#include <linux/highmem.h>
#define DRIVER_NAME "tifm_sd"
#define DRIVER_VERSION "0.6"
static int no_dma = 0;
static int fixed_timeout = 0;
module_param(no_dma, bool, 0644);
module_param(fixed_timeout, bool, 0644);
/* Constants here are mostly from OMAP5912 datasheet */
#define TIFM_MMCSD_RESET 0x0002
#define TIFM_MMCSD_CLKMASK 0x03ff
#define TIFM_MMCSD_POWER 0x0800
#define TIFM_MMCSD_4BBUS 0x8000
#define TIFM_MMCSD_RXDE 0x8000 /* rx dma enable */
#define TIFM_MMCSD_TXDE 0x0080 /* tx dma enable */
#define TIFM_MMCSD_BUFINT 0x0c00 /* set bits: AE, AF */
#define TIFM_MMCSD_DPE 0x0020 /* data timeout counted in kilocycles */
#define TIFM_MMCSD_INAB 0x0080 /* abort / initialize command */
#define TIFM_MMCSD_READ 0x8000
#define TIFM_MMCSD_DATAMASK 0x001d /* set bits: EOFB, BRS, CB, EOC */
#define TIFM_MMCSD_ERRMASK 0x41e0 /* set bits: CERR, CCRC, CTO, DCRC, DTO */
#define TIFM_MMCSD_EOC 0x0001 /* end of command phase */
#define TIFM_MMCSD_CB 0x0004 /* card enter busy state */
#define TIFM_MMCSD_BRS 0x0008 /* block received/sent */
#define TIFM_MMCSD_EOFB 0x0010 /* card exit busy state */
#define TIFM_MMCSD_DTO 0x0020 /* data time-out */
#define TIFM_MMCSD_DCRC 0x0040 /* data crc error */
#define TIFM_MMCSD_CTO 0x0080 /* command time-out */
#define TIFM_MMCSD_CCRC 0x0100 /* command crc error */
#define TIFM_MMCSD_AF 0x0400 /* fifo almost full */
#define TIFM_MMCSD_AE 0x0800 /* fifo almost empty */
#define TIFM_MMCSD_CERR 0x4000 /* card status error */
#define TIFM_MMCSD_FIFO_SIZE 0x0020
#define TIFM_MMCSD_RSP_R0 0x0000
#define TIFM_MMCSD_RSP_R1 0x0100
#define TIFM_MMCSD_RSP_R2 0x0200
#define TIFM_MMCSD_RSP_R3 0x0300
#define TIFM_MMCSD_RSP_R4 0x0400
#define TIFM_MMCSD_RSP_R5 0x0500
#define TIFM_MMCSD_RSP_R6 0x0600
#define TIFM_MMCSD_RSP_BUSY 0x0800
#define TIFM_MMCSD_CMD_BC 0x0000
#define TIFM_MMCSD_CMD_BCR 0x1000
#define TIFM_MMCSD_CMD_AC 0x2000
#define TIFM_MMCSD_CMD_ADTC 0x3000
typedef enum {
IDLE = 0,
CMD, /* main command ended */
BRS, /* block transfer finished */
SCMD, /* stop command ended */
CARD, /* card left busy state */
FIFO, /* FIFO operation completed (uncertain) */
READY
} card_state_t;
enum {
FIFO_RDY = 0x0001, /* hardware dependent value */
HOST_REG = 0x0002,
EJECT = 0x0004,
EJECT_DONE = 0x0008,
CARD_BUSY = 0x0010,
OPENDRAIN = 0x0040, /* hardware dependent value */
CARD_EVENT = 0x0100, /* hardware dependent value */
CARD_RO = 0x0200, /* hardware dependent value */
FIFO_EVENT = 0x10000 }; /* hardware dependent value */
struct tifm_sd {
struct tifm_dev *dev;
unsigned int flags;
card_state_t state;
unsigned int clk_freq;
unsigned int clk_div;
unsigned long timeout_jiffies; // software timeout - 2 sec
struct mmc_request *req;
struct work_struct cmd_handler;
struct work_struct abort_handler;
wait_queue_head_t can_eject;
size_t written_blocks;
char *buffer;
size_t buffer_size;
size_t buffer_pos;
};
static int tifm_sd_transfer_data(struct tifm_dev *sock, struct tifm_sd *host,
unsigned int host_status)
{
struct mmc_command *cmd = host->req->cmd;
unsigned int t_val = 0, cnt = 0;
if (host_status & TIFM_MMCSD_BRS) {
/* in non-dma rx mode BRS fires when fifo is still not empty */
if (host->buffer && (cmd->data->flags & MMC_DATA_READ)) {
while (host->buffer_size > host->buffer_pos) {
t_val = readl(sock->addr + SOCK_MMCSD_DATA);
host->buffer[host->buffer_pos++] = t_val & 0xff;
host->buffer[host->buffer_pos++] =
(t_val >> 8) & 0xff;
}
}
return 1;
} else if (host->buffer) {
if ((cmd->data->flags & MMC_DATA_READ) &&
(host_status & TIFM_MMCSD_AF)) {
for (cnt = 0; cnt < TIFM_MMCSD_FIFO_SIZE; cnt++) {
t_val = readl(sock->addr + SOCK_MMCSD_DATA);
if (host->buffer_size > host->buffer_pos) {
host->buffer[host->buffer_pos++] =
t_val & 0xff;
host->buffer[host->buffer_pos++] =
(t_val >> 8) & 0xff;
}
}
} else if ((cmd->data->flags & MMC_DATA_WRITE)
&& (host_status & TIFM_MMCSD_AE)) {
for (cnt = 0; cnt < TIFM_MMCSD_FIFO_SIZE; cnt++) {
if (host->buffer_size > host->buffer_pos) {
t_val = host->buffer[host->buffer_pos++] & 0x00ff;
t_val |= ((host->buffer[host->buffer_pos++]) << 8)
& 0xff00;
writel(t_val,
sock->addr + SOCK_MMCSD_DATA);
}
}
}
}
return 0;
}
static unsigned int tifm_sd_op_flags(struct mmc_command *cmd)
{
unsigned int rc = 0;
switch (mmc_resp_type(cmd)) {
case MMC_RSP_NONE:
rc |= TIFM_MMCSD_RSP_R0;
break;
case MMC_RSP_R1B:
rc |= TIFM_MMCSD_RSP_BUSY; // deliberate fall-through
case MMC_RSP_R1:
rc |= TIFM_MMCSD_RSP_R1;
break;
case MMC_RSP_R2:
rc |= TIFM_MMCSD_RSP_R2;
break;
case MMC_RSP_R3:
rc |= TIFM_MMCSD_RSP_R3;
break;
case MMC_RSP_R6:
rc |= TIFM_MMCSD_RSP_R6;
break;
default:
BUG();
}
switch (mmc_cmd_type(cmd)) {
case MMC_CMD_BC:
rc |= TIFM_MMCSD_CMD_BC;
break;
case MMC_CMD_BCR:
rc |= TIFM_MMCSD_CMD_BCR;
break;
case MMC_CMD_AC:
rc |= TIFM_MMCSD_CMD_AC;
break;
case MMC_CMD_ADTC:
rc |= TIFM_MMCSD_CMD_ADTC;
break;
default:
BUG();
}
return rc;
}
static void tifm_sd_exec(struct tifm_sd *host, struct mmc_command *cmd)
{
struct tifm_dev *sock = host->dev;
unsigned int cmd_mask = tifm_sd_op_flags(cmd) |
(host->flags & OPENDRAIN);
if (cmd->data && (cmd->data->flags & MMC_DATA_READ))
cmd_mask |= TIFM_MMCSD_READ;
dev_dbg(&sock->dev, "executing opcode 0x%x, arg: 0x%x, mask: 0x%x\n",
cmd->opcode, cmd->arg, cmd_mask);
writel((cmd->arg >> 16) & 0xffff, sock->addr + SOCK_MMCSD_ARG_HIGH);
writel(cmd->arg & 0xffff, sock->addr + SOCK_MMCSD_ARG_LOW);
writel(cmd->opcode | cmd_mask, sock->addr + SOCK_MMCSD_COMMAND);
}
static void tifm_sd_fetch_resp(struct mmc_command *cmd, struct tifm_dev *sock)
{
cmd->resp[0] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x1c) << 16)
| readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x18);
cmd->resp[1] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x14) << 16)
| readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x10);
cmd->resp[2] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x0c) << 16)
| readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x08);
cmd->resp[3] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x04) << 16)
| readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x00);
}
static void tifm_sd_process_cmd(struct tifm_dev *sock, struct tifm_sd *host,
unsigned int host_status)
{
struct mmc_command *cmd = host->req->cmd;
change_state:
switch (host->state) {
case IDLE:
return;
case CMD:
if (host_status & TIFM_MMCSD_EOC) {
tifm_sd_fetch_resp(cmd, sock);
if (cmd->data) {
host->state = BRS;
} else
host->state = READY;
goto change_state;
}
break;
case BRS:
if (tifm_sd_transfer_data(sock, host, host_status)) {
if (!host->req->stop) {
if (cmd->data->flags & MMC_DATA_WRITE) {
host->state = CARD;
} else {
host->state =
host->buffer ? READY : FIFO;
}
goto change_state;
}
tifm_sd_exec(host, host->req->stop);
host->state = SCMD;
}
break;
case SCMD:
if (host_status & TIFM_MMCSD_EOC) {
tifm_sd_fetch_resp(host->req->stop, sock);
if (cmd->error) {
host->state = READY;
} else if (cmd->data->flags & MMC_DATA_WRITE) {
host->state = CARD;
} else {
host->state = host->buffer ? READY : FIFO;
}
goto change_state;
}
break;
case CARD:
if (!(host->flags & CARD_BUSY)
&& (host->written_blocks == cmd->data->blocks)) {
host->state = host->buffer ? READY : FIFO;
goto change_state;
}
break;
case FIFO:
if (host->flags & FIFO_RDY) {
host->state = READY;
host->flags &= ~FIFO_RDY;
goto change_state;
}
break;
case READY:
queue_work(sock->wq, &host->cmd_handler);
return;
}
queue_delayed_work(sock->wq, &host->abort_handler,
host->timeout_jiffies);
}
/* Called from interrupt handler */
static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
unsigned int sock_irq_status)
{
struct tifm_sd *host;
unsigned int host_status = 0, fifo_status = 0;
int error_code = 0;
spin_lock(&sock->lock);
host = mmc_priv((struct mmc_host*)tifm_get_drvdata(sock));
cancel_delayed_work(&host->abort_handler);
if (sock_irq_status & FIFO_EVENT) {
fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS);
writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS);
host->flags |= fifo_status & FIFO_RDY;
}
if (sock_irq_status & CARD_EVENT) {
host_status = readl(sock->addr + SOCK_MMCSD_STATUS);
writel(host_status, sock->addr + SOCK_MMCSD_STATUS);
if (!(host->flags & HOST_REG))
queue_work(sock->wq, &host->cmd_handler);
if (!host->req)
goto done;
if (host_status & TIFM_MMCSD_ERRMASK) {
if (host_status & TIFM_MMCSD_CERR)
error_code = MMC_ERR_FAILED;
else if (host_status &
(TIFM_MMCSD_CTO | TIFM_MMCSD_DTO))
error_code = MMC_ERR_TIMEOUT;
else if (host_status &
(TIFM_MMCSD_CCRC | TIFM_MMCSD_DCRC))
error_code = MMC_ERR_BADCRC;
writel(TIFM_FIFO_INT_SETALL,
sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL);
if (host->req->stop) {
if (host->state == SCMD) {
host->req->stop->error = error_code;
} else if(host->state == BRS) {
host->req->cmd->error = error_code;
tifm_sd_exec(host, host->req->stop);
queue_delayed_work(sock->wq,
&host->abort_handler,
host->timeout_jiffies);
host->state = SCMD;
goto done;
} else {
host->req->cmd->error = error_code;
}
} else {
host->req->cmd->error = error_code;
}
host->state = READY;
}
if (host_status & TIFM_MMCSD_CB)
host->flags |= CARD_BUSY;
if ((host_status & TIFM_MMCSD_EOFB) &&
(host->flags & CARD_BUSY)) {
host->written_blocks++;
host->flags &= ~CARD_BUSY;
}
}
if (host->req)
tifm_sd_process_cmd(sock, host, host_status);
done:
dev_dbg(&sock->dev, "host_status %x, fifo_status %x\n",
host_status, fifo_status);
spin_unlock(&sock->lock);
return sock_irq_status;
}
static void tifm_sd_prepare_data(struct tifm_sd *card, struct mmc_command *cmd)
{
struct tifm_dev *sock = card->dev;
unsigned int dest_cnt;
/* DMA style IO */
writel(TIFM_FIFO_INT_SETALL,
sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
writel(long_log2(cmd->data->blksz) - 2,
sock->addr + SOCK_FIFO_PAGE_SIZE);
writel(TIFM_FIFO_ENABLE, sock->addr + SOCK_FIFO_CONTROL);
writel(TIFM_FIFO_INTMASK, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
dest_cnt = (cmd->data->blocks) << 8;
writel(sg_dma_address(cmd->data->sg), sock->addr + SOCK_DMA_ADDRESS);
writel(cmd->data->blocks - 1, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
writel(cmd->data->blksz - 1, sock->addr + SOCK_MMCSD_BLOCK_LEN);
if (cmd->data->flags & MMC_DATA_WRITE) {
writel(TIFM_MMCSD_TXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
writel(dest_cnt | TIFM_DMA_TX | TIFM_DMA_EN,
sock->addr + SOCK_DMA_CONTROL);
} else {
writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
writel(dest_cnt | TIFM_DMA_EN, sock->addr + SOCK_DMA_CONTROL);
}
}
static void tifm_sd_set_data_timeout(struct tifm_sd *host,
struct mmc_data *data)
{
struct tifm_dev *sock = host->dev;
unsigned int data_timeout = data->timeout_clks;
if (fixed_timeout)
return;
data_timeout += data->timeout_ns /
((1000000000 / host->clk_freq) * host->clk_div);
data_timeout *= 10; // call it fudge factor for now
if (data_timeout < 0xffff) {
writel((~TIFM_MMCSD_DPE) &
readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
writel(data_timeout, sock->addr + SOCK_MMCSD_DATA_TO);
} else {
writel(TIFM_MMCSD_DPE |
readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
data_timeout = (data_timeout >> 10) + 1;
if(data_timeout > 0xffff)
data_timeout = 0; /* set to unlimited */
writel(data_timeout, sock->addr + SOCK_MMCSD_DATA_TO);
}
}
static void tifm_sd_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct tifm_sd *host = mmc_priv(mmc);
struct tifm_dev *sock = host->dev;
unsigned long flags;
int sg_count = 0;
struct mmc_data *r_data = mrq->cmd->data;
spin_lock_irqsave(&sock->lock, flags);
if (host->flags & EJECT) {
spin_unlock_irqrestore(&sock->lock, flags);
goto err_out;
}
if (host->req) {
printk(KERN_ERR DRIVER_NAME ": unfinished request detected\n");
spin_unlock_irqrestore(&sock->lock, flags);
goto err_out;
}
if (r_data) {
tifm_sd_set_data_timeout(host, r_data);
sg_count = tifm_map_sg(sock, r_data->sg, r_data->sg_len,
mrq->cmd->flags & MMC_DATA_WRITE
? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
if (sg_count != 1) {
printk(KERN_ERR DRIVER_NAME
": scatterlist map failed\n");
spin_unlock_irqrestore(&sock->lock, flags);
goto err_out;
}
host->written_blocks = 0;
host->flags &= ~CARD_BUSY;
tifm_sd_prepare_data(host, mrq->cmd);
}
host->req = mrq;
host->state = CMD;
queue_delayed_work(sock->wq, &host->abort_handler,
host->timeout_jiffies);
writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
tifm_sd_exec(host, mrq->cmd);
spin_unlock_irqrestore(&sock->lock, flags);
return;
err_out:
if (sg_count > 0)
tifm_unmap_sg(sock, r_data->sg, r_data->sg_len,
(r_data->flags & MMC_DATA_WRITE)
? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
mrq->cmd->error = MMC_ERR_TIMEOUT;
mmc_request_done(mmc, mrq);
}
static void tifm_sd_end_cmd(void *data)
{
struct tifm_sd *host = data;
struct tifm_dev *sock = host->dev;
struct mmc_host *mmc = tifm_get_drvdata(sock);
struct mmc_request *mrq;
struct mmc_data *r_data = 0;
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
mrq = host->req;
host->req = 0;
host->state = IDLE;
if (!mrq) {
printk(KERN_ERR DRIVER_NAME ": no request to complete?\n");
spin_unlock_irqrestore(&sock->lock, flags);
return;
}
r_data = mrq->cmd->data;
if (r_data) {
if (r_data->flags & MMC_DATA_WRITE) {
r_data->bytes_xfered = host->written_blocks *
r_data->blksz;
} else {
r_data->bytes_xfered = r_data->blocks -
readl(sock->addr + SOCK_MMCSD_NUM_BLOCKS) - 1;
r_data->bytes_xfered *= r_data->blksz;
r_data->bytes_xfered += r_data->blksz -
readl(sock->addr + SOCK_MMCSD_BLOCK_LEN) + 1;
}
tifm_unmap_sg(sock, r_data->sg, r_data->sg_len,
(r_data->flags & MMC_DATA_WRITE)
? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
}
writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
spin_unlock_irqrestore(&sock->lock, flags);
mmc_request_done(mmc, mrq);
}
static void tifm_sd_request_nodma(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct tifm_sd *host = mmc_priv(mmc);
struct tifm_dev *sock = host->dev;
unsigned long flags;
struct mmc_data *r_data = mrq->cmd->data;
char *t_buffer = 0;
if (r_data) {
t_buffer = kmap(r_data->sg->page);
if (!t_buffer) {
printk(KERN_ERR DRIVER_NAME ": kmap failed\n");
goto err_out;
}
}
spin_lock_irqsave(&sock->lock, flags);
if (host->flags & EJECT) {
spin_unlock_irqrestore(&sock->lock, flags);
goto err_out;
}
if (host->req) {
printk(KERN_ERR DRIVER_NAME ": unfinished request detected\n");
spin_unlock_irqrestore(&sock->lock, flags);
goto err_out;
}
if (r_data) {
tifm_sd_set_data_timeout(host, r_data);
host->buffer = t_buffer + r_data->sg->offset;
host->buffer_size = mrq->cmd->data->blocks *
mrq->cmd->data->blksz;
writel(TIFM_MMCSD_BUFINT |
readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
sock->addr + SOCK_MMCSD_INT_ENABLE);
writel(((TIFM_MMCSD_FIFO_SIZE - 1) << 8) |
(TIFM_MMCSD_FIFO_SIZE - 1),
sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
host->written_blocks = 0;
host->flags &= ~CARD_BUSY;
host->buffer_pos = 0;
writel(r_data->blocks - 1, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
writel(r_data->blksz - 1, sock->addr + SOCK_MMCSD_BLOCK_LEN);
}
host->req = mrq;
host->state = CMD;
queue_delayed_work(sock->wq, &host->abort_handler,
host->timeout_jiffies);
writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
tifm_sd_exec(host, mrq->cmd);
spin_unlock_irqrestore(&sock->lock, flags);
return;
err_out:
if (t_buffer)
kunmap(r_data->sg->page);
mrq->cmd->error = MMC_ERR_TIMEOUT;
mmc_request_done(mmc, mrq);
}
static void tifm_sd_end_cmd_nodma(void *data)
{
struct tifm_sd *host = (struct tifm_sd*)data;
struct tifm_dev *sock = host->dev;
struct mmc_host *mmc = tifm_get_drvdata(sock);
struct mmc_request *mrq;
struct mmc_data *r_data = 0;
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
mrq = host->req;
host->req = 0;
host->state = IDLE;
if (!mrq) {
printk(KERN_ERR DRIVER_NAME ": no request to complete?\n");
spin_unlock_irqrestore(&sock->lock, flags);
return;
}
r_data = mrq->cmd->data;
if (r_data) {
writel((~TIFM_MMCSD_BUFINT) &
readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
sock->addr + SOCK_MMCSD_INT_ENABLE);
if (r_data->flags & MMC_DATA_WRITE) {
r_data->bytes_xfered = host->written_blocks *
r_data->blksz;
} else {
r_data->bytes_xfered = r_data->blocks -
readl(sock->addr + SOCK_MMCSD_NUM_BLOCKS) - 1;
r_data->bytes_xfered *= r_data->blksz;
r_data->bytes_xfered += r_data->blksz -
readl(sock->addr + SOCK_MMCSD_BLOCK_LEN) + 1;
}
host->buffer = 0;
host->buffer_pos = 0;
host->buffer_size = 0;
}
writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
spin_unlock_irqrestore(&sock->lock, flags);
if (r_data)
kunmap(r_data->sg->page);
mmc_request_done(mmc, mrq);
}
static void tifm_sd_abort(void *data)
{
printk(KERN_ERR DRIVER_NAME
": card failed to respond for a long period of time");
tifm_eject(((struct tifm_sd*)data)->dev);
}
static void tifm_sd_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct tifm_sd *host = mmc_priv(mmc);
struct tifm_dev *sock = host->dev;
unsigned int clk_div1, clk_div2;
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
dev_dbg(&sock->dev, "Setting bus width %d, power %d\n", ios->bus_width,
ios->power_mode);
if (ios->bus_width == MMC_BUS_WIDTH_4) {
writel(TIFM_MMCSD_4BBUS | readl(sock->addr + SOCK_MMCSD_CONFIG),
sock->addr + SOCK_MMCSD_CONFIG);
} else {
writel((~TIFM_MMCSD_4BBUS) &
readl(sock->addr + SOCK_MMCSD_CONFIG),
sock->addr + SOCK_MMCSD_CONFIG);
}
if (ios->clock) {
clk_div1 = 20000000 / ios->clock;
if (!clk_div1)
clk_div1 = 1;
clk_div2 = 24000000 / ios->clock;
if (!clk_div2)
clk_div2 = 1;
if ((20000000 / clk_div1) > ios->clock)
clk_div1++;
if ((24000000 / clk_div2) > ios->clock)
clk_div2++;
if ((20000000 / clk_div1) > (24000000 / clk_div2)) {
host->clk_freq = 20000000;
host->clk_div = clk_div1;
writel((~TIFM_CTRL_FAST_CLK) &
readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
} else {
host->clk_freq = 24000000;
host->clk_div = clk_div2;
writel(TIFM_CTRL_FAST_CLK |
readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
}
} else {
host->clk_div = 0;
}
host->clk_div &= TIFM_MMCSD_CLKMASK;
writel(host->clk_div | ((~TIFM_MMCSD_CLKMASK) &
readl(sock->addr + SOCK_MMCSD_CONFIG)),
sock->addr + SOCK_MMCSD_CONFIG);
if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
host->flags |= OPENDRAIN;
else
host->flags &= ~OPENDRAIN;
/* chip_select : maybe later */
//vdd
//power is set before probe / after remove
//I believe, power_off when already marked for eject is sufficient to
// allow removal.
if ((host->flags & EJECT) && ios->power_mode == MMC_POWER_OFF) {
host->flags |= EJECT_DONE;
wake_up_all(&host->can_eject);
}
spin_unlock_irqrestore(&sock->lock, flags);
}
static int tifm_sd_ro(struct mmc_host *mmc)
{
int rc;
struct tifm_sd *host = mmc_priv(mmc);
struct tifm_dev *sock = host->dev;
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
host->flags |= (CARD_RO & readl(sock->addr + SOCK_PRESENT_STATE));
rc = (host->flags & CARD_RO) ? 1 : 0;
spin_unlock_irqrestore(&sock->lock, flags);
return rc;
}
static struct mmc_host_ops tifm_sd_ops = {
.request = tifm_sd_request,
.set_ios = tifm_sd_ios,
.get_ro = tifm_sd_ro
};
static void tifm_sd_register_host(void *data)
{
struct tifm_sd *host = (struct tifm_sd*)data;
struct tifm_dev *sock = host->dev;
struct mmc_host *mmc = tifm_get_drvdata(sock);
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
host->flags |= HOST_REG;
PREPARE_WORK(&host->cmd_handler,
no_dma ? tifm_sd_end_cmd_nodma : tifm_sd_end_cmd,
data);
spin_unlock_irqrestore(&sock->lock, flags);
dev_dbg(&sock->dev, "adding host\n");
mmc_add_host(mmc);
}
static int tifm_sd_probe(struct tifm_dev *sock)
{
struct mmc_host *mmc;
struct tifm_sd *host;
int rc = -EIO;
if (!(TIFM_SOCK_STATE_OCCUPIED &
readl(sock->addr + SOCK_PRESENT_STATE))) {
printk(KERN_WARNING DRIVER_NAME ": card gone, unexpectedly\n");
return rc;
}
mmc = mmc_alloc_host(sizeof(struct tifm_sd), &sock->dev);
if (!mmc)
return -ENOMEM;
host = mmc_priv(mmc);
host->dev = sock;
host->clk_div = 61;
init_waitqueue_head(&host->can_eject);
INIT_WORK(&host->cmd_handler, tifm_sd_register_host, host);
INIT_WORK(&host->abort_handler, tifm_sd_abort, host);
tifm_set_drvdata(sock, mmc);
sock->signal_irq = tifm_sd_signal_irq;
host->clk_freq = 20000000;
host->timeout_jiffies = msecs_to_jiffies(1000);
tifm_sd_ops.request = no_dma ? tifm_sd_request_nodma : tifm_sd_request;
mmc->ops = &tifm_sd_ops;
mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
mmc->caps = MMC_CAP_4_BIT_DATA;
mmc->f_min = 20000000 / 60;
mmc->f_max = 24000000;
mmc->max_hw_segs = 1;
mmc->max_phys_segs = 1;
mmc->max_sectors = 127;
mmc->max_seg_size = mmc->max_sectors << 11; //2k maximum hw block length
writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
writel(TIFM_MMCSD_RESET, sock->addr + SOCK_MMCSD_SYSTEM_CONTROL);
writel(host->clk_div | TIFM_MMCSD_POWER,
sock->addr + SOCK_MMCSD_CONFIG);
for (rc = 0; rc < 50; rc++) {
/* Wait for reset ack */
if (1 & readl(sock->addr + SOCK_MMCSD_SYSTEM_STATUS)) {
rc = 0;
break;
}
msleep(10);
}
if (rc) {
printk(KERN_ERR DRIVER_NAME
": card not ready - probe failed\n");
mmc_free_host(mmc);
return -ENODEV;
}
writel(0, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
writel(host->clk_div | TIFM_MMCSD_POWER,
sock->addr + SOCK_MMCSD_CONFIG);
writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
writel(TIFM_MMCSD_DATAMASK | TIFM_MMCSD_ERRMASK,
sock->addr + SOCK_MMCSD_INT_ENABLE);
writel(64, sock->addr + SOCK_MMCSD_COMMAND_TO); // command timeout 64 clocks for now
writel(TIFM_MMCSD_INAB, sock->addr + SOCK_MMCSD_COMMAND);
writel(host->clk_div | TIFM_MMCSD_POWER,
sock->addr + SOCK_MMCSD_CONFIG);
queue_delayed_work(sock->wq, &host->abort_handler,
host->timeout_jiffies);
return 0;
}
static int tifm_sd_host_is_down(struct tifm_dev *sock)
{
struct mmc_host *mmc = tifm_get_drvdata(sock);
struct tifm_sd *host = mmc_priv(mmc);
unsigned long flags;
int rc = 0;
spin_lock_irqsave(&sock->lock, flags);
rc = (host->flags & EJECT_DONE);
spin_unlock_irqrestore(&sock->lock, flags);
return rc;
}
static void tifm_sd_remove(struct tifm_dev *sock)
{
struct mmc_host *mmc = tifm_get_drvdata(sock);
struct tifm_sd *host = mmc_priv(mmc);
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
host->flags |= EJECT;
if (host->req)
queue_work(sock->wq, &host->cmd_handler);
spin_unlock_irqrestore(&sock->lock, flags);
wait_event_timeout(host->can_eject, tifm_sd_host_is_down(sock),
host->timeout_jiffies);
if (host->flags & HOST_REG)
mmc_remove_host(mmc);
/* The meaning of the bit majority in this constant is unknown. */
writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL);
writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
writel(TIFM_FIFO_INT_SETALL,
sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
tifm_set_drvdata(sock, 0);
mmc_free_host(mmc);
}
static tifm_media_id tifm_sd_id_tbl[] = {
FM_SD, 0
};
static struct tifm_driver tifm_sd_driver = {
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE
},
.id_table = tifm_sd_id_tbl,
.probe = tifm_sd_probe,
.remove = tifm_sd_remove
};
static int __init tifm_sd_init(void)
{
return tifm_register_driver(&tifm_sd_driver);
}
static void __exit tifm_sd_exit(void)
{
tifm_unregister_driver(&tifm_sd_driver);
}
MODULE_AUTHOR("Alex Dubov");
MODULE_DESCRIPTION("TI FlashMedia SD driver");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(tifm, tifm_sd_id_tbl);
MODULE_VERSION(DRIVER_VERSION);
module_init(tifm_sd_init);
module_exit(tifm_sd_exit);

158
include/linux/tifm.h Normal file
View File

@ -0,0 +1,158 @@
/*
* tifm.h - TI FlashMedia driver
*
* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#ifndef _TIFM_H
#define _TIFM_H
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/pci.h>
/* Host registers (relative to pci base address): */
enum {
FM_SET_INTERRUPT_ENABLE = 0x008,
FM_CLEAR_INTERRUPT_ENABLE = 0x00c,
FM_INTERRUPT_STATUS = 0x014 };
/* Socket registers (relative to socket base address): */
enum {
SOCK_CONTROL = 0x004,
SOCK_PRESENT_STATE = 0x008,
SOCK_DMA_ADDRESS = 0x00c,
SOCK_DMA_CONTROL = 0x010,
SOCK_DMA_FIFO_INT_ENABLE_SET = 0x014,
SOCK_DMA_FIFO_INT_ENABLE_CLEAR = 0x018,
SOCK_DMA_FIFO_STATUS = 0x020,
SOCK_FIFO_CONTROL = 0x024,
SOCK_FIFO_PAGE_SIZE = 0x028,
SOCK_MMCSD_COMMAND = 0x104,
SOCK_MMCSD_ARG_LOW = 0x108,
SOCK_MMCSD_ARG_HIGH = 0x10c,
SOCK_MMCSD_CONFIG = 0x110,
SOCK_MMCSD_STATUS = 0x114,
SOCK_MMCSD_INT_ENABLE = 0x118,
SOCK_MMCSD_COMMAND_TO = 0x11c,
SOCK_MMCSD_DATA_TO = 0x120,
SOCK_MMCSD_DATA = 0x124,
SOCK_MMCSD_BLOCK_LEN = 0x128,
SOCK_MMCSD_NUM_BLOCKS = 0x12c,
SOCK_MMCSD_BUFFER_CONFIG = 0x130,
SOCK_MMCSD_SPI_CONFIG = 0x134,
SOCK_MMCSD_SDIO_MODE_CONFIG = 0x138,
SOCK_MMCSD_RESPONSE = 0x144,
SOCK_MMCSD_SDIO_SR = 0x164,
SOCK_MMCSD_SYSTEM_CONTROL = 0x168,
SOCK_MMCSD_SYSTEM_STATUS = 0x16c,
SOCK_MS_COMMAND = 0x184,
SOCK_MS_DATA = 0x188,
SOCK_MS_STATUS = 0x18c,
SOCK_MS_SYSTEM = 0x190,
SOCK_FIFO_ACCESS = 0x200 };
#define TIFM_IRQ_ENABLE 0x80000000
#define TIFM_IRQ_SOCKMASK 0x00000001
#define TIFM_IRQ_CARDMASK 0x00000100
#define TIFM_IRQ_FIFOMASK 0x00010000
#define TIFM_IRQ_SETALL 0xffffffff
#define TIFM_IRQ_SETALLSOCK 0x0000000f
#define TIFM_CTRL_LED 0x00000040
#define TIFM_CTRL_FAST_CLK 0x00000100
#define TIFM_SOCK_STATE_OCCUPIED 0x00000008
#define TIFM_SOCK_STATE_POWERED 0x00000080
#define TIFM_FIFO_ENABLE 0x00000001 /* Meaning of this constant is unverified */
#define TIFM_FIFO_INT_SETALL 0x0000ffff
#define TIFM_FIFO_INTMASK 0x00000005 /* Meaning of this constant is unverified */
#define TIFM_DMA_RESET 0x00000002 /* Meaning of this constant is unverified */
#define TIFM_DMA_TX 0x00008000 /* Meaning of this constant is unverified */
#define TIFM_DMA_EN 0x00000001 /* Meaning of this constant is unverified */
typedef enum {FM_NULL = 0, FM_XD = 0x01, FM_MS = 0x02, FM_SD = 0x03} tifm_media_id;
struct tifm_driver;
struct tifm_dev {
char __iomem *addr;
spinlock_t lock;
tifm_media_id media_id;
char wq_name[KOBJ_NAME_LEN];
struct workqueue_struct *wq;
unsigned int (*signal_irq)(struct tifm_dev *sock,
unsigned int sock_irq_status);
struct tifm_driver *drv;
struct device dev;
};
struct tifm_driver {
tifm_media_id *id_table;
int (*probe)(struct tifm_dev *dev);
void (*remove)(struct tifm_dev *dev);
struct device_driver driver;
};
struct tifm_adapter {
char __iomem *addr;
unsigned int irq_status;
unsigned int insert_mask;
unsigned int remove_mask;
spinlock_t lock;
unsigned int id;
unsigned int max_sockets;
char wq_name[KOBJ_NAME_LEN];
unsigned int inhibit_new_cards;
struct workqueue_struct *wq;
struct work_struct media_inserter;
struct work_struct media_remover;
struct tifm_dev **sockets;
struct class_device cdev;
struct device *dev;
void (*eject)(struct tifm_adapter *fm, struct tifm_dev *sock);
};
struct tifm_adapter *tifm_alloc_adapter(void);
void tifm_free_device(struct device *dev);
void tifm_free_adapter(struct tifm_adapter *fm);
int tifm_add_adapter(struct tifm_adapter *fm);
void tifm_remove_adapter(struct tifm_adapter *fm);
struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id);
int tifm_register_driver(struct tifm_driver *drv);
void tifm_unregister_driver(struct tifm_driver *drv);
void tifm_eject(struct tifm_dev *sock);
int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
int direction);
void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
int direction);
static inline void *tifm_get_drvdata(struct tifm_dev *dev)
{
return dev_get_drvdata(&dev->dev);
}
static inline void tifm_set_drvdata(struct tifm_dev *dev, void *data)
{
dev_set_drvdata(&dev->dev, data);
}
struct tifm_device_id {
tifm_media_id media_id;
};
#endif