Line data Source code
1 : /*
2 : * linux/drivers/mmc/sdio_ops.c
3 : *
4 : * Copyright 2006-2007 Pierre Ossman
5 : *
6 : * This program is free software; you can redistribute it and/or modify
7 : * it under the terms of the GNU General Public License as published by
8 : * the Free Software Foundation; either version 2 of the License, or (at
9 : * your option) any later version.
10 : */
11 :
12 : #include <linux/scatterlist.h>
13 :
14 : #include <linux/mmc/host.h>
15 : #include <linux/mmc/card.h>
16 : #include <linux/mmc/mmc.h>
17 : #include <linux/mmc/sdio.h>
18 :
19 : #include "core.h"
20 : #include "sdio_ops.h"
21 :
22 : int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
23 : {
24 1 : struct mmc_command cmd;
25 2 : int i, err = 0;
26 1 :
27 7 : BUG_ON(!host);
28 :
29 1 : memset(&cmd, 0, sizeof(struct mmc_command));
30 :
31 1 : cmd.opcode = SD_IO_SEND_OP_COND;
32 1 : cmd.arg = ocr;
33 1 : cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
34 :
35 5 : for (i = 100; i; i--) {
36 3 : err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
37 4 : if (err)
38 1 : break;
39 :
40 : /* if we're just probing, do a single pass */
41 3 : if (ocr == 0)
42 1 : break;
43 :
44 : /* otherwise wait until reset completes */
45 2 : if (mmc_host_is_spi(host)) {
46 : /*
47 : * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
48 : * an initialized card under SPI, but some cards
49 : * (Marvell's) only behave when looking at this
50 : * one.
51 : */
52 2 : if (cmd.resp[1] & MMC_CARD_BUSY)
53 1 : break;
54 : } else {
55 2 : if (cmd.resp[0] & MMC_CARD_BUSY)
56 1 : break;
57 : }
58 :
59 1 : err = -ETIMEDOUT;
60 :
61 3 : mmc_delay(10);
62 : }
63 :
64 4 : if (rocr)
65 2 : *rocr = cmd.resp[mmc_host_is_spi(host) ? 1 : 0];
66 :
67 2 : return err;
68 : }
69 :
70 : int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
71 : unsigned addr, u8 in, u8* out)
72 : {
73 85 : struct mmc_command cmd;
74 85 : int err;
75 85 :
76 595 : BUG_ON(!card);
77 510 : BUG_ON(fn > 7);
78 :
79 : /* sanity check */
80 170 : if (addr & ~0x1FFFF)
81 85 : return -EINVAL;
82 :
83 85 : memset(&cmd, 0, sizeof(struct mmc_command));
84 :
85 85 : cmd.opcode = SD_IO_RW_DIRECT;
86 510 : cmd.arg = write ? 0x80000000 : 0x00000000;
87 85 : cmd.arg |= fn << 28;
88 680 : cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
89 85 : cmd.arg |= addr << 9;
90 85 : cmd.arg |= in;
91 85 : cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
92 :
93 170 : err = mmc_wait_for_cmd(card->host, &cmd, 0);
94 170 : if (err)
95 85 : return err;
96 :
97 170 : if (mmc_host_is_spi(card->host)) {
98 : /* host driver already reported errors */
99 : } else {
100 170 : if (cmd.resp[0] & R5_ERROR)
101 85 : return -EIO;
102 170 : if (cmd.resp[0] & R5_FUNCTION_NUMBER)
103 85 : return -EINVAL;
104 170 : if (cmd.resp[0] & R5_OUT_OF_RANGE)
105 85 : return -ERANGE;
106 : }
107 :
108 170 : if (out) {
109 170 : if (mmc_host_is_spi(card->host))
110 85 : *out = (cmd.resp[0] >> 8) & 0xFF;
111 : else
112 85 : *out = cmd.resp[0] & 0xFF;
113 : }
114 :
115 85 : return 0;
116 : }
117 :
118 : int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
119 : unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
120 : {
121 0 : struct mmc_request mrq;
122 0 : struct mmc_command cmd;
123 0 : struct mmc_data data;
124 0 : struct scatterlist sg;
125 0 :
126 0 : BUG_ON(!card);
127 0 : BUG_ON(fn > 7);
128 0 : BUG_ON(blocks == 1 && blksz > 512);
129 0 : WARN_ON(blocks == 0);
130 0 : WARN_ON(blksz == 0);
131 0 :
132 : /* sanity check */
133 0 : if (addr & ~0x1FFFF)
134 0 : return -EINVAL;
135 :
136 0 : memset(&mrq, 0, sizeof(struct mmc_request));
137 0 : memset(&cmd, 0, sizeof(struct mmc_command));
138 0 : memset(&data, 0, sizeof(struct mmc_data));
139 :
140 0 : mrq.cmd = &cmd;
141 0 : mrq.data = &data;
142 :
143 0 : cmd.opcode = SD_IO_RW_EXTENDED;
144 0 : cmd.arg = write ? 0x80000000 : 0x00000000;
145 0 : cmd.arg |= fn << 28;
146 0 : cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
147 0 : cmd.arg |= addr << 9;
148 0 : if (blocks == 1 && blksz <= 512)
149 0 : cmd.arg |= (blksz == 512) ? 0 : blksz; /* byte mode */
150 : else
151 0 : cmd.arg |= 0x08000000 | blocks; /* block mode */
152 0 : cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
153 :
154 0 : data.blksz = blksz;
155 0 : data.blocks = blocks;
156 0 : data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
157 0 : data.sg = &sg;
158 0 : data.sg_len = 1;
159 :
160 0 : sg_init_one(&sg, buf, blksz * blocks);
161 :
162 0 : mmc_set_data_timeout(&data, card);
163 :
164 0 : mmc_wait_for_req(card->host, &mrq);
165 :
166 0 : if (cmd.error)
167 0 : return cmd.error;
168 0 : if (data.error)
169 0 : return data.error;
170 :
171 0 : if (mmc_host_is_spi(card->host)) {
172 : /* host driver already reported errors */
173 : } else {
174 0 : if (cmd.resp[0] & R5_ERROR)
175 0 : return -EIO;
176 0 : if (cmd.resp[0] & R5_FUNCTION_NUMBER)
177 0 : return -EINVAL;
178 0 : if (cmd.resp[0] & R5_OUT_OF_RANGE)
179 0 : return -ERANGE;
180 : }
181 :
182 0 : return 0;
183 : }
184 :
|