pixel_pi 0.0.1

data/ext/ws2811/dma.c

@@ -0,0 +1,192 @@
+/*
+ * dma.c
+ *
+ * Copyright (c) 2014 Jeremy Garff <jer @ jers.net>
+ *
+ * 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.
+ *     3.  Neither the name of the owner nor the names of its contributors may be used to endorse
+ *         or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include "dma.h"
+
+
+// DMA address mapping by DMA number index
+const static uint32_t dma_addr[] =
+{
+    DMA0,
+    DMA1,
+    DMA2,
+    DMA3,
+    DMA4,
+    DMA5,
+    DMA6,
+    DMA7,
+    DMA8,
+    DMA9,
+    DMA10,
+    DMA11,
+    DMA12,
+    DMA13,
+    DMA14,
+    DMA15,
+};
+
+
+uint32_t dmanum_to_phys(int dmanum)
+{
+    int array_size = sizeof(dma_addr) / sizeof(dma_addr[0]);
+
+    if (dmanum >= array_size)
+    {
+        return 0;
+    }
+
+    return dma_addr[dmanum];
+}
+
+
+dma_page_t *dma_page_add(dma_page_t *head, void *addr)
+{
+    dma_page_t *page = malloc(sizeof(dma_page_t));
+
+    if (!page)
+    {
+        return NULL;
+    }
+
+    page->next = head;
+    page->prev = head->prev;
+
+    head->prev->next = page;
+    head->prev = page;
+
+    page->addr = addr;
+
+    return page;
+}
+
+void dma_page_remove(dma_page_t *page)
+{
+    page->prev->next = page->next;
+    page->next->prev = page->prev;
+
+    free(page);
+}
+
+void dma_page_remove_all(dma_page_t *head)
+{
+    while (head->next != head)
+    {
+        dma_page_remove(head->next);
+    }
+}
+
+dma_page_t *dma_page_next(dma_page_t *head, dma_page_t *page)
+{
+    if (page->next != head)
+    {
+        return page->next;
+    }
+
+    return NULL;
+}
+
+void dma_page_init(dma_page_t *page)
+{
+    memset(page, 0, sizeof(*page));
+
+    page->next = page;
+    page->prev = page;
+}
+
+void *dma_alloc(dma_page_t *head, uint32_t size)
+{
+    uint32_t pages = (size / PAGE_SIZE) + 1;
+    void *vaddr;
+    int i;
+
+    vaddr = mmap(NULL, pages * PAGE_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_SHARED | MAP_ANONYMOUS | MAP_NORESERVE |
+                 MAP_LOCKED, -1, 0);
+    if (vaddr == MAP_FAILED)
+    {
+        perror("dma_alloc() mmap() failed");
+        return NULL;
+    }
+
+    for (i = 0; i < pages; i++)
+    {
+        if (!dma_page_add(head, &((uint8_t *)vaddr)[PAGE_SIZE * i]))
+        {
+            dma_page_remove_all(head);
+            munmap(vaddr, pages * PAGE_SIZE);
+            return NULL;
+        }
+    }
+
+    return vaddr;
+}
+
+dma_cb_t *dma_desc_alloc(uint32_t descriptors)
+{
+    uint32_t pages = ((descriptors * sizeof(dma_cb_t)) / PAGE_SIZE);
+    dma_cb_t *vaddr;
+
+    if (pages > 1)
+    {
+        return NULL;
+    }
+
+    vaddr = mmap(NULL, pages * PAGE_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_SHARED | MAP_ANONYMOUS | MAP_NORESERVE |
+                 MAP_LOCKED, -1, 0);
+    if (vaddr == MAP_FAILED)
+    {
+        perror("dma_desc_alloc() mmap() failed");
+        return NULL;
+    }
+
+    return vaddr;
+}
+
+void dma_page_free(void *buffer, const uint32_t size)
+{
+    uint32_t pages = (size / PAGE_SIZE) + 1;
+
+    munmap(buffer, pages * PAGE_SIZE);
+}
+
+

data/ext/ws2811/dma.h

@@ -0,0 +1,146 @@
+/*
+ * dma.h
+ *
+ * Copyright (c) 2014 Jeremy Garff <jer @ jers.net>
+ *
+ * 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.
+ *     3.  Neither the name of the owner nor the names of its contributors may be used to endorse
+ *         or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER 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.
+ *
+ */
+
+#ifndef __DMA_H__
+#define __DMA_H__
+
+
+/*
+ * DMA Control Block in Main Memory
+ *
+ * Note: Must start at a 256 byte aligned address.
+ *       Use corresponding register field definitions.
+ */
+typedef struct
+{
+    uint32_t ti;
+    uint32_t source_ad;
+    uint32_t dest_ad;
+    uint32_t txfr_len;
+    uint32_t stride;
+    uint32_t nextconbk;
+    uint32_t resvd_0x18[2];
+} __attribute__((packed)) dma_cb_t;
+
+/*
+ * DMA register set
+ */
+typedef struct
+{
+    uint32_t cs;
+#define RPI_DMA_CS_RESET                         (1 << 31)
+#define RPI_DMA_CS_ABORT                         (1 << 30)
+#define RPI_DMA_CS_DISDEBUG                      (1 << 29)
+#define RPI_DMA_CS_WAIT_OUTSTANDING_WRITES       (1 << 28)
+#define RPI_DMA_CS_PANIC_PRIORITY(val)           ((val & 0xf) << 20)                
+#define RPI_DMA_CS_PRIORITY(val)                 ((val & 0xf) << 16)
+#define RPI_DMA_CS_ERROR                         (1 << 8)
+#define RPI_DMA_CS_WAITING_OUTSTANDING_WRITES    (1 << 6)
+#define RPI_DMA_CS_DREQ_STOPS_DMA                (1 << 5)
+#define RPI_DMA_CS_PAUSED                        (1 << 4)
+#define RPI_DMA_CS_DREQ                          (1 << 3)
+#define RPI_DMA_CS_INT                           (1 << 2)
+#define RPI_DMA_CS_END                           (1 << 1)
+#define RPI_DMA_CS_ACTIVE                        (1 << 0)
+    uint32_t conblk_ad;
+    uint32_t ti;
+#define RPI_DMA_TI_NO_WIDE_BURSTS                (1 << 26)
+#define RPI_DMA_TI_WAITS(val)                    ((val & 0x1f) << 21)
+#define RPI_DMA_TI_PERMAP(val)                   ((val & 0x1f) << 16)
+#define RPI_DMA_TI_BURST_LENGTH(val)             ((val & 0xf) << 12)
+#define RPI_DMA_TI_SRC_IGNORE                    (1 << 11)
+#define RPI_DMA_TI_SRC_DREQ                      (1 << 10)
+#define RPI_DMA_TI_SRC_WIDTH                     (1 << 9)
+#define RPI_DMA_TI_SRC_INC                       (1 << 8)
+#define RPI_DMA_TI_DEST_IGNORE                   (1 << 7)
+#define RPI_DMA_TI_DEST_DREQ                     (1 << 6)
+#define RPI_DMA_TI_DEST_WIDTH                    (1 << 5)
+#define RPI_DMA_TI_DEST_INC                      (1 << 4)
+#define RPI_DMA_TI_WAIT_RESP                     (1 << 3)
+#define RPI_DMA_TI_TDMODE                        (1 << 1)
+#define RPI_DMA_TI_INTEN                         (1 << 0)
+    uint32_t source_ad;
+    uint32_t dest_ad;
+    uint32_t txfr_len;
+#define RPI_DMA_TXFR_LEN_YLENGTH(val)            ((val & 0xffff) << 16)
+#define RPI_DMA_TXFR_LEN_XLENGTH(val)            ((val & 0xffff) << 0)
+    uint32_t stride;
+#define RPI_DMA_STRIDE_D_STRIDE(val)             ((val & 0xffff) << 16)
+#define RPI_DMA_STRIDE_S_STRIDE(val)             ((val & 0xffff) << 0)
+    uint32_t nextconbk;
+    uint32_t debug;
+} __attribute__((packed)) dma_t;
+
+
+#define DMA0                                     (0x20007000)  // 0x7e007000
+#define DMA1                                     (0x20007100)
+#define DMA2                                     (0x20007200)
+#define DMA3                                     (0x20007300)
+#define DMA4                                     (0x20007400)
+#define DMA5                                     (0x20007500)
+#define DMA6                                     (0x20007600)
+#define DMA7                                     (0x20007700)
+#define DMA8                                     (0x20007800)
+#define DMA9                                     (0x20007900)
+#define DMA10                                    (0x20007a00)
+#define DMA11                                    (0x20007b00)
+#define DMA12                                    (0x20007c00)
+#define DMA13                                    (0x20007d00)
+#define DMA14                                    (0x20007e00)
+#define DMA15                                    (0x20e05000)
+
+
+#define PAGE_SIZE                                (1 << 12)
+#define PAGE_MASK                                (~(PAGE_SIZE - 1))
+#define PAGE_OFFSET(page)                        (page & (PAGE_SIZE - 1))
+#define MAX_PAGES                                (PAGE_SIZE / sizeof(dma_cb_t))
+
+
+typedef struct dma_page
+{
+    struct dma_page *next;
+    struct dma_page *prev;
+    void *addr;
+} dma_page_t;
+
+
+uint32_t dmanum_to_phys(int dmanum);
+
+void dma_page_init(dma_page_t *page);
+dma_page_t *dma_page_add(dma_page_t *head, void *addr);
+void dma_page_remove(dma_page_t *page);
+void dma_page_remove_all(dma_page_t *head);
+dma_page_t *dma_page_next(dma_page_t *head, dma_page_t *page);
+
+void *dma_alloc(dma_page_t *head, uint32_t size);
+dma_cb_t *dma_desc_alloc(uint32_t descriptors);
+void dma_page_free(void *buffer, const uint32_t size);
+
+
+#endif /* __DMA_H__ */

data/ext/ws2811/gpio.h

@@ -0,0 +1,108 @@
+/*
+ * gpio.h
+ *
+ * Copyright (c) 2014 Jeremy Garff <jer @ jers.net>
+ *
+ * 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.
+ *     3.  Neither the name of the owner nor the names of its contributors may be used to endorse
+ *         or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER 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.
+ *
+ */
+
+#ifndef __GPIO_H__
+#define __GPIO_H__
+
+
+typedef struct
+{
+    uint32_t fsel[6];                            // GPIO Function Select
+    uint32_t resvd_0x18;
+    uint32_t set[2];                             // GPIO Pin Output Set
+    uint32_t resvd_0x24;
+    uint32_t clr[2];                             // GPIO Pin Output Clear
+    uint32_t resvd_0x30;
+    uint32_t lev[2];                             // GPIO Pin Level
+    uint32_t resvd_0x3c;
+    uint32_t eds[2];                             // GPIO Pin Event Detect Status
+    uint32_t resvd_0x48;
+    uint32_t ren[2];                             // GPIO Pin Rising Edge Detect Enable
+    uint32_t resvd_0x54;
+    uint32_t fen[2];                             // GPIO Pin Falling Edge Detect Enable
+    uint32_t resvd_0x60;
+    uint32_t hen[2];                             // GPIO Pin High Detect Enable
+    uint32_t resvd_0x6c;
+    uint32_t len[2];                             // GPIO Pin Low Detect Enable
+    uint32_t resvd_0x78;
+    uint32_t aren[2];                            // GPIO Pin Async Rising Edge Detect
+    uint32_t resvd_0x84;
+    uint32_t afen[2];                            // GPIO Pin Async Falling Edge Detect
+    uint32_t resvd_0x90;
+    uint32_t pud;                                // GPIO Pin Pull up/down Enable
+    uint32_t pudclk[2];                          // GPIO Pin Pull up/down Enable Clock
+    uint32_t resvd_0xa0[4];
+    uint32_t test;
+} __attribute__((packed)) gpio_t;
+
+
+#define GPIO                                     (0x20200000)  // 0x7e200000
+
+
+static inline void gpio_function_set(volatile gpio_t *gpio, uint8_t pin, uint8_t function)
+{
+    int regnum = pin / 10;
+    int offset = (pin % 10) * 3;
+    uint8_t funcmap[] = { 4, 5, 6, 7, 3, 2 };  // See datasheet for mapping
+
+    if (function > 5)
+    {
+        return;
+    }
+
+    gpio->fsel[regnum] &= ~(0x7 << offset);
+    gpio->fsel[regnum] |= ((funcmap[function]) << offset);
+}
+
+static inline void gpio_level_set(volatile gpio_t *gpio, uint8_t pin, uint8_t level)
+{
+    int regnum = pin >> 5;
+    int offset = (pin & 0x1f);
+
+    if (level)
+    {
+        gpio->set[regnum] = (1 << offset);
+    }
+    else
+    {
+        gpio->clr[regnum] = (1 << offset);
+    }
+}
+
+static inline void gpio_output_set(volatile gpio_t *gpio, uint8_t pin, uint8_t output)
+{
+    int regnum = pin / 10;
+    int offset = (pin % 10) * 3;
+    uint8_t function = output ? 1 : 0;  // See datasheet for mapping
+
+    gpio->fsel[regnum] &= ~(0x7 << offset);
+    gpio->fsel[regnum] |= ((function & 0x7) << offset);
+}
+
+#endif /* __GPIO_H__ */

data/ext/ws2811/pwm.c

@@ -0,0 +1,112 @@
+/*
+ * pwm.c
+ *
+ * Copyright (c) 2014 Jeremy Garff <jer @ jers.net>
+ *
+ * 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.
+ *     3.  Neither the name of the owner nor the names of its contributors may be used to endorse
+ *         or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include <stdint.h>
+
+#include "ws2811.h"
+
+#include "pwm.h"
+
+
+// Mapping of Pin to alternate function for PWM channel 0
+const pwm_pin_table_t pwm_pin_chan0[] =
+{
+    {
+        .pinnum = 12,
+        .altnum = 0,
+    },
+    {
+        .pinnum = 18,
+        .altnum = 5,
+    },
+    {
+        .pinnum = 40,
+        .altnum = 0,
+    },
+    {
+        .pinnum = 52,
+        .altnum = 1,
+    },
+};
+
+// Mapping of Pin to alternate function for PWM channel 1
+const pwm_pin_table_t pwm_pin_chan1[] =
+{
+    {
+        .pinnum = 13,
+        .altnum = 0,
+    },
+    {
+        .pinnum = 19,
+        .altnum = 5,
+    },
+    {
+        .pinnum = 41,
+        .altnum = 0,
+    },
+    {
+        .pinnum = 45,
+        .altnum = 0,
+    },
+    {
+        .pinnum = 53,
+        .altnum = 1,
+    },
+};
+
+const pwm_pin_tables_t pwm_pin_tables[RPI_PWM_CHANNELS] =
+{
+    {
+        .pins = pwm_pin_chan0,
+        .count = sizeof(pwm_pin_chan0) / sizeof(pwm_pin_chan0[0]),
+    },
+    {
+        .pins = pwm_pin_chan1,
+        .count = sizeof(pwm_pin_chan1) / sizeof(pwm_pin_chan1[0]),
+    },
+};
+
+
+int pwm_pin_alt(int chan, int pinnum)
+{
+    const pwm_pin_tables_t *pintable = &pwm_pin_tables[chan];
+    int i;
+
+    for (i = 0; i < pintable->count; i++)
+    {
+        if (pintable->pins[i].pinnum == pinnum)
+        {
+            return pintable->pins[i].altnum;
+        }
+    }
+
+    return -1;
+}
+

data/ext/ws2811/pwm.h

@@ -0,0 +1,122 @@
+/*
+ * pwm.h
+ *
+ * Copyright (c) 2014 Jeremy Garff <jer @ jers.net>
+ *
+ * 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.
+ *     3.  Neither the name of the owner nor the names of its contributors may be used to endorse
+ *         or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER 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.
+ *
+ */
+
+#ifndef __PWM_H__
+#define __PWM_H__
+
+
+/*
+ *
+ * Pin mappint of alternate pin configuration for PWM
+ *
+ * GPIO    ALT PWM0   ALT PWM1
+ *
+ *  12        0
+ *  13                   0
+ *  18        5
+ *  19                   5
+ *  40        0
+ *  41                   0
+ *  45                   0
+ *  52        1
+ *  53                   1
+ *
+ */
+
+
+#define RPI_PWM_CHANNELS                         2
+
+
+typedef struct
+{
+    uint32_t ctl;
+#define RPI_PWM_CTL_MSEN2                        (1 << 15)
+#define RPI_PWM_CTL_USEF2                        (1 << 13)
+#define RPI_PWM_CTL_POLA2                        (1 << 12)
+#define RPI_PWM_CTL_SBIT2                        (1 << 11)
+#define RPI_PWM_CTL_RPTL2                        (1 << 10)
+#define RPI_PWM_CTL_MODE2                        (1 << 9)
+#define RPI_PWM_CTL_PWEN2                        (1 << 8)
+#define RPI_PWM_CTL_MSEN1                        (1 << 7)
+#define RPI_PWM_CTL_CLRF1                        (1 << 6)
+#define RPI_PWM_CTL_USEF1                        (1 << 5)
+#define RPI_PWM_CTL_POLA1                        (1 << 4)
+#define RPI_PWM_CTL_SBIT1                        (1 << 3)
+#define RPI_PWM_CTL_RPTL1                        (1 << 2)
+#define RPI_PWM_CTL_MODE1                        (1 << 1)
+#define RPI_PWM_CTL_PWEN1                        (1 << 0)
+    uint32_t sta;
+#define RPI_PWM_STA_STA4                         (1 << 12)
+#define RPI_PWM_STA_STA3                         (1 << 11)
+#define RPI_PWM_STA_STA2                         (1 << 10)
+#define RPI_PWM_STA_STA1                         (1 << 9)
+#define RPI_PWM_STA_BERR                         (1 << 8)
+#define RPI_PWM_STA_GAP04                        (1 << 7)
+#define RPI_PWM_STA_GAP03                        (1 << 6)
+#define RPI_PWM_STA_GAP02                        (1 << 5)
+#define RPI_PWM_STA_GAP01                        (1 << 4)
+#define RPI_PWM_STA_RERR1                        (1 << 3)
+#define RPI_PWM_STA_WERR1                        (1 << 2)
+#define RPI_PWM_STA_EMPT1                        (1 << 1)
+#define RPI_PWM_STA_FULL1                        (1 << 0)
+    uint32_t dmac;
+#define RPI_PWM_DMAC_ENAB                        (1 << 31)
+#define RPI_PWM_DMAC_PANIC(val)                  ((val & 0xff) << 8)
+#define RPI_PWM_DMAC_DREQ(val)                   ((val & 0xff) << 0)
+    uint32_t resvd_0x0c;
+    uint32_t rng1;
+    uint32_t dat1;
+    uint32_t fif1;
+    uint32_t resvd_0x1c;
+    uint32_t rng2;
+    uint32_t dat2;
+} __attribute__((packed)) pwm_t;
+
+
+#define PWM                                      (0x2020c000)  // 0x7e20c000
+#define PWM_PERIPH                               (0x7e20c000)
+
+
+typedef struct
+{
+    int pinnum;
+    int altnum;
+} pwm_pin_table_t;
+
+typedef struct 
+{
+    const int count;
+    const pwm_pin_table_t *pins;
+} pwm_pin_tables_t;
+
+
+int pwm_pin_alt(int chan, int pinnum);
+
+
+#endif /* __PWM_H__ */