static gpio_priv_t* init()
{
gpio_priv_t* ctx = malloc(sizeof(gpio_priv_t));
int save_error;
if (ctx != NULL) {
if ((ctx->vaddr = map_registers(GPIO_BASE, GPIO_LEN)) == MAP_FAILED)
goto error;
ctx->base[0] = ctx->vaddr;
ctx->base[1] = (uint32_t*) (ctx->vaddr + 0x4);
}
return ctx;
error:
save_error = errno;
final(ctx);
int init(){
uint32_t revision = getBoardRev();
uint32_t offset = ((revision == 0xa01041 || revision == 0xa21041)?0x1F000000:0);
if(revision == 0xa01041)
revision = 0x10;//pi2 has B+ pinout
else if(revision == 0xa21041)
revision = 0x13;//pi2 has B+ pinout
if(revision >= PINMASKS_LEN || !rpi_model_pinmasks[revision]){
fprintf(stderr, "UNKNOWN_REVISION: 0x%08X\n", revision);
return 1;
}
if(map_registers(offset))
return 1;
_board_revision = revision;
init_pins();
srand(time(NULL));
return 0;
}
/**
* @return Return 0 on success and not 1 on failure.
*/
int init(){
RASPBERRY_PI_INFO_T info;
getRaspberryPiInformation(&info);
uint32_t offset = info.peripheralBase - 0x20000000;
if (info.model == RPI_MODEL_B_PI_2 || info.model == RPI_MODEL_ZERO) {
info.revisionNumber = 0x10;
}
if(info.revisionNumber >= PINMASKS_LEN || !rpi_model_pinmasks[info.revisionNumber]){
fprintf(stderr, "UNKNOWN_REVISION: 0x%08X\n", info.revisionNumber);
return 1;
}
if(map_registers(offset))
return 1;
_board_revision = info.revisionNumber;
init_pins();
srand(time(NULL));
return 0;
}
/**
* Allocate and initialize memory, buffers, pages, PWM, DMA, and GPIO.
*
* @param ws2811 ws2811 instance pointer.
*
* @returns 0 on success, -1 otherwise.
*/
int ws2811_init(ws2811_t *ws2811)
{
ws2811_device_t *device = NULL;
int chan;
// Zero mbox; non-zero values indicate action needed on cleanup
memset(&mbox, 0, sizeof(mbox));
ws2811->device = malloc(sizeof(*ws2811->device));
if (!ws2811->device)
{
return -1;
}
device = ws2811->device;
// Determine how much physical memory we need for DMA
mbox.size = PWM_BYTE_COUNT(max_channel_led_count(ws2811), ws2811->freq) +
+ sizeof(dma_cb_t);
// Round up to page size multiple
mbox.size = (mbox.size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
// Use the mailbox interface to request memory from the VideoCore
// We specifiy (-1) for the handle rather than calling mbox_open()
// so multiple users can share the resource.
mbox.handle = -1; // mbox_open();
mbox.mem_ref = mem_alloc(mbox.handle, mbox.size, PAGE_SIZE,
board_info_sdram_address() == 0x40000000 ? 0xC : 0x4);
if (mbox.mem_ref == (unsigned) ~0)
{
return -1;
}
mbox.bus_addr = mem_lock(mbox.handle, mbox.mem_ref);
if (mbox.bus_addr == (unsigned) ~0)
{
mem_free(mbox.handle, mbox.size);
return -1;
}
mbox.virt_addr = mapmem(BUS_TO_PHYS(mbox.bus_addr), mbox.size);
// Initialize all pointers to NULL. Any non-NULL pointers will be freed on cleanup.
device->pwm_raw = NULL;
device->dma_cb = NULL;
for (chan = 0; chan < RPI_PWM_CHANNELS; chan++)
{
ws2811->channel[chan].leds = NULL;
}
// Allocate the LED buffers
for (chan = 0; chan < RPI_PWM_CHANNELS; chan++)
{
ws2811_channel_t *channel = &ws2811->channel[chan];
channel->leds = malloc(sizeof(ws2811_led_t) * channel->count);
if (!channel->leds)
{
goto err;
}
memset(channel->leds, 0, sizeof(ws2811_led_t) * channel->count);
}
device->dma_cb = (dma_cb_t *)mbox.virt_addr;
device->pwm_raw = (uint8_t *)mbox.virt_addr + sizeof(dma_cb_t);
pwm_raw_init(ws2811);
memset((dma_cb_t *)device->dma_cb, 0, sizeof(dma_cb_t));
// Cache the DMA control block bus address
device->dma_cb_addr = addr_to_bus(device->dma_cb);
// Map the physical registers into userspace
if (map_registers(ws2811))
{
goto err;
}
// Initialize the GPIO pins
if (gpio_init(ws2811))
{
unmap_registers(ws2811);
goto err;
}
// Setup the PWM, clocks, and DMA
if (setup_pwm(ws2811))
{
unmap_registers(ws2811);
goto err;
}
return 0;
err:
ws2811_cleanup(ws2811);
return -1;
}
/**
* Allocate and initialize memory, buffers, pages, PWM, DMA, and GPIO.
*
* @param ws2811 ws2811 instance pointer.
*
* @returns 0 on success, -1 otherwise.
*/
int ws2811_init(ws2811_t *ws2811)
{
ws2811_device_t *device;
const rpi_hw_t *rpi_hw;
int chan;
ws2811->rpi_hw = rpi_hw_detect();
if (!ws2811->rpi_hw)
{
return -1;
}
rpi_hw = ws2811->rpi_hw;
ws2811->device = malloc(sizeof(*ws2811->device));
if (!ws2811->device)
{
return -1;
}
device = ws2811->device;
// Determine how much physical memory we need for DMA
device->mbox.size = PWM_BYTE_COUNT(max_channel_led_count(ws2811), ws2811->freq) +
sizeof(dma_cb_t);
// Round up to page size multiple
device->mbox.size = (device->mbox.size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
device->mbox.handle = mbox_open();
if (device->mbox.handle == -1)
{
return -1;
}
device->mbox.mem_ref = mem_alloc(device->mbox.handle, device->mbox.size, PAGE_SIZE,
rpi_hw->videocore_base == 0x40000000 ? 0xC : 0x4);
if (device->mbox.mem_ref == 0)
{
return -1;
}
device->mbox.bus_addr = mem_lock(device->mbox.handle, device->mbox.mem_ref);
if (device->mbox.bus_addr == (uint32_t) ~0UL)
{
mem_free(device->mbox.handle, device->mbox.size);
return -1;
}
device->mbox.virt_addr = mapmem(BUS_TO_PHYS(device->mbox.bus_addr), device->mbox.size);
// Initialize all pointers to NULL. Any non-NULL pointers will be freed on cleanup.
device->pwm_raw = NULL;
device->dma_cb = NULL;
for (chan = 0; chan < RPI_PWM_CHANNELS; chan++)
{
ws2811->channel[chan].leds = NULL;
}
// Allocate the LED buffers
for (chan = 0; chan < RPI_PWM_CHANNELS; chan++)
{
ws2811_channel_t *channel = &ws2811->channel[chan];
channel->leds = malloc(sizeof(ws2811_led_t) * channel->count);
if (!channel->leds)
{
goto err;
}
memset(channel->leds, 0, sizeof(ws2811_led_t) * channel->count);
if (!channel->strip_type)
{
channel->strip_type=WS2811_STRIP_RGB;
}
}
device->dma_cb = (dma_cb_t *)device->mbox.virt_addr;
device->pwm_raw = (uint8_t *)device->mbox.virt_addr + sizeof(dma_cb_t);
pwm_raw_init(ws2811);
memset((dma_cb_t *)device->dma_cb, 0, sizeof(dma_cb_t));
// Cache the DMA control block bus address
device->dma_cb_addr = addr_to_bus(device, device->dma_cb);
// Map the physical registers into userspace
if (map_registers(ws2811))
{
goto err;
}
// Initialize the GPIO pins
if (gpio_init(ws2811))
{
unmap_registers(ws2811);
goto err;
}
// Setup the PWM, clocks, and DMA
if (setup_pwm(ws2811))
{
unmap_registers(ws2811);
goto err;
}
return 0;
err:
ws2811_cleanup(ws2811);
return -1;
}
