Subversion Repositories s80186

// Copyright Jamie Iles, 2017
//
// This file is part of s80x86.
//
// s80x86 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 3 of the License, or
// (at your option) any later version.
//
// s80x86 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 s80x86.  If not, see <http://www.gnu.org/licenses/>.
 
#include "io.h"
#include "serial.h"
#include "bios.h"
#include "utils.h"
 
#define SPI_CONTROL_PORT 0xfff0
#define SPI_TRANSFER_PORT 0xfff2
#define SPI_XFER_BUSY (1 << 8)
#define SPI_CS_DEACTIVATE (1 << 9)
 
static char spi_xfer_buf[1280];
static char sd_is_sdhc;
 
static void noinline spi_xfer_buf_set(int offs, unsigned char v)
{
    spi_xfer_buf[offs] = v;
}
 
static unsigned char noinline spi_xfer_buf_get(int offs)
{
    return spi_xfer_buf[offs];
}
 
static void spi_wait_idle(void)
{
    while (inw(SPI_TRANSFER_PORT) & SPI_XFER_BUSY)
        continue;
}
 
static void spi_xfer(int len)
{
    int i;
 
    for (i = 0; i < len; ++i) {
        outw(SPI_TRANSFER_PORT, spi_xfer_buf_get(i));
        spi_wait_idle();
        spi_xfer_buf_set(i, inw(SPI_TRANSFER_PORT) & 0xff);
    }
}
 
static void sd_send_initial_clock(void)
{
    int i;
 
    for (i = 0; i < 8; ++i)
        spi_xfer_buf_set(i, 0xff);
    // No CS, slow clock
    outw(SPI_CONTROL_PORT, SPI_CS_DEACTIVATE | 0x1ff);
 
    spi_xfer(8);
}
 
static void sd_flush_fifo(void)
{
    int i;
 
    for (i = 0; i < 128; ++i)
        spi_xfer_buf_set(i, 0xff);
    // No CS, slow clock
    outw(SPI_CONTROL_PORT, 0x1ff);
 
    spi_xfer(8);
}
 
struct spi_cmd {
    unsigned char cmd;
    unsigned char arg[4];
    unsigned char crc;
 
    unsigned short data_seg;
    const void *data_addr;
    unsigned short tx_datalen;
    unsigned short rx_datalen;
};
 
struct r1_response {
    unsigned char v;
};
 
#define R1_ERROR_MASK 0xfe
#define SD_NCR 8
#define DATA_START_TOKEN 0xfe
#define BLOCK_SIZE 512
/* Maximum number of high bytes to read before a data start token. */
#define MAX_DATA_START_OFFS 512
 
static unsigned short spi_command_len(const struct spi_cmd *cmd)
{
    return 1 + 6 + cmd->tx_datalen + cmd->rx_datalen + SD_NCR;
}
 
static void spi_do_command(const struct spi_cmd *cmd)
{
    int m, cmdlen;
 
    cmdlen = spi_command_len(cmd);
 
    // The command.
    spi_xfer_buf_set(0, 0xff);
    spi_xfer_buf_set(1, cmd->cmd);
    for (m = 0; m < 4; ++m)
        spi_xfer_buf_set(2 + m, cmd->arg[m]);
    spi_xfer_buf_set(6, cmd->crc);
    // Transmit data.
    memcpy_seg(get_cs(), spi_xfer_buf + 7, cmd->data_seg, cmd->data_addr,
               cmd->tx_datalen);
    // Initialize receive buffer so we don't shift out new, garbage data.
    for (m = 7 + cmd->tx_datalen; m < cmdlen; ++m)
        spi_xfer_buf_set(m, 0xff);
 
    // Fast clock, CS enabled.
    outw(SPI_CONTROL_PORT, 0x1);
    spi_xfer(cmdlen);
}
 
static int find_r1_response(struct r1_response *r1)
{
    int i;
 
    r1->v = 0;
 
    for (i = 0; i < sizeof(spi_xfer_buf) / sizeof(spi_xfer_buf[0]); ++i)
        if (spi_xfer_buf_get(i) != 0xff) {
            r1->v = spi_xfer_buf_get(i);
            break;
        }
 
    if (i == sizeof(spi_xfer_buf))
        return -1;
 
    return i;
}
 
static int sd_send_reset(void)
{
    struct spi_cmd cmd = {
        .cmd = 0x40, .crc = 0x95, .rx_datalen = 1,
    };
    struct r1_response r1;
 
    spi_do_command(&cmd);
    if (find_r1_response(&r1) < 0)
        return -1;
 
    return r1.v & R1_ERROR_MASK;
}
 
static int sd_send_if_cond(void)
{
    struct spi_cmd cmd = {
        .cmd = 0x48,
        .crc = 0x87,
        .arg = {0x00, 0x00, 0x01, 0xaa},
        .rx_datalen = 1,
    };
    struct r1_response r1;
 
    spi_do_command(&cmd);
    if (find_r1_response(&r1) < 0)
        return -1;
 
    return r1.v & R1_ERROR_MASK;
}
 
static int sd_send_read_ocr(void)
{
    struct spi_cmd cmd = {
        .cmd = 0x7a, .rx_datalen = 5,
    };
    struct r1_response r1;
 
    spi_do_command(&cmd);
    int r1_offs = find_r1_response(&r1);
    if (r1_offs < 0)
        return -1;
 
    union {
        unsigned char u8[4];
        unsigned long u32;
    } converter = {
        .u8 =
            {
                spi_xfer_buf_get(r1_offs + 4), spi_xfer_buf_get(r1_offs + 3),
                spi_xfer_buf_get(r1_offs + 2), spi_xfer_buf_get(r1_offs + 1),
            },
    };
 
    if (converter.u32 & (1LU << 30))
        sd_is_sdhc = 1;
    else
        sd_is_sdhc = 0;
 
    return r1.v & R1_ERROR_MASK;
}
 
static int send_acmd(void)
{
    struct spi_cmd cmd = {
        .cmd = 0x77, .arg = {0x00, 0x00, 0x00, 0x00}, .rx_datalen = 1,
    };
    struct r1_response r1;
 
    spi_do_command(&cmd);
    if (find_r1_response(&r1) < 0)
        return -1;
 
    return r1.v & R1_ERROR_MASK;
}
 
static int sd_wait_ready(void)
{
    struct r1_response r1 = {};
 
    do {
        struct spi_cmd cmd = {
            .cmd = 0x69, .arg = {0x40, 0x00, 0x00, 0x00}, .rx_datalen = 1,
        };
        int rc = send_acmd();
 
        if (rc)
            return rc;
 
        spi_do_command(&cmd);
        if (find_r1_response(&r1) < 0)
            return -1;
 
        if (r1.v & R1_ERROR_MASK)
            return r1.v & R1_ERROR_MASK;
    } while (r1.v & 0x1);
 
    return 0;
}
 
static int sd_set_blocklen(void)
{
    struct spi_cmd cmd = {
        .cmd = 0x50,
        /* BLOCK_SIZE bytes */
        .arg = {0x00, 0x00, 0x02, 0x00},
        .rx_datalen = 1,
    };
    struct r1_response r1;
 
    spi_do_command(&cmd);
    if (find_r1_response(&r1) < 0)
        return -1;
 
    return r1.v & R1_ERROR_MASK;
}
 
static int find_data_start(int r1offs)
{
    ++r1offs;
    while (spi_xfer_buf_get(r1offs) != DATA_START_TOKEN &&
           r1offs < sizeof(spi_xfer_buf))
        ++r1offs;
 
    return r1offs == sizeof(spi_xfer_buf) ? -1 : r1offs + 1;
}
 
static int noinline sd_make_write_request(unsigned long address)
{
    struct spi_cmd cmd = {
        .cmd = 0x58, .rx_datalen = 1,
    };
    struct r1_response r1;
 
    cmd.arg[0] = (address >> 24) & 0xff;
    cmd.arg[1] = (address >> 16) & 0xff;
    cmd.arg[2] = (address >> 8) & 0xff;
    cmd.arg[3] = (address >> 0) & 0xff;
 
    spi_do_command(&cmd);
    if (find_r1_response(&r1) < 0)
        return -1;
 
    return r1.v & R1_ERROR_MASK;
}
 
static void noinline sd_write_block(unsigned short sseg, unsigned short saddr)
{
    spi_xfer_buf_set(0, 0xff); // Gap
    spi_xfer_buf_set(1, 0xfe); // Data start token
    memcpy_seg(get_cs(), spi_xfer_buf + 2, sseg, (const void *)saddr, 512);
    spi_xfer_buf_set(2 + 512, 0x0);  // CRC1
    spi_xfer_buf_set(3 + 512, 0x0);  // CRC2
    spi_xfer_buf_set(4 + 512, 0xff); // Packet response
 
    spi_xfer(5 + 512);
}
 
static int noinline write_received(unsigned char packet_response)
{
    return (packet_response & 0x1) && ((packet_response >> 1) & 0x7) == 0x2;
}
 
static int noinline wait_for_write_completion(void)
{
    int i = 0;
 
    for (i = 0; i < 4096; ++i) {
        spi_xfer_buf_set(0, 0xff);
        spi_xfer(1);
        if (spi_xfer_buf_get(0) != 0)
            return 0;
    }
 
    return -1;
}
 
int write_sector(unsigned short sector,
                 unsigned short sseg,
                 unsigned short saddr)
{
    unsigned long address = sector;
 
    if (!sd_is_sdhc)
        address *= 512;
 
    if (sd_make_write_request(address))
        return -1;
 
    sd_write_block(sseg, saddr);
 
    unsigned char packet_response = spi_xfer_buf_get(4 + 512);
    if (!write_received(packet_response))
        return -1;
 
    return wait_for_write_completion();
}
 
int read_sector(unsigned short sector,
                unsigned short dseg,
                unsigned short daddr)
{
    struct spi_cmd cmd = {
        .cmd = 0x51,
        /* r1, start token, data, CRC16 */
        .rx_datalen = 1 + 1 + BLOCK_SIZE + 2 + MAX_DATA_START_OFFS,
    };
    struct r1_response r1;
    int r1offs, data_start;
    unsigned long address = sector;
 
    if (!sd_is_sdhc)
        address *= 512;
 
    cmd.arg[0] = (address >> 24) & 0xff;
    cmd.arg[1] = (address >> 16) & 0xff;
    cmd.arg[2] = (address >> 8) & 0xff;
    cmd.arg[3] = (address >> 0) & 0xff;
 
    spi_do_command(&cmd);
    r1offs = find_r1_response(&r1);
    if (r1offs < 0) {
        putstr("Failed to find R1 response\n");
        return -1;
    }
    if (r1.v & R1_ERROR_MASK) {
        putstr("Read sector failed\n");
        return -1;
    }
 
    data_start = find_data_start(r1offs);
    if (data_start < 0) {
        putstr("No data start token\n");
        return -1;
    }
 
    memcpy_seg(dseg, (void *)daddr, get_cs(), spi_xfer_buf + data_start, 512);
 
    return 0;
}
 
void sd_init(void)
{
    sd_send_initial_clock();
    sd_flush_fifo();
    if (sd_send_reset())
        panic("Failed to reset SD card");
    if (sd_send_if_cond())
        panic("Failed to send interface conditions to SD card");
    if (sd_send_read_ocr())
        panic("Failed to read OCR for SD card");
    if (sd_wait_ready())
        panic("Failed to wait for SD card init");
    if (sd_send_read_ocr())
        panic("Failed to re-read OCR for SD card");
    if (sd_set_blocklen())
        panic("Failed to wait for SD card init");
 
    putstr("SD card ready\n");
}
 
void sd_boot(void)
{
    if (read_sector(0, 0, 0x7c00))
        panic("Failed to read boot sector\n");
 
    putstr("Booting from SD card...\n");
    asm volatile(
        "mov $0x80, %dl\n"
        "jmp $0x0000, $0x7c00");
}