drivers/block/blk-uclass.c

   1 /*
   2  * Copyright (C) 2016 Google, Inc
   3  * Written by Simon Glass <sjg@chromium.org>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <blk.h>
  10 #include <dm.h>
  11 #include <dm/device-internal.h>
  12 #include <dm/lists.h>
  13
  14 static const char *if_typename_str[IF_TYPE_COUNT] = {
  15         [IF_TYPE_IDE]           = "ide",
  16         [IF_TYPE_SCSI]          = "scsi",
  17         [IF_TYPE_ATAPI]         = "atapi",
  18         [IF_TYPE_USB]           = "usb",
  19         [IF_TYPE_DOC]           = "doc",
  20         [IF_TYPE_MMC]           = "mmc",
  21         [IF_TYPE_SD]            = "sd",
  22         [IF_TYPE_SATA]          = "sata",
  23         [IF_TYPE_HOST]          = "host",
  24         [IF_TYPE_SYSTEMACE]     = "ace",
  25 };
  26
  27 static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
  28         [IF_TYPE_IDE]           = UCLASS_INVALID,
  29         [IF_TYPE_SCSI]          = UCLASS_SCSI,
  30         [IF_TYPE_ATAPI]         = UCLASS_INVALID,
  31         [IF_TYPE_USB]           = UCLASS_MASS_STORAGE,
  32         [IF_TYPE_DOC]           = UCLASS_INVALID,
  33         [IF_TYPE_MMC]           = UCLASS_MMC,
  34         [IF_TYPE_SD]            = UCLASS_INVALID,
  35         [IF_TYPE_SATA]          = UCLASS_AHCI,
  36         [IF_TYPE_HOST]          = UCLASS_ROOT,
  37         [IF_TYPE_SYSTEMACE]     = UCLASS_INVALID,
  38 };
  39
  40 static enum if_type if_typename_to_iftype(const char *if_typename)
  41 {
  42         int i;
  43
  44         for (i = 0; i < IF_TYPE_COUNT; i++) {
  45                 if (if_typename_str[i] &&
  46                     !strcmp(if_typename, if_typename_str[i]))
  47                         return i;
  48         }
  49
  50         return IF_TYPE_UNKNOWN;
  51 }
  52
  53 static enum uclass_id if_type_to_uclass_id(enum if_type if_type)
  54 {
  55         return if_type_uclass_id[if_type];
  56 }
  57
  58 struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
  59 {
  60         struct blk_desc *desc;
  61         struct udevice *dev;
  62         int ret;
  63
  64         ret = blk_get_device(if_type, devnum, &dev);
  65         if (ret)
  66                 return NULL;
  67         desc = dev_get_uclass_platdata(dev);
  68
  69         return desc;
  70 }
  71
  72 /*
  73  * This function is complicated with driver model. We look up the interface
  74  * name in a local table. This gives us an interface type which we can match
  75  * against the uclass of the block device's parent.
  76  */
  77 struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
  78 {
  79         enum uclass_id uclass_id;
  80         enum if_type if_type;
  81         struct udevice *dev;
  82         struct uclass *uc;
  83         int ret;
  84
  85         if_type = if_typename_to_iftype(if_typename);
  86         if (if_type == IF_TYPE_UNKNOWN) {
  87                 debug("%s: Unknown interface type '%s'\n", __func__,
  88                       if_typename);
  89                 return NULL;
  90         }
  91         uclass_id = if_type_to_uclass_id(if_type);
  92         if (uclass_id == UCLASS_INVALID) {
  93                 debug("%s: Unknown uclass for interface type'\n",
  94                       if_typename_str[if_type]);
  95                 return NULL;
  96         }
  97
  98         ret = uclass_get(UCLASS_BLK, &uc);
  99         if (ret)
 100                 return NULL;
 101         uclass_foreach_dev(dev, uc) {
 102                 struct blk_desc *desc = dev_get_uclass_platdata(dev);
 103
 104                 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
 105                       if_type, devnum, dev->name, desc->if_type, desc->devnum);
 106                 if (desc->devnum != devnum)
 107                         continue;
 108
 109                 /* Find out the parent device uclass */
 110                 if (device_get_uclass_id(dev->parent) != uclass_id) {
 111                         debug("%s: parent uclass %d, this dev %d\n", __func__,
 112                               device_get_uclass_id(dev->parent), uclass_id);
 113                         continue;
 114                 }
 115
 116                 if (device_probe(dev))
 117                         return NULL;
 118
 119                 debug("%s: Device desc %p\n", __func__, desc);
 120                 return desc;
 121         }
 122         debug("%s: No device found\n", __func__);
 123
 124         return NULL;
 125 }
 126
 127 /**
 128  * get_desc() - Get the block device descriptor for the given device number
 129  *
 130  * @if_type:    Interface type
 131  * @devnum:     Device number (0 = first)
 132  * @descp:      Returns block device descriptor on success
 133  * @return 0 on success, -ENODEV if there is no such device and no device
 134  * with a higher device number, -ENOENT if there is no such device but there
 135  * is one with a higher number, or other -ve on other error.
 136  */
 137 static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
 138 {
 139         bool found_more = false;
 140         struct udevice *dev;
 141         struct uclass *uc;
 142         int ret;
 143
 144         *descp = NULL;
 145         ret = uclass_get(UCLASS_BLK, &uc);
 146         if (ret)
 147                 return ret;
 148         uclass_foreach_dev(dev, uc) {
 149                 struct blk_desc *desc = dev_get_uclass_platdata(dev);
 150
 151                 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
 152                       if_type, devnum, dev->name, desc->if_type, desc->devnum);
 153                 if (desc->if_type == if_type) {
 154                         if (desc->devnum == devnum) {
 155                                 ret = device_probe(dev);
 156                                 if (ret)
 157                                         return ret;
 158
 159                                 *descp = desc;
 160                                 return 0;
 161                         } else if (desc->devnum > devnum) {
 162                                 found_more = true;
 163                         }
 164                 }
 165         }
 166
 167         return found_more ? -ENOENT : -ENODEV;
 168 }
 169
 170 int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
 171 {
 172         struct udevice *dev;
 173         int ret;
 174
 175         ret = blk_get_device(if_type, devnum, &dev);
 176         if (ret)
 177                 return ret;
 178
 179         return blk_select_hwpart(dev, hwpart);
 180 }
 181
 182 int blk_list_part(enum if_type if_type)
 183 {
 184         struct blk_desc *desc;
 185         int devnum, ok;
 186         int ret;
 187
 188         for (ok = 0, devnum = 0;; ++devnum) {
 189                 ret = get_desc(if_type, devnum, &desc);
 190                 if (ret == -ENODEV)
 191                         break;
 192                 else if (ret)
 193                         continue;
 194                 if (desc->part_type != PART_TYPE_UNKNOWN) {
 195                         ++ok;
 196                         if (devnum)
 197                                 putc('\n');
 198                         part_print(desc);
 199                 }
 200         }
 201         if (!ok)
 202                 return -ENODEV;
 203
 204         return 0;
 205 }
 206
 207 int blk_print_part_devnum(enum if_type if_type, int devnum)
 208 {
 209         struct blk_desc *desc;
 210         int ret;
 211
 212         ret = get_desc(if_type, devnum, &desc);
 213         if (ret)
 214                 return ret;
 215         if (desc->type == DEV_TYPE_UNKNOWN)
 216                 return -ENOENT;
 217         part_print(desc);
 218
 219         return 0;
 220 }
 221
 222 void blk_list_devices(enum if_type if_type)
 223 {
 224         struct blk_desc *desc;
 225         int ret;
 226         int i;
 227
 228         for (i = 0;; ++i) {
 229                 ret = get_desc(if_type, i, &desc);
 230                 if (ret == -ENODEV)
 231                         break;
 232                 else if (ret)
 233                         continue;
 234                 if (desc->type == DEV_TYPE_UNKNOWN)
 235                         continue;  /* list only known devices */
 236                 printf("Device %d: ", i);
 237                 dev_print(desc);
 238         }
 239 }
 240
 241 int blk_print_device_num(enum if_type if_type, int devnum)
 242 {
 243         struct blk_desc *desc;
 244         int ret;
 245
 246         ret = get_desc(if_type, devnum, &desc);
 247         if (ret)
 248                 return ret;
 249         printf("\nIDE device %d: ", devnum);
 250         dev_print(desc);
 251
 252         return 0;
 253 }
 254
 255 int blk_show_device(enum if_type if_type, int devnum)
 256 {
 257         struct blk_desc *desc;
 258         int ret;
 259
 260         printf("\nDevice %d: ", devnum);
 261         ret = get_desc(if_type, devnum, &desc);
 262         if (ret == -ENODEV || ret == -ENOENT) {
 263                 printf("unknown device\n");
 264                 return -ENODEV;
 265         }
 266         if (ret)
 267                 return ret;
 268         dev_print(desc);
 269
 270         if (desc->type == DEV_TYPE_UNKNOWN)
 271                 return -ENOENT;
 272
 273         return 0;
 274 }
 275
 276 ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
 277                       lbaint_t blkcnt, void *buffer)
 278 {
 279         struct blk_desc *desc;
 280         ulong n;
 281         int ret;
 282
 283         ret = get_desc(if_type, devnum, &desc);
 284         if (ret)
 285                 return ret;
 286         n = blk_dread(desc, start, blkcnt, buffer);
 287         if (IS_ERR_VALUE(n))
 288                 return n;
 289
 290         /* flush cache after read */
 291         flush_cache((ulong)buffer, blkcnt * desc->blksz);
 292
 293         return n;
 294 }
 295
 296 ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
 297                        lbaint_t blkcnt, const void *buffer)
 298 {
 299         struct blk_desc *desc;
 300         int ret;
 301
 302         ret = get_desc(if_type, devnum, &desc);
 303         if (ret)
 304                 return ret;
 305         return blk_dwrite(desc, start, blkcnt, buffer);
 306 }
 307
 308 int blk_select_hwpart(struct udevice *dev, int hwpart)
 309 {
 310         const struct blk_ops *ops = blk_get_ops(dev);
 311
 312         if (!ops)
 313                 return -ENOSYS;
 314         if (!ops->select_hwpart)
 315                 return 0;
 316
 317         return ops->select_hwpart(dev, hwpart);
 318 }
 319
 320 int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
 321 {
 322         return blk_select_hwpart(desc->bdev, hwpart);
 323 }
 324
 325 int blk_first_device(int if_type, struct udevice **devp)
 326 {
 327         struct blk_desc *desc;
 328         int ret;
 329
 330         ret = uclass_first_device(UCLASS_BLK, devp);
 331         if (ret)
 332                 return ret;
 333         if (!*devp)
 334                 return -ENODEV;
 335         do {
 336                 desc = dev_get_uclass_platdata(*devp);
 337                 if (desc->if_type == if_type)
 338                         return 0;
 339                 ret = uclass_next_device(devp);
 340                 if (ret)
 341                         return ret;
 342         } while (*devp);
 343
 344         return -ENODEV;
 345 }
 346
 347 int blk_next_device(struct udevice **devp)
 348 {
 349         struct blk_desc *desc;
 350         int ret, if_type;
 351
 352         desc = dev_get_uclass_platdata(*devp);
 353         if_type = desc->if_type;
 354         do {
 355                 ret = uclass_next_device(devp);
 356                 if (ret)
 357                         return ret;
 358                 if (!*devp)
 359                         return -ENODEV;
 360                 desc = dev_get_uclass_platdata(*devp);
 361                 if (desc->if_type == if_type)
 362                         return 0;
 363         } while (1);
 364 }
 365
 366 int blk_get_device(int if_type, int devnum, struct udevice **devp)
 367 {
 368         struct uclass *uc;
 369         struct udevice *dev;
 370         int ret;
 371
 372         ret = uclass_get(UCLASS_BLK, &uc);
 373         if (ret)
 374                 return ret;
 375         uclass_foreach_dev(dev, uc) {
 376                 struct blk_desc *desc = dev_get_uclass_platdata(dev);
 377
 378                 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
 379                       if_type, devnum, dev->name, desc->if_type, desc->devnum);
 380                 if (desc->if_type == if_type && desc->devnum == devnum) {
 381                         *devp = dev;
 382                         return device_probe(dev);
 383                 }
 384         }
 385
 386         return -ENODEV;
 387 }
 388
 389 unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
 390                         lbaint_t blkcnt, void *buffer)
 391 {
 392         struct udevice *dev = block_dev->bdev;
 393         const struct blk_ops *ops = blk_get_ops(dev);
 394         ulong blks_read;
 395
 396         if (!ops->read)
 397                 return -ENOSYS;
 398
 399         if (blkcache_read(block_dev->if_type, block_dev->devnum,
 400                           start, blkcnt, block_dev->blksz, buffer))
 401                 return blkcnt;
 402         blks_read = ops->read(dev, start, blkcnt, buffer);
 403         if (blks_read == blkcnt)
 404                 blkcache_fill(block_dev->if_type, block_dev->devnum,
 405                               start, blkcnt, block_dev->blksz, buffer);
 406
 407         return blks_read;
 408 }
 409
 410 unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
 411                          lbaint_t blkcnt, const void *buffer)
 412 {
 413         struct udevice *dev = block_dev->bdev;
 414         const struct blk_ops *ops = blk_get_ops(dev);
 415
 416         if (!ops->write)
 417                 return -ENOSYS;
 418
 419         blkcache_invalidate(block_dev->if_type, block_dev->devnum);
 420         return ops->write(dev, start, blkcnt, buffer);
 421 }
 422
 423 unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
 424                          lbaint_t blkcnt)
 425 {
 426         struct udevice *dev = block_dev->bdev;
 427         const struct blk_ops *ops = blk_get_ops(dev);
 428
 429         if (!ops->erase)
 430                 return -ENOSYS;
 431
 432         blkcache_invalidate(block_dev->if_type, block_dev->devnum);
 433         return ops->erase(dev, start, blkcnt);
 434 }
 435
 436 int blk_prepare_device(struct udevice *dev)
 437 {
 438         struct blk_desc *desc = dev_get_uclass_platdata(dev);
 439
 440         part_init(desc);
 441
 442         return 0;
 443 }
 444
 445 int blk_find_max_devnum(enum if_type if_type)
 446 {
 447         struct udevice *dev;
 448         int max_devnum = -ENODEV;
 449         struct uclass *uc;
 450         int ret;
 451
 452         ret = uclass_get(UCLASS_BLK, &uc);
 453         if (ret)
 454                 return ret;
 455         uclass_foreach_dev(dev, uc) {
 456                 struct blk_desc *desc = dev_get_uclass_platdata(dev);
 457
 458                 if (desc->if_type == if_type && desc->devnum > max_devnum)
 459                         max_devnum = desc->devnum;
 460         }
 461
 462         return max_devnum;
 463 }
 464
 465 int blk_create_device(struct udevice *parent, const char *drv_name,
 466                       const char *name, int if_type, int devnum, int blksz,
 467                       lbaint_t size, struct udevice **devp)
 468 {
 469         struct blk_desc *desc;
 470         struct udevice *dev;
 471         int ret;
 472
 473         if (devnum == -1) {
 474                 ret = blk_find_max_devnum(if_type);
 475                 if (ret == -ENODEV)
 476                         devnum = 0;
 477                 else if (ret < 0)
 478                         return ret;
 479                 else
 480                         devnum = ret + 1;
 481         }
 482         ret = device_bind_driver(parent, drv_name, name, &dev);
 483         if (ret)
 484                 return ret;
 485         desc = dev_get_uclass_platdata(dev);
 486         desc->if_type = if_type;
 487         desc->blksz = blksz;
 488         desc->lba = size / blksz;
 489         desc->part_type = PART_TYPE_UNKNOWN;
 490         desc->bdev = dev;
 491         desc->devnum = devnum;
 492         *devp = dev;
 493
 494         return 0;
 495 }
 496
 497 int blk_create_devicef(struct udevice *parent, const char *drv_name,
 498                        const char *name, int if_type, int devnum, int blksz,
 499                        lbaint_t size, struct udevice **devp)
 500 {
 501         char dev_name[30], *str;
 502         int ret;
 503
 504         snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
 505         str = strdup(dev_name);
 506         if (!str)
 507                 return -ENOMEM;
 508
 509         ret = blk_create_device(parent, drv_name, str, if_type, devnum,
 510                                 blksz, size, devp);
 511         if (ret) {
 512                 free(str);
 513                 return ret;
 514         }
 515         device_set_name_alloced(*devp);
 516
 517         return ret;
 518 }
 519
 520 int blk_unbind_all(int if_type)
 521 {
 522         struct uclass *uc;
 523         struct udevice *dev, *next;
 524         int ret;
 525
 526         ret = uclass_get(UCLASS_BLK, &uc);
 527         if (ret)
 528                 return ret;
 529         uclass_foreach_dev_safe(dev, next, uc) {
 530                 struct blk_desc *desc = dev_get_uclass_platdata(dev);
 531
 532                 if (desc->if_type == if_type) {
 533                         ret = device_remove(dev, DM_REMOVE_NORMAL);
 534                         if (ret)
 535                                 return ret;
 536                         ret = device_unbind(dev);
 537                         if (ret)
 538                                 return ret;
 539                 }
 540         }
 541
 542         return 0;
 543 }
 544
 545 UCLASS_DRIVER(blk) = {
 546         .id             = UCLASS_BLK,
 547         .name           = "blk",
 548         .per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
 549 };