sdio_cis.c 8.81 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
2 3 4 5 6 7 8
/*
 * linux/drivers/mmc/core/sdio_cis.c
 *
 * Author:	Nicolas Pitre
 * Created:	June 11, 2007
 * Copyright:	MontaVista Software Inc.
 *
9
 * Copyright 2007 Pierre Ossman
10 11 12
 */

#include <linux/kernel.h>
13
#include <linux/slab.h>
14 15

#include <linux/mmc/host.h>
16
#include <linux/mmc/card.h>
17 18 19 20 21 22
#include <linux/mmc/sdio.h>
#include <linux/mmc/sdio_func.h>

#include "sdio_cis.h"
#include "sdio_ops.h"

Pierre Ossman's avatar
Pierre Ossman committed
23 24 25 26 27 28
static int cistpl_vers_1(struct mmc_card *card, struct sdio_func *func,
			 const unsigned char *buf, unsigned size)
{
	unsigned i, nr_strings;
	char **buffer, *string;

29 30
	/* Find all null-terminated (including zero length) strings in
	   the TPLLV1_INFO field. Trailing garbage is ignored. */
Pierre Ossman's avatar
Pierre Ossman committed
31 32 33 34 35 36 37 38 39 40
	buf += 2;
	size -= 2;

	nr_strings = 0;
	for (i = 0; i < size; i++) {
		if (buf[i] == 0xff)
			break;
		if (buf[i] == 0)
			nr_strings++;
	}
41
	if (nr_strings == 0)
Pierre Ossman's avatar
Pierre Ossman committed
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
		return 0;

	size = i;

	buffer = kzalloc(sizeof(char*) * nr_strings + size, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	string = (char*)(buffer + nr_strings);

	for (i = 0; i < nr_strings; i++) {
		buffer[i] = string;
		strcpy(string, buf);
		string += strlen(string) + 1;
		buf += strlen(buf) + 1;
	}

	if (func) {
		func->num_info = nr_strings;
		func->info = (const char**)buffer;
	} else {
		card->num_info = nr_strings;
		card->info = (const char**)buffer;
	}

	return 0;
}

70 71
static int cistpl_manfid(struct mmc_card *card, struct sdio_func *func,
			 const unsigned char *buf, unsigned size)
72
{
73 74
	unsigned int vendor, device;

75
	/* TPLMID_MANF */
76
	vendor = buf[0] | (buf[1] << 8);
77 78

	/* TPLMID_CARD */
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
	device = buf[2] | (buf[3] << 8);

	if (func) {
		func->vendor = vendor;
		func->device = device;
	} else {
		card->cis.vendor = vendor;
		card->cis.device = device;
	}

	return 0;
}

static const unsigned char speed_val[16] =
	{ 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 };
static const unsigned int speed_unit[8] =
	{ 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };

97 98 99 100 101 102 103 104

typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *,
			   const unsigned char *, unsigned);

struct cis_tpl {
	unsigned char code;
	unsigned char min_size;
	tpl_parse_t *parse;
105 106
};

107 108 109 110 111
static int cis_tpl_parse(struct mmc_card *card, struct sdio_func *func,
			 const char *tpl_descr,
			 const struct cis_tpl *tpl, int tpl_count,
			 unsigned char code,
			 const unsigned char *buf, unsigned size)
112
{
113
	int i, ret;
114

115 116 117 118
	/* look for a matching code in the table */
	for (i = 0; i < tpl_count; i++, tpl++) {
		if (tpl->code == code)
			break;
119
	}
120 121 122 123 124 125 126 127 128 129 130
	if (i < tpl_count) {
		if (size >= tpl->min_size) {
			if (tpl->parse)
				ret = tpl->parse(card, func, buf, size);
			else
				ret = -EILSEQ;	/* known tuple, not parsed */
		} else {
			/* invalid tuple */
			ret = -EINVAL;
		}
		if (ret && ret != -EILSEQ && ret != -ENOENT) {
131
			pr_err("%s: bad %s tuple 0x%02x (%u bytes)\n",
132 133 134 135 136 137 138 139
			       mmc_hostname(card->host), tpl_descr, code, size);
		}
	} else {
		/* unknown tuple */
		ret = -ENOENT;
	}

	return ret;
140 141
}

142
static int cistpl_funce_common(struct mmc_card *card, struct sdio_func *func,
143 144
			       const unsigned char *buf, unsigned size)
{
145 146
	/* Only valid for the common CIS (function 0) */
	if (func)
147 148 149 150 151 152 153 154 155 156 157 158
		return -EINVAL;

	/* TPLFE_FN0_BLK_SIZE */
	card->cis.blksize = buf[1] | (buf[2] << 8);

	/* TPLFE_MAX_TRAN_SPEED */
	card->cis.max_dtr = speed_val[(buf[3] >> 3) & 15] *
			    speed_unit[buf[3] & 7];

	return 0;
}

159
static int cistpl_funce_func(struct mmc_card *card, struct sdio_func *func,
160 161 162 163 164
			     const unsigned char *buf, unsigned size)
{
	unsigned vsn;
	unsigned min_size;

165 166 167
	/* Only valid for the individual function's CIS (1-7) */
	if (!func)
		return -EINVAL;
168

169 170 171 172
	/*
	 * This tuple has a different length depending on the SDIO spec
	 * version.
	 */
173 174 175
	vsn = func->card->cccr.sdio_vsn;
	min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;

176 177 178 179 180
	if (size == 28 && vsn == SDIO_SDIO_REV_1_10) {
		pr_warn("%s: card has broken SDIO 1.1 CIS, forcing SDIO 1.0\n",
			mmc_hostname(card->host));
		vsn = SDIO_SDIO_REV_1_00;
	} else if (size < min_size) {
181
		return -EINVAL;
182
	}
183 184

	/* TPLFE_MAX_BLK_SIZE */
185
	func->max_blksize = buf[12] | (buf[13] << 8);
186

187 188 189 190 191 192
	/* TPLFE_ENABLE_TIMEOUT_VAL, present in ver 1.1 and above */
	if (vsn > SDIO_SDIO_REV_1_00)
		func->enable_timeout = (buf[28] | (buf[29] << 8)) * 10;
	else
		func->enable_timeout = jiffies_to_msecs(HZ);

193 194 195
	return 0;
}

196 197 198 199 200 201 202 203 204 205 206 207 208
/*
 * Known TPLFE_TYPEs table for CISTPL_FUNCE tuples.
 *
 * Note that, unlike PCMCIA, CISTPL_FUNCE tuples are not parsed depending
 * on the TPLFID_FUNCTION value of the previous CISTPL_FUNCID as on SDIO
 * TPLFID_FUNCTION is always hardcoded to 0x0C.
 */
static const struct cis_tpl cis_tpl_funce_list[] = {
	{	0x00,	4,	cistpl_funce_common		},
	{	0x01,	0,	cistpl_funce_func		},
	{	0x04,	1+1+6,	/* CISTPL_FUNCE_LAN_NODE_ID */	},
};

209 210 211
static int cistpl_funce(struct mmc_card *card, struct sdio_func *func,
			const unsigned char *buf, unsigned size)
{
212 213
	if (size < 1)
		return -EINVAL;
214

215 216 217 218
	return cis_tpl_parse(card, func, "CISTPL_FUNCE",
			     cis_tpl_funce_list,
			     ARRAY_SIZE(cis_tpl_funce_list),
			     buf[0], buf, size);
219 220
}

221
/* Known TPL_CODEs table for CIS tuples */
222
static const struct cis_tpl cis_tpl_list[] = {
Pierre Ossman's avatar
Pierre Ossman committed
223
	{	0x15,	3,	cistpl_vers_1		},
224 225
	{	0x20,	4,	cistpl_manfid		},
	{	0x21,	2,	/* cistpl_funcid */	},
226
	{	0x22,	0,	cistpl_funce		},
227
	{	0x91,	2,	/* cistpl_sdio_std */	},
228 229
};

230
static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
231 232
{
	int ret;
233
	struct sdio_func_tuple *this, **prev;
234 235
	unsigned i, ptr = 0;

236 237 238 239 240
	/*
	 * Note that this works for the common CIS (function number 0) as
	 * well as a function's CIS * since SDIO_CCCR_CIS and SDIO_FBR_CIS
	 * have the same offset.
	 */
241
	for (i = 0; i < 3; i++) {
242 243 244 245 246 247 248 249
		unsigned char x, fn;

		if (func)
			fn = func->num;
		else
			fn = 0;

		ret = mmc_io_rw_direct(card, 0, 0,
250
			SDIO_FBR_BASE(fn) + SDIO_FBR_CIS + i, 0, &x);
251 252 253 254 255
		if (ret)
			return ret;
		ptr |= x << (i * 8);
	}

256 257 258 259 260
	if (func)
		prev = &func->tuples;
	else
		prev = &card->tuples;

261 262
	if (*prev)
		return -EINVAL;
263 264 265 266

	do {
		unsigned char tpl_code, tpl_link;

267
		ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_code);
268 269 270 271 272 273 274
		if (ret)
			break;

		/* 0xff means we're done */
		if (tpl_code == 0xff)
			break;

Pierre Ossman's avatar
Pierre Ossman committed
275 276 277 278
		/* null entries have no link field or data */
		if (tpl_code == 0x00)
			continue;

279
		ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_link);
280 281 282
		if (ret)
			break;

283 284 285 286
		/* a size of 0xff also means we're done */
		if (tpl_link == 0xff)
			break;

287 288 289 290 291
		this = kmalloc(sizeof(*this) + tpl_link, GFP_KERNEL);
		if (!this)
			return -ENOMEM;

		for (i = 0; i < tpl_link; i++) {
292
			ret = mmc_io_rw_direct(card, 0, 0,
293 294
					       ptr + i, 0, &this->data[i]);
			if (ret)
295 296
				break;
		}
297 298
		if (ret) {
			kfree(this);
299 300 301
			break;
		}

302 303 304 305 306
		/* Try to parse the CIS tuple */
		ret = cis_tpl_parse(card, func, "CIS",
				    cis_tpl_list, ARRAY_SIZE(cis_tpl_list),
				    tpl_code, this->data, tpl_link);
		if (ret == -EILSEQ || ret == -ENOENT) {
307
			/*
308 309
			 * The tuple is unknown or known but not parsed.
			 * Queue the tuple for the function driver.
310 311 312 313 314 315
			 */
			this->next = NULL;
			this->code = tpl_code;
			this->size = tpl_link;
			*prev = this;
			prev = &this->next;
316 317 318

			if (ret == -ENOENT) {
				/* warn about unknown tuples */
319
				pr_warn_ratelimited("%s: queuing unknown"
320 321 322 323 324
				       " CIS tuple 0x%02x (%u bytes)\n",
				       mmc_hostname(card->host),
				       tpl_code, tpl_link);
			}

325 326
			/* keep on analyzing tuples */
			ret = 0;
327 328 329 330 331 332 333
		} else {
			/*
			 * We don't need the tuple anymore if it was
			 * successfully parsed by the SDIO core or if it is
			 * not going to be queued for a driver.
			 */
			kfree(this);
334 335
		}

336
		ptr += tpl_link;
337 338
	} while (!ret);

339 340 341 342 343 344 345
	/*
	 * Link in all unknown tuples found in the common CIS so that
	 * drivers don't have to go digging in two places.
	 */
	if (func)
		*prev = card->tuples;

346 347
	return ret;
}
348

349 350 351 352 353 354
int sdio_read_common_cis(struct mmc_card *card)
{
	return sdio_read_cis(card, NULL);
}

void sdio_free_common_cis(struct mmc_card *card)
355 356 357
{
	struct sdio_func_tuple *tuple, *victim;

358
	tuple = card->tuples;
359 360 361 362 363 364 365

	while (tuple) {
		victim = tuple;
		tuple = tuple->next;
		kfree(victim);
	}

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
	card->tuples = NULL;
}

int sdio_read_func_cis(struct sdio_func *func)
{
	int ret;

	ret = sdio_read_cis(func->card, func);
	if (ret)
		return ret;

	/*
	 * Since we've linked to tuples in the card structure,
	 * we must make sure we have a reference to it.
	 */
	get_device(&func->card->dev);

	/*
	 * Vendor/device id is optional for function CIS, so
	 * copy it from the card structure as needed.
	 */
	if (func->vendor == 0) {
		func->vendor = func->card->cis.vendor;
		func->device = func->card->cis.device;
	}

	return 0;
}

void sdio_free_func_cis(struct sdio_func *func)
{
	struct sdio_func_tuple *tuple, *victim;

	tuple = func->tuples;

	while (tuple && tuple != func->card->tuples) {
		victim = tuple;
		tuple = tuple->next;
		kfree(victim);
	}

407
	func->tuples = NULL;
408 409 410 411 412 413

	/*
	 * We have now removed the link to the tuples in the
	 * card structure, so remove the reference.
	 */
	put_device(&func->card->dev);
414 415
}