[PATCH] mmc: driver for TI FlashMedia card reader - source (4020f2d7) · Commits · e / devices / android_kernel_sony_msm8998

MAINTAINERS

+5 −0

Original line number	Diff line number	Diff line
		@@ -2854,6 +2854,11 @@ M: hlhung3i@gmail.com
		W: http://tcp-lp-mod.sourceforge.net/
		S: Maintained

		TI FLASH MEDIA INTERFACE DRIVER
		P: Alex Dubov
		M: oakad@yahoo.com
		S: Maintained

		TI OMAP RANDOM NUMBER GENERATOR SUPPORT
		P: Deepak Saxena
		M: dsaxena@plexity.net

drivers/misc/tifm_7xx1.c

0 → 100644

+437 −0

Original line number	Diff line number	Diff line
		/*
		* tifm_7xx1.c - TI FlashMedia driver
		*
		* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*
		*/

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

		#define DRIVER_NAME "tifm_7xx1"
		#define DRIVER_VERSION "0.6"

		static void tifm_7xx1_eject(struct tifm_adapter fm, struct tifm_dev sock)
		{
		int cnt;
		unsigned long flags;

		spin_lock_irqsave(&fm->lock, flags);
		if (!fm->inhibit_new_cards) {
		for (cnt = 0; cnt < fm->max_sockets; cnt++) {
		if (fm->sockets[cnt] == sock) {
		fm->remove_mask \|= (1 << cnt);
		queue_work(fm->wq, &fm->media_remover);
		break;
		}
		}
		}
		spin_unlock_irqrestore(&fm->lock, flags);
		}

		static void tifm_7xx1_remove_media(void *adapter)
		{
		struct tifm_adapter *fm = adapter;
		unsigned long flags;
		int cnt;
		struct tifm_dev *sock;

		if (!class_device_get(&fm->cdev))
		return;
		spin_lock_irqsave(&fm->lock, flags);
		for (cnt = 0; cnt < fm->max_sockets; cnt++) {
		if (fm->sockets[cnt] && (fm->remove_mask & (1 << cnt))) {
		printk(KERN_INFO DRIVER_NAME
		": demand removing card from socket %d\n", cnt);
		sock = fm->sockets[cnt];
		fm->sockets[cnt] = 0;
		fm->remove_mask &= ~(1 << cnt);

		writel(0x0e00, sock->addr + SOCK_CONTROL);

		writel((TIFM_IRQ_FIFOMASK \| TIFM_IRQ_CARDMASK) << cnt,
		fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		writel((TIFM_IRQ_FIFOMASK \| TIFM_IRQ_CARDMASK) << cnt,
		fm->addr + FM_SET_INTERRUPT_ENABLE);

		spin_unlock_irqrestore(&fm->lock, flags);
		device_unregister(&sock->dev);
		spin_lock_irqsave(&fm->lock, flags);
		}
		}
		spin_unlock_irqrestore(&fm->lock, flags);
		class_device_put(&fm->cdev);
		}

		static irqreturn_t tifm_7xx1_isr(int irq, void dev_id, struct pt_regs regs)
		{
		struct tifm_adapter *fm = dev_id;
		unsigned int irq_status;
		unsigned int sock_irq_status, cnt;

		spin_lock(&fm->lock);
		irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);
		if (irq_status == 0 \|\| irq_status == (~0)) {
		spin_unlock(&fm->lock);
		return IRQ_NONE;
		}

		if (irq_status & TIFM_IRQ_ENABLE) {
		writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);

		for (cnt = 0; cnt < fm->max_sockets; cnt++) {
		sock_irq_status = (irq_status >> cnt) &
		(TIFM_IRQ_FIFOMASK \| TIFM_IRQ_CARDMASK);

		if (fm->sockets[cnt]) {
		if (sock_irq_status &&
		fm->sockets[cnt]->signal_irq)
		sock_irq_status = fm->sockets[cnt]->
		signal_irq(fm->sockets[cnt],
		sock_irq_status);

		if (irq_status & (1 << cnt))
		fm->remove_mask \|= 1 << cnt;
		} else {
		if (irq_status & (1 << cnt))
		fm->insert_mask \|= 1 << cnt;
		}
		}
		}
		writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);

		if (!fm->inhibit_new_cards) {
		if (!fm->remove_mask && !fm->insert_mask) {
		writel(TIFM_IRQ_ENABLE,
		fm->addr + FM_SET_INTERRUPT_ENABLE);
		} else {
		queue_work(fm->wq, &fm->media_remover);
		queue_work(fm->wq, &fm->media_inserter);
		}
		}

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

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

		writel(0x0e00, sock_addr + SOCK_CONTROL);

		for (cnt = 0; cnt < 100; cnt++) {
		if (!(TIFM_SOCK_STATE_POWERED &
		readl(sock_addr + SOCK_PRESENT_STATE)))
		break;
		msleep(10);
		}

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

		if (is_x2) {
		writel((s_state & 7) \| 0x0c00, sock_addr + SOCK_CONTROL);
		} else {
		// SmartMedia cards need extra 40 msec
		if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7) == 1)
		msleep(40);
		writel(readl(sock_addr + SOCK_CONTROL) \| TIFM_CTRL_LED,
		sock_addr + SOCK_CONTROL);
		msleep(10);
		writel((s_state & 0x7) \| 0x0c00 \| TIFM_CTRL_LED,
		sock_addr + SOCK_CONTROL);
		}

		for (cnt = 0; cnt < 100; cnt++) {
		if ((TIFM_SOCK_STATE_POWERED &
		readl(sock_addr + SOCK_PRESENT_STATE)))
		break;
		msleep(10);
		}

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

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

		inline static char tifm_7xx1_sock_addr(char base_addr, unsigned int sock_num)
		{
		return base_addr + ((sock_num + 1) << 10);
		}

		static void tifm_7xx1_insert_media(void *adapter)
		{
		struct tifm_adapter *fm = adapter;
		unsigned long flags;
		tifm_media_id media_id;
		char *card_name = "xx";
		int cnt, ok_to_register;
		unsigned int insert_mask;
		struct tifm_dev *new_sock = 0;

		if (!class_device_get(&fm->cdev))
		return;
		spin_lock_irqsave(&fm->lock, flags);
		insert_mask = fm->insert_mask;
		fm->insert_mask = 0;
		if (fm->inhibit_new_cards) {
		spin_unlock_irqrestore(&fm->lock, flags);
		class_device_put(&fm->cdev);
		return;
		}
		spin_unlock_irqrestore(&fm->lock, flags);

		for (cnt = 0; cnt < fm->max_sockets; cnt++) {
		if (!(insert_mask & (1 << cnt)))
		continue;

		media_id = tifm_7xx1_toggle_sock_power(tifm_7xx1_sock_addr(fm->addr, cnt),
		fm->max_sockets == 2);
		if (media_id) {
		ok_to_register = 0;
		new_sock = tifm_alloc_device(fm, cnt);
		if (new_sock) {
		new_sock->addr = tifm_7xx1_sock_addr(fm->addr,
		cnt);
		new_sock->media_id = media_id;
		switch (media_id) {
		case 1:
		card_name = "xd";
		break;
		case 2:
		card_name = "ms";
		break;
		case 3:
		card_name = "sd";
		break;
		default:
		break;
		}
		snprintf(new_sock->dev.bus_id, BUS_ID_SIZE,
		"tifm_%s%u:%u", card_name, fm->id, cnt);
		printk(KERN_INFO DRIVER_NAME
		": %s card detected in socket %d\n",
		card_name, cnt);
		spin_lock_irqsave(&fm->lock, flags);
		if (!fm->sockets[cnt]) {
		fm->sockets[cnt] = new_sock;
		ok_to_register = 1;
		}
		spin_unlock_irqrestore(&fm->lock, flags);
		if (!ok_to_register \|\|
		device_register(&new_sock->dev)) {
		spin_lock_irqsave(&fm->lock, flags);
		fm->sockets[cnt] = 0;
		spin_unlock_irqrestore(&fm->lock,
		flags);
		tifm_free_device(&new_sock->dev);
		}
		}
		}
		writel((TIFM_IRQ_FIFOMASK \| TIFM_IRQ_CARDMASK) << cnt,
		fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		writel((TIFM_IRQ_FIFOMASK \| TIFM_IRQ_CARDMASK) << cnt,
		fm->addr + FM_SET_INTERRUPT_ENABLE);
		}

		writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
		class_device_put(&fm->cdev);
		}

		static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
		{
		struct tifm_adapter *fm = pci_get_drvdata(dev);
		unsigned long flags;

		spin_lock_irqsave(&fm->lock, flags);
		fm->inhibit_new_cards = 1;
		fm->remove_mask = 0xf;
		fm->insert_mask = 0;
		writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		spin_unlock_irqrestore(&fm->lock, flags);
		flush_workqueue(fm->wq);

		tifm_7xx1_remove_media(fm);

		pci_set_power_state(dev, PCI_D3hot);
		pci_disable_device(dev);
		pci_save_state(dev);
		return 0;
		}

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

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

		spin_lock_irqsave(&fm->lock, flags);
		fm->inhibit_new_cards = 0;
		writel(TIFM_IRQ_SETALL, fm->addr + FM_INTERRUPT_STATUS);
		writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		writel(TIFM_IRQ_ENABLE \| TIFM_IRQ_SETALLSOCK,
		fm->addr + FM_SET_INTERRUPT_ENABLE);
		fm->insert_mask = 0xf;
		spin_unlock_irqrestore(&fm->lock, flags);
		return 0;
		}

		static int tifm_7xx1_probe(struct pci_dev *dev,
		const struct pci_device_id *dev_id)
		{
		struct tifm_adapter *fm;
		int pci_dev_busy = 0;
		int rc;

		rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
		if (rc)
		return rc;

		rc = pci_enable_device(dev);
		if (rc)
		return rc;

		pci_set_master(dev);

		rc = pci_request_regions(dev, DRIVER_NAME);
		if (rc) {
		pci_dev_busy = 1;
		goto err_out;
		}

		pci_intx(dev, 1);

		fm = tifm_alloc_adapter();
		if (!fm) {
		rc = -ENOMEM;
		goto err_out_int;
		}

		fm->dev = &dev->dev;
		fm->max_sockets = (dev->device == 0x803B) ? 2 : 4;
		fm->sockets = kzalloc(sizeof(struct tifm_dev) fm->max_sockets,
		GFP_KERNEL);
		if (!fm->sockets)
		goto err_out_free;

		INIT_WORK(&fm->media_inserter, tifm_7xx1_insert_media, fm);
		INIT_WORK(&fm->media_remover, tifm_7xx1_remove_media, fm);
		fm->eject = tifm_7xx1_eject;
		pci_set_drvdata(dev, fm);

		fm->addr = ioremap(pci_resource_start(dev, 0),
		pci_resource_len(dev, 0));
		if (!fm->addr)
		goto err_out_free;

		rc = request_irq(dev->irq, tifm_7xx1_isr, SA_SHIRQ, DRIVER_NAME, fm);
		if (rc)
		goto err_out_unmap;

		rc = tifm_add_adapter(fm);
		if (rc)
		goto err_out_irq;

		writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		writel(TIFM_IRQ_ENABLE \| TIFM_IRQ_SETALLSOCK,
		fm->addr + FM_SET_INTERRUPT_ENABLE);

		fm->insert_mask = 0xf;

		return 0;

		err_out_irq:
		free_irq(dev->irq, fm);
		err_out_unmap:
		iounmap(fm->addr);
		err_out_free:
		pci_set_drvdata(dev, NULL);
		tifm_free_adapter(fm);
		err_out_int:
		pci_intx(dev, 0);
		pci_release_regions(dev);
		err_out:
		if (!pci_dev_busy)
		pci_disable_device(dev);
		return rc;
		}

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

		spin_lock_irqsave(&fm->lock, flags);
		fm->inhibit_new_cards = 1;
		fm->remove_mask = 0xf;
		fm->insert_mask = 0;
		writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		spin_unlock_irqrestore(&fm->lock, flags);

		flush_workqueue(fm->wq);

		tifm_7xx1_remove_media(fm);

		writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
		free_irq(dev->irq, fm);

		tifm_remove_adapter(fm);

		pci_set_drvdata(dev, 0);

		iounmap(fm->addr);
		pci_intx(dev, 0);
		pci_release_regions(dev);

		pci_disable_device(dev);
		tifm_free_adapter(fm);
		}

		static struct pci_device_id tifm_7xx1_pci_tbl [] = {
		{ PCI_VENDOR_ID_TI, 0x8033, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
		0 }, /* xx21 - the one I have */
		{ PCI_VENDOR_ID_TI, 0x803B, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
		0 }, /* xx12 - should be also supported */
		{ }
		};

		static struct pci_driver tifm_7xx1_driver = {
		.name = DRIVER_NAME,
		.id_table = tifm_7xx1_pci_tbl,
		.probe = tifm_7xx1_probe,
		.remove = tifm_7xx1_remove,
		.suspend = tifm_7xx1_suspend,
		.resume = tifm_7xx1_resume,
		};

		static int __init tifm_7xx1_init(void)
		{
		return pci_register_driver(&tifm_7xx1_driver);
		}

		static void __exit tifm_7xx1_exit(void)
		{
		pci_unregister_driver(&tifm_7xx1_driver);
		}

		MODULE_AUTHOR("Alex Dubov");
		MODULE_DESCRIPTION("TI FlashMedia host driver");
		MODULE_LICENSE("GPL");
		MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl);
		MODULE_VERSION(DRIVER_VERSION);

		module_init(tifm_7xx1_init);
		module_exit(tifm_7xx1_exit);

drivers/misc/tifm_core.c

0 → 100644

+272 −0

Original line number	Diff line number	Diff line
		/*
		* tifm_core.c - TI FlashMedia driver
		*
		* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*
		*/

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

		#define DRIVER_NAME "tifm_core"
		#define DRIVER_VERSION "0.6"

		static DEFINE_IDR(tifm_adapter_idr);
		static DEFINE_SPINLOCK(tifm_adapter_lock);

		static tifm_media_id tifm_device_match(tifm_media_id ids,
		struct tifm_dev *dev)
		{
		while (*ids) {
		if (dev->media_id == *ids)
		return ids;
		ids++;
		}
		return NULL;
		}

		static int tifm_match(struct device dev, struct device_driver drv)
		{
		struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
		struct tifm_driver *fm_drv;

		fm_drv = container_of(drv, struct tifm_driver, driver);
		if (!fm_drv->id_table)
		return -EINVAL;
		if (tifm_device_match(fm_drv->id_table, fm_dev))
		return 1;
		return -ENODEV;
		}

		static int tifm_uevent(struct device dev, char *envp, int num_envp,
		char *buffer, int buffer_size)
		{
		struct tifm_dev *fm_dev;
		int i = 0;
		int length = 0;
		const char *card_type_name[] = {"INV", "SM", "MS", "SD"};

		if (!dev \|\| !(fm_dev = container_of(dev, struct tifm_dev, dev)))
		return -ENODEV;
		if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
		"TIFM_CARD_TYPE=%s", card_type_name[fm_dev->media_id]))
		return -ENOMEM;

		return 0;
		}

		static struct bus_type tifm_bus_type = {
		.name = "tifm",
		.match = tifm_match,
		.uevent = tifm_uevent,
		};

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

		kfree(fm->sockets);
		if (fm->wq)
		destroy_workqueue(fm->wq);
		kfree(fm);
		}

		static struct class tifm_adapter_class = {
		.name = "tifm_adapter",
		.release = tifm_free
		};

		struct tifm_adapter *tifm_alloc_adapter(void)
		{
		struct tifm_adapter *fm;

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

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

		int tifm_add_adapter(struct tifm_adapter *fm)
		{
		int rc;

		if (!idr_pre_get(&tifm_adapter_idr, GFP_KERNEL))
		return -ENOMEM;

		spin_lock(&tifm_adapter_lock);
		rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id);
		spin_unlock(&tifm_adapter_lock);
		if (!rc) {
		snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);
		strncpy(fm->wq_name, fm->cdev.class_id, KOBJ_NAME_LEN);

		fm->wq = create_singlethread_workqueue(fm->wq_name);
		if (fm->wq)
		return class_device_add(&fm->cdev);

		spin_lock(&tifm_adapter_lock);
		idr_remove(&tifm_adapter_idr, fm->id);
		spin_unlock(&tifm_adapter_lock);
		rc = -ENOMEM;
		}
		return rc;
		}
		EXPORT_SYMBOL(tifm_add_adapter);

		void tifm_remove_adapter(struct tifm_adapter *fm)
		{
		class_device_del(&fm->cdev);

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

		void tifm_free_device(struct device *dev)
		{
		struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
		if (fm_dev->wq)
		destroy_workqueue(fm_dev->wq);
		kfree(fm_dev);
		}
		EXPORT_SYMBOL(tifm_free_device);

		struct tifm_dev tifm_alloc_device(struct tifm_adapter fm, unsigned int id)
		{
		struct tifm_dev *dev = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);

		if (dev) {
		spin_lock_init(&dev->lock);
		snprintf(dev->wq_name, KOBJ_NAME_LEN, "tifm%u:%u", fm->id, id);
		dev->wq = create_singlethread_workqueue(dev->wq_name);
		if (!dev->wq) {
		kfree(dev);
		return 0;
		}
		dev->dev.parent = fm->dev;
		dev->dev.bus = &tifm_bus_type;
		dev->dev.release = tifm_free_device;
		}
		return dev;
		}
		EXPORT_SYMBOL(tifm_alloc_device);

		void tifm_eject(struct tifm_dev *sock)
		{
		struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent);
		fm->eject(fm, sock);
		}
		EXPORT_SYMBOL(tifm_eject);

		int tifm_map_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
		int direction)
		{
		return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction);
		}
		EXPORT_SYMBOL(tifm_map_sg);

		void tifm_unmap_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
		int direction)
		{
		pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction);
		}
		EXPORT_SYMBOL(tifm_unmap_sg);

		static int tifm_device_probe(struct device *dev)
		{
		struct tifm_driver *drv;
		struct tifm_dev *fm_dev;
		int rc = 0;
		const tifm_media_id *id;

		drv = container_of(dev->driver, struct tifm_driver, driver);
		fm_dev = container_of(dev, struct tifm_dev, dev);
		get_device(dev);
		if (!fm_dev->drv && drv->probe && drv->id_table) {
		rc = -ENODEV;
		id = tifm_device_match(drv->id_table, fm_dev);
		if (id)
		rc = drv->probe(fm_dev);
		if (rc >= 0) {
		rc = 0;
		fm_dev->drv = drv;
		}
		}
		if (rc)
		put_device(dev);
		return rc;
		}

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

		if (drv) {
		if (drv->remove) drv->remove(fm_dev);
		fm_dev->drv = 0;
		}

		put_device(dev);
		return 0;
		}

		int tifm_register_driver(struct tifm_driver *drv)
		{
		drv->driver.bus = &tifm_bus_type;
		drv->driver.probe = tifm_device_probe;
		drv->driver.remove = tifm_device_remove;

		return driver_register(&drv->driver);
		}
		EXPORT_SYMBOL(tifm_register_driver);

		void tifm_unregister_driver(struct tifm_driver *drv)
		{
		driver_unregister(&drv->driver);
		}
		EXPORT_SYMBOL(tifm_unregister_driver);

		static int __init tifm_init(void)
		{
		int rc = bus_register(&tifm_bus_type);

		if (!rc) {
		rc = class_register(&tifm_adapter_class);
		if (rc)
		bus_unregister(&tifm_bus_type);
		}

		return rc;
		}

		static void __exit tifm_exit(void)
		{
		class_unregister(&tifm_adapter_class);
		bus_unregister(&tifm_bus_type);
		}

		subsys_initcall(tifm_init);
		module_exit(tifm_exit);

		MODULE_LICENSE("GPL");
		MODULE_AUTHOR("Alex Dubov");
		MODULE_DESCRIPTION("TI FlashMedia core driver");
		MODULE_LICENSE("GPL");
		MODULE_VERSION(DRIVER_VERSION);

drivers/mmc/tifm_sd.c

0 → 100644

+933 −0

File added.

Preview size limit exceeded, changes collapsed.

include/linux/tifm.h

0 → 100644

+158 −0

Original line number	Diff line number	Diff line
		/*
		* tifm.h - TI FlashMedia driver
		*
		* Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*
		*/

		#ifndef _TIFM_H
		#define _TIFM_H

		#include <linux/spinlock.h>
		#include <linux/interrupt.h>
		#include <linux/wait.h>
		#include <linux/delay.h>
		#include <linux/pci.h>

		/* Host registers (relative to pci base address): */
		enum {
		FM_SET_INTERRUPT_ENABLE = 0x008,
		FM_CLEAR_INTERRUPT_ENABLE = 0x00c,
		FM_INTERRUPT_STATUS = 0x014 };

		/* Socket registers (relative to socket base address): */
		enum {
		SOCK_CONTROL = 0x004,
		SOCK_PRESENT_STATE = 0x008,
		SOCK_DMA_ADDRESS = 0x00c,
		SOCK_DMA_CONTROL = 0x010,
		SOCK_DMA_FIFO_INT_ENABLE_SET = 0x014,
		SOCK_DMA_FIFO_INT_ENABLE_CLEAR = 0x018,
		SOCK_DMA_FIFO_STATUS = 0x020,
		SOCK_FIFO_CONTROL = 0x024,
		SOCK_FIFO_PAGE_SIZE = 0x028,
		SOCK_MMCSD_COMMAND = 0x104,
		SOCK_MMCSD_ARG_LOW = 0x108,
		SOCK_MMCSD_ARG_HIGH = 0x10c,
		SOCK_MMCSD_CONFIG = 0x110,
		SOCK_MMCSD_STATUS = 0x114,
		SOCK_MMCSD_INT_ENABLE = 0x118,
		SOCK_MMCSD_COMMAND_TO = 0x11c,
		SOCK_MMCSD_DATA_TO = 0x120,
		SOCK_MMCSD_DATA = 0x124,
		SOCK_MMCSD_BLOCK_LEN = 0x128,
		SOCK_MMCSD_NUM_BLOCKS = 0x12c,
		SOCK_MMCSD_BUFFER_CONFIG = 0x130,
		SOCK_MMCSD_SPI_CONFIG = 0x134,
		SOCK_MMCSD_SDIO_MODE_CONFIG = 0x138,
		SOCK_MMCSD_RESPONSE = 0x144,
		SOCK_MMCSD_SDIO_SR = 0x164,
		SOCK_MMCSD_SYSTEM_CONTROL = 0x168,
		SOCK_MMCSD_SYSTEM_STATUS = 0x16c,
		SOCK_MS_COMMAND = 0x184,
		SOCK_MS_DATA = 0x188,
		SOCK_MS_STATUS = 0x18c,
		SOCK_MS_SYSTEM = 0x190,
		SOCK_FIFO_ACCESS = 0x200 };


		#define TIFM_IRQ_ENABLE 0x80000000
		#define TIFM_IRQ_SOCKMASK 0x00000001
		#define TIFM_IRQ_CARDMASK 0x00000100
		#define TIFM_IRQ_FIFOMASK 0x00010000
		#define TIFM_IRQ_SETALL 0xffffffff
		#define TIFM_IRQ_SETALLSOCK 0x0000000f

		#define TIFM_CTRL_LED 0x00000040
		#define TIFM_CTRL_FAST_CLK 0x00000100

		#define TIFM_SOCK_STATE_OCCUPIED 0x00000008
		#define TIFM_SOCK_STATE_POWERED 0x00000080

		#define TIFM_FIFO_ENABLE 0x00000001 /* Meaning of this constant is unverified */
		#define TIFM_FIFO_INT_SETALL 0x0000ffff
		#define TIFM_FIFO_INTMASK 0x00000005 /* Meaning of this constant is unverified */

		#define TIFM_DMA_RESET 0x00000002 /* Meaning of this constant is unverified */
		#define TIFM_DMA_TX 0x00008000 /* Meaning of this constant is unverified */
		#define TIFM_DMA_EN 0x00000001 /* Meaning of this constant is unverified */

		typedef enum {FM_NULL = 0, FM_XD = 0x01, FM_MS = 0x02, FM_SD = 0x03} tifm_media_id;

		struct tifm_driver;
		struct tifm_dev {
		char __iomem *addr;
		spinlock_t lock;
		tifm_media_id media_id;
		char wq_name[KOBJ_NAME_LEN];
		struct workqueue_struct *wq;

		unsigned int (signal_irq)(struct tifm_dev sock,
		unsigned int sock_irq_status);

		struct tifm_driver *drv;
		struct device dev;
		};

		struct tifm_driver {
		tifm_media_id *id_table;
		int (probe)(struct tifm_dev dev);
		void (remove)(struct tifm_dev dev);

		struct device_driver driver;
		};

		struct tifm_adapter {
		char __iomem *addr;
		unsigned int irq_status;
		unsigned int insert_mask;
		unsigned int remove_mask;
		spinlock_t lock;
		unsigned int id;
		unsigned int max_sockets;
		char wq_name[KOBJ_NAME_LEN];
		unsigned int inhibit_new_cards;
		struct workqueue_struct *wq;
		struct work_struct media_inserter;
		struct work_struct media_remover;
		struct tifm_dev **sockets;
		struct class_device cdev;
		struct device *dev;

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

		struct tifm_adapter *tifm_alloc_adapter(void);
		void tifm_free_device(struct device *dev);
		void tifm_free_adapter(struct tifm_adapter *fm);
		int tifm_add_adapter(struct tifm_adapter *fm);
		void tifm_remove_adapter(struct tifm_adapter *fm);
		struct tifm_dev tifm_alloc_device(struct tifm_adapter fm, unsigned int id);
		int tifm_register_driver(struct tifm_driver *drv);
		void tifm_unregister_driver(struct tifm_driver *drv);
		void tifm_eject(struct tifm_dev *sock);
		int tifm_map_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
		int direction);
		void tifm_unmap_sg(struct tifm_dev sock, struct scatterlist sg, int nents,
		int direction);


		static inline void tifm_get_drvdata(struct tifm_dev dev)
		{
		return dev_get_drvdata(&dev->dev);
		}

		static inline void tifm_set_drvdata(struct tifm_dev dev, void data)
		{
		dev_set_drvdata(&dev->dev, data);
		}

		struct tifm_device_id {
		tifm_media_id media_id;
		};

		#endif