diff options
Diffstat (limited to 'sys/arch')
54 files changed, 5805 insertions, 0 deletions
diff --git a/sys/arch/socppc/conf/GENERIC b/sys/arch/socppc/conf/GENERIC new file mode 100644 index 00000000000..5021ce57449 --- /dev/null +++ b/sys/arch/socppc/conf/GENERIC @@ -0,0 +1,63 @@ +# $OpenBSD: GENERIC,v 1.1 2008/05/10 12:02:20 kettenis Exp $g +# +# For further information on compiling OpenBSD kernels, see the config(8) +# man page. +# +# For further information on hardware support for this architecture, see +# the intro(4) man page. For further information about kernel options +# for this architecture, see the options(4) man page. For an explanation +# of each device driver in this file see the section 4 man page for the +# device. + +machine socppc powerpc +include "../../../conf/GENERIC" +maxusers 32 # estimated number of users + +option USB_DEBUG +option PCIVERBOSE +option USBVERBOSE + +option USER_PCICONF # user-space PCI configuration +option APERTURE + +config bsd swap generic + +mainbus0 at root +cpu0 at mainbus0 +obio0 at mainbus0 + +# On-board IPIC +ipic0 at obio? addr 0x00700 + +# On-board I2C +sociic0 at obio? addr 0x03000 ivec 14 +sociic1 at obio? addr 0x03100 ivec 15 +iic* at sociic? +ricohrtc0 at iic? addr 0x32 # Ricoh RTC +fintek0 at iic? flags 0x0001 # temp/fan controller + +# On-board DUART +com0 at obio? addr 0x04500 ivec 9 +com1 at obio? addr 0x04600 ivec 10 + +# On-board PCI +socpcic0 at obio? addr 0x08300 +socpcic1 at obio? addr 0x08380 +pci* at socpcic? + +pciide* at pci? +wd* at pciide? flags 0x0000 + +# Ob-board USB +ehci0 at obio? addr 0x22100 ivec 39 +usb* at ehci? + +# USB devices +uhub* at usb? # USB Hubs +uhub* at uhub? # USB Hubs +umass* at uhub? # USB Mass Storage devices +scsibus* at umass? +ural* at uhub? # Ralink RT2500USB +rum* at uhub? # Ralink RT2501USB/RT2601USB + +sd* at scsibus? diff --git a/sys/arch/socppc/conf/Makefile.socppc b/sys/arch/socppc/conf/Makefile.socppc new file mode 100644 index 00000000000..baa5d9ca8c7 --- /dev/null +++ b/sys/arch/socppc/conf/Makefile.socppc @@ -0,0 +1,189 @@ +# $OpenBSD: Makefile.socppc,v 1.1 2008/05/10 12:02:20 kettenis Exp $ +# +# Makefile for OpenBSD PowerPC +# +# This makefile is constructed from a machine description: +# config machineid +# Most changes should be made in the machine description +# /sys/arch/socppc/conf/``machineid'' +# after which you should do +# config machineid +# Machine generic makefile changes should be made in +# /sys/arch/socppc/conf/Makefile.socppc +# after which config should be rerun for all machines of that type. +# +# N.B.: NO DEPENDENCIES ON FOLLOWING FLAGS ARE VISIBLE TO MAKEFILE +# IF YOU CHANGE THE DEFINITION OF ANY OF THESE RECOMPILE EVERYTHING +# +# -DTRACE compile in kernel tracing hooks +# -DQUOTA compile in file system quotas +# +.SUFFIXES: .S .c .o + +# DEBUG is set to -g if debugging. +# PROF is set to -pg if profiling. + +.include <bsd.own.mk> + +MKDEP?= mkdep +STRIP?= strip +SIZE?= size + +# source tree is located via $S relative to the compilation directory +.ifndef S +S!= cd ../../../..; pwd +.endif +SOCPPC= $S/arch/socppc + +INCLUDES= -I. -I$S -I$S/arch -nostdinc +CPPFLAGS= ${INCLUDES} ${IDENT} -D_KERNEL \ + -D__socppc__ +CWARNFLAGS= -Werror -Wall -Wstrict-prototypes -Wmissing-prototypes \ + -Wno-uninitialized -Wno-format -Wno-main \ + -Wstack-larger-than-2047 -Wvariable-decl +CMACHFLAGS= -msoft-float -Wa,-many -fno-builtin-printf -fno-builtin-log +.if ${IDENT:M-DNO_PROPOLICE} +CMACHFLAGS+= -fno-stack-protector +.endif +COPTS?= -O2 +CFLAGS= ${DEBUG} ${CWARNFLAGS} ${CMACHFLAGS} ${COPTS} ${PIPE} +AFLAGS= -D_LOCORE -Wa,-many +LINKFLAGS= -N -Ttext 200000 -e start --warn-common +STRIPFLAGS= -g -X -x + +HOSTCC?= ${CC} +HOSTED_CPPFLAGS=${CPPFLAGS:S/^-nostdinc$//} +HOSTED_CFLAGS= ${CFLAGS} + +# compile rules: rules are named ${TYPE}_${SUFFIX}${CONFIG_DEP} +# where TYPE is NORMAL, DRIVER, or PROFILE}; SUFFIX is the file suffix, +# capitalized (e.g. C for a .c file), and CONFIG_DEP is _C if the file +# is marked as config-dependent. + +NORMAL_C_NOP= ${CC} ${CFLAGS} ${CPPFLAGS} -c $< +NORMAL_C= ${CC} ${CFLAGS} ${CPPFLAGS} ${PROF} -c $< +NORMAL_C_C= ${CC} ${CFLAGS} ${CPPFLAGS} ${PROF} ${PARAM} -c $< + +DRIVER_C= ${CC} ${CFLAGS} ${CPPFLAGS} ${PROF} -c $< +DRIVER_C_C= ${CC} ${CFLAGS} ${CPPFLAGS} ${PROF} ${PARAM} -c $< + +NORMAL_S= ${CC} ${AFLAGS} ${CPPFLAGS} -c $< +NORMAL_S_C= ${AS} ${COPTS} ${PARAM} $< -o $@ + + +%OBJS + +%CFILES + +%SFILES + +# load lines for config "xxx" will be emitted as: +# xxx: ${SYSTEM_DEP} swapxxx.o +# ${SYSTEM_LD_HEAD} +# ${SYSTEM_LD} swapxxx.o +# ${SYSTEM_LD_TAIL} +SYSTEM_OBJ= locore.o param.o ioconf.o ${OBJS} +SYSTEM_DEP= Makefile ${SYSTEM_OBJ} +SYSTEM_LD_HEAD= rm -f $@ +SYSTEM_LD= @echo ${LD} ${LINKFLAGS} -o $@ '$${SYSTEM_OBJ}' vers.o; \ + ${LD} ${LINKFLAGS} -o $@ ${SYSTEM_OBJ} vers.o +SYSTEM_LD_TAIL= @${SIZE} $@; chmod 755 $@ + +DEBUG?= +.if ${DEBUG} == "-g" +LINKFLAGS+= -X +SYSTEM_LD_TAIL+=; \ + echo mv $@ $@.gdb; rm -f $@.gdb; mv $@ $@.gdb; \ + echo ${STRIP} ${STRIPFLAGS} -o $@ $@.gdb; \ + ${STRIP} ${STRIPFLAGS} -o $@ $@.gdb +.else +LINKFLAGS+= -S -x +.endif + +%LOAD + +assym.h: $S/kern/genassym.sh ${SOCPPC}/socppc/genassym.cf Makefile + sh $S/kern/genassym.sh ${CC} ${CFLAGS} ${CPPFLAGS} \ + < ${SOCPPC}/socppc/genassym.cf > assym.h.tmp && \ + mv -f assym.h.tmp assym.h + +param.c: $S/conf/param.c + rm -f param.c + cp $S/conf/param.c . + +param.o: param.c Makefile + ${NORMAL_C_C} + +mcount.o: $S/lib/libkern/mcount.c Makefile + ${NORMAL_C_NOP} + +ioconf.o: ioconf.c + ${NORMAL_C} + +newvers: ${SYSTEM_DEP} ${SYSTEM_SWAP_DEP} + sh $S/conf/newvers.sh + ${CC} ${CFLAGS} ${CPPFLAGS} ${PROF} -c vers.c + +clean:: + rm -f eddep *bsd bsd.gdb tags *.[io] [a-z]*.s \ + [Ee]rrs linterrs makelinks genassym genassym.o assym.h + +lint: + @lint -hbxncez -DGENERIC -Dvolatile= ${CPPFLAGS} -UKGDB ${CFILES} \ + ioconf.c param.c | \ + grep -v 'static function .* unused' + +tags: + @echo "see $S/kern/Makefile for tags" + +links: + egrep '#if' ${CFILES} | sed -f $S/conf/defines | \ + sed -e 's/:.*//' -e 's/\.c/.o/' | sort -u > dontlink + echo ${CFILES} | tr -s ' ' '\12' | sed 's/\.c/.o/' | \ + sort -u | comm -23 - dontlink | \ + sed 's,../.*/\(.*.o\),rm -f \1; ln -s ../GENERIC/\1 \1,' > makelinks + sh makelinks && rm -f dontlink + +SRCS= ${SOCPPC}/socppc/locore.S \ + param.c ioconf.c ${CFILES} ${SFILES} +depend:: .depend +.depend: ${SRCS} assym.h param.c + ${MKDEP} ${AFLAGS} ${CPPFLAGS} ${SOCPPC}/socppc/locore.S + ${MKDEP} -a ${CFLAGS} ${CPPFLAGS} param.c ioconf.c ${CFILES} +.if ${SFILES} != "" + ${MKDEP} -a ${AFLAGS} ${CPPFLAGS} ${SFILES} +.endif + sh $S/kern/genassym.sh ${MKDEP} -f assym.dep ${CFLAGS} \ + ${CPPFLAGS} < ${SOCPPC}/socppc/genassym.cf + @sed -e 's/.*\.o:.* /assym.h: /' < assym.dep >> .depend + @rm -f assym.dep + +# depend on root or device configuration +autoconf.o conf.o: Makefile + +# depend on network or filesystem configuration +uipc_proto.o vfs_conf.o: Makefile + +# depend on maxusers +genassym.o machdep.o: Makefile + +# depend on CPU configuration +locore.o machdep.o: Makefile + + +locore.o: ${SOCPPC}/socppc/locore.S assym.h + ${NORMAL_S} + +# The install target can be redefined by putting a +# install-kernel-${MACHINE_NAME} target into /etc/mk.conf +MACHINE_NAME!= uname -n +install: install-kernel-${MACHINE_NAME} +.if !target(install-kernel-${MACHINE_NAME}}) +install-kernel-${MACHINE_NAME}: + rm -f /obsd + ln /bsd /obsd + cp bsd /nbsd + mv /nbsd /bsd +.endif + +%RULES diff --git a/sys/arch/socppc/conf/files.socppc b/sys/arch/socppc/conf/files.socppc new file mode 100644 index 00000000000..d22ecf309f2 --- /dev/null +++ b/sys/arch/socppc/conf/files.socppc @@ -0,0 +1,93 @@ +# $OpenBSD: files.socppc,v 1.1 2008/05/10 12:02:20 kettenis Exp $ + +# +# macppc-specific configuration info +# +maxpartitions 16 + +maxusers 2 8 64 + +file arch/socppc/socppc/autoconf.c +file arch/socppc/socppc/clock.c +file arch/socppc/socppc/conf.c +file arch/socppc/socppc/disksubr.c disk +file arch/socppc/socppc/machdep.c +file arch/socppc/socppc/mem.c +file arch/socppc/socppc/dma.c +file dev/cninit.c +file arch/socppc/socppc/db_interface.c ddb + + +define mainbus {} +device mainbus +attach mainbus at root +file arch/socppc/socppc/mainbus.c mainbus + +device cpu +attach cpu at mainbus +file arch/socppc/socppc/cpu.c + +# MPC8349E on-board devices +device obio {addr, [ivec = -1]} +attach obio at mainbus +file arch/socppc/dev/obio.c + +# On-board IPIC +device ipic +attach ipic at obio +file arch/socppc/dev/ipic.c + +# On-board I2C +device sociic: i2cbus +attach sociic at obio +file arch/socppc/dev/sociic.c + +# On-board DUART +attach com at obio with com_obio +file arch/socppc/dev/com_obio.c + +# +# Media Independent Interface (mii) +# +include "../../../dev/mii/files.mii" + +major {rd = 17} +major {wd = 0} +major {sd = 2} +major {cd = 3} + +include "../../../scsi/files.scsi" + +# +# I2O +# +include "../../../dev/i2o/files.i2o" + +include "dev/pci/files.pci" +file arch/socppc/dev/pciide_machdep.c pciide + +# On-board PCI +device socpcic: pcibus +attach socpcic at obio +file arch/socppc/dev/socpcic.c + +# +# Machine-independent ATAPI drivers +# + +include "../../../dev/atapiscsi/files.atapiscsi" +include "../../../dev/ata/files.ata" + +# +# Machine-independent USB drivers +# +include "dev/usb/files.usb" + +# On-board USB +attach ehci at obio with ehci_obio +file arch/socppc/dev/ehci_obio.c + +# +# Machine-independent I2C drivers +# +include "dev/i2c/files.i2c" diff --git a/sys/arch/socppc/dev/com_obio.c b/sys/arch/socppc/dev/com_obio.c new file mode 100644 index 00000000000..c509c800e05 --- /dev/null +++ b/sys/arch/socppc/dev/com_obio.c @@ -0,0 +1,69 @@ +/* $OpenBSD: com_obio.c,v 1.1 2008/05/10 12:02:20 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> +#include <sys/tty.h> + +#include <machine/autoconf.h> + +#include <dev/ic/comreg.h> +#include <dev/ic/comvar.h> + +int com_obio_match(struct device *, void *, void *); +void com_obio_attach(struct device *, struct device *, void *); + +struct cfattach com_obio_ca = { + sizeof(struct com_softc), com_obio_match, com_obio_attach +}; + +struct cfdriver com_obio_cd = { + NULL, "com", DV_DULL +}; + +int +com_obio_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +com_obio_attach(struct device *parent, struct device *self, void *aux) +{ + struct com_softc *sc = (void *)self; + struct obio_attach_args *oa = aux; + + sc->sc_iot = oa->oa_iot; + sc->sc_iobase = oa->oa_offset; + sc->sc_frequency = 266666666; /* XXX */ + + if (sc->sc_iobase != comconsaddr) { + if (bus_space_map(sc->sc_iot, sc->sc_iobase, + COM_NPORTS, 0, &sc->sc_ioh)) { + printf(": can't map registers\n"); + return; + } + } else + sc->sc_ioh = comconsioh; + + com_attach_subr(sc); + + intr_establish(oa->oa_ivec, IST_LEVEL, IPL_TTY, comintr, + sc, sc->sc_dev.dv_xname); +} diff --git a/sys/arch/socppc/dev/ehci_obio.c b/sys/arch/socppc/dev/ehci_obio.c new file mode 100644 index 00000000000..93039e45533 --- /dev/null +++ b/sys/arch/socppc/dev/ehci_obio.c @@ -0,0 +1,118 @@ +/* $OpenBSD: ehci_obio.c,v 1.1 2008/05/10 12:02:20 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> +#include <sys/rwlock.h> +#include <sys/timeout.h> + +#include <machine/autoconf.h> + +#include <dev/usb/usb.h> +#include <dev/usb/usbdi.h> +#include <dev/usb/usbdivar.h> +#include <dev/usb/usb_mem.h> + +#include <dev/usb/ehcireg.h> +#include <dev/usb/ehcivar.h> + +#include <dev/pci/pcidevs.h> + +int ehci_obio_match(struct device *, void *, void *); +void ehci_obio_attach(struct device *, struct device *, void *); + +struct cfattach ehci_obio_ca = { + sizeof(struct ehci_softc), ehci_obio_match, ehci_obio_attach +}; + +struct cfdriver ehci_obio_cd = { + NULL, "ehci", DV_DULL +}; + +struct powerpc_bus_dma_tag ehci_bus_dma_tag = { + NULL, + _dmamap_create, + _dmamap_destroy, + _dmamap_load, + _dmamap_load_mbuf, + _dmamap_load_uio, + _dmamap_load_raw, + _dmamap_unload, + _dmamap_sync, + _dmamem_alloc, + _dmamem_free, + _dmamem_map, + _dmamem_unmap, + _dmamem_mmap +}; + +int +ehci_obio_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +ehci_obio_attach(struct device *parent, struct device *self, void *aux) +{ + struct ehci_softc *sc = (void *)self; + struct obio_attach_args *oa = aux; + usbd_status r; + int s; + + sc->iot = oa->oa_iot; + sc->sc_size = 1024; + if (bus_space_map(sc->iot, oa->oa_offset, sc->sc_size, 0, &sc->ioh)) { + printf(": can't map registers\n"); + return; + } + + sc->sc_id_vendor = PCI_VENDOR_FREESCALE; + strlcpy(sc->sc_vendor, "Freescale", sizeof sc->sc_vendor); + + sc->sc_bus.dmatag = &ehci_bus_dma_tag; + + bus_space_write_4(sc->iot, sc->ioh, 0x400, 0x04000000); + bus_space_write_4(sc->iot, sc->ioh, 0x300, 0x1e000000); + + s = splhardusb(); + sc->sc_offs = EREAD1(sc, EHCI_CAPLENGTH); + EOWRITE2(sc, EHCI_USBINTR, 0); + + intr_establish(oa->oa_ivec, IST_LEVEL, IPL_USB, ehci_intr, sc, + sc->sc_bus.bdev.dv_xname); + + r = ehci_init(sc); + if (r != USBD_NORMAL_COMPLETION) { + printf(": init failed, error=%d\n", r); + goto unmap_ret; + } + splx(s); + + printf("\n"); + + /* Attach usb device. */ + sc->sc_child = config_found((void *)sc, &sc->sc_bus, usbctlprint); + + return; + +unmap_ret: + bus_space_unmap(sc->iot, sc->ioh, sc->sc_size); + splx(s); +} diff --git a/sys/arch/socppc/dev/ipic.c b/sys/arch/socppc/dev/ipic.c new file mode 100644 index 00000000000..befc10c43e3 --- /dev/null +++ b/sys/arch/socppc/dev/ipic.c @@ -0,0 +1,333 @@ +/* $OpenBSD: ipic.c,v 1.1 2008/05/10 12:02:20 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> +#include <sys/malloc.h> + +#include <machine/autoconf.h> +#include <machine/intr.h> + +#define IPIC_SICFR 0x00 +#define IPIC_SIVCR 0x04 +#define IPIC_SIPNR_H 0x08 +#define IPIC_SIPNR_L 0x0c +#define IPIC_SIPRR_A 0x10 +#define IPIC_SIPRR_D 0x1c +#define IPIC_SIMSR_H 0x20 +#define IPIC_SIMSR_L 0x24 +#define IPIC_SICNR 0x28 +#define IPIC_SEPNR 0x2c +#define IPIC_SMPRR_A 0x30 +#define IPIC_SMPRR_B 0x34 +#define IPIC_SEMSR 0x38 +#define IPIC_SECNR 0x3c +#define IPIC_SERSR 0x40 +#define IPIC_SERMR 0x44 +#define IPIC_SERCR 0x48 +#define IPIC_SIFCR_H 0x50 +#define IPIC_SIFCR_L 0x54 +#define IPIC_SEFCR 0x58 +#define IPIC_SERFR 0x5c +#define IPIC_SCVCR 0x60 +#define IPIC_SMVCR 0x64 + +#define IPIC_NVEC 128 + +#define IPIC_EXTERNAL(ivec) ((ivec) >= 17 && (ivec) <= 23) + +struct ipic_softc { + struct device sc_dev; + bus_space_tag_t sc_iot; + bus_space_handle_t sc_ioh; + + uint32_t sc_simsr_h[IPL_NUM]; + uint32_t sc_simsr_l[IPL_NUM]; + uint32_t sc_semsr[IPL_NUM]; +}; + +uint32_t ipic_imask; +struct intrhand *ipic_intrhand[IPIC_NVEC]; +struct ipic_softc *ipic_sc; + +int ipic_match(struct device *, void *, void *); +void ipic_attach(struct device *, struct device *, void *); + +struct cfattach ipic_ca = { + sizeof(struct ipic_softc), ipic_match, ipic_attach +}; + +struct cfdriver ipic_cd = { + NULL, "ipic", DV_DULL +}; + +uint32_t ipic_read(struct ipic_softc *, bus_addr_t); +void ipic_write(struct ipic_softc *, bus_addr_t, uint32_t); +uint32_t ipic_simsr_h(int); +uint32_t ipic_simsr_l(int); +uint32_t ipic_semsr(int); + +void ext_intr(void); +void ipic_do_pending_int(void); + +int +ipic_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +ipic_attach(struct device *parent, struct device *self, void *aux) +{ + struct ipic_softc *sc = (void *)self; + struct obio_attach_args *oa = aux; + + sc->sc_iot = oa->oa_iot; + if (bus_space_map(sc->sc_iot, oa->oa_offset, 128, 0, &sc->sc_ioh)) { + printf(": can't map registers\n"); + return; + } + + ipic_sc = sc; + printf("\n"); +} + +uint32_t +ipic_read(struct ipic_softc *sc, bus_addr_t addr) +{ + return (letoh32(bus_space_read_4(sc->sc_iot, sc->sc_ioh, addr))); +} + +void +ipic_write(struct ipic_softc *sc, bus_addr_t addr, uint32_t data) +{ + bus_space_write_4(sc->sc_iot, sc->sc_ioh, addr, htole32(data)); +} + +uint32_t +ipic_simsr_h(int ivec) +{ + switch (ivec) { + case 9: + return 0x00000080; + case 10: + return 0x00000040; + case 39: + return 0x01000000; + } + + return 0; +} + +uint32_t +ipic_simsr_l(int ivec) +{ + return 0; +} + +uint32_t +ipic_semsr(int ivec) +{ + switch (ivec) { + case 17: + return 0x40000000; + case 18: + return 0x20000000; + case 19: + return 0x10000000; + case 20: + return 0x08000000; + case 21: + return 0x04000000; + case 22: + return 0x02000000; + case 23: + return 0x01000000; + } + + return 0; +} + +static void +intr_calculatemasks(void) +{ + struct ipic_softc *sc = ipic_sc; + int level; + + for (level = IPL_NONE; level < IPL_NUM; level++) + imask[level] = SINT_MASK | (1 << level); + + /* + * There are tty, network and disk drivers that use free() at interrupt + * time, so vm > (tty | net | bio). + * + * Enforce a hierarchy that gives slow devices a better chance at not + * dropping data. + */ + imask[IPL_NET] |= imask[IPL_BIO]; + imask[IPL_TTY] |= imask[IPL_NET]; + imask[IPL_VM] |= imask[IPL_TTY]; + imask[IPL_CLOCK] |= imask[IPL_VM] | SPL_CLOCK; + + /* + * These are pseudo-levels. + */ + imask[IPL_NONE] = 0x00000000; + imask[IPL_HIGH] = 0xffffffff; + + sc->sc_simsr_h[IPL_NET] |= sc->sc_simsr_h[IPL_BIO]; + sc->sc_simsr_h[IPL_TTY] |= sc->sc_simsr_h[IPL_NET]; + sc->sc_simsr_h[IPL_VM] |= sc->sc_simsr_h[IPL_TTY]; + sc->sc_simsr_h[IPL_NET] |= sc->sc_simsr_h[IPL_VM]; + sc->sc_simsr_h[IPL_HIGH] |= sc->sc_simsr_h[IPL_NET]; + + sc->sc_simsr_l[IPL_NET] |= sc->sc_simsr_l[IPL_BIO]; + sc->sc_simsr_l[IPL_TTY] |= sc->sc_simsr_l[IPL_NET]; + sc->sc_simsr_l[IPL_VM] |= sc->sc_simsr_l[IPL_TTY]; + sc->sc_simsr_l[IPL_NET] |= sc->sc_simsr_l[IPL_VM]; + sc->sc_simsr_l[IPL_HIGH] |= sc->sc_simsr_l[IPL_NET]; + + sc->sc_semsr[IPL_NET] |= sc->sc_semsr[IPL_BIO]; + sc->sc_semsr[IPL_TTY] |= sc->sc_semsr[IPL_NET]; + sc->sc_semsr[IPL_VM] |= sc->sc_semsr[IPL_TTY]; + sc->sc_semsr[IPL_NET] |= sc->sc_semsr[IPL_VM]; + sc->sc_semsr[IPL_HIGH] |= sc->sc_semsr[IPL_NET]; +} + +void * +intr_establish(int ivec, int type, int level, + int (*ih_fun)(void *), void *ih_arg, const char *name) +{ + struct ipic_softc *sc = ipic_sc; + struct intrhand **p, *q, *ih; + uint32_t mask; + + ih = malloc(sizeof *ih, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK); + if (ih == NULL) + panic("xxx"); + + if (ivec < 0 || ivec >= IPIC_NVEC) + panic("xxx"); + + for (p = &ipic_intrhand[ivec]; (q = *p) != NULL; p = &q->ih_next) + ; + + sc->sc_simsr_h[level] |= ipic_simsr_h(ivec); + sc->sc_simsr_l[level] |= ipic_simsr_l(ivec); + sc->sc_semsr[level] |= ipic_semsr(ivec); + intr_calculatemasks(); + + ih->ih_fun = ih_fun; + ih->ih_arg = ih_arg; + ih->ih_next = NULL; + ih->ih_level = level; + ih->ih_irq = ivec; + evcount_attach(&ih->ih_count, name, NULL, &evcount_intr); + *p = ih; + + /* Unmask the interrupt. */ + mask = ipic_read(sc, IPIC_SIMSR_H); + mask |= ipic_simsr_h(ivec); + ipic_write(sc, IPIC_SIMSR_H, mask); + mask = ipic_read(sc, IPIC_SIMSR_L); + mask |= ipic_simsr_l(ivec); + ipic_write(sc, IPIC_SIMSR_L, mask); + mask = ipic_read(sc, IPIC_SEMSR); + mask |= ipic_semsr(ivec); + ipic_write(sc, IPIC_SEMSR, mask); + + return (ih); +} + +void +ext_intr(void) +{ + struct cpu_info *ci = curcpu(); + struct ipic_softc *sc = ipic_sc; + struct intrhand *ih; + uint32_t simsr_h, simsr_l, semsr; + int pcpl, ocpl; + int ivec; + + pcpl = ci->ci_cpl; + ivec = ipic_read(sc, IPIC_SIVCR) & 0x7f; + + simsr_h = ipic_read(sc, IPIC_SIMSR_H); + simsr_l = ipic_read(sc, IPIC_SIMSR_L); + semsr = ipic_read(sc, IPIC_SEMSR); + ipic_write(sc, IPIC_SIMSR_H, simsr_h & ~ipic_simsr_h(ivec)); + ipic_write(sc, IPIC_SIMSR_L, simsr_l & ~ipic_simsr_l(ivec)); + ipic_write(sc, IPIC_SEMSR, semsr & ~ipic_semsr(ivec)); + + ih = ipic_intrhand[ivec]; + while (ih) { + if (ci->ci_cpl & (1 << ih->ih_level)) { + ci->ci_ipending |= (1 << ih->ih_level); + return; + } + + ipic_write(sc, IPIC_SIMSR_H, sc->sc_simsr_h[ih->ih_level]); + ipic_write(sc, IPIC_SIMSR_L, sc->sc_simsr_l[ih->ih_level]); + ipic_write(sc, IPIC_SEMSR, sc->sc_semsr[ih->ih_level]); + ocpl = splraise(imask[ih->ih_level]); + ppc_intr_enable(1); + + KERNEL_LOCK(); + if ((*ih->ih_fun)(ih->ih_arg)) + ih->ih_count.ec_count++; + KERNEL_UNLOCK(); + + ppc_intr_disable(); + ci->ci_cpl = ocpl; + ih = ih->ih_next; + } + + ipic_write(sc, IPIC_SIMSR_H, simsr_h); + ipic_write(sc, IPIC_SIMSR_L, simsr_l); + ipic_write(sc, IPIC_SEMSR, semsr); + splx(pcpl); +} + +static __inline int +cntlzw(int x) +{ + int a; + + __asm __volatile("cntlzw %0,%1" : "=r"(a) : "r"(x)); + + return a; +} + +void +ipic_do_pending_int(void) +{ + struct cpu_info *ci = curcpu(); + struct ipic_softc *sc = ipic_sc; + uint32_t mask; + int level; + + ci->ci_ipending &= SINT_MASK; + level = cntlzw(31 - (ci->ci_cpl & ~(SPL_CLOCK|SINT_MASK))); + mask = sc->sc_simsr_h[IPL_HIGH] & ~sc->sc_simsr_h[level]; + ipic_write(sc, IPIC_SIMSR_H, mask); + mask = sc->sc_simsr_l[IPL_HIGH] & ~sc->sc_simsr_l[level]; + ipic_write(sc, IPIC_SIMSR_L, mask); + mask = sc->sc_semsr[IPL_HIGH] & ~sc->sc_semsr[level]; + ipic_write(sc, IPIC_SEMSR, mask); +} diff --git a/sys/arch/socppc/dev/obio.c b/sys/arch/socppc/dev/obio.c new file mode 100644 index 00000000000..036564fc8a4 --- /dev/null +++ b/sys/arch/socppc/dev/obio.c @@ -0,0 +1,83 @@ +/* $OpenBSD: obio.c,v 1.1 2008/05/10 12:02:20 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> + +#include <machine/autoconf.h> + +int obio_match(struct device *, void *, void *); +void obio_attach(struct device *, struct device *, void *); + +struct cfattach obio_ca = { + sizeof(struct device), obio_match, obio_attach +}; + +struct cfdriver obio_cd = { + NULL, "obio", DV_DULL +}; + +int obio_search(struct device *, void *, void *); +int obio_print(void *, const char *); + +int +obio_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +obio_attach(struct device *parent, struct device *self, void *aux) +{ + printf("\n"); + + config_search(obio_search, self, aux); +} + +int +obio_search(struct device *parent, void *cfdata, void *aux) +{ + struct mainbus_attach_args *ma = aux; + struct obio_attach_args oa; + struct cfdata *cf = cfdata; + + bzero(&oa, sizeof oa); + oa.oa_iot = ma->ma_iot; + oa.oa_name = cf->cf_driver->cd_name; + oa.oa_offset = cf->cf_offset; + oa.oa_ivec = cf->cf_ivec; + config_found(parent, &oa, obio_print); + + return (1); +} + +int +obio_print(void *aux, const char *name) +{ + struct obio_attach_args *oa = aux; + + if (name) + printf("%s at %s", oa->oa_name, name); + if (oa->oa_offset) + printf(" offset 0x%05x", oa->oa_offset); + if (oa->oa_ivec != -1) + printf(" ivec %d", oa->oa_ivec); + + return (UNCONF); +} diff --git a/sys/arch/socppc/dev/pciide_machdep.c b/sys/arch/socppc/dev/pciide_machdep.c new file mode 100644 index 00000000000..b9b3ab8a9c9 --- /dev/null +++ b/sys/arch/socppc/dev/pciide_machdep.c @@ -0,0 +1,40 @@ +/* $OpenBSD: pciide_machdep.c,v 1.1 2008/05/10 12:02:20 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> + +#include <dev/pci/pcireg.h> +#include <dev/pci/pcivar.h> +#include <dev/pci/pciidereg.h> +#include <dev/pci/pciidevar.h> + +#include <machine/autoconf.h> + +void * +pciide_machdep_compat_intr_establish(struct device *dev, + struct pci_attach_args *pa, int chan, int (*func)(void *), void *arg) +{ + return (NULL); +} + +void +pciide_machdep_compat_intr_disestablish(pci_chipset_tag_t pc, void *cookie) +{ +} diff --git a/sys/arch/socppc/dev/sociic.c b/sys/arch/socppc/dev/sociic.c new file mode 100644 index 00000000000..b35c0397963 --- /dev/null +++ b/sys/arch/socppc/dev/sociic.c @@ -0,0 +1,290 @@ +/* $OpenBSD: sociic.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Driver for the I2C interface on the MPC8349E processors. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> +#include <sys/rwlock.h> + +#include <machine/autoconf.h> +#include <machine/bus.h> + +#include <dev/i2c/i2cvar.h> + +#define I2C_ADR 0x00 /* Address Register */ +#define I2C_FDR 0x04 /* Fequency Divider Register */ +#define I2C_CR 0x08 /* Control Register */ +#define I2C_CR_MEN 0x80 +#define I2C_CR_MIEN 0x40 +#define I2C_CR_MSTA 0x20 +#define I2C_CR_MTX 0x10 +#define I2C_CR_TXAK 0x08 +#define I2C_CR_RSTA 0x04 +#define I2C_CR_BCST 0x01 +#define I2C_SR 0x0c /* Status Register */ +#define I2C_SR_MCF 0x80 +#define I2C_SR_MAAS 0x40 +#define I2C_SR_MBB 0x20 +#define I2C_SR_MAL 0x10 +#define I2C_SR_BCSTM 0x08 +#define I2C_SR_SRW 0x04 +#define I2C_SR_MIF 0x02 +#define I2C_SR_RXAK 0x01 +#define I2C_DR 0x10 /* Data Register */ +#define I2C_DFSRR 0x14 /* Digital Filter Sampling Rate Register */ + +struct sociic_softc { + struct device sc_dev; + bus_space_tag_t sc_iot; + bus_space_handle_t sc_ioh; + + struct i2c_controller sc_i2c; + struct rwlock sc_lock; +}; + +int sociic_match(struct device *, void *, void *); +void sociic_attach(struct device *, struct device *, void *); + +struct cfattach sociic_ca = { + sizeof(struct sociic_softc), sociic_match, sociic_attach +}; + +struct cfdriver sociic_cd = { + NULL, "sociic", DV_DULL +}; + +void sociic_write(struct sociic_softc *, bus_addr_t, uint8_t); +uint8_t sociic_read(struct sociic_softc *, bus_addr_t); +int sociic_wait(struct sociic_softc *, int); +int sociic_wait_bus(struct sociic_softc *); +int sociic_i2c_acquire_bus(void *, int); +void sociic_i2c_release_bus(void *, int); +int sociic_i2c_exec(void *, i2c_op_t, i2c_addr_t, + const void *, size_t, void *, size_t, int); + +int +sociic_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +sociic_attach(struct device *parent, struct device *self, void *aux) +{ + struct sociic_softc *sc = (void *)self; + struct obio_attach_args *oa = aux; + struct i2cbus_attach_args iba; + + sc->sc_iot = oa->oa_iot; + if (bus_space_map(sc->sc_iot, oa->oa_offset, 24, 0, &sc->sc_ioh)) { + printf(": can't map registers\n"); + return; + } + + printf("\n"); + + rw_init(&sc->sc_lock, "iiclk"); + sc->sc_i2c.ic_cookie = sc; + sc->sc_i2c.ic_acquire_bus = sociic_i2c_acquire_bus; + sc->sc_i2c.ic_release_bus = sociic_i2c_release_bus; + sc->sc_i2c.ic_exec = sociic_i2c_exec; + + bzero(&iba, sizeof iba); + iba.iba_name = "iic"; + iba.iba_tag = &sc->sc_i2c; + config_found(&sc->sc_dev, &iba, iicbus_print); +} + +void +sociic_write(struct sociic_softc *sc, bus_addr_t addr, uint8_t data) +{ + bus_space_write_1(sc->sc_iot, sc->sc_ioh, addr, data); +} + +uint8_t +sociic_read(struct sociic_softc *sc, bus_addr_t addr) +{ + return (bus_space_read_1(sc->sc_iot, sc->sc_ioh, addr)); +} + +int +sociic_wait(struct sociic_softc *sc, int flags) +{ + uint8_t sr; + int i; + + for (i = 0; i < 1000; i++) { + sr = sociic_read(sc, I2C_SR); + if (sr & I2C_SR_MIF) { + sociic_write(sc, I2C_SR, 0); + + if (sr & I2C_SR_MAL) + return (EIO); + + if ((sr & I2C_SR_MCF) == 0) + return (EIO); + + if ((flags & I2C_F_READ) == 0 && (sr & I2C_SR_RXAK)) + return (EIO); + + return (0); + } + delay(100); + } + + return (ETIMEDOUT); +} + +int +sociic_wait_bus(struct sociic_softc *sc) +{ + uint8_t sr; + int i; + + for (i = 0; i < 1000; i++) { + sr = sociic_read(sc, I2C_SR); + if ((sr & I2C_SR_MBB) == 0) + return (0); + delay(1000); + } + + return (ETIMEDOUT); +} + +int +sociic_i2c_acquire_bus(void *arg, int flags) +{ + struct sociic_softc *sc = arg; + + if (cold || (flags & I2C_F_POLL)) + return (0); + + return (rw_enter(&sc->sc_lock, RW_WRITE | RW_INTR)); +} + +void +sociic_i2c_release_bus(void *arg, int flags) +{ + struct sociic_softc *sc = arg; + + if (cold || (flags & I2C_F_POLL)) + return; + + rw_exit(&sc->sc_lock); +} + +int +sociic_i2c_exec(void *arg, i2c_op_t op, i2c_addr_t addr, + const void *vcmdbuf, size_t cmdlen, void *vbuf, size_t buflen, int flags) +{ + struct sociic_softc *sc = arg; + const uint8_t *cmdbuf = vcmdbuf; + uint8_t *buf = vbuf; + int err = 0; + size_t len; + uint8_t val; + + /* Clear the bus. */ + sociic_write(sc, I2C_SR, 0); + sociic_write(sc, I2C_CR, I2C_CR_MEN); + err = sociic_wait_bus(sc); + if (err) + return (err); + + if (cmdlen > 0) { + sociic_write(sc, I2C_CR, I2C_CR_MEN|I2C_CR_MSTA|I2C_CR_MTX); + sociic_write(sc, I2C_DR, addr << 1); + err = sociic_wait(sc, I2C_F_WRITE); + if (err) + goto out; + + len = cmdlen; + while (len--) { + sociic_write(sc, I2C_DR, *cmdbuf++); + err = sociic_wait(sc, I2C_F_WRITE); + if (err) + goto out; + } + } + + if (I2C_OP_READ_P(op) && buflen > 0) { + /* RESTART if we did write a command above. */ + val = I2C_CR_MEN|I2C_CR_MSTA|I2C_CR_MTX; + if (cmdlen > 0) + val |= I2C_CR_RSTA; + sociic_write(sc, I2C_CR, val); + sociic_write(sc, I2C_DR, (addr << 1) | 1); + err = sociic_wait(sc, I2C_F_WRITE); + if (err) + goto out; + + /* NACK if we're only sending one byte. */ + val = I2C_CR_MEN|I2C_CR_MSTA; + if (buflen == 1) + val |= I2C_CR_TXAK; + sociic_write(sc, I2C_CR, val); + + /* Dummy read. */ + sociic_read(sc, I2C_DR); + + len = buflen; + while (len--) { + err = sociic_wait(sc, I2C_F_READ); + if (err) + goto out; + + /* NACK on last byte. */ + if (len == 1) + sociic_write(sc, I2C_CR, + I2C_CR_MEN|I2C_CR_MSTA|I2C_CR_TXAK); + /* STOP after last byte. */ + if (len == 0) + sociic_write(sc, I2C_CR, + I2C_CR_MEN|I2C_CR_TXAK); + *buf++ = sociic_read(sc, I2C_DR); + } + } + + if (I2C_OP_WRITE_P(op) && cmdlen == 0 && buflen > 0) { + /* START if we didn't write a command. */ + sociic_write(sc, I2C_CR, I2C_CR_MEN|I2C_CR_MSTA|I2C_CR_MTX); + sociic_write(sc, I2C_DR, addr << 1); + err = sociic_wait(sc, I2C_F_WRITE); + if (err) + goto out; + } + + if (I2C_OP_WRITE_P(op) && buflen > 0) { + len = buflen; + while (len--) { + sociic_write(sc, I2C_DR, *buf++); + err = sociic_wait(sc, I2C_F_WRITE); + if (err) + goto out; + } + } + +out: + /* STOP if we're still holding the bus. */ + sociic_write(sc, I2C_CR, I2C_CR_MEN); + return (err); +} diff --git a/sys/arch/socppc/dev/socpcic.c b/sys/arch/socppc/dev/socpcic.c new file mode 100644 index 00000000000..94fef8a70f6 --- /dev/null +++ b/sys/arch/socppc/dev/socpcic.c @@ -0,0 +1,266 @@ +/* $OpenBSD: socpcic.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> + +#include <machine/autoconf.h> +#include <machine/bus.h> + +#include <dev/pci/pcireg.h> +#include <dev/pci/pcivar.h> +#include <dev/pci/pcidevs.h> + +struct socpcic_softc { + struct device sc_dev; + bus_space_tag_t sc_iot; + bus_space_handle_t sc_cfg_ioh; + struct ppc_bus_space sc_mem_bus_space; + struct ppc_bus_space sc_io_bus_space; + struct ppc_pci_chipset sc_pc; +}; + +int socpcic_match(struct device *, void *, void *); +void socpcic_attach(struct device *, struct device *, void *); + +struct cfattach socpcic_ca = { + sizeof(struct socpcic_softc), socpcic_match, socpcic_attach +}; + +struct cfdriver socpcic_cd = { + NULL, "socpcic", DV_DULL +}; + +void socpcic_attach_hook(struct device *, struct device *, + struct pcibus_attach_args *); +int socpcic_bus_maxdevs(void *, int); +pcitag_t socpcic_make_tag(void *, int, int, int); +void socpcic_decompose_tag(void *, pcitag_t, int *, int *, int *); +pcireg_t socpcic_conf_read(void *, pcitag_t, int); +void socpcic_conf_write(void *, pcitag_t, int, pcireg_t); +int socpcic_intr_map(void *, pcitag_t, int, int, pci_intr_handle_t *); +const char *socpcic_intr_string(void *, pci_intr_handle_t); +int socpcic_intr_line(void *, pci_intr_handle_t); +void *socpcic_intr_establish(void *, pci_intr_handle_t, int, + int (*)(void *), void *, char *); +void socpcic_intr_disestablish(void *, void *); +int socpcic_ether_hw_addr(struct ppc_pci_chipset *, u_int8_t *); + +int socpcic_print(void *, const char *); + +struct powerpc_bus_dma_tag pci_bus_dma_tag = { + NULL, + _dmamap_create, + _dmamap_destroy, + _dmamap_load, + _dmamap_load_mbuf, + _dmamap_load_uio, + _dmamap_load_raw, + _dmamap_unload, + _dmamap_sync, + _dmamem_alloc, + _dmamem_free, + _dmamem_map, + _dmamem_unmap, + _dmamem_mmap +}; + +int +socpcic_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +socpcic_attach(struct device *parent, struct device *self, void *aux) +{ + struct socpcic_softc *sc = (void *)self; + struct obio_attach_args *oa = aux; + struct pcibus_attach_args pba; + + sc->sc_iot = oa->oa_iot; + if (bus_space_map(sc->sc_iot, oa->oa_offset, 16, 0, &sc->sc_cfg_ioh)) { + printf(": can't map configuration registers\n"); + return; + } + + sc->sc_io_bus_space.bus_base = 0xe2000000; + sc->sc_io_bus_space.bus_size = 0x01000000; + + sc->sc_pc.pc_conf_v = sc; + sc->sc_pc.pc_attach_hook = socpcic_attach_hook; + sc->sc_pc.pc_bus_maxdevs = socpcic_bus_maxdevs; + sc->sc_pc.pc_make_tag = socpcic_make_tag; + sc->sc_pc.pc_decompose_tag = socpcic_decompose_tag; + sc->sc_pc.pc_conf_read = socpcic_conf_read; + sc->sc_pc.pc_conf_write = socpcic_conf_write; + + sc->sc_pc.pc_intr_v = sc; + sc->sc_pc.pc_intr_map = socpcic_intr_map; + sc->sc_pc.pc_intr_string = socpcic_intr_string; + sc->sc_pc.pc_intr_line = socpcic_intr_line; + sc->sc_pc.pc_intr_establish = socpcic_intr_establish; + sc->sc_pc.pc_intr_disestablish = socpcic_intr_disestablish; + sc->sc_pc.pc_ether_hw_addr = socpcic_ether_hw_addr; + + pba.pba_busname = "pci"; + pba.pba_iot = &sc->sc_io_bus_space; + pba.pba_memt = &sc->sc_mem_bus_space; + pba.pba_dmat = &pci_bus_dma_tag; + pba.pba_pc = &sc->sc_pc; + pba.pba_domain = pci_ndomains++; + pba.pba_bus = 0; + pba.pba_bridgetag = NULL; + + printf("\n"); + + config_found(self, &pba, socpcic_print); +} + +void +socpcic_attach_hook(struct device *parent, struct device *self, + struct pcibus_attach_args *pba) +{ +} + +int +socpcic_bus_maxdevs(void *cpv, int bus) +{ + return (32); +} + +pcitag_t +socpcic_make_tag(void *cpv, int bus, int dev, int fun) +{ + return ((bus << 16) | (dev << 11) | (fun << 8)); +} + +void +socpcic_decompose_tag(void *cpv, pcitag_t tag, int *busp, int *devp, int *funp) +{ + if (busp) + *busp = (tag >> 16) & 0xff; + if (devp) + *devp = (tag >> 11) & 0x1f; + if (funp) + *funp = (tag >> 8) & 0x7; +} + +pcireg_t +socpcic_conf_read(void *cpv, pcitag_t tag, int offset) +{ + struct socpcic_softc *sc = cpv; + int bus, dev, fun; + pcireg_t addr, data; + + socpcic_decompose_tag(sc, tag, &bus, &dev, &fun); + if (bus == 0) { + if (dev > 0 && dev < 11) + return (0xffffffff); + if (dev == 31) + tag = (10 << 11) | (fun << 8); + } + + addr = 0x80000000 | tag | offset; + bus_space_write_4(sc->sc_iot, sc->sc_cfg_ioh, 0, addr); + bus_space_read_4(sc->sc_iot, sc->sc_cfg_ioh, 0); + data = bus_space_read_4(sc->sc_iot, sc->sc_cfg_ioh, 4); + bus_space_write_4(sc->sc_iot, sc->sc_cfg_ioh, 0, 0); + bus_space_read_4(sc->sc_iot, sc->sc_cfg_ioh, 0); + + return (data); +} + +void +socpcic_conf_write(void *cpv, pcitag_t tag, int offset, pcireg_t data) +{ + struct socpcic_softc *sc = cpv; + int bus, dev, fun; + pcireg_t addr; + + socpcic_decompose_tag(sc, tag, &bus, &dev, &fun); + if (bus == 0) { + if (dev > 0 && dev < 11) + return; + if (dev == 31) + tag = (10 << 11) | (fun << 8); + } + + addr = 0x80000000 | tag | offset; + bus_space_write_4(sc->sc_iot, sc->sc_cfg_ioh, 0, addr); + bus_space_read_4(sc->sc_iot, sc->sc_cfg_ioh, 0); + bus_space_write_4(sc->sc_iot, sc->sc_cfg_ioh, 4, data); + bus_space_write_4(sc->sc_iot, sc->sc_cfg_ioh, 0, 0); + bus_space_read_4(sc->sc_iot, sc->sc_cfg_ioh, 0); +} + +int +socpcic_intr_map(void *cpv, pcitag_t tag, int pin, int line, + pci_intr_handle_t *ihp) +{ + *ihp = 20; /* XXX */ + return (0); +} + +const char * +socpcic_intr_string(void *cpv, pci_intr_handle_t ih) +{ + static char str[16]; + + snprintf(str, sizeof str, "ivec %ld", ih); + return (str); +} + +int +socpcic_intr_line(void *cpv, pci_intr_handle_t ih) +{ + return (ih); +} + +void * +socpcic_intr_establish(void *cpv, pci_intr_handle_t ih, int level, + int (*func)(void *), void *arg, char *name) +{ + return (intr_establish(ih, IST_LEVEL, level, func, arg, name)); +} + +void +socpcic_intr_disestablish(void *lcv, void *cookie) +{ +} + +int +socpcic_ether_hw_addr(struct ppc_pci_chipset *lcpc, u_int8_t *oaddr) +{ + oaddr[0] = oaddr[1] = oaddr[2] = 0xff; + oaddr[3] = oaddr[4] = oaddr[5] = 0xff; + + return (0); +} + +int +socpcic_print(void *aux, const char *pnp) +{ + struct pcibus_attach_args *pba = aux; + + if (pnp) + printf("%s at %s", pba->pba_busname, pnp); + printf(" bus %d", pba->pba_bus); + return (UNCONF); +} diff --git a/sys/arch/socppc/include/_types.h b/sys/arch/socppc/include/_types.h new file mode 100644 index 00000000000..f6f4ea673a5 --- /dev/null +++ b/sys/arch/socppc/include/_types.h @@ -0,0 +1,3 @@ +/* $OpenBSD: _types.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/_types.h> diff --git a/sys/arch/socppc/include/asm.h b/sys/arch/socppc/include/asm.h new file mode 100644 index 00000000000..35852110f54 --- /dev/null +++ b/sys/arch/socppc/include/asm.h @@ -0,0 +1,3 @@ +/* $OpenBSD: asm.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/asm.h> diff --git a/sys/arch/socppc/include/atomic.h b/sys/arch/socppc/include/atomic.h new file mode 100644 index 00000000000..1dbd296cee4 --- /dev/null +++ b/sys/arch/socppc/include/atomic.h @@ -0,0 +1,3 @@ +/* $OpenBSD: atomic.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/atomic.h> diff --git a/sys/arch/socppc/include/autoconf.h b/sys/arch/socppc/include/autoconf.h new file mode 100644 index 00000000000..0f9ba3fc9e7 --- /dev/null +++ b/sys/arch/socppc/include/autoconf.h @@ -0,0 +1,45 @@ +/* $OpenBSD: autoconf.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _MACHINE_AUTOCONF_H_ +#define _MACHINE_AUTOCONF_H_ + +#include <machine/bus.h> + +struct mainbus_attach_args { + bus_space_tag_t ma_iot; + char *ma_name; +}; + +struct obio_attach_args { + bus_space_tag_t oa_iot; + bus_addr_t oa_offset; + int oa_ivec; + char *oa_name; +}; + +#define cf_offset cf_loc[0] +#define cf_ivec cf_loc[1] + +typedef int (time_read_t)(time_t *sec); +typedef int (time_write_t)(time_t sec); + +extern time_read_t *time_read; +extern time_write_t *time_write; + +#endif /* _MACHINE_AUTOCONF_H_ */ diff --git a/sys/arch/socppc/include/bat.h b/sys/arch/socppc/include/bat.h new file mode 100644 index 00000000000..16a586e725d --- /dev/null +++ b/sys/arch/socppc/include/bat.h @@ -0,0 +1,3 @@ +/* $OpenBSD: bat.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/bat.h> diff --git a/sys/arch/socppc/include/bus.h b/sys/arch/socppc/include/bus.h new file mode 100644 index 00000000000..81696e1d3ec --- /dev/null +++ b/sys/arch/socppc/include/bus.h @@ -0,0 +1,609 @@ +/* $OpenBSD: bus.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 1997 Per Fogelstrom. All rights reserved. + * Copyright (c) 1996 Niklas Hallqvist. 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. + */ + +#ifndef _MACHINE_BUS_H_ +#define _MACHINE_BUS_H_ + +#include <machine/pio.h> + +#ifdef __STDC__ +#define CAT(a,b) a##b +#define CAT3(a,b,c) a##b##c +#else +#define CAT(a,b) a/**/b +#define CAT3(a,b,c) a/**/b/**/c +#endif + +/* + * Bus access types. + */ +typedef u_long bus_addr_t; +typedef u_int32_t bus_size_t; +typedef u_int32_t bus_space_handle_t; +typedef struct ppc_bus_space *bus_space_tag_t; + +struct ppc_bus_space { + u_int32_t bus_base; + u_int32_t bus_size; + u_int8_t bus_io; /* IO or memory */ +}; +#define POWERPC_BUS_TAG_BASE(x) ((x)->bus_base) + +extern struct ppc_bus_space ppc_isa_io, ppc_isa_mem; + +/* + * Access methods for bus resources + */ +int bus_space_map(bus_space_tag_t t, bus_addr_t addr, + bus_size_t size, int cacheable, bus_space_handle_t *bshp); +void bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh, + bus_size_t size); +int bus_space_subregion(bus_space_tag_t t, bus_space_handle_t bsh, + bus_size_t offset, bus_size_t size, bus_space_handle_t *nbshp); +int bus_space_alloc(bus_space_tag_t tag, bus_addr_t rstart, + bus_addr_t rend, bus_size_t size, bus_size_t alignment, + bus_size_t boundary, int cacheable, bus_addr_t *addrp, + bus_space_handle_t *handlep); +void bus_space_free(bus_space_tag_t tag, bus_space_handle_t handle, + bus_size_t size); + +#define bus_space_read(n,m) \ +static __inline CAT3(u_int,m,_t) \ +CAT(bus_space_read_,n)(bus_space_tag_t bst, bus_space_handle_t bsh, \ + bus_addr_t ba) \ +{ \ + return CAT3(in,m,rb)((volatile CAT3(u_int,m,_t) *)(bsh + (ba))); \ +} + +bus_space_read(1,8) +bus_space_read(2,16) +bus_space_read(4,32) + +#define bus_space_read_8 !!! bus_space_read_8 unimplemented !!! + +#define bus_space_write(n,m) \ +static __inline void \ +CAT(bus_space_write_,n)(bus_space_tag_t bst, bus_space_handle_t bsh, \ + bus_addr_t ba, CAT3(u_int,m,_t) x) \ +{ \ + CAT3(out,m,rb)((volatile CAT3(u_int,m,_t) *)(bsh + (ba)), x); \ +} + +bus_space_write(1,8) +bus_space_write(2,16) +bus_space_write(4,32) + +#define bus_space_write_8 !!! bus_space_write_8 unimplemented !!! + +#define bus_space_read_multi(n, m) \ +static __inline void \ +CAT(bus_space_read_multi_,n)(bus_space_tag_t bst, bus_space_handle_t bsh, \ + bus_size_t ba, CAT3(u_int,m,_t) *buf, bus_size_t cnt) \ +{ \ + while (cnt--) \ + *buf++ = CAT(bus_space_read_,n)(bst, bsh, ba); \ +} + +bus_space_read_multi(1,8) +bus_space_read_multi(2,16) +bus_space_read_multi(4,32) + +#define bus_space_read_multi_8 !!! bus_space_read_multi_8 not implemented !!! + + +#define bus_space_write_multi_8 !!! bus_space_write_multi_8 not implemented !!! + +#define bus_space_write_multi(n, m) \ +static __inline void \ +CAT(bus_space_write_multi_,n)(bus_space_tag_t bst, bus_space_handle_t bsh, \ + bus_size_t ba, const CAT3(u_int,m,_t) *buf, bus_size_t cnt) \ +{ \ + while (cnt--) \ + CAT(bus_space_write_,n)(bst, bsh, ba, *buf++); \ +} + +bus_space_write_multi(1,8) +bus_space_write_multi(2,16) +bus_space_write_multi(4,32) + +#define bus_space_write_multi_8 !!! bus_space_write_multi_8 not implemented !!! + +/* + * void bus_space_read_region_N(bus_space_tag_t tag, + * bus_space_handle_t bsh, bus_size_t offset, + * u_intN_t *addr, size_t count); + * + * Read `count' 1, 2, 4, or 8 byte quantities from bus space + * described by tag/handle and starting at `offset' and copy into + * buffer provided. + */ +#define __BA(t, h, o) ((void *)((h) + (o))) + +static __inline void +bus_space_read_region_1(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, u_int8_t *addr, size_t count) +{ + volatile u_int8_t *s = __BA(tag, bsh, offset); + + while (count--) + *addr++ = *s++; + __asm __volatile("eieio; sync"); +} + +static __inline void +bus_space_read_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, u_int16_t *addr, size_t count) +{ + volatile u_int16_t *s = __BA(tag, bsh, offset); + + while (count--) + __asm __volatile("lhbrx %0, 0, %1" : + "=r"(*addr++) : "r"(s++)); + __asm __volatile("eieio; sync"); +} + +static __inline void +bus_space_read_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, u_int32_t *addr, size_t count) +{ + volatile u_int32_t *s = __BA(tag, bsh, offset); + + while (count--) + __asm __volatile("lwbrx %0, 0, %1" : + "=r"(*addr++) : "r"(s++)); + __asm __volatile("eieio; sync"); +} + +#if 0 /* Cause a link error for bus_space_read_region_8 */ +#define bus_space_read_region_8 !!! unimplemented !!! +#endif + + +/* + * void bus_space_write_region_N(bus_space_tag_t tag, + * bus_space_handle_t bsh, bus_size_t offset, + * const u_intN_t *addr, size_t count); + * + * Write `count' 1, 2, 4, or 8 byte quantities from the buffer provided + * to bus space described by tag/handle starting at `offset'. + */ + +static __inline void +bus_space_write_region_1(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, const u_int8_t *addr, size_t count) +{ + volatile u_int8_t *d = __BA(tag, bsh, offset); + + while (count--) + *d++ = *addr++; + __asm __volatile("eieio; sync"); +} + +static __inline void +bus_space_write_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, const u_int16_t *addr, size_t count) +{ + volatile u_int16_t *d = __BA(tag, bsh, offset); + + while (count--) + __asm __volatile("sthbrx %0, 0, %1" :: + "r"(*addr++), "r"(d++)); + __asm __volatile("eieio; sync"); +} + +static __inline void +bus_space_write_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, const u_int32_t *addr, size_t count) +{ + volatile u_int32_t *d = __BA(tag, bsh, offset); + + while (count--) + __asm __volatile("stwbrx %0, 0, %1" :: + "r"(*addr++), "r"(d++)); + __asm __volatile("eieio; sync"); +} + +#if 0 +#define bus_space_write_region_8 !!! bus_space_write_region_8 unimplemented !!! +#endif + +/* + * void bus_space_read_raw_region_N(bus_space_tag_t tag, + * bus_space_handle_t bsh, bus_size_t offset, + * u_intN_t *addr, size_t count); + * + * Read `count' bytes from bus space described by tag/handle and starting + * at `offset' and copy into buffer provided w/o bus-host byte swapping. + */ + +static __inline void +bus_space_read_raw_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, u_int8_t *addr, size_t count) +{ + volatile u_int16_t *s = __BA(tag, bsh, offset); + u_int16_t *laddr = (void *)addr; + + count = count >> 1; + + while (count--) + *laddr++ = *s++; + __asm __volatile("eieio; sync"); +} + +static __inline void +bus_space_read_raw_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, u_int8_t *addr, size_t count) +{ + volatile u_int32_t *s = __BA(tag, bsh, offset); + u_int32_t *laddr = (void *)addr; + + count = count >> 2; + + while (count--) + *laddr++ = *s++; + __asm __volatile("eieio; sync"); +} + +#if 0 /* Cause a link error for bus_space_read_raw_region_8 */ +#define bus_space_read_raw_region_8 \ + !!! bus_space_read_raw_region_8 unimplemented !!! +#endif + + +/* + * void bus_space_write_raw_region_N(bus_space_tag_t tag, + * bus_space_handle_t bsh, bus_size_t offset, + * const u_intN_t *addr, size_t count); + * + * Write `count' bytes from the buffer provided to bus space described + * by tag/handle starting at `offset' w/o host-bus byte swapping. + */ + +static __inline void +bus_space_write_raw_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, const u_int8_t *addr, size_t count) +{ + volatile u_int16_t *d = __BA(tag, bsh, offset); + const u_int16_t *laddr = (void *)addr; + + count = count >> 1; + + while (count--) + *d++ = *laddr++; + __asm __volatile("eieio; sync"); +} + +static __inline void +bus_space_write_raw_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, + bus_size_t offset, const u_int8_t *addr, size_t count) +{ + volatile u_int32_t *d = __BA(tag, bsh, offset); + const u_int32_t *laddr = (void *)addr; + + count = count >> 2; + + while (count--) + *d++ = *laddr++; + __asm __volatile("eieio; sync"); +} + +#if 0 +#define bus_space_write_raw_region_8 \ + !!! bus_space_write_raw_region_8 unimplemented !!! +#endif + +/* + * void bus_space_set_multi_N(bus_space_tag_t tag, + * bus_space_handle_t bsh, bus_size_t offset, u_intN_t val, + * size_t count); + * + * Write the 1, 2, 4, or 8 byte value `val' to bus space described + * by tag/handle/offset `count' times. + */ +static __inline void bus_space_set_multi_1(bus_space_tag_t, + bus_space_handle_t, bus_size_t, u_int8_t, size_t); +static __inline void bus_space_set_multi_2(bus_space_tag_t, + bus_space_handle_t, bus_size_t, u_int16_t, size_t); +static __inline void bus_space_set_multi_4(bus_space_tag_t, + bus_space_handle_t, bus_size_t, u_int32_t, size_t); + +static __inline void +bus_space_set_multi_1(tag, bsh, offset, val, count) + bus_space_tag_t tag; + bus_space_handle_t bsh; + bus_size_t offset; + u_int8_t val; + size_t count; +{ + volatile u_int8_t *d = __BA(tag, bsh, offset); + + while (count--) + *d = val; + __asm__ volatile("eieio; sync"); +} + +static __inline void +bus_space_set_multi_2(tag, bsh, offset, val, count) + bus_space_tag_t tag; + bus_space_handle_t bsh; + bus_size_t offset; + u_int16_t val; + size_t count; +{ + volatile u_int16_t *d = __BA(tag, bsh, offset); + + while (count--) + __asm__ volatile("sthbrx %0, 0, %1" :: + "r"(val), "r"(d)); + __asm__ volatile("eieio; sync"); +} + +static __inline void +bus_space_set_multi_4(tag, bsh, offset, val, count) + bus_space_tag_t tag; + bus_space_handle_t bsh; + bus_size_t offset; + u_int32_t val; + size_t count; +{ + volatile u_int32_t *d = __BA(tag, bsh, offset); + + while (count--) + __asm__ volatile("stwbrx %0, 0, %1" :: + "r"(val), "r"(d)); + __asm__ volatile("eieio; sync"); +} + +#define bus_space_set_multi_8 !!! bus_space_set_multi_8 unimplemented !!! + +/* These are OpenBSD extensions to the general NetBSD bus interface. */ +void +bus_space_read_raw_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh, + bus_addr_t ba, u_int8_t *dst, bus_size_t size); +void +bus_space_read_raw_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh, + bus_addr_t ba, u_int8_t *dst, bus_size_t size); +#define bus_space_read_raw_multi_8 \ + !!! bus_space_read_raw_multi_8 not implemented !!! + +void +bus_space_write_raw_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh, + bus_addr_t ba, const u_int8_t *src, bus_size_t size); +void +bus_space_write_raw_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh, + bus_addr_t ba, const u_int8_t *src, bus_size_t size); +#define bus_space_write_raw_multi_8 \ + !!! bus_space_write_raw_multi_8 not implemented !!! + +void +bus_space_set_region_1(bus_space_tag_t bst, bus_space_handle_t h, bus_size_t o, + u_int8_t val, bus_size_t c); +void +bus_space_set_region_2(bus_space_tag_t bst, bus_space_handle_t h, bus_size_t o, + u_int16_t val, bus_size_t c); +void +bus_space_set_region_4(bus_space_tag_t bst, bus_space_handle_t h, bus_size_t o, + u_int32_t val, bus_size_t c); +#define bus_space_set_region_8 \ + !!! bus_space_set_region_8 not implemented !!! + +void +bus_space_copy_1(void *v, bus_space_handle_t h1, bus_space_handle_t h2, + bus_size_t o1, bus_size_t o2, bus_size_t c); +void +bus_space_copy_2(void *v, bus_space_handle_t h1, bus_space_handle_t h2, + bus_size_t o1, bus_size_t o2, bus_size_t c); +void +bus_space_copy_4(void *v, bus_space_handle_t h1, bus_space_handle_t h2, + bus_size_t o1, bus_size_t o2, bus_size_t c); +#define bus_space_copy_8 \ + !!! bus_space_write_raw_multi_8 not implemented !!! + +/* + * Bus read/write barrier methods. + * + * void bus_space_barrier(bus_space_tag_t tag, + * bus_space_handle_t bsh, bus_size_t offset, + * bus_size_t len, int flags); + * + * Note: powerpc does not currently implement barriers, but we must + * provide the flags to MI code. + * the processor does have eieio which is effectively the barrier + * operator, however due to how memory is mapped this should? not + * be required. + */ +#define bus_space_barrier(t, h, o, l, f) \ + ((void)((void)(t), (void)(h), (void)(o), (void)(l), (void)(f))) +#define BUS_SPACE_BARRIER_READ 0x01 /* force read barrier */ +#define BUS_SPACE_BARRIER_WRITE 0x02 /* force write barrier */ +/* Compatibility defines */ +#define BUS_BARRIER_READ BUS_SPACE_BARRIER_READ +#define BUS_BARRIER_WRITE BUS_SPACE_BARRIER_WRITE + + +#define BUS_DMA_WAITOK 0x000 /* safe to sleep (pseudo-flag) */ +#define BUS_DMA_NOWAIT 0x001 /* not safe to sleep */ +#define BUS_DMA_ALLOCNOW 0x002 /* perform resource allocation now */ +#define BUS_DMAMEM_NOSYNC 0x004 +#define BUS_DMA_COHERENT 0x008 /* hint: map memory DMA coherent */ +#define BUS_DMA_BUS1 0x010 /* placeholders for bus functions... */ +#define BUS_DMA_BUS2 0x020 +#define BUS_DMA_BUS3 0x040 +#define BUS_DMA_BUS4 0x080 +#define BUS_DMA_READ 0x100 /* mapping is device -> memory only */ +#define BUS_DMA_WRITE 0x200 /* mapping is memory -> device only */ +#define BUS_DMA_STREAMING 0x400 /* hint: sequential, unidirectional */ + + +/* Forwards needed by prototypes below. */ +struct mbuf; +struct proc; +struct uio; + +#define BUS_DMASYNC_POSTREAD 0x01 +#define BUS_DMASYNC_POSTWRITE 0x02 +#define BUS_DMASYNC_PREREAD 0x04 +#define BUS_DMASYNC_PREWRITE 0x08 + +typedef struct powerpc_bus_dma_tag *bus_dma_tag_t; +typedef struct powerpc_bus_dmamap *bus_dmamap_t; + +/* + * bus_dma_segment_t + * + * Describes a single contiguous DMA transaction. Values + * are suitable for programming into DMA registers. + */ +struct powerpc_bus_dma_segment { + bus_addr_t ds_addr; /* DMA address */ + bus_size_t ds_len; /* length of transfer */ +}; +typedef struct powerpc_bus_dma_segment bus_dma_segment_t; + +/* + * bus_dma_tag_t + * + * A machine-dependent opaque type describing the implementation of + * DMA for a given bus. + */ + +struct powerpc_bus_dma_tag { + void *_cookie; /* cookie used in the guts */ + + /* + * DMA mapping methods. + */ + int (*_dmamap_create)(bus_dma_tag_t , bus_size_t, int, + bus_size_t, bus_size_t, int, bus_dmamap_t *); + void (*_dmamap_destroy)(bus_dma_tag_t , bus_dmamap_t); + int (*_dmamap_load)(bus_dma_tag_t , bus_dmamap_t, void *, + bus_size_t, struct proc *, int); + int (*_dmamap_load_mbuf)(bus_dma_tag_t , bus_dmamap_t, + struct mbuf *, int); + int (*_dmamap_load_uio)(bus_dma_tag_t , bus_dmamap_t, + struct uio *, int); + int (*_dmamap_load_raw)(bus_dma_tag_t , bus_dmamap_t, + bus_dma_segment_t *, int, bus_size_t, int); + void (*_dmamap_unload)(bus_dma_tag_t , bus_dmamap_t); + void (*_dmamap_sync)(bus_dma_tag_t , bus_dmamap_t, + bus_addr_t, bus_size_t, int); + + /* + * DMA memory utility functions. + */ + int (*_dmamem_alloc)(bus_dma_tag_t, bus_size_t, bus_size_t, + bus_size_t, bus_dma_segment_t *, int, int *, int); + void (*_dmamem_free)(bus_dma_tag_t, bus_dma_segment_t *, int); + int (*_dmamem_map)(bus_dma_tag_t, bus_dma_segment_t *, + int, size_t, caddr_t *, int); + void (*_dmamem_unmap)(bus_dma_tag_t, caddr_t, size_t); + paddr_t (*_dmamem_mmap)(bus_dma_tag_t, bus_dma_segment_t *, + int, off_t, int, int); +}; + +#define bus_dmamap_create(t, s, n, m, b, f, p) \ + (*(t)->_dmamap_create)((t), (s), (n), (m), (b), (f), (p)) +#define bus_dmamap_destroy(t, p) \ + (*(t)->_dmamap_destroy)((t), (p)) +#define bus_dmamap_load(t, m, b, s, p, f) \ + (*(t)->_dmamap_load)((t), (m), (b), (s), (p), (f)) +#define bus_dmamap_load_mbuf(t, m, b, f) \ + (*(t)->_dmamap_load_mbuf)((t), (m), (b), (f)) +#define bus_dmamap_load_uio(t, m, u, f) \ + (*(t)->_dmamap_load_uio)((t), (m), (u), (f)) +#define bus_dmamap_load_raw(t, m, sg, n, s, f) \ + (*(t)->_dmamap_load_raw)((t), (m), (sg), (n), (s), (f)) +#define bus_dmamap_unload(t, p) \ + (*(t)->_dmamap_unload)((t), (p)) +#define bus_dmamap_sync(t, p, a, l, o) \ + (void)((t)->_dmamap_sync ? \ + (*(t)->_dmamap_sync)((t), (p), (a), (l), (o)) : (void)0) + +#define bus_dmamem_alloc(t, s, a, b, sg, n, r, f) \ + (*(t)->_dmamem_alloc)((t)->_cookie, (s), (a), (b), (sg), (n), (r), (f)) +#define bus_dmamem_free(t, sg, n) \ + (*(t)->_dmamem_free)((t)->_cookie, (sg), (n)) +#define bus_dmamem_map(t, sg, n, s, k, f) \ + (*(t)->_dmamem_map)((t)->_cookie, (sg), (n), (s), (k), (f)) +#define bus_dmamem_unmap(t, k, s) \ + (*(t)->_dmamem_unmap)((t)->_cookie, (k), (s)) +#define bus_dmamem_mmap(t, sg, n, o, p, f) \ + (*(t)->_dmamem_mmap)((t)->_cookie, (sg), (n), (o), (p), (f)) + +int _dmamap_create(bus_dma_tag_t, bus_size_t, int, + bus_size_t, bus_size_t, int, bus_dmamap_t *); +void _dmamap_destroy(bus_dma_tag_t, bus_dmamap_t); +int _dmamap_load(bus_dma_tag_t, bus_dmamap_t, void *, + bus_size_t, struct proc *, int); +int _dmamap_load_mbuf(bus_dma_tag_t, bus_dmamap_t, struct mbuf *, int); +int _dmamap_load_uio(bus_dma_tag_t, bus_dmamap_t, struct uio *, int); +int _dmamap_load_raw(bus_dma_tag_t, bus_dmamap_t, + bus_dma_segment_t *, int, bus_size_t, int); +void _dmamap_unload(bus_dma_tag_t, bus_dmamap_t); +void _dmamap_sync(bus_dma_tag_t, bus_dmamap_t, bus_addr_t, bus_size_t, + int); + +int _dmamem_alloc(bus_dma_tag_t, bus_size_t, bus_size_t, + bus_size_t, bus_dma_segment_t *, int, int *, int); +void _dmamem_free(bus_dma_tag_t, bus_dma_segment_t *, int); +int _dmamem_map(bus_dma_tag_t, bus_dma_segment_t *, + int, size_t, caddr_t *, int); +void _dmamem_unmap(bus_dma_tag_t, caddr_t, size_t); +paddr_t _dmamem_mmap(bus_dma_tag_t, bus_dma_segment_t *, int, off_t, int, int); + +/* + * bus_dmamap_t + * + * Describes a DMA mapping. + */ +struct powerpc_bus_dmamap { + /* + * PRIVATE MEMBERS: not for use by machine-independent code. + */ + bus_size_t _dm_size; /* largest DMA transfer mappable */ + int _dm_segcnt; /* number of segs this map can map */ + bus_size_t _dm_maxsegsz; /* largest possible segment */ + bus_size_t _dm_boundary; /* don't cross this */ + int _dm_flags; /* misc. flags */ + + void *_dm_cookie; /* cookie for bus-specific functions */ + + /* + * PUBLIC MEMBERS: these are used by machine-independent code. + */ + bus_size_t dm_mapsize; /* size of the mapping */ + int dm_nsegs; /* # valid segments in mapping */ + bus_dma_segment_t dm_segs[1]; /* segments; variable length */ +}; + +#endif /* _MACHINE_BUS_H_ */ diff --git a/sys/arch/socppc/include/cdefs.h b/sys/arch/socppc/include/cdefs.h new file mode 100644 index 00000000000..8362c75969c --- /dev/null +++ b/sys/arch/socppc/include/cdefs.h @@ -0,0 +1,3 @@ +/* $OpenBSD: cdefs.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/cdefs.h> diff --git a/sys/arch/socppc/include/conf.h b/sys/arch/socppc/include/conf.h new file mode 100644 index 00000000000..2797e30ad4c --- /dev/null +++ b/sys/arch/socppc/include/conf.h @@ -0,0 +1,37 @@ +/* $OpenBSD: conf.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: conf.h,v 1.2 1996/05/05 19:28:34 christos Exp $ */ + +/* + * Copyright (c) 1996 Christos Zoulas. 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 Christos Zoulas. + * 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/conf.h> + +#define mmread mmrw +#define mmwrite mmrw +cdev_decl(mm); diff --git a/sys/arch/socppc/include/cpu.h b/sys/arch/socppc/include/cpu.h new file mode 100644 index 00000000000..9e21d0c6084 --- /dev/null +++ b/sys/arch/socppc/include/cpu.h @@ -0,0 +1,53 @@ +/* $OpenBSD: cpu.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: cpu.h,v 1.1 1996/09/30 16:34:21 ws Exp $ */ + +/* + * Copyright (C) 1995, 1996 Wolfgang Solfrank. + * Copyright (C) 1995, 1996 TooLs GmbH. + * 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 TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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. + */ + +#ifndef _MACHINE_CPU_H_ +#define _MACHINE_CPU_H_ + +#include <powerpc/cpu.h> + +/* + * CTL_MACHDEP definitions. + */ +#define CPU_ALLOWAPERTURE 1 /* allow mmap of /dev/xf86 */ +#define CPU_ALTIVEC 2 /* altivec is present */ +#define CPU_MAXID 3 /* number of valid machdep ids */ + +#define CTL_MACHDEP_NAMES { \ + { 0, 0 }, \ + { "allowaperture", CTLTYPE_INT }, \ + { "altivec", CTLTYPE_INT }, \ +} + +#endif /* _MACHINE_CPU_H_ */ diff --git a/sys/arch/socppc/include/db_machdep.h b/sys/arch/socppc/include/db_machdep.h new file mode 100644 index 00000000000..df6783f5cc6 --- /dev/null +++ b/sys/arch/socppc/include/db_machdep.h @@ -0,0 +1,3 @@ +/* $OpenBSD: db_machdep.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/db_machdep.h> diff --git a/sys/arch/socppc/include/disklabel.h b/sys/arch/socppc/include/disklabel.h new file mode 100644 index 00000000000..1bf6635ae0f --- /dev/null +++ b/sys/arch/socppc/include/disklabel.h @@ -0,0 +1,90 @@ +/* $OpenBSD: disklabel.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 1994 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. + * 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. + */ + +#ifndef _MACHINE_DISKLABEL_H_ +#define _MACHINE_DISKLABEL_H_ + +#define LABELSECTOR 1 /* sector containing label */ +#define LABELOFFSET 0 /* offset of label in sector */ +#define MAXPARTITIONS 16 /* number of partitions */ + +/* HFS/DPME */ + +/* partition map structure from Inside Macintosh: Devices, SCSI Manager + * pp. 13-14. The partition map always begins on physical block 1. + * + * With the exception of block 0, all blocks on the disk must belong to + * exactly one partition. The partition map itself belongs to a partition + * of type `APPLE_PARTITION_MAP', and is not limited in size by anything + * other than available disk space. The partition map is not necessarily + * the first partition listed. + */ +struct part_map_entry { +#define PART_ENTRY_MAGIC 0x504d + u_int16_t pmSig; /* partition signature */ + u_int16_t pmSigPad; /* (reserved) */ + u_int32_t pmMapBlkCnt; /* number of blocks in partition map */ + u_int32_t pmPyPartStart; /* first physical block of partition */ + u_int32_t pmPartBlkCnt; /* number of blocks in partition */ + char pmPartName[32]; /* partition name */ + char pmPartType[32]; /* partition type */ + u_int32_t pmLgDataStart; /* first logical block of data area */ + u_int32_t pmDataCnt; /* number of blocks in data area */ + u_int32_t pmPartStatus; /* partition status information */ + u_int32_t pmLgBootStart; /* first logical block of boot code */ + u_int32_t pmBootSize; /* size of boot code, in bytes */ + u_int32_t pmBootLoad; /* boot code load address */ + u_int32_t pmBootLoad2; /* (reserved) */ + u_int32_t pmBootEntry; /* boot code entry point */ + u_int32_t pmBootEntry2; /* (reserved) */ + u_int32_t pmBootCksum; /* boot code checksum */ + char pmProcessor[16]; /* processor type (e.g. "68020") */ + u_int8_t pmBootArgs[128]; /* A/UX boot arguments */ + /* we do not index the disk image as an array, + * leave out the on disk padding + */ +#if 0 + u_int8_t pad[248]; /* pad to end of block */ +#endif +}; + +#define PART_TYPE_DRIVER "APPLE_DRIVER" +#define PART_TYPE_DRIVER43 "APPLE_DRIVER43" +#define PART_TYPE_DRIVERATA "APPLE_DRIVER_ATA" +#define PART_TYPE_DRIVERIOKIT "APPLE_DRIVER_IOKIT" +#define PART_TYPE_FWDRIVER "APPLE_FWDRIVER" +#define PART_TYPE_FWB_COMPONENT "FWB DRIVER COMPONENTS" +#define PART_TYPE_FREE "APPLE_FREE" +#define PART_TYPE_MAC "APPLE_HFS" +#define PART_TYPE_OPENBSD "OPENBSD" + +#endif /* _MACHINE_DISKLABEL_H_ */ diff --git a/sys/arch/socppc/include/endian.h b/sys/arch/socppc/include/endian.h new file mode 100644 index 00000000000..1a72bba14a8 --- /dev/null +++ b/sys/arch/socppc/include/endian.h @@ -0,0 +1,3 @@ +/* $OpenBSD: endian.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/endian.h> diff --git a/sys/arch/socppc/include/exec.h b/sys/arch/socppc/include/exec.h new file mode 100644 index 00000000000..01c0c5722a1 --- /dev/null +++ b/sys/arch/socppc/include/exec.h @@ -0,0 +1,3 @@ +/* $OpenBSD: exec.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/exec.h> diff --git a/sys/arch/socppc/include/fpu.h b/sys/arch/socppc/include/fpu.h new file mode 100644 index 00000000000..83e3b628f83 --- /dev/null +++ b/sys/arch/socppc/include/fpu.h @@ -0,0 +1,3 @@ +/* $OpenBSD: fpu.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/fpu.h> diff --git a/sys/arch/socppc/include/frame.h b/sys/arch/socppc/include/frame.h new file mode 100644 index 00000000000..ba860b82dd9 --- /dev/null +++ b/sys/arch/socppc/include/frame.h @@ -0,0 +1,3 @@ +/* $OpenBSD: frame.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/frame.h> diff --git a/sys/arch/socppc/include/internal_types.h b/sys/arch/socppc/include/internal_types.h new file mode 100644 index 00000000000..4eb1ac1cfe1 --- /dev/null +++ b/sys/arch/socppc/include/internal_types.h @@ -0,0 +1,3 @@ +/* $OpenBSD: internal_types.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/internal_types.h> diff --git a/sys/arch/socppc/include/intr.h b/sys/arch/socppc/include/intr.h new file mode 100644 index 00000000000..f79a4c6d006 --- /dev/null +++ b/sys/arch/socppc/include/intr.h @@ -0,0 +1,11 @@ +/* $OpenBSD: intr.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/intr.h> + +#ifndef _LOCORE + +void softtty(void); + +void *intr_establish(int, int, int, int (*)(void *), void *, const char *); + +#endif diff --git a/sys/arch/socppc/include/limits.h b/sys/arch/socppc/include/limits.h new file mode 100644 index 00000000000..d6468bd2aa1 --- /dev/null +++ b/sys/arch/socppc/include/limits.h @@ -0,0 +1,3 @@ +/* $OpenBSD: limits.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/limits.h> diff --git a/sys/arch/socppc/include/lock.h b/sys/arch/socppc/include/lock.h new file mode 100644 index 00000000000..0ec5a702b00 --- /dev/null +++ b/sys/arch/socppc/include/lock.h @@ -0,0 +1,3 @@ +/* $OpenBSD: lock.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/lock.h> diff --git a/sys/arch/socppc/include/mutex.h b/sys/arch/socppc/include/mutex.h new file mode 100644 index 00000000000..6564781e0c5 --- /dev/null +++ b/sys/arch/socppc/include/mutex.h @@ -0,0 +1,3 @@ +/* $OpenBSD: mutex.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/mutex.h> diff --git a/sys/arch/socppc/include/param.h b/sys/arch/socppc/include/param.h new file mode 100644 index 00000000000..161ce9f6e9c --- /dev/null +++ b/sys/arch/socppc/include/param.h @@ -0,0 +1,51 @@ +/* $OpenBSD: param.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: param.h,v 1.1 1996/09/30 16:34:28 ws Exp $ */ + +/*- + * Copyright (C) 1995, 1996 Wolfgang Solfrank. + * Copyright (C) 1995, 1996 TooLs GmbH. + * 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 TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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. + */ + +#ifdef _KERNEL +#ifndef _LOCORE +#include <machine/cpu.h> +#endif /* _LOCORE */ +#endif + +#include <powerpc/param.h> + +/* + * Machine dependent constants for socppc + */ +#define MACHINE "socppc" +#define _MACHINE socppc + +#define KERNBASE 0x200000 + +#define MSGBUFSIZE (NBPG*2) diff --git a/sys/arch/socppc/include/pcb.h b/sys/arch/socppc/include/pcb.h new file mode 100644 index 00000000000..0fde40255c1 --- /dev/null +++ b/sys/arch/socppc/include/pcb.h @@ -0,0 +1,3 @@ +/* $OpenBSD: pcb.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/pcb.h> diff --git a/sys/arch/socppc/include/pio.h b/sys/arch/socppc/include/pio.h new file mode 100644 index 00000000000..6be1eecbd9c --- /dev/null +++ b/sys/arch/socppc/include/pio.h @@ -0,0 +1,3 @@ +/* $OpenBSD: pio.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/pio.h> diff --git a/sys/arch/socppc/include/pmap.h b/sys/arch/socppc/include/pmap.h new file mode 100644 index 00000000000..b310d018415 --- /dev/null +++ b/sys/arch/socppc/include/pmap.h @@ -0,0 +1,3 @@ +/* $OpenBSD: pmap.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/pmap.h> diff --git a/sys/arch/socppc/include/powerpc.h b/sys/arch/socppc/include/powerpc.h new file mode 100644 index 00000000000..378d9259b93 --- /dev/null +++ b/sys/arch/socppc/include/powerpc.h @@ -0,0 +1,94 @@ +/* $OpenBSD: powerpc.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: powerpc.h,v 1.1 1996/09/30 16:34:30 ws Exp $ */ + +/* + * Copyright (C) 1996 Wolfgang Solfrank. + * Copyright (C) 1996 TooLs GmbH. + * 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 TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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. + */ + +#ifndef _MACHINE_POWERPC_H_ +#define _MACHINE_POWERPC_H_ + +struct mem_region { + vaddr_t start; + vsize_t size; +}; + +void mem_regions(struct mem_region **, struct mem_region **); + +/* + * These two functions get used solely in boot() in machdep.c. + * + * Not sure whether boot itself should be implementation dependent instead. XXX + */ +typedef void (exit_f)(void) /*__attribute__((__noreturn__))*/ ; +typedef void (boot_f)(char *bootspec) /* __attribute__((__noreturn__))*/ ; +typedef void (vmon_f)(void); + +/* firmware interface. + * regardless of type of firmware used several items + * are need from firmware to boot up. + * these include: + * memory information + * vmsetup for firmware calls. + * default character print mechanism ??? + * firmware exit (return) + * firmware boot (reset) + * vmon - tell firmware the bsd vm is active. + */ + +typedef void (mem_regions_f)(struct mem_region **memp, + struct mem_region **availp); + +struct firmware { + mem_regions_f *mem_regions; + exit_f *exit; + boot_f *boot; + vmon_f *vmon; + +#ifdef FW_HAS_PUTC + boot_f *putc; +#endif +}; +extern struct firmware *fw; +int ppc_open_pci_bridge(void); +void ppc_close_pci_bridge(int); +void install_extint(void (*handler) (void)); +void ppc_intr_enable(int enable); +int ppc_intr_disable(void); + +struct dumpmem { + vaddr_t start; + vsize_t end; +}; +extern struct dumpmem dumpmem[VM_PHYSSEG_MAX]; +extern u_int ndumpmem; +extern vaddr_t dumpspace; + +#endif /* _MACHINE_POWERPC_H_ */ diff --git a/sys/arch/socppc/include/proc.h b/sys/arch/socppc/include/proc.h new file mode 100644 index 00000000000..1b78bbf4d75 --- /dev/null +++ b/sys/arch/socppc/include/proc.h @@ -0,0 +1,3 @@ +/* $OpenBSD: proc.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/proc.h> diff --git a/sys/arch/socppc/include/psl.h b/sys/arch/socppc/include/psl.h new file mode 100644 index 00000000000..2efac1c8750 --- /dev/null +++ b/sys/arch/socppc/include/psl.h @@ -0,0 +1,3 @@ +/* $OpenBSD: psl.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/psl.h> diff --git a/sys/arch/socppc/include/pte.h b/sys/arch/socppc/include/pte.h new file mode 100644 index 00000000000..cca262bf6e7 --- /dev/null +++ b/sys/arch/socppc/include/pte.h @@ -0,0 +1,3 @@ +/* $OpenBSD: pte.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/pte.h> diff --git a/sys/arch/socppc/include/ptrace.h b/sys/arch/socppc/include/ptrace.h new file mode 100644 index 00000000000..1c82569d472 --- /dev/null +++ b/sys/arch/socppc/include/ptrace.h @@ -0,0 +1,3 @@ +/* $OpenBSD: ptrace.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/ptrace.h> diff --git a/sys/arch/socppc/include/reg.h b/sys/arch/socppc/include/reg.h new file mode 100644 index 00000000000..26ed5eaa4e2 --- /dev/null +++ b/sys/arch/socppc/include/reg.h @@ -0,0 +1,3 @@ +/* $OpenBSD: reg.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/reg.h> diff --git a/sys/arch/socppc/include/signal.h b/sys/arch/socppc/include/signal.h new file mode 100644 index 00000000000..7ab86d1b3fe --- /dev/null +++ b/sys/arch/socppc/include/signal.h @@ -0,0 +1,3 @@ +/* $OpenBSD: signal.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/signal.h> diff --git a/sys/arch/socppc/include/spinlock.h b/sys/arch/socppc/include/spinlock.h new file mode 100644 index 00000000000..22bbf5008eb --- /dev/null +++ b/sys/arch/socppc/include/spinlock.h @@ -0,0 +1,3 @@ +/* $OpenBSD: spinlock.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/spinlock.h> diff --git a/sys/arch/socppc/include/trap.h b/sys/arch/socppc/include/trap.h new file mode 100644 index 00000000000..80a0f96d872 --- /dev/null +++ b/sys/arch/socppc/include/trap.h @@ -0,0 +1,3 @@ +/* $OpenBSD: trap.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +#include <powerpc/trap.h> diff --git a/sys/arch/socppc/include/vmparam.h b/sys/arch/socppc/include/vmparam.h new file mode 100644 index 00000000000..0cdd4986416 --- /dev/null +++ b/sys/arch/socppc/include/vmparam.h @@ -0,0 +1,114 @@ +/* $OpenBSD: vmparam.h,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: vmparam.h,v 1.1 1996/09/30 16:34:38 ws Exp $ */ + +/*- + * Copyright (C) 1995, 1996 Wolfgang Solfrank. + * Copyright (C) 1995, 1996 TooLs GmbH. + * 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 TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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. + */ + +#ifndef MACHINE_VMPARAM_H +#define MACHINE_VMPARAM_H + +#define USRTEXT PAGE_SIZE +#define USRSTACK VM_MAXUSER_ADDRESS + +#ifndef MAXTSIZ +#define MAXTSIZ (64*1024*1024) /* max text size */ +#endif + +#ifndef DFLDSIZ +#define DFLDSIZ (64*1024*1024) /* default data size */ +#endif + +#ifndef MAXDSIZ +#define MAXDSIZ (512*1024*1024) /* max data size */ +#endif + +#ifndef DFLSSIZ +#define DFLSSIZ (1*1024*1024) /* default stack size */ +#endif + +#ifndef MAXSSIZ +#define MAXSSIZ (32*1024*1024) /* max stack size */ +#endif + +#define STACKGAP_RANDOM 256*1024 + +/* + * Size of shared memory map + */ +#ifndef SHMMAXPGS +#define SHMMAXPGS 8192 /* 32mb */ +#endif + +/* + * Size of User Raw I/O map + */ +#define USRIOSIZE 1024 + +/* + * Would like to have MAX addresses = 0, but this doesn't (currently) work + */ +#define VM_MIN_ADDRESS ((vaddr_t)0) +#define VM_MAXUSER_ADDRESS ((vaddr_t)0xfffff000) +#define VM_MAX_ADDRESS VM_MAXUSER_ADDRESS +#define VM_MIN_KERNEL_ADDRESS ((vaddr_t)(PPC_KERNEL_SR << ADDR_SR_SHIFT)) + +/* ppc_kvm_stolen is so that vm space can be stolen before vm is fully + * initialized. + */ +extern vaddr_t ppc_kvm_stolen; +#define VM_KERN_ADDRESS_SIZE (PPC_SEGMENT_LENGTH - (32 * 1024 * 1024)) +#define VM_MAX_KERNEL_ADDRESS (VM_MIN_KERNEL_ADDRESS + VM_KERN_ADDRESS_SIZE) + +#define VM_PHYS_SIZE (USRIOSIZE * PAGE_SIZE) + +#define VM_PHYSSEG_MAX 32 /* actually we could have this many segments */ +#define VM_PHYSSEG_STRAT VM_PSTRAT_BSEARCH +#define VM_PHYSSEG_NOADD /* can't add RAM after vm_mem_init */ + +#define VM_NFREELIST 1 +#define VM_FREELIST_DEFAULT 0 + +#ifdef _KERNEL + +#define __HAVE_VM_PAGE_MD +struct pv_entry; +struct vm_page_md { + LIST_HEAD(,pte_desc) pv_list; +}; + +#define VM_MDPAGE_INIT(pg) do { \ + LIST_INIT(&((pg)->mdpage.pv_list)); \ +} while (0) + +#endif + + +#endif diff --git a/sys/arch/socppc/socppc/autoconf.c b/sys/arch/socppc/socppc/autoconf.c new file mode 100644 index 00000000000..90da6d18b0c --- /dev/null +++ b/sys/arch/socppc/socppc/autoconf.c @@ -0,0 +1,69 @@ +/* $OpenBSD: autoconf.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/reboot.h> + +#include <uvm/uvm_extern.h> + +#include <machine/powerpc.h> + +void dumpconf(void); + +int cold = 1; + +struct dumpmem dumpmem[VM_PHYSSEG_MAX]; +u_int ndumpmem; + +void +cpu_configure(void) +{ + splhigh(); + + if (config_rootfound("mainbus", "mainbus") == 0) + panic("no mainbus found"); + + /* Configuration is finished, turn on interrupts. */ + spl0(); + cold = 0; +} + +void +device_register(struct device *dev, void *aux) +{ +} + +void +diskconf(void) +{ + struct device *dv; + dev_t tmpdev; + + dv = parsedisk("wd0a", strlen("wd0a"), 0, &tmpdev); + setroot(dv, 0, RB_USERREQ); + dumpconf(); +} + +struct nam2blk nam2blk[] = { + { "wd", 0 }, + { "sd", 2 }, + { "rd", 17 }, + { "raid", 19 }, + { NULL, -1 } +}; diff --git a/sys/arch/socppc/socppc/clock.c b/sys/arch/socppc/socppc/clock.c new file mode 100644 index 00000000000..bb2bcb814a8 --- /dev/null +++ b/sys/arch/socppc/socppc/clock.c @@ -0,0 +1,342 @@ +/* $OpenBSD: clock.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: clock.c,v 1.1 1996/09/30 16:34:40 ws Exp $ */ + +/* + * Copyright (C) 1995, 1996 Wolfgang Solfrank. + * Copyright (C) 1995, 1996 TooLs GmbH. + * 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 TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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/param.h> +#include <sys/kernel.h> +#include <sys/systm.h> +#include <sys/timetc.h> + +#include <machine/autoconf.h> + +#include <dev/clock_subr.h> + +void decr_intr(struct clockframe *frame); +u_int tb_get_timecount(struct timecounter *); + +/* + * Initially we assume a processor with a bus frequency of 266 MHz. + */ +static u_int32_t ticks_per_sec = 66666666; +static u_int32_t ns_per_tick = 15; +static int32_t ticks_per_intr; + +static struct timecounter tb_timecounter = { + tb_get_timecount, NULL, 0x7fffffff, 0, "tb", 0, NULL +}; + +/* Global TOD clock handle. */ +todr_chip_handle_t todr_handle; + +/* vars for stats */ +int statint; +u_int32_t statvar; +u_int32_t statmin; + +static struct evcount clk_count; +static struct evcount stat_count; +static int clk_irq = PPC_CLK_IRQ; +static int stat_irq = PPC_STAT_IRQ; + +/* + * Set up the system's time, given a `reasonable' time value. + */ +void +inittodr(time_t base) +{ + int badbase = 0, waszero = base == 0; + char *bad = NULL; + struct timeval tv; + struct timespec ts; + + if (base < 5 * SECYR) { + /* + * If base is 0, assume filesystem time is just unknown + * instead of preposterous. Don't bark. + */ + if (base != 0) + printf("WARNING: preposterous time in file system\n"); + /* not going to use it anyway, if the chip is readable */ + base = 21*SECYR + 186*SECDAY + SECDAY/2; + badbase = 1; + } + + if (todr_handle != NULL && todr_gettime(todr_handle, &tv) != 0) + tv.tv_sec = tv.tv_usec = 0; + + if (tv.tv_sec == 0) { + /* + * Believe the time in the file system for lack of + * anything better, resetting the clock. + */ + bad = "WARNING: unable to get date/time"; + tv.tv_sec = base; + tv.tv_usec = 0; + if (!badbase) + resettodr(); + } else { + int deltat; + + tv.tv_sec += tz.tz_minuteswest * 60; + if (tz.tz_dsttime) + tv.tv_sec -= 3600; + + deltat = tv.tv_sec - base; + + if (deltat < 0) + deltat = -deltat; + if (!(waszero || deltat < 2 * SECDAY)) { + printf("WARNING: clock %s %d days", + tv.tv_sec < base ? "lost" : "gained", deltat / SECDAY); + bad = ""; + + if (tv.tv_sec < base && deltat > 1000 * SECDAY) { + printf(", using FS time"); + tv.tv_sec = base; + } + } + } + + ts.tv_sec = tv.tv_sec; + ts.tv_nsec = tv.tv_usec * 1000; + tc_setclock(&ts); + + if (bad) { + printf("%s", bad); + printf(" -- CHECK AND RESET THE DATE!\n"); + } +} + +/* + * Similar to the above + */ +void +resettodr(void) +{ + struct timeval tv; + + if (time_second == 0) + return; + + microtime(&tv); + + if (todr_handle == NULL || todr_settime(todr_handle, &tv) != 0) + printf("Cannot set time in time-of-day clock\n"); +} + +void +decr_intr(struct clockframe *frame) +{ + u_int64_t tb; + u_int64_t nextevent; + struct cpu_info *ci = curcpu(); + int nstats; + int s; + + /* + * Check whether we are initialized. + */ + if (!ticks_per_intr) + return; + + /* + * Based on the actual time delay since the last decrementer reload, + * we arrange for earlier interrupt next time. + */ + + tb = ppc_mftb(); + while (ci->ci_nexttimerevent <= tb) + ci->ci_nexttimerevent += ticks_per_intr; + + ci->ci_prevtb = ci->ci_nexttimerevent - ticks_per_intr; + + for (nstats = 0; ci->ci_nextstatevent <= tb; nstats++) { + int r; + do { + r = random() & (statvar -1); + } while (r == 0); /* random == 0 not allowed */ + ci->ci_nextstatevent += statmin + r; + } + + /* only count timer ticks for CLK_IRQ */ + stat_count.ec_count += nstats; + + if (ci->ci_nexttimerevent < ci->ci_nextstatevent) + nextevent = ci->ci_nexttimerevent; + else + nextevent = ci->ci_nextstatevent; + + /* + * Need to work about the near constant skew this introduces??? + * reloading tb here could cause a missed tick. + */ + ppc_mtdec(nextevent - tb); + + if (curcpu()->ci_cpl & SPL_CLOCK) { + ci->ci_statspending += nstats; + } else { + KERNEL_LOCK(); + + nstats += ci->ci_statspending; + ci->ci_statspending = 0; + + s = splclock(); + + /* + * Reenable interrupts + */ + ppc_intr_enable(1); + + /* + * Do standard timer interrupt stuff. + */ + while (ci->ci_lasttb < ci->ci_prevtb) { + /* sync lasttb with hardclock */ + ci->ci_lasttb += ticks_per_intr; + clk_count.ec_count++; + hardclock(frame); + } + + while (nstats-- > 0) + statclock(frame); + + splx(s); + (void) ppc_intr_disable(); + + /* if a tick has occurred while dealing with these, + * dont service it now, delay until the next tick. + */ + KERNEL_UNLOCK(); + } +} + +void cpu_startclock(void); + +void +cpu_initclocks(void) +{ + int intrstate; + int minint; + + intrstate = ppc_intr_disable(); + + stathz = 100; + profhz = 1000; /* must be a multiple of stathz */ + + /* init secondary clock to stathz */ + statint = ticks_per_sec / stathz; + statvar = 0x40000000; /* really big power of two */ + /* find largest 2^n which is nearly smaller than statint/2 */ + minint = statint / 2 + 100; + while (statvar > minint) + statvar >>= 1; + statmin = statint - (statvar >> 1); + + evcount_attach(&clk_count, "clock", (void *)&clk_irq, &evcount_intr); + evcount_attach(&stat_count, "stat", (void *)&stat_irq, &evcount_intr); + + ticks_per_intr = ticks_per_sec / hz; + cpu_startclock(); + + tb_timecounter.tc_frequency = ticks_per_sec; + tc_init(&tb_timecounter); + ppc_intr_enable(intrstate); +} + +void +cpu_startclock() +{ + struct cpu_info *ci = curcpu(); + u_int64_t nextevent; + + ci->ci_lasttb = ppc_mftb(); + + /* + * no point in having random on the first tick, + * it just complicates the code. + */ + ci->ci_nexttimerevent = ci->ci_lasttb + ticks_per_intr; + nextevent = ci->ci_nextstatevent = ci->ci_nexttimerevent; + + ci->ci_statspending = 0; + + ppc_mtdec(nextevent - ci->ci_lasttb); +} + +void +delay(unsigned n) +{ + u_int64_t tb; + u_int32_t tbh, tbl, scratch; + + tb = ppc_mftb(); + tb += (n * 1000 + ns_per_tick - 1) / ns_per_tick; + tbh = tb >> 32; + tbl = (u_int32_t)tb; + asm ("1: mftbu %0; cmplw %0,%1; blt 1b; bgt 2f;" + " mftb %0; cmplw %0,%2; blt 1b; 2:" + :: "r"(scratch), "r"(tbh), "r"(tbl)); +} + +/* + * Nothing to do. + */ +void +setstatclockrate(int newhz) +{ + int minint; + int intrstate; + + intrstate = ppc_intr_disable(); + + statint = ticks_per_sec / newhz; + statvar = 0x40000000; /* really big power of two */ + /* find largest 2^n which is nearly smaller than statint/2 */ + minint = statint / 2 + 100; + while (statvar > minint) + statvar >>= 1; + + statmin = statint - (statvar >> 1); + ppc_intr_enable(intrstate); + + /* + * XXX this allows the next stat timer to occur then it switches + * to the new frequency. Rather than switching instantly. + */ +} + +u_int +tb_get_timecount(struct timecounter *tc) +{ + return ppc_mftbl(); +} diff --git a/sys/arch/socppc/socppc/conf.c b/sys/arch/socppc/socppc/conf.c new file mode 100644 index 00000000000..db8ce25396c --- /dev/null +++ b/sys/arch/socppc/socppc/conf.c @@ -0,0 +1,287 @@ +/* $OpenBSD: conf.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 1997 Per Fogelstrom + * Copyright (c) 1997 RTMX Inc, North Carolina + * + * 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 under OpenBSD for RTMX Inc, + * North Carolina, USA, by Per Fogelstrom, Opsycon AB, Sweden. + * 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/param.h> +#include <sys/systm.h> +#include <sys/tty.h> + +#include <machine/conf.h> + +#include "sd.h" +#include "cd.h" +#include "rd.h" +#include "wd.h" +bdev_decl(wd); +cdev_decl(wd); + +#include "vnd.h" + +struct bdevsw bdevsw[] = { + bdev_disk_init(NWD,wd), /* 0: ST506/ESDI/IDE disk */ + bdev_swap_init(1,sw), /* 1 swap pseudo device */ + bdev_disk_init(NSD,sd), /* 2 SCSI Disk */ + bdev_disk_init(NCD,cd), /* 3 SCSI CD-ROM */ + bdev_notdef(), /* 4 unknown*/ + bdev_notdef(), /* 5 unknown*/ + bdev_notdef(), /* 6 unknown*/ + bdev_notdef(), /* 7 unknown*/ + bdev_lkm_dummy(), /* 8 */ + bdev_lkm_dummy(), /* 9 */ + bdev_lkm_dummy(), /* 10 */ + bdev_lkm_dummy(), /* 11 */ + bdev_lkm_dummy(), /* 12 */ + bdev_lkm_dummy(), /* 13 */ + bdev_disk_init(NVND,vnd), /* 14 vnode disk driver*/ + bdev_notdef(), /* 15 unknown*/ + bdev_notdef(), /* 16 unknown*/ + bdev_disk_init(NRD,rd), /* 17 ram disk driver*/ +}; +int nblkdev = sizeof bdevsw / sizeof bdevsw[0]; + +#include "pty.h" + +#include "com.h" +cdev_decl(com); + +#include "bpfilter.h" + +#include "tun.h" + +#ifdef USER_PCICONF +#include "pci.h" +cdev_decl(pci); +#endif + +#include "pf.h" + +#include "systrace.h" + +#ifdef LKM +#define NLKM 1 +#else +#define NLKM 0 +#endif + +#include "ksyms.h" +#include "usb.h" + +struct cdevsw cdevsw[] = { + cdev_cn_init(1,cn), /* 0: virtual console */ + cdev_ctty_init(1,ctty), /* 1: controlling terminal */ + cdev_mm_init(1,mm), /* 2: /dev/{null,mem,kmem,...} */ + cdev_swap_init(1,sw), /* 3: /dev/drum (swap pseudo-device) */ + cdev_tty_init(NPTY,pts), /* 4: pseudo-tty slave */ + cdev_ptc_init(NPTY,ptc), /* 5: pseudo-tty master */ + cdev_log_init(1,log), /* 6: /dev/klog */ + cdev_notdef(), /* 7 */ + cdev_disk_init(NSD,sd), /* 8: SCSI disk */ + cdev_disk_init(NCD,cd), /* 9: SCSI CD-ROM */ + cdev_notdef(), /* 10 */ + cdev_disk_init(NWD,wd), /* 11: ST506/ESDI/IDE disk */ + cdev_notdef(), /* 12 */ + cdev_notdef(), /* 13 */ + cdev_notdef(), /* 14 */ + cdev_notdef(), /* 15 */ + cdev_notdef(), /* 16 */ + cdev_disk_init(NRD,rd), /* 17 ram disk driver*/ + cdev_notdef(), /* 18 */ + cdev_disk_init(NVND,vnd), /* 19: vnode disk */ + cdev_notdef(), /* 20 */ + cdev_fd_init(1,filedesc), /* 21: file descriptor pseudo-dev */ + cdev_bpf_init(NBPFILTER,bpf), /* 22: berkeley packet filter */ + cdev_tun_init(NTUN,tun), /* 23: network tunnel */ + cdev_lkm_init(NLKM,lkm), /* 24: loadable module driver */ + cdev_notdef(), /* 25 */ + cdev_tty_init(NCOM,com), /* 26: serial port */ + cdev_notdef(), /* 27 */ + cdev_notdef(), /* 28 */ + cdev_notdef(), /* 29 */ + cdev_notdef(), /* 30 */ + cdev_notdef(), /* 31 */ + cdev_notdef(), /* 32 */ + cdev_lkm_dummy(), /* 33 */ + cdev_lkm_dummy(), /* 34 */ + cdev_lkm_dummy(), /* 35 */ + cdev_lkm_dummy(), /* 36 */ + cdev_lkm_dummy(), /* 37 */ + cdev_lkm_dummy(), /* 38 */ + cdev_pf_init(NPF,pf), /* 39: packet filter */ + cdev_random_init(1,random), /* 40: random data source */ + cdev_notdef(), /* 41 */ + cdev_notdef(), /* 42 */ + cdev_ksyms_init(NKSYMS,ksyms), /* 43: Kernel symbols device */ + cdev_notdef(), /* 44 */ + cdev_notdef(), /* 45 */ + cdev_notdef(), /* 46 */ + cdev_notdef(), /* 47 */ + cdev_notdef(), /* 48 */ + cdev_notdef(), /* 49 */ + cdev_systrace_init(NSYSTRACE,systrace), /* 50 system call tracing */ + cdev_notdef(), /* 51 */ + cdev_notdef(), /* 52 */ + cdev_notdef(), /* 53 */ + cdev_notdef(), /* 54 */ + cdev_notdef(), /* 55 */ + cdev_notdef(), /* 56 */ + cdev_notdef(), /* 57 */ + cdev_notdef(), /* 58 */ + cdev_notdef(), /* 59 */ + cdev_notdef(), /* 60 */ + cdev_usb_init(NUSB,usb), /* 61: USB controller */ + cdev_notdef(), /* 62 */ + cdev_notdef(), /* 63 */ + cdev_notdef(), /* 64 */ + cdev_notdef(), /* 65 */ + cdev_notdef(), /* 66 */ + cdev_notdef(), /* 67 */ + cdev_notdef(), /* 68 */ + cdev_notdef(), /* 69 */ + cdev_notdef(), /* 70 */ +#ifdef USER_PCICONF + cdev_pci_init(NPCI,pci), /* 71: PCI user */ +#else + cdev_notdef(), +#endif + cdev_notdef(), /* 72 */ + cdev_notdef(), /* 73 */ + cdev_notdef(), /* 74 */ + cdev_notdef(), /* 75 */ + cdev_notdef(), /* 76 */ + cdev_ptm_init(NPTY,ptm), /* 77: pseudo-tty ptm device */ +}; +int nchrdev = sizeof cdevsw / sizeof cdevsw[0]; + +int mem_no = 2; /* major number of /dev/mem */ + +/* + * Swapdev is a fake device implemented in sw.c. + * It is used only internally to get to swstrategy. + */ +dev_t swapdev = makedev(1, 0); + +/* + * Check whether dev is /dev/mem or /dev/kmem. + */ +int +iskmemdev(dev_t dev) +{ + return major(dev) == mem_no && minor(dev) < 2; +} + +/* + * Check whether dev is /dev/zero. + */ +int +iszerodev(dev_t dev) +{ + return major(dev) == mem_no && minor(dev) == 12; +} + +dev_t +getnulldev() +{ + return makedev(mem_no, 2); +} + +int chrtoblktbl[] = { + /*VCHR*/ /*VBLK*/ + /* 0 */ NODEV, + /* 1 */ NODEV, + /* 2 */ NODEV, + /* 3 */ NODEV, + /* 4 */ NODEV, + /* 5 */ NODEV, + /* 6 */ NODEV, + /* 7 */ NODEV, + /* 8 */ 2, + /* 9 */ NODEV, + /* 10 */ NODEV, + /* 11 */ 0, + /* 12 */ NODEV, + /* 13 */ 4, + /* 14 */ NODEV, + /* 15 */ NODEV, + /* 16 */ NODEV, + /* 17 */ 17, + /* 18 */ NODEV, + /* 19 */ NODEV, + /* 20 */ NODEV, + /* 21 */ NODEV, + /* 22 */ NODEV, + /* 23 */ NODEV, + /* 24 */ NODEV, + /* 25 */ NODEV, + /* 26 */ NODEV, + /* 27 */ NODEV, + /* 28 */ NODEV, + /* 29 */ NODEV, + /* 30 */ NODEV, + /* 31 */ NODEV, + /* 32 */ NODEV, + /* 33 */ NODEV, + /* 34 */ NODEV, + /* 35 */ NODEV, + /* 36 */ NODEV, + /* 37 */ NODEV, + /* 38 */ NODEV, + /* 39 */ NODEV, + /* 40 */ NODEV, + /* 41 */ NODEV, + /* 42 */ NODEV, + /* 43 */ NODEV, + /* 44 */ NODEV, + /* 45 */ NODEV, + /* 46 */ NODEV, + /* 47 */ NODEV, + /* 48 */ NODEV, + /* 49 */ NODEV, + /* 50 */ NODEV, + /* 51 */ NODEV, + /* 52 */ NODEV, + /* 53 */ NODEV, + /* 54 */ 19, +}; +int nchrtoblktbl = sizeof(chrtoblktbl) / sizeof(chrtoblktbl[0]); + +#include <dev/cons.h> + +cons_decl(com); + +struct consdev constab[] = { +#if NCOM > 0 + cons_init(com), +#endif + { 0 }, +}; diff --git a/sys/arch/socppc/socppc/cpu.c b/sys/arch/socppc/socppc/cpu.c new file mode 100644 index 00000000000..72c4c59ee73 --- /dev/null +++ b/sys/arch/socppc/socppc/cpu.c @@ -0,0 +1,115 @@ +/* $OpenBSD: cpu.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> + +#define HID0_DOZE (1 << (31-8)) +#define HID0_NAP (1 << (31-9)) +#define HID0_SLEEP (1 << (31-10)) +#define HID0_DPM (1 << (31-11)) +#define HID0_ICE (1 << (31-16)) +#define HID0_DCE (1 << (31-17)) +#define HID0_ICFI (1 << (31-20)) +#define HID0_DCFI (1 << (31-21)) + +extern u_int32_t hid0_idle; + + +struct cpu_info cpu_info[PPC_MAXPROCS] = { { NULL } }; /* XXX */ + +char *cpu_model = "8347"; +char machine[] = MACHINE; /* cpu architecture */ + +int cpu_match(struct device *, void *, void *); +void cpu_attach(struct device *, struct device *, void *); + +struct cfattach cpu_ca = { + sizeof(struct device), cpu_match, cpu_attach +}; + +struct cfdriver cpu_cd = { + NULL, "cpu", DV_DULL +}; + +int +cpu_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +cpu_attach(struct device *parent, struct device *self, void *aux) +{ + struct cpu_info *ci; + u_int32_t hid0; + + ci = &cpu_info[0]; + ci->ci_cpuid = 0; + ci->ci_intrdepth = -1; + ci->ci_randseed = 1; + ci->ci_dev = self; + + printf(": %s\n", cpu_model); + + /* Enable data cache. */ + hid0 = ppc_mfhid0(); + if ((hid0 & HID0_DCE) == 0) { + __asm __volatile ( + "sync; mtspr 1008,%0; mtspr 1008,%1" + :: "r" (hid0 | HID0_DCFI), "r" (hid0 | HID0_DCE)); + } + + /* Enable instruction cache. */ + hid0 = ppc_mfhid0(); + if ((hid0 & HID0_ICE) == 0) { + __asm __volatile ( + "isync; mtspr 1008,%0; mtspr 1008,%1" + :: "r" (hid0 | HID0_ICFI), "r" (hid0 | HID0_ICE)); + } + + /* Select DOZE mode. */ + hid0 = ppc_mfhid0(); + hid0 &= ~(HID0_NAP | HID0_DOZE | HID0_SLEEP); + hid0_idle = HID0_DOZE; + hid0 |= HID0_DPM; + ppc_mthid0(hid0); +} + +int ppc_proc_is_64b; +extern u_int32_t nop_inst; +struct patch { + u_int32_t *s; + u_int32_t *e; +}; +extern struct patch nop32_start; + +void +ppc_check_procid() +{ + u_int32_t *inst; + struct patch *p; + + ppc_proc_is_64b = 0; + for (p = &nop32_start; p->s; p++) { + for (inst = p->s; inst < p->e; inst++) + *inst = nop_inst; + syncicache(p->s, (p->e - p->s) * sizeof(p->e)); + } +} diff --git a/sys/arch/socppc/socppc/db_interface.c b/sys/arch/socppc/socppc/db_interface.c new file mode 100644 index 00000000000..02a44a53a76 --- /dev/null +++ b/sys/arch/socppc/socppc/db_interface.c @@ -0,0 +1,44 @@ +/* $OpenBSD: db_interface.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: db_interface.c,v 1.12 2001/07/22 11:29:46 wiz Exp $ */ + +#include <sys/param.h> +#include <sys/proc.h> +#include <sys/systm.h> + +#include <dev/cons.h> + +#include <machine/db_machdep.h> +#include <ddb/db_extern.h> + +int ddb_trap_glue(struct trapframe *frame); /* called from locore */ + +void +Debugger() +{ + ddb_trap(); +} + +int +ddb_trap_glue(struct trapframe *frame) +{ + if (!(frame->srr1 & PSL_PR) + && (frame->exc == EXC_TRC + || (frame->exc == EXC_PGM && (frame->srr1 & 0x20000)) + || frame->exc == EXC_BPT)) { + + bcopy(frame->fixreg, DDB_REGS->tf.fixreg, + 32 * sizeof(u_int32_t)); + DDB_REGS->tf.srr0 = frame->srr0; + DDB_REGS->tf.srr1 = frame->srr1; + + cnpollc(TRUE); + db_trap(T_BREAKPOINT, 0); + cnpollc(FALSE); + + bcopy(DDB_REGS->tf.fixreg, frame->fixreg, + 32 * sizeof(u_int32_t)); + + return 1; + } + return 0; +} diff --git a/sys/arch/socppc/socppc/disksubr.c b/sys/arch/socppc/socppc/disksubr.c new file mode 100644 index 00000000000..f41bd161701 --- /dev/null +++ b/sys/arch/socppc/socppc/disksubr.c @@ -0,0 +1,214 @@ +/* $OpenBSD: disksubr.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: disksubr.c,v 1.21 1996/05/03 19:42:03 christos Exp $ */ + +/* + * Copyright (c) 1996 Theo de Raadt + * Copyright (c) 1982, 1986, 1988 Regents of the University of California. + * 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. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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/param.h> +#include <sys/systm.h> +#include <sys/buf.h> +#include <sys/disklabel.h> +#include <sys/disk.h> + +char *readdpmelabel(struct buf *, void (*)(struct buf *), + struct disklabel *, int *, int); + +/* + * Attempt to read a disk label from a device + * using the indicated strategy routine. + * The label must be partly set up before this: + * secpercyl, secsize and anything required for a block i/o read + * operation in the driver's strategy/start routines + * must be filled in before calling us. + * + * If dos partition table requested, attempt to load it and + * find disklabel inside a DOS partition. Return buffer + * for use in signalling errors if requested. + * + * We would like to check if each MBR has a valid DOSMBR_SIGNATURE, but + * we cannot because it doesn't always exist. So.. we assume the + * MBR is valid. + * + * Returns null on success and an error string on failure. + */ +char * +readdisklabel(dev_t dev, void (*strat)(struct buf *), + struct disklabel *lp, int spoofonly) +{ + struct buf *bp = NULL; + char *msg; + + if ((msg = initdisklabel(lp))) + goto done; + + /* get a buffer and initialize it */ + bp = geteblk((int)lp->d_secsize); + bp->b_dev = dev; + + msg = readdpmelabel(bp, strat, lp, NULL, spoofonly); + if (msg == NULL) + goto done; + + msg = readdoslabel(bp, strat, lp, NULL, spoofonly); + if (msg == NULL) + goto done; + +#if defined(CD9660) + if (iso_disklabelspoof(dev, strat, lp) == 0) { + msg = NULL; + goto done; + } +#endif +#if defined(UDF) + if (udf_disklabelspoof(dev, strat, lp) == 0) { + msg = NULL; + goto done; + } +#endif + +done: + if (bp) { + bp->b_flags |= B_INVAL; + brelse(bp); + } + return (msg); +} + +char * +readdpmelabel(struct buf *bp, void (*strat)(struct buf *), + struct disklabel *lp, int *partoffp, int spoofonly) +{ + int i, part_cnt, n, hfspartoff = -1; + struct part_map_entry *part; + + /* First check for a DPME (HFS) disklabel */ + bp->b_blkno = 1; + bp->b_bcount = lp->d_secsize; + bp->b_flags = B_BUSY | B_READ; + (*strat)(bp); + if (biowait(bp)) + return ("DPME partition I/O error"); + + /* if successful, wander through DPME partition table */ + part = (struct part_map_entry *)bp->b_data; + /* if first partition is not valid, assume not HFS/DPME partitioned */ + if (part->pmSig != PART_ENTRY_MAGIC) + return ("not a DPMI partition"); + part_cnt = part->pmMapBlkCnt; + n = 0; + for (i = 0; i < part_cnt; i++) { + struct partition *pp = &lp->d_partitions[8+n]; + char *s; + + bp->b_blkno = 1+i; + bp->b_bcount = lp->d_secsize; + bp->b_flags = B_BUSY | B_READ; + (*strat)(bp); + if (biowait(bp)) + return ("DPME partition I/O error"); + + part = (struct part_map_entry *)bp->b_data; + /* toupper the string, in case caps are different... */ + for (s = part->pmPartType; *s; s++) + if ((*s >= 'a') && (*s <= 'z')) + *s = (*s - 'a' + 'A'); + + if (strcmp(part->pmPartType, PART_TYPE_OPENBSD) == 0) + hfspartoff = part->pmPyPartStart - LABELSECTOR; + + /* currently we ignore all but HFS partitions */ + if (strcmp(part->pmPartType, PART_TYPE_MAC) == 0) { + DL_SETPOFFSET(pp, part->pmPyPartStart); + DL_SETPSIZE(pp, part->pmPartBlkCnt); + pp->p_fstype = FS_HFS; + n++; + } + } + lp->d_npartitions = MAXPARTITIONS; + + if (hfspartoff == -1) + return ("no OpenBSD parition inside DPME label"); + + if (partoffp) + *partoffp = hfspartoff; + + if (spoofonly) + return (NULL); + + /* next, dig out disk label */ + bp->b_blkno = hfspartoff + LABELSECTOR; + bp->b_bcount = lp->d_secsize; + bp->b_flags = B_BUSY | B_READ; + (*strat)(bp); + if (biowait(bp)) + return("disk label I/O error"); + + return checkdisklabel(bp->b_data + LABELOFFSET, lp); +} + +/* + * Write disk label back to device after modification. + */ +int +writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp) +{ + int error = EIO, partoff = -1; + struct disklabel *dlp; + struct buf *bp = NULL; + + /* get a buffer and initialize it */ + bp = geteblk((int)lp->d_secsize); + bp->b_dev = dev; + + if (readdpmelabel(bp, strat, lp, &partoff, 1) != NULL && + readdoslabel(bp, strat, lp, &partoff, 1) != NULL) + goto done; + + /* Read it in, slap the new label in, and write it back out */ + bp->b_blkno = partoff + LABELSECTOR; + bp->b_bcount = lp->d_secsize; + bp->b_flags = B_BUSY | B_READ; + (*strat)(bp); + if ((error = biowait(bp)) != 0) + goto done; + + dlp = (struct disklabel *)(bp->b_data + LABELOFFSET); + *dlp = *lp; + bp->b_flags = B_BUSY | B_WRITE; + (*strat)(bp); + error = biowait(bp); + +done: + if (bp) { + bp->b_flags |= B_INVAL; + brelse(bp); + } + return (error); +} diff --git a/sys/arch/socppc/socppc/dma.c b/sys/arch/socppc/socppc/dma.c new file mode 100644 index 00000000000..49f2d951595 --- /dev/null +++ b/sys/arch/socppc/socppc/dma.c @@ -0,0 +1,608 @@ +/* $OpenBSD: dma.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: machdep.c,v 1.214 1996/11/10 03:16:17 thorpej Exp $ */ + +/*- + * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, + * NASA Ames Research Center. + * + * 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 the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``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 FOUNDATION OR CONTRIBUTORS + * 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/param.h> +#include <sys/proc.h> +#include <sys/user.h> +#include <sys/extent.h> +#include <sys/buf.h> +#include <sys/device.h> +#include <sys/systm.h> +#include <sys/conf.h> +#include <sys/file.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/mount.h> + +#include <uvm/uvm.h> +#include <uvm/uvm_page.h> + +#include <machine/bus.h> +int _dmamem_alloc_range( bus_dma_tag_t t, bus_size_t size, + bus_size_t alignment, bus_size_t boundary, bus_dma_segment_t *segs, + int nsegs, int *rsegs, int flags, vaddr_t low, vaddr_t high); +int _dmamap_load_buffer(bus_dma_tag_t, bus_dmamap_t, void *, bus_size_t, + struct proc *, int, bus_addr_t *, int *, int); +/* + * Common function for DMA map creation. May be called by bus-specific + * DMA map creation functions. + */ +int +_dmamap_create(bus_dma_tag_t t, bus_size_t size, int nsegments, + bus_size_t maxsegsz, bus_size_t boundary, int flags, bus_dmamap_t *dmamp) +{ + struct powerpc_bus_dmamap *map; + void *mapstore; + size_t mapsize; + + /* + * Allocate and initialize the DMA map. The end of the map + * is a variable-sized array of segments, so we allocate enough + * room for them in one shot. + * + * Note we don't preserve the WAITOK or NOWAIT flags. Preservation + * of ALLOCNOW notifies others that we've reserved these resources, + * and they are not to be freed. + * + * The bus_dmamap_t includes one bus_dma_segment_t, hence + * the (nsegments - 1). + */ + mapsize = sizeof(struct powerpc_bus_dmamap) + + (sizeof(bus_dma_segment_t) * (nsegments - 1)); + if ((mapstore = malloc(mapsize, M_DEVBUF, (flags & BUS_DMA_NOWAIT) ? + (M_NOWAIT | M_ZERO) : (M_WAITOK | M_ZERO))) == NULL) + return (ENOMEM); + + map = (struct powerpc_bus_dmamap *)mapstore; + map->_dm_size = size; + map->_dm_segcnt = nsegments; + map->_dm_maxsegsz = maxsegsz; + map->_dm_boundary = boundary; + map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT); + map->dm_nsegs = 0; /* no valid mappings */ + map->dm_mapsize = 0; + + *dmamp = map; + return (0); +} + +/* + * Common function for DMA map destruction. May be called by bus-specific + * DMA map destruction functions. + */ +void +_dmamap_destroy(bus_dma_tag_t t, bus_dmamap_t map) +{ + + free(map, M_DEVBUF); +} + + +int +_dmamap_load_buffer(bus_dma_tag_t t, bus_dmamap_t map, void *buf, + bus_size_t buflen, struct proc *p, int flags, bus_addr_t *lastaddrp, + int *segp, int first) +{ + bus_size_t sgsize; + bus_addr_t curaddr, lastaddr, baddr, bmask; + vaddr_t vaddr = (vaddr_t)buf; + pmap_t pmap; + int seg; + + lastaddr = *lastaddrp; + bmask = ~(map->_dm_boundary - 1); + + if (p != NULL) + pmap = p->p_vmspace->vm_map.pmap; + else + pmap = pmap_kernel(); + + for (seg = *segp; buflen > 0; ) { + /* + * Get the physical address for this segment. + */ + if (pmap_extract(pmap, vaddr, (paddr_t *)&curaddr) != TRUE) { + panic("dmamap_load_buffer pmap %p vaddr %lx " + "pmap_extract failed", pmap, vaddr); + } + + /* + * Compute the segment size, and adjust counts. + */ + sgsize = PAGE_SIZE - ((u_long)vaddr & PGOFSET); + if (buflen < sgsize) + sgsize = buflen; + + /* + * Make sure we don't cross any boundaries. + */ + if (map->_dm_boundary > 0) { + baddr = (curaddr + map->_dm_boundary) & bmask; + if (sgsize > (baddr - curaddr)) + sgsize = (baddr - curaddr); + } + + /* + * Insert chunk into a segment, coalescing with the + * previous segment if possible. + */ + if (first) { + map->dm_segs[seg].ds_addr = curaddr; + map->dm_segs[seg].ds_len = sgsize; + first = 0; + } else { + if (curaddr == lastaddr && + (map->dm_segs[seg].ds_len + sgsize) <= + map->_dm_maxsegsz && + (map->_dm_boundary == 0 || + (map->dm_segs[seg].ds_addr & bmask) == + (curaddr & bmask))) + map->dm_segs[seg].ds_len += sgsize; + else { + if (++seg >= map->_dm_segcnt) + break; + map->dm_segs[seg].ds_addr = curaddr; + map->dm_segs[seg].ds_len = sgsize; + } + } + + lastaddr = curaddr + sgsize; + vaddr += sgsize; + buflen -= sgsize; + } + + *segp = seg; + *lastaddrp = lastaddr; + + /* + * Did we fit? + */ + if (buflen != 0) + return (EFBIG); /* XX better return value here? */ + + return (0); +} + +/* + * Common function for loading a DMA map with a linear buffer. May + * be called by bus-specific DMA map load functions. + */ +int +_dmamap_load(bus_dma_tag_t t, bus_dmamap_t map, void *buf, bus_size_t buflen, + struct proc *p, int flags) +{ + bus_addr_t lastaddr; + int seg, error; + + /* + * Make sure that on error condition we return "no valid mappings". + */ + map->dm_mapsize = 0; + map->dm_nsegs = 0; + + if (buflen > map->_dm_size) + return (EINVAL); + + seg = 0; + error = _dmamap_load_buffer(t, map, buf, buflen, p, flags, + &lastaddr, &seg, 1); + if (error == 0) { + map->dm_mapsize = buflen; + map->dm_nsegs = seg + 1; + } + return (error); +} + +/* + * Like _bus_dmamap_load(), but for mbufs. + */ +int +_dmamap_load_mbuf(bus_dma_tag_t t, bus_dmamap_t map, struct mbuf *m0, + int flags) +{ + bus_addr_t lastaddr; + int seg, error, first; + struct mbuf *m; + + /* + * Make sure that on error condition we return "no valid mappings". + */ + map->dm_mapsize = 0; + map->dm_nsegs = 0; + +#ifdef DIAGNOSTIC + if ((m0->m_flags & M_PKTHDR) == 0) + panic("_bus_dmamap_load_mbuf: no packet header"); +#endif + + if (m0->m_pkthdr.len > map->_dm_size) + return (EINVAL); + + first = 1; + seg = 0; + error = 0; + for (m = m0; m != NULL && error == 0; m = m->m_next) { + if (m->m_len == 0) + continue; + error = _dmamap_load_buffer(t, map, m->m_data, m->m_len, + NULL, flags, &lastaddr, &seg, first); + first = 0; + } + if (error == 0) { + map->dm_mapsize = m0->m_pkthdr.len; + map->dm_nsegs = seg + 1; + } + return (error); +} + +/* + * Like _bus_dmamap_load(), but for uios. + */ +int +_dmamap_load_uio(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio, int flags) +{ + bus_addr_t lastaddr; + int seg, i, error, first; + bus_size_t minlen, resid; + struct proc *p = NULL; + struct iovec *iov; + caddr_t addr; + + /* + * Make sure that on error condition we return "no valid mappings". + */ + map->dm_mapsize = 0; + map->dm_nsegs = 0; + + resid = uio->uio_resid; + iov = uio->uio_iov; + + if (resid > map->_dm_size) + return (EINVAL); + + if (uio->uio_segflg == UIO_USERSPACE) { + p = uio->uio_procp; +#ifdef DIAGNOSTIC + if (p == NULL) + panic("_bus_dmamap_load_uio: USERSPACE but no proc"); +#endif + } + + first = 1; + seg = 0; + error = 0; + for (i = 0; i < uio->uio_iovcnt && resid != 0 && error == 0; i++) { + /* + * Now at the first iovec to load. Load each iovec + * until we have exhausted the residual count. + */ + minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len; + addr = (caddr_t)iov[i].iov_base; + + error = _dmamap_load_buffer(t, map, addr, minlen, + p, flags, &lastaddr, &seg, first); + first = 0; + + resid -= minlen; + } + if (error == 0) { + map->dm_mapsize = uio->uio_resid; + map->dm_nsegs = seg + 1; + } + return (error); +} + +/* + * Like _bus_dmamap_load(), but for raw memory allocated with + * bus_dmamem_alloc(). + */ +int +_dmamap_load_raw(bus_dma_tag_t t, bus_dmamap_t map, bus_dma_segment_t *segs, + int nsegs, bus_size_t size, int flags) +{ + if (nsegs > map->_dm_segcnt || size > map->_dm_size) + return (EINVAL); + + /* + * Make sure we don't cross any boundaries. + */ + if (map->_dm_boundary) { + bus_addr_t bmask = ~(map->_dm_boundary - 1); + int i; + + for (i = 0; i < nsegs; i++) { + if (segs[i].ds_len > map->_dm_maxsegsz) + return (EINVAL); + if ((segs[i].ds_addr & bmask) != + ((segs[i].ds_addr + segs[i].ds_len - 1) & bmask)) + return (EINVAL); + } + } + + bcopy(segs, map->dm_segs, nsegs * sizeof(*segs)); + map->dm_nsegs = nsegs; + map->dm_mapsize = size; + return (0); +} + +/* + * Common function for unloading a DMA map. May be called by + * bus-specific DMA map unload functions. + */ +void +_dmamap_unload(bus_dma_tag_t t, bus_dmamap_t map) +{ + + /* + * No resources to free; just mark the mappings as + * invalid. + */ + map->dm_nsegs = 0; + map->dm_mapsize = 0; +} + +/* + * Common function for DMA map synchronization. May be called + * by bus-specific DMA map synchronization functions. + */ +void +_dmamap_sync(bus_dma_tag_t t, bus_dmamap_t map, bus_addr_t offset, +bus_size_t len, int op) +{ + int i; + bus_size_t minlen, wlen; + bus_addr_t pa, addr; + struct vm_page *pg; + + for (i = 0; i < map->dm_nsegs && len != 0; i++) { + /* Find the beginning segment. */ + if (offset >= map->dm_segs[i].ds_len) { + offset -= map->dm_segs[i].ds_len; + continue; + } + + minlen = len < map->dm_segs[i].ds_len - offset ? + len : map->dm_segs[i].ds_len - offset; + + addr = map->dm_segs[i].ds_addr + offset; + + switch (op) { + case BUS_DMASYNC_POSTWRITE: + for (pa = trunc_page(addr), wlen = 0; + pa < round_page(addr + minlen); + pa += PAGE_SIZE) { + pg = PHYS_TO_VM_PAGE(pa); + if (pg != NULL) + atomic_clearbits_int(&pg->pg_flags, + PG_PMAP_EXE); + } + } + + } +} + +/* + * Common function for DMA-safe memory allocation. May be called + * by bus-specific DMA memory allocation functions. + */ +int +_dmamem_alloc(bus_dma_tag_t t, bus_size_t size, bus_size_t alignment, + bus_size_t boundary, bus_dma_segment_t *segs, int nsegs, int *rsegs, + int flags) +{ + return (_dmamem_alloc_range(t, size, alignment, boundary, + segs, nsegs, rsegs, flags, 0, 0xf0000000)); +} + +/* + * Common function for freeing DMA-safe memory. May be called by + * bus-specific DMA memory free functions. + */ +void +_dmamem_free(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs) +{ + struct vm_page *m; + bus_addr_t addr; + struct pglist mlist; + int curseg; + + /* + * Build a list of pages to free back to the VM system. + */ + TAILQ_INIT(&mlist); + for (curseg = 0; curseg < nsegs; curseg++) { + for (addr = segs[curseg].ds_addr; + addr < (segs[curseg].ds_addr + segs[curseg].ds_len); + addr += PAGE_SIZE) { + m = PHYS_TO_VM_PAGE(addr); + TAILQ_INSERT_TAIL(&mlist, m, pageq); + } + } + + uvm_pglistfree(&mlist); +} + +/* + * Common function for mapping DMA-safe memory. May be called by + * bus-specific DMA memory map functions. + */ +int +_dmamem_map(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs, size_t size, + caddr_t *kvap, int flags) +{ + vaddr_t va; + bus_addr_t addr; + int curseg; + + size = round_page(size); + va = uvm_km_valloc(kernel_map, size); + if (va == 0) + return (ENOMEM); + + *kvap = (caddr_t)va; + + for (curseg = 0; curseg < nsegs; curseg++) { + for (addr = segs[curseg].ds_addr; + addr < (segs[curseg].ds_addr + segs[curseg].ds_len); + addr += PAGE_SIZE, va += PAGE_SIZE, size -= PAGE_SIZE) { + if (size == 0) + panic("_bus_dmamem_map: size botch"); + pmap_enter(pmap_kernel(), va, addr, + VM_PROT_READ | VM_PROT_WRITE, + VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED); + } + } + pmap_update(pmap_kernel()); + + return (0); +} + +/* + * Common function for unmapping DMA-safe memory. May be called by + * bus-specific DMA memory unmapping functions. + */ +void +_dmamem_unmap(bus_dma_tag_t t, caddr_t kva, size_t size) +{ + +#ifdef DIAGNOSTIC + if ((u_long)kva & PGOFSET) + panic("_bus_dmamem_unmap"); +#endif + + size = round_page(size); + uvm_km_free(kernel_map, (vaddr_t)kva, size); +} + +/* + * Common function for mmap(2)'ing DMA-safe memory. May be called by + * bus-specific DMA mmap(2)'ing functions. + */ +paddr_t +_dmamem_mmap(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs, off_t off, + int prot, int flags) +{ + int i; + + for (i = 0; i < nsegs; i++) { +#ifdef DIAGNOSTIC + if (off & PGOFSET) + panic("_bus_dmamem_mmap: offset unaligned"); + if (segs[i].ds_addr & PGOFSET) + panic("_bus_dmamem_mmap: segment unaligned"); + if (segs[i].ds_len & PGOFSET) + panic("_bus_dmamem_mmap: segment size not multiple" + " of page size"); +#endif + if (off >= segs[i].ds_len) { + off -= segs[i].ds_len; + continue; + } + + return (atop(segs[i].ds_addr + off)); + } + + /* Page not found. */ + return (-1); +} + +/********************************************************************** + * DMA utility functions + **********************************************************************/ + +/* + * Allocate physical memory from the given physical address range. + * Called by DMA-safe memory allocation methods. + */ +int +_dmamem_alloc_range(bus_dma_tag_t t, bus_size_t size, bus_size_t alignment, + bus_size_t boundary, bus_dma_segment_t *segs, int nsegs, int *rsegs, + int flags, vaddr_t low, vaddr_t high) +{ + vaddr_t curaddr, lastaddr; + struct vm_page *m; + struct pglist mlist; + int curseg, error; + + /* Always round the size. */ + size = round_page(size); + + /* + * Allocate pages from the VM system. + */ + TAILQ_INIT(&mlist); + error = uvm_pglistalloc(size, low, high, + alignment, boundary, &mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0); + if (error) + return (error); + + /* + * Compute the location, size, and number of segments actually + * returned by the VM code. + */ + m = TAILQ_FIRST(&mlist); + curseg = 0; + lastaddr = segs[curseg].ds_addr = VM_PAGE_TO_PHYS(m); + segs[curseg].ds_len = PAGE_SIZE; + m = TAILQ_NEXT(m, pageq); + + for (; m != NULL; m = TAILQ_NEXT(m, pageq)) { + curaddr = VM_PAGE_TO_PHYS(m); +#ifdef DIAGNOSTIC + if (curaddr < low || curaddr >= high) { + printf("vm_page_alloc_memory returned non-sensical" + " address 0x%lx\n", curaddr); + panic("dmamem_alloc_range"); + } +#endif + if (curaddr == (lastaddr + PAGE_SIZE)) + segs[curseg].ds_len += PAGE_SIZE; + else { + curseg++; + segs[curseg].ds_addr = curaddr; + segs[curseg].ds_len = PAGE_SIZE; + } + lastaddr = curaddr; + } + + *rsegs = curseg + 1; + + return (0); +} diff --git a/sys/arch/socppc/socppc/machdep.c b/sys/arch/socppc/socppc/machdep.c new file mode 100644 index 00000000000..d95c625e504 --- /dev/null +++ b/sys/arch/socppc/socppc/machdep.c @@ -0,0 +1,1147 @@ +/* $OpenBSD: machdep.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: machdep.c,v 1.4 1996/10/16 19:33:11 ws Exp $ */ + +/* + * Copyright (C) 1995, 1996 Wolfgang Solfrank. + * Copyright (C) 1995, 1996 TooLs GmbH. + * 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 TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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/param.h> +#include <sys/buf.h> +#include <sys/conf.h> +#include <sys/exec.h> +#include <sys/extent.h> +#include <sys/malloc.h> +#include <sys/mount.h> +#ifdef SYSVMSG +#include <sys/msg.h> +#endif +#include <sys/msgbuf.h> +#include <sys/proc.h> +#include <sys/reboot.h> +#include <sys/signalvar.h> +#include <sys/syscallargs.h> +#include <sys/sysctl.h> +#include <sys/tty.h> +#include <sys/user.h> + +#include <uvm/uvm_extern.h> + +#include <machine/bat.h> +#include <machine/bus.h> +#include <machine/pio.h> +#include <machine/powerpc.h> +#include <machine/trap.h> + +#include <net/netisr.h> + +#include <dev/cons.h> + +#include <dev/ic/comvar.h> + +/* + * Global variables used here and there + */ +extern struct user *proc0paddr; + +/* + * Declare these as initialized data so we can patch them. + */ +#ifndef BUFCACHEPERCENT +#define BUFCACHEPERCENT 5 +#endif + +#ifdef BUFPAGES +int bufpages = BUFPAGES; +#else +int bufpages = 0; +#endif +int bufcachepercent = BUFCACHEPERCENT; + +struct bat battable[16]; + +struct vm_map *exec_map = NULL; +struct vm_map *phys_map = NULL; + +int ppc_malloc_ok = 0; + +void uboot_mem_regions(struct mem_region **, struct mem_region **); +void uboot_vmon(void); + +struct firmware uboot_firmware = { + uboot_mem_regions, + NULL, + NULL, + uboot_vmon +}; + +struct firmware *fw = &uboot_firmware; + +#ifdef APERTURE +#ifdef INSECURE +int allowaperture = 1; +#else +int allowaperture = 0; +#endif +#endif + +caddr_t allocsys(caddr_t); +void dumpsys(void); +int lcsplx(int ipl); +int bus_mem_add_mapping(bus_addr_t, bus_size_t, int, bus_space_handle_t *); +bus_addr_t bus_space_unmap_p(bus_space_tag_t, bus_space_handle_t, bus_size_t); +void bus_space_unmap(bus_space_tag_t, bus_space_handle_t, bus_size_t); + +/* + * Extent maps to manage I/O. Allocate storage for 8 regions in each, + * initially. Later devio_malloc_safe will indicate that it's safe to + * use malloc() to dynamically allocate region descriptors. + */ +static long devio_ex_storage[EXTENT_FIXED_STORAGE_SIZE(8) / sizeof (long)]; +struct extent *devio_ex; +static int devio_malloc_safe = 0; + +void initppc(u_int, u_int, char *); + +void prom_printf(const char *, ...); + +extern struct ppc_bus_space mainbus_bus_space; + +void +initppc(u_int startkernel, u_int endkernel, char *args) +{ + extern void *trapcode; extern int trapsize; + extern void *extint; extern int extsize; + extern void *dsitrap; extern int dsisize; + extern void *isitrap; extern int isisize; + extern void *alitrap; extern int alisize; + extern void *decrint; extern int decrsize; + extern void *tlbimiss; extern int tlbimsize; + extern void *tlbdlmiss; extern int tlbdlmsize; + extern void *tlbdsmiss; extern int tlbdsmsize; +#ifdef DDB + extern void *ddblow; extern int ddbsize; +#endif + extern void *msgbuf_addr; + int exc, scratch; + + extern char __bss_start[], __end[]; + bzero(__bss_start, __end - __bss_start); + + proc0.p_cpu = &cpu_info[0]; + proc0.p_addr = proc0paddr; + bzero(proc0.p_addr, sizeof *proc0.p_addr); + + curpcb = &proc0paddr->u_pcb; + + curpm = curpcb->pcb_pmreal = curpcb->pcb_pm = pmap_kernel(); + + ppc_check_procid(); + +#if 0 + { + prom_printf("AER: 0x%08x\n", *(uint32_t *)0xe000080c); + prom_printf("AIDR: 0x%08x\n", *(uint32_t *)0xe0000810); + prom_printf("AEATR: 0x%08x\n", *(uint32_t *)0xe0000818); + prom_printf("AEADR: 0x%08x\n", *(uint32_t *)0xe000081c); + *(uint32_t *)0xe0000810 = 0x00000001; + *(uint32_t *)0xe0000814 = 0x00000001; + *(uint32_t *)0xe0000818 = 0x00000000; + *(uint32_t *)0xe000081c = 0x00000000; + } +#endif + + /* + * Initialize BAT registers to unmapped to not generate + * overlapping mappings below. + */ + ppc_mtibat0u(0); + ppc_mtibat1u(0); + ppc_mtibat2u(0); + ppc_mtibat3u(0); + ppc_mtdbat0u(0); + ppc_mtdbat1u(0); + ppc_mtdbat2u(0); + ppc_mtdbat3u(0); + + /* + * Set up initial BAT table to only map the lowest 256 MB area + */ + battable[0].batl = BATL(0x00000000, BAT_M); +#if 0 + battable[0].batu = BATU(0x00000000); +#else + battable[0].batu = 0x0ffe; /* XXX only map 128MB for now */ +#endif + + /* + * Now setup fixed bat registers + * + * Note that we still run in real mode, and the BAT + * registers were cleared above. + */ + /* IBAT0 used for initial 256 MB segment */ + ppc_mtibat0l(battable[0].batl); + ppc_mtibat0u(battable[0].batu); + + /* DBAT0 used similar */ + ppc_mtdbat0l(battable[0].batl); + ppc_mtdbat0u(battable[0].batu); + + /* + * Set up trap vectors + */ + for (exc = EXC_RSVD; exc <= EXC_LAST; exc += 0x100) { + switch (exc) { + default: + bcopy(&trapcode, (void *)exc, (size_t)&trapsize); + break; + case EXC_EXI: + bcopy(&extint, (void *)EXC_EXI, (size_t)&extsize); + break; + case EXC_DSI: + bcopy(&dsitrap, (void *)EXC_DSI, (size_t)&dsisize); + break; + case EXC_ISI: + bcopy(&isitrap, (void *)EXC_ISI, (size_t)&isisize); + break; + case EXC_ALI: + bcopy(&alitrap, (void *)EXC_ALI, (size_t)&alisize); + break; + case EXC_DECR: + bcopy(&decrint, (void *)EXC_DECR, (size_t)&decrsize); + break; + case EXC_IMISS: + bcopy(&tlbimiss, (void *)EXC_IMISS, (size_t)&tlbimsize); + break; + case EXC_DLMISS: + bcopy(&tlbdlmiss, (void *)EXC_DLMISS, (size_t)&tlbdlmsize); + break; + case EXC_DSMISS: + bcopy(&tlbdsmiss, (void *)EXC_DSMISS, (size_t)&tlbdsmsize); + break; + case EXC_PGM: + case EXC_TRC: + case EXC_BPT: +#if defined(DDB) + bcopy(&ddblow, (void *)exc, (size_t)&ddbsize); +#endif + break; + } + } + + syncicache((void *)EXC_RST, EXC_LAST - EXC_RST + 0x100); + + + uvmexp.pagesize = 4096; + uvm_setpagesize(); + + /* + * Initialize pmap module. + */ + pmap_bootstrap(startkernel, endkernel); + + /* now that we know physmem size, map physical memory with BATs */ + if (physmem > atop(0x10000000)) { + battable[0x1].batl = BATL(0x10000000, BAT_M); + battable[0x1].batu = BATU(0x10000000); + } + if (physmem > atop(0x20000000)) { + battable[0x2].batl = BATL(0x20000000, BAT_M); + battable[0x2].batu = BATU(0x20000000); + } + if (physmem > atop(0x30000000)) { + battable[0x3].batl = BATL(0x30000000, BAT_M); + battable[0x3].batu = BATU(0x30000000); + } + if (physmem > atop(0x40000000)) { + battable[0x4].batl = BATL(0x40000000, BAT_M); + battable[0x4].batu = BATU(0x40000000); + } + if (physmem > atop(0x50000000)) { + battable[0x5].batl = BATL(0x50000000, BAT_M); + battable[0x5].batu = BATU(0x50000000); + } + if (physmem > atop(0x60000000)) { + battable[0x6].batl = BATL(0x60000000, BAT_M); + battable[0x6].batu = BATU(0x60000000); + } + if (physmem > atop(0x70000000)) { + battable[0x7].batl = BATL(0x70000000, BAT_M); + battable[0x7].batu = BATU(0x70000000); + } + + /* + * Now enable translation (and machine checks/recoverable interrupts). + */ + (fw->vmon)(); + +#if 0 + ppc_mtdbat1l(BATL(0xe0000000, BAT_M | BAT_I | BAT_G)); + ppc_mtdbat1u(0xe000000e); +#endif + + __asm__ volatile ("eieio; mfmsr %0; ori %0,%0,%1; mtmsr %0; sync;isync" + : "=r"(scratch) : "K"(PSL_IR|PSL_DR|PSL_ME|PSL_RI)); + + /* + * use the memory provided by pmap_bootstrap for message buffer + */ + initmsgbuf(msgbuf_addr, MSGBUFSIZE); + + /* + * Look at arguments passed to us and compute boothowto. + */ + boothowto = RB_AUTOBOOT; + + devio_ex = extent_create("devio", 0x80000000, 0xffffffff, M_DEVBUF, + (caddr_t)devio_ex_storage, sizeof(devio_ex_storage), + EX_NOCOALESCE|EX_NOWAIT); + + /* + * Replace with real console. + */ + extern int comconsrate; + comconsfreq = 266666666; + comconsrate = 115200; + comconsaddr = 0x00004500; + comconsiot = &mainbus_bus_space; + consinit(); +} + +void +dumpsys(void) +{ +} + +int imask[IPL_NUM]; + +int netisr; + +/* + * Soft networking interrupts. + */ +void +softnet(int isr) +{ +#define DONETISR(flag, func) \ + if (isr & (1 << flag))\ + func(); + +#include <net/netisr_dispatch.h> +} + +int +lcsplx(int ipl) +{ + return spllower(ipl); +} + +/* BUS functions */ +int +bus_space_map(bus_space_tag_t t, bus_addr_t bpa, bus_size_t size, + int cacheable, bus_space_handle_t *bshp) +{ + int error; + + if (POWERPC_BUS_TAG_BASE(t) == 0) { + /* if bus has base of 0 fail. */ + return 1; + } + bpa |= POWERPC_BUS_TAG_BASE(t); + if ((error = extent_alloc_region(devio_ex, bpa, size, EX_NOWAIT | + (ppc_malloc_ok ? EX_MALLOCOK : 0)))) + return error; + + if ((error = bus_mem_add_mapping(bpa, size, cacheable, bshp))) { + if (extent_free(devio_ex, bpa, size, EX_NOWAIT | + (ppc_malloc_ok ? EX_MALLOCOK : 0))) + { + printf("bus_space_map: pa 0x%lx, size 0x%x\n", + bpa, size); + printf("bus_space_map: can't free region\n"); + } + } + return 0; +} + +bus_addr_t +bus_space_unmap_p(bus_space_tag_t t, bus_space_handle_t bsh, bus_size_t size) +{ + bus_addr_t paddr; + + pmap_extract(pmap_kernel(), bsh, &paddr); + bus_space_unmap((t), (bsh), (size)); + return paddr ; +} + +void +bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh, bus_size_t size) +{ + bus_addr_t sva; + bus_size_t off, len; + bus_addr_t bpa; + + /* should this verify that the proper size is freed? */ + sva = trunc_page(bsh); + off = bsh - sva; + len = size+off; + + if (pmap_extract(pmap_kernel(), sva, &bpa) == TRUE) { + if (extent_free(devio_ex, bpa | (bsh & PAGE_MASK), size, EX_NOWAIT | + (ppc_malloc_ok ? EX_MALLOCOK : 0))) + { + printf("bus_space_map: pa 0x%lx, size 0x%x\n", + bpa, size); + printf("bus_space_map: can't free region\n"); + } + } + /* do not free memory which was stolen from the vm system */ + if (ppc_malloc_ok && + ((sva >= VM_MIN_KERNEL_ADDRESS) && (sva < VM_MAX_KERNEL_ADDRESS))) + uvm_km_free(phys_map, sva, len); + else { + pmap_remove(pmap_kernel(), sva, sva+len); + pmap_update(pmap_kernel()); + } +} + +vaddr_t ppc_kvm_stolen = VM_KERN_ADDRESS_SIZE; + +int +bus_mem_add_mapping(bus_addr_t bpa, bus_size_t size, int cacheable, + bus_space_handle_t *bshp) +{ + bus_addr_t vaddr; + bus_addr_t spa, epa; + bus_size_t off; + int len; + + spa = trunc_page(bpa); + epa = bpa + size; + off = bpa - spa; + len = size+off; + +#if 0 + if (epa <= spa) { + panic("bus_mem_add_mapping: overflow"); + } +#endif + if (ppc_malloc_ok == 0) { + bus_size_t alloc_size; + + /* need to steal vm space before kernel vm is initialized */ + alloc_size = round_page(len); + + vaddr = VM_MIN_KERNEL_ADDRESS + ppc_kvm_stolen; + ppc_kvm_stolen += alloc_size; + if (ppc_kvm_stolen > PPC_SEGMENT_LENGTH) { + panic("ppc_kvm_stolen, out of space"); + } + } else { + vaddr = uvm_km_kmemalloc(phys_map, NULL, len, + UVM_KMF_NOWAIT|UVM_KMF_VALLOC); + if (vaddr == 0) + panic("bus_mem_add_mapping: kvm alloc of 0x%x failed", + len); + } + *bshp = vaddr + off; +#ifdef DEBUG_BUS_MEM_ADD_MAPPING + printf("mapping %x size %x to %x vbase %x\n", + bpa, size, *bshp, spa); +#endif + for (; len > 0; len -= PAGE_SIZE) { + pmap_kenter_cache(vaddr, spa, + VM_PROT_READ | VM_PROT_WRITE, + cacheable ? PMAP_CACHE_WT : PMAP_CACHE_CI); + spa += PAGE_SIZE; + vaddr += PAGE_SIZE; + } + return 0; +} + +int +bus_space_alloc(bus_space_tag_t tag, bus_addr_t rstart, bus_addr_t rend, + bus_size_t size, bus_size_t alignment, bus_size_t boundary, int cacheable, + bus_addr_t *addrp, bus_space_handle_t *handlep) +{ + + panic("bus_space_alloc: unimplemented"); +} + +void +bus_space_free(bus_space_tag_t tag, bus_space_handle_t handle, bus_size_t size) +{ + + panic("bus_space_free: unimplemented"); +} + +void * +mapiodev(paddr_t pa, psize_t len) +{ + paddr_t spa; + vaddr_t vaddr, va; + int off; + int size; + + spa = trunc_page(pa); + off = pa - spa; + size = round_page(off+len); + if (ppc_malloc_ok == 0) { + /* need to steal vm space before kernel vm is initialized */ + va = VM_MIN_KERNEL_ADDRESS + ppc_kvm_stolen; + ppc_kvm_stolen += size; + if (ppc_kvm_stolen > PPC_SEGMENT_LENGTH) { + panic("ppc_kvm_stolen, out of space"); + } + } else { + va = uvm_km_kmemalloc(phys_map, NULL, size, + UVM_KMF_NOWAIT|UVM_KMF_VALLOC); + } + + if (va == 0) + return NULL; + + for (vaddr = va; size > 0; size -= PAGE_SIZE) { + pmap_kenter_cache(vaddr, spa, + VM_PROT_READ | VM_PROT_WRITE, PMAP_CACHE_DEFAULT); + spa += PAGE_SIZE; + vaddr += PAGE_SIZE; + } + return (void *) (va+off); +} + +void +unmapiodev(void *kva, psize_t p_size) +{ + vaddr_t vaddr; + int size; + + size = p_size; + + vaddr = trunc_page((vaddr_t)kva); + + uvm_km_free_wakeup(phys_map, vaddr, size); + + for (; size > 0; size -= PAGE_SIZE) { + pmap_remove(pmap_kernel(), vaddr, vaddr+PAGE_SIZE-1); + vaddr += PAGE_SIZE; + } + pmap_update(pmap_kernel()); +} + + +/* + * probably should be ppc_space_copy + */ + +#define _CONCAT(A,B) A ## B +#define __C(A,B) _CONCAT(A,B) + +#define BUS_SPACE_COPY_N(BYTES,TYPE) \ +void \ +__C(bus_space_copy_,BYTES)(void *v, bus_space_handle_t h1, \ + bus_size_t o1, bus_space_handle_t h2, bus_size_t o2, \ + bus_size_t c) \ +{ \ + TYPE *src, *dst; \ + int i; \ + \ + src = (TYPE *) (h1+o1); \ + dst = (TYPE *) (h2+o2); \ + \ + if (h1 == h2 && o2 > o1) \ + for (i = c-1; i >= 0; i--) \ + dst[i] = src[i]; \ + else \ + for (i = 0; i < c; i++) \ + dst[i] = src[i]; \ +} +BUS_SPACE_COPY_N(1,u_int8_t) +BUS_SPACE_COPY_N(2,u_int16_t) +BUS_SPACE_COPY_N(4,u_int32_t) + +void +bus_space_set_region_1(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, + u_int8_t val, bus_size_t c) +{ + u_int8_t *dst; + int i; + + dst = (u_int8_t *) (h+o); + + for (i = 0; i < c; i++) + dst[i] = val; +} + +void +bus_space_set_region_2(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, + u_int16_t val, bus_size_t c) +{ + u_int16_t *dst; + int i; + + dst = (u_int16_t *) (h+o); + val = swap16(val); + + for (i = 0; i < c; i++) + dst[i] = val; +} +void +bus_space_set_region_4(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, + u_int32_t val, bus_size_t c) +{ + u_int32_t *dst; + int i; + + dst = (u_int32_t *) (h+o); + val = swap32(val); + + for (i = 0; i < c; i++) + dst[i] = val; +} + +#define BUS_SPACE_READ_RAW_MULTI_N(BYTES,SHIFT,TYPE) \ +void \ +__C(bus_space_read_raw_multi_,BYTES)(bus_space_tag_t bst, \ + bus_space_handle_t h, bus_addr_t o, u_int8_t *dst, bus_size_t size) \ +{ \ + TYPE *src; \ + TYPE *rdst = (TYPE *)dst; \ + int i; \ + int count = size >> SHIFT; \ + \ + src = (TYPE *)(h+o); \ + for (i = 0; i < count; i++) { \ + rdst[i] = *src; \ + __asm__("eieio"); \ + } \ +} +BUS_SPACE_READ_RAW_MULTI_N(2,1,u_int16_t) +BUS_SPACE_READ_RAW_MULTI_N(4,2,u_int32_t) + +#define BUS_SPACE_WRITE_RAW_MULTI_N(BYTES,SHIFT,TYPE) \ +void \ +__C(bus_space_write_raw_multi_,BYTES)( bus_space_tag_t bst, \ + bus_space_handle_t h, bus_addr_t o, const u_int8_t *src, \ + bus_size_t size) \ +{ \ + int i; \ + TYPE *dst; \ + TYPE *rsrc = (TYPE *)src; \ + int count = size >> SHIFT; \ + \ + dst = (TYPE *)(h+o); \ + for (i = 0; i < count; i++) { \ + *dst = rsrc[i]; \ + __asm__("eieio"); \ + } \ +} + +BUS_SPACE_WRITE_RAW_MULTI_N(2,1,u_int16_t) +BUS_SPACE_WRITE_RAW_MULTI_N(4,2,u_int32_t) + +int +bus_space_subregion(bus_space_tag_t t, bus_space_handle_t bsh, + bus_size_t offset, bus_size_t size, bus_space_handle_t *nbshp) +{ + *nbshp = bsh + offset; + return (0); +} + +/* + * Machine dependent startup code. + */ +void +cpu_startup() +{ + int sz; + caddr_t v; + vaddr_t minaddr, maxaddr; + + v = (caddr_t)proc0paddr + USPACE; + proc0.p_addr = proc0paddr; + + printf("%s", version); + + printf("real mem = %u (%uMB)\n", ptoa(physmem), + ptoa(physmem)/1024/1024); + + /* + * Find out how much space we need, allocate it, + * and then give everything true virtual addresses. + */ + sz = (int)allocsys((caddr_t)0); + if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(sz))) == 0) + panic("startup: no room for tables"); + if (allocsys(v) - v != sz) + panic("startup: table size inconsistency"); + + /* + * Determine how many buffers to allocate. + * We allocate bufcachepercent% of memory for buffer space. + */ + if (bufpages == 0) + bufpages = physmem * bufcachepercent / 100; + + /* Restrict to at most 25% filled kvm */ + if (bufpages > + (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4) + bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / + PAGE_SIZE / 4; + + /* + * Allocate a submap for exec arguments. This map effectively + * limits the number of processes exec'ing at any time. + */ + minaddr = vm_map_min(kernel_map); + exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr, 16 * NCARGS, + VM_MAP_PAGEABLE, FALSE, NULL); + + /* + * Allocate a submap for physio + */ + phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr, + VM_PHYS_SIZE, 0, FALSE, NULL); + ppc_malloc_ok = 1; + + printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free), + ptoa(uvmexp.free) / 1024 / 1024); + + /* + * Set up the buffers. + */ + bufinit(); + + devio_malloc_safe = 1; +} + +/* + * Allocate space for system data structures. + */ +caddr_t +allocsys(caddr_t v) +{ +#define valloc(name, type, num) \ + v = (caddr_t)(((name) = (type *)v) + (num)) + +#ifdef SYSVMSG + valloc(msgpool, char, msginfo.msgmax); + valloc(msgmaps, struct msgmap, msginfo.msgseg); + valloc(msghdrs, struct msg, msginfo.msgtql); + valloc(msqids, struct msqid_ds, msginfo.msgmni); +#endif + + return v; +} + +/* + * consinit + * Initialize system console. + */ +void +consinit() +{ + static int cons_initted = 0; + + if (cons_initted) + return; + cninit(); + cons_initted = 1; +} + +/* + * Clear registers on exec + */ +void +setregs(struct proc *p, struct exec_package *pack, u_long stack, + register_t *retval) +{ + u_int32_t newstack; + u_int32_t pargs; + u_int32_t args[4]; + + struct trapframe *tf = trapframe(p); + pargs = -roundup(-stack + 8, 16); + newstack = (u_int32_t)(pargs - 32); + + copyin ((void *)(VM_MAX_ADDRESS-0x10), &args, 0x10); + + bzero(tf, sizeof *tf); + tf->fixreg[1] = newstack; + tf->fixreg[3] = retval[0] = args[1]; /* XXX */ + tf->fixreg[4] = retval[1] = args[0]; /* XXX */ + tf->fixreg[5] = args[2]; /* XXX */ + tf->fixreg[6] = args[3]; /* XXX */ + tf->srr0 = pack->ep_entry; + tf->srr1 = PSL_MBO | PSL_USERSET | PSL_FE_DFLT; + p->p_addr->u_pcb.pcb_flags = 0; +} + +/* + * Send a signal to process. + */ +void +sendsig(sig_t catcher, int sig, int mask, u_long code, int type, + union sigval val) +{ + struct proc *p = curproc; + struct trapframe *tf; + struct sigframe *fp, frame; + struct sigacts *psp = p->p_sigacts; + int oldonstack; + + frame.sf_signum = sig; + + tf = trapframe(p); + oldonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK; + + /* + * Allocate stack space for signal handler. + */ + if ((psp->ps_flags & SAS_ALTSTACK) + && !oldonstack + && (psp->ps_sigonstack & sigmask(sig))) { + fp = (struct sigframe *)(psp->ps_sigstk.ss_sp + + psp->ps_sigstk.ss_size); + psp->ps_sigstk.ss_flags |= SS_ONSTACK; + } else + fp = (struct sigframe *)tf->fixreg[1]; + + fp = (struct sigframe *)((int)(fp - 1) & ~0xf); + + /* + * Generate signal context for SYS_sigreturn. + */ + frame.sf_sc.sc_onstack = oldonstack; + frame.sf_sc.sc_mask = mask; + frame.sf_sip = NULL; + bcopy(tf, &frame.sf_sc.sc_frame, sizeof *tf); + if (psp->ps_siginfo & sigmask(sig)) { + frame.sf_sip = &fp->sf_si; + initsiginfo(&frame.sf_si, sig, code, type, val); + } + if (copyout(&frame, fp, sizeof frame) != 0) + sigexit(p, SIGILL); + + + tf->fixreg[1] = (int)fp; + tf->lr = (int)catcher; + tf->fixreg[3] = (int)sig; + tf->fixreg[4] = (psp->ps_siginfo & sigmask(sig)) ? (int)&fp->sf_si : 0; + tf->fixreg[5] = (int)&fp->sf_sc; + tf->srr0 = p->p_sigcode; + +#if WHEN_WE_ONLY_FLUSH_DATA_WHEN_DOING_PMAP_ENTER + pmap_extract(vm_map_pmap(&p->p_vmspace->vm_map),tf->srr0, &pa); + syncicache(pa, (p->p_emul->e_esigcode - p->p_emul->e_sigcode)); +#endif +} + +/* + * System call to cleanup state after a signal handler returns. + */ +int +sys_sigreturn(struct proc *p, void *v, register_t *retval) +{ + struct sys_sigreturn_args /* { + syscallarg(struct sigcontext *) sigcntxp; + } */ *uap = v; + struct sigcontext sc; + struct trapframe *tf; + int error; + + if ((error = copyin(SCARG(uap, sigcntxp), &sc, sizeof sc))) + return error; + tf = trapframe(p); + if ((sc.sc_frame.srr1 & PSL_USERSTATIC) != (tf->srr1 & PSL_USERSTATIC)) + return EINVAL; + bcopy(&sc.sc_frame, tf, sizeof *tf); + if (sc.sc_onstack & 1) + p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK; + else + p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK; + p->p_sigmask = sc.sc_mask & ~sigcantmask; + return EJUSTRETURN; +} + +/* + * Machine dependent system variables. + * None for now. + */ +int +cpu_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, + size_t newlen, struct proc *p) +{ + /* all sysctl names at this level are terminal */ + if (namelen != 1) + return ENOTDIR; + switch (name[0]) { + case CPU_ALLOWAPERTURE: +#ifdef APERTURE + if (securelevel > 0) + return (sysctl_int_lower(oldp, oldlenp, newp, newlen, + &allowaperture)); + else + return (sysctl_int(oldp, oldlenp, newp, newlen, + &allowaperture)); +#else + return (sysctl_rdint(oldp, oldlenp, newp, 0)); +#endif + case CPU_ALTIVEC: + return (sysctl_rdint(oldp, oldlenp, newp, 0)); + default: + return EOPNOTSUPP; + } +} + +u_long dumpmag = 0x04959fca; /* magic number */ +int dumpsize = 0; /* size of dump in pages */ +long dumplo = -1; /* blocks */ + +/* + * This is called by configure to set dumplo and dumpsize. + * Dumps always skip the first CLBYTES of disk space + * in case there might be a disk label stored there. + * If there is extra space, put dump at the end to + * reduce the chance that swapping trashes it. + */ +void dumpconf(void); + +void +dumpconf(void) +{ + int nblks; /* size of dump area */ + int i; + + if (dumpdev == NODEV || + (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0) + return; + if (nblks <= ctod(1)) + return; + + /* Always skip the first block, in case there is a label there. */ + if (dumplo < ctod(1)) + dumplo = ctod(1); + + for (i = 0; i < ndumpmem; i++) + dumpsize = max(dumpsize, dumpmem[i].end); + + /* Put dump at end of partition, and make it fit. */ + if (dumpsize > dtoc(nblks - dumplo - 1)) + dumpsize = dtoc(nblks - dumplo - 1); + if (dumplo < nblks - ctod(dumpsize) - 1) + dumplo = nblks - ctod(dumpsize) - 1; + +} + +#define BYTES_PER_DUMP (PAGE_SIZE) /* must be a multiple of pagesize */ +vaddr_t dumpspace; + +int +reserve_dumppages(caddr_t p) +{ + dumpspace = (vaddr_t)p; + return BYTES_PER_DUMP; +} + +/* + * Halt or reboot the machine after syncing/dumping according to howto. + */ +void +boot(int howto) +{ + static int syncing; + + boothowto = howto; + if (!cold && !(howto & RB_NOSYNC) && !syncing) { + syncing = 1; + vfs_shutdown(); /* sync */ + + /* + * If we've been adjusting the clock, the todr + * will be out of synch; adjust it now unless + * the system was sitting in ddb. + */ + if ((howto & RB_TIMEBAD) == 0) { + resettodr(); + } else { + printf("WARNING: not updating battery clock\n"); + } + } + + uvm_shutdown(); + splhigh(); + if (howto & RB_HALT) { + doshutdownhooks(); + if ((howto & RB_POWERDOWN) == RB_POWERDOWN) { + ; + } + + printf("halted\n\n"); + (fw->exit)(); + } + if (!cold && (howto & RB_DUMP)) + dumpsys(); + doshutdownhooks(); + printf("rebooting\n\n"); + + { + volatile int32_t *reset; + int32_t v; + + reset = mapiodev(0xe0000900, 0x100); + reset[6] = 0x52535445; + v = reset[6]; + reset[7] = 0x00000002; + } + + printf("boot failed, spinning\n"); + while(1) /* forever */; +} + +extern void ipic_do_pending_int(void); + +void +do_pending_int(void) +{ + struct cpu_info *ci = curcpu(); + int pcpl, s; + + if (ci->ci_iactive) + return; + + ci->ci_iactive = 1; + s = ppc_intr_disable(); + pcpl = ci->ci_cpl; + + ipic_do_pending_int(); + + do { + if((ci->ci_ipending & SINT_CLOCK) & ~pcpl) { + ci->ci_ipending &= ~SINT_CLOCK; + ci->ci_cpl = SINT_CLOCK|SINT_NET|SINT_TTY; + ppc_intr_enable(1); + KERNEL_LOCK(); + softclock(); + KERNEL_UNLOCK(); + ppc_intr_disable(); + continue; + } + if((ci->ci_ipending & SINT_NET) & ~pcpl) { + extern int netisr; + int pisr; + + ci->ci_ipending &= ~SINT_NET; + ci->ci_cpl = SINT_NET|SINT_TTY; + while ((pisr = netisr) != 0) { + atomic_clearbits_int(&netisr, pisr); + ppc_intr_enable(1); + KERNEL_LOCK(); + softnet(pisr); + KERNEL_UNLOCK(); + ppc_intr_disable(); + } + continue; + } +#if 0 + if((ci->ci_ipending & SINT_TTY) & ~pcpl) { + ci->ci_ipending &= ~SINT_TTY; + ci->ci_cpl = SINT_TTY; + ppc_intr_enable(1); + KERNEL_LOCK(); + softtty(); + KERNEL_UNLOCK(); + ppc_intr_disable(); + continue; + } +#endif + } while ((ci->ci_ipending & SINT_MASK) & ~pcpl); + ci->ci_cpl = pcpl; /* Don't use splx... we are here already! */ + + ci->ci_iactive = 0; + ppc_intr_enable(s); +} + +/* + * Notify the current process (p) that it has a signal pending, + * process as soon as possible. + */ +void +signotify(struct proc *p) +{ + aston(p); +} + +/* bcopy(), error on fault */ +int +kcopy(const void *from, void *to, size_t size) +{ + faultbuf env; + void *oldh = curproc->p_addr->u_pcb.pcb_onfault; + + if (setfault(&env)) { + curproc->p_addr->u_pcb.pcb_onfault = oldh; + return EFAULT; + } + bcopy(from, to, size); + curproc->p_addr->u_pcb.pcb_onfault = oldh; + + return 0; +} + +struct mem_region uboot_mem[2] = { + { 0x00000000, 0x04000000 }, + { 0, 0 } +}; + +struct mem_region uboot_avail[2] = { + { 0x00800000, 0x04000000 }, + { 0, 0 } +}; + +void +uboot_mem_regions(struct mem_region **memp, struct mem_region **availp) +{ + *memp = uboot_mem; + *availp = uboot_avail; +} + +void +uboot_vmon(void) +{ +} + +/* prototype for locore function */ +void cpu_switchto_asm(struct proc *oldproc, struct proc *newproc); + +void cpu_switchto(struct proc *oldproc, struct proc *newproc) +{ + cpu_switchto_asm(oldproc, newproc); +} diff --git a/sys/arch/socppc/socppc/mainbus.c b/sys/arch/socppc/socppc/mainbus.c new file mode 100644 index 00000000000..ecd92ab7389 --- /dev/null +++ b/sys/arch/socppc/socppc/mainbus.c @@ -0,0 +1,77 @@ +/* $OpenBSD: mainbus.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ + +/* + * Copyright (c) 2008 Mark Kettenis + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> + +#include <machine/autoconf.h> + +int mainbus_match(struct device *, void *, void *); +void mainbus_attach(struct device *, struct device *, void *); + +struct cfattach mainbus_ca = { + sizeof(struct device), mainbus_match, mainbus_attach +}; + +struct cfdriver mainbus_cd = { + NULL, "mainbus", DV_DULL +}; + +int mainbus_search(struct device *, void *, void *); +int mainbus_print(void *, const char *); + +int +mainbus_match(struct device *parent, void *cfdata, void *aux) +{ + return (1); +} + +void +mainbus_attach(struct device *parent, struct device *self, void *aux) +{ + printf("\n"); + + config_search(mainbus_search, self, self); +} + +struct ppc_bus_space mainbus_bus_space = { 0xe0000000, 0x1000000, 1 }; + +int +mainbus_search(struct device *parent, void *cfdata, void *aux) +{ + struct mainbus_attach_args ma; + struct cfdata *cf = cfdata; + + ma.ma_iot = &mainbus_bus_space; + ma.ma_name = cf->cf_driver->cd_name; + config_found(parent, &ma, mainbus_print); + + return (1); +} + +int +mainbus_print(void *aux, const char *name) +{ + struct mainbus_attach_args *ma = aux; + + if (name) + printf("%s at %s", ma->ma_name, name); + + return (UNCONF); +} diff --git a/sys/arch/socppc/socppc/mem.c b/sys/arch/socppc/socppc/mem.c new file mode 100644 index 00000000000..add5fc64368 --- /dev/null +++ b/sys/arch/socppc/socppc/mem.c @@ -0,0 +1,179 @@ +/* $OpenBSD: mem.c,v 1.1 2008/05/10 12:02:21 kettenis Exp $ */ +/* $NetBSD: mem.c,v 1.1 1996/09/30 16:34:50 ws Exp $ */ + +/* + * Copyright (c) 1988 University of Utah. + * Copyright (c) 1982, 1986, 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * the Systems Programming Group of the University of Utah Computer + * Science Department. + * + * 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. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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. + * + * @(#)mem.c 8.3 (Berkeley) 1/12/94 + */ + +/* + * Memory special file + */ + +#include <sys/param.h> +#include <sys/buf.h> +#include <sys/systm.h> +#include <sys/ioccom.h> +#include <sys/uio.h> +#include <sys/malloc.h> +#include <sys/types.h> + +#include <machine/cpu.h> + +#include <uvm/uvm_extern.h> + +#include <machine/conf.h> + +/*ARGSUSED*/ +int +mmopen(dev_t dev, int flag, int mode, struct proc *p) +{ + + switch (minor(dev)) { + case 0: + case 1: + case 2: + case 12: + break; +#ifdef xAPERTURE + case 4: + if (suser(p, 0) != 0 || !allowaperture) + return (EPERM); + + /* authorize only one simultaneous open() */ + if (ap_open_count > 0) + return(EPERM); + ap_open_count++; + break; +#endif + default: + return (ENXIO); + } + return (0); +} + +/*ARGSUSED*/ +int +mmclose(dev_t dev, int flag, int mode, struct proc *p) +{ +#ifdef xAPERTURE + if (minor(dev) == 4) + ap_open_count--; +#endif + return 0; +} + +/*ARGSUSED*/ +int +mmrw(dev_t dev, struct uio *uio, int flags) +{ + vaddr_t v; + vsize_t c; + struct iovec *iov; + int error = 0; + static caddr_t zeropage; + + while (uio->uio_resid > 0 && error == 0) { + iov = uio->uio_iov; + if (iov->iov_len == 0) { + uio->uio_iov++; + uio->uio_iovcnt--; + if (uio->uio_iovcnt < 0) + panic("mmrw"); + continue; + } + switch (minor(dev)) { + + /* minor device 0 is physical memory */ + case 0: + v = uio->uio_offset; + c = uio->uio_resid; + /* This doesn't allow device mapping! XXX */ + pmap_real_memory(&v, &c); + error = uiomove((caddr_t)v, c, uio); + continue; + + /* minor device 1 is kernel memory */ + case 1: + v = uio->uio_offset; + c = min(iov->iov_len, MAXPHYS); + error = uiomove((caddr_t)v, c, uio); + continue; + + /* minor device 2 is EOF/RATHOLE */ + case 2: + if (uio->uio_rw == UIO_WRITE) + uio->uio_resid = 0; + return 0; + + /* minor device 12 (/dev/zero) is source of nulls on read, + * rathole on write + */ + case 12: + if (uio->uio_rw == UIO_WRITE) { + c = iov->iov_len; + break; + } + if (zeropage == NULL) + zeropage = malloc(PAGE_SIZE, M_TEMP, + M_WAITOK | M_ZERO); + c = min(iov->iov_len, PAGE_SIZE); + error = uiomove(zeropage, c, uio); + continue; + + default: + return ENXIO; + } + if (error) + break; + iov->iov_base += c; + iov->iov_len -= c; + uio->uio_offset += c; + uio->uio_resid -= c; + } + return error; +} + +paddr_t +mmmmap(dev_t dev, off_t off, int prot) +{ + return (-1); +} + +/*ARGSUSED*/ +int +mmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +{ + return (EOPNOTSUPP); +} |