[linux.git] / drivers / mmc / core / card.h

/*
 * Private header for the mmc subsystem
 *
 * Copyright (C) 2016 Linaro Ltd
 *
 * Author: Ulf Hansson <[email protected]>
 *
 * License terms: GNU General Public License (GPL) version 2
 */

#ifndef _MMC_CORE_CARD_H
#define _MMC_CORE_CARD_H

#include <linux/mmc/card.h>

#define mmc_card_name(c)	((c)->cid.prod_name)
#define mmc_card_id(c)		(dev_name(&(c)->dev))
#define mmc_dev_to_card(d)	container_of(d, struct mmc_card, dev)

/* Card states */
#define MMC_STATE_PRESENT	(1<<0)		/* present in sysfs */
#define MMC_STATE_READONLY	(1<<1)		/* card is read-only */
#define MMC_STATE_BLOCKADDR	(1<<2)		/* card uses block-addressing */
#define MMC_CARD_SDXC		(1<<3)		/* card is SDXC */
#define MMC_CARD_REMOVED	(1<<4)		/* card has been removed */
#define MMC_STATE_DOING_BKOPS	(1<<5)		/* card is doing BKOPS */
#define MMC_STATE_SUSPENDED	(1<<6)		/* card is suspended */

#define mmc_card_present(c)	((c)->state & MMC_STATE_PRESENT)
#define mmc_card_readonly(c)	((c)->state & MMC_STATE_READONLY)
#define mmc_card_blockaddr(c)	((c)->state & MMC_STATE_BLOCKADDR)
#define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
#define mmc_card_removed(c)	((c) && ((c)->state & MMC_CARD_REMOVED))
#define mmc_card_doing_bkops(c)	((c)->state & MMC_STATE_DOING_BKOPS)
#define mmc_card_suspended(c)	((c)->state & MMC_STATE_SUSPENDED)

#define mmc_card_set_present(c)	((c)->state |= MMC_STATE_PRESENT)
#define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)
#define mmc_card_set_blockaddr(c) ((c)->state |= MMC_STATE_BLOCKADDR)
#define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC)
#define mmc_card_set_removed(c) ((c)->state |= MMC_CARD_REMOVED)
#define mmc_card_set_doing_bkops(c)	((c)->state |= MMC_STATE_DOING_BKOPS)
#define mmc_card_clr_doing_bkops(c)	((c)->state &= ~MMC_STATE_DOING_BKOPS)
#define mmc_card_set_suspended(c) ((c)->state |= MMC_STATE_SUSPENDED)
#define mmc_card_clr_suspended(c) ((c)->state &= ~MMC_STATE_SUSPENDED)

/*
 * The world is not perfect and supplies us with broken mmc/sdio devices.
 * For at least some of these bugs we need a work-around.
 */
struct mmc_fixup {
	/* CID-specific fields. */
	const char *name;

	/* Valid revision range */
	u64 rev_start, rev_end;

	unsigned int manfid;
	unsigned short oemid;

	/* SDIO-specific fields. You can use SDIO_ANY_ID here of course */
	u16 cis_vendor, cis_device;

	/* for MMC cards */
	unsigned int ext_csd_rev;

	void (*vendor_fixup)(struct mmc_card *card, int data);
	int data;
};

#define CID_MANFID_ANY (-1u)
#define CID_OEMID_ANY ((unsigned short) -1)
#define CID_NAME_ANY (NULL)

#define EXT_CSD_REV_ANY (-1u)

#define CID_MANFID_SANDISK      0x2
#define CID_MANFID_ATP          0x9
#define CID_MANFID_TOSHIBA      0x11
#define CID_MANFID_MICRON       0x13
#define CID_MANFID_SAMSUNG      0x15
#define CID_MANFID_APACER       0x27
#define CID_MANFID_KINGSTON     0x70
#define CID_MANFID_HYNIX	0x90
#define CID_MANFID_NUMONYX	0xFE

#define END_FIXUP { NULL }

#define _FIXUP_EXT(_name, _manfid, _oemid, _rev_start, _rev_end,	\
		   _cis_vendor, _cis_device,				\
		   _fixup, _data, _ext_csd_rev)				\
	{						\
		.name = (_name),			\
		.manfid = (_manfid),			\
		.oemid = (_oemid),			\
		.rev_start = (_rev_start),		\
		.rev_end = (_rev_end),			\
		.cis_vendor = (_cis_vendor),		\
		.cis_device = (_cis_device),		\
		.vendor_fixup = (_fixup),		\
		.data = (_data),			\
		.ext_csd_rev = (_ext_csd_rev),		\
	}

#define MMC_FIXUP_REV(_name, _manfid, _oemid, _rev_start, _rev_end,	\
		      _fixup, _data, _ext_csd_rev)			\
	_FIXUP_EXT(_name, _manfid,					\
		   _oemid, _rev_start, _rev_end,			\
		   SDIO_ANY_ID, SDIO_ANY_ID,				\
		   _fixup, _data, _ext_csd_rev)				\

#define MMC_FIXUP(_name, _manfid, _oemid, _fixup, _data) \
	MMC_FIXUP_REV(_name, _manfid, _oemid, 0, -1ull, _fixup, _data,	\
		      EXT_CSD_REV_ANY)

#define MMC_FIXUP_EXT_CSD_REV(_name, _manfid, _oemid, _fixup, _data,	\
			      _ext_csd_rev)				\
	MMC_FIXUP_REV(_name, _manfid, _oemid, 0, -1ull, _fixup, _data,	\
		      _ext_csd_rev)

#define SDIO_FIXUP(_vendor, _device, _fixup, _data)			\
	_FIXUP_EXT(CID_NAME_ANY, CID_MANFID_ANY,			\
		    CID_OEMID_ANY, 0, -1ull,				\
		   _vendor, _device,					\
		   _fixup, _data, EXT_CSD_REV_ANY)			\

#define cid_rev(hwrev, fwrev, year, month)	\
	(((u64) hwrev) << 40 |			\
	 ((u64) fwrev) << 32 |			\
	 ((u64) year) << 16 |			\
	 ((u64) month))

#define cid_rev_card(card)			\
	cid_rev(card->cid.hwrev,		\
		    card->cid.fwrev,		\
		    card->cid.year,		\
		    card->cid.month)

/*
 * Unconditionally quirk add/remove.
 */
static inline void __maybe_unused add_quirk(struct mmc_card *card, int data)
{
	card->quirks |= data;
}

static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
{
	card->quirks &= ~data;
}

static inline void __maybe_unused add_limit_rate_quirk(struct mmc_card *card,
						       int data)
{
	card->quirk_max_rate = data;
}

/*
 * Quirk add/remove for MMC products.
 */
static inline void __maybe_unused add_quirk_mmc(struct mmc_card *card, int data)
{
	if (mmc_card_mmc(card))
		card->quirks |= data;
}

static inline void __maybe_unused remove_quirk_mmc(struct mmc_card *card,
						   int data)
{
	if (mmc_card_mmc(card))
		card->quirks &= ~data;
}

/*
 * Quirk add/remove for SD products.
 */
static inline void __maybe_unused add_quirk_sd(struct mmc_card *card, int data)
{
	if (mmc_card_sd(card))
		card->quirks |= data;
}

static inline void __maybe_unused remove_quirk_sd(struct mmc_card *card,
						   int data)
{
	if (mmc_card_sd(card))
		card->quirks &= ~data;
}

static inline int mmc_card_lenient_fn0(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_LENIENT_FN0;
}

static inline int mmc_blksz_for_byte_mode(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
}

static inline int mmc_card_disable_cd(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_DISABLE_CD;
}

static inline int mmc_card_nonstd_func_interface(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_NONSTD_FUNC_IF;
}

static inline int mmc_card_broken_byte_mode_512(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_BROKEN_BYTE_MODE_512;
}

static inline int mmc_card_long_read_time(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_LONG_READ_TIME;
}

static inline int mmc_card_broken_irq_polling(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_BROKEN_IRQ_POLLING;
}

static inline int mmc_card_broken_hpi(const struct mmc_card *c)
{
	return c->quirks & MMC_QUIRK_BROKEN_HPI;
}

#endif
Commit	Line	Data
4facdde1 UH	1	/*
	2	* Private header for the mmc subsystem
	3	*
	4	* Copyright (C) 2016 Linaro Ltd
	5	*
	6	* Author: Ulf Hansson <[email protected]>
	7	*
	8	* License terms: GNU General Public License (GPL) version 2
	9	*/
	10
	11	#ifndef _MMC_CORE_CARD_H
	12	#define _MMC_CORE_CARD_H
	13
	14	#include <linux/mmc/card.h>
	15
	16	#define mmc_card_name(c) ((c)->cid.prod_name)
	17	#define mmc_card_id(c) (dev_name(&(c)->dev))
	18	#define mmc_dev_to_card(d) container_of(d, struct mmc_card, dev)
	19
	20	/* Card states */
	21	#define MMC_STATE_PRESENT (1<<0) /* present in sysfs */
	22	#define MMC_STATE_READONLY (1<<1) /* card is read-only */
	23	#define MMC_STATE_BLOCKADDR (1<<2) /* card uses block-addressing */
	24	#define MMC_CARD_SDXC (1<<3) /* card is SDXC */
	25	#define MMC_CARD_REMOVED (1<<4) /* card has been removed */
	26	#define MMC_STATE_DOING_BKOPS (1<<5) /* card is doing BKOPS */
	27	#define MMC_STATE_SUSPENDED (1<<6) /* card is suspended */
	28
	29	#define mmc_card_present(c) ((c)->state & MMC_STATE_PRESENT)
	30	#define mmc_card_readonly(c) ((c)->state & MMC_STATE_READONLY)
	31	#define mmc_card_blockaddr(c) ((c)->state & MMC_STATE_BLOCKADDR)
	32	#define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
	33	#define mmc_card_removed(c) ((c) && ((c)->state & MMC_CARD_REMOVED))
	34	#define mmc_card_doing_bkops(c) ((c)->state & MMC_STATE_DOING_BKOPS)
	35	#define mmc_card_suspended(c) ((c)->state & MMC_STATE_SUSPENDED)
	36
	37	#define mmc_card_set_present(c) ((c)->state \|= MMC_STATE_PRESENT)
	38	#define mmc_card_set_readonly(c) ((c)->state \|= MMC_STATE_READONLY)
	39	#define mmc_card_set_blockaddr(c) ((c)->state \|= MMC_STATE_BLOCKADDR)
	40	#define mmc_card_set_ext_capacity(c) ((c)->state \|= MMC_CARD_SDXC)
	41	#define mmc_card_set_removed(c) ((c)->state \|= MMC_CARD_REMOVED)
	42	#define mmc_card_set_doing_bkops(c) ((c)->state \|= MMC_STATE_DOING_BKOPS)
	43	#define mmc_card_clr_doing_bkops(c) ((c)->state &= ~MMC_STATE_DOING_BKOPS)
	44	#define mmc_card_set_suspended(c) ((c)->state \|= MMC_STATE_SUSPENDED)
	45	#define mmc_card_clr_suspended(c) ((c)->state &= ~MMC_STATE_SUSPENDED)
	46
	47	/*
	48	* The world is not perfect and supplies us with broken mmc/sdio devices.
	49	* For at least some of these bugs we need a work-around.
	50	*/
	51	struct mmc_fixup {
	52	/* CID-specific fields. */
	53	const char *name;
	54
	55	/* Valid revision range */
	56	u64 rev_start, rev_end;
	57
	58	unsigned int manfid;
	59	unsigned short oemid;
	60
	61	/* SDIO-specific fields. You can use SDIO_ANY_ID here of course */
	62	u16 cis_vendor, cis_device;
	63
	64	/* for MMC cards */
65	unsigned int ext_csd_rev;
66
67	void (vendor_fixup)(struct mmc_card card, int data);
68	int data;
69	};
70
71	#define CID_MANFID_ANY (-1u)
72	#define CID_OEMID_ANY ((unsigned short) -1)
73	#define CID_NAME_ANY (NULL)
74
75	#define EXT_CSD_REV_ANY (-1u)
76
77	#define CID_MANFID_SANDISK 0x2
91516a2a	78	#define CID_MANFID_ATP 0x9
4facdde1 UH	79	#define CID_MANFID_TOSHIBA 0x11
	80	#define CID_MANFID_MICRON 0x13
	81	#define CID_MANFID_SAMSUNG 0x15
91516a2a	82	#define CID_MANFID_APACER 0x27
4facdde1 UH	83	#define CID_MANFID_KINGSTON 0x70
4facdde1 UH	84	#define CID_MANFID_HYNIX 0x90
dbe7dc6b	85	#define CID_MANFID_NUMONYX 0xFE
4facdde1 UH	86
	87	#define END_FIXUP { NULL }
	88
	89	#define _FIXUP_EXT(_name, _manfid, _oemid, _rev_start, _rev_end, \
	90	_cis_vendor, _cis_device, \
	91	_fixup, _data, _ext_csd_rev) \
	92	{ \
	93	.name = (_name), \
	94	.manfid = (_manfid), \
	95	.oemid = (_oemid), \
	96	.rev_start = (_rev_start), \
	97	.rev_end = (_rev_end), \
	98	.cis_vendor = (_cis_vendor), \
	99	.cis_device = (_cis_device), \
	100	.vendor_fixup = (_fixup), \
	101	.data = (_data), \
	102	.ext_csd_rev = (_ext_csd_rev), \
	103	}
	104
	105	#define MMC_FIXUP_REV(_name, _manfid, _oemid, _rev_start, _rev_end, \
	106	_fixup, _data, _ext_csd_rev) \
	107	_FIXUP_EXT(_name, _manfid, \
	108	_oemid, _rev_start, _rev_end, \
	109	SDIO_ANY_ID, SDIO_ANY_ID, \
	110	_fixup, _data, _ext_csd_rev) \
	111
	112	#define MMC_FIXUP(_name, _manfid, _oemid, _fixup, _data) \
	113	MMC_FIXUP_REV(_name, _manfid, _oemid, 0, -1ull, _fixup, _data, \
	114	EXT_CSD_REV_ANY)
	115
	116	#define MMC_FIXUP_EXT_CSD_REV(_name, _manfid, _oemid, _fixup, _data, \
	117	_ext_csd_rev) \
	118	MMC_FIXUP_REV(_name, _manfid, _oemid, 0, -1ull, _fixup, _data, \
	119	_ext_csd_rev)
	120
	121	#define SDIO_FIXUP(_vendor, _device, _fixup, _data) \
	122	_FIXUP_EXT(CID_NAME_ANY, CID_MANFID_ANY, \
	123	CID_OEMID_ANY, 0, -1ull, \
	124	_vendor, _device, \
	125	_fixup, _data, EXT_CSD_REV_ANY) \
	126
	127	#define cid_rev(hwrev, fwrev, year, month) \
	128	(((u64) hwrev) << 40 \| \
	129	((u64) fwrev) << 32 \| \
	130	((u64) year) << 16 \| \
	131	((u64) month))
	132
	133	#define cid_rev_card(card) \
	134	cid_rev(card->cid.hwrev, \
	135	card->cid.fwrev, \
	136	card->cid.year, \
	137	card->cid.month)
	138
	139	/*
	140	* Unconditionally quirk add/remove.
	141	*/
	142	static inline void __maybe_unused add_quirk(struct mmc_card *card, int data)
	143	{
	144	card->quirks \|= data;
	145	}
	146
	147	static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
	148	{
	149	card->quirks &= ~data;
150	}
151
ebc5a1bf	152	static inline void __maybe_unused add_limit_rate_quirk(struct mmc_card *card,
	153	int data)
	154	{
	155	card->quirk_max_rate = data;
	156	}
	157
4facdde1 UH	158	/*
	159	* Quirk add/remove for MMC products.
	160	*/
	161	static inline void __maybe_unused add_quirk_mmc(struct mmc_card *card, int data)
	162	{
	163	if (mmc_card_mmc(card))
	164	card->quirks \|= data;
	165	}
	166
	167	static inline void __maybe_unused remove_quirk_mmc(struct mmc_card *card,
	168	int data)
	169	{
	170	if (mmc_card_mmc(card))
	171	card->quirks &= ~data;
	172	}
	173
	174	/*
	175	* Quirk add/remove for SD products.
	176	*/
	177	static inline void __maybe_unused add_quirk_sd(struct mmc_card *card, int data)
	178	{
	179	if (mmc_card_sd(card))
	180	card->quirks \|= data;
	181	}
	182
	183	static inline void __maybe_unused remove_quirk_sd(struct mmc_card *card,
	184	int data)
	185	{
	186	if (mmc_card_sd(card))
	187	card->quirks &= ~data;
	188	}
	189
	190	static inline int mmc_card_lenient_fn0(const struct mmc_card *c)
	191	{
	192	return c->quirks & MMC_QUIRK_LENIENT_FN0;
	193	}
	194
	195	static inline int mmc_blksz_for_byte_mode(const struct mmc_card *c)
	196	{
	197	return c->quirks & MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
	198	}
	199
	200	static inline int mmc_card_disable_cd(const struct mmc_card *c)
	201	{
	202	return c->quirks & MMC_QUIRK_DISABLE_CD;
	203	}
	204
	205	static inline int mmc_card_nonstd_func_interface(const struct mmc_card *c)
	206	{
	207	return c->quirks & MMC_QUIRK_NONSTD_FUNC_IF;
	208	}
	209
	210	static inline int mmc_card_broken_byte_mode_512(const struct mmc_card *c)
	211	{
	212	return c->quirks & MMC_QUIRK_BROKEN_BYTE_MODE_512;
	213	}
	214
	215	static inline int mmc_card_long_read_time(const struct mmc_card *c)
	216	{
	217	return c->quirks & MMC_QUIRK_LONG_READ_TIME;
	218	}
	219
	220	static inline int mmc_card_broken_irq_polling(const struct mmc_card *c)
	221	{
222	return c->quirks & MMC_QUIRK_BROKEN_IRQ_POLLING;
223	}
224
225	static inline int mmc_card_broken_hpi(const struct mmc_card *c)
226	{
227	return c->quirks & MMC_QUIRK_BROKEN_HPI;
228	}
229
4facdde1	230	#endif