/* $NetBSD: windermere.c,v 1.3 2021/08/07 16:18:48 thorpej Exp $ */ /* * Copyright (c) 2012 KIYOHARA Takashi * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: windermere.c,v 1.3 2021/08/07 16:18:48 thorpej Exp $"); #include "opt_com.h" #define _INTR_PRIVATE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "locators.h" static int windermere_match(device_t, cfdata_t, void *); static void windermere_attach(device_t parent, device_t self, void *aux); static int windermere_print(void *, const char *); static int windermere_submatch(device_t, cfdata_t, const int *, void *); static int windermere_find_pending_irqs(void); static void windermere_pic_unblock_irqs(struct pic_softc *, size_t, uint32_t); static void windermere_pic_block_irqs(struct pic_softc *, size_t, uint32_t); static void windermere_pic_establish_irq(struct pic_softc *, struct intrsource *); #define TC_READ(base, off) (*((base) + (off))) #define TC_WRITE(base, off, val) (*((base) + (off)) = (val)) static void windermere_initclocks(void); static int windermere_clockintr(void *); static void windermere_tc_init(void); static u_int windermere_get_timecount(struct timecounter *); static void windermere_delay(unsigned int); CFATTACH_DECL_NEW(windermere, 0, windermere_match, windermere_attach, NULL, NULL); static const struct { const char *name; bus_addr_t offset; int irq; } windermere_periphs[] = { { "wmlcd", 0x200, WINDERMERECF_IRQ_DEFAULT }, { "wmcom", 0x600, 12 }, { "wmcom", 0x700, 13 }, { "wmrtc", 0xd00, 10 }, { "wmpm", WINDERMERECF_OFFSET_DEFAULT, WINDERMERECF_IRQ_DEFAULT }, { "wmaudio", WINDERMERECF_OFFSET_DEFAULT, WINDERMERECF_IRQ_DEFAULT }, { "wmkbd", 0xe28, WINDERMERECF_IRQ_DEFAULT }, }; static struct pic_ops windermere_picops = { .pic_unblock_irqs = windermere_pic_unblock_irqs, .pic_block_irqs = windermere_pic_block_irqs, .pic_establish_irq = windermere_pic_establish_irq, }; static struct pic_softc windermere_pic = { .pic_ops = &windermere_picops, .pic_maxsources = 16, .pic_name = "windermere", }; static uint16_t pic_mask = 0x0000; /* ARGSUSED */ static int windermere_match(device_t parent, cfdata_t match, void *aux) { return 1; } /* ARGSUSED */ static void windermere_attach(device_t parent, device_t self, void *aux) { struct mainbus_attach_args *maa = aux; struct windermere_attach_args aa; bus_space_handle_t ioh; int i; aprint_naive("\n"); aprint_normal("\n"); if (bus_space_map(maa->mb_iot, maa->mb_iobase, ARM7XX_INTRREG_SIZE, 0, &ioh) != 0) { aprint_error_dev(self, "can't map registers\n"); return; } pic_add(&windermere_pic, 0); soc_find_pending_irqs = windermere_find_pending_irqs; soc_initclocks = windermere_initclocks; soc_delay = windermere_delay; for (i = 0; i < __arraycount(windermere_periphs); i++) { aa.aa_name = windermere_periphs[i].name; aa.aa_iot = maa->mb_iot; aa.aa_ioh = &ioh; aa.aa_offset = windermere_periphs[i].offset; aa.aa_size = 0; aa.aa_irq = windermere_periphs[i].irq; config_found(self, &aa, windermere_print, CFARGS(.submatch = windermere_submatch)); } } static int windermere_print(void *aux, const char *pnp) { struct windermere_attach_args *aa = aux; if (pnp) aprint_normal("%s at %s", aa->aa_name, pnp); else { if (aa->aa_offset != WINDERMERECF_OFFSET_DEFAULT) { aprint_normal(" offset 0x%04lx", aa->aa_offset); if (aa->aa_size > 0) aprint_normal("-0x%04lx", aa->aa_offset + aa->aa_size - 1); } if (aa->aa_irq != WINDERMERECF_IRQ_DEFAULT) aprint_normal(" irq %d", aa->aa_irq); } return UNCONF; } /* ARGSUSED */ static int windermere_submatch(device_t parent, cfdata_t cf, const int *ldesc, void *aux) { struct windermere_attach_args *aa = aux; /* * special case. match *kbd@windermere. * Windermere helps implement to machine-dependent keyboard. */ if (strcmp(aa->aa_name, "wmkbd") == 0 && strcmp(cf->cf_name + strlen(cf->cf_name) - 3, "kbd") == 0) return config_match(parent, cf, aux); if (strcmp(cf->cf_name, aa->aa_name) != 0) return 0; return config_match(parent, cf, aux); } static int windermere_find_pending_irqs(void) { volatile uint32_t *intr = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_INTR_OFFSET); uint16_t pending; pending = *(intr + INTSR); if (pending & ~pic_mask) { *(intr + INTENC) = pending & ~pic_mask; printf("stray interrupt pending: 0x%04x\n", pending & ~pic_mask); pending &= pic_mask; } if (pending == 0) return 0; return pic_mark_pending_sources(&windermere_pic, 0, pending); } /* ARGSUSED */ static void windermere_pic_unblock_irqs(struct pic_softc *pic, size_t irqbase, uint32_t irq_mask) { volatile uint32_t *intr = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_INTR_OFFSET); *(intr + INTENS) = irq_mask; pic_mask |= irq_mask; } /* ARGSUSED */ static void windermere_pic_block_irqs(struct pic_softc *pic, size_t irqbase, uint32_t irq_mask) { volatile uint32_t *intr = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_INTR_OFFSET); *(intr + INTENC) = irq_mask; pic_mask &= ~irq_mask; } static void windermere_pic_establish_irq(struct pic_softc *pic, struct intrsource *is) { /* Nothing */ } static void windermere_initclocks(void) { volatile uint32_t *tc1, *tc2; uint32_t ctrl; tc1 = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_TC_OFFSET + TC1_OFFSET); tc2 = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_TC_OFFSET + TC2_OFFSET); /* set clock to TC1 */ ctrl = TC_READ(tc1, TC_CTRL); ctrl |= (CTRL_CLKSEL | CTRL_MODE | CTRL_ENABLE); /* select 512kHz */ TC_WRITE(tc1, TC_CTRL, ctrl); TC_WRITE(tc1, TC_LOAD, 512 * 1000 / hz - 1); /* 512kHz / hz - 1 */ intr_establish(8, IPL_CLOCK, 0, windermere_clockintr, NULL); /* set delay counter */ ctrl = TC_READ(tc2, TC_CTRL); ctrl |= (CTRL_CLKSEL | CTRL_MODE | CTRL_ENABLE); /* select 512kHz */ TC_WRITE(tc2, TC_CTRL, ctrl); TC_WRITE(tc2, TC_LOAD, TC_MAX); windermere_tc_init(); } static int windermere_clockintr(void *arg) { volatile uint32_t *tc1; tc1 = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_TC_OFFSET + TC1_OFFSET); TC_WRITE(tc1, TC_EOI, EOI_EOI); hardclock(arg); return 1; } static void windermere_tc_init(void) { static struct timecounter windermere_tc = { .tc_get_timecount = windermere_get_timecount, .tc_counter_mask = TC_MASK, .tc_frequency = 512000, .tc_name = "windermere", .tc_quality = 100, }; tc_init(&windermere_tc); } static u_int windermere_get_timecount(struct timecounter *tc) { volatile uint32_t *tc2; tc2 = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_TC_OFFSET + TC2_OFFSET); return TC_READ(tc2, TC_VAL) ^ TC_MASK; /* It is decremental counter */ } static void windermere_delay(unsigned int us) { volatile uint32_t *tc2; int prev, now, remaining; tc2 = (uint32_t *)(ARM7XX_INTRREG_VBASE + WINDERMERE_TC_OFFSET + TC2_OFFSET); prev = TC_READ(tc2, TC_VAL) & TC_MASK; remaining = us * 512 / 1000 + 1; while (remaining > 0) { now = TC_READ(tc2, TC_VAL) & TC_MASK; if (now >= prev) remaining -= (now - prev); else remaining -= (USHRT_MAX - now + prev + 1); prev = now; } }