Attachment #11312 for bug #8052




 *
 */

#include "linux/tifm.h"
#include <linux/dma-mapping.h>
#include <linux/freezer.h>

#define DRIVER_NAME "tifm_7xx1"
#define DRIVER_VERSION "0.8"

#define TIFM_IRQ_ENABLE           0x80000000
#define TIFM_IRQ_SOCKMASK(x)      (x)
#define TIFM_IRQ_CARDMASK(x)      ((x) << 8)
#define TIFM_IRQ_FIFOMASK(x)      ((x) << 16)
#define TIFM_IRQ_SETALL           0xffffffff

static void tifm_7xx1_dummy_eject(struct tifm_adapter *fm,
				  struct tifm_dev *sock)
{
}

static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock)
{


	spin_lock_irqsave(&fm->lock, flags);
	fm->socket_change_set |= 1 << sock->socket_id;
	tifm_queue_work(&fm->media_switcher);
	spin_unlock_irqrestore(&fm->lock, flags);
}


{
	struct tifm_adapter *fm = dev_id;
	struct tifm_dev *sock;
	unsigned int irq_status, cnt;
	unsigned int sock_irq_status, cnt;

	spin_lock(&fm->lock);
	irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);


		for (cnt = 0; cnt < fm->num_sockets; cnt++) {
			sock = fm->sockets[cnt];
			if (sock) {
				if ((irq_status >> cnt) & TIFM_IRQ_FIFOMASK(1))
					sock->data_event(sock);
				if ((irq_status >> cnt) & TIFM_IRQ_CARDMASK(1))
					sock->card_event(sock);
			}
		}

		fm->socket_change_set |= irq_status

	}
	writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);

	if (fm->finish_me)
		complete_all(fm->finish_me);
	else if (!fm->socket_change_set)
		writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
	else
		tifm_queue_work(&fm->media_switcher);

	spin_unlock(&fm->lock);
	return IRQ_HANDLED;
}

static unsigned char tifm_7xx1_toggle_sock_power(char __iomem *sock_addr)
						 int is_x2)
{
	unsigned int s_state;
	int cnt;

	writel(0x0e00, sock_addr + SOCK_CONTROL);

	for (cnt = 16; cnt <= 256; cnt <<= 1) {
		if (!(TIFM_SOCK_STATE_POWERED
		      & readl(sock_addr + SOCK_PRESENT_STATE)))
			break;

		msleep(cnt);
	}

	s_state = readl(sock_addr + SOCK_PRESENT_STATE);
	if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))
		return 0;

	writel(readl(sock_addr + SOCK_CONTROL) | TIFM_CTRL_LED,
	       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);
	}

	/* xd needs some extra time before power on */
	if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7)
	    == TIFM_TYPE_XD)
		msleep(40);

	writel((s_state & 7) | 0x0c00, sock_addr + SOCK_CONTROL);
	/* wait for power to stabilize */
	msleep(20);
	for (cnt = 16; cnt <= 256; cnt <<= 1) {
		if ((TIFM_SOCK_STATE_POWERED
		     & readl(sock_addr + SOCK_PRESENT_STATE)))
			break;

		msleep(cnt);
	}

	writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),
	       sock_addr + SOCK_CONTROL);
		       sock_addr + SOCK_CONTROL);

	return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
}

	return base_addr + ((sock_num + 1) << 10);
}

static void tifm_7xx1_switch_media(struct work_struct *work)
{
	struct tifm_adapter *fm = container_of(work, struct tifm_adapter,
					       media_switcher);
	tifm_media_id media_id;
	char *card_name = "xx";
	int cnt, rc;
	struct tifm_dev *sock;
	unsigned long flags;
	unsigned char media_id;
	unsigned int socket_change_set, cnt;
		rc = wait_event_interruptible(fm->change_set_notify,
					      fm->socket_change_set);
		if (rc == -ERESTARTSYS)
			try_to_freeze();

	spin_lock_irqsave(&fm->lock, flags);
	socket_change_set = fm->socket_change_set;
	fm->socket_change_set = 0;

	dev_dbg(fm->cdev.dev, "checking media set %x\n",
		socket_change_set);

	if (!socket_change_set) {
			socket_change_set = (1 << fm->num_sockets) - 1;
		spin_unlock_irqrestore(&fm->lock, flags);
		return;
	}

	for (cnt = 0; cnt < fm->num_sockets; cnt++) {
		if (!(socket_change_set & (1 << cnt)))
			continue;
		sock = fm->sockets[cnt];
		if (sock) {
			printk(KERN_INFO
			       "%s : demand removing card from socket %u:%u\n",
			       fm->cdev.class_id, fm->id, cnt);
			fm->sockets[cnt] = NULL;
			if (sock) {
				printk(KERN_INFO DRIVER_NAME
				       ": demand removing card from socket %d\n",
				       cnt);
				fm->sockets[cnt] = NULL;
				spin_unlock_irqrestore(&fm->lock, flags);
				device_unregister(&sock->dev);
				spin_lock_irqsave(&fm->lock, flags);
				writel(0x0e00,
				       tifm_7xx1_sock_addr(fm->addr, cnt)
				       + SOCK_CONTROL);
			}
			if (kthread_should_stop())
				continue;

			spin_unlock_irqrestore(&fm->lock, flags);
			device_unregister(&sock->dev);
			spin_lock_irqsave(&fm->lock, flags);
			writel(0x0e00, tifm_7xx1_sock_addr(fm->addr, cnt)
			       + SOCK_CONTROL);
				sock = tifm_alloc_device(fm);
				if (sock) {
					sock->addr = tifm_7xx1_sock_addr(fm->addr,
									 cnt);
					sock->media_id = media_id;
					sock->socket_id = cnt;
					switch (media_id) {
					case 1:
						card_name = "xd";
						break;
					case 2:
						card_name = "ms";
						break;
					case 3:
						card_name = "sd";
						break;
					default:
						tifm_free_device(&sock->dev);
						spin_lock_irqsave(&fm->lock, flags);
						continue;
					}
					snprintf(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);
					if (!device_register(&sock->dev)) {
						spin_lock_irqsave(&fm->lock, flags);
						if (!fm->sockets[cnt]) {
							fm->sockets[cnt] = sock;
							sock = NULL;
						}
						spin_unlock_irqrestore(&fm->lock, flags);
					}
					if (sock)
						tifm_free_device(&sock->dev);
				}
				spin_lock_irqsave(&fm->lock, flags);
			}
		}

		spin_unlock_irqrestore(&fm->lock, flags);

		media_id = tifm_7xx1_toggle_sock_power(
				tifm_7xx1_sock_addr(fm->addr, cnt));

		// tifm_alloc_device will check if media_id is valid
		sock = tifm_alloc_device(fm, cnt, media_id);
		if (sock) {
			sock->addr = tifm_7xx1_sock_addr(fm->addr, cnt);

			if (!device_register(&sock->dev)) {
				spin_lock_irqsave(&fm->lock, flags);
				if (!fm->sockets[cnt]) {
					fm->sockets[cnt] = sock;
					sock = NULL;
				}
				spin_unlock_irqrestore(&fm->lock, flags);
				return 0;
			} else {
				spin_unlock_irqrestore(&fm->lock, flags);
			}
			if (sock)
				tifm_free_device(&sock->dev);
		}
		spin_lock_irqsave(&fm->lock, flags);
	}

	writel(TIFM_IRQ_FIFOMASK(socket_change_set)
	       | TIFM_IRQ_CARDMASK(socket_change_set),
	       fm->addr + FM_CLEAR_INTERRUPT_ENABLE);

	writel(TIFM_IRQ_FIFOMASK(socket_change_set)
	       | TIFM_IRQ_CARDMASK(socket_change_set),
	       fm->addr + FM_SET_INTERRUPT_ENABLE);

	writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
	spin_unlock_irqrestore(&fm->lock, flags);
}

#ifdef CONFIG_PM

static int tifm_7xx1_resume(struct pci_dev *dev)
{
	struct tifm_adapter *fm = pci_get_drvdata(dev);
	int rc;
	unsigned int good_sockets = 0, bad_sockets = 0;
	unsigned long flags;
	unsigned char new_ids[fm->num_sockets];
	DECLARE_COMPLETION_ONSTACK(finish_resume);

	pci_set_power_state(dev, PCI_D0);
	pci_restore_state(dev);


	dev_dbg(&dev->dev, "resuming host\n");

	for (rc = 0; rc < fm->num_sockets; rc++)
		new_ids[rc] = tifm_7xx1_toggle_sock_power(
					tifm_7xx1_sock_addr(fm->addr, rc));
					fm->num_sockets == 2);
	spin_lock_irqsave(&fm->lock, flags);
	for (rc = 0; rc < fm->num_sockets; rc++) {
		if (fm->sockets[rc]) {
			if (fm->sockets[rc]->type == new_ids[rc])
				good_sockets |= 1 << rc;
			else
				bad_sockets |= 1 << rc;
			fm->sockets[cnt]->media_id = new_ids[cnt];
		}
	}

	writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
	       fm->addr + FM_SET_INTERRUPT_ENABLE);
	dev_dbg(&dev->dev, "change sets on resume: good %x, bad %x\n",
		good_sockets, bad_sockets);

	fm->socket_change_set = 0;
	if (good_sockets) {
		fm->finish_me = &finish_resume;
		spin_unlock_irqrestore(&fm->lock, flags);
		rc = wait_for_completion_timeout(&finish_resume, HZ);
		dev_dbg(&dev->dev, "wait returned %d\n", rc);
		writel(TIFM_IRQ_FIFOMASK(good_sockets)
		       | TIFM_IRQ_CARDMASK(good_sockets),
		       fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		writel(TIFM_IRQ_FIFOMASK(good_sockets)
		       | TIFM_IRQ_CARDMASK(good_sockets),
		       fm->addr + FM_SET_INTERRUPT_ENABLE);
		spin_lock_irqsave(&fm->lock, flags);
		fm->finish_me = NULL;
		fm->socket_change_set ^= good_sockets & fm->socket_change_set;
	}

	fm->socket_change_set |= bad_sockets;
	if (fm->socket_change_set)
		tifm_queue_work(&fm->media_switcher);

	spin_unlock_irqrestore(&fm->lock, flags);
	writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
	       | TIFM_IRQ_CARDMASK(fm->socket_change_set),
	       fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
	writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
	       | TIFM_IRQ_CARDMASK(fm->socket_change_set),
	       fm->addr + FM_SET_INTERRUPT_ENABLE);
	writel(TIFM_IRQ_ENABLE,
	       fm->addr + FM_SET_INTERRUPT_ENABLE);
	fm->socket_change_set = 0;

	spin_unlock_irqrestore(&fm->lock, flags);
	return 0;
}



#endif /* CONFIG_PM */

static int tifm_7xx1_dummy_has_ms_pif(struct tifm_adapter *fm,
				      struct tifm_dev *sock)
{
	return 0;
}

static int tifm_7xx1_has_ms_pif(struct tifm_adapter *fm, struct tifm_dev *sock)
{
	if (((fm->num_sockets == 4) && (sock->socket_id == 2))
	    || ((fm->num_sockets == 2) && (sock->socket_id == 0)))
		return 1;

	return 0;
}

static int tifm_7xx1_probe(struct pci_dev *dev,
			   const struct pci_device_id *dev_id)
{


	pci_intx(dev, 1);

	fm = tifm_alloc_adapter(dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM
				? 4 : 2, &dev->dev);
	if (!fm) {
		rc = -ENOMEM;
		goto err_out_int;
	}

	INIT_WORK(&fm->media_switcher, tifm_7xx1_switch_media);
	fm->num_sockets = (dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM)
			  ? 4 : 2;
	fm->sockets = kzalloc(sizeof(struct tifm_dev*) * fm->num_sockets,
			      GFP_KERNEL);
	if (!fm->sockets)
		goto err_out_free;

	fm->eject = tifm_7xx1_eject;
	fm->has_ms_pif = tifm_7xx1_has_ms_pif;
	pci_set_drvdata(dev, fm);

	fm->addr = ioremap(pci_resource_start(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);
	rc = tifm_add_adapter(fm, tifm_7xx1_switch_media);
	if (rc)
		goto err_out_irq;

	writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
	writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
	       fm->addr + FM_SET_INTERRUPT_ENABLE);
	wake_up_process(fm->media_switcher);
	return 0;

err_out_irq:

static void tifm_7xx1_remove(struct pci_dev *dev)
{
	struct tifm_adapter *fm = pci_get_drvdata(dev);
	unsigned long flags;

	fm->eject = tifm_7xx1_dummy_eject;
	fm->has_ms_pif = tifm_7xx1_dummy_has_ms_pif;
	writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
	mmiowb();
	free_irq(dev->irq, fm);

	spin_lock_irqsave(&fm->lock, flags);
	fm->socket_change_set = (1 << fm->num_sockets) - 1;
	spin_unlock_irqrestore(&fm->lock, flags);

	kthread_stop(fm->media_switcher);

	tifm_remove_adapter(fm);

	pci_set_drvdata(dev, NULL);




 *
 */

#include "linux/tifm.h"
#include <linux/init.h>
#include <linux/idr.h>

#define DRIVER_NAME "tifm_core"
#define DRIVER_VERSION "0.8"

static struct workqueue_struct *workqueue;
static DEFINE_IDR(tifm_adapter_idr);
static DEFINE_SPINLOCK(tifm_adapter_lock);

static const char *tifm_media_type_name(unsigned char type, unsigned char nt)
			struct tifm_dev *dev)
{
	const char *card_type_name[3][3] = {
		{ "SmartMedia/xD", "MemoryStick", "MMC/SD" },
		{ "XD", "MS", "SD"},
		{ "xd", "ms", "sd"}
	};

	if (nt > 2 || type < 1 || type > 3)
		return NULL;
	return card_type_name[nt][type - 1];
}

static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id)
{
	if (sock->type == id->type)
	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 0;
}

static int tifm_bus_match(struct device *dev, struct device_driver *drv)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	struct tifm_driver *fm_drv = container_of(drv, struct tifm_driver,
						  driver);
	struct tifm_device_id *ids = fm_drv->id_table;

	if (ids) {
		while (ids->type) {
			if (tifm_dev_match(sock, ids))
				return 1;
			++ids;
		}
	}
	return 0;
}

static int tifm_uevent(struct device *dev, char **envp, int num_envp,
		       char *buffer, int buffer_size)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, 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",
			   tifm_media_type_name(sock->type, 1)))
		return -ENOMEM;

	return 0;
}

static int tifm_device_probe(struct device *dev)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
					       driver);
	int rc = -ENODEV;

	get_device(dev);
	if (dev->driver && drv->probe) {
		rc = drv->probe(sock);
		if (!rc)
			return 0;
	}
	put_device(dev);
	return rc;
}

static void tifm_dummy_event(struct tifm_dev *sock)
{
	return;
}

static int tifm_device_remove(struct device *dev)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
					       driver);

	if (dev->driver && drv->remove) {
		sock->card_event = tifm_dummy_event;
		sock->data_event = tifm_dummy_event;
		drv->remove(sock);
		sock->dev.driver = NULL;
	}

	put_device(dev);
	return 0;
}

#ifdef CONFIG_PM

static int tifm_device_suspend(struct device *dev, pm_message_t state)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
					       driver);

	if (dev->driver && drv->suspend)
		return drv->suspend(sock, state);
	return 0;
}

static int tifm_device_resume(struct device *dev)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
					       driver);

	if (dev->driver && drv->resume)
		return drv->resume(sock);
	return 0;
}



#endif /* CONFIG_PM */

static ssize_t type_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	return sprintf(buf, "%x", sock->type);
}

static struct device_attribute tifm_dev_attrs[] = {
	__ATTR(type, S_IRUGO, type_show, NULL),
	__ATTR_NULL
};

static struct bus_type tifm_bus_type = {
	.name      = "tifm",
	.dev_attrs = tifm_dev_attrs,
	.match     = tifm_bus_match,
	.uevent    = tifm_uevent,
	.probe     = tifm_device_probe,
	.remove    = tifm_device_remove,
	.suspend   = tifm_device_suspend,
	.resume    = tifm_device_resume
};

static void tifm_free(struct class_device *cdev)
{
	struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);

	kfree(fm->sockets);
	kfree(fm);
}


	.release = tifm_free
};

struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets,
					struct device *dev)
{
	struct tifm_adapter *fm;

	fm = kzalloc(sizeof(struct tifm_adapter)
		     + sizeof(struct tifm_dev*) * num_sockets, GFP_KERNEL);
	if (fm) {
		fm->cdev.class = &tifm_adapter_class;
		fm->cdev.dev = dev;
		class_device_initialize(&fm->cdev);
		spin_lock_init(&fm->lock);
		fm->num_sockets = num_sockets;
	}
	return fm;
}
EXPORT_SYMBOL(tifm_alloc_adapter);

int tifm_add_adapter(struct tifm_adapter *fm)
{
	class_device_put(&fm->cdev);
}
EXPORT_SYMBOL(tifm_free_adapter);

int tifm_add_adapter(struct tifm_adapter *fm,
		     int (*mediathreadfn)(void *data))
{
	int rc;


	spin_lock(&tifm_adapter_lock);
	rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id);
	spin_unlock(&tifm_adapter_lock);
	if (rc)
		return rc;
		fm->media_switcher = kthread_create(mediathreadfn,
						    fm, "tifm/%u", fm->id);

		if (!IS_ERR(fm->media_switcher))
			return class_device_add(&fm->cdev);

	snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);
	rc = class_device_add(&fm->cdev);
	if (rc) {
		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)
{
	unsigned int cnt;

	flush_workqueue(workqueue);
	for (cnt = 0; cnt < fm->num_sockets; ++cnt) {
		if (fm->sockets[cnt])
			device_unregister(&fm->sockets[cnt]->dev);
	}

	spin_lock(&tifm_adapter_lock);
	idr_remove(&tifm_adapter_idr, fm->id);
	spin_unlock(&tifm_adapter_lock);
	class_device_del(&fm->cdev);
}
EXPORT_SYMBOL(tifm_remove_adapter);

void tifm_free_adapter(struct tifm_adapter *fm)
{
	class_device_put(&fm->cdev);
	kfree(fm_dev);
}
EXPORT_SYMBOL(tifm_free_adapter);

void tifm_free_device(struct device *dev)
				  unsigned int sock_irq_status)
{
	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
	kfree(sock);
}
EXPORT_SYMBOL(tifm_free_device);

struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id,
				   unsigned char type)
{
	struct tifm_dev *sock = NULL;

	if (!tifm_media_type_name(type, 0))
		return sock;

	sock = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);
	if (sock) {
		spin_lock_init(&sock->lock);
		sock->type = type;
		sock->socket_id = id;
		sock->card_event = tifm_dummy_event;
		sock->data_event = tifm_dummy_event;

		sock->dev.parent = fm->cdev.dev;
		sock->dev.bus = &tifm_bus_type;
		sock->dev.dma_mask = fm->cdev.dev->dma_mask;
		sock->dev.release = tifm_free_device;

		snprintf(sock->dev.bus_id, BUS_ID_SIZE,
			 "tifm_%s%u:%u", tifm_media_type_name(type, 2),
			 fm->id, id);
		printk(KERN_INFO DRIVER_NAME
		       ": %s card detected in socket %u:%u\n",
		       tifm_media_type_name(type, 0), fm->id, id);
	}
	return sock;
}
EXPORT_SYMBOL(tifm_alloc_device);


}
EXPORT_SYMBOL(tifm_eject);

int tifm_has_ms_pif(struct tifm_dev *sock)
{
	struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent);
	return fm->has_ms_pif(fm, sock);
}
EXPORT_SYMBOL(tifm_has_ms_pif);

int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
		int direction)
{

}
EXPORT_SYMBOL(tifm_unmap_sg);

void tifm_queue_work(struct work_struct *work)
{
	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)
{
	queue_work(workqueue, work);
	struct tifm_driver *drv = fm_dev->drv;

	if (drv) {
		fm_dev->signal_irq = tifm_dummy_signal_irq;
		if (drv->remove)
			drv->remove(fm_dev);
		fm_dev->drv = NULL;
	}

	put_device(dev);
	return 0;
}
EXPORT_SYMBOL(tifm_queue_work);

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;
	drv->driver.suspend = tifm_device_suspend;
	drv->driver.resume = tifm_device_resume;

	return driver_register(&drv->driver);
}


static int __init tifm_init(void)
{
	int rc;

	workqueue = create_freezeable_workqueue("tifm");
	if (!workqueue)
		return -ENOMEM;

	rc = bus_register(&tifm_bus_type);

	if (rc)
		goto err_out_wq;

	rc = class_register(&tifm_adapter_class);
	if (!rc)
		return 0;

	bus_unregister(&tifm_bus_type);

err_out_wq:
	destroy_workqueue(workqueue);

	return rc;
}

{
	class_unregister(&tifm_adapter_class);
	bus_unregister(&tifm_bus_type);
	destroy_workqueue(workqueue);
}

subsys_initcall(tifm_init);




 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Special thanks to Brad Campbell for extensive testing of this driver.
 *
 */


#include "linux/tifm.h"
#include <linux/mmc/protocol.h>
#include <linux/mmc/host.h>
#include <linux/highmem.h>
#include <linux/scatterlist.h>
#include <asm/io.h>

#define DRIVER_NAME "tifm_sd"
#define DRIVER_VERSION "0.8"

static int no_dma = 0;
static int fixed_timeout = 0;

#define TIFM_MMCSD_INAB       0x0080   /* abort / initialize command */
#define TIFM_MMCSD_READ       0x8000

#define TIFM_MMCSD_DATAMASK   0x401d   /* set bits: CERR, EOFB, BRS, CB, EOC */
#define TIFM_MMCSD_ERRMASK    0x01e0   /* set bits: CCRC, CTO, DCRC, DTO */
#define TIFM_MMCSD_EOC        0x0001   /* end of command phase  */
#define TIFM_MMCSD_CD         0x0002   /* card detect           */
#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_CCRC       0x0100   /* command crc error     */
#define TIFM_MMCSD_AF         0x0400   /* fifo almost full      */
#define TIFM_MMCSD_AE         0x0800   /* fifo almost empty     */
#define TIFM_MMCSD_OCRB       0x1000   /* OCR busy              */
#define TIFM_MMCSD_CIRQ       0x2000   /* card irq (cmd40/sdio) */
#define TIFM_MMCSD_CERR       0x4000   /* card status error     */

#define TIFM_MMCSD_ODTO       0x0040   /* open drain / extended timeout */
#define TIFM_MMCSD_CARD_RO    0x0200   /* card is read-only     */

#define TIFM_MMCSD_FIFO_SIZE  0x0020

#define TIFM_MMCSD_RSP_R0     0x0000

#define TIFM_MMCSD_CMD_AC     0x2000
#define TIFM_MMCSD_CMD_ADTC   0x3000

#define TIFM_MMCSD_MAX_BLOCK_SIZE  0x0800UL
	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 {
	CMD_READY    = 0x0001,
	FIFO_READY   = 0x0002,
	BRS_READY    = 0x0004,
	SCMD_ACTIVE  = 0x0008,
	SCMD_READY   = 0x0010,
	CARD_BUSY    = 0x0020,
	DATA_CARRY   = 0x0040
};

struct tifm_sd {
	struct tifm_dev       *dev;

	unsigned short        eject:1,
			      open_drain:1,
			      no_dma:1;
	unsigned short        cmd_flags;

	unsigned int          clk_freq;
	unsigned int          clk_div;
	unsigned long         timeout_jiffies;

	struct tasklet_struct finish_tasklet;
	struct timer_list     timer;
	struct mmc_request    *req;
	wait_queue_head_t     notify;

	size_t                written_blocks;
	size_t                buffer_size;
	size_t                buffer_pos;

	int                   sg_len;
	int                   sg_pos;
	unsigned int          block_pos;
	struct scatterlist    bounce_buf;
	unsigned char         bounce_buf_data[TIFM_MMCSD_MAX_BLOCK_SIZE];
};

/* for some reason, host won't respond correctly to readw/writew */
static void tifm_sd_read_fifo(struct tifm_sd *host, struct page *pg,
			      unsigned int off, unsigned int cnt)
{
	struct tifm_dev *sock = host->dev;
	unsigned char *buf;
	unsigned int pos = 0, val;

	buf = kmap_atomic(pg, KM_BIO_DST_IRQ) + off;
	if (host->cmd_flags & DATA_CARRY) {
		buf[pos++] = host->bounce_buf_data[0];
		host->cmd_flags &= ~DATA_CARRY;
	}

	while (pos < cnt) {
		val = readl(sock->addr + SOCK_MMCSD_DATA);
		buf[pos++] = val & 0xff;
		if (pos == cnt) {
			host->bounce_buf_data[0] = (val >> 8) & 0xff;
			host->cmd_flags |= DATA_CARRY;
			break;
		}
		buf[pos++] = (val >> 8) & 0xff;
	}
	kunmap_atomic(buf - off, KM_BIO_DST_IRQ);
}

static void tifm_sd_write_fifo(struct tifm_sd *host, struct page *pg,
			       unsigned int off, unsigned int cnt)
{
	struct tifm_dev *sock = host->dev;
	unsigned char *buf;
	unsigned int pos = 0, val;

	buf = kmap_atomic(pg, KM_BIO_SRC_IRQ) + off;
	if (host->cmd_flags & DATA_CARRY) {
		val = host->bounce_buf_data[0] | ((buf[pos++] << 8) & 0xff00);
		writel(val, sock->addr + SOCK_MMCSD_DATA);
		host->cmd_flags &= ~DATA_CARRY;
	}

	while (pos < cnt) {
		val = buf[pos++];
		if (pos == cnt) {
			host->bounce_buf_data[0] = val & 0xff;
			host->cmd_flags |= DATA_CARRY;
			break;
		}
		val |= (buf[pos++] << 8) & 0xff00;
		writel(val, sock->addr + SOCK_MMCSD_DATA);
	}
	kunmap_atomic(buf - off, KM_BIO_SRC_IRQ);
}

static void tifm_sd_transfer_data(struct tifm_sd *host)
{
	struct mmc_data *r_data = host->req->cmd->data;
	struct scatterlist *sg = r_data->sg;
	unsigned int off, cnt, t_size = TIFM_MMCSD_FIFO_SIZE * 2;
	unsigned int p_off, p_cnt;
	struct page *pg;

	if (host->sg_pos == host->sg_len)
		return;
	while (t_size) {
		cnt = sg[host->sg_pos].length - host->block_pos;
		if (!cnt) {
			host->block_pos = 0;
			host->sg_pos++;
			if (host->sg_pos == host->sg_len) {
				if ((r_data->flags & MMC_DATA_WRITE)
				    && DATA_CARRY)
					writel(host->bounce_buf_data[0],
					       host->dev->addr
					       + SOCK_MMCSD_DATA);

				return;
			}
			cnt = sg[host->sg_pos].length;
		}
		off = sg[host->sg_pos].offset + host->block_pos;

		pg = nth_page(sg[host->sg_pos].page, off >> PAGE_SHIFT);
		p_off = offset_in_page(off);
		p_cnt = PAGE_SIZE - p_off;
		p_cnt = min(p_cnt, cnt);
		p_cnt = min(p_cnt, t_size);

		if (r_data->flags & MMC_DATA_READ)
			tifm_sd_read_fifo(host, pg, p_off, p_cnt);
		else if (r_data->flags & MMC_DATA_WRITE)
			tifm_sd_write_fifo(host, pg, p_off, p_cnt);

		t_size -= p_cnt;
		host->block_pos += p_cnt;
	}
}

static void tifm_sd_copy_page(struct page *dst, unsigned int dst_off,
			      struct page *src, unsigned int src_off,
			      unsigned int count)
{
	unsigned char *src_buf = kmap_atomic(src, KM_BIO_SRC_IRQ) + src_off;
	unsigned char *dst_buf = kmap_atomic(dst, KM_BIO_DST_IRQ) + dst_off;

	memcpy(dst_buf, src_buf, count);

	kunmap_atomic(dst_buf - dst_off, KM_BIO_DST_IRQ);
	kunmap_atomic(src_buf - src_off, KM_BIO_SRC_IRQ);
}

static void tifm_sd_bounce_block(struct tifm_sd *host, struct mmc_data *r_data)
{
	struct scatterlist *sg = r_data->sg;
	unsigned int t_size = r_data->blksz;
	unsigned int off, cnt;
	unsigned int p_off, p_cnt;
	struct page *pg;

	dev_dbg(&host->dev->dev, "bouncing block\n");
	while (t_size) {
		cnt = sg[host->sg_pos].length - host->block_pos;
		if (!cnt) {
			host->block_pos = 0;
			host->sg_pos++;
			if (host->sg_pos == host->sg_len)
				return;
			cnt = sg[host->sg_pos].length;
		}
		off = sg[host->sg_pos].offset + host->block_pos;

		pg = nth_page(sg[host->sg_pos].page, off >> PAGE_SHIFT);
		p_off = offset_in_page(off);
		p_cnt = PAGE_SIZE - p_off;
		p_cnt = min(p_cnt, cnt);
		p_cnt = min(p_cnt, t_size);

		if (r_data->flags & MMC_DATA_WRITE)
			tifm_sd_copy_page(host->bounce_buf.page,
					  r_data->blksz - t_size,
					  pg, p_off, p_cnt);
		else if (r_data->flags & MMC_DATA_READ)
			tifm_sd_copy_page(pg, p_off, host->bounce_buf.page,
					  r_data->blksz - t_size, p_cnt);

		t_size -= p_cnt;
		host->block_pos += p_cnt;
	}
}

int tifm_sd_set_dma_data(struct tifm_sd *host, struct mmc_data *r_data)
{
	struct tifm_dev *sock = host->dev;
	unsigned int t_size = TIFM_DMA_TSIZE * r_data->blksz;
	unsigned int dma_len, dma_blk_cnt, dma_off;
	struct scatterlist *sg = NULL;
	unsigned long flags;

	if (host->sg_pos == host->sg_len)
		return 1;

	if (host->cmd_flags & DATA_CARRY) {
		host->cmd_flags &= ~DATA_CARRY;
		local_irq_save(flags);
		tifm_sd_bounce_block(host, r_data);
		local_irq_restore(flags);
		if (host->sg_pos == host->sg_len)
			return 1;
	}

	dma_len = sg_dma_len(&r_data->sg[host->sg_pos]) - host->block_pos;
	if (!dma_len) {
		host->block_pos = 0;
		host->sg_pos++;
		if (host->sg_pos == host->sg_len)
			return 1;
		dma_len = sg_dma_len(&r_data->sg[host->sg_pos]);
	}

	if (dma_len < t_size) {
		dma_blk_cnt = dma_len / r_data->blksz;
		dma_off = host->block_pos;
		host->block_pos += dma_blk_cnt * r_data->blksz;
	} else {
		dma_blk_cnt = TIFM_DMA_TSIZE;
		dma_off = host->block_pos;
		host->block_pos += t_size;
	}

	if (dma_blk_cnt)
		sg = &r_data->sg[host->sg_pos];
	else if (dma_len) {
		if (r_data->flags & MMC_DATA_WRITE) {
			local_irq_save(flags);
			tifm_sd_bounce_block(host, r_data);
			local_irq_restore(flags);
		} else
			host->cmd_flags |= DATA_CARRY;

		sg = &host->bounce_buf;
		dma_off = 0;
		dma_blk_cnt = 1;
	} else
		return 1;

	dev_dbg(&sock->dev, "setting dma for %d blocks\n", dma_blk_cnt);
	writel(sg_dma_address(sg) + dma_off, sock->addr + SOCK_DMA_ADDRESS);
	if (r_data->flags & MMC_DATA_WRITE)
		writel((dma_blk_cnt << 8) | TIFM_DMA_TX | TIFM_DMA_EN,
		       sock->addr + SOCK_DMA_CONTROL);
	else
		writel((dma_blk_cnt << 8) | TIFM_DMA_EN,
		       sock->addr + SOCK_DMA_CONTROL);

	return 0;
}


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);

	if (host->open_drain)
		cmd_mask |= TIFM_MMCSD_ODTO;

	if (cmd->data && (cmd->data->flags & MMC_DATA_READ))
		cmd_mask |= TIFM_MMCSD_READ;

		       | readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x00);
}

static void tifm_sd_check_status(struct tifm_sd *host)
				       unsigned int host_status)
{
	struct tifm_dev *sock = host->dev;
	struct mmc_command *cmd = host->req->cmd;

	if (cmd->error != MMC_ERR_NONE)
		goto finish_request;

	if (!(host->cmd_flags & CMD_READY))
		return;

	if (cmd->data) {
		if (cmd->data->error != MMC_ERR_NONE) {
			if ((host->cmd_flags & SCMD_ACTIVE)
			    && !(host->cmd_flags & SCMD_READY))
				return;

			goto finish_request;
			goto change_state;
		}
		break;
	case BRS:
		if (tifm_sd_transfer_data(sock, host, host_status)) {
			if (cmd->data->flags & MMC_DATA_WRITE) {
				host->state = CARD;
			} else {
				if (no_dma) {
					if (host->req->stop) {
						tifm_sd_exec(host, host->req->stop);
						host->state = SCMD;
					} else {
						host->state = READY;
					}
				} else {
					host->state = FIFO;
				}
			}
			goto change_state;
		}
		break;
	case SCMD:
		if (host_status & TIFM_MMCSD_EOC) {
			tifm_sd_fetch_resp(host->req->stop, sock);
			host->state = READY;
			goto change_state;
		}

		if (!(host->cmd_flags & BRS_READY))
			return;

		if (!(host->no_dma || (host->cmd_flags & FIFO_READY)))
			return;

		if (cmd->data->flags & MMC_DATA_WRITE) {
			if (host->req->stop) {
				if (!(host->cmd_flags & SCMD_ACTIVE)) {
					host->cmd_flags |= SCMD_ACTIVE;
					writel(TIFM_MMCSD_EOFB
					       | readl(sock->addr
						       + SOCK_MMCSD_INT_ENABLE),
					       sock->addr
					       + SOCK_MMCSD_INT_ENABLE);
					tifm_sd_exec(host, host->req->stop);
					return;
				} else {
					if (!(host->cmd_flags & SCMD_READY)
					    || (host->cmd_flags & CARD_BUSY))
						return;
					writel((~TIFM_MMCSD_EOFB)
					       & readl(sock->addr
						       + SOCK_MMCSD_INT_ENABLE),
					       sock->addr
					       + SOCK_MMCSD_INT_ENABLE);
				}
			} else {
				if (host->cmd_flags & CARD_BUSY)
					return;
				writel((~TIFM_MMCSD_EOFB)
				       & readl(sock->addr
					       + SOCK_MMCSD_INT_ENABLE),
				       sock->addr + SOCK_MMCSD_INT_ENABLE);
			}
		} else {
		}
		break;
	case FIFO:
		if (host->flags & FIFO_RDY) {
			host->flags &= ~FIFO_RDY;
			if (host->req->stop) {
				if (!(host->cmd_flags & SCMD_ACTIVE)) {
					host->cmd_flags |= SCMD_ACTIVE;
					tifm_sd_exec(host, host->req->stop);
					return;
				} else {
					if (!(host->cmd_flags & SCMD_READY))
						return;
				}
			}
			goto change_state;
		}
		break;
	case READY:
		tasklet_schedule(&host->finish_tasklet);
		return;
	}
finish_request:
	tasklet_schedule(&host->finish_tasklet);
}

/* Called from interrupt handler */
static void tifm_sd_data_event(struct tifm_dev *sock)
			       unsigned int sock_irq_status)
{
	struct tifm_sd *host;
	unsigned int fifo_status = 0;
	struct mmc_data *r_data = NULL;

	spin_lock(&sock->lock);
	host = mmc_priv((struct mmc_host*)tifm_get_drvdata(sock));
	fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS);
	dev_dbg(&sock->dev, "data event: fifo_status %x, flags %x\n",
		fifo_status, host->cmd_flags);

	if (host->req) {
		r_data = host->req->cmd->data;
		writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS);

		if (r_data && (fifo_status & TIFM_FIFO_READY)) {
			if (tifm_sd_set_dma_data(host, r_data)) {
				host->cmd_flags |= FIFO_READY;
				tifm_sd_check_status(host);
			}
		}
	}

	writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS);
	spin_unlock(&sock->lock);
}

/* Called from interrupt handler */
static void tifm_sd_card_event(struct tifm_dev *sock)
{
	struct tifm_sd *host;
	unsigned int host_status = 0;
	int cmd_error = MMC_ERR_NONE;
	struct mmc_command *cmd = NULL;
	unsigned long flags;

	spin_lock(&sock->lock);
	host = mmc_priv((struct mmc_host*)tifm_get_drvdata(sock));
	host_status = readl(sock->addr + SOCK_MMCSD_STATUS);
	dev_dbg(&sock->dev, "host event: host_status %x, flags %x\n",
		host_status, host->cmd_flags);

	if (host->req) {
		cmd = host->req->cmd;

		if (host_status & TIFM_MMCSD_ERRMASK) {
			writel(host_status & TIFM_MMCSD_ERRMASK,
			       sock->addr + SOCK_MMCSD_STATUS);
			if (host_status & TIFM_MMCSD_CTO)
				cmd_error = MMC_ERR_TIMEOUT;
			else if (host_status & TIFM_MMCSD_CCRC)
				cmd_error = MMC_ERR_BADCRC;

			if (cmd->data) {
				if (host_status & TIFM_MMCSD_DTO)
					cmd->data->error = MMC_ERR_TIMEOUT;
				else if (host_status & TIFM_MMCSD_DCRC)
					cmd->data->error = 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->cmd_flags & SCMD_ACTIVE) {
					host->req->stop->error = cmd_error;
					host->cmd_flags |= SCMD_READY;
					   || host->state == CARD
					   || host->state == FIFO) {
					host->req->cmd->error = error_code;
					tifm_sd_exec(host, host->req->stop);
					host->state = SCMD;
					goto done;
				} else {
					cmd->error = cmd_error;
					//host->cmd_flags |= SCMD_ACTIVE;
					//tifm_sd_exec(host, host->req->stop);
					tifm_sd_check_status(host);
					goto done;
				}
			} else
				cmd->error = cmd_error;
		} else {
			if (host_status & (TIFM_MMCSD_EOC | TIFM_MMCSD_CERR)) {
				if (!(host->cmd_flags & CMD_READY)) {
					host->cmd_flags |= CMD_READY;
					tifm_sd_fetch_resp(cmd, sock);
				} else if (host->cmd_flags & SCMD_ACTIVE) {
					host->cmd_flags |= SCMD_READY;
					tifm_sd_fetch_resp(host->req->stop,
							   sock);
				}
			} else {
				host->req->cmd->error = error_code;
			}
			if (host_status & TIFM_MMCSD_BRS)
				host->cmd_flags |= BRS_READY;
		}

		if (host->no_dma && cmd->data) {
			if (host_status & TIFM_MMCSD_AE)
				writel(host_status & TIFM_MMCSD_AE,
				       sock->addr + SOCK_MMCSD_STATUS);

			if (host_status & (TIFM_MMCSD_AE | TIFM_MMCSD_AF
					   | TIFM_MMCSD_BRS)) {
				local_irq_save(flags);
				tifm_sd_transfer_data(host);
				local_irq_restore(flags);
				host_status &= ~TIFM_MMCSD_AE;
			}
		}
        }

	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);
}

static void tifm_sd_prepare_data(struct tifm_sd *host, struct mmc_command *cmd)
{
	struct tifm_dev *sock = host->dev;
	unsigned int dest_cnt;

	/* DMA style IO */
	dev_dbg(&sock->dev, "setting dma for %d blocks\n",
		cmd->data->blocks);
	writel(TIFM_FIFO_INT_SETALL,
	       sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
	writel(ilog2(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);

		if (host_status & TIFM_MMCSD_EOFB)
			host->cmd_flags &= ~CARD_BUSY;
		else if (host_status & TIFM_MMCSD_CB)
			host->cmd_flags |= CARD_BUSY;

		tifm_sd_check_status(host);
		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);
	}
done:
	writel(host_status, sock->addr + SOCK_MMCSD_STATUS);
	spin_unlock(&sock->lock);
}

static void tifm_sd_set_data_timeout(struct tifm_sd *host,

	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->eject) {
		spin_unlock_irqrestore(&sock->lock, flags);
		goto err_out;
	}

	if (host->req) {
		printk(KERN_ERR "%s : unfinished request detected\n",
		       sock->dev.bus_id);
		spin_unlock_irqrestore(&sock->lock, flags);
		goto err_out;
	}

	host->cmd_flags = 0;
	host->block_pos = 0;
	host->sg_pos = 0;

	if (r_data) {
		tifm_sd_set_data_timeout(host, r_data);

		if ((r_data->flags & MMC_DATA_WRITE) && !mrq->stop)
			 writel(TIFM_MMCSD_EOFB
				| readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
				sock->addr + SOCK_MMCSD_INT_ENABLE);
			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;
	mod_timer(&host->timer, jiffies + host->timeout_jiffies);
	host->state = CMD;
	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(unsigned long 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 = NULL;
	unsigned long flags;

	spin_lock_irqsave(&sock->lock, flags);

	del_timer(&host->timer);
	mrq = host->req;
	host->req = NULL;
	host->state = IDLE;

		if (host->no_dma) {
			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->sg_len = r_data->sg_len;
	if (r_data) {
		if (r_data->flags & MMC_DATA_WRITE) {
			r_data->bytes_xfered = host->written_blocks
					       * r_data->blksz;
		} else {
			sg_init_one(&host->bounce_buf, host->bounce_buf_data,
				    r_data->blksz);

			if(1 != tifm_map_sg(sock, &host->bounce_buf, 1,
					    r_data->flags & MMC_DATA_WRITE
					    ? PCI_DMA_TODEVICE
					    : PCI_DMA_FROMDEVICE)) {
				printk(KERN_ERR "%s : scatterlist map failed\n",
				       sock->dev.bus_id);
				spin_unlock_irqrestore(&sock->lock, flags);
				goto err_out;
			}
			host->sg_len = tifm_map_sg(sock, r_data->sg,
						   r_data->sg_len,
						   r_data->flags
						   & MMC_DATA_WRITE
						   ? PCI_DMA_TODEVICE
						   : PCI_DMA_FROMDEVICE);
			if (host->sg_len < 1) {
				printk(KERN_ERR "%s : scatterlist map failed\n",
				       sock->dev.bus_id);
				tifm_unmap_sg(sock, &host->bounce_buf, 1,
					      r_data->flags & MMC_DATA_WRITE
					      ? PCI_DMA_TODEVICE
					      : PCI_DMA_FROMDEVICE);
				spin_unlock_irqrestore(&sock->lock, flags);
				goto err_out;
			}
		goto err_out;
	}

	if (host->req) {
		printk(KERN_ERR DRIVER_NAME ": unfinished request detected\n");
		spin_unlock_irqrestore(&sock->lock, flags);
		goto err_out;
	}

			writel(TIFM_FIFO_INT_SETALL,
			       sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
			writel(ilog2(r_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);

			if (r_data->flags & MMC_DATA_WRITE)
				writel(TIFM_MMCSD_TXDE,
				       sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
			else
				writel(TIFM_MMCSD_RXDE,
				       sock->addr + SOCK_MMCSD_BUFFER_CONFIG);

			tifm_sd_set_dma_data(host, r_data);
		}

		writel(r_data->blocks - 1,
		       sock->addr + SOCK_MMCSD_NUM_BLOCKS);
		writel(r_data->blksz - 1,
		       sock->addr + SOCK_MMCSD_BLOCK_LEN);
		       | 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;
	mod_timer(&host->timer, jiffies + host->timeout_jiffies);
	host->state = CMD;
	writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
	       sock->addr + SOCK_CONTROL);
	tifm_sd_exec(host, mrq->cmd);

	mmc_request_done(mmc, mrq);
}

static void tifm_sd_end_cmd(unsigned long data)
{
	struct tifm_sd *host = (struct tifm_sd*)data;
	struct tifm_dev *sock = host->dev;

	del_timer(&host->timer);
	mrq = host->req;
	host->req = NULL;
	host->state = IDLE;

	if (!mrq) {
		printk(KERN_ERR " %s : no request to complete?\n",
		       sock->dev.bus_id);
		spin_unlock_irqrestore(&sock->lock, flags);
		return;
	}

	r_data = mrq->cmd->data;
	if (r_data) {
		if (host->no_dma) {
			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 {
			tifm_unmap_sg(sock, &host->bounce_buf, 1,
				      (r_data->flags & MMC_DATA_WRITE)
				      ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
			tifm_unmap_sg(sock, r_data->sg, r_data->sg_len,
				      (r_data->flags & MMC_DATA_WRITE)
				      ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
		}

		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;
	}

	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_terminate(struct tifm_sd *host)
{
	struct tifm_dev *sock = host->dev;
	unsigned long flags;

	writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
	mmiowb();
	spin_lock_irqsave(&sock->lock, flags);
	host->flags |= EJECT;
	if (host->req) {
		writel(TIFM_FIFO_INT_SETALL,
		       sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
		writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
		tasklet_schedule(&host->finish_tasklet);
	}
	spin_unlock_irqrestore(&sock->lock, flags);
}

static void tifm_sd_abort(unsigned long data)
{
	struct tifm_sd *host = (struct tifm_sd*)data;

	printk(KERN_ERR
	       "%s : card failed to respond for a long period of time "
	       "(%x, %x)\n",
	       host->dev->dev.bus_id, host->req->cmd->opcode, host->cmd_flags);

	tifm_sd_terminate(host);
	tifm_eject(host->dev);
}



	spin_lock_irqsave(&sock->lock, flags);

	dev_dbg(&sock->dev, "ios: clock = %u, vdd = %x, bus_mode = %x, "
		"chip_select = %x, power_mode = %x, bus_width = %x\n",
		ios->clock, ios->vdd, ios->bus_mode, ios->chip_select,
		ios->power_mode, ios->bus_width);

	if (ios->bus_width == MMC_BUS_WIDTH_4) {
		writel(TIFM_MMCSD_4BBUS | readl(sock->addr + SOCK_MMCSD_CONFIG),
		       sock->addr + SOCK_MMCSD_CONFIG);

		  & readl(sock->addr + SOCK_MMCSD_CONFIG)),
	       sock->addr + SOCK_MMCSD_CONFIG);

	host->open_drain = (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->notify);
	}

	spin_unlock_irqrestore(&sock->lock, flags);
}

static int tifm_sd_ro(struct mmc_host *mmc)
{
	int rc = 0;
	struct tifm_sd *host = mmc_priv(mmc);
	struct tifm_dev *sock = host->dev;
	unsigned long flags;

	spin_lock_irqsave(&sock->lock, flags);
	if (TIFM_MMCSD_CARD_RO & readl(sock->addr + SOCK_PRESENT_STATE))
		rc = 1;
	rc = (host->flags & CARD_RO) ? 1 : 0;

	spin_unlock_irqrestore(&sock->lock, flags);
	return rc;
}

static const struct mmc_host_ops tifm_sd_ops = {
	.request = tifm_sd_request,
	.set_ios = tifm_sd_ios,
	.get_ro  = tifm_sd_ro

	       sock->addr + SOCK_MMCSD_CONFIG);

	/* wait up to 0.51 sec for reset */
	for (rc = 32; rc <= 256; rc <<= 1) {
		if (1 & readl(sock->addr + SOCK_MMCSD_SYSTEM_STATUS)) {
			rc = 0;
			break;

	}

	if (rc) {
		printk(KERN_ERR "%s : controller failed to reset\n",
		       sock->dev.bus_id);
		return -ENODEV;
	}


	writel(64, sock->addr + SOCK_MMCSD_COMMAND_TO);
	writel(TIFM_MMCSD_INAB, sock->addr + SOCK_MMCSD_COMMAND);

	for (rc = 16; rc <= 64; rc <<= 1) {
	for (rc = 1; rc <= 16; rc <<= 1) {
		host_status = readl(sock->addr + SOCK_MMCSD_STATUS);
		writel(host_status, sock->addr + SOCK_MMCSD_STATUS);
		if (!(host_status & TIFM_MMCSD_ERRMASK)

	}

	if (rc) {
		printk(KERN_ERR
		       "%s : card not ready - probe failed on initialization\n",
		       sock->dev.bus_id);
		return -ENODEV;
	}

	writel(TIFM_MMCSD_CERR | TIFM_MMCSD_BRS | TIFM_MMCSD_EOC
	       | TIFM_MMCSD_ERRMASK,
	       sock->addr + SOCK_MMCSD_INT_ENABLE);
	mmiowb();



	if (!(TIFM_SOCK_STATE_OCCUPIED
	      & readl(sock->addr + SOCK_PRESENT_STATE))) {
		printk(KERN_WARNING "%s : card gone, unexpectedly\n",
		       sock->dev.bus_id);
		return rc;
	}


		return -ENOMEM;

	host = mmc_priv(mmc);
	host->no_dma = no_dma;
	tifm_set_drvdata(sock, mmc);
	host->dev = sock;
	host->timeout_jiffies = msecs_to_jiffies(1000);

	tasklet_init(&host->finish_tasklet, tifm_sd_end_cmd,
	tasklet_init(&host->finish_tasklet,
		     no_dma ? tifm_sd_end_cmd_nodma : tifm_sd_end_cmd,
		     (unsigned long)host);
	setup_timer(&host->timer, tifm_sd_abort, (unsigned long)host);

	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_CAP_MULTIWRITE;
	mmc->f_min = 20000000 / 60;
	mmc->f_max = 24000000;
#if 0
	mmc->max_seg_size = 2048 * 2048;
	mmc->max_hw_segs = 2048;
	mmc->max_phys_segs = 2048;
	mmc->max_sectors = 2048;
#endif
	mmc->max_blk_count = 2048;
	mmc->max_hw_segs = mmc->max_blk_count;
	mmc->max_phys_segs = mmc->max_hw_segs;
	mmc->max_blk_size = min(2048UL, PAGE_SIZE);
	mmc->max_seg_size = mmc->max_blk_count * mmc->max_blk_size;
	mmc->max_req_size = mmc->max_seg_size;

	sock->card_event = tifm_sd_card_event;
	sock->data_event = tifm_sd_data_event;
	rc = tifm_sd_initialize_host(host);

	if (!rc)
		rc = mmc_add_host(mmc);
	if (!rc)
		return 0;

	return 0;
out_free_mmc:
	mmc_free_host(mmc);
	return rc;
}

{
	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->eject = 1;
	writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
	mmiowb();
	spin_unlock_irqrestore(&sock->lock, flags);

	del_timer_sync(&host->timer);
	tifm_sd_terminate(host);
	wait_event_timeout(host->notify, host->flags & EJECT_DONE,
			   host->timeout_jiffies);
	tasklet_kill(&host->finish_tasklet);

	spin_lock_irqsave(&sock->lock, flags);
	if (host->req) {
		writel(TIFM_FIFO_INT_SETALL,
		       sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
		writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
		host->req->cmd->error = MMC_ERR_TIMEOUT;
		if (host->req->stop)
			host->req->stop->error = MMC_ERR_TIMEOUT;
		tasklet_schedule(&host->finish_tasklet);
	}
	spin_unlock_irqrestore(&sock->lock, flags);
	mmc_remove_host(mmc);
	dev_dbg(&sock->dev, "after remove\n");

	/* The meaning of the bit majority in this constant is unknown. */
	writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
	       sock->addr + SOCK_CONTROL);

	tifm_set_drvdata(sock, NULL);
	mmc_free_host(mmc);
}


{
	struct mmc_host *mmc = tifm_get_drvdata(sock);
	struct tifm_sd *host = mmc_priv(mmc);
	int rc;

	rc = tifm_sd_initialize_host(host);
	dev_dbg(&sock->dev, "resume initialize %d\n", rc);

	if (rc)
		host->eject = 1;
	else
		rc = mmc_resume_host(mmc);

	return rc;
}

#else


#endif /* CONFIG_PM */

static struct tifm_device_id tifm_sd_id_tbl[] = {
	{ TIFM_TYPE_SD }, { }
};

static struct tifm_driver tifm_sd_driver = {





#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/workqueue.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_MS_DATA                   = 0x188,
	SOCK_MS_STATUS                 = 0x18c,
	SOCK_MS_SYSTEM                 = 0x190,
	SOCK_FIFO_ACCESS               = 0x200
};

#define TIFM_IRQ_ENABLE           0x80000000
#define TIFM_IRQ_SOCKMASK(x)      (x)
#define TIFM_IRQ_CARDMASK(x)      ((x) << 8)
#define TIFM_IRQ_FIFOMASK(x)      ((x) << 16)
#define TIFM_IRQ_SETALL           0xffffffff

#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
#define TIFM_FIFO_READY           0x00000001
#define TIFM_FIFO_INT_SETALL      0x0000ffff
#define TIFM_FIFO_INTMASK         0x00000005

#define TIFM_DMA_RESET            0x00000002
#define TIFM_DMA_TX               0x00008000
#define TIFM_DMA_EN               0x00000001
#define TIFM_DMA_TSIZE            0x0000007f

#define TIFM_TYPE_XD 1
#define TIFM_TYPE_MS 2
#define TIFM_TYPE_SD 3

struct tifm_device_id {
	unsigned char type;
};

struct tifm_driver;
struct tifm_dev {
	char __iomem  *addr;
	spinlock_t    lock;
	unsigned char type;
	unsigned int  socket_id;

	void          (*card_event)(struct tifm_dev *sock);
	void          (*data_event)(struct tifm_dev *sock);

	struct device dev;
	struct device           dev;
};

struct tifm_driver {
	struct tifm_device_id *id_table;
	int                   (*probe)(struct tifm_dev *dev);
	void                  (*remove)(struct tifm_dev *dev);
	int                   (*suspend)(struct tifm_dev *dev,
					 pm_message_t state);
	int                   (*resume)(struct tifm_dev *dev);

	struct device_driver  driver;
};

struct tifm_adapter {
	char __iomem        *addr;
	spinlock_t          lock;
	unsigned int        irq_status;
	unsigned int        socket_change_set;
	unsigned int        id;
	unsigned int        num_sockets;
	struct completion   *finish_me;

	struct work_struct  media_switcher;
	struct class_device cdev;

	void                (*eject)(struct tifm_adapter *fm,
				     struct tifm_dev *sock);
	int                 (*has_ms_pif)(struct tifm_adapter *fm,
					  struct tifm_dev *sock);

	struct tifm_dev     *sockets[0];
};

struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets,
					struct device *dev);
int tifm_add_adapter(struct tifm_adapter *fm);
int tifm_add_adapter(struct tifm_adapter *fm, int (*mediathreadfn)(void *data));
void tifm_remove_adapter(struct tifm_adapter *fm);
void tifm_free_adapter(struct tifm_adapter *fm);

void tifm_free_device(struct device *dev);
struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id,
				   unsigned char type);

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_has_ms_pif(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);
void tifm_queue_work(struct work_struct *work);

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

Return to bug 8052

Lines 14-29 Link Here

(-)a/include/linux/tifm.h (-57 / +63 lines)
14		14
15	#include <linux/spinlock.h>	15	#include <linux/spinlock.h>
16	#include <linux/interrupt.h>	16	#include <linux/interrupt.h>
17	#include <linux/wait.h>
18	#include <linux/delay.h>	17	#include <linux/delay.h>
19	#include <linux/pci.h>	18	#include <linux/pci.h>
20	#include <linux/kthread.h>	19	#include <linux/workqueue.h>
21		20
22	/* Host registers (relative to pci base address): */	21	/* Host registers (relative to pci base address): */
23	enum {	22	enum {
24	FM_SET_INTERRUPT_ENABLE = 0x008,	23	FM_SET_INTERRUPT_ENABLE = 0x008,
25	FM_CLEAR_INTERRUPT_ENABLE = 0x00c,	24	FM_CLEAR_INTERRUPT_ENABLE = 0x00c,
26	FM_INTERRUPT_STATUS = 0x014 };	25	FM_INTERRUPT_STATUS = 0x014
		26	};
27		27
28	/* Socket registers (relative to socket base address): */	28	/* Socket registers (relative to socket base address): */
29	enum {	29	enum {
Lines 58-71 enum { Link Here
58	SOCK_MS_DATA = 0x188,	58	SOCK_MS_DATA = 0x188,
59	SOCK_MS_STATUS = 0x18c,	59	SOCK_MS_STATUS = 0x18c,
60	SOCK_MS_SYSTEM = 0x190,	60	SOCK_MS_SYSTEM = 0x190,
61	SOCK_FIFO_ACCESS = 0x200 };	61	SOCK_FIFO_ACCESS = 0x200
62		62	};
63
64	#define TIFM_IRQ_ENABLE 0x80000000
65	#define TIFM_IRQ_SOCKMASK(x) (x)
66	#define TIFM_IRQ_CARDMASK(x) ((x) << 8)
67	#define TIFM_IRQ_FIFOMASK(x) ((x) << 16)
68	#define TIFM_IRQ_SETALL 0xffffffff
69		63
70	#define TIFM_CTRL_LED 0x00000040	64	#define TIFM_CTRL_LED 0x00000040
71	#define TIFM_CTRL_FAST_CLK 0x00000100	65	#define TIFM_CTRL_FAST_CLK 0x00000100
Lines 73-147 enum { Link Here
73	#define TIFM_SOCK_STATE_OCCUPIED 0x00000008	67	#define TIFM_SOCK_STATE_OCCUPIED 0x00000008
74	#define TIFM_SOCK_STATE_POWERED 0x00000080	68	#define TIFM_SOCK_STATE_POWERED 0x00000080
75		69
76	#define TIFM_FIFO_ENABLE 0x00000001 /* Meaning of this constant is unverified */	70	#define TIFM_FIFO_ENABLE 0x00000001
		71	#define TIFM_FIFO_READY 0x00000001
77	#define TIFM_FIFO_INT_SETALL 0x0000ffff	72	#define TIFM_FIFO_INT_SETALL 0x0000ffff
78	#define TIFM_FIFO_INTMASK 0x00000005 /* Meaning of this constant is unverified */	73	#define TIFM_FIFO_INTMASK 0x00000005
79		74
80	#define TIFM_DMA_RESET 0x00000002 /* Meaning of this constant is unverified */	75	#define TIFM_DMA_RESET 0x00000002
81	#define TIFM_DMA_TX 0x00008000 /* Meaning of this constant is unverified */	76	#define TIFM_DMA_TX 0x00008000
82	#define TIFM_DMA_EN 0x00000001 /* Meaning of this constant is unverified */	77	#define TIFM_DMA_EN 0x00000001
		78	#define TIFM_DMA_TSIZE 0x0000007f
83		79
84	typedef enum {FM_NULL = 0, FM_XD = 0x01, FM_MS = 0x02, FM_SD = 0x03} tifm_media_id;	80	#define TIFM_TYPE_XD 1
		81	#define TIFM_TYPE_MS 2
		82	#define TIFM_TYPE_SD 3
		83
		84	struct tifm_device_id {
		85	unsigned char type;
		86	};
85		87
86	struct tifm_driver;	88	struct tifm_driver;
87	struct tifm_dev {	89	struct tifm_dev {
88	char __iomem *addr;	90	char __iomem *addr;
89	spinlock_t lock;	91	spinlock_t lock;
90	tifm_media_id media_id;	92	unsigned char type;
91	unsigned int socket_id;	93	unsigned int socket_id;
92		94
93	void (signal_irq)(struct tifm_dev sock,	95	void (card_event)(struct tifm_dev sock);
94	unsigned int sock_irq_status);	96	void (data_event)(struct tifm_dev sock);
95		97
96	struct tifm_driver *drv;	98	struct device dev;
97	struct device dev;
98	};	99	};
99		100
100	struct tifm_driver {	101	struct tifm_driver {
101	tifm_media_id *id_table;	102	struct tifm_device_id *id_table;
102	int (probe)(struct tifm_dev dev);	103	int (probe)(struct tifm_dev dev);
103	void (remove)(struct tifm_dev dev);	104	void (remove)(struct tifm_dev dev);
104	int (suspend)(struct tifm_dev dev,	105	int (suspend)(struct tifm_dev dev,
105	pm_message_t state);	106	pm_message_t state);
106	int (resume)(struct tifm_dev dev);	107	int (resume)(struct tifm_dev dev);
107		108
108	struct device_driver driver;	109	struct device_driver driver;
109	};	110	};
110		111
111	struct tifm_adapter {	112	struct tifm_adapter {
112	char __iomem *addr;	113	char __iomem *addr;
113	spinlock_t lock;	114	spinlock_t lock;
114	unsigned int irq_status;	115	unsigned int irq_status;
115	unsigned int socket_change_set;	116	unsigned int socket_change_set;
116	wait_queue_head_t change_set_notify;	117	unsigned int id;
117	unsigned int id;	118	unsigned int num_sockets;
118	unsigned int num_sockets;	119	struct completion *finish_me;
119	struct tifm_dev **sockets;	120
120	struct task_struct *media_switcher;	121	struct work_struct media_switcher;
121	struct class_device cdev;	122	struct class_device cdev;
122	struct device *dev;	123
123		124	void (eject)(struct tifm_adapter fm,
124	void (eject)(struct tifm_adapter fm, struct tifm_dev *sock);	125	struct tifm_dev *sock);
		126	int (has_ms_pif)(struct tifm_adapter fm,
		127	struct tifm_dev *sock);
		128
		129	struct tifm_dev *sockets[0];
125	};	130	};
126		131
127	struct tifm_adapter *tifm_alloc_adapter(void);	132	struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets,
128	void tifm_free_device(struct device *dev);	133	struct device *dev);
129	void tifm_free_adapter(struct tifm_adapter *fm);	134	int tifm_add_adapter(struct tifm_adapter *fm);
130	int tifm_add_adapter(struct tifm_adapter fm, int (mediathreadfn)(void *data));
131	void tifm_remove_adapter(struct tifm_adapter *fm);	135	void tifm_remove_adapter(struct tifm_adapter *fm);
132	struct tifm_dev tifm_alloc_device(struct tifm_adapter fm);	136	void tifm_free_adapter(struct tifm_adapter *fm);
		137
		138	void tifm_free_device(struct device *dev);
		139	struct tifm_dev tifm_alloc_device(struct tifm_adapter fm, unsigned int id,
		140	unsigned char type);
		141
133	int tifm_register_driver(struct tifm_driver *drv);	142	int tifm_register_driver(struct tifm_driver *drv);
134	void tifm_unregister_driver(struct tifm_driver *drv);	143	void tifm_unregister_driver(struct tifm_driver *drv);
135	void tifm_eject(struct tifm_dev *sock);	144	void tifm_eject(struct tifm_dev *sock);
		145	int tifm_has_ms_pif(struct tifm_dev *sock);
136	int tifm_map_sg(struct tifm_dev sock, struct scatterlist sg, int nents,	146	int tifm_map_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
137	int direction);	147	int direction);
138	void tifm_unmap_sg(struct tifm_dev sock, struct scatterlist sg, int nents,	148	void tifm_unmap_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
139	int direction);	149	int direction);
140		150	void tifm_queue_work(struct work_struct *work);
141		151
142	static inline void tifm_get_drvdata(struct tifm_dev dev)	152	static inline void tifm_get_drvdata(struct tifm_dev dev)
143	{	153	{
144	return dev_get_drvdata(&dev->dev);	154	return dev_get_drvdata(&dev->dev);
145	}	155	}
146		156
147	static inline void tifm_set_drvdata(struct tifm_dev dev, void data)	157	static inline void tifm_set_drvdata(struct tifm_dev dev, void data)
Lines 149-156 static inline void tifm_set_drvdata(struct tifm_dev dev, void data) Link Here
149	dev_set_drvdata(&dev->dev, data);	159	dev_set_drvdata(&dev->dev, data);
150	}	160	}
151		161
152	struct tifm_device_id {
153	tifm_media_id media_id;
154	};
155
156	#endif	162	#endif

Lines 9-20 Link Here

(-)a/drivers/misc/tifm_7xx1.c (-193 / +159 lines)
9	*	9	*
10	*/	10	*/
11		11
12	#include <linux/tifm.h>	12	#include "linux/tifm.h"
13	#include <linux/dma-mapping.h>
14	#include <linux/freezer.h>
15		13
16	#define DRIVER_NAME "tifm_7xx1"	14	#define DRIVER_NAME "tifm_7xx1"
17	#define DRIVER_VERSION "0.7"	15	#define DRIVER_VERSION "0.8"
		16
		17	#define TIFM_IRQ_ENABLE 0x80000000
		18	#define TIFM_IRQ_SOCKMASK(x) (x)
		19	#define TIFM_IRQ_CARDMASK(x) ((x) << 8)
		20	#define TIFM_IRQ_FIFOMASK(x) ((x) << 16)
		21	#define TIFM_IRQ_SETALL 0xffffffff
		22
		23	static void tifm_7xx1_dummy_eject(struct tifm_adapter *fm,
		24	struct tifm_dev *sock)
		25	{
		26	}
18		27
19	static void tifm_7xx1_eject(struct tifm_adapter fm, struct tifm_dev sock)	28	static void tifm_7xx1_eject(struct tifm_adapter fm, struct tifm_dev sock)
20	{	29	{
Lines 22-28 static void tifm_7xx1_eject(struct tifm_adapter fm, struct tifm_dev sock) Link Here
22		31
23	spin_lock_irqsave(&fm->lock, flags);	32	spin_lock_irqsave(&fm->lock, flags);
24	fm->socket_change_set \|= 1 << sock->socket_id;	33	fm->socket_change_set \|= 1 << sock->socket_id;
25	wake_up_all(&fm->change_set_notify);	34	tifm_queue_work(&fm->media_switcher);
26	spin_unlock_irqrestore(&fm->lock, flags);	35	spin_unlock_irqrestore(&fm->lock, flags);
27	}	36	}
28		37
Lines 30-37 static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id) Link Here
30	{	39	{
31	struct tifm_adapter *fm = dev_id;	40	struct tifm_adapter *fm = dev_id;
32	struct tifm_dev *sock;	41	struct tifm_dev *sock;
33	unsigned int irq_status;	42	unsigned int irq_status, cnt;
34	unsigned int sock_irq_status, cnt;
35		43
36	spin_lock(&fm->lock);	44	spin_lock(&fm->lock);
37	irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);	45	irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);
Lines 45-56 static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id) Link Here
45		53
46	for (cnt = 0; cnt < fm->num_sockets; cnt++) {	54	for (cnt = 0; cnt < fm->num_sockets; cnt++) {
47	sock = fm->sockets[cnt];	55	sock = fm->sockets[cnt];
48	sock_irq_status = (irq_status >> cnt)	56	if (sock) {
49	& (TIFM_IRQ_FIFOMASK(1)	57	if ((irq_status >> cnt) & TIFM_IRQ_FIFOMASK(1))
50	\| TIFM_IRQ_CARDMASK(1));	58	sock->data_event(sock);
51		59	if ((irq_status >> cnt) & TIFM_IRQ_CARDMASK(1))
52	if (sock && sock_irq_status)	60	sock->card_event(sock);
53	sock->signal_irq(sock, sock_irq_status);	61	}
54	}	62	}
55		63
56	fm->socket_change_set \|= irq_status	64	fm->socket_change_set \|= irq_status
Lines 58-114 static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id) Link Here
58	}	66	}
59	writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);	67	writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);
60		68
61	if (!fm->socket_change_set)	69	if (fm->finish_me)
		70	complete_all(fm->finish_me);
		71	else if (!fm->socket_change_set)
62	writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);	72	writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
63	else	73	else
64	wake_up_all(&fm->change_set_notify);	74	tifm_queue_work(&fm->media_switcher);
65		75
66	spin_unlock(&fm->lock);	76	spin_unlock(&fm->lock);
67	return IRQ_HANDLED;	77	return IRQ_HANDLED;
68	}	78	}
69		79
70	static tifm_media_id tifm_7xx1_toggle_sock_power(char __iomem *sock_addr,	80	static unsigned char tifm_7xx1_toggle_sock_power(char __iomem *sock_addr)
71	int is_x2)
72	{	81	{
73	unsigned int s_state;	82	unsigned int s_state;
74	int cnt;	83	int cnt;
75		84
76	writel(0x0e00, sock_addr + SOCK_CONTROL);	85	writel(0x0e00, sock_addr + SOCK_CONTROL);
77		86
78	for (cnt = 0; cnt < 100; cnt++) {	87	for (cnt = 16; cnt <= 256; cnt <<= 1) {
79	if (!(TIFM_SOCK_STATE_POWERED	88	if (!(TIFM_SOCK_STATE_POWERED
80	& readl(sock_addr + SOCK_PRESENT_STATE)))	89	& readl(sock_addr + SOCK_PRESENT_STATE)))
81	break;	90	break;
82	msleep(10);	91
		92	msleep(cnt);
83	}	93	}
84		94
85	s_state = readl(sock_addr + SOCK_PRESENT_STATE);	95	s_state = readl(sock_addr + SOCK_PRESENT_STATE);
86	if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))	96	if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))
87	return FM_NULL;	97	return 0;
88		98
89	if (is_x2) {	99	writel(readl(sock_addr + SOCK_CONTROL) \| TIFM_CTRL_LED,
90	writel((s_state & 7) \| 0x0c00, sock_addr + SOCK_CONTROL);	100	sock_addr + SOCK_CONTROL);
91	} else {
92	// SmartMedia cards need extra 40 msec
93	if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7) == 1)
94	msleep(40);
95	writel(readl(sock_addr + SOCK_CONTROL) \| TIFM_CTRL_LED,
96	sock_addr + SOCK_CONTROL);
97	msleep(10);
98	writel((s_state & 0x7) \| 0x0c00 \| TIFM_CTRL_LED,
99	sock_addr + SOCK_CONTROL);
100	}
101		101
102	for (cnt = 0; cnt < 100; cnt++) {	102	/* xd needs some extra time before power on */
		103	if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7)
		104	== TIFM_TYPE_XD)
		105	msleep(40);
		106
		107	writel((s_state & 7) \| 0x0c00, sock_addr + SOCK_CONTROL);
		108	/* wait for power to stabilize */
		109	msleep(20);
		110	for (cnt = 16; cnt <= 256; cnt <<= 1) {
103	if ((TIFM_SOCK_STATE_POWERED	111	if ((TIFM_SOCK_STATE_POWERED
104	& readl(sock_addr + SOCK_PRESENT_STATE)))	112	& readl(sock_addr + SOCK_PRESENT_STATE)))
105	break;	113	break;
106	msleep(10);	114
		115	msleep(cnt);
107	}	116	}
108		117
109	if (!is_x2)	118	writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),
110	writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),	119	sock_addr + SOCK_CONTROL);
111	sock_addr + SOCK_CONTROL);
112		120
113	return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;	121	return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
114	}	122	}
Lines 119-245 tifm_7xx1_sock_addr(char __iomem *base_addr, unsigned int sock_num) Link Here
119	return base_addr + ((sock_num + 1) << 10);	127	return base_addr + ((sock_num + 1) << 10);
120	}	128	}
121		129
122	static int tifm_7xx1_switch_media(void *data)	130	static void tifm_7xx1_switch_media(struct work_struct *work)
123	{	131	{
124	struct tifm_adapter *fm = data;	132	struct tifm_adapter *fm = container_of(work, struct tifm_adapter,
125	unsigned long flags;	133	media_switcher);
126	tifm_media_id media_id;
127	char *card_name = "xx";
128	int cnt, rc;
129	struct tifm_dev *sock;	134	struct tifm_dev *sock;
130	unsigned int socket_change_set;	135	unsigned long flags;
131		136	unsigned char media_id;
132	while (1) {	137	unsigned int socket_change_set, cnt;
133	rc = wait_event_interruptible(fm->change_set_notify,
134	fm->socket_change_set);
135	if (rc == -ERESTARTSYS)
136	try_to_freeze();
137		138
138	spin_lock_irqsave(&fm->lock, flags);	139	spin_lock_irqsave(&fm->lock, flags);
139	socket_change_set = fm->socket_change_set;	140	socket_change_set = fm->socket_change_set;
140	fm->socket_change_set = 0;	141	fm->socket_change_set = 0;
141		142
142	dev_dbg(fm->dev, "checking media set %x\n",	143	dev_dbg(fm->cdev.dev, "checking media set %x\n",
143	socket_change_set);	144	socket_change_set);
144		145
145	if (kthread_should_stop())	146	if (!socket_change_set) {
146	socket_change_set = (1 << fm->num_sockets) - 1;
147	spin_unlock_irqrestore(&fm->lock, flags);	147	spin_unlock_irqrestore(&fm->lock, flags);
		148	return;
		149	}
148		150
149	if (!socket_change_set)	151	for (cnt = 0; cnt < fm->num_sockets; cnt++) {
		152	if (!(socket_change_set & (1 << cnt)))
150	continue;	153	continue;
151		154	sock = fm->sockets[cnt];
152	spin_lock_irqsave(&fm->lock, flags);	155	if (sock) {
153	for (cnt = 0; cnt < fm->num_sockets; cnt++) {	156	printk(KERN_INFO
154	if (!(socket_change_set & (1 << cnt)))	157	"%s : demand removing card from socket %u:%u\n",
155	continue;	158	fm->cdev.class_id, fm->id, cnt);
156	sock = fm->sockets[cnt];	159	fm->sockets[cnt] = NULL;
157	if (sock) {
158	printk(KERN_INFO DRIVER_NAME
159	": demand removing card from socket %d\n",
160	cnt);
161	fm->sockets[cnt] = NULL;
162	spin_unlock_irqrestore(&fm->lock, flags);
163	device_unregister(&sock->dev);
164	spin_lock_irqsave(&fm->lock, flags);
165	writel(0x0e00,
166	tifm_7xx1_sock_addr(fm->addr, cnt)
167	+ SOCK_CONTROL);
168	}
169	if (kthread_should_stop())
170	continue;
171
172	spin_unlock_irqrestore(&fm->lock, flags);	160	spin_unlock_irqrestore(&fm->lock, flags);
173	media_id = tifm_7xx1_toggle_sock_power(	161	device_unregister(&sock->dev);
174	tifm_7xx1_sock_addr(fm->addr, cnt),	162	spin_lock_irqsave(&fm->lock, flags);
175	fm->num_sockets == 2);	163	writel(0x0e00, tifm_7xx1_sock_addr(fm->addr, cnt)
176	if (media_id) {	164	+ SOCK_CONTROL);
177	sock = tifm_alloc_device(fm);
178	if (sock) {
179	sock->addr = tifm_7xx1_sock_addr(fm->addr,
180	cnt);
181	sock->media_id = media_id;
182	sock->socket_id = cnt;
183	switch (media_id) {
184	case 1:
185	card_name = "xd";
186	break;
187	case 2:
188	card_name = "ms";
189	break;
190	case 3:
191	card_name = "sd";
192	break;
193	default:
194	tifm_free_device(&sock->dev);
195	spin_lock_irqsave(&fm->lock, flags);
196	continue;
197	}
198	snprintf(sock->dev.bus_id, BUS_ID_SIZE,
199	"tifm_%s%u:%u", card_name,
200	fm->id, cnt);
201	printk(KERN_INFO DRIVER_NAME
202	": %s card detected in socket %d\n",
203	card_name, cnt);
204	if (!device_register(&sock->dev)) {
205	spin_lock_irqsave(&fm->lock, flags);
206	if (!fm->sockets[cnt]) {
207	fm->sockets[cnt] = sock;
208	sock = NULL;
209	}
210	spin_unlock_irqrestore(&fm->lock, flags);
211	}
212	if (sock)
213	tifm_free_device(&sock->dev);
214	}
215	spin_lock_irqsave(&fm->lock, flags);
216	}
217	}	165	}
218		166
219	if (!kthread_should_stop()) {	167	spin_unlock_irqrestore(&fm->lock, flags);
220	writel(TIFM_IRQ_FIFOMASK(socket_change_set)	168
221	\| TIFM_IRQ_CARDMASK(socket_change_set),	169	media_id = tifm_7xx1_toggle_sock_power(
222	fm->addr + FM_CLEAR_INTERRUPT_ENABLE);	170	tifm_7xx1_sock_addr(fm->addr, cnt));
223	writel(TIFM_IRQ_FIFOMASK(socket_change_set)	171
224	\| TIFM_IRQ_CARDMASK(socket_change_set),	172	// tifm_alloc_device will check if media_id is valid
225	fm->addr + FM_SET_INTERRUPT_ENABLE);	173	sock = tifm_alloc_device(fm, cnt, media_id);
226	writel(TIFM_IRQ_ENABLE,	174	if (sock) {
227	fm->addr + FM_SET_INTERRUPT_ENABLE);	175	sock->addr = tifm_7xx1_sock_addr(fm->addr, cnt);
228	spin_unlock_irqrestore(&fm->lock, flags);	176
229	} else {	177	if (!device_register(&sock->dev)) {
230	for (cnt = 0; cnt < fm->num_sockets; cnt++) {	178	spin_lock_irqsave(&fm->lock, flags);
231	if (fm->sockets[cnt])	179	if (!fm->sockets[cnt]) {
232	fm->socket_change_set \|= 1 << cnt;	180	fm->sockets[cnt] = sock;
233	}	181	sock = NULL;
234	if (!fm->socket_change_set) {	182	}
235	spin_unlock_irqrestore(&fm->lock, flags);
236	return 0;
237	} else {
238	spin_unlock_irqrestore(&fm->lock, flags);	183	spin_unlock_irqrestore(&fm->lock, flags);
239	}	184	}
		185	if (sock)
		186	tifm_free_device(&sock->dev);
240	}	187	}
		188	spin_lock_irqsave(&fm->lock, flags);
241	}	189	}
242	return 0;	190
		191	writel(TIFM_IRQ_FIFOMASK(socket_change_set)
		192	\| TIFM_IRQ_CARDMASK(socket_change_set),
		193	fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		194
		195	writel(TIFM_IRQ_FIFOMASK(socket_change_set)
		196	\| TIFM_IRQ_CARDMASK(socket_change_set),
		197	fm->addr + FM_SET_INTERRUPT_ENABLE);
		198
		199	writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
		200	spin_unlock_irqrestore(&fm->lock, flags);
243	}	201	}
244		202
245	#ifdef CONFIG_PM	203	#ifdef CONFIG_PM
Lines 258-266 static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state) Link Here
258	static int tifm_7xx1_resume(struct pci_dev *dev)	216	static int tifm_7xx1_resume(struct pci_dev *dev)
259	{	217	{
260	struct tifm_adapter *fm = pci_get_drvdata(dev);	218	struct tifm_adapter *fm = pci_get_drvdata(dev);
261	int cnt, rc;	219	int rc;
		220	unsigned int good_sockets = 0, bad_sockets = 0;
262	unsigned long flags;	221	unsigned long flags;
263	tifm_media_id new_ids[fm->num_sockets];	222	unsigned char new_ids[fm->num_sockets];
		223	DECLARE_COMPLETION_ONSTACK(finish_resume);
264		224
265	pci_set_power_state(dev, PCI_D0);	225	pci_set_power_state(dev, PCI_D0);
266	pci_restore_state(dev);	226	pci_restore_state(dev);
Lines 271-315 static int tifm_7xx1_resume(struct pci_dev *dev) Link Here
271		231
272	dev_dbg(&dev->dev, "resuming host\n");	232	dev_dbg(&dev->dev, "resuming host\n");
273		233
274	for (cnt = 0; cnt < fm->num_sockets; cnt++)	234	for (rc = 0; rc < fm->num_sockets; rc++)
275	new_ids[cnt] = tifm_7xx1_toggle_sock_power(	235	new_ids[rc] = tifm_7xx1_toggle_sock_power(
276	tifm_7xx1_sock_addr(fm->addr, cnt),	236	tifm_7xx1_sock_addr(fm->addr, rc));
277	fm->num_sockets == 2);
278	spin_lock_irqsave(&fm->lock, flags);	237	spin_lock_irqsave(&fm->lock, flags);
279	fm->socket_change_set = 0;	238	for (rc = 0; rc < fm->num_sockets; rc++) {
280	for (cnt = 0; cnt < fm->num_sockets; cnt++) {	239	if (fm->sockets[rc]) {
281	if (fm->sockets[cnt]) {	240	if (fm->sockets[rc]->type == new_ids[rc])
282	if (fm->sockets[cnt]->media_id == new_ids[cnt])	241	good_sockets \|= 1 << rc;
283	fm->socket_change_set \|= 1 << cnt;	242	else
284		243	bad_sockets \|= 1 << rc;
285	fm->sockets[cnt]->media_id = new_ids[cnt];
286	}	244	}
287	}	245	}
288		246
289	writel(TIFM_IRQ_ENABLE \| TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),	247	writel(TIFM_IRQ_ENABLE \| TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
290	fm->addr + FM_SET_INTERRUPT_ENABLE);	248	fm->addr + FM_SET_INTERRUPT_ENABLE);
291	if (!fm->socket_change_set) {	249	dev_dbg(&dev->dev, "change sets on resume: good %x, bad %x\n",
292	spin_unlock_irqrestore(&fm->lock, flags);	250	good_sockets, bad_sockets);
293	return 0;	251
294	} else {	252	fm->socket_change_set = 0;
295	fm->socket_change_set = 0;	253	if (good_sockets) {
		254	fm->finish_me = &finish_resume;
296	spin_unlock_irqrestore(&fm->lock, flags);	255	spin_unlock_irqrestore(&fm->lock, flags);
		256	rc = wait_for_completion_timeout(&finish_resume, HZ);
		257	dev_dbg(&dev->dev, "wait returned %d\n", rc);
		258	writel(TIFM_IRQ_FIFOMASK(good_sockets)
		259	\| TIFM_IRQ_CARDMASK(good_sockets),
		260	fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		261	writel(TIFM_IRQ_FIFOMASK(good_sockets)
		262	\| TIFM_IRQ_CARDMASK(good_sockets),
		263	fm->addr + FM_SET_INTERRUPT_ENABLE);
		264	spin_lock_irqsave(&fm->lock, flags);
		265	fm->finish_me = NULL;
		266	fm->socket_change_set ^= good_sockets & fm->socket_change_set;
297	}	267	}
298		268
299	wait_event_timeout(fm->change_set_notify, fm->socket_change_set, HZ);	269	fm->socket_change_set \|= bad_sockets;
		270	if (fm->socket_change_set)
		271	tifm_queue_work(&fm->media_switcher);
300		272
301	spin_lock_irqsave(&fm->lock, flags);	273	spin_unlock_irqrestore(&fm->lock, flags);
302	writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
303	\| TIFM_IRQ_CARDMASK(fm->socket_change_set),
304	fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
305	writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
306	\| TIFM_IRQ_CARDMASK(fm->socket_change_set),
307	fm->addr + FM_SET_INTERRUPT_ENABLE);
308	writel(TIFM_IRQ_ENABLE,	274	writel(TIFM_IRQ_ENABLE,
309	fm->addr + FM_SET_INTERRUPT_ENABLE);	275	fm->addr + FM_SET_INTERRUPT_ENABLE);
310	fm->socket_change_set = 0;
311		276
312	spin_unlock_irqrestore(&fm->lock, flags);
313	return 0;	277	return 0;
314	}	278	}
315		279
Lines 320-325 static int tifm_7xx1_resume(struct pci_dev *dev) Link Here
320		284
321	#endif /* CONFIG_PM */	285	#endif /* CONFIG_PM */
322		286
		287	static int tifm_7xx1_dummy_has_ms_pif(struct tifm_adapter *fm,
		288	struct tifm_dev *sock)
		289	{
		290	return 0;
		291	}
		292
		293	static int tifm_7xx1_has_ms_pif(struct tifm_adapter fm, struct tifm_dev sock)
		294	{
		295	if (((fm->num_sockets == 4) && (sock->socket_id == 2))
		296	\|\| ((fm->num_sockets == 2) && (sock->socket_id == 0)))
		297	return 1;
		298
		299	return 0;
		300	}
		301
323	static int tifm_7xx1_probe(struct pci_dev *dev,	302	static int tifm_7xx1_probe(struct pci_dev *dev,
324	const struct pci_device_id *dev_id)	303	const struct pci_device_id *dev_id)
325	{	304	{
Lines 345-365 static int tifm_7xx1_probe(struct pci_dev *dev, Link Here
345		324
346	pci_intx(dev, 1);	325	pci_intx(dev, 1);
347		326
348	fm = tifm_alloc_adapter();	327	fm = tifm_alloc_adapter(dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM
		328	? 4 : 2, &dev->dev);
349	if (!fm) {	329	if (!fm) {
350	rc = -ENOMEM;	330	rc = -ENOMEM;
351	goto err_out_int;	331	goto err_out_int;
352	}	332	}
353		333
354	fm->dev = &dev->dev;	334	INIT_WORK(&fm->media_switcher, tifm_7xx1_switch_media);
355	fm->num_sockets = (dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM)
356	? 4 : 2;
357	fm->sockets = kzalloc(sizeof(struct tifm_dev) fm->num_sockets,
358	GFP_KERNEL);
359	if (!fm->sockets)
360	goto err_out_free;
361
362	fm->eject = tifm_7xx1_eject;	335	fm->eject = tifm_7xx1_eject;
		336	fm->has_ms_pif = tifm_7xx1_has_ms_pif;
363	pci_set_drvdata(dev, fm);	337	pci_set_drvdata(dev, fm);
364		338
365	fm->addr = ioremap(pci_resource_start(dev, 0),	339	fm->addr = ioremap(pci_resource_start(dev, 0),
Lines 367-385 static int tifm_7xx1_probe(struct pci_dev *dev, Link Here
367	if (!fm->addr)	341	if (!fm->addr)
368	goto err_out_free;	342	goto err_out_free;
369		343
370	rc = request_irq(dev->irq, tifm_7xx1_isr, IRQF_SHARED, DRIVER_NAME, fm);	344	rc = request_irq(dev->irq, tifm_7xx1_isr, SA_SHIRQ, DRIVER_NAME, fm);
371	if (rc)	345	if (rc)
372	goto err_out_unmap;	346	goto err_out_unmap;
373		347
374	init_waitqueue_head(&fm->change_set_notify);	348	rc = tifm_add_adapter(fm);
375	rc = tifm_add_adapter(fm, tifm_7xx1_switch_media);
376	if (rc)	349	if (rc)
377	goto err_out_irq;	350	goto err_out_irq;
378		351
379	writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
380	writel(TIFM_IRQ_ENABLE \| TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),	352	writel(TIFM_IRQ_ENABLE \| TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
381	fm->addr + FM_SET_INTERRUPT_ENABLE);	353	fm->addr + FM_SET_INTERRUPT_ENABLE);
382	wake_up_process(fm->media_switcher);
383	return 0;	354	return 0;
384		355
385	err_out_irq:	356	err_out_irq:
Lines 401-418 err_out: Link Here
401	static void tifm_7xx1_remove(struct pci_dev *dev)	372	static void tifm_7xx1_remove(struct pci_dev *dev)
402	{	373	{
403	struct tifm_adapter *fm = pci_get_drvdata(dev);	374	struct tifm_adapter *fm = pci_get_drvdata(dev);
404	unsigned long flags;
405		375
		376	fm->eject = tifm_7xx1_dummy_eject;
		377	fm->has_ms_pif = tifm_7xx1_dummy_has_ms_pif;
406	writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);	378	writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
407	mmiowb();	379	mmiowb();
408	free_irq(dev->irq, fm);	380	free_irq(dev->irq, fm);
409		381
410	spin_lock_irqsave(&fm->lock, flags);
411	fm->socket_change_set = (1 << fm->num_sockets) - 1;
412	spin_unlock_irqrestore(&fm->lock, flags);
413
414	kthread_stop(fm->media_switcher);
415
416	tifm_remove_adapter(fm);	382	tifm_remove_adapter(fm);
417		383
418	pci_set_drvdata(dev, NULL);	384	pci_set_drvdata(dev, NULL);

Lines 9-84 Link Here

(-)a/drivers/misc/tifm_core.c (-124 / +190 lines)
9	*	9	*
10	*/	10	*/
11		11
12	#include <linux/tifm.h>	12	#include "linux/tifm.h"
13	#include <linux/init.h>	13	#include <linux/init.h>
14	#include <linux/idr.h>	14	#include <linux/idr.h>
15		15
16	#define DRIVER_NAME "tifm_core"	16	#define DRIVER_NAME "tifm_core"
17	#define DRIVER_VERSION "0.7"	17	#define DRIVER_VERSION "0.8"
18		18
		19	static struct workqueue_struct *workqueue;
19	static DEFINE_IDR(tifm_adapter_idr);	20	static DEFINE_IDR(tifm_adapter_idr);
20	static DEFINE_SPINLOCK(tifm_adapter_lock);	21	static DEFINE_SPINLOCK(tifm_adapter_lock);
21		22
22	static tifm_media_id tifm_device_match(tifm_media_id ids,	23	static const char *tifm_media_type_name(unsigned char type, unsigned char nt)
23	struct tifm_dev *dev)
24	{	24	{
25	while (*ids) {	25	const char *card_type_name[3][3] = {
26	if (dev->media_id == *ids)	26	{ "SmartMedia/xD", "MemoryStick", "MMC/SD" },
27	return ids;	27	{ "XD", "MS", "SD"},
28	ids++;	28	{ "xd", "ms", "sd"}
29	}	29	};
30	return NULL;	30
		31	if (nt > 2 \|\| type < 1 \|\| type > 3)
		32	return NULL;
		33	return card_type_name[nt][type - 1];
31	}	34	}
32		35
33	static int tifm_match(struct device dev, struct device_driver drv)	36	static int tifm_dev_match(struct tifm_dev sock, struct tifm_device_id id)
34	{	37	{
35	struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);	38	if (sock->type == id->type)
36	struct tifm_driver *fm_drv;
37
38	fm_drv = container_of(drv, struct tifm_driver, driver);
39	if (!fm_drv->id_table)
40	return -EINVAL;
41	if (tifm_device_match(fm_drv->id_table, fm_dev))
42	return 1;	39	return 1;
43	return -ENODEV;	40	return 0;
		41	}
		42
		43	static int tifm_bus_match(struct device dev, struct device_driver drv)
		44	{
		45	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
		46	struct tifm_driver *fm_drv = container_of(drv, struct tifm_driver,
		47	driver);
		48	struct tifm_device_id *ids = fm_drv->id_table;
		49
		50	if (ids) {
		51	while (ids->type) {
		52	if (tifm_dev_match(sock, ids))
		53	return 1;
		54	++ids;
		55	}
		56	}
		57	return 0;
44	}	58	}
45		59
46	static int tifm_uevent(struct device dev, char *envp, int num_envp,	60	static int tifm_uevent(struct device dev, char *envp, int num_envp,
47	char *buffer, int buffer_size)	61	char *buffer, int buffer_size)
48	{	62	{
49	struct tifm_dev *fm_dev;	63	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
50	int i = 0;	64	int i = 0;
51	int length = 0;	65	int length = 0;
52	const char *card_type_name[] = {"INV", "SM", "MS", "SD"};
53		66
54	if (!dev \|\| !(fm_dev = container_of(dev, struct tifm_dev, dev)))
55	return -ENODEV;
56	if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,	67	if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
57	"TIFM_CARD_TYPE=%s", card_type_name[fm_dev->media_id]))	68	"TIFM_CARD_TYPE=%s",
		69	tifm_media_type_name(sock->type, 1)))
58	return -ENOMEM;	70	return -ENOMEM;
59		71
60	return 0;	72	return 0;
61	}	73	}
62		74
		75	static int tifm_device_probe(struct device *dev)
		76	{
		77	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
		78	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
		79	driver);
		80	int rc = -ENODEV;
		81
		82	get_device(dev);
		83	if (dev->driver && drv->probe) {
		84	rc = drv->probe(sock);
		85	if (!rc)
		86	return 0;
		87	}
		88	put_device(dev);
		89	return rc;
		90	}
		91
		92	static void tifm_dummy_event(struct tifm_dev *sock)
		93	{
		94	return;
		95	}
		96
		97	static int tifm_device_remove(struct device *dev)
		98	{
		99	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
		100	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
		101	driver);
		102
		103	if (dev->driver && drv->remove) {
		104	sock->card_event = tifm_dummy_event;
		105	sock->data_event = tifm_dummy_event;
		106	drv->remove(sock);
		107	sock->dev.driver = NULL;
		108	}
		109
		110	put_device(dev);
		111	return 0;
		112	}
		113
63	#ifdef CONFIG_PM	114	#ifdef CONFIG_PM
64		115
65	static int tifm_device_suspend(struct device *dev, pm_message_t state)	116	static int tifm_device_suspend(struct device *dev, pm_message_t state)
66	{	117	{
67	struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);	118	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
68	struct tifm_driver *drv = fm_dev->drv;	119	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
		120	driver);
69		121
70	if (drv && drv->suspend)	122	if (dev->driver && drv->suspend)
71	return drv->suspend(fm_dev, state);	123	return drv->suspend(sock, state);
72	return 0;	124	return 0;
73	}	125	}
74		126
75	static int tifm_device_resume(struct device *dev)	127	static int tifm_device_resume(struct device *dev)
76	{	128	{
77	struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);	129	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
78	struct tifm_driver *drv = fm_dev->drv;	130	struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
		131	driver);
79		132
80	if (drv && drv->resume)	133	if (dev->driver && drv->resume)
81	return drv->resume(fm_dev);	134	return drv->resume(sock);
82	return 0;	135	return 0;
83	}	136	}
84		137
Lines 89-107 static int tifm_device_resume(struct device *dev) Link Here
89		142
90	#endif /* CONFIG_PM */	143	#endif /* CONFIG_PM */
91		144
		145	static ssize_t type_show(struct device dev, struct device_attribute attr,
		146	char *buf)
		147	{
		148	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
		149	return sprintf(buf, "%x", sock->type);
		150	}
		151
		152	static struct device_attribute tifm_dev_attrs[] = {
		153	__ATTR(type, S_IRUGO, type_show, NULL),
		154	__ATTR_NULL
		155	};
		156
92	static struct bus_type tifm_bus_type = {	157	static struct bus_type tifm_bus_type = {
93	.name = "tifm",	158	.name = "tifm",
94	.match = tifm_match,	159	.dev_attrs = tifm_dev_attrs,
95	.uevent = tifm_uevent,	160	.match = tifm_bus_match,
96	.suspend = tifm_device_suspend,	161	.uevent = tifm_uevent,
97	.resume = tifm_device_resume	162	.probe = tifm_device_probe,
		163	.remove = tifm_device_remove,
		164	.suspend = tifm_device_suspend,
		165	.resume = tifm_device_resume
98	};	166	};
99		167
100	static void tifm_free(struct class_device *cdev)	168	static void tifm_free(struct class_device *cdev)
101	{	169	{
102	struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);	170	struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);
103		171
104	kfree(fm->sockets);
105	kfree(fm);	172	kfree(fm);
106	}	173	}
107		174
Lines 110-137 static struct class tifm_adapter_class = { Link Here
110	.release = tifm_free	177	.release = tifm_free
111	};	178	};
112		179
113	struct tifm_adapter *tifm_alloc_adapter(void)	180	struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets,
		181	struct device *dev)
114	{	182	{
115	struct tifm_adapter *fm;	183	struct tifm_adapter *fm;
116		184
117	fm = kzalloc(sizeof(struct tifm_adapter), GFP_KERNEL);	185	fm = kzalloc(sizeof(struct tifm_adapter)
		186	+ sizeof(struct tifm_dev) num_sockets, GFP_KERNEL);
118	if (fm) {	187	if (fm) {
119	fm->cdev.class = &tifm_adapter_class;	188	fm->cdev.class = &tifm_adapter_class;
120	spin_lock_init(&fm->lock);	189	fm->cdev.dev = dev;
121	class_device_initialize(&fm->cdev);	190	class_device_initialize(&fm->cdev);
		191	spin_lock_init(&fm->lock);
		192	fm->num_sockets = num_sockets;
122	}	193	}
123	return fm;	194	return fm;
124	}	195	}
125	EXPORT_SYMBOL(tifm_alloc_adapter);	196	EXPORT_SYMBOL(tifm_alloc_adapter);
126		197
127	void tifm_free_adapter(struct tifm_adapter *fm)	198	int tifm_add_adapter(struct tifm_adapter *fm)
128	{
129	class_device_put(&fm->cdev);
130	}
131	EXPORT_SYMBOL(tifm_free_adapter);
132
133	int tifm_add_adapter(struct tifm_adapter *fm,
134	int (mediathreadfn)(void data))
135	{	199	{
136	int rc;	200	int rc;
137		201
Lines 141-199 int tifm_add_adapter(struct tifm_adapter *fm, Link Here
141	spin_lock(&tifm_adapter_lock);	205	spin_lock(&tifm_adapter_lock);
142	rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id);	206	rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id);
143	spin_unlock(&tifm_adapter_lock);	207	spin_unlock(&tifm_adapter_lock);
144	if (!rc) {	208	if (rc)
145	snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);	209	return rc;
146	fm->media_switcher = kthread_create(mediathreadfn,
147	fm, "tifm/%u", fm->id);
148
149	if (!IS_ERR(fm->media_switcher))
150	return class_device_add(&fm->cdev);
151		210
		211	snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);
		212	rc = class_device_add(&fm->cdev);
		213	if (rc) {
152	spin_lock(&tifm_adapter_lock);	214	spin_lock(&tifm_adapter_lock);
153	idr_remove(&tifm_adapter_idr, fm->id);	215	idr_remove(&tifm_adapter_idr, fm->id);
154	spin_unlock(&tifm_adapter_lock);	216	spin_unlock(&tifm_adapter_lock);
155	rc = -ENOMEM;
156	}	217	}
		218
157	return rc;	219	return rc;
158	}	220	}
159	EXPORT_SYMBOL(tifm_add_adapter);	221	EXPORT_SYMBOL(tifm_add_adapter);
160		222
161	void tifm_remove_adapter(struct tifm_adapter *fm)	223	void tifm_remove_adapter(struct tifm_adapter *fm)
162	{	224	{
163	class_device_del(&fm->cdev);	225	unsigned int cnt;
		226
		227	flush_workqueue(workqueue);
		228	for (cnt = 0; cnt < fm->num_sockets; ++cnt) {
		229	if (fm->sockets[cnt])
		230	device_unregister(&fm->sockets[cnt]->dev);
		231	}
164		232
165	spin_lock(&tifm_adapter_lock);	233	spin_lock(&tifm_adapter_lock);
166	idr_remove(&tifm_adapter_idr, fm->id);	234	idr_remove(&tifm_adapter_idr, fm->id);
167	spin_unlock(&tifm_adapter_lock);	235	spin_unlock(&tifm_adapter_lock);
		236	class_device_del(&fm->cdev);
168	}	237	}
169	EXPORT_SYMBOL(tifm_remove_adapter);	238	EXPORT_SYMBOL(tifm_remove_adapter);
170		239
171	void tifm_free_device(struct device *dev)	240	void tifm_free_adapter(struct tifm_adapter *fm)
172	{	241	{
173	struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);	242	class_device_put(&fm->cdev);
174	kfree(fm_dev);
175	}	243	}
176	EXPORT_SYMBOL(tifm_free_device);	244	EXPORT_SYMBOL(tifm_free_adapter);
177		245
178	static void tifm_dummy_signal_irq(struct tifm_dev *sock,	246	void tifm_free_device(struct device *dev)
179	unsigned int sock_irq_status)
180	{	247	{
181	return;	248	struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
		249	kfree(sock);
182	}	250	}
		251	EXPORT_SYMBOL(tifm_free_device);
183		252
184	struct tifm_dev tifm_alloc_device(struct tifm_adapter fm)	253	struct tifm_dev tifm_alloc_device(struct tifm_adapter fm, unsigned int id,
		254	unsigned char type)
185	{	255	{
186	struct tifm_dev *dev = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);	256	struct tifm_dev *sock = NULL;
187		257
188	if (dev) {	258	if (!tifm_media_type_name(type, 0))
189	spin_lock_init(&dev->lock);	259	return sock;
190		260
191	dev->dev.parent = fm->dev;	261	sock = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);
192	dev->dev.bus = &tifm_bus_type;	262	if (sock) {
193	dev->dev.release = tifm_free_device;	263	spin_lock_init(&sock->lock);
194	dev->signal_irq = tifm_dummy_signal_irq;	264	sock->type = type;
		265	sock->socket_id = id;
		266	sock->card_event = tifm_dummy_event;
		267	sock->data_event = tifm_dummy_event;
		268
		269	sock->dev.parent = fm->cdev.dev;
		270	sock->dev.bus = &tifm_bus_type;
		271	sock->dev.dma_mask = fm->cdev.dev->dma_mask;
		272	sock->dev.release = tifm_free_device;
		273
		274	snprintf(sock->dev.bus_id, BUS_ID_SIZE,
		275	"tifm_%s%u:%u", tifm_media_type_name(type, 2),
		276	fm->id, id);
		277	printk(KERN_INFO DRIVER_NAME
		278	": %s card detected in socket %u:%u\n",
		279	tifm_media_type_name(type, 0), fm->id, id);
195	}	280	}
196	return dev;	281	return sock;
197	}	282	}
198	EXPORT_SYMBOL(tifm_alloc_device);	283	EXPORT_SYMBOL(tifm_alloc_device);
199		284
Lines 204-209 void tifm_eject(struct tifm_dev *sock) Link Here
204	}	289	}
205	EXPORT_SYMBOL(tifm_eject);	290	EXPORT_SYMBOL(tifm_eject);
206		291
		292	int tifm_has_ms_pif(struct tifm_dev *sock)
		293	{
		294	struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent);
		295	return fm->has_ms_pif(fm, sock);
		296	}
		297	EXPORT_SYMBOL(tifm_has_ms_pif);
		298
207	int tifm_map_sg(struct tifm_dev sock, struct scatterlist sg, int nents,	299	int tifm_map_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
208	int direction)	300	int direction)
209	{	301	{
Lines 218-271 void tifm_unmap_sg(struct tifm_dev sock, struct scatterlist sg, int nents, Link Here
218	}	310	}
219	EXPORT_SYMBOL(tifm_unmap_sg);	311	EXPORT_SYMBOL(tifm_unmap_sg);
220		312
221	static int tifm_device_probe(struct device *dev)	313	void tifm_queue_work(struct work_struct *work)
222	{
223	struct tifm_driver *drv;
224	struct tifm_dev *fm_dev;
225	int rc = 0;
226	const tifm_media_id *id;
227
228	drv = container_of(dev->driver, struct tifm_driver, driver);
229	fm_dev = container_of(dev, struct tifm_dev, dev);
230	get_device(dev);
231	if (!fm_dev->drv && drv->probe && drv->id_table) {
232	rc = -ENODEV;
233	id = tifm_device_match(drv->id_table, fm_dev);
234	if (id)
235	rc = drv->probe(fm_dev);
236	if (rc >= 0) {
237	rc = 0;
238	fm_dev->drv = drv;
239	}
240	}
241	if (rc)
242	put_device(dev);
243	return rc;
244	}
245
246	static int tifm_device_remove(struct device *dev)
247	{	314	{
248	struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);	315	queue_work(workqueue, work);
249	struct tifm_driver *drv = fm_dev->drv;
250
251	if (drv) {
252	fm_dev->signal_irq = tifm_dummy_signal_irq;
253	if (drv->remove)
254	drv->remove(fm_dev);
255	fm_dev->drv = NULL;
256	}
257
258	put_device(dev);
259	return 0;
260	}	316	}
		317	EXPORT_SYMBOL(tifm_queue_work);
261		318
262	int tifm_register_driver(struct tifm_driver *drv)	319	int tifm_register_driver(struct tifm_driver *drv)
263	{	320	{
264	drv->driver.bus = &tifm_bus_type;	321	drv->driver.bus = &tifm_bus_type;
265	drv->driver.probe = tifm_device_probe;
266	drv->driver.remove = tifm_device_remove;
267	drv->driver.suspend = tifm_device_suspend;
268	drv->driver.resume = tifm_device_resume;
269		322
270	return driver_register(&drv->driver);	323	return driver_register(&drv->driver);
271	}	324	}
Lines 279-291 EXPORT_SYMBOL(tifm_unregister_driver); Link Here
279		332
280	static int __init tifm_init(void)	333	static int __init tifm_init(void)
281	{	334	{
282	int rc = bus_register(&tifm_bus_type);	335	int rc;
283		336
284	if (!rc) {	337	workqueue = create_freezeable_workqueue("tifm");
285	rc = class_register(&tifm_adapter_class);	338	if (!workqueue)
286	if (rc)	339	return -ENOMEM;
287	bus_unregister(&tifm_bus_type);	340
288	}	341	rc = bus_register(&tifm_bus_type);
		342
		343	if (rc)
		344	goto err_out_wq;
		345
		346	rc = class_register(&tifm_adapter_class);
		347	if (!rc)
		348	return 0;
		349
		350	bus_unregister(&tifm_bus_type);
		351
		352	err_out_wq:
		353	destroy_workqueue(workqueue);
289		354
290	return rc;	355	return rc;
291	}	356	}
Lines 294-299 static void __exit tifm_exit(void) Link Here
294	{	359	{
295	class_unregister(&tifm_adapter_class);	360	class_unregister(&tifm_adapter_class);
296	bus_unregister(&tifm_bus_type);	361	bus_unregister(&tifm_bus_type);
		362	destroy_workqueue(workqueue);
297	}	363	}
298		364
299	subsys_initcall(tifm_init);	365	subsys_initcall(tifm_init);