hc
2025-02-14 bbb9540dc49f70f6b703d1c8d1b85fa5f602d86e
1
2
3
4
5
6
7
8
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
37
38
39
40
41
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
/*
 * (C) Copyright 2012 SAMSUNG Electronics
 * Jaehoon Chung <jh80.chung@samsung.com>
 *
 * SPDX-License-Identifier:    GPL-2.0+
 */
 
#ifndef __DWMMC_HW_H
#define __DWMMC_HW_H
 
#include <asm/io.h>
#include <mmc.h>
 
#define DWMCI_CTRL        0x000
#define    DWMCI_PWREN        0x004
#define DWMCI_CLKDIV        0x008
#define DWMCI_CLKSRC        0x00C
#define DWMCI_CLKENA        0x010
#define DWMCI_TMOUT        0x014
#define DWMCI_CTYPE        0x018
#define DWMCI_BLKSIZ        0x01C
#define DWMCI_BYTCNT        0x020
#define DWMCI_INTMASK        0x024
#define DWMCI_CMDARG        0x028
#define DWMCI_CMD        0x02C
#define DWMCI_RESP0        0x030
#define DWMCI_RESP1        0x034
#define DWMCI_RESP2        0x038
#define DWMCI_RESP3        0x03C
#define DWMCI_MINTSTS        0x040
#define DWMCI_RINTSTS        0x044
#define DWMCI_STATUS        0x048
#define DWMCI_FIFOTH        0x04C
#define DWMCI_CDETECT        0x050
#define DWMCI_WRTPRT        0x054
#define DWMCI_GPIO        0x058
#define DWMCI_TCMCNT        0x05C
#define DWMCI_TBBCNT        0x060
#define DWMCI_DEBNCE        0x064
#define DWMCI_USRID        0x068
#define DWMCI_VERID        0x06C
#define DWMCI_HCON        0x070
#define DWMCI_UHS_REG        0x074
#define DWMCI_BMOD        0x080
#define DWMCI_PLDMND        0x084
#define DWMCI_DBADDR        0x088
#define DWMCI_IDSTS        0x08C
#define DWMCI_IDINTEN        0x090
#define DWMCI_DSCADDR        0x094
#define DWMCI_BUFADDR        0x098
#define DWMCI_CARDTHRCTL    0x100
#define DWMCI_DATA        0x200
 
/* Interrupt Mask register */
#define DWMCI_INTMSK_ALL    0xffffffff
#define DWMCI_INTMSK_RE        (1 << 1)
#define DWMCI_INTMSK_CDONE    (1 << 2)
#define DWMCI_INTMSK_DTO    (1 << 3)
#define DWMCI_INTMSK_TXDR    (1 << 4)
#define DWMCI_INTMSK_RXDR    (1 << 5)
#define DWMCI_INTMSK_DCRC    (1 << 7)
#define DWMCI_INTMSK_RTO    (1 << 8)
#define DWMCI_INTMSK_DRTO    (1 << 9)
#define DWMCI_INTMSK_HTO    (1 << 10)
#define DWMCI_INTMSK_FRUN    (1 << 11)
#define DWMCI_INTMSK_HLE    (1 << 12)
#define DWMCI_INTMSK_SBE    (1 << 13)
#define DWMCI_INTMSK_ACD    (1 << 14)
#define DWMCI_INTMSK_EBE    (1 << 15)
 
/* Raw interrupt Regsiter */
#define DWMCI_DATA_ERR    (DWMCI_INTMSK_EBE | DWMCI_INTMSK_SBE | DWMCI_INTMSK_HLE |\
           DWMCI_INTMSK_FRUN | DWMCI_INTMSK_EBE | DWMCI_INTMSK_DCRC)
#define DWMCI_DATA_TOUT    (DWMCI_INTMSK_HTO | DWMCI_INTMSK_DRTO)
/* CTRL register */
#define DWMCI_CTRL_RESET    (1 << 0)
#define DWMCI_CTRL_FIFO_RESET    (1 << 1)
#define DWMCI_CTRL_DMA_RESET    (1 << 2)
#define DWMCI_DMA_EN        (1 << 5)
#define DWMCI_CTRL_SEND_AS_CCSD    (1 << 10)
#define DWMCI_IDMAC_EN        (1 << 25)
#define DWMCI_RESET_ALL        (DWMCI_CTRL_RESET | DWMCI_CTRL_FIFO_RESET |\
               DWMCI_CTRL_DMA_RESET)
 
/* CMD register */
#define DWMCI_CMD_RESP_EXP    (1 << 6)
#define DWMCI_CMD_RESP_LENGTH    (1 << 7)
#define DWMCI_CMD_CHECK_CRC    (1 << 8)
#define DWMCI_CMD_DATA_EXP    (1 << 9)
#define DWMCI_CMD_RW        (1 << 10)
#define DWMCI_CMD_SEND_STOP    (1 << 12)
#define DWMCI_CMD_ABORT_STOP    (1 << 14)
#define DWMCI_CMD_PRV_DAT_WAIT    (1 << 13)
#define DWMCI_CMD_UPD_CLK    (1 << 21)
#define DWMCI_CMD_USE_HOLD_REG    (1 << 29)
#define DWMCI_CMD_START        (1 << 31)
 
/* CLKENA register */
#define DWMCI_CLKEN_ENABLE    (1 << 0)
#define DWMCI_CLKEN_LOW_PWR    (1 << 16)
 
/* Card-type registe */
#define DWMCI_CTYPE_1BIT    0
#define DWMCI_CTYPE_4BIT    (1 << 0)
#define DWMCI_CTYPE_8BIT    (1 << 16)
 
/* Status Register */
#define DWMCI_BUSY        (1 << 9)
#define DWMCI_FIFO_MASK        0x1fff
#define DWMCI_FIFO_SHIFT    17
 
/* FIFOTH Register */
#define MSIZE(x)        ((x) << 28)
#define RX_WMARK(x)        ((x) << 16)
#define TX_WMARK(x)        (x)
#define RX_WMARK_SHIFT        16
#define RX_WMARK_MASK        (0xfff << RX_WMARK_SHIFT)
 
/* HCON Register */
#define DMA_INTERFACE_IDMA        (0x0)
#define SDMMC_GET_TRANS_MODE(x)        (((x)>>16) & 0x3)
 
#define DWMCI_IDMAC_OWN        (1 << 31)
#define DWMCI_IDMAC_CH        (1 << 4)
#define DWMCI_IDMAC_FS        (1 << 3)
#define DWMCI_IDMAC_LD        (1 << 2)
 
/*  Bus Mode Register */
#define DWMCI_BMOD_IDMAC_RESET    (1 << 0)
#define DWMCI_BMOD_IDMAC_FB    (1 << 1)
#define DWMCI_BMOD_IDMAC_EN    (1 << 7)
 
/* UHS register */
#define DWMCI_DDR_MODE    (1 << 16)
 
/* quirks */
#define DWMCI_QUIRK_DISABLE_SMU        (1 << 0)
 
/*
 * DWMCI_MSIZE is uses to set burst size of multiple transaction.
 * The burst size is set to 128 if DWMCI_MSIZE is set to 0x6.
 */
#define DWMCI_MSIZE    0x6
 
/* The DW MMC Controller Version */
#define DW_MMC_240A        0x240a
 
/* sdmmc cardthrctl set */
#define DWMCI_CDTHRCTRL_CONFIG (1 + (0x200 << 16))
 
/**
 * struct dwmci_host - Information about a designware MMC host
 *
 * @name:    Device name
 * @ioaddr:    Base I/O address of controller
 * @quirks:    Quick flags - see DWMCI_QUIRK_...
 * @caps:    Capabilities - see MMC_MODE_...
 * @bus_hz:    Bus speed in Hz, if @get_mmc_clk() is NULL
 * @div:    Arbitrary clock divider value for use by controller
 * @dev_index:    Arbitrary device index for use by controller
 * @dev_id:    Arbitrary device ID for use by controller
 * @buswidth:    Bus width in bits (8 or 4)
 * @fifoth_val:    Value for FIFOTH register (or 0 to leave unset)
 * @mmc:    Pointer to generic MMC structure for this device
 * @priv:    Private pointer for use by controller
 * @stride_pio: Provide the ability of accessing fifo with burst mode
 */
struct dwmci_host {
   const char *name;
   void *ioaddr;
   unsigned int quirks;
   unsigned int caps;
   unsigned int version;
   unsigned int clock;
   unsigned int bus_hz;
   unsigned int div;
   int dev_index;
   int dev_id;
   int buswidth;
   u32 fifoth_val;
   struct mmc *mmc;
   void *priv;
   bool stride_pio;
 
   void (*clksel)(struct dwmci_host *host);
   void (*board_init)(struct dwmci_host *host);
 
   /**
    * Get / set a particular MMC clock frequency
    *
    * This is used to request the current clock frequency of the clock
    * that drives the DWMMC peripheral. The caller will then use this
    * information to work out the divider it needs to achieve the
    * required MMC bus clock frequency. If you want to handle the
    * clock external to DWMMC, use @freq to select the frequency and
    * return that value too. Then DWMMC will put itself in bypass mode.
    *
    * @host:    DWMMC host
    * @freq:    Frequency the host is trying to achieve
    */
   unsigned int (*get_mmc_clk)(struct dwmci_host *host, uint freq);
   int (*execute_tuning)(struct dwmci_host *host, u32 opcode);
#ifndef CONFIG_BLK
   struct mmc_config cfg;
#endif
 
   /* use fifo mode to read and write data */
   bool fifo_mode;
};
 
struct dwmci_idmac {
   u32 flags;
   u32 cnt;
   u32 addr;
   u32 next_addr;
} __aligned(ARCH_DMA_MINALIGN);
 
static inline void dwmci_writel(struct dwmci_host *host, int reg, u32 val)
{
   writel(val, host->ioaddr + reg);
}
 
static inline void dwmci_writew(struct dwmci_host *host, int reg, u16 val)
{
   writew(val, host->ioaddr + reg);
}
 
static inline void dwmci_writeb(struct dwmci_host *host, int reg, u8 val)
{
   writeb(val, host->ioaddr + reg);
}
static inline u32 dwmci_readl(struct dwmci_host *host, int reg)
{
   return readl(host->ioaddr + reg);
}
 
static inline u16 dwmci_readw(struct dwmci_host *host, int reg)
{
   return readw(host->ioaddr + reg);
}
 
static inline u8 dwmci_readb(struct dwmci_host *host, int reg)
{
   return readb(host->ioaddr + reg);
}
 
#ifdef CONFIG_BLK
/**
 * dwmci_setup_cfg() - Set up the configuration for DWMMC
 *
 * This is used to set up a DWMMC device when you are using CONFIG_BLK.
 *
 * This should be called from your MMC driver's probe() method once you have
 * the information required.
 *
 * Generally your driver will have a platform data structure which holds both
 * the configuration (struct mmc_config) and the MMC device info (struct mmc).
 * For example:
 *
 * struct rockchip_mmc_plat {
 *    struct mmc_config cfg;
 *    struct mmc mmc;
 * };
 *
 * ...
 *
 * Inside U_BOOT_DRIVER():
 *    .platdata_auto_alloc_size = sizeof(struct rockchip_mmc_plat),
 *
 * To access platform data:
 *    struct rockchip_mmc_plat *plat = dev_get_platdata(dev);
 *
 * See rockchip_dw_mmc.c for an example.
 *
 * @cfg:    Configuration structure to fill in (generally &plat->mmc)
 * @host:    DWMMC host
 * @max_clk:    Maximum supported clock speed in HZ (e.g. 150000000)
 * @min_clk:    Minimum supported clock speed in HZ (e.g. 400000)
 */
void dwmci_setup_cfg(struct mmc_config *cfg, struct dwmci_host *host,
       u32 max_clk, u32 min_clk);
 
/**
 * dwmci_bind() - Set up a new MMC block device
 *
 * This is used to set up a DWMMC block device when you are using CONFIG_BLK.
 * It should be called from your driver's bind() method.
 *
 * See rockchip_dw_mmc.c for an example.
 *
 * @dev:    Device to set up
 * @mmc:    Pointer to mmc structure (normally &plat->mmc)
 * @cfg:    Empty configuration structure (generally &plat->cfg). This is
 *        normally all zeroes at this point. The only purpose of passing
 *        this in is to set mmc->cfg to it.
 * @return 0 if OK, -ve if the block device could not be created
 */
int dwmci_bind(struct udevice *dev, struct mmc *mmc, struct mmc_config *cfg);
 
#else
/**
 * add_dwmci() - Add a new DWMMC interface
 *
 * This is used when you are not using CONFIG_BLK. Convert your driver over!
 *
 * @host:    DWMMC host structure
 * @max_clk:    Maximum supported clock speed in HZ (e.g. 150000000)
 * @min_clk:    Minimum supported clock speed in HZ (e.g. 400000)
 * @return 0 if OK, -ve on error
 */
int add_dwmci(struct dwmci_host *host, u32 max_clk, u32 min_clk);
#endif /* !CONFIG_BLK */
 
#ifdef CONFIG_DM_MMC
/* Export the operations to drivers */
int dwmci_probe(struct udevice *dev);
extern const struct dm_mmc_ops dm_dwmci_ops;
#endif
 
#endif    /* __DWMMC_HW_H */