OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/target/linux/cns3xxx/patches-2.6.31/204-cns3xxx_mmc_support.patch

1	--- a/drivers/mmc/card/block.c
2	+++ b/drivers/mmc/card/block.c
3	@@ -130,7 +130,7 @@ mmc_blk_getgeo(struct block_device *bdev
4	return 0;
5	}
6
7	-static struct block_device_operations mmc_bdops = {
8	+static const struct block_device_operations mmc_bdops = {
9	.open = mmc_blk_open,
10	.release = mmc_blk_release,
11	.getgeo = mmc_blk_getgeo,
12	@@ -392,13 +392,9 @@ static int mmc_blk_issue_rq(struct mmc_q
13	} while (!(cmd.resp[0] & R1_READY_FOR_DATA) \|\|
14	(R1_CURRENT_STATE(cmd.resp[0]) == 7));
15
16	-#if 0
17	if (cmd.resp[0] & ~0x00000900)
18	printk(KERN_ERR "%s: status = %08x\n",
19	req->rq_disk->disk_name, cmd.resp[0]);
20	- if (mmc_decode_status(cmd.resp))
21	- goto cmd_err;
22	-#endif
23	}
24
25	if (brq.cmd.error \|\| brq.stop.error \|\| brq.data.error) {
26	--- a/drivers/mmc/core/core.c
27	+++ b/drivers/mmc/core/core.c
28	@@ -37,6 +37,9 @@
29	#include "sd_ops.h"
30	#include "sdio_ops.h"
31
32	+/* scott.trace */
33	+//#define MMC_DEBUG
34	+
35	static struct workqueue_struct *workqueue;
36
37	/*
38	@@ -90,17 +93,30 @@ void mmc_request_done(struct mmc_host *h
39	cmd->error = 0;
40	host->ops->request(host, mrq);
41	} else {
42	+#if defined(CONFIG_LEDS_CLASS) \|\| defined(CONFIG_LEDS_CLASS_MODULE)
43	led_trigger_event(host->led, LED_OFF);
44	+#endif
45
46	pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
47	mmc_hostname(host), cmd->opcode, err,
48	cmd->resp[0], cmd->resp[1],
49	cmd->resp[2], cmd->resp[3]);
50	+#ifdef MMC_DEBUG
51	+ printk("[MMC_DEBUG] %s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
52	+ mmc_hostname(host), cmd->opcode, err,
53	+ cmd->resp[0], cmd->resp[1],
54	+ cmd->resp[2], cmd->resp[3]);
55	+#endif
56
57	if (mrq->data) {
58	pr_debug("%s: %d bytes transferred: %d\n",
59	mmc_hostname(host),
60	mrq->data->bytes_xfered, mrq->data->error);
61	+#ifdef MMC_DEBUG
62	+ printk("[MMC_DEBUG] %s: %d bytes transferred: %d\n",
63	+ mmc_hostname(host),
64	+ mrq->data->bytes_xfered, mrq->data->error);
65	+#endif
66	}
67
68	if (mrq->stop) {
69	@@ -109,6 +125,13 @@ void mmc_request_done(struct mmc_host *h
70	mrq->stop->error,
71	mrq->stop->resp[0], mrq->stop->resp[1],
72	mrq->stop->resp[2], mrq->stop->resp[3]);
73	+#ifdef MMC_DEBUG
74	+ printk("[MMC_DEBUG] %s: (CMD%u): %d: %08x %08x %08x %08x\n",
75	+ mmc_hostname(host), mrq->stop->opcode,
76	+ mrq->stop->error,
77	+ mrq->stop->resp[0], mrq->stop->resp[1],
78	+ mrq->stop->resp[2], mrq->stop->resp[3]);
79	+#endif
80	}
81
82	if (mrq->done)
83	@@ -129,6 +152,11 @@ mmc_start_request(struct mmc_host *host,
84	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
85	mmc_hostname(host), mrq->cmd->opcode,
86	mrq->cmd->arg, mrq->cmd->flags);
87	+#ifdef MMC_DEBUG
88	+ printk("[MMC_DEBUG] %s: starting CMD%u arg %08x flags %08x\n",
89	+ mmc_hostname(host), mrq->cmd->opcode,
90	+ mrq->cmd->arg, mrq->cmd->flags);
91	+#endif
92
93	if (mrq->data) {
94	pr_debug("%s: blksz %d blocks %d flags %08x "
95	@@ -137,17 +165,32 @@ mmc_start_request(struct mmc_host *host,
96	mrq->data->blocks, mrq->data->flags,
97	mrq->data->timeout_ns / 1000000,
98	mrq->data->timeout_clks);
99	+#ifdef MMC_DEBUG
100	+ printk("[MMC_DEBUG] %s: blksz %d blocks %d flags %08x "
101	+ "tsac %d ms nsac %d\n",
102	+ mmc_hostname(host), mrq->data->blksz,
103	+ mrq->data->blocks, mrq->data->flags,
104	+ mrq->data->timeout_ns / 1000000,
105	+ mrq->data->timeout_clks);
106	+#endif
107	}
108
109	if (mrq->stop) {
110	pr_debug("%s: CMD%u arg %08x flags %08x\n",
111	mmc_hostname(host), mrq->stop->opcode,
112	mrq->stop->arg, mrq->stop->flags);
113	+#ifdef MMC_DEBUG
114	+ printk("[MMC_DEBUG] %s: CMD%u arg %08x flags %08x\n",
115	+ mmc_hostname(host), mrq->stop->opcode,
116	+ mrq->stop->arg, mrq->stop->flags);
117	+#endif
118	}
119
120	WARN_ON(!host->claimed);
121
122	+#if defined(CONFIG_LEDS_CLASS) \|\| defined(CONFIG_LEDS_CLASS_MODULE)
123	led_trigger_event(host->led, LED_FULL);
124	+#endif
125
126	mrq->cmd->error = 0;
127	mrq->cmd->mrq = mrq;
128	@@ -286,9 +329,9 @@ void mmc_set_data_timeout(struct mmc_dat
129	* The limit is really 250 ms, but that is
130	* insufficient for some crappy cards.
131	*/
132	- limit_us = 300000;
133	+ limit_us = 500000;
134	else
135	- limit_us = 100000;
136	+ limit_us = 200000;
137
138	/*
139	* SDHC cards always use these fixed values.
140	@@ -344,6 +387,101 @@ unsigned int mmc_align_data_size(struct
141	EXPORT_SYMBOL(mmc_align_data_size);
142
143	/**
144	+ * mmc_host_enable - enable a host.
145	+ * @host: mmc host to enable
146	+ *
147	+ * Hosts that support power saving can use the 'enable' and 'disable'
148	+ * methods to exit and enter power saving states. For more information
149	+ * see comments for struct mmc_host_ops.
150	+ */
151	+int mmc_host_enable(struct mmc_host *host)
152	+{
153	+ if (!(host->caps & MMC_CAP_DISABLE))
154	+ return 0;
155	+
156	+ if (host->en_dis_recurs)
157	+ return 0;
158	+
159	+ if (host->nesting_cnt++)
160	+ return 0;
161	+
162	+ cancel_delayed_work_sync(&host->disable);
163	+
164	+ if (host->enabled)
165	+ return 0;
166	+
167	+ if (host->ops->enable) {
168	+ int err;
169	+
170	+ host->en_dis_recurs = 1;
171	+ err = host->ops->enable(host);
172	+ host->en_dis_recurs = 0;
173	+
174	+ if (err) {
175	+ pr_debug("%s: enable error %d\n",
176	+ mmc_hostname(host), err);
177	+ return err;
178	+ }
179	+ }
180	+ host->enabled = 1;
181	+ return 0;
182	+}
183	+EXPORT_SYMBOL(mmc_host_enable);
184	+
185	+static int mmc_host_do_disable(struct mmc_host *host, int lazy)
186	+{
187	+ if (host->ops->disable) {
188	+ int err;
189	+
190	+ host->en_dis_recurs = 1;
191	+ err = host->ops->disable(host, lazy);
192	+ host->en_dis_recurs = 0;
193	+
194	+ if (err < 0) {
195	+ pr_debug("%s: disable error %d\n",
196	+ mmc_hostname(host), err);
197	+ return err;
198	+ }
199	+ if (err > 0) {
200	+ unsigned long delay = msecs_to_jiffies(err);
201	+
202	+ mmc_schedule_delayed_work(&host->disable, delay);
203	+ }
204	+ }
205	+ host->enabled = 0;
206	+ return 0;
207	+}
208	+
209	+/**
210	+ * mmc_host_disable - disable a host.
211	+ * @host: mmc host to disable
212	+ *
213	+ * Hosts that support power saving can use the 'enable' and 'disable'
214	+ * methods to exit and enter power saving states. For more information
215	+ * see comments for struct mmc_host_ops.
216	+ */
217	+int mmc_host_disable(struct mmc_host *host)
218	+{
219	+ int err;
220	+
221	+ if (!(host->caps & MMC_CAP_DISABLE))
222	+ return 0;
223	+
224	+ if (host->en_dis_recurs)
225	+ return 0;
226	+
227	+ if (--host->nesting_cnt)
228	+ return 0;
229	+
230	+ if (!host->enabled)
231	+ return 0;
232	+
233	+ err = mmc_host_do_disable(host, 0);
234	+ return err;
235	+}
236	+EXPORT_SYMBOL(mmc_host_disable);
237	+
238	+/**
239	* __mmc_claim_host - exclusively claim a host
240	* @host: mmc host to claim
241	* @abort: whether or not the operation should be aborted
242	@@ -366,25 +504,111 @@ int __mmc_claim_host(struct mmc_host *ho
243	while (1) {
244	set_current_state(TASK_UNINTERRUPTIBLE);
245	stop = abort ? atomic_read(abort) : 0;
246	- if (stop \|\| !host->claimed)
247	+ if (stop \|\| !host->claimed \|\| host->claimer == current)
248	break;
249	spin_unlock_irqrestore(&host->lock, flags);
250	schedule();
251	spin_lock_irqsave(&host->lock, flags);
252	}
253	set_current_state(TASK_RUNNING);
254	- if (!stop)
255	+ if (!stop) {
256	host->claimed = 1;
257	- else
258	+ host->claimer = current;
259	+ host->claim_cnt += 1;
260	+ } else
261	wake_up(&host->wq);
262	spin_unlock_irqrestore(&host->lock, flags);
263	remove_wait_queue(&host->wq, &wait);
264	+ if (!stop)
265	+ mmc_host_enable(host);
266	return stop;
267	}
268
269	EXPORT_SYMBOL(__mmc_claim_host);
270
271	/**
272	+ * mmc_try_claim_host - try exclusively to claim a host
273	+ * @host: mmc host to claim
274	+ *
275	+ * Returns %1 if the host is claimed, %0 otherwise.
276	+ */
277	+int mmc_try_claim_host(struct mmc_host *host)
278	+{
279	+ int claimed_host = 0;
280	+ unsigned long flags;
281	+
282	+ spin_lock_irqsave(&host->lock, flags);
283	+ if (!host->claimed \|\| host->claimer == current) {
284	+ host->claimed = 1;
285	+ host->claimer = current;
286	+ host->claim_cnt += 1;
287	+ claimed_host = 1;
288	+ }
289	+ spin_unlock_irqrestore(&host->lock, flags);
290	+ return claimed_host;
291	+}
292	+EXPORT_SYMBOL(mmc_try_claim_host);
293	+
294	+static void mmc_do_release_host(struct mmc_host *host)
295	+{
296	+ unsigned long flags;
297	+
298	+ spin_lock_irqsave(&host->lock, flags);
299	+ if (--host->claim_cnt) {
300	+ /* Release for nested claim */
301	+ spin_unlock_irqrestore(&host->lock, flags);
302	+ } else {
303	+ host->claimed = 0;
304	+ host->claimer = NULL;
305	+ spin_unlock_irqrestore(&host->lock, flags);
306	+ wake_up(&host->wq);
307	+ }
308	+}
309	+
310	+void mmc_host_deeper_disable(struct work_struct *work)
311	+{
312	+ struct mmc_host *host =
313	+ container_of(work, struct mmc_host, disable.work);
314	+
315	+ /* If the host is claimed then we do not want to disable it anymore */
316	+ if (!mmc_try_claim_host(host))
317	+ return;
318	+ mmc_host_do_disable(host, 1);
319	+ mmc_do_release_host(host);
320	+}
321	+
322	+/**
323	+ * mmc_host_lazy_disable - lazily disable a host.
324	+ * @host: mmc host to disable
325	+ *
326	+ * Hosts that support power saving can use the 'enable' and 'disable'
327	+ * methods to exit and enter power saving states. For more information
328	+ * see comments for struct mmc_host_ops.
329	+ */
330	+int mmc_host_lazy_disable(struct mmc_host *host)
331	+{
332	+ if (!(host->caps & MMC_CAP_DISABLE))
333	+ return 0;
334	+
335	+ if (host->en_dis_recurs)
336	+ return 0;
337	+
338	+ if (--host->nesting_cnt)
339	+ return 0;
340	+
341	+ if (!host->enabled)
342	+ return 0;
343	+
344	+ if (host->disable_delay) {
345	+ mmc_schedule_delayed_work(&host->disable,
346	+ msecs_to_jiffies(host->disable_delay));
347	+ return 0;
348	+ } else
349	+ return mmc_host_do_disable(host, 1);
350	+}
351	+EXPORT_SYMBOL(mmc_host_lazy_disable);
352	+
353	+/**
354	* mmc_release_host - release a host
355	* @host: mmc host to release
356	*
357	@@ -393,15 +617,11 @@ EXPORT_SYMBOL(__mmc_claim_host);
358	*/
359	void mmc_release_host(struct mmc_host *host)
360	{
361	- unsigned long flags;
362	-
363	WARN_ON(!host->claimed);
364
365	- spin_lock_irqsave(&host->lock, flags);
366	- host->claimed = 0;
367	- spin_unlock_irqrestore(&host->lock, flags);
368	+ mmc_host_lazy_disable(host);
369
370	- wake_up(&host->wq);
371	+ mmc_do_release_host(host);
372	}
373
374	EXPORT_SYMBOL(mmc_release_host);
375	@@ -687,7 +907,13 @@ void mmc_set_timing(struct mmc_host *hos
376	*/
377	static void mmc_power_up(struct mmc_host *host)
378	{
379	- int bit = fls(host->ocr_avail) - 1;
380	+ int bit;
381	+
382	+ /* If ocr is set, we use it */
383	+ if (host->ocr)
384	+ bit = ffs(host->ocr) - 1;
385	+ else
386	+ bit = fls(host->ocr_avail) - 1;
387
388	host->ios.vdd = bit;
389	if (mmc_host_is_spi(host)) {
390	@@ -947,6 +1173,8 @@ void mmc_stop_host(struct mmc_host *host
391	spin_unlock_irqrestore(&host->lock, flags);
392	#endif
393
394	+ if (host->caps & MMC_CAP_DISABLE)
395	+ cancel_delayed_work(&host->disable);
396	cancel_delayed_work(&host->detect);
397	mmc_flush_scheduled_work();
398
399	@@ -958,6 +1186,8 @@ void mmc_stop_host(struct mmc_host *host
400	mmc_claim_host(host);
401	mmc_detach_bus(host);
402	mmc_release_host(host);
403	+ mmc_bus_put(host);
404	+ return;
405	}
406	mmc_bus_put(host);
407
408	@@ -966,6 +1196,80 @@ void mmc_stop_host(struct mmc_host *host
409	mmc_power_off(host);
410	}
411
412	+void mmc_power_save_host(struct mmc_host *host)
413	+{
414	+ mmc_bus_get(host);
415	+
416	+ if (!host->bus_ops \|\| host->bus_dead \|\| !host->bus_ops->power_restore) {
417	+ mmc_bus_put(host);
418	+ return;
419	+ }
420	+
421	+ if (host->bus_ops->power_save)
422	+ host->bus_ops->power_save(host);
423	+
424	+ mmc_bus_put(host);
425	+
426	+ mmc_power_off(host);
427	+}
428	+EXPORT_SYMBOL(mmc_power_save_host);
429	+
430	+void mmc_power_restore_host(struct mmc_host *host)
431	+{
432	+ mmc_bus_get(host);
433	+
434	+ if (!host->bus_ops \|\| host->bus_dead \|\| !host->bus_ops->power_restore) {
435	+ mmc_bus_put(host);
436	+ return;
437	+ }
438	+
439	+ mmc_power_up(host);
440	+ host->bus_ops->power_restore(host);
441	+
442	+ mmc_bus_put(host);
443	+}
444	+EXPORT_SYMBOL(mmc_power_restore_host);
445	+
446	+int mmc_card_awake(struct mmc_host *host)
447	+{
448	+ int err = -ENOSYS;
449	+
450	+ mmc_bus_get(host);
451	+
452	+ if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
453	+ err = host->bus_ops->awake(host);
454	+
455	+ mmc_bus_put(host);
456	+
457	+ return err;
458	+}
459	+EXPORT_SYMBOL(mmc_card_awake);
460	+
461	+int mmc_card_sleep(struct mmc_host *host)
462	+{
463	+ int err = -ENOSYS;
464	+
465	+ mmc_bus_get(host);
466	+
467	+ if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
468	+ err = host->bus_ops->sleep(host);
469	+
470	+ mmc_bus_put(host);
471	+
472	+ return err;
473	+}
474	+EXPORT_SYMBOL(mmc_card_sleep);
475	+
476	+int mmc_card_can_sleep(struct mmc_host *host)
477	+{
478	+ struct mmc_card *card = host->card;
479	+
480	+ if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3)
481	+ return 1;
482	+ return 0;
483	+}
484	+EXPORT_SYMBOL(mmc_card_can_sleep);
485	+
486	#ifdef CONFIG_PM
487
488	/**
489	@@ -975,27 +1279,36 @@ void mmc_stop_host(struct mmc_host *host
490	*/
491	int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
492	{
493	+ int err = 0;
494	+
495	+ if (host->caps & MMC_CAP_DISABLE)
496	+ cancel_delayed_work(&host->disable);
497	cancel_delayed_work(&host->detect);
498	mmc_flush_scheduled_work();
499
500	mmc_bus_get(host);
501	if (host->bus_ops && !host->bus_dead) {
502	if (host->bus_ops->suspend)
503	- host->bus_ops->suspend(host);
504	- if (!host->bus_ops->resume) {
505	+ err = host->bus_ops->suspend(host);
506	+ if (err == -ENOSYS \|\| !host->bus_ops->resume) {
507	+ /*
508	+ * We simply "remove" the card in this case.
509	+ * It will be redetected on resume.
510	+ */
511	if (host->bus_ops->remove)
512	host->bus_ops->remove(host);
513	-
514	mmc_claim_host(host);
515	mmc_detach_bus(host);
516	mmc_release_host(host);
517	+ err = 0;
518	}
519	}
520	mmc_bus_put(host);
521
522	- mmc_power_off(host);
523	+ if (!err)
524	+ mmc_power_off(host);
525
526	- return 0;
527	+ return err;
528	}
529
530	EXPORT_SYMBOL(mmc_suspend_host);
531	@@ -1006,12 +1319,26 @@ EXPORT_SYMBOL(mmc_suspend_host);
532	*/
533	int mmc_resume_host(struct mmc_host *host)
534	{
535	+ int err = 0;
536	+
537	mmc_bus_get(host);
538	if (host->bus_ops && !host->bus_dead) {
539	mmc_power_up(host);
540	mmc_select_voltage(host, host->ocr);
541	BUG_ON(!host->bus_ops->resume);
542	- host->bus_ops->resume(host);
543	+ err = host->bus_ops->resume(host);
544	+ if (err) {
545	+ printk(KERN_WARNING "%s: error %d during resume "
546	+ "(card was removed?)\n",
547	+ mmc_hostname(host), err);
548	+ if (host->bus_ops->remove)
549	+ host->bus_ops->remove(host);
550	+ mmc_claim_host(host);
551	+ mmc_detach_bus(host);
552	+ mmc_release_host(host);
553	+ /* no need to bother upper layers */
554	+ err = 0;
555	+ }
556	}
557	mmc_bus_put(host);
558
559	@@ -1021,7 +1348,7 @@ int mmc_resume_host(struct mmc_host *hos
560	*/
561	mmc_detect_change(host, 1);
562
563	- return 0;
564	+ return err;
565	}
566
567	EXPORT_SYMBOL(mmc_resume_host);
568	--- a/drivers/mmc/core/core.h
569	+++ b/drivers/mmc/core/core.h
570	@@ -16,10 +16,14 @@
571	#define MMC_CMD_RETRIES 3
572
573	struct mmc_bus_ops {
574	+ int (awake)(struct mmc_host );
575	+ int (sleep)(struct mmc_host );
576	void (remove)(struct mmc_host );
577	void (detect)(struct mmc_host );
578	- void (suspend)(struct mmc_host );
579	- void (resume)(struct mmc_host );
580	+ int (suspend)(struct mmc_host );
581	+ int (resume)(struct mmc_host );
582	+ void (power_save)(struct mmc_host );
583	+ void (power_restore)(struct mmc_host );
584	};
585
586	void mmc_attach_bus(struct mmc_host host, const struct mmc_bus_ops ops);
587	--- a/drivers/mmc/core/debugfs.c
588	+++ b/drivers/mmc/core/debugfs.c
589	@@ -240,7 +240,7 @@ static int mmc_ext_csd_release(struct in
590	return 0;
591	}
592
593	-static struct file_operations mmc_dbg_ext_csd_fops = {
594	+static const struct file_operations mmc_dbg_ext_csd_fops = {
595	.open = mmc_ext_csd_open,
596	.read = mmc_ext_csd_read,
597	.release = mmc_ext_csd_release,
598	--- a/drivers/mmc/core/host.c
599	+++ b/drivers/mmc/core/host.c
600	@@ -83,6 +83,7 @@ struct mmc_host *mmc_alloc_host(int extr
601	spin_lock_init(&host->lock);
602	init_waitqueue_head(&host->wq);
603	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
604	+ INIT_DELAYED_WORK_DEFERRABLE(&host->disable, mmc_host_deeper_disable);
605
606	/*
607	* By default, hosts do not support SGIO or large requests.
608	--- a/drivers/mmc/core/host.h
609	+++ b/drivers/mmc/core/host.h
610	@@ -14,5 +14,7 @@
611	int mmc_register_host_class(void);
612	void mmc_unregister_host_class(void);
613
614	+void mmc_host_deeper_disable(struct work_struct *work);
615	+
616	#endif
617
618	--- a/drivers/mmc/core/mmc.c
619	+++ b/drivers/mmc/core/mmc.c
620	@@ -160,7 +160,6 @@ static int mmc_read_ext_csd(struct mmc_c
621	{
622	int err;
623	u8 *ext_csd;
624	- unsigned int ext_csd_struct;
625
626	BUG_ON(!card);
627
628	@@ -207,16 +206,16 @@ static int mmc_read_ext_csd(struct mmc_c
629	goto out;
630	}
631
632	- ext_csd_struct = ext_csd[EXT_CSD_REV];
633	- if (ext_csd_struct > 3) {
634	+ card->ext_csd.rev = ext_csd[EXT_CSD_REV];
635	+ if (card->ext_csd.rev > 3) {
636	printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
637	"version %d\n", mmc_hostname(card->host),
638	- ext_csd_struct);
639	+ card->ext_csd.rev);
640	err = -EINVAL;
641	goto out;
642	}
643
644	- if (ext_csd_struct >= 2) {
645	+ if (card->ext_csd.rev >= 2) {
646	card->ext_csd.sectors =
647	ext_csd[EXT_CSD_SEC_CNT + 0] << 0 \|
648	ext_csd[EXT_CSD_SEC_CNT + 1] << 8 \|
649	@@ -241,6 +240,15 @@ static int mmc_read_ext_csd(struct mmc_c
650	goto out;
651	}
652
653	+ if (card->ext_csd.rev >= 3) {
654	+ u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
655	+
656	+ /* Sleep / awake timeout in 100ns units */
657	+ if (sa_shift > 0 && sa_shift <= 0x17)
658	+ card->ext_csd.sa_timeout =
659	+ 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
660	+ }
661	+
662	out:
663	kfree(ext_csd);
664
665	@@ -276,7 +284,7 @@ static struct attribute_group mmc_std_at
666	.attrs = mmc_std_attrs,
667	};
668
669	-static struct attribute_group *mmc_attr_groups[] = {
670	+static const struct attribute_group *mmc_attr_groups[] = {
671	&mmc_std_attr_group,
672	NULL,
673	};
674	@@ -408,12 +416,17 @@ static int mmc_init_card(struct mmc_host
675	(host->caps & MMC_CAP_MMC_HIGHSPEED)) {
676	err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
677	EXT_CSD_HS_TIMING, 1);
678	- if (err)
679	+ if (err && err != -EBADMSG)
680	goto free_card;
681
682	- mmc_card_set_highspeed(card);
683	-
684	- mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
685	+ if (err) {
686	+ printk(KERN_WARNING "%s: switch to highspeed failed\n",
687	+ mmc_hostname(card->host));
688	+ err = 0;
689	+ } else {
690	+ mmc_card_set_highspeed(card);
691	+ mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
692	+ }
693	}
694
695	/*
696	@@ -448,10 +461,17 @@ static int mmc_init_card(struct mmc_host
697	err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
698	EXT_CSD_BUS_WIDTH, ext_csd_bit);
699
700	- if (err)
701	+ if (err && err != -EBADMSG)
702	goto free_card;
703
704	- mmc_set_bus_width(card->host, bus_width);
705	+ if (err) {
706	+ printk(KERN_WARNING "%s: switch to bus width %d "
707	+ "failed\n", mmc_hostname(card->host),
708	+ 1 << bus_width);
709	+ err = 0;
710	+ } else {
711	+ mmc_set_bus_width(card->host, bus_width);
712	+ }
713	}
714
715	if (!oldcard)
716	@@ -507,12 +527,10 @@ static void mmc_detect(struct mmc_host *
717	}
718	}
719
720	-#ifdef CONFIG_MMC_UNSAFE_RESUME
721	-
722	/*
723	* Suspend callback from host.
724	*/
725	-static void mmc_suspend(struct mmc_host *host)
726	+static int mmc_suspend(struct mmc_host *host)
727	{
728	BUG_ON(!host);
729	BUG_ON(!host->card);
730	@@ -522,6 +540,8 @@ static void mmc_suspend(struct mmc_host
731	mmc_deselect_cards(host);
732	host->card->state &= ~MMC_STATE_HIGHSPEED;
733	mmc_release_host(host);
734	+
735	+ return 0;
736	}
737
738	/*
739	@@ -530,7 +550,7 @@ static void mmc_suspend(struct mmc_host
740	* This function tries to determine if the same card is still present
741	* and, if so, restore all state to it.
742	*/
743	-static void mmc_resume(struct mmc_host *host)
744	+static int mmc_resume(struct mmc_host *host)
745	{
746	int err;
747
748	@@ -541,30 +561,99 @@ static void mmc_resume(struct mmc_host *
749	err = mmc_init_card(host, host->ocr, host->card);
750	mmc_release_host(host);
751
752	- if (err) {
753	- mmc_remove(host);
754	+ return err;
755	+}
756
757	- mmc_claim_host(host);
758	- mmc_detach_bus(host);
759	- mmc_release_host(host);
760	+static void mmc_power_restore(struct mmc_host *host)
761	+{
762	+ host->card->state &= ~MMC_STATE_HIGHSPEED;
763	+ mmc_claim_host(host);
764	+ mmc_init_card(host, host->ocr, host->card);
765	+ mmc_release_host(host);
766	+}
767	+
768	+static int mmc_sleep(struct mmc_host *host)
769	+{
770	+ struct mmc_card *card = host->card;
771	+ int err = -ENOSYS;
772	+
773	+ if (card && card->ext_csd.rev >= 3) {
774	+ err = mmc_card_sleepawake(host, 1);
775	+ if (err < 0)
776	+ pr_debug("%s: Error %d while putting card into sleep",
777	+ mmc_hostname(host), err);
778	}
779
780	+ return err;
781	}
782
783	-#else
784	+static int mmc_awake(struct mmc_host *host)
785	+{
786	+ struct mmc_card *card = host->card;
787	+ int err = -ENOSYS;
788
789	-#define mmc_suspend NULL
790	-#define mmc_resume NULL
791	+ if (card && card->ext_csd.rev >= 3) {
792	+ err = mmc_card_sleepawake(host, 0);
793	+ if (err < 0)
794	+ pr_debug("%s: Error %d while awaking sleeping card",
795	+ mmc_hostname(host), err);
796	+ }
797
798	-#endif
799	+ return err;
800	+}
801	+
802	+#ifdef CONFIG_MMC_UNSAFE_RESUME
803	+
804	+static const struct mmc_bus_ops mmc_ops = {
805	+ .awake = mmc_awake,
806	+ .sleep = mmc_sleep,
807	+ .remove = mmc_remove,
808	+ .detect = mmc_detect,
809	+ .suspend = mmc_suspend,
810	+ .resume = mmc_resume,
811	+ .power_restore = mmc_power_restore,
812	+};
813	+
814	+static void mmc_attach_bus_ops(struct mmc_host *host)
815	+{
816	+ mmc_attach_bus(host, &mmc_ops);
817	+}
818	+
819	+#else
820
821	static const struct mmc_bus_ops mmc_ops = {
822	+ .awake = mmc_awake,
823	+ .sleep = mmc_sleep,
824	+ .remove = mmc_remove,
825	+ .detect = mmc_detect,
826	+ .suspend = NULL,
827	+ .resume = NULL,
828	+ .power_restore = mmc_power_restore,
829	+};
830	+
831	+static const struct mmc_bus_ops mmc_ops_unsafe = {
832	+ .awake = mmc_awake,
833	+ .sleep = mmc_sleep,
834	.remove = mmc_remove,
835	.detect = mmc_detect,
836	.suspend = mmc_suspend,
837	.resume = mmc_resume,
838	+ .power_restore = mmc_power_restore,
839	};
840
841	+static void mmc_attach_bus_ops(struct mmc_host *host)
842	+{
843	+ const struct mmc_bus_ops *bus_ops;
844	+
845	+ if (host->caps & MMC_CAP_NONREMOVABLE)
846	+ bus_ops = &mmc_ops_unsafe;
847	+ else
848	+ bus_ops = &mmc_ops;
849	+ mmc_attach_bus(host, bus_ops);
850	+}
851	+
852	+#endif
853	+
854	/*
855	* Starting point for MMC card init.
856	*/
857	@@ -575,7 +664,7 @@ int mmc_attach_mmc(struct mmc_host *host
858	BUG_ON(!host);
859	WARN_ON(!host->claimed);
860
861	- mmc_attach_bus(host, &mmc_ops);
862	+ mmc_attach_bus_ops(host);
863
864	/*
865	* We need to get OCR a different way for SPI.
866	--- a/drivers/mmc/core/mmc_ops.c
867	+++ b/drivers/mmc/core/mmc_ops.c
868	@@ -57,6 +57,42 @@ int mmc_deselect_cards(struct mmc_host *
869	return _mmc_select_card(host, NULL);
870	}
871
872	+int mmc_card_sleepawake(struct mmc_host *host, int sleep)
873	+{
874	+ struct mmc_command cmd;
875	+ struct mmc_card *card = host->card;
876	+ int err;
877	+
878	+ if (sleep)
879	+ mmc_deselect_cards(host);
880	+
881	+ memset(&cmd, 0, sizeof(struct mmc_command));
882	+
883	+ cmd.opcode = MMC_SLEEP_AWAKE;
884	+ cmd.arg = card->rca << 16;
885	+ if (sleep)
886	+ cmd.arg \|= 1 << 15;
887	+
888	+ cmd.flags = MMC_RSP_R1B \| MMC_CMD_AC;
889	+ err = mmc_wait_for_cmd(host, &cmd, 0);
890	+ if (err)
891	+ return err;
892	+
893	+ /*
894	+ * If the host does not wait while the card signals busy, then we will
895	+ * will have to wait the sleep/awake timeout. Note, we cannot use the
896	+ * SEND_STATUS command to poll the status because that command (and most
897	+ * others) is invalid while the card sleeps.
898	+ */
899	+ if (!(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
900	+ mmc_delay(DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000));
901	+
902	+ if (!sleep)
903	+ err = mmc_select_card(card);
904	+
905	+ return err;
906	+}
907	+
908	int mmc_go_idle(struct mmc_host *host)
909	{
910	int err;
911	@@ -354,6 +390,7 @@ int mmc_switch(struct mmc_card *card, u8
912	{
913	int err;
914	struct mmc_command cmd;
915	+ u32 status;
916
917	BUG_ON(!card);
918	BUG_ON(!card->host);
919	@@ -371,6 +408,28 @@ int mmc_switch(struct mmc_card *card, u8
920	if (err)
921	return err;
922
923	+ /* Must check status to be sure of no errors */
924	+ do {
925	+ err = mmc_send_status(card, &status);
926	+ if (err)
927	+ return err;
928	+ if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
929	+ break;
930	+ if (mmc_host_is_spi(card->host))
931	+ break;
932	+ } while (R1_CURRENT_STATE(status) == 7);
933	+
934	+ if (mmc_host_is_spi(card->host)) {
935	+ if (status & R1_SPI_ILLEGAL_COMMAND)
936	+ return -EBADMSG;
937	+ } else {
938	+ if (status & 0xFDFFA000)
939	+ printk(KERN_WARNING "%s: unexpected status %#x after "
940	+ "switch", mmc_hostname(card->host), status);
941	+ if (status & R1_SWITCH_ERROR)
942	+ return -EBADMSG;
943	+ }
944	+
945	return 0;
946	}
947
948	--- a/drivers/mmc/core/mmc_ops.h
949	+++ b/drivers/mmc/core/mmc_ops.h
950	@@ -25,6 +25,7 @@ int mmc_send_status(struct mmc_card *car
951	int mmc_send_cid(struct mmc_host host, u32 cid);
952	int mmc_spi_read_ocr(struct mmc_host host, int highcap, u32 ocrp);
953	int mmc_spi_set_crc(struct mmc_host *host, int use_crc);
954	+int mmc_card_sleepawake(struct mmc_host *host, int sleep);
955
956	#endif
957
958	--- a/drivers/mmc/core/sd.c
959	+++ b/drivers/mmc/core/sd.c
960	@@ -314,7 +314,7 @@ static struct attribute_group sd_std_att
961	.attrs = sd_std_attrs,
962	};
963
964	-static struct attribute_group *sd_attr_groups[] = {
965	+static const struct attribute_group *sd_attr_groups[] = {
966	&sd_std_attr_group,
967	NULL,
968	};
969	@@ -561,12 +561,10 @@ static void mmc_sd_detect(struct mmc_hos
970	}
971	}
972
973	-#ifdef CONFIG_MMC_UNSAFE_RESUME
974	-
975	/*
976	* Suspend callback from host.
977	*/
978	-static void mmc_sd_suspend(struct mmc_host *host)
979	+static int mmc_sd_suspend(struct mmc_host *host)
980	{
981	BUG_ON(!host);
982	BUG_ON(!host->card);
983	@@ -576,6 +574,8 @@ static void mmc_sd_suspend(struct mmc_ho
984	mmc_deselect_cards(host);
985	host->card->state &= ~MMC_STATE_HIGHSPEED;
986	mmc_release_host(host);
987	+
988	+ return 0;
989	}
990
991	/*
992	@@ -584,7 +584,7 @@ static void mmc_sd_suspend(struct mmc_ho
993	* This function tries to determine if the same card is still present
994	* and, if so, restore all state to it.
995	*/
996	-static void mmc_sd_resume(struct mmc_host *host)
997	+static int mmc_sd_resume(struct mmc_host *host)
998	{
999	int err;
1000
1001	@@ -595,30 +595,63 @@ static void mmc_sd_resume(struct mmc_hos
1002	err = mmc_sd_init_card(host, host->ocr, host->card);
1003	mmc_release_host(host);
1004
1005	- if (err) {
1006	- mmc_sd_remove(host);
1007	-
1008	- mmc_claim_host(host);
1009	- mmc_detach_bus(host);
1010	- mmc_release_host(host);
1011	- }
1012	+ return err;
1013	+}
1014
1015	+static void mmc_sd_power_restore(struct mmc_host *host)
1016	+{
1017	+ host->card->state &= ~MMC_STATE_HIGHSPEED;
1018	+ mmc_claim_host(host);
1019	+ mmc_sd_init_card(host, host->ocr, host->card);
1020	+ mmc_release_host(host);
1021	}
1022
1023	-#else
1024	+#ifdef CONFIG_MMC_UNSAFE_RESUME
1025
1026	-#define mmc_sd_suspend NULL
1027	-#define mmc_sd_resume NULL
1028	+static const struct mmc_bus_ops mmc_sd_ops = {
1029	+ .remove = mmc_sd_remove,
1030	+ .detect = mmc_sd_detect,
1031	+ .suspend = mmc_sd_suspend,
1032	+ .resume = mmc_sd_resume,
1033	+ .power_restore = mmc_sd_power_restore,
1034	+};
1035
1036	-#endif
1037	+static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1038	+{
1039	+ mmc_attach_bus(host, &mmc_sd_ops);
1040	+}
1041	+
1042	+#else
1043
1044	static const struct mmc_bus_ops mmc_sd_ops = {
1045	.remove = mmc_sd_remove,
1046	.detect = mmc_sd_detect,
1047	+ .suspend = NULL,
1048	+ .resume = NULL,
1049	+ .power_restore = mmc_sd_power_restore,
1050	+};
1051	+
1052	+static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
1053	+ .remove = mmc_sd_remove,
1054	+ .detect = mmc_sd_detect,
1055	.suspend = mmc_sd_suspend,
1056	.resume = mmc_sd_resume,
1057	+ .power_restore = mmc_sd_power_restore,
1058	};
1059
1060	+static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1061	+{
1062	+ const struct mmc_bus_ops *bus_ops;
1063	+
1064	+ if (host->caps & MMC_CAP_NONREMOVABLE)
1065	+ bus_ops = &mmc_sd_ops_unsafe;
1066	+ else
1067	+ bus_ops = &mmc_sd_ops;
1068	+ mmc_attach_bus(host, bus_ops);
1069	+}
1070	+
1071	+#endif
1072	+
1073	/*
1074	* Starting point for SD card init.
1075	*/
1076	@@ -629,7 +662,7 @@ int mmc_attach_sd(struct mmc_host *host,
1077	BUG_ON(!host);
1078	WARN_ON(!host->claimed);
1079
1080	- mmc_attach_bus(host, &mmc_sd_ops);
1081	+ mmc_sd_attach_bus_ops(host);
1082
1083	/*
1084	* We need to get OCR a different way for SPI.
1085	--- a/drivers/mmc/core/sdio_bus.c
1086	+++ b/drivers/mmc/core/sdio_bus.c
1087	@@ -20,9 +20,6 @@
1088	#include "sdio_cis.h"
1089	#include "sdio_bus.h"
1090
1091	-#define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev)
1092	-#define to_sdio_driver(d) container_of(d, struct sdio_driver, drv)
1093	-
1094	/* show configuration fields */
1095	#define sdio_config_attr(field, format_string) \
1096	static ssize_t \
1097	@@ -251,12 +248,15 @@ int sdio_add_func(struct sdio_func *func
1098	/*
1099	* Unregister a SDIO function with the driver model, and
1100	* (eventually) free it.
1101	+ * This function can be called through error paths where sdio_add_func() was
1102	+ * never executed (because a failure occurred at an earlier point).
1103	*/
1104	void sdio_remove_func(struct sdio_func *func)
1105	{
1106	- if (sdio_func_present(func))
1107	- device_del(&func->dev);
1108	+ if (!sdio_func_present(func))
1109	+ return;
1110
1111	+ device_del(&func->dev);
1112	put_device(&func->dev);
1113	}
1114
1115	--- a/drivers/mmc/core/sdio.c
1116	+++ b/drivers/mmc/core/sdio.c
1117	@@ -165,6 +165,29 @@ static int sdio_enable_wide(struct mmc_c
1118	}
1119
1120	/*
1121	+ * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
1122	+ * of the card. This may be required on certain setups of boards,
1123	+ * controllers and embedded sdio device which do not need the card's
1124	+ * pull-up. As a result, card detection is disabled and power is saved.
1125	+ */
1126	+static int sdio_disable_cd(struct mmc_card *card)
1127	+{
1128	+ int ret;
1129	+ u8 ctrl;
1130	+
1131	+ if (!card->cccr.disable_cd)
1132	+ return 0;
1133	+
1134	+ ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
1135	+ if (ret)
1136	+ return ret;
1137	+
1138	+ ctrl \|= SDIO_BUS_CD_DISABLE;
1139	+
1140	+ return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
1141	+}
1142	+
1143	+/*
1144	* Test if the card supports high-speed mode and, if so, switch to it.
1145	*/
1146	static int sdio_enable_hs(struct mmc_card *card)
1147	@@ -195,6 +218,135 @@ static int sdio_enable_hs(struct mmc_car
1148	}
1149
1150	/*
1151	+ * Handle the detection and initialisation of a card.
1152	+ *
1153	+ * In the case of a resume, "oldcard" will contain the card
1154	+ * we're trying to reinitialise.
1155	+ */
1156	+static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
1157	+ struct mmc_card *oldcard)
1158	+{
1159	+ struct mmc_card *card;
1160	+ int err;
1161	+
1162	+ BUG_ON(!host);
1163	+ WARN_ON(!host->claimed);
1164	+
1165	+ /*
1166	+ * Inform the card of the voltage
1167	+ */
1168	+ err = mmc_send_io_op_cond(host, host->ocr, &ocr);
1169	+ if (err)
1170	+ goto err;
1171	+
1172	+ /*
1173	+ * For SPI, enable CRC as appropriate.
1174	+ */
1175	+ if (mmc_host_is_spi(host)) {
1176	+ err = mmc_spi_set_crc(host, use_spi_crc);
1177	+ if (err)
1178	+ goto err;
1179	+ }
1180	+
1181	+ /*
1182	+ * Allocate card structure.
1183	+ */
1184	+ card = mmc_alloc_card(host, NULL);
1185	+ if (IS_ERR(card)) {
1186	+ err = PTR_ERR(card);
1187	+ goto err;
1188	+ }
1189	+
1190	+ card->type = MMC_TYPE_SDIO;
1191	+
1192	+ /*
1193	+ * For native busses: set card RCA and quit open drain mode.
1194	+ */
1195	+ if (!mmc_host_is_spi(host)) {
1196	+ err = mmc_send_relative_addr(host, &card->rca);
1197	+ if (err)
1198	+ goto remove;
1199	+
1200	+ mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1201	+ }
1202	+
1203	+ /*
1204	+ * Select card, as all following commands rely on that.
1205	+ */
1206	+ if (!mmc_host_is_spi(host)) {
1207	+ err = mmc_select_card(card);
1208	+ if (err)
1209	+ goto remove;
1210	+ }
1211	+
1212	+ /*
1213	+ * Read the common registers.
1214	+ */
1215	+ err = sdio_read_cccr(card);
1216	+ if (err)
1217	+ goto remove;
1218	+
1219	+ /*
1220	+ * Read the common CIS tuples.
1221	+ */
1222	+ err = sdio_read_common_cis(card);
1223	+ if (err)
1224	+ goto remove;
1225	+
1226	+ if (oldcard) {
1227	+ int same = (card->cis.vendor == oldcard->cis.vendor &&
1228	+ card->cis.device == oldcard->cis.device);
1229	+ mmc_remove_card(card);
1230	+ if (!same) {
1231	+ err = -ENOENT;
1232	+ goto err;
1233	+ }
1234	+ card = oldcard;
1235	+ return 0;
1236	+ }
1237	+
1238	+ /*
1239	+ * Switch to high-speed (if supported).
1240	+ */
1241	+ err = sdio_enable_hs(card);
1242	+ if (err)
1243	+ goto remove;
1244	+
1245	+ /*
1246	+ * Change to the card's maximum speed.
1247	+ */
1248	+ if (mmc_card_highspeed(card)) {
1249	+ /*
1250	+ * The SDIO specification doesn't mention how
1251	+ * the CIS transfer speed register relates to
1252	+ * high-speed, but it seems that 50 MHz is
1253	+ * mandatory.
1254	+ */
1255	+ mmc_set_clock(host, 50000000);
1256	+ } else {
1257	+ mmc_set_clock(host, card->cis.max_dtr);
1258	+ }
1259	+
1260	+ /*
1261	+ * Switch to wider bus (if supported).
1262	+ */
1263	+ err = sdio_enable_wide(card);
1264	+ if (err)
1265	+ goto remove;
1266	+
1267	+ if (!oldcard)
1268	+ host->card = card;
1269	+ return 0;
1270	+
1271	+remove:
1272	+ if (!oldcard)
1273	+ mmc_remove_card(card);
1274	+
1275	+err:
1276	+ return err;
1277	+}
1278	+
1279	+/*
1280	* Host is being removed. Free up the current card.
1281	*/
1282	static void mmc_sdio_remove(struct mmc_host *host)
1283	@@ -243,10 +395,77 @@ static void mmc_sdio_detect(struct mmc_h
1284	}
1285	}
1286
1287	+/*
1288	+ * SDIO suspend. We need to suspend all functions separately.
1289	+ * Therefore all registered functions must have drivers with suspend
1290	+ * and resume methods. Failing that we simply remove the whole card.
1291	+ */
1292	+static int mmc_sdio_suspend(struct mmc_host *host)
1293	+{
1294	+ int i, err = 0;
1295	+
1296	+ for (i = 0; i < host->card->sdio_funcs; i++) {
1297	+ struct sdio_func *func = host->card->sdio_func[i];
1298	+ if (func && sdio_func_present(func) && func->dev.driver) {
1299	+ const struct dev_pm_ops *pmops = func->dev.driver->pm;
1300	+ if (!pmops \|\| !pmops->suspend \|\| !pmops->resume) {
1301	+ /* force removal of entire card in that case */
1302	+ err = -ENOSYS;
1303	+ } else
1304	+ err = pmops->suspend(&func->dev);
1305	+ if (err)
1306	+ break;
1307	+ }
1308	+ }
1309	+ while (err && --i >= 0) {
1310	+ struct sdio_func *func = host->card->sdio_func[i];
1311	+ if (func && sdio_func_present(func) && func->dev.driver) {
1312	+ const struct dev_pm_ops *pmops = func->dev.driver->pm;
1313	+ pmops->resume(&func->dev);
1314	+ }
1315	+ }
1316	+
1317	+ return err;
1318	+}
1319	+
1320	+static int mmc_sdio_resume(struct mmc_host *host)
1321	+{
1322	+ int i, err;
1323	+
1324	+ BUG_ON(!host);
1325	+ BUG_ON(!host->card);
1326	+
1327	+ /* Basic card reinitialization. */
1328	+ mmc_claim_host(host);
1329	+ err = mmc_sdio_init_card(host, host->ocr, host->card);
1330	+ mmc_release_host(host);
1331	+
1332	+ /*
1333	+ * If the card looked to be the same as before suspending, then
1334	+ * we proceed to resume all card functions. If one of them returns
1335	+ * an error then we simply return that error to the core and the
1336	+ * card will be redetected as new. It is the responsibility of
1337	+ * the function driver to perform further tests with the extra
1338	+ * knowledge it has of the card to confirm the card is indeed the
1339	+ * same as before suspending (same MAC address for network cards,
1340	+ * etc.) and return an error otherwise.
1341	+ */
1342	+ for (i = 0; !err && i < host->card->sdio_funcs; i++) {
1343	+ struct sdio_func *func = host->card->sdio_func[i];
1344	+ if (func && sdio_func_present(func) && func->dev.driver) {
1345	+ const struct dev_pm_ops *pmops = func->dev.driver->pm;
1346	+ err = pmops->resume(&func->dev);
1347	+ }
1348	+ }
1349	+
1350	+ return err;
1351	+}
1352
1353	static const struct mmc_bus_ops mmc_sdio_ops = {
1354	.remove = mmc_sdio_remove,
1355	.detect = mmc_sdio_detect,
1356	+ .suspend = mmc_sdio_suspend,
1357	+ .resume = mmc_sdio_resume,
1358	};
1359
1360
1361	@@ -275,13 +494,6 @@ int mmc_attach_sdio(struct mmc_host *hos
1362	ocr &= ~0x7F;
1363	}
1364
1365	- if (ocr & MMC_VDD_165_195) {
1366	- printk(KERN_WARNING "%s: SDIO card claims to support the "
1367	- "incompletely defined 'low voltage range'. This "
1368	- "will be ignored.\n", mmc_hostname(host));
1369	- ocr &= ~MMC_VDD_165_195;
1370	- }
1371	-
1372	host->ocr = mmc_select_voltage(host, ocr);
1373
1374	/*
1375	@@ -293,108 +505,31 @@ int mmc_attach_sdio(struct mmc_host *hos
1376	}
1377
1378	/*
1379	- * Inform the card of the voltage
1380	+ * Detect and init the card.
1381	*/
1382	- err = mmc_send_io_op_cond(host, host->ocr, &ocr);
1383	+ err = mmc_sdio_init_card(host, host->ocr, NULL);
1384	if (err)
1385	goto err;
1386	-
1387	- /*
1388	- * For SPI, enable CRC as appropriate.
1389	- */
1390	- if (mmc_host_is_spi(host)) {
1391	- err = mmc_spi_set_crc(host, use_spi_crc);
1392	- if (err)
1393	- goto err;
1394	- }
1395	+ card = host->card;
1396
1397	/*
1398	* The number of functions on the card is encoded inside
1399	* the ocr.
1400	*/
1401	funcs = (ocr & 0x70000000) >> 28;
1402	+ card->sdio_funcs = 0;
1403
1404	/*
1405	- * Allocate card structure.
1406	- */
1407	- card = mmc_alloc_card(host, NULL);
1408	- if (IS_ERR(card)) {
1409	- err = PTR_ERR(card);
1410	- goto err;
1411	- }
1412	-
1413	- card->type = MMC_TYPE_SDIO;
1414	- card->sdio_funcs = funcs;
1415	-
1416	- host->card = card;
1417	-
1418	- /*
1419	- * For native busses: set card RCA and quit open drain mode.
1420	+ * If needed, disconnect card detection pull-up resistor.
1421	*/
1422	- if (!mmc_host_is_spi(host)) {
1423	- err = mmc_send_relative_addr(host, &card->rca);
1424	- if (err)
1425	- goto remove;
1426	-
1427	- mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1428	- }
1429	-
1430	- /*
1431	- * Select card, as all following commands rely on that.
1432	- */
1433	- if (!mmc_host_is_spi(host)) {
1434	- err = mmc_select_card(card);
1435	- if (err)
1436	- goto remove;
1437	- }
1438	-
1439	- /*
1440	- * Read the common registers.
1441	- */
1442	- err = sdio_read_cccr(card);
1443	- if (err)
1444	- goto remove;
1445	-
1446	- /*
1447	- * Read the common CIS tuples.
1448	- */
1449	- err = sdio_read_common_cis(card);
1450	- if (err)
1451	- goto remove;
1452	-
1453	- /*
1454	- * Switch to high-speed (if supported).
1455	- */
1456	- err = sdio_enable_hs(card);
1457	- if (err)
1458	- goto remove;
1459	-
1460	- /*
1461	- * Change to the card's maximum speed.
1462	- */
1463	- if (mmc_card_highspeed(card)) {
1464	- /*
1465	- * The SDIO specification doesn't mention how
1466	- * the CIS transfer speed register relates to
1467	- * high-speed, but it seems that 50 MHz is
1468	- * mandatory.
1469	- */
1470	- mmc_set_clock(host, 50000000);
1471	- } else {
1472	- mmc_set_clock(host, card->cis.max_dtr);
1473	- }
1474	-
1475	- /*
1476	- * Switch to wider bus (if supported).
1477	- */
1478	- err = sdio_enable_wide(card);
1479	+ err = sdio_disable_cd(card);
1480	if (err)
1481	goto remove;
1482
1483	/*
1484	* Initialize (but don't add) all present functions.
1485	*/
1486	- for (i = 0;i < funcs;i++) {
1487	+ for (i = 0; i < funcs; i++, card->sdio_funcs++) {
1488	err = sdio_init_func(host->card, i + 1);
1489	if (err)
1490	goto remove;
1491	--- a/drivers/mmc/core/sdio_cis.c
1492	+++ b/drivers/mmc/core/sdio_cis.c
1493	@@ -29,6 +29,8 @@ static int cistpl_vers_1(struct mmc_card
1494	unsigned i, nr_strings;
1495	char *buffer, string;
1496
1497	+ /* Find all null-terminated (including zero length) strings in
1498	+ the TPLLV1_INFO field. Trailing garbage is ignored. */
1499	buf += 2;
1500	size -= 2;
1501
1502	@@ -39,11 +41,8 @@ static int cistpl_vers_1(struct mmc_card
1503	if (buf[i] == 0)
1504	nr_strings++;
1505	}
1506	-
1507	- if (buf[i-1] != '\0') {
1508	- printk(KERN_WARNING "SDIO: ignoring broken CISTPL_VERS_1\n");
1509	+ if (nr_strings == 0)
1510	return 0;
1511	- }
1512
1513	size = i;
1514
1515	@@ -98,6 +97,22 @@ static const unsigned char speed_val[16]
1516	static const unsigned int speed_unit[8] =
1517	{ 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };
1518
1519	+/* FUNCE tuples with these types get passed to SDIO drivers */
1520	+static const unsigned char funce_type_whitelist[] = {
1521	+ 4 /* CISTPL_FUNCE_LAN_NODE_ID used in Broadcom cards */
1522	+};
1523	+
1524	+static int cistpl_funce_whitelisted(unsigned char type)
1525	+{
1526	+ int i;
1527	+
1528	+ for (i = 0; i < ARRAY_SIZE(funce_type_whitelist); i++) {
1529	+ if (funce_type_whitelist[i] == type)
1530	+ return 1;
1531	+ }
1532	+ return 0;
1533	+}
1534	+
1535	static int cistpl_funce_common(struct mmc_card *card,
1536	const unsigned char *buf, unsigned size)
1537	{
1538	@@ -120,6 +135,10 @@ static int cistpl_funce_func(struct sdio
1539	unsigned vsn;
1540	unsigned min_size;
1541
1542	+ /* let SDIO drivers take care of whitelisted FUNCE tuples */
1543	+ if (cistpl_funce_whitelisted(buf[0]))
1544	+ return -EILSEQ;
1545	+
1546	vsn = func->card->cccr.sdio_vsn;
1547	min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;
1548
1549	@@ -154,13 +173,12 @@ static int cistpl_funce(struct mmc_card
1550	else
1551	ret = cistpl_funce_common(card, buf, size);
1552
1553	- if (ret) {
1554	+ if (ret && ret != -EILSEQ) {
1555	printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u "
1556	"type %u\n", mmc_hostname(card->host), size, buf[0]);
1557	- return ret;
1558	}
1559
1560	- return 0;
1561	+ return ret;
1562	}
1563
1564	typedef int (tpl_parse_t)(struct mmc_card , struct sdio_func ,
1565	@@ -253,21 +271,12 @@ static int sdio_read_cis(struct mmc_card
1566	for (i = 0; i < ARRAY_SIZE(cis_tpl_list); i++)
1567	if (cis_tpl_list[i].code == tpl_code)
1568	break;
1569	- if (i >= ARRAY_SIZE(cis_tpl_list)) {
1570	- /* this tuple is unknown to the core */
1571	- this->next = NULL;
1572	- this->code = tpl_code;
1573	- this->size = tpl_link;
1574	- *prev = this;
1575	- prev = &this->next;
1576	- printk(KERN_DEBUG
1577	- "%s: queuing CIS tuple 0x%02x length %u\n",
1578	- mmc_hostname(card->host), tpl_code, tpl_link);
1579	- } else {
1580	+ if (i < ARRAY_SIZE(cis_tpl_list)) {
1581	const struct cis_tpl *tpl = cis_tpl_list + i;
1582	if (tpl_link < tpl->min_size) {
1583	printk(KERN_ERR
1584	- "%s: bad CIS tuple 0x%02x (length = %u, expected >= %u)\n",
1585	+ "%s: bad CIS tuple 0x%02x"
1586	+ " (length = %u, expected >= %u)\n",
1587	mmc_hostname(card->host),
1588	tpl_code, tpl_link, tpl->min_size);
1589	ret = -EINVAL;
1590	@@ -275,7 +284,30 @@ static int sdio_read_cis(struct mmc_card
1591	ret = tpl->parse(card, func,
1592	this->data, tpl_link);
1593	}
1594	- kfree(this);
1595	+ /*
1596	+ * We don't need the tuple anymore if it was
1597	+ * successfully parsed by the SDIO core or if it is
1598	+ * not going to be parsed by SDIO drivers.
1599	+ */
1600	+ if (!ret \|\| ret != -EILSEQ)
1601	+ kfree(this);
1602	+ } else {
1603	+ /* unknown tuple */
1604	+ ret = -EILSEQ;
1605	+ }
1606	+
1607	+ if (ret == -EILSEQ) {
1608	+ /* this tuple is unknown to the core or whitelisted */
1609	+ this->next = NULL;
1610	+ this->code = tpl_code;
1611	+ this->size = tpl_link;
1612	+ *prev = this;
1613	+ prev = &this->next;
1614	+ printk(KERN_DEBUG
1615	+ "%s: queuing CIS tuple 0x%02x length %u\n",
1616	+ mmc_hostname(card->host), tpl_code, tpl_link);
1617	+ /* keep on analyzing tuples */
1618	+ ret = 0;
1619	}
1620
1621	ptr += tpl_link;
1622	--- a/drivers/mmc/core/sdio_io.c
1623	+++ b/drivers/mmc/core/sdio_io.c
1624	@@ -624,7 +624,7 @@ void sdio_f0_writeb(struct sdio_func *fu
1625
1626	BUG_ON(!func);
1627
1628	- if (addr < 0xF0 \|\| addr > 0xFF) {
1629	+ if ((addr < 0xF0 \|\| addr > 0xFF) && (!mmc_card_lenient_fn0(func->card))) {
1630	if (err_ret)
1631	*err_ret = -EINVAL;
1632	return;
1633	--- a/drivers/mmc/host/Kconfig
1634	+++ b/drivers/mmc/host/Kconfig
1635	@@ -55,6 +55,17 @@ config MMC_SDHCI_PCI
1636
1637	If unsure, say N.
1638
1639	+config MMC_SDHCI_CNS3XXX
1640	+ tristate "SDHCI support on CNS3XXX"
1641	+ depends on MMC_SDHCI && ARCH_CNS3XXX
1642	+ help
1643	+ This selects the Secure Digital Host Controller Interface (SDHCI)
1644	+ in Cavium Networks CNS3XXX SOCs.
1645	+
1646	+ If you have a controller with this interface, say Y or M here.
1647	+
1648	+ If unsure, say N.
1649	+
1650	config MMC_RICOH_MMC
1651	tristate "Ricoh MMC Controller Disabler (EXPERIMENTAL)"
1652	depends on MMC_SDHCI_PCI
1653	--- a/drivers/mmc/host/Makefile
1654	+++ b/drivers/mmc/host/Makefile
1655	@@ -12,6 +12,7 @@ obj-$(CONFIG_MMC_IMX) += imxmmc.o
1656	obj-$(CONFIG_MMC_MXC) += mxcmmc.o
1657	obj-$(CONFIG_MMC_SDHCI) += sdhci.o
1658	obj-$(CONFIG_MMC_SDHCI_PCI) += sdhci-pci.o
1659	+obj-$(CONFIG_MMC_SDHCI_CNS3XXX) += sdhci-cns3xxx.o
1660	obj-$(CONFIG_MMC_RICOH_MMC) += ricoh_mmc.o
1661	obj-$(CONFIG_MMC_SDHCI_OF) += sdhci-of.o
1662	obj-$(CONFIG_MMC_SDHCI_PLTFM) += sdhci-pltfm.o
1663	--- a/drivers/mmc/host/sdhci.c
1664	+++ b/drivers/mmc/host/sdhci.c
1665	@@ -27,6 +27,15 @@
1666
1667	#define DRIVER_NAME "sdhci"
1668
1669	+#define SDHCI_DEBUG
1670	+#undef SDHCI_DEBUG
1671	+
1672	+#ifdef SDHCI_DEBUG
1673	+#define sd_printk(x...) printk(x)
1674	+#else
1675	+#define sd_printk(x...) do { } while(0)
1676	+#endif
1677	+
1678	#define DBG(f, x...) \
1679	pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x)
1680
1681	@@ -43,6 +52,39 @@ static void sdhci_finish_data(struct sdh
1682	static void sdhci_send_command(struct sdhci_host , struct mmc_command );
1683	static void sdhci_finish_command(struct sdhci_host *);
1684
1685	+static void sdhci_dumpallregs(struct sdhci_host *host)
1686	+{
1687	+#ifdef SDHCI_DEBUG
1688	+ printk(" _______________________________________________\n");
1689	+
1690	+ printk(" 0x00: 0x%08x \| 0x04: 0x%08x\n", sdhci_readl(host, 0x00), sdhci_readl(host, 0x04));
1691	+ printk(" 0x08: 0x%08x \| 0x0C: 0x%08x\n", sdhci_readl(host, 0x08), sdhci_readl(host, 0x0C));
1692	+ printk(" 0x10: 0x%08x \| 0x14: 0x%08x\n", sdhci_readl(host, 0x10), sdhci_readl(host, 0x14));
1693	+ printk(" 0x18: 0x%08x \| 0x1C: 0x%08x\n", sdhci_readl(host, 0x18), sdhci_readl(host, 0x1C));
1694	+ printk(" -----------------\| 0x24: 0x%08x\n", sdhci_readl(host, 0x24));
1695	+ printk(" 0x28: 0x%08x \| 0x2C: 0x%08x\n", sdhci_readl(host, 0x28), sdhci_readl(host, 0x2C));
1696	+ printk(" 0x30: 0x%08x \| 0x34: 0x%08x\n", sdhci_readl(host, 0x30), sdhci_readl(host, 0x34));
1697	+ printk(" 0x38: 0x%08x \| 0x3C: 0x%08x\n", sdhci_readl(host, 0x38), sdhci_readl(host, 0x3C));
1698	+ printk(" 0x40: 0x%08x \| 0x44: 0x%08x\n", sdhci_readl(host, 0x40), sdhci_readl(host, 0x44));
1699	+ printk(" 0x48: 0x%08x \| 0x4C: 0x%08x\n", sdhci_readl(host, 0x48), sdhci_readl(host, 0x4C));
1700	+ printk(" 0x50: 0x%08x \| 0xFC: 0x%08x\n", sdhci_readl(host, 0x50), sdhci_readl(host, 0xFC));
1701	+//#else
1702	+ printk(KERN_DEBUG " _______________________________________________\n");
1703	+
1704	+ printk(KERN_DEBUG " 0x00: 0x%08x \| 0x04: 0x%08x\n", sdhci_readl(host, 0x00), sdhci_readl(host, 0x04));
1705	+ printk(KERN_DEBUG " 0x08: 0x%08x \| 0x0C: 0x%08x\n", sdhci_readl(host, 0x08), sdhci_readl(host, 0x0C));
1706	+ printk(KERN_DEBUG " 0x10: 0x%08x \| 0x14: 0x%08x\n", sdhci_readl(host, 0x10), sdhci_readl(host, 0x14));
1707	+ printk(KERN_DEBUG " 0x18: 0x%08x \| 0x1C: 0x%08x\n", sdhci_readl(host, 0x18), sdhci_readl(host, 0x1C));
1708	+ printk(KERN_DEBUG " -----------------\| 0x24: 0x%08x\n", sdhci_readl(host, 0x24));
1709	+ printk(KERN_DEBUG " 0x28: 0x%08x \| 0x2C: 0x%08x\n", sdhci_readl(host, 0x28), sdhci_readl(host, 0x2C));
1710	+ printk(KERN_DEBUG " 0x30: 0x%08x \| 0x34: 0x%08x\n", sdhci_readl(host, 0x30), sdhci_readl(host, 0x34));
1711	+ printk(KERN_DEBUG " 0x38: 0x%08x \| 0x3C: 0x%08x\n", sdhci_readl(host, 0x38), sdhci_readl(host, 0x3C));
1712	+ printk(KERN_DEBUG " 0x40: 0x%08x \| 0x44: 0x%08x\n", sdhci_readl(host, 0x40), sdhci_readl(host, 0x44));
1713	+ printk(KERN_DEBUG " 0x48: 0x%08x \| 0x4C: 0x%08x\n", sdhci_readl(host, 0x48), sdhci_readl(host, 0x4C));
1714	+ printk(KERN_DEBUG " 0x50: 0x%08x \| 0xFC: 0x%08x\n", sdhci_readl(host, 0x50), sdhci_readl(host, 0xFC));
1715	+#endif
1716	+}
1717	+
1718	static void sdhci_dumpregs(struct sdhci_host *host)
1719	{
1720	printk(KERN_DEBUG DRIVER_NAME ": ============== REGISTER DUMP ==============\n");
1721	@@ -591,6 +633,9 @@ static u8 sdhci_calc_timeout(struct sdhc
1722	target_timeout = data->timeout_ns / 1000 +
1723	data->timeout_clks / host->clock;
1724
1725	+ if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
1726	+ host->timeout_clk = host->clock / 1000;
1727	+
1728	/*
1729	* Figure out needed cycles.
1730	* We do this in steps in order to fit inside a 32 bit int.
1731	@@ -622,7 +667,7 @@ static u8 sdhci_calc_timeout(struct sdhc
1732	static void sdhci_set_transfer_irqs(struct sdhci_host *host)
1733	{
1734	u32 pio_irqs = SDHCI_INT_DATA_AVAIL \| SDHCI_INT_SPACE_AVAIL;
1735	- u32 dma_irqs = SDHCI_INT_DMA_END \| SDHCI_INT_ADMA_ERROR;
1736	+ u32 dma_irqs = SDHCI_INT_DMA_END \| SDHCI_INT_ACMD12ERR \| SDHCI_INT_ADMA_ERROR;
1737
1738	if (host->flags & SDHCI_REQ_USE_DMA)
1739	sdhci_clear_set_irqs(host, pio_irqs, dma_irqs);
1740	@@ -652,7 +697,7 @@ static void sdhci_prepare_data(struct sd
1741	count = sdhci_calc_timeout(host, data);
1742	sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
1743
1744	- if (host->flags & SDHCI_USE_DMA)
1745	+ if (host->flags & (SDHCI_USE_SDMA \| SDHCI_USE_ADMA))
1746	host->flags \|= SDHCI_REQ_USE_DMA;
1747
1748	/*
1749	@@ -736,11 +781,21 @@ static void sdhci_prepare_data(struct sd
1750	} else {
1751	int sg_cnt;
1752
1753	+ sd_printk("[SDHCI_DEBUG] dma_map_sg(), mmc_dev(host->mmc) = %p \n", mmc_dev(host->mmc));
1754	+ sd_printk("[SDHCI_DEBUG] dma_map_sg(), data->sg = %p \n", data->sg);
1755	+ sd_printk("[SDHCI_DEBUG] dma_map_sg(), data->sg_len = %d \n", data->sg_len);
1756	sg_cnt = dma_map_sg(mmc_dev(host->mmc),
1757	data->sg, data->sg_len,
1758	(data->flags & MMC_DATA_READ) ?
1759	DMA_FROM_DEVICE :
1760	DMA_TO_DEVICE);
1761	+ if (data->sg == NULL) {
1762	+ sd_printk("[SDHCI_DEBUG] dma_map_sg(), data->sg = (NULL) \n");
1763	+ return;
1764	+ }
1765	+ sd_printk("[SDHCI_DEBUG] dma_map_sg(), data->sg = %p \n", data->sg);
1766	+ sd_printk("[SDHCI_DEBUG] dma_map_sg(), sg_cnt = %d \n", sg_cnt);
1767	+
1768	if (sg_cnt == 0) {
1769	/*
1770	* This only happens when someone fed
1771	@@ -750,6 +805,7 @@ static void sdhci_prepare_data(struct sd
1772	host->flags &= ~SDHCI_REQ_USE_DMA;
1773	} else {
1774	WARN_ON(sg_cnt != 1);
1775	+ sd_printk("[SDHCI_DEBUG] sg_dma_address() => %08x \n", sg_dma_address(data->sg));
1776	sdhci_writel(host, sg_dma_address(data->sg),
1777	SDHCI_DMA_ADDRESS);
1778	}
1779	@@ -763,14 +819,32 @@ static void sdhci_prepare_data(struct sd
1780	*/
1781	if (host->version >= SDHCI_SPEC_200) {
1782	ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1783	+#ifdef SDHCI_USE_LEDS_CLASS
1784	+ ctrl \|= SDHCI_CTRL_LED;
1785	+#else
1786	+ ctrl &= ~SDHCI_CTRL_LED;
1787	+#endif
1788	ctrl &= ~SDHCI_CTRL_DMA_MASK;
1789	if ((host->flags & SDHCI_REQ_USE_DMA) &&
1790	(host->flags & SDHCI_USE_ADMA))
1791	ctrl \|= SDHCI_CTRL_ADMA32;
1792	else
1793	ctrl \|= SDHCI_CTRL_SDMA;
1794	+
1795	sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1796	- }
1797	+ } else if (host->version == SDHCI_SPEC_100) {
1798	+ ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1799	+#ifdef SDHCI_USE_LEDS_CLASS
1800	+ ctrl \|= SDHCI_CTRL_LED;
1801	+#else
1802	+ ctrl &= ~SDHCI_CTRL_LED;
1803	+#endif
1804	+ ctrl &= ~SDHCI_CTRL_DMA_MASK;
1805	+ if (host->flags & SDHCI_REQ_USE_DMA)
1806	+ ctrl \|= SDHCI_CTRL_SDMA;
1807	+
1808	+ sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1809	+ }
1810
1811	if (!(host->flags & SDHCI_REQ_USE_DMA)) {
1812	int flags;
1813	@@ -795,15 +869,26 @@ static void sdhci_set_transfer_mode(stru
1814	struct mmc_data *data)
1815	{
1816	u16 mode;
1817	+ u8 bgctrl;
1818
1819	if (data == NULL)
1820	return;
1821
1822	WARN_ON(!host->data);
1823
1824	+ bgctrl = sdhci_readb(host, SDHCI_BLOCK_GAP_CONTROL);
1825	+ if (host->quirks & SDHCI_QUIRK_READ_WAIT_CTRL)
1826	+ bgctrl \|= SDHCI_READ_WAIT_CTRL;
1827	+ sdhci_writeb(host, bgctrl, SDHCI_BLOCK_GAP_CONTROL);
1828	+
1829	mode = SDHCI_TRNS_BLK_CNT_EN;
1830	- if (data->blocks > 1)
1831	+
1832	+ if (data->blocks > 1) {
1833	mode \|= SDHCI_TRNS_MULTI;
1834	+
1835	+ if (host->quirks & SDHCI_QUIRK_AUTO_CMD12)
1836	+ mode \|= SDHCI_TRNS_ACMD12;
1837	+ }
1838	if (data->flags & MMC_DATA_READ)
1839	mode \|= SDHCI_TRNS_READ;
1840	if (host->flags & SDHCI_REQ_USE_DMA)
1841	@@ -812,6 +897,20 @@ static void sdhci_set_transfer_mode(stru
1842	sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
1843	}
1844
1845	+static void shdci_check_dma_overrun(struct sdhci_host host, struct mmc_data data)
1846	+{
1847	+ u32 dma_pos = sdhci_readl(host, SDHCI_DMA_ADDRESS);
1848	+ u32 dma_start = sg_dma_address(data->sg);
1849	+ u32 dma_end = dma_start + data->sg->length;
1850	+
1851	+ /* Test whether we ended up moving more data than was originally requested. */
1852	+ if (dma_pos <= dma_end)
1853	+ return;
1854	+
1855	+ printk(KERN_ERR "%s: dma overrun, dma %08x, req %08x..%08x\n",
1856	+ mmc_hostname(host->mmc), dma_pos, dma_start, dma_end);
1857	+}
1858	+
1859	static void sdhci_finish_data(struct sdhci_host *host)
1860	{
1861	struct mmc_data *data;
1862	@@ -825,6 +924,9 @@ static void sdhci_finish_data(struct sdh
1863	if (host->flags & SDHCI_USE_ADMA)
1864	sdhci_adma_table_post(host, data);
1865	else {
1866	+ shdci_check_dma_overrun(host, data);
1867	+
1868	+ sd_printk("[SDHCI_DEBUG] dma_unmap_sg(), data->sg_len = %d \n", data->sg_len);
1869	dma_unmap_sg(mmc_dev(host->mmc), data->sg,
1870	data->sg_len, (data->flags & MMC_DATA_READ) ?
1871	DMA_FROM_DEVICE : DMA_TO_DEVICE);
1872	@@ -866,12 +968,16 @@ static void sdhci_send_command(struct sd
1873
1874	WARN_ON(host->cmd);
1875
1876	+ sd_printk("[SDHCI_DEBUG] sdhci_send_command() \n");
1877	+
1878	/* Wait max 10 ms */
1879	timeout = 10;
1880
1881	mask = SDHCI_CMD_INHIBIT;
1882	if ((cmd->data != NULL) \|\| (cmd->flags & MMC_RSP_BUSY))
1883	mask \|= SDHCI_DATA_INHIBIT;
1884	+ if ((cmd->data != NULL))
1885	+ mask \|= SDHCI_DATA_INHIBIT;
1886
1887	/* We shouldn't wait for data inihibit for stop commands, even
1888	though they might use busy signaling */
1889	@@ -925,7 +1031,11 @@ static void sdhci_send_command(struct sd
1890	if (cmd->data)
1891	flags \|= SDHCI_CMD_DATA;
1892
1893	+ sd_printk("[SDHCI_DEBUG] sdhci_send_command() => %08x \n", SDHCI_MAKE_CMD(cmd->opcode, flags));
1894	+ sdhci_dumpallregs(host);
1895	sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
1896	+ sd_printk("[SDHCI_DEBUG] sdhci_send_command(): After issue command \n");
1897	+ sdhci_dumpallregs(host);
1898	}
1899
1900	static void sdhci_finish_command(struct sdhci_host *host)
1901	@@ -934,6 +1044,8 @@ static void sdhci_finish_command(struct
1902
1903	BUG_ON(host->cmd == NULL);
1904
1905	+ sd_printk("[SDHCI_DEBUG] sdhci_finish_command() \n");
1906	+
1907	if (host->cmd->flags & MMC_RSP_PRESENT) {
1908	if (host->cmd->flags & MMC_RSP_136) {
1909	/* CRC is stripped so we need to do some shifting. */
1910	@@ -991,8 +1103,8 @@ static void sdhci_set_clock(struct sdhci
1911	clk \|= SDHCI_CLOCK_INT_EN;
1912	sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1913
1914	- /* Wait max 10 ms */
1915	- timeout = 10;
1916	+ /* Wait max 20 ms */
1917	+ timeout = 20;
1918	while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
1919	& SDHCI_CLOCK_INT_STABLE)) {
1920	if (timeout == 0) {
1921	@@ -1154,6 +1266,12 @@ static void sdhci_set_ios(struct mmc_hos
1922	else
1923	ctrl &= ~SDHCI_CTRL_HISPD;
1924
1925	+#ifdef SDHCI_USE_LEDS_CLASS
1926	+ ctrl \|= SDHCI_CTRL_LED;
1927	+#else
1928	+ ctrl &= ~SDHCI_CTRL_LED;
1929	+#endif
1930	+
1931	sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1932
1933	/*
1934	@@ -1321,7 +1439,11 @@ static void sdhci_timeout_timer(unsigned
1935	if (host->mrq) {
1936	printk(KERN_ERR "%s: Timeout waiting for hardware "
1937	"interrupt.\n", mmc_hostname(host->mmc));
1938	+#ifdef SDHCI_DEBUG
1939	+ sdhci_dumpallregs(host);
1940	+#else
1941	sdhci_dumpregs(host);
1942	+#endif
1943
1944	if (host->data) {
1945	host->data->error = -ETIMEDOUT;
1946	@@ -1508,6 +1630,10 @@ static irqreturn_t sdhci_irq(int irq, vo
1947	DBG("*** %s got interrupt: 0x%08x\n",
1948	mmc_hostname(host->mmc), intmask);
1949
1950	+#ifdef SDHCI_DEBUG
1951	+ printk("*** %s got interrupt: 0x%08x\n", mmc_hostname(host->mmc), intmask);
1952	+#endif
1953	+
1954	if (intmask & (SDHCI_INT_CARD_INSERT \| SDHCI_INT_CARD_REMOVE)) {
1955	sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT \|
1956	SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
1957	@@ -1597,7 +1723,7 @@ int sdhci_resume_host(struct sdhci_host
1958	{
1959	int ret;
1960
1961	- if (host->flags & SDHCI_USE_DMA) {
1962	+ if (host->flags & (SDHCI_USE_SDMA \| SDHCI_USE_ADMA)) {
1963	if (host->ops->enable_dma)
1964	host->ops->enable_dma(host);
1965	}
1966	@@ -1678,23 +1804,20 @@ int sdhci_add_host(struct sdhci_host *ho
1967	caps = sdhci_readl(host, SDHCI_CAPABILITIES);
1968
1969	if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
1970	- host->flags \|= SDHCI_USE_DMA;
1971	- else if (!(caps & SDHCI_CAN_DO_DMA))
1972	- DBG("Controller doesn't have DMA capability\n");
1973	+ host->flags \|= SDHCI_USE_SDMA;
1974	+ else if (!(caps & SDHCI_CAN_DO_SDMA))
1975	+ DBG("Controller doesn't have SDMA capability\n");
1976	else
1977	- host->flags \|= SDHCI_USE_DMA;
1978	+ host->flags \|= SDHCI_USE_SDMA;
1979
1980	if ((host->quirks & SDHCI_QUIRK_BROKEN_DMA) &&
1981	- (host->flags & SDHCI_USE_DMA)) {
1982	+ (host->flags & SDHCI_USE_SDMA)) {
1983	DBG("Disabling DMA as it is marked broken\n");
1984	- host->flags &= ~SDHCI_USE_DMA;
1985	+ host->flags &= ~SDHCI_USE_SDMA;
1986	}
1987
1988	- if (host->flags & SDHCI_USE_DMA) {
1989	- if ((host->version >= SDHCI_SPEC_200) &&
1990	- (caps & SDHCI_CAN_DO_ADMA2))
1991	- host->flags \|= SDHCI_USE_ADMA;
1992	- }
1993	+ if ((host->version >= SDHCI_SPEC_200) && (caps & SDHCI_CAN_DO_ADMA2))
1994	+ host->flags \|= SDHCI_USE_ADMA;
1995
1996	if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
1997	(host->flags & SDHCI_USE_ADMA)) {
1998	@@ -1702,13 +1825,14 @@ int sdhci_add_host(struct sdhci_host *ho
1999	host->flags &= ~SDHCI_USE_ADMA;
2000	}
2001
2002	- if (host->flags & SDHCI_USE_DMA) {
2003	+ if (host->flags & (SDHCI_USE_SDMA \| SDHCI_USE_ADMA)) {
2004	if (host->ops->enable_dma) {
2005	if (host->ops->enable_dma(host)) {
2006	printk(KERN_WARNING "%s: No suitable DMA "
2007	"available. Falling back to PIO.\n",
2008	mmc_hostname(mmc));
2009	- host->flags &= ~(SDHCI_USE_DMA \| SDHCI_USE_ADMA);
2010	+ host->flags &=
2011	+ ~(SDHCI_USE_SDMA \| SDHCI_USE_ADMA);
2012	}
2013	}
2014	}
2015	@@ -1736,7 +1860,7 @@ int sdhci_add_host(struct sdhci_host *ho
2016	* mask, but PIO does not need the hw shim so we set a new
2017	* mask here in that case.
2018	*/
2019	- if (!(host->flags & SDHCI_USE_DMA)) {
2020	+ if (!(host->flags & (SDHCI_USE_SDMA \| SDHCI_USE_ADMA))) {
2021	host->dma_mask = DMA_BIT_MASK(64);
2022	mmc_dev(host->mmc)->dma_mask = &host->dma_mask;
2023	}
2024	@@ -1757,13 +1881,15 @@ int sdhci_add_host(struct sdhci_host *ho
2025	host->timeout_clk =
2026	(caps & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
2027	if (host->timeout_clk == 0) {
2028	- if (!host->ops->get_timeout_clock) {
2029	+ if (host->ops->get_timeout_clock) {
2030	+ host->timeout_clk = host->ops->get_timeout_clock(host);
2031	+ } else if (!(host->quirks &
2032	+ SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
2033	printk(KERN_ERR
2034	"%s: Hardware doesn't specify timeout clock "
2035	"frequency.\n", mmc_hostname(mmc));
2036	return -ENODEV;
2037	}
2038	- host->timeout_clk = host->ops->get_timeout_clock(host);
2039	}
2040	if (caps & SDHCI_TIMEOUT_CLK_UNIT)
2041	host->timeout_clk *= 1000;
2042	@@ -1772,7 +1898,8 @@ int sdhci_add_host(struct sdhci_host *ho
2043	* Set host parameters.
2044	*/
2045	mmc->ops = &sdhci_ops;
2046	- if (host->ops->get_min_clock)
2047	+ if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK &&
2048	+ host->ops->set_clock && host->ops->get_min_clock)
2049	mmc->f_min = host->ops->get_min_clock(host);
2050	else
2051	mmc->f_min = host->max_clk / 256;
2052	@@ -1810,7 +1937,7 @@ int sdhci_add_host(struct sdhci_host *ho
2053	*/
2054	if (host->flags & SDHCI_USE_ADMA)
2055	mmc->max_hw_segs = 128;
2056	- else if (host->flags & SDHCI_USE_DMA)
2057	+ else if (host->flags & SDHCI_USE_SDMA)
2058	mmc->max_hw_segs = 1;
2059	else /* PIO */
2060	mmc->max_hw_segs = 128;
2061	@@ -1893,10 +2020,10 @@ int sdhci_add_host(struct sdhci_host *ho
2062
2063	mmc_add_host(mmc);
2064
2065	- printk(KERN_INFO "%s: SDHCI controller on %s [%s] using %s%s\n",
2066	+ printk(KERN_INFO "%s: SDHCI controller on %s [%s] using %s\n",
2067	mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
2068	- (host->flags & SDHCI_USE_ADMA)?"A":"",
2069	- (host->flags & SDHCI_USE_DMA)?"DMA":"PIO");
2070	+ (host->flags & SDHCI_USE_ADMA) ? "ADMA" :
2071	+ (host->flags & SDHCI_USE_SDMA) ? "SDMA" : "PIO");
2072
2073	sdhci_enable_card_detection(host);
2074
2075	--- /dev/null
2076	+++ b/drivers/mmc/host/sdhci-cns3xxx.c
2077	@@ -0,0 +1,313 @@
2078	+/*******************************************************************************
2079	+ *
2080	+ * drivers/mmc/host/sdhci-cns3xxx.c
2081	+ *
2082	+ * SDHCI support for the CNS3XXX SOCs
2083	+ *
2084	+ * Author: Scott Shu
2085	+ *
2086	+ * Copyright (c) 2008 Cavium Networks
2087	+ *
2088	+ * This file is free software; you can redistribute it and/or modify
2089	+ * it under the terms of the GNU General Public License, Version 2, as
2090	+ * published by the Free Software Foundation.
2091	+ *
2092	+ * This file is distributed in the hope that it will be useful,
2093	+ * but AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty of
2094	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
2095	+ * NONINFRINGEMENT. See the GNU General Public License for more details.
2096	+ *
2097	+ * You should have received a copy of the GNU General Public License
2098	+ * along with this file; if not, write to the Free Software
2099	+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA or
2100	+ * visit http://www.gnu.org/licenses/.
2101	+ *
2102	+ * This file may also be available under a different license from Cavium.
2103	+ * Contact Cavium Networks for more information
2104	+ *
2105	+ ******************************************************************************/
2106	+
2107	+#include <linux/delay.h>
2108	+#include <linux/highmem.h>
2109	+#include <linux/platform_device.h>
2110	+#include <linux/dma-mapping.h>
2111	+
2112	+#include <linux/mmc/host.h>
2113	+
2114	+#include <asm/scatterlist.h>
2115	+#include <asm/io.h>
2116	+#include <linux/interrupt.h>
2117	+
2118	+#include <mach/sdhci.h>
2119	+#include <mach/pm.h>
2120	+
2121	+#include "sdhci.h"
2122	+
2123	+//#define DEBUG
2124	+
2125	+#define MAX_BUS_CLK (4)
2126	+
2127	+static unsigned __initdata use_dma = 0;
2128	+
2129	+struct sdhci_cns3xxx {
2130	+ struct sdhci_host *host;
2131	+ struct platform_device *pdev;
2132	+ struct resource *ioarea;
2133	+ struct cns3xxx_sdhci_platdata *pdata;
2134	+ struct clk *clk_io;
2135	+ struct clk *clk_bus[MAX_BUS_CLK];
2136	+};
2137	+
2138	+static unsigned int sdhci_cns3xxx_get_max_clk(struct sdhci_host *host)
2139	+{
2140	+ int clk = 50000000;
2141	+
2142	+ return clk;
2143	+}
2144	+
2145	+static unsigned int sdhci_cns3xxx_get_timeout_clk(struct sdhci_host *host)
2146	+{
2147	+ return sdhci_cns3xxx_get_max_clk(host) / 100000;
2148	+}
2149	+
2150	+/*
2151	+ * sdhci_cns3xxx_set_clock - callback on clock change
2152	+ *
2153	+ * When the card's clock is going to be changed, look at the new frequency
2154	+ * and find the best clock source to go with it.
2155	+ */
2156	+static void sdhci_cns3xxx_set_clock(struct sdhci_host *host, unsigned int clock)
2157	+{
2158	+ u16 clk;
2159	+ unsigned long timeout;
2160	+
2161	+ if (clock == host->clock)
2162	+ return;
2163	+
2164	+ sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
2165	+
2166	+ if (clock == 0)
2167	+ goto out;
2168	+#if 1
2169	+ clk = 0x03 << SDHCI_DIVIDER_SHIFT; /* base clock divided by 3 */
2170	+#else
2171	+ /* high speed mode or normal speed mode */
2172	+ if (0x4 & sdhci_readw(host, 0x28)) {
2173	+ clk = 0x03 << SDHCI_DIVIDER_SHIFT; /* base clock divided by 3 */
2174	+ } else {
2175	+ clk = 0x02 << SDHCI_DIVIDER_SHIFT; /* base clock divided by 4 */
2176	+ }
2177	+#endif
2178	+ clk \|= SDHCI_CLOCK_INT_EN;
2179	+ sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
2180	+
2181	+ timeout = 10;
2182	+ while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
2183	+ & SDHCI_CLOCK_INT_STABLE)) {
2184	+ if (timeout == 0) {
2185	+ return;
2186	+ }
2187	+ timeout--;
2188	+ mdelay(1);
2189	+ }
2190	+
2191	+ clk \|= SDHCI_CLOCK_CARD_EN;
2192	+ sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
2193	+
2194	+ host->timeout_clk = sdhci_cns3xxx_get_timeout_clk(host);
2195	+out:
2196	+ host->clock = clock;
2197	+}
2198	+
2199	+static struct sdhci_ops sdhci_cns3xxx_ops = {
2200	+ .get_max_clock = sdhci_cns3xxx_get_max_clk,
2201	+ .get_timeout_clock = sdhci_cns3xxx_get_timeout_clk,
2202	+ .set_clock = sdhci_cns3xxx_set_clock,
2203	+};
2204	+
2205	+static int __devinit sdhci_cns3xxx_probe(struct platform_device *pdev)
2206	+{
2207	+ struct cns3xxx_sdhci_platdata *pdata = pdev->dev.platform_data;
2208	+ struct device *dev = &pdev->dev;
2209	+ struct sdhci_host *host;
2210	+ struct sdhci_cns3xxx *sc;
2211	+ struct resource *res;
2212	+ int ret, irq;
2213	+
2214	+ if (!pdata) {
2215	+ dev_err(dev, "no device data specified\n");
2216	+ return -ENOENT;
2217	+ }
2218	+
2219	+ irq = platform_get_irq(pdev, 0);
2220	+ if (irq < 0) {
2221	+ dev_err(dev, "no irq specified\n");
2222	+ return irq;
2223	+ }
2224	+
2225	+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2226	+ if (!res) {
2227	+ dev_err(dev, "no memory specified\n");
2228	+ return -ENOENT;
2229	+ }
2230	+
2231	+ host = sdhci_alloc_host(dev, sizeof(*sc));
2232	+ if (IS_ERR(host)) {
2233	+ dev_err(dev, "sdhci_alloc_host() failed\n");
2234	+ return PTR_ERR(host);
2235	+ }
2236	+
2237	+ sc = sdhci_priv(host);
2238	+
2239	+ sc->host = host;
2240	+ sc->pdev = pdev;
2241	+ sc->pdata = pdata;
2242	+
2243	+ platform_set_drvdata(pdev, host);
2244	+
2245	+ sc->ioarea = request_mem_region(res->start, resource_size(res), mmc_hostname(host->mmc));
2246	+ if (!sc->ioarea) {
2247	+ dev_err(dev, "failed to reserve register area\n");
2248	+ ret = -ENXIO;
2249	+ goto err_req_regs;
2250	+ }
2251	+
2252	+ host->ioaddr = ioremap_nocache(res->start, resource_size(res));
2253	+ if (!host->ioaddr) {
2254	+ dev_err(dev, "failed to map registers\n");
2255	+ ret = -ENXIO;
2256	+ goto err_req_regs;
2257	+ }
2258	+
2259	+ host->hw_name = "cns3xxx";
2260	+ host->ops = &sdhci_cns3xxx_ops;
2261	+ host->quirks = 0;
2262	+ host->irq = irq;
2263	+
2264	+ if (use_dma != 1) {
2265	+ host->quirks \|= SDHCI_QUIRK_BROKEN_DMA;
2266	+ host->quirks \|= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK;
2267	+ } else {
2268	+ host->quirks \|= SDHCI_QUIRK_FORCE_DMA;
2269	+ host->quirks \|= SDHCI_QUIRK_BROKEN_ADMA;
2270	+ host->quirks \|= (SDHCI_QUIRK_32BIT_DMA_ADDR \| SDHCI_QUIRK_32BIT_DMA_SIZE);
2271	+ host->quirks \|= SDHCI_QUIRK_NO_BUSY_IRQ;
2272	+ //host->quirks \|= SDHCI_QUIRK_FORCE_BLK_SZ_2048;
2273	+ //host->quirks \|= SDHCI_QUIRK_NO_MULTIBLOCK;
2274	+ host->quirks \|= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK;
2275	+ host->quirks \|= SDHCI_QUIRK_AUTO_CMD12;
2276	+ host->quirks \|= SDHCI_QUIRK_READ_WAIT_CTRL;
2277	+ }
2278	+
2279	+ //host->quirks \|= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
2280	+
2281	+ host->quirks \|= SDHCI_QUIRK_NONSTANDARD_CLOCK;
2282	+
2283	+ host->quirks \|= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
2284	+
2285	+ ret = sdhci_add_host(host);
2286	+ if (ret) {
2287	+ dev_err(dev, "sdhci_add_host() failed (%d)\n", ret);
2288	+ goto err_add_host;
2289	+ }
2290	+
2291	+ return 0;
2292	+
2293	+err_add_host:
2294	+ free_irq(host->irq, host);
2295	+ iounmap(host->ioaddr);
2296	+ release_resource(sc->ioarea);
2297	+ kfree(sc->ioarea);
2298	+
2299	+err_req_regs:
2300	+ sdhci_free_host(host);
2301	+
2302	+ return ret;
2303	+}
2304	+
2305	+static int __devexit sdhci_cns3xxx_remove(struct platform_device *pdev)
2306	+{
2307	+ struct device *dev = &pdev->dev;
2308	+ struct sdhci_host *host = dev_get_drvdata(dev);
2309	+ struct resource *res;
2310	+
2311	+ pr_debug("%s: remove=%p\n", __func__, pdev);
2312	+
2313	+ sdhci_remove_host(host, 0);
2314	+ sdhci_free_host(host);
2315	+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2316	+ release_mem_region(res->start, resource_size(res));
2317	+
2318	+ return 0;
2319	+}
2320	+
2321	+#ifdef CONFIG_PM
2322	+
2323	+static int sdhci_cns3xxx_suspend(struct platform_device *dev, pm_message_t state)
2324	+{
2325	+
2326	+ return 0;
2327	+}
2328	+
2329	+static int sdhci_cns3xxx_resume(struct platform_device *dev)
2330	+{
2331	+
2332	+ return 0;
2333	+}
2334	+
2335	+#else
2336	+#define sdhci_cns3xxx_suspend NULL
2337	+#define sdhci_cns3xxx_resume NULL
2338	+#endif /* CONFIG_PM */
2339	+
2340	+static struct platform_driver sdhci_cns3xxx_driver = {
2341	+ .probe = sdhci_cns3xxx_probe,
2342	+ .remove = __devexit_p(sdhci_cns3xxx_remove),
2343	+ .suspend = sdhci_cns3xxx_suspend,
2344	+ .resume = sdhci_cns3xxx_resume,
2345	+ .driver = {
2346	+ .name = "cns3xxx-sdhci",
2347	+ .owner = THIS_MODULE,
2348	+ },
2349	+};
2350	+
2351	+static char banner[] __initdata = KERN_INFO "cns3xxx-sdhci, (c) 2009 Cavium Networks\n";
2352	+
2353	+static int __init sdhci_cns3xxx_init(void)
2354	+{
2355	+#ifdef CONFIG_SILICON
2356	+ unsigned long gpioapin = __raw_readl((void __iomem *)(CNS3XXX_MISC_BASE_VIRT + 0x0014));;
2357	+#else
2358	+ unsigned long status = __raw_readl((void __iomem *)(CNS3XXX_MISC_BASE_VIRT + 0x0700));
2359	+#endif
2360	+
2361	+ printk(banner);
2362	+
2363	+#ifdef CONFIG_SILICON
2364	+ /* MMC/SD pins share with GPIOA */
2365	+ __raw_writel(gpioapin \| (0x1fff0004), (void __iomem *)(CNS3XXX_MISC_BASE_VIRT + 0x0014));
2366	+ cns3xxx_pwr_clk_en(CNS3XXX_PWR_CLK_EN(SDIO));
2367	+ cns3xxx_pwr_soft_rst(CNS3XXX_PWR_SOFTWARE_RST(SDIO));
2368	+#else
2369	+ /* insert a delay on SDIO output interface (only for FPGA mode & high-speed mode) */
2370	+ __raw_writel(status \| (1 << 4), (void __iomem *)(CNS3XXX_MISC_BASE_VIRT + 0x0700));
2371	+#endif
2372	+ return platform_driver_register(&sdhci_cns3xxx_driver);
2373	+}
2374	+
2375	+static void __exit sdhci_cns3xxx_exit(void)
2376	+{
2377	+ platform_driver_unregister(&sdhci_cns3xxx_driver);
2378	+}
2379	+
2380	+module_init(sdhci_cns3xxx_init);
2381	+module_exit(sdhci_cns3xxx_exit);
2382	+
2383	+module_param(use_dma, uint, 0);
2384	+
2385	+MODULE_AUTHOR("Scott Shu");
2386	+MODULE_DESCRIPTION("Cavium Networks CNS3XXX SDHCI glue");
2387	+MODULE_LICENSE("GPL");
2388	+MODULE_ALIAS("platform:cns3xxx-sdhci");
2389	+
2390	+MODULE_PARM_DESC(use_dma, "Whether to use DMA or not. Default = 0");
2391	--- a/drivers/mmc/host/sdhci.h
2392	+++ b/drivers/mmc/host/sdhci.h
2393	@@ -8,6 +8,8 @@
2394	* the Free Software Foundation; either version 2 of the License, or (at
2395	* your option) any later version.
2396	*/
2397	+#ifndef __SDHCI_H
2398	+#define __SDHCI_H
2399
2400	#include <linux/scatterlist.h>
2401	#include <linux/compiler.h>
2402	@@ -78,6 +80,7 @@
2403	#define SDHCI_POWER_330 0x0E
2404
2405	#define SDHCI_BLOCK_GAP_CONTROL 0x2A
2406	+#define SDHCI_READ_WAIT_CTRL 0x04
2407
2408	#define SDHCI_WAKE_UP_CONTROL 0x2B
2409
2410	@@ -143,7 +146,7 @@
2411	#define SDHCI_CAN_DO_ADMA2 0x00080000
2412	#define SDHCI_CAN_DO_ADMA1 0x00100000
2413	#define SDHCI_CAN_DO_HISPD 0x00200000
2414	-#define SDHCI_CAN_DO_DMA 0x00400000
2415	+#define SDHCI_CAN_DO_SDMA 0x00400000
2416	#define SDHCI_CAN_VDD_330 0x01000000
2417	#define SDHCI_CAN_VDD_300 0x02000000
2418	#define SDHCI_CAN_VDD_180 0x04000000
2419	@@ -232,6 +235,12 @@ struct sdhci_host {
2420	#define SDHCI_QUIRK_FORCE_1_BIT_DATA (1<<22)
2421	/* Controller needs 10ms delay between applying power and clock */
2422	#define SDHCI_QUIRK_DELAY_AFTER_POWER (1<<23)
2423	+/* Controller uses SDCLK instead of TMCLK for data timeouts */
2424	+#define SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK (1<<24)
2425	+/* Controller uses Auto CMD12 */
2426	+#define SDHCI_QUIRK_AUTO_CMD12 (1<<25)
2427	+/* Controller uses read wait control protocol */
2428	+#define SDHCI_QUIRK_READ_WAIT_CTRL (1<<26)
2429
2430	int irq; /* Device IRQ */
2431	void __iomem * ioaddr; /* Mapped address */
2432	@@ -250,7 +259,7 @@ struct sdhci_host {
2433	spinlock_t lock; /* Mutex */
2434
2435	int flags; /* Host attributes */
2436	-#define SDHCI_USE_DMA (1<<0) /* Host is DMA capable */
2437	+#define SDHCI_USE_SDMA (1<<0) /* Host is SDMA capable */
2438	#define SDHCI_USE_ADMA (1<<1) /* Host is ADMA capable */
2439	#define SDHCI_REQ_USE_DMA (1<<2) /* Use DMA for this req. */
2440	#define SDHCI_DEVICE_DEAD (1<<3) /* Device unresponsive */
2441	@@ -406,3 +415,5 @@ extern void sdhci_remove_host(struct sdh
2442	extern int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state);
2443	extern int sdhci_resume_host(struct sdhci_host *host);
2444	#endif
2445	+
2446	+#endif /* __SDHCI_H */
2447	--- a/include/linux/mmc/card.h
2448	+++ b/include/linux/mmc/card.h
2449	@@ -40,6 +40,8 @@ struct mmc_csd {
2450	};
2451
2452	struct mmc_ext_csd {
2453	+ u8 rev;
2454	+ unsigned int sa_timeout; /* Units: 100ns */
2455	unsigned int hs_max_dtr;
2456	unsigned int sectors;
2457	};
2458	@@ -62,7 +64,8 @@ struct sdio_cccr {
2459	low_speed:1,
2460	wide_bus:1,
2461	high_power:1,
2462	- high_speed:1;
2463	+ high_speed:1,
2464	+ disable_cd:1;
2465	};
2466
2467	struct sdio_cis {
2468	@@ -94,6 +97,8 @@ struct mmc_card {
2469	#define MMC_STATE_READONLY (1<<1) /* card is read-only */
2470	#define MMC_STATE_HIGHSPEED (1<<2) /* card is in high speed mode */
2471	#define MMC_STATE_BLOCKADDR (1<<3) /* card uses block-addressing */
2472	+ unsigned int quirks; /* card quirks */
2473	+#define MMC_QUIRK_LENIENT_FN0 (1<<0) /* allow SDIO FN0 writes outside of the VS CCCR range */
2474
2475	u32 raw_cid[4]; /* raw card CID */
2476	u32 raw_csd[4]; /* raw card CSD */
2477	@@ -129,6 +134,11 @@ struct mmc_card {
2478	#define mmc_card_set_highspeed(c) ((c)->state \|= MMC_STATE_HIGHSPEED)
2479	#define mmc_card_set_blockaddr(c) ((c)->state \|= MMC_STATE_BLOCKADDR)
2480
2481	+static inline int mmc_card_lenient_fn0(const struct mmc_card *c)
2482	+{
2483	+ return c->quirks & MMC_QUIRK_LENIENT_FN0;
2484	+}
2485	+
2486	#define mmc_card_name(c) ((c)->cid.prod_name)
2487	#define mmc_card_id(c) (dev_name(&(c)->dev))
2488
2489	--- a/include/linux/mmc/core.h
2490	+++ b/include/linux/mmc/core.h
2491	@@ -139,6 +139,7 @@ extern unsigned int mmc_align_data_size(
2492
2493	extern int __mmc_claim_host(struct mmc_host host, atomic_t abort);
2494	extern void mmc_release_host(struct mmc_host *host);
2495	+extern int mmc_try_claim_host(struct mmc_host *host);
2496
2497	/**
2498	* mmc_claim_host - exclusively claim a host
2499	--- a/include/linux/mmc/host.h
2500	+++ b/include/linux/mmc/host.h
2501	@@ -11,6 +11,7 @@
2502	#define LINUX_MMC_HOST_H
2503
2504	#include <linux/leds.h>
2505	+#include <linux/sched.h>
2506
2507	#include <linux/mmc/core.h>
2508
2509	@@ -51,6 +52,35 @@ struct mmc_ios {
2510	};
2511
2512	struct mmc_host_ops {
2513	+ /*
2514	+ * Hosts that support power saving can use the 'enable' and 'disable'
2515	+ * methods to exit and enter power saving states. 'enable' is called
2516	+ * when the host is claimed and 'disable' is called (or scheduled with
2517	+ * a delay) when the host is released. The 'disable' is scheduled if
2518	+ * the disable delay set by 'mmc_set_disable_delay()' is non-zero,
2519	+ * otherwise 'disable' is called immediately. 'disable' may be
2520	+ * scheduled repeatedly, to permit ever greater power saving at the
2521	+ * expense of ever greater latency to re-enable. Rescheduling is
2522	+ * determined by the return value of the 'disable' method. A positive
2523	+ * value gives the delay in milliseconds.
2524	+ *
2525	+ * In the case where a host function (like set_ios) may be called
2526	+ * with or without the host claimed, enabling and disabling can be
2527	+ * done directly and will nest correctly. Call 'mmc_host_enable()' and
2528	+ * 'mmc_host_lazy_disable()' for this purpose, but note that these
2529	+ * functions must be paired.
2530	+ *
2531	+ * Alternatively, 'mmc_host_enable()' may be paired with
2532	+ * 'mmc_host_disable()' which calls 'disable' immediately. In this
2533	+ * case the 'disable' method will be called with 'lazy' set to 0.
2534	+ * This is mainly useful for error paths.
2535	+ *
2536	+ * Because lazy disable may be called from a work queue, the 'disable'
2537	+ * method must claim the host when 'lazy' != 0, which will work
2538	+ * correctly because recursion is detected and handled.
2539	+ */
2540	+ int (enable)(struct mmc_host host);
2541	+ int (disable)(struct mmc_host host, int lazy);
2542	void (request)(struct mmc_host host, struct mmc_request *req);
2543	/*
2544	* Avoid calling these three functions too often or in a "fast path",
2545	@@ -118,6 +148,9 @@ struct mmc_host {
2546	#define MMC_CAP_SPI (1 << 4) /* Talks only SPI protocols */
2547	#define MMC_CAP_NEEDS_POLL (1 << 5) /* Needs polling for card-detection */
2548	#define MMC_CAP_8_BIT_DATA (1 << 6) /* Can the host do 8 bit transfers */
2549	+#define MMC_CAP_DISABLE (1 << 7) /* Can the host be disabled */
2550	+#define MMC_CAP_NONREMOVABLE (1 << 8) /* Nonremovable e.g. eMMC */
2551	+#define MMC_CAP_WAIT_WHILE_BUSY (1 << 9) /* Waits while card is busy */
2552
2553	/* host specific block data */
2554	unsigned int max_seg_size; /* see blk_queue_max_segment_size */
2555	@@ -142,9 +175,18 @@ struct mmc_host {
2556	unsigned int removed:1; /* host is being removed */
2557	#endif
2558
2559	+ /* Only used with MMC_CAP_DISABLE */
2560	+ int enabled; /* host is enabled */
2561	+ int nesting_cnt; /* "enable" nesting count */
2562	+ int en_dis_recurs; /* detect recursion */
2563	+ unsigned int disable_delay; /* disable delay in msecs */
2564	+ struct delayed_work disable; /* disabling work */
2565	+
2566	struct mmc_card card; / device attached to this host */
2567
2568	wait_queue_head_t wq;
2569	+ struct task_struct claimer; / task that has host claimed */
2570	+ int claim_cnt; /* "claim" nesting count */
2571
2572	struct delayed_work detect;
2573
2574	@@ -183,6 +225,9 @@ static inline void *mmc_priv(struct mmc_
2575	extern int mmc_suspend_host(struct mmc_host *, pm_message_t);
2576	extern int mmc_resume_host(struct mmc_host *);
2577
2578	+extern void mmc_power_save_host(struct mmc_host *host);
2579	+extern void mmc_power_restore_host(struct mmc_host *host);
2580	+
2581	extern void mmc_detect_change(struct mmc_host *, unsigned long delay);
2582	extern void mmc_request_done(struct mmc_host , struct mmc_request );
2583
2584	@@ -197,5 +242,19 @@ struct regulator;
2585	int mmc_regulator_get_ocrmask(struct regulator *supply);
2586	int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit);
2587
2588	+int mmc_card_awake(struct mmc_host *host);
2589	+int mmc_card_sleep(struct mmc_host *host);
2590	+int mmc_card_can_sleep(struct mmc_host *host);
2591	+
2592	+int mmc_host_enable(struct mmc_host *host);
2593	+int mmc_host_disable(struct mmc_host *host);
2594	+int mmc_host_lazy_disable(struct mmc_host *host);
2595	+
2596	+static inline void mmc_set_disable_delay(struct mmc_host *host,
2597	+ unsigned int disable_delay)
2598	+{
2599	+ host->disable_delay = disable_delay;
2600	+}
2601	+
2602	#endif
2603
2604	--- a/include/linux/mmc/mmc.h
2605	+++ b/include/linux/mmc/mmc.h
2606	@@ -31,6 +31,7 @@
2607	#define MMC_ALL_SEND_CID 2 /* bcr R2 */
2608	#define MMC_SET_RELATIVE_ADDR 3 /* ac [31:16] RCA R1 */
2609	#define MMC_SET_DSR 4 /* bc [31:16] RCA */
2610	+#define MMC_SLEEP_AWAKE 5 /* ac [31:16] RCA 15:flg R1b */
2611	#define MMC_SWITCH 6 /* ac [31:0] See below R1b */
2612	#define MMC_SELECT_CARD 7 /* ac [31:16] RCA R1 */
2613	#define MMC_SEND_EXT_CSD 8 /* adtc R1 */
2614	@@ -127,6 +128,7 @@
2615	#define R1_STATUS(x) (x & 0xFFFFE000)
2616	#define R1_CURRENT_STATE(x) ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
2617	#define R1_READY_FOR_DATA (1 << 8) /* sx, a */
2618	+#define R1_SWITCH_ERROR (1 << 7) /* sx, c */
2619	#define R1_APP_CMD (1 << 5) /* sr, c */
2620
2621	/*
2622	@@ -254,6 +256,7 @@ struct _mmc_csd {
2623	#define EXT_CSD_CARD_TYPE 196 /* RO */
2624	#define EXT_CSD_REV 192 /* RO */
2625	#define EXT_CSD_SEC_CNT 212 /* RO, 4 bytes */
2626	+#define EXT_CSD_S_A_TIMEOUT 217
2627
2628	/*
2629	* EXT_CSD field definitions
2630	--- a/include/linux/mmc/sdio_func.h
2631	+++ b/include/linux/mmc/sdio_func.h
2632	@@ -67,6 +67,7 @@ struct sdio_func {
2633
2634	#define sdio_get_drvdata(f) dev_get_drvdata(&(f)->dev)
2635	#define sdio_set_drvdata(f,d) dev_set_drvdata(&(f)->dev, d)
2636	+#define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev)
2637
2638	/*
2639	* SDIO function device driver
2640	@@ -81,6 +82,8 @@ struct sdio_driver {
2641	struct device_driver drv;
2642	};
2643
2644	+#define to_sdio_driver(d) container_of(d, struct sdio_driver, drv)
2645	+
2646	/**
2647	* SDIO_DEVICE - macro used to describe a specific SDIO device
2648	* @vend: the 16 bit manufacturer code
2649	--- a/include/linux/mmc/sdio_ids.h
2650	+++ b/include/linux/mmc/sdio_ids.h
2651	@@ -22,6 +22,12 @@
2652	/*
2653	* Vendors and devices. Sort key: vendor first, device next.
2654	*/
2655	+#define SDIO_VENDOR_ID_INTEL 0x0089
2656	+#define SDIO_DEVICE_ID_INTEL_IWMC3200WIMAX 0x1402
2657	+#define SDIO_DEVICE_ID_INTEL_IWMC3200WIFI 0x1403
2658	+#define SDIO_DEVICE_ID_INTEL_IWMC3200TOP 0x1404
2659	+#define SDIO_DEVICE_ID_INTEL_IWMC3200GPS 0x1405
2660	+#define SDIO_DEVICE_ID_INTEL_IWMC3200BT 0x1406
2661
2662	#define SDIO_VENDOR_ID_MARVELL 0x02df
2663	#define SDIO_DEVICE_ID_MARVELL_LIBERTAS 0x9103
2664

Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl

OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/target/linux/cns3xxx/patches-2.6.31/204-cns3xxx_mmc_support.patch

interactive