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