include/bootflow.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Copyright 2021 Google LLC
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #ifndef __bootflow_h
   8 #define __bootflow_h
   9
  10 #include <linux/list.h>
  11
  12 /**
  13  * enum bootflow_state_t - states that a particular bootflow can be in
  14  *
  15  * Only bootflows in state BOOTFLOWST_READY can be used to boot.
  16  *
  17  * See bootflow_state[] for the names for each of these
  18  */
  19 enum bootflow_state_t {
  20         BOOTFLOWST_BASE,        /**< Nothing known yet */
  21         BOOTFLOWST_MEDIA,       /**< Media exists */
  22         BOOTFLOWST_PART,        /**< Partition exists */
  23         BOOTFLOWST_FS,          /**< Filesystem exists */
  24         BOOTFLOWST_FILE,        /**< Bootflow file exists */
  25         BOOTFLOWST_READY,       /**< Bootflow file loaded */
  26
  27         BOOTFLOWST_COUNT
  28 };
  29
  30 /**
  31  * struct bootflow - information about a bootflow
  32  *
  33  * This is connected into two separate linked lists:
  34  *
  35  *   bm_sibling - links all bootflows in the same bootdev
  36  *   glob_sibling - links all bootflows in all bootdevs
  37  *
  38  * @bm_node: Points to siblings in the same bootdev
  39  * @glob_node: Points to siblings in the global list (all bootdev)
  40  * @dev: Bootdevice device which produced this bootflow
  41  * @blk: Block device which contains this bootflow, NULL if this is a network
  42  *      device
  43  * @part: Partition number (0 for whole device)
  44  * @fs_type: Filesystem type (FS_TYPE...) if this is fixed by the media, else 0.
  45  *      For example, the sandbox host-filesystem bootdev sets this to
  46  *      FS_TYPE_SANDBOX
  47  * @method: Bootmethod device used to perform the boot and read files
  48  * @name: Name of bootflow (allocated)
  49  * @state: Current state (enum bootflow_state_t)
  50  * @subdir: Subdirectory to fetch files from (with trailing /), or NULL if none
  51  * @fname: Filename of bootflow file (allocated)
  52  * @buf: Bootflow file contents (allocated)
  53  * @size: Size of bootflow file in bytes
  54  * @err: Error number received (0 if OK)
  55  */
  56 struct bootflow {
  57         struct list_head bm_node;
  58         struct list_head glob_node;
  59         struct udevice *dev;
  60         struct udevice *blk;
  61         int part;
  62         int fs_type;
  63         struct udevice *method;
  64         char *name;
  65         enum bootflow_state_t state;
  66         char *subdir;
  67         char *fname;
  68         char *buf;
  69         int size;
  70         int err;
  71 };
  72
  73 /**
  74  * enum bootflow_flags_t - flags for the bootflow iterator
  75  *
  76  * @BOOTFLOWF_FIXED: Only used fixed/internal media
  77  * @BOOTFLOWF_SHOW: Show each bootdev before scanning it
  78  * @BOOTFLOWF_ALL: Return bootflows with errors as well
  79  * @BOOTFLOWF_SINGLE_DEV: Just scan one bootmeth
  80  */
  81 enum bootflow_flags_t {
  82         BOOTFLOWF_FIXED         = 1 << 0,
  83         BOOTFLOWF_SHOW          = 1 << 1,
  84         BOOTFLOWF_ALL           = 1 << 2,
  85         BOOTFLOWF_SINGLE_DEV    = 1 << 3,
  86 };
  87
  88 /**
  89  * struct bootflow_iter - state for iterating through bootflows
  90  *
  91  * This starts at with the first bootdev/partition/bootmeth and can be used to
  92  * iterate through all of them.
  93  *
  94  * Iteration starts with the bootdev. The first partition (0, i.e. whole device)
  95  * is scanned first. For partition 0, it iterates through all the available
  96  * bootmeths to see which one(s) can provide a bootflow. Then it moves to
  97  * parition 1 (if there is one) and the process continues. Once all partitions
  98  * are examined, it moves to the next bootdev.
  99  *
 100  * Initially @max_part is 0, meaning that only the whole device (@part=0) can be
 101  * used. During scanning, if a partition table is found, then @max_part is
 102  * updated to a larger value, no less than the number of available partitions.
 103  * This ensures that iteration works through all partitions on the bootdev.
 104  *
 105  * @flags: Flags to use (see enum bootflow_flags_t)
 106  * @dev: Current bootdev
 107  * @part: Current partition number (0 for whole device)
 108  * @method: Current bootmeth
 109  * @max_part: Maximum hardware partition number in @dev, 0 if there is no
 110  *      partition table
 111  * @err: Error obtained from checking the last iteration. This is used to skip
 112  *      forward (e.g. to skip the current partition because it is not valid)
 113  *      -ESHUTDOWN: try next bootdev
 114  * @num_devs: Number of bootdevs in @dev_order
 115  * @cur_dev: Current bootdev number, an index into @dev_order[]
 116  * @dev_order: List of bootdevs to scan, in order of priority. The scan starts
 117  *      with the first one on the list
 118  * @num_methods: Number of bootmeth devices in @method_order
 119  * @cur_method: Current method number, an index into @method_order
 120  * @method_order: List of bootmeth devices to use, in order
 121  */
 122 struct bootflow_iter {
 123         int flags;
 124         struct udevice *dev;
 125         int part;
 126         struct udevice *method;
 127         int max_part;
 128         int err;
 129         int num_devs;
 130         int cur_dev;
 131         struct udevice **dev_order;
 132         int num_methods;
 133         int cur_method;
 134         struct udevice **method_order;
 135 };
 136
 137 /**
 138  * bootflow_iter_init() - Reset a bootflow iterator
 139  *
 140  * This sets everything to the starting point, ready for use.
 141  *
 142  * @iter: Place to store private info (inited by this call)
 143  * @flags: Flags to use (see enum bootflow_flags_t)
 144  */
 145 void bootflow_iter_init(struct bootflow_iter *iter, int flags);
 146
 147 /**
 148  * bootflow_iter_uninit() - Free memory used by an interator
 149  *
 150  * @iter:       Iterator to free
 151  */
 152 void bootflow_iter_uninit(struct bootflow_iter *iter);
 153
 154 /**
 155  * bootflow_scan_bootdev() - find the first bootflow in a bootdev
 156  *
 157  * If @flags includes BOOTFLOWF_ALL then bootflows with errors are returned too
 158  *
 159  * @dev:        Boot device to scan, NULL to work through all of them until it
 160  *      finds one that * can supply a bootflow
 161  * @iter:       Place to store private info (inited by this call)
 162  * @flags:      Flags for bootdev (enum bootflow_flags_t)
 163  * @bflow:      Place to put the bootflow if found
 164  * Return: 0 if found,  -ENODEV if no device, other -ve on other error
 165  *      (iteration can continue)
 166  */
 167 int bootflow_scan_bootdev(struct udevice *dev, struct bootflow_iter *iter,
 168                           int flags, struct bootflow *bflow);
 169
 170 /**
 171  * bootflow_scan_first() - find the first bootflow
 172  *
 173  * This works through the available bootdev devices until it finds one that
 174  * can supply a bootflow. It then returns that
 175  *
 176  * If @flags includes BOOTFLOWF_ALL then bootflows with errors are returned too
 177  *
 178  * @iter:       Place to store private info (inited by this call), with
 179  * @flags:      Flags for bootdev (enum bootflow_flags_t)
 180  * @bflow:      Place to put the bootflow if found
 181  * Return: 0 if found, -ENODEV if no device, other -ve on other error (iteration
 182  *      can continue)
 183  */
 184 int bootflow_scan_first(struct bootflow_iter *iter, int flags,
 185                         struct bootflow *bflow);
 186
 187 /**
 188  * bootflow_scan_next() - find the next bootflow
 189  *
 190  * This works through the available bootdev devices until it finds one that
 191  * can supply a bootflow. It then returns that bootflow
 192  *
 193  * @iter:       Private info (as set up by bootflow_scan_first())
 194  * @bflow:      Place to put the bootflow if found
 195  * Return: 0 if found, -ENODEV if no device, -ESHUTDOWN if no more bootflows,
 196  *      other -ve on other error (iteration can continue)
 197  */
 198 int bootflow_scan_next(struct bootflow_iter *iter, struct bootflow *bflow);
 199
 200 /**
 201  * bootflow_first_glob() - Get the first bootflow from the global list
 202  *
 203  * Returns the first bootflow in the global list, no matter what bootflow it is
 204  * attached to
 205  *
 206  * @bflowp: Returns a pointer to the bootflow
 207  * Return: 0 if found, -ENOENT if there are no bootflows
 208  */
 209 int bootflow_first_glob(struct bootflow **bflowp);
 210
 211 /**
 212  * bootflow_next_glob() - Get the next bootflow from the global list
 213  *
 214  * Returns the next bootflow in the global list, no matter what bootflow it is
 215  * attached to
 216  *
 217  * @bflowp: On entry, the last bootflow returned , e.g. from
 218  *      bootflow_first_glob()
 219  * Return: 0 if found, -ENOENT if there are no more bootflows
 220  */
 221 int bootflow_next_glob(struct bootflow **bflowp);
 222
 223 /**
 224  * bootflow_free() - Free memory used by a bootflow
 225  *
 226  * This frees fields within @bflow, but not the @bflow pointer itself
 227  */
 228 void bootflow_free(struct bootflow *bflow);
 229
 230 /**
 231  * bootflow_boot() - boot a bootflow
 232  *
 233  * @bflow: Bootflow to boot
 234  * Return: -EPROTO if bootflow has not been loaded, -ENOSYS if the bootflow
 235  *      type is not supported, -EFAULT if the boot returned without an error
 236  *      when we are expecting it to boot, -ENOTSUPP if trying method resulted in
 237  *      finding out that is not actually supported for this boot and should not
 238  *      be tried again unless something changes
 239  */
 240 int bootflow_boot(struct bootflow *bflow);
 241
 242 /**
 243  * bootflow_run_boot() - Try to boot a bootflow
 244  *
 245  * @iter: Current iteration (or NULL if none). Used to disable a bootmeth if the
 246  *      boot returns -ENOTSUPP
 247  * @bflow: Bootflow to boot
 248  * Return: result of trying to boot
 249  */
 250 int bootflow_run_boot(struct bootflow_iter *iter, struct bootflow *bflow);
 251
 252 /**
 253  * bootflow_state_get_name() - Get the name of a bootflow state
 254  *
 255  * @state: State to check
 256  * Return: name, or "?" if invalid
 257  */
 258 const char *bootflow_state_get_name(enum bootflow_state_t state);
 259
 260 #endif