1 /*- 2 * Copyright (C) 2000 Benno Rice. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 18 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 20 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 21 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 22 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 23 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include <sys/cdefs.h> 27 __FBSDID("$FreeBSD$"); 28 29 /* 30 * Disk I/O routines using Open Firmware 31 */ 32 33 #include <sys/param.h> 34 35 #include <netinet/in.h> 36 37 #include <machine/stdarg.h> 38 39 #include <stand.h> 40 41 #include "bootstrap.h" 42 #include "libofw.h" 43 44 static int ofwd_init(void); 45 static int ofwd_strategy(void *devdata, int flag, daddr_t dblk, 46 size_t size, char *buf, size_t *rsize); 47 static int ofwd_open(struct open_file *f, ...); 48 static int ofwd_close(struct open_file *f); 49 static int ofwd_ioctl(struct open_file *f, u_long cmd, void *data); 50 static void ofwd_print(int verbose); 51 52 struct devsw ofwdisk = { 53 "block", 54 DEVT_DISK, 55 ofwd_init, 56 ofwd_strategy, 57 ofwd_open, 58 ofwd_close, 59 ofwd_ioctl, 60 ofwd_print 61 }; 62 63 /* 64 * We're not guaranteed to be able to open a device more than once and there 65 * is no OFW standard method to determine whether a device is already opened. 66 * Opening a device multiple times simultaneously happens to work with most 67 * OFW block device drivers but triggers a trap with at least the driver for 68 * the on-board controllers of Sun Fire V100 and Ultra 1. Upper layers and MI 69 * code expect to be able to open a device more than once however. Given that 70 * different partitions of the same device might be opened at the same time as 71 * done by ZFS, we can't generally just keep track of the opened devices and 72 * reuse the instance handle when asked to open an already opened device. So 73 * the best we can do is to cache the lastly used device path and close and 74 * open devices in ofwd_strategy() as needed. 75 */ 76 static struct ofw_devdesc *kdp; 77 78 static int 79 ofwd_init(void) 80 { 81 82 return (0); 83 } 84 85 static int 86 ofwd_strategy(void *devdata, int flag __unused, daddr_t dblk, size_t size, 87 char *buf, size_t *rsize) 88 { 89 struct ofw_devdesc *dp = (struct ofw_devdesc *)devdata; 90 daddr_t pos; 91 int n; 92 93 if (dp != kdp) { 94 if (kdp != NULL) { 95 #if !defined(__powerpc__) 96 OF_close(kdp->d_handle); 97 #endif 98 kdp = NULL; 99 } 100 if ((dp->d_handle = OF_open(dp->d_path)) == -1) 101 return (ENOENT); 102 kdp = dp; 103 } 104 105 pos = dblk * 512; 106 do { 107 if (OF_seek(dp->d_handle, pos) < 0) 108 return (EIO); 109 n = OF_read(dp->d_handle, buf, size); 110 if (n < 0 && n != -2) 111 return (EIO); 112 } while (n == -2); 113 *rsize = size; 114 return (0); 115 } 116 117 static int 118 ofwd_open(struct open_file *f, ...) 119 { 120 struct ofw_devdesc *dp; 121 va_list vl; 122 123 va_start(vl, f); 124 dp = va_arg(vl, struct ofw_devdesc *); 125 va_end(vl); 126 127 if (dp != kdp) { 128 if (kdp != NULL) { 129 OF_close(kdp->d_handle); 130 kdp = NULL; 131 } 132 if ((dp->d_handle = OF_open(dp->d_path)) == -1) { 133 printf("%s: Could not open %s\n", __func__, 134 dp->d_path); 135 return (ENOENT); 136 } 137 kdp = dp; 138 } 139 return (0); 140 } 141 142 static int 143 ofwd_close(struct open_file *f) 144 { 145 struct ofw_devdesc *dev = f->f_devdata; 146 147 if (dev == kdp) { 148 #if !defined(__powerpc__) 149 OF_close(dev->d_handle); 150 #endif 151 kdp = NULL; 152 } 153 return (0); 154 } 155 156 static int 157 ofwd_ioctl(struct open_file *f __unused, u_long cmd __unused, 158 void *data __unused) 159 { 160 161 return (EINVAL); 162 } 163 164 static void 165 ofwd_print(int verbose __unused) 166 { 167 168 } 169