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