2 * Copyright (c) 2000-2004
3 * Diomidis D. Spinellis, Athens, Greece
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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.
28 * $Id: pbio.c,v 1.12 2003/10/11 13:05:08 dds Exp dds $
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h> /* SYSINIT stuff */
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>
47 #include <dev/pbio/pbioio.h> /* pbio IOCTL definitions */
49 #include <sys/fcntl.h>
50 #include <isa/isavar.h>
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);
62 /* Device registers */
69 /* Per-port buffer size */
70 #define PBIO_BUFSIZ 64
72 /* Number of /dev entries */
78 static char *port_names[] = {"a", "b", "ch", "cl"};
80 #define PBIO_PNAME(n) (port_names[(n)])
82 #define UNIT(dev) (dev2unit(dev) >> 2)
83 #define PORT(dev) (dev2unit(dev) & 0x3)
85 #define PBIOPRI ((PZERO + 5) | PCATCH)
87 static struct cdevsw pbio_cdevsw = {
88 .d_version = D_VERSION,
89 .d_flags = D_NEEDGIANT,
100 * Data specific to each I/O 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 */
112 * One of these per allocated device
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;
120 bus_space_handle_t bsh;
123 typedef struct pbio_softc *sc_p;
125 static device_method_t pbio_methods[] = {
126 /* Device interface */
127 DEVMETHOD(device_probe, pbioprobe),
128 DEVMETHOD(device_attach, pbioattach),
132 static devclass_t pbio_devclass;
133 #define pbio_addr(unit) \
134 ((struct pbio_softc *) devclass_get_softc(pbio_devclass, unit))
136 static char driver_name[] = "pbio";
138 static driver_t pbio_driver = {
141 sizeof(struct pbio_softc),
144 DRIVER_MODULE(pbio, isa, pbio_driver, pbio_devclass, 0, 0);
146 static __inline uint8_t
147 pbinb(struct pbio_softc *scp, int off)
150 return bus_space_read_1(scp->bst, scp->bsh, off);
154 pboutb(struct pbio_softc *scp, int off, uint8_t val)
157 bus_space_write_1(scp->bst, scp->bsh, off, val);
162 pbioprobe(device_t dev)
165 struct pbio_softc *scp = device_get_softc(dev);
166 #ifdef GENERIC_PBIO_PROBE
170 if (isa_get_logicalid(dev)) /* skip PnP probes */
173 scp->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
174 0, ~0, IO_PBIOSIZE, RF_ACTIVE);
175 if (scp->res == NULL)
178 #ifdef GENERIC_PBIO_PROBE
179 scp->bst = rman_get_bustag(scp->res);
180 scp->bsh = rman_get_bushandle(scp->res);
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
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);
194 bus_release_resource(dev, SYS_RES_IOPORT, rid, sc->res);
197 pboutb(scp, PBIO_PORTA, 0x5a);
198 val = pbinb(scp, PBIO_PORTA);
199 printf("pbio val=0x%02x (should be 0x5a)\n", val);
201 bus_release_resource(dev, SYS_RES_IOPORT, rid, sc->res);
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);
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.
218 pbioattach (device_t dev)
223 struct pbio_softc *sc;
225 sc = device_get_softc(dev);
226 unit = device_get_unit(dev);
228 sc->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
229 0, ~0, IO_PBIOSIZE, RF_ACTIVE);
232 sc->bst = rman_get_bustag(sc->res);
233 sc->bsh = rman_get_bushandle(sc->res);
236 * Store whatever seems wise.
238 sc->iomode = 0x9b; /* All ports to input */
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));
247 pbioioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag,
250 struct pbio_softc *scp;
255 scp = pbio_addr(unit);
260 scp->pd[port].diff = *(int *)data;
263 scp->pd[port].ipace = *(int *)data;
266 scp->pd[port].opace = *(int *)data;
269 *(int *)data = scp->pd[port].diff;
272 *(int *)data = scp->pd[port].ipace;
275 *(int *)data = scp->pd[port].opace;
284 pbioopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
286 struct pbio_softc *scp;
287 int ocfg, port, unit;
288 int portbit; /* Port configuration bit */
292 scp = pbio_addr(unit);
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);
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));
318 pbioclose(struct cdev *dev, int fflag, int devtype, struct thread *td)
320 struct pbio_softc *scp;
324 scp = pbio_addr(unit);
332 * Return the value of a given port on a given I/O base address
333 * Handles the split C port nibbles and blocking
336 portval(int port, struct pbio_softc *scp, char *val)
343 *val = pbinb(scp, PBIO_PORTA);
346 *val = pbinb(scp, PBIO_PORTB);
349 *val = (pbinb(scp, PBIO_PORTC) >> 4) & 0xf;
352 *val = pbinb(scp, PBIO_PORTC) & 0xf;
358 if (scp->pd[port].diff) {
359 if (*val != scp->pd[port].oldval) {
360 scp->pd[port].oldval = *val;
363 err = tsleep((caddr_t)&(scp->pd[port].diff), PBIOPRI,
364 "pbiopl", max(1, scp->pd[port].ipace));
373 pbioread(struct cdev *dev, struct uio *uio, int ioflag)
375 struct pbio_softc *scp;
376 int err, i, port, ret, toread, unit;
381 scp = pbio_addr(unit);
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)
389 for (i = 0; i < toread; i++) {
390 if ((err = portval(port, scp, &val)) != 0)
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);
402 pbiowrite(struct cdev *dev, struct uio *uio, int ioflag)
404 struct pbio_softc *scp;
405 int i, port, ret, towrite, unit;
410 scp = pbio_addr(unit);
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)
418 for (i = 0; i < towrite; i++) {
419 val = scp->pd[port].buff[i];
422 pboutb(scp, PBIO_PORTA, val);
425 pboutb(scp, PBIO_PORTB, val);
428 oval = pbinb(scp, PBIO_PORTC);
431 pboutb(scp, PBIO_PORTC, val | oval);
434 oval = pbinb(scp, PBIO_PORTC);
437 pboutb(scp, PBIO_PORTC, oval | val);
440 if (scp->pd[port].opace)
441 tsleep((caddr_t)&(scp->pd[port].opace),
443 scp->pd[port].opace);
450 pbiopoll(struct cdev *dev, int which, struct thread *td)
452 struct pbio_softc *scp;
456 scp = pbio_addr(unit);
463 return (0); /* this is the wrong value I'm sure */