bmd.c revision 1.12.10.2
1 /* $NetBSD: bmd.c,v 1.12.10.2 2010/08/11 22:52:53 yamt 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.12.10.2 2010/08/11 22:52:53 yamt 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 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 extern struct cfdriver bmd_cd; 97 98 CFATTACH_DECL_NEW(bmd, sizeof(struct bmd_softc), 99 bmd_match, bmd_attach, NULL, NULL); 100 101 dev_type_open(bmdopen); 102 dev_type_close(bmdclose); 103 dev_type_read(bmdread); 104 dev_type_write(bmdwrite); 105 dev_type_ioctl(bmdioctl); 106 dev_type_strategy(bmdstrategy); 107 dev_type_dump(bmddump); 108 dev_type_size(bmdsize); 109 110 const struct bdevsw bmd_bdevsw = { 111 bmdopen, bmdclose, bmdstrategy, bmdioctl, bmddump, bmdsize, D_DISK 112 }; 113 114 const struct cdevsw bmd_cdevsw = { 115 bmdopen, bmdclose, bmdread, bmdwrite, bmdioctl, 116 nostop, notty, nopoll, nommap, nokqfilter, D_DISK 117 }; 118 119 struct dkdriver bmddkdriver = { bmdstrategy }; 120 121 static int 122 bmd_match(device_t parent, cfdata_t cf, void *aux) 123 { 124 struct intio_attach_args *ia = aux; 125 bus_space_tag_t iot = ia->ia_bst; 126 bus_space_handle_t ioh; 127 int window; 128 int r; 129 130 if (ia->ia_addr == INTIOCF_ADDR_DEFAULT) 131 ia->ia_addr = BMD_ADDR1; 132 133 /* fixed parameter */ 134 if (ia->ia_addr != BMD_ADDR1 && ia->ia_addr != BMD_ADDR2) 135 return (0); 136 137 /* Check CTRL addr */ 138 if (badaddr((void *)IIOV(ia->ia_addr))) 139 return (0); 140 141 ia->ia_size = 2; 142 if (bus_space_map(iot, ia->ia_addr, ia->ia_size, 0, &ioh)) 143 return (0); 144 145 /* Check window addr */ 146 r = bus_space_read_1(iot, ioh, BMD_CTRL); 147 bus_space_unmap(iot, ioh, ia->ia_size); 148 149 if ((r & BMD_CTRL_WINDOW)) 150 window = 0xef0000; 151 else 152 window = 0xee0000; 153 if (badaddr((void *)IIOV(window))) 154 return (0); 155 156 return (1); 157 } 158 159 static void 160 bmd_attach(device_t parent, device_t self, void *aux) 161 { 162 struct bmd_softc *sc = device_private(self); 163 struct intio_attach_args *ia = aux; 164 bus_space_tag_t iot = ia->ia_bst; 165 bus_space_handle_t ioh; 166 u_int8_t r; 167 168 aprint_normal(": Nereid Bank Memory Disk\n"); 169 170 /* Map I/O space */ 171 ia->ia_size = 2; 172 if (bus_space_map(iot, ia->ia_addr, ia->ia_size, 0, &ioh)) { 173 aprint_error_dev(self, "can't map I/O space\n"); 174 return; 175 } 176 177 sc->sc_iot = iot; 178 sc->sc_ioh = ioh; 179 180 /* read control register */ 181 r = bus_space_read_1(sc->sc_iot, sc->sc_ioh, BMD_CTRL); 182 183 /* check enable-bit */ 184 if ((r & BMD_CTRL_ENABLE) == 0) { 185 aprint_error_dev(self, "disabled by DIP-SW 8\n"); 186 return; 187 } 188 189 if ((r & BMD_CTRL_MEMORY)) 190 sc->sc_maxpage = 256; 191 else 192 sc->sc_maxpage = 64; 193 194 if ((r & BMD_CTRL_WINDOW)) 195 sc->sc_window = 0xef0000; 196 else 197 sc->sc_window = 0xee0000; 198 199 /* Map bank area */ 200 if (bus_space_map(iot, sc->sc_window, BMD_PAGESIZE, 0, &sc->sc_bank)) { 201 aprint_error_dev(self, "can't map bank area: 0x%x\n", 202 sc->sc_window); 203 return; 204 } 205 206 aprint_normal_dev(self, "%d MB, 0x%x(64KB) x %d pages\n", 207 (sc->sc_maxpage / 16), sc->sc_window, sc->sc_maxpage); 208 209 disk_init(&sc->sc_dkdev, device_xname(self), &bmddkdriver); 210 disk_attach(&sc->sc_dkdev); 211 } 212 213 int 214 bmdopen(dev_t dev, int oflags, int devtype, struct lwp *l) 215 { 216 struct bmd_softc *sc; 217 218 DPRINTF(("%s%d\n", __func__, unit)); 219 220 sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev)); 221 if (sc == NULL) 222 return ENXIO; 223 224 switch (devtype) { 225 case S_IFCHR: 226 sc->sc_flags |= BMD_OPENCHR; 227 break; 228 case S_IFBLK: 229 sc->sc_flags |= BMD_OPENBLK; 230 break; 231 } 232 233 bmd_getdisklabel(sc, dev); 234 235 return (0); 236 } 237 238 int 239 bmdclose(dev_t dev, int fflag, int devtype, struct lwp *l) 240 { 241 struct bmd_softc *sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev)); 242 243 DPRINTF(("%s%d\n", __func__, BMD_UNIT(dev))); 244 245 switch (devtype) { 246 case S_IFCHR: 247 sc->sc_flags &= ~BMD_OPENCHR; 248 break; 249 case S_IFBLK: 250 sc->sc_flags &= ~BMD_OPENBLK; 251 break; 252 } 253 254 return (0); 255 } 256 257 void 258 bmdstrategy(struct buf *bp) 259 { 260 int unit = BMD_UNIT(bp->b_dev); 261 struct bmd_softc *sc; 262 int offset, disksize, resid; 263 int page, pg_offset, pg_resid; 264 void *data; 265 266 if (unit >= bmd_cd.cd_ndevs) { 267 bp->b_error = ENXIO; 268 goto done; 269 } 270 271 sc = device_lookup_private(&bmd_cd, BMD_UNIT(bp->b_dev)); 272 if (sc == NULL) { 273 bp->b_error = ENXIO; 274 goto done; 275 } 276 277 DPRINTF(("bmdstrategy: %s blkno %d bcount %ld:", 278 (bp->b_flags & B_READ) ? "read " : "write", 279 bp->b_blkno, bp->b_bcount)); 280 281 bp->b_resid = bp->b_bcount; 282 offset = (bp->b_blkno << DEV_BSHIFT); 283 disksize = sc->sc_maxpage * BMD_PAGESIZE; 284 if (offset >= disksize) { 285 /* EOF if read, EIO if write */ 286 if (bp->b_flags & B_READ) 287 goto done; 288 bp->b_error = EIO; 289 goto done; 290 } 291 292 resid = bp->b_resid; 293 if (resid > disksize - offset) 294 resid = disksize - offset; 295 296 data = bp->b_data; 297 do { 298 page = offset / BMD_PAGESIZE; 299 pg_offset = offset % BMD_PAGESIZE; 300 301 /* length */ 302 pg_resid = MIN(resid, BMD_PAGESIZE - pg_offset); 303 304 /* switch bank page */ 305 bus_space_write_1(sc->sc_iot, sc->sc_ioh, BMD_PAGE, page); 306 307 /* XXX we should use DMA transfer? */ 308 if ((bp->b_flags & B_READ)) { 309 bus_space_read_region_1(sc->sc_iot, sc->sc_bank, 310 pg_offset, data, pg_resid); 311 } else { 312 bus_space_write_region_1(sc->sc_iot, sc->sc_bank, 313 pg_offset, data, pg_resid); 314 } 315 316 data = (char *)data + pg_resid; 317 offset += pg_resid; 318 resid -= pg_resid; 319 bp->b_resid -= pg_resid; 320 } while (resid > 0); 321 322 DPRINTF(("\n")); 323 324 done: 325 biodone(bp); 326 } 327 328 int 329 bmdioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 330 { 331 struct bmd_softc *sc; 332 struct disklabel dl; 333 int error; 334 335 DPRINTF(("%s%d %ld\n", __func__, BMD_UNIT(dev), cmd)); 336 337 sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev)); 338 if (sc == NULL) 339 return ENXIO; 340 341 switch (cmd) { 342 case DIOCGDINFO: 343 *(struct disklabel *)data = *(sc->sc_dkdev.dk_label); 344 break; 345 346 case DIOCWDINFO: 347 if ((flag & FWRITE) == 0) 348 return EBADF; 349 350 error = setdisklabel(&dl, (struct disklabel *)data, 0, NULL); 351 if (error) 352 return error; 353 error = writedisklabel(dev, bmdstrategy, &dl, NULL); 354 return error; 355 356 default: 357 return EINVAL; 358 } 359 return 0; 360 } 361 362 int 363 bmddump(dev_t dev, daddr_t blkno, void *va, size_t size) 364 { 365 366 DPRINTF(("%s%d ", __func__, BMD_UNIT(dev))); 367 return ENODEV; 368 } 369 370 int 371 bmdsize(dev_t dev) 372 { 373 struct bmd_softc *sc; 374 375 DPRINTF(("%s%d ", __func__, BMD_UNIT(dev))); 376 377 sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev)); 378 if (sc == NULL) 379 return 0; 380 381 return (sc->sc_maxpage * BMD_PAGESIZE) >> DEV_BSHIFT; 382 } 383 384 int 385 bmdread(dev_t dev, struct uio *uio, int ioflag) 386 { 387 return physio(bmdstrategy, NULL, dev, B_READ, minphys, uio); 388 } 389 390 int 391 bmdwrite(dev_t dev, struct uio *uio, int ioflag) 392 { 393 return physio(bmdstrategy, NULL, dev, B_WRITE, minphys, uio); 394 } 395 396 static int 397 bmd_getdisklabel(struct bmd_softc *sc, dev_t dev) 398 { 399 struct disklabel *lp; 400 int part; 401 402 part = DISKPART(dev); 403 lp = sc->sc_dkdev.dk_label; 404 memset(lp, 0, sizeof(struct disklabel)); 405 406 lp->d_secsize = BMD_BSIZE; 407 lp->d_nsectors = BLKS_PER_PAGE; 408 lp->d_ntracks = sc->sc_maxpage; 409 lp->d_ncylinders = 1; 410 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks; 411 lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders; 412 413 lp->d_type = DTYPE_LD; 414 lp->d_rpm = 300; /* dummy */ 415 lp->d_interleave = 1; /* dummy? */ 416 417 lp->d_npartitions = part + 1; 418 lp->d_bbsize = 8192; 419 lp->d_sbsize = 8192; /* ? */ 420 421 lp->d_magic = DISKMAGIC; 422 lp->d_magic2 = DISKMAGIC; 423 lp->d_checksum = dkcksum(lp); 424 425 lp->d_partitions[part].p_size = lp->d_secperunit; 426 lp->d_partitions[part].p_fstype = FS_BSDFFS; 427 lp->d_partitions[part].p_fsize = 1024; 428 lp->d_partitions[part].p_frag = 8; 429 430 return (0); 431 } 432
Indexes created Mon Oct 20 11:09:49 GMT 2025