[net-next-2.6.git] / drivers / memstick / core / memstick.c

/*
 *  Sony MemoryStick support
 *
 *  Copyright (C) 2007 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.
 *
 * Special thanks to Carlos Corbacho for providing various MemoryStick cards
 * that made this driver possible.
 *
 */

#include <linux/memstick.h>
#include <linux/idr.h>
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/slab.h>

#define DRIVER_NAME "memstick"

static unsigned int cmd_retries = 3;
module_param(cmd_retries, uint, 0644);

static struct workqueue_struct *workqueue;
static DEFINE_IDR(memstick_host_idr);
static DEFINE_SPINLOCK(memstick_host_lock);

static int memstick_dev_match(struct memstick_dev *card,
			      struct memstick_device_id *id)
{
	if (id->match_flags & MEMSTICK_MATCH_ALL) {
		if ((id->type == card->id.type)
		    && (id->category == card->id.category)
		    && (id->class == card->id.class))
			return 1;
	}

	return 0;
}

static int memstick_bus_match(struct device *dev, struct device_driver *drv)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						 dev);
	struct memstick_driver *ms_drv = container_of(drv,
						      struct memstick_driver,
						      driver);
	struct memstick_device_id *ids = ms_drv->id_table;

	if (ids) {
		while (ids->match_flags) {
			if (memstick_dev_match(card, ids))
				return 1;
			++ids;
		}
	}
	return 0;
}

static int memstick_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						  dev);

	if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type))
		return -ENOMEM;

	if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category))
		return -ENOMEM;

	if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class))
		return -ENOMEM;

	return 0;
}

static int memstick_device_probe(struct device *dev)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						 dev);
	struct memstick_driver *drv = container_of(dev->driver,
						   struct memstick_driver,
						   driver);
	int rc = -ENODEV;

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

static int memstick_device_remove(struct device *dev)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						  dev);
	struct memstick_driver *drv = container_of(dev->driver,
						   struct memstick_driver,
						   driver);

	if (dev->driver && drv->remove) {
		drv->remove(card);
		card->dev.driver = NULL;
	}

	put_device(dev);
	return 0;
}

#ifdef CONFIG_PM

static int memstick_device_suspend(struct device *dev, pm_message_t state)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						  dev);
	struct memstick_driver *drv = container_of(dev->driver,
						   struct memstick_driver,
						   driver);

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

static int memstick_device_resume(struct device *dev)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						  dev);
	struct memstick_driver *drv = container_of(dev->driver,
						   struct memstick_driver,
						   driver);

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

#else

#define memstick_device_suspend NULL
#define memstick_device_resume NULL

#endif /* CONFIG_PM */

#define MEMSTICK_ATTR(name, format)                                           \
static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \
			    char *buf)                                        \
{                                                                             \
	struct memstick_dev *card = container_of(dev, struct memstick_dev,    \
						 dev);                        \
	return sprintf(buf, format, card->id.name);                           \
}

MEMSTICK_ATTR(type, "%02X");
MEMSTICK_ATTR(category, "%02X");
MEMSTICK_ATTR(class, "%02X");

#define MEMSTICK_ATTR_RO(name) __ATTR(name, S_IRUGO, name##_show, NULL)

static struct device_attribute memstick_dev_attrs[] = {
	MEMSTICK_ATTR_RO(type),
	MEMSTICK_ATTR_RO(category),
	MEMSTICK_ATTR_RO(class),
	__ATTR_NULL
};

static struct bus_type memstick_bus_type = {
	.name           = "memstick",
	.dev_attrs      = memstick_dev_attrs,
	.match          = memstick_bus_match,
	.uevent         = memstick_uevent,
	.probe          = memstick_device_probe,
	.remove         = memstick_device_remove,
	.suspend        = memstick_device_suspend,
	.resume         = memstick_device_resume
};

static void memstick_free(struct device *dev)
{
	struct memstick_host *host = container_of(dev, struct memstick_host,
						  dev);
	kfree(host);
}

static struct class memstick_host_class = {
	.name        = "memstick_host",
	.dev_release = memstick_free
};

static void memstick_free_card(struct device *dev)
{
	struct memstick_dev *card = container_of(dev, struct memstick_dev,
						 dev);
	kfree(card);
}

static int memstick_dummy_check(struct memstick_dev *card)
{
	return 0;
}

/**
 * memstick_detect_change - schedule media detection on memstick host
 * @host - host to use
 */
void memstick_detect_change(struct memstick_host *host)
{
	queue_work(workqueue, &host->media_checker);
}
EXPORT_SYMBOL(memstick_detect_change);

/**
 * memstick_next_req - called by host driver to obtain next request to process
 * @host - host to use
 * @mrq - pointer to stick the request to
 *
 * Host calls this function from idle state (*mrq == NULL) or after finishing
 * previous request (*mrq should point to it). If previous request was
 * unsuccessful, it is retried for predetermined number of times. Return value
 * of 0 means that new request was assigned to the host.
 */
int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
{
	int rc = -ENXIO;

	if ((*mrq) && (*mrq)->error && host->retries) {
		(*mrq)->error = rc;
		host->retries--;
		return 0;
	}

	if (host->card && host->card->next_request)
		rc = host->card->next_request(host->card, mrq);

	if (!rc)
		host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
	else
		*mrq = NULL;

	return rc;
}
EXPORT_SYMBOL(memstick_next_req);

/**
 * memstick_new_req - notify the host that some requests are pending
 * @host - host to use
 */
void memstick_new_req(struct memstick_host *host)
{
	if (host->card) {
		host->retries = cmd_retries;
		INIT_COMPLETION(host->card->mrq_complete);
		host->request(host);
	}
}
EXPORT_SYMBOL(memstick_new_req);

/**
 * memstick_init_req_sg - set request fields needed for bulk data transfer
 * @mrq - request to use
 * @tpc - memstick Transport Protocol Command
 * @sg - TPC argument
 */
void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
			  const struct scatterlist *sg)
{
	mrq->tpc = tpc;
	if (tpc & 8)
		mrq->data_dir = WRITE;
	else
		mrq->data_dir = READ;

	mrq->sg = *sg;
	mrq->long_data = 1;

	if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
		mrq->need_card_int = 1;
	else
		mrq->need_card_int = 0;
}
EXPORT_SYMBOL(memstick_init_req_sg);

/**
 * memstick_init_req - set request fields needed for short data transfer
 * @mrq - request to use
 * @tpc - memstick Transport Protocol Command
 * @buf - TPC argument buffer
 * @length - TPC argument size
 *
 * The intended use of this function (transfer of data items several bytes
 * in size) allows us to just copy the value between request structure and
 * user supplied buffer.
 */
void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
		       const void *buf, size_t length)
{
	mrq->tpc = tpc;
	if (tpc & 8)
		mrq->data_dir = WRITE;
	else
		mrq->data_dir = READ;

	mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length;
	if (mrq->data_dir == WRITE)
		memcpy(mrq->data, buf, mrq->data_len);

	mrq->long_data = 0;

	if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
		mrq->need_card_int = 1;
	else
		mrq->need_card_int = 0;
}
EXPORT_SYMBOL(memstick_init_req);

/*
 * Functions prefixed with "h_" are protocol callbacks. They can be called from
 * interrupt context. Return value of 0 means that request processing is still
 * ongoing, while special error value of -EAGAIN means that current request is
 * finished (and request processor should come back some time later).
 */

static int h_memstick_read_dev_id(struct memstick_dev *card,
				  struct memstick_request **mrq)
{
	struct ms_id_register id_reg;

	if (!(*mrq)) {
		memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, NULL,
				  sizeof(struct ms_id_register));
		*mrq = &card->current_mrq;
		return 0;
	} else {
		if (!(*mrq)->error) {
			memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
			card->id.match_flags = MEMSTICK_MATCH_ALL;
			card->id.type = id_reg.type;
			card->id.category = id_reg.category;
			card->id.class = id_reg.class;
			dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
		}
		complete(&card->mrq_complete);
		return -EAGAIN;
	}
}

static int h_memstick_set_rw_addr(struct memstick_dev *card,
				  struct memstick_request **mrq)
{
	if (!(*mrq)) {
		memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
				  (char *)&card->reg_addr,
				  sizeof(card->reg_addr));
		*mrq = &card->current_mrq;
		return 0;
	} else {
		complete(&card->mrq_complete);
		return -EAGAIN;
	}
}

/**
 * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
 *                        complete
 * @card - media device to use
 */
int memstick_set_rw_addr(struct memstick_dev *card)
{
	card->next_request = h_memstick_set_rw_addr;
	memstick_new_req(card->host);
	wait_for_completion(&card->mrq_complete);

	return card->current_mrq.error;
}
EXPORT_SYMBOL(memstick_set_rw_addr);

static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
{
	struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
					    GFP_KERNEL);
	struct memstick_dev *old_card = host->card;
	struct ms_id_register id_reg;

	if (card) {
		card->host = host;
		dev_set_name(&card->dev, "%s", dev_name(&host->dev));
		card->dev.parent = &host->dev;
		card->dev.bus = &memstick_bus_type;
		card->dev.release = memstick_free_card;
		card->check = memstick_dummy_check;

		card->reg_addr.r_offset = offsetof(struct ms_register, id);
		card->reg_addr.r_length = sizeof(id_reg);
		card->reg_addr.w_offset = offsetof(struct ms_register, id);
		card->reg_addr.w_length = sizeof(id_reg);

		init_completion(&card->mrq_complete);

		host->card = card;
		if (memstick_set_rw_addr(card))
			goto err_out;

		card->next_request = h_memstick_read_dev_id;
		memstick_new_req(host);
		wait_for_completion(&card->mrq_complete);

		if (card->current_mrq.error)
			goto err_out;
	}
	host->card = old_card;
	return card;
err_out:
	host->card = old_card;
	kfree(card);
	return NULL;
}

static int memstick_power_on(struct memstick_host *host)
{
	int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);

	if (!rc)
		rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);

	return rc;
}

static void memstick_check(struct work_struct *work)
{
	struct memstick_host *host = container_of(work, struct memstick_host,
						  media_checker);
	struct memstick_dev *card;

	dev_dbg(&host->dev, "memstick_check started\n");
	mutex_lock(&host->lock);
	if (!host->card) {
		if (memstick_power_on(host))
			goto out_power_off;
	} else if (host->card->stop)
		host->card->stop(host->card);

	card = memstick_alloc_card(host);

	if (!card) {
		if (host->card) {
			device_unregister(&host->card->dev);
			host->card = NULL;
		}
	} else {
		dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
			card->id.type, card->id.category, card->id.class);
		if (host->card) {
			if (memstick_set_rw_addr(host->card)
			    || !memstick_dev_match(host->card, &card->id)
			    || !(host->card->check(host->card))) {
				device_unregister(&host->card->dev);
				host->card = NULL;
			} else if (host->card->start)
				host->card->start(host->card);
		}

		if (!host->card) {
			host->card = card;
			if (device_register(&card->dev)) {
				kfree(host->card);
				host->card = NULL;
			}
		} else
			kfree(card);
	}

out_power_off:
	if (!host->card)
		host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);

	mutex_unlock(&host->lock);
	dev_dbg(&host->dev, "memstick_check finished\n");
}

/**
 * memstick_alloc_host - allocate a memstick_host structure
 * @extra: size of the user private data to allocate
 * @dev: parent device of the host
 */
struct memstick_host *memstick_alloc_host(unsigned int extra,
					  struct device *dev)
{
	struct memstick_host *host;

	host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
	if (host) {
		mutex_init(&host->lock);
		INIT_WORK(&host->media_checker, memstick_check);
		host->dev.class = &memstick_host_class;
		host->dev.parent = dev;
		device_initialize(&host->dev);
	}
	return host;
}
EXPORT_SYMBOL(memstick_alloc_host);

/**
 * memstick_add_host - start request processing on memstick host
 * @host - host to use
 */
int memstick_add_host(struct memstick_host *host)
{
	int rc;

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

	spin_lock(&memstick_host_lock);
	rc = idr_get_new(&memstick_host_idr, host, &host->id);
	spin_unlock(&memstick_host_lock);
	if (rc)
		return rc;

	dev_set_name(&host->dev, "memstick%u", host->id);

	rc = device_add(&host->dev);
	if (rc) {
		spin_lock(&memstick_host_lock);
		idr_remove(&memstick_host_idr, host->id);
		spin_unlock(&memstick_host_lock);
		return rc;
	}

	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	memstick_detect_change(host);
	return 0;
}
EXPORT_SYMBOL(memstick_add_host);

/**
 * memstick_remove_host - stop request processing on memstick host
 * @host - host to use
 */
void memstick_remove_host(struct memstick_host *host)
{
	flush_workqueue(workqueue);
	mutex_lock(&host->lock);
	if (host->card)
		device_unregister(&host->card->dev);
	host->card = NULL;
	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	mutex_unlock(&host->lock);

	spin_lock(&memstick_host_lock);
	idr_remove(&memstick_host_idr, host->id);
	spin_unlock(&memstick_host_lock);
	device_del(&host->dev);
}
EXPORT_SYMBOL(memstick_remove_host);

/**
 * memstick_free_host - free memstick host
 * @host - host to use
 */
void memstick_free_host(struct memstick_host *host)
{
	mutex_destroy(&host->lock);
	put_device(&host->dev);
}
EXPORT_SYMBOL(memstick_free_host);

/**
 * memstick_suspend_host - notify bus driver of host suspension
 * @host - host to use
 */
void memstick_suspend_host(struct memstick_host *host)
{
	mutex_lock(&host->lock);
	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	mutex_unlock(&host->lock);
}
EXPORT_SYMBOL(memstick_suspend_host);

/**
 * memstick_resume_host - notify bus driver of host resumption
 * @host - host to use
 */
void memstick_resume_host(struct memstick_host *host)
{
	int rc = 0;

	mutex_lock(&host->lock);
	if (host->card)
		rc = memstick_power_on(host);
	mutex_unlock(&host->lock);

	if (!rc)
		memstick_detect_change(host);
}
EXPORT_SYMBOL(memstick_resume_host);

int memstick_register_driver(struct memstick_driver *drv)
{
	drv->driver.bus = &memstick_bus_type;

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

void memstick_unregister_driver(struct memstick_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(memstick_unregister_driver);


static int __init memstick_init(void)
{
	int rc;

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

	rc = bus_register(&memstick_bus_type);
	if (!rc)
		rc = class_register(&memstick_host_class);

	if (!rc)
		return 0;

	bus_unregister(&memstick_bus_type);
	destroy_workqueue(workqueue);

	return rc;
}

static void __exit memstick_exit(void)
{
	class_unregister(&memstick_host_class);
	bus_unregister(&memstick_bus_type);
	destroy_workqueue(workqueue);
	idr_destroy(&memstick_host_idr);
}

module_init(memstick_init);
module_exit(memstick_exit);

MODULE_AUTHOR("Alex Dubov");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Sony MemoryStick core driver");
Commit	Line	Data
baf8532a AD	1	/*
	2	* Sony MemoryStick support
	3	*
	4	* Copyright (C) 2007 Alex Dubov <oakad@yahoo.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* Special thanks to Carlos Corbacho for providing various MemoryStick cards
	11	* that made this driver possible.
	12	*
	13	*/
	14
	15	#include <linux/memstick.h>
	16	#include <linux/idr.h>
	17	#include <linux/fs.h>
	18	#include <linux/delay.h>
5a0e3ad6	19	#include <linux/slab.h>
baf8532a AD	20
baf8532a AD	21	#define DRIVER_NAME "memstick"
baf8532a AD	22
	23	static unsigned int cmd_retries = 3;
	24	module_param(cmd_retries, uint, 0644);
	25
	26	static struct workqueue_struct *workqueue;
	27	static DEFINE_IDR(memstick_host_idr);
	28	static DEFINE_SPINLOCK(memstick_host_lock);
	29
	30	static int memstick_dev_match(struct memstick_dev *card,
	31	struct memstick_device_id *id)
	32	{
	33	if (id->match_flags & MEMSTICK_MATCH_ALL) {
	34	if ((id->type == card->id.type)
	35	&& (id->category == card->id.category)
	36	&& (id->class == card->id.class))
	37	return 1;
	38	}
	39
	40	return 0;
	41	}
	42
	43	static int memstick_bus_match(struct device dev, struct device_driver drv)
	44	{
	45	struct memstick_dev *card = container_of(dev, struct memstick_dev,
	46	dev);
	47	struct memstick_driver *ms_drv = container_of(drv,
	48	struct memstick_driver,
	49	driver);
	50	struct memstick_device_id *ids = ms_drv->id_table;
	51
	52	if (ids) {
	53	while (ids->match_flags) {
	54	if (memstick_dev_match(card, ids))
	55	return 1;
	56	++ids;
	57	}
	58	}
	59	return 0;
	60	}
	61
	62	static int memstick_uevent(struct device dev, struct kobj_uevent_env env)
	63	{
	64	struct memstick_dev *card = container_of(dev, struct memstick_dev,
	65	dev);
	66
	67	if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type))
	68	return -ENOMEM;
	69
	70	if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category))
	71	return -ENOMEM;
	72
	73	if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class))
	74	return -ENOMEM;
	75
	76	return 0;
	77	}
	78
	79	static int memstick_device_probe(struct device *dev)
	80	{
	81	struct memstick_dev *card = container_of(dev, struct memstick_dev,
	82	dev);
	83	struct memstick_driver *drv = container_of(dev->driver,
	84	struct memstick_driver,
	85	driver);
86	int rc = -ENODEV;
87
88	if (dev->driver && drv->probe) {
89	rc = drv->probe(card);
90	if (!rc)
91	get_device(dev);
92	}
93	return rc;
94	}
95
96	static int memstick_device_remove(struct device *dev)
97	{
98	struct memstick_dev *card = container_of(dev, struct memstick_dev,
99	dev);
100	struct memstick_driver *drv = container_of(dev->driver,
101	struct memstick_driver,
102	driver);
103
104	if (dev->driver && drv->remove) {
105	drv->remove(card);
106	card->dev.driver = NULL;
107	}
108
109	put_device(dev);
110	return 0;
111	}
112
113	#ifdef CONFIG_PM
114
115	static int memstick_device_suspend(struct device *dev, pm_message_t state)
116	{
117	struct memstick_dev *card = container_of(dev, struct memstick_dev,
118	dev);
119	struct memstick_driver *drv = container_of(dev->driver,
120	struct memstick_driver,
121	driver);
122
123	if (dev->driver && drv->suspend)
124	return drv->suspend(card, state);
125	return 0;
126	}
127
128	static int memstick_device_resume(struct device *dev)
129	{
130	struct memstick_dev *card = container_of(dev, struct memstick_dev,
131	dev);
132	struct memstick_driver *drv = container_of(dev->driver,
133	struct memstick_driver,
134	driver);
135
136	if (dev->driver && drv->resume)
137	return drv->resume(card);
138	return 0;
139	}
140
141	#else
142
143	#define memstick_device_suspend NULL
144	#define memstick_device_resume NULL
145
146	#endif /* CONFIG_PM */
147
148	#define MEMSTICK_ATTR(name, format) \
149	static ssize_t name##_show(struct device dev, struct device_attribute attr, \
150	char *buf) \
151	{ \
152	struct memstick_dev *card = container_of(dev, struct memstick_dev, \
153	dev); \
154	return sprintf(buf, format, card->id.name); \
155	}
156
157	MEMSTICK_ATTR(type, "%02X");
158	MEMSTICK_ATTR(category, "%02X");
159	MEMSTICK_ATTR(class, "%02X");
160
161	#define MEMSTICK_ATTR_RO(name) __ATTR(name, S_IRUGO, name##_show, NULL)
162
163	static struct device_attribute memstick_dev_attrs[] = {
164	MEMSTICK_ATTR_RO(type),
165	MEMSTICK_ATTR_RO(category),
166	MEMSTICK_ATTR_RO(class),
167	__ATTR_NULL
168	};
169
170	static struct bus_type memstick_bus_type = {
171	.name = "memstick",
172	.dev_attrs = memstick_dev_attrs,
173	.match = memstick_bus_match,
174	.uevent = memstick_uevent,
175	.probe = memstick_device_probe,
176	.remove = memstick_device_remove,
177	.suspend = memstick_device_suspend,
178	.resume = memstick_device_resume
179	};
180
c4c66cf1	181	static void memstick_free(struct device *dev)
baf8532a	182	{
c4c66cf1 GKH	183	struct memstick_host *host = container_of(dev, struct memstick_host,
c4c66cf1 GKH	184	dev);
baf8532a AD	185	kfree(host);
	186	}
	187
	188	static struct class memstick_host_class = {
8e82f8c3	189	.name = "memstick_host",
c4c66cf1	190	.dev_release = memstick_free
baf8532a AD	191	};
	192
	193	static void memstick_free_card(struct device *dev)
	194	{
	195	struct memstick_dev *card = container_of(dev, struct memstick_dev,
	196	dev);
	197	kfree(card);
	198	}
	199
	200	static int memstick_dummy_check(struct memstick_dev *card)
	201	{
	202	return 0;
	203	}
	204
	205	/**
	206	* memstick_detect_change - schedule media detection on memstick host
	207	* @host - host to use
	208	*/
	209	void memstick_detect_change(struct memstick_host *host)
	210	{
	211	queue_work(workqueue, &host->media_checker);
	212	}
	213	EXPORT_SYMBOL(memstick_detect_change);
	214
	215	/**
	216	* memstick_next_req - called by host driver to obtain next request to process
	217	* @host - host to use
	218	* @mrq - pointer to stick the request to
	219	*
	220	* Host calls this function from idle state (*mrq == NULL) or after finishing
	221	* previous request (*mrq should point to it). If previous request was
	222	* unsuccessful, it is retried for predetermined number of times. Return value
	223	* of 0 means that new request was assigned to the host.
	224	*/
	225	int memstick_next_req(struct memstick_host host, struct memstick_request *mrq)
	226	{
	227	int rc = -ENXIO;
	228
	229	if ((mrq) && (mrq)->error && host->retries) {
	230	(*mrq)->error = rc;
	231	host->retries--;
	232	return 0;
	233	}
	234
	235	if (host->card && host->card->next_request)
	236	rc = host->card->next_request(host->card, mrq);
	237
	238	if (!rc)
29196dc6	239	host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
baf8532a AD	240	else
	241	*mrq = NULL;
	242
	243	return rc;
	244	}
	245	EXPORT_SYMBOL(memstick_next_req);
	246
	247	/**
	248	* memstick_new_req - notify the host that some requests are pending
	249	* @host - host to use
	250	*/
	251	void memstick_new_req(struct memstick_host *host)
	252	{
f1d82698 AD	253	if (host->card) {
	254	host->retries = cmd_retries;
	255	INIT_COMPLETION(host->card->mrq_complete);
	256	host->request(host);
	257	}
baf8532a AD	258	}
	259	EXPORT_SYMBOL(memstick_new_req);
	260
	261	/**
	262	* memstick_init_req_sg - set request fields needed for bulk data transfer
	263	* @mrq - request to use
	264	* @tpc - memstick Transport Protocol Command
	265	* @sg - TPC argument
	266	*/
	267	void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
8e82f8c3	268	const struct scatterlist *sg)
baf8532a AD	269	{
	270	mrq->tpc = tpc;
	271	if (tpc & 8)
	272	mrq->data_dir = WRITE;
	273	else
	274	mrq->data_dir = READ;
	275
	276	mrq->sg = *sg;
e1f19995	277	mrq->long_data = 1;
baf8532a AD	278
	279	if (tpc == MS_TPC_SET_CMD \|\| tpc == MS_TPC_EX_SET_CMD)
	280	mrq->need_card_int = 1;
	281	else
	282	mrq->need_card_int = 0;
baf8532a AD	283	}
	284	EXPORT_SYMBOL(memstick_init_req_sg);
	285
	286	/**
	287	* memstick_init_req - set request fields needed for short data transfer
	288	* @mrq - request to use
	289	* @tpc - memstick Transport Protocol Command
	290	* @buf - TPC argument buffer
	291	* @length - TPC argument size
	292	*
	293	* The intended use of this function (transfer of data items several bytes
	294	* in size) allows us to just copy the value between request structure and
	295	* user supplied buffer.
	296	*/
	297	void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
8e82f8c3	298	const void *buf, size_t length)
baf8532a AD	299	{
	300	mrq->tpc = tpc;
	301	if (tpc & 8)
	302	mrq->data_dir = WRITE;
	303	else
	304	mrq->data_dir = READ;
	305
	306	mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length;
	307	if (mrq->data_dir == WRITE)
	308	memcpy(mrq->data, buf, mrq->data_len);
	309
e1f19995	310	mrq->long_data = 0;
baf8532a AD	311
	312	if (tpc == MS_TPC_SET_CMD \|\| tpc == MS_TPC_EX_SET_CMD)
	313	mrq->need_card_int = 1;
	314	else
	315	mrq->need_card_int = 0;
baf8532a AD	316	}
	317	EXPORT_SYMBOL(memstick_init_req);
	318
	319	/*
	320	* Functions prefixed with "h_" are protocol callbacks. They can be called from
	321	* interrupt context. Return value of 0 means that request processing is still
	322	* ongoing, while special error value of -EAGAIN means that current request is
	323	* finished (and request processor should come back some time later).
	324	*/
	325
	326	static int h_memstick_read_dev_id(struct memstick_dev *card,
	327	struct memstick_request **mrq)
	328	{
	329	struct ms_id_register id_reg;
	330
	331	if (!(*mrq)) {
	332	memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, NULL,
	333	sizeof(struct ms_id_register));
	334	*mrq = &card->current_mrq;
	335	return 0;
	336	} else {
	337	if (!(*mrq)->error) {
	338	memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
	339	card->id.match_flags = MEMSTICK_MATCH_ALL;
	340	card->id.type = id_reg.type;
	341	card->id.category = id_reg.category;
	342	card->id.class = id_reg.class;
b873c2f3	343	dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
baf8532a AD	344	}
	345	complete(&card->mrq_complete);
	346	return -EAGAIN;
	347	}
	348	}
	349
	350	static int h_memstick_set_rw_addr(struct memstick_dev *card,
	351	struct memstick_request **mrq)
	352	{
	353	if (!(*mrq)) {
	354	memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
	355	(char *)&card->reg_addr,
	356	sizeof(card->reg_addr));
	357	*mrq = &card->current_mrq;
	358	return 0;
	359	} else {
	360	complete(&card->mrq_complete);
	361	return -EAGAIN;
	362	}
	363	}
	364
	365	/**
	366	* memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
	367	* complete
	368	* @card - media device to use
	369	*/
	370	int memstick_set_rw_addr(struct memstick_dev *card)
	371	{
	372	card->next_request = h_memstick_set_rw_addr;
	373	memstick_new_req(card->host);
	374	wait_for_completion(&card->mrq_complete);
	375
	376	return card->current_mrq.error;
	377	}
	378	EXPORT_SYMBOL(memstick_set_rw_addr);
	379
	380	static struct memstick_dev memstick_alloc_card(struct memstick_host host)
	381	{
	382	struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
	383	GFP_KERNEL);
	384	struct memstick_dev *old_card = host->card;
	385	struct ms_id_register id_reg;
	386
	387	if (card) {
	388	card->host = host;
0252c3b4	389	dev_set_name(&card->dev, "%s", dev_name(&host->dev));
c4c66cf1	390	card->dev.parent = &host->dev;
baf8532a AD	391	card->dev.bus = &memstick_bus_type;
	392	card->dev.release = memstick_free_card;
	393	card->check = memstick_dummy_check;
	394
	395	card->reg_addr.r_offset = offsetof(struct ms_register, id);
	396	card->reg_addr.r_length = sizeof(id_reg);
	397	card->reg_addr.w_offset = offsetof(struct ms_register, id);
	398	card->reg_addr.w_length = sizeof(id_reg);
	399
	400	init_completion(&card->mrq_complete);
	401
	402	host->card = card;
	403	if (memstick_set_rw_addr(card))
	404	goto err_out;
	405
	406	card->next_request = h_memstick_read_dev_id;
	407	memstick_new_req(host);
	408	wait_for_completion(&card->mrq_complete);
	409
	410	if (card->current_mrq.error)
	411	goto err_out;
	412	}
	413	host->card = old_card;
	414	return card;
	415	err_out:
	416	host->card = old_card;
	417	kfree(card);
	418	return NULL;
	419	}
	420
b7789998	421	static int memstick_power_on(struct memstick_host *host)
baf8532a	422	{
b7789998 AD	423	int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
	424
	425	if (!rc)
	426	rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
	427
	428	return rc;
baf8532a AD	429	}
	430
	431	static void memstick_check(struct work_struct *work)
	432	{
	433	struct memstick_host *host = container_of(work, struct memstick_host,
	434	media_checker);
	435	struct memstick_dev *card;
	436
c4c66cf1	437	dev_dbg(&host->dev, "memstick_check started\n");
baf8532a	438	mutex_lock(&host->lock);
17017d8d AD	439	if (!host->card) {
	440	if (memstick_power_on(host))
	441	goto out_power_off;
8e82f8c3	442	} else if (host->card->stop)
17017d8d	443	host->card->stop(host->card);
baf8532a AD	444
	445	card = memstick_alloc_card(host);
	446
	447	if (!card) {
	448	if (host->card) {
	449	device_unregister(&host->card->dev);
	450	host->card = NULL;
	451	}
	452	} else {
c4c66cf1	453	dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
baf8532a AD	454	card->id.type, card->id.category, card->id.class);
	455	if (host->card) {
	456	if (memstick_set_rw_addr(host->card)
	457	\|\| !memstick_dev_match(host->card, &card->id)
	458	\|\| !(host->card->check(host->card))) {
	459	device_unregister(&host->card->dev);
	460	host->card = NULL;
8e82f8c3	461	} else if (host->card->start)
17017d8d	462	host->card->start(host->card);
baf8532a AD	463	}
	464
	465	if (!host->card) {
	466	host->card = card;
	467	if (device_register(&card->dev)) {
	468	kfree(host->card);
	469	host->card = NULL;
	470	}
	471	} else
	472	kfree(card);
	473	}
	474
17017d8d	475	out_power_off:
baf8532a AD	476	if (!host->card)
	477	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	478
	479	mutex_unlock(&host->lock);
c4c66cf1	480	dev_dbg(&host->dev, "memstick_check finished\n");
baf8532a AD	481	}
	482
	483	/**
	484	* memstick_alloc_host - allocate a memstick_host structure
	485	* @extra: size of the user private data to allocate
	486	* @dev: parent device of the host
	487	*/
	488	struct memstick_host *memstick_alloc_host(unsigned int extra,
	489	struct device *dev)
	490	{
	491	struct memstick_host *host;
	492
	493	host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
	494	if (host) {
	495	mutex_init(&host->lock);
	496	INIT_WORK(&host->media_checker, memstick_check);
c4c66cf1 GKH	497	host->dev.class = &memstick_host_class;
	498	host->dev.parent = dev;
	499	device_initialize(&host->dev);
baf8532a AD	500	}
	501	return host;
	502	}
	503	EXPORT_SYMBOL(memstick_alloc_host);
	504
	505	/**
	506	* memstick_add_host - start request processing on memstick host
	507	* @host - host to use
	508	*/
	509	int memstick_add_host(struct memstick_host *host)
	510	{
	511	int rc;
	512
	513	if (!idr_pre_get(&memstick_host_idr, GFP_KERNEL))
	514	return -ENOMEM;
	515
	516	spin_lock(&memstick_host_lock);
	517	rc = idr_get_new(&memstick_host_idr, host, &host->id);
	518	spin_unlock(&memstick_host_lock);
	519	if (rc)
	520	return rc;
	521
0252c3b4	522	dev_set_name(&host->dev, "memstick%u", host->id);
baf8532a	523
c4c66cf1	524	rc = device_add(&host->dev);
baf8532a AD	525	if (rc) {
	526	spin_lock(&memstick_host_lock);
	527	idr_remove(&memstick_host_idr, host->id);
	528	spin_unlock(&memstick_host_lock);
	529	return rc;
	530	}
	531
	532	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	533	memstick_detect_change(host);
	534	return 0;
	535	}
	536	EXPORT_SYMBOL(memstick_add_host);
	537
	538	/**
	539	* memstick_remove_host - stop request processing on memstick host
	540	* @host - host to use
	541	*/
	542	void memstick_remove_host(struct memstick_host *host)
	543	{
	544	flush_workqueue(workqueue);
	545	mutex_lock(&host->lock);
	546	if (host->card)
	547	device_unregister(&host->card->dev);
	548	host->card = NULL;
	549	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	550	mutex_unlock(&host->lock);
	551
	552	spin_lock(&memstick_host_lock);
	553	idr_remove(&memstick_host_idr, host->id);
	554	spin_unlock(&memstick_host_lock);
c4c66cf1	555	device_del(&host->dev);
baf8532a AD	556	}
	557	EXPORT_SYMBOL(memstick_remove_host);
	558
	559	/**
	560	* memstick_free_host - free memstick host
	561	* @host - host to use
	562	*/
	563	void memstick_free_host(struct memstick_host *host)
	564	{
	565	mutex_destroy(&host->lock);
c4c66cf1	566	put_device(&host->dev);
baf8532a AD	567	}
	568	EXPORT_SYMBOL(memstick_free_host);
	569
d114ad54 AD	570	/**
	571	* memstick_suspend_host - notify bus driver of host suspension
	572	* @host - host to use
	573	*/
	574	void memstick_suspend_host(struct memstick_host *host)
	575	{
	576	mutex_lock(&host->lock);
	577	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
	578	mutex_unlock(&host->lock);
	579	}
	580	EXPORT_SYMBOL(memstick_suspend_host);
	581
	582	/**
	583	* memstick_resume_host - notify bus driver of host resumption
	584	* @host - host to use
	585	*/
	586	void memstick_resume_host(struct memstick_host *host)
	587	{
b7789998 AD	588	int rc = 0;
b7789998 AD	589
d114ad54	590	mutex_lock(&host->lock);
ead70773	591	if (host->card)
b7789998	592	rc = memstick_power_on(host);
d114ad54	593	mutex_unlock(&host->lock);
b7789998 AD	594
	595	if (!rc)
	596	memstick_detect_change(host);
d114ad54 AD	597	}
	598	EXPORT_SYMBOL(memstick_resume_host);
	599
baf8532a AD	600	int memstick_register_driver(struct memstick_driver *drv)
	601	{
	602	drv->driver.bus = &memstick_bus_type;
	603
	604	return driver_register(&drv->driver);
	605	}
	606	EXPORT_SYMBOL(memstick_register_driver);
	607
	608	void memstick_unregister_driver(struct memstick_driver *drv)
	609	{
	610	driver_unregister(&drv->driver);
	611	}
	612	EXPORT_SYMBOL(memstick_unregister_driver);
	613
	614
	615	static int __init memstick_init(void)
	616	{
	617	int rc;
	618
	619	workqueue = create_freezeable_workqueue("kmemstick");
	620	if (!workqueue)
	621	return -ENOMEM;
	622
	623	rc = bus_register(&memstick_bus_type);
	624	if (!rc)
	625	rc = class_register(&memstick_host_class);
	626
	627	if (!rc)
	628	return 0;
	629
	630	bus_unregister(&memstick_bus_type);
	631	destroy_workqueue(workqueue);
	632
	633	return rc;
	634	}
	635
	636	static void __exit memstick_exit(void)
	637	{
	638	class_unregister(&memstick_host_class);
	639	bus_unregister(&memstick_bus_type);
	640	destroy_workqueue(workqueue);
	641	idr_destroy(&memstick_host_idr);
	642	}
	643
	644	module_init(memstick_init);
	645	module_exit(memstick_exit);
	646
	647	MODULE_AUTHOR("Alex Dubov");
	648	MODULE_LICENSE("GPL");
	649	MODULE_DESCRIPTION("Sony MemoryStick core driver");