LXR uboot/api/api

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