1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2013 Henrik Nordstrom <henrik@henriknordstrom.net>
4 */
5
6 #include <common.h>
7 #include <blk.h>
8 #include <dm.h>
9 #include <fdtdec.h>
10 #include <part.h>
11 #include <os.h>
12 #include <malloc.h>
13 #include <sandboxblockdev.h>
14 #include <asm/global_data.h>
15 #include <dm/device_compat.h>
16 #include <linux/errno.h>
17 #include <dm/device-internal.h>
18
19 DECLARE_GLOBAL_DATA_PTR;
20
21 #ifndef CONFIG_BLK
22 static struct host_block_dev host_devices[CONFIG_HOST_MAX_DEVICES];
23
find_host_device(int dev)24 static struct host_block_dev *find_host_device(int dev)
25 {
26 if (dev >= 0 && dev < CONFIG_HOST_MAX_DEVICES)
27 return &host_devices[dev];
28
29 return NULL;
30 }
31 #endif
32
33 #ifdef CONFIG_BLK
host_block_read(struct udevice * dev,unsigned long start,lbaint_t blkcnt,void * buffer)34 static unsigned long host_block_read(struct udevice *dev,
35 unsigned long start, lbaint_t blkcnt,
36 void *buffer)
37 {
38 struct host_block_dev *host_dev = dev_get_plat(dev);
39 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
40
41 #else
42 static 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
53 if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
54 -1) {
55 printf("ERROR: Invalid block %lx\n", start);
56 return -1;
57 }
58 ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
59 if (len >= 0)
60 return len / block_dev->blksz;
61 return -1;
62 }
63
64 #ifdef CONFIG_BLK
65 static unsigned long host_block_write(struct udevice *dev,
66 unsigned long start, lbaint_t blkcnt,
67 const void *buffer)
68 {
69 struct host_block_dev *host_dev = dev_get_plat(dev);
70 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
71 #else
72 static 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
79
80 if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
81 -1) {
82 printf("ERROR: Invalid block %lx\n", start);
83 return -1;
84 }
85 ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
86 if (len >= 0)
87 return len / block_dev->blksz;
88 return -1;
89 }
90
91 #ifdef CONFIG_BLK
92 int host_dev_bind(int devnum, char *filename, bool removable)
93 {
94 struct host_block_dev *host_dev;
95 struct udevice *dev;
96 struct blk_desc *desc;
97 char dev_name[20], *str, *fname;
98 int ret, fd;
99
100 /* Remove and unbind the old device, if any */
101 ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
102 if (ret == 0) {
103 ret = device_remove(dev, DM_REMOVE_NORMAL);
104 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) {
128 printf("Failed to access host backing file '%s'\n", filename);
129 ret = -ENOENT;
130 goto err;
131 }
132 ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
133 IF_TYPE_HOST, devnum, 512,
134 os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
135 if (ret)
136 goto err_file;
137
138 host_dev = dev_get_plat(dev);
139 host_dev->fd = fd;
140 host_dev->filename = fname;
141
142 ret = device_probe(dev);
143 if (ret) {
144 device_unbind(dev);
145 goto err_file;
146 }
147
148 desc = blk_get_devnum_by_type(IF_TYPE_HOST, devnum);
149 desc->removable = removable;
150 snprintf(desc->vendor, BLK_VEN_SIZE, "U-Boot");
151 snprintf(desc->product, BLK_PRD_SIZE, "hostfile");
152 snprintf(desc->revision, BLK_REV_SIZE, "1.0");
153
154 return 0;
155 err_file:
156 os_close(fd);
157 err:
158 free(fname);
159 free(str);
160 return ret;
161 }
162 #else
163 int host_dev_bind(int dev, char *filename, bool removable)
164 {
165 struct host_block_dev *host_dev = find_host_device(dev);
166
167 if (!host_dev)
168 return -1;
169 if (host_dev->blk_dev.priv) {
170 os_close(host_dev->fd);
171 host_dev->blk_dev.priv = NULL;
172 }
173 if (host_dev->filename)
174 free(host_dev->filename);
175 if (filename && *filename) {
176 host_dev->filename = strdup(filename);
177 } else {
178 host_dev->filename = NULL;
179 return 0;
180 }
181
182 host_dev->fd = os_open(host_dev->filename, OS_O_RDWR);
183 if (host_dev->fd == -1) {
184 printf("Failed to access host backing file '%s'\n",
185 host_dev->filename);
186 return 1;
187 }
188
189 struct blk_desc *blk_dev = &host_dev->blk_dev;
190 blk_dev->if_type = IF_TYPE_HOST;
191 blk_dev->priv = host_dev;
192 blk_dev->blksz = 512;
193 blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
194 blk_dev->block_read = host_block_read;
195 blk_dev->block_write = host_block_write;
196 blk_dev->devnum = dev;
197 blk_dev->part_type = PART_TYPE_UNKNOWN;
198 blk_dev->removable = removable;
199 snprintf(blk_dev->vendor, BLK_VEN_SIZE, "U-Boot");
200 snprintf(blk_dev->product, BLK_PRD_SIZE, "hostfile");
201 snprintf(blk_dev->revision, BLK_REV_SIZE, "1.0");
202 part_init(blk_dev);
203
204 return 0;
205 }
206 #endif
207
208 int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
209 {
210 #ifdef CONFIG_BLK
211 struct udevice *dev;
212 int ret;
213
214 ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
215 if (ret)
216 return ret;
217 *blk_devp = dev_get_uclass_plat(dev);
218 #else
219 struct host_block_dev *host_dev = find_host_device(devnum);
220
221 if (!host_dev)
222 return -ENODEV;
223
224 if (!host_dev->blk_dev.priv)
225 return -ENOENT;
226
227 *blk_devp = &host_dev->blk_dev;
228 #endif
229
230 return 0;
231 }
232
233 #ifdef CONFIG_BLK
234
235 int sandbox_host_unbind(struct udevice *dev)
236 {
237 struct host_block_dev *host_dev;
238
239 /* Data validity is checked in host_dev_bind() */
240 host_dev = dev_get_plat(dev);
241 os_close(host_dev->fd);
242
243 return 0;
244 }
245
246 static const struct blk_ops sandbox_host_blk_ops = {
247 .read = host_block_read,
248 .write = host_block_write,
249 };
250
251 U_BOOT_DRIVER(sandbox_host_blk) = {
252 .name = "sandbox_host_blk",
253 .id = UCLASS_BLK,
254 .ops = &sandbox_host_blk_ops,
255 .unbind = sandbox_host_unbind,
256 .plat_auto = sizeof(struct host_block_dev),
257 };
258 #else
259 U_BOOT_LEGACY_BLK(sandbox_host) = {
260 .if_typename = "host",
261 .if_type = IF_TYPE_HOST,
262 .max_devs = CONFIG_HOST_MAX_DEVICES,
263 .get_dev = host_get_dev_err,
264 };
265 #endif
266