static void
pxauart_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct pxaip_attach_args *pxa = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
int cken = 0;
sc->sc_dev = self;
iot = &pxa2x0_a4x_bs_tag; /* XXX: This sucks */
iobase = pxa->pxa_addr;
sc->sc_frequency = PXA2X0_COM_FREQ;
sc->sc_type = COM_TYPE_PXA2x0;
if (com_is_console(iot, iobase, &ioh) == 0 &&
bus_space_map(iot, iobase, pxa->pxa_size, 0, &ioh)) {
aprint_error(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
switch (pxa->pxa_addr) {
case PXA2X0_FFUART_BASE: cken = CKEN_FFUART; break;
case PXA2X0_STUART_BASE: cken = CKEN_STUART; break;
case PXA2X0_BTUART_BASE: cken = CKEN_BTUART; break;
case PXA2X0_HWUART_BASE: cken = CKEN_HWUART; break;
}
pxa2x0_clkman_config(cken, 1);
com_attach_subr(sc);
pxa2x0_intr_establish(pxa->pxa_intr, IPL_SERIAL, comintr, sc);
}
void
ralink_com_attach(device_t parent, device_t self, void *aux)
{
const struct mainbus_attach_args *ma = aux;
struct ralink_com_softc * const rtsc = device_private(self);
struct com_softc * const sc = &rtsc->sc_com;
bus_space_handle_t ioh;
int error;
if ((error = bus_space_map(ma->ma_memt, RA_UART_LITE_BASE,
0x1000, 0, &ioh)) != 0) {
aprint_error(": can't map registers, error=%d\n", error);
return;
}
COM_INIT_REGS(sc->sc_regs, ma->ma_memt, ioh, RA_UART_LITE_BASE);
sc->sc_dev = self;
sc->sc_frequency = RA_UART_FREQ;
sc->sc_regs.cr_nports = 0x1000;
sc->sc_type = COM_TYPE_AU1x00;
sc->enabled = 1;
ralink_com_initmap(&sc->sc_regs);
rtsc->sc_ih = ra_intr_establish(RA_IRQ_UARTL, comintr, sc, 1);
com_attach_subr(sc);
}
static void
obiouart_attach(device_t parent, device_t self, void *aux)
{
struct com_obio_softc *osc = device_private(self);
struct com_softc *sc = &osc->sc_sc;
struct obio_attach_args *obio = aux;
bus_space_tag_t bst;
bus_space_handle_t bsh = 0;
bus_addr_t iobase;
sc->sc_dev = self;
bst = obio->obio_bst;
iobase = obio->obio_base + obio->obio_offset;
sc->sc_frequency = ROCKCHIP_UART_FREQ;
sc->sc_type = COM_TYPE_NORMAL;
if (com_is_console(bst, iobase, &bsh) == 0 &&
bus_space_subregion(bst, obio->obio_bsh, obio->obio_size, 0, &bsh)) {
panic(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, bst, bsh, iobase);
com_attach_subr(sc);
aprint_naive("\n");
KASSERT(obio->obio_intr != OBIOCF_INTR_DEFAULT);
osc->sc_ih = intr_establish(obio->obio_intr, IPL_SERIAL, IST_LEVEL,
comintr, sc);
if (osc->sc_ih == NULL)
panic("%s: failed to establish interrup %d",
device_xname(self), obio->obio_intr);
}
void
com_mainbus_attach(device_t parent, device_t self, void *aux)
{
struct com_mainbus_softc *msc = device_private(self);
struct com_softc *sc = &msc->sc_com;
struct mainbus_attach_args *ma = aux;
bus_space_handle_t ioh;
sc->sc_dev = self;
if (com_is_console(ma->ma_st, ma->ma_addr, &ioh) == 0 &&
bus_space_map(ma->ma_st, ma->ma_addr, COM_NPORTS, 0, &ioh) != 0) {
aprint_error(": can't map i/o space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, ma->ma_st, ioh, ma->ma_addr);
sc->sc_frequency = COM_FREQ;
com_attach_subr(sc);
msc->sc_ih = (*algor_intr_establish)(ma->ma_irq, comintr, sc);
if (msc->sc_ih == NULL) {
aprint_error_dev(self, "unable to establish interrupt\n");
return;
}
if (!pmf_device_register1(self, com_suspend, com_resume, com_cleanup)) {
aprint_error_dev(self, "could not establish shutdown hook");
}
}
static void
ixsipcom_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct ixpsip_attach_args *sa = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
sc->sc_dev = self;
iot = &ixp425_a4x_bs_tag;
iobase = sa->sa_addr;
sc->sc_frequency = IXP425_UART_FREQ;
sc->sc_type = COM_TYPE_PXA2x0;
if (com_is_console(iot, iobase, &ioh) == 0 &&
bus_space_map(iot, iobase, sa->sa_size, 0, &ioh)) {
aprint_error(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
ixp425_intr_establish(uart_irq[sa->sa_index], IPL_SERIAL, comintr, sc);
}
void
com_eumb_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct eumb_attach_args *eaa = aux;
int comaddr, epicirq;
bus_space_handle_t ioh;
extern u_long ticks_per_sec;
sc->sc_dev = self;
found = 1;
comaddr = (eaa->eumb_unit == 1) ? 0x4600 : 0x4500;
if (comaddr == cnregs.cr_iobase)
sc->sc_regs = cnregs;
else {
ioh = comaddr;
bus_space_map(eaa->eumb_bt, comaddr, COM_NPORTS, 0, &ioh);
COM_INIT_REGS(sc->sc_regs, eaa->eumb_bt, ioh, comaddr);
}
sc->sc_frequency = 4 * ticks_per_sec;
epicirq = (eaa->eumb_unit == 1) ? 25 : 24;
com_attach_subr(sc);
intr_establish(epicirq + 16, IST_LEVEL, IPL_SERIAL, comintr, sc);
}
static void
gemini_com_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct obio_attach_args *obio = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
sc->sc_dev = self;
iot = obio->obio_iot;
iobase = obio->obio_addr;
sc->sc_frequency = GEMINI_COM_FREQ;
sc->sc_type = COM_TYPE_16550_NOERS;
if (com_is_console(iot, iobase, &ioh) == 0 &&
bus_space_map(iot, iobase, obio->obio_size, 0, &ioh)) {
panic(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
aprint_naive("\n");
intr_establish(obio->obio_intr, IPL_SERIAL, IST_LEVEL_HIGH,
comintr, sc);
}
void
com_jensenio_attach(device_t parent, device_t self, void *aux)
{
struct com_jensenio_softc *jsc = device_private(self);
struct com_softc *sc = &jsc->sc_com;
struct jensenio_attach_args *ja = aux;
bus_space_handle_t ioh;
sc->sc_dev = self;
if (com_is_console(ja->ja_iot, ja->ja_ioaddr, &ioh) == 0 &&
bus_space_map(ja->ja_iot, ja->ja_ioaddr, COM_NPORTS, 0,
&ioh) != 0) {
aprint_error(": can't map i/o space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, ja->ja_iot, ioh, ja->ja_ioaddr);
sc->sc_frequency = COM_FREQ;
com_attach_subr(sc);
scb_set(ja->ja_irq[0], com_jensenio_intr, sc, IPL_VM);
aprint_normal_dev(self, "interrupting at vector 0x%x\n",
ja->ja_irq[0]);
sprintf(jsc->sc_vecstr, "0x%x", ja->ja_irq[0]);
evcnt_attach_dynamic(&jsc->sc_ev_intr, EVCNT_TYPE_INTR,
NULL, "vector", jsc->sc_vecstr);
if (!pmf_device_register1(self, com_suspend, com_resume, com_cleanup)) {
aprint_error_dev(self, "could not establish shutdown hook");
}
}
static void
amlogic_com_attach(device_t parent, device_t self, void *aux)
{
struct amlogic_com_softc * const asc = device_private(self);
struct com_softc * const sc = &asc->asc_sc;
struct amlogicio_attach_args * const aio = aux;
const struct amlogic_locators * const loc = &aio->aio_loc;
bus_space_tag_t iot = aio->aio_core_a4x_bst;
const bus_addr_t iobase = AMLOGIC_CORE_BASE + loc->loc_offset;
bus_space_handle_t ioh;
amlogic_com_ports |= __BIT(loc->loc_port);
sc->sc_dev = self;
sc->sc_frequency = AMLOGIC_UART_FREQ;
sc->sc_type = COM_TYPE_NORMAL;
if (com_is_console(iot, iobase, &ioh) == 0
&& bus_space_subregion(iot, aio->aio_bsh,
loc->loc_offset / 4, loc->loc_size, &ioh)) {
panic(": can't map registers");
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
aprint_naive("\n");
KASSERT(loc->loc_intr != AMLOGICIO_INTR_DEFAULT);
asc->asc_ih = intr_establish(loc->loc_intr, IPL_SERIAL,
IST_EDGE | IST_MPSAFE, comintr, sc);
if (asc->asc_ih == NULL)
panic("%s: failed to establish interrupt %d",
device_xname(self), loc->loc_intr);
}
static void
com_mace_attach(device_t parent, device_t self, void *aux)
{
struct com_mace_softc *msc = device_private(self);
struct com_softc *sc = &msc->sc_com;
struct mace_attach_args *maa = aux;
bus_space_handle_t ioh;
sc->sc_dev = self;
/*
* XXX should check com_is_console() and
* XXX use bus_space_map().
*/
ioh = maa->maa_sh + maa->maa_offset;
/* note that ioh on mac is *also* the iobase address */
COM_INIT_REGS(sc->sc_regs, maa->maa_st, ioh, ioh);
sc->sc_frequency = COM_FREQ;
delay(10000);
com_attach_subr(sc);
delay(10000);
cpu_intr_establish(maa->maa_intr, maa->maa_intrmask, comintr, sc);
return;
}
void
com_obio_attach(device_t parent, device_t self, void *aux)
{
struct obio_attach_args *oba = aux;
struct com_obio_softc *osc = device_private(self);
struct com_softc *sc = &osc->sc_com;
bus_space_handle_t ioh;
int error;
sc->sc_dev = self;
sc->sc_frequency = COM_FREQ;
sc->sc_hwflags = COM_HW_NO_TXPRELOAD;
error = bus_space_map(oba->oba_st, oba->oba_addr, 8, 0, &ioh);
if (error) {
aprint_error(": failed to map registers: %d\n", error);
return;
}
COM_INIT_REGS(sc->sc_regs, oba->oba_st, ioh, oba->oba_addr);
com_attach_subr(sc);
osc->sc_ih = i80321_intr_establish(oba->oba_irq, IPL_SERIAL,
comintr, sc);
if (osc->sc_ih == NULL)
aprint_error_dev(self,
"unable to establish interrupt at irq %d\n", oba->oba_irq);
}
static void
com_acemidi_attach(device_t parent, device_t self, void *aux)
{
struct com_acemidi_softc *sc = device_private(self);
struct com_softc *csc = &sc->sc_com;
struct podulebus_attach_args *pa = aux;
bus_space_handle_t ioh;
bus_space_tag_t iot;
bus_addr_t iobase;
iot = pa->pa_fast_t;
iobase = pa->pa_fast_base + ACEMIDI_16550_BASE;
bus_space_map(iot, iobase, COM_NPORTS, 0, &ioh);
COM_INIT_REGS(csc->sc_regs, iot, ioh, iobase);
csc->sc_frequency = ACEMIDI_16550_FREQ;
com_attach_subr(csc);
evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
device_xname(self), "intr");
podulebus_irq_establish(pa->pa_ih, IPL_SERIAL, comintr, sc,
&sc->sc_intrcnt);
}
void
com_isa_attach(device_t parent, device_t self, void *aux)
{
struct com_isa_softc *isc = device_private(self);
struct com_softc *sc = &isc->sc_com;
int iobase, irq;
bus_space_tag_t iot;
bus_space_handle_t ioh;
struct isa_attach_args *ia = aux;
#ifdef COM_HAYESP
int hayesp_ports[] = { 0x140, 0x180, 0x280, 0x300, 0 };
int *hayespp;
#endif
/*
* We're living on an isa.
*/
iobase = ia->ia_io[0].ir_addr;
iot = ia->ia_iot;
if (!com_is_console(iot, iobase, &ioh) &&
bus_space_map(iot, iobase, COM_NPORTS, 0, &ioh)) {
printf(": can't map i/o space\n");
return;
}
sc->sc_dev = self;
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
sc->sc_frequency = COM_FREQ;
irq = ia->ia_irq[0].ir_irq;
#ifdef COM_HAYESP
for (hayespp = hayesp_ports; *hayespp != 0; hayespp++) {
bus_space_handle_t hayespioh;
#define HAYESP_NPORTS 8
if (bus_space_map(iot, *hayespp, HAYESP_NPORTS, 0, &hayespioh))
continue;
if (com_isa_isHAYESP(hayespioh, sc)) {
break;
}
bus_space_unmap(iot, hayespioh, HAYESP_NPORTS);
}
#endif
com_attach_subr(sc);
if (!pmf_device_register1(self, com_isa_suspend, com_isa_resume,
com_cleanup))
aprint_error_dev(self, "couldn't establish power handler\n");
isc->sc_ic = ia->ia_ic;
isc->sc_irq = irq;
isc->sc_ih = isa_intr_establish_xname(ia->ia_ic, irq, IST_EDGE,
IPL_SERIAL, comintr, sc, device_xname(sc->sc_dev));
}
void
com_gsc_attach(device_t parent, device_t self, void *aux)
{
struct com_gsc_softc *gsc = device_private(self);
struct com_softc *sc = &gsc->sc_com;
struct gsc_attach_args *ga = aux;
int pagezero_cookie;
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
sc->sc_dev = self;
sc->sc_hwflags = 0;
sc->sc_swflags = 0;
iot = ga->ga_iot;
iobase = (bus_addr_t)ga->ga_hpa + COMGSC_OFFSET;
sc->sc_frequency = COMGSC_FREQUENCY;
/* Test if this is the console. Compare either HPA or device path. */
pagezero_cookie = hp700_pagezero_map();
if ((hppa_hpa_t)PAGE0->mem_cons.pz_hpa == ga->ga_hpa ) {
/*
* This port is the console. In this case we must call
* comcnattach() and later com_is_console() to initialize
* everything properly.
*/
if (comcnattach(iot, iobase, B9600,
sc->sc_frequency, COM_TYPE_NORMAL,
(TTYDEF_CFLAG & ~(CSIZE | PARENB)) | CS8) != 0) {
aprint_error(": can't comcnattach\n");
hp700_pagezero_unmap(pagezero_cookie);
return;
}
}
hp700_pagezero_unmap(pagezero_cookie);
/*
* Get the already initialized console ioh via com_is_console() if
* this is the console or map the I/O space if this isn't the console.
*/
if (!com_is_console(iot, iobase, &ioh) &&
bus_space_map(iot, iobase, COM_NPORTS, 0, &ioh) != 0) {
aprint_error(": can't map I/O space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
gsc->sc_ih = hp700_intr_establish(sc->sc_dev, IPL_TTY,
comintr, sc, ga->ga_int_reg, ga->ga_irq);
}
static void
com_upc_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct upc_attach_args *ua = aux;
sc->sc_dev = self;
sc->sc_frequency = COM_FREQ;
COM_INIT_REGS(sc->sc_regs, ua->ua_iot, ua->ua_ioh, ua->ua_offset);
com_attach_subr(sc);
upc_intr_establish(ua->ua_irqhandle, IPL_SERIAL, comintr, sc);
}
void
com_mca_attach(device_t parent, device_t self, void *aux)
{
struct com_mca_softc *isc = device_private(self);
struct com_softc *sc = &isc->sc_com;
int iobase, irq;
struct mca_attach_args *ma = aux;
const struct com_mca_product *cpp;
bus_space_handle_t ioh;
sc->sc_dev = self;
cpp = com_mca_lookup(ma->ma_id);
/* get iobase and irq */
if ((*cpp->cp_getcfg)(ma, &iobase, &irq))
return;
if (bus_space_map(ma->ma_iot, iobase, COM_NPORTS, 0, &ioh)) {
aprint_error(": can't map i/o space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, ma->ma_iot, ioh, iobase);
sc->sc_frequency = COM_FREQ;
aprint_normal(" slot %d i/o %#x-%#x irq %d", ma->ma_slot + 1,
iobase, iobase + COM_NPORTS - 1, irq);
com_attach_subr(sc);
aprint_normal_dev(self, "%s\n", cpp->cp_name);
isc->sc_ih = mca_intr_establish(ma->ma_mc, irq, IPL_SERIAL,
comintr, sc);
if (isc->sc_ih == NULL) {
aprint_error_dev(self,
"couldn't establish interrupt handler\n");
return;
}
/*
* com_cleanup: shutdown hook for buggy BIOSs that don't
* recognize the UART without a disabled FIFO.
* XXX is this necessary on MCA ? --- jdolecek
*/
if (!pmf_device_register1(self, com_suspend, com_resume, com_cleanup))
aprint_error_dev(self, "could not establish shutdown hook\n");
}
static void
awin_com_attach(device_t parent, device_t self, void *aux)
{
cfdata_t cf = device_cfdata(self);
struct awin_com_softc * const asc = device_private(self);
struct com_softc * const sc = &asc->asc_sc;
struct awinio_attach_args * const aio = aux;
const struct awin_locators * const loc = &aio->aio_loc;
bus_space_tag_t iot = aio->aio_core_a4x_bst;
const bus_addr_t iobase = AWIN_CORE_PBASE + loc->loc_offset;
const struct awin_gpio_pinset *pinset;
bus_space_handle_t ioh;
if (awin_chip_id() == AWIN_CHIP_ID_A31) {
pinset = awin_com_pinsets_a31;
} else if (awin_chip_id() == AWIN_CHIP_ID_A80) {
pinset = awin_com_pinsets_a80;
} else {
pinset = loc->loc_port + ((cf->cf_flags & 1) ?
awin_com_alt_pinsets : awin_com_pinsets);
}
awin_com_ports |= __BIT(loc->loc_port);
awin_gpio_pinset_acquire(pinset);
sc->sc_dev = self;
sc->sc_frequency = AWIN_UART_FREQ;
sc->sc_type = COM_TYPE_NORMAL;
if (com_is_console(iot, iobase, &ioh) == 0
&& bus_space_subregion(iot, aio->aio_core_bsh,
loc->loc_offset / 4, loc->loc_size, &ioh)) {
panic(": can't map registers");
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
aprint_naive("\n");
KASSERT(loc->loc_intr != AWINIO_INTR_DEFAULT);
asc->asc_ih = intr_establish(loc->loc_intr, IPL_SERIAL,
IST_EDGE | IST_MPSAFE, comintr, sc);
if (asc->asc_ih == NULL)
panic("%s: failed to establish interrupt %d",
device_xname(self), loc->loc_intr);
}
void
com_pnpbios_attach(device_t parent, device_t self, void *aux)
{
struct com_pnpbios_softc *psc = device_private(self);
struct com_softc *sc = &psc->sc_com;
struct pnpbiosdev_attach_args *aa = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
int iobase;
sc->sc_dev = self;
if (pnpbios_getiobase(aa->pbt, aa->resc, 0, &iot, &iobase)) {
aprint_error(": can't get iobase\n");
return;
}
if ((!com_is_console(iot, iobase, &ioh)) &&
pnpbios_io_map(aa->pbt, aa->resc, 0, &iot, &ioh)) {
aprint_error(": can't map i/o space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
aprint_normal("\n");
pnpbios_print_devres(self, aa);
aprint_normal("%s", device_xname(self));
/*
* if the chip isn't something we recognise skip it.
*/
if (com_probe_subr(&sc->sc_regs) == 0) {
aprint_error(": com probe failed\n");
return;
}
sc->sc_frequency = 115200 * 16;
com_attach_subr(sc);
psc->sc_ih = pnpbios_intr_establish(aa->pbt, aa->resc, 0, IPL_SERIAL,
comintr, sc);
}
void
com_ssio_attach(device_t parent, device_t self, void *aux)
{
struct com_ssio_softc *sc_ssio = device_private(self);
struct com_softc *sc = &sc_ssio->sc_com;
struct ssio_attach_args *saa = aux;
int pagezero_cookie;
bus_addr_t iobase;
bus_space_handle_t ioh;
bus_space_tag_t iot;
sc->sc_dev = self;
iobase = saa->saa_iobase;
iot = saa->saa_iot;
if (bus_space_map(iot, iobase, COM_NPORTS,
0, &ioh)) {
aprint_error(": can't map I/O space\n");
return;
}
/* Test if this is the console. */
pagezero_cookie = hp700_pagezero_map();
if (PAGE0->mem_cons.pz_class == PCL_DUPLEX &&
PAGE0->mem_cons.pz_hpa == (struct iomod *)ioh) {
bus_space_unmap(iot, ioh, COM_NPORTS);
if (comcnattach(iot, iobase, B9600, COM_SSIO_FREQ,
COM_TYPE_NORMAL,
(TTYDEF_CFLAG & ~(CSIZE | PARENB)) | CS8) != 0) {
aprint_error(": can't comcnattach\n");
hp700_pagezero_unmap(pagezero_cookie);
return;
}
}
hp700_pagezero_unmap(pagezero_cookie);
sc->sc_frequency = COM_SSIO_FREQ;
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
sc_ssio->sc_ih = ssio_intr_establish(IPL_TTY, saa->saa_irq,
comintr, sc, device_xname(self));
}
void
com_multi_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct commulti_attach_args *ca = aux;
sc->sc_dev = self;
/*
* We're living on a commulti.
*/
COM_INIT_REGS(sc->sc_regs, ca->ca_iot, ca->ca_ioh, ca->ca_iobase);
sc->sc_frequency = 115200 * 16;
if (ca->ca_noien)
sc->sc_hwflags |= COM_HW_NOIEN;
com_attach_subr(sc);
}
static void
com_ebus_attach(device_t parent, device_t self, void *aux)
{
struct com_ebus_softc *ebsc = device_private(self);
struct com_softc *sc = &ebsc->ebsc_com;
struct ebus_attach_args *ea = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
sc->sc_dev = self;
iot = ea->ea_bustag;
iobase = EBUS_ADDR_FROM_REG(&ea->ea_reg[0]);
sc->sc_frequency = COM_FREQ;
sc->sc_hwflags = COM_HW_NO_TXPRELOAD;
/*
* XXX: It would be nice to be able to split console input and
* output to different devices. For now switch to serial
* console if PROM stdin is on serial (so that we can use DDB).
*/
if (prom_instance_to_package(prom_stdin()) == ea->ea_node)
comcnattach(iot, iobase, B9600, sc->sc_frequency,
COM_TYPE_NORMAL, (CLOCAL | CREAD | CS8));
if (!com_is_console(iot, iobase, &ioh)
&& bus_space_map(iot, iobase, ea->ea_reg[0].size,
0, &ioh) != 0)
{
aprint_error(": unable to map device registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
if (ea->ea_nintr != 0)
(void)bus_intr_establish(iot, ea->ea_intr[0], IPL_SERIAL,
comintr, sc);
}
void
com_elb_attach(device_t parent, device_t self, void *aux)
{
struct com_elb_softc *msc = device_private(self);
struct com_softc *sc = &msc->sc_com;
struct elb_attach_args *eaa = aux;
bus_space_handle_t ioh;
sc->sc_dev = self;
bus_space_map(eaa->elb_bt,
_BUS_SPACE_UNSTRIDE(eaa->elb_bt, eaa->elb_base),
COM_NPORTS, 0, &ioh);
COM_INIT_REGS(sc->sc_regs, eaa->elb_bt, ioh,
_BUS_SPACE_UNSTRIDE(eaa->elb_bt, eaa->elb_base));
sc->sc_frequency = COM_FREQ;
com_attach_subr(sc);
intr_establish(eaa->elb_irq, IST_LEVEL, IPL_SERIAL, comintr, sc);
}
void
com_mainbus_attach(device_t parent, device_t self, void *aux)
{
struct com_mainbus_softc *msc = device_private(self);
struct com_softc *sc = &msc->sc_com;
int serial, interrupt_length;
int interrupts[8];
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
sc->sc_dev = self;
serial = OF_finddevice("/ht@0/isa@4/serial@0x3f8");
if (serial != -1) {
interrupt_length =
OF_getprop(serial, "interrupts", interrupts, sizeof(interrupts));
}
iot = (bus_space_tag_t)0xf4000000;
iobase = 0x3f8;
comcnattach(iot, iobase, 9600, 1843200, COM_TYPE_NORMAL, (CREAD | CS8));
bus_space_map(iot, iobase, COM_NPORTS, 0, &ioh);
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
sc->sc_frequency = 1843200;
com_attach_subr(sc);
#if 1
msc->sc_ih =
intr_establish(interrupts[0], IST_LEVEL, IPL_SERIAL, comintr, sc);
if (msc->sc_ih == NULL)
panic("failed to establish int handler");
#endif
}
void
com_sableio_attach(device_t parent, device_t self, void *aux)
{
struct com_sableio_softc *ssc = device_private(self);
struct com_softc *sc = &ssc->sc_com;
struct sableio_attach_args *sa = aux;
const char *intrstr;
bus_space_handle_t ioh;
sc->sc_dev = self;
if (com_is_console(sa->sa_iot, sa->sa_ioaddr, &ioh) == 0 &&
bus_space_map(sa->sa_iot, sa->sa_ioaddr, COM_NPORTS, 0,
&ioh) != 0) {
aprint_error(": can't map i/o space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, sa->sa_iot, ioh, sa->sa_ioaddr);
sc->sc_frequency = COM_FREQ;
com_attach_subr(sc);
intrstr = pci_intr_string(sa->sa_pc, sa->sa_sableirq[0]);
ssc->sc_ih = pci_intr_establish(sa->sa_pc, sa->sa_sableirq[0],
IPL_SERIAL, comintr, sc);
if (ssc->sc_ih == NULL) {
aprint_error_dev(self, "unable to establish interrupt");
if (intrstr != NULL)
aprint_normal(" at %s", intrstr);
aprint_normal("\n");
return;
}
aprint_normal_dev(self, "interrupting at %s\n", intrstr);
if (!pmf_device_register1(self, com_suspend, com_resume, com_cleanup)) {
aprint_error_dev(self, "could not establish shutdown hook");
}
}
void
com_mainbus_attach(device_t parent, device_t self, void *aux)
{
struct com_mainbus_softc *msc = device_private(self);
struct com_softc *sc = &msc->sc_com;
struct mainbus_attach_args *maa = aux;
bus_space_handle_t ioh;
sc->sc_dev = self;
if (!com_is_console(maa->ma_iot, maa->ma_addr, &ioh) &&
bus_space_map(maa->ma_iot, maa->ma_addr, COM_NPORTS, 0, &ioh)) {
aprint_error(": can't map i/o space\n");
return;
}
COM_INIT_REGS(sc->sc_regs, maa->ma_iot, ioh, maa->ma_addr);
sc->sc_frequency = COM_MAINBUS_FREQ;
com_attach_subr(sc);
cpu_intr_establish(maa->ma_level, IPL_SERIAL, comintr, sc);
return;
}
void
hd64465uart_attach(device_t parent, device_t self, void *aux)
{
struct hd64465_attach_args *ha = aux;
struct hd64465uart_softc *sc = device_private(self);
struct com_softc *csc = &sc->sc_com;
bus_space_handle_t ioh;
csc->sc_dev = self;
sc->sc_chip = &hd64465uart_chip;
sc->sc_module_id = ha->ha_module_id;
if (!sc->sc_chip->console)
hd64465uart_init();
bus_space_map(sc->sc_chip->io_tag, 0, 8, 0, &ioh);
COM_INIT_REGS(csc->sc_regs, sc->sc_chip->io_tag, ioh, 0);
csc->sc_frequency = COM_FREQ;
/* supply clock XXX notyet */
/* sanity check */
if (!com_probe_subr(&csc->sc_regs)) {
aprint_error(": device problem. don't attach.\n");
/* stop clock XXX notyet */
return;
}
com_attach_subr(csc);
/* register interrupt handler */
hd64465_intr_establish(HD64465_UART, IST_LEVEL, IPL_TTY,
comintr, self);
}
void
com_arbus_attach(device_t parent, device_t self, void *aux)
{
struct com_arbus_softc *arsc = device_private(self);
struct com_softc *sc = &arsc->sc_com;
struct arbus_attach_args *aa = aux;
prop_number_t prop;
bus_space_handle_t ioh;
sc->sc_dev = self;
prop = prop_dictionary_get(device_properties(sc->sc_dev),
"frequency");
if (prop == NULL) {
aprint_error(": unable to get frequency property\n");
return;
}
KASSERT(prop_object_type(prop) == PROP_TYPE_NUMBER);
sc->sc_frequency = (int)prop_number_integer_value(prop);
if (!com_is_console(aa->aa_bst, aa->aa_addr, &ioh)
&& bus_space_map(aa->aa_bst, aa->aa_addr, aa->aa_size, 0,
&ioh) != 0) {
aprint_error(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, aa->aa_bst, ioh, aa->aa_addr);
sc->sc_regs.cr_nports = aa->aa_size;
com_arbus_initmap(&sc->sc_regs);
com_attach_subr(sc);
arbus_intr_establish(aa->aa_cirq, aa->aa_mirq, comintr, sc);
}
static void
com_obio_attach(device_t parent, device_t self, void *aux)
{
struct com_obio_softc *osc = device_private(self);
struct com_softc *sc = &osc->osc_com;
union obio_attach_args *uoba = aux;
struct sbus_attach_args *sa = &uoba->uoba_sbus;
bus_space_handle_t ioh;
bus_space_tag_t iot;
bus_addr_t iobase;
sc->sc_dev = self;
if (strcmp("modem", sa->sa_name) == 0) {
osc->osc_tadpole = 1;
}
/*
* We're living on an obio that looks like an sbus slot.
*/
iot = sa->sa_bustag;
iobase = sa->sa_offset;
sc->sc_frequency = COM_FREQ;
/*
* XXX: It would be nice to be able to split console input and
* output to different devices. For now switch to serial
* console if PROM stdin is on serial (so that we can use DDB).
*/
if (prom_instance_to_package(prom_stdin()) == sa->sa_node)
comcnattach(iot, iobase, B9600, sc->sc_frequency,
COM_TYPE_NORMAL, (CLOCAL | CREAD | CS8));
if (!com_is_console(iot, iobase, &ioh) &&
sbus_bus_map(iot, sa->sa_slot, iobase, sa->sa_size,
BUS_SPACE_MAP_LINEAR, &ioh) != 0) {
aprint_error(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
if (osc->osc_tadpole) {
*AUXIO4M_REG |= (AUXIO4M_LED|AUXIO4M_LTE);
do {
DELAY(100);
} while (!com_probe_subr(&sc->sc_regs));
#if 0
printf("modem: attach: lcr=0x%02x iir=0x%02x\n",
bus_space_read_1(sc->sc_regs.iot, sc->sc_regs.ioh, 3),
bus_space_read_1(sc->sc_regs.iot, sc->sc_regs.ioh, 2));
#endif
}
com_attach_subr(sc);
if (sa->sa_nintr != 0) {
(void)bus_intr_establish(sc->sc_regs.cr_iot, sa->sa_pri,
IPL_SERIAL, comintr, sc);
evcnt_attach_dynamic(&osc->osc_intrcnt, EVCNT_TYPE_INTR, NULL,
device_xname(self), "intr");
}
if (!pmf_device_register1(self, com_suspend, com_resume, com_cleanup)) {
aprint_error_dev(self, "could not establish shutdown hook");
}
}
