circuitpython/ports/broadcom/common-hal/busio/SPI.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

346 lines
10 KiB
C
Raw Normal View History

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Scott Shawcroft for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "shared-bindings/busio/SPI.h"
#include "shared/runtime/interrupt_char.h"
#include "py/mperrno.h"
#include "py/runtime.h"
#include "supervisor/board.h"
#include "common-hal/microcontroller/Pin.h"
#include "shared-bindings/microcontroller/Pin.h"
#include "peripherals/broadcom/cpu.h"
#include "peripherals/broadcom/defines.h"
#include "peripherals/broadcom/gpio.h"
#include "peripherals/broadcom/pins.h"
#include "peripherals/broadcom/vcmailbox.h"
#if BCM_VERSION == 2711
#define NUM_SPI (7)
STATIC SPI0_Type *spi[NUM_SPI] = {SPI0, NULL, NULL, SPI3, SPI4, SPI5, SPI6};
STATIC SPI1_Type *aux_spi[NUM_SPI] = {NULL, SPI1, SPI2, NULL, NULL, NULL, NULL};
#else
#define NUM_SPI (3)
STATIC SPI0_Type *spi[NUM_SPI] = {SPI0, NULL, NULL};
STATIC SPI1_Type *aux_spi[NUM_SPI] = {NULL, SPI1, SPI2};
#endif
STATIC bool never_reset_spi[NUM_SPI];
STATIC bool spi_in_use[NUM_SPI];
void reset_spi(void) {
for (size_t i = 0; i < NUM_SPI; i++) {
if (never_reset_spi[i]) {
continue;
}
if (i == 1 || i == 2) {
if (i == 1) {
AUX->ENABLES_b.SPI_1 = false;
} else {
AUX->ENABLES_b.SPI_2 = false;
}
aux_spi[i]->CNTL0 = 0;
} else {
// Set CS back to default. All 0 except read enable.
spi[i]->CS = SPI0_CS_REN_Msk;
}
spi_in_use[i] = false;
}
}
void common_hal_busio_spi_construct(busio_spi_obj_t *self,
const mcu_pin_obj_t *clock, const mcu_pin_obj_t *mosi,
const mcu_pin_obj_t *miso, bool half_duplex) {
size_t instance_index = NUM_SPI;
BP_Function_Enum clock_alt = 0;
BP_Function_Enum mosi_alt = 0;
BP_Function_Enum miso_alt = 0;
if (half_duplex) {
mp_raise_NotImplementedError(translate("Half duplex SPI is not implemented"));
}
for (size_t i = 0; i < NUM_SPI; i++) {
if (spi_in_use[i]) {
continue;
}
if (!pin_find_alt(clock, PIN_FUNCTION_SPI, i, SPI_FUNCTION_SCLK, &clock_alt)) {
continue;
}
if (mosi != NULL && !pin_find_alt(mosi, PIN_FUNCTION_SPI, i, SPI_FUNCTION_MOSI, &mosi_alt)) {
continue;
}
if (miso != NULL && !pin_find_alt(miso, PIN_FUNCTION_SPI, i, SPI_FUNCTION_MISO, &miso_alt)) {
continue;
}
instance_index = i;
break;
}
if (instance_index == NUM_SPI) {
mp_raise_ValueError(translate("Invalid pins"));
}
self->clock = clock;
self->MOSI = mosi;
self->MISO = miso;
self->index = instance_index;
spi_in_use[instance_index] = true;
if (instance_index == 1) {
AUX->ENABLES_b.SPI_1 = true;
} else if (instance_index == 2) {
AUX->ENABLES_b.SPI_2 = true;
}
common_hal_busio_spi_configure(self, 250000, 0, 0, 8);
COMPLETE_MEMORY_READS;
gpio_set_pull(clock->number, BP_PULL_NONE);
gpio_set_function(clock->number, clock_alt);
if (mosi != NULL) {
gpio_set_pull(mosi->number, BP_PULL_NONE);
gpio_set_function(mosi->number, mosi_alt);
}
if (miso != NULL) {
gpio_set_pull(miso->number, BP_PULL_NONE);
gpio_set_function(miso->number, miso_alt);
}
}
void common_hal_busio_spi_never_reset(busio_spi_obj_t *self) {
never_reset_spi[self->index] = true;
common_hal_never_reset_pin(self->clock);
common_hal_never_reset_pin(self->MOSI);
common_hal_never_reset_pin(self->MISO);
}
bool common_hal_busio_spi_deinited(busio_spi_obj_t *self) {
return self->clock == NULL;
}
void common_hal_busio_spi_deinit(busio_spi_obj_t *self) {
if (common_hal_busio_spi_deinited(self)) {
return;
}
never_reset_spi[self->index] = false;
common_hal_reset_pin(self->clock);
common_hal_reset_pin(self->MOSI);
common_hal_reset_pin(self->MISO);
self->clock = NULL;
if (self->index == 1 ||
self->index == 2) {
aux_spi[self->index]->CNTL0_b.ENABLE = false;
if (self->index == 1) {
AUX->ENABLES_b.SPI_1 = false;
} else if (self->index == 2) {
AUX->ENABLES_b.SPI_2 = false;
}
}
}
bool common_hal_busio_spi_configure(busio_spi_obj_t *self,
uint32_t baudrate, uint8_t polarity, uint8_t phase, uint8_t bits) {
if (baudrate == self->target_frequency &&
polarity == self->polarity &&
phase == self->phase &&
bits == self->bits) {
return true;
}
if (self->index == 1 || self->index == 2) {
SPI1_Type *p = aux_spi[self->index];
uint32_t source_clock = vcmailbox_get_clock_rate_measured(VCMAILBOX_CLOCK_CORE);
uint16_t clock_divider = source_clock / baudrate;
if (source_clock % baudrate > 0) {
clock_divider += 2;
}
p->CNTL0 = (clock_divider / 2 - 1) << SPI1_CNTL0_SPEED_Pos |
SPI1_CNTL0_ENABLE_Msk |
SPI1_CNTL0_MSB_FIRST_Msk |
(polarity == 1? SPI1_CNTL0_INVERT_CLK_Msk : 0) |
(phase == polarity? SPI1_CNTL0_IN_RISING_Msk : SPI1_CNTL0_OUT_RISING_Msk) |
8 << SPI1_CNTL0_SHIFT_LENGTH_Pos;
p->CNTL1 = SPI1_CNTL1_MSB_FIRST_Msk;
self->real_frequency = source_clock / clock_divider;
} else {
SPI0_Type *p = spi[self->index];
p->CS = polarity << SPI0_CS_CPOL_Pos |
phase << SPI0_CS_CPHA_Pos;
uint32_t source_clock = vcmailbox_get_clock_rate_measured(VCMAILBOX_CLOCK_CORE);
uint16_t clock_divider = source_clock / baudrate;
if (source_clock % baudrate > 0) {
clock_divider += 2;
}
p->CLK = clock_divider;
self->real_frequency = source_clock / clock_divider;
}
self->polarity = polarity;
self->phase = phase;
self->bits = bits;
self->target_frequency = baudrate;
return true;
}
bool common_hal_busio_spi_try_lock(busio_spi_obj_t *self) {
bool grabbed_lock = false;
if (!self->has_lock) {
grabbed_lock = true;
self->has_lock = true;
}
return grabbed_lock;
}
bool common_hal_busio_spi_has_lock(busio_spi_obj_t *self) {
return self->has_lock;
}
void common_hal_busio_spi_unlock(busio_spi_obj_t *self) {
self->has_lock = false;
}
STATIC void _spi_transfer(SPI0_Type *p,
const uint8_t *data_out, size_t out_len,
uint8_t *data_in, size_t in_len) {
size_t len = MAX(out_len, in_len);
COMPLETE_MEMORY_READS;
p->DLEN = len;
p->CS |= SPI0_CS_TA_Msk | SPI0_CS_CLEAR_Msk;
size_t in = 0;
size_t out = 0;
while (in < len) {
while (out < len && p->CS_b.TXD == 1) {
if (out_len == 1) {
p->FIFO = data_out[0];
} else {
p->FIFO = data_out[out];
}
out++;
}
// Wait for data to read (also means data has been sent.)
while (p->CS_b.RXD == 0) {
RUN_BACKGROUND_TASKS;
}
while (p->CS_b.RXD == 1) {
uint8_t data = p->FIFO;
if (data_in != NULL) {
data_in[in] = data;
} else {
(void)data;
}
in++;
}
}
p->CS_b.TA = false;
COMPLETE_MEMORY_READS;
}
STATIC void _aux_spi_transfer(SPI1_Type *p,
const uint8_t *data_out, size_t out_len,
uint8_t *data_in, size_t in_len) {
size_t len = MAX(out_len, in_len);
p->CNTL0 |= SPI1_CNTL0_CLEAR_FIFOS_Msk;
p->CNTL0 &= ~SPI1_CNTL0_CLEAR_FIFOS_Msk;
size_t in = 0;
size_t out = 0;
while (in < len) {
while (out < len && p->STAT_b.TX_FULL == 0) {
if (out_len == 1) {
p->TXHOLD0 = data_out[0] << 24;
} else {
p->TXHOLD0 = data_out[out] << 24;
}
out++;
}
// Wait for data to read (also means data has been sent.)
while (p->STAT_b.RX_EMPTY == 1) {
RUN_BACKGROUND_TASKS;
}
while (p->STAT_b.RX_EMPTY == 0) {
uint8_t data = p->TXHOLD0;
if (data_in != NULL) {
data_in[in] = data;
} else {
(void)data;
}
in++;
}
}
}
bool common_hal_busio_spi_write(busio_spi_obj_t *self,
const uint8_t *data, size_t len) {
if (self->index == 1 || self->index == 2) {
_aux_spi_transfer(aux_spi[self->index], data, len, NULL, 0);
} else {
_spi_transfer(spi[self->index], data, len, NULL, 0);
}
return true;
}
bool common_hal_busio_spi_read(busio_spi_obj_t *self,
uint8_t *data, size_t len, uint8_t write_value) {
if (self->index == 1 || self->index == 2) {
_aux_spi_transfer(aux_spi[self->index], &write_value, 1, data, len);
} else {
_spi_transfer(spi[self->index], &write_value, 1, data, len);
}
return true;
}
bool common_hal_busio_spi_transfer(busio_spi_obj_t *self,
const uint8_t *data_out, uint8_t *data_in, size_t len) {
if (self->index == 1 || self->index == 2) {
_aux_spi_transfer(aux_spi[self->index], data_out, len, data_in, len);
} else {
_spi_transfer(spi[self->index], data_out, len, data_in, len);
}
return true;
}
uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t *self) {
return self->real_frequency;
}
uint8_t common_hal_busio_spi_get_phase(busio_spi_obj_t *self) {
return self->phase;
}
uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t *self) {
return self->polarity;
}