]>
git.ipfire.org Git - people/ms/u-boot.git/blob - include/blk.h
2 * (C) Copyright 2000-2004
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * SPDX-License-Identifier: GPL-2.0+
11 #ifdef CONFIG_SYS_64BIT_LBA
12 typedef uint64_t lbaint_t
;
13 #define LBAFlength "ll"
15 typedef ulong lbaint_t
;
16 #define LBAFlength "l"
18 #define LBAF "%" LBAFlength "x"
19 #define LBAFU "%" LBAFlength "u"
21 /* Interface types: */
35 IF_TYPE_COUNT
, /* Number of interface types */
39 * With driver model (CONFIG_BLK) this is uclass platform data, accessible
40 * with dev_get_uclass_platdata(dev)
44 * TODO: With driver model we should be able to use the parent
45 * device's uclass instead.
47 enum if_type if_type
; /* type of the interface */
48 int devnum
; /* device number */
49 unsigned char part_type
; /* partition type */
50 unsigned char target
; /* target SCSI ID */
51 unsigned char lun
; /* target LUN */
52 unsigned char hwpart
; /* HW partition, e.g. for eMMC */
53 unsigned char type
; /* device type */
54 unsigned char removable
; /* removable device */
56 /* device can use 48bit addr (ATA/ATAPI v7) */
59 lbaint_t lba
; /* number of blocks */
60 unsigned long blksz
; /* block size */
61 int log2blksz
; /* for convenience: log2(blksz) */
62 char vendor
[40+1]; /* IDE model, SCSI Vendor */
63 char product
[20+1]; /* IDE Serial no, SCSI product */
64 char revision
[8+1]; /* firmware revision */
67 * For now we have a few functions which take struct blk_desc as a
68 * parameter. This field allows them to look up the associated
69 * device. Once these functions are removed we can drop this field.
73 unsigned long (*block_read
)(struct blk_desc
*block_dev
,
77 unsigned long (*block_write
)(struct blk_desc
*block_dev
,
81 unsigned long (*block_erase
)(struct blk_desc
*block_dev
,
84 void *priv
; /* driver private struct pointer */
88 #define BLOCK_CNT(size, blk_desc) (PAD_COUNT(size, blk_desc->blksz))
89 #define PAD_TO_BLOCKSIZE(size, blk_desc) \
90 (PAD_SIZE(size, blk_desc->blksz))
92 #ifdef CONFIG_BLOCK_CACHE
94 * blkcache_read() - attempt to read a set of blocks from cache
96 * @param iftype - IF_TYPE_x for type of device
97 * @param dev - device index of particular type
98 * @param start - starting block number
99 * @param blkcnt - number of blocks to read
100 * @param blksz - size in bytes of each block
101 * @param buf - buffer to contain cached data
103 * @return - '1' if block returned from cache, '0' otherwise.
105 int blkcache_read(int iftype
, int dev
,
106 lbaint_t start
, lbaint_t blkcnt
,
107 unsigned long blksz
, void *buffer
);
110 * blkcache_fill() - make data read from a block device available
113 * @param iftype - IF_TYPE_x for type of device
114 * @param dev - device index of particular type
115 * @param start - starting block number
116 * @param blkcnt - number of blocks available
117 * @param blksz - size in bytes of each block
118 * @param buf - buffer containing data to cache
121 void blkcache_fill(int iftype
, int dev
,
122 lbaint_t start
, lbaint_t blkcnt
,
123 unsigned long blksz
, void const *buffer
);
126 * blkcache_invalidate() - discard the cache for a set of blocks
127 * because of a write or device (re)initialization.
129 * @param iftype - IF_TYPE_x for type of device
130 * @param dev - device index of particular type
132 void blkcache_invalidate(int iftype
, int dev
);
135 * blkcache_configure() - configure block cache
137 * @param blocks - maximum blocks per entry
138 * @param entries - maximum entries in cache
140 void blkcache_configure(unsigned blocks
, unsigned entries
);
143 * statistics of the block cache
145 struct block_cache_stats
{
148 unsigned entries
; /* current entry count */
149 unsigned max_blocks_per_entry
;
150 unsigned max_entries
;
154 * get_blkcache_stats() - return statistics and reset
156 * @param stats - statistics are copied here
158 void blkcache_stats(struct block_cache_stats
*stats
);
162 static inline int blkcache_read(int iftype
, int dev
,
163 lbaint_t start
, lbaint_t blkcnt
,
164 unsigned long blksz
, void *buffer
)
169 static inline void blkcache_fill(int iftype
, int dev
,
170 lbaint_t start
, lbaint_t blkcnt
,
171 unsigned long blksz
, void const *buffer
) {}
173 static inline void blkcache_invalidate(int iftype
, int dev
) {}
180 /* Operations on block devices */
183 * read() - read from a block device
185 * @dev: Device to read from
186 * @start: Start block number to read (0=first)
187 * @blkcnt: Number of blocks to read
188 * @buffer: Destination buffer for data read
189 * @return number of blocks read, or -ve error number (see the
190 * IS_ERR_VALUE() macro
192 unsigned long (*read
)(struct udevice
*dev
, lbaint_t start
,
193 lbaint_t blkcnt
, void *buffer
);
196 * write() - write to a block device
198 * @dev: Device to write to
199 * @start: Start block number to write (0=first)
200 * @blkcnt: Number of blocks to write
201 * @buffer: Source buffer for data to write
202 * @return number of blocks written, or -ve error number (see the
203 * IS_ERR_VALUE() macro
205 unsigned long (*write
)(struct udevice
*dev
, lbaint_t start
,
206 lbaint_t blkcnt
, const void *buffer
);
209 * erase() - erase a section of a block device
211 * @dev: Device to (partially) erase
212 * @start: Start block number to erase (0=first)
213 * @blkcnt: Number of blocks to erase
214 * @return number of blocks erased, or -ve error number (see the
215 * IS_ERR_VALUE() macro
217 unsigned long (*erase
)(struct udevice
*dev
, lbaint_t start
,
221 * select_hwpart() - select a particular hardware partition
223 * Some devices (e.g. MMC) can support partitioning at the hardware
224 * level. This is quite separate from the normal idea of
225 * software-based partitions. MMC hardware partitions must be
226 * explicitly selected. Once selected only the region of the device
227 * covered by that partition is accessible.
229 * The MMC standard provides for two boot partitions (numbered 1 and 2),
230 * rpmb (3), and up to 4 addition general-purpose partitions (4-7).
232 * @desc: Block device to update
233 * @hwpart: Hardware partition number to select. 0 means the raw
234 * device, 1 is the first partition, 2 is the second, etc.
235 * @return 0 if OK, -ve on error
237 int (*select_hwpart
)(struct udevice
*dev
, int hwpart
);
240 #define blk_get_ops(dev) ((struct blk_ops *)(dev)->driver->ops)
243 * These functions should take struct udevice instead of struct blk_desc,
244 * but this is convenient for migration to driver model. Add a 'd' prefix
245 * to the function operations, so that blk_read(), etc. can be reserved for
246 * functions with the correct arguments.
248 unsigned long blk_dread(struct blk_desc
*block_dev
, lbaint_t start
,
249 lbaint_t blkcnt
, void *buffer
);
250 unsigned long blk_dwrite(struct blk_desc
*block_dev
, lbaint_t start
,
251 lbaint_t blkcnt
, const void *buffer
);
252 unsigned long blk_derase(struct blk_desc
*block_dev
, lbaint_t start
,
256 * blk_get_device() - Find and probe a block device ready for use
258 * @if_type: Interface type (enum if_type_t)
259 * @devnum: Device number (specific to each interface type)
260 * @devp: the device, if found
261 * @return - if found, -ENODEV if no device found, or other -ve error value
263 int blk_get_device(int if_type
, int devnum
, struct udevice
**devp
);
266 * blk_first_device() - Find the first device for a given interface
268 * The device is probed ready for use
270 * @devnum: Device number (specific to each interface type)
271 * @devp: the device, if found
272 * @return 0 if found, -ENODEV if no device, or other -ve error value
274 int blk_first_device(int if_type
, struct udevice
**devp
);
277 * blk_next_device() - Find the next device for a given interface
279 * This can be called repeatedly after blk_first_device() to iterate through
280 * all devices of the given interface type.
282 * The device is probed ready for use
284 * @devp: On entry, the previous device returned. On exit, the next
286 * @return 0 if found, -ENODEV if no device, or other -ve error value
288 int blk_next_device(struct udevice
**devp
);
291 * blk_create_device() - Create a new block device
293 * @parent: Parent of the new device
294 * @drv_name: Driver name to use for the block device
295 * @name: Name for the device
296 * @if_type: Interface type (enum if_type_t)
297 * @devnum: Device number, specific to the interface type, or -1 to
298 * allocate the next available number
299 * @blksz: Block size of the device in bytes (typically 512)
300 * @size: Total size of the device in bytes
301 * @devp: the new device (which has not been probed)
303 int blk_create_device(struct udevice
*parent
, const char *drv_name
,
304 const char *name
, int if_type
, int devnum
, int blksz
,
305 lbaint_t size
, struct udevice
**devp
);
308 * blk_create_devicef() - Create a new named block device
310 * @parent: Parent of the new device
311 * @drv_name: Driver name to use for the block device
312 * @name: Name for the device (parent name is prepended)
313 * @if_type: Interface type (enum if_type_t)
314 * @devnum: Device number, specific to the interface type, or -1 to
315 * allocate the next available number
316 * @blksz: Block size of the device in bytes (typically 512)
317 * @size: Total size of the device in bytes
318 * @devp: the new device (which has not been probed)
320 int blk_create_devicef(struct udevice
*parent
, const char *drv_name
,
321 const char *name
, int if_type
, int devnum
, int blksz
,
322 lbaint_t size
, struct udevice
**devp
);
325 * blk_prepare_device() - Prepare a block device for use
327 * This reads partition information from the device if supported.
329 * @dev: Device to prepare
330 * @return 0 if ok, -ve on error
332 int blk_prepare_device(struct udevice
*dev
);
335 * blk_unbind_all() - Unbind all device of the given interface type
337 * The devices are removed and then unbound.
339 * @if_type: Interface type to unbind
340 * @return 0 if OK, -ve on error
342 int blk_unbind_all(int if_type
);
345 * blk_find_max_devnum() - find the maximum device number for an interface type
347 * Finds the last allocated device number for an interface type @if_type. The
348 * next number is safe to use for a newly allocated device.
350 * @if_type: Interface type to scan
351 * @return maximum device number found, or -ENODEV if none, or other -ve on
354 int blk_find_max_devnum(enum if_type if_type
);
357 * blk_select_hwpart() - select a hardware partition
359 * Select a hardware partition if the device supports it (typically MMC does)
361 * @dev: Device to update
362 * @hwpart: Partition number to select
363 * @return 0 if OK, -ve on error
365 int blk_select_hwpart(struct udevice
*dev
, int hwpart
);
370 * These functions should take struct udevice instead of struct blk_desc,
371 * but this is convenient for migration to driver model. Add a 'd' prefix
372 * to the function operations, so that blk_read(), etc. can be reserved for
373 * functions with the correct arguments.
375 static inline ulong
blk_dread(struct blk_desc
*block_dev
, lbaint_t start
,
376 lbaint_t blkcnt
, void *buffer
)
379 if (blkcache_read(block_dev
->if_type
, block_dev
->devnum
,
380 start
, blkcnt
, block_dev
->blksz
, buffer
))
384 * We could check if block_read is NULL and return -ENOSYS. But this
385 * bloats the code slightly (cause some board to fail to build), and
386 * it would be an error to try an operation that does not exist.
388 blks_read
= block_dev
->block_read(block_dev
, start
, blkcnt
, buffer
);
389 if (blks_read
== blkcnt
)
390 blkcache_fill(block_dev
->if_type
, block_dev
->devnum
,
391 start
, blkcnt
, block_dev
->blksz
, buffer
);
396 static inline ulong
blk_dwrite(struct blk_desc
*block_dev
, lbaint_t start
,
397 lbaint_t blkcnt
, const void *buffer
)
399 blkcache_invalidate(block_dev
->if_type
, block_dev
->devnum
);
400 return block_dev
->block_write(block_dev
, start
, blkcnt
, buffer
);
403 static inline ulong
blk_derase(struct blk_desc
*block_dev
, lbaint_t start
,
406 blkcache_invalidate(block_dev
->if_type
, block_dev
->devnum
);
407 return block_dev
->block_erase(block_dev
, start
, blkcnt
);
411 * struct blk_driver - Driver for block interface types
413 * This provides access to the block devices for each interface type. One
414 * driver should be provided using U_BOOT_LEGACY_BLK() for each interface
415 * type that is to be supported.
417 * @if_typename: Interface type name
418 * @if_type: Interface type
419 * @max_devs: Maximum number of devices supported
420 * @desc: Pointer to list of devices for this interface type,
421 * or NULL to use @get_dev() instead
424 const char *if_typename
;
425 enum if_type if_type
;
427 struct blk_desc
*desc
;
429 * get_dev() - get a pointer to a block device given its number
431 * Each interface allocates its own devices and typically
432 * struct blk_desc is contained with the interface's data structure.
433 * There is no global numbering for block devices. This method allows
434 * the device for an interface type to be obtained when @desc is NULL.
436 * @devnum: Device number (0 for first device on that interface,
438 * @descp: Returns pointer to the block device on success
439 * @return 0 if OK, -ve on error
441 int (*get_dev
)(int devnum
, struct blk_desc
**descp
);
444 * select_hwpart() - Select a hardware partition
446 * Some devices (e.g. MMC) can support partitioning at the hardware
447 * level. This is quite separate from the normal idea of
448 * software-based partitions. MMC hardware partitions must be
449 * explicitly selected. Once selected only the region of the device
450 * covered by that partition is accessible.
452 * The MMC standard provides for two boot partitions (numbered 1 and 2),
453 * rpmb (3), and up to 4 addition general-purpose partitions (4-7).
454 * Partition 0 is the main user-data partition.
456 * @desc: Block device descriptor
457 * @hwpart: Hardware partition number to select. 0 means the main
458 * user-data partition, 1 is the first partition, 2 is
460 * @return 0 if OK, other value for an error
462 int (*select_hwpart
)(struct blk_desc
*desc
, int hwpart
);
466 * Declare a new U-Boot legacy block driver. New drivers should use driver
467 * model (UCLASS_BLK).
469 #define U_BOOT_LEGACY_BLK(__name) \
470 ll_entry_declare(struct blk_driver, __name, blk_driver)
472 struct blk_driver
*blk_driver_lookup_type(int if_type
);
474 #endif /* !CONFIG_BLK */
477 * blk_get_devnum_by_typename() - Get a block device by type and number
479 * This looks through the available block devices of the given type, returning
480 * the one with the given @devnum.
482 * @if_type: Block device type
483 * @devnum: Device number
484 * @return point to block device descriptor, or NULL if not found
486 struct blk_desc
*blk_get_devnum_by_type(enum if_type if_type
, int devnum
);
489 * blk_get_devnum_by_type() - Get a block device by type name, and number
491 * This looks up the block device type based on @if_typename, then calls
492 * blk_get_devnum_by_type().
494 * @if_typename: Block device type name
495 * @devnum: Device number
496 * @return point to block device descriptor, or NULL if not found
498 struct blk_desc
*blk_get_devnum_by_typename(const char *if_typename
,
502 * blk_dselect_hwpart() - select a hardware partition
504 * This selects a hardware partition (such as is supported by MMC). The block
505 * device size may change as this effectively points the block device to a
506 * partition at the hardware level. See the select_hwpart() method above.
508 * @desc: Block device descriptor for the device to select
509 * @hwpart: Partition number to select
510 * @return 0 if OK, -ve on error
512 int blk_dselect_hwpart(struct blk_desc
*desc
, int hwpart
);
515 * blk_list_part() - list the partitions for block devices of a given type
517 * This looks up the partition type for each block device of type @if_type,
518 * then displays a list of partitions.
520 * @if_type: Block device type
521 * @return 0 if OK, -ENODEV if there is none of that type
523 int blk_list_part(enum if_type if_type
);
526 * blk_list_devices() - list the block devices of a given type
528 * This lists each block device of the type @if_type, showing the capacity
529 * as well as type-specific information.
531 * @if_type: Block device type
533 void blk_list_devices(enum if_type if_type
);
536 * blk_show_device() - show information about a given block device
538 * This shows the block device capacity as well as type-specific information.
540 * @if_type: Block device type
541 * @devnum: Device number
542 * @return 0 if OK, -ENODEV for invalid device number
544 int blk_show_device(enum if_type if_type
, int devnum
);
547 * blk_print_device_num() - show information about a given block device
549 * This is similar to blk_show_device() but returns an error if the block
550 * device type is unknown.
552 * @if_type: Block device type
553 * @devnum: Device number
554 * @return 0 if OK, -ENODEV for invalid device number, -ENOENT if the block
555 * device is not connected
557 int blk_print_device_num(enum if_type if_type
, int devnum
);
560 * blk_print_part_devnum() - print the partition information for a device
562 * @if_type: Block device type
563 * @devnum: Device number
564 * @return 0 if OK, -ENOENT if the block device is not connected, -ENOSYS if
565 * the interface type is not supported, other -ve on other error
567 int blk_print_part_devnum(enum if_type if_type
, int devnum
);
570 * blk_read_devnum() - read blocks from a device
572 * @if_type: Block device type
573 * @devnum: Device number
574 * @blkcnt: Number of blocks to read
575 * @buffer: Address to write data to
576 * @return number of blocks read, or -ve error number on error
578 ulong
blk_read_devnum(enum if_type if_type
, int devnum
, lbaint_t start
,
579 lbaint_t blkcnt
, void *buffer
);
582 * blk_write_devnum() - write blocks to a device
584 * @if_type: Block device type
585 * @devnum: Device number
586 * @blkcnt: Number of blocks to write
587 * @buffer: Address to read data from
588 * @return number of blocks written, or -ve error number on error
590 ulong
blk_write_devnum(enum if_type if_type
, int devnum
, lbaint_t start
,
591 lbaint_t blkcnt
, const void *buffer
);
594 * blk_select_hwpart_devnum() - select a hardware partition
596 * This is similar to blk_dselect_hwpart() but it looks up the interface and
599 * @if_type: Block device type
600 * @devnum: Device number
601 * @hwpart: Partition number to select
602 * @return 0 if OK, -ve on error
604 int blk_select_hwpart_devnum(enum if_type if_type
, int devnum
, int hwpart
);