Merge master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6 into next
[linux-2.6] / drivers / mmc / core / sdio_cis.c
1 /*
2  * linux/drivers/mmc/core/sdio_cis.c
3  *
4  * Author:      Nicolas Pitre
5  * Created:     June 11, 2007
6  * Copyright:   MontaVista Software Inc.
7  *
8  * Copyright 2007 Pierre Ossman
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or (at
13  * your option) any later version.
14  */
15
16 #include <linux/kernel.h>
17
18 #include <linux/mmc/host.h>
19 #include <linux/mmc/card.h>
20 #include <linux/mmc/sdio.h>
21 #include <linux/mmc/sdio_func.h>
22
23 #include "sdio_cis.h"
24 #include "sdio_ops.h"
25
26 static int cistpl_vers_1(struct mmc_card *card, struct sdio_func *func,
27                          const unsigned char *buf, unsigned size)
28 {
29         unsigned i, nr_strings;
30         char **buffer, *string;
31
32         buf += 2;
33         size -= 2;
34
35         nr_strings = 0;
36         for (i = 0; i < size; i++) {
37                 if (buf[i] == 0xff)
38                         break;
39                 if (buf[i] == 0)
40                         nr_strings++;
41         }
42
43         if (buf[i-1] != '\0') {
44                 printk(KERN_WARNING "SDIO: ignoring broken CISTPL_VERS_1\n");
45                 return 0;
46         }
47
48         size = i;
49
50         buffer = kzalloc(sizeof(char*) * nr_strings + size, GFP_KERNEL);
51         if (!buffer)
52                 return -ENOMEM;
53
54         string = (char*)(buffer + nr_strings);
55
56         for (i = 0; i < nr_strings; i++) {
57                 buffer[i] = string;
58                 strcpy(string, buf);
59                 string += strlen(string) + 1;
60                 buf += strlen(buf) + 1;
61         }
62
63         if (func) {
64                 func->num_info = nr_strings;
65                 func->info = (const char**)buffer;
66         } else {
67                 card->num_info = nr_strings;
68                 card->info = (const char**)buffer;
69         }
70
71         return 0;
72 }
73
74 static int cistpl_manfid(struct mmc_card *card, struct sdio_func *func,
75                          const unsigned char *buf, unsigned size)
76 {
77         unsigned int vendor, device;
78
79         /* TPLMID_MANF */
80         vendor = buf[0] | (buf[1] << 8);
81
82         /* TPLMID_CARD */
83         device = buf[2] | (buf[3] << 8);
84
85         if (func) {
86                 func->vendor = vendor;
87                 func->device = device;
88         } else {
89                 card->cis.vendor = vendor;
90                 card->cis.device = device;
91         }
92
93         return 0;
94 }
95
96 static const unsigned char speed_val[16] =
97         { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 };
98 static const unsigned int speed_unit[8] =
99         { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };
100
101 static int cistpl_funce_common(struct mmc_card *card,
102                                const unsigned char *buf, unsigned size)
103 {
104         if (size < 0x04 || buf[0] != 0)
105                 return -EINVAL;
106
107         /* TPLFE_FN0_BLK_SIZE */
108         card->cis.blksize = buf[1] | (buf[2] << 8);
109
110         /* TPLFE_MAX_TRAN_SPEED */
111         card->cis.max_dtr = speed_val[(buf[3] >> 3) & 15] *
112                             speed_unit[buf[3] & 7];
113
114         return 0;
115 }
116
117 static int cistpl_funce_func(struct sdio_func *func,
118                              const unsigned char *buf, unsigned size)
119 {
120         unsigned vsn;
121         unsigned min_size;
122
123         vsn = func->card->cccr.sdio_vsn;
124         min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;
125
126         if (size < min_size || buf[0] != 1)
127                 return -EINVAL;
128
129         /* TPLFE_MAX_BLK_SIZE */
130         func->max_blksize = buf[12] | (buf[13] << 8);
131
132         /* TPLFE_ENABLE_TIMEOUT_VAL, present in ver 1.1 and above */
133         if (vsn > SDIO_SDIO_REV_1_00)
134                 func->enable_timeout = (buf[28] | (buf[29] << 8)) * 10;
135         else
136                 func->enable_timeout = jiffies_to_msecs(HZ);
137
138         return 0;
139 }
140
141 static int cistpl_funce(struct mmc_card *card, struct sdio_func *func,
142                         const unsigned char *buf, unsigned size)
143 {
144         int ret;
145
146         /*
147          * There should be two versions of the CISTPL_FUNCE tuple,
148          * one for the common CIS (function 0) and a version used by
149          * the individual function's CIS (1-7). Yet, the later has a
150          * different length depending on the SDIO spec version.
151          */
152         if (func)
153                 ret = cistpl_funce_func(func, buf, size);
154         else
155                 ret = cistpl_funce_common(card, buf, size);
156
157         if (ret) {
158                 printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u "
159                        "type %u\n", mmc_hostname(card->host), size, buf[0]);
160                 return ret;
161         }
162
163         return 0;
164 }
165
166 typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *,
167                            const unsigned char *, unsigned);
168
169 struct cis_tpl {
170         unsigned char code;
171         unsigned char min_size;
172         tpl_parse_t *parse;
173 };
174
175 static const struct cis_tpl cis_tpl_list[] = {
176         {       0x15,   3,      cistpl_vers_1           },
177         {       0x20,   4,      cistpl_manfid           },
178         {       0x21,   2,      /* cistpl_funcid */     },
179         {       0x22,   0,      cistpl_funce            },
180 };
181
182 static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
183 {
184         int ret;
185         struct sdio_func_tuple *this, **prev;
186         unsigned i, ptr = 0;
187
188         /*
189          * Note that this works for the common CIS (function number 0) as
190          * well as a function's CIS * since SDIO_CCCR_CIS and SDIO_FBR_CIS
191          * have the same offset.
192          */
193         for (i = 0; i < 3; i++) {
194                 unsigned char x, fn;
195
196                 if (func)
197                         fn = func->num;
198                 else
199                         fn = 0;
200
201                 ret = mmc_io_rw_direct(card, 0, 0,
202                         SDIO_FBR_BASE(fn) + SDIO_FBR_CIS + i, 0, &x);
203                 if (ret)
204                         return ret;
205                 ptr |= x << (i * 8);
206         }
207
208         if (func)
209                 prev = &func->tuples;
210         else
211                 prev = &card->tuples;
212
213         BUG_ON(*prev);
214
215         do {
216                 unsigned char tpl_code, tpl_link;
217
218                 ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_code);
219                 if (ret)
220                         break;
221
222                 /* 0xff means we're done */
223                 if (tpl_code == 0xff)
224                         break;
225
226                 ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_link);
227                 if (ret)
228                         break;
229
230                 this = kmalloc(sizeof(*this) + tpl_link, GFP_KERNEL);
231                 if (!this)
232                         return -ENOMEM;
233
234                 for (i = 0; i < tpl_link; i++) {
235                         ret = mmc_io_rw_direct(card, 0, 0,
236                                                ptr + i, 0, &this->data[i]);
237                         if (ret)
238                                 break;
239                 }
240                 if (ret) {
241                         kfree(this);
242                         break;
243                 }
244
245                 for (i = 0; i < ARRAY_SIZE(cis_tpl_list); i++)
246                         if (cis_tpl_list[i].code == tpl_code)
247                                 break;
248                 if (i >= ARRAY_SIZE(cis_tpl_list)) {
249                         /* this tuple is unknown to the core */
250                         this->next = NULL;
251                         this->code = tpl_code;
252                         this->size = tpl_link;
253                         *prev = this;
254                         prev = &this->next;
255                         printk(KERN_DEBUG
256                                "%s: queuing CIS tuple 0x%02x length %u\n",
257                                mmc_hostname(card->host), tpl_code, tpl_link);
258                 } else {
259                         const struct cis_tpl *tpl = cis_tpl_list + i;
260                         if (tpl_link < tpl->min_size) {
261                                 printk(KERN_ERR
262                                        "%s: bad CIS tuple 0x%02x (length = %u, expected >= %u)\n",
263                                        mmc_hostname(card->host),
264                                        tpl_code, tpl_link, tpl->min_size);
265                                 ret = -EINVAL;
266                         } else if (tpl->parse) {
267                                 ret = tpl->parse(card, func,
268                                                  this->data, tpl_link);
269                         }
270                         kfree(this);
271                 }
272
273                 ptr += tpl_link;
274         } while (!ret);
275
276         /*
277          * Link in all unknown tuples found in the common CIS so that
278          * drivers don't have to go digging in two places.
279          */
280         if (func)
281                 *prev = card->tuples;
282
283         return ret;
284 }
285
286 int sdio_read_common_cis(struct mmc_card *card)
287 {
288         return sdio_read_cis(card, NULL);
289 }
290
291 void sdio_free_common_cis(struct mmc_card *card)
292 {
293         struct sdio_func_tuple *tuple, *victim;
294
295         tuple = card->tuples;
296
297         while (tuple) {
298                 victim = tuple;
299                 tuple = tuple->next;
300                 kfree(victim);
301         }
302
303         card->tuples = NULL;
304 }
305
306 int sdio_read_func_cis(struct sdio_func *func)
307 {
308         int ret;
309
310         ret = sdio_read_cis(func->card, func);
311         if (ret)
312                 return ret;
313
314         /*
315          * Since we've linked to tuples in the card structure,
316          * we must make sure we have a reference to it.
317          */
318         get_device(&func->card->dev);
319
320         /*
321          * Vendor/device id is optional for function CIS, so
322          * copy it from the card structure as needed.
323          */
324         if (func->vendor == 0) {
325                 func->vendor = func->card->cis.vendor;
326                 func->device = func->card->cis.device;
327         }
328
329         return 0;
330 }
331
332 void sdio_free_func_cis(struct sdio_func *func)
333 {
334         struct sdio_func_tuple *tuple, *victim;
335
336         tuple = func->tuples;
337
338         while (tuple && tuple != func->card->tuples) {
339                 victim = tuple;
340                 tuple = tuple->next;
341                 kfree(victim);
342         }
343
344         func->tuples = NULL;
345
346         /*
347          * We have now removed the link to the tuples in the
348          * card structure, so remove the reference.
349          */
350         put_device(&func->card->dev);
351 }
352