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/devices/clocks.h> 26 #include <l4/devices/dma.h> 27 #include <l4/devices/gpio.h> 28 #include <l4/sys/types.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 /* MSC adapter functions. */ 170 171 void *msc_init(l4_addr_t msc_start, l4_addr_t start, l4_addr_t end, void *cpm); 172 173 void *msc_get_channel(void *msc, uint8_t channel, l4_cap_idx_t irq, void *dma); 174 175 struct msc_card *msc_get_cards(void *msc_channel); 176 177 uint8_t msc_num_cards(void *msc_channel); 178 179 void msc_enable(void *msc_channel); 180 181 uint32_t msc_read_blocks(void *msc_channel, uint8_t card, 182 struct dma_region *region, 183 uint32_t block_address, uint32_t block_count); 184 185 186 187 /* RTC adapter functions. */ 188 189 void *rtc_init(l4_addr_t start, void *cpm); 190 191 void rtc_disable(void *rtc); 192 193 void rtc_enable(void *rtc); 194 195 void rtc_alarm_disable(void *rtc); 196 197 void rtc_alarm_enable(void *rtc); 198 199 uint32_t rtc_get_seconds(void *rtc); 200 201 void rtc_set_seconds(void *rtc, uint32_t seconds); 202 203 uint32_t rtc_get_alarm_seconds(void *rtc); 204 205 void rtc_set_alarm_seconds(void *rtc, uint32_t seconds); 206 207 void rtc_hibernate(void *rtc); 208 209 void rtc_power_down(void *rtc); 210 211 void rtc_set_regulator(void *rtc, uint32_t base, uint32_t adjustment); 212 213 214 215 /* SPI adapter functions. */ 216 217 void *spi_init(l4_addr_t spi_start, l4_addr_t start, l4_addr_t end, void *cpm); 218 219 void *spi_get_channel(void *spi, uint8_t num, void *channel, uint64_t frequency, 220 void *control_chip, int control_pin, int control_alt_func); 221 222 void *spi_get_channel_gpio(uint64_t frequency, 223 void *clock_chip, int clock_pin, 224 void *data_chip, int data_pin, 225 void *enable_chip, int enable_pin, 226 void *control_chip, int control_pin); 227 228 void spi_acquire_control(void *channel, int level); 229 230 void spi_release_control(void *channel); 231 232 void spi_send(void *channel, uint32_t bytes, const uint8_t data[]); 233 234 void spi_send_units(void *channel, uint32_t bytes, const uint8_t data[], 235 uint8_t unit_size, uint8_t char_size, int big_endian); 236 237 uint32_t spi_transfer(void *channel, l4_addr_t vaddr, 238 l4re_dma_space_dma_addr_t paddr, uint32_t count, 239 uint8_t unit_size, uint8_t char_size, 240 l4_addr_t desc_vaddr, l4re_dma_space_dma_addr_t desc_paddr); 241 242 243 244 /* TCU adapter functions. */ 245 246 void *tcu_init(l4_addr_t start, l4_addr_t end); 247 248 void *tcu_get_channel(void *tcu, uint8_t channel, l4_cap_idx_t irq); 249 250 void tcu_disable(void *tcu_channel); 251 252 void tcu_enable(void *tcu_channel); 253 254 int tcu_is_enabled(void *tcu_channel); 255 256 uint8_t tcu_get_clock(void *tcu_channel); 257 258 void tcu_set_clock(void *tcu_channel, uint8_t clock); 259 260 uint32_t tcu_get_prescale(void *tcu_channel); 261 262 void tcu_set_prescale(void *tcu_channel, uint32_t prescale); 263 264 uint32_t tcu_get_counter(void *tcu_channel); 265 266 void tcu_set_counter(void *tcu_channel, uint32_t value); 267 268 uint8_t tcu_get_count_mode(void *tcu_channel); 269 270 void tcu_set_count_mode(void *tcu_channel, uint8_t mode); 271 272 uint32_t tcu_get_full_data_value(void *tcu_channel); 273 274 void tcu_set_full_data_value(void *tcu_channel, uint32_t value); 275 276 uint32_t tcu_get_half_data_value(void *tcu_channel); 277 278 void tcu_set_half_data_value(void *tcu_channel, uint32_t value); 279 280 int tcu_get_full_data_mask(void *tcu_channel); 281 282 void tcu_set_full_data_mask(void *tcu_channel, int masked); 283 284 int tcu_get_half_data_mask(void *tcu_channel); 285 286 void tcu_set_half_data_mask(void *tcu_channel, int masked); 287 288 int tcu_have_interrupt(void *tcu_channel); 289 290 int tcu_wait_for_irq(void *tcu_channel, uint32_t timeout); 291 292 293 294 /* Memory regions. */ 295 296 enum memory_regions 297 { 298 AIC, CPM, DMA, GPIO, I2C, MSC, RTC, SSI, TCU 299 }; 300 301 302 303 /* CPM definitions. */ 304 305 struct clock_info 306 { 307 const char *id; 308 enum Clock_identifiers clock; 309 const char *name; 310 }; 311 312 313 314 /* GPIO definitions. */ 315 316 struct gpio_port 317 { 318 const uint32_t pull_ups, pull_downs; 319 }; 320 321 322 323 /* Memory definitions. */ 324 325 struct memory_region 326 { 327 unsigned int size; 328 l4_addr_t addr; 329 };