blob: f2aae89716b4211beccf9b49442cf49d95bf91eb [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Henrik Nordström26f9a6c2013-11-10 10:26:56 -07002/*
3 * Copyright (C) 2013 Henrik Nordstrom <henrik@henriknordstrom.net>
Henrik Nordström26f9a6c2013-11-10 10:26:56 -07004 */
5
Henrik Nordström26f9a6c2013-11-10 10:26:56 -07006#include <common.h>
Simon Glass2c2075a2016-02-29 15:25:57 -07007#include <blk.h>
8#include <dm.h>
9#include <fdtdec.h>
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070010#include <part.h>
11#include <os.h>
12#include <malloc.h>
13#include <sandboxblockdev.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060014#include <asm/global_data.h>
Simon Glass9bc15642020-02-03 07:36:16 -070015#include <dm/device_compat.h>
Masahiro Yamada56a931c2016-09-21 11:28:55 +090016#include <linux/errno.h>
Simon Glass2c2075a2016-02-29 15:25:57 -070017#include <dm/device-internal.h>
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070018
Simon Glass2c2075a2016-02-29 15:25:57 -070019DECLARE_GLOBAL_DATA_PTR;
20
Simon Glass86bc14f2016-05-01 11:35:49 -060021#ifndef CONFIG_BLK
Simon Glassc6d76812021-11-24 09:26:40 -070022static struct host_block_dev host_devices[SANDBOX_HOST_MAX_DEVICES];
Simon Glass86bc14f2016-05-01 11:35:49 -060023
24static struct host_block_dev *find_host_device(int dev)
25{
Simon Glassc6d76812021-11-24 09:26:40 -070026 if (dev >= 0 && dev < SANDBOX_HOST_MAX_DEVICES)
Simon Glass86bc14f2016-05-01 11:35:49 -060027 return &host_devices[dev];
28
29 return NULL;
30}
31#endif
32
33#ifdef CONFIG_BLK
Simon Glass2c2075a2016-02-29 15:25:57 -070034static unsigned long host_block_read(struct udevice *dev,
35 unsigned long start, lbaint_t blkcnt,
36 void *buffer)
37{
Simon Glassfa20e932020-12-03 16:55:20 -070038 struct host_block_dev *host_dev = dev_get_plat(dev);
Simon Glass71fa5b42020-12-03 16:55:18 -070039 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
Simon Glass2c2075a2016-02-29 15:25:57 -070040
Simon Glass86bc14f2016-05-01 11:35:49 -060041#else
42static unsigned long host_block_read(struct blk_desc *block_dev,
43 unsigned long start, lbaint_t blkcnt,
44 void *buffer)
45{
46 int dev = block_dev->devnum;
47 struct host_block_dev *host_dev = find_host_device(dev);
48
49 if (!host_dev)
50 return -1;
51#endif
52
Simon Glass52e85ac2016-02-29 15:25:56 -070053 if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
54 -1) {
55 printf("ERROR: Invalid block %lx\n", start);
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070056 return -1;
57 }
Simon Glass52e85ac2016-02-29 15:25:56 -070058 ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070059 if (len >= 0)
Simon Glass52e85ac2016-02-29 15:25:56 -070060 return len / block_dev->blksz;
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070061 return -1;
62}
63
Simon Glass86bc14f2016-05-01 11:35:49 -060064#ifdef CONFIG_BLK
Simon Glass2c2075a2016-02-29 15:25:57 -070065static unsigned long host_block_write(struct udevice *dev,
66 unsigned long start, lbaint_t blkcnt,
67 const void *buffer)
68{
Simon Glassfa20e932020-12-03 16:55:20 -070069 struct host_block_dev *host_dev = dev_get_plat(dev);
Simon Glass71fa5b42020-12-03 16:55:18 -070070 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
Simon Glass86bc14f2016-05-01 11:35:49 -060071#else
72static unsigned long host_block_write(struct blk_desc *block_dev,
73 unsigned long start, lbaint_t blkcnt,
74 const void *buffer)
75{
76 int dev = block_dev->devnum;
77 struct host_block_dev *host_dev = find_host_device(dev);
78#endif
Simon Glass52e85ac2016-02-29 15:25:56 -070079
80 if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
81 -1) {
82 printf("ERROR: Invalid block %lx\n", start);
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070083 return -1;
84 }
Simon Glass52e85ac2016-02-29 15:25:56 -070085 ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070086 if (len >= 0)
Simon Glass52e85ac2016-02-29 15:25:56 -070087 return len / block_dev->blksz;
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070088 return -1;
89}
90
Simon Glass86bc14f2016-05-01 11:35:49 -060091#ifdef CONFIG_BLK
Simon Glassb4d00772021-03-15 18:11:11 +130092int host_dev_bind(int devnum, char *filename, bool removable)
Simon Glass2c2075a2016-02-29 15:25:57 -070093{
94 struct host_block_dev *host_dev;
95 struct udevice *dev;
Heinrich Schuchardte3cfde92021-01-25 12:57:14 +010096 struct blk_desc *desc;
Simon Glass2c2075a2016-02-29 15:25:57 -070097 char dev_name[20], *str, *fname;
98 int ret, fd;
99
100 /* Remove and unbind the old device, if any */
Simon Glassdbfa32c2022-08-11 19:34:59 -0600101 ret = blk_get_device(UCLASS_ROOT, devnum, &dev);
Simon Glass2c2075a2016-02-29 15:25:57 -0700102 if (ret == 0) {
Stefan Roese80b5bc92017-03-20 12:51:48 +0100103 ret = device_remove(dev, DM_REMOVE_NORMAL);
Simon Glass2c2075a2016-02-29 15:25:57 -0700104 if (ret)
105 return ret;
106 ret = device_unbind(dev);
107 if (ret)
108 return ret;
109 } else if (ret != -ENODEV) {
110 return ret;
111 }
112
113 if (!filename)
114 return 0;
115
116 snprintf(dev_name, sizeof(dev_name), "host%d", devnum);
117 str = strdup(dev_name);
118 if (!str)
119 return -ENOMEM;
120 fname = strdup(filename);
121 if (!fname) {
122 free(str);
123 return -ENOMEM;
124 }
125
126 fd = os_open(filename, OS_O_RDWR);
127 if (fd == -1) {
Simon Glass08831622022-02-28 15:13:47 -0700128 printf("Failed to access host backing file '%s', trying read-only\n",
129 filename);
130 fd = os_open(filename, OS_O_RDONLY);
131 if (fd == -1) {
132 printf("- still failed\n");
133 ret = -ENOENT;
134 goto err;
135 }
Simon Glass2c2075a2016-02-29 15:25:57 -0700136 }
137 ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
Simon Glassdbfa32c2022-08-11 19:34:59 -0600138 UCLASS_ROOT, devnum, 512,
Jean-Jacques Hiblot99b324a2017-06-09 16:45:18 +0200139 os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
Simon Glass2c2075a2016-02-29 15:25:57 -0700140 if (ret)
141 goto err_file;
Bin Meng311f8002018-10-15 02:21:05 -0700142
Simon Glassfa20e932020-12-03 16:55:20 -0700143 host_dev = dev_get_plat(dev);
Bin Meng311f8002018-10-15 02:21:05 -0700144 host_dev->fd = fd;
145 host_dev->filename = fname;
146
Simon Glass2c2075a2016-02-29 15:25:57 -0700147 ret = device_probe(dev);
148 if (ret) {
149 device_unbind(dev);
150 goto err_file;
151 }
152
Simon Glassfada3f92022-09-17 09:00:09 -0600153 desc = blk_get_devnum_by_uclass_id(UCLASS_ROOT, devnum);
Simon Glassb4d00772021-03-15 18:11:11 +1300154 desc->removable = removable;
Heinrich Schuchardte3cfde92021-01-25 12:57:14 +0100155 snprintf(desc->vendor, BLK_VEN_SIZE, "U-Boot");
156 snprintf(desc->product, BLK_PRD_SIZE, "hostfile");
157 snprintf(desc->revision, BLK_REV_SIZE, "1.0");
158
Bin Mengcbc3da82018-10-15 02:21:07 -0700159 return 0;
Simon Glass2c2075a2016-02-29 15:25:57 -0700160err_file:
161 os_close(fd);
162err:
163 free(fname);
164 free(str);
165 return ret;
166}
Simon Glass86bc14f2016-05-01 11:35:49 -0600167#else
Simon Glassb4d00772021-03-15 18:11:11 +1300168int host_dev_bind(int dev, char *filename, bool removable)
Simon Glass86bc14f2016-05-01 11:35:49 -0600169{
170 struct host_block_dev *host_dev = find_host_device(dev);
171
172 if (!host_dev)
173 return -1;
174 if (host_dev->blk_dev.priv) {
175 os_close(host_dev->fd);
176 host_dev->blk_dev.priv = NULL;
177 }
178 if (host_dev->filename)
179 free(host_dev->filename);
180 if (filename && *filename) {
181 host_dev->filename = strdup(filename);
182 } else {
183 host_dev->filename = NULL;
184 return 0;
185 }
186
187 host_dev->fd = os_open(host_dev->filename, OS_O_RDWR);
188 if (host_dev->fd == -1) {
189 printf("Failed to access host backing file '%s'\n",
190 host_dev->filename);
191 return 1;
192 }
193
194 struct blk_desc *blk_dev = &host_dev->blk_dev;
Simon Glassfada3f92022-09-17 09:00:09 -0600195 blk_dev->uclass_id = UCLASS_ROOT;
Simon Glass86bc14f2016-05-01 11:35:49 -0600196 blk_dev->priv = host_dev;
197 blk_dev->blksz = 512;
198 blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
199 blk_dev->block_read = host_block_read;
200 blk_dev->block_write = host_block_write;
201 blk_dev->devnum = dev;
202 blk_dev->part_type = PART_TYPE_UNKNOWN;
Simon Glassb4d00772021-03-15 18:11:11 +1300203 blk_dev->removable = removable;
Heinrich Schuchardte3cfde92021-01-25 12:57:14 +0100204 snprintf(blk_dev->vendor, BLK_VEN_SIZE, "U-Boot");
205 snprintf(blk_dev->product, BLK_PRD_SIZE, "hostfile");
206 snprintf(blk_dev->revision, BLK_REV_SIZE, "1.0");
Simon Glass86bc14f2016-05-01 11:35:49 -0600207 part_init(blk_dev);
208
209 return 0;
210}
211#endif
Henrik Nordström26f9a6c2013-11-10 10:26:56 -0700212
Simon Glass52e85ac2016-02-29 15:25:56 -0700213int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
Henrik Nordström26f9a6c2013-11-10 10:26:56 -0700214{
Simon Glass86bc14f2016-05-01 11:35:49 -0600215#ifdef CONFIG_BLK
Simon Glass2c2075a2016-02-29 15:25:57 -0700216 struct udevice *dev;
217 int ret;
218
Simon Glassdbfa32c2022-08-11 19:34:59 -0600219 ret = blk_get_device(UCLASS_ROOT, devnum, &dev);
Simon Glass2c2075a2016-02-29 15:25:57 -0700220 if (ret)
221 return ret;
Simon Glass71fa5b42020-12-03 16:55:18 -0700222 *blk_devp = dev_get_uclass_plat(dev);
Simon Glass86bc14f2016-05-01 11:35:49 -0600223#else
224 struct host_block_dev *host_dev = find_host_device(devnum);
225
226 if (!host_dev)
227 return -ENODEV;
228
229 if (!host_dev->blk_dev.priv)
230 return -ENOENT;
231
232 *blk_devp = &host_dev->blk_dev;
233#endif
Simon Glass2c2075a2016-02-29 15:25:57 -0700234
Henrik Nordström26f9a6c2013-11-10 10:26:56 -0700235 return 0;
236}
237
Simon Glass86bc14f2016-05-01 11:35:49 -0600238#ifdef CONFIG_BLK
Heinrich Schuchardt49b5e2e2021-02-03 00:21:56 +0100239
240int sandbox_host_unbind(struct udevice *dev)
241{
242 struct host_block_dev *host_dev;
243
244 /* Data validity is checked in host_dev_bind() */
245 host_dev = dev_get_plat(dev);
246 os_close(host_dev->fd);
247
248 return 0;
249}
250
Simon Glass2c2075a2016-02-29 15:25:57 -0700251static const struct blk_ops sandbox_host_blk_ops = {
252 .read = host_block_read,
253 .write = host_block_write,
254};
255
256U_BOOT_DRIVER(sandbox_host_blk) = {
257 .name = "sandbox_host_blk",
258 .id = UCLASS_BLK,
259 .ops = &sandbox_host_blk_ops,
Heinrich Schuchardt49b5e2e2021-02-03 00:21:56 +0100260 .unbind = sandbox_host_unbind,
Simon Glass71fa5b42020-12-03 16:55:18 -0700261 .plat_auto = sizeof(struct host_block_dev),
Simon Glass2c2075a2016-02-29 15:25:57 -0700262};
Simon Glassa57299e2016-05-01 11:36:05 -0600263#else
264U_BOOT_LEGACY_BLK(sandbox_host) = {
Simon Glassfada3f92022-09-17 09:00:09 -0600265 .uclass_idname = "host",
266 .uclass_id = UCLASS_ROOT,
Simon Glassc6d76812021-11-24 09:26:40 -0700267 .max_devs = SANDBOX_HOST_MAX_DEVICES,
Simon Glassa57299e2016-05-01 11:36:05 -0600268 .get_dev = host_get_dev_err,
269};
Simon Glass86bc14f2016-05-01 11:35:49 -0600270#endif