1/*
2 *  linux/drivers/mmc/core/core.c
3 *
4 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
5 *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
6 *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
7 *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13#include <linux/module.h>
14#include <linux/init.h>
15#include <linux/interrupt.h>
16#include <linux/completion.h>
17#include <linux/device.h>
18#include <linux/delay.h>
19#include <linux/pagemap.h>
20#include <linux/err.h>
21#include <asm/scatterlist.h>
22#include <linux/scatterlist.h>
23
24#include <linux/mmc/card.h>
25#include <linux/mmc/host.h>
26#include <linux/mmc/mmc.h>
27#include <linux/mmc/sd.h>
28
29#include "core.h"
30#include "sysfs.h"
31
32#include "mmc_ops.h"
33#include "sd_ops.h"
34
35extern int mmc_attach_mmc(struct mmc_host *host, u32 ocr);
36extern int mmc_attach_sd(struct mmc_host *host, u32 ocr);
37
38/**
39 *	mmc_request_done - finish processing an MMC request
40 *	@host: MMC host which completed request
41 *	@mrq: MMC request which request
42 *
43 *	MMC drivers should call this function when they have completed
44 *	their processing of a request.
45 */
46void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
47{
48	struct mmc_command *cmd = mrq->cmd;
49	int err = cmd->error;
50
51	pr_debug("%s: req done (CMD%u): %d/%d/%d: %08x %08x %08x %08x\n",
52		 mmc_hostname(host), cmd->opcode, err,
53		 mrq->data ? mrq->data->error : 0,
54		 mrq->stop ? mrq->stop->error : 0,
55		 cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
56
57	if (err && cmd->retries) {
58		cmd->retries--;
59		cmd->error = 0;
60		host->ops->request(host, mrq);
61	} else if (mrq->done) {
62		mrq->done(mrq);
63	}
64}
65
66EXPORT_SYMBOL(mmc_request_done);
67
68/**
69 *	mmc_start_request - start a command on a host
70 *	@host: MMC host to start command on
71 *	@mrq: MMC request to start
72 *
73 *	Queue a command on the specified host.  We expect the
74 *	caller to be holding the host lock with interrupts disabled.
75 */
76void
77mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
78{
79#ifdef CONFIG_MMC_DEBUG
80	unsigned int i, sz;
81#endif
82
83	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
84		 mmc_hostname(host), mrq->cmd->opcode,
85		 mrq->cmd->arg, mrq->cmd->flags);
86
87	WARN_ON(!host->claimed);
88
89	mrq->cmd->error = 0;
90	mrq->cmd->mrq = mrq;
91	if (mrq->data) {
92		BUG_ON(mrq->data->blksz > host->max_blk_size);
93		BUG_ON(mrq->data->blocks > host->max_blk_count);
94		BUG_ON(mrq->data->blocks * mrq->data->blksz >
95			host->max_req_size);
96
97#ifdef CONFIG_MMC_DEBUG
98		sz = 0;
99		for (i = 0;i < mrq->data->sg_len;i++)
100			sz += mrq->data->sg[i].length;
101		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
102#endif
103
104		mrq->cmd->data = mrq->data;
105		mrq->data->error = 0;
106		mrq->data->mrq = mrq;
107		if (mrq->stop) {
108			mrq->data->stop = mrq->stop;
109			mrq->stop->error = 0;
110			mrq->stop->mrq = mrq;
111		}
112	}
113	host->ops->request(host, mrq);
114}
115
116EXPORT_SYMBOL(mmc_start_request);
117
118static void mmc_wait_done(struct mmc_request *mrq)
119{
120	complete(mrq->done_data);
121}
122
123int mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
124{
125	DECLARE_COMPLETION_ONSTACK(complete);
126
127	mrq->done_data = &complete;
128	mrq->done = mmc_wait_done;
129
130	mmc_start_request(host, mrq);
131
132	wait_for_completion(&complete);
133
134	return 0;
135}
136
137EXPORT_SYMBOL(mmc_wait_for_req);
138
139/**
140 *	mmc_wait_for_cmd - start a command and wait for completion
141 *	@host: MMC host to start command
142 *	@cmd: MMC command to start
143 *	@retries: maximum number of retries
144 *
145 *	Start a new MMC command for a host, and wait for the command
146 *	to complete.  Return any error that occurred while the command
147 *	was executing.  Do not attempt to parse the response.
148 */
149int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
150{
151	struct mmc_request mrq;
152
153	BUG_ON(!host->claimed);
154
155	memset(&mrq, 0, sizeof(struct mmc_request));
156
157	memset(cmd->resp, 0, sizeof(cmd->resp));
158	cmd->retries = retries;
159
160	mrq.cmd = cmd;
161	cmd->data = NULL;
162
163	mmc_wait_for_req(host, &mrq);
164
165	return cmd->error;
166}
167
168EXPORT_SYMBOL(mmc_wait_for_cmd);
169
170/**
171 *	mmc_set_data_timeout - set the timeout for a data command
172 *	@data: data phase for command
173 *	@card: the MMC card associated with the data transfer
174 *	@write: flag to differentiate reads from writes
175 */
176void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card,
177			  int write)
178{
179	unsigned int mult;
180
181	/*
182	 * SD cards use a 100 multiplier rather than 10
183	 */
184	mult = mmc_card_sd(card) ? 100 : 10;
185
186	/*
187	 * Scale up the multiplier (and therefore the timeout) by
188	 * the r2w factor for writes.
189	 */
190	if (write)
191		mult <<= card->csd.r2w_factor;
192
193	data->timeout_ns = card->csd.tacc_ns * mult;
194	data->timeout_clks = card->csd.tacc_clks * mult;
195
196	/*
197	 * SD cards also have an upper limit on the timeout.
198	 */
199	if (mmc_card_sd(card)) {
200		unsigned int timeout_us, limit_us;
201
202		timeout_us = data->timeout_ns / 1000;
203		timeout_us += data->timeout_clks * 1000 /
204			(card->host->ios.clock / 1000);
205
206		if (write)
207			limit_us = 250000;
208		else
209			limit_us = 100000;
210
211		/*
212		 * SDHC cards always use these fixed values.
213		 */
214		if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
215			data->timeout_ns = limit_us * 1000;
216			data->timeout_clks = 0;
217		}
218	}
219}
220EXPORT_SYMBOL(mmc_set_data_timeout);
221
222/**
223 *	__mmc_claim_host - exclusively claim a host
224 *	@host: mmc host to claim
225 *	@card: mmc card to claim host for
226 *
227 *	Claim a host for a set of operations.  If a valid card
228 *	is passed and this wasn't the last card selected, select
229 *	the card before returning.
230 *
231 *	Note: you should use mmc_card_claim_host or mmc_claim_host.
232 */
233void mmc_claim_host(struct mmc_host *host)
234{
235	DECLARE_WAITQUEUE(wait, current);
236	unsigned long flags;
237
238	add_wait_queue(&host->wq, &wait);
239	spin_lock_irqsave(&host->lock, flags);
240	while (1) {
241		set_current_state(TASK_UNINTERRUPTIBLE);
242		if (!host->claimed)
243			break;
244		spin_unlock_irqrestore(&host->lock, flags);
245		schedule();
246		spin_lock_irqsave(&host->lock, flags);
247	}
248	set_current_state(TASK_RUNNING);
249	host->claimed = 1;
250	spin_unlock_irqrestore(&host->lock, flags);
251	remove_wait_queue(&host->wq, &wait);
252}
253
254EXPORT_SYMBOL(mmc_claim_host);
255
256/**
257 *	mmc_release_host - release a host
258 *	@host: mmc host to release
259 *
260 *	Release a MMC host, allowing others to claim the host
261 *	for their operations.
262 */
263void mmc_release_host(struct mmc_host *host)
264{
265	unsigned long flags;
266
267	BUG_ON(!host->claimed);
268
269	spin_lock_irqsave(&host->lock, flags);
270	host->claimed = 0;
271	spin_unlock_irqrestore(&host->lock, flags);
272
273	wake_up(&host->wq);
274}
275
276EXPORT_SYMBOL(mmc_release_host);
277
278/*
279 * Internal function that does the actual ios call to the host driver,
280 * optionally printing some debug output.
281 */
282static inline void mmc_set_ios(struct mmc_host *host)
283{
284	struct mmc_ios *ios = &host->ios;
285
286	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
287		"width %u timing %u\n",
288		 mmc_hostname(host), ios->clock, ios->bus_mode,
289		 ios->power_mode, ios->chip_select, ios->vdd,
290		 ios->bus_width, ios->timing);
291
292	host->ops->set_ios(host, ios);
293}
294
295/*
296 * Control chip select pin on a host.
297 */
298void mmc_set_chip_select(struct mmc_host *host, int mode)
299{
300	host->ios.chip_select = mode;
301	mmc_set_ios(host);
302}
303
304/*
305 * Sets the host clock to the highest possible frequency that
306 * is below "hz".
307 */
308void mmc_set_clock(struct mmc_host *host, unsigned int hz)
309{
310	WARN_ON(hz < host->f_min);
311
312	if (hz > host->f_max)
313		hz = host->f_max;
314
315	host->ios.clock = hz;
316	mmc_set_ios(host);
317}
318
319/*
320 * Change the bus mode (open drain/push-pull) of a host.
321 */
322void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
323{
324	host->ios.bus_mode = mode;
325	mmc_set_ios(host);
326}
327
328/*
329 * Change data bus width of a host.
330 */
331void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
332{
333	host->ios.bus_width = width;
334	mmc_set_ios(host);
335}
336
337/*
338 * Mask off any voltages we don't support and select
339 * the lowest voltage
340 */
341u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
342{
343	int bit;
344
345	ocr &= host->ocr_avail;
346
347	bit = ffs(ocr);
348	if (bit) {
349		bit -= 1;
350
351		ocr &= 3 << bit;
352
353		host->ios.vdd = bit;
354		mmc_set_ios(host);
355	} else {
356		ocr = 0;
357	}
358
359	return ocr;
360}
361
362/*
363 * Select timing parameters for host.
364 */
365void mmc_set_timing(struct mmc_host *host, unsigned int timing)
366{
367	host->ios.timing = timing;
368	mmc_set_ios(host);
369}
370
371/*
372 * Allocate a new MMC card
373 */
374struct mmc_card *mmc_alloc_card(struct mmc_host *host)
375{
376	struct mmc_card *card;
377
378	card = kmalloc(sizeof(struct mmc_card), GFP_KERNEL);
379	if (!card)
380		return ERR_PTR(-ENOMEM);
381
382	mmc_init_card(card, host);
383
384	return card;
385}
386
387/*
388 * Apply power to the MMC stack.  This is a two-stage process.
389 * First, we enable power to the card without the clock running.
390 * We then wait a bit for the power to stabilise.  Finally,
391 * enable the bus drivers and clock to the card.
392 *
393 * We must _NOT_ enable the clock prior to power stablising.
394 *
395 * If a host does all the power sequencing itself, ignore the
396 * initial MMC_POWER_UP stage.
397 */
398static void mmc_power_up(struct mmc_host *host)
399{
400	int bit = fls(host->ocr_avail) - 1;
401
402	host->ios.vdd = bit;
403	host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
404	host->ios.chip_select = MMC_CS_DONTCARE;
405	host->ios.power_mode = MMC_POWER_UP;
406	host->ios.bus_width = MMC_BUS_WIDTH_1;
407	host->ios.timing = MMC_TIMING_LEGACY;
408	mmc_set_ios(host);
409
410	mmc_delay(1);
411
412	host->ios.clock = host->f_min;
413	host->ios.power_mode = MMC_POWER_ON;
414	mmc_set_ios(host);
415
416	mmc_delay(2);
417}
418
419static void mmc_power_off(struct mmc_host *host)
420{
421	host->ios.clock = 0;
422	host->ios.vdd = 0;
423	host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
424	host->ios.chip_select = MMC_CS_DONTCARE;
425	host->ios.power_mode = MMC_POWER_OFF;
426	host->ios.bus_width = MMC_BUS_WIDTH_1;
427	host->ios.timing = MMC_TIMING_LEGACY;
428	mmc_set_ios(host);
429}
430
431/*
432 * Assign a mmc bus handler to a host. Only one bus handler may control a
433 * host at any given time.
434 */
435void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
436{
437	unsigned long flags;
438
439	BUG_ON(!host);
440	BUG_ON(!ops);
441
442	BUG_ON(!host->claimed);
443
444	spin_lock_irqsave(&host->lock, flags);
445
446	BUG_ON(host->bus_ops);
447	BUG_ON(host->bus_refs);
448
449	host->bus_ops = ops;
450	host->bus_refs = 1;
451	host->bus_dead = 0;
452
453	spin_unlock_irqrestore(&host->lock, flags);
454}
455
456/*
457 * Remove the current bus handler from a host. Assumes that there are
458 * no interesting cards left, so the bus is powered down.
459 */
460void mmc_detach_bus(struct mmc_host *host)
461{
462	unsigned long flags;
463
464	BUG_ON(!host);
465
466	BUG_ON(!host->claimed);
467	BUG_ON(!host->bus_ops);
468
469	spin_lock_irqsave(&host->lock, flags);
470
471	host->bus_dead = 1;
472
473	spin_unlock_irqrestore(&host->lock, flags);
474
475	mmc_power_off(host);
476
477	mmc_bus_put(host);
478}
479
480/*
481 * Cleanup when the last reference to the bus operator is dropped.
482 */
483void __mmc_release_bus(struct mmc_host *host)
484{
485	BUG_ON(!host);
486	BUG_ON(host->bus_refs);
487	BUG_ON(!host->bus_dead);
488
489	host->bus_ops = NULL;
490}
491
492/**
493 *	mmc_detect_change - process change of state on a MMC socket
494 *	@host: host which changed state.
495 *	@delay: optional delay to wait before detection (jiffies)
496 *
497 *	All we know is that card(s) have been inserted or removed
498 *	from the socket(s).  We don't know which socket or cards.
499 */
500void mmc_detect_change(struct mmc_host *host, unsigned long delay)
501{
502#ifdef CONFIG_MMC_DEBUG
503	unsigned long flags;
504	spin_lock_irqsave(&host->lock, flags);
505	BUG_ON(host->removed);
506	spin_unlock_irqrestore(&host->lock, flags);
507#endif
508
509	mmc_schedule_delayed_work(&host->detect, delay);
510}
511
512EXPORT_SYMBOL(mmc_detect_change);
513
514
515static void mmc_rescan(struct work_struct *work)
516{
517	struct mmc_host *host =
518		container_of(work, struct mmc_host, detect.work);
519	u32 ocr;
520	int err;
521
522	mmc_bus_get(host);
523
524	if (host->bus_ops == NULL) {
525		/*
526		 * Only we can add a new handler, so it's safe to
527		 * release the lock here.
528		 */
529		mmc_bus_put(host);
530
531		mmc_claim_host(host);
532
533		mmc_power_up(host);
534		mmc_go_idle(host);
535
536		mmc_send_if_cond(host, host->ocr_avail);
537
538		err = mmc_send_app_op_cond(host, 0, &ocr);
539		if (err == MMC_ERR_NONE) {
540			if (mmc_attach_sd(host, ocr))
541				mmc_power_off(host);
542		} else {
543			/*
544			 * If we fail to detect any SD cards then try
545			 * searching for MMC cards.
546			 */
547			err = mmc_send_op_cond(host, 0, &ocr);
548			if (err == MMC_ERR_NONE) {
549				if (mmc_attach_mmc(host, ocr))
550					mmc_power_off(host);
551			} else {
552				mmc_power_off(host);
553				mmc_release_host(host);
554			}
555		}
556	} else {
557		if (host->bus_ops->detect && !host->bus_dead)
558			host->bus_ops->detect(host);
559
560		mmc_bus_put(host);
561	}
562}
563
564
565/**
566 *	mmc_alloc_host - initialise the per-host structure.
567 *	@extra: sizeof private data structure
568 *	@dev: pointer to host device model structure
569 *
570 *	Initialise the per-host structure.
571 */
572struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
573{
574	struct mmc_host *host;
575
576	host = mmc_alloc_host_sysfs(extra, dev);
577	if (host) {
578		spin_lock_init(&host->lock);
579		init_waitqueue_head(&host->wq);
580		INIT_DELAYED_WORK(&host->detect, mmc_rescan);
581
582		/*
583		 * By default, hosts do not support SGIO or large requests.
584		 * They have to set these according to their abilities.
585		 */
586		host->max_hw_segs = 1;
587		host->max_phys_segs = 1;
588		host->max_seg_size = PAGE_CACHE_SIZE;
589
590		host->max_req_size = PAGE_CACHE_SIZE;
591		host->max_blk_size = 512;
592		host->max_blk_count = PAGE_CACHE_SIZE / 512;
593	}
594
595	return host;
596}
597
598EXPORT_SYMBOL(mmc_alloc_host);
599
600/**
601 *	mmc_add_host - initialise host hardware
602 *	@host: mmc host
603 */
604int mmc_add_host(struct mmc_host *host)
605{
606	int ret;
607
608	ret = mmc_add_host_sysfs(host);
609	if (ret == 0) {
610		mmc_power_off(host);
611		mmc_detect_change(host, 0);
612	}
613
614	return ret;
615}
616
617EXPORT_SYMBOL(mmc_add_host);
618
619/**
620 *	mmc_remove_host - remove host hardware
621 *	@host: mmc host
622 *
623 *	Unregister and remove all cards associated with this host,
624 *	and power down the MMC bus.
625 */
626void mmc_remove_host(struct mmc_host *host)
627{
628#ifdef CONFIG_MMC_DEBUG
629	unsigned long flags;
630	spin_lock_irqsave(&host->lock, flags);
631	host->removed = 1;
632	spin_unlock_irqrestore(&host->lock, flags);
633#endif
634
635	mmc_flush_scheduled_work();
636
637	mmc_bus_get(host);
638	if (host->bus_ops && !host->bus_dead) {
639		if (host->bus_ops->remove)
640			host->bus_ops->remove(host);
641
642		mmc_claim_host(host);
643		mmc_detach_bus(host);
644		mmc_release_host(host);
645	}
646	mmc_bus_put(host);
647
648	BUG_ON(host->card);
649
650	mmc_power_off(host);
651	mmc_remove_host_sysfs(host);
652}
653
654EXPORT_SYMBOL(mmc_remove_host);
655
656/**
657 *	mmc_free_host - free the host structure
658 *	@host: mmc host
659 *
660 *	Free the host once all references to it have been dropped.
661 */
662void mmc_free_host(struct mmc_host *host)
663{
664	mmc_free_host_sysfs(host);
665}
666
667EXPORT_SYMBOL(mmc_free_host);
668
669#ifdef CONFIG_PM
670
671/**
672 *	mmc_suspend_host - suspend a host
673 *	@host: mmc host
674 *	@state: suspend mode (PM_SUSPEND_xxx)
675 */
676int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
677{
678	mmc_flush_scheduled_work();
679
680	mmc_bus_get(host);
681	if (host->bus_ops && !host->bus_dead) {
682		if (host->bus_ops->suspend)
683			host->bus_ops->suspend(host);
684		if (!host->bus_ops->resume) {
685			if (host->bus_ops->remove)
686				host->bus_ops->remove(host);
687
688			mmc_claim_host(host);
689			mmc_detach_bus(host);
690			mmc_release_host(host);
691		}
692	}
693	mmc_bus_put(host);
694
695	mmc_power_off(host);
696
697	return 0;
698}
699
700EXPORT_SYMBOL(mmc_suspend_host);
701
702/**
703 *	mmc_resume_host - resume a previously suspended host
704 *	@host: mmc host
705 */
706int mmc_resume_host(struct mmc_host *host)
707{
708	mmc_bus_get(host);
709	if (host->bus_ops && !host->bus_dead) {
710		mmc_power_up(host);
711		BUG_ON(!host->bus_ops->resume);
712		host->bus_ops->resume(host);
713	}
714	mmc_bus_put(host);
715
716	/*
717	 * We add a slight delay here so that resume can progress
718	 * in parallel.
719	 */
720	mmc_detect_change(host, 1);
721
722	return 0;
723}
724
725EXPORT_SYMBOL(mmc_resume_host);
726
727#endif
728
729MODULE_LICENSE("GPL");
730