source: SVN/rincon/u-boot/api/api_storage.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 8.7 KB
Line 
1/*
2 * (C) Copyright 2007-2008 Semihalf
3 *
4 * Written by: Rafal Jaworowski <raj@semihalf.com>
5 *
6 * See file CREDITS for list of people who contributed to this
7 * project.
8 *
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; either version 2 of
12 * the License, or (at your option) any later version.
13 *
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.
18 *
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,
22 * MA 02111-1307 USA
23 *
24 */
25
26#include <config.h>
27
28#if defined(CONFIG_API)
29
30#include <common.h>
31#include <api_public.h>
32
33#define DEBUG
34#undef DEBUG
35
36#ifdef DEBUG
37#define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt, ##args); } while (0)
38#else
39#define debugf(fmt, args...)
40#endif
41
42#define errf(fmt, args...) do { printf("ERROR @ %s(): ", __func__); printf(fmt, ##args); } while (0)
43
44
45#define ENUM_IDE        0
46#define ENUM_USB        1
47#define ENUM_SCSI       2
48#define ENUM_MMC        3
49#define ENUM_SATA       4
50#define ENUM_MAX        5
51
52struct stor_spec {
53        int             max_dev;
54        int             enum_started;
55        int             enum_ended;
56        int             type;           /* "external" type: DT_STOR_{IDE,USB,etc} */
57        char            *name;
58};
59
60static struct stor_spec specs[ENUM_MAX] = { { 0, 0, 0, 0, "" }, };
61
62
63void dev_stor_init(void)
64{
65#if defined(CONFIG_CMD_IDE)
66        specs[ENUM_IDE].max_dev = CFG_IDE_MAXDEVICE;
67        specs[ENUM_IDE].enum_started = 0;
68        specs[ENUM_IDE].enum_ended = 0;
69        specs[ENUM_IDE].type = DEV_TYP_STOR | DT_STOR_IDE;
70        specs[ENUM_IDE].name = "ide";
71#endif
72#if defined(CONFIG_CMD_MMC)
73        specs[ENUM_MMC].max_dev = CFG_MMC_MAX_DEVICE;
74        specs[ENUM_MMC].enum_started = 0;
75        specs[ENUM_MMC].enum_ended = 0;
76        specs[ENUM_MMC].type = DEV_TYP_STOR | DT_STOR_MMC;
77        specs[ENUM_MMC].name = "mmc";
78#endif
79#if defined(CONFIG_CMD_SATA)
80        specs[ENUM_SATA].max_dev = CFG_SATA_MAX_DEVICE;
81        specs[ENUM_SATA].enum_started = 0;
82        specs[ENUM_SATA].enum_ended = 0;
83        specs[ENUM_SATA].type = DEV_TYP_STOR | DT_STOR_SATA;
84        specs[ENUM_SATA].name = "sata";
85#endif
86#if defined(CONFIG_CMD_SCSI)
87        specs[ENUM_SCSI].max_dev = CFG_SCSI_MAX_DEVICE;
88        specs[ENUM_SCSI].enum_started = 0;
89        specs[ENUM_SCSI].enum_ended = 0;
90        specs[ENUM_SCSI].type = DEV_TYP_STOR | DT_STOR_SCSI;
91        specs[ENUM_SCSI].name = "scsi";
92#endif
93#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
94        specs[ENUM_USB].max_dev = USB_MAX_STOR_DEV;
95        specs[ENUM_USB].enum_started = 0;
96        specs[ENUM_USB].enum_ended = 0;
97        specs[ENUM_USB].type = DEV_TYP_STOR | DT_STOR_USB;
98        specs[ENUM_USB].name = "usb";
99#endif
100}
101
102/*
103 * Finds next available device in the storage group
104 *
105 * type:        storage group type - ENUM_IDE, ENUM_SCSI etc.
106 *
107 * first:       if 1 the first device in the storage group is returned (if
108 *              exists), if 0 the next available device is searched
109 *
110 * more:        returns 0/1 depending if there are more devices in this group
111 *              available (for future iterations)
112 *
113 * returns:     0/1 depending if device found in this iteration
114 */
115static int dev_stor_get(int type, int first, int *more, struct device_info *di)
116{
117        int found = 0;
118        *more = 0;
119
120        int i;
121
122        block_dev_desc_t *dd;
123
124        if (first) {
125                di->cookie = (void *)get_dev(specs[type].name, 0);
126                if (di->cookie == NULL)
127                        return 0;
128                else
129                        found = 1;
130
131        } else {
132                for (i = 0; i < specs[type].max_dev; i++)
133                        if (di->cookie == (void *)get_dev(specs[type].name, i)) {
134                                /* previous cookie found -- advance to the
135                                 * next device, if possible */
136
137                                if (++i >= specs[type].max_dev) {
138                                        /* out of range, no more to enum */
139                                        di->cookie = NULL;
140                                        break;
141                                }
142
143                                di->cookie = (void *)get_dev(specs[type].name, i);
144                                if (di->cookie == NULL)
145                                        return 0;
146                                else
147                                        found = 1;
148
149                                /* provide hint if there are more devices in
150                                 * this group to enumerate */
151                                if ((i + 1) < specs[type].max_dev)
152                                        *more = 1;
153
154                                break;
155                        }
156        }
157
158        if (found) {
159                di->type = specs[type].type;
160
161                if (di->cookie != NULL) {
162                        dd = (block_dev_desc_t *)di->cookie;
163                        if (dd->type == DEV_TYPE_UNKNOWN) {
164                                debugf("device instance exists, but is not active..");
165                                found = 0;
166                        } else {
167                                di->di_stor.block_count = dd->lba;
168                                di->di_stor.block_size = dd->blksz;
169                        }
170                }
171
172        } else
173                di->cookie = NULL;
174
175        return found;
176}
177
178
179/*
180 * returns:     ENUM_IDE, ENUM_USB etc. based on block_dev_desc_t
181 */
182static int dev_stor_type(block_dev_desc_t *dd)
183{
184        int i, j;
185
186        for (i = ENUM_IDE; i < ENUM_MAX; i++)
187                for (j = 0; j < specs[i].max_dev; j++)
188                        if (dd == get_dev(specs[i].name, j))
189                                return i;
190
191        return ENUM_MAX;
192}
193
194
195/*
196 * returns:     0/1 whether cookie points to some device in this group
197 */
198static int dev_is_stor(int type, struct device_info *di)
199{
200        return (dev_stor_type(di->cookie) == type) ? 1 : 0;
201}
202
203
204static int dev_enum_stor(int type, struct device_info *di)
205{
206        int found = 0, more = 0;
207
208        debugf("called, type %d\n", type);
209
210        /*
211         * Formulae for enumerating storage devices:
212         * 1. if cookie (hint from previous enum call) is NULL we start again
213         *    with enumeration, so return the first available device, done.
214         *
215         * 2. if cookie is not NULL, check if it identifies some device in
216         *    this group:
217         *
218         * 2a. if cookie is a storage device from our group (IDE, USB etc.),
219         *     return next available (if exists) in this group
220         *
221         * 2b. if it isn't device from our group, check if such devices were
222         *     ever enumerated before:
223         *     - if not, return the first available device from this group
224         *     - else return 0
225         */
226
227        if (di->cookie == NULL) {
228
229                debugf("group%d - enum restart\n", type);
230
231                /*
232                 * 1. Enumeration (re-)started: take the first available
233                 * device, if exists
234                 */
235                found = dev_stor_get(type, 1, &more, di);
236                specs[type].enum_started = 1;
237
238        } else if (dev_is_stor(type, di)) {
239
240                debugf("group%d - enum continued for the next device\n", type);
241
242                if (specs[type].enum_ended) {
243                        debugf("group%d - nothing more to enum!\n", type);
244                        return 0;
245                }
246
247                /* 2a. Attempt to take a next available device in the group */
248                found = dev_stor_get(type, 0, &more, di);
249
250        } else {
251
252                if (specs[type].enum_ended) {
253                        debugf("group %d - already enumerated, skipping\n", type);
254                        return 0;
255                }
256
257                debugf("group%d - first time enum\n", type);
258
259                if (specs[type].enum_started == 0) {
260                        /*
261                         * 2b.  If enumerating devices in this group did not
262                         * happen before, it means the cookie pointed to a
263                         * device frome some other group (another storage
264                         * group, or network); in this case try to take the
265                         * first available device from our group
266                         */
267                        specs[type].enum_started = 1;
268
269                        /*
270                         * Attempt to take the first device in this group:
271                         *'first element' flag is set
272                         */
273                        found = dev_stor_get(type, 1, &more, di);
274
275                } else {
276                        errf("group%d - out of order iteration\n", type);
277                        found = 0;
278                        more = 0;
279                }
280        }
281
282        /*
283         * If there are no more devices in this group, consider its
284         * enumeration finished
285         */
286        specs[type].enum_ended = (!more) ? 1 : 0;
287
288        if (found)
289                debugf("device found, returning cookie 0x%08x\n",
290                        (u_int32_t)di->cookie);
291        else
292                debugf("no device found\n");
293
294        return found;
295}
296
297void dev_enum_reset(void)
298{
299        int i;
300
301        for (i = 0; i < ENUM_MAX; i ++) {
302                specs[i].enum_started = 0;
303                specs[i].enum_ended = 0;
304        }
305}
306
307int dev_enum_storage(struct device_info *di)
308{
309        int i;
310
311        /*
312         * check: ide, usb, scsi, mmc
313         */
314        for (i = ENUM_IDE; i < ENUM_MAX; i ++) {
315                if (dev_enum_stor(i, di))
316                        return 1;
317        }
318
319        return 0;
320}
321
322static int dev_stor_is_valid(int type, block_dev_desc_t *dd)
323{
324        int i;
325
326        for (i = 0; i < specs[type].max_dev; i++)
327                if (dd == get_dev(specs[type].name, i))
328                        if (dd->type != DEV_TYPE_UNKNOWN)
329                                return 1;
330
331        return 0;
332}
333
334
335int dev_open_stor(void *cookie)
336{
337        int type = dev_stor_type(cookie);
338
339        if (type == ENUM_MAX)
340                return API_ENODEV;
341
342        if (dev_stor_is_valid(type, (block_dev_desc_t *)cookie))
343                return 0;
344
345        return API_ENODEV;
346}
347
348
349int dev_close_stor(void *cookie)
350{
351        /*
352         * Not much to do as we actually do not alter storage devices upon
353         * close
354         */
355        return 0;
356}
357
358
359static int dev_stor_index(block_dev_desc_t *dd)
360{
361        int i, type;
362
363        type = dev_stor_type(dd);
364        for (i = 0; i < specs[type].max_dev; i++)
365                if (dd == get_dev(specs[type].name, i))
366                        return i;
367
368        return (specs[type].max_dev);
369}
370
371
372lbasize_t dev_read_stor(void *cookie, void *buf, lbasize_t len, lbastart_t start)
373{
374        int type;
375        block_dev_desc_t *dd = (block_dev_desc_t *)cookie;
376
377        if ((type = dev_stor_type(dd)) == ENUM_MAX)
378                return 0;
379
380        if (!dev_stor_is_valid(type, dd))
381                return 0;
382
383        if ((dd->block_read) == NULL) {
384                debugf("no block_read() for device 0x%08x\n", cookie);
385                return 0;
386        }
387
388        return (dd->block_read(dev_stor_index(dd), start, len, buf));
389}
390
391#endif /* CONFIG_API */
Note: See TracBrowser for help on using the repository browser.