1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2008-2012 Juli Mallett <jmallett@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 * $FreeBSD: stable/12/sys/dev/gxemul/disk/gxemul_disk.c 326255 2017-11-27 14:52:40Z pfg $
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD: stable/12/sys/dev/gxemul/disk/gxemul_disk.c 326255 2017-11-27 14:52:40Z pfg $");
33
34 #include <sys/param.h>
35 #include <sys/bio.h>
36 #include <sys/systm.h>
37 #include <sys/bus.h>
38 #include <sys/kernel.h>
39 #include <sys/lock.h>
40 #include <sys/malloc.h>
41 #include <sys/module.h>
42 #include <sys/mutex.h>
43 #include <sys/rman.h>
44
45 #include <geom/geom.h>
46
47 #include <machine/cpuregs.h>
48
49 #include <dev/gxemul/disk/gxemul_diskreg.h>
50
51 struct gxemul_disk_softc {
52 device_t sc_dev;
53 uint64_t sc_size;
54 struct g_geom *sc_geom;
55 struct g_provider *sc_provider;
56 };
57
58 static struct mtx gxemul_disk_controller_mutex;
59
60 static g_start_t gxemul_disk_start;
61 static g_access_t gxemul_disk_access;
62
63 struct g_class g_gxemul_disk_class = {
64 .name = "GXemul",
65 .version = G_VERSION,
66 .start = gxemul_disk_start,
67 .access = gxemul_disk_access,
68 };
69
70 DECLARE_GEOM_CLASS(g_gxemul_disk_class, g_gxemul_disk);
71
72 static void gxemul_disk_identify(driver_t *, device_t);
73 static int gxemul_disk_probe(device_t);
74 static int gxemul_disk_attach(device_t);
75 static void gxemul_disk_attach_geom(void *, int);
76
77 static int gxemul_disk_read(unsigned, void *, off_t);
78 static int gxemul_disk_size(unsigned, uint64_t *);
79 static int gxemul_disk_write(unsigned, const void *, off_t);
80
81 static void
gxemul_disk_start(struct bio * bp)82 gxemul_disk_start(struct bio *bp)
83 {
84 struct gxemul_disk_softc *sc;
85 unsigned diskid;
86 off_t offset;
87 uint8_t *buf;
88 int error;
89
90 sc = bp->bio_to->geom->softc;
91 diskid = device_get_unit(sc->sc_dev);
92
93 if ((bp->bio_length % GXEMUL_DISK_DEV_BLOCKSIZE) != 0) {
94 g_io_deliver(bp, EINVAL);
95 return;
96 }
97
98 buf = bp->bio_data;
99 offset = bp->bio_offset;
100 bp->bio_resid = bp->bio_length;
101 while (bp->bio_resid != 0) {
102 switch (bp->bio_cmd) {
103 case BIO_READ:
104 mtx_lock(&gxemul_disk_controller_mutex);
105 error = gxemul_disk_read(diskid, buf, offset);
106 mtx_unlock(&gxemul_disk_controller_mutex);
107 break;
108 case BIO_WRITE:
109 mtx_lock(&gxemul_disk_controller_mutex);
110 error = gxemul_disk_write(diskid, buf, offset);
111 mtx_unlock(&gxemul_disk_controller_mutex);
112 break;
113 default:
114 g_io_deliver(bp, EOPNOTSUPP);
115 return;
116 }
117 if (error != 0) {
118 g_io_deliver(bp, error);
119 return;
120 }
121
122 buf += GXEMUL_DISK_DEV_BLOCKSIZE;
123 offset += GXEMUL_DISK_DEV_BLOCKSIZE;
124 bp->bio_completed += GXEMUL_DISK_DEV_BLOCKSIZE;
125 bp->bio_resid -= GXEMUL_DISK_DEV_BLOCKSIZE;
126 }
127
128 g_io_deliver(bp, 0);
129 }
130
131 static int
gxemul_disk_access(struct g_provider * pp,int r,int w,int e)132 gxemul_disk_access(struct g_provider *pp, int r, int w, int e)
133 {
134 return (0);
135 }
136
137 static void
gxemul_disk_identify(driver_t * drv,device_t parent)138 gxemul_disk_identify(driver_t *drv, device_t parent)
139 {
140 unsigned diskid;
141
142 mtx_init(&gxemul_disk_controller_mutex, "GXemul disk controller", NULL, MTX_DEF);
143
144 mtx_lock(&gxemul_disk_controller_mutex);
145 for (diskid = 0; diskid < 0x100; diskid++) {
146 /*
147 * If we can read at offset 0, this disk id must be
148 * present enough. If we get an error, stop looking.
149 * Disks in GXemul are allocated linearly from 0.
150 */
151 if (gxemul_disk_read(diskid, NULL, 0) != 0)
152 break;
153 BUS_ADD_CHILD(parent, 0, "gxemul_disk", diskid);
154 }
155 mtx_unlock(&gxemul_disk_controller_mutex);
156 }
157
158 static int
gxemul_disk_probe(device_t dev)159 gxemul_disk_probe(device_t dev)
160 {
161 device_set_desc(dev, "GXemul test disk");
162
163 return (BUS_PROBE_NOWILDCARD);
164 }
165
166 static void
gxemul_disk_attach_geom(void * arg,int flag)167 gxemul_disk_attach_geom(void *arg, int flag)
168 {
169 struct gxemul_disk_softc *sc;
170
171 sc = arg;
172
173 sc->sc_geom = g_new_geomf(&g_gxemul_disk_class, "%s", device_get_nameunit(sc->sc_dev));
174 sc->sc_geom->softc = sc;
175
176 sc->sc_provider = g_new_providerf(sc->sc_geom, "%s", sc->sc_geom->name);
177 sc->sc_provider->sectorsize = GXEMUL_DISK_DEV_BLOCKSIZE;
178 sc->sc_provider->mediasize = sc->sc_size;
179 g_error_provider(sc->sc_provider, 0);
180 }
181
182 static int
gxemul_disk_attach(device_t dev)183 gxemul_disk_attach(device_t dev)
184 {
185 struct gxemul_disk_softc *sc;
186 unsigned diskid;
187 int error;
188
189 diskid = device_get_unit(dev);
190
191 sc = device_get_softc(dev);
192 sc->sc_dev = dev;
193 sc->sc_geom = NULL;
194 sc->sc_provider = NULL;
195
196 mtx_lock(&gxemul_disk_controller_mutex);
197 error = gxemul_disk_size(diskid, &sc->sc_size);
198 if (error != 0) {
199 mtx_unlock(&gxemul_disk_controller_mutex);
200 return (error);
201 }
202 mtx_unlock(&gxemul_disk_controller_mutex);
203
204 g_post_event(gxemul_disk_attach_geom, sc, M_WAITOK, NULL);
205
206 return (0);
207 }
208
209 static int
gxemul_disk_read(unsigned diskid,void * buf,off_t off)210 gxemul_disk_read(unsigned diskid, void *buf, off_t off)
211 {
212 const volatile void *src;
213
214 mtx_assert(&gxemul_disk_controller_mutex, MA_OWNED);
215
216 if (off < 0 || off % GXEMUL_DISK_DEV_BLOCKSIZE != 0)
217 return (EINVAL);
218
219 #ifdef _LP64
220 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_OFFSET, (uint64_t)off);
221 #else
222 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_OFFSET_LO,
223 (uint32_t)(off & 0xffffffff));
224 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_OFFSET_HI,
225 (uint32_t)((off >> 32) & 0xffffffff));
226 #endif
227 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_DISKID, diskid);
228 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_START, GXEMUL_DISK_DEV_START_READ);
229 switch (GXEMUL_DISK_DEV_READ(GXEMUL_DISK_DEV_STATUS)) {
230 case GXEMUL_DISK_DEV_STATUS_FAILURE:
231 return (EIO);
232 default:
233 break;
234 }
235
236 if (buf != NULL) {
237 src = GXEMUL_DISK_DEV_FUNCTION(GXEMUL_DISK_DEV_BLOCK);
238 memcpy(buf, (const void *)(uintptr_t)src,
239 GXEMUL_DISK_DEV_BLOCKSIZE);
240 }
241
242 return (0);
243 }
244
245 static int
gxemul_disk_size(unsigned diskid,uint64_t * sizep)246 gxemul_disk_size(unsigned diskid, uint64_t *sizep)
247 {
248 uint64_t offset, ogood;
249 uint64_t m, s;
250 int error;
251
252 m = 1;
253 s = 3;
254 ogood = 0;
255
256 for (;;) {
257 offset = (ogood * s) + (m * GXEMUL_DISK_DEV_BLOCKSIZE);
258
259 error = gxemul_disk_read(diskid, NULL, offset);
260 if (error != 0) {
261 if (m == 1 && s == 1) {
262 *sizep = ogood + GXEMUL_DISK_DEV_BLOCKSIZE;
263 return (0);
264 }
265 if (m > 1)
266 m /= 2;
267 if (s > 1)
268 s--;
269 continue;
270 }
271 if (ogood == offset) {
272 m = 1;
273 continue;
274 }
275 ogood = offset;
276 m++;
277 }
278
279 return (EDOOFUS);
280 }
281
282 static int
gxemul_disk_write(unsigned diskid,const void * buf,off_t off)283 gxemul_disk_write(unsigned diskid, const void *buf, off_t off)
284 {
285 volatile void *dst;
286
287 mtx_assert(&gxemul_disk_controller_mutex, MA_OWNED);
288
289 if (off < 0 || off % GXEMUL_DISK_DEV_BLOCKSIZE != 0)
290 return (EINVAL);
291
292 #ifdef _LP64
293 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_OFFSET, (uint64_t)off);
294 #else
295 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_OFFSET_LO,
296 (uint32_t)(off & 0xffffffff));
297 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_OFFSET_HI,
298 (uint32_t)((off >> 32) & 0xffffffff));
299 #endif
300
301 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_DISKID, diskid);
302
303 dst = GXEMUL_DISK_DEV_FUNCTION(GXEMUL_DISK_DEV_BLOCK);
304 memcpy((void *)(uintptr_t)dst, buf, GXEMUL_DISK_DEV_BLOCKSIZE);
305
306 GXEMUL_DISK_DEV_WRITE(GXEMUL_DISK_DEV_START, GXEMUL_DISK_DEV_START_WRITE);
307 switch (GXEMUL_DISK_DEV_READ(GXEMUL_DISK_DEV_STATUS)) {
308 case GXEMUL_DISK_DEV_STATUS_FAILURE:
309 return (EIO);
310 default:
311 break;
312 }
313
314 return (0);
315 }
316
317 static device_method_t gxemul_disk_methods[] = {
318 DEVMETHOD(device_probe, gxemul_disk_probe),
319 DEVMETHOD(device_identify, gxemul_disk_identify),
320 DEVMETHOD(device_attach, gxemul_disk_attach),
321
322 { 0, 0 }
323 };
324
325 static driver_t gxemul_disk_driver = {
326 "gxemul_disk",
327 gxemul_disk_methods,
328 sizeof (struct gxemul_disk_softc)
329 };
330
331 static devclass_t gxemul_disk_devclass;
332 DRIVER_MODULE(gxemul_disk, nexus, gxemul_disk_driver, gxemul_disk_devclass, 0, 0);
333