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