3 * Texas Instruments, <www.ti.com>
4 * Syed Mohammed Khasim <khasim@ti.com>
6 * See file CREDITS for list of people who contributed to this
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation's version 2 of
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
33 #include <asm/arch/mmc.h>
35 const unsigned short mmc_transspeed_val
[15][4] = {
36 {CLKD(10, 1), CLKD(10, 10), CLKD(10, 100), CLKD(10, 1000)},
37 {CLKD(12, 1), CLKD(12, 10), CLKD(12, 100), CLKD(12, 1000)},
38 {CLKD(13, 1), CLKD(13, 10), CLKD(13, 100), CLKD(13, 1000)},
39 {CLKD(15, 1), CLKD(15, 10), CLKD(15, 100), CLKD(15, 1000)},
40 {CLKD(20, 1), CLKD(20, 10), CLKD(20, 100), CLKD(20, 1000)},
41 {CLKD(26, 1), CLKD(26, 10), CLKD(26, 100), CLKD(26, 1000)},
42 {CLKD(30, 1), CLKD(30, 10), CLKD(30, 100), CLKD(30, 1000)},
43 {CLKD(35, 1), CLKD(35, 10), CLKD(35, 100), CLKD(35, 1000)},
44 {CLKD(40, 1), CLKD(40, 10), CLKD(40, 100), CLKD(40, 1000)},
45 {CLKD(45, 1), CLKD(45, 10), CLKD(45, 100), CLKD(45, 1000)},
46 {CLKD(52, 1), CLKD(52, 10), CLKD(52, 100), CLKD(52, 1000)},
47 {CLKD(55, 1), CLKD(55, 10), CLKD(55, 100), CLKD(55, 1000)},
48 {CLKD(60, 1), CLKD(60, 10), CLKD(60, 100), CLKD(60, 1000)},
49 {CLKD(70, 1), CLKD(70, 10), CLKD(70, 100), CLKD(70, 1000)},
50 {CLKD(80, 1), CLKD(80, 10), CLKD(80, 100), CLKD(80, 1000)}
53 mmc_card_data cur_card_data
;
54 static block_dev_desc_t mmc_blk_dev
;
55 static hsmmc_t
*mmc_base
= (hsmmc_t
*)OMAP_HSMMC_BASE
;
57 block_dev_desc_t
*mmc_get_dev(int dev
)
59 return (block_dev_desc_t
*) &mmc_blk_dev
;
62 unsigned char mmc_board_init(void)
64 t2_t
*t2_base
= (t2_t
*)T2_BASE
;
66 twl4030_power_mmc_init();
68 writel(readl(&t2_base
->pbias_lite
) | PBIASLITEPWRDNZ1
|
69 PBIASSPEEDCTRL0
| PBIASLITEPWRDNZ0
,
70 &t2_base
->pbias_lite
);
72 writel(readl(&t2_base
->devconf0
) | MMCSDIO1ADPCLKISEL
,
78 void mmc_init_stream(void)
80 writel(readl(&mmc_base
->con
) | INIT_INITSTREAM
, &mmc_base
->con
);
82 writel(MMC_CMD0
, &mmc_base
->cmd
);
83 while (!(readl(&mmc_base
->stat
) & CC_MASK
));
85 writel(CC_MASK
, &mmc_base
->stat
);
87 writel(MMC_CMD0
, &mmc_base
->cmd
);
88 while (!(readl(&mmc_base
->stat
) & CC_MASK
));
90 writel(readl(&mmc_base
->con
) & ~INIT_INITSTREAM
, &mmc_base
->con
);
93 unsigned char mmc_clock_config(unsigned int iclk
, unsigned short clk_div
)
97 mmc_reg_out(&mmc_base
->sysctl
, (ICE_MASK
| DTO_MASK
| CEN_MASK
),
98 (ICE_STOP
| DTO_15THDTO
| CEN_DISABLE
));
102 val
= MMC_INIT_SEQ_CLK
/ 2;
105 val
= MMC_400kHz_CLK
;
113 mmc_reg_out(&mmc_base
->sysctl
, ICE_MASK
| CLKD_MASK
,
114 (val
<< CLKD_OFFSET
) | ICE_OSCILLATE
);
116 while ((readl(&mmc_base
->sysctl
) & ICS_MASK
) == ICS_NOTREADY
);
118 writel(readl(&mmc_base
->sysctl
) | CEN_ENABLE
, &mmc_base
->sysctl
);
122 unsigned char mmc_init_setup(void)
124 unsigned int reg_val
;
128 writel(readl(&mmc_base
->sysconfig
) | MMC_SOFTRESET
,
129 &mmc_base
->sysconfig
);
130 while ((readl(&mmc_base
->sysstatus
) & RESETDONE
) == 0);
132 writel(readl(&mmc_base
->sysctl
) | SOFTRESETALL
, &mmc_base
->sysctl
);
133 while ((readl(&mmc_base
->sysctl
) & SOFTRESETALL
) != 0x0);
135 writel(DTW_1_BITMODE
| SDBP_PWROFF
| SDVS_3V0
, &mmc_base
->hctl
);
136 writel(readl(&mmc_base
->capa
) | VS30_3V0SUP
| VS18_1V8SUP
,
139 reg_val
= readl(&mmc_base
->con
) & RESERVED_MASK
;
141 writel(CTPL_MMC_SD
| reg_val
| WPP_ACTIVEHIGH
| CDP_ACTIVEHIGH
|
142 MIT_CTO
| DW8_1_4BITMODE
| MODE_FUNC
| STR_BLOCK
|
143 HR_NOHOSTRESP
| INIT_NOINIT
| NOOPENDRAIN
, &mmc_base
->con
);
145 mmc_clock_config(CLK_INITSEQ
, 0);
146 writel(readl(&mmc_base
->hctl
) | SDBP_PWRON
, &mmc_base
->hctl
);
148 writel(IE_BADA
| IE_CERR
| IE_DEB
| IE_DCRC
| IE_DTO
| IE_CIE
|
149 IE_CEB
| IE_CCRC
| IE_CTO
| IE_BRR
| IE_BWR
| IE_TC
| IE_CC
,
156 unsigned char mmc_send_cmd(unsigned int cmd
, unsigned int arg
,
157 unsigned int *response
)
159 unsigned int mmc_stat
;
161 while ((readl(&mmc_base
->pstate
) & DATI_MASK
) == DATI_CMDDIS
);
163 writel(BLEN_512BYTESLEN
| NBLK_STPCNT
, &mmc_base
->blk
);
164 writel(0xFFFFFFFF, &mmc_base
->stat
);
165 writel(arg
, &mmc_base
->arg
);
166 writel(cmd
| CMD_TYPE_NORMAL
| CICE_NOCHECK
| CCCE_NOCHECK
|
167 MSBS_SGLEBLK
| ACEN_DISABLE
| BCE_DISABLE
| DE_DISABLE
,
172 mmc_stat
= readl(&mmc_base
->stat
);
173 } while (mmc_stat
== 0);
175 if ((mmc_stat
& ERRI_MASK
) != 0)
176 return (unsigned char) mmc_stat
;
178 if (mmc_stat
& CC_MASK
) {
179 writel(CC_MASK
, &mmc_base
->stat
);
180 response
[0] = readl(&mmc_base
->rsp10
);
181 if ((cmd
& RSP_TYPE_MASK
) == RSP_TYPE_LGHT136
) {
182 response
[1] = readl(&mmc_base
->rsp32
);
183 response
[2] = readl(&mmc_base
->rsp54
);
184 response
[3] = readl(&mmc_base
->rsp76
);
192 unsigned char mmc_read_data(unsigned int *output_buf
)
194 unsigned int mmc_stat
;
195 unsigned int read_count
= 0;
202 mmc_stat
= readl(&mmc_base
->stat
);
203 } while (mmc_stat
== 0);
205 if ((mmc_stat
& ERRI_MASK
) != 0)
206 return (unsigned char) mmc_stat
;
208 if (mmc_stat
& BRR_MASK
) {
211 writel(readl(&mmc_base
->stat
) | BRR_MASK
,
213 for (k
= 0; k
< MMCSD_SECTOR_SIZE
/ 4; k
++) {
214 *output_buf
= readl(&mmc_base
->data
);
220 if (mmc_stat
& BWR_MASK
)
221 writel(readl(&mmc_base
->stat
) | BWR_MASK
,
224 if (mmc_stat
& TC_MASK
) {
225 writel(readl(&mmc_base
->stat
) | TC_MASK
,
233 unsigned char mmc_detect_card(mmc_card_data
*mmc_card_cur
)
236 unsigned int argument
= 0;
237 unsigned int ocr_value
, ocr_recvd
, ret_cmd41
, hcs_val
;
238 unsigned short retry_cnt
= 2000;
241 /* Set to Initialization Clock */
242 err
= mmc_clock_config(CLK_400KHZ
, 0);
246 mmc_card_cur
->RCA
= MMC_RELATIVE_CARD_ADDRESS
;
247 argument
= 0x00000000;
249 ocr_value
= (0x1FF << 15);
250 err
= mmc_send_cmd(MMC_CMD0
, argument
, mmc_resp
.resp
);
254 argument
= SD_CMD8_CHECK_PATTERN
| SD_CMD8_2_7_3_6_V_RANGE
;
255 err
= mmc_send_cmd(MMC_SDCMD8
, argument
, mmc_resp
.resp
);
256 hcs_val
= (err
== 1) ?
257 MMC_OCR_REG_HOST_CAPACITY_SUPPORT_SECTOR
:
258 MMC_OCR_REG_HOST_CAPACITY_SUPPORT_BYTE
;
260 argument
= 0x0000 << 16;
261 err
= mmc_send_cmd(MMC_CMD55
, argument
, mmc_resp
.resp
);
263 mmc_card_cur
->card_type
= SD_CARD
;
264 ocr_value
|= hcs_val
;
265 ret_cmd41
= MMC_ACMD41
;
267 mmc_card_cur
->card_type
= MMC_CARD
;
268 ocr_value
|= MMC_OCR_REG_ACCESS_MODE_SECTOR
;
269 ret_cmd41
= MMC_CMD1
;
270 writel(readl(&mmc_base
->con
) & ~OD
, &mmc_base
->con
);
271 writel(readl(&mmc_base
->con
) | OPENDRAIN
, &mmc_base
->con
);
274 argument
= ocr_value
;
275 err
= mmc_send_cmd(ret_cmd41
, argument
, mmc_resp
.resp
);
279 ocr_recvd
= mmc_resp
.r3
.ocr
;
281 while (!(ocr_recvd
& (0x1 << 31)) && (retry_cnt
> 0)) {
283 if (mmc_card_cur
->card_type
== SD_CARD
) {
284 argument
= 0x0000 << 16;
285 err
= mmc_send_cmd(MMC_CMD55
, argument
, mmc_resp
.resp
);
288 argument
= ocr_value
;
289 err
= mmc_send_cmd(ret_cmd41
, argument
, mmc_resp
.resp
);
292 ocr_recvd
= mmc_resp
.r3
.ocr
;
295 if (!(ocr_recvd
& (0x1 << 31)))
298 if (mmc_card_cur
->card_type
== MMC_CARD
) {
299 if ((ocr_recvd
& MMC_OCR_REG_ACCESS_MODE_MASK
) ==
300 MMC_OCR_REG_ACCESS_MODE_SECTOR
) {
301 mmc_card_cur
->mode
= SECTOR_MODE
;
303 mmc_card_cur
->mode
= BYTE_MODE
;
306 ocr_recvd
&= ~MMC_OCR_REG_ACCESS_MODE_MASK
;
308 if ((ocr_recvd
& MMC_OCR_REG_HOST_CAPACITY_SUPPORT_MASK
)
309 == MMC_OCR_REG_HOST_CAPACITY_SUPPORT_SECTOR
) {
310 mmc_card_cur
->mode
= SECTOR_MODE
;
312 mmc_card_cur
->mode
= BYTE_MODE
;
314 ocr_recvd
&= ~MMC_OCR_REG_HOST_CAPACITY_SUPPORT_MASK
;
317 ocr_recvd
&= ~(0x1 << 31);
318 if (!(ocr_recvd
& ocr_value
))
321 err
= mmc_send_cmd(MMC_CMD2
, argument
, mmc_resp
.resp
);
325 if (mmc_card_cur
->card_type
== MMC_CARD
) {
326 argument
= mmc_card_cur
->RCA
<< 16;
327 err
= mmc_send_cmd(MMC_CMD3
, argument
, mmc_resp
.resp
);
331 argument
= 0x00000000;
332 err
= mmc_send_cmd(MMC_SDCMD3
, argument
, mmc_resp
.resp
);
336 mmc_card_cur
->RCA
= mmc_resp
.r6
.newpublishedrca
;
339 writel(readl(&mmc_base
->con
) & ~OD
, &mmc_base
->con
);
340 writel(readl(&mmc_base
->con
) | NOOPENDRAIN
, &mmc_base
->con
);
344 unsigned char mmc_read_cardsize(mmc_card_data
*mmc_dev_data
,
345 mmc_csd_reg_t
*cur_csd
)
347 mmc_extended_csd_reg_t ext_csd
;
348 unsigned int size
, count
, blk_len
, blk_no
, card_size
, argument
;
350 unsigned int resp
[4];
352 if (mmc_dev_data
->mode
== SECTOR_MODE
) {
353 if (mmc_dev_data
->card_type
== SD_CARD
) {
355 (((mmc_sd2_csd_reg_t
*) cur_csd
)->
356 c_size_lsb
& MMC_SD2_CSD_C_SIZE_LSB_MASK
) |
357 ((((mmc_sd2_csd_reg_t
*) cur_csd
)->
358 c_size_msb
& MMC_SD2_CSD_C_SIZE_MSB_MASK
)
359 << MMC_SD2_CSD_C_SIZE_MSB_OFFSET
);
360 mmc_dev_data
->size
= card_size
* 1024;
361 if (mmc_dev_data
->size
== 0)
364 argument
= 0x00000000;
365 err
= mmc_send_cmd(MMC_CMD8
, argument
, resp
);
368 err
= mmc_read_data((unsigned int *) &ext_csd
);
371 mmc_dev_data
->size
= ext_csd
.sectorcount
;
373 if (mmc_dev_data
->size
== 0)
374 mmc_dev_data
->size
= 8388608;
377 if (cur_csd
->c_size_mult
>= 8)
380 if (cur_csd
->read_bl_len
>= 12)
384 count
= 1 << (cur_csd
->c_size_mult
+ 2);
385 card_size
= (cur_csd
->c_size_lsb
& MMC_CSD_C_SIZE_LSB_MASK
) |
386 ((cur_csd
->c_size_msb
& MMC_CSD_C_SIZE_MSB_MASK
)
387 << MMC_CSD_C_SIZE_MSB_OFFSET
);
388 blk_no
= (card_size
+ 1) * count
;
389 blk_len
= 1 << cur_csd
->read_bl_len
;
390 size
= blk_no
* blk_len
;
391 mmc_dev_data
->size
= size
/ MMCSD_SECTOR_SIZE
;
392 if (mmc_dev_data
->size
== 0)
398 unsigned char omap_mmc_read_sect(unsigned int start_sec
, unsigned int num_bytes
,
399 mmc_card_data
*mmc_c
,
400 unsigned long *output_buf
)
403 unsigned int argument
;
404 unsigned int resp
[4];
405 unsigned int num_sec_val
=
406 (num_bytes
+ (MMCSD_SECTOR_SIZE
- 1)) / MMCSD_SECTOR_SIZE
;
407 unsigned int sec_inc_val
;
409 if (num_sec_val
== 0)
412 if (mmc_c
->mode
== SECTOR_MODE
) {
413 argument
= start_sec
;
416 argument
= start_sec
* MMCSD_SECTOR_SIZE
;
417 sec_inc_val
= MMCSD_SECTOR_SIZE
;
420 while (num_sec_val
) {
421 err
= mmc_send_cmd(MMC_CMD17
, argument
, resp
);
425 err
= mmc_read_data((unsigned int *) output_buf
);
429 output_buf
+= (MMCSD_SECTOR_SIZE
/ 4);
430 argument
+= sec_inc_val
;
436 unsigned char configure_mmc(mmc_card_data
*mmc_card_cur
)
438 unsigned char ret_val
;
439 unsigned int argument
;
440 unsigned int trans_clk
, trans_fact
, trans_unit
, retries
= 2;
441 unsigned char trans_speed
;
444 ret_val
= mmc_init_setup();
450 ret_val
= mmc_detect_card(mmc_card_cur
);
452 } while ((retries
> 0) && (ret_val
!= 1));
454 argument
= mmc_card_cur
->RCA
<< 16;
455 ret_val
= mmc_send_cmd(MMC_CMD9
, argument
, mmc_resp
.resp
);
459 if (mmc_card_cur
->card_type
== MMC_CARD
)
460 mmc_card_cur
->version
= mmc_resp
.Card_CSD
.spec_vers
;
462 trans_speed
= mmc_resp
.Card_CSD
.tran_speed
;
464 ret_val
= mmc_send_cmd(MMC_CMD4
, MMC_DSR_DEFAULT
<< 16, mmc_resp
.resp
);
468 trans_unit
= trans_speed
& MMC_CSD_TRAN_SPEED_UNIT_MASK
;
469 trans_fact
= trans_speed
& MMC_CSD_TRAN_SPEED_FACTOR_MASK
;
471 if (trans_unit
> MMC_CSD_TRAN_SPEED_UNIT_100MHZ
)
474 if ((trans_fact
< MMC_CSD_TRAN_SPEED_FACTOR_1_0
) ||
475 (trans_fact
> MMC_CSD_TRAN_SPEED_FACTOR_8_0
))
481 trans_clk
= mmc_transspeed_val
[trans_fact
- 1][trans_unit
] * 2;
482 ret_val
= mmc_clock_config(CLK_MISC
, trans_clk
);
487 argument
= mmc_card_cur
->RCA
<< 16;
488 ret_val
= mmc_send_cmd(MMC_CMD7_SELECT
, argument
, mmc_resp
.resp
);
492 /* Configure the block length to 512 bytes */
493 argument
= MMCSD_SECTOR_SIZE
;
494 ret_val
= mmc_send_cmd(MMC_CMD16
, argument
, mmc_resp
.resp
);
498 /* get the card size in sectors */
499 ret_val
= mmc_read_cardsize(mmc_card_cur
, &mmc_resp
.Card_CSD
);
505 unsigned long mmc_bread(int dev_num
, unsigned long blknr
, lbaint_t blkcnt
,
508 omap_mmc_read_sect(blknr
, (blkcnt
* MMCSD_SECTOR_SIZE
), &cur_card_data
,
509 (unsigned long *) dst
);
513 int mmc_legacy_init(int verbose
)
515 if (configure_mmc(&cur_card_data
) != 1)
518 mmc_blk_dev
.if_type
= IF_TYPE_MMC
;
519 mmc_blk_dev
.part_type
= PART_TYPE_DOS
;
522 mmc_blk_dev
.type
= 0;
524 /* FIXME fill in the correct size (is set to 32MByte) */
525 mmc_blk_dev
.blksz
= MMCSD_SECTOR_SIZE
;
526 mmc_blk_dev
.lba
= 0x10000;
527 mmc_blk_dev
.removable
= 0;
528 mmc_blk_dev
.block_read
= mmc_bread
;
530 fat_register_device(&mmc_blk_dev
, 1);