blob: 34c26cda47ecdce44e39f214d0e6013f13a5a55d [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Henrik Nordströmf4d8de42013-11-10 10:26:56 -07002/*
3 * Copyright (C) 2013 Henrik Nordstrom <henrik@henriknordstrom.net>
Henrik Nordströmf4d8de42013-11-10 10:26:56 -07004 */
5
Henrik Nordströmf4d8de42013-11-10 10:26:56 -07006#include <common.h>
Simon Glass40fd0502016-02-29 15:25:57 -07007#include <blk.h>
8#include <dm.h>
9#include <fdtdec.h>
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070010#include <part.h>
11#include <os.h>
12#include <malloc.h>
13#include <sandboxblockdev.h>
Simon Glass336d4612020-02-03 07:36:16 -070014#include <dm/device_compat.h>
Masahiro Yamada1221ce42016-09-21 11:28:55 +090015#include <linux/errno.h>
Simon Glass40fd0502016-02-29 15:25:57 -070016#include <dm/device-internal.h>
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070017
Simon Glass40fd0502016-02-29 15:25:57 -070018DECLARE_GLOBAL_DATA_PTR;
19
Simon Glasse1613562016-05-01 11:35:49 -060020#ifndef CONFIG_BLK
21static struct host_block_dev host_devices[CONFIG_HOST_MAX_DEVICES];
22
23static struct host_block_dev *find_host_device(int dev)
24{
25 if (dev >= 0 && dev < CONFIG_HOST_MAX_DEVICES)
26 return &host_devices[dev];
27
28 return NULL;
29}
30#endif
31
32#ifdef CONFIG_BLK
Simon Glass40fd0502016-02-29 15:25:57 -070033static unsigned long host_block_read(struct udevice *dev,
34 unsigned long start, lbaint_t blkcnt,
35 void *buffer)
36{
Simon Glassc69cda22020-12-03 16:55:20 -070037 struct host_block_dev *host_dev = dev_get_plat(dev);
Simon Glasscaa4daa2020-12-03 16:55:18 -070038 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
Simon Glass40fd0502016-02-29 15:25:57 -070039
Simon Glasse1613562016-05-01 11:35:49 -060040#else
41static unsigned long host_block_read(struct blk_desc *block_dev,
42 unsigned long start, lbaint_t blkcnt,
43 void *buffer)
44{
45 int dev = block_dev->devnum;
46 struct host_block_dev *host_dev = find_host_device(dev);
47
48 if (!host_dev)
49 return -1;
50#endif
51
Simon Glass7ded9592016-02-29 15:25:56 -070052 if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
53 -1) {
54 printf("ERROR: Invalid block %lx\n", start);
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070055 return -1;
56 }
Simon Glass7ded9592016-02-29 15:25:56 -070057 ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070058 if (len >= 0)
Simon Glass7ded9592016-02-29 15:25:56 -070059 return len / block_dev->blksz;
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070060 return -1;
61}
62
Simon Glasse1613562016-05-01 11:35:49 -060063#ifdef CONFIG_BLK
Simon Glass40fd0502016-02-29 15:25:57 -070064static unsigned long host_block_write(struct udevice *dev,
65 unsigned long start, lbaint_t blkcnt,
66 const void *buffer)
67{
Simon Glassc69cda22020-12-03 16:55:20 -070068 struct host_block_dev *host_dev = dev_get_plat(dev);
Simon Glasscaa4daa2020-12-03 16:55:18 -070069 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
Simon Glasse1613562016-05-01 11:35:49 -060070#else
71static unsigned long host_block_write(struct blk_desc *block_dev,
72 unsigned long start, lbaint_t blkcnt,
73 const void *buffer)
74{
75 int dev = block_dev->devnum;
76 struct host_block_dev *host_dev = find_host_device(dev);
77#endif
Simon Glass7ded9592016-02-29 15:25:56 -070078
79 if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
80 -1) {
81 printf("ERROR: Invalid block %lx\n", start);
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070082 return -1;
83 }
Simon Glass7ded9592016-02-29 15:25:56 -070084 ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070085 if (len >= 0)
Simon Glass7ded9592016-02-29 15:25:56 -070086 return len / block_dev->blksz;
Henrik Nordströmf4d8de42013-11-10 10:26:56 -070087 return -1;
88}
89
Simon Glasse1613562016-05-01 11:35:49 -060090#ifdef CONFIG_BLK
Simon Glass40fd0502016-02-29 15:25:57 -070091int host_dev_bind(int devnum, char *filename)
92{
93 struct host_block_dev *host_dev;
94 struct udevice *dev;
95 char dev_name[20], *str, *fname;
96 int ret, fd;
97
98 /* Remove and unbind the old device, if any */
99 ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
100 if (ret == 0) {
Stefan Roese706865a2017-03-20 12:51:48 +0100101 ret = device_remove(dev, DM_REMOVE_NORMAL);
Simon Glass40fd0502016-02-29 15:25:57 -0700102 if (ret)
103 return ret;
104 ret = device_unbind(dev);
105 if (ret)
106 return ret;
107 } else if (ret != -ENODEV) {
108 return ret;
109 }
110
111 if (!filename)
112 return 0;
113
114 snprintf(dev_name, sizeof(dev_name), "host%d", devnum);
115 str = strdup(dev_name);
116 if (!str)
117 return -ENOMEM;
118 fname = strdup(filename);
119 if (!fname) {
120 free(str);
121 return -ENOMEM;
122 }
123
124 fd = os_open(filename, OS_O_RDWR);
125 if (fd == -1) {
126 printf("Failed to access host backing file '%s'\n", filename);
127 ret = -ENOENT;
128 goto err;
129 }
130 ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
131 IF_TYPE_HOST, devnum, 512,
Jean-Jacques Hiblot5fe77022017-06-09 16:45:18 +0200132 os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
Simon Glass40fd0502016-02-29 15:25:57 -0700133 if (ret)
134 goto err_file;
Bin Meng8f994c82018-10-15 02:21:05 -0700135
Simon Glassc69cda22020-12-03 16:55:20 -0700136 host_dev = dev_get_plat(dev);
Bin Meng8f994c82018-10-15 02:21:05 -0700137 host_dev->fd = fd;
138 host_dev->filename = fname;
139
Simon Glass40fd0502016-02-29 15:25:57 -0700140 ret = device_probe(dev);
141 if (ret) {
142 device_unbind(dev);
143 goto err_file;
144 }
145
Bin Mengd0851c82018-10-15 02:21:07 -0700146 return 0;
Simon Glass40fd0502016-02-29 15:25:57 -0700147err_file:
148 os_close(fd);
149err:
150 free(fname);
151 free(str);
152 return ret;
153}
Simon Glasse1613562016-05-01 11:35:49 -0600154#else
155int host_dev_bind(int dev, char *filename)
156{
157 struct host_block_dev *host_dev = find_host_device(dev);
158
159 if (!host_dev)
160 return -1;
161 if (host_dev->blk_dev.priv) {
162 os_close(host_dev->fd);
163 host_dev->blk_dev.priv = NULL;
164 }
165 if (host_dev->filename)
166 free(host_dev->filename);
167 if (filename && *filename) {
168 host_dev->filename = strdup(filename);
169 } else {
170 host_dev->filename = NULL;
171 return 0;
172 }
173
174 host_dev->fd = os_open(host_dev->filename, OS_O_RDWR);
175 if (host_dev->fd == -1) {
176 printf("Failed to access host backing file '%s'\n",
177 host_dev->filename);
178 return 1;
179 }
180
181 struct blk_desc *blk_dev = &host_dev->blk_dev;
182 blk_dev->if_type = IF_TYPE_HOST;
183 blk_dev->priv = host_dev;
184 blk_dev->blksz = 512;
185 blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
186 blk_dev->block_read = host_block_read;
187 blk_dev->block_write = host_block_write;
188 blk_dev->devnum = dev;
189 blk_dev->part_type = PART_TYPE_UNKNOWN;
190 part_init(blk_dev);
191
192 return 0;
193}
194#endif
Henrik Nordströmf4d8de42013-11-10 10:26:56 -0700195
Simon Glass7ded9592016-02-29 15:25:56 -0700196int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
Henrik Nordströmf4d8de42013-11-10 10:26:56 -0700197{
Simon Glasse1613562016-05-01 11:35:49 -0600198#ifdef CONFIG_BLK
Simon Glass40fd0502016-02-29 15:25:57 -0700199 struct udevice *dev;
200 int ret;
201
202 ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
203 if (ret)
204 return ret;
Simon Glasscaa4daa2020-12-03 16:55:18 -0700205 *blk_devp = dev_get_uclass_plat(dev);
Simon Glasse1613562016-05-01 11:35:49 -0600206#else
207 struct host_block_dev *host_dev = find_host_device(devnum);
208
209 if (!host_dev)
210 return -ENODEV;
211
212 if (!host_dev->blk_dev.priv)
213 return -ENOENT;
214
215 *blk_devp = &host_dev->blk_dev;
216#endif
Simon Glass40fd0502016-02-29 15:25:57 -0700217
Henrik Nordströmf4d8de42013-11-10 10:26:56 -0700218 return 0;
219}
220
Simon Glasse1613562016-05-01 11:35:49 -0600221#ifdef CONFIG_BLK
Simon Glass40fd0502016-02-29 15:25:57 -0700222static const struct blk_ops sandbox_host_blk_ops = {
223 .read = host_block_read,
224 .write = host_block_write,
225};
226
227U_BOOT_DRIVER(sandbox_host_blk) = {
228 .name = "sandbox_host_blk",
229 .id = UCLASS_BLK,
230 .ops = &sandbox_host_blk_ops,
Simon Glasscaa4daa2020-12-03 16:55:18 -0700231 .plat_auto = sizeof(struct host_block_dev),
Simon Glass40fd0502016-02-29 15:25:57 -0700232};
Simon Glass0cc65a72016-05-01 11:36:05 -0600233#else
234U_BOOT_LEGACY_BLK(sandbox_host) = {
235 .if_typename = "host",
236 .if_type = IF_TYPE_HOST,
237 .max_devs = CONFIG_HOST_MAX_DEVICES,
238 .get_dev = host_get_dev_err,
239};
Simon Glasse1613562016-05-01 11:35:49 -0600240#endif