1 /* $NetBSD: bmd.c,v 1.28 2024/01/07 07:58:33 isaki 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.28 2024/01/07 07:58:33 isaki 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 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 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 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__, BMD_UNIT(dev))); 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 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 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 %" PRIx64 " bcount %d:", 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 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 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 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 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 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 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
Indexes created Tue Sep 30 17:09:57 GMT 2025