?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
LP-500 HoTT Telemetry added device definitions
[librepilot.git] / flight / targets / boards / discoveryf4bare / board_hw_defs.c
blob0c833776b6b5a2ee8988d6df3f19da17bf2bab95
1 /**
2 ******************************************************************************
3 * @file board_hw_defs.c
4 * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012.
5 * @author PhoenixPilot, http://github.com/PhoenixPilot, Copyright (C) 2012
6 * @addtogroup OpenPilotSystem OpenPilot System
7 * @{
8 * @addtogroup OpenPilotCore OpenPilot Core
9 * @{
10 * @brief Defines board specific static initializers for hardware for the Revolution board.
11 *****************************************************************************/
12 /*
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 3 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
20 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 * for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28 #if defined(PIOS_INCLUDE_LED)
29
30 #include <pios_led_priv.h>
31 static const struct pios_gpio pios_leds[] = {
32 [PIOS_LED_HEARTBEAT] = {
33 .pin = {
34 .gpio = GPIOD,
35 .init = {
36 .GPIO_Pin = GPIO_Pin_15,
37 .GPIO_Speed = GPIO_Speed_50MHz,
38 .GPIO_Mode = GPIO_Mode_OUT,
39 .GPIO_OType = GPIO_OType_PP,
40 .GPIO_PuPd = GPIO_PuPd_UP
41 },
42 },
43 .active_low = false
44 },
45 [PIOS_LED_ALARM] = {
46 .pin = {
47 .gpio = GPIOD,
48 .init = {
49 .GPIO_Pin = GPIO_Pin_14,
50 .GPIO_Speed = GPIO_Speed_50MHz,
51 .GPIO_Mode = GPIO_Mode_OUT,
52 .GPIO_OType = GPIO_OType_PP,
53 .GPIO_PuPd = GPIO_PuPd_UP
54 },
55 },
56 .active_low = false
57 },
58 [PIOS_LED_D1] = {
59 .pin = {
60 .gpio = GPIOD,
61 .init = {
62 .GPIO_Pin = GPIO_Pin_13,
63 .GPIO_Speed = GPIO_Speed_50MHz,
64 .GPIO_Mode = GPIO_Mode_OUT,
65 .GPIO_OType = GPIO_OType_PP,
66 .GPIO_PuPd = GPIO_PuPd_UP
67 },
68 },
69 .active_low = false
70 },
71 [PIOS_LED_D2] = {
72 .pin = {
73 .gpio = GPIOD,
74 .init = {
75 .GPIO_Pin = GPIO_Pin_12,
76 .GPIO_Speed = GPIO_Speed_50MHz,
77 .GPIO_Mode = GPIO_Mode_OUT,
78 .GPIO_OType = GPIO_OType_PP,
79 .GPIO_PuPd = GPIO_PuPd_UP
80 },
81 },
82 .active_low = false
83 },
84 };
85
86 static const struct pios_gpio_cfg pios_led_cfg = {
87 .gpios = pios_leds,
88 .num_gpios = NELEMENTS(pios_leds),
89 };
90
91
92 const struct pios_gpio_cfg *PIOS_BOARD_HW_DEFS_GetLedCfg(__attribute__((unused)) uint32_t board_revision)
93 {
94 return &pios_led_cfg;
95 }
96
97 #endif /* PIOS_INCLUDE_LED */
98
99 #if defined(PIOS_INCLUDE_SPI)
100 #include <pios_spi_priv.h>
101
102 #if defined(PIOS_OVERO_SPI)
103 /* SPI2 Interface
104 * - Used for Flexi/IO/Overo communications
105 3: PB12 = SPI2 NSS, CAN2 RX
106 4: PB13 = SPI2 SCK, CAN2 TX, USART3 CTS
107 5: PB14 = SPI2 MISO, TIM12 CH1, USART3 RTS
108 6: PB15 = SPI2 MOSI, TIM12 CH2
109 */
110 #include <pios_overo_priv.h>
111 void PIOS_OVERO_irq_handler(void);
112 void DMA1_Stream7_IRQHandler(void) __attribute__((alias("PIOS_OVERO_irq_handler")));
113 static const struct pios_overo_cfg pios_overo_cfg = {
114 .regs = SPI2,
115 .remap = GPIO_AF_SPI2,
116 .init = {
117 .SPI_Mode = SPI_Mode_Slave,
118 .SPI_Direction = SPI_Direction_2Lines_FullDuplex,
119 .SPI_DataSize = SPI_DataSize_8b,
120 .SPI_NSS = SPI_NSS_Hard,
121 .SPI_FirstBit = SPI_FirstBit_MSB,
122 .SPI_CRCPolynomial = 7,
123 .SPI_CPOL = SPI_CPOL_High,
124 .SPI_CPHA = SPI_CPHA_2Edge,
125 .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2,
126 },
127 .use_crc = false,
128 .dma = {
129 .irq = {
130 // Note this is the stream ID that triggers interrupts (in this case TX)
131 .flags = (DMA_IT_TCIF7),
132 .init = {
133 .NVIC_IRQChannel = DMA1_Stream7_IRQn,
134 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
135 .NVIC_IRQChannelSubPriority = 0,
136 .NVIC_IRQChannelCmd = ENABLE,
137 },
138 },
139
140 .rx = {
141 .channel = DMA1_Stream0,
142 .init = {
143 .DMA_Channel = DMA_Channel_0,
144 .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR),
145 .DMA_DIR = DMA_DIR_PeripheralToMemory,
146 .DMA_PeripheralInc = DMA_PeripheralInc_Disable,
147 .DMA_MemoryInc = DMA_MemoryInc_Enable,
148 .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
149 .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte,
150 .DMA_Mode = DMA_Mode_Circular,
151 .DMA_Priority = DMA_Priority_Medium,
152 // TODO: Enable FIFO
153 .DMA_FIFOMode = DMA_FIFOMode_Disable,
154 .DMA_FIFOThreshold = DMA_FIFOThreshold_Full,
155 .DMA_MemoryBurst = DMA_MemoryBurst_Single,
156 .DMA_PeripheralBurst = DMA_PeripheralBurst_Single,
157 },
158 },
159 .tx = {
160 .channel = DMA1_Stream7,
161 .init = {
162 .DMA_Channel = DMA_Channel_0,
163 .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR),
164 .DMA_DIR = DMA_DIR_MemoryToPeripheral,
165 .DMA_PeripheralInc = DMA_PeripheralInc_Disable,
166 .DMA_MemoryInc = DMA_MemoryInc_Enable,
167 .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
168 .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte,
169 .DMA_Mode = DMA_Mode_Circular,
170 .DMA_Priority = DMA_Priority_Medium,
171 .DMA_FIFOMode = DMA_FIFOMode_Disable,
172 .DMA_FIFOThreshold = DMA_FIFOThreshold_Full,
173 .DMA_MemoryBurst = DMA_MemoryBurst_Single,
174 .DMA_PeripheralBurst = DMA_PeripheralBurst_Single,
175 },
176 },
177 },
178 .sclk = {
179 .gpio = GPIOB,
180 .init = {
181 .GPIO_Pin = GPIO_Pin_13,
182 .GPIO_Speed = GPIO_Speed_100MHz,
183 .GPIO_Mode = GPIO_Mode_AF,
184 .GPIO_OType = GPIO_OType_PP,
185 .GPIO_PuPd = GPIO_PuPd_NOPULL
186 },
187 },
188 .miso = {
189 .gpio = GPIOB,
190 .init = {
191 .GPIO_Pin = GPIO_Pin_14,
192 .GPIO_Speed = GPIO_Speed_50MHz,
193 .GPIO_Mode = GPIO_Mode_AF,
194 .GPIO_OType = GPIO_OType_PP,
195 .GPIO_PuPd = GPIO_PuPd_NOPULL
196 },
197 },
198 .mosi = {
199 .gpio = GPIOB,
200 .init = {
201 .GPIO_Pin = GPIO_Pin_15,
202 .GPIO_Speed = GPIO_Speed_50MHz,
203 .GPIO_Mode = GPIO_Mode_AF,
204 .GPIO_OType = GPIO_OType_PP,
205 .GPIO_PuPd = GPIO_PuPd_NOPULL
206 },
207 },
208 .slave_count = 1,
209 .ssel = {
210 {
211 .gpio = GPIOB,
212 .init = {
213 .GPIO_Pin = GPIO_Pin_12,
214 .GPIO_Speed = GPIO_Speed_50MHz,
215 .GPIO_Mode = GPIO_Mode_OUT,
216 .GPIO_OType = GPIO_OType_PP,
217 .GPIO_PuPd = GPIO_PuPd_UP
218 },
219 }
220 },
221 };
222 uint32_t pios_overo_id = 0;
223 void PIOS_OVERO_irq_handler(void)
224 {
225 /* Call into the generic code to handle the IRQ for this specific device */
226 PIOS_OVERO_DMA_irq_handler(pios_overo_id);
227 }
228
229 #endif /* PIOS_OVERO_SPI */
230
231 /*
232 * SPI1 Interface
233 * Used for MPU6000 gyro and accelerometer
234 */
235 void PIOS_SPI_gyro_irq_handler(void);
236 void DMA2_Stream0_IRQHandler(void) __attribute__((alias("PIOS_SPI_gyro_irq_handler")));
237 void DMA2_Stream3_IRQHandler(void) __attribute__((alias("PIOS_SPI_gyro_irq_handler")));
238 static const struct pios_spi_cfg pios_spi_gyro_cfg = {
239 .regs = SPI1,
240 .remap = GPIO_AF_SPI1,
241 .init = {
242 .SPI_Mode = SPI_Mode_Master,
243 .SPI_Direction = SPI_Direction_2Lines_FullDuplex,
244 .SPI_DataSize = SPI_DataSize_8b,
245 .SPI_NSS = SPI_NSS_Soft,
246 .SPI_FirstBit = SPI_FirstBit_MSB,
247 .SPI_CRCPolynomial = 7,
248 .SPI_CPOL = SPI_CPOL_High,
249 .SPI_CPHA = SPI_CPHA_2Edge,
250 .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16,
251 },
252 .use_crc = false,
253 .dma = {
254 .irq = {
255 .flags = (DMA_IT_TCIF0 | DMA_IT_TEIF0 | DMA_IT_HTIF0),
256 .init = {
257 .NVIC_IRQChannel = DMA2_Stream0_IRQn,
258 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
259 .NVIC_IRQChannelSubPriority = 0,
260 .NVIC_IRQChannelCmd = ENABLE,
261 },
262 },
263
264 .rx = {
265 .channel = DMA2_Stream0,
266 .init = {
267 .DMA_Channel = DMA_Channel_3,
268 .DMA_PeripheralBaseAddr = (uint32_t)&(SPI1->DR),
269 .DMA_DIR = DMA_DIR_PeripheralToMemory,
270 .DMA_PeripheralInc = DMA_PeripheralInc_Disable,
271 .DMA_MemoryInc = DMA_MemoryInc_Enable,
272 .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
273 .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte,
274 .DMA_Mode = DMA_Mode_Normal,
275 .DMA_Priority = DMA_Priority_Medium,
276 .DMA_FIFOMode = DMA_FIFOMode_Disable,
277 /* .DMA_FIFOThreshold */
278 .DMA_MemoryBurst = DMA_MemoryBurst_Single,
279 .DMA_PeripheralBurst = DMA_PeripheralBurst_Single,
280 },
281 },
282 .tx = {
283 .channel = DMA2_Stream3,
284 .init = {
285 .DMA_Channel = DMA_Channel_3,
286 .DMA_PeripheralBaseAddr = (uint32_t)&(SPI1->DR),
287 .DMA_DIR = DMA_DIR_MemoryToPeripheral,
288 .DMA_PeripheralInc = DMA_PeripheralInc_Disable,
289 .DMA_MemoryInc = DMA_MemoryInc_Enable,
290 .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
291 .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte,
292 .DMA_Mode = DMA_Mode_Normal,
293 .DMA_Priority = DMA_Priority_High,
294 .DMA_FIFOMode = DMA_FIFOMode_Disable,
295 /* .DMA_FIFOThreshold */
296 .DMA_MemoryBurst = DMA_MemoryBurst_Single,
297 .DMA_PeripheralBurst = DMA_PeripheralBurst_Single,
298 },
299 },
300 },
301 .sclk = {
302 .gpio = GPIOA,
303 .init = {
304 .GPIO_Pin = GPIO_Pin_5,
305 .GPIO_Speed = GPIO_Speed_100MHz,
306 .GPIO_Mode = GPIO_Mode_AF,
307 .GPIO_OType = GPIO_OType_PP,
308 .GPIO_PuPd = GPIO_PuPd_UP
309 },
310 },
311 .miso = {
312 .gpio = GPIOA,
313 .init = {
314 .GPIO_Pin = GPIO_Pin_6,
315 .GPIO_Speed = GPIO_Speed_50MHz,
316 .GPIO_Mode = GPIO_Mode_AF,
317 .GPIO_OType = GPIO_OType_PP,
318 .GPIO_PuPd = GPIO_PuPd_UP
319 },
320 },
321 .mosi = {
322 .gpio = GPIOA,
323 .init = {
324 .GPIO_Pin = GPIO_Pin_7,
325 .GPIO_Speed = GPIO_Speed_50MHz,
326 .GPIO_Mode = GPIO_Mode_AF,
327 .GPIO_OType = GPIO_OType_PP,
328 .GPIO_PuPd = GPIO_PuPd_UP
329 },
330 },
331 .slave_count = 1,
332 .ssel = {
333 {
334 .gpio = GPIOA,
335 .init = {
336 .GPIO_Pin = GPIO_Pin_4,
337 .GPIO_Speed = GPIO_Speed_50MHz,
338 .GPIO_Mode = GPIO_Mode_OUT,
339 .GPIO_OType = GPIO_OType_PP,
340 .GPIO_PuPd = GPIO_PuPd_UP
341 }
342 }
343 }
344 };
345
346 static uint32_t pios_spi_gyro_id;
347 void PIOS_SPI_gyro_irq_handler(void)
348 {
349 /* Call into the generic code to handle the IRQ for this specific device */
350 PIOS_SPI_IRQ_Handler(pios_spi_gyro_id);
351 }
352
353
354 #if false
355 /*
356 * SPI3 Interface
357 * Used for Flash and the RFM22B
358 */
359 void PIOS_SPI_telem_flash_irq_handler(void);
360 void DMA1_Stream0_IRQHandler(void) __attribute__((alias("PIOS_SPI_telem_flash_irq_handler")));
361 void DMA1_Stream5_IRQHandler(void) __attribute__((alias("PIOS_SPI_telem_flash_irq_handler")));
362 static const struct pios_spi_cfg pios_spi_telem_flash_cfg = {
363 .regs = SPI3,
364 .remap = GPIO_AF_SPI3,
365 .init = {
366 .SPI_Mode = SPI_Mode_Master,
367 .SPI_Direction = SPI_Direction_2Lines_FullDuplex,
368 .SPI_DataSize = SPI_DataSize_8b,
369 .SPI_NSS = SPI_NSS_Soft,
370 .SPI_FirstBit = SPI_FirstBit_MSB,
371 .SPI_CRCPolynomial = 7,
372 .SPI_CPOL = SPI_CPOL_Low,
373 .SPI_CPHA = SPI_CPHA_1Edge,
374 .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8,
375 },
376 .use_crc = false,
377 .dma = {
378 .irq = {
379 // Note this is the stream ID that triggers interrupts (in this case RX)
380 .flags = (DMA_IT_TCIF0 | DMA_IT_TEIF0 | DMA_IT_HTIF0),
381 .init = {
382 .NVIC_IRQChannel = DMA1_Stream0_IRQn,
383 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
384 .NVIC_IRQChannelSubPriority = 0,
385 .NVIC_IRQChannelCmd = ENABLE,
386 },
387 },
388
389 .rx = {
390 .channel = DMA1_Stream0,
391 .init = {
392 .DMA_Channel = DMA_Channel_0,
393 .DMA_PeripheralBaseAddr = (uint32_t)&(SPI3->DR),
394 .DMA_DIR = DMA_DIR_PeripheralToMemory,
395 .DMA_PeripheralInc = DMA_PeripheralInc_Disable,
396 .DMA_MemoryInc = DMA_MemoryInc_Enable,
397 .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
398 .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte,
399 .DMA_Mode = DMA_Mode_Normal,
400 .DMA_Priority = DMA_Priority_Medium,
401 // TODO: Enable FIFO
402 .DMA_FIFOMode = DMA_FIFOMode_Disable,
403 .DMA_FIFOThreshold = DMA_FIFOThreshold_Full,
404 .DMA_MemoryBurst = DMA_MemoryBurst_Single,
405 .DMA_PeripheralBurst = DMA_PeripheralBurst_Single,
406 },
407 },
408 .tx = {
409 .channel = DMA1_Stream5,
410 .init = {
411 .DMA_Channel = DMA_Channel_0,
412 .DMA_PeripheralBaseAddr = (uint32_t)&(SPI3->DR),
413 .DMA_DIR = DMA_DIR_MemoryToPeripheral,
414 .DMA_PeripheralInc = DMA_PeripheralInc_Disable,
415 .DMA_MemoryInc = DMA_MemoryInc_Enable,
416 .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
417 .DMA_MemoryDataSize = DMA_MemoryDataSize_Byte,
418 .DMA_Mode = DMA_Mode_Normal,
419 .DMA_Priority = DMA_Priority_Medium,
420 .DMA_FIFOMode = DMA_FIFOMode_Disable,
421 .DMA_FIFOThreshold = DMA_FIFOThreshold_Full,
422 .DMA_MemoryBurst = DMA_MemoryBurst_Single,
423 .DMA_PeripheralBurst = DMA_PeripheralBurst_Single,
424 },
425 },
426 },
427 .sclk = {
428 .gpio = GPIOC,
429 .init = {
430 .GPIO_Pin = GPIO_Pin_10,
431 .GPIO_Speed = GPIO_Speed_100MHz,
432 .GPIO_Mode = GPIO_Mode_AF,
433 .GPIO_OType = GPIO_OType_PP,
434 .GPIO_PuPd = GPIO_PuPd_NOPULL
435 },
436 },
437 .miso = {
438 .gpio = GPIOC,
439 .init = {
440 .GPIO_Pin = GPIO_Pin_11,
441 .GPIO_Speed = GPIO_Speed_50MHz,
442 .GPIO_Mode = GPIO_Mode_AF,
443 .GPIO_OType = GPIO_OType_PP,
444 .GPIO_PuPd = GPIO_PuPd_NOPULL
445 },
446 },
447 .mosi = {
448 .gpio = GPIOC,
449 .init = {
450 .GPIO_Pin = GPIO_Pin_12,
451 .GPIO_Speed = GPIO_Speed_50MHz,
452 .GPIO_Mode = GPIO_Mode_AF,
453 .GPIO_OType = GPIO_OType_PP,
454 .GPIO_PuPd = GPIO_PuPd_NOPULL
455 },
456 },
457 .slave_count = 2,
458 .ssel = {
459 { // RFM22b
460 .gpio = GPIOA,
461 .init = {
462 .GPIO_Pin = GPIO_Pin_15,
463 .GPIO_Speed = GPIO_Speed_50MHz,
464 .GPIO_Mode = GPIO_Mode_OUT,
465 .GPIO_OType = GPIO_OType_PP,
466 .GPIO_PuPd = GPIO_PuPd_UP
467 }
468 },
469 { // Flash
470 .gpio = GPIOB,
471 .init = {
472 .GPIO_Pin = GPIO_Pin_3,
473 .GPIO_Speed = GPIO_Speed_50MHz,
474 .GPIO_Mode = GPIO_Mode_OUT,
475 .GPIO_OType = GPIO_OType_PP,
476 .GPIO_PuPd = GPIO_PuPd_UP
477 }
478 },
479 },
480 };
481
482 uint32_t pios_spi_telem_flash_id;
483 void PIOS_SPI_telem_flash_irq_handler(void)
484 {
485 /* Call into the generic code to handle the IRQ for this specific device */
486 PIOS_SPI_IRQ_Handler(pios_spi_telem_flash_id);
487 }
488
489
490 #if defined(PIOS_INCLUDE_RFM22B)
491 #include <pios_rfm22b_priv.h>
492
493 static const struct pios_exti_cfg pios_exti_rfm22b_cfg __exti_config = {
494 .vector = PIOS_RFM22_EXT_Int,
495 .line = EXTI_Line2,
496 .pin = {
497 .gpio = GPIOD,
498 .init = {
499 .GPIO_Pin = GPIO_Pin_2,
500 .GPIO_Speed = GPIO_Speed_100MHz,
501 .GPIO_Mode = GPIO_Mode_IN,
502 .GPIO_OType = GPIO_OType_OD,
503 .GPIO_PuPd = GPIO_PuPd_NOPULL,
504 },
505 },
506 .irq = {
507 .init = {
508 .NVIC_IRQChannel = EXTI2_IRQn,
509 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_LOW,
510 .NVIC_IRQChannelSubPriority = 0,
511 .NVIC_IRQChannelCmd = ENABLE,
512 },
513 },
514 .exti = {
515 .init = {
516 .EXTI_Line = EXTI_Line2, // matches above GPIO pin
517 .EXTI_Mode = EXTI_Mode_Interrupt,
518 .EXTI_Trigger = EXTI_Trigger_Falling,
519 .EXTI_LineCmd = ENABLE,
520 },
521 },
522 };
523
524 const struct pios_rfm22b_cfg pios_rfm22b_rm1_cfg = {
525 .spi_cfg = &pios_spi_telem_flash_cfg,
526 .exti_cfg = &pios_exti_rfm22b_cfg,
527 .RFXtalCap = 0x7f,
528 .slave_num = 0,
529 .gpio_direction = GPIO0_RX_GPIO1_TX,
530 };
531
532 const struct pios_rfm22b_cfg pios_rfm22b_rm2_cfg = {
533 .spi_cfg = &pios_spi_telem_flash_cfg,
534 .exti_cfg = &pios_exti_rfm22b_cfg,
535 .RFXtalCap = 0x7f,
536 .slave_num = 0,
537 .gpio_direction = GPIO0_TX_GPIO1_RX,
538 };
539
540 const struct pios_rfm22b_cfg *PIOS_BOARD_HW_DEFS_GetRfm22Cfg(uint32_t board_revision)
541 {
542 switch (board_revision) {
543 case 2:
544 return &pios_rfm22b_rm1_cfg;
545
546 break;
547 case 3:
548 return &pios_rfm22b_rm2_cfg;
549
550 break;
551 default:
552 PIOS_DEBUG_Assert(0);
553 }
554 return NULL;
555 }
556
557 #endif /* PIOS_INCLUDE_RFM22B */
558 #endif /* false */
559 #endif /* PIOS_INCLUDE_SPI */
560
561 #if defined(PIOS_INCLUDE_FLASH)
562 #include "pios_flashfs_logfs_priv.h"
563 #include "pios_flash_jedec_priv.h"
564 #include "pios_flash_internal_priv.h"
565
566 static const struct flashfs_logfs_cfg flashfs_external_cfg = {
567 .fs_magic = 0x99abceef,
568 .total_fs_size = 0x00200000, /* 2M bytes (32 sectors = entire chip) */
569 .arena_size = 0x00010000, /* 256 * slot size */
570 .slot_size = 0x00000100, /* 256 bytes */
571
572 .start_offset = 0, /* start at the beginning of the chip */
573 .sector_size = 0x00010000, /* 64K bytes */
574 .page_size = 0x00000100, /* 256 bytes */
575 };
576
577
578 static const struct pios_flash_internal_cfg flash_internal_system_cfg = {};
579
580 static const struct flashfs_logfs_cfg flashfs_internal_cfg = {
581 .fs_magic = 0x99abcfef,
582 .total_fs_size = EE_BANK_SIZE, /* 32K bytes (2x16KB sectors) */
583 .arena_size = 0x00004000, /* 64 * slot size = 16K bytes = 1 sector */
584 .slot_size = 0x00000100, /* 256 bytes */
585
586 .start_offset = EE_BANK_BASE, /* start after the bootloader */
587 .sector_size = 0x00004000, /* 16K bytes */
588 .page_size = 0x00004000, /* 16K bytes */
589 };
590
591 static const struct flashfs_logfs_cfg flashfs_internal_user_cfg = {
592 .fs_magic = 0x99abcfef,
593 .total_fs_size = USER_EE_BANK_SIZE, /* 128K bytes (2x16KB sectors) */
594 .arena_size = 0x00020000, /* 64 * slot size = 16K bytes = 1 sector */
595 .slot_size = 0x00000100, /* 256 bytes */
596
597 .start_offset = USER_EE_BANK_BASE, /* start after the bootloader */
598 .sector_size = 0x00020000, /* 128K bytes */
599 .page_size = 0x00020000, /* 128K bytes */
600 };
601 #endif /* PIOS_INCLUDE_FLASH */
602
603 #include <pios_usart_priv.h>
604
605 #ifdef PIOS_INCLUDE_COM_TELEM
606
607 /*
608 * MAIN USART
609 */
610 static const struct pios_usart_cfg pios_usart_main_cfg = {
611 .regs = USART1,
612 .remap = GPIO_AF_USART1,
613 .init = {
614 .USART_BaudRate = 57600,
615 .USART_WordLength = USART_WordLength_8b,
616 .USART_Parity = USART_Parity_No,
617 .USART_StopBits = USART_StopBits_1,
618 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
619 .USART_Mode = USART_Mode_Rx | USART_Mode_Tx,
620 },
621 .irq = {
622 .init = {
623 .NVIC_IRQChannel = USART1_IRQn,
624 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
625 .NVIC_IRQChannelSubPriority = 0,
626 .NVIC_IRQChannelCmd = ENABLE,
627 },
628 },
629 .rx = {
630 .gpio = GPIOA,
631 .init = {
632 .GPIO_Pin = GPIO_Pin_10,
633 .GPIO_Speed = GPIO_Speed_2MHz,
634 .GPIO_Mode = GPIO_Mode_AF,
635 .GPIO_OType = GPIO_OType_PP,
636 .GPIO_PuPd = GPIO_PuPd_UP
637 },
638 },
639 .tx = {
640 .gpio = GPIOA,
641 .init = {
642 .GPIO_Pin = GPIO_Pin_9,
643 .GPIO_Speed = GPIO_Speed_2MHz,
644 .GPIO_Mode = GPIO_Mode_AF,
645 .GPIO_OType = GPIO_OType_PP,
646 .GPIO_PuPd = GPIO_PuPd_UP
647 },
648 },
649 };
650 #endif /* PIOS_INCLUDE_COM_TELEM */
651
652 #ifdef PIOS_INCLUDE_DSM
653
654 #include "pios_dsm_priv.h"
655 static const struct pios_usart_cfg pios_usart_dsm_main_cfg = {
656 .regs = USART1,
657 .remap = GPIO_AF_USART1,
658 .init = {
659 .USART_BaudRate = 115200,
660 .USART_WordLength = USART_WordLength_8b,
661 .USART_Parity = USART_Parity_No,
662 .USART_StopBits = USART_StopBits_1,
663 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
664 .USART_Mode = USART_Mode_Rx,
665 },
666 .irq = {
667 .init = {
668 .NVIC_IRQChannel = USART1_IRQn,
669 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
670 .NVIC_IRQChannelSubPriority = 0,
671 .NVIC_IRQChannelCmd = ENABLE,
672 },
673 },
674 .rx = {
675 .gpio = GPIOA,
676 .init = {
677 .GPIO_Pin = GPIO_Pin_10,
678 .GPIO_Speed = GPIO_Speed_2MHz,
679 .GPIO_Mode = GPIO_Mode_AF,
680 .GPIO_OType = GPIO_OType_PP,
681 .GPIO_PuPd = GPIO_PuPd_UP
682 },
683 },
684 .tx = {
685 .gpio = GPIOA,
686 .init = {
687 .GPIO_Pin = GPIO_Pin_9,
688 .GPIO_Speed = GPIO_Speed_2MHz,
689 .GPIO_Mode = GPIO_Mode_AF,
690 .GPIO_OType = GPIO_OType_PP,
691 .GPIO_PuPd = GPIO_PuPd_UP
692 },
693 },
694 };
695
696 // Because of the inverter on the main port this will not
697 // work. Notice the mode is set to IN to maintain API
698 // compatibility but protect the pins
699 static const struct pios_dsm_cfg pios_dsm_main_cfg = {
700 .bind = {
701 .gpio = GPIOA,
702 .init = {
703 .GPIO_Pin = GPIO_Pin_10,
704 .GPIO_Speed = GPIO_Speed_2MHz,
705 .GPIO_Mode = GPIO_Mode_IN,
706 .GPIO_OType = GPIO_OType_PP,
707 .GPIO_PuPd = GPIO_PuPd_NOPULL
708 },
709 },
710 };
711
712 #endif /* PIOS_INCLUDE_DSM */
713
714 #include <pios_sbus_priv.h>
715 #if defined(PIOS_INCLUDE_SBUS)
716 /*
717 * S.Bus USART
718 */
719 #include <pios_sbus_priv.h>
720
721 static const struct pios_usart_cfg pios_usart_sbus_main_cfg = {
722 .regs = USART1,
723 .remap = GPIO_AF_USART1,
724 .init = {
725 .USART_BaudRate = 100000,
726 .USART_WordLength = USART_WordLength_8b,
727 .USART_Parity = USART_Parity_Even,
728 .USART_StopBits = USART_StopBits_2,
729 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
730 .USART_Mode = USART_Mode_Rx,
731 },
732 .irq = {
733 .init = {
734 .NVIC_IRQChannel = USART1_IRQn,
735 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
736 .NVIC_IRQChannelSubPriority = 0,
737 .NVIC_IRQChannelCmd = ENABLE,
738 },
739 },
740 .rx = {
741 .gpio = GPIOA,
742 .init = {
743 .GPIO_Pin = GPIO_Pin_10,
744 .GPIO_Speed = GPIO_Speed_2MHz,
745 .GPIO_Mode = GPIO_Mode_AF,
746 .GPIO_OType = GPIO_OType_PP,
747 .GPIO_PuPd = GPIO_PuPd_UP
748 },
749 },
750 .tx = {
751 .gpio = GPIOA,
752 .init = {
753 .GPIO_Pin = GPIO_Pin_9,
754 .GPIO_Speed = GPIO_Speed_2MHz,
755 .GPIO_Mode = GPIO_Mode_OUT,
756 .GPIO_OType = GPIO_OType_PP,
757 .GPIO_PuPd = GPIO_PuPd_NOPULL
758 },
759 },
760 };
761
762 #endif /* PIOS_INCLUDE_SBUS */
763
764 // Need this defined regardless to be able to turn it off
765 static const struct pios_sbus_cfg pios_sbus_cfg = {
766 /* Inverter configuration */
767 .inv = {
768 .gpio = GPIOC,
769 .init = {
770 .GPIO_Pin = GPIO_Pin_0,
771 .GPIO_Speed = GPIO_Speed_2MHz,
772 .GPIO_Mode = GPIO_Mode_OUT,
773 .GPIO_OType = GPIO_OType_PP,
774 .GPIO_PuPd = GPIO_PuPd_UP
775 },
776 },
777 .gpio_inv_enable = Bit_SET,
778 .gpio_inv_disable = Bit_RESET,
779 .gpio_clk_func = RCC_AHB1PeriphClockCmd,
780 .gpio_clk_periph = RCC_AHB1Periph_GPIOC,
781 };
782
783
784 #ifdef PIOS_INCLUDE_COM_FLEXI
785 /*
786 * FLEXI PORT
787 */
788 static const struct pios_usart_cfg pios_usart_flexi_cfg = {
789 .regs = USART3,
790 .remap = GPIO_AF_USART3,
791 .init = {
792 .USART_BaudRate = 57600,
793 .USART_WordLength = USART_WordLength_8b,
794 .USART_Parity = USART_Parity_No,
795 .USART_StopBits = USART_StopBits_1,
796 .USART_HardwareFlowControl =
797 USART_HardwareFlowControl_None,
798 .USART_Mode = USART_Mode_Rx | USART_Mode_Tx,
799 },
800 .irq = {
801 .init = {
802 .NVIC_IRQChannel = USART3_IRQn,
803 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
804 .NVIC_IRQChannelSubPriority = 0,
805 .NVIC_IRQChannelCmd = ENABLE,
806 },
807 },
808 .rx = {
809 .gpio = GPIOB,
810 .init = {
811 .GPIO_Pin = GPIO_Pin_11,
812 .GPIO_Speed = GPIO_Speed_2MHz,
813 .GPIO_Mode = GPIO_Mode_AF,
814 .GPIO_OType = GPIO_OType_PP,
815 .GPIO_PuPd = GPIO_PuPd_UP
816 },
817 },
818 .tx = {
819 .gpio = GPIOB,
820 .init = {
821 .GPIO_Pin = GPIO_Pin_10,
822 .GPIO_Speed = GPIO_Speed_2MHz,
823 .GPIO_Mode = GPIO_Mode_AF,
824 .GPIO_OType = GPIO_OType_PP,
825 .GPIO_PuPd = GPIO_PuPd_UP
826 },
827 },
828 };
829
830 #endif /* PIOS_INCLUDE_COM_FLEXI */
831
832 #ifdef PIOS_INCLUDE_DSM
833
834 #include "pios_dsm_priv.h"
835 static const struct pios_usart_cfg pios_usart_dsm_flexi_cfg = {
836 .regs = USART3,
837 .remap = GPIO_AF_USART3,
838 .init = {
839 .USART_BaudRate = 115200,
840 .USART_WordLength = USART_WordLength_8b,
841 .USART_Parity = USART_Parity_No,
842 .USART_StopBits = USART_StopBits_1,
843 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
844 .USART_Mode = USART_Mode_Rx,
845 },
846 .irq = {
847 .init = {
848 .NVIC_IRQChannel = USART3_IRQn,
849 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
850 .NVIC_IRQChannelSubPriority = 0,
851 .NVIC_IRQChannelCmd = ENABLE,
852 },
853 },
854 .rx = {
855 .gpio = GPIOB,
856 .init = {
857 .GPIO_Pin = GPIO_Pin_11,
858 .GPIO_Speed = GPIO_Speed_2MHz,
859 .GPIO_Mode = GPIO_Mode_AF,
860 .GPIO_OType = GPIO_OType_PP,
861 .GPIO_PuPd = GPIO_PuPd_UP
862 },
863 },
864 .tx = {
865 .gpio = GPIOB,
866 .init = {
867 .GPIO_Pin = GPIO_Pin_10,
868 .GPIO_Speed = GPIO_Speed_2MHz,
869 .GPIO_Mode = GPIO_Mode_AF,
870 .GPIO_OType = GPIO_OType_PP,
871 .GPIO_PuPd = GPIO_PuPd_UP
872 },
873 },
874 };
875
876 static const struct pios_dsm_cfg pios_dsm_flexi_cfg = {
877 .bind = {
878 .gpio = GPIOB,
879 .init = {
880 .GPIO_Pin = GPIO_Pin_11,
881 .GPIO_Speed = GPIO_Speed_2MHz,
882 .GPIO_Mode = GPIO_Mode_OUT,
883 .GPIO_OType = GPIO_OType_PP,
884 .GPIO_PuPd = GPIO_PuPd_NOPULL
885 },
886 },
887 };
888
889 #endif /* PIOS_INCLUDE_DSM */
890
891 /*
892 * HK OSD
893 */
894 static const struct pios_usart_cfg pios_usart_hkosd_main_cfg = {
895 .regs = USART1,
896 .remap = GPIO_AF_USART1,
897 .init = {
898 .USART_BaudRate = 57600,
899 .USART_WordLength = USART_WordLength_8b,
900 .USART_Parity = USART_Parity_No,
901 .USART_StopBits = USART_StopBits_1,
902 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
903 .USART_Mode = USART_Mode_Rx | USART_Mode_Tx,
904 },
905 .irq = {
906 .init = {
907 .NVIC_IRQChannel = USART1_IRQn,
908 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
909 .NVIC_IRQChannelSubPriority = 0,
910 .NVIC_IRQChannelCmd = ENABLE,
911 },
912 },
913 .rx = {
914 .gpio = GPIOA,
915 .init = {
916 .GPIO_Pin = GPIO_Pin_10,
917 .GPIO_Speed = GPIO_Speed_2MHz,
918 .GPIO_Mode = GPIO_Mode_AF,
919 .GPIO_OType = GPIO_OType_PP,
920 .GPIO_PuPd = GPIO_PuPd_UP
921 },
922 },
923 .tx = {
924 .gpio = GPIOA,
925 .init = {
926 .GPIO_Pin = GPIO_Pin_9,
927 .GPIO_Speed = GPIO_Speed_2MHz,
928 .GPIO_Mode = GPIO_Mode_AF,
929 .GPIO_OType = GPIO_OType_PP,
930 .GPIO_PuPd = GPIO_PuPd_UP
931 },
932 },
933 };
934
935 static const struct pios_usart_cfg pios_usart_hkosd_flexi_cfg = {
936 .regs = USART3,
937 .remap = GPIO_AF_USART3,
938 .init = {
939 .USART_BaudRate = 57600,
940 .USART_WordLength = USART_WordLength_8b,
941 .USART_Parity = USART_Parity_No,
942 .USART_StopBits = USART_StopBits_1,
943 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
944 .USART_Mode = USART_Mode_Rx | USART_Mode_Tx,
945 },
946 .irq = {
947 .init = {
948 .NVIC_IRQChannel = USART3_IRQn,
949 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
950 .NVIC_IRQChannelSubPriority = 0,
951 .NVIC_IRQChannelCmd = ENABLE,
952 },
953 },
954 .rx = {
955 .gpio = GPIOB,
956 .init = {
957 .GPIO_Pin = GPIO_Pin_11,
958 .GPIO_Speed = GPIO_Speed_2MHz,
959 .GPIO_Mode = GPIO_Mode_AF,
960 .GPIO_OType = GPIO_OType_PP,
961 .GPIO_PuPd = GPIO_PuPd_UP
962 },
963 },
964 .tx = {
965 .gpio = GPIOB,
966 .init = {
967 .GPIO_Pin = GPIO_Pin_10,
968 .GPIO_Speed = GPIO_Speed_2MHz,
969 .GPIO_Mode = GPIO_Mode_AF,
970 .GPIO_OType = GPIO_OType_PP,
971 .GPIO_PuPd = GPIO_PuPd_UP
972 },
973 },
974 };
975
976 static const struct pios_usart_cfg pios_usart_rcvrport_cfg = {
977 .regs = USART6,
978 .remap = GPIO_AF_USART6,
979 .init = {
980 .USART_BaudRate = 57600,
981 .USART_WordLength = USART_WordLength_8b,
982 .USART_Parity = USART_Parity_No,
983 .USART_StopBits = USART_StopBits_1,
984 .USART_HardwareFlowControl = USART_HardwareFlowControl_None,
985 .USART_Mode = USART_Mode_Rx | USART_Mode_Tx,
986 },
987 .irq = {
988 .init = {
989 .NVIC_IRQChannel = USART6_IRQn,
990 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
991 .NVIC_IRQChannelSubPriority = 0,
992 .NVIC_IRQChannelCmd = ENABLE,
993 },
994 },
995
996 .dtr = {
997 // FlexIO pin 9
998 .gpio = GPIOC,
999 .init = {
1000 .GPIO_Pin = GPIO_Pin_8,
1001 .GPIO_Speed = GPIO_Speed_25MHz,
1002 .GPIO_Mode = GPIO_Mode_OUT,
1003 .GPIO_OType = GPIO_OType_PP,
1004 },
1005 },
1006
1007 .tx = {
1008 // * 7: PC6 = TIM8 CH1, USART6 TX
1009 .gpio = GPIOC,
1010 .init = {
1011 .GPIO_Pin = GPIO_Pin_6,
1012 .GPIO_Speed = GPIO_Speed_2MHz,
1013 .GPIO_Mode = GPIO_Mode_AF,
1014 .GPIO_OType = GPIO_OType_PP,
1015 .GPIO_PuPd = GPIO_PuPd_UP
1016 },
1017 .pin_source = GPIO_PinSource6,
1018 },
1019
1020 .rx = {
1021 // * 8: PC7 = TIM8 CH2, USART6 RX
1022 .gpio = GPIOC,
1023 .init = {
1024 .GPIO_Pin = GPIO_Pin_7,
1025 .GPIO_Speed = GPIO_Speed_2MHz,
1026 .GPIO_Mode = GPIO_Mode_AF,
1027 .GPIO_OType = GPIO_OType_PP,
1028 .GPIO_PuPd = GPIO_PuPd_UP
1029 },
1030 .pin_source = GPIO_PinSource7,
1031 }
1032 };
1033
1034 #if defined(PIOS_INCLUDE_COM)
1035
1036 #include <pios_com_priv.h>
1037
1038 #endif /* PIOS_INCLUDE_COM */
1039
1040 #if defined(PIOS_INCLUDE_I2C)
1041
1042 #include <pios_i2c_priv.h>
1043
1044 /*
1045 * I2C Adapters
1046 */
1047 void PIOS_I2C_mag_pressure_adapter_ev_irq_handler(void);
1048 void PIOS_I2C_mag_pressureadapter_er_irq_handler(void);
1049 void I2C1_EV_IRQHandler()
1050 __attribute__((alias("PIOS_I2C_mag_pressure_adapter_ev_irq_handler")));
1051 void I2C1_ER_IRQHandler()
1052 __attribute__((alias("PIOS_I2C_mag_pressure_adapter_er_irq_handler")));
1053
1054 static const struct pios_i2c_adapter_cfg pios_i2c_mag_pressure_adapter_cfg = {
1055 .regs = I2C1,
1056 .remapSCL = GPIO_AF_I2C1,
1057 .remapSDA = GPIO_AF_I2C1,
1058 .init = {
1059 .I2C_Mode = I2C_Mode_I2C,
1060 .I2C_OwnAddress1 = 0,
1061 .I2C_Ack = I2C_Ack_Enable,
1062 .I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit,
1063 .I2C_DutyCycle = I2C_DutyCycle_2,
1064 .I2C_ClockSpeed = 400000, /* bits/s */
1065 },
1066 .transfer_timeout_ms = 50,
1067 .scl = {
1068 .gpio = GPIOB,
1069 .init = {
1070 .GPIO_Pin = GPIO_Pin_8,
1071 .GPIO_Mode = GPIO_Mode_AF,
1072 .GPIO_Speed = GPIO_Speed_50MHz,
1073 .GPIO_OType = GPIO_OType_OD,
1074 .GPIO_PuPd = GPIO_PuPd_NOPULL,
1075 },
1076 },
1077 .sda = {
1078 .gpio = GPIOB,
1079 .init = {
1080 .GPIO_Pin = GPIO_Pin_9,
1081 .GPIO_Mode = GPIO_Mode_AF,
1082 .GPIO_Speed = GPIO_Speed_50MHz,
1083 .GPIO_OType = GPIO_OType_OD,
1084 .GPIO_PuPd = GPIO_PuPd_NOPULL,
1085 },
1086 },
1087 .event = {
1088 .flags = 0, /* FIXME: check this */
1089 .init = {
1090 .NVIC_IRQChannel = I2C1_EV_IRQn,
1091 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST,
1092 .NVIC_IRQChannelSubPriority = 0,
1093 .NVIC_IRQChannelCmd = ENABLE,
1094 },
1095 },
1096 .error = {
1097 .flags = 0, /* FIXME: check this */
1098 .init = {
1099 .NVIC_IRQChannel = I2C1_ER_IRQn,
1100 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST,
1101 .NVIC_IRQChannelSubPriority = 0,
1102 .NVIC_IRQChannelCmd = ENABLE,
1103 },
1104 },
1105 };
1106
1107 uint32_t pios_i2c_mag_pressure_adapter_id;
1108 void PIOS_I2C_mag_pressure_adapter_ev_irq_handler(void)
1109 {
1110 /* Call into the generic code to handle the IRQ for this specific device */
1111 PIOS_I2C_EV_IRQ_Handler(pios_i2c_mag_pressure_adapter_id);
1112 }
1113
1114 void PIOS_I2C_mag_pressure_adapter_er_irq_handler(void)
1115 {
1116 /* Call into the generic code to handle the IRQ for this specific device */
1117 PIOS_I2C_ER_IRQ_Handler(pios_i2c_mag_pressure_adapter_id);
1118 }
1119
1120
1121 void PIOS_I2C_flexiport_adapter_ev_irq_handler(void);
1122 void PIOS_I2C_flexiport_adapter_er_irq_handler(void);
1123 void I2C2_EV_IRQHandler() __attribute__((alias("PIOS_I2C_flexiport_adapter_ev_irq_handler")));
1124 void I2C2_ER_IRQHandler() __attribute__((alias("PIOS_I2C_flexiport_adapter_er_irq_handler")));
1125
1126 static const struct pios_i2c_adapter_cfg pios_i2c_flexiport_adapter_cfg = {
1127 .regs = I2C2,
1128 .remapSCL = GPIO_AF_I2C2,
1129 .remapSDA = GPIO_AF_I2C2,
1130 .init = {
1131 .I2C_Mode = I2C_Mode_I2C,
1132 .I2C_OwnAddress1 = 0,
1133 .I2C_Ack = I2C_Ack_Enable,
1134 .I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit,
1135 .I2C_DutyCycle = I2C_DutyCycle_2,
1136 .I2C_ClockSpeed = 400000, /* bits/s */
1137 },
1138 .transfer_timeout_ms = 50,
1139 .scl = {
1140 .gpio = GPIOB,
1141 .init = {
1142 .GPIO_Pin = GPIO_Pin_10,
1143 .GPIO_Mode = GPIO_Mode_AF,
1144 .GPIO_Speed = GPIO_Speed_50MHz,
1145 .GPIO_OType = GPIO_OType_OD,
1146 .GPIO_PuPd = GPIO_PuPd_UP,
1147 },
1148 },
1149 .sda = {
1150 .gpio = GPIOB,
1151 .init = {
1152 .GPIO_Pin = GPIO_Pin_11,
1153 .GPIO_Mode = GPIO_Mode_AF,
1154 .GPIO_Speed = GPIO_Speed_50MHz,
1155 .GPIO_OType = GPIO_OType_OD,
1156 .GPIO_PuPd = GPIO_PuPd_UP,
1157 },
1158 },
1159 .event = {
1160 .flags = 0, /* FIXME: check this */
1161 .init = {
1162 .NVIC_IRQChannel = I2C2_EV_IRQn,
1163 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST,
1164 .NVIC_IRQChannelSubPriority = 0,
1165 .NVIC_IRQChannelCmd = ENABLE,
1166 },
1167 },
1168 .error = {
1169 .flags = 0, /* FIXME: check this */
1170 .init = {
1171 .NVIC_IRQChannel = I2C2_ER_IRQn,
1172 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST,
1173 .NVIC_IRQChannelSubPriority = 0,
1174 .NVIC_IRQChannelCmd = ENABLE,
1175 },
1176 },
1177 };
1178
1179 uint32_t pios_i2c_flexiport_adapter_id;
1180 void PIOS_I2C_flexiport_adapter_ev_irq_handler(void)
1181 {
1182 /* Call into the generic code to handle the IRQ for this specific device */
1183 PIOS_I2C_EV_IRQ_Handler(pios_i2c_flexiport_adapter_id);
1184 }
1185
1186 void PIOS_I2C_flexiport_adapter_er_irq_handler(void)
1187 {
1188 /* Call into the generic code to handle the IRQ for this specific device */
1189 PIOS_I2C_ER_IRQ_Handler(pios_i2c_flexiport_adapter_id);
1190 }
1191
1192
1193 void PIOS_I2C_pressure_adapter_ev_irq_handler(void);
1194 void PIOS_I2C_pressure_adapter_er_irq_handler(void);
1195
1196 #endif /* PIOS_INCLUDE_I2C */
1197
1198 #if defined(PIOS_INCLUDE_RTC)
1199 /*
1200 * Realtime Clock (RTC)
1201 */
1202 #include <pios_rtc_priv.h>
1203
1204 void PIOS_RTC_IRQ_Handler(void);
1205 void RTC_WKUP_IRQHandler() __attribute__((alias("PIOS_RTC_IRQ_Handler")));
1206 static const struct pios_rtc_cfg pios_rtc_main_cfg = {
1207 .clksrc = RCC_RTCCLKSource_HSE_Div8, // Divide 8 Mhz crystal down to 1
1208 // For some reason it's acting like crystal is 16 Mhz. This clock is then divided
1209 // by another 16 to give a nominal 62.5 khz clock
1210 .prescaler = 100, // Every 100 cycles gives 625 Hz
1211 .irq = {
1212 .init = {
1213 .NVIC_IRQChannel = RTC_WKUP_IRQn,
1214 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1215 .NVIC_IRQChannelSubPriority = 0,
1216 .NVIC_IRQChannelCmd = ENABLE,
1217 },
1218 },
1219 };
1220
1221 void PIOS_RTC_IRQ_Handler(void)
1222 {
1223 PIOS_RTC_irq_handler();
1224 }
1225
1226 #endif /* if defined(PIOS_INCLUDE_RTC) */
1227
1228 #include "pios_tim_priv.h"
1229
1230 static const TIM_TimeBaseInitTypeDef tim_3_5_time_base = {
1231 .TIM_Prescaler = (PIOS_PERIPHERAL_APB1_CLOCK / 1000000) - 1,
1232 .TIM_ClockDivision = TIM_CKD_DIV1,
1233 .TIM_CounterMode = TIM_CounterMode_Up,
1234 .TIM_Period = ((1000000 / PIOS_SERVO_UPDATE_HZ) - 1),
1235 .TIM_RepetitionCounter = 0x0000,
1236 };
1237 static const TIM_TimeBaseInitTypeDef tim_9_10_11_time_base = {
1238 .TIM_Prescaler = (PIOS_PERIPHERAL_APB2_CLOCK / 1000000) - 1,
1239 .TIM_ClockDivision = TIM_CKD_DIV1,
1240 .TIM_CounterMode = TIM_CounterMode_Up,
1241 .TIM_Period = ((1000000 / PIOS_SERVO_UPDATE_HZ) - 1),
1242 .TIM_RepetitionCounter = 0x0000,
1243 };
1244
1245 static const struct pios_tim_clock_cfg tim_3_cfg = {
1246 .timer = TIM3,
1247 .time_base_init = &tim_3_5_time_base,
1248 .irq = {
1249 .init = {
1250 .NVIC_IRQChannel = TIM3_IRQn,
1251 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1252 .NVIC_IRQChannelSubPriority = 0,
1253 .NVIC_IRQChannelCmd = ENABLE,
1254 },
1255 },
1256 };
1257
1258 static const struct pios_tim_clock_cfg tim_5_cfg = {
1259 .timer = TIM5,
1260 .time_base_init = &tim_3_5_time_base,
1261 .irq = {
1262 .init = {
1263 .NVIC_IRQChannel = TIM5_IRQn,
1264 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1265 .NVIC_IRQChannelSubPriority = 0,
1266 .NVIC_IRQChannelCmd = ENABLE,
1267 },
1268 },
1269 };
1270
1271 static const struct pios_tim_clock_cfg tim_9_cfg = {
1272 .timer = TIM9,
1273 .time_base_init = &tim_9_10_11_time_base,
1274 .irq = {
1275 .init = {
1276 .NVIC_IRQChannel = TIM1_BRK_TIM9_IRQn,
1277 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1278 .NVIC_IRQChannelSubPriority = 0,
1279 .NVIC_IRQChannelCmd = ENABLE,
1280 },
1281 },
1282 };
1283
1284 static const struct pios_tim_clock_cfg tim_10_cfg = {
1285 .timer = TIM10,
1286 .time_base_init = &tim_9_10_11_time_base,
1287 .irq = {
1288 .init = {
1289 .NVIC_IRQChannel = TIM1_UP_TIM10_IRQn,
1290 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1291 .NVIC_IRQChannelSubPriority = 0,
1292 .NVIC_IRQChannelCmd = ENABLE,
1293 },
1294 },
1295 };
1296
1297 static const struct pios_tim_clock_cfg tim_11_cfg = {
1298 .timer = TIM11,
1299 .time_base_init = &tim_9_10_11_time_base,
1300 .irq = {
1301 .init = {
1302 .NVIC_IRQChannel = TIM1_TRG_COM_TIM11_IRQn,
1303 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1304 .NVIC_IRQChannelSubPriority = 0,
1305 .NVIC_IRQChannelCmd = ENABLE,
1306 },
1307 },
1308 };
1309
1310 // Set up timers that only have inputs on APB1
1311 // TIM2,3,4,5,6,7,12,13,14
1312 static const TIM_TimeBaseInitTypeDef tim_apb1_time_base = {
1313 .TIM_Prescaler = (PIOS_PERIPHERAL_APB1_CLOCK / 1000000) - 1,
1314 .TIM_ClockDivision = TIM_CKD_DIV1,
1315 .TIM_CounterMode = TIM_CounterMode_Up,
1316 .TIM_Period = 0xFFFF,
1317 .TIM_RepetitionCounter = 0x0000,
1318 };
1319
1320
1321 // Set up timers that only have inputs on APB2
1322 // TIM1,8,9,10,11
1323 static const TIM_TimeBaseInitTypeDef tim_apb2_time_base = {
1324 .TIM_Prescaler = (PIOS_PERIPHERAL_APB2_CLOCK / 1000000) - 1,
1325 .TIM_ClockDivision = TIM_CKD_DIV1,
1326 .TIM_CounterMode = TIM_CounterMode_Up,
1327 .TIM_Period = 0xFFFF,
1328 .TIM_RepetitionCounter = 0x0000,
1329 };
1330
1331 static const struct pios_tim_clock_cfg tim_1_cfg = {
1332 .timer = TIM1,
1333 .time_base_init = &tim_apb2_time_base,
1334 .irq = {
1335 .init = {
1336 .NVIC_IRQChannel = TIM1_CC_IRQn,
1337 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1338 .NVIC_IRQChannelSubPriority = 0,
1339 .NVIC_IRQChannelCmd = ENABLE,
1340 },
1341 },
1342 };
1343
1344 static const struct pios_tim_clock_cfg tim_4_cfg = {
1345 .timer = TIM4,
1346 .time_base_init = &tim_apb1_time_base,
1347 .irq = {
1348 .init = {
1349 .NVIC_IRQChannel = TIM4_IRQn,
1350 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1351 .NVIC_IRQChannelSubPriority = 0,
1352 .NVIC_IRQChannelCmd = ENABLE,
1353 },
1354 },
1355 };
1356 static const struct pios_tim_clock_cfg tim_8_cfg = {
1357 .timer = TIM8,
1358 .time_base_init = &tim_apb2_time_base,
1359 .irq = {
1360 .init = {
1361 .NVIC_IRQChannel = TIM8_CC_IRQn,
1362 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1363 .NVIC_IRQChannelSubPriority = 0,
1364 .NVIC_IRQChannelCmd = ENABLE,
1365 },
1366 },
1367 };
1368
1369 static const struct pios_tim_clock_cfg tim_12_cfg = {
1370 .timer = TIM12,
1371 .time_base_init = &tim_apb1_time_base,
1372 .irq = {
1373 .init = {
1374 .NVIC_IRQChannel = TIM8_BRK_TIM12_IRQn,
1375 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID,
1376 .NVIC_IRQChannelSubPriority = 0,
1377 .NVIC_IRQChannelCmd = ENABLE,
1378 },
1379 },
1380 };
1381
1382
1383 /**
1384 * Pios servo configuration structures
1385 * Using TIM3, TIM9, TIM2, TIM5
1386 */
1387 #include <pios_servo_priv.h>
1388 static const struct pios_tim_channel pios_tim_servoport_all_pins[] = {
1389 {
1390 .timer = TIM3,
1391 .timer_chan = TIM_Channel_3,
1392 .pin = {
1393 .gpio = GPIOB,
1394 .init = {
1395 .GPIO_Pin = GPIO_Pin_0,
1396 .GPIO_Speed = GPIO_Speed_2MHz,
1397 .GPIO_Mode = GPIO_Mode_AF,
1398 .GPIO_OType = GPIO_OType_PP,
1399 .GPIO_PuPd = GPIO_PuPd_UP
1400 },
1401 .pin_source = GPIO_PinSource0,
1402 },
1403 .remap = GPIO_AF_TIM3,
1404 },
1405 {
1406 .timer = TIM3,
1407 .timer_chan = TIM_Channel_4,
1408 .pin = {
1409 .gpio = GPIOB,
1410 .init = {
1411 .GPIO_Pin = GPIO_Pin_1,
1412 .GPIO_Speed = GPIO_Speed_2MHz,
1413 .GPIO_Mode = GPIO_Mode_AF,
1414 .GPIO_OType = GPIO_OType_PP,
1415 .GPIO_PuPd = GPIO_PuPd_UP
1416 },
1417 .pin_source = GPIO_PinSource1,
1418 },
1419 .remap = GPIO_AF_TIM3,
1420 },
1421 {
1422 .timer = TIM9,
1423 .timer_chan = TIM_Channel_2,
1424 .pin = {
1425 .gpio = GPIOA,
1426 .init = {
1427 .GPIO_Pin = GPIO_Pin_3,
1428 .GPIO_Speed = GPIO_Speed_2MHz,
1429 .GPIO_Mode = GPIO_Mode_AF,
1430 .GPIO_OType = GPIO_OType_PP,
1431 .GPIO_PuPd = GPIO_PuPd_UP
1432 },
1433 .pin_source = GPIO_PinSource3,
1434 },
1435 .remap = GPIO_AF_TIM9,
1436 },
1437 {
1438 .timer = TIM2,
1439 .timer_chan = TIM_Channel_3,
1440 .pin = {
1441 .gpio = GPIOA,
1442 .init = {
1443 .GPIO_Pin = GPIO_Pin_2,
1444 .GPIO_Speed = GPIO_Speed_2MHz,
1445 .GPIO_Mode = GPIO_Mode_AF,
1446 .GPIO_OType = GPIO_OType_PP,
1447 .GPIO_PuPd = GPIO_PuPd_UP
1448 },
1449 .pin_source = GPIO_PinSource2,
1450 },
1451 .remap = GPIO_AF_TIM2,
1452 },
1453 {
1454 .timer = TIM5,
1455 .timer_chan = TIM_Channel_2,
1456 .pin = {
1457 .gpio = GPIOA,
1458 .init = {
1459 .GPIO_Pin = GPIO_Pin_1,
1460 .GPIO_Speed = GPIO_Speed_2MHz,
1461 .GPIO_Mode = GPIO_Mode_AF,
1462 .GPIO_OType = GPIO_OType_PP,
1463 .GPIO_PuPd = GPIO_PuPd_UP
1464 },
1465 .pin_source = GPIO_PinSource1,
1466 },
1467 .remap = GPIO_AF_TIM5,
1468 },
1469 {
1470 .timer = TIM5,
1471 .timer_chan = TIM_Channel_1,
1472 .pin = {
1473 .gpio = GPIOA,
1474 .init = {
1475 .GPIO_Pin = GPIO_Pin_0,
1476 .GPIO_Speed = GPIO_Speed_2MHz,
1477 .GPIO_Mode = GPIO_Mode_AF,
1478 .GPIO_OType = GPIO_OType_PP,
1479 .GPIO_PuPd = GPIO_PuPd_UP
1480 },
1481 .pin_source = GPIO_PinSource0,
1482 },
1483 .remap = GPIO_AF_TIM5,
1484 },
1485 // PWM pins on FlexiIO(receiver) port
1486 {
1487 // * 6: PB15 = SPI2 MOSI, TIM12 CH2
1488
1489 .timer = TIM12,
1490 .timer_chan = TIM_Channel_2,
1491 .pin = {
1492 .gpio = GPIOB,
1493 .init = {
1494 .GPIO_Pin = GPIO_Pin_15,
1495 .GPIO_Speed = GPIO_Speed_2MHz,
1496 .GPIO_Mode = GPIO_Mode_AF,
1497 .GPIO_OType = GPIO_OType_PP,
1498 .GPIO_PuPd = GPIO_PuPd_UP
1499 },
1500 .pin_source = GPIO_PinSource15,
1501 },
1502 .remap = GPIO_AF_TIM12,
1503 },
1504 {
1505 // * 7: PC6 = TIM8 CH1, USART6 TX
1506 .timer = TIM8,
1507 .timer_chan = TIM_Channel_1,
1508 .pin = {
1509 .gpio = GPIOC,
1510 .init = {
1511 .GPIO_Pin = GPIO_Pin_6,
1512 .GPIO_Speed = GPIO_Speed_2MHz,
1513 .GPIO_Mode = GPIO_Mode_AF,
1514 .GPIO_OType = GPIO_OType_PP,
1515 .GPIO_PuPd = GPIO_PuPd_UP
1516 },
1517 .pin_source = GPIO_PinSource6,
1518 },
1519 .remap = GPIO_AF_TIM8,
1520 },
1521
1522 {
1523 // * 8: PC7 = TIM8 CH2, USART6 RX
1524 .timer = TIM8,
1525 .timer_chan = TIM_Channel_2,
1526 .pin = {
1527 .gpio = GPIOC,
1528 .init = {
1529 .GPIO_Pin = GPIO_Pin_7,
1530 .GPIO_Speed = GPIO_Speed_2MHz,
1531 .GPIO_Mode = GPIO_Mode_AF,
1532 .GPIO_OType = GPIO_OType_PP,
1533 .GPIO_PuPd = GPIO_PuPd_UP
1534 },
1535 .pin_source = GPIO_PinSource7,
1536 },
1537 .remap = GPIO_AF_TIM8,
1538 },
1539
1540 {
1541 // * 9: PC8 = TIM8 CH3
1542 .timer = TIM8,
1543 .timer_chan = TIM_Channel_3,
1544 .pin = {
1545 .gpio = GPIOC,
1546 .init = {
1547 .GPIO_Pin = GPIO_Pin_8,
1548 .GPIO_Speed = GPIO_Speed_2MHz,
1549 .GPIO_Mode = GPIO_Mode_AF,
1550 .GPIO_OType = GPIO_OType_PP,
1551 .GPIO_PuPd = GPIO_PuPd_UP
1552 },
1553 .pin_source = GPIO_PinSource8,
1554 },
1555 .remap = GPIO_AF_TIM8,
1556 },
1557
1558 {
1559 // * 10: PC9 = TIM8 CH4
1560 .timer = TIM8,
1561 .timer_chan = TIM_Channel_4,
1562 .pin = {
1563 .gpio = GPIOC,
1564 .init = {
1565 .GPIO_Pin = GPIO_Pin_9,
1566 .GPIO_Speed = GPIO_Speed_2MHz,
1567 .GPIO_Mode = GPIO_Mode_AF,
1568 .GPIO_OType = GPIO_OType_PP,
1569 .GPIO_PuPd = GPIO_PuPd_UP
1570 },
1571 .pin_source = GPIO_PinSource9,
1572 },
1573 .remap = GPIO_AF_TIM8,
1574 },
1575
1576 {
1577 // * 5: PB14 = SPI2 MISO, TIM12 CH1, USART3 RTS
1578 .timer = TIM12,
1579 .timer_chan = TIM_Channel_1,
1580 .pin = {
1581 .gpio = GPIOB,
1582 .init = {
1583 .GPIO_Pin = GPIO_Pin_14,
1584 .GPIO_Speed = GPIO_Speed_2MHz,
1585 .GPIO_Mode = GPIO_Mode_AF,
1586 .GPIO_OType = GPIO_OType_PP,
1587 .GPIO_PuPd = GPIO_PuPd_UP
1588 },
1589 .pin_source = GPIO_PinSource14,
1590 },
1591 .remap = GPIO_AF_TIM12,
1592 },
1593 };
1594 #define PIOS_SERVOPORT_ALL_PINS_PWMOUT 6
1595 #define PIOS_SERVOPORT_ALL_PINS_PWMOUT_IN_PPM 11
1596 #define PIOS_SERVOPORT_ALL_PINS_PWMOUT_IN 12
1597
1598 const struct pios_servo_cfg pios_servo_cfg_out = {
1599 .tim_oc_init = {
1600 .TIM_OCMode = TIM_OCMode_PWM1,
1601 .TIM_OutputState = TIM_OutputState_Enable,
1602 .TIM_OutputNState = TIM_OutputNState_Disable,
1603 .TIM_Pulse = PIOS_SERVOS_INITIAL_POSITION,
1604 .TIM_OCPolarity = TIM_OCPolarity_High,
1605 .TIM_OCNPolarity = TIM_OCPolarity_High,
1606 .TIM_OCIdleState = TIM_OCIdleState_Reset,
1607 .TIM_OCNIdleState = TIM_OCNIdleState_Reset,
1608 },
1609 .channels = pios_tim_servoport_all_pins,
1610 .num_channels = PIOS_SERVOPORT_ALL_PINS_PWMOUT,
1611 };
1612 // All servo outputs, servo input ch1 ppm, ch2-6 outputs
1613 const struct pios_servo_cfg pios_servo_cfg_out_in_ppm = {
1614 .tim_oc_init = {
1615 .TIM_OCMode = TIM_OCMode_PWM1,
1616 .TIM_OutputState = TIM_OutputState_Enable,
1617 .TIM_OutputNState = TIM_OutputNState_Disable,
1618 .TIM_Pulse = PIOS_SERVOS_INITIAL_POSITION,
1619 .TIM_OCPolarity = TIM_OCPolarity_High,
1620 .TIM_OCNPolarity = TIM_OCPolarity_High,
1621 .TIM_OCIdleState = TIM_OCIdleState_Reset,
1622 .TIM_OCNIdleState = TIM_OCNIdleState_Reset,
1623 },
1624 .channels = pios_tim_servoport_all_pins,
1625 .num_channels = PIOS_SERVOPORT_ALL_PINS_PWMOUT_IN_PPM,
1626 };
1627 // All servo outputs, servo inputs ch1-6 Outputs
1628 const struct pios_servo_cfg pios_servo_cfg_out_in = {
1629 .tim_oc_init = {
1630 .TIM_OCMode = TIM_OCMode_PWM1,
1631 .TIM_OutputState = TIM_OutputState_Enable,
1632 .TIM_OutputNState = TIM_OutputNState_Disable,
1633 .TIM_Pulse = PIOS_SERVOS_INITIAL_POSITION,
1634 .TIM_OCPolarity = TIM_OCPolarity_High,
1635 .TIM_OCNPolarity = TIM_OCPolarity_High,
1636 .TIM_OCIdleState = TIM_OCIdleState_Reset,
1637 .TIM_OCNIdleState = TIM_OCNIdleState_Reset,
1638 },
1639 .channels = pios_tim_servoport_all_pins,
1640 .num_channels = PIOS_SERVOPORT_ALL_PINS_PWMOUT_IN,
1641 };
1642
1643
1644 /*
1645 * PWM Inputs
1646 * TIM1, TIM8, TIM12
1647 */
1648 #if defined(PIOS_INCLUDE_PWM) || defined(PIOS_INCLUDE_PPM)
1649 #include <pios_pwm_priv.h>
1650 static const struct pios_tim_channel pios_tim_rcvrport_all_channels[] = {
1651 {
1652 .timer = TIM12,
1653 .timer_chan = TIM_Channel_1,
1654 .pin = {
1655 .gpio = GPIOB,
1656 .init = {
1657 .GPIO_Pin = GPIO_Pin_14,
1658 .GPIO_Speed = GPIO_Speed_2MHz,
1659 .GPIO_Mode = GPIO_Mode_AF,
1660 .GPIO_OType = GPIO_OType_PP,
1661 .GPIO_PuPd = GPIO_PuPd_UP
1662 },
1663 .pin_source = GPIO_PinSource14,
1664 },
1665 .remap = GPIO_AF_TIM12,
1666 },
1667 {
1668 .timer = TIM12,
1669 .timer_chan = TIM_Channel_2,
1670 .pin = {
1671 .gpio = GPIOB,
1672 .init = {
1673 .GPIO_Pin = GPIO_Pin_15,
1674 .GPIO_Speed = GPIO_Speed_2MHz,
1675 .GPIO_Mode = GPIO_Mode_AF,
1676 .GPIO_OType = GPIO_OType_PP,
1677 .GPIO_PuPd = GPIO_PuPd_UP
1678 },
1679 .pin_source = GPIO_PinSource15,
1680 },
1681 .remap = GPIO_AF_TIM12,
1682 },
1683 {
1684 .timer = TIM8,
1685 .timer_chan = TIM_Channel_1,
1686 .pin = {
1687 .gpio = GPIOC,
1688 .init = {
1689 .GPIO_Pin = GPIO_Pin_6,
1690 .GPIO_Speed = GPIO_Speed_2MHz,
1691 .GPIO_Mode = GPIO_Mode_AF,
1692 .GPIO_OType = GPIO_OType_PP,
1693 .GPIO_PuPd = GPIO_PuPd_UP
1694 },
1695 .pin_source = GPIO_PinSource6,
1696 },
1697 .remap = GPIO_AF_TIM8,
1698 },
1699 {
1700 .timer = TIM8,
1701 .timer_chan = TIM_Channel_2,
1702 .pin = {
1703 .gpio = GPIOC,
1704 .init = {
1705 .GPIO_Pin = GPIO_Pin_7,
1706 .GPIO_Speed = GPIO_Speed_2MHz,
1707 .GPIO_Mode = GPIO_Mode_AF,
1708 .GPIO_OType = GPIO_OType_PP,
1709 .GPIO_PuPd = GPIO_PuPd_UP
1710 },
1711 .pin_source = GPIO_PinSource7,
1712 },
1713 .remap = GPIO_AF_TIM8,
1714 },
1715 {
1716 .timer = TIM8,
1717 .timer_chan = TIM_Channel_3,
1718 .pin = {
1719 .gpio = GPIOC,
1720 .init = {
1721 .GPIO_Pin = GPIO_Pin_8,
1722 .GPIO_Speed = GPIO_Speed_2MHz,
1723 .GPIO_Mode = GPIO_Mode_AF,
1724 .GPIO_OType = GPIO_OType_PP,
1725 .GPIO_PuPd = GPIO_PuPd_UP
1726 },
1727 .pin_source = GPIO_PinSource8,
1728 },
1729 .remap = GPIO_AF_TIM8,
1730 },
1731 {
1732 .timer = TIM8,
1733 .timer_chan = TIM_Channel_4,
1734 .pin = {
1735 .gpio = GPIOC,
1736 .init = {
1737 .GPIO_Pin = GPIO_Pin_9,
1738 .GPIO_Speed = GPIO_Speed_2MHz,
1739 .GPIO_Mode = GPIO_Mode_AF,
1740 .GPIO_OType = GPIO_OType_PP,
1741 .GPIO_PuPd = GPIO_PuPd_UP
1742 },
1743 .pin_source = GPIO_PinSource9,
1744 },
1745 .remap = GPIO_AF_TIM8,
1746 },
1747 };
1748
1749 const struct pios_pwm_cfg pios_pwm_cfg = {
1750 .tim_ic_init = {
1751 .TIM_ICPolarity = TIM_ICPolarity_Rising,
1752 .TIM_ICSelection = TIM_ICSelection_DirectTI,
1753 .TIM_ICPrescaler = TIM_ICPSC_DIV1,
1754 .TIM_ICFilter = 0x0,
1755 },
1756 .channels = pios_tim_rcvrport_all_channels,
1757 .num_channels = NELEMENTS(pios_tim_rcvrport_all_channels),
1758 };
1759 // this configures outputs 2-6 as pwm inputs
1760 const struct pios_pwm_cfg pios_pwm_ppm_cfg = {
1761 .tim_ic_init = {
1762 .TIM_ICPolarity = TIM_ICPolarity_Rising,
1763 .TIM_ICSelection = TIM_ICSelection_DirectTI,
1764 .TIM_ICPrescaler = TIM_ICPSC_DIV1,
1765 .TIM_ICFilter = 0x0,
1766 },
1767 .channels = &pios_tim_rcvrport_all_channels[1],
1768 .num_channels = NELEMENTS(pios_tim_rcvrport_all_channels) - 1,
1769 };
1770
1771 #endif /* if defined(PIOS_INCLUDE_PWM) || defined(PIOS_INCLUDE_PPM) */
1772
1773 /*
1774 * PPM Input
1775 */
1776 #if defined(PIOS_INCLUDE_PPM)
1777 #include <pios_ppm_priv.h>
1778 static const struct pios_ppm_cfg pios_ppm_cfg = {
1779 .tim_ic_init = {
1780 .TIM_ICPolarity = TIM_ICPolarity_Rising,
1781 .TIM_ICSelection = TIM_ICSelection_DirectTI,
1782 .TIM_ICPrescaler = TIM_ICPSC_DIV1,
1783 .TIM_ICFilter = 0x0,
1784 .TIM_Channel = TIM_Channel_1,
1785 },
1786 /* Use only the first channel for ppm */
1787 .channels = &pios_tim_rcvrport_all_channels[0],
1788 .num_channels = 1,
1789 };
1790
1791 #endif // PPM
1792
1793 #if defined(PIOS_INCLUDE_GCSRCVR)
1794 #include "pios_gcsrcvr_priv.h"
1795 #endif /* PIOS_INCLUDE_GCSRCVR */
1796
1797 #if defined(PIOS_INCLUDE_RCVR)
1798 #include "pios_rcvr_priv.h"
1799 #endif /* PIOS_INCLUDE_RCVR */
1800
1801 #if defined(PIOS_INCLUDE_USB)
1802 #include "pios_usb_priv.h"
1803
1804 static const struct pios_usb_cfg pios_usb_discovery_cfg = {
1805 .irq = {
1806 .init = {
1807 .NVIC_IRQChannel = OTG_FS_IRQn,
1808 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
1809 .NVIC_IRQChannelSubPriority = 0, // PriorityGroup=4
1810 .NVIC_IRQChannelCmd = ENABLE,
1811 },
1812 },
1813 .vsense = {
1814 .gpio = GPIOA,
1815 .init = {
1816 .GPIO_Pin = GPIO_Pin_9,
1817 .GPIO_Speed = GPIO_Speed_25MHz,
1818 .GPIO_Mode = GPIO_Mode_IN,
1819 .GPIO_OType = GPIO_OType_OD,
1820 },
1821 },
1822 .vsense_active_low = false
1823 };
1824
1825 const struct pios_usb_cfg *PIOS_BOARD_HW_DEFS_GetUsbCfg(__attribute__((unused)) uint32_t board_revision)
1826 {
1827 return &pios_usb_discovery_cfg;
1828 }
1829
1830 #include "pios_usb_board_data_priv.h"
1831 #include "pios_usb_desc_hid_cdc_priv.h"
1832 #include "pios_usb_desc_hid_only_priv.h"
1833 #include "pios_usbhook.h"
1834
1835 #endif /* PIOS_INCLUDE_USB */
1836
1837 #if defined(PIOS_INCLUDE_COM_MSG)
1838
1839 #include <pios_com_msg_priv.h>
1840
1841 #endif /* PIOS_INCLUDE_COM_MSG */
1842
1843 #if defined(PIOS_INCLUDE_USB_HID) && !defined(PIOS_INCLUDE_USB_CDC)
1844 #include <pios_usb_hid_priv.h>
1845
1846 const struct pios_usb_hid_cfg pios_usb_hid_cfg = {
1847 .data_if = 0,
1848 .data_rx_ep = 1,
1849 .data_tx_ep = 1,
1850 };
1851 #endif /* PIOS_INCLUDE_USB_HID && !PIOS_INCLUDE_USB_CDC */
1852
1853 #if defined(PIOS_INCLUDE_USB_HID) && defined(PIOS_INCLUDE_USB_CDC)
1854 #include <pios_usb_cdc_priv.h>
1855
1856 const struct pios_usb_cdc_cfg pios_usb_cdc_cfg = {
1857 .ctrl_if = 0,
1858 .ctrl_tx_ep = 2,
1859
1860 .data_if = 1,
1861 .data_rx_ep = 3,
1862 .data_tx_ep = 3,
1863 };
1864
1865 #include <pios_usb_hid_priv.h>
1866
1867 const struct pios_usb_hid_cfg pios_usb_hid_cfg = {
1868 .data_if = 2,
1869 .data_rx_ep = 1,
1870 .data_tx_ep = 1,
1871 };
1872 #endif /* PIOS_INCLUDE_USB_HID && PIOS_INCLUDE_USB_CDC */
1873 #ifdef PIOS_INCLUDE_WS2811
1874 #include <pios_ws2811_cfg.h>
1875 #define PIOS_WS2811_TIM_DIVIDER (PIOS_PERIPHERAL_APB2_CLOCK / (800000 * PIOS_WS2811_TIM_PERIOD))
1876
1877 void DMA2_Stream1_IRQHandler(void) __attribute__((alias("PIOS_WS2811_irq_handler")));
1878
1879 const struct pios_ws2811_pin_cfg pios_ws2811_pin_cfg = {
1880 .gpio = GPIOA,
1881 .gpioInit = {
1882 .GPIO_Pin = GPIO_Pin_3,
1883 .GPIO_Speed = GPIO_Speed_50MHz,
1884 .GPIO_Mode = GPIO_Mode_OUT,
1885 .GPIO_OType = GPIO_OType_PP,
1886 },
1887 };
1888
1889 const struct pios_ws2811_cfg pios_ws2811_cfg = {
1890 .timer = TIM1,
1891 .timerInit = {
1892 .TIM_Prescaler = PIOS_WS2811_TIM_DIVIDER - 1,
1893 .TIM_ClockDivision = TIM_CKD_DIV1,
1894 .TIM_CounterMode = TIM_CounterMode_Up,
1895 // period (1.25 uS per period
1896 .TIM_Period = PIOS_WS2811_TIM_PERIOD,
1897 .TIM_RepetitionCounter = 0x0000,
1898 },
1899
1900 .timerCh1 = 1,
1901 .streamCh1 = DMA2_Stream1,
1902 .timerCh2 = 3,
1903 .streamCh2 = DMA2_Stream6,
1904 .streamUpdate = DMA2_Stream5,
1905
1906 // DMA streamCh1, triggered by timerCh1 pwm signal.
1907 // if FrameBuffer indicates, reset output value early to indicate "0" bit to ws2812
1908 .dmaInitCh1 = PIOS_WS2811_DMA_CH1_CONFIG(DMA_Channel_6),
1909 .dmaItCh1 = DMA_IT_TEIF1 | DMA_IT_TCIF1,
1910
1911 // DMA streamCh2, triggered by timerCh2 pwm signal.
1912 // Reset output value late to indicate "1" bit to ws2812.
1913 .dmaInitCh2 = PIOS_WS2811_DMA_CH2_CONFIG(DMA_Channel_6),
1914 .dmaItCh2 = DMA_IT_TEIF6 | DMA_IT_TCIF6,
1915
1916 // DMA streamUpdate Triggered by timer update event
1917 // Outputs a high logic level at beginning of a cycle
1918 .dmaInitUpdate = PIOS_WS2811_DMA_UPDATE_CONFIG(DMA_Channel_6),
1919 .dmaItUpdate = DMA_IT_TEIF5 | DMA_IT_TCIF5,
1920 .dmaSource = TIM_DMA_CC1 | TIM_DMA_CC3 | TIM_DMA_Update,
1921
1922 // DMA streamCh1 interrupt vector, used to block timer at end of framebuffer transfer
1923 .irq = {
1924 .flags = (DMA_IT_TCIF1),
1925 .init = {
1926 .NVIC_IRQChannel = DMA2_Stream1_IRQn,
1927 .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGHEST,
1928 .NVIC_IRQChannelSubPriority = 0,
1929 .NVIC_IRQChannelCmd = ENABLE,
1930 },
1931 },
1932 };
1933
1934 void PIOS_WS2811_irq_handler(void)
1935 {
1936 PIOS_WS2811_DMA_irq_handler();
1937 }
1938 #endif // PIOS_INCLUDE_WS2811