mmc_ops.c 22.8 KB
Newer Older
Pierre Ossman's avatar
Pierre Ossman committed
1
/*
Pierre Ossman's avatar
Pierre Ossman committed
2
 *  linux/drivers/mmc/core/mmc_ops.h
Pierre Ossman's avatar
Pierre Ossman committed
3
4
5
6
7
8
9
10
11
 *
 *  Copyright 2006-2007 Pierre Ossman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 */

12
#include <linux/slab.h>
13
#include <linux/export.h>
Pierre Ossman's avatar
Pierre Ossman committed
14
15
16
17
18
19
20
21
#include <linux/types.h>
#include <linux/scatterlist.h>

#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/mmc.h>

#include "core.h"
22
#include "card.h"
23
#include "host.h"
Pierre Ossman's avatar
Pierre Ossman committed
24
25
#include "mmc_ops.h"

26
27
#define MMC_OPS_TIMEOUT_MS	(10 * 60 * 1000) /* 10 minute timeout */

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
static const u8 tuning_blk_pattern_4bit[] = {
	0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
	0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
	0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
	0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
	0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
	0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
	0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
	0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
};

static const u8 tuning_blk_pattern_8bit[] = {
	0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
	0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
	0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
	0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
	0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
	0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
	0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
	0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
	0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
	0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
	0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
	0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
	0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
	0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
	0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
	0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
};

58
int __mmc_send_status(struct mmc_card *card, u32 *status, unsigned int retries)
59
60
{
	int err;
61
	struct mmc_command cmd = {};
62
63
64
65
66
67

	cmd.opcode = MMC_SEND_STATUS;
	if (!mmc_host_is_spi(card->host))
		cmd.arg = card->rca << 16;
	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;

68
	err = mmc_wait_for_cmd(card->host, &cmd, retries);
69
70
71
72
73
74
75
76
77
78
79
	if (err)
		return err;

	/* NOTE: callers are required to understand the difference
	 * between "native" and SPI format status words!
	 */
	if (status)
		*status = cmd.resp[0];

	return 0;
}
80
81
82
83
84
85
EXPORT_SYMBOL_GPL(__mmc_send_status);

int mmc_send_status(struct mmc_card *card, u32 *status)
{
	return __mmc_send_status(card, status, MMC_CMD_RETRIES);
}
86
EXPORT_SYMBOL_GPL(mmc_send_status);
87

Pierre Ossman's avatar
Pierre Ossman committed
88
89
static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
{
90
	struct mmc_command cmd = {};
Pierre Ossman's avatar
Pierre Ossman committed
91
92
93
94
95
96
97
98
99
100
101

	cmd.opcode = MMC_SELECT_CARD;

	if (card) {
		cmd.arg = card->rca << 16;
		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
	} else {
		cmd.arg = 0;
		cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
	}

102
	return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
Pierre Ossman's avatar
Pierre Ossman committed
103
104
105
106
107
108
109
110
111
112
113
114
115
}

int mmc_select_card(struct mmc_card *card)
{

	return _mmc_select_card(card->host, card);
}

int mmc_deselect_cards(struct mmc_host *host)
{
	return _mmc_select_card(host, NULL);
}

116
117
118
119
120
121
122
123
124
125
/*
 * Write the value specified in the device tree or board code into the optional
 * 16 bit Driver Stage Register. This can be used to tune raise/fall times and
 * drive strength of the DAT and CMD outputs. The actual meaning of a given
 * value is hardware dependant.
 * The presence of the DSR register can be determined from the CSD register,
 * bit 76.
 */
int mmc_set_dsr(struct mmc_host *host)
{
126
	struct mmc_command cmd = {};
127
128
129
130
131
132
133
134
135

	cmd.opcode = MMC_SET_DSR;

	cmd.arg = (host->dsr << 16) | 0xffff;
	cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;

	return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
}

Pierre Ossman's avatar
Pierre Ossman committed
136
137
138
int mmc_go_idle(struct mmc_host *host)
{
	int err;
139
	struct mmc_command cmd = {};
Pierre Ossman's avatar
Pierre Ossman committed
140

David Brownell's avatar
David Brownell committed
141
142
143
144
145
146
	/*
	 * Non-SPI hosts need to prevent chipselect going active during
	 * GO_IDLE; that would put chips into SPI mode.  Remind them of
	 * that in case of hardware that won't pull up DAT3/nCS otherwise.
	 *
	 * SPI hosts ignore ios.chip_select; it's managed according to
Lucas De Marchi's avatar
Lucas De Marchi committed
147
	 * rules that must accommodate non-MMC slaves which this layer
David Brownell's avatar
David Brownell committed
148
149
150
151
152
153
	 * won't even know about.
	 */
	if (!mmc_host_is_spi(host)) {
		mmc_set_chip_select(host, MMC_CS_HIGH);
		mmc_delay(1);
	}
Pierre Ossman's avatar
Pierre Ossman committed
154
155
156

	cmd.opcode = MMC_GO_IDLE_STATE;
	cmd.arg = 0;
David Brownell's avatar
David Brownell committed
157
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
Pierre Ossman's avatar
Pierre Ossman committed
158
159
160
161
162

	err = mmc_wait_for_cmd(host, &cmd, 0);

	mmc_delay(1);

David Brownell's avatar
David Brownell committed
163
164
165
166
	if (!mmc_host_is_spi(host)) {
		mmc_set_chip_select(host, MMC_CS_DONTCARE);
		mmc_delay(1);
	}
Pierre Ossman's avatar
Pierre Ossman committed
167

David Brownell's avatar
David Brownell committed
168
	host->use_spi_crc = 0;
Pierre Ossman's avatar
Pierre Ossman committed
169
170
171
172
173
174

	return err;
}

int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
{
175
	struct mmc_command cmd = {};
Pierre Ossman's avatar
Pierre Ossman committed
176
177
178
	int i, err = 0;

	cmd.opcode = MMC_SEND_OP_COND;
David Brownell's avatar
David Brownell committed
179
180
	cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
Pierre Ossman's avatar
Pierre Ossman committed
181
182
183

	for (i = 100; i; i--) {
		err = mmc_wait_for_cmd(host, &cmd, 0);
Pierre Ossman's avatar
Pierre Ossman committed
184
		if (err)
Pierre Ossman's avatar
Pierre Ossman committed
185
186
			break;

David Brownell's avatar
David Brownell committed
187
188
		/* if we're just probing, do a single pass */
		if (ocr == 0)
Pierre Ossman's avatar
Pierre Ossman committed
189
190
			break;

David Brownell's avatar
David Brownell committed
191
192
193
194
195
196
197
198
199
		/* otherwise wait until reset completes */
		if (mmc_host_is_spi(host)) {
			if (!(cmd.resp[0] & R1_SPI_IDLE))
				break;
		} else {
			if (cmd.resp[0] & MMC_CARD_BUSY)
				break;
		}

Pierre Ossman's avatar
Pierre Ossman committed
200
		err = -ETIMEDOUT;
Pierre Ossman's avatar
Pierre Ossman committed
201
202
203
204

		mmc_delay(10);
	}

David Brownell's avatar
David Brownell committed
205
	if (rocr && !mmc_host_is_spi(host))
Pierre Ossman's avatar
Pierre Ossman committed
206
207
208
209
210
211
212
		*rocr = cmd.resp[0];

	return err;
}

int mmc_set_relative_addr(struct mmc_card *card)
{
213
	struct mmc_command cmd = {};
Pierre Ossman's avatar
Pierre Ossman committed
214
215
216
217
218

	cmd.opcode = MMC_SET_RELATIVE_ADDR;
	cmd.arg = card->rca << 16;
	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

219
	return mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
Pierre Ossman's avatar
Pierre Ossman committed
220
221
}

David Brownell's avatar
David Brownell committed
222
223
static int
mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
Pierre Ossman's avatar
Pierre Ossman committed
224
225
{
	int err;
226
	struct mmc_command cmd = {};
Pierre Ossman's avatar
Pierre Ossman committed
227

David Brownell's avatar
David Brownell committed
228
229
	cmd.opcode = opcode;
	cmd.arg = arg;
Pierre Ossman's avatar
Pierre Ossman committed
230
231
	cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;

David Brownell's avatar
David Brownell committed
232
	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
Pierre Ossman's avatar
Pierre Ossman committed
233
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
234
235
		return err;

David Brownell's avatar
David Brownell committed
236
	memcpy(cxd, cmd.resp, sizeof(u32) * 4);
Pierre Ossman's avatar
Pierre Ossman committed
237

Pierre Ossman's avatar
Pierre Ossman committed
238
	return 0;
Pierre Ossman's avatar
Pierre Ossman committed
239
240
}

241
242
243
244
/*
 * NOTE: void *buf, caller for the buf is required to use DMA-capable
 * buffer or on-stack buffer (with some overhead in callee).
 */
David Brownell's avatar
David Brownell committed
245
246
247
static int
mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
		u32 opcode, void *buf, unsigned len)
Pierre Ossman's avatar
Pierre Ossman committed
248
{
249
250
251
	struct mmc_request mrq = {};
	struct mmc_command cmd = {};
	struct mmc_data data = {};
Pierre Ossman's avatar
Pierre Ossman committed
252
253
254
255
256
	struct scatterlist sg;

	mrq.cmd = &cmd;
	mrq.data = &data;

David Brownell's avatar
David Brownell committed
257
	cmd.opcode = opcode;
Pierre Ossman's avatar
Pierre Ossman committed
258
259
	cmd.arg = 0;

David Brownell's avatar
David Brownell committed
260
261
262
263
264
265
266
267
	/* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
	 * rely on callers to never use this with "native" calls for reading
	 * CSD or CID.  Native versions of those commands use the R2 type,
	 * not R1 plus a data block.
	 */
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

	data.blksz = len;
Pierre Ossman's avatar
Pierre Ossman committed
268
269
270
271
272
	data.blocks = 1;
	data.flags = MMC_DATA_READ;
	data.sg = &sg;
	data.sg_len = 1;

273
	sg_init_one(&sg, buf, len);
Pierre Ossman's avatar
Pierre Ossman committed
274

275
276
277
278
279
280
281
282
283
	if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
		/*
		 * The spec states that CSR and CID accesses have a timeout
		 * of 64 clock cycles.
		 */
		data.timeout_ns = 0;
		data.timeout_clks = 64;
	} else
		mmc_set_data_timeout(&data, card);
Pierre Ossman's avatar
Pierre Ossman committed
284

David Brownell's avatar
David Brownell committed
285
286
	mmc_wait_for_req(host, &mrq);

Pierre Ossman's avatar
Pierre Ossman committed
287
	if (cmd.error)
Pierre Ossman's avatar
Pierre Ossman committed
288
		return cmd.error;
Pierre Ossman's avatar
Pierre Ossman committed
289
	if (data.error)
Pierre Ossman's avatar
Pierre Ossman committed
290
291
		return data.error;

Pierre Ossman's avatar
Pierre Ossman committed
292
	return 0;
Pierre Ossman's avatar
Pierre Ossman committed
293
294
}

295
static int mmc_spi_send_csd(struct mmc_card *card, u32 *csd)
David Brownell's avatar
David Brownell committed
296
{
297
	int ret, i;
298
	__be32 *csd_tmp;
299

300
	csd_tmp = kzalloc(16, GFP_KERNEL);
301
302
303
304
	if (!csd_tmp)
		return -ENOMEM;

	ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16);
305
	if (ret)
306
		goto err;
307

308
	for (i = 0; i < 4; i++)
309
		csd[i] = be32_to_cpu(csd_tmp[i]);
310

311
312
313
err:
	kfree(csd_tmp);
	return ret;
David Brownell's avatar
David Brownell committed
314
315
}

316
317
318
319
320
321
322
323
324
int mmc_send_csd(struct mmc_card *card, u32 *csd)
{
	if (mmc_host_is_spi(card->host))
		return mmc_spi_send_csd(card, csd);

	return mmc_send_cxd_native(card->host, card->rca << 16,	csd,
				MMC_SEND_CSD);
}

325
static int mmc_spi_send_cid(struct mmc_host *host, u32 *cid)
David Brownell's avatar
David Brownell committed
326
{
327
	int ret, i;
328
	__be32 *cid_tmp;
329

330
	cid_tmp = kzalloc(16, GFP_KERNEL);
331
332
333
334
	if (!cid_tmp)
		return -ENOMEM;

	ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16);
335
	if (ret)
336
		goto err;
337

338
	for (i = 0; i < 4; i++)
339
		cid[i] = be32_to_cpu(cid_tmp[i]);
340

341
342
343
err:
	kfree(cid_tmp);
	return ret;
David Brownell's avatar
David Brownell committed
344
345
}

346
347
348
349
350
int mmc_send_cid(struct mmc_host *host, u32 *cid)
{
	if (mmc_host_is_spi(host))
		return mmc_spi_send_cid(host, cid);

351
	return mmc_send_cxd_native(host, 0, cid, MMC_ALL_SEND_CID);
352
353
}

354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
{
	int err;
	u8 *ext_csd;

	if (!card || !new_ext_csd)
		return -EINVAL;

	if (!mmc_can_ext_csd(card))
		return -EOPNOTSUPP;

	/*
	 * As the ext_csd is so large and mostly unused, we don't store the
	 * raw block in mmc_card.
	 */
369
	ext_csd = kzalloc(512, GFP_KERNEL);
370
371
372
	if (!ext_csd)
		return -ENOMEM;

373
374
	err = mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, ext_csd,
				512);
375
376
377
378
379
380
381
382
383
	if (err)
		kfree(ext_csd);
	else
		*new_ext_csd = ext_csd;

	return err;
}
EXPORT_SYMBOL_GPL(mmc_get_ext_csd);

David Brownell's avatar
David Brownell committed
384
385
int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
{
386
	struct mmc_command cmd = {};
David Brownell's avatar
David Brownell committed
387
388
389
390
391
392
393
394
395
396
397
398
399
400
	int err;

	cmd.opcode = MMC_SPI_READ_OCR;
	cmd.arg = highcap ? (1 << 30) : 0;
	cmd.flags = MMC_RSP_SPI_R3;

	err = mmc_wait_for_cmd(host, &cmd, 0);

	*ocrp = cmd.resp[1];
	return err;
}

int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
{
401
	struct mmc_command cmd = {};
David Brownell's avatar
David Brownell committed
402
403
404
405
406
407
408
409
410
411
412
413
	int err;

	cmd.opcode = MMC_SPI_CRC_ON_OFF;
	cmd.flags = MMC_RSP_SPI_R1;
	cmd.arg = use_crc;

	err = mmc_wait_for_cmd(host, &cmd, 0);
	if (!err)
		host->use_spi_crc = use_crc;
	return err;
}

414
static int mmc_switch_status_error(struct mmc_host *host, u32 status)
415
416
417
418
419
{
	if (mmc_host_is_spi(host)) {
		if (status & R1_SPI_ILLEGAL_COMMAND)
			return -EBADMSG;
	} else {
420
		if (R1_STATUS(status))
421
422
423
424
425
426
427
428
			pr_warn("%s: unexpected status %#x after switch\n",
				mmc_hostname(host), status);
		if (status & R1_SWITCH_ERROR)
			return -EBADMSG;
	}
	return 0;
}

429
/* Caller must hold re-tuning */
430
int __mmc_switch_status(struct mmc_card *card, bool crc_err_fatal)
431
432
433
434
435
{
	u32 status;
	int err;

	err = mmc_send_status(card, &status);
436
437
	if (!crc_err_fatal && err == -EILSEQ)
		return 0;
438
439
440
441
442
443
	if (err)
		return err;

	return mmc_switch_status_error(card->host, status);
}

444
445
446
447
448
int mmc_switch_status(struct mmc_card *card)
{
	return __mmc_switch_status(card, true);
}

449
static int mmc_poll_for_busy(struct mmc_card *card, unsigned int timeout_ms,
450
			bool send_status, bool retry_crc_err)
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
{
	struct mmc_host *host = card->host;
	int err;
	unsigned long timeout;
	u32 status = 0;
	bool expired = false;
	bool busy = false;

	/* We have an unspecified cmd timeout, use the fallback value. */
	if (!timeout_ms)
		timeout_ms = MMC_OPS_TIMEOUT_MS;

	/*
	 * In cases when not allowed to poll by using CMD13 or because we aren't
	 * capable of polling by using ->card_busy(), then rely on waiting the
	 * stated timeout to be sufficient.
	 */
	if (!send_status && !host->ops->card_busy) {
		mmc_delay(timeout_ms);
		return 0;
	}

	timeout = jiffies + msecs_to_jiffies(timeout_ms) + 1;
	do {
		/*
476
477
		 * Due to the possibility of being preempted while polling,
		 * check the expiration time first.
478
479
		 */
		expired = time_after(jiffies, timeout);
480
481
482
483

		if (host->ops->card_busy) {
			busy = host->ops->card_busy(host);
		} else {
484
			err = mmc_send_status(card, &status);
485
			if (retry_crc_err && err == -EILSEQ) {
486
				busy = true;
487
			} else if (err) {
488
				return err;
489
490
491
492
			} else {
				err = mmc_switch_status_error(host, status);
				if (err)
					return err;
493
				busy = R1_CURRENT_STATE(status) == R1_STATE_PRG;
494
			}
495
496
		}

497
498
499
		/* Timeout if the device still remains busy. */
		if (expired && busy) {
			pr_err("%s: Card stuck being busy! %s\n",
500
501
502
				mmc_hostname(host), __func__);
			return -ETIMEDOUT;
		}
503
	} while (busy);
504

505
	return 0;
506
507
}

508
/**
509
 *	__mmc_switch - modify EXT_CSD register
510
511
512
513
514
515
 *	@card: the MMC card associated with the data transfer
 *	@set: cmd set values
 *	@index: EXT_CSD register index
 *	@value: value to program into EXT_CSD register
 *	@timeout_ms: timeout (ms) for operation performed by register write,
 *                   timeout of zero implies maximum possible timeout
516
 *	@timing: new timing to change to
517
 *	@use_busy_signal: use the busy signal as response type
518
 *	@send_status: send status cmd to poll for busy
519
 *	@retry_crc_err: retry when CRC errors when polling with CMD13 for busy
520
521
522
 *
 *	Modifies the EXT_CSD register for selected card.
 */
523
int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
524
525
		unsigned int timeout_ms, unsigned char timing,
		bool use_busy_signal, bool send_status,	bool retry_crc_err)
Pierre Ossman's avatar
Pierre Ossman committed
526
{
527
	struct mmc_host *host = card->host;
Pierre Ossman's avatar
Pierre Ossman committed
528
	int err;
529
	struct mmc_command cmd = {};
530
	bool use_r1b_resp = use_busy_signal;
531
	unsigned char old_timing = host->ios.timing;
532

533
534
	mmc_retune_hold(host);

535
536
537
538
539
540
541
542
543
	/*
	 * If the cmd timeout and the max_busy_timeout of the host are both
	 * specified, let's validate them. A failure means we need to prevent
	 * the host from doing hw busy detection, which is done by converting
	 * to a R1 response instead of a R1B.
	 */
	if (timeout_ms && host->max_busy_timeout &&
		(timeout_ms > host->max_busy_timeout))
		use_r1b_resp = false;
Pierre Ossman's avatar
Pierre Ossman committed
544
545
546
547
548
549

	cmd.opcode = MMC_SWITCH;
	cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
		  (index << 16) |
		  (value << 8) |
		  set;
550
	cmd.flags = MMC_CMD_AC;
551
	if (use_r1b_resp) {
552
		cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
553
554
555
556
557
558
		/*
		 * A busy_timeout of zero means the host can decide to use
		 * whatever value it finds suitable.
		 */
		cmd.busy_timeout = timeout_ms;
	} else {
559
		cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
560
	}
561

562
563
	if (index == EXT_CSD_SANITIZE_START)
		cmd.sanitize_busy = true;
Pierre Ossman's avatar
Pierre Ossman committed
564

565
	err = mmc_wait_for_cmd(host, &cmd, 0);
Pierre Ossman's avatar
Pierre Ossman committed
566
	if (err)
567
		goto out;
Pierre Ossman's avatar
Pierre Ossman committed
568

569
570
	/* No need to check card status in case of unblocking command */
	if (!use_busy_signal)
571
		goto out;
572

573
574
	/*If SPI or used HW busy detection above, then we don't need to poll. */
	if (((host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp) ||
575
		mmc_host_is_spi(host))
576
		goto out_tim;
577

578
	/* Let's try to poll to find out when the command is completed. */
579
	err = mmc_poll_for_busy(card, timeout_ms, send_status, retry_crc_err);
580
581
	if (err)
		goto out;
582
583

out_tim:
584
585
586
587
588
589
590
591
592
	/* Switch to new timing before check switch status. */
	if (timing)
		mmc_set_timing(host, timing);

	if (send_status) {
		err = mmc_switch_status(card);
		if (err && timing)
			mmc_set_timing(host, old_timing);
	}
593
594
out:
	mmc_retune_release(host);
595

596
	return err;
Pierre Ossman's avatar
Pierre Ossman committed
597
}
598
599
600
601

int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
		unsigned int timeout_ms)
{
602
603
	return __mmc_switch(card, set, index, value, timeout_ms, 0,
			true, true, false);
604
}
605
EXPORT_SYMBOL_GPL(mmc_switch);
Pierre Ossman's avatar
Pierre Ossman committed
606

607
int mmc_send_tuning(struct mmc_host *host, u32 opcode, int *cmd_error)
608
{
609
610
611
	struct mmc_request mrq = {};
	struct mmc_command cmd = {};
	struct mmc_data data = {};
612
	struct scatterlist sg;
613
	struct mmc_ios *ios = &host->ios;
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
	const u8 *tuning_block_pattern;
	int size, err = 0;
	u8 *data_buf;

	if (ios->bus_width == MMC_BUS_WIDTH_8) {
		tuning_block_pattern = tuning_blk_pattern_8bit;
		size = sizeof(tuning_blk_pattern_8bit);
	} else if (ios->bus_width == MMC_BUS_WIDTH_4) {
		tuning_block_pattern = tuning_blk_pattern_4bit;
		size = sizeof(tuning_blk_pattern_4bit);
	} else
		return -EINVAL;

	data_buf = kzalloc(size, GFP_KERNEL);
	if (!data_buf)
		return -ENOMEM;

	mrq.cmd = &cmd;
	mrq.data = &data;

	cmd.opcode = opcode;
	cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;

	data.blksz = size;
	data.blocks = 1;
	data.flags = MMC_DATA_READ;

	/*
	 * According to the tuning specs, Tuning process
	 * is normally shorter 40 executions of CMD19,
	 * and timeout value should be shorter than 150 ms
	 */
	data.timeout_ns = 150 * NSEC_PER_MSEC;

	data.sg = &sg;
	data.sg_len = 1;
	sg_init_one(&sg, data_buf, size);

652
	mmc_wait_for_req(host, &mrq);
653

654
655
656
	if (cmd_error)
		*cmd_error = cmd.error;

657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
	if (cmd.error) {
		err = cmd.error;
		goto out;
	}

	if (data.error) {
		err = data.error;
		goto out;
	}

	if (memcmp(data_buf, tuning_block_pattern, size))
		err = -EIO;

out:
	kfree(data_buf);
	return err;
}
EXPORT_SYMBOL_GPL(mmc_send_tuning);

676
677
int mmc_abort_tuning(struct mmc_host *host, u32 opcode)
{
678
	struct mmc_command cmd = {};
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700

	/*
	 * eMMC specification specifies that CMD12 can be used to stop a tuning
	 * command, but SD specification does not, so do nothing unless it is
	 * eMMC.
	 */
	if (opcode != MMC_SEND_TUNING_BLOCK_HS200)
		return 0;

	cmd.opcode = MMC_STOP_TRANSMISSION;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;

	/*
	 * For drivers that override R1 to R1b, set an arbitrary timeout based
	 * on the tuning timeout i.e. 150ms.
	 */
	cmd.busy_timeout = 150;

	return mmc_wait_for_cmd(host, &cmd, 0);
}
EXPORT_SYMBOL_GPL(mmc_abort_tuning);

701
702
703
704
static int
mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
		  u8 len)
{
705
706
707
	struct mmc_request mrq = {};
	struct mmc_command cmd = {};
	struct mmc_data data = {};
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
	struct scatterlist sg;
	u8 *data_buf;
	u8 *test_buf;
	int i, err;
	static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
	static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };

	/* dma onto stack is unsafe/nonportable, but callers to this
	 * routine normally provide temporary on-stack buffers ...
	 */
	data_buf = kmalloc(len, GFP_KERNEL);
	if (!data_buf)
		return -ENOMEM;

	if (len == 8)
		test_buf = testdata_8bit;
	else if (len == 4)
		test_buf = testdata_4bit;
	else {
727
		pr_err("%s: Invalid bus_width %d\n",
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
		       mmc_hostname(host), len);
		kfree(data_buf);
		return -EINVAL;
	}

	if (opcode == MMC_BUS_TEST_W)
		memcpy(data_buf, test_buf, len);

	mrq.cmd = &cmd;
	mrq.data = &data;
	cmd.opcode = opcode;
	cmd.arg = 0;

	/* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
	 * rely on callers to never use this with "native" calls for reading
	 * CSD or CID.  Native versions of those commands use the R2 type,
	 * not R1 plus a data block.
	 */
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

	data.blksz = len;
	data.blocks = 1;
	if (opcode == MMC_BUS_TEST_R)
		data.flags = MMC_DATA_READ;
	else
		data.flags = MMC_DATA_WRITE;

	data.sg = &sg;
	data.sg_len = 1;
757
	mmc_set_data_timeout(&data, card);
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
	sg_init_one(&sg, data_buf, len);
	mmc_wait_for_req(host, &mrq);
	err = 0;
	if (opcode == MMC_BUS_TEST_R) {
		for (i = 0; i < len / 4; i++)
			if ((test_buf[i] ^ data_buf[i]) != 0xff) {
				err = -EIO;
				break;
			}
	}
	kfree(data_buf);

	if (cmd.error)
		return cmd.error;
	if (data.error)
		return data.error;

	return err;
}

int mmc_bus_test(struct mmc_card *card, u8 bus_width)
{
780
	int width;
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795

	if (bus_width == MMC_BUS_WIDTH_8)
		width = 8;
	else if (bus_width == MMC_BUS_WIDTH_4)
		width = 4;
	else if (bus_width == MMC_BUS_WIDTH_1)
		return 0; /* no need for test */
	else
		return -EINVAL;

	/*
	 * Ignore errors from BUS_TEST_W.  BUS_TEST_R will fail if there
	 * is a problem.  This improves chances that the test will work.
	 */
	mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
796
	return mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
797
}
798

799
static int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
800
{
801
	struct mmc_command cmd = {};
802
803
804
805
806
	unsigned int opcode;
	int err;

	opcode = card->ext_csd.hpi_cmd;
	if (opcode == MMC_STOP_TRANSMISSION)
807
		cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
808
	else if (opcode == MMC_SEND_STATUS)
809
		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825

	cmd.opcode = opcode;
	cmd.arg = card->rca << 16 | 1;

	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err) {
		pr_warn("%s: error %d interrupting operation. "
			"HPI command response %#x\n", mmc_hostname(card->host),
			err, cmd.resp[0]);
		return err;
	}
	if (status)
		*status = cmd.resp[0];

	return 0;
}
826

827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
/**
 *	mmc_interrupt_hpi - Issue for High priority Interrupt
 *	@card: the MMC card associated with the HPI transfer
 *
 *	Issued High Priority Interrupt, and check for card status
 *	until out-of prg-state.
 */
int mmc_interrupt_hpi(struct mmc_card *card)
{
	int err;
	u32 status;
	unsigned long prg_wait;

	if (!card->ext_csd.hpi_en) {
		pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
		return 1;
	}

	err = mmc_send_status(card, &status);
	if (err) {
		pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
		goto out;
	}

	switch (R1_CURRENT_STATE(status)) {
	case R1_STATE_IDLE:
	case R1_STATE_READY:
	case R1_STATE_STBY:
	case R1_STATE_TRAN:
		/*
		 * In idle and transfer states, HPI is not needed and the caller
		 * can issue the next intended command immediately
		 */
		goto out;
	case R1_STATE_PRG:
		break;
	default:
		/* In all other states, it's illegal to issue HPI */
		pr_debug("%s: HPI cannot be sent. Card state=%d\n",
			mmc_hostname(card->host), R1_CURRENT_STATE(status));
		err = -EINVAL;
		goto out;
	}

	err = mmc_send_hpi_cmd(card, &status);
	if (err)
		goto out;

	prg_wait = jiffies + msecs_to_jiffies(card->ext_csd.out_of_int_time);
	do {
		err = mmc_send_status(card, &status);

		if (!err && R1_CURRENT_STATE(status) == R1_STATE_TRAN)
			break;
		if (time_after(jiffies, prg_wait))
			err = -ETIMEDOUT;
	} while (!err);

out:
	return err;
}

889
890
891
892
int mmc_can_ext_csd(struct mmc_card *card)
{
	return (card && card->csd.mmca_vsn > CSD_SPEC_VER_3);
}
893

894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
static int mmc_read_bkops_status(struct mmc_card *card)
{
	int err;
	u8 *ext_csd;

	err = mmc_get_ext_csd(card, &ext_csd);
	if (err)
		return err;

	card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
	card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
	kfree(ext_csd);
	return 0;
}

/**
Ulf Hansson's avatar
Ulf Hansson committed
910
911
 *	mmc_run_bkops - Run BKOPS for supported cards
 *	@card: MMC card to run BKOPS for
912
 *
Ulf Hansson's avatar
Ulf Hansson committed
913
914
 *	Run background operations synchronously for cards having manual BKOPS
 *	enabled and in case it reports urgent BKOPS level.
915
*/
Ulf Hansson's avatar
Ulf Hansson committed
916
void mmc_run_bkops(struct mmc_card *card)
917
918
919
{
	int err;

Ulf Hansson's avatar
Ulf Hansson committed
920
	if (!card->ext_csd.man_bkops_en)
921
922
923
924
925
926
927
928
929
		return;

	err = mmc_read_bkops_status(card);
	if (err) {
		pr_err("%s: Failed to read bkops status: %d\n",
		       mmc_hostname(card->host), err);
		return;
	}

Ulf Hansson's avatar
Ulf Hansson committed
930
931
	if (!card->ext_csd.raw_bkops_status ||
	    card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2)
932
933
934
935
		return;

	mmc_retune_hold(card->host);

Ulf Hansson's avatar
Ulf Hansson committed
936
937
938
939
940
941
942
943
	/*
	 * For urgent BKOPS status, LEVEL_2 and higher, let's execute
	 * synchronously. Future wise, we may consider to start BKOPS, for less
	 * urgent levels by using an asynchronous background task, when idle.
	 */
	err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
			EXT_CSD_BKOPS_START, 1, MMC_OPS_TIMEOUT_MS);
	if (err)
944
945
946
		pr_warn("%s: Error %d starting bkops\n",
			mmc_hostname(card->host), err);

Ulf Hansson's avatar
Ulf Hansson committed
947
	mmc_retune_release(card->host);
948
}
Ulf Hansson's avatar
Ulf Hansson committed
949
EXPORT_SYMBOL(mmc_run_bkops);
950

951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
/*
 * Flush the cache to the non-volatile storage.
 */
int mmc_flush_cache(struct mmc_card *card)
{
	int err = 0;

	if (mmc_card_mmc(card) &&
			(card->ext_csd.cache_size > 0) &&
			(card->ext_csd.cache_ctrl & 1)) {
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				EXT_CSD_FLUSH_CACHE, 1, 0);
		if (err)
			pr_err("%s: cache flush error %d\n",
					mmc_hostname(card->host), err);
	}

	return err;
}
EXPORT_SYMBOL(mmc_flush_cache);

972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
static int mmc_cmdq_switch(struct mmc_card *card, bool enable)
{
	u8 val = enable ? EXT_CSD_CMDQ_MODE_ENABLED : 0;
	int err;

	if (!card->ext_csd.cmdq_support)
		return -EOPNOTSUPP;

	err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_CMDQ_MODE_EN,
			 val, card->ext_csd.generic_cmd6_time);
	if (!err)
		card->ext_csd.cmdq_en = enable;

	return err;
}

int mmc_cmdq_enable(struct mmc_card *card)
{
	return mmc_cmdq_switch(card, true);
}
EXPORT_SYMBOL_GPL(mmc_cmdq_enable);

int mmc_cmdq_disable(struct mmc_card *card)
{
	return mmc_cmdq_switch(card, false);
}
EXPORT_SYMBOL_GPL(mmc_cmdq_disable);