 @@ -1,14 +1,14 @@
-/*	$NetBSD: pxa2x0.c,v 1.18 2009/08/09 06:12:33 kiyohara Exp $ */
+/*	$NetBSD: pxa2x0.c,v 1.19 2011/06/09 17:29:42 nonaka Exp $ */
 /*
  * Copyright (c) 2002, 2005  Genetec Corporation.  All rights reserved.
  * Written by Hiroyuki Bessho for Genetec Corporation.
+ *
  * 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.
 @@ -89,127 +89,127 @@
  * 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/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pxa2x0.c,v 1.18 2009/08/09 06:12:33 kiyohara Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pxa2x0.c,v 1.19 2011/06/09 17:29:42 nonaka Exp $");
 #include "pxaintc.h"
 #include "pxagpio.h"
 #if 0
 #include "pxadmac.h"	/* Not yet */
 #endif
 #include "locators.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/reboot.h>
 #include <machine/cpu.h>
 #include <machine/bus.h>
 #include <arm/cpufunc.h>
 #include <arm/mainbus/mainbus.h>
 #include <arm/xscale/pxa2x0cpu.h>
 #include <arm/xscale/pxa2x0reg.h>
 #include <arm/xscale/pxa2x0var.h>
 #include <arm/xscale/xscalereg.h>
 struct pxaip_softc {
-	struct device sc_dev;
+	device_t sc_dev;
 	bus_space_tag_t sc_bust;
 	bus_dma_tag_t sc_dmat;
 	bus_space_handle_t sc_bush_clk;
 	bus_space_handle_t sc_bush_mem;
 };
 /* prototypes */
-static int	pxaip_match(struct device *, struct cfdata *, void *);
+static int	pxaip_match(device_t, cfdata_t, void *);
-static void	pxaip_attach(struct device *, struct device *, void *);
+static void	pxaip_attach(device_t, device_t, void *);
-static int 	pxaip_search(struct device *, struct cfdata *,
+static int 	pxaip_search(device_t, cfdata_t, const int *, void *);
 			     const int *, void *);
 static void	pxaip_attach_critical(struct pxaip_softc *);
 static int	pxaip_print(void *, const char *);
 static int	pxaip_measure_cpuclock(struct pxaip_softc *);
 #if defined(CPU_XSCALE_PXA250) && defined(CPU_XSCALE_PXA270)
 # define SUPPORTED_CPU	"PXA250 and PXA270"
 #elif defined(CPU_XSCALE_PXA250)
 # define SUPPORTED_CPU	"PXA250"
 #elif defined(CPU_XSCALE_PXA270)
 # define SUPPORTED_CPU	"PXA270"
 #else
 # define SUPPORTED_CPU	"none of PXA2xx"
 #endif
 /* attach structures */
-CFATTACH_DECL(pxaip, sizeof(struct pxaip_softc),
+CFATTACH_DECL_NEW(pxaip, sizeof(struct pxaip_softc),
     pxaip_match, pxaip_attach, NULL, NULL);
 static struct pxaip_softc *pxaip_sc;
 static vaddr_t pxamemctl_regs;
 #define MEMCTL_BOOTSTRAP_REG(reg) \
 	(*((volatile uint32_t *)(pxamemctl_regs + (reg))))
 static vaddr_t pxaclkman_regs;
 #define CLKMAN_BOOTSTRAP_REG(reg) \
 	(*((volatile uint32_t *)(pxaclkman_regs + (reg))))
 static int
-pxaip_match(struct device *parent, struct cfdata *match, void *aux)
+pxaip_match(device_t parent, cfdata_t match, void *aux)
+{
 #if	!defined(CPU_XSCALE_PXA270)
 	if (__CPU_IS_PXA270)
 		goto bad_config;
 #endif
 #if	!defined(CPU_XSCALE_PXA250)
 	if (__CPU_IS_PXA250)
 		goto bad_config;
 #endif
 	return 1;
 #if	defined(CPU_XSCALE_PXA250) + defined(CPU_XSCALE_PXA270) != 2
  bad_config:
 	aprint_error("Kernel is configured for %s, but CPU is %s\n",
 		     SUPPORTED_CPU, __CPU_IS_PXA270 ? "PXA270" : "PXA250");
 	return 0;
 #endif
+}
 static void
-pxaip_attach(struct device *parent, struct device *self, void *aux)
+pxaip_attach(device_t parent, device_t self, void *aux)
+{
-	struct pxaip_softc *sc = (struct pxaip_softc *)self;
+	struct pxaip_softc *sc = device_private(self);
 	int cpuclock;
 	pxaip_sc = sc;
 	sc->sc_dev = self;
 	sc->sc_bust = &pxa2x0_bs_tag;
 	sc->sc_dmat = &pxa2x0_bus_dma_tag;
-	aprint_normal(": PXA2x0 Onchip Peripheral Bus\n");
+	aprint_normal(": Onchip Peripheral Bus\n");
 	if (bus_space_map(sc->sc_bust, PXA2X0_CLKMAN_BASE, PXA2X0_CLKMAN_SIZE,
 , &sc->sc_bush_clk))
 		panic("pxaip_attach: failed to map CLKMAN");
 	if (bus_space_map(sc->sc_bust, PXA2X0_MEMCTL_BASE, PXA2X0_MEMCTL_SIZE,
 , &sc->sc_bush_mem))
 		panic("pxaip_attach: failed to map MEMCTL");
 	/*
 	 * Calculate clock speed
 	 * This takes 2 secs at most.
 	 */
 @@ -224,28 +224,27 @@ pxaip_attach(struct device *parent, stru
 	/*
 	 * Attach critical devices
 	 */
 	pxaip_attach_critical(sc);
 	/*
 	 * Attach all other devices
 	 */
 	config_search_ia(pxaip_search, self, "pxaip", sc);
+}
 static int
-pxaip_search(struct device *parent, struct cfdata *cf,
+pxaip_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux)
 	     const int *ldesc, void *aux)
+{
 	struct pxaip_softc *sc = aux;
 	struct pxaip_attach_args aa;
 	aa.pxa_iot = sc->sc_bust;
 	aa.pxa_dmat = sc->sc_dmat;
 	aa.pxa_name = cf->cf_name;
 	aa.pxa_addr = cf->cf_loc[PXAIPCF_ADDR];
 	aa.pxa_size = cf->cf_loc[PXAIPCF_SIZE];
 	aa.pxa_index = cf->cf_loc[PXAIPCF_INDEX];
 	aa.pxa_intr = cf->cf_loc[PXAIPCF_INTR];
 	if (config_match(parent, cf, &aa))
 @@ -255,56 +254,56 @@ pxaip_search(struct device *parent, stru
+}
 static void
 pxaip_attach_critical(struct pxaip_softc *sc)
+{
 	struct pxaip_attach_args aa;
 	aa.pxa_iot = sc->sc_bust;
 	aa.pxa_dmat = sc->sc_dmat;
 	aa.pxa_name = "pxaintc";
 	aa.pxa_addr = PXA2X0_INTCTL_BASE;
 	aa.pxa_size = PXA2X0_INTCTL_SIZE;
 	aa.pxa_intr = PXAIPCF_INTR_DEFAULT;
-	if (config_found(&sc->sc_dev, &aa, pxaip_print) == NULL)
+	if (config_found(sc->sc_dev, &aa, pxaip_print) == NULL)
 		panic("pxaip_attach_critical: failed to attach INTC!");
 #if NPXAGPIO > 0
 	aa.pxa_iot = sc->sc_bust;
 	aa.pxa_dmat = sc->sc_dmat;
 	aa.pxa_name = "pxagpio";
 	aa.pxa_addr = PXA2X0_GPIO_BASE;
 	aa.pxa_size = PXA2X0_GPIO_SIZE;
 	aa.pxa_intr = PXAIPCF_INTR_DEFAULT;
-	if (config_found(&sc->sc_dev, &aa, pxaip_print) == NULL)
+	if (config_found(sc->sc_dev, &aa, pxaip_print) == NULL)
 		panic("pxaip_attach_critical: failed to attach GPIO!");
 #endif
 #if NPXADMAC > 0
 	aa.pxa_iot = sc->sc_bust;
 	aa.pxa_dmat = sc->sc_dmat;
 	aa.pxa_name = "pxaidmac";
 	aa.pxa_addr = PXA2X0_DMAC_BASE;
 	aa.pxa_size = PXA2X0_DMAC_SIZE;
 	aa.pxa_intr = PXA2X0_INT_DMA;
-	if (config_found(&sc->sc_dev, &aa, pxaip_print) == NULL)
+	if (config_found(sc->sc_dev, &aa, pxaip_print) == NULL)
 		panic("pxaip_attach_critical: failed to attach DMAC!");
 #endif
+}
 static int
 pxaip_print(void *aux, const char *name)
+{
-	struct pxaip_attach_args *sa = (struct pxaip_attach_args*)aux;
+	struct pxaip_attach_args *sa = (struct pxaip_attach_args *)aux;
 	if (sa->pxa_addr != PXAIPCF_ADDR_DEFAULT) {
 		aprint_normal(" addr 0x%lx", sa->pxa_addr);
 		if (sa->pxa_size > PXAIPCF_SIZE_DEFAULT)
 			aprint_normal("-0x%lx", sa->pxa_addr + sa->pxa_size-1);
+	}
 	if (sa->pxa_intr != PXAIPCF_INTR_DEFAULT)
 		aprint_normal(" intr %d", sa->pxa_intr);
 	return (UNCONF);
+}
 static inline uint32_t

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pxa2x0_ac97.c,v 1.7 2007/10/17 19:53:44 garbled Exp $	*/
+/*	$NetBSD: pxa2x0_ac97.c,v 1.8 2011/06/09 17:29:42 nonaka Exp $	*/
 /*
  * Copyright (c) 2003, 2005 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Steve C. Woodford for Wasabi Systems, Inc.
+ *
  * 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
 @@ -65,27 +65,27 @@ struct acu_dma {
 	bus_dmamap_t ad_map;
 	void *ad_addr;
 #define	ACU_N_SEGS	1	/* XXX: We don't support > 1 */
 	bus_dma_segment_t ad_segs[ACU_N_SEGS];
 	int ad_nsegs;
 	size_t ad_size;
 	struct dmac_xfer *ad_dx;
 	struct acu_dma *ad_next;
 };
 #define KERNADDR(ad) ((void *)((ad)->ad_addr))
 struct acu_softc {
-	struct device sc_dev;
+	device_t sc_dev;
 	bus_space_tag_t sc_bust;
 	bus_dma_tag_t sc_dmat;
 	bus_space_handle_t sc_bush;
 	void *sc_irqcookie;
 	int sc_in_reset;
 	u_int sc_dac_rate;
 	u_int sc_adc_rate;
 	/* List of DMA ring-buffers allocated by acu_malloc() */
 	struct acu_dma *sc_dmas;
 	/* Dummy DMA segment which points to the AC97 PCM Fifo register */
 	bus_dma_segment_t sc_dr;
 @@ -103,30 +103,30 @@ struct acu_softc {
 	void *sc_rxarg;
 	/* AC97 Codec State */
 	struct ac97_codec_if *sc_codec_if;
 	struct ac97_host_if sc_host_if;
 	/* Child audio(4) device */
 	struct device *sc_audiodev;
 	/* auconv encodings */
 	struct audio_encoding_set *sc_encodings;
 };
-static int	pxaacu_match(struct device *, struct cfdata *, void *);
+static int	pxaacu_match(device_t, cfdata_t, void *);
-static void	pxaacu_attach(struct device *, struct device *, void *);
+static void	pxaacu_attach(device_t, device_t, void *);
-CFATTACH_DECL(pxaacu, sizeof(struct acu_softc),
+CFATTACH_DECL_NEW(pxaacu, sizeof(struct acu_softc),
     pxaacu_match, pxaacu_attach, NULL, NULL);
 static int acu_codec_attach(void *, struct ac97_codec_if *);
 static int acu_codec_read(void *, u_int8_t, u_int16_t *);
 static int acu_codec_write(void *, u_int8_t, u_int16_t);
 static int acu_codec_reset(void *);
 static int acu_intr(void *);
 static int acu_open(void *, int);
 static void acu_close(void *);
 static int acu_query_encoding(void *, struct audio_encoding *);
 static int acu_set_params(void *, int, int, audio_params_t *, audio_params_t *,
 	    stream_filter_list_t *, stream_filter_list_t *);
 @@ -220,128 +220,126 @@ acu_wait_gsr(struct acu_softc *sc, u_int
 	for (timeout = 5000; timeout; timeout--) {
 		if ((rv = acu_reg_read(sc, AC97_GSR)) & bit) {
 			acu_reg_write(sc, AC97_GSR, rv | bit);
 			return (0);
+		}
 		delay(1);
+	}
 	return (1);
+}
 static int
-pxaacu_match(struct device *parent, struct cfdata *cf, void *aux)
+pxaacu_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct pxaip_attach_args *pxa = aux;
 	struct pxa2x0_gpioconf *gpioconf;
 	u_int gpio;
 	int i;
 	if (pxa->pxa_addr != PXA2X0_AC97_BASE ||
 	    pxa->pxa_intr != PXA2X0_INT_AC97)
 		return (0);
 	gpioconf = CPU_IS_PXA250 ? pxa25x_pxaacu_gpioconf :
 	    pxa27x_pxaacu_gpioconf;
 	for (i = 0; gpioconf[i].pin != -1; i++) {
 		gpio = pxa2x0_gpio_get_function(gpioconf[i].pin);
 		if (GPIO_FN(gpio) != GPIO_FN(gpioconf[i].value) ||
 		    GPIO_FN_IS_OUT(gpio) != GPIO_FN_IS_OUT(gpioconf[i].value))
 			return (0);
+	}
 	pxa->pxa_size = PXA2X0_AC97_SIZE;
 	return (1);
+}
 static void
-pxaacu_attach(struct device *parent, struct device *self, void *aux)
+pxaacu_attach(device_t parent, device_t self, void *aux)
+{
-	struct acu_softc *sc = (struct acu_softc *)self;
+	struct acu_softc *sc = device_private(self);
 	struct pxaip_attach_args *pxa = aux;
 	sc->sc_dev = self;
 	sc->sc_bust = pxa->pxa_iot;
 	sc->sc_dmat = pxa->pxa_dmat;
 	aprint_naive("\n");
 	aprint_normal(": AC97 Controller\n");
 	if (bus_space_map(sc->sc_bust, pxa->pxa_addr, pxa->pxa_size, 0,
 	    &sc->sc_bush)) {
-		aprint_error("%s: Can't map registers!\n", sc->sc_dev.dv_xname);
+		aprint_error_dev(self, "Can't map registers!\n");
 		return;
+	}
 	sc->sc_irqcookie = pxa2x0_intr_establish(pxa->pxa_intr, IPL_AUDIO,
 	    acu_intr, sc);
 	KASSERT(sc->sc_irqcookie != NULL);
 	/* Make sure the AC97 clock is enabled */
 	pxa2x0_clkman_config(CKEN_AC97, true);
 	delay(100);
 	/* Do a cold reset */
 	acu_reg_write(sc, AC97_GCR, 0);
 	delay(100);
 	acu_reg_write(sc, AC97_GCR, GCR_COLD_RST);
 	delay(100);
 	acu_reg_write(sc, AC97_CAR, 0);
 	if (acu_wait_gsr(sc, GSR_PCR)) {
 		acu_reg_write(sc, AC97_GCR, 0);
 		delay(100);
 		pxa2x0_clkman_config(CKEN_AC97, false);
 		bus_space_unmap(sc->sc_bust, sc->sc_bush, pxa->pxa_size);
-		aprint_error("%s: Primary codec not ready\n",
+		aprint_error_dev(self, "Primary codec not ready\n");
 		    sc->sc_dev.dv_xname);
 		return;
+	}
 	sc->sc_dr.ds_addr = pxa->pxa_addr + AC97_PCDR;
 	sc->sc_dr.ds_len = 4;
 	sc->sc_codec_if = NULL;
 	sc->sc_host_if.arg = sc;
 	sc->sc_host_if.attach = acu_codec_attach;
 	sc->sc_host_if.read = acu_codec_read;
 	sc->sc_host_if.write = acu_codec_write;
 	sc->sc_host_if.reset = acu_codec_reset;
 	sc->sc_host_if.flags = NULL;
 	sc->sc_in_reset = 0;
 	sc->sc_dac_rate = sc->sc_adc_rate = 0;
-	if (ac97_attach(&sc->sc_host_if, &sc->sc_dev)) {
+	if (ac97_attach(&sc->sc_host_if, sc->sc_dev)) {
-		aprint_error("%s: Failed to attach primary codec\n",
+		aprint_error_dev(self, "Failed to attach primary codec\n");
 		    sc->sc_dev.dv_xname);
  fail:
 		acu_reg_write(sc, AC97_GCR, 0);
 		delay(100);
 		pxa2x0_clkman_config(CKEN_AC97, false);
 		bus_space_unmap(sc->sc_bust, sc->sc_bush, pxa->pxa_size);
 		return;
+	}
 	if (auconv_create_encodings(acu_formats, ACU_NFORMATS,
 	    &sc->sc_encodings)) {
-		aprint_error("%s: Failed to create encodings\n",
+		aprint_error_dev(self, "Failed to create encodings\n");
 		    sc->sc_dev.dv_xname);
 		if (sc->sc_codec_if != NULL)
 			(sc->sc_codec_if->vtbl->detach)(sc->sc_codec_if);
 		goto fail;
+	}
-	sc->sc_audiodev = audio_attach_mi(&acu_hw_if, sc, &sc->sc_dev);
+	sc->sc_audiodev = audio_attach_mi(&acu_hw_if, sc, sc->sc_dev);
 	/*
 	 * As a work-around for braindamage in the PXA250's AC97 controller
 	 * (see errata #125), we hold the ACUNIT/Codec in Cold Reset until
 	 * acu_open() is called. acu_close() also puts the controller into
 	 * Cold Reset.
+	 *
 	 * While this won't necessarily prevent Rx FIFO overruns, it at least
 	 * allows the user to recover by closing then re-opening the audio
 	 * device.
 	 */
 	acu_reg_write(sc, AC97_GCR, 0);
 	sc->sc_in_reset = 1;
 @@ -453,66 +451,66 @@ acu_codec_write(void *arg, u_int8_t code
 static int
 acu_codec_reset(void *arg)
+{
 	struct acu_softc *sc = arg;
 	u_int32_t rv;
 	rv = acu_reg_read(sc, AC97_GCR);
 	acu_reg_write(sc, AC97_GCR, rv | GCR_WARM_RST);
 	delay(100);
 	acu_reg_write(sc, AC97_GCR, rv);
 	delay(100);
 	if (acu_wait_gsr(sc, GSR_PCR)) {
-		printf("%s: acu_codec_reset: failed to ready after reset\n",
+		aprint_error_dev(sc->sc_dev,
-		    sc->sc_dev.dv_xname);
+		    "acu_codec_reset: failed to ready after reset\n");
 		return (ETIMEDOUT);
+	}
 	return (0);
+}
 static int
 acu_intr(void *arg)
+{
 	struct acu_softc *sc = arg;
 	u_int32_t gsr, reg;
 	gsr = acu_reg_read(sc, AC97_GSR);
 	/*
 	 * Tx FIFO underruns are no big deal. Just log it and ignore and
 	 * subsequent underruns until the next time acu_trigger_output()
 	 * is called.
 	 */
 	if ((gsr & GSR_POINT) && (acu_reg_read(sc, AC97_POCR) & AC97_FEFIE)) {
 		acu_reg_write(sc, AC97_POCR, 0);
 		reg = acu_reg_read(sc, AC97_POSR);
 		acu_reg_write(sc, AC97_POSR, reg);
-		printf("%s: Tx PCM Fifo underrun\n", sc->sc_dev.dv_xname);
+		aprint_error_dev(sc->sc_dev, "Tx PCM Fifo underrun\n");
+	}
 	/*
 	 * Rx FIFO overruns are a different story. See PAX250 Errata #125
 	 * for the gory details.
 	 * I don't see any way to gracefully recover from this problem,
 	 * other than a issuing a Cold Reset in acu_close().
 	 * The best we can do here is to report the problem on the console.
 	 */
 	if ((gsr & GSR_PIINT) && (acu_reg_read(sc, AC97_PICR) & AC97_FEFIE)) {
 		acu_reg_write(sc, AC97_PICR, 0);
 		reg = acu_reg_read(sc, AC97_PISR);
 		acu_reg_write(sc, AC97_PISR, reg);
-		printf("%s: Rx PCM Fifo overrun\n", sc->sc_dev.dv_xname);
+		aprint_error_dev(sc->sc_dev, "Rx PCM Fifo overrun\n");
+	}
 	return (1);
+}
 static int
 acu_open(void *arg, int flags)
+{
 	struct acu_softc *sc = arg;
 	/*
 	 * Deassert Cold Reset
 	 */
 @@ -915,46 +913,46 @@ static void
 acu_tx_loop_segment(struct dmac_xfer *dx, int status)
+{
 	struct acu_softc *sc = dx->dx_cookie;
 	struct acu_dma *ad;
 	int s;
 	if ((ad = sc->sc_txdma) == NULL)
 		panic("acu_tx_loop_segment: bad TX dma descriptor!");
 	if (ad->ad_dx != dx)
 		panic("acu_tx_loop_segment: xfer mismatch!");
 	if (status) {
-		printf(
+		aprint_error_dev(sc->sc_dev,
-		    "%s: acu_tx_loop_segment: non-zero completion status %d\n",
+		    "acu_tx_loop_segment: non-zero completion status %d\n",
-		    sc->sc_dev.dv_xname, status);
+		    status);
+	}
 	s = splaudio();
 	(sc->sc_txfunc)(sc->sc_txarg);
 	splx(s);
+}
 static void
 acu_rx_loop_segment(struct dmac_xfer *dx, int status)
+{
 	struct acu_softc *sc = dx->dx_cookie;
 	struct acu_dma *ad;
 	int s;
 	if ((ad = sc->sc_rxdma) == NULL)
 		panic("acu_rx_loop_segment: bad RX dma descriptor!");
 	if (ad->ad_dx != dx)
 		panic("acu_rx_loop_segment: xfer mismatch!");
 	if (status) {
-		printf(
+		aprint_error_dev(sc->sc_dev,
-		    "%s: acu_rx_loop_segment: non-zero completion status %d\n",
+		    "acu_rx_loop_segment: non-zero completion status %d\n",
-		    sc->sc_dev.dv_xname, status);
+		    status);
+	}
 	s = splaudio();
 	(sc->sc_rxfunc)(sc->sc_rxarg);
 	splx(s);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pxa2x0_dmac.c,v 1.6 2009/03/16 11:42:31 nonaka Exp $	*/
+/*	$NetBSD: pxa2x0_dmac.c,v 1.7 2011/06/09 17:29:42 nonaka Exp $	*/
 /*
  * Copyright (c) 2003, 2005 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Steve C. Woodford for Wasabi Systems, Inc.
+ *
  * 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
 @@ -153,27 +153,27 @@ struct dmac_dmover_state {
 /*
  * Overall dmover(9) backend state
  */
 struct dmac_dmover {
 	struct dmover_backend dd_backend;
 	int dd_busy;
 	LIST_HEAD(, dmac_dmover_state) dd_free;
 	struct dmac_dmover_state dd_state[PXA2X0_DMAC_DMOVER_CONCURRENCY];
 };
 #endif
 struct pxadmac_softc {
-	struct device sc_dev;
+	device_t sc_dev;
 	bus_space_tag_t sc_bust;
 	bus_dma_tag_t sc_dmat;
 	bus_space_handle_t sc_bush;
 	void *sc_irqcookie;
 	/*
 	 * Queue of pending requests, per priority
 	 */
 	struct dmac_xfer_state_head sc_queue[DMAC_N_PRIORITIES];
 	/*
 	 * Queue of pending requests, per peripheral
 	 */
 @@ -206,30 +206,30 @@ struct pxadmac_softc {
 #define	DMAC_DESCS_SIZE	(DMAC_N_DESCS * sizeof(struct pxa2x0_dma_desc))
 	struct dmac_desc sc_all_descs[DMAC_N_DESCS];
 	u_int sc_free_descs;
 	SLIST_HEAD(, dmac_desc) sc_descs;
 #if (PXA2X0_DMAC_DMOVER_CONCURRENCY > 0)
 	/*
 	 * dmover(9) backend state
 	 */
 	struct dmac_dmover sc_dmover;
 #endif
 };
-static int	pxadmac_match(struct device *, struct cfdata *, void *);
+static int	pxadmac_match(device_t, cfdata_t, void *);
-static void	pxadmac_attach(struct device *, struct device *, void *);
+static void	pxadmac_attach(device_t, device_t, void *);
-CFATTACH_DECL(pxadmac, sizeof(struct pxadmac_softc),
+CFATTACH_DECL_NEW(pxadmac, sizeof(struct pxadmac_softc),
     pxadmac_match, pxadmac_attach, NULL, NULL);
 static struct pxadmac_softc *pxadmac_sc;
 static void dmac_start(struct pxadmac_softc *, dmac_priority_t);
 static int dmac_continue_xfer(struct pxadmac_softc *, struct dmac_xfer_state *);
 static u_int dmac_channel_intr(struct pxadmac_softc *, u_int);
 static int dmac_intr(void *);
 #if (PXA2X0_DMAC_DMOVER_CONCURRENCY > 0)
 static void dmac_dmover_attach(struct pxadmac_softc *);
 static void dmac_dmover_process(struct dmover_backend *);
 static void dmac_dmover_run(struct dmover_backend *);
 @@ -268,55 +268,56 @@ dmac_allocate_channel(struct pxadmac_sof
 static inline void
 dmac_free_channel(struct pxadmac_softc *sc, dmac_priority_t priority,
     u_int channel)
+{
 	KDASSERT((u_int)priority < DMAC_N_PRIORITIES);
 	sc->sc_prio[priority].p_pri[channel] = sc->sc_prio[priority].p_first;
 	sc->sc_prio[priority].p_first = channel;
+}
 static int
-pxadmac_match(struct device *parent, struct cfdata *cf, void *aux)
+pxadmac_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct pxaip_attach_args *pxa = aux;
 	if (pxadmac_sc || pxa->pxa_addr != PXA2X0_DMAC_BASE ||
 	    pxa->pxa_intr != PXA2X0_INT_DMA)
 		return (0);
 	pxa->pxa_size = PXA2X0_DMAC_SIZE;
 	return (1);
+}
 static void
-pxadmac_attach(struct device *parent, struct device *self, void *aux)
+pxadmac_attach(device_t parent, device_t self, void *aux)
+{
-	struct pxadmac_softc *sc = (struct pxadmac_softc *)self;
+	struct pxadmac_softc *sc = device_private(self);
 	struct pxaip_attach_args *pxa = aux;
 	struct pxa2x0_dma_desc *dd;
 	int i, nsegs;
 	sc->sc_dev = self;
 	sc->sc_bust = pxa->pxa_iot;
 	sc->sc_dmat = pxa->pxa_dmat;
 	aprint_normal(": DMA Controller\n");
 	if (bus_space_map(sc->sc_bust, pxa->pxa_addr, pxa->pxa_size, 0,
 	    &sc->sc_bush)) {
-		aprint_error("%s: Can't map registers!\n", sc->sc_dev.dv_xname);
+		aprint_error_dev(self, "Can't map registers!\n");
 		return;
+	}
 	pxadmac_sc = sc;
 	/*
 	 * Make sure the DMAC is quiescent
 	 */
 	for (i = 0; i < DMAC_N_CHANNELS; i++) {
 		dmac_reg_write(sc, DMAC_DCSR(i), 0);
 		dmac_reg_write(sc, DMAC_DRCMR(i), 0);
 		sc->sc_active[i] = NULL;
+	}
 @@ -1176,28 +1177,29 @@ static u_int
 dmac_channel_intr(struct pxadmac_softc *sc, u_int channel)
+{
 	struct dmac_xfer_state *dxs;
 	struct dmac_desc *desc, *ndesc;
 	u_int32_t dcsr;
 	u_int rv = 0;
 	dcsr = dmac_reg_read(sc, DMAC_DCSR(channel));
 	dmac_reg_write(sc, DMAC_DCSR(channel), dcsr);
 	if (dmac_reg_read(sc, DMAC_DCSR(channel)) & DCSR_STOPSTATE)
 		dmac_reg_write(sc, DMAC_DCSR(channel), dcsr & ~DCSR_RUN);
 	if ((dxs = sc->sc_active[channel]) == NULL) {
-		printf("%s: Stray DMAC interrupt for unallocated channel %d\n",
+		aprint_error_dev(sc->sc_dev,
-		    sc->sc_dev.dv_xname, channel);
+		    "Stray DMAC interrupt for unallocated channel %d\n",
 		    channel);
 		return (0);
+	}
 	/*
 	 * Clear down the interrupt in the DMA Interrupt Register
 	 */
 	dmac_reg_write(sc, DMAC_DINT, (1u << channel));
 	/*
 	 * If this is a looping request, invoke the 'done' callback and
 	 * return immediately.
 	 */
 	if (dxs->dxs_loop_notify != DMAC_DONT_LOOP &&

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pxa2x0_gpio.c,v 1.13 2009/08/04 12:11:33 kiyohara Exp $	*/
+/*	$NetBSD: pxa2x0_gpio.c,v 1.14 2011/06/09 17:29:42 nonaka Exp $	*/
 /*
  * Copyright 2003 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Steve C. Woodford for Wasabi Systems, Inc.
+ *
  * 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
 @@ -26,27 +26,27 @@
  * 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 WASABI SYSTEMS, INC
  * 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/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pxa2x0_gpio.c,v 1.13 2009/08/04 12:11:33 kiyohara Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pxa2x0_gpio.c,v 1.14 2011/06/09 17:29:42 nonaka Exp $");
 #include "opt_pxa2x0_gpio.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/malloc.h>
 #include <machine/intr.h>
 #include <machine/bus.h>
 #include <arm/xscale/pxa2x0cpu.h>
 #include <arm/xscale/pxa2x0reg.h>
 @@ -55,42 +55,42 @@ __KERNEL_RCSID(0, "$NetBSD: pxa2x0_gpio.
 #include "locators.h"
 struct gpio_irq_handler {
 	struct gpio_irq_handler *gh_next;
 	int (*gh_func)(void *);
 	void *gh_arg;
 	int gh_spl;
 	u_int gh_gpio;
 	int gh_level;
 };
 struct pxagpio_softc {
-	struct device sc_dev;
+	device_t sc_dev;
 	bus_space_tag_t sc_bust;
 	bus_space_handle_t sc_bush;
 	void *sc_irqcookie[4];
 	u_int32_t sc_mask[4];
 #ifdef PXAGPIO_HAS_GPION_INTRS
 	struct gpio_irq_handler *sc_handlers[GPIO_NPINS];
 #else
 	struct gpio_irq_handler *sc_handlers[2];
 #endif
 };
-static int	pxagpio_match(struct device *, struct cfdata *, void *);
+static int	pxagpio_match(device_t, cfdata_t, void *);
-static void	pxagpio_attach(struct device *, struct device *, void *);
+static void	pxagpio_attach(device_t, device_t, void *);
-CFATTACH_DECL(pxagpio, sizeof(struct pxagpio_softc),
+CFATTACH_DECL_NEW(pxagpio, sizeof(struct pxagpio_softc),
     pxagpio_match, pxagpio_attach, NULL, NULL);
 static struct pxagpio_softc *pxagpio_softc;
 static vaddr_t pxagpio_regs;
 #define GPIO_BOOTSTRAP_REG(reg)	\
 	(*((volatile u_int32_t *)(pxagpio_regs + (reg))))
 static int gpio_intr0(void *);
 static int gpio_intr1(void *);
 #ifdef PXAGPIO_HAS_GPION_INTRS
 static int gpio_dispatch(struct pxagpio_softc *, int);
 static int gpio_intrN(void *);
 #endif
 @@ -110,51 +110,52 @@ static inline void
 pxagpio_reg_write(struct pxagpio_softc *sc, int reg, u_int32_t val)
+{
 	if (__predict_true(sc != NULL))
 		bus_space_write_4(sc->sc_bust, sc->sc_bush, reg, val);
 	else
 	if (pxagpio_regs)
 		GPIO_BOOTSTRAP_REG(reg) = val;
 	else
 		panic("pxagpio_reg_write: not bootstrapped");
 	return;
+}
 static int
-pxagpio_match(struct device *parent, struct cfdata *cf, void *aux)
+pxagpio_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct pxaip_attach_args *pxa = aux;
 	if (pxagpio_softc != NULL || pxa->pxa_addr != PXA2X0_GPIO_BASE)
 		return (0);
 	pxa->pxa_size = PXA2X0_GPIO_SIZE;
 	return (1);
+}
 static void
-pxagpio_attach(struct device *parent, struct device *self, void *aux)
+pxagpio_attach(device_t parent, device_t self, void *aux)
+{
-	struct pxagpio_softc *sc = (struct pxagpio_softc *)self;
+	struct pxagpio_softc *sc = device_private(self);
 	struct pxaip_attach_args *pxa = aux;
 	sc->sc_dev = self;
 	sc->sc_bust = pxa->pxa_iot;
 	aprint_normal(": GPIO Controller\n");
 	if (bus_space_map(sc->sc_bust, pxa->pxa_addr, pxa->pxa_size, 0,
 	    &sc->sc_bush)) {
-		aprint_error("%s: Can't map registers!\n", sc->sc_dev.dv_xname);
+		aprint_error_dev(self, "Can't map registers!\n");
 		return;
+	}
 	pxagpio_regs = (vaddr_t)bus_space_vaddr(sc->sc_bust, sc->sc_bush);
 	memset(sc->sc_handlers, 0, sizeof(sc->sc_handlers));
 	/*
 	 * Disable all GPIO interrupts
 	 */
 	pxagpio_reg_write(sc, GPIO_GRER0, 0);
 	pxagpio_reg_write(sc, GPIO_GRER1, 0);
 	pxagpio_reg_write(sc, GPIO_GRER2, 0);
 @@ -166,28 +167,27 @@ pxagpio_attach(struct device *parent, st
 	pxagpio_reg_write(sc, GPIO_GEDR2, ~0);
 #ifdef	CPU_XSCALE_PXA270
 	if (CPU_IS_PXA270) {
 		pxagpio_reg_write(sc, GPIO_GRER3, 0);
 		pxagpio_reg_write(sc, GPIO_GFER3, 0);
 		pxagpio_reg_write(sc, GPIO_GEDR3, ~0);
+	}
 #endif
 #ifdef PXAGPIO_HAS_GPION_INTRS
 	sc->sc_irqcookie[2] = pxa2x0_intr_establish(PXA2X0_INT_GPION, IPL_BIO,
 	    gpio_intrN, sc);
 	if (sc->sc_irqcookie[2] == NULL) {
-		aprint_error("%s: failed to hook main GPIO interrupt\n",
+		aprint_error_dev(self, "failed to hook main GPIO interrupt\n");
 		    sc->sc_dev.dv_xname);
 		return;
+	}
 #endif
 	sc->sc_irqcookie[0] = sc->sc_irqcookie[1] = NULL;
 	pxagpio_softc = sc;
+}
 void
 pxa2x0_gpio_bootstrap(vaddr_t gpio_regs)
+{
 @@ -313,47 +313,45 @@ pxa2x0_gpio_intr_disestablish(void *cook
 #endif
+	}
 	free(gh, M_DEVBUF);
+}
 static int
 gpio_intr0(void *arg)
+{
 	struct pxagpio_softc *sc = arg;
 #ifdef DIAGNOSTIC
 	if (sc->sc_handlers[0] == NULL) {
-		printf("%s: stray GPIO#0 edge interrupt\n",
+		aprint_error_dev(sc->sc_dev, "stray GPIO#0 edge interrupt\n");
 		    sc->sc_dev.dv_xname);
 		return (0);
+	}
 #endif
 	bus_space_write_4(sc->sc_bust, sc->sc_bush, GPIO_REG(GPIO_GEDR0, 0),
 	    GPIO_BIT(0));
 	return ((sc->sc_handlers[0]->gh_func)(sc->sc_handlers[0]->gh_arg));
+}
 static int
 gpio_intr1(void *arg)
+{
 	struct pxagpio_softc *sc = arg;
 #ifdef DIAGNOSTIC
 	if (sc->sc_handlers[1] == NULL) {
-		printf("%s: stray GPIO#1 edge interrupt\n",
+		aprint_error_dev(sc->sc_dev, "stray GPIO#1 edge interrupt\n");
 		    sc->sc_dev.dv_xname);
 		return (0);
+	}
 #endif
 	bus_space_write_4(sc->sc_bust, sc->sc_bush, GPIO_REG(GPIO_GEDR0, 1),
 	    GPIO_BIT(1));
 	return ((sc->sc_handlers[1]->gh_func)(sc->sc_handlers[1]->gh_arg));
+}
 #ifdef PXAGPIO_HAS_GPION_INTRS
 static int
 gpio_dispatch(struct pxagpio_softc *sc, int gpio_base)
 @@ -375,48 +373,50 @@ gpio_dispatch(struct pxagpio_softc *sc,
 		return (0);
 	/* Acknowledge pending interrupts. */
 	pxagpio_reg_write(sc, GPIO_REG(GPIO_GEDR0, gpio_base), gedr);
 	bank = GPIO_BANK(gpio_base);
 	/*
 	 * We're only interested in those for which we have a handler
 	 * registered
 	 */
 #ifdef DEBUG
 	if ((gedr & sc->sc_mask[bank]) == 0) {
-		printf("%s: stray GPIO interrupt. Bank %d, GEDR 0x%08x, mask 0x%08x\n",
+		aprint_error_dev(sc->sc_dev,
-		    sc->sc_dev.dv_xname, bank, gedr, sc->sc_mask[bank]);
+		    "stray GPIO interrupt. Bank %d, GEDR 0x%08x, mask 0x%08x\n",
 		    bank, gedr, sc->sc_mask[bank]);
 		return (1);	/* XXX: Pretend we dealt with it */
+	}
 #endif
 	gedr &= sc->sc_mask[bank];
 	ghp = &sc->sc_handlers[gpio_base];
 	if (CPU_IS_PXA270)
 		pins = (gpio_base < 96) ? 32 : 25;
 	else
 		pins = (gpio_base < 64) ? 32 : 17;
 	handled = 0;
 	for (i = 0, mask = 1; i < pins && gedr; i++, ghp++, mask <<= 1) {
 		if ((gedr & mask) == 0)
 			continue;
 		gedr &= ~mask;
 		if ((gh = *ghp) == NULL) {
-			printf("%s: unhandled GPIO interrupt. GPIO#%d\n",
+			aprint_error_dev(sc->sc_dev,
-			    sc->sc_dev.dv_xname, gpio_base + i);
+			    "unhandled GPIO interrupt. GPIO#%d\n",
 			    gpio_base + i);
 			continue;
+		}
 		s = _splraise(gh->gh_spl);
 		do {
 			nhandled = (gh->gh_func)(gh->gh_arg);
 			handled |= nhandled;
 			gh = gh->gh_next;
 		} while (gh != NULL);
 		splx(s);
+	}
 	return (handled);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pxa2x0_udc.c,v 1.3 2009/08/09 06:24:03 kiyohara Exp $	*/
+/*	$NetBSD: pxa2x0_udc.c,v 1.4 2011/06/09 17:29:42 nonaka Exp $	*/
 /*	$OpenBSD: pxa27x_udc.c,v 1.5 2005/03/30 14:24:39 dlg Exp $ */
 /*
  * Copyright (c) 2005 David Gwynne <dlg@openbsd.org>
+ *
  * 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
 @@ -21,94 +21,95 @@
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <machine/intr.h>
 #include <machine/bus.h>
 #include <arm/xscale/pxa2x0cpu.h>
 #include <arm/xscale/pxa2x0reg.h>
 #include <arm/xscale/pxa2x0var.h>
 #include <arm/xscale/pxa2x0_gpio.h>
 struct pxaudc_softc {
-	struct device		sc_dev;
+	device_t		sc_dev;
 	bus_space_tag_t		sc_iot;
 	bus_space_handle_t	sc_ioh;
 	bus_size_t		sc_size;
 	void 			*sc_powerhook;
 };
-static int	pxaudc_match(struct device *, struct cfdata *, void *);
+static int	pxaudc_match(device_t, cfdata_t, void *);
-static void	pxaudc_attach(struct device *, struct device *, void *);
+static void	pxaudc_attach(device_t, device_t, void *);
-static int	pxaudc_detach(struct device *, int);
+static int	pxaudc_detach(device_t, int);
-CFATTACH_DECL(pxaudc, sizeof(struct pxaudc_softc),
+CFATTACH_DECL_NEW(pxaudc, sizeof(struct pxaudc_softc),
     pxaudc_match, pxaudc_attach, pxaudc_detach, NULL);
 static void	pxaudc_power(int, void *);
 static void	pxaudc_enable(struct pxaudc_softc *);
 static int
-pxaudc_match(struct device *parent, struct cfdata *cf, void *aux)
+pxaudc_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct pxaip_attach_args *pxa = aux;
 	if (CPU_IS_PXA270 && strcmp(pxa->pxa_name, cf->cf_name) == 0) {
 		pxa->pxa_size = PXA270_USBDC_SIZE;
 		return 1;
+	}
 	return 0;
+}
 static void
-pxaudc_attach(struct device *parent, struct device *self, void *aux)
+pxaudc_attach(device_t parent, device_t self, void *aux)
+{
-	struct pxaudc_softc *sc = (struct pxaudc_softc *)self;
+	struct pxaudc_softc *sc = device_private(self);
 	struct pxaip_attach_args *pxa = (struct pxaip_attach_args *)aux;
 	sc->sc_dev = self;
 	sc->sc_iot = pxa->pxa_iot;
 	sc->sc_size = 0;
 	sc->sc_powerhook = NULL;
 	aprint_normal(": USB Device Controller\n");
 	aprint_naive("\n");
 	if (bus_space_map(sc->sc_iot, pxa->pxa_addr, pxa->pxa_size, 0,
 	    &sc->sc_ioh)) {
-		aprint_error(": couldn't map memory space\n");
+		aprint_error_dev(self, "couldn't map memory space\n");
 		return;
+	}
 	sc->sc_size = pxa->pxa_size;
 	printf(": PXA2x0 USB Device Controller\n");
 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, 0, sc->sc_size,
 	    BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE);
 	pxa2x0_clkman_config(CKEN_USBDC, 1);
 	pxaudc_enable(sc);
-	sc->sc_powerhook = powerhook_establish(sc->sc_dev.dv_xname,
+	sc->sc_powerhook = powerhook_establish(device_xname(self),
 	    pxaudc_power, sc);
 	if (sc->sc_powerhook == NULL) {
-		aprint_error("%s: unable to establish powerhook.\n",
+		aprint_error_dev(self, "unable to establish powerhook.\n");
 		    sc->sc_dev.dv_xname);
+	}
+}
 static int
-pxaudc_detach(struct device *self, int flags)
+pxaudc_detach(device_t self, int flags)
+{
-	struct pxaudc_softc *sc = (struct pxaudc_softc *)self;
+	struct pxaudc_softc *sc = device_private(self);
 	if (sc->sc_powerhook)
 		powerhook_disestablish(sc->sc_powerhook);
 	if (sc->sc_size) {
 		bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_size);
 		sc->sc_size = 0;
+	}
 	return 0;
+}
 static void