1 /* $NetBSD: bmd.c,v 1.26 2022/05/26 14:33:29 tsutsui Exp $ */
2
3 /*
4 * Copyright (c) 2002 Tetsuya Isaki. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 /*
29 * Nereid bank memory disk
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: bmd.c,v 1.26 2022/05/26 14:33:29 tsutsui Exp $");
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/buf.h>
38 #include <sys/conf.h>
39 #include <sys/device.h>
40 #include <sys/kernel.h>
41 #include <sys/stat.h>
42 #include <sys/disk.h>
43 #include <sys/disklabel.h>
44 #include <sys/ioctl.h>
45 #include <sys/fcntl.h>
46 #include <sys/proc.h>
47
48 #include <machine/bus.h>
49 #include <machine/cpu.h>
50
51 #include <arch/x68k/dev/intiovar.h>
52
53 #include "ioconf.h"
54
55 #define BMD_ADDR1 (0xece3f0)
56 #define BMD_ADDR2 (0xecebf0)
57
58 #define BMD_PAGESIZE (0x10000) /* 64KB */
59 #define BMD_BSIZE (512)
60 #define BLKS_PER_PAGE (BMD_PAGESIZE / BMD_BSIZE)
61
62 #define BMD_PAGE (0)
63 #define BMD_CTRL (1)
64 #define BMD_CTRL_ENABLE (0x80) /* DIP8: 1=Enable, 0=Disable */
65 #define BMD_CTRL_MEMORY (0x40) /* 1=16M available, 0=4M available */
66 #define BMD_CTRL_WINDOW (0x20) /* DIP6: 1=0xee0000, 0=0xef0000 */
67
68
69 #define BMD_UNIT(dev) (minor(dev) / 8)
70
71 #ifdef BMD_DEBUG
72 #define DPRINTF(x) printf x
73 #else
74 #define DPRINTF(x) /* nothing */
75 #endif
76
77 struct bmd_softc {
78 struct disk sc_dkdev;
79 bus_space_tag_t sc_iot;
80 bus_space_handle_t sc_ioh;
81 bus_space_handle_t sc_bank;
82
83 int sc_maxpage;
84 int sc_window;
85
86 int sc_flags;
87 #define BMD_OPENBLK (0x01)
88 #define BMD_OPENCHR (0x02)
89 #define BMD_OPEN (BMD_OPENBLK | BMD_OPENCHR)
90 };
91
92 static int bmd_match(device_t, cfdata_t, void *);
93 static void bmd_attach(device_t, device_t, void *);
94 static int bmd_getdisklabel(struct bmd_softc *, dev_t);
95
96 CFATTACH_DECL_NEW(bmd, sizeof(struct bmd_softc),
97 bmd_match, bmd_attach, NULL, NULL);
98
99 dev_type_open(bmdopen);
100 dev_type_close(bmdclose);
101 dev_type_read(bmdread);
102 dev_type_write(bmdwrite);
103 dev_type_ioctl(bmdioctl);
104 dev_type_strategy(bmdstrategy);
105 dev_type_dump(bmddump);
106 dev_type_size(bmdsize);
107
108 const struct bdevsw bmd_bdevsw = {
109 .d_open = bmdopen,
110 .d_close = bmdclose,
111 .d_strategy = bmdstrategy,
112 .d_ioctl = bmdioctl,
113 .d_dump = bmddump,
114 .d_psize = bmdsize,
115 .d_discard = nodiscard,
116 .d_flag = D_DISK
117 };
118
119 const struct cdevsw bmd_cdevsw = {
120 .d_open = bmdopen,
121 .d_close = bmdclose,
122 .d_read = bmdread,
123 .d_write = bmdwrite,
124 .d_ioctl = bmdioctl,
125 .d_stop = nostop,
126 .d_tty = notty,
127 .d_poll = nopoll,
128 .d_mmap = nommap,
129 .d_kqfilter = nokqfilter,
130 .d_discard = nodiscard,
131 .d_flag = D_DISK
132 };
133
134 struct dkdriver bmddkdriver = {
135 .d_strategy = bmdstrategy
136 };
137
138 static int
bmd_match(device_t parent,cfdata_t cf,void * aux)139 bmd_match(device_t parent, cfdata_t cf, void *aux)
140 {
141 struct intio_attach_args *ia = aux;
142 bus_space_tag_t iot = ia->ia_bst;
143 bus_space_handle_t ioh;
144 int window;
145 int r;
146
147 if (ia->ia_addr == INTIOCF_ADDR_DEFAULT)
148 ia->ia_addr = BMD_ADDR1;
149
150 /* fixed parameter */
151 if (ia->ia_addr != BMD_ADDR1 && ia->ia_addr != BMD_ADDR2)
152 return (0);
153
154 /* Check CTRL addr */
155 if (badaddr((void *)IIOV(ia->ia_addr)))
156 return (0);
157
158 ia->ia_size = 2;
159 if (bus_space_map(iot, ia->ia_addr, ia->ia_size, 0, &ioh))
160 return (0);
161
162 /* Check window addr */
163 r = bus_space_read_1(iot, ioh, BMD_CTRL);
164 bus_space_unmap(iot, ioh, ia->ia_size);
165
166 if ((r & BMD_CTRL_WINDOW))
167 window = 0xef0000;
168 else
169 window = 0xee0000;
170 if (badaddr((void *)IIOV(window)))
171 return (0);
172
173 return (1);
174 }
175
176 static void
bmd_attach(device_t parent,device_t self,void * aux)177 bmd_attach(device_t parent, device_t self, void *aux)
178 {
179 struct bmd_softc *sc = device_private(self);
180 struct intio_attach_args *ia = aux;
181 bus_space_tag_t iot = ia->ia_bst;
182 bus_space_handle_t ioh;
183 u_int8_t r;
184
185 aprint_normal(": Nereid Bank Memory Disk\n");
186
187 /* Map I/O space */
188 ia->ia_size = 2;
189 if (bus_space_map(iot, ia->ia_addr, ia->ia_size, 0, &ioh)) {
190 aprint_error_dev(self, "can't map I/O space\n");
191 return;
192 }
193
194 sc->sc_iot = iot;
195 sc->sc_ioh = ioh;
196
197 /* read control register */
198 r = bus_space_read_1(sc->sc_iot, sc->sc_ioh, BMD_CTRL);
199
200 /* check enable-bit */
201 if ((r & BMD_CTRL_ENABLE) == 0) {
202 aprint_error_dev(self, "disabled by DIP-SW 8\n");
203 return;
204 }
205
206 if ((r & BMD_CTRL_MEMORY))
207 sc->sc_maxpage = 256;
208 else
209 sc->sc_maxpage = 64;
210
211 if ((r & BMD_CTRL_WINDOW))
212 sc->sc_window = 0xef0000;
213 else
214 sc->sc_window = 0xee0000;
215
216 /* Map bank area */
217 if (bus_space_map(iot, sc->sc_window, BMD_PAGESIZE, 0, &sc->sc_bank)) {
218 aprint_error_dev(self, "can't map bank area: 0x%x\n",
219 sc->sc_window);
220 return;
221 }
222
223 aprint_normal_dev(self, "%d MB, 0x%x(64KB) x %d pages\n",
224 (sc->sc_maxpage / 16), sc->sc_window, sc->sc_maxpage);
225
226 disk_init(&sc->sc_dkdev, device_xname(self), &bmddkdriver);
227 disk_attach(&sc->sc_dkdev);
228 }
229
230 int
bmdopen(dev_t dev,int oflags,int devtype,struct lwp * l)231 bmdopen(dev_t dev, int oflags, int devtype, struct lwp *l)
232 {
233 struct bmd_softc *sc;
234
235 DPRINTF(("%s%d\n", __func__, unit));
236
237 sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev));
238 if (sc == NULL)
239 return ENXIO;
240
241 switch (devtype) {
242 case S_IFCHR:
243 sc->sc_flags |= BMD_OPENCHR;
244 break;
245 case S_IFBLK:
246 sc->sc_flags |= BMD_OPENBLK;
247 break;
248 }
249
250 bmd_getdisklabel(sc, dev);
251
252 return (0);
253 }
254
255 int
bmdclose(dev_t dev,int fflag,int devtype,struct lwp * l)256 bmdclose(dev_t dev, int fflag, int devtype, struct lwp *l)
257 {
258 struct bmd_softc *sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev));
259
260 DPRINTF(("%s%d\n", __func__, BMD_UNIT(dev)));
261
262 switch (devtype) {
263 case S_IFCHR:
264 sc->sc_flags &= ~BMD_OPENCHR;
265 break;
266 case S_IFBLK:
267 sc->sc_flags &= ~BMD_OPENBLK;
268 break;
269 }
270
271 return (0);
272 }
273
274 void
bmdstrategy(struct buf * bp)275 bmdstrategy(struct buf *bp)
276 {
277 int unit = BMD_UNIT(bp->b_dev);
278 struct bmd_softc *sc;
279 int offset, disksize, resid;
280 int page, pg_offset, pg_resid;
281 void *data;
282
283 if (unit >= bmd_cd.cd_ndevs) {
284 bp->b_error = ENXIO;
285 goto done;
286 }
287
288 sc = device_lookup_private(&bmd_cd, BMD_UNIT(bp->b_dev));
289 if (sc == NULL) {
290 bp->b_error = ENXIO;
291 goto done;
292 }
293
294 DPRINTF(("bmdstrategy: %s blkno %d bcount %ld:",
295 (bp->b_flags & B_READ) ? "read " : "write",
296 bp->b_blkno, bp->b_bcount));
297
298 bp->b_resid = bp->b_bcount;
299 offset = (bp->b_blkno << DEV_BSHIFT);
300 disksize = sc->sc_maxpage * BMD_PAGESIZE;
301 if (offset >= disksize) {
302 /* EOF if read, EIO if write */
303 if (bp->b_flags & B_READ)
304 goto done;
305 bp->b_error = EIO;
306 goto done;
307 }
308
309 resid = bp->b_resid;
310 if (resid > disksize - offset)
311 resid = disksize - offset;
312
313 data = bp->b_data;
314 do {
315 page = offset / BMD_PAGESIZE;
316 pg_offset = offset % BMD_PAGESIZE;
317
318 /* length */
319 pg_resid = MIN(resid, BMD_PAGESIZE - pg_offset);
320
321 /* switch bank page */
322 bus_space_write_1(sc->sc_iot, sc->sc_ioh, BMD_PAGE, page);
323
324 /* XXX we should use DMA transfer? */
325 if ((bp->b_flags & B_READ)) {
326 bus_space_read_region_1(sc->sc_iot, sc->sc_bank,
327 pg_offset, data, pg_resid);
328 } else {
329 bus_space_write_region_1(sc->sc_iot, sc->sc_bank,
330 pg_offset, data, pg_resid);
331 }
332
333 data = (char *)data + pg_resid;
334 offset += pg_resid;
335 resid -= pg_resid;
336 bp->b_resid -= pg_resid;
337 } while (resid > 0);
338
339 DPRINTF(("\n"));
340
341 done:
342 biodone(bp);
343 }
344
345 int
bmdioctl(dev_t dev,u_long cmd,void * data,int flag,struct lwp * l)346 bmdioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
347 {
348 struct bmd_softc *sc;
349 struct disklabel dl;
350 int error;
351
352 DPRINTF(("%s%d %ld\n", __func__, BMD_UNIT(dev), cmd));
353
354 sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev));
355
356 if (sc == NULL)
357 return ENXIO;
358
359 error = disk_ioctl(&sc->sc_dkdev, dev, cmd, data, flag, l);
360 if (error != EPASSTHROUGH)
361 return error;
362
363 switch (cmd) {
364 case DIOCWDINFO:
365 if ((flag & FWRITE) == 0)
366 return EBADF;
367
368 error = setdisklabel(&dl, (struct disklabel *)data, 0, NULL);
369 if (error)
370 return error;
371 error = writedisklabel(dev, bmdstrategy, &dl, NULL);
372 return error;
373
374 default:
375 return EINVAL;
376 }
377 return 0;
378 }
379
380 int
bmddump(dev_t dev,daddr_t blkno,void * va,size_t size)381 bmddump(dev_t dev, daddr_t blkno, void *va, size_t size)
382 {
383
384 DPRINTF(("%s%d ", __func__, BMD_UNIT(dev)));
385 return ENODEV;
386 }
387
388 int
bmdsize(dev_t dev)389 bmdsize(dev_t dev)
390 {
391 struct bmd_softc *sc;
392
393 DPRINTF(("%s%d ", __func__, BMD_UNIT(dev)));
394
395 sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev));
396 if (sc == NULL)
397 return 0;
398
399 return (sc->sc_maxpage * BMD_PAGESIZE) >> DEV_BSHIFT;
400 }
401
402 int
bmdread(dev_t dev,struct uio * uio,int ioflag)403 bmdread(dev_t dev, struct uio *uio, int ioflag)
404 {
405 return physio(bmdstrategy, NULL, dev, B_READ, minphys, uio);
406 }
407
408 int
bmdwrite(dev_t dev,struct uio * uio,int ioflag)409 bmdwrite(dev_t dev, struct uio *uio, int ioflag)
410 {
411 return physio(bmdstrategy, NULL, dev, B_WRITE, minphys, uio);
412 }
413
414 static int
bmd_getdisklabel(struct bmd_softc * sc,dev_t dev)415 bmd_getdisklabel(struct bmd_softc *sc, dev_t dev)
416 {
417 struct disklabel *lp;
418 int part;
419
420 part = DISKPART(dev);
421 lp = sc->sc_dkdev.dk_label;
422 memset(lp, 0, sizeof(struct disklabel));
423
424 lp->d_secsize = BMD_BSIZE;
425 lp->d_nsectors = BLKS_PER_PAGE;
426 lp->d_ntracks = sc->sc_maxpage;
427 lp->d_ncylinders = 1;
428 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
429 lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
430
431 lp->d_type = DKTYPE_LD;
432 lp->d_rpm = 300; /* dummy */
433 lp->d_interleave = 1; /* dummy? */
434
435 lp->d_npartitions = part + 1;
436 lp->d_bbsize = 8192;
437 lp->d_sbsize = 8192; /* ? */
438
439 lp->d_magic = DISKMAGIC;
440 lp->d_magic2 = DISKMAGIC;
441 lp->d_checksum = dkcksum(lp);
442
443 lp->d_partitions[part].p_size = lp->d_secperunit;
444 lp->d_partitions[part].p_fstype = FS_BSDFFS;
445 lp->d_partitions[part].p_fsize = 1024;
446 lp->d_partitions[part].p_frag = 8;
447
448 return (0);
449 }
450