mac-rom-simm-programmer/hal/at90usb646/parallel_bus.c
2023-06-25 11:38:41 -07:00

734 lines
22 KiB
C

/*
* parallel_bus.c
*
* Created on: Nov 26, 2011
* Author: Doug
*
* Copyright (C) 2011-2023 Doug Brown
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* -----------------------------------------------------------------------------
*
* For some reason, avr-gcc is super inefficient dealing with uint32_t
* variables. Looking at the individual bytes using a union results in much
* more optimized code. Every cycle counts for this. So several of these
* functions may seem weird with the unions, but it's faster than operating
* directly with the uint32_t variables.
*
* There are also a few time-critical places where I had to bypass the GPIO and
* SPI drivers, so it's not 100% clean. Oh well...
*/
#include "../parallel_bus.h"
#include "../../drivers/mcp23s17.h"
#include "../../util.h"
#include "gpio_hw.h"
#include <avr/io.h>
/// The port object where the OE, WE, and CS pins are connected
/// (This also happens to be where the MCP control pins are connected)
#define FLASH_CONTROL_PORT PORTB
/// The index of the MCP23S17 chip select pin
#define MCP_CS_PIN 0
/// The index of the CS pin
#define FLASH_CS_PIN 4
/// The index of the OE pin
#define FLASH_OE_PIN 5
/// The index of the WE pin
#define FLASH_WE_PIN 6
/// The index of the MCP23S17 reset pin
#define MCP_RESET_PIN 7
/// The index of the highest address line on the parallel bus
#define PARALLEL_BUS_HIGHEST_ADDRESS_LINE 20
static ALWAYS_INLINE uint8_t SPITransfer(uint8_t byte);
static ALWAYS_INLINE void SPITransferNoRead(uint8_t byte);
static ALWAYS_INLINE void AssertControl(uint8_t pin);
static ALWAYS_INLINE void DeassertControl(uint8_t pin);
/// The MCP23S17 device
static MCP23S17 mcp23s17 = {
.spi = {
.csPin = {GPIOB, MCP_CS_PIN}
}
};
/// The reset pin for the MCP23S17
static const GPIOPin mcpReset = {GPIOB, MCP_RESET_PIN};
/// The /WE pin for the parallel bus
static const GPIOPin flashWEPin = {GPIOB, FLASH_WE_PIN};
/// The /OE pin for the parallel bus
static const GPIOPin flashOEPin = {GPIOB, FLASH_OE_PIN};
/// The /CS pin for the flash chip
static const GPIOPin flashCSPin = {GPIOB, FLASH_CS_PIN};
/// Whether or not data pins are outputs
static bool dataIsOutput;
/** Initializes the 32-bit data/21-bit address parallel bus.
*
*/
void ParallelBus_Init(void)
{
static bool mcpInited = false;
if (!mcpInited)
{
// Set up the MCP23S17
SPI_InitController(SPI_Controller(0));
mcp23s17.spi.controller = SPI_Controller(0);
MCP23S17_Init(&mcp23s17, mcpReset);
// Go ahead and let the MCP23S17 take over the SPI bus forever.
// There's nothing else attached to it.
MCP23S17_Begin(&mcp23s17);
mcpInited = true;
}
// Configure all address lines as outputs, outputting address 0
ParallelBus_SetAddressDir((1UL << (PARALLEL_BUS_HIGHEST_ADDRESS_LINE + 1)) - 1);
ParallelBus_SetAddress(0);
// Set all data lines to pulled-up inputs
ParallelBus_SetDataDir(0);
ParallelBus_SetDataPullups(0xFFFFFFFFUL);
dataIsOutput = false;
// Note: During normal operation of read/write cycles, the pullups in the
// MCP23S17 will remember they are enabled, so we can do an optimization
// when using ParallelBus_ReadCycle/WriteCycle and assume they are already
// pulled up. This means we'll bypass ParallelBus_SetDataPullups.
// Control lines
ParallelBus_SetCSDir(true);
ParallelBus_SetOEDir(true);
ParallelBus_SetWEDir(true);
// Default to only CS asserted
DeassertControl(FLASH_WE_PIN);
DeassertControl(FLASH_OE_PIN);
AssertControl(FLASH_CS_PIN);
}
/** Sets the address being output on the 21-bit address bus
*
* @param address The address
*/
void ParallelBus_SetAddress(uint32_t address)
{
// For efficiency, we talk directly to the PORT registers in this function,
// rather than going through the GPIO class.
// NOTE: If any of PORTA or PORTC or PORTD pins 0, 1, 4, 5, or 6 are set as
// inputs, this function might mess with their pull-up resistors.
// Only use it under normal operation when all the address pins are being
// used as outputs.
union {
uint32_t addr;
uint8_t addrBytes[4];
} u;
u.addr = address;
PORTA = u.addrBytes[0]; // A0-A7
PORTC = u.addrBytes[1]; // A8-A15
// A16-A20 are special because they are split up...(We use PORTD pins 0, 1, 4, 5, 6)
u.addrBytes[2] = (u.addrBytes[2] & 0x03) | (uint8_t)((u.addrBytes[2] & 0x1C) << 2) | (PORTD & 0x8C);
PORTD = u.addrBytes[2];
}
/** Sets the output data on the 32-bit data bus
*
* @param data The data
*/
void ParallelBus_SetData(uint32_t data)
{
// For efficiency, we talk directly to the PORT registers in this function,
// rather than going through the GPIO class.
// NOTE: If any pins of PORTE or PORTF are set as inputs, this
// function might mess with their pull-up resistors.
// Only use it under normal operation when all the data pins are being
// used as outputs
union {
uint32_t data;
uint16_t dataShorts[2];
uint8_t dataBytes[4];
} u;
u.data = data;
// Doing the AVR registers first makes it so we don't have to use the stack
// (at least according to my testing with avr-gcc)
PORTE = u.dataBytes[1]; // D16-D23
PORTF = u.dataBytes[0]; // D24-D31
// D0-D15 are part of the MCP23S17
MCP23S17_SetOutputs(&mcp23s17, u.dataShorts[1]);
}
/** Sets the output value of the CS pin
*
* @param high True if it should be high, false if low
*/
void ParallelBus_SetCS(bool high)
{
GPIO_Set(flashCSPin, high);
}
/** Sets the output value of the OE pin
*
* @param high True if it should be high, false if low
*/
void ParallelBus_SetOE(bool high)
{
GPIO_Set(flashOEPin, high);
}
/** Sets the output value of the WE pin
*
* @param high True if it should be high, false if low
*/
void ParallelBus_SetWE(bool high)
{
GPIO_Set(flashWEPin, high);
}
/** Sets which pins on the 21-bit address bus should be outputs
*
* @param outputs Mask of pins that should be outputs. 1 = output, 0 = input
*
* Typically the address pins will be outputs. This flexibility is provided in
* case we want to do electrical testing.
*/
void ParallelBus_SetAddressDir(uint32_t outputs)
{
DDRA = (outputs & 0xFF); // A0-A7
DDRC = ((outputs >> 8) & 0xFF); // A8-A15
// A16-A20 are special because they are split up...(We use PORTD pins 0, 1, 4, 5, 6)
uint8_t tmp = (outputs >> 16) & 0xFF;
tmp = (tmp & 0x03) | ((tmp & 0x1C) << 2);
// Now, turn off the DDR bits we have to turn off,
// and turn on the DDR bits we have to turn on
// (without affecting other bits [2, 3, and 7]
// that we aren't supposed to touch)
DDRD &= (0x8C | tmp); // This should turn off all '0' bits in tmp.
DDRD |= tmp; // This should turn on all '1' bits in tmp
}
/** Sets which pins on the 32-bit data bus should be outputs
*
* @param outputs Mask of pins that should be outputs. 1 = output, 0 = input
*
* Typically all pins would be set as inputs or outputs, and it's automatically
* handled by the read/write cycle functions. This function exists mainly for
* test purposes.
*/
void ParallelBus_SetDataDir(uint32_t outputs)
{
union {
uint32_t data;
uint16_t dataShorts[2];
uint8_t dataBytes[4];
} u;
u.data = outputs;
// Doing the AVR registers first makes it so we don't have to use the stack
DDRE = u.dataBytes[1]; // D16-D23
DDRF = u.dataBytes[0]; // D24-D31
// D0-D15 are part of the MCP23S17
MCP23S17_SetDDR(&mcp23s17, u.dataShorts[1]);
// If none of the pins are outputs, ensure dataIsOutput is false
if (outputs == 0)
{
dataIsOutput = false;
}
// If all of the pins are outputs, ensure dataIsOutput is true
else if (outputs == 0xFFFFFFFFUL)
{
dataIsOutput = true;
}
}
/** Sets the direction of the CS pin
*
* @param output True if it's an output, false if it's an input
*
* Typically this pin will be an output. This flexibility is provided in case
* we want to do electrical testing.
*/
void ParallelBus_SetCSDir(bool output)
{
GPIO_SetDirection(flashCSPin, output);
}
/** Sets the direction of the OE pin
*
* @param output True if it's an output, false if it's an input
*
* Typically this pin will be an output. This flexibility is provided in case
* we want to do electrical testing.
*/
void ParallelBus_SetOEDir(bool output)
{
GPIO_SetDirection(flashOEPin, output);
}
/** Sets the direction of the WE pin
*
* @param output True if it's an output, false if it's an input
*
* Typically this pin will be an output. This flexibility is provided in case
* we want to do electrical testing.
*/
void ParallelBus_SetWEDir(bool output)
{
GPIO_SetDirection(flashWEPin, output);
}
/** Sets which pins on the 21-bit address bus should be pulled up (if inputs)
*
* @param pullups Mask of pins that should be pullups.
*
* This would typically only be used for testing. Under normal operation, the
* address bus will be outputting, so the pullups are irrelevant.
*/
void ParallelBus_SetAddressPullups(uint32_t pullups)
{
// Pull-ups are set by writing to the data register when in input mode.
// MAKE SURE THE PINS ARE SET AS INPUTS FIRST! This is a cheat only
// possible on the AVR. Some places like SIMMElectricalTest call SetAddress
// followed by SetAddressPullups, which is kinda weird because it sets the
// same registers. But the way it's called doesn't hurt anything...
ParallelBus_SetAddress(pullups);
}
/** Sets which pins on the 32-bit data bus should be pulled up (if inputs)
*
* @param pullups Mask of pins that should be pullups.
*
* Typically these will be enabled in order to provide a default value if a
* chip isn't responding properly. Sometimes it's useful to customize it during
* testing though.
*/
void ParallelBus_SetDataPullups(uint32_t pullups)
{
// NOTE: If any pins of PORTE or PORTF are set as outputs, this
// function might mess with their output values.
// Only use it when all the data pins are being used as inputs
union {
uint32_t data;
uint16_t dataShorts[2];
uint8_t dataBytes[4];
} u;
u.data = pullups;
PORTE = u.dataBytes[1]; // D16-D23
PORTF = u.dataBytes[0]; // D24-D31
// D0-D15 are part of the MCP23S17
MCP23S17_SetPullups(&mcp23s17, u.dataShorts[1]);
}
/** Sets whether the CS pin is pulled up, if it's an input.
*
* @param pullup True if the CS pin should be pulled up, false if not
*
* This would typically only be used for testing. Under normal operation, this
* pin will be set as an output, so the pullup state is irrelevant.
*/
void ParallelBus_SetCSPullup(bool pullup)
{
GPIO_SetPullup(flashCSPin, pullup);
}
/** Sets whether the OE pin is pulled up, if it's an input.
*
* @param pullup True if the OE pin should be pulled up, false if not
*
* This would typically only be used for testing. Under normal operation, this
* pin will be set as an output, so the pullup state is irrelevant.
*/
void ParallelBus_SetOEPullup(bool pullup)
{
GPIO_SetPullup(flashOEPin, pullup);
}
/** Sets whether the WE pin is pulled up, if it's an input.
*
* @param pullup True if the WE pin should be pulled up, false if not
*
* This would typically only be used for testing. Under normal operation, this
* pin will be set as an output, so the pullup state is irrelevant.
*/
void ParallelBus_SetWEPullup(bool pullup)
{
GPIO_SetPullup(flashWEPin, pullup);
}
/** Reads the current data on the address bus.
*
* @return The address bus readback
*
* This would typically only be used for testing. Under normal operation, the
* address bus will be outputting, so the readback is irrelevant.
*/
uint32_t ParallelBus_ReadAddress(void)
{
uint32_t result = PINA;
result |= (((uint32_t)PINC) << 8);
uint8_t tmp = (PIND & 0x03) | ((PIND & 0x70) >> 2);
result |= (((uint32_t)tmp) << 16);
return result;
}
/** Reads the current data on the 32-bit data bus.
*
* @return The 32-bit data readback
*/
uint32_t ParallelBus_ReadData(void)
{
union {
uint32_t data;
uint16_t dataShorts[2];
uint8_t dataBytes[4];
} u;
u.dataShorts[1] = MCP23S17_ReadInputs(&mcp23s17);
// Grab the other two bytes...
u.dataBytes[1] = PINE;
u.dataBytes[0] = PINF;
return u.data;
}
/** Reads the status of the CS pin, if it's set as an input.
*
* @return True if the CS pin is high, false if it's low
*
* This would typically only be used for testing. Under normal operation, this
* pin will be set as an output, so the readback is irrelevant.
*/
bool ParallelBus_ReadCS(void)
{
return GPIO_Read(flashCSPin);
}
/** Reads the status of the OE pin, if it's set as an input.
*
* @return True if the OE pin is high, false if it's low
*
* This would typically only be used for testing. Under normal operation, this
* pin will be set as an output, so the readback is irrelevant.
*/
bool ParallelBus_ReadOE(void)
{
return GPIO_Read(flashOEPin);
}
/** Reads the status of the WE pin, if it's set as an input.
*
* @return True if the WE pin is high, false if it's low
*
* This would typically only be used for testing. Under normal operation, this
* pin will be set as an output, so the readback is irrelevant.
*/
bool ParallelBus_ReadWE(void)
{
return GPIO_Read(flashWEPin);
}
/** Performs a write cycle on the parallel bus.
*
* @param address The address to write to
* @param data The 32-bit data to write to the bus
*
* Because this function is used a lot during programming, it is super
* optimized and bypasses the GPIO and SPI drivers. It's a necessary evil.
* It makes a big difference in programming time.
*/
void ParallelBus_WriteCycle(uint32_t address, uint32_t data)
{
// Using this union surprisingly speeds things up when assembling or
// interpreting a uint32_t on the AVR.
union {
uint32_t word;
uint8_t bytes[4];
} u;
// We should currently be in a state of "CS is asserted, OE/WE not asserted".
// As an optimization, operate under that assumption.
// Set address. This is basically the exact same code as ParallelBus_SetAddress,
// but repeated in here so we don't have any function call overhead.
u.word = address;
PORTA = u.bytes[0];
PORTC = u.bytes[1];
u.bytes[2] = (u.bytes[2] & 0x03) | (uint8_t)((u.bytes[2] & 0x1C) << 2) | (PORTD & 0x8C);
PORTD = u.bytes[2];
// If the data port is not already set as outputs, set it to be outputs now
if (!dataIsOutput)
{
// Set data as outputs. Bypass the SPI/GPIO drivers for this for efficiency.
DDRE = 0xFF;
DDRF = 0xFF;
AssertControl(MCP_CS_PIN);
SPITransferNoRead(MCP23S17_CONTROL_WRITE(0));
SPITransferNoRead(MCP23S17_IODIRA);
SPITransferNoRead(0);
SPITransferNoRead(0);
DeassertControl(MCP_CS_PIN);
dataIsOutput = true;
}
// Set data. Bypass the SPI/GPIO drivers again...
u.word = data;
PORTE = u.bytes[1];
PORTF = u.bytes[0];
AssertControl(MCP_CS_PIN);
SPITransferNoRead(MCP23S17_CONTROL_WRITE(0));
SPITransferNoRead(MCP23S17_GPIOA);
SPITransferNoRead(u.bytes[3]);
SPITransferNoRead(u.bytes[2]);
DeassertControl(MCP_CS_PIN);
// Assert and then deassert WE to actually do the write cycle.
AssertControl(FLASH_WE_PIN);
DeassertControl(FLASH_WE_PIN);
// Control lines are left as "CS asserted, OE/WE not asserted" here.
}
/** Performs a read cycle on the parallel bus.
*
* @param address The address to read from
* @return The returned 32-bit data
*
* Because this function is used a lot during programming, it is super
* optimized and bypasses the GPIO and SPI drivers. It's a necessary evil.
* It makes a big difference in programming time.
*/
uint32_t ParallelBus_ReadCycle(uint32_t address)
{
// Using this union surprisingly speeds things up when assembling or
// interpreting a uint32_t on the AVR.
union {
uint32_t word;
uint8_t bytes[4];
} u;
// We should currently be in a state of "CS is asserted, OE/WE not asserted".
// As an optimization, operate under that assumption.
// If the data pins are set as outputs, change them to inputs
if (dataIsOutput)
{
// Set data as inputs. Bypass the SPI/GPIO drivers for this for efficiency.
DDRE = 0;
DDRF = 0;
AssertControl(MCP_CS_PIN);
SPITransferNoRead(MCP23S17_CONTROL_WRITE(0));
SPITransferNoRead(MCP23S17_IODIRA);
SPITransferNoRead(0xFF);
SPITransferNoRead(0xFF);
DeassertControl(MCP_CS_PIN);
// Set pull-ups on the AVR data pins so we get a default value if a chip
// isn't responding. We can assume the MCP23S17 has already been configured
// to have its inputs pulled up. On the AVR we can't assume because its
// pull-up state is shared by the same register used for data output.
PORTE = 0xFF;
PORTF = 0xFF;
dataIsOutput = false;
}
// Assert OE so we start reading from the chip. Safe to do now that
// the data pins have been set as inputs.
AssertControl(FLASH_OE_PIN);
// Set address. This is basically the exact same code as ParallelBus_SetAddress,
// but repeated in here so we don't have any function call overhead.
u.word = address;
PORTA = u.bytes[0];
PORTC = u.bytes[1];
u.bytes[2] = (u.bytes[2] & 0x03) | (uint8_t)((u.bytes[2] & 0x1C) << 2) | (PORTD & 0x8C);
PORTD = u.bytes[2];
// Start the SPI read. Each clock cycle at 16 MHz is 62.5 nanoseconds. We don't want to
// immediately read back the data bus until the address has settled, so do some SPI
// preparation in the meantime.
AssertControl(MCP_CS_PIN);
SPITransferNoRead(MCP23S17_CONTROL_READ(0));
SPITransferNoRead(MCP23S17_GPIOA);
// Read data. Bypass the GPIO/SPI drivers again...
u.bytes[1] = PINE;
u.bytes[0] = PINF;
u.bytes[3] = SPITransfer(0);
u.bytes[2] = SPITransfer(0);
DeassertControl(MCP_CS_PIN);
// Deassert OE, and we're done.
DeassertControl(FLASH_OE_PIN);
// Control lines are left as "CS asserted, OE/WE not asserted" here.
// Return the final value
return u.word;
}
/** Reads a bunch of consecutive data from the parallel bus
*
* @param startAddress The address to start reading from
* @param buf Buffer to store the readback
* @param len The number of 32-bit words to read
*
* This function is just a time saver if we know we will be reading a big block
* of data. It doesn't bother playing with the control lines between each byte.
*/
void ParallelBus_Read(uint32_t startAddress, uint32_t *buf, uint16_t len)
{
// We should currently be in a state of "CS is asserted, OE/WE not asserted".
// As an optimization, operate under that assumption.
// Using this union surprisingly speeds things up when assembling or
// interpreting a uint32_t on the AVR.
union {
uint32_t word;
uint8_t bytes[4];
} u;
// If the data pins are set as outputs, change them to inputs
if (dataIsOutput)
{
// Set data as inputs. Bypass the SPI/GPIO drivers for this for efficiency.
DDRE = 0;
DDRF = 0;
AssertControl(MCP_CS_PIN);
SPITransferNoRead(MCP23S17_CONTROL_WRITE(0));
SPITransferNoRead(MCP23S17_IODIRA);
SPITransferNoRead(0xFF);
SPITransferNoRead(0xFF);
DeassertControl(MCP_CS_PIN);
// Set pull-ups on the AVR data pins so we get a default value if a chip
// isn't responding. We can assume the MCP23S17 has already been configured
// to have its inputs pulled up. On the AVR we can't assume because its
// pull-up state is shared by the same register used for data output.
PORTE = 0xFF;
PORTF = 0xFF;
dataIsOutput = false;
}
// Assert OE, now the chip will start spitting out data.
AssertControl(FLASH_OE_PIN);
while (len--)
{
// Set address. This is basically the exact same code as ParallelBus_SetAddress,
// but repeated in here so we don't have any function call overhead.
u.word = startAddress++;
PORTA = u.bytes[0];
PORTC = u.bytes[1];
u.bytes[2] = (u.bytes[2] & 0x03) | (uint8_t)((u.bytes[2] & 0x1C) << 2) | (PORTD & 0x8C);
PORTD = u.bytes[2];
// Start the SPI read. Each clock cycle at 16 MHz is 62.5 nanoseconds. We don't want to
// immediately read back the data bus until the address has settled, so do some SPI
// preparation in the meantime.
AssertControl(MCP_CS_PIN);
SPITransferNoRead(MCP23S17_CONTROL_READ(0));
SPITransferNoRead(MCP23S17_GPIOA);
// Read data. Bypass the GPIO/SPI drivers again...
u.bytes[1] = PINE;
u.bytes[0] = PINF;
u.bytes[3] = SPITransfer(0);
u.bytes[2] = SPITransfer(0);
DeassertControl(MCP_CS_PIN);
*buf++ = u.word;
}
// Deassert OE once we are done
DeassertControl(FLASH_OE_PIN);
// Control lines are left as "CS asserted, OE/WE not asserted" here.
}
/** Writes/reads a byte to/from the MCP23S17. More optimal than using the driver.
*
* @param byte The byte to write
* @return The byte read back
*/
static ALWAYS_INLINE uint8_t SPITransfer(uint8_t byte)
{
SPDR = byte;
// Crazy optimization. Instead of waiting for the status register
// (see the commented-out "while" statement below), wait for 17 clock
// cycles instead. We know that our SPI bit rate is half the CPU clock.
// After 17 clock cycles, the entire byte has been written out.
__asm__ __volatile__ ("nop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\n");
__asm__ __volatile__ ("nop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\n");
__asm__ __volatile__ ("nop\n");
//while (!(SPSR & (1 << SPIF)));
return SPDR;
}
/** Writes a byte to the MCP23S17 without reading back the result. More optimal
* than using the driver.
*
* @param byte The byte to write
*/
static ALWAYS_INLINE void SPITransferNoRead(uint8_t byte)
{
SPDR = byte;
// Crazy optimization. Instead of waiting for the status register
// (see the commented-out "while" statement below), wait for 17 clock
// cycles instead. We know that our SPI bit rate is half the CPU clock.
// After 17 clock cycles, the entire byte has been written out.
__asm__ __volatile__ ("nop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\n");
__asm__ __volatile__ ("nop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\n");
__asm__ __volatile__ ("nop\n");
//while (!(SPSR & (1 << SPIF)));
}
/** Asserts a control pin
*
* @param pin Pin number of the control pin to assert
*
* This is slightly faster than using the GPIO driver because it inlines directly
* to a port RMW operation. Just a small optimization for performance.
*/
static ALWAYS_INLINE void AssertControl(uint8_t pin)
{
FLASH_CONTROL_PORT &= ~(1 << pin);
}
/** Deasserts a control pin
*
* @param pin Pin number of the control pin to deassert
*
* This is slightly faster than using the GPIO driver because it inlines directly
* to a port RMW operation. Just a small optimization for performance.
*/
static ALWAYS_INLINE void DeassertControl(uint8_t pin)
{
FLASH_CONTROL_PORT |= (1 << pin);
}