void
bppattach(device_t parent, device_t self, void *aux)
{
struct bpp_softc *dsc = device_private(self);
struct lsi64854_softc *sc = &dsc->sc_lsi64854;
struct sbus_softc *sbsc = device_private(parent);
struct sbus_attach_args *sa = aux;
int burst, sbusburst;
int node;
sc->sc_dev = self;
selinit(&dsc->sc_rsel);
selinit(&dsc->sc_wsel);
dsc->sc_sih = softint_establish(SOFTINT_CLOCK, bppsoftintr, dsc);
sc->sc_bustag = sa->sa_bustag;
sc->sc_dmatag = sa->sa_dmatag;
node = sa->sa_node;
/* Map device registers */
if (sbus_bus_map(sa->sa_bustag,
sa->sa_slot, sa->sa_offset, sa->sa_size,
0, &sc->sc_regs) != 0) {
aprint_error(": cannot map registers\n");
return;
}
/*
* Get transfer burst size from PROM and plug it into the
* controller registers. This is needed on the Sun4m; do
* others need it too?
*/
sbusburst = sbsc->sc_burst;
if (sbusburst == 0)
sbusburst = SBUS_BURST_32 - 1; /* 1->16 */
burst = prom_getpropint(node, "burst-sizes", -1);
if (burst == -1)
/* take SBus burst sizes */
burst = sbusburst;
/* Clamp at parent's burst sizes */
burst &= sbusburst;
sc->sc_burst = (burst & SBUS_BURST_32) ? 32 :
(burst & SBUS_BURST_16) ? 16 : 0;
/* Join the Sbus device family */
dsc->sc_sd.sd_reset = NULL;
sbus_establish(&dsc->sc_sd, self);
/* Initialize the DMA channel */
sc->sc_channel = L64854_CHANNEL_PP;
lsi64854_attach(sc);
/* Establish interrupt handler */
if (sa->sa_nintr) {
sc->sc_intrchain = bppintr;
sc->sc_intrchainarg = dsc;
(void)bus_intr_establish(sa->sa_bustag, sa->sa_pri, IPL_TTY,
bppintr, sc);
}
/* Allocate buffer XXX - should actually use dmamap_uio() */
dsc->sc_bufsz = 1024;
dsc->sc_buf = malloc(dsc->sc_bufsz, M_DEVBUF, M_NOWAIT);
/* XXX read default state */
{
bus_space_handle_t h = sc->sc_regs;
struct hwstate *hw = &dsc->sc_hwdefault;
int ack_rate = sa->sa_frequency / 1000000;
hw->hw_hcr = bus_space_read_2(sc->sc_bustag, h, L64854_REG_HCR);
hw->hw_ocr = bus_space_read_2(sc->sc_bustag, h, L64854_REG_OCR);
hw->hw_tcr = bus_space_read_1(sc->sc_bustag, h, L64854_REG_TCR);
hw->hw_or = bus_space_read_1(sc->sc_bustag, h, L64854_REG_OR);
DPRINTF(("bpp: hcr %x ocr %x tcr %x or %x\n",
hw->hw_hcr, hw->hw_ocr, hw->hw_tcr, hw->hw_or));
/* Set these to sane values */
hw->hw_hcr = ((ack_rate<<BPP_HCR_DSS_SHFT)&BPP_HCR_DSS_MASK)
| ((ack_rate<<BPP_HCR_DSW_SHFT)&BPP_HCR_DSW_MASK);
hw->hw_ocr |= BPP_OCR_ACK_OP;
}
}
void
leattach_ledma(device_t parent, device_t self, void *aux)
{
struct le_softc *lesc = device_private(self);
struct lance_softc *sc = &lesc->sc_am7990.lsc;
struct lsi64854_softc *lsi = device_private(parent);
struct sbus_attach_args *sa = aux;
bus_dma_tag_t dmatag = sa->sa_dmatag;
bus_dma_segment_t seg;
int rseg, error;
sc->sc_dev = self;
lesc->sc_bustag = sa->sa_bustag;
/* Establish link to `ledma' device */
lesc->sc_dma = lsi;
lesc->sc_dma->sc_client = lesc;
/* Map device registers */
if (sbus_bus_map(sa->sa_bustag,
sa->sa_slot,
sa->sa_offset,
sa->sa_size,
0, &lesc->sc_reg) != 0) {
aprint_error(": cannot map registers\n");
return;
}
/* Allocate buffer memory */
sc->sc_memsize = MEMSIZE;
/* Get a DMA handle */
if ((error = bus_dmamap_create(dmatag, MEMSIZE, 1, MEMSIZE,
LEDMA_BOUNDARY, BUS_DMA_NOWAIT,
&lesc->sc_dmamap)) != 0) {
aprint_error(": DMA map create error %d\n", error);
return;
}
/* Allocate DMA buffer */
if ((error = bus_dmamem_alloc(dmatag, MEMSIZE, 0, LEDMA_BOUNDARY,
&seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
aprint_error(": DMA buffer alloc error %d\n",error);
return;
}
/* Map DMA buffer into kernel space */
if ((error = bus_dmamem_map(dmatag, &seg, rseg, MEMSIZE,
(void **)&sc->sc_mem,
BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) {
aprint_error(": DMA buffer map error %d\n", error);
bus_dmamem_free(dmatag, &seg, rseg);
return;
}
/* Load DMA buffer */
if ((error = bus_dmamap_load(dmatag, lesc->sc_dmamap, sc->sc_mem,
MEMSIZE, NULL, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) {
aprint_error(": DMA buffer map load error %d\n", error);
bus_dmamem_free(dmatag, &seg, rseg);
bus_dmamem_unmap(dmatag, sc->sc_mem, MEMSIZE);
return;
}
lesc->sc_laddr = lesc->sc_dmamap->dm_segs[0].ds_addr;
sc->sc_addr = lesc->sc_laddr & 0xffffff;
sc->sc_conf3 = LE_C3_BSWP | LE_C3_ACON | LE_C3_BCON;
/* Assume SBus is grandparent */
lesc->sc_sd.sd_reset = (void *)lance_reset;
sbus_establish(&lesc->sc_sd, parent);
sc->sc_mediachange = lemediachange;
sc->sc_mediastatus = lemediastatus;
sc->sc_supmedia = lemedia;
sc->sc_nsupmedia = NLEMEDIA;
sc->sc_defaultmedia = IFM_ETHER|IFM_AUTO;
prom_getether(sa->sa_node, sc->sc_enaddr);
sc->sc_copytodesc = lance_copytobuf_contig;
sc->sc_copyfromdesc = lance_copyfrombuf_contig;
sc->sc_copytobuf = lance_copytobuf_contig;
sc->sc_copyfrombuf = lance_copyfrombuf_contig;
sc->sc_zerobuf = lance_zerobuf_contig;
sc->sc_rdcsr = lerdcsr;
sc->sc_wrcsr = lewrcsr;
sc->sc_hwinit = lehwinit;
sc->sc_nocarrier = lenocarrier;
sc->sc_hwreset = lehwreset;
/* Establish interrupt handler */
if (sa->sa_nintr != 0)
(void)bus_intr_establish(sa->sa_bustag, sa->sa_pri, IPL_NET,
am7990_intr, sc);
am7990_config(&lesc->sc_am7990);
/* now initialize DMA */
lehwreset(sc);
}
/*
* Attach a display. We need to notice if it is the console, too.
*/
static void
p9100_sbus_attach(struct device *parent, struct device *self, void *args)
{
struct p9100_softc *sc = device_private(self);
struct sbus_attach_args *sa = args;
struct fbdevice *fb = &sc->sc_fb;
int isconsole;
int node;
int i, j;
uint8_t ver;
#if NWSDISPLAY > 0
struct wsemuldisplaydev_attach_args aa;
struct rasops_info *ri;
unsigned long defattr;
#endif
sc->sc_last_offset = 0xffffffff;
/* Remember cookies for p9100_mmap() */
sc->sc_bustag = sa->sa_bustag;
sc->sc_ctl_paddr = sbus_bus_addr(sa->sa_bustag,
sa->sa_reg[0].oa_space, sa->sa_reg[0].oa_base);
sc->sc_ctl_psize = 0x8000;/*(bus_size_t)sa->sa_reg[0].oa_size;*/
sc->sc_cmd_paddr = sbus_bus_addr(sa->sa_bustag,
sa->sa_reg[1].oa_space, sa->sa_reg[1].oa_base);
sc->sc_cmd_psize = (bus_size_t)sa->sa_reg[1].oa_size;
sc->sc_fb_paddr = sbus_bus_addr(sa->sa_bustag,
sa->sa_reg[2].oa_space, sa->sa_reg[2].oa_base);
sc->sc_fb_psize = (bus_size_t)sa->sa_reg[2].oa_size;
fb->fb_driver = &p9100fbdriver;
fb->fb_device = &sc->sc_dev;
fb->fb_flags = device_cfdata(&sc->sc_dev)->cf_flags & FB_USERMASK;
#ifdef PNOZZ_EMUL_CG3
fb->fb_type.fb_type = FBTYPE_SUN3COLOR;
#else
fb->fb_type.fb_type = FBTYPE_P9100;
#endif
fb->fb_pixels = NULL;
sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
node = sa->sa_node;
isconsole = fb_is_console(node);
if (!isconsole) {
aprint_normal("\n");
aprint_error_dev(self, "fatal error: PROM didn't configure device\n");
return;
}
/*
* When the ROM has mapped in a p9100 display, the address
* maps only the video RAM, so in any case we have to map the
* registers ourselves. We only need the video RAM if we are
* going to print characters via rconsole.
*/
if (sbus_bus_map(sc->sc_bustag,
sa->sa_reg[0].oa_space,
sa->sa_reg[0].oa_base,
/*
* XXX for some reason the SBus resources don't cover
* all registers, so we just map what we need
*/
/*sc->sc_ctl_psize*/ 0x8000,
/*BUS_SPACE_MAP_LINEAR*/0, &sc->sc_ctl_memh) != 0) {
aprint_error_dev(self, "cannot map control registers\n");
return;
}
if (sa->sa_npromvaddrs != 0)
fb->fb_pixels = (void *)sa->sa_promvaddrs[0];
if (fb->fb_pixels == NULL) {
if (sbus_bus_map(sc->sc_bustag,
sa->sa_reg[2].oa_space,
sa->sa_reg[2].oa_base,
sc->sc_fb_psize,
BUS_SPACE_MAP_LINEAR, &sc->sc_fb_memh) != 0) {
aprint_error_dev(self, "cannot map framebuffer\n");
return;
}
fb->fb_pixels = (char *)sc->sc_fb_memh;
} else {
sc->sc_fb_memh = (bus_space_handle_t) fb->fb_pixels;
}
i = p9100_ctl_read_4(sc, 0x0004);
switch ((i >> 26) & 7) {
case 5: fb->fb_type.fb_depth = 32; break;
case 7: fb->fb_type.fb_depth = 24; break;
case 3: fb->fb_type.fb_depth = 16; break;
case 2: fb->fb_type.fb_depth = 8; break;
default: {
panic("pnozz: can't determine screen depth (0x%02x)", i);
}
}
sc->sc_depth = (fb->fb_type.fb_depth >> 3);
/* XXX for some reason I get a kernel trap with this */
sc->sc_width = prom_getpropint(node, "width", 800);
sc->sc_height = prom_getpropint(node, "height", 600);
sc->sc_stride = prom_getpropint(node, "linebytes", sc->sc_width *
(fb->fb_type.fb_depth >> 3));
/* check the RAMDAC */
ver = p9100_ramdac_read_ctl(sc, DAC_VERSION);
p9100_init_engine(sc);
fb_setsize_obp(fb, fb->fb_type.fb_depth, sc->sc_width, sc->sc_height,
node);
sbus_establish(&sc->sc_sd, &sc->sc_dev);
bus_intr_establish(sc->sc_bustag, sa->sa_pri, IPL_BIO,
p9100_intr, sc);
fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes;
printf(": rev %d / %x, %dx%d, depth %d mem %x",
(i & 7), ver, fb->fb_type.fb_width, fb->fb_type.fb_height,
fb->fb_type.fb_depth, (unsigned int)sc->sc_fb_psize);
fb->fb_type.fb_cmsize = prom_getpropint(node, "cmsize", 256);
if ((1 << fb->fb_type.fb_depth) != fb->fb_type.fb_cmsize)
printf(", %d entry colormap", fb->fb_type.fb_cmsize);
/* Initialize the default color map. */
/*bt_initcmap(&sc->sc_cmap, 256);*/
j = 0;
for (i = 0; i < 256; i++) {
sc->sc_cmap.cm_map[i][0] = rasops_cmap[j];
j++;
sc->sc_cmap.cm_map[i][1] = rasops_cmap[j];
j++;
sc->sc_cmap.cm_map[i][2] = rasops_cmap[j];
j++;
}
p9100loadcmap(sc, 0, 256);
/* make sure we are not blanked */
if (isconsole)
p9100_set_video(sc, 1);
if (shutdownhook_establish(p9100_shutdown, sc) == NULL) {
panic("%s: could not establish shutdown hook",
device_xname(&sc->sc_dev));
}
if (isconsole) {
printf(" (console)\n");
#ifdef RASTERCONSOLE
/*p9100loadcmap(sc, 255, 1);*/
fbrcons_init(fb);
#endif
} else
printf("\n");
#if NWSDISPLAY > 0
wsfont_init();
vcons_init(&sc->vd, sc, &p9100_defscreendesc, &p9100_accessops);
sc->vd.init_screen = p9100_init_screen;
vcons_init_screen(&sc->vd, &p9100_console_screen, 1, &defattr);
p9100_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;
sc->sc_bg = (defattr >> 16) & 0xff;
p9100_clearscreen(sc);
ri = &p9100_console_screen.scr_ri;
p9100_defscreendesc.nrows = ri->ri_rows;
p9100_defscreendesc.ncols = ri->ri_cols;
p9100_defscreendesc.textops = &ri->ri_ops;
p9100_defscreendesc.capabilities = ri->ri_caps;
if(isconsole) {
wsdisplay_cnattach(&p9100_defscreendesc, ri, 0, 0, defattr);
}
aa.console = isconsole;
aa.scrdata = &p9100_screenlist;
aa.accessops = &p9100_accessops;
aa.accesscookie = &sc->vd;
config_found(self, &aa, wsemuldisplaydevprint);
#endif
/* cursor sprite handling */
p9100_init_cursor(sc);
/* attach the fb */
fb_attach(fb, isconsole);
/* register with power management */
sc->sc_video = 1;
sc->sc_powerstate = PWR_RESUME;
powerhook_establish(device_xname(&sc->sc_dev), p9100_power_hook, sc);
#if NTCTRL > 0
/* register callback for external monitor status change */
tadpole_register_callback(p9100_set_extvga, sc);
#endif
}
void
presto_attach(struct device *parent, struct device *self, void *args)
{
struct presto_softc *sc = (struct presto_softc *)self;
struct confargs *ca = args;
char *model, *submodel;
u_int8_t status;
/* Get card parameters */
model = getpropstring(ca->ca_ra.ra_node, "model");
if (*model == '\0')
submodel = "fictitious";
else {
submodel = memchr(model, ',', strlen(model));
if (submodel != NULL)
submodel++;
else
submodel = model;
}
strncpy(sc->sc_model, submodel, 16);
sc->sc_memsize = ca->ca_ra.ra_len;
printf(": %s\n%s: %d MB NVRAM, ", model,
sc->sc_dev.dv_xname, sc->sc_memsize >> 20);
/* Map memory */
sc->sc_mem = (void *)mapiodev(ca->ca_ra.ra_reg, 0, sc->sc_memsize);
/*
* Clear the ``disconnect battery'' bit.
*/
*(u_int8_t *)(sc->sc_mem + PSERVE_BATTERYSTATUS) = 0x00;
/*
* Clear the ``unflushed data'' status. This way, if the card is
* reused under SunOS, the system will not try to flush whatever
* data the user put in the nvram...
*/
*(u_int8_t *)(sc->sc_mem + PSERVE_DATASTATUS) = 0x00;
/*
* Decode battery status
*/
status = *(u_int8_t *)(sc->sc_mem + PSERVE_BATTERYSTATUS);
printf("battery status %x ", status);
if (ISSET(status, PSBAT_FAULT)) {
printf("(non-working)");
} else if (ISSET(status, PSBAT_CONNECTED)) {
if (ISSET(status, PSBAT_CHARGING))
printf("(charging)");
else
printf("(ok)");
} else
printf("(disabled)");
printf("\n");
#ifdef DEBUG
printf("%s: status codes %02.2x, %02.2x, %02.2x, %02.2x\n",
sc->sc_dev.dv_xname,
*(u_int8_t *)(sc->sc_mem + 0x03), *(u_int8_t *)(sc->sc_mem + 0x07),
*(u_int8_t *)(sc->sc_mem + 0x0b), *(u_int8_t *)(sc->sc_mem + 0x0f));
#endif
sbus_establish(&sc->sc_sd, &sc->sc_dev);
sc->sc_dk.dk_driver = &presto_dk;
sc->sc_dk.dk_name = sc->sc_dev.dv_xname;
disk_attach(&sc->sc_dk);
/* read the disk label immediately */
presto_getdisklabel(sc);
}
void
agtenattach(struct device *parent, struct device *self, void *args)
{
struct agten_softc *sc = (struct agten_softc *)self;
struct confargs *ca = args;
struct wsemuldisplaydev_attach_args waa;
int node, isconsole;
char *nam;
sc->sc_sunfb.sf_flags = self->dv_cfdata->cf_flags;
node = ca->ca_ra.ra_node;
nam = getpropstring(node, "model");
printf(": model %s", nam);
isconsole = node == fbnode;
sc->sc_phys = ca->ca_ra.ra_reg[0];
/*
* Map the various beasts of this card we are interested in.
*/
sc->sc_physoffset =
(off_t)getpropint(node, "i128_fb_physaddr", 0x8000000);
sc->sc_i128_fb = mapiodev(ca->ca_ra.ra_reg, sc->sc_physoffset,
getpropint(node, "i128_fb_size", 0x400000));
sc->sc_dac = mapiodev(ca->ca_ra.ra_reg,
getpropint(node, "p9100_reg_physaddr", 0x10a0000) + 0x200,
0x800 - 0x200);
/*
* For some reason the agten does not use the canonical name for
* properties, but uses an ffb_ prefix; and the linebytes property is
* missing.
* The following is a specific version of
* fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, BUS_SBUS);
* using the correct property names.
*/
#ifdef notyet
sc->sc_sunfb.sf_depth = 32;
#else
sc->sc_sunfb.sf_depth = getpropint(node, "ffb_depth", 8);
#endif
sc->sc_sunfb.sf_width = getpropint(node, "ffb_width", 1152);
sc->sc_sunfb.sf_height = getpropint(node, "ffb_height", 900);
sc->sc_sunfb.sf_linebytes =
roundup(sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_depth) *
sc->sc_sunfb.sf_depth / 8;
sc->sc_sunfb.sf_fbsize =
sc->sc_sunfb.sf_height * sc->sc_sunfb.sf_linebytes;
printf(", %dx%d, depth %d\n",
sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height,
sc->sc_sunfb.sf_depth);
sc->sc_sunfb.sf_ro.ri_bits = (void *)sc->sc_i128_fb;
sc->sc_sunfb.sf_ro.ri_hw = sc;
fbwscons_init(&sc->sc_sunfb, isconsole);
fbwscons_setcolormap(&sc->sc_sunfb, agten_setcolor);
agten_stdscreen.capabilities = sc->sc_sunfb.sf_ro.ri_caps;
agten_stdscreen.nrows = sc->sc_sunfb.sf_ro.ri_rows;
agten_stdscreen.ncols = sc->sc_sunfb.sf_ro.ri_cols;
agten_stdscreen.textops = &sc->sc_sunfb.sf_ro.ri_ops;
if (isconsole) {
fbwscons_console_init(&sc->sc_sunfb, &agten_stdscreen, -1,
NULL);
}
sbus_establish(&sc->sc_sd, &sc->sc_sunfb.sf_dev);
waa.console = isconsole;
waa.scrdata = &agten_screenlist;
waa.accessops = &agten_accessops;
waa.accesscookie = sc;
config_found(self, &waa, wsemuldisplaydevprint);
}
void
dmaattach_sbus(device_t parent, device_t self, void *aux)
{
struct dma_softc *dsc = device_private(self);
struct lsi64854_softc *sc = &dsc->sc_lsi64854;
struct sbus_attach_args *sa = aux;
struct sbus_softc *sbsc = device_private(parent);
bus_space_tag_t sbt;
int sbusburst, burst;
int node;
node = sa->sa_node;
sc->sc_dev = self;
sc->sc_bustag = sa->sa_bustag;
sc->sc_dmatag = sa->sa_dmatag;
/* Map registers */
if (sa->sa_npromvaddrs) {
sbus_promaddr_to_handle(sa->sa_bustag,
sa->sa_promvaddrs[0], &sc->sc_regs);
} else {
if (sbus_bus_map(sa->sa_bustag,
sa->sa_slot, sa->sa_offset, sa->sa_size,
0, &sc->sc_regs) != 0) {
aprint_error(": cannot map registers\n");
return;
}
}
/*
* Get transfer burst size from PROM and plug it into the
* controller registers. This is needed on the Sun4m; do
* others need it too?
*/
sbusburst = sbsc->sc_burst;
if (sbusburst == 0)
sbusburst = SBUS_BURST_32 - 1; /* 1->16 */
burst = prom_getpropint(node,"burst-sizes", -1);
if (burst == -1)
/* take SBus burst sizes */
burst = sbusburst;
/* Clamp at parent's burst sizes */
burst &= sbusburst;
sc->sc_burst = (burst & SBUS_BURST_32) ? 32 :
(burst & SBUS_BURST_16) ? 16 : 0;
if (device_is_a(self, "ledma")) {
char *cabletype;
uint32_t csr;
/*
* Check to see which cable type is currently active and
* set the appropriate bit in the ledma csr so that it
* gets used. If we didn't netboot, the PROM won't have
* the "cable-selection" property; default to TP and then
* the user can change it via a "media" option to ifconfig.
*/
cabletype = prom_getpropstring(node, "cable-selection");
csr = L64854_GCSR(sc);
if (strcmp(cabletype, "tpe") == 0) {
csr |= E_TP_AUI;
} else if (strcmp(cabletype, "aui") == 0) {
csr &= ~E_TP_AUI;
} else {
/* assume TP if nothing there */
csr |= E_TP_AUI;
}
L64854_SCSR(sc, csr);
delay(20000); /* manual says we need a 20ms delay */
sc->sc_channel = L64854_CHANNEL_ENET;
} else {
sc->sc_channel = L64854_CHANNEL_SCSI;
}
sbus_establish(&dsc->sc_sd, self);
if ((sbt = bus_space_tag_alloc(sc->sc_bustag, dsc)) == NULL) {
aprint_error(": out of memory\n");
return;
}
sbt->sparc_intr_establish = dmabus_intr_establish;
lsi64854_attach(sc);
/* Attach children */
for (node = firstchild(sa->sa_node); node; node = nextsibling(node)) {
struct sbus_attach_args sax;
sbus_setup_attach_args(sbsc, sbt, sc->sc_dmatag, node, &sax);
(void)config_found(self, (void *)&sax, dmaprint_sbus);
sbus_destroy_attach_args(&sax);
}
}
