 @@ -1,158 +1,159 @@
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_com.c,v 1.3 2013/09/07 01:50:12 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_com.c,v 1.4 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/termios.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 #include <dev/ic/comvar.h>
 static int awin_com_match(device_t, cfdata_t, void *);
 static void awin_com_attach(device_t, device_t, void *);
 struct awin_com_softc {
 	struct com_softc asc_sc;
 	void *asc_ih;
 };
 static const struct awin_gpio_pinset awin_com_pinsets[] = {
 	{ 'B', AWIN_PIO_PB_UART0_FUNC, AWIN_PIO_PB_UART0_PINS },
 	{ 'A', AWIN_PIO_PA_UART1_FUNC, AWIN_PIO_PA_UART1_PINS },
 	{ 'I', AWIN_PIO_PI_UART2_FUNC, AWIN_PIO_PI_UART2_PINS },
 	{ 'H', AWIN_PIO_PH_UART3_FUNC, AWIN_PIO_PH_UART3_PINS },
 	{ 'H', AWIN_PIO_PH_UART4_FUNC, AWIN_PIO_PH_UART4_PINS },
 	{ 'H', AWIN_PIO_PH_UART5_FUNC, AWIN_PIO_PH_UART5_PINS },
 	{ 'I', AWIN_PIO_PI_UART6_FUNC, AWIN_PIO_PI_UART6_PINS },
 	{ 'I', AWIN_PIO_PI_UART7_FUNC, AWIN_PIO_PI_UART7_PINS },
 };
 /* alternative pinnings */
 static const struct awin_gpio_pinset awin_com_alt_pinsets[] = {
 	{ 'F', AWIN_PIO_PF_UART0_FUNC, AWIN_PIO_PF_UART0_PINS },
 	{ 0, 0, 0},
 	{ 'A', AWIN_PIO_PA_UART2_FUNC, AWIN_PIO_PA_UART2_PINS },
 	{ 'G', AWIN_PIO_PG_UART3_FUNC, AWIN_PIO_PG_UART3_PINS },
 	{ 'G', AWIN_PIO_PG_UART4_FUNC, AWIN_PIO_PG_UART4_PINS },
 	{ 'I', AWIN_PIO_PI_UART5_FUNC, AWIN_PIO_PI_UART5_PINS },
 	{ 'A', AWIN_PIO_PA_UART6_FUNC, AWIN_PIO_PA_UART6_PINS },
 	{ 'A', AWIN_PIO_PA_UART7_FUNC, AWIN_PIO_PA_UART7_PINS },
 };
 CFATTACH_DECL_NEW(awin_com, sizeof(struct awin_com_softc),
 	awin_com_match, awin_com_attach, NULL, NULL);
 static int awin_com_ports;
 static int
 awin_com_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	bus_space_tag_t iot = aio->aio_core_a4x_bst;
 	bus_space_handle_t bsh;
 	const struct awin_gpio_pinset * const pinset = loc->loc_port +
 	    ((cf->cf_flags & 1) ? awin_com_alt_pinsets : awin_com_pinsets);
 	KASSERT(!strcmp(cf->cf_name, loc->loc_name));
 	KASSERT(loc->loc_offset >= AWIN_UART0_OFFSET);
 	KASSERT(loc->loc_offset <= AWIN_UART7_OFFSET);
 	KASSERT((loc->loc_offset & 0x3ff) == 0);
 	KASSERT((awin_com_ports & __BIT(loc->loc_port)) == 0);
 	KASSERT(cf->cf_loc[AWINIOCF_PORT] == AWINIOCF_PORT_DEFAULT
 	    || cf->cf_loc[AWINIOCF_PORT] == loc->loc_port);
 	if (!awin_gpio_pinset_available(pinset))
 		return 0;
 	if (com_is_console(iot, AWIN_CORE_PBASE + loc->loc_offset, NULL))
 		return 1;
 	awin_gpio_pinset_acquire(pinset);
 	bus_space_subregion(iot, aio->aio_core_bsh,
 	    loc->loc_offset, loc->loc_size, &bsh);
 	const int rv = comprobe1(iot, bsh);
 	awin_gpio_pinset_release(pinset);
 	return rv;
+}
 static void
 awin_com_attach(device_t parent, device_t self, void *aux)
+{
 	cfdata_t cf = device_cfdata(self);
 	struct awin_com_softc * const asc = device_private(self);
 	struct com_softc * const sc = &asc->asc_sc;
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	bus_space_tag_t iot = aio->aio_core_a4x_bst;
 	const bus_addr_t iobase = AWIN_CORE_PBASE + loc->loc_offset;
 	const struct awin_gpio_pinset * const pinset = loc->loc_port +
 	    ((cf->cf_flags & 1) ? awin_com_alt_pinsets : awin_com_pinsets);
 	bus_space_handle_t ioh;
 	awin_com_ports |= __BIT(loc->loc_port);
 	awin_gpio_pinset_acquire(pinset);
 	sc->sc_dev = self;
 	sc->sc_frequency = AWIN_UART_FREQ;
 	sc->sc_type = COM_TYPE_NORMAL;
 	if (com_is_console(iot, iobase, &ioh) == 0
 	    && bus_space_subregion(iot, aio->aio_core_bsh,
 		loc->loc_offset / 4, loc->loc_size, &ioh)) {
 		panic(": can't map registers");
+	}
 	COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
 	com_attach_subr(sc);
 	aprint_naive("\n");
 	KASSERT(loc->loc_intr != AWINIO_INTR_DEFAULT);
 	asc->asc_ih = intr_establish(loc->loc_intr, IPL_SERIAL, IST_EDGE,
 	    comintr, sc);
 	if (asc->asc_ih == NULL)
 		panic("%s: failed to establish interrupt %d",
 		    device_xname(self), loc->loc_intr);
+}

 @@ -1,152 +1,153 @@
 /*-
  * Copyright (c) 2012 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_sdhc.c,v 1.3 2013/09/07 00:35:52 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_sdhc.c,v 1.4 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 #include <dev/sdmmc/sdhcreg.h>
 #include <dev/sdmmc/sdhcvar.h>
 static int awin_sdhc_match(device_t, cfdata_t, void *);
 static void awin_sdhc_attach(device_t, device_t, void *);
 struct awin_sdhc_softc {
 	struct sdhc_softc asc_sc;
 	bus_space_tag_t asc_bst;
 	bus_space_handle_t asc_bsh;
 	struct sdhc_host *asc_hosts[1];
 	void *asc_ih;
 };
 static const struct awin_gpio_pinset awin_sdhc_pinsets[] = {
 	{ 'F', AWIN_PIO_PF_SDC0_FUNC, AWIN_PIO_PF_SDC0_PINS },
 	{ 'G', AWIN_PIO_PG_SDC1_FUNC, AWIN_PIO_PG_SDC1_PINS },
 	{ 'C', AWIN_PIO_PC_SDC2_FUNC, AWIN_PIO_PC_SDC2_PINS },
 	{ 'I', AWIN_PIO_PI_SDC3_FUNC, AWIN_PIO_PI_SDC3_PINS },
 };
 static const struct awin_gpio_pinset awin_sdhc_alt_pinsets[] = {
 	{ 0, 0, 0 },
 	{ 'H', AWIN_PIO_PH_SDC1_FUNC, AWIN_PIO_PH_SDC1_PINS },
 	{ 0, 0, 0 },
 	{ 0, 0, 0 },
 };
 CFATTACH_DECL_NEW(awin_sdhc, sizeof(struct awin_sdhc_softc),
 	awin_sdhc_match, awin_sdhc_attach, NULL, NULL);
 static int awin_sdhc_ports;
 static int
 awin_sdhc_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	const struct awin_gpio_pinset * const pinset = loc->loc_port
 	    + ((cf->cf_flags & 1) ? awin_sdhc_alt_pinsets : awin_sdhc_pinsets);
 	KASSERT(!strcmp(cf->cf_name, loc->loc_name));
 	KASSERT(cf->cf_loc[AWINIOCF_PORT] == AWINIOCF_PORT_DEFAULT
 	    || cf->cf_loc[AWINIOCF_PORT] == loc->loc_port);
 	KASSERT((awin_sdhc_ports & __BIT(loc->loc_port)) == 0);
 	if (!awin_gpio_pinset_available(pinset))
 		return 0;
 	return 1;
+}
 static void
 awin_sdhc_attach(device_t parent, device_t self, void *aux)
+{
 	struct awin_sdhc_softc * const asc = device_private(self);
 	struct sdhc_softc * const sc = &asc->asc_sc;
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	cfdata_t cf = device_cfdata(self);
 	const struct awin_gpio_pinset * const pinset = loc->loc_port
 	    + ((cf->cf_flags & 1) ? awin_sdhc_alt_pinsets : awin_sdhc_pinsets);
 	int error;
 	awin_sdhc_ports |= __BIT(loc->loc_port);
 	awin_gpio_pinset_acquire(pinset);
 	asc->asc_bst = aio->aio_core_bst;
 	bus_space_subregion(asc->asc_bst, aio->aio_core_bsh,
 	    loc->loc_offset, loc->loc_size, &asc->asc_bsh);
 	sc->sc_dev = self;
 	sc->sc_dmat = aio->aio_dmat;
 	sc->sc_host = asc->asc_hosts;
 	sc->sc_flags |= SDHC_FLAG_32BIT_ACCESS;
 	sc->sc_flags |= SDHC_FLAG_HAVE_CGM;
 	//sc->sc_flags |= SDHC_FLAG_USE_DMA;
 	aprint_naive(": SDHC controller\n");
 	aprint_normal(": SDHC controller%s\n",
 	   (sc->sc_flags & SDHC_FLAG_USE_DMA) ? " (DMA enabled)" : "");
 	asc->asc_ih = intr_establish(loc->loc_intr, IPL_VM, IST_LEVEL,
 	    sdhc_intr, sc);
 	if (asc->asc_ih == NULL) {
 		aprint_error_dev(self, "failed to establish interrupt %d\n",
 		     loc->loc_intr);
 		goto fail;
+	}
 	aprint_normal_dev(self, "interrupting on irq %d\n",
 	     loc->loc_intr);
 	error = sdhc_host_found(sc, asc->asc_bst, asc->asc_bsh,
 	    loc->loc_size);
 	if (error != 0) {
 		aprint_error_dev(self, "couldn't initialize host, error=%d\n",
 		    error);
 		goto fail;
+	}
 	return;
 fail:
 	if (asc->asc_ih) {
 		intr_disestablish(asc->asc_ih);
 		asc->asc_ih = NULL;
+	}
+}

 @@ -1,134 +1,135 @@
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_twi.c,v 1.2 2013/09/07 00:35:52 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_twi.c,v 1.3 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <dev/i2c/i2cvar.h>
 #include <dev/i2c/gttwsivar.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 static int awin_twi_match(device_t, cfdata_t, void *);
 static void awin_twi_attach(device_t, device_t, void *);
 struct awin_twi_softc {
 	struct gttwsi_softc asc_sc;
 	void *asc_ih;
 };
 static int awin_twi_ports;
 static const struct awin_gpio_pinset awin_twi_pinsets[] = {
 	[0] = { 'B', AWIN_PIO_PB_TWI0_FUNC, AWIN_PIO_PB_TWI0_PINS },
 	[1] = { 'B', AWIN_PIO_PB_TWI1_FUNC, AWIN_PIO_PB_TWI1_PINS },
 	[2] = { 'B', AWIN_PIO_PB_TWI2_FUNC, AWIN_PIO_PB_TWI2_PINS },
 	[3] = { 'I', AWIN_PIO_PI_TWI3_FUNC, AWIN_PIO_PI_TWI3_PINS },
 	[4] = { 'I', AWIN_PIO_PI_TWI4_FUNC, AWIN_PIO_PI_TWI4_PINS },
 };
 CFATTACH_DECL_NEW(awin_twi, sizeof(struct awin_twi_softc),
 	awin_twi_match, awin_twi_attach, NULL, NULL);
 static int
 awin_twi_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	KASSERT(!strcmp(cf->cf_name, loc->loc_name));
 	KASSERT(cf->cf_loc[AWINIOCF_PORT] == AWINIOCF_PORT_DEFAULT
 	    || cf->cf_loc[AWINIOCF_PORT] == loc->loc_port);
 	KASSERT((awin_twi_ports & __BIT(loc->loc_port)) == 0);
 	/*
 	 * We don't have alternative mappings so if one is requested
 	 * fail the match.
 	 */
 	if (cf->cf_flags & 1)
 		return 0;
 	if (!awin_gpio_pinset_available(&awin_twi_pinsets[loc->loc_port]))
 		return 0;
 	return 1;
+}
 static void
 awin_twi_attach(device_t parent, device_t self, void *aux)
+{
 	struct awin_twi_softc * const asc = device_private(self);
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	bus_space_handle_t bsh;
 	awin_twi_ports |= __BIT(loc->loc_port);
 	/*
 	 * Acquite the PIO pins needed for the TWI port.
 	 */
 	awin_gpio_pinset_acquire(&awin_twi_pinsets[loc->loc_port]);
 	/*
 	 * Get a bus space handle for this TWI port.
 	 */
 	bus_space_subregion(aio->aio_core_bst, aio->aio_core_bsh,
 	    loc->loc_offset, loc->loc_size, &bsh);
 	/*
 	 * Do the MI attach
 	 */
 	gttwsi_attach_subr(self, aio->aio_core_bst, bsh);
 	/*
 	 * Establish interrupt for it
 	 */
 	asc->asc_ih = intr_establish(loc->loc_intr, IPL_BIO, IST_LEVEL,
 	    gttwsi_intr, &asc->asc_sc);
 	if (asc->asc_ih == NULL) {
 		aprint_error_dev(self, "failed to establish interrupt %d\n",
 		    loc->loc_intr);
                 return;
+        }
 	aprint_normal_dev(self, "interrupting on irq %d\n", loc->loc_intr);
 	/*
 	 * Configure its children
 	 */
 	gttwsi_config_children(self);
+}

 @@ -1,208 +1,209 @@
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include "opt_allwinner.h"
 #include "awin_wdt.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_wdt.c,v 1.2 2013/09/04 17:45:40 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_wdt.c,v 1.3 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/wdog.h>
 #include <dev/sysmon/sysmonvar.h>
 #include <arm/locore.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 #if NAWIN_WDT > 0
 static int awin_wdt_match(device_t, cfdata_t, void *);
 static void awin_wdt_attach(device_t, device_t, void *);
 #ifndef AWIN_WDT_PERIOD_DEFAULT
 #define AWIN_WDT_PERIOD_DEFAULT  10
 #endif
 static const uint8_t period_map[] = {
 	[0] = __SHIFTIN(AWIN_WDOG_MODE_INTV_1SEC, AWIN_WDOG_MODE_INTV),
 	[1] = __SHIFTIN(AWIN_WDOG_MODE_INTV_1SEC, AWIN_WDOG_MODE_INTV),
 	[2] = __SHIFTIN(AWIN_WDOG_MODE_INTV_2SEC, AWIN_WDOG_MODE_INTV),
 	[3] = __SHIFTIN(AWIN_WDOG_MODE_INTV_3SEC, AWIN_WDOG_MODE_INTV),
 	[4] = __SHIFTIN(AWIN_WDOG_MODE_INTV_4SEC, AWIN_WDOG_MODE_INTV),
 	[5] = __SHIFTIN(AWIN_WDOG_MODE_INTV_5SEC, AWIN_WDOG_MODE_INTV),
 	[6] = __SHIFTIN(AWIN_WDOG_MODE_INTV_6SEC, AWIN_WDOG_MODE_INTV),
 	[7] = __SHIFTIN(AWIN_WDOG_MODE_INTV_8SEC, AWIN_WDOG_MODE_INTV),
 	[8] = __SHIFTIN(AWIN_WDOG_MODE_INTV_8SEC, AWIN_WDOG_MODE_INTV),
 	[9] = __SHIFTIN(AWIN_WDOG_MODE_INTV_10SEC, AWIN_WDOG_MODE_INTV),
 	[10] = __SHIFTIN(AWIN_WDOG_MODE_INTV_10SEC, AWIN_WDOG_MODE_INTV),
 	[11] = __SHIFTIN(AWIN_WDOG_MODE_INTV_12SEC, AWIN_WDOG_MODE_INTV),
 	[12] = __SHIFTIN(AWIN_WDOG_MODE_INTV_12SEC, AWIN_WDOG_MODE_INTV),
 	[13] = __SHIFTIN(AWIN_WDOG_MODE_INTV_14SEC, AWIN_WDOG_MODE_INTV),
 	[14] = __SHIFTIN(AWIN_WDOG_MODE_INTV_14SEC, AWIN_WDOG_MODE_INTV),
 	[15] = __SHIFTIN(AWIN_WDOG_MODE_INTV_16SEC, AWIN_WDOG_MODE_INTV),
 	[16] = __SHIFTIN(AWIN_WDOG_MODE_INTV_16SEC, AWIN_WDOG_MODE_INTV),
 };
 static struct awin_wdt_softc {
 	device_t sc_dev;
 	bus_space_tag_t sc_bst;
 	bus_space_handle_t sc_bsh;
 	struct sysmon_wdog sc_smw;
         u_int sc_wdog_period;
         bool sc_wdog_armed;
 	uint32_t sc_wdog_mode;
 } awin_wdt_sc = {
 	.sc_bst = &awin_bs_tag,
 	.sc_wdog_period = AWIN_WDT_PERIOD_DEFAULT,
 };
 static int
 awin_wdt_tickle(struct sysmon_wdog *smw)
+{
 	struct awin_wdt_softc * const sc = smw->smw_cookie;
 	bus_space_write_4(sc->sc_bst, sc->sc_bsh, AWIN_WDOG_CTRL_REG,
 	    AWIN_WDOG_CTRL_RSTART);
 	return 0;
+}
 static int
 awin_wdt_setmode(struct sysmon_wdog *smw)
+{
 	struct awin_wdt_softc * const sc = smw->smw_cookie;
 	if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
 		/*
 		 * We can't disarm the watchdog.
 		 */
 		return sc->sc_wdog_armed ? EBUSY : 0;
+	}
 	if (sc->sc_wdog_armed && smw->smw_period == sc->sc_wdog_period) {
 		bus_space_write_4(sc->sc_bst, sc->sc_bsh, AWIN_WDOG_MODE_REG,
 		    sc->sc_wdog_mode);
 		bus_space_write_4(sc->sc_bst, sc->sc_bsh, AWIN_WDOG_CTRL_REG,
 		    AWIN_WDOG_CTRL_RSTART);
 		return 0;
+	}
 	if (smw->smw_period > __arraycount(period_map)) {
 		return EINVAL;
+	}
 	if (smw->smw_period == WDOG_PERIOD_DEFAULT) {
 		smw->smw_period = AWIN_WDT_PERIOD_DEFAULT;
 		sc->sc_wdog_period = AWIN_WDT_PERIOD_DEFAULT;
+	}
 	sc->sc_wdog_mode = AWIN_WDOG_MODE_EN | AWIN_WDOG_MODE_RST_EN
 	    | period_map[sc->sc_wdog_period];
 	bus_space_write_4(sc->sc_bst, sc->sc_bsh, AWIN_WDOG_MODE_REG,
 	    sc->sc_wdog_mode);
 	bus_space_write_4(sc->sc_bst, sc->sc_bsh, AWIN_WDOG_CTRL_REG,
 	    AWIN_WDOG_CTRL_RSTART);
 	return 0;
+}
 CFATTACH_DECL_NEW(awin_wdt, 0,
 	awin_wdt_match, awin_wdt_attach, NULL, NULL);
 static int
 awin_wdt_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	const int port = cf->cf_loc[AWINIOCF_PORT];
 	if (awin_wdt_sc.sc_dev != NULL)
 		return 0;
 	if (strcmp(cf->cf_name, loc->loc_name)
 	    || (port != AWINIOCF_PORT_DEFAULT && port != loc->loc_port))
 		return 0;
 	KASSERT(loc->loc_port == AWINIOCF_PORT_DEFAULT);
 	return 1;
+}
 static void
 awin_wdt_attach(device_t parent, device_t self, void *aux)
+{
 	struct awin_wdt_softc * const sc = &awin_wdt_sc;
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	sc->sc_dev = self;
 	sc->sc_wdog_armed = (device_cfdata(self)->cf_flags & 1) != 0;
 	sc->sc_bst = aio->aio_core_bst;
 	bus_space_subregion(sc->sc_bst, aio->aio_core_bsh,
 	    loc->loc_offset, loc->loc_size, &sc->sc_bsh);
 	aprint_naive("\n");
 	aprint_normal(": default period is %u seconds%s\n",
 	    sc->sc_wdog_period,
 	    sc->sc_wdog_armed ? " (wdog is active)" : "");
 	sc->sc_smw.smw_name = device_xname(sc->sc_dev);
 	sc->sc_smw.smw_cookie = sc;
 	sc->sc_smw.smw_setmode = awin_wdt_setmode;
 	sc->sc_smw.smw_tickle = awin_wdt_tickle;
 	sc->sc_smw.smw_period = sc->sc_wdog_period;
 	if (sysmon_wdog_register(&sc->sc_smw) != 0)
 		aprint_error_dev(self, "unable to register with sysmon\n");
 	if (sc->sc_wdog_armed) {
 		int error = sysmon_wdog_setmode(&sc->sc_smw, WDOG_MODE_KTICKLE,
 		    sc->sc_wdog_period);
 		if (error)
 			aprint_error_dev(self,
 			    "failed to start kernel tickler: %d\n", error);
+	}
+}
 #endif
 void
 awin_wdog_reset(void)
+{
 	cpsid(I32_bit|F32_bit);
 	bus_space_write_4(&awin_bs_tag, awin_core_bsh,
 	    AWIN_TMR_OFFSET + AWIN_WDOG_MODE_REG,
 	    AWIN_WDOG_MODE_EN | AWIN_WDOG_MODE_RST_EN);
 	for (;;) {
 		__asm("wfi");
+	}
+}

 @@ -1,624 +1,625 @@
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include "gpio.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_gpio.c,v 1.7 2013/12/19 22:13:38 joerg Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_gpio.c,v 1.8 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <sys/kmem.h>
 #include <sys/gpio.h>
 #include <dev/gpio/gpiovar.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 static int awin_gpio_match(device_t, cfdata_t, void *);
 static void awin_gpio_attach(device_t, device_t, void *);
 static int awin_gpio_pin_read(void *, int);
 static void awin_gpio_pin_write(void *, int, int);
 static void awin_gpio_pin_ctl(void *, int, int);
 #if 0
 static const int ist_maps[] = {
 	[IST_LEVEL_LOW] =	AWIN_PIO_EINT_LOW_LEVEL,
 	[IST_LEVEL_HIGH] =	AWIN_PIO_EINT_HIGH_LEVEL,
 	[IST_EDGE_FALLING] =	AWIN_PIO_EINT_POSITIVE_EDGE,
 	[IST_EDGE_RISING] =	AWIN_PIO_EINT_NEGATIVE_EDGE,
 	[IST_EDGE_BOTH] =	AWIN_PIO_EINT_DOUBLE_EDGE,
 };
 #endif
 struct awin_gpio_pin_cfg {
 	uint32_t cfg[4];
 	uint32_t drv[2];
 	uint32_t pul[2];
 };
 static struct awin_gpio_pin_group {
 	uint32_t grp_pin_mask;
 	uint32_t grp_pin_inuse_mask;
 	bus_space_handle_t grp_bsh;
 	struct awin_gpio_pin_cfg grp_cfg;
 	struct gpio_chipset_tag grp_gc_tag;
 	const char grp_nc_name[6];
 } pin_groups[] = {
 	[0] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PA_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[0],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pa",
 	},
 	[1] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PB_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[1],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pb",
 	},
 	[2] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PC_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[2],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pc",
 	},
 	[3] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PD_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[3],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pd",
 	},
 	[4] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PE_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[4],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pe",
 	},
 	[5] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PF_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[5],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pf",
 	},
 	[6] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PG_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[6],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pg",
 	},
 	[7] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PH_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[7],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-ph",
 	},
 	[8] = {
 		.grp_pin_mask = __BIT(AWIN_PIO_PI_PINS) - 1,
 		.grp_gc_tag = {
 			.gp_cookie = &pin_groups[8],
 			.gp_pin_read = awin_gpio_pin_read,
 			.gp_pin_write = awin_gpio_pin_write,
 			.gp_pin_ctl = awin_gpio_pin_ctl,
 		},
 		.grp_nc_name = "nc-pi",
 	},
 };
 static struct awin_gpio_softc {
 	device_t sc_dev;
 	bus_space_tag_t sc_bst;
 	bus_space_handle_t sc_bsh;
 } awin_gpio_sc = {
 	.sc_bst = &awin_bs_tag,
 };
 CFATTACH_DECL_NEW(awin_gpio, sizeof(struct awin_gpio_softc),
 	awin_gpio_match, awin_gpio_attach, NULL, NULL);
 static int
 awin_gpio_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	KASSERT(!strcmp(cf->cf_name, loc->loc_name));
 	KASSERT(loc->loc_port == AWINIOCF_PORT_DEFAULT);
 	KASSERT(cf->cf_loc[AWINIOCF_PORT] == AWINIOCF_PORT_DEFAULT);
 	if (awin_gpio_sc.sc_dev != NULL)
 		return 0;
 	return 1;
+}
 #if NGPIO > 0
 static void
 awin_gpio_config_pins(device_t self)
+{
 	struct awin_gpio_softc * const sc = &awin_gpio_sc;
 	/*
 	 * First find out how many pins we can offer.
 	 */
 	size_t pin_count = 0;
 	for (u_int i = 0; i < __arraycount(pin_groups); i++) {
 		struct awin_gpio_pin_group * const grp = &pin_groups[i];
 		pin_count +=
 		    popcount32(grp->grp_pin_mask & ~grp->grp_pin_inuse_mask);
+	}
 	/*
 	 * Allocate the pin data.
 	 */
 	gpio_pin_t * const pins = kmem_zalloc(sizeof(gpio_pin_t) * pin_count,
 	    KM_SLEEP);
 	KASSERT(pins != NULL);
 	const int pincaps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT
 		| GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN;
 	gpio_pin_t *pin = pins;
 	for (u_int i = 0; i < __arraycount(pin_groups); i++) {
 		struct awin_gpio_pin_group * const grp = &pin_groups[i];
 		uint32_t mask = grp->grp_pin_mask & ~grp->grp_pin_inuse_mask;
 		/*
 		 * If this group has no bits to provide, skip it.
 		 */
 		if (mask == 0)
 			continue;
 		struct gpiobus_attach_args gba = {
 			.gba_gc = &grp->grp_gc_tag,
 			.gba_pins = pin,
 		};
 		uint32_t data = bus_space_read_4(sc->sc_bst, grp->grp_bsh,
 		    AWIN_PIO_DAT_REG);
 		for (int num = 0; mask != 0; mask >>= 1, data >>= 1, num++) {
 			if (mask & 1) {
 				pin->pin_num = num + (i << 5);
 				pin->pin_caps = pincaps;
 				pin->pin_flags = pincaps;
 				pin->pin_state = (data & 1) != 0;
 				pin++;
+			}
+		}
 		gba.gba_npins = pin - gba.gba_pins;
 		config_found_ia(self, "gpiobus", &gba, gpiobus_print);
+	}
+}
 #endif /* NGPIO > 0 */
 static void
 awin_gpio_attach(device_t parent, device_t self, void *aux)
+{
 	struct awin_gpio_softc * const sc = &awin_gpio_sc;
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	prop_dictionary_t dict = device_properties(self);
 	sc->sc_dev = self;
 	sc->sc_bst = aio->aio_core_bst;
 	bus_space_subregion(sc->sc_bst, aio->aio_core_bsh,
 	    loc->loc_offset, loc->loc_size, &sc->sc_bsh);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	for (u_int i = 0; i < __arraycount(pin_groups); i++) {
 		struct awin_gpio_pin_group * const grp = &pin_groups[i];
 		/*
 		 * See if this group has any unconnected pins and make sure
 		 * we won't use them.
 		 */
 		uint32_t nc;
 		if (prop_dictionary_get_uint32(dict, grp->grp_nc_name, &nc)) {
 			KASSERT((~grp->grp_pin_mask & nc) == 0);
 			KASSERT((grp->grp_pin_inuse_mask & ~nc) == 0);
 			grp->grp_pin_mask &= ~nc;
+		}
+	}
 #if NGPIO > 0
 	config_defer(self, awin_gpio_config_pins);
 #endif
+}
 static u_int
 awin_gpio_get_pin_func(const struct awin_gpio_pin_cfg *cfg, u_int pin)
+{
 	const u_int shift = (pin & 7) << 2;
 	const u_int i = (pin >> 3) & 3;
 	return (cfg->cfg[i] >> shift) & 0x0f;
+}
 static void
 awin_gpio_set_pin_func(struct awin_gpio_pin_cfg *cfg, u_int pin, u_int func)
+{
 	const u_int shift = (pin & 7) << 2;
 	const u_int i = (pin >> 3) & 3;
 	cfg->cfg[i] &= ~(0x0f << shift);
 	cfg->cfg[i] |= func << shift;
+}
 static void
 awin_gpio_set_pin_pull(struct awin_gpio_pin_cfg *cfg, u_int pin, u_int pull)
+{
 	const u_int shift = (pin & 15) << 1;
 	const u_int i = (pin >> 4) & 1;
 	cfg->pul[i] &= ~(0x03 << shift);
 	cfg->pul[i] |= pull << shift;
+}
 static void
 awin_gpio_update_cfg_regs(bus_space_tag_t bst, struct awin_gpio_pin_group *grp,
     const struct awin_gpio_pin_cfg *ncfg)
+{
 	for (u_int i = 0; i < 4; i++) {
 		if (grp->grp_cfg.cfg[i] != ncfg->cfg[i]) {
 			bus_space_write_4(bst, grp->grp_bsh,
 			    AWIN_PIO_CFG0_REG + 4 * i, ncfg->cfg[i]);
 			grp->grp_cfg.cfg[i] = ncfg->cfg[i];
+		}
+	}
 	for (u_int i = 0; i < 2; i++) {
 		if (grp->grp_cfg.drv[i] != ncfg->drv[i]) {
 			bus_space_write_4(bst, grp->grp_bsh,
 			    AWIN_PIO_DRV0_REG + 4 * i, ncfg->drv[i]);
 			grp->grp_cfg.drv[i] = ncfg->drv[i];
+		}
 		if (grp->grp_cfg.pul[i] != ncfg->pul[i]) {
 			bus_space_write_4(bst, grp->grp_bsh,
 			    AWIN_PIO_PUL0_REG + 4 * i, ncfg->pul[i]);
 			grp->grp_cfg.pul[i] = ncfg->pul[i];
+		}
+	}
+}
 void
 awin_gpio_init(void)
+{
 	struct awin_gpio_softc * const sc = &awin_gpio_sc;
 	bus_size_t offset = AWIN_PIO_OFFSET;
 #ifdef VERBOSE_INIT_ARM
 	printf(" free");
 #endif
 	for (u_int i = 0;
 	     i < __arraycount(pin_groups);
 	     i++, offset += AWIN_PIO_GRP_SIZE) {
 		struct awin_gpio_pin_group * const grp = &pin_groups[i];
 		bus_space_subregion(sc->sc_bst, awin_core_bsh,
 		    offset, AWIN_PIO_GRP_SIZE, &grp->grp_bsh);
 		for (u_int j = 0; j < 4; j++) {
 			grp->grp_cfg.cfg[j] = bus_space_read_4(sc->sc_bst,
 			    grp->grp_bsh, AWIN_PIO_CFG0_REG + j * 4);
+		}
 		grp->grp_cfg.drv[0] = bus_space_read_4(sc->sc_bst,
 		    grp->grp_bsh, AWIN_PIO_DRV0_REG);
 		grp->grp_cfg.drv[1] = bus_space_read_4(sc->sc_bst,
 		    grp->grp_bsh, AWIN_PIO_DRV1_REG);
 		grp->grp_cfg.pul[0] = bus_space_read_4(sc->sc_bst,
 		    grp->grp_bsh, AWIN_PIO_PUL0_REG);
 		grp->grp_cfg.pul[1] = bus_space_read_4(sc->sc_bst,
 		    grp->grp_bsh, AWIN_PIO_PUL1_REG);
 		for (uint32_t j = 0, mask = 1;
 		     (mask & grp->grp_pin_mask) != 0;
 		     j++, mask <<= 1) {
 			u_int func = awin_gpio_get_pin_func(&grp->grp_cfg, j);
 			if (func > AWIN_PIO_FUNC_OUTPUT) {
 				grp->grp_pin_inuse_mask |= mask;
+			}
+		}
 #ifdef VERBOSE_INIT_ARM
 		printf(" P%c=%d", 'A' + i,
 		    popcount32(grp->grp_pin_mask & ~grp->grp_pin_inuse_mask));
 #endif
+	}
+}
 bool
 awin_gpio_pinset_available(const struct awin_gpio_pinset *req)
+{
 	KASSERT(req != NULL);
 	if (!req->pinset_group)
 		return false;
 	KASSERT('A' <= req->pinset_group && req->pinset_group <= 'I');
 	struct awin_gpio_pin_group * const grp =
 	    &pin_groups[req->pinset_group - 'A'];
 	/*
 	 * If there are unconnected pins, then they've been remove from
 	 * the groups pin mask.  If we want pins that are unconnected,
 	 * fail the request.
 	 */
 	if (req->pinset_mask & ~grp->grp_pin_mask)
 		return false;
 	/*
 	 * If none of the pins are in use, they must be available.
 	 */
 	if (req->pinset_mask & ~grp->grp_pin_inuse_mask)
 		return true;
 	/*
 	 * Check to see if the pins are already setup for this function.
 	 */
 	for (uint32_t j = 0, inuse = req->pinset_mask & grp->grp_pin_inuse_mask;
 	     inuse != 0;
 	     j++, inuse >>= 1) {
 		const u_int n = ffs(inuse) - 1;
 		j += n;
 		inuse >>= n;
 		/*
 		 * If this pin is in use but it's for a different
 		 * function, fail the request.
 		 */
 		if (awin_gpio_get_pin_func(&grp->grp_cfg, j) != req->pinset_func)
 			return false;
+	}
 	/*
 	 * Nothing incompatible encountered so the pins must be available.
 	 */
 	return true;
+}
 void
 awin_gpio_pinset_acquire(const struct awin_gpio_pinset *req)
+{
 	KASSERT(awin_gpio_pinset_available(req));
 	struct awin_gpio_pin_group * const grp =
 	    &pin_groups[req->pinset_group - 'A'];
 	/*
 	 * If all the pins already have right function, just return.
 	 */
 	if ((req->pinset_mask & ~grp->grp_pin_inuse_mask) == 0) {
 		return;
+	}
 	/*
 	 * Copy the current config.
 	 */
 	struct awin_gpio_pin_cfg ncfg = grp->grp_cfg;
 	/*
 	 * For each pin not inuse, update the cloned config's function for it.
 	 */
 	for (uint32_t j = 0, todo = req->pinset_mask & ~grp->grp_pin_inuse_mask;
 	     todo != 0;
 	     j++, todo >>= 1) {
 		const u_int n = ffs(todo) - 1;
 		j += n;
 		todo >>= n;
 		/*
 		 * Change the function of this pin.
 		 */
 		awin_gpio_set_pin_func(&ncfg, j, req->pinset_func);
+	}
 	/*
 	 * Now update any config register that changed.
 	 */
 	awin_gpio_update_cfg_regs(&awin_bs_tag, grp, &ncfg);
 	/*
 	 * Mark all these pins as in use.
 	 */
 	grp->grp_pin_inuse_mask |= req->pinset_mask;
+}
 void
 awin_gpio_pinset_release(const struct awin_gpio_pinset *req)
+{
 	KASSERT(awin_gpio_pinset_available(req));
 	struct awin_gpio_pin_group * const grp =
 	    &pin_groups[req->pinset_group - 'A'];
 #if 0
 	/*
 	 * Copy the current config.
 	 */
 	struct awin_gpio_pin_cfg ncfg = grp->grp_cfg;
 	/*
 	 * For each pin not inuse, update the cloned config's function for it.
 	 */
 	for (uint32_t j = 0, todo = req->pinset_mask;
 	     todo != 0;
 	     j++, todo >>= 1) {
 		const u_int n = ffs(todo) - 1;
 		j += n;
 		todo >>= n;
 		/*
 		 * Change the function of this pin.
 		 */
 		awin_gpio_set_pin_func(&ncfg, AWIN_PIO_FUNC_INPUT);
+	}
 	/*
 	 * Now update any config register that changed.
 	 */
 	awin_gpio_update_cfg_regs(sc->sc_bst, grp, &ncfg);
 #endif
 	/*
 	 * Clear these pins as being in use.
 	 */
 	grp->grp_pin_inuse_mask &= ~req->pinset_mask;
+}
 static int
 awin_gpio_pin_read(void *cookie, int pin)
+{
 	struct awin_gpio_pin_group * const grp = cookie;
 	KASSERT(pin < 32);
 	return (bus_space_read_4(awin_gpio_sc.sc_bst, grp->grp_bsh,
 	    AWIN_PIO_DAT_REG) >> pin) & 1;
+}
 static void
 awin_gpio_pin_write(void *cookie, int pin, int value)
+{
 	struct awin_gpio_pin_group * const grp = cookie;
 	KASSERT(pin < 32);
 	awin_reg_set_clear(awin_gpio_sc.sc_bst, grp->grp_bsh,
 	    AWIN_PIO_DAT_REG, value ? __BIT(pin) : 0, __BIT(pin));
+}
 static void
 awin_gpio_pin_ctl(void *cookie, int pin, int flags)
+{
 	struct awin_gpio_pin_group * const grp = cookie;
 	struct awin_gpio_pin_cfg ncfg = grp->grp_cfg;
 	u_int pull_value = AWIN_PIO_PULL_NONE;
 	if (flags & GPIO_PIN_PULLUP) {
 		pull_value = AWIN_PIO_PULL_UP;
 	} else if (flags & GPIO_PIN_PULLDOWN) {
 		pull_value = AWIN_PIO_PULL_DOWN;
+	}
 	awin_gpio_set_pin_pull(&ncfg, pin, pull_value);
 	if (flags & GPIO_PIN_INPUT) {
 		awin_gpio_set_pin_func(&ncfg, pin, AWIN_PIO_FUNC_INPUT);
 	} else if (flags & GPIO_PIN_OUTPUT) {
 		awin_gpio_set_pin_func(&ncfg, pin, AWIN_PIO_FUNC_OUTPUT);
+	}
 	/*
 	 * Now update any config register that changed.
 	 */
 	awin_gpio_update_cfg_regs(&awin_bs_tag, grp, &ncfg);
+}
 bool
 awin_gpio_pin_reserve(const char *name, struct awin_gpio_pindata *pd)
+{
 	struct awin_gpio_softc * const sc = &awin_gpio_sc;
 	prop_dictionary_t dict = device_properties(sc->sc_dev);
 	const char *pin_data;
 	if (!prop_dictionary_get_cstring_nocopy(dict, name, &pin_data))
 		return false;
 	KASSERT(pin_data[0] == '>' || pin_data[0] == '<');
 	KASSERT(pin_data[1] == 'P');
 	KASSERT('A' <= pin_data[2] && pin_data[2] <= 'I');
 	struct awin_gpio_pin_group * const grp = &pin_groups[pin_data[2] - 'A'];
 	u_int pin = pin_data[3] - '0';
 	KASSERT(pin < 10);
 	if (pin_data[4] != 0) {
 		KASSERT(pin_data[5] == 0);
 		pin = pin * 10 + pin_data[4] - '0';
+	}
 	KASSERT(pin < 32);
 	KASSERT(grp->grp_pin_mask & __BIT(pin));
 	KASSERT((grp->grp_pin_inuse_mask & __BIT(pin)) == 0);
 	struct awin_gpio_pin_cfg ncfg = grp->grp_cfg;
 	awin_gpio_set_pin_func(&ncfg, pin,
 	   pin_data[0] == '<' ? AWIN_PIO_FUNC_INPUT : AWIN_PIO_FUNC_OUTPUT);
 	/*
 	 * Now update any config register that changed.
 	 */
 	awin_gpio_update_cfg_regs(sc->sc_bst, grp, &ncfg);
 	grp->grp_pin_inuse_mask &= ~__BIT(pin);
 	pd->pd_gc = &grp->grp_gc_tag;
 	pd->pd_pin = pin;
 	return true;
+}

 @@ -1,133 +1,134 @@
 /*-
  * Copyright (c) 2012 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_wdc.c,v 1.1 2013/09/04 02:39:01 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_wdc.c,v 1.2 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 #include <dev/ata/atavar.h>
 #include <dev/ic/wdcvar.h>
 static int awin_wdc_match(device_t, cfdata_t, void *);
 static void awin_wdc_attach(device_t, device_t, void *);
 struct awin_wdc_softc {
 	struct wdc_softc asc_sc;
         struct ata_channel *asc_chanlist[1];
         struct ata_channel asc_channel;
         struct ata_queue asc_chqueue;
         struct wdc_regs asc_wdc_regs;
         void    *asc_ih;
 };
 CFATTACH_DECL_NEW(awin_wdc, sizeof(struct awin_wdc_softc),
 	awin_wdc_match, awin_wdc_attach, NULL, NULL);
 static int
 awin_wdc_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	const int port = cf->cf_loc[AWINIOCF_PORT];
 	if (strcmp(cf->cf_name, loc->loc_name))
 		return 0;
 	if (port != AWINIOCF_PORT_DEFAULT)
 		return 0;
 	return 1;
+}
 static void
 awin_wdc_attach(device_t parent, device_t self, void *aux)
+{
 	struct awin_wdc_softc * const asc = device_private(self);
 	struct wdc_softc * const sc = &asc->asc_sc;
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	struct wdc_regs * const regs = &asc->asc_wdc_regs;
         sc->sc_atac.atac_dev = self;
 	sc->regs = regs;
 	regs->cmd_iot = aio->aio_core_a4x_bst;
 	regs->ctl_iot = aio->aio_core_a4x_bst;
 	regs->data32iot = aio->aio_core_a4x_bst;
 	bus_space_subregion(regs->cmd_iot, aio->aio_core_bsh,
 	    loc->loc_offset / 4, loc->loc_size, &regs->cmd_baseioh);
 	aprint_naive(": ATA controller\n");
 	aprint_normal(": ATA controller\n");
         for (u_int i = 0; i < 8; i++) {
                 if (bus_space_subregion(regs->cmd_iot, regs->cmd_baseioh,
                     i, 1, &regs->cmd_iohs[i]) != 0) {
                         aprint_error(": couldn't subregion registers\n");
                         return;
+                }
+        }
         if (bus_space_subregion(regs->ctl_iot, regs->cmd_baseioh,
             AWIN_PATA_CTL_REG, 1, &regs->ctl_ioh) != 0) {
                 aprint_error(": couldn't subregion registers\n");
                 return;
+        }
 	asc->asc_ih = intr_establish(loc->loc_intr, IPL_VM, IST_LEVEL,
 	    wdcintr, sc);
 	if (asc->asc_ih == NULL) {
 		aprint_error_dev(self, "failed to establish interrupt %d\n",
 		     loc->loc_intr);
 		goto fail;
+	}
 	aprint_normal_dev(self, "interrupting on irq %d\n",
 	     loc->loc_intr);
 	return;
 fail:
 	if (asc->asc_ih) {
 		intr_disestablish(asc->asc_ih);
 		asc->asc_ih = NULL;
+	}
+}

 @@ -1,201 +1,202 @@
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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 "locators.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_io.c,v 1.5 2013/09/08 04:06:44 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_io.c,v 1.6 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <arm/locore.h>
 #include <arm/mainbus/mainbus.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 static int awinio_match(device_t, cfdata_t, void *);
 static void awinio_attach(device_t, device_t, void *);
 static struct awinio_softc {
 	device_t sc_dev;
 	bus_space_tag_t sc_bst;
 	bus_space_tag_t sc_a4x_bst;
 	bus_space_handle_t sc_bsh;
 	bus_space_handle_t sc_ccm_bsh;
 	bus_dma_tag_t sc_dmat;
 } awinio_sc;
 CFATTACH_DECL_NEW(awin_io, 0,
 	awinio_match, awinio_attach, NULL, NULL);
 static int
 awinio_match(device_t parent, cfdata_t cf, void *aux)
+{
 	if (awinio_sc.sc_dev != NULL)
 		return 0;
 	return 1;
+}
 static int
 awinio_print(void *aux, const char *pnp)
+{
 	const struct awinio_attach_args * const aio = aux;
 	if (aio->aio_loc.loc_port != AWINIOCF_PORT_DEFAULT)
 		aprint_normal(" port %d", aio->aio_loc.loc_port);
 	return QUIET;
+}
 #define	OFFANDSIZE(n) AWIN_##n##_OFFSET, (AWIN_##n##_OFFSET < 0x20000 ? 0x1000 : 0x400)
 #define	NOPORT	AWINIOCF_PORT_DEFAULT
 #define	NOINTR	AWINIO_INTR_DEFAULT
 #define	AANY	0
 #define	A10	AWINIO_ONLY_A10
 #define	A20	AWINIO_ONLY_A20
 #define	REQ	AWINIO_REQUIRED
 static const struct awin_locators awin_locators[] = {
 	{ "awinicu", OFFANDSIZE(INTC), NOPORT, NOINTR, A10|REQ },
 	{ "awingpio", OFFANDSIZE(PIO), NOPORT, NOINTR, AANY|REQ },
 	{ "awintmr", OFFANDSIZE(TMR), NOPORT, AWIN_IRQ_TMR0, A10 },
 	{ "com", OFFANDSIZE(UART0), 0, AWIN_IRQ_UART0, AANY },
 	{ "com", OFFANDSIZE(UART1), 1, AWIN_IRQ_UART1, AANY },
 	{ "com", OFFANDSIZE(UART2), 2, AWIN_IRQ_UART2, AANY },
 	{ "com", OFFANDSIZE(UART3), 3, AWIN_IRQ_UART3, AANY },
 	{ "com", OFFANDSIZE(UART4), 4, AWIN_IRQ_UART4, AANY },
 	{ "com", OFFANDSIZE(UART5), 5, AWIN_IRQ_UART5, AANY },
 	{ "com", OFFANDSIZE(UART6), 6, AWIN_IRQ_UART6, AANY },
 	{ "com", OFFANDSIZE(UART7), 7, AWIN_IRQ_UART7, AANY },
 	{ "awinwdt", OFFANDSIZE(TMR), NOPORT, NOINTR, AANY },
 	{ "awinusb", OFFANDSIZE(USB1), 0, NOINTR, AANY },
 	{ "awinusb", OFFANDSIZE(USB2), 1, NOINTR, AANY },
 	{ "sdhc", OFFANDSIZE(SDMMC0), 0, AWIN_IRQ_SDMMC0, AANY },
 	{ "sdhc", OFFANDSIZE(SDMMC1), 1, AWIN_IRQ_SDMMC1, AANY },
 	{ "sdhc", OFFANDSIZE(SDMMC2), 2, AWIN_IRQ_SDMMC2, AANY },
 	{ "sdhc", OFFANDSIZE(SDMMC3), 3, AWIN_IRQ_SDMMC3, AANY },
 	{ "sdhc", OFFANDSIZE(SDMMC1), 4, AWIN_IRQ_SDMMC1, AANY },
 	{ "ahcisata", OFFANDSIZE(SATA), NOPORT, AWIN_IRQ_SATA, AANY },
 	{ "awiniic", OFFANDSIZE(TWI0), 0, AWIN_IRQ_TWI0, AANY },
 	{ "awiniic", OFFANDSIZE(TWI1), 1, AWIN_IRQ_TWI1, AANY },
 	{ "awiniic", OFFANDSIZE(TWI2), 2, AWIN_IRQ_TWI2, AANY },
 	{ "awiniic", OFFANDSIZE(TWI3), 3, AWIN_IRQ_TWI3, AANY },
 	{ "awiniic", OFFANDSIZE(TWI4), 4, AWIN_IRQ_TWI4, AANY },
 	{ "spi", OFFANDSIZE(SPI0), 0, AWIN_IRQ_SPI0, AANY },
 	{ "spi", OFFANDSIZE(SPI1), 1, AWIN_IRQ_SPI1, AANY },
 	{ "spi", OFFANDSIZE(SPI2), 1, AWIN_IRQ_SPI2, AANY },
 	{ "spi", OFFANDSIZE(SPI3), 3, AWIN_IRQ_SPI3, AANY },
 	{ "awe", OFFANDSIZE(EMAC), NOPORT, AWIN_IRQ_EMAC, AANY },
 	{ "awge", AWIN_GMAC_OFFSET, AWIN_GMAC_SIZE, NOPORT, AWIN_IRQ_GMAC, A20 },
 	{ "awincrypto", OFFANDSIZE(SS), NOPORT, AWIN_IRQ_SS, AANY },
 };
 static int
 awinio_find(device_t parent, cfdata_t cf, const int *ldesc, void *aux)
+{
 	const struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	const int port = cf->cf_loc[AWINIOCF_PORT];
 	if (strcmp(cf->cf_name, loc->loc_name)
 	    || (port != AWINIOCF_PORT_DEFAULT && port != loc->loc_port))
 		return 0;
 	return config_match(parent, cf, aux);
+}
 static void
 awinio_attach(device_t parent, device_t self, void *aux)
+{
 	struct awinio_softc * const sc = &awinio_sc;
 	const bool a10_p = CPU_ID_CORTEX_A8_P(curcpu()->ci_arm_cpuid);
 	const bool a20_p = CPU_ID_CORTEX_A7_P(curcpu()->ci_arm_cpuid);
 	prop_dictionary_t dict = device_properties(self);
 	sc->sc_dev = self;
 	sc->sc_bst = &awin_bs_tag;
 	sc->sc_a4x_bst = &awin_a4x_bs_tag;
 	sc->sc_bsh = awin_core_bsh;
 	sc->sc_dmat = &awin_dma_tag;
 	bus_space_subregion(sc->sc_bst, sc->sc_bsh, AWIN_CCM_OFFSET, 0x1000,
 	    &sc->sc_ccm_bsh);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	const struct awin_locators * const eloc =
 	    awin_locators + __arraycount(awin_locators);
 	for (const struct awin_locators *loc = awin_locators; loc < eloc; loc++) {
 		char prop_name[31];
 		bool skip;
 		if (loc->loc_port == AWINIOCF_PORT_DEFAULT) {
 			snprintf(prop_name, sizeof(prop_name),
 			    "no-%s", loc->loc_name);
 		} else {
 			snprintf(prop_name, sizeof(prop_name),
 			    "no-%s-%d", loc->loc_name, loc->loc_port);
+		}
 		if (prop_dictionary_get_bool(dict, prop_name, &skip) && skip)
 			continue;
 		if (loc->loc_flags & AWINIO_ONLY) {
 			if (a10_p && !(loc->loc_flags & AWINIO_ONLY_A10))
 				continue;
 			if (a20_p && !(loc->loc_flags & AWINIO_ONLY_A20))
 				continue;
+		}
 		struct awinio_attach_args aio = {
 			.aio_loc = *loc,
 			.aio_core_bst = sc->sc_bst,
 			.aio_core_a4x_bst = sc->sc_a4x_bst,
 			.aio_core_bsh = sc->sc_bsh,
 			.aio_ccm_bsh = sc->sc_ccm_bsh,
 			.aio_dmat = sc->sc_dmat,
 		};
 		cfdata_t cf = config_search_ia(awinio_find,
 		    sc->sc_dev, "awinio", &aio);
 		if (cf == NULL) {
 			if (loc->loc_flags & AWINIO_REQUIRED)
 				panic("%s: failed to find %s!", __func__,
 				    loc->loc_name);
 			continue;
+		}
 		config_attach(sc->sc_dev, cf, &aio, awinio_print);
+	}
+}

 @@ -1,424 +1,425 @@
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * 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.
  */
 #define USBH_PRIVATE
 #include "locators.h"
 #include "ohci.h"
 #include "ehci.h"
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: awin_usb.c,v 1.9 2013/09/08 01:01:33 matt Exp $");
+__KERNEL_RCSID(1, "$NetBSD: awin_usb.c,v 1.10 2014/02/20 21:48:38 matt Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/intr.h>
 #include <sys/systm.h>
 #include <arm/allwinner/awin_reg.h>
 #include <arm/allwinner/awin_var.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usb_mem.h>
 #if NOHCI > 0
 #include <dev/usb/ohcireg.h>
 #include <dev/usb/ohcivar.h>
 #endif
 #if NEHCI > 0
 #include <dev/usb/ehcireg.h>
 #include <dev/usb/ehcivar.h>
 #endif
 #include <dev/pci/pcidevs.h>
 struct awinusb_softc {
 	device_t usbsc_dev;
 	bus_dma_tag_t usbsc_dmat;
 	bus_space_tag_t usbsc_bst;
 	bus_space_handle_t usbsc_ehci_bsh;
 	bus_space_handle_t usbsc_ohci_bsh;
 	bus_space_handle_t usbsc_usb0_phy_csr_bsh;
 	u_int usbsc_number;
 	struct awin_gpio_pindata usbsc_drv_pin;
 	device_t usbsc_ohci_dev;
 	device_t usbsc_ehci_dev;
 	void *usbsc_ohci_ih;
 	void *usbsc_ehci_ih;
 };
 struct awinusb_attach_args {
 	const char *usbaa_name;
 	bus_dma_tag_t usbaa_dmat;
 	bus_space_tag_t usbaa_bst;
 	bus_space_handle_t usbaa_bsh;
 	bus_space_handle_t usbaa_ccm_bsh;
 	bus_size_t usbaa_size;
 	int usbaa_port;
 };
 #if NOHCI > 0
 static const int awinusb_ohci_irqs[2] = { AWIN_IRQ_USB3, AWIN_IRQ_USB4 };
 #ifdef OHCI_DEBUG
 #define OHCI_DPRINTF(x)	if (ohcidebug) printf x
 extern int ohcidebug;
 #else
 #define OHCI_DPRINTF(x)
 #endif
 static int ohci_awinusb_match(device_t, cfdata_t, void *);
 static void ohci_awinusb_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(ohci_awinusb, sizeof(struct ohci_softc),
 	ohci_awinusb_match, ohci_awinusb_attach, NULL, NULL);
 static int
 ohci_awinusb_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinusb_attach_args * const usbaa = aux;
 	if (strcmp(cf->cf_name, usbaa->usbaa_name))
 		return 0;
 	return 1;
+}
 static void
 ohci_awinusb_attach(device_t parent, device_t self, void *aux)
+{
 	struct awinusb_softc * const usbsc = device_private(parent);
 	struct ohci_softc * const sc = device_private(self);
 	struct awinusb_attach_args * const usbaa = aux;
 	sc->sc_dev = self;
 	sc->iot = usbaa->usbaa_bst;
 	sc->ioh = usbaa->usbaa_bsh;
 	sc->sc_size = usbaa->usbaa_size;
 	sc->sc_bus.dmatag = usbaa->usbaa_dmat;
 	sc->sc_bus.hci_private = sc;
 	//sc->sc_id_vendor = PCI_VENDOR_ALLWINNER;
 	strlcpy(sc->sc_vendor, "Allwinner", sizeof(sc->sc_vendor));
 	aprint_naive(": OHCI USB controller\n");
 	aprint_normal(": OHCI USB controller\n");
 	int error = ohci_init(sc);
 	if (error != USBD_NORMAL_COMPLETION) {
 		aprint_error_dev(self, "init failed, error=%d\n", error);
 	} else {
 		/* Attach usb device. */
 		sc->sc_child = config_found(self, &sc->sc_bus, usbctlprint);
+	}
 	const int irq = awinusb_ohci_irqs[usbaa->usbaa_port];
 	usbsc->usbsc_ohci_ih = intr_establish(irq, IPL_USB,
 	    IST_LEVEL, ohci_intr, sc);
 	if (usbsc->usbsc_ohci_ih == NULL) {
 		aprint_error_dev(self, "failed to establish interrupt %d\n",
 		     irq);
 		return;
+	}
 	aprint_normal_dev(self, "interrupting on irq %d\n", irq);
+}
 #endif /* NOHCI > 0 */
 #if NEHCI > 0
 #ifdef EHCI_DEBUG
 #define EHCI_DPRINTF(x)	if (ehcidebug) printf x
 extern int ehcidebug;
 #else
 #define EHCI_DPRINTF(x)
 #endif
 static int ehci_awinusb_match(device_t, cfdata_t, void *);
 static void ehci_awinusb_attach(device_t, device_t, void *);
 static const int awinusb_ehci_irqs[2] = { AWIN_IRQ_USB1, AWIN_IRQ_USB2 };
 CFATTACH_DECL_NEW(ehci_awinusb, sizeof(struct ehci_softc),
 	ehci_awinusb_match, ehci_awinusb_attach, NULL, NULL);
 static int
 ehci_awinusb_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinusb_attach_args * const usbaa = aux;
 	if (strcmp(cf->cf_name, usbaa->usbaa_name))
 		return 0;
 	return 1;
+}
 static void
 ehci_awinusb_attach(device_t parent, device_t self, void *aux)
+{
 	struct awinusb_softc * const usbsc = device_private(parent);
 	struct ehci_softc * const sc = device_private(self);
 	struct awinusb_attach_args * const usbaa = aux;
 	sc->sc_dev = self;
 	sc->iot = usbaa->usbaa_bst;
 	sc->ioh = usbaa->usbaa_bsh;
 	sc->sc_size = usbaa->usbaa_size;
 	sc->sc_bus.dmatag = usbaa->usbaa_dmat;
 	sc->sc_bus.hci_private = sc;
 	sc->sc_bus.usbrev = USBREV_2_0;
 	sc->sc_ncomp = 0;
 	if (usbsc->usbsc_ohci_dev != NULL) {
 		sc->sc_comps[sc->sc_ncomp++] = usbsc->usbsc_ohci_dev;
+	}
 	//sc->sc_id_vendor = PCI_VENDOR_ALLWINNER;
 	strlcpy(sc->sc_vendor, "Allwinner", sizeof(sc->sc_vendor));
 	aprint_naive(": EHCI USB controller\n");
 	aprint_normal(": EHCI USB controller\n");
 	int error = ehci_init(sc);
 	if (error != USBD_NORMAL_COMPLETION) {
 		aprint_error_dev(self, "init failed, error=%d\n", error);
 	} else {
 		/* Attach usb device. */
 		sc->sc_child = config_found(self, &sc->sc_bus, usbctlprint);
+	}
 	const int irq = awinusb_ehci_irqs[usbaa->usbaa_port];
 	usbsc->usbsc_ehci_ih = intr_establish(irq, IPL_USB,
 	    IST_LEVEL, ehci_intr, sc);
 	if (usbsc->usbsc_ehci_ih == NULL) {
 		aprint_error_dev(self, "failed to establish interrupt %d\n",
 		     irq);
 		return;
+	}
 	aprint_normal_dev(self, "interrupting on irq %d\n", irq);
+}
 #endif /* NEHCI > 0 */
 static void
 awin_usb_phy_write(struct awinusb_softc *usbsc, u_int bit_addr, u_int bits,
 	u_int len)
+{
 	bus_space_tag_t bst = usbsc->usbsc_bst;
 	bus_space_handle_t bsh = usbsc->usbsc_usb0_phy_csr_bsh;
 	uint32_t clk = AWIN_USB0_PHY_CSR_CLK0 << usbsc->usbsc_number;
 	uint32_t v = bus_space_read_4(bst, bsh, 0);
 	KASSERT((v & AWIN_USB0_PHY_CSR_CLK0) == 0);
 	KASSERT((v & AWIN_USB0_PHY_CSR_CLK1) == 0);
 	KASSERT((v & AWIN_USB0_PHY_CSR_CLK2) == 0);
 	v &= ~AWIN_USB0_PHY_CSR_ADDR;
 	v &= ~AWIN_USB0_PHY_CSR_DAT;
 	v |= __SHIFTIN(bit_addr, AWIN_USB0_PHY_CSR_ADDR);
 	/*
 	 * Bitbang the data to the phy, bit by bit, incrementing bit address
 	 * as we go.
 	 */
 	for (; len > 0; bit_addr++, bits >>= 1, len--) {
 		v |= __SHIFTIN(bits & 1, AWIN_USB0_PHY_CSR_DAT);
 		bus_space_write_4(bst, bsh, 0, v);
 		delay(1);
 		bus_space_write_4(bst, bsh, 0, v | clk);
 		delay(1);
 		bus_space_write_4(bst, bsh, 0, v);
 		delay(1);
 		v += __LOWEST_SET_BIT(AWIN_USB0_PHY_CSR_ADDR);
 		v &= ~AWIN_USB0_PHY_CSR_DAT;
+	}
+}
 static int awinusb_match(device_t, cfdata_t, void *);
 static void awinusb_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(awin_usb, sizeof(struct awinusb_softc),
 	awinusb_match, awinusb_attach, NULL, NULL);
 static int awinusb_ports;
 static const char awinusb_drvpin_names[2][8] = { "usb1drv", "usb2drv" };
 static const bus_size_t awinusb_dram_hpcr_regs[2] = {
 	AWIN_DRAM_HPCR_USB1_REG,
 	AWIN_DRAM_HPCR_USB2_REG,
 };
 static const uint32_t awinusb_ahb_gating[2] = {
 #if NOHCI > 0
 	AWIN_AHB_GATING0_USB_OHCI0 |
 #endif
 	AWIN_AHB_GATING0_USB_EHCI0,
 #if NOHCI > 0
 	AWIN_AHB_GATING0_USB_OHCI1 |
 #endif
 	AWIN_AHB_GATING0_USB_EHCI1,
 };
 static const uint32_t awinusb_usb_clk_set[2] = {
 #if NOHCI > 0
 	AWIN_USB_CLK_OHCI0_ENABLE |
 #endif
 	AWIN_USB_CLK_USBPHY_ENABLE|AWIN_USB_CLK_PHY1_ENABLE,
 #if NOHCI > 0
 	AWIN_USB_CLK_OHCI1_ENABLE |
 #endif
 	AWIN_USB_CLK_USBPHY_ENABLE|AWIN_USB_CLK_PHY2_ENABLE,
 };
 int
 awinusb_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	KASSERT(loc->loc_port != AWINIOCF_PORT_DEFAULT);
 	KASSERT(!strcmp(cf->cf_name, loc->loc_name));
 	KASSERT(cf->cf_loc[AWINIOCF_PORT] == AWINIOCF_PORT_DEFAULT
 	    || cf->cf_loc[AWINIOCF_PORT] == loc->loc_port);
 	KASSERT((awinusb_ports & __BIT(loc->loc_port)) == 0);
 	return 1;
+}
 void
 awinusb_attach(device_t parent, device_t self, void *aux)
+{
 	struct awinusb_softc * const usbsc = device_private(self);
 	const struct awinio_attach_args * const aio = aux;
 	const struct awin_locators * const loc = &aio->aio_loc;
 	awinusb_ports |= __BIT(loc->loc_port);
 	usbsc->usbsc_bst = aio->aio_core_bst;
 	usbsc->usbsc_dmat = aio->aio_dmat;
 	usbsc->usbsc_number = loc->loc_port + 1;
 	bus_space_subregion(usbsc->usbsc_bst, aio->aio_core_bsh,
 	    loc->loc_offset + AWIN_EHCI_OFFSET, AWIN_EHCI_SIZE,
 	    &usbsc->usbsc_ehci_bsh);
 	bus_space_subregion(usbsc->usbsc_bst, aio->aio_core_bsh,
 	    loc->loc_offset + AWIN_OHCI_OFFSET, AWIN_OHCI_SIZE,
 	    &usbsc->usbsc_ohci_bsh);
 	bus_space_subregion(usbsc->usbsc_bst, aio->aio_core_bsh,
 	    AWIN_USB0_OFFSET + AWIN_USB0_PHY_CSR_REG, 4,
 	    &usbsc->usbsc_usb0_phy_csr_bsh);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	/*
 	 * Access to the USB phy is off USB0 so make sure it's on.
 	*/
 	awin_reg_set_clear(usbsc->usbsc_bst, aio->aio_ccm_bsh,
 	    AWIN_AHB_GATING0_REG,
 	    AWIN_AHB_GATING0_USB0 | awinusb_ahb_gating[loc->loc_port], 0);
 	/*
 	 * Enable the USB phy for this port.
 	 */
 	awin_reg_set_clear(usbsc->usbsc_bst, aio->aio_ccm_bsh,
 	    AWIN_USB_CLK_REG, awinusb_usb_clk_set[loc->loc_port], 0);
 	/*
 	 * Allow USB DMA engine access to the DRAM.
 	 */
 	awin_reg_set_clear(usbsc->usbsc_bst, aio->aio_core_bsh,
 	    loc->loc_offset + AWIN_USB_PMU_IRQ_REG,
 	    AWIN_USB_PMU_IRQ_AHB_INCR8 | AWIN_USB_PMU_IRQ_AHB_INCR4
 	       | AWIN_USB_PMU_IRQ_AHB_INCRX | AWIN_USB_PMU_IRQ_ULPI_BYPASS,
 );
 	awin_reg_set_clear(usbsc->usbsc_bst, aio->aio_core_bsh,
 	    AWIN_DRAM_OFFSET + awinusb_dram_hpcr_regs[loc->loc_port],
 	    AWIN_DRAM_HPCR_ACCESS_EN, 0);
 	/* initialize the USB phy */
 	awin_usb_phy_write(usbsc, 0x20, 0x14, 5);
 	awin_usb_phy_write(usbsc, 0x2a, 0x03, 2);
 	/*
 	 * Now get the GPIO that enables the power to the port and
 	 * turn it on.
 	 */
 	if (awin_gpio_pin_reserve(awinusb_drvpin_names[loc->loc_port],
 		    &usbsc->usbsc_drv_pin)) {
 		awin_gpio_pindata_write(&usbsc->usbsc_drv_pin, 1);
 	} else {
 		aprint_error_dev(self, "no power gpio found\n");
+	}
 	/*
 	 * Disable interrupts
 	 */
 #if NOHCI > 0
 	bus_space_write_4(usbsc->usbsc_bst, usbsc->usbsc_ohci_bsh,
 	    OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS);
 #endif
 #if NEHCI > 0
 	bus_size_t caplength = bus_space_read_1(usbsc->usbsc_bst,
 	    usbsc->usbsc_ehci_bsh, EHCI_CAPLENGTH);
 	bus_space_write_4(usbsc->usbsc_bst, usbsc->usbsc_ehci_bsh,
 	    caplength + EHCI_USBINTR, 0);
 #endif
 #if NOHCI > 0
 	struct awinusb_attach_args usbaa_ohci = {
 		.usbaa_name = "ohci",
 		.usbaa_dmat = usbsc->usbsc_dmat,
 		.usbaa_bst = usbsc->usbsc_bst,
 		.usbaa_bsh = usbsc->usbsc_ohci_bsh,
 		.usbaa_ccm_bsh = aio->aio_ccm_bsh,
 		.usbaa_size = AWIN_OHCI_SIZE,
 		.usbaa_port = loc->loc_port,
 	};
 	usbsc->usbsc_ohci_dev = config_found(self, &usbaa_ohci, NULL);
 #endif
 #if NEHCI > 0
 	struct awinusb_attach_args usbaa_ehci = {
 		.usbaa_name = "ehci",
 		.usbaa_dmat = usbsc->usbsc_dmat,
 		.usbaa_bst = usbsc->usbsc_bst,
 		.usbaa_bsh = usbsc->usbsc_ehci_bsh,
 		.usbaa_ccm_bsh = aio->aio_ccm_bsh,
 		.usbaa_size = AWIN_EHCI_SIZE,
 		.usbaa_port = loc->loc_port,
 	};
 	config_found(self, &usbaa_ehci, NULL);
 #endif
+}