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"); } }