1 /* 2 * Common definitions and adapter function signatures for access to 3 * board-specific functionality. 4 * 5 * Copyright (C) 2023, 2024 Paul Boddie <paul@boddie.org.uk> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as 9 * published by the Free Software Foundation; either version 2 of 10 * the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 20 * Boston, MA 02110-1301, USA 21 */ 22 23 #pragma once 24 25 #include <l4/re/c/dma_space.h> 26 #include <l4/sys/types.h> 27 #include <l4/devices/clocks.h> 28 #include <l4/devices/gpio.h> 29 #include <stdint.h> 30 31 32 33 /* AIC adapter functions. */ 34 35 void *aic_init(l4_addr_t aic_start, l4_addr_t start, l4_addr_t end, void *cpm); 36 37 void *aic_get_channel(void *aic, int num, void *channel); 38 39 unsigned int aic_transfer(void *channel, l4re_dma_space_dma_addr_t paddr, 40 uint32_t count, uint32_t sample_rate, 41 uint8_t sample_size); 42 43 44 45 /* CPM adapter functions. */ 46 47 void *cpm_init(l4_addr_t cpm_base); 48 49 const char *cpm_clock_type(void *cpm, enum Clock_identifiers clock); 50 51 int cpm_have_clock(void *cpm, enum Clock_identifiers clock); 52 53 void cpm_start_clock(void *cpm, enum Clock_identifiers clock); 54 55 void cpm_stop_clock(void *cpm, enum Clock_identifiers clock); 56 57 int cpm_get_parameters(void *cpm, enum Clock_identifiers clock, 58 uint32_t parameters[]); 59 60 int cpm_set_parameters(void *cpm, enum Clock_identifiers clock, 61 int num_parameters, uint32_t parameters[]); 62 63 uint8_t cpm_get_source(void *cpm, enum Clock_identifiers clock); 64 65 void cpm_set_source(void *cpm, enum Clock_identifiers clock, uint8_t source); 66 67 enum Clock_identifiers cpm_get_source_clock(void *cpm, enum Clock_identifiers clock); 68 69 void cpm_set_source_clock(void *cpm, enum Clock_identifiers clock, 70 enum Clock_identifiers source); 71 72 uint64_t cpm_get_source_frequency(void *cpm, enum Clock_identifiers clock); 73 74 uint64_t cpm_get_frequency(void *cpm, enum Clock_identifiers clock); 75 76 int cpm_set_frequency(void *cpm, enum Clock_identifiers clock, uint64_t frequency); 77 78 79 80 /* DMA adapter functions. */ 81 82 void *dma_init(l4_addr_t start, l4_addr_t end, void *cpm); 83 84 void dma_disable(void *dma_chip); 85 86 void dma_enable(void *dma_chip); 87 88 void *dma_get_channel(void *dma, uint8_t channel, l4_cap_idx_t irq); 89 90 unsigned int dma_transfer(void *dma_channel, 91 uint32_t source, uint32_t destination, 92 unsigned int count, 93 int source_increment, int destination_increment, 94 uint8_t source_width, uint8_t destination_width, 95 uint8_t transfer_unit_size, 96 int type); 97 98 unsigned int dma_wait(void *dma_channel); 99 100 101 102 /* GPIO adapter functions. */ 103 104 void *gpio_init(l4_addr_t start, l4_addr_t end, unsigned pins, 105 l4_uint32_t pull_ups, l4_uint32_t pull_downs); 106 107 void gpio_setup(void *gpio, unsigned pin, unsigned mode, int value); 108 109 void gpio_config_pull(void *gpio, unsigned pin, unsigned mode); 110 111 void gpio_config_pad(void *gpio, unsigned pin, unsigned func, unsigned value); 112 113 void gpio_config_get(void *gpio, unsigned pin, unsigned reg, unsigned *value); 114 115 void gpio_config_pad_get(void *gpio, unsigned pin, unsigned *func, unsigned *value); 116 117 void gpio_multi_setup(void *gpio, Pin_slice const *mask, unsigned mode, unsigned outvalues); 118 119 void gpio_multi_config_pad(void *gpio, Pin_slice const *mask, unsigned func, unsigned value); 120 121 void gpio_multi_set(void *gpio, Pin_slice const *mask, unsigned data); 122 123 unsigned gpio_multi_get(void *gpio, unsigned offset); 124 125 int gpio_get(void *gpio, unsigned pin); 126 127 void gpio_set(void *gpio, unsigned pin, int value); 128 129 void *gpio_get_irq(void *gpio, unsigned pin); 130 131 bool gpio_irq_set_mode(void *gpio_irq, unsigned mode); 132 133 134 135 /* I2C adapter functions. */ 136 137 void *i2c_init(l4_addr_t start, l4_addr_t end, void *cpm, uint32_t frequency); 138 139 void *i2c_get_channel(void *i2c, uint8_t channel); 140 141 uint32_t i2c_get_frequency(void *i2c_channel); 142 143 void i2c_set_target(void *i2c_channel, uint8_t addr); 144 145 void i2c_start_read(void *i2c_channel, uint8_t buf[], unsigned int total, 146 int stop); 147 148 void i2c_read(void *i2c_channel); 149 150 void i2c_start_write(void *i2c_channel, uint8_t buf[], unsigned int total, 151 int stop); 152 153 void i2c_write(void *i2c_channel); 154 155 int i2c_read_done(void *i2c_channel); 156 157 int i2c_write_done(void *i2c_channel); 158 159 unsigned int i2c_have_read(void *i2c_channel); 160 161 unsigned int i2c_have_written(void *i2c_channel); 162 163 int i2c_failed(void *i2c_channel); 164 165 void i2c_stop(void *i2c_channel); 166 167 168 169 /* RTC adapter functions. */ 170 171 void *rtc_init(l4_addr_t start, void *cpm); 172 173 void rtc_disable(void *rtc); 174 175 void rtc_enable(void *rtc); 176 177 void rtc_alarm_disable(void *rtc); 178 179 void rtc_alarm_enable(void *rtc); 180 181 uint32_t rtc_get_seconds(void *rtc); 182 183 void rtc_set_seconds(void *rtc, uint32_t seconds); 184 185 uint32_t rtc_get_alarm_seconds(void *rtc); 186 187 void rtc_set_alarm_seconds(void *rtc, uint32_t seconds); 188 189 void rtc_hibernate(void *rtc); 190 191 void rtc_power_down(void *rtc); 192 193 void rtc_set_regulator(void *rtc, uint32_t base, uint32_t adjustment); 194 195 196 197 /* SPI adapter functions. */ 198 199 void *spi_init(l4_addr_t spi_start, l4_addr_t start, l4_addr_t end, void *cpm); 200 201 void *spi_get_channel(void *spi, uint8_t num, void *channel, uint64_t frequency, 202 void *control_chip, int control_pin, int control_alt_func); 203 204 void *spi_get_channel_gpio(uint64_t frequency, 205 void *clock_chip, int clock_pin, 206 void *data_chip, int data_pin, 207 void *enable_chip, int enable_pin, 208 void *control_chip, int control_pin); 209 210 void spi_acquire_control(void *channel, int level); 211 212 void spi_release_control(void *channel); 213 214 void spi_send(void *channel, uint32_t bytes, const uint8_t data[]); 215 216 void spi_send_units(void *channel, uint32_t bytes, const uint8_t data[], 217 uint8_t unit_size, uint8_t char_size, int big_endian); 218 219 uint32_t spi_transfer(void *channel, l4_addr_t vaddr, 220 l4re_dma_space_dma_addr_t paddr, uint32_t count, 221 uint8_t unit_size, uint8_t char_size, 222 l4_addr_t desc_vaddr, l4re_dma_space_dma_addr_t desc_paddr); 223 224 225 226 /* TCU adapter functions. */ 227 228 void *tcu_init(l4_addr_t start, l4_addr_t end); 229 230 void *tcu_get_channel(void *tcu, uint8_t channel, l4_cap_idx_t irq); 231 232 void tcu_disable(void *tcu_channel); 233 234 void tcu_enable(void *tcu_channel); 235 236 int tcu_is_enabled(void *tcu_channel); 237 238 uint8_t tcu_get_clock(void *tcu_channel); 239 240 void tcu_set_clock(void *tcu_channel, uint8_t clock); 241 242 uint32_t tcu_get_prescale(void *tcu_channel); 243 244 void tcu_set_prescale(void *tcu_channel, uint32_t prescale); 245 246 uint32_t tcu_get_counter(void *tcu_channel); 247 248 void tcu_set_counter(void *tcu_channel, uint32_t value); 249 250 uint8_t tcu_get_count_mode(void *tcu_channel); 251 252 void tcu_set_count_mode(void *tcu_channel, uint8_t mode); 253 254 uint32_t tcu_get_full_data_value(void *tcu_channel); 255 256 void tcu_set_full_data_value(void *tcu_channel, uint32_t value); 257 258 uint32_t tcu_get_half_data_value(void *tcu_channel); 259 260 void tcu_set_half_data_value(void *tcu_channel, uint32_t value); 261 262 int tcu_get_full_data_mask(void *tcu_channel); 263 264 void tcu_set_full_data_mask(void *tcu_channel, int masked); 265 266 int tcu_get_half_data_mask(void *tcu_channel); 267 268 void tcu_set_half_data_mask(void *tcu_channel, int masked); 269 270 int tcu_have_interrupt(void *tcu_channel); 271 272 int tcu_wait_for_irq(void *tcu_channel, uint32_t timeout); 273 274 275 276 /* Memory regions. */ 277 278 enum memory_regions 279 { 280 AIC, CPM, DMA, GPIO, I2C, RTC, SSI, TCU 281 }; 282 283 284 285 /* CPM definitions. */ 286 287 struct clock_info 288 { 289 const char *id; 290 enum Clock_identifiers clock; 291 const char *name; 292 }; 293 294 295 296 /* DMA definitions. */ 297 298 struct dma_region 299 { 300 unsigned int size; 301 unsigned int align; 302 l4_addr_t vaddr; 303 l4re_dma_space_dma_addr_t paddr; 304 l4_cap_idx_t mem; 305 }; 306 307 308 309 /* GPIO definitions. */ 310 311 struct gpio_port 312 { 313 const uint32_t pull_ups, pull_downs; 314 }; 315 316 317 318 /* Memory definitions. */ 319 320 struct memory_region 321 { 322 unsigned int size; 323 l4_addr_t addr; 324 };