1164426Ssam/* $NetBSD: ixp425.c,v 1.10 2005/12/11 12:16:51 christos Exp $ */ 2164426Ssam 3331722Seadler/* 4164426Ssam * Copyright (c) 2003 5164426Ssam * Ichiro FUKUHARA <ichiro@ichiro.org>. 6164426Ssam * All rights reserved. 7164426Ssam * 8164426Ssam * Redistribution and use in source and binary forms, with or without 9164426Ssam * modification, are permitted provided that the following conditions 10164426Ssam * are met: 11164426Ssam * 1. Redistributions of source code must retain the above copyright 12164426Ssam * notice, this list of conditions and the following disclaimer. 13164426Ssam * 2. Redistributions in binary form must reproduce the above copyright 14164426Ssam * notice, this list of conditions and the following disclaimer in the 15164426Ssam * documentation and/or other materials provided with the distribution. 16164426Ssam * 3. All advertising materials mentioning features or use of this software 17164426Ssam * must display the following acknowledgement: 18164426Ssam * This product includes software developed by Ichiro FUKUHARA. 19164426Ssam * 4. The name of the company nor the name of the author may be used to 20164426Ssam * endorse or promote products derived from this software without specific 21164426Ssam * prior written permission. 22164426Ssam * 23164426Ssam * THIS SOFTWARE IS PROVIDED BY ICHIRO FUKUHARA ``AS IS'' AND ANY EXPRESS OR 24164426Ssam * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 25164426Ssam * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26164426Ssam * IN NO EVENT SHALL ICHIRO FUKUHARA OR THE VOICES IN HIS HEAD BE LIABLE FOR 27164426Ssam * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28164426Ssam * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29164426Ssam * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30164426Ssam * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31164426Ssam * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32164426Ssam * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33164426Ssam * SUCH DAMAGE. 34164426Ssam */ 35164426Ssam 36164426Ssam#include <sys/cdefs.h> 37164426Ssam__FBSDID("$FreeBSD$"); 38164426Ssam 39189633Ssam#include "opt_ddb.h" 40189633Ssam 41164426Ssam#define _ARM32_BUS_DMA_PRIVATE 42164426Ssam#include <sys/param.h> 43164426Ssam#include <sys/systm.h> 44164426Ssam#include <sys/bus.h> 45164426Ssam#include <sys/kernel.h> 46164426Ssam#include <sys/module.h> 47164426Ssam#include <sys/malloc.h> 48164426Ssam#include <sys/rman.h> 49271398Sandrew#include <machine/armreg.h> 50164426Ssam#include <machine/bus.h> 51164426Ssam#include <machine/intr.h> 52164426Ssam 53164426Ssam#include <vm/vm.h> 54164426Ssam#include <vm/pmap.h> 55164426Ssam#include <arm/xscale/ixp425/ixp425reg.h> 56164426Ssam#include <arm/xscale/ixp425/ixp425var.h> 57164426Ssam#include <arm/xscale/ixp425/ixp425_intr.h> 58164426Ssam 59164426Ssam#include <dev/pci/pcireg.h> 60164426Ssam 61164426Ssamvolatile uint32_t intr_enabled; 62164426Ssamuint32_t intr_steer = 0; 63164426Ssam 64186352Ssam/* ixp43x et. al have +32 IRQ's */ 65186352Ssamvolatile uint32_t intr_enabled2; 66186352Ssamuint32_t intr_steer2 = 0; 67186352Ssam 68164426Ssamstruct ixp425_softc *ixp425_softc = NULL; 69164426Ssam 70215319Sthompsastruct mtx ixp425_gpio_mtx; 71215319Sthompsa 72164426Ssamstatic int ixp425_probe(device_t); 73164426Ssamstatic void ixp425_identify(driver_t *, device_t); 74164426Ssamstatic int ixp425_attach(device_t); 75164426Ssam 76186418Ssam/* 77186418Ssam * Return a mask of the "fuse" bits that identify 78186418Ssam * which h/w features are present. 79186418Ssam * NB: assumes the expansion bus is mapped. 80186418Ssam */ 81186418Ssamuint32_t 82186418Ssamixp4xx_read_feature_bits(void) 83186418Ssam{ 84186418Ssam uint32_t bits = ~IXPREG(IXP425_EXP_VBASE + EXP_FCTRL_OFFSET); 85186418Ssam bits &= ~EXP_FCTRL_RESVD; 86186418Ssam if (!cpu_is_ixp46x()) 87186418Ssam bits &= ~EXP_FCTRL_IXP46X_ONLY; 88186418Ssam return bits; 89186418Ssam} 90186418Ssam 91194319Ssamvoid 92194319Ssamixp4xx_write_feature_bits(uint32_t v) 93194319Ssam{ 94194319Ssam IXPREG(IXP425_EXP_VBASE + EXP_FCTRL_OFFSET) = ~v; 95194319Ssam} 96194319Ssam 97164426Ssamstruct arm32_dma_range * 98164426Ssambus_dma_get_range(void) 99164426Ssam{ 100164426Ssam return (NULL); 101164426Ssam} 102164426Ssam 103164426Ssamint 104164426Ssambus_dma_get_range_nb(void) 105164426Ssam{ 106164426Ssam return (0); 107164426Ssam} 108164426Ssam 109189633Ssamstatic const uint8_t int2gpio[32] __attribute__ ((aligned(32))) = { 110189633Ssam 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* INT#0 -> INT#5 */ 111189633Ssam 0x00, 0x01, /* GPIO#0 -> GPIO#1 */ 112189633Ssam 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* INT#8 -> INT#13 */ 113189633Ssam 0xff, 0xff, 0xff, 0xff, 0xff, /* INT#14 -> INT#18 */ 114189633Ssam 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* GPIO#2 -> GPIO#7 */ 115189633Ssam 0x08, 0x09, 0x0a, 0x0b, 0x0c, /* GPIO#8 -> GPIO#12 */ 116189633Ssam 0xff, 0xff /* INT#30 -> INT#31 */ 117189633Ssam}; 118189633Ssam 119194648Ssamstatic __inline uint32_t 120164426Ssamixp425_irq2gpio_bit(int irq) 121164426Ssam{ 122189633Ssam return (1U << int2gpio[irq]); 123189633Ssam} 124164426Ssam 125189633Ssam#ifdef DDB 126189633Ssam#include <ddb/ddb.h> 127189633Ssam 128189633SsamDB_SHOW_COMMAND(gpio, db_show_gpio) 129189633Ssam{ 130189633Ssam static const char *itype[8] = { 131189633Ssam [GPIO_TYPE_ACT_HIGH] = "act-high", 132189633Ssam [GPIO_TYPE_ACT_LOW] = "act-low", 133189633Ssam [GPIO_TYPE_EDG_RISING] = "edge-rising", 134189633Ssam [GPIO_TYPE_EDG_FALLING] = "edge-falling", 135189633Ssam [GPIO_TYPE_TRANSITIONAL]= "transitional", 136189633Ssam [5] = "type-5", [6] = "type-6", [7] = "type-7" 137164426Ssam }; 138189633Ssam uint32_t gpoutr = GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPOUTR); 139189633Ssam uint32_t gpoer = GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPOER); 140189633Ssam uint32_t gpinr = GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPINR); 141189633Ssam uint32_t gpit1r = GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPIT1R); 142189633Ssam uint32_t gpit2r = GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPIT2R); 143189633Ssam int i, j; 144164426Ssam 145194649Ssam db_printf("GPOUTR %08x GPINR %08x GPOER %08x GPISR %08x\n", 146194649Ssam gpoutr, gpinr, gpoer, 147189633Ssam GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPISR)); 148189633Ssam db_printf("GPIT1R %08x GPIT2R %08x GPCLKR %08x\n", 149189633Ssam gpit1r, gpit2r, GPIO_CONF_READ_4(ixp425_softc, IXP425_GPIO_GPCLKR)); 150189633Ssam for (i = 0; i < 16; i++) { 151189633Ssam db_printf("[%2d] out %u in %u %-3s", i, 152189633Ssam (gpoutr>>i)&1, (gpinr>>i)&1, (gpoer>>i)&1 ? "in" : "out"); 153189633Ssam for (j = 0; j < 32; j++) 154189633Ssam if (int2gpio[j] == i) { 155189633Ssam db_printf(" irq %2u %s", j, itype[ 156189633Ssam (((i & 8) ? gpit2r : gpit1r) >> (3*(i&7))) 157189633Ssam & 7]); 158189633Ssam break; 159189633Ssam } 160189633Ssam db_printf("\n"); 161189633Ssam } 162164426Ssam} 163189633Ssam#endif 164164426Ssam 165194653Ssamvoid 166194653Ssamixp425_set_gpio(struct ixp425_softc *sc, int pin, int type) 167194653Ssam{ 168194653Ssam uint32_t gpiotr = GPIO_CONF_READ_4(sc, GPIO_TYPE_REG(pin)); 169194653Ssam 170215319Sthompsa IXP4XX_GPIO_LOCK(); 171194653Ssam /* clear interrupt type */ 172194653Ssam GPIO_CONF_WRITE_4(sc, GPIO_TYPE_REG(pin), 173194653Ssam gpiotr &~ GPIO_TYPE(pin, GPIO_TYPE_MASK)); 174194653Ssam /* clear any pending interrupt */ 175194653Ssam GPIO_CONF_WRITE_4(sc, IXP425_GPIO_GPISR, (1<<pin)); 176194653Ssam /* set new interrupt type */ 177194653Ssam GPIO_CONF_WRITE_4(sc, GPIO_TYPE_REG(pin), 178194653Ssam gpiotr | GPIO_TYPE(pin, type)); 179194653Ssam 180194653Ssam /* configure gpio line as an input */ 181236987Simp GPIO_CONF_WRITE_4(sc, IXP425_GPIO_GPOER, 182194653Ssam GPIO_CONF_READ_4(sc, IXP425_GPIO_GPOER) | (1<<pin)); 183215319Sthompsa IXP4XX_GPIO_UNLOCK(); 184194653Ssam} 185194653Ssam 186194650Ssamstatic __inline void 187194650Ssamixp425_gpio_ack(int irq) 188194650Ssam{ 189194650Ssam if (irq < 32 && ((1 << irq) & IXP425_INT_GPIOMASK)) 190194650Ssam IXPREG(IXP425_GPIO_VBASE + IXP425_GPIO_GPISR) = 191194650Ssam ixp425_irq2gpio_bit(irq); 192194650Ssam} 193194650Ssam 194194656Ssamstatic void 195194656Ssamixp425_post_filter(void *arg) 196194656Ssam{ 197194656Ssam uintptr_t irq = (uintptr_t) arg; 198194656Ssam ixp425_gpio_ack(irq); 199194656Ssam} 200194656Ssam 201164426Ssamvoid 202164426Ssamarm_mask_irq(uintptr_t nb) 203164426Ssam{ 204182946Scognet int i; 205194651Ssam 206271398Sandrew i = disable_interrupts(PSR_I); 207186352Ssam if (nb < 32) { 208186352Ssam intr_enabled &= ~(1 << nb); 209186352Ssam ixp425_set_intrmask(); 210186352Ssam } else { 211186352Ssam intr_enabled2 &= ~(1 << (nb - 32)); 212186352Ssam ixp435_set_intrmask(); 213186352Ssam } 214182946Scognet restore_interrupts(i); 215164426Ssam /*XXX; If it's a GPIO interrupt, ACK it know. Can it be a problem ?*/ 216194650Ssam ixp425_gpio_ack(nb); 217164426Ssam} 218164426Ssam 219164426Ssamvoid 220164426Ssamarm_unmask_irq(uintptr_t nb) 221164426Ssam{ 222182946Scognet int i; 223194651Ssam 224271398Sandrew i = disable_interrupts(PSR_I); 225186352Ssam if (nb < 32) { 226186352Ssam intr_enabled |= (1 << nb); 227186352Ssam ixp425_set_intrmask(); 228186352Ssam } else { 229186352Ssam intr_enabled2 |= (1 << (nb - 32)); 230186352Ssam ixp435_set_intrmask(); 231186352Ssam } 232182946Scognet restore_interrupts(i); 233164426Ssam} 234164426Ssam 235164426Ssamstatic __inline uint32_t 236164426Ssamixp425_irq_read(void) 237164426Ssam{ 238164426Ssam return IXPREG(IXP425_INT_STATUS) & intr_enabled; 239164426Ssam} 240164426Ssam 241186352Ssamstatic __inline uint32_t 242186352Ssamixp435_irq_read(void) 243186352Ssam{ 244186352Ssam return IXPREG(IXP435_INT_STATUS2) & intr_enabled2; 245186352Ssam} 246186352Ssam 247164426Ssamint 248194652Ssamarm_get_next_irq(int last) 249164426Ssam{ 250194652Ssam uint32_t mask; 251164426Ssam 252194652Ssam last += 1; /* always advance fwd, NB: handles -1 */ 253194652Ssam if (last < 32) { 254194652Ssam mask = ixp425_irq_read() >> last; 255194752Ssam for (; mask != 0; mask >>= 1, last++) { 256194652Ssam if (mask & 1) 257194652Ssam return last; 258194652Ssam } 259194652Ssam last = 32; 260194652Ssam } 261194652Ssam if (cpu_is_ixp43x()) { 262194652Ssam mask = ixp435_irq_read() >> (32-last); 263194652Ssam for (; mask != 0; mask >>= 1, last++) { 264194652Ssam if (mask & 1) 265194652Ssam return last; 266194652Ssam } 267194652Ssam } 268194652Ssam return -1; 269164426Ssam} 270164426Ssam 271164426Ssamvoid 272164426Ssamcpu_reset(void) 273164426Ssam{ 274164426Ssam 275164426Ssam bus_space_write_4(&ixp425_bs_tag, IXP425_TIMER_VBASE, 276164426Ssam IXP425_OST_WDOG_KEY, OST_WDOG_KEY_MAJICK); 277164426Ssam bus_space_write_4(&ixp425_bs_tag, IXP425_TIMER_VBASE, 278164426Ssam IXP425_OST_WDOG, 0); 279164426Ssam bus_space_write_4(&ixp425_bs_tag, IXP425_TIMER_VBASE, 280164426Ssam IXP425_OST_WDOG_ENAB, OST_WDOG_ENAB_RST_ENA | 281164426Ssam OST_WDOG_ENAB_CNT_ENA); 282164426Ssam printf("Reset failed!\n"); 283164426Ssam for(;;); 284164426Ssam} 285164426Ssam 286164426Ssamstatic void 287164426Ssamixp425_identify(driver_t *driver, device_t parent) 288164426Ssam{ 289164426Ssam BUS_ADD_CHILD(parent, 0, "ixp", 0); 290164426Ssam} 291164426Ssam 292164426Ssamstatic int 293164426Ssamixp425_probe(device_t dev) 294164426Ssam{ 295186352Ssam device_set_desc(dev, "Intel IXP4XX"); 296164426Ssam return (0); 297164426Ssam} 298164426Ssam 299164426Ssamstatic int 300164426Ssamixp425_attach(device_t dev) 301164426Ssam{ 302164426Ssam struct ixp425_softc *sc; 303164426Ssam 304186418Ssam device_printf(dev, "%b\n", ixp4xx_read_feature_bits(), EXP_FCTRL_BITS); 305186418Ssam 306164426Ssam sc = device_get_softc(dev); 307164426Ssam sc->sc_iot = &ixp425_bs_tag; 308186352Ssam KASSERT(ixp425_softc == NULL, ("%s called twice?", __func__)); 309164426Ssam ixp425_softc = sc; 310164426Ssam 311164426Ssam intr_enabled = 0; 312164426Ssam ixp425_set_intrmask(); 313164426Ssam ixp425_set_intrsteer(); 314186352Ssam if (cpu_is_ixp43x()) { 315186352Ssam intr_enabled2 = 0; 316186352Ssam ixp435_set_intrmask(); 317186352Ssam ixp435_set_intrsteer(); 318186352Ssam } 319194656Ssam arm_post_filter = ixp425_post_filter; 320164426Ssam 321215319Sthompsa mtx_init(&ixp425_gpio_mtx, "gpio", NULL, MTX_DEF); 322194670Ssam if (bus_space_map(sc->sc_iot, IXP425_GPIO_HWBASE, IXP425_GPIO_SIZE, 323194670Ssam 0, &sc->sc_gpio_ioh)) 324194670Ssam panic("%s: unable to map GPIO registers", __func__); 325194670Ssam if (bus_space_map(sc->sc_iot, IXP425_EXP_HWBASE, IXP425_EXP_SIZE, 326194670Ssam 0, &sc->sc_exp_ioh)) 327194670Ssam panic("%s: unable to map Expansion Bus registers", __func__); 328194670Ssam 329194670Ssam /* XXX belongs in platform init */ 330194670Ssam if (cpu_is_ixp43x()) 331194670Ssam cambria_exp_bus_init(sc); 332194670Ssam 333166064Scognet if (bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT, 334236987Simp BUS_SPACE_MAXADDR, NULL, NULL, 0xffffffff, 0xff, 0xffffffff, 0, 335166064Scognet NULL, NULL, &sc->sc_dmat)) 336186352Ssam panic("%s: failed to create dma tag", __func__); 337166064Scognet 338164426Ssam sc->sc_irq_rman.rm_type = RMAN_ARRAY; 339186352Ssam sc->sc_irq_rman.rm_descr = "IXP4XX IRQs"; 340164426Ssam if (rman_init(&sc->sc_irq_rman) != 0 || 341186352Ssam rman_manage_region(&sc->sc_irq_rman, 0, cpu_is_ixp43x() ? 63 : 31) != 0) 342186352Ssam panic("%s: failed to set up IRQ rman", __func__); 343164426Ssam 344164426Ssam sc->sc_mem_rman.rm_type = RMAN_ARRAY; 345186352Ssam sc->sc_mem_rman.rm_descr = "IXP4XX Memory"; 346164426Ssam if (rman_init(&sc->sc_mem_rman) != 0 || 347164426Ssam rman_manage_region(&sc->sc_mem_rman, 0, ~0) != 0) 348186352Ssam panic("%s: failed to set up memory rman", __func__); 349164426Ssam 350169952Ssam BUS_ADD_CHILD(dev, 0, "pcib", 0); 351169952Ssam BUS_ADD_CHILD(dev, 0, "ixpclk", 0); 352169952Ssam BUS_ADD_CHILD(dev, 0, "ixpiic", 0); 353169952Ssam /* XXX move to hints? */ 354169952Ssam BUS_ADD_CHILD(dev, 0, "ixpwdog", 0); 355164426Ssam 356169952Ssam /* attach wired devices via hints */ 357169952Ssam bus_enumerate_hinted_children(dev); 358169952Ssam 359164426Ssam bus_generic_probe(dev); 360164426Ssam bus_generic_attach(dev); 361164426Ssam 362164426Ssam return (0); 363164426Ssam} 364164426Ssam 365169952Ssamstatic void 366169952Ssamixp425_hinted_child(device_t bus, const char *dname, int dunit) 367169952Ssam{ 368169952Ssam device_t child; 369169952Ssam struct ixp425_ivar *ivar; 370169952Ssam 371169952Ssam child = BUS_ADD_CHILD(bus, 0, dname, dunit); 372169952Ssam ivar = IXP425_IVAR(child); 373169952Ssam resource_int_value(dname, dunit, "addr", &ivar->addr); 374169952Ssam resource_int_value(dname, dunit, "irq", &ivar->irq); 375169952Ssam} 376169952Ssam 377169952Ssamstatic device_t 378212413Savgixp425_add_child(device_t dev, u_int order, const char *name, int unit) 379169952Ssam{ 380169952Ssam device_t child; 381169952Ssam struct ixp425_ivar *ivar; 382169952Ssam 383169952Ssam child = device_add_child_ordered(dev, order, name, unit); 384169952Ssam if (child == NULL) 385169952Ssam return NULL; 386169952Ssam ivar = malloc(sizeof(struct ixp425_ivar), M_DEVBUF, M_NOWAIT); 387169952Ssam if (ivar == NULL) { 388169952Ssam device_delete_child(dev, child); 389169952Ssam return NULL; 390169952Ssam } 391169952Ssam ivar->addr = 0; 392169952Ssam ivar->irq = -1; 393169952Ssam device_set_ivars(child, ivar); 394169952Ssam return child; 395169952Ssam} 396169952Ssam 397169952Ssamstatic int 398194015Savgixp425_read_ivar(device_t bus, device_t child, int which, uintptr_t *result) 399169952Ssam{ 400169952Ssam struct ixp425_ivar *ivar = IXP425_IVAR(child); 401169952Ssam 402169952Ssam switch (which) { 403169952Ssam case IXP425_IVAR_ADDR: 404169952Ssam if (ivar->addr != 0) { 405169952Ssam *(uint32_t *)result = ivar->addr; 406169952Ssam return 0; 407169952Ssam } 408169952Ssam break; 409169952Ssam case IXP425_IVAR_IRQ: 410169952Ssam if (ivar->irq != -1) { 411169952Ssam *(int *)result = ivar->irq; 412169952Ssam return 0; 413169952Ssam } 414169952Ssam break; 415169952Ssam } 416169952Ssam return EINVAL; 417169952Ssam} 418169952Ssam 419186352Ssam/* 420189632Ssam * NB: This table handles P->V translations for regions setup with 421189632Ssam * static mappings in initarm. This is used solely for calls to 422189632Ssam * bus_alloc_resource_any; anything done with bus_space_map is 423189632Ssam * handled elsewhere and does not require an entry here. 424186352Ssam * 425189632Ssam * XXX this table is also used by uart_cpu_getdev via getvbase 426189632Ssam * (hence the public api) 427186352Ssam */ 428189632Ssamstruct hwvtrans { 429186352Ssam uint32_t hwbase; 430186352Ssam uint32_t size; 431186352Ssam uint32_t vbase; 432189632Ssam int isa4x; /* XXX needs special bus space tag */ 433194670Ssam int isslow; /* XXX needs special bus space tag */ 434186352Ssam}; 435186352Ssam 436189632Ssamstatic const struct hwvtrans * 437189632Ssamgethwvtrans(uint32_t hwbase, uint32_t size) 438186352Ssam{ 439189632Ssam static const struct hwvtrans hwvtrans[] = { 440189632Ssam /* NB: needed only for uart_cpu_getdev */ 441189632Ssam { .hwbase = IXP425_UART0_HWBASE, 442189632Ssam .size = IXP425_REG_SIZE, 443189632Ssam .vbase = IXP425_UART0_VBASE, 444189632Ssam .isa4x = 1 }, 445189632Ssam { .hwbase = IXP425_UART1_HWBASE, 446189632Ssam .size = IXP425_REG_SIZE, 447189632Ssam .vbase = IXP425_UART1_VBASE, 448189632Ssam .isa4x = 1 }, 449189632Ssam { .hwbase = IXP425_PCI_HWBASE, 450189632Ssam .size = IXP425_PCI_SIZE, 451189632Ssam .vbase = IXP425_PCI_VBASE }, 452189632Ssam { .hwbase = IXP425_PCI_MEM_HWBASE, 453189632Ssam .size = IXP425_PCI_MEM_SIZE, 454189632Ssam .vbase = IXP425_PCI_MEM_VBASE }, 455189632Ssam { .hwbase = IXP425_EXP_BUS_CS0_HWBASE, 456189632Ssam .size = IXP425_EXP_BUS_CS0_SIZE, 457189632Ssam .vbase = IXP425_EXP_BUS_CS0_VBASE }, 458189632Ssam /* NB: needed for ixp435 ehci controllers */ 459189632Ssam { .hwbase = IXP435_USB1_HWBASE, 460189632Ssam .size = IXP435_USB1_SIZE, 461189632Ssam .vbase = IXP435_USB1_VBASE }, 462189632Ssam { .hwbase = IXP435_USB2_HWBASE, 463189632Ssam .size = IXP435_USB2_SIZE, 464189632Ssam .vbase = IXP435_USB2_VBASE }, 465189632Ssam { .hwbase = CAMBRIA_GPS_HWBASE, 466189632Ssam .size = CAMBRIA_GPS_SIZE, 467194670Ssam .vbase = CAMBRIA_GPS_VBASE, 468194670Ssam .isslow = 1 }, 469189632Ssam { .hwbase = CAMBRIA_RS485_HWBASE, 470189632Ssam .size = CAMBRIA_RS485_SIZE, 471194670Ssam .vbase = CAMBRIA_RS485_VBASE, 472194670Ssam .isslow = 1 }, 473189632Ssam }; 474186352Ssam int i; 475186352Ssam 476298352Spfg for (i = 0; i < nitems(hwvtrans); i++) { 477186352Ssam if (hwbase >= hwvtrans[i].hwbase && 478189632Ssam hwbase + size <= hwvtrans[i].hwbase + hwvtrans[i].size) 479189632Ssam return &hwvtrans[i]; 480186352Ssam } 481189632Ssam return NULL; 482186352Ssam} 483186352Ssam 484189632Ssam/* XXX for uart_cpu_getdev */ 485189632Ssamint 486189632Ssamgetvbase(uint32_t hwbase, uint32_t size, uint32_t *vbase) 487189632Ssam{ 488189632Ssam const struct hwvtrans *hw; 489189632Ssam 490189632Ssam hw = gethwvtrans(hwbase, size); 491189632Ssam if (hw == NULL) 492189632Ssam return (ENOENT); 493189632Ssam *vbase = hwbase - hw->hwbase + hw->vbase; 494189632Ssam return (0); 495189632Ssam} 496189632Ssam 497164426Ssamstatic struct resource * 498164426Ssamixp425_alloc_resource(device_t dev, device_t child, int type, int *rid, 499294883Sjhibbits rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 500164426Ssam{ 501164426Ssam struct ixp425_softc *sc = device_get_softc(dev); 502189632Ssam const struct hwvtrans *vtrans; 503164426Ssam struct resource *rv; 504189632Ssam uint32_t addr; 505189630Ssam int needactivate = flags & RF_ACTIVE; 506169952Ssam int irq; 507164426Ssam 508189630Ssam flags &= ~RF_ACTIVE; 509164426Ssam switch (type) { 510164426Ssam case SYS_RES_IRQ: 511169952Ssam /* override per hints */ 512169952Ssam if (BUS_READ_IVAR(dev, child, IXP425_IVAR_IRQ, &irq) == 0) 513169952Ssam start = end = irq; 514189641Ssam rv = rman_reserve_resource(&sc->sc_irq_rman, start, end, count, 515189641Ssam flags, child); 516169952Ssam if (rv != NULL) 517169952Ssam rman_set_rid(rv, *rid); 518164426Ssam break; 519164426Ssam 520164426Ssam case SYS_RES_MEMORY: 521169952Ssam /* override per hints */ 522169952Ssam if (BUS_READ_IVAR(dev, child, IXP425_IVAR_ADDR, &addr) == 0) { 523169952Ssam start = addr; 524189632Ssam /* XXX use nominal window to check for mapping */ 525189632Ssam vtrans = gethwvtrans(start, 0x1000); 526189632Ssam if (vtrans != NULL) { 527189632Ssam /* 528189632Ssam * Assign the entire mapped region; this may 529189632Ssam * not be correct but without more info from 530189632Ssam * the caller we cannot tell. 531189632Ssam */ 532189632Ssam end = start + vtrans->size - 533189632Ssam (start - vtrans->hwbase); 534189632Ssam if (bootverbose) 535189632Ssam device_printf(child, 536297000Sjhibbits "%s: assign 0x%jx:0x%jx%s\n", 537189632Ssam __func__, start, end - start, 538236987Simp vtrans->isa4x ? " A4X" : 539194670Ssam vtrans->isslow ? " SLOW" : ""); 540189632Ssam } 541189632Ssam } else 542189632Ssam vtrans = gethwvtrans(start, end - start); 543189632Ssam if (vtrans == NULL) { 544186352Ssam /* likely means above table needs to be updated */ 545297000Sjhibbits device_printf(child, "%s: no mapping for 0x%jx:0x%jx\n", 546189641Ssam __func__, start, end - start); 547169952Ssam return NULL; 548186352Ssam } 549189641Ssam rv = rman_reserve_resource(&sc->sc_mem_rman, start, end, 550189641Ssam end - start, flags, child); 551189641Ssam if (rv == NULL) { 552297000Sjhibbits device_printf(child, "%s: cannot reserve 0x%jx:0x%jx\n", 553189641Ssam __func__, start, end - start); 554189641Ssam return NULL; 555189641Ssam } 556189641Ssam rman_set_rid(rv, *rid); 557164426Ssam break; 558164426Ssam default: 559169952Ssam rv = NULL; 560169952Ssam break; 561164426Ssam } 562189630Ssam if (rv != NULL && needactivate) { 563189630Ssam if (bus_activate_resource(child, type, *rid, rv)) { 564189630Ssam rman_release_resource(rv); 565189630Ssam return (NULL); 566189630Ssam } 567189630Ssam } 568189630Ssam return (rv); 569164426Ssam} 570164426Ssam 571189630Ssamstatic int 572189641Ssamixp425_release_resource(device_t bus, device_t child, int type, int rid, 573189641Ssam struct resource *r) 574189641Ssam{ 575189641Ssam /* NB: no private resources, just release */ 576189641Ssam return rman_release_resource(r); 577189641Ssam} 578189641Ssam 579189641Ssamstatic int 580189630Ssamixp425_activate_resource(device_t dev, device_t child, int type, int rid, 581189630Ssam struct resource *r) 582189630Ssam{ 583189630Ssam struct ixp425_softc *sc = device_get_softc(dev); 584189632Ssam const struct hwvtrans *vtrans; 585189630Ssam 586189630Ssam if (type == SYS_RES_MEMORY) { 587189632Ssam vtrans = gethwvtrans(rman_get_start(r), rman_get_size(r)); 588189641Ssam if (vtrans == NULL) { /* NB: should not happen */ 589297000Sjhibbits device_printf(child, "%s: no mapping for 0x%jx:0x%jx\n", 590189641Ssam __func__, rman_get_start(r), rman_get_size(r)); 591189632Ssam return (ENOENT); 592189641Ssam } 593189632Ssam if (vtrans->isa4x) 594189630Ssam rman_set_bustag(r, &ixp425_a4x_bs_tag); 595194670Ssam else if (vtrans->isslow) 596194670Ssam rman_set_bustag(r, &cambria_exp_bs_tag); 597189630Ssam else 598189630Ssam rman_set_bustag(r, sc->sc_iot); 599189632Ssam rman_set_bushandle(r, vtrans->vbase); 600189630Ssam } 601189630Ssam return (rman_activate_resource(r)); 602189630Ssam} 603189630Ssam 604189641Ssamstatic int 605189641Ssamixp425_deactivate_resource(device_t bus, device_t child, int type, int rid, 606236987Simp struct resource *r) 607189641Ssam{ 608189641Ssam /* NB: no private resources, just deactive */ 609189641Ssam return (rman_deactivate_resource(r)); 610189641Ssam} 611189641Ssam 612186352Ssamstatic __inline void 613186352Ssamget_masks(struct resource *res, uint32_t *mask, uint32_t *mask2) 614186352Ssam{ 615186352Ssam int i; 616186352Ssam 617186352Ssam *mask = 0; 618186352Ssam for (i = rman_get_start(res); i < 32 && i <= rman_get_end(res); i++) 619186352Ssam *mask |= 1 << i; 620186352Ssam *mask2 = 0; 621186352Ssam for (; i <= rman_get_end(res); i++) 622186352Ssam *mask2 |= 1 << (i - 32); 623186352Ssam} 624186352Ssam 625186352Ssamstatic __inline void 626186352Ssamupdate_masks(uint32_t mask, uint32_t mask2) 627186352Ssam{ 628186352Ssam 629186352Ssam intr_enabled = mask; 630186352Ssam ixp425_set_intrmask(); 631186352Ssam if (cpu_is_ixp43x()) { 632186352Ssam intr_enabled2 = mask2; 633186352Ssam ixp435_set_intrmask(); 634186352Ssam } 635186352Ssam} 636186352Ssam 637164426Ssamstatic int 638164426Ssamixp425_setup_intr(device_t dev, device_t child, 639236987Simp struct resource *res, int flags, driver_filter_t *filt, 640236987Simp driver_intr_t *intr, void *arg, void **cookiep) 641164426Ssam{ 642186352Ssam uint32_t mask, mask2; 643226832Skevlo int error; 644164426Ssam 645226832Skevlo error = BUS_SETUP_INTR(device_get_parent(dev), child, res, flags, 646226832Skevlo filt, intr, arg, cookiep); 647226832Skevlo if (error) 648226832Skevlo return (error); 649164426Ssam 650186352Ssam get_masks(res, &mask, &mask2); 651186352Ssam update_masks(intr_enabled | mask, intr_enabled2 | mask2); 652164426Ssam 653164426Ssam return (0); 654164426Ssam} 655164426Ssam 656164426Ssamstatic int 657164426Ssamixp425_teardown_intr(device_t dev, device_t child, struct resource *res, 658164426Ssam void *cookie) 659164426Ssam{ 660186352Ssam uint32_t mask, mask2; 661164426Ssam 662186352Ssam get_masks(res, &mask, &mask2); 663186352Ssam update_masks(intr_enabled &~ mask, intr_enabled2 &~ mask2); 664164426Ssam 665164426Ssam return (BUS_TEARDOWN_INTR(device_get_parent(dev), child, res, cookie)); 666164426Ssam} 667164426Ssam 668164426Ssamstatic device_method_t ixp425_methods[] = { 669164426Ssam /* Device interface */ 670189641Ssam DEVMETHOD(device_probe, ixp425_probe), 671189641Ssam DEVMETHOD(device_attach, ixp425_attach), 672189641Ssam DEVMETHOD(device_identify, ixp425_identify), 673164426Ssam 674164426Ssam /* Bus interface */ 675189641Ssam DEVMETHOD(bus_add_child, ixp425_add_child), 676189641Ssam DEVMETHOD(bus_hinted_child, ixp425_hinted_child), 677189641Ssam DEVMETHOD(bus_read_ivar, ixp425_read_ivar), 678169952Ssam 679189641Ssam DEVMETHOD(bus_alloc_resource, ixp425_alloc_resource), 680189641Ssam DEVMETHOD(bus_release_resource, ixp425_release_resource), 681189641Ssam DEVMETHOD(bus_activate_resource, ixp425_activate_resource), 682189641Ssam DEVMETHOD(bus_deactivate_resource, ixp425_deactivate_resource), 683189641Ssam DEVMETHOD(bus_setup_intr, ixp425_setup_intr), 684189641Ssam DEVMETHOD(bus_teardown_intr, ixp425_teardown_intr), 685164426Ssam 686164426Ssam {0, 0}, 687164426Ssam}; 688164426Ssam 689164426Ssamstatic driver_t ixp425_driver = { 690164426Ssam "ixp", 691164426Ssam ixp425_methods, 692164426Ssam sizeof(struct ixp425_softc), 693164426Ssam}; 694164426Ssamstatic devclass_t ixp425_devclass; 695164426Ssam 696164426SsamDRIVER_MODULE(ixp, nexus, ixp425_driver, ixp425_devclass, 0, 0); 697