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#include <sys/disk.h> 41 42#include "bootstrap.h" 43#include "libofw.h" 44 45static int ofwd_init(void); 46static int ofwd_strategy(void *devdata, int flag, daddr_t dblk, 47 size_t size, char *buf, size_t *rsize); 48static int ofwd_open(struct open_file *f, ...); 49static int ofwd_close(struct open_file *f); 50static int ofwd_ioctl(struct open_file *f, u_long cmd, void *data); 51static int ofwd_print(int verbose); 52 53struct devsw ofwdisk = { 54 "block", 55 DEVT_DISK, 56 ofwd_init, 57 ofwd_strategy, 58 ofwd_open, 59 ofwd_close, 60 ofwd_ioctl, 61 ofwd_print 62}; 63 64/* 65 * We're not guaranteed to be able to open a device more than once and there 66 * is no OFW standard method to determine whether a device is already opened. 67 * Opening a device multiple times simultaneously happens to work with most 68 * OFW block device drivers but triggers a trap with at least the driver for 69 * the on-board controllers of Sun Fire V100 and Ultra 1. Upper layers and MI 70 * code expect to be able to open a device more than once however. Given that 71 * different partitions of the same device might be opened at the same time as 72 * done by ZFS, we can't generally just keep track of the opened devices and 73 * reuse the instance handle when asked to open an already opened device. So 74 * the best we can do is to cache the lastly used device path and close and 75 * open devices in ofwd_strategy() as needed. 76 */ 77static struct ofw_devdesc *kdp; 78 79static int 80ofwd_init(void) 81{ 82 83 return (0); 84} 85 86static int 87ofwd_strategy(void *devdata, int flag __unused, daddr_t dblk, size_t size, 88 char *buf, size_t *rsize) 89{ 90 struct ofw_devdesc *dp = (struct ofw_devdesc *)devdata; 91 daddr_t pos; 92 int n; 93 94 if (dp != kdp) { 95 if (kdp != NULL) { 96#if !defined(__powerpc__) 97 OF_close(kdp->d_handle); 98#endif 99 kdp = NULL; 100 } 101 if ((dp->d_handle = OF_open(dp->d_path)) == -1) 102 return (ENOENT); 103 kdp = dp; 104 } 105 106 pos = dblk * 512; 107 do { 108 if (OF_seek(dp->d_handle, pos) < 0) 109 return (EIO); 110 n = OF_read(dp->d_handle, buf, size); 111 if (n < 0 && n != -2) 112 return (EIO); 113 } while (n == -2); 114 *rsize = size; 115 return (0); 116} 117 118static int 119ofwd_open(struct open_file *f, ...) 120{ 121 struct ofw_devdesc *dp; 122 va_list vl; 123 124 va_start(vl, f); 125 dp = va_arg(vl, struct ofw_devdesc *); 126 va_end(vl); 127 128 if (dp != kdp) { 129 if (kdp != NULL) { 130 OF_close(kdp->d_handle); 131 kdp = NULL; 132 } 133 if ((dp->d_handle = OF_open(dp->d_path)) == -1) { 134 printf("%s: Could not open %s\n", __func__, 135 dp->d_path); 136 return (ENOENT); 137 } 138 kdp = dp; 139 } 140 return (0); 141} 142 143static int 144ofwd_close(struct open_file *f) 145{ 146 struct ofw_devdesc *dev = f->f_devdata; 147 148 if (dev == kdp) { 149#if !defined(__powerpc__) 150 OF_close(dev->d_handle); 151#endif 152 kdp = NULL; 153 } 154 return (0); 155} 156 157static int 158ofwd_ioctl(struct open_file *f, u_long cmd, void *data) 159{ 160 struct ofw_devdesc *dev = f->f_devdata; 161 int block_size; 162 unsigned int n; 163 164 switch (cmd) { 165 case DIOCGSECTORSIZE: 166 block_size = OF_block_size(dev->d_handle); 167 *(u_int *)data = block_size; 168 break; 169 case DIOCGMEDIASIZE: 170 block_size = OF_block_size(dev->d_handle); 171 n = OF_blocks(dev->d_handle); 172 *(uint64_t *)data = (uint64_t)(n * block_size); 173 break; 174 default: 175 return (ENOTTY); 176 } 177 return (0); 178} 179 180static int 181ofwd_print(int verbose __unused) 182{ 183 return (0); 184} 185