uart/ns8250: Factor out reading the divisor
ClosedPublic
Actions

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines

static int ofw_cpulist_probe(device_t);		static int ofw_cpulist_probe(device_t);
static int ofw_cpulist_attach(device_t);		static int ofw_cpulist_attach(device_t);
static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,		static const struct ofw_bus_devinfo *ofw_cpulist_get_devinfo(device_t dev,
device_t child);		device_t child);

static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");		static MALLOC_DEFINE(M_OFWCPU, "ofwcpu", "OFW CPU device information");

		struct ofw_cpulist_softc {
		pcell_t sc_addr_cells;
		};

static device_method_t ofw_cpulist_methods[] = {		static device_method_t ofw_cpulist_methods[] = {
/* Device interface */		/* Device interface */
DEVMETHOD(device_probe, ofw_cpulist_probe),		DEVMETHOD(device_probe, ofw_cpulist_probe),
DEVMETHOD(device_attach, ofw_cpulist_attach),		DEVMETHOD(device_attach, ofw_cpulist_attach),

/* Bus interface */		/* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child),		DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),		DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),

/* ofw_bus interface */		/* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),		DEVMETHOD(ofw_bus_get_devinfo, ofw_cpulist_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),		DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),		DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),		DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),		DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),		DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),

DEVMETHOD_END		DEVMETHOD_END
};		};

static driver_t ofw_cpulist_driver = {		static driver_t ofw_cpulist_driver = {
"cpulist",		"cpulist",
ofw_cpulist_methods,		ofw_cpulist_methods,
0		sizeof(struct ofw_cpulist_softc)
};		};

static devclass_t ofw_cpulist_devclass;		static devclass_t ofw_cpulist_devclass;

DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,		DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0);		0, 0);

static int		static int
Show All 9 Lines	ofw_cpulist_probe(device_t dev)
device_set_desc(dev, "Open Firmware CPU Group");		device_set_desc(dev, "Open Firmware CPU Group");

return (0);		return (0);
}		}

static int		static int
ofw_cpulist_attach(device_t dev)		ofw_cpulist_attach(device_t dev)
{		{
		struct ofw_cpulist_softc *sc;
phandle_t root, child;		phandle_t root, child;
device_t cdev;		device_t cdev;
struct ofw_bus_devinfo *dinfo;		struct ofw_bus_devinfo *dinfo;

		sc = device_get_softc(dev);
root = ofw_bus_get_node(dev);		root = ofw_bus_get_node(dev);

		sc->sc_addr_cells = 1;
		OF_getencprop(root, "#address-cells", &sc->sc_addr_cells,
		sizeof(sc->sc_addr_cells));

for (child = OF_child(root); child != 0; child = OF_peer(child)) {		for (child = OF_child(root); child != 0; child = OF_peer(child)) {
dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK \| M_ZERO);		dinfo = malloc(sizeof(*dinfo), M_OFWCPU, M_WAITOK \| M_ZERO);

if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {		if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
free(dinfo, M_OFWCPU);		free(dinfo, M_OFWCPU);
continue;		continue;
}		}
cdev = device_add_child(dev, NULL, -1);		cdev = device_add_child(dev, NULL, -1);
Show All 19 Lines
static int ofw_cpu_probe(device_t);		static int ofw_cpu_probe(device_t);
static int ofw_cpu_attach(device_t);		static int ofw_cpu_attach(device_t);
static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,		static int ofw_cpu_read_ivar(device_t dev, device_t child, int index,
uintptr_t *result);		uintptr_t *result);

struct ofw_cpu_softc {		struct ofw_cpu_softc {
struct pcpu *sc_cpu_pcpu;		struct pcpu *sc_cpu_pcpu;
uint32_t sc_nominal_mhz;		uint32_t sc_nominal_mhz;
		boolean_t sc_reg_valid;
		pcell_t sc_reg[2];
};		};

static device_method_t ofw_cpu_methods[] = {		static device_method_t ofw_cpu_methods[] = {
/* Device interface */		/* Device interface */
DEVMETHOD(device_probe, ofw_cpu_probe),		DEVMETHOD(device_probe, ofw_cpu_probe),
DEVMETHOD(device_attach, ofw_cpu_attach),		DEVMETHOD(device_attach, ofw_cpu_attach),

/* Bus interface */		/* Bus interface */
Show All 28 Lines	ofw_cpu_probe(device_t dev)

device_set_desc(dev, "Open Firmware CPU");		device_set_desc(dev, "Open Firmware CPU");
return (0);		return (0);
}		}

static int		static int
ofw_cpu_attach(device_t dev)		ofw_cpu_attach(device_t dev)
{		{
		struct ofw_cpulist_softc *psc;
struct ofw_cpu_softc *sc;		struct ofw_cpu_softc *sc;
phandle_t node;		phandle_t node;
uint32_t cell;		pcell_t cell;
		int rv;

sc = device_get_softc(dev);		sc = device_get_softc(dev);
node = ofw_bus_get_node(dev);		psc = device_get_softc(device_get_parent(dev));
if (OF_getencprop(node, "reg", &cell, sizeof(cell)) < 0) {
cell = device_get_unit(dev);		if (nitems(sc->sc_reg) < psc->sc_addr_cells) {
device_printf(dev, "missing 'reg' property, using %u\n", cell);		if (bootverbose)
		device_printf(dev, "Too many address cells\n");
		return (EINVAL);
}		}
sc->sc_cpu_pcpu = pcpu_find(cell);
		node = ofw_bus_get_node(dev);

		/* Read and validate the reg property for use later */
		sc->sc_reg_valid = false;
		rv = OF_getencprop(node, "reg", sc->sc_reg, sizeof(sc->sc_reg));
		if (rv < 0)
		device_printf(dev, "missing 'reg' property\n");
		else if ((rv % 4) != 0) {
		if (bootverbose)
		device_printf(dev, "Malformed reg property\n");
		} else if ((rv / 4) != psc->sc_addr_cells) {
		if (bootverbose)
		device_printf(dev, "Invalid reg size %u\n", rv);
		} else
		sc->sc_reg_valid = true;

		sc->sc_cpu_pcpu = pcpu_find(device_get_unit(dev));

if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {		if (OF_getencprop(node, "clock-frequency", &cell, sizeof(cell)) < 0) {
if (bootverbose)		if (bootverbose)
device_printf(dev,		device_printf(dev,
"missing 'clock-frequency' property\n");		"missing 'clock-frequency' property\n");
} else		} else
sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */		sc->sc_nominal_mhz = cell / 1000000; /* convert to MHz */

bus_generic_probe(dev);		bus_generic_probe(dev);
Show All 25 Lines

uart/ns8250: Factor out reading the divisorClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 144858

sys/dev/uart/uart_dev_ns8250.c

uart/ns8250: Factor out reading the divisor
ClosedPublic
Actions

Revision Contents
Changeset List