Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/pbio/pbio.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2000-2004 3 * Diomidis D. Spinellis, Athens, Greece 4 * 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 as 11 * the first lines of this file unmodified. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY Diomidis D. Spinellis ``AS IS'' AND ANY 17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Diomidis D. Spinellis BE 20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * $Id: pbio.c,v 1.12 2003/10/11 13:05:08 dds Exp dds $ 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD: releng/9.0/sys/dev/pbio/pbio.c 183397 2008-09-27 08:51:18Z ed $"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> /* SYSINIT stuff */ 37 #include <sys/bus.h> 38 #include <sys/resource.h> 39 #include <sys/syslog.h> 40 #include <sys/sysctl.h> 41 #include <sys/conf.h> /* cdevsw stuff */ 42 #include <sys/malloc.h> /* malloc region definitions */ 43 #include <sys/module.h> 44 #include <machine/bus.h> 45 #include <machine/resource.h> 46 #include <sys/rman.h> 47 #include <dev/pbio/pbioio.h> /* pbio IOCTL definitions */ 48 #include <sys/uio.h> 49 #include <sys/fcntl.h> 50 #include <isa/isavar.h> 51 52 /* Function prototypes (these should all be static) */ 53 static d_open_t pbioopen; 54 static d_close_t pbioclose; 55 static d_read_t pbioread; 56 static d_write_t pbiowrite; 57 static d_ioctl_t pbioioctl; 58 static d_poll_t pbiopoll; 59 static int pbioprobe(device_t); 60 static int pbioattach(device_t); 61 62 /* Device registers */ 63 #define PBIO_PORTA 0 64 #define PBIO_PORTB 1 65 #define PBIO_PORTC 2 66 #define PBIO_CFG 3 67 #define PBIO_IOSIZE 4 68 69 /* Per-port buffer size */ 70 #define PBIO_BUFSIZ 64 71 72 /* Number of /dev entries */ 73 #define PBIO_NPORTS 4 74 75 /* I/O port range */ 76 #define IO_PBIOSIZE 4 77 78 static char *port_names[] = {"a", "b", "ch", "cl"}; 79 80 #define PBIO_PNAME(n) (port_names[(n)]) 81 82 #define UNIT(dev) (dev2unit(dev) >> 2) 83 #define PORT(dev) (dev2unit(dev) & 0x3) 84 85 #define PBIOPRI ((PZERO + 5) | PCATCH) 86 87 static struct cdevsw pbio_cdevsw = { 88 .d_version = D_VERSION, 89 .d_flags = D_NEEDGIANT, 90 .d_open = pbioopen, 91 .d_close = pbioclose, 92 .d_read = pbioread, 93 .d_write = pbiowrite, 94 .d_ioctl = pbioioctl, 95 .d_poll = pbiopoll, 96 .d_name = "pbio" 97 }; 98 99 /* 100 * Data specific to each I/O port 101 */ 102 struct portdata { 103 struct cdev *port; 104 int diff; /* When true read only differences */ 105 int ipace; /* Input pace */ 106 int opace; /* Output pace */ 107 char oldval; /* Last value read */ 108 char buff[PBIO_BUFSIZ]; /* Per-port data buffer */ 109 }; 110 111 /* 112 * One of these per allocated device 113 */ 114 struct pbio_softc { 115 struct portdata pd[PBIO_NPORTS];/* Per port data */ 116 int iomode; /* Virtualized I/O mode port value */ 117 /* The real port is write-only */ 118 struct resource *res; 119 bus_space_tag_t bst; 120 bus_space_handle_t bsh; 121 }; 122 123 typedef struct pbio_softc *sc_p; 124 125 static device_method_t pbio_methods[] = { 126 /* Device interface */ 127 DEVMETHOD(device_probe, pbioprobe), 128 DEVMETHOD(device_attach, pbioattach), 129 { 0, 0 } 130 }; 131 132 static devclass_t pbio_devclass; 133 #define pbio_addr(unit) \ 134 ((struct pbio_softc *) devclass_get_softc(pbio_devclass, unit)) 135 136 static char driver_name[] = "pbio"; 137 138 static driver_t pbio_driver = { 139 driver_name, 140 pbio_methods, 141 sizeof(struct pbio_softc), 142 }; 143 144 DRIVER_MODULE(pbio, isa, pbio_driver, pbio_devclass, 0, 0); 145 146 static __inline uint8_t 147 pbinb(struct pbio_softc *scp, int off) 148 { 149 150 return bus_space_read_1(scp->bst, scp->bsh, off); 151 } 152 153 static __inline void 154 pboutb(struct pbio_softc *scp, int off, uint8_t val) 155 { 156 157 bus_space_write_1(scp->bst, scp->bsh, off, val); 158 } 159 160 161 static int 162 pbioprobe(device_t dev) 163 { 164 int rid; 165 struct pbio_softc *scp = device_get_softc(dev); 166 #ifdef GENERIC_PBIO_PROBE 167 unsigned char val; 168 #endif 169 170 if (isa_get_logicalid(dev)) /* skip PnP probes */ 171 return (ENXIO); 172 rid = 0; 173 scp->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 174 0, ~0, IO_PBIOSIZE, RF_ACTIVE); 175 if (scp->res == NULL) 176 return (ENXIO); 177 178 #ifdef GENERIC_PBIO_PROBE 179 scp->bst = rman_get_bustag(scp->res); 180 scp->bsh = rman_get_bushandle(scp->res); 181 /* 182 * try see if the device is there. 183 * This probe works only if the device has no I/O attached to it 184 * XXX Better allow flags to abort testing 185 */ 186 /* Set all ports to output */ 187 pboutb(scp, PBIO_CFG, 0x80); 188 printf("pbio val(CFG: 0x%03x)=0x%02x (should be 0x80)\n", 189 rman_get_start(scp->res), pbinb(scp, PBIO_CFG)); 190 pboutb(scp, PBIO_PORTA, 0xa5); 191 val = pbinb(scp, PBIO_PORTA); 192 printf("pbio val=0x%02x (should be 0xa5)\n", val); 193 if (val != 0xa5) { 194 bus_release_resource(dev, SYS_RES_IOPORT, rid, sc->res); 195 return (ENXIO); 196 } 197 pboutb(scp, PBIO_PORTA, 0x5a); 198 val = pbinb(scp, PBIO_PORTA); 199 printf("pbio val=0x%02x (should be 0x5a)\n", val); 200 if (val != 0x5a) { 201 bus_release_resource(dev, SYS_RES_IOPORT, rid, sc->res); 202 return (ENXIO); 203 } 204 #endif 205 device_set_desc(dev, "Intel 8255 PPI (basic mode)"); 206 /* Set all ports to input */ 207 /* pboutb(scp, PBIO_CFG, 0x9b); */ 208 bus_release_resource(dev, SYS_RES_IOPORT, rid, scp->res); 209 return (0); 210 } 211 212 /* 213 * Called if the probe succeeded. 214 * We can be destructive here as we know we have the device. 215 * we can also trust the unit number. 216 */ 217 static int 218 pbioattach (device_t dev) 219 { 220 int unit; 221 int i; 222 int rid; 223 struct pbio_softc *sc; 224 225 sc = device_get_softc(dev); 226 unit = device_get_unit(dev); 227 rid = 0; 228 sc->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 229 0, ~0, IO_PBIOSIZE, RF_ACTIVE); 230 if (sc->res == NULL) 231 return (ENXIO); 232 sc->bst = rman_get_bustag(sc->res); 233 sc->bsh = rman_get_bushandle(sc->res); 234 235 /* 236 * Store whatever seems wise. 237 */ 238 sc->iomode = 0x9b; /* All ports to input */ 239 240 for (i = 0; i < PBIO_NPORTS; i++) 241 sc->pd[i].port = make_dev(&pbio_cdevsw, (unit << 2) + i, 0, 0, 242 0600, "pbio%d%s", unit, PBIO_PNAME(i)); 243 return (0); 244 } 245 246 static int 247 pbioioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag, 248 struct thread *td) 249 { 250 struct pbio_softc *scp; 251 int port, unit; 252 253 unit = UNIT(dev); 254 port = PORT(dev); 255 scp = pbio_addr(unit); 256 if (scp == NULL) 257 return (ENODEV); 258 switch (cmd) { 259 case PBIO_SETDIFF: 260 scp->pd[port].diff = *(int *)data; 261 break; 262 case PBIO_SETIPACE: 263 scp->pd[port].ipace = *(int *)data; 264 break; 265 case PBIO_SETOPACE: 266 scp->pd[port].opace = *(int *)data; 267 break; 268 case PBIO_GETDIFF: 269 *(int *)data = scp->pd[port].diff; 270 break; 271 case PBIO_GETIPACE: 272 *(int *)data = scp->pd[port].ipace; 273 break; 274 case PBIO_GETOPACE: 275 *(int *)data = scp->pd[port].opace; 276 break; 277 default: 278 return ENXIO; 279 } 280 return (0); 281 } 282 283 static int 284 pbioopen(struct cdev *dev, int oflags, int devtype, struct thread *td) 285 { 286 struct pbio_softc *scp; 287 int ocfg, port, unit; 288 int portbit; /* Port configuration bit */ 289 290 unit = UNIT(dev); 291 port = PORT(dev); 292 scp = pbio_addr(unit); 293 if (scp == NULL) 294 return (ENODEV); 295 296 switch (port) { 297 case 0: portbit = 0x10; break; /* Port A */ 298 case 1: portbit = 0x02; break; /* Port B */ 299 case 2: portbit = 0x08; break; /* Port CH */ 300 case 3: portbit = 0x01; break; /* Port CL */ 301 default: return (ENODEV); 302 } 303 ocfg = scp->iomode; 304 305 if (oflags & FWRITE) 306 /* Writing == output; zero the bit */ 307 pboutb(scp, PBIO_CFG, scp->iomode = (ocfg & (~portbit))); 308 else if (oflags & FREAD) 309 /* Reading == input; set the bit */ 310 pboutb(scp, PBIO_CFG, scp->iomode = (ocfg | portbit)); 311 else 312 return (EACCES); 313 314 return (0); 315 } 316 317 static int 318 pbioclose(struct cdev *dev, int fflag, int devtype, struct thread *td) 319 { 320 struct pbio_softc *scp; 321 int unit; 322 323 unit = UNIT(dev); 324 scp = pbio_addr(unit); 325 if (scp == NULL) 326 return (ENODEV); 327 328 return (0); 329 } 330 331 /* 332 * Return the value of a given port on a given I/O base address 333 * Handles the split C port nibbles and blocking 334 */ 335 static int 336 portval(int port, struct pbio_softc *scp, char *val) 337 { 338 int err; 339 340 for (;;) { 341 switch (port) { 342 case 0: 343 *val = pbinb(scp, PBIO_PORTA); 344 break; 345 case 1: 346 *val = pbinb(scp, PBIO_PORTB); 347 break; 348 case 2: 349 *val = (pbinb(scp, PBIO_PORTC) >> 4) & 0xf; 350 break; 351 case 3: 352 *val = pbinb(scp, PBIO_PORTC) & 0xf; 353 break; 354 default: 355 *val = 0; 356 break; 357 } 358 if (scp->pd[port].diff) { 359 if (*val != scp->pd[port].oldval) { 360 scp->pd[port].oldval = *val; 361 return (0); 362 } 363 err = tsleep((caddr_t)&(scp->pd[port].diff), PBIOPRI, 364 "pbiopl", max(1, scp->pd[port].ipace)); 365 if (err == EINTR) 366 return (EINTR); 367 } else 368 return (0); 369 } 370 } 371 372 static int 373 pbioread(struct cdev *dev, struct uio *uio, int ioflag) 374 { 375 struct pbio_softc *scp; 376 int err, i, port, ret, toread, unit; 377 char val; 378 379 unit = UNIT(dev); 380 port = PORT(dev); 381 scp = pbio_addr(unit); 382 if (scp == NULL) 383 return (ENODEV); 384 385 while (uio->uio_resid > 0) { 386 toread = min(uio->uio_resid, PBIO_BUFSIZ); 387 if ((ret = uiomove(scp->pd[port].buff, toread, uio)) != 0) 388 return (ret); 389 for (i = 0; i < toread; i++) { 390 if ((err = portval(port, scp, &val)) != 0) 391 return (err); 392 scp->pd[port].buff[i] = val; 393 if (!scp->pd[port].diff && scp->pd[port].ipace) 394 tsleep((caddr_t)&(scp->pd[port].ipace), PBIOPRI, 395 "pbioip", scp->pd[port].ipace); 396 } 397 } 398 return 0; 399 } 400 401 static int 402 pbiowrite(struct cdev *dev, struct uio *uio, int ioflag) 403 { 404 struct pbio_softc *scp; 405 int i, port, ret, towrite, unit; 406 char val, oval; 407 408 unit = UNIT(dev); 409 port = PORT(dev); 410 scp = pbio_addr(unit); 411 if (scp == NULL) 412 return (ENODEV); 413 414 while (uio->uio_resid > 0) { 415 towrite = min(uio->uio_resid, PBIO_BUFSIZ); 416 if ((ret = uiomove(scp->pd[port].buff, towrite, uio)) != 0) 417 return (ret); 418 for (i = 0; i < towrite; i++) { 419 val = scp->pd[port].buff[i]; 420 switch (port) { 421 case 0: 422 pboutb(scp, PBIO_PORTA, val); 423 break; 424 case 1: 425 pboutb(scp, PBIO_PORTB, val); 426 break; 427 case 2: 428 oval = pbinb(scp, PBIO_PORTC); 429 oval &= 0xf; 430 val <<= 4; 431 pboutb(scp, PBIO_PORTC, val | oval); 432 break; 433 case 3: 434 oval = pbinb(scp, PBIO_PORTC); 435 oval &= 0xf0; 436 val &= 0xf; 437 pboutb(scp, PBIO_PORTC, oval | val); 438 break; 439 } 440 if (scp->pd[port].opace) 441 tsleep((caddr_t)&(scp->pd[port].opace), 442 PBIOPRI, "pbioop", 443 scp->pd[port].opace); 444 } 445 } 446 return (0); 447 } 448 449 static int 450 pbiopoll(struct cdev *dev, int which, struct thread *td) 451 { 452 struct pbio_softc *scp; 453 int unit; 454 455 unit = UNIT(dev); 456 scp = pbio_addr(unit); 457 if (scp == NULL) 458 return (ENODEV); 459 460 /* 461 * Do processing 462 */ 463 return (0); /* this is the wrong value I'm sure */ 464 }
Cache object: 96a42037089ecc1fcef26cd3bd8e4da5
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]