tmio_mmc_core.c 35.1 KB
Newer Older
1
/*
2
3
4
 * Driver for the MMC / SD / SDIO IP found in:
 *
 * TC6393XB, TC6391XB, TC6387XB, T7L66XB, ASIC3, SH-Mobile SoCs
5
 *
6
7
8
 * Copyright (C) 2015-17 Renesas Electronics Corporation
 * Copyright (C) 2016-17 Sang Engineering, Wolfram Sang
 * Copyright (C) 2017 Horms Solutions, Simon Horman
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 * Copyright (C) 2011 Guennadi Liakhovetski
 * Copyright (C) 2007 Ian Molton
 * Copyright (C) 2004 Ian Molton
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This driver draws mainly on scattered spec sheets, Reverse engineering
 * of the toshiba e800  SD driver and some parts of the 2.4 ASIC3 driver (4 bit
 * support). (Further 4 bit support from a later datasheet).
 *
 * TODO:
 *   Investigate using a workqueue for PIO transfers
 *   Eliminate FIXMEs
 *   Better Power management
 *   Handle MMC errors better
 *   double buffer support
 *
 */

#include <linux/delay.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/mfd/tmio.h>
Ai Kyuse's avatar
Ai Kyuse committed
37
#include <linux/mmc/card.h>
38
#include <linux/mmc/host.h>
39
#include <linux/mmc/mmc.h>
40
#include <linux/mmc/slot-gpio.h>
41
42
43
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/platform_device.h>
44
#include <linux/pm_qos.h>
45
#include <linux/pm_runtime.h>
46
#include <linux/regulator/consumer.h>
47
#include <linux/mmc/sdio.h>
48
49
#include <linux/scatterlist.h>
#include <linux/spinlock.h>
50
#include <linux/swiotlb.h>
51
#include <linux/workqueue.h>
52
53
54

#include "tmio_mmc.h"

55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
static inline void tmio_mmc_start_dma(struct tmio_mmc_host *host,
				      struct mmc_data *data)
{
	if (host->dma_ops)
		host->dma_ops->start(host, data);
}

static inline void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
{
	if (host->dma_ops)
		host->dma_ops->enable(host, enable);
}

static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,
					struct tmio_mmc_data *pdata)
{
	if (host->dma_ops) {
		host->dma_ops->request(host, pdata);
	} else {
		host->chan_tx = NULL;
		host->chan_rx = NULL;
	}
}

static inline void tmio_mmc_release_dma(struct tmio_mmc_host *host)
{
	if (host->dma_ops)
		host->dma_ops->release(host);
}

static inline void tmio_mmc_abort_dma(struct tmio_mmc_host *host)
{
	if (host->dma_ops)
		host->dma_ops->abort(host);
}

91
92
93
94
95
96
static inline void tmio_mmc_dataend_dma(struct tmio_mmc_host *host)
{
	if (host->dma_ops)
		host->dma_ops->dataend(host);
}

97
98
void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
{
99
	host->sdcard_irq_mask &= ~(i & TMIO_MASK_IRQ);
100
	sd_ctrl_write32_as_16_and_16(host, CTL_IRQ_MASK, host->sdcard_irq_mask);
101
}
102
EXPORT_SYMBOL_GPL(tmio_mmc_enable_mmc_irqs);
103
104
105

void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
{
106
	host->sdcard_irq_mask |= (i & TMIO_MASK_IRQ);
107
	sd_ctrl_write32_as_16_and_16(host, CTL_IRQ_MASK, host->sdcard_irq_mask);
108
}
109
EXPORT_SYMBOL_GPL(tmio_mmc_disable_mmc_irqs);
110
111
112

static void tmio_mmc_ack_mmc_irqs(struct tmio_mmc_host *host, u32 i)
{
113
	sd_ctrl_write32_as_16_and_16(host, CTL_STATUS, ~i);
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
}

static void tmio_mmc_init_sg(struct tmio_mmc_host *host, struct mmc_data *data)
{
	host->sg_len = data->sg_len;
	host->sg_ptr = data->sg;
	host->sg_orig = data->sg;
	host->sg_off = 0;
}

static int tmio_mmc_next_sg(struct tmio_mmc_host *host)
{
	host->sg_ptr = sg_next(host->sg_ptr);
	host->sg_off = 0;
	return --host->sg_len;
}

131
132
#define CMDREQ_TIMEOUT	5000

133
134
135
136
static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
{
	struct tmio_mmc_host *host = mmc_priv(mmc);

137
	if (enable && !host->sdio_irq_enabled) {
138
139
		u16 sdio_status;

140
141
142
		/* Keep device active while SDIO irq is enabled */
		pm_runtime_get_sync(mmc_dev(mmc));

143
		host->sdio_irq_enabled = true;
144
		host->sdio_irq_mask = TMIO_SDIO_MASK_ALL & ~TMIO_SDIO_STAT_IOIRQ;
145
146
147
148
149
150
151

		/* Clear obsolete interrupts before enabling */
		sdio_status = sd_ctrl_read16(host, CTL_SDIO_STATUS) & ~TMIO_SDIO_MASK_ALL;
		if (host->pdata->flags & TMIO_MMC_SDIO_STATUS_SETBITS)
			sdio_status |= TMIO_SDIO_SETBITS_MASK;
		sd_ctrl_write16(host, CTL_SDIO_STATUS, sdio_status);

152
		sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, host->sdio_irq_mask);
153
	} else if (!enable && host->sdio_irq_enabled) {
154
155
		host->sdio_irq_mask = TMIO_SDIO_MASK_ALL;
		sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, host->sdio_irq_mask);
156
157

		host->sdio_irq_enabled = false;
158
159
		pm_runtime_mark_last_busy(mmc_dev(mmc));
		pm_runtime_put_autosuspend(mmc_dev(mmc));
160
161
162
	}
}

163
164
165
166
static void tmio_mmc_clk_start(struct tmio_mmc_host *host)
{
	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, CLK_CTL_SCLKEN |
		sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
167
168
169

	/* HW engineers overrode docs: no sleep needed on R-Car2+ */
	if (!(host->pdata->flags & TMIO_MMC_MIN_RCAR2))
170
		usleep_range(10000, 11000);
171
172
173

	if (host->pdata->flags & TMIO_MMC_HAVE_HIGH_REG) {
		sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0100);
174
		usleep_range(10000, 11000);
175
176
177
	}
}

178
179
180
181
static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
{
	if (host->pdata->flags & TMIO_MMC_HAVE_HIGH_REG) {
		sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0000);
182
		usleep_range(10000, 11000);
183
184
185
186
	}

	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~CLK_CTL_SCLKEN &
		sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
187
188
189

	/* HW engineers overrode docs: no sleep needed on R-Car2+ */
	if (!(host->pdata->flags & TMIO_MMC_MIN_RCAR2))
190
		usleep_range(10000, 11000);
191
192
}

193
static void tmio_mmc_set_clock(struct tmio_mmc_host *host,
194
			       unsigned int new_clock)
195
196
197
{
	u32 clk = 0, clock;

198
199
200
201
	if (new_clock == 0) {
		tmio_mmc_clk_stop(host);
		return;
	}
202

203
204
205
206
	if (host->clk_update)
		clock = host->clk_update(host, new_clock) / 512;
	else
		clock = host->mmc->f_min;
207

208
209
210
211
212
213
	for (clk = 0x80000080; new_clock >= (clock << 1); clk >>= 1)
		clock <<= 1;

	/* 1/1 clock is option */
	if ((host->pdata->flags & TMIO_MMC_CLK_ACTUAL) && ((clk >> 22) & 0x1))
		clk |= 0xff;
214
215

	if (host->set_clk_div)
216
		host->set_clk_div(host->pdev, (clk >> 22) & 1);
217

218
219
	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~CLK_CTL_SCLKEN &
			sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
220
	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk & CLK_CTL_DIV_MASK);
221
	if (!(host->pdata->flags & TMIO_MMC_MIN_RCAR2))
222
		usleep_range(10000, 11000);
223
224

	tmio_mmc_clk_start(host);
225
226
227
228
229
230
}

static void tmio_mmc_reset(struct tmio_mmc_host *host)
{
	/* FIXME - should we set stop clock reg here */
	sd_ctrl_write16(host, CTL_RESET_SD, 0x0000);
231
	if (host->pdata->flags & TMIO_MMC_HAVE_HIGH_REG)
232
		sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0000);
233
	usleep_range(10000, 11000);
234
	sd_ctrl_write16(host, CTL_RESET_SD, 0x0001);
235
	if (host->pdata->flags & TMIO_MMC_HAVE_HIGH_REG)
236
		sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0001);
237
	usleep_range(10000, 11000);
238
239
240
241
242
243

	if (host->pdata->flags & TMIO_MMC_SDIO_IRQ) {
		sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, host->sdio_irq_mask);
		sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0001);
	}

244
245
246
247
248
249
250
251
252
253
254
255
}

static void tmio_mmc_reset_work(struct work_struct *work)
{
	struct tmio_mmc_host *host = container_of(work, struct tmio_mmc_host,
						  delayed_reset_work.work);
	struct mmc_request *mrq;
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
	mrq = host->mrq;

256
257
258
259
260
	/*
	 * is request already finished? Since we use a non-blocking
	 * cancel_delayed_work(), it can happen, that a .set_ios() call preempts
	 * us, so, have to check for IS_ERR(host->mrq)
	 */
261
262
263
	if (IS_ERR_OR_NULL(mrq) ||
	    time_is_after_jiffies(host->last_req_ts +
				  msecs_to_jiffies(CMDREQ_TIMEOUT))) {
264
265
266
267
268
		spin_unlock_irqrestore(&host->lock, flags);
		return;
	}

	dev_warn(&host->pdev->dev,
269
270
		 "timeout waiting for hardware interrupt (CMD%u)\n",
		 mrq->cmd->opcode);
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

	if (host->data)
		host->data->error = -ETIMEDOUT;
	else if (host->cmd)
		host->cmd->error = -ETIMEDOUT;
	else
		mrq->cmd->error = -ETIMEDOUT;

	host->cmd = NULL;
	host->data = NULL;
	host->force_pio = false;

	spin_unlock_irqrestore(&host->lock, flags);

	tmio_mmc_reset(host);

287
288
289
	/* Ready for new calls */
	host->mrq = NULL;

290
	tmio_mmc_abort_dma(host);
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
	mmc_request_done(host->mmc, mrq);
}

/* These are the bitmasks the tmio chip requires to implement the MMC response
 * types. Note that R1 and R6 are the same in this scheme. */
#define APP_CMD        0x0040
#define RESP_NONE      0x0300
#define RESP_R1        0x0400
#define RESP_R1B       0x0500
#define RESP_R2        0x0600
#define RESP_R3        0x0700
#define DATA_PRESENT   0x0800
#define TRANSFER_READ  0x1000
#define TRANSFER_MULTI 0x2000
#define SECURITY_CMD   0x4000
306
#define NO_CMD12_ISSUE 0x4000 /* TMIO_MMC_HAVE_CMD12_CTRL */
307

308
309
static int tmio_mmc_start_command(struct tmio_mmc_host *host,
				  struct mmc_command *cmd)
310
311
312
{
	struct mmc_data *data = host->data;
	int c = cmd->opcode;
313
	u32 irq_mask = TMIO_MASK_CMD;
314
315
316

	switch (mmc_resp_type(cmd)) {
	case MMC_RSP_NONE: c |= RESP_NONE; break;
Wolfram Sang's avatar
Wolfram Sang committed
317
318
319
	case MMC_RSP_R1:
	case MMC_RSP_R1_NO_CRC:
			   c |= RESP_R1;   break;
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
	case MMC_RSP_R1B:  c |= RESP_R1B;  break;
	case MMC_RSP_R2:   c |= RESP_R2;   break;
	case MMC_RSP_R3:   c |= RESP_R3;   break;
	default:
		pr_debug("Unknown response type %d\n", mmc_resp_type(cmd));
		return -EINVAL;
	}

	host->cmd = cmd;

/* FIXME - this seems to be ok commented out but the spec suggest this bit
 *         should be set when issuing app commands.
 *	if(cmd->flags & MMC_FLAG_ACMD)
 *		c |= APP_CMD;
 */
	if (data) {
		c |= DATA_PRESENT;
		if (data->blocks > 1) {
338
			sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, TMIO_STOP_SEC);
339
			c |= TRANSFER_MULTI;
340
341

			/*
342
343
			 * Disable auto CMD12 at IO_RW_EXTENDED and
			 * SET_BLOCK_COUNT when doing multiple block transfer
344
345
			 */
			if ((host->pdata->flags & TMIO_MMC_HAVE_CMD12_CTRL) &&
Wolfram Sang's avatar
Wolfram Sang committed
346
			    (cmd->opcode == SD_IO_RW_EXTENDED || host->mrq->sbc))
347
				c |= NO_CMD12_ISSUE;
348
349
350
351
352
		}
		if (data->flags & MMC_DATA_READ)
			c |= TRANSFER_READ;
	}

353
354
355
	if (!host->native_hotplug)
		irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
	tmio_mmc_enable_mmc_irqs(host, irq_mask);
356
357

	/* Fire off the command */
358
	sd_ctrl_write32_as_16_and_16(host, CTL_ARG_REG, cmd->arg);
359
360
361
362
363
	sd_ctrl_write16(host, CTL_SD_CMD, c);

	return 0;
}

364
365
366
367
368
369
370
371
372
373
static void tmio_mmc_transfer_data(struct tmio_mmc_host *host,
				   unsigned short *buf,
				   unsigned int count)
{
	int is_read = host->data->flags & MMC_DATA_READ;
	u8  *buf8;

	/*
	 * Transfer the data
	 */
374
	if (host->pdata->flags & TMIO_MMC_32BIT_DATA_PORT) {
375
376
		u32 data = 0;
		u32 *buf32 = (u32 *)buf;
377
378

		if (is_read)
379
			sd_ctrl_read32_rep(host, CTL_SD_DATA_PORT, buf32,
380
381
					   count >> 2);
		else
382
			sd_ctrl_write32_rep(host, CTL_SD_DATA_PORT, buf32,
383
384
385
386
387
388
					    count >> 2);

		/* if count was multiple of 4 */
		if (!(count & 0x3))
			return;

389
		buf32 += count >> 2;
390
391
392
		count %= 4;

		if (is_read) {
393
394
			sd_ctrl_read32_rep(host, CTL_SD_DATA_PORT, &data, 1);
			memcpy(buf32, &data, count);
395
		} else {
396
397
			memcpy(&data, buf32, count);
			sd_ctrl_write32_rep(host, CTL_SD_DATA_PORT, &data, 1);
398
399
400
401
402
		}

		return;
	}

403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
	if (is_read)
		sd_ctrl_read16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
	else
		sd_ctrl_write16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);

	/* if count was even number */
	if (!(count & 0x1))
		return;

	/* if count was odd number */
	buf8 = (u8 *)(buf + (count >> 1));

	/*
	 * FIXME
	 *
	 * driver and this function are assuming that
	 * it is used as little endian
	 */
	if (is_read)
		*buf8 = sd_ctrl_read16(host, CTL_SD_DATA_PORT) & 0xff;
	else
		sd_ctrl_write16(host, CTL_SD_DATA_PORT, *buf8);
}

427
428
429
/*
 * This chip always returns (at least?) as much data as you ask for.
 * I'm unsure what happens if you ask for less than a block. This should be
Lucas De Marchi's avatar
Lucas De Marchi committed
430
 * looked into to ensure that a funny length read doesn't hose the controller.
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
 */
static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
{
	struct mmc_data *data = host->data;
	void *sg_virt;
	unsigned short *buf;
	unsigned int count;
	unsigned long flags;

	if ((host->chan_tx || host->chan_rx) && !host->force_pio) {
		pr_err("PIO IRQ in DMA mode!\n");
		return;
	} else if (!data) {
		pr_debug("Spurious PIO IRQ\n");
		return;
	}

	sg_virt = tmio_mmc_kmap_atomic(host->sg_ptr, &flags);
	buf = (unsigned short *)(sg_virt + host->sg_off);

	count = host->sg_ptr->length - host->sg_off;
	if (count > data->blksz)
		count = data->blksz;

	pr_debug("count: %08x offset: %08x flags %08x\n",
		 count, host->sg_off, data->flags);

	/* Transfer the data */
459
	tmio_mmc_transfer_data(host, buf, count);
460
461
462
463
464
465
466
467
468
469
470
471
472
473

	host->sg_off += count;

	tmio_mmc_kunmap_atomic(host->sg_ptr, &flags, sg_virt);

	if (host->sg_off == host->sg_ptr->length)
		tmio_mmc_next_sg(host);
}

static void tmio_mmc_check_bounce_buffer(struct tmio_mmc_host *host)
{
	if (host->sg_ptr == &host->bounce_sg) {
		unsigned long flags;
		void *sg_vaddr = tmio_mmc_kmap_atomic(host->sg_orig, &flags);
474

475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
		memcpy(sg_vaddr, host->bounce_buf, host->bounce_sg.length);
		tmio_mmc_kunmap_atomic(host->sg_orig, &flags, sg_vaddr);
	}
}

/* needs to be called with host->lock held */
void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
{
	struct mmc_data *data = host->data;
	struct mmc_command *stop;

	host->data = NULL;

	if (!data) {
		dev_warn(&host->pdev->dev, "Spurious data end IRQ\n");
		return;
	}
	stop = data->stop;

	/* FIXME - return correct transfer count on errors */
	if (!data->error)
		data->bytes_xfered = data->blocks * data->blksz;
	else
		data->bytes_xfered = 0;

	pr_debug("Completed data request\n");

	/*
	 * FIXME: other drivers allow an optional stop command of any given type
	 *        which we dont do, as the chip can auto generate them.
	 *        Perhaps we can be smarter about when to use auto CMD12 and
	 *        only issue the auto request when we know this is the desired
	 *        stop command, allowing fallback to the stop command the
	 *        upper layers expect. For now, we do what works.
	 */

	if (data->flags & MMC_DATA_READ) {
		if (host->chan_rx && !host->force_pio)
			tmio_mmc_check_bounce_buffer(host);
		dev_dbg(&host->pdev->dev, "Complete Rx request %p\n",
			host->mrq);
	} else {
		dev_dbg(&host->pdev->dev, "Complete Tx request %p\n",
			host->mrq);
	}

Wolfram Sang's avatar
Wolfram Sang committed
521
	if (stop && !host->mrq->sbc) {
522
523
524
525
		if (stop->opcode != MMC_STOP_TRANSMISSION || stop->arg)
			dev_err(&host->pdev->dev, "unsupported stop: CMD%u,0x%x. We did CMD12,0\n",
				stop->opcode, stop->arg);

526
527
528
		/* fill in response from auto CMD12 */
		stop->resp[0] = sd_ctrl_read16_and_16_as_32(host, CTL_RESPONSE);

529
		sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0);
530
531
	}

532
	schedule_work(&host->done);
533
}
534
EXPORT_SYMBOL_GPL(tmio_mmc_do_data_irq);
535

536
static void tmio_mmc_data_irq(struct tmio_mmc_host *host, unsigned int stat)
537
538
{
	struct mmc_data *data;
539

540
541
542
543
544
545
	spin_lock(&host->lock);
	data = host->data;

	if (!data)
		goto out;

546
547
548
	if (stat & TMIO_STAT_CRCFAIL || stat & TMIO_STAT_STOPBIT_ERR ||
	    stat & TMIO_STAT_TXUNDERRUN)
		data->error = -EILSEQ;
549
	if (host->chan_tx && (data->flags & MMC_DATA_WRITE) && !host->force_pio) {
550
		u32 status = sd_ctrl_read16_and_16_as_32(host, CTL_STATUS);
551
552
		bool done = false;

553
554
555
556
557
558
559
560
		/*
		 * Has all data been written out yet? Testing on SuperH showed,
		 * that in most cases the first interrupt comes already with the
		 * BUSY status bit clear, but on some operations, like mount or
		 * in the beginning of a write / sync / umount, there is one
		 * DATAEND interrupt with the BUSY bit set, in this cases
		 * waiting for one more interrupt fixes the problem.
		 */
561
		if (host->pdata->flags & TMIO_MMC_HAS_IDLE_WAIT) {
562
			if (status & TMIO_STAT_SCLKDIVEN)
563
564
565
566
567
568
569
				done = true;
		} else {
			if (!(status & TMIO_STAT_CMD_BUSY))
				done = true;
		}

		if (done) {
570
			tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_DATAEND);
571
			tmio_mmc_dataend_dma(host);
572
573
574
		}
	} else if (host->chan_rx && (data->flags & MMC_DATA_READ) && !host->force_pio) {
		tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_DATAEND);
575
		tmio_mmc_dataend_dma(host);
576
577
578
579
580
581
582
583
	} else {
		tmio_mmc_do_data_irq(host);
		tmio_mmc_disable_mmc_irqs(host, TMIO_MASK_READOP | TMIO_MASK_WRITEOP);
	}
out:
	spin_unlock(&host->lock);
}

584
static void tmio_mmc_cmd_irq(struct tmio_mmc_host *host, unsigned int stat)
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
{
	struct mmc_command *cmd = host->cmd;
	int i, addr;

	spin_lock(&host->lock);

	if (!host->cmd) {
		pr_debug("Spurious CMD irq\n");
		goto out;
	}

	/* This controller is sicker than the PXA one. Not only do we need to
	 * drop the top 8 bits of the first response word, we also need to
	 * modify the order of the response for short response command types.
	 */

	for (i = 3, addr = CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
602
		cmd->resp[i] = sd_ctrl_read16_and_16_as_32(host, addr);
603
604
605
606
607
608
609
610
611
612
613
614

	if (cmd->flags &  MMC_RSP_136) {
		cmd->resp[0] = (cmd->resp[0] << 8) | (cmd->resp[1] >> 24);
		cmd->resp[1] = (cmd->resp[1] << 8) | (cmd->resp[2] >> 24);
		cmd->resp[2] = (cmd->resp[2] << 8) | (cmd->resp[3] >> 24);
		cmd->resp[3] <<= 8;
	} else if (cmd->flags & MMC_RSP_R3) {
		cmd->resp[0] = cmd->resp[3];
	}

	if (stat & TMIO_STAT_CMDTIMEOUT)
		cmd->error = -ETIMEDOUT;
615
616
617
	else if ((stat & TMIO_STAT_CRCFAIL && cmd->flags & MMC_RSP_CRC) ||
		 stat & TMIO_STAT_STOPBIT_ERR ||
		 stat & TMIO_STAT_CMD_IDX_ERR)
618
619
620
621
622
623
		cmd->error = -EILSEQ;

	/* If there is data to handle we enable data IRQs here, and
	 * we will ultimatley finish the request in the data_end handler.
	 * If theres no data or we encountered an error, finish now.
	 */
624
	if (host->data && (!cmd->error || cmd->error == -EILSEQ)) {
625
626
627
628
629
630
631
632
633
634
635
636
		if (host->data->flags & MMC_DATA_READ) {
			if (host->force_pio || !host->chan_rx)
				tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_READOP);
			else
				tasklet_schedule(&host->dma_issue);
		} else {
			if (host->force_pio || !host->chan_tx)
				tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_WRITEOP);
			else
				tasklet_schedule(&host->dma_issue);
		}
	} else {
637
		schedule_work(&host->done);
638
639
640
641
642
643
	}

out:
	spin_unlock(&host->lock);
}

644
static bool __tmio_mmc_card_detect_irq(struct tmio_mmc_host *host,
645
				       int ireg, int status)
646
647
{
	struct mmc_host *mmc = host->mmc;
648

649
650
651
652
	/* Card insert / remove attempts */
	if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
		tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_CARD_INSERT |
			TMIO_STAT_CARD_REMOVE);
653
654
655
		if ((((ireg & TMIO_STAT_CARD_REMOVE) && mmc->card) ||
		     ((ireg & TMIO_STAT_CARD_INSERT) && !mmc->card)) &&
		    !work_pending(&mmc->detect.work))
656
			mmc_detect_change(host->mmc, msecs_to_jiffies(100));
657
		return true;
658
659
	}

660
661
662
	return false;
}

663
664
static bool __tmio_mmc_sdcard_irq(struct tmio_mmc_host *host, int ireg,
				  int status)
665
{
666
667
	/* Command completion */
	if (ireg & (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT)) {
668
669
		tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_CMDRESPEND |
				      TMIO_STAT_CMDTIMEOUT);
670
		tmio_mmc_cmd_irq(host, status);
671
		return true;
672
	}
673

674
675
676
677
	/* Data transfer */
	if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
		tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
		tmio_mmc_pio_irq(host);
678
		return true;
679
	}
680

681
682
683
	/* Data transfer completion */
	if (ireg & TMIO_STAT_DATAEND) {
		tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_DATAEND);
684
		tmio_mmc_data_irq(host, status);
685
		return true;
686
	}
687

688
689
690
	return false;
}

691
static void __tmio_mmc_sdio_irq(struct tmio_mmc_host *host)
692
693
694
695
{
	struct mmc_host *mmc = host->mmc;
	struct tmio_mmc_data *pdata = host->pdata;
	unsigned int ireg, status;
696
	unsigned int sdio_status;
697
698

	if (!(pdata->flags & TMIO_MMC_SDIO_IRQ))
699
		return;
700
701

	status = sd_ctrl_read16(host, CTL_SDIO_STATUS);
702
	ireg = status & TMIO_SDIO_MASK_ALL & ~host->sdio_irq_mask;
703

704
	sdio_status = status & ~TMIO_SDIO_MASK_ALL;
705
	if (pdata->flags & TMIO_MMC_SDIO_STATUS_SETBITS)
706
		sdio_status |= TMIO_SDIO_SETBITS_MASK;
707
708

	sd_ctrl_write16(host, CTL_SDIO_STATUS, sdio_status);
709
710
711
712
713
714
715
716
717
718

	if (mmc->caps & MMC_CAP_SDIO_IRQ && ireg & TMIO_SDIO_STAT_IOIRQ)
		mmc_signal_sdio_irq(mmc);
}

irqreturn_t tmio_mmc_irq(int irq, void *devid)
{
	struct tmio_mmc_host *host = devid;
	unsigned int ireg, status;

719
	status = sd_ctrl_read16_and_16_as_32(host, CTL_STATUS);
Wolfram Sang's avatar
Wolfram Sang committed
720
721
722
	ireg = status & TMIO_MASK_IRQ & ~host->sdcard_irq_mask;

	/* Clear the status except the interrupt status */
723
	sd_ctrl_write32_as_16_and_16(host, CTL_STATUS, TMIO_MASK_IRQ);
724
725
726
727
728
729

	if (__tmio_mmc_card_detect_irq(host, ireg, status))
		return IRQ_HANDLED;
	if (__tmio_mmc_sdcard_irq(host, ireg, status))
		return IRQ_HANDLED;

730
	__tmio_mmc_sdio_irq(host);
731
732
733

	return IRQ_HANDLED;
}
734
EXPORT_SYMBOL_GPL(tmio_mmc_irq);
735
736

static int tmio_mmc_start_data(struct tmio_mmc_host *host,
737
			       struct mmc_data *data)
738
739
740
741
742
743
{
	struct tmio_mmc_data *pdata = host->pdata;

	pr_debug("setup data transfer: blocksize %08x  nr_blocks %d\n",
		 data->blksz, data->blocks);

Wolfram Sang's avatar
Wolfram Sang committed
744
745
746
	/* Some hardware cannot perform 2 byte requests in 4/8 bit mode */
	if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4 ||
	    host->mmc->ios.bus_width == MMC_BUS_WIDTH_8) {
747
748
749
		int blksz_2bytes = pdata->flags & TMIO_MMC_BLKSZ_2BYTES;

		if (data->blksz < 2 || (data->blksz < 4 && !blksz_2bytes)) {
Wolfram Sang's avatar
Wolfram Sang committed
750
			pr_err("%s: %d byte block unsupported in 4/8 bit mode\n",
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
			       mmc_hostname(host->mmc), data->blksz);
			return -EINVAL;
		}
	}

	tmio_mmc_init_sg(host, data);
	host->data = data;

	/* Set transfer length / blocksize */
	sd_ctrl_write16(host, CTL_SD_XFER_LEN, data->blksz);
	sd_ctrl_write16(host, CTL_XFER_BLK_COUNT, data->blocks);

	tmio_mmc_start_dma(host, data);

	return 0;
}

Ai Kyuse's avatar
Ai Kyuse committed
768
769
770
771
772
773
774
775
static void tmio_mmc_hw_reset(struct mmc_host *mmc)
{
	struct tmio_mmc_host *host = mmc_priv(mmc);

	if (host->hw_reset)
		host->hw_reset(host);
}

Ai Kyuse's avatar
Ai Kyuse committed
776
777
778
779
780
static int tmio_mmc_execute_tuning(struct mmc_host *mmc, u32 opcode)
{
	struct tmio_mmc_host *host = mmc_priv(mmc);
	int i, ret = 0;

781
782
783
	if (!host->init_tuning || !host->select_tuning)
		/* Tuning is not supported */
		goto out;
Ai Kyuse's avatar
Ai Kyuse committed
784

785
786
787
788
	host->tap_num = host->init_tuning(host);
	if (!host->tap_num)
		/* Tuning is not supported */
		goto out;
Ai Kyuse's avatar
Ai Kyuse committed
789
790
791

	if (host->tap_num * 2 >= sizeof(host->taps) * BITS_PER_BYTE) {
		dev_warn_once(&host->pdev->dev,
792
			"Too many taps, skipping tuning. Please consider updating size of taps field of tmio_mmc_host\n");
Ai Kyuse's avatar
Ai Kyuse committed
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
		goto out;
	}

	bitmap_zero(host->taps, host->tap_num * 2);

	/* Issue CMD19 twice for each tap */
	for (i = 0; i < 2 * host->tap_num; i++) {
		if (host->prepare_tuning)
			host->prepare_tuning(host, i % host->tap_num);

		ret = mmc_send_tuning(mmc, opcode, NULL);
		if (ret && ret != -EILSEQ)
			goto out;
		if (ret == 0)
			set_bit(i, host->taps);

809
		usleep_range(1000, 1200);
Ai Kyuse's avatar
Ai Kyuse committed
810
811
812
813
814
815
816
817
818
819
820
821
822
	}

	ret = host->select_tuning(host);

out:
	if (ret < 0) {
		dev_warn(&host->pdev->dev, "Tuning procedure failed\n");
		tmio_mmc_hw_reset(mmc);
	}

	return ret;
}

823
824
static void tmio_process_mrq(struct tmio_mmc_host *host,
			     struct mmc_request *mrq)
825
{
Wolfram Sang's avatar
Wolfram Sang committed
826
	struct mmc_command *cmd;
827
828
	int ret;

Wolfram Sang's avatar
Wolfram Sang committed
829
830
831
832
833
834
835
836
837
	if (mrq->sbc && host->cmd != mrq->sbc) {
		cmd = mrq->sbc;
	} else {
		cmd = mrq->cmd;
		if (mrq->data) {
			ret = tmio_mmc_start_data(host, mrq->data);
			if (ret)
				goto fail;
		}
838
839
	}

Wolfram Sang's avatar
Wolfram Sang committed
840
	ret = tmio_mmc_start_command(host, cmd);
841
842
843
844
845
846
847
848
849
850
851
852
853
854
	if (ret)
		goto fail;

	schedule_delayed_work(&host->delayed_reset_work,
			      msecs_to_jiffies(CMDREQ_TIMEOUT));
	return;

fail:
	host->force_pio = false;
	host->mrq = NULL;
	mrq->cmd->error = ret;
	mmc_request_done(host->mmc, mrq);
}

855
856
857
858
/* Process requests from the MMC layer */
static void tmio_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
	struct tmio_mmc_host *host = mmc_priv(mmc);
859
	unsigned long flags;
860

861
862
863
	spin_lock_irqsave(&host->lock, flags);

	if (host->mrq) {
864
		pr_debug("request not null\n");
865
866
867
868
869
870
871
		if (IS_ERR(host->mrq)) {
			spin_unlock_irqrestore(&host->lock, flags);
			mrq->cmd->error = -EAGAIN;
			mmc_request_done(mmc, mrq);
			return;
		}
	}
872
873
874
875
876

	host->last_req_ts = jiffies;
	wmb();
	host->mrq = mrq;

877
878
	spin_unlock_irqrestore(&host->lock, flags);

879
	tmio_process_mrq(host, mrq);
880
881
}

882
883
884
885
886
887
888
889
890
891
892
893
894
static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
{
	struct mmc_request *mrq;
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);

	mrq = host->mrq;
	if (IS_ERR_OR_NULL(mrq)) {
		spin_unlock_irqrestore(&host->lock, flags);
		return;
	}

Wolfram Sang's avatar
Wolfram Sang committed
895
896
897
898
899
900
901
	/* If not SET_BLOCK_COUNT, clear old data */
	if (host->cmd != mrq->sbc) {
		host->cmd = NULL;
		host->data = NULL;
		host->force_pio = false;
		host->mrq = NULL;
	}
902
903
904
905
906
907
908
909
910
911
912

	cancel_delayed_work(&host->delayed_reset_work);

	spin_unlock_irqrestore(&host->lock, flags);

	if (mrq->cmd->error || (mrq->data && mrq->data->error))
		tmio_mmc_abort_dma(host);

	if (host->check_scc_error)
		host->check_scc_error(host);

Wolfram Sang's avatar
Wolfram Sang committed
913
914
915
916
917
918
	/* If SET_BLOCK_COUNT, continue with main command */
	if (host->mrq) {
		tmio_process_mrq(host, mrq);
		return;
	}

919
920
921
922
923
924
925
926
927
928
	mmc_request_done(host->mmc, mrq);
}

static void tmio_mmc_done_work(struct work_struct *work)
{
	struct tmio_mmc_host *host = container_of(work, struct tmio_mmc_host,
						  done);
	tmio_mmc_finish_request(host);
}

929
static int tmio_mmc_clk_enable(struct tmio_mmc_host *host)
930
{
931
	if (!host->clk_enable)
932
933
		return -ENOTSUPP;

934
	return host->clk_enable(host);
935
936
}

937
938
939
940
941
942
static void tmio_mmc_clk_disable(struct tmio_mmc_host *host)
{
	if (host->clk_disable)
		host->clk_disable(host);
}

943
static void tmio_mmc_power_on(struct tmio_mmc_host *host, unsigned short vdd)
944
945
{
	struct mmc_host *mmc = host->mmc;
946
947
948
	int ret = 0;

	/* .set_ios() is returning void, so, no chance to report an error */
949

950
951
952
	if (host->set_pwr)
		host->set_pwr(host->pdev, 1);

953
954
955
956
957
958
959
960
	if (!IS_ERR(mmc->supply.vmmc)) {
		ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
		/*
		 * Attention: empiric value. With a b43 WiFi SDIO card this
		 * delay proved necessary for reliable card-insertion probing.
		 * 100us were not enough. Is this the same 140us delay, as in
		 * tmio_mmc_set_ios()?
		 */
961
		usleep_range(200, 300);
962
963
964
965
966
967
	}
	/*
	 * It seems, VccQ should be switched on after Vcc, this is also what the
	 * omap_hsmmc.c driver does.
	 */
	if (!IS_ERR(mmc->supply.vqmmc) && !ret) {
968
		ret = regulator_enable(mmc->supply.vqmmc);
969
		usleep_range(200, 300);
970
	}
971
972
973
974

	if (ret < 0)
		dev_dbg(&host->pdev->dev, "Regulators failed to power up: %d\n",
			ret);
975
976
977
978
979
980
981
982
983
}

static void tmio_mmc_power_off(struct tmio_mmc_host *host)
{
	struct mmc_host *mmc = host->mmc;

	if (!IS_ERR(mmc->supply.vqmmc))
		regulator_disable(mmc->supply.vqmmc);

984
	if (!IS_ERR(mmc->supply.vmmc))
985
		mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, 0);
986
987
988

	if (host->set_pwr)
		host->set_pwr(host->pdev, 0);
989
990
}

991
static void tmio_mmc_set_bus_width(struct tmio_mmc_host *host,
992
				   unsigned char bus_width)
993
{
Wolfram Sang's avatar
Wolfram Sang committed
994
995
996
997
998
999
1000
	u16 reg = sd_ctrl_read16(host, CTL_SD_MEM_CARD_OPT)
				& ~(CARD_OPT_WIDTH | CARD_OPT_WIDTH8);

	/* reg now applies to MMC_BUS_WIDTH_4 */
	if (bus_width == MMC_BUS_WIDTH_1)
		reg |= CARD_OPT_WIDTH;
	else if (bus_width == MMC_BUS_WIDTH_8)
For faster browsing, not all history is shown. View entire blame