freebsd-dev/sys/dev/puc/puc.c
Marcel Moolenaar dc7d0dea12 Enhance puc(4) to support uart(4). This includes:
o  Introduce PUC_PORT_TYPE_UART so that we can attach to uart(4),
o  Introduce port sub-types (eg PUC_PORT_UART_NS8250, PUC_PORT_UART_Z8530)
   to handle different hardware and determine resource sizes.
o  Introduce two new IVARs: PUC_IVAR_SUBTYPE and PUC_IVAR_REGSHFT. Both
   are used by uart(4) to get sufficient information to talk to the HW.
o  Introduce PUC_FLAGS_ALTRES to tell puc(4) to try memory mapped I/O
   if I/O port space cannot be allocated, or vice versa.
o  Have ports of type PUC_PORT_TYPE_COM attach to uart(1) if attaching
   to sio(4) fails (due to not having the sio driver).
o  Put struct puc_device_description in struct puc_softc instead of
   having a pointer to a device description in the softc. This allows
   us to create device descriptions on the fly without having to use
   malloc() or otherwise have them staticly defined.
o  Move puc_find_description() from puc.c to puc_pci.c as it's specific
   to PCI.
o  Add EBUS and SBUS frontends for use on sparc64. Note that the P in
   puc stands for PCI, so we kinda mess things up here. It's too soon
   to worry about it though. We'll know what to do about it in time.

NOTE: This commit changes the behaviour of puc(4) to not quieten the
device probe and attach for child devices. The uart(4) driver provides
additional device description that is valuable to have.
2003-09-06 21:48:50 +00:00

612 lines
16 KiB
C

/* $NetBSD: puc.c,v 1.7 2000/07/29 17:43:38 jlam Exp $ */
/*-
* Copyright (c) 2002 JF Hay. All rights reserved.
* Copyright (c) 2000 M. Warner Losh. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
/*
* Copyright (c) 1996, 1998, 1999
* Christopher G. Demetriou. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Christopher G. Demetriou
* for the NetBSD Project.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
/*
* PCI "universal" communication card device driver, glues com, lpt,
* and similar ports to PCI via bridge chip often much larger than
* the devices being glued.
*
* Author: Christopher G. Demetriou, May 14, 1998 (derived from NetBSD
* sys/dev/pci/pciide.c, revision 1.6).
*
* These devices could be (and some times are) described as
* communications/{serial,parallel}, etc. devices with known
* programming interfaces, but those programming interfaces (in
* particular the BAR assignments for devices, etc.) in fact are not
* particularly well defined.
*
* After I/we have seen more of these devices, it may be possible
* to generalize some of these bits. In particular, devices which
* describe themselves as communications/serial/16[45]50, and
* communications/parallel/??? might be attached via direct
* 'com' and 'lpt' attachments to pci.
*/
#include "opt_puc.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/malloc.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#define PUC_ENTRAILS 1
#include <dev/puc/pucvar.h>
struct puc_device {
struct resource_list resources;
u_int serialfreq;
u_int subtype;
int regshft;
};
static void puc_intr(void *arg);
static int puc_find_free_unit(char *);
#ifdef PUC_DEBUG
static void puc_print_resource_list(struct resource_list *);
#endif
devclass_t puc_devclass;
static int
puc_port_bar_index(struct puc_softc *sc, int bar)
{
int i;
for (i = 0; i < PUC_MAX_BAR; i += 1) {
if (!sc->sc_bar_mappings[i].used)
break;
if (sc->sc_bar_mappings[i].bar == bar)
return (i);
}
sc->sc_bar_mappings[i].bar = bar;
sc->sc_bar_mappings[i].used = 1;
return (i);
}
static int
puc_probe_ilr(struct puc_softc *sc, struct resource *res)
{
u_char t1, t2;
int i;
switch (sc->sc_desc.ilr_type) {
case PUC_ILR_TYPE_DIGI:
sc->ilr_st = rman_get_bustag(res);
sc->ilr_sh = rman_get_bushandle(res);
for (i = 0; i < 2 && sc->sc_desc.ilr_offset[i] != 0; i++) {
t1 = bus_space_read_1(sc->ilr_st, sc->ilr_sh,
sc->sc_desc.ilr_offset[i]);
t1 = ~t1;
bus_space_write_1(sc->ilr_st, sc->ilr_sh,
sc->sc_desc.ilr_offset[i], t1);
t2 = bus_space_read_1(sc->ilr_st, sc->ilr_sh,
sc->sc_desc.ilr_offset[i]);
if (t2 == t1)
return (0);
}
return (1);
default:
break;
}
return (0);
}
int
puc_attach(device_t dev, const struct puc_device_description *desc)
{
char *typestr;
int bidx, childunit, i, irq_setup, ressz, rid, type;
struct puc_softc *sc;
struct puc_device *pdev;
struct resource *res;
struct resource_list_entry *rle;
if (desc == NULL)
return (ENXIO);
sc = (struct puc_softc *)device_get_softc(dev);
bzero(sc, sizeof(*sc));
sc->sc_desc = *desc;
#ifdef PUC_DEBUG
bootverbose = 1;
printf("puc: name: %s\n", sc->sc_desc.name);
#endif
rid = 0;
res = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
RF_ACTIVE | RF_SHAREABLE);
if (!res)
return (ENXIO);
sc->irqres = res;
sc->irqrid = rid;
#ifdef PUC_FASTINTR
irq_setup = BUS_SETUP_INTR(device_get_parent(dev), dev, res,
INTR_TYPE_TTY | INTR_FAST, puc_intr, sc, &sc->intr_cookie);
if (irq_setup == 0)
sc->fastintr = INTR_FAST;
else
irq_setup = BUS_SETUP_INTR(device_get_parent(dev), dev, res,
INTR_TYPE_TTY, puc_intr, sc, &sc->intr_cookie);
#else
irq_setup = BUS_SETUP_INTR(device_get_parent(dev), dev, res,
INTR_TYPE_TTY, puc_intr, sc, &sc->intr_cookie);
#endif
if (irq_setup != 0)
return (ENXIO);
rid = 0;
for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) {
if (i > 0 && rid == sc->sc_desc.ports[i].bar)
sc->barmuxed = 1;
rid = sc->sc_desc.ports[i].bar;
bidx = puc_port_bar_index(sc, rid);
if (sc->sc_bar_mappings[bidx].res != NULL)
continue;
type = (sc->sc_desc.ports[i].flags & PUC_FLAGS_MEMORY)
? SYS_RES_MEMORY : SYS_RES_IOPORT;
res = bus_alloc_resource(dev, type, &rid, 0ul, ~0ul, 1,
RF_ACTIVE);
if (res == NULL &&
sc->sc_desc.ports[i].flags & PUC_FLAGS_ALTRES) {
type = (type == SYS_RES_IOPORT)
? SYS_RES_MEMORY : SYS_RES_IOPORT;
res = bus_alloc_resource(dev, type, &rid, 0ul, ~0ul, 1,
RF_ACTIVE);
}
if (res == NULL) {
device_printf(dev, "could not get resource\n");
continue;
}
sc->sc_bar_mappings[bidx].type = type;
sc->sc_bar_mappings[bidx].res = res;
if (sc->sc_desc.ilr_type != PUC_ILR_TYPE_NONE) {
sc->ilr_enabled = puc_probe_ilr(sc, res);
if (sc->ilr_enabled)
device_printf(dev, "ILR enabled\n");
else
device_printf(dev, "ILR disabled\n");
}
#ifdef PUC_DEBUG
printf("%s rid %d bst %lx, start %lx, end %lx\n",
(type == SYS_RES_MEMORY) ? "memory" : "port", rid,
(u_long)rman_get_bustag(res), (u_long)rman_get_start(res),
(u_long)rman_get_end(res));
#endif
}
if (desc->init != NULL) {
i = desc->init(sc);
if (i != 0)
return (i);
}
for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) {
rid = sc->sc_desc.ports[i].bar;
bidx = puc_port_bar_index(sc, rid);
if (sc->sc_bar_mappings[bidx].res == NULL)
continue;
switch (sc->sc_desc.ports[i].type & ~PUC_PORT_SUBTYPE_MASK) {
case PUC_PORT_TYPE_COM:
typestr = "sio";
break;
case PUC_PORT_TYPE_LPT:
typestr = "ppc";
break;
case PUC_PORT_TYPE_UART:
typestr = "uart";
break;
default:
continue;
}
switch (sc->sc_desc.ports[i].type & PUC_PORT_SUBTYPE_MASK) {
case PUC_PORT_UART_SAB82532:
ressz = 64;
break;
case PUC_PORT_UART_Z8530:
ressz = 2;
break;
default:
ressz = 8;
break;
}
pdev = malloc(sizeof(struct puc_device), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (!pdev)
continue;
resource_list_init(&pdev->resources);
/* First fake up an IRQ resource. */
resource_list_add(&pdev->resources, SYS_RES_IRQ, 0,
rman_get_start(sc->irqres), rman_get_end(sc->irqres),
rman_get_end(sc->irqres) - rman_get_start(sc->irqres) + 1);
rle = resource_list_find(&pdev->resources, SYS_RES_IRQ, 0);
rle->res = sc->irqres;
/* Now fake an IOPORT or MEMORY resource */
res = sc->sc_bar_mappings[bidx].res;
type = sc->sc_bar_mappings[bidx].type;
resource_list_add(&pdev->resources, type, 0,
rman_get_start(res) + sc->sc_desc.ports[i].offset,
rman_get_start(res) + sc->sc_desc.ports[i].offset
+ ressz - 1, ressz);
rle = resource_list_find(&pdev->resources, type, 0);
if (sc->barmuxed == 0) {
rle->res = sc->sc_bar_mappings[bidx].res;
} else {
rle->res = malloc(sizeof(struct resource), M_DEVBUF,
M_WAITOK | M_ZERO);
if (rle->res == NULL) {
free(pdev, M_DEVBUF);
return (ENOMEM);
}
rle->res->r_start = rman_get_start(res) +
sc->sc_desc.ports[i].offset;
rle->res->r_end = rle->res->r_start + ressz - 1;
rle->res->r_bustag = rman_get_bustag(res);
bus_space_subregion(rle->res->r_bustag,
rman_get_bushandle(res),
sc->sc_desc.ports[i].offset, ressz,
&rle->res->r_bushandle);
}
pdev->serialfreq = sc->sc_desc.ports[i].serialfreq;
pdev->subtype = sc->sc_desc.ports[i].type &
PUC_PORT_SUBTYPE_MASK;
pdev->regshft = sc->sc_desc.ports[i].regshft;
childunit = puc_find_free_unit(typestr);
if (childunit < 0 && strcmp(typestr, "uart") != 0) {
typestr = "uart";
childunit = puc_find_free_unit(typestr);
}
sc->sc_ports[i].dev = device_add_child(dev, typestr,
childunit);
if (sc->sc_ports[i].dev == NULL) {
if (sc->barmuxed) {
bus_space_unmap(rman_get_bustag(rle->res),
rman_get_bushandle(rle->res), ressz);
free(rle->res, M_DEVBUF);
free(pdev, M_DEVBUF);
}
continue;
}
device_set_ivars(sc->sc_ports[i].dev, pdev);
device_set_desc(sc->sc_ports[i].dev, sc->sc_desc.name);
#ifdef PUC_DEBUG
printf("puc: type %d, bar %x, offset %x\n",
sc->sc_desc.ports[i].type,
sc->sc_desc.ports[i].bar,
sc->sc_desc.ports[i].offset);
puc_print_resource_list(&pdev->resources);
#endif
device_set_flags(sc->sc_ports[i].dev,
sc->sc_desc.ports[i].flags);
if (device_probe_and_attach(sc->sc_ports[i].dev) != 0) {
if (sc->barmuxed) {
bus_space_unmap(rman_get_bustag(rle->res),
rman_get_bushandle(rle->res), ressz);
free(rle->res, M_DEVBUF);
free(pdev, M_DEVBUF);
}
}
}
#ifdef PUC_DEBUG
bootverbose = 0;
#endif
return (0);
}
static u_int32_t
puc_ilr_read(struct puc_softc *sc)
{
u_int32_t mask;
int i;
mask = 0;
switch (sc->sc_desc.ilr_type) {
case PUC_ILR_TYPE_DIGI:
for (i = 1; i >= 0 && sc->sc_desc.ilr_offset[i] != 0; i--) {
mask = (mask << 8) | (bus_space_read_1(sc->ilr_st,
sc->ilr_sh, sc->sc_desc.ilr_offset[i]) & 0xff);
}
break;
default:
mask = 0xffffffff;
break;
}
return (mask);
}
/*
* This is an interrupt handler. For boards that can't tell us which
* device generated the interrupt it just calls all the registered
* handlers sequencially, but for boards that can tell us which
* device(s) generated the interrupt it calls only handlers for devices
* that actually generated the interrupt.
*/
static void
puc_intr(void *arg)
{
int i;
u_int32_t ilr_mask;
struct puc_softc *sc;
sc = (struct puc_softc *)arg;
ilr_mask = sc->ilr_enabled ? puc_ilr_read(sc) : 0xffffffff;
for (i = 0; i < PUC_MAX_PORTS; i++)
if (sc->sc_ports[i].ihand != NULL &&
((ilr_mask >> i) & 0x00000001))
(sc->sc_ports[i].ihand)(sc->sc_ports[i].ihandarg);
}
static int
puc_find_free_unit(char *name)
{
devclass_t dc;
int start;
int unit;
unit = 0;
start = 0;
while (resource_int_value(name, unit, "port", &start) == 0 &&
start > 0)
unit++;
dc = devclass_find(name);
if (dc == NULL)
return (-1);
while (devclass_get_device(dc, unit))
unit++;
#ifdef PUC_DEBUG
printf("puc: Using %s%d\n", name, unit);
#endif
return (unit);
}
#ifdef PUC_DEBUG
static void
puc_print_resource_list(struct resource_list *rl)
{
#if 0
struct resource_list_entry *rle;
printf("print_resource_list: rl %p\n", rl);
SLIST_FOREACH(rle, rl, link)
printf(" type %x, rid %x start %lx end %lx count %lx\n",
rle->type, rle->rid, rle->start, rle->end, rle->count);
printf("print_resource_list: end.\n");
#endif
}
#endif
struct resource *
puc_alloc_resource(device_t dev, device_t child, int type, int *rid,
u_long start, u_long end, u_long count, u_int flags)
{
struct puc_device *pdev;
struct resource *retval;
struct resource_list *rl;
struct resource_list_entry *rle;
device_t my_child;
/*
* in the case of a child of child we need to find our immediate child
*/
for (my_child = child; device_get_parent(my_child) != dev;
my_child = device_get_parent(my_child));
pdev = device_get_ivars(my_child);
rl = &pdev->resources;
#ifdef PUC_DEBUG
printf("puc_alloc_resource: pdev %p, looking for t %x, r %x\n",
pdev, type, *rid);
puc_print_resource_list(rl);
#endif
retval = NULL;
rle = resource_list_find(rl, type, *rid);
if (rle) {
#ifdef PUC_DEBUG
printf("found rle, %lx, %lx, %lx\n", rle->start, rle->end,
rle->count);
#endif
retval = rle->res;
}
#ifdef PUC_DEBUG
else
printf("oops rle is gone\n");
#endif
return (retval);
}
int
puc_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *res)
{
return (0);
}
int
puc_get_resource(device_t dev, device_t child, int type, int rid,
u_long *startp, u_long *countp)
{
struct puc_device *pdev;
struct resource_list *rl;
struct resource_list_entry *rle;
pdev = device_get_ivars(child);
rl = &pdev->resources;
#ifdef PUC_DEBUG
printf("puc_get_resource: pdev %p, looking for t %x, r %x\n", pdev,
type, rid);
puc_print_resource_list(rl);
#endif
rle = resource_list_find(rl, type, rid);
if (rle) {
#ifdef PUC_DEBUG
printf("found rle %p,", rle);
#endif
if (startp != NULL)
*startp = rle->start;
if (countp != NULL)
*countp = rle->count;
#ifdef PUC_DEBUG
printf(" %lx, %lx\n", rle->start, rle->count);
#endif
return (0);
} else
printf("oops rle is gone\n");
return (ENXIO);
}
int
puc_setup_intr(device_t dev, device_t child, struct resource *r, int flags,
void (*ihand)(void *), void *arg, void **cookiep)
{
int i;
struct puc_softc *sc;
sc = (struct puc_softc *)device_get_softc(dev);
if ((flags & INTR_FAST) != sc->fastintr)
return (ENXIO);
for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) {
if (sc->sc_ports[i].dev == child) {
if (sc->sc_ports[i].ihand != 0)
return (ENXIO);
sc->sc_ports[i].ihand = ihand;
sc->sc_ports[i].ihandarg = arg;
*cookiep = arg;
return (0);
}
}
return (ENXIO);
}
int
puc_teardown_intr(device_t dev, device_t child, struct resource *r,
void *cookie)
{
int i;
struct puc_softc *sc;
sc = (struct puc_softc *)device_get_softc(dev);
for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) {
if (sc->sc_ports[i].dev == child) {
sc->sc_ports[i].ihand = NULL;
sc->sc_ports[i].ihandarg = NULL;
return (0);
}
}
return (ENXIO);
}
int
puc_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
{
struct puc_device *pdev;
pdev = device_get_ivars(child);
if (pdev == NULL)
return (ENOENT);
switch(index) {
case PUC_IVAR_FREQ:
*result = pdev->serialfreq;
break;
case PUC_IVAR_SUBTYPE:
*result = pdev->subtype;
break;
case PUC_IVAR_REGSHFT:
*result = pdev->regshft;
break;
default:
return (ENOENT);
}
return (0);
}