Index: head/sys/arm/allwinner/aw_thermal.c =================================================================== --- head/sys/arm/allwinner/aw_thermal.c (revision 305351) +++ head/sys/arm/allwinner/aw_thermal.c (revision 305352) @@ -1,232 +1,384 @@ /*- * Copyright (c) 2016 Jared McNeill * 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. * * $FreeBSD$ */ /* * Allwinner thermal sensor controller */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include +#include #include #include #include #include +#include +#include + #include #define THS_CTRL0 0x00 +#define THS_CTRL1 0x04 +#define ADC_CALI_EN (1 << 17) #define THS_CTRL2 0x40 #define SENSOR_ACQ1_SHIFT 16 #define SENSOR2_EN (1 << 2) #define SENSOR1_EN (1 << 1) #define SENSOR0_EN (1 << 0) #define THS_INTC 0x44 #define THS_INTS 0x48 +#define THS2_DATA_IRQ_STS (1 << 10) +#define THS1_DATA_IRQ_STS (1 << 9) +#define THS0_DATA_IRQ_STS (1 << 8) +#define SHUT_INT2_STS (1 << 6) +#define SHUT_INT1_STS (1 << 5) +#define SHUT_INT0_STS (1 << 4) +#define ALARM_INT2_STS (1 << 2) +#define ALARM_INT1_STS (1 << 1) +#define ALARM_INT0_STS (1 << 0) #define THS_FILTER 0x70 -#define FILTER_EN (1 << 2) #define THS_CALIB0 0x74 #define THS_CALIB1 0x78 #define THS_DATA0 0x80 #define THS_DATA1 0x84 #define THS_DATA2 0x88 #define DATA_MASK 0xfff -#define TEMP_BASE 2719 -#define TEMP_MUL 1000 -#define TEMP_DIV 14186 -#define TEMP_TO_K 273 -#define ADC_ACQUIRE_TIME (24 - 1) +#define A83T_ADC_ACQUIRE_TIME 0x17 +#define A83T_FILTER 0x4 +#define A83T_INTC 0x1000 +#define A83T_TEMP_BASE 2719000 +#define A83T_TEMP_DIV 14186 +#define A83T_CLK_RATE 24000000 + +#define A64_ADC_ACQUIRE_TIME 0x190 +#define A64_FILTER 0x6 +#define A64_INTC 0x18000 +#define A64_TEMP_BASE 2170000 +#define A64_TEMP_DIV 8560 +#define A64_CLK_RATE 4000000 + +#define TEMP_C_TO_K 273 #define SENSOR_ENABLE_ALL (SENSOR0_EN|SENSOR1_EN|SENSOR2_EN) +#define SHUT_INT_ALL (SHUT_INT0_STS|SHUT_INT1_STS|SHUT_INT2_STS) -enum aw_thermal_sensor { - THS_SENSOR_CPU_CLUSTER0, - THS_SENSOR_CPU_CLUSTER1, - THS_SENSOR_GPU, - THS_SENSOR_END = -1 -}; +#define MAX_SENSORS 3 -struct aw_thermal_sensor_config { - enum aw_thermal_sensor sensor; +struct aw_thermal_sensor { const char *name; const char *desc; }; -static const struct aw_thermal_sensor_config a83t_sensor_config[] = { - { .sensor = THS_SENSOR_CPU_CLUSTER0, - .name = "cluster0", .desc = "CPU cluster 0 temperature" }, - { .sensor = THS_SENSOR_CPU_CLUSTER1, - .name = "cluster1", .desc = "CPU cluster 1 temperature" }, - { .sensor = THS_SENSOR_GPU, - .name = "gpu", .desc = "GPU temperature" }, - { .sensor = THS_SENSOR_END } +struct aw_thermal_config { + struct aw_thermal_sensor sensors[MAX_SENSORS]; + int nsensors; + uint64_t clk_rate; + uint32_t adc_acquire_time; + uint32_t filter; + uint32_t intc; + uint32_t temp_base; + uint32_t temp_div; }; +static const struct aw_thermal_config a83t_config = { + .nsensors = 3, + .sensors = { + [0] = { + .name = "cluster0", + .desc = "CPU cluster 0 temperature", + }, + [1] = { + .name = "cluster1", + .desc = "CPU cluster 1 temperature", + }, + [2] = { + .name = "gpu", + .desc = "GPU temperature", + }, + }, + .clk_rate = A83T_CLK_RATE, + .adc_acquire_time = A83T_ADC_ACQUIRE_TIME, + .filter = A83T_FILTER, + .intc = A83T_INTC, + .temp_base = A83T_TEMP_BASE, + .temp_div = A83T_TEMP_DIV, +}; + +static const struct aw_thermal_config a64_config = { + .nsensors = 3, + .sensors = { + [0] = { + .name = "cpu", + .desc = "CPU temperature", + }, + [1] = { + .name = "gpu1", + .desc = "GPU temperature 1", + }, + [2] = { + .name = "gpu2", + .desc = "GPU temperature 2", + }, + }, + .clk_rate = A64_CLK_RATE, + .adc_acquire_time = A64_ADC_ACQUIRE_TIME, + .filter = A64_FILTER, + .intc = A64_INTC, + .temp_base = A64_TEMP_BASE, + .temp_div = A64_TEMP_DIV, +}; + static struct ofw_compat_data compat_data[] = { - { "allwinner,sun8i-a83t-ts", (uintptr_t)&a83t_sensor_config }, + { "allwinner,sun8i-a83t-ts", (uintptr_t)&a83t_config }, + { "allwinner,sun50i-a64-ts", (uintptr_t)&a64_config }, { NULL, (uintptr_t)NULL } }; #define THS_CONF(d) \ (void *)ofw_bus_search_compatible((d), compat_data)->ocd_data struct aw_thermal_softc { - struct resource *res; - struct aw_thermal_sensor_config *conf; + struct resource *res[2]; + struct aw_thermal_config *conf; }; static struct resource_spec aw_thermal_spec[] = { { SYS_RES_MEMORY, 0, RF_ACTIVE }, + { SYS_RES_IRQ, 0, RF_ACTIVE }, { -1, 0 } }; -#define RD4(sc, reg) bus_read_4((sc)->res, (reg)) -#define WR4(sc, reg, val) bus_write_4((sc)->res, (reg), (val)) +#define RD4(sc, reg) bus_read_4((sc)->res[0], (reg)) +#define WR4(sc, reg, val) bus_write_4((sc)->res[0], (reg), (val)) static int aw_thermal_init(struct aw_thermal_softc *sc) { uint32_t calib0, calib1; int error; /* Read calibration settings from SRAM */ error = aw_sid_read_tscalib(&calib0, &calib1); if (error != 0) return (error); /* Write calibration settings to thermal controller */ WR4(sc, THS_CALIB0, calib0); WR4(sc, THS_CALIB1, calib1); /* Configure ADC acquire time (CLK_IN/(N+1)) and enable sensors */ - WR4(sc, THS_CTRL0, ADC_ACQUIRE_TIME); - WR4(sc, THS_CTRL2, (ADC_ACQUIRE_TIME << SENSOR_ACQ1_SHIFT) | - SENSOR_ENABLE_ALL); + WR4(sc, THS_CTRL1, ADC_CALI_EN); + WR4(sc, THS_CTRL0, sc->conf->adc_acquire_time); + WR4(sc, THS_CTRL2, sc->conf->adc_acquire_time << SENSOR_ACQ1_SHIFT); - /* Disable interrupts */ - WR4(sc, THS_INTC, 0); + /* Enable average filter */ + WR4(sc, THS_FILTER, sc->conf->filter); + + /* Enable interrupts */ WR4(sc, THS_INTS, RD4(sc, THS_INTS)); + WR4(sc, THS_INTC, sc->conf->intc | SHUT_INT_ALL); - /* Enable average filter */ - WR4(sc, THS_FILTER, RD4(sc, THS_FILTER) | FILTER_EN); + /* Enable sensors */ + WR4(sc, THS_CTRL2, RD4(sc, THS_CTRL2) | SENSOR_ENABLE_ALL); return (0); } static int -aw_thermal_gettemp(uint32_t val) +aw_thermal_reg_to_temp(struct aw_thermal_softc *sc, uint32_t val) { - int raw; + return ((sc->conf->temp_base - val * 1000) / sc->conf->temp_div); +} - raw = val & DATA_MASK; - return (((TEMP_BASE - raw) * TEMP_MUL) / TEMP_DIV) + TEMP_TO_K; +static int +aw_thermal_gettemp(struct aw_thermal_softc *sc, int sensor) +{ + uint32_t val; + + val = RD4(sc, THS_DATA0 + (sensor * 4)); + + return (aw_thermal_reg_to_temp(sc, val) + TEMP_C_TO_K); } static int aw_thermal_sysctl(SYSCTL_HANDLER_ARGS) { struct aw_thermal_softc *sc; - enum aw_thermal_sensor sensor; - int val; + int sensor, val; sc = arg1; sensor = arg2; - val = aw_thermal_gettemp(RD4(sc, THS_DATA0 + (sensor * 4))); + val = aw_thermal_gettemp(sc, sensor); return sysctl_handle_opaque(oidp, &val, sizeof(val), req); } +static void +aw_thermal_intr(void *arg) +{ + struct aw_thermal_softc *sc; + device_t dev; + uint32_t ints; + + dev = arg; + sc = device_get_softc(dev); + + ints = RD4(sc, THS_INTS); + WR4(sc, THS_INTS, ints); + + if ((ints & SHUT_INT_ALL) != 0) { + device_printf(dev, + "WARNING - current temperature exceeds safe limits\n"); + shutdown_nice(RB_POWEROFF); + } +} + static int aw_thermal_probe(device_t dev) { if (!ofw_bus_status_okay(dev)) return (ENXIO); if (THS_CONF(dev) == NULL) return (ENXIO); device_set_desc(dev, "Allwinner Thermal Sensor Controller"); return (BUS_PROBE_DEFAULT); } static int aw_thermal_attach(device_t dev) { struct aw_thermal_softc *sc; - int i; + clk_t clk_ahb, clk_ths; + hwreset_t rst; + int i, error; + void *ih; sc = device_get_softc(dev); + clk_ahb = clk_ths = NULL; + rst = NULL; + ih = NULL; sc->conf = THS_CONF(dev); - if (bus_alloc_resources(dev, aw_thermal_spec, &sc->res) != 0) { + if (bus_alloc_resources(dev, aw_thermal_spec, sc->res) != 0) { device_printf(dev, "cannot allocate resources for device\n"); return (ENXIO); } + if (clk_get_by_ofw_name(dev, 0, "ahb", &clk_ahb) == 0) { + error = clk_enable(clk_ahb); + if (error != 0) { + device_printf(dev, "cannot enable ahb clock\n"); + goto fail; + } + } + if (clk_get_by_ofw_name(dev, 0, "ths", &clk_ths) == 0) { + error = clk_set_freq(clk_ths, sc->conf->clk_rate, 0); + if (error != 0) { + device_printf(dev, "cannot set ths clock rate\n"); + goto fail; + } + error = clk_enable(clk_ths); + if (error != 0) { + device_printf(dev, "cannot enable ths clock\n"); + goto fail; + } + } + if (hwreset_get_by_ofw_idx(dev, 0, 0, &rst) == 0) { + error = hwreset_deassert(rst); + if (error != 0) { + device_printf(dev, "cannot de-assert reset\n"); + goto fail; + } + } + + error = bus_setup_intr(dev, sc->res[1], INTR_TYPE_MISC | INTR_MPSAFE, + NULL, aw_thermal_intr, dev, &ih); + if (error != 0) { + device_printf(dev, "cannot setup interrupt handler\n"); + goto fail; + } + if (aw_thermal_init(sc) != 0) - return (ENXIO); + goto fail; - for (i = 0; sc->conf[i].sensor != THS_SENSOR_END; i++) + for (i = 0; i < sc->conf->nsensors; i++) SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), - OID_AUTO, sc->conf[i].name, + OID_AUTO, sc->conf->sensors[i].name, CTLTYPE_INT | CTLFLAG_RD, - sc, sc->conf[i].sensor, aw_thermal_sysctl, "IK0", - sc->conf[i].desc); + sc, i, aw_thermal_sysctl, "IK0", + sc->conf->sensors[i].desc); return (0); + +fail: + if (ih != NULL) + bus_teardown_intr(dev, sc->res[1], ih); + if (rst != NULL) + hwreset_release(rst); + if (clk_ahb != NULL) + clk_release(clk_ahb); + if (clk_ths != NULL) + clk_release(clk_ths); + bus_release_resources(dev, aw_thermal_spec, sc->res); + + return (ENXIO); } static device_method_t aw_thermal_methods[] = { /* Device interface */ DEVMETHOD(device_probe, aw_thermal_probe), DEVMETHOD(device_attach, aw_thermal_attach), DEVMETHOD_END }; static driver_t aw_thermal_driver = { "aw_thermal", aw_thermal_methods, sizeof(struct aw_thermal_softc), }; static devclass_t aw_thermal_devclass; DRIVER_MODULE(aw_thermal, simplebus, aw_thermal_driver, aw_thermal_devclass, 0, 0); MODULE_VERSION(aw_thermal, 1); Index: head/sys/arm/allwinner/clk/aw_thsclk.c =================================================================== --- head/sys/arm/allwinner/clk/aw_thsclk.c (nonexistent) +++ head/sys/arm/allwinner/clk/aw_thsclk.c (revision 305352) @@ -0,0 +1,320 @@ +/*- + * Copyright (c) 2016 Jared McNeill + * 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. + * + * $FreeBSD$ + */ + +/* + * Allwinner THS clocks + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include "clkdev_if.h" + +#define SCLK_GATING (1 << 31) +#define CLK_SRC_SEL (0x3 << 24) +#define CLK_SRC_SEL_SHIFT 24 +#define CLK_SRC_SEL_MAX 1 +#define CLK_DIV_RATIO (0x3 << 0) +#define CLK_DIV_RATIO_SHIFT 0 +#define CLK_DIV_RATIO_MAX 3 + +static struct ofw_compat_data compat_data[] = { + { "allwinner,sun50i-a64-ths-clk", 1 }, + { NULL, 0 } +}; + +struct aw_thsclk_sc { + device_t clkdev; + bus_addr_t reg; +}; + +#define THSCLK_READ(sc, val) CLKDEV_READ_4((sc)->clkdev, (sc)->reg, (val)) +#define THSCLK_WRITE(sc, val) CLKDEV_WRITE_4((sc)->clkdev, (sc)->reg, (val)) +#define DEVICE_LOCK(sc) CLKDEV_DEVICE_LOCK((sc)->clkdev) +#define DEVICE_UNLOCK(sc) CLKDEV_DEVICE_UNLOCK((sc)->clkdev) + +static int +aw_thsclk_init(struct clknode *clk, device_t dev) +{ + struct aw_thsclk_sc *sc; + uint32_t val, index; + + sc = clknode_get_softc(clk); + + DEVICE_LOCK(sc); + THSCLK_READ(sc, &val); + DEVICE_UNLOCK(sc); + + index = (val & CLK_SRC_SEL) >> CLK_SRC_SEL_SHIFT; + + clknode_init_parent_idx(clk, index); + return (0); +} + +static int +aw_thsclk_set_mux(struct clknode *clk, int index) +{ + struct aw_thsclk_sc *sc; + uint32_t val; + + sc = clknode_get_softc(clk); + + if (index < 0 || index >= CLK_SRC_SEL_MAX) + return (ERANGE); + + DEVICE_LOCK(sc); + THSCLK_READ(sc, &val); + val &= ~CLK_SRC_SEL; + val |= (index << CLK_SRC_SEL_SHIFT); + THSCLK_WRITE(sc, val); + DEVICE_UNLOCK(sc); + + return (0); +} + +static int +aw_thsclk_set_gate(struct clknode *clk, bool enable) +{ + struct aw_thsclk_sc *sc; + uint32_t val; + + sc = clknode_get_softc(clk); + + DEVICE_LOCK(sc); + THSCLK_READ(sc, &val); + if (enable) + val |= SCLK_GATING; + else + val &= ~SCLK_GATING; + THSCLK_WRITE(sc, val); + DEVICE_UNLOCK(sc); + + return (0); +} + +static int +aw_thsclk_recalc_freq(struct clknode *clk, uint64_t *freq) +{ + struct aw_thsclk_sc *sc; + uint32_t val, div; + + sc = clknode_get_softc(clk); + + DEVICE_LOCK(sc); + THSCLK_READ(sc, &val); + DEVICE_UNLOCK(sc); + + switch (val & CLK_DIV_RATIO) { + case 3: + div = 6; + break; + default: + div = 1 << (val & CLK_DIV_RATIO); + break; + } + + *freq = *freq / div; + + return (0); +} + +static int +aw_thsclk_set_freq(struct clknode *clk, uint64_t fin, uint64_t *fout, + int flags, int *stop) +{ + struct aw_thsclk_sc *sc; + uint32_t val, div, n, best_div, best_n; + uint64_t cur_freq; + int64_t best_diff, cur_diff; + + sc = clknode_get_softc(clk); + best_diff = (int64_t)*fout; + best_n = 0; + + for (div = 0; div <= CLK_DIV_RATIO_MAX; div++) { + n = (div == 3) ? 6 : (1 << div); + cur_freq = fin / n; + cur_diff = (int64_t)*fout - cur_freq; + if (cur_diff >= 0 && cur_diff < best_diff) { + best_diff = cur_diff; + best_div = div; + best_n = n; + } + } + + if (best_diff == (int64_t)*fout || best_n == 0) + return (ERANGE); + + DEVICE_LOCK(sc); + THSCLK_READ(sc, &val); + val &= ~CLK_DIV_RATIO; + val |= (best_div << CLK_DIV_RATIO_SHIFT); + THSCLK_WRITE(sc, val); + DEVICE_UNLOCK(sc); + + *fout = fin / best_n; + *stop = 1; + + return (0); +} + +static clknode_method_t aw_thsclk_clknode_methods[] = { + /* Device interface */ + CLKNODEMETHOD(clknode_init, aw_thsclk_init), + CLKNODEMETHOD(clknode_set_gate, aw_thsclk_set_gate), + CLKNODEMETHOD(clknode_set_mux, aw_thsclk_set_mux), + CLKNODEMETHOD(clknode_recalc_freq, aw_thsclk_recalc_freq), + CLKNODEMETHOD(clknode_set_freq, aw_thsclk_set_freq), + CLKNODEMETHOD_END +}; +DEFINE_CLASS_1(aw_thsclk_clknode, aw_thsclk_clknode_class, + aw_thsclk_clknode_methods, sizeof(struct aw_thsclk_sc), clknode_class); + +static int +aw_thsclk_probe(device_t dev) +{ + if (!ofw_bus_status_okay(dev)) + return (ENXIO); + + if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) + return (ENXIO); + + device_set_desc(dev, "Allwinner THS Clock"); + return (BUS_PROBE_DEFAULT); +} + +static int +aw_thsclk_attach(device_t dev) +{ + struct clknode_init_def def; + struct aw_thsclk_sc *sc; + struct clkdom *clkdom; + struct clknode *clk; + clk_t clk_parent; + bus_addr_t paddr; + bus_size_t psize; + phandle_t node; + int error, ncells, i; + + node = ofw_bus_get_node(dev); + + if (ofw_reg_to_paddr(node, 0, &paddr, &psize, NULL) != 0) { + device_printf(dev, "cannot parse 'reg' property\n"); + return (ENXIO); + } + + error = ofw_bus_parse_xref_list_get_length(node, "clocks", + "#clock-cells", &ncells); + if (error != 0) { + device_printf(dev, "cannot get clock count\n"); + return (error); + } + + clkdom = clkdom_create(dev); + + memset(&def, 0, sizeof(def)); + error = clk_parse_ofw_clk_name(dev, node, &def.name); + if (error != 0) { + device_printf(dev, "cannot parse clock name\n"); + error = ENXIO; + goto fail; + } + def.id = 1; + def.parent_names = malloc(sizeof(char *) * ncells, M_OFWPROP, M_WAITOK); + for (i = 0; i < ncells; i++) { + error = clk_get_by_ofw_index(dev, 0, i, &clk_parent); + if (error != 0) { + device_printf(dev, "cannot get clock %d\n", i); + goto fail; + } + def.parent_names[i] = clk_get_name(clk_parent); + clk_release(clk_parent); + } + def.parent_cnt = ncells; + + clk = clknode_create(clkdom, &aw_thsclk_clknode_class, &def); + if (clk == NULL) { + device_printf(dev, "cannot create clknode\n"); + error = ENXIO; + goto fail; + } + + sc = clknode_get_softc(clk); + sc->reg = paddr; + sc->clkdev = device_get_parent(dev); + + clknode_register(clkdom, clk); + + if (clkdom_finit(clkdom) != 0) { + device_printf(dev, "cannot finalize clkdom initialization\n"); + error = ENXIO; + goto fail; + } + + if (bootverbose) + clkdom_dump(clkdom); + + return (0); + +fail: + return (error); +} + +static device_method_t aw_thsclk_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, aw_thsclk_probe), + DEVMETHOD(device_attach, aw_thsclk_attach), + + DEVMETHOD_END +}; + +static driver_t aw_thsclk_driver = { + "aw_thsclk", + aw_thsclk_methods, + 0 +}; + +static devclass_t aw_thsclk_devclass; + +EARLY_DRIVER_MODULE(aw_thsclk, simplebus, aw_thsclk_driver, + aw_thsclk_devclass, 0, 0, BUS_PASS_BUS + BUS_PASS_ORDER_MIDDLE); Property changes on: head/sys/arm/allwinner/clk/aw_thsclk.c ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: head/sys/arm64/conf/GENERIC =================================================================== --- head/sys/arm64/conf/GENERIC (revision 305351) +++ head/sys/arm64/conf/GENERIC (revision 305352) @@ -1,200 +1,206 @@ # # GENERIC -- Generic kernel configuration file for FreeBSD/arm64 # # For more information on this file, please read the config(5) manual page, # and/or the handbook section on Kernel Configuration Files: # # http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/kernelconfig-config.html # # The handbook is also available locally in /usr/share/doc/handbook # if you've installed the doc distribution, otherwise always see the # FreeBSD World Wide Web server (http://www.FreeBSD.org/) for the # latest information. # # An exhaustive list of options and more detailed explanations of the # device lines is also present in the ../../conf/NOTES and NOTES files. # If you are in doubt as to the purpose or necessity of a line, check first # in NOTES. # # $FreeBSD$ cpu ARM64 ident GENERIC makeoptions DEBUG=-g # Build kernel with gdb(1) debug symbols makeoptions WITH_CTF=1 # Run ctfconvert(1) for DTrace support options SCHED_ULE # ULE scheduler options PREEMPTION # Enable kernel thread preemption options INET # InterNETworking options INET6 # IPv6 communications protocols options IPSEC # IP (v4/v6) security options TCP_OFFLOAD # TCP offload options SCTP # Stream Control Transmission Protocol options FFS # Berkeley Fast Filesystem options SOFTUPDATES # Enable FFS soft updates support options UFS_ACL # Support for access control lists options UFS_DIRHASH # Improve performance on big directories options UFS_GJOURNAL # Enable gjournal-based UFS journaling options QUOTA # Enable disk quotas for UFS options MD_ROOT # MD is a potential root device options NFSCL # Network Filesystem Client options NFSD # Network Filesystem Server options NFSLOCKD # Network Lock Manager options NFS_ROOT # NFS usable as /, requires NFSCL options MSDOSFS # MSDOS Filesystem options CD9660 # ISO 9660 Filesystem options PROCFS # Process filesystem (requires PSEUDOFS) options PSEUDOFS # Pseudo-filesystem framework options GEOM_PART_GPT # GUID Partition Tables. options GEOM_RAID # Soft RAID functionality. options GEOM_LABEL # Provides labelization options SCSI_DELAY=5000 # Delay (in ms) before probing SCSI options KTRACE # ktrace(1) support options STACK # stack(9) support options SYSVSHM # SYSV-style shared memory options SYSVMSG # SYSV-style message queues options SYSVSEM # SYSV-style semaphores options _KPOSIX_PRIORITY_SCHEDULING # POSIX P1003_1B real-time extensions options PRINTF_BUFR_SIZE=128 # Prevent printf output being interspersed. options KBD_INSTALL_CDEV # install a CDEV entry in /dev options HWPMC_HOOKS # Necessary kernel hooks for hwpmc(4) options AUDIT # Security event auditing options CAPABILITY_MODE # Capsicum capability mode options CAPABILITIES # Capsicum capabilities options MAC # TrustedBSD MAC Framework options KDTRACE_FRAME # Ensure frames are compiled in options KDTRACE_HOOKS # Kernel DTrace hooks options VFP # Floating-point support options RACCT # Resource accounting framework options RACCT_DEFAULT_TO_DISABLED # Set kern.racct.enable=0 by default options RCTL # Resource limits options SMP options INTRNG # Debugging support. Always need this: options KDB # Enable kernel debugger support. options KDB_TRACE # Print a stack trace for a panic. # For full debugger support use (turn off in stable branch): options DDB # Support DDB. #options GDB # Support remote GDB. options DEADLKRES # Enable the deadlock resolver options INVARIANTS # Enable calls of extra sanity checking options INVARIANT_SUPPORT # Extra sanity checks of internal structures, required by INVARIANTS options WITNESS # Enable checks to detect deadlocks and cycles options WITNESS_SKIPSPIN # Don't run witness on spinlocks for speed options MALLOC_DEBUG_MAXZONES=8 # Separate malloc(9) zones # SoC support options SOC_ALLWINNER_A64 options SOC_CAVM_THUNDERX options SOC_HISI_HI6220 # VirtIO support device virtio device virtio_mmio device virtio_blk device vtnet # Bus drivers device pci options PCI_HP # PCI-Express native HotPlug options PCI_IOV # PCI SR-IOV support # Ethernet NICs device mii device miibus # MII bus support device awg # Allwinner EMAC Gigabit Ethernet device em # Intel PRO/1000 Gigabit Ethernet Family device igb # Intel PRO/1000 PCIE Server Gigabit Family device ix # Intel 10Gb Ethernet Family device msk # Marvell/SysKonnect Yukon II Gigabit Ethernet device vnic # Cavium ThunderX NIC # Block devices device ahci device scbus device da # ATA/SCSI peripherals device pass # Passthrough device (direct ATA/SCSI access) # MMC/SD/SDIO Card slot support device aw_mmc # Allwinner SD/MMC controller device mmc # mmc/sd bus device mmcsd # mmc/sd flash cards device dwmmc # Serial (COM) ports device uart # Generic UART driver device uart_ns8250 # ns8250-type UART driver device uart_snps device pl011 # USB support options USB_DEBUG # enable debug msgs device aw_ehci # Allwinner EHCI USB interface (USB 2.0) device aw_usbphy # Allwinner USB PHY device dwcotg # DWC OTG controller device ohci # OHCI USB interface device ehci # EHCI USB interface (USB 2.0) device xhci # XHCI PCI->USB interface (USB 3.0) device usb # USB Bus (required) device ukbd # Keyboard device umass # Disks/Mass storage - Requires scbus and da # GPIO device aw_gpio # Allwinner GPIO controller device gpio device fdt_pinctrl # I2C device aw_rsb # Allwinner Reduced Serial Bus device iicbus # Clock and reset controllers device aw_ccu # Allwinner clock controller # Interrupt controllers device aw_nmi # Allwinner NMI support # Real-time clock support device aw_rtc # Allwinner Real-time Clock # Watchdog controllers device aw_wdog # Allwinner Watchdog # Power management controllers device axp81x # X-Powers AXP81x PMIC +# EFUSE +device aw_sid # Allwinner Secure ID EFUSE + +# Thermal sensors +device aw_thermal # Allwinner Thermal Sensor Controller + # Pseudo devices. device loop # Network loopback device random # Entropy device device ether # Ethernet support device vlan # 802.1Q VLAN support device tun # Packet tunnel. device md # Memory "disks" device gif # IPv6 and IPv4 tunneling device firmware # firmware assist module device psci # Support for ARM PSCI # EXT_RESOURCES pseudo devices options EXT_RESOURCES device clk device phy device hwreset device regulator # The `bpf' device enables the Berkeley Packet Filter. # Be aware of the administrative consequences of enabling this! # Note that 'bpf' is required for DHCP. device bpf # Berkeley packet filter # Chip-specific errata options THUNDERX_PASS_1_1_ERRATA options FDT #device acpi # The crypto framework is required by IPSEC device crypto # Required by IPSEC Index: head/sys/conf/files.arm64 =================================================================== --- head/sys/conf/files.arm64 (revision 305351) +++ head/sys/conf/files.arm64 (revision 305352) @@ -1,138 +1,141 @@ # $FreeBSD$ cloudabi64_vdso.o optional compat_cloudabi64 \ dependency "$S/contrib/cloudabi/cloudabi_vdso_aarch64.S" \ compile-with "${CC} -x assembler-with-cpp -shared -nostdinc -nostdlib -Wl,-T$S/compat/cloudabi/cloudabi_vdso.lds $S/contrib/cloudabi/cloudabi_vdso_aarch64.S -o ${.TARGET}" \ no-obj no-implicit-rule \ clean "cloudabi64_vdso.o" # cloudabi64_vdso_blob.o optional compat_cloudabi64 \ dependency "cloudabi64_vdso.o" \ compile-with "${OBJCOPY} --input-target binary --output-target elf64-littleaarch64 --binary-architecture aarch64 cloudabi64_vdso.o ${.TARGET}" \ no-implicit-rule \ clean "cloudabi64_vdso_blob.o" # arm/allwinner/a10_ehci.c optional ehci aw_ehci arm/allwinner/a10_gpio.c optional gpio aw_gpio arm/allwinner/a10_mmc.c optional mmc aw_mmc arm/allwinner/a64/a64_padconf.c optional soc_allwinner_a64 arm/allwinner/a64/a64_r_padconf.c optional soc_allwinner_a64 arm/allwinner/aw_ccu.c optional aw_ccu arm/allwinner/aw_nmi.c optional aw_nmi \ compile-with "${NORMAL_C} -I$S/gnu/dts/include" arm/allwinner/aw_reset.c optional aw_ccu arm/allwinner/aw_rsb.c optional aw_rsb arm/allwinner/aw_rtc.c optional aw_rtc +arm/allwinner/aw_sid.c optional aw_sid +arm/allwinner/aw_thermal.c optional aw_thermal arm/allwinner/aw_usbphy.c optional ehci aw_usbphy arm/allwinner/aw_wdog.c optional aw_wdog arm/allwinner/axp81x.c optional axp81x arm/allwinner/clk/aw_ahbclk.c optional aw_ccu arm/allwinner/clk/aw_apbclk.c optional aw_ccu arm/allwinner/clk/aw_axiclk.c optional aw_ccu arm/allwinner/clk/aw_cpuclk.c optional aw_ccu arm/allwinner/clk/aw_gate.c optional aw_ccu arm/allwinner/clk/aw_modclk.c optional aw_ccu arm/allwinner/clk/aw_pll.c optional aw_ccu \ compile-with "${NORMAL_C} -I$S/gnu/dts/include" +arm/allwinner/clk/aw_thsclk.c optional aw_ccu arm/allwinner/clk/aw_usbclk.c optional aw_ccu arm/allwinner/if_awg.c optional awg arm/arm/generic_timer.c standard arm/arm/gic.c standard arm/arm/gic_fdt.c optional fdt arm/arm/pmu.c standard arm64/acpica/acpi_machdep.c optional acpi arm64/acpica/OsdEnvironment.c optional acpi arm64/acpica/acpi_wakeup.c optional acpi arm64/acpica/pci_cfgreg.c optional acpi pci arm64/arm64/autoconf.c standard arm64/arm64/bcopy.c standard arm64/arm64/bus_machdep.c standard arm64/arm64/bus_space_asm.S standard arm64/arm64/busdma_bounce.c standard arm64/arm64/busdma_machdep.c standard arm64/arm64/bzero.S standard arm64/arm64/clock.c standard arm64/arm64/copyinout.S standard arm64/arm64/copystr.c standard arm64/arm64/cpufunc_asm.S standard arm64/arm64/db_disasm.c optional ddb arm64/arm64/db_interface.c optional ddb arm64/arm64/db_trace.c optional ddb arm64/arm64/debug_monitor.c optional kdb arm64/arm64/disassem.c optional ddb arm64/arm64/dump_machdep.c standard arm64/arm64/elf_machdep.c standard arm64/arm64/exception.S standard arm64/arm64/gicv3_its.c optional intrng arm64/arm64/gic_v3.c standard arm64/arm64/gic_v3_fdt.c optional fdt arm64/arm64/identcpu.c standard arm64/arm64/in_cksum.c optional inet | inet6 arm64/arm64/locore.S standard no-obj arm64/arm64/machdep.c standard arm64/arm64/mem.c standard arm64/arm64/minidump_machdep.c standard arm64/arm64/mp_machdep.c optional smp arm64/arm64/nexus.c standard arm64/arm64/ofw_machdep.c optional fdt arm64/arm64/pmap.c standard arm64/arm64/stack_machdep.c optional ddb | stack arm64/arm64/support.S standard arm64/arm64/swtch.S standard arm64/arm64/sys_machdep.c standard arm64/arm64/trap.c standard arm64/arm64/uio_machdep.c standard arm64/arm64/uma_machdep.c standard arm64/arm64/unwind.c optional ddb | kdtrace_hooks | stack arm64/arm64/vfp.c standard arm64/arm64/vm_machdep.c standard arm64/cavium/thunder_pcie_fdt.c optional soc_cavm_thunderx pci fdt arm64/cavium/thunder_pcie_pem.c optional soc_cavm_thunderx pci arm64/cavium/thunder_pcie_pem_fdt.c optional soc_cavm_thunderx pci fdt arm64/cavium/thunder_pcie_common.c optional soc_cavm_thunderx pci arm64/cloudabi64/cloudabi64_sysvec.c optional compat_cloudabi64 crypto/blowfish/bf_enc.c optional crypto | ipsec crypto/des/des_enc.c optional crypto | ipsec | netsmb dev/acpica/acpi_if.m optional acpi dev/ahci/ahci_generic.c optional ahci fdt dev/hwpmc/hwpmc_arm64.c optional hwpmc dev/hwpmc/hwpmc_arm64_md.c optional hwpmc dev/mmc/host/dwmmc.c optional dwmmc fdt dev/mmc/host/dwmmc_hisi.c optional dwmmc fdt soc_hisi_hi6220 dev/ofw/ofw_cpu.c optional fdt dev/ofw/ofwpci.c optional fdt pci dev/pci/pci_host_generic.c optional pci fdt dev/psci/psci.c optional psci dev/psci/psci_arm64.S optional psci dev/uart/uart_cpu_fdt.c optional uart fdt dev/uart/uart_dev_pl011.c optional uart pl011 dev/usb/controller/dwc_otg_hisi.c optional dwcotg fdt soc_hisi_hi6220 dev/usb/controller/generic_ehci.c optional ehci acpi dev/usb/controller/generic_ohci.c optional ohci fdt dev/usb/controller/generic_usb_if.m optional ohci fdt dev/vnic/mrml_bridge.c optional vnic fdt dev/vnic/nic_main.c optional vnic pci dev/vnic/nicvf_main.c optional vnic pci pci_iov dev/vnic/nicvf_queues.c optional vnic pci pci_iov dev/vnic/thunder_bgx_fdt.c optional vnic fdt dev/vnic/thunder_bgx.c optional vnic pci dev/vnic/thunder_mdio_fdt.c optional vnic fdt dev/vnic/thunder_mdio.c optional vnic dev/vnic/lmac_if.m optional inet | inet6 | vnic kern/kern_clocksource.c standard kern/msi_if.m optional intrng kern/pic_if.m optional intrng kern/subr_devmap.c standard kern/subr_intr.c optional intrng libkern/bcmp.c standard libkern/ffs.c standard libkern/ffsl.c standard libkern/ffsll.c standard libkern/fls.c standard libkern/flsl.c standard libkern/flsll.c standard libkern/memmove.c standard libkern/memset.c standard cddl/contrib/opensolaris/common/atomic/aarch64/opensolaris_atomic.S optional zfs | dtrace compile-with "${CDDL_C}" cddl/dev/dtrace/aarch64/dtrace_asm.S optional dtrace compile-with "${DTRACE_S}" cddl/dev/dtrace/aarch64/dtrace_subr.c optional dtrace compile-with "${DTRACE_C}" cddl/dev/fbt/aarch64/fbt_isa.c optional dtrace_fbt | dtraceall compile-with "${FBT_C}"