1 /*- 2 * Copyright (c) 2008 Semihalf, Rafal Jaworowski 3 * Copyright (c) 2009 Semihalf, Piotr Ziecik 4 * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 */ 29 30 /* 31 * Block storage I/O routines for U-Boot 32 */ 33 34 #include <sys/param.h> 35 #include <sys/disk.h> 36 #include <machine/stdarg.h> 37 #include <stand.h> 38 39 #include "api_public.h" 40 #include "bootstrap.h" 41 #include "disk.h" 42 #include "glue.h" 43 #include "libuboot.h" 44 45 #define stor_printf(fmt, args...) do { \ 46 printf("%s%d: ", dev->dd.d_dev->dv_name, dev->dd.d_unit); \ 47 printf(fmt, ##args); \ 48 } while (0) 49 50 #ifdef DEBUG 51 #define debugf(fmt, args...) do { printf("%s(): ", __func__); \ 52 printf(fmt,##args); } while (0) 53 #else 54 #define debugf(fmt, args...) 55 #endif 56 57 static struct { 58 int opened; /* device is opened */ 59 int handle; /* storage device handle */ 60 int type; /* storage type */ 61 off_t blocks; /* block count */ 62 u_int bsize; /* block size */ 63 } stor_info[UB_MAX_DEV]; 64 65 #define SI(dev) (stor_info[(dev)->dd.d_unit]) 66 67 static int stor_info_no = 0; 68 static int stor_opendev(struct disk_devdesc *); 69 static int stor_readdev(struct disk_devdesc *, daddr_t, size_t, char *); 70 71 /* devsw I/F */ 72 static int stor_init(void); 73 static int stor_strategy(void *, int, daddr_t, size_t, char *, size_t *); 74 static int stor_open(struct open_file *, ...); 75 static int stor_close(struct open_file *); 76 static int stor_ioctl(struct open_file *f, u_long cmd, void *data); 77 static int stor_print(int); 78 static void stor_cleanup(void); 79 80 struct devsw uboot_storage = { 81 .dv_name = "disk", 82 .dv_type = DEVT_DISK, 83 .dv_init = stor_init, 84 .dv_strategy = stor_strategy, 85 .dv_open = stor_open, 86 .dv_close = stor_close, 87 .dv_ioctl = stor_ioctl, 88 .dv_print = stor_print, 89 .dv_cleanup = stor_cleanup, 90 .dv_fmtdev = disk_fmtdev, 91 .dv_parsedev = disk_parsedev, 92 }; 93 94 static int 95 stor_init(void) 96 { 97 struct device_info *di; 98 int i; 99 100 if (devs_no == 0) { 101 printf("No U-Boot devices! Really enumerated?\n"); 102 return (-1); 103 } 104 105 for (i = 0; i < devs_no; i++) { 106 di = ub_dev_get(i); 107 if ((di != NULL) && (di->type & DEV_TYP_STOR)) { 108 if (stor_info_no >= UB_MAX_DEV) { 109 printf("Too many storage devices: %d\n", 110 stor_info_no); 111 return (-1); 112 } 113 stor_info[stor_info_no].handle = i; 114 stor_info[stor_info_no].opened = 0; 115 stor_info[stor_info_no].type = di->type; 116 stor_info[stor_info_no].blocks = 117 di->di_stor.block_count; 118 stor_info[stor_info_no].bsize = 119 di->di_stor.block_size; 120 stor_info_no++; 121 } 122 } 123 124 if (!stor_info_no) { 125 debugf("No storage devices\n"); 126 return (-1); 127 } 128 129 debugf("storage devices found: %d\n", stor_info_no); 130 return (0); 131 } 132 133 static void 134 stor_cleanup(void) 135 { 136 int i; 137 138 for (i = 0; i < stor_info_no; i++) 139 if (stor_info[i].opened > 0) 140 ub_dev_close(stor_info[i].handle); 141 } 142 143 static int 144 stor_strategy(void *devdata, int rw, daddr_t blk, size_t size, 145 char *buf, size_t *rsize) 146 { 147 struct disk_devdesc *dev = (struct disk_devdesc *)devdata; 148 daddr_t bcount; 149 int err; 150 151 rw &= F_MASK; 152 if (rw != F_READ) { 153 stor_printf("write attempt, operation not supported!\n"); 154 return (EROFS); 155 } 156 157 if (size % SI(dev).bsize) { 158 stor_printf("size=%zu not multiple of device " 159 "block size=%d\n", 160 size, SI(dev).bsize); 161 return (EIO); 162 } 163 bcount = size / SI(dev).bsize; 164 if (rsize) 165 *rsize = 0; 166 167 err = stor_readdev(dev, blk + dev->d_offset, bcount, buf); 168 if (!err && rsize) 169 *rsize = size; 170 171 return (err); 172 } 173 174 static int 175 stor_open(struct open_file *f, ...) 176 { 177 va_list ap; 178 struct disk_devdesc *dev; 179 180 va_start(ap, f); 181 dev = va_arg(ap, struct disk_devdesc *); 182 va_end(ap); 183 184 return (stor_opendev(dev)); 185 } 186 187 static int 188 stor_opendev(struct disk_devdesc *dev) 189 { 190 int err; 191 192 if (dev->dd.d_unit < 0 || dev->dd.d_unit >= stor_info_no) 193 return (EIO); 194 195 if (SI(dev).opened == 0) { 196 err = ub_dev_open(SI(dev).handle); 197 if (err != 0) { 198 stor_printf("device open failed with error=%d, " 199 "handle=%d\n", err, SI(dev).handle); 200 return (ENXIO); 201 } 202 SI(dev).opened++; 203 } 204 return (disk_open(dev, SI(dev).blocks * SI(dev).bsize, 205 SI(dev).bsize)); 206 } 207 208 static int 209 stor_close(struct open_file *f) 210 { 211 struct disk_devdesc *dev; 212 213 dev = (struct disk_devdesc *)(f->f_devdata); 214 return (disk_close(dev)); 215 } 216 217 static int 218 stor_readdev(struct disk_devdesc *dev, daddr_t blk, size_t size, char *buf) 219 { 220 lbasize_t real_size; 221 int err; 222 223 debugf("reading blk=%d size=%d @ 0x%08x\n", (int)blk, size, (uint32_t)buf); 224 225 err = ub_dev_read(SI(dev).handle, buf, size, blk, &real_size); 226 if (err != 0) { 227 stor_printf("read failed, error=%d\n", err); 228 return (EIO); 229 } 230 231 if (real_size != size) { 232 stor_printf("real size != size\n"); 233 err = EIO; 234 } 235 236 return (err); 237 } 238 239 static int 240 stor_print(int verbose) 241 { 242 struct disk_devdesc dev; 243 static char line[80]; 244 int i, ret = 0; 245 246 if (stor_info_no == 0) 247 return (ret); 248 249 printf("%s devices:", uboot_storage.dv_name); 250 if ((ret = pager_output("\n")) != 0) 251 return (ret); 252 253 for (i = 0; i < stor_info_no; i++) { 254 dev.dd.d_dev = &uboot_storage; 255 dev.dd.d_unit = i; 256 dev.d_slice = D_SLICENONE; 257 dev.d_partition = D_PARTNONE; 258 snprintf(line, sizeof(line), "\tdisk%d (%s)\n", i, 259 ub_stor_type(SI(&dev).type)); 260 if ((ret = pager_output(line)) != 0) 261 break; 262 if (stor_opendev(&dev) == 0) { 263 sprintf(line, "\tdisk%d", i); 264 ret = disk_print(&dev, line, verbose); 265 disk_close(&dev); 266 if (ret != 0) 267 break; 268 } 269 } 270 return (ret); 271 } 272 273 static int 274 stor_ioctl(struct open_file *f, u_long cmd, void *data) 275 { 276 struct disk_devdesc *dev; 277 int rc; 278 279 dev = (struct disk_devdesc *)f->f_devdata; 280 rc = disk_ioctl(dev, cmd, data); 281 if (rc != ENOTTY) 282 return (rc); 283 284 switch (cmd) { 285 case DIOCGSECTORSIZE: 286 *(u_int *)data = SI(dev).bsize; 287 break; 288 case DIOCGMEDIASIZE: 289 *(uint64_t *)data = SI(dev).bsize * SI(dev).blocks; 290 break; 291 default: 292 return (ENOTTY); 293 } 294 return (0); 295 } 296 297 298 /* 299 * Return the device unit number for the given type and type-relative unit 300 * number. 301 */ 302 int 303 uboot_diskgetunit(int type, int type_unit) 304 { 305 int local_type_unit; 306 int i; 307 308 local_type_unit = 0; 309 for (i = 0; i < stor_info_no; i++) { 310 if ((stor_info[i].type & type) == type) { 311 if (local_type_unit == type_unit) { 312 return (i); 313 } 314 local_type_unit++; 315 } 316 } 317 318 return (-1); 319 } 320