// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * (c) 2001 Micro Solutions Inc.
 *
 * backpack.c is a low-level protocol driver for the Micro Solutions
 * "BACKPACK" parallel port IDE adapter (works on Series 6 drives).
 *
 * Written by: Ken Hahn (linux-dev@micro-solutions.com)
 *             Clive Turvey (linux-dev@micro-solutions.com)
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/parport.h>
#include "pata_parport.h"

/* 60772 Commands */
#define ACCESS_REG              0x00
#define ACCESS_PORT             0x40

#define ACCESS_READ             0x00
#define ACCESS_WRITE            0x20

/* 60772 Command Prefix */
#define CMD_PREFIX_SET          0xe0    // Special command that modifies next command's operation
#define CMD_PREFIX_RESET        0xc0    // Resets current cmd modifier reg bits
 #define PREFIX_IO16            0x01    // perform 16-bit wide I/O
 #define PREFIX_FASTWR          0x04    // enable PPC mode fast-write
 #define PREFIX_BLK             0x08    // enable block transfer mode

/* 60772 Registers */
#define REG_STATUS              0x00    // status register
 #define STATUS_IRQA            0x01    // Peripheral IRQA line
 #define STATUS_EEPROM_DO       0x40    // Serial EEPROM data bit
#define REG_VERSION             0x01    // PPC version register (read)
#define REG_HWCFG               0x02    // Hardware Config register
#define REG_RAMSIZE             0x03    // Size of RAM Buffer
 #define RAMSIZE_128K           0x02
#define REG_EEPROM              0x06    // EEPROM control register
 #define EEPROM_SK              0x01    // eeprom SK bit
 #define EEPROM_DI              0x02    // eeprom DI bit
 #define EEPROM_CS              0x04    // eeprom CS bit
 #define EEPROM_EN              0x08    // eeprom output enable
#define REG_BLKSIZE             0x08    // Block transfer len (24 bit)

/* flags */
#define fifo_wait               0x10

/* DONT CHANGE THESE LEST YOU BREAK EVERYTHING - BIT FIELD DEPENDENCIES */
#define PPCMODE_UNI_SW          0
#define PPCMODE_UNI_FW          1
#define PPCMODE_BI_SW           2
#define PPCMODE_BI_FW           3
#define PPCMODE_EPP_BYTE        4
#define PPCMODE_EPP_WORD        5
#define PPCMODE_EPP_DWORD       6

static int mode_map[] = { PPCMODE_UNI_FW, PPCMODE_BI_FW, PPCMODE_EPP_BYTE,
                          PPCMODE_EPP_WORD, PPCMODE_EPP_DWORD };

static void bpck6_send_cmd(struct pi_adapter *pi, u8 cmd)
{
        switch (mode_map[pi->mode]) {
        case PPCMODE_UNI_SW:
        case PPCMODE_UNI_FW:
        case PPCMODE_BI_SW:
        case PPCMODE_BI_FW:
                parport_write_data(pi->pardev->port, cmd);
                parport_frob_control(pi->pardev->port, 0, PARPORT_CONTROL_AUTOFD);
                break;
        case PPCMODE_EPP_BYTE:
        case PPCMODE_EPP_WORD:
        case PPCMODE_EPP_DWORD:
                pi->pardev->port->ops->epp_write_addr(pi->pardev->port, &cmd, 1, 0);
                break;
        }
}

static u8 bpck6_rd_data_byte(struct pi_adapter *pi)
{
        u8 data = 0;

        switch (mode_map[pi->mode]) {
        case PPCMODE_UNI_SW:
        case PPCMODE_UNI_FW:
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE,
                                                        PARPORT_CONTROL_INIT);
                data = parport_read_status(pi->pardev->port);
                data = ((data & 0x80) >> 1) | ((data & 0x38) >> 3);
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE,
                                                        PARPORT_CONTROL_STROBE);
                data |= parport_read_status(pi->pardev->port) & 0xB8;
                break;
        case PPCMODE_BI_SW:
        case PPCMODE_BI_FW:
                parport_data_reverse(pi->pardev->port);
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE,
                                PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT);
                data = parport_read_data(pi->pardev->port);
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE, 0);
                parport_data_forward(pi->pardev->port);
                break;
        case PPCMODE_EPP_BYTE:
        case PPCMODE_EPP_WORD:
        case PPCMODE_EPP_DWORD:
                pi->pardev->port->ops->epp_read_data(pi->pardev->port, &data, 1, 0);
                break;
        }

        return data;
}

static void bpck6_wr_data_byte(struct pi_adapter *pi, u8 data)
{
        switch (mode_map[pi->mode]) {
        case PPCMODE_UNI_SW:
        case PPCMODE_UNI_FW:
        case PPCMODE_BI_SW:
        case PPCMODE_BI_FW:
                parport_write_data(pi->pardev->port, data);
                parport_frob_control(pi->pardev->port, 0, PARPORT_CONTROL_INIT);
                break;
        case PPCMODE_EPP_BYTE:
        case PPCMODE_EPP_WORD:
        case PPCMODE_EPP_DWORD:
                pi->pardev->port->ops->epp_write_data(pi->pardev->port, &data, 1, 0);
                break;
        }
}

static int bpck6_read_regr(struct pi_adapter *pi, int cont, int reg)
{
        u8 port = cont ? reg | 8 : reg;

        bpck6_send_cmd(pi, port | ACCESS_PORT | ACCESS_READ);
        return bpck6_rd_data_byte(pi);
}

static void bpck6_write_regr(struct pi_adapter *pi, int cont, int reg, int val)
{
        u8 port = cont ? reg | 8 : reg;

        bpck6_send_cmd(pi, port | ACCESS_PORT | ACCESS_WRITE);
        bpck6_wr_data_byte(pi, val);
}

static void bpck6_wait_for_fifo(struct pi_adapter *pi)
{
        int i;

        if (pi->private & fifo_wait) {
                for (i = 0; i < 20; i++)
                        parport_read_status(pi->pardev->port);
        }
}

static void bpck6_write_block(struct pi_adapter *pi, char *buf, int len)
{
        u8 this, last;

        bpck6_send_cmd(pi, REG_BLKSIZE | ACCESS_REG | ACCESS_WRITE);
        bpck6_wr_data_byte(pi, (u8)len);
        bpck6_wr_data_byte(pi, (u8)(len >> 8));
        bpck6_wr_data_byte(pi, 0);

        bpck6_send_cmd(pi, CMD_PREFIX_SET | PREFIX_IO16 | PREFIX_BLK);
        bpck6_send_cmd(pi, ATA_REG_DATA | ACCESS_PORT | ACCESS_WRITE);

        switch (mode_map[pi->mode]) {
        case PPCMODE_UNI_SW:
        case PPCMODE_BI_SW:
                while (len--) {
                        parport_write_data(pi->pardev->port, *buf++);
                        parport_frob_control(pi->pardev->port, 0,
                                                        PARPORT_CONTROL_INIT);
                }
                break;
        case PPCMODE_UNI_FW:
        case PPCMODE_BI_FW:
                bpck6_send_cmd(pi, CMD_PREFIX_SET | PREFIX_FASTWR);

                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE,
                                                        PARPORT_CONTROL_STROBE);

                last = *buf;

                parport_write_data(pi->pardev->port, last);

                while (len) {
                        this = *buf++;
                        len--;

                        if (this == last) {
                                parport_frob_control(pi->pardev->port, 0,
                                                        PARPORT_CONTROL_INIT);
                        } else {
                                parport_write_data(pi->pardev->port, this);
                                last = this;
                        }
                }

                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE,
                                                        0);
                bpck6_send_cmd(pi, CMD_PREFIX_RESET | PREFIX_FASTWR);
                break;
        case PPCMODE_EPP_BYTE:
                pi->pardev->port->ops->epp_write_data(pi->pardev->port, buf,
                                                len, PARPORT_EPP_FAST_8);
                bpck6_wait_for_fifo(pi);
                break;
        case PPCMODE_EPP_WORD:
                pi->pardev->port->ops->epp_write_data(pi->pardev->port, buf,
                                                len, PARPORT_EPP_FAST_16);
                bpck6_wait_for_fifo(pi);
                break;
        case PPCMODE_EPP_DWORD:
                pi->pardev->port->ops->epp_write_data(pi->pardev->port, buf,
                                                len, PARPORT_EPP_FAST_32);
                bpck6_wait_for_fifo(pi);
                break;
        }

        bpck6_send_cmd(pi, CMD_PREFIX_RESET | PREFIX_IO16 | PREFIX_BLK);
}

static void bpck6_read_block(struct pi_adapter *pi, char *buf, int len)
{
        bpck6_send_cmd(pi, REG_BLKSIZE | ACCESS_REG | ACCESS_WRITE);
        bpck6_wr_data_byte(pi, (u8)len);
        bpck6_wr_data_byte(pi, (u8)(len >> 8));
        bpck6_wr_data_byte(pi, 0);

        bpck6_send_cmd(pi, CMD_PREFIX_SET | PREFIX_IO16 | PREFIX_BLK);
        bpck6_send_cmd(pi, ATA_REG_DATA | ACCESS_PORT | ACCESS_READ);

        switch (mode_map[pi->mode]) {
        case PPCMODE_UNI_SW:
        case PPCMODE_UNI_FW:
                while (len) {
                        u8 d;

                        parport_frob_control(pi->pardev->port,
                                        PARPORT_CONTROL_STROBE,
                                        PARPORT_CONTROL_INIT); /* DATA STROBE */
                        d = parport_read_status(pi->pardev->port);
                        d = ((d & 0x80) >> 1) | ((d & 0x38) >> 3);
                        parport_frob_control(pi->pardev->port,
                                        PARPORT_CONTROL_STROBE,
                                        PARPORT_CONTROL_STROBE);
                        d |= parport_read_status(pi->pardev->port) & 0xB8;
                        *buf++ = d;
                        len--;
                }
                break;
        case PPCMODE_BI_SW:
        case PPCMODE_BI_FW:
                parport_data_reverse(pi->pardev->port);
                while (len) {
                        parport_frob_control(pi->pardev->port,
                                PARPORT_CONTROL_STROBE,
                                PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT);
                        *buf++ = parport_read_data(pi->pardev->port);
                        len--;
                }
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_STROBE,
                                        0);
                parport_data_forward(pi->pardev->port);
                break;
        case PPCMODE_EPP_BYTE:
                pi->pardev->port->ops->epp_read_data(pi->pardev->port, buf, len,
                                                PARPORT_EPP_FAST_8);
                break;
        case PPCMODE_EPP_WORD:
                pi->pardev->port->ops->epp_read_data(pi->pardev->port, buf, len,
                                                PARPORT_EPP_FAST_16);
                break;
        case PPCMODE_EPP_DWORD:
                pi->pardev->port->ops->epp_read_data(pi->pardev->port, buf, len,
                                                PARPORT_EPP_FAST_32);
                break;
        }

        bpck6_send_cmd(pi, CMD_PREFIX_RESET | PREFIX_IO16 | PREFIX_BLK);
}

static int bpck6_open(struct pi_adapter *pi)
{
        u8 i, j, k;

        pi->saved_r0 = parport_read_data(pi->pardev->port);
        pi->saved_r2 = parport_read_control(pi->pardev->port) & 0x5F;

        parport_frob_control(pi->pardev->port, PARPORT_CONTROL_SELECT,
                                                PARPORT_CONTROL_SELECT);
        if (pi->saved_r0 == 'b')
                parport_write_data(pi->pardev->port, 'x');
        parport_write_data(pi->pardev->port, 'b');
        parport_write_data(pi->pardev->port, 'p');
        parport_write_data(pi->pardev->port, pi->unit);
        parport_write_data(pi->pardev->port, ~pi->unit);

        parport_frob_control(pi->pardev->port, PARPORT_CONTROL_SELECT, 0);
        parport_write_control(pi->pardev->port, PARPORT_CONTROL_INIT);

        i = mode_map[pi->mode] & 0x0C;
        if (i == 0)
                i = (mode_map[pi->mode] & 2) | 1;
        parport_write_data(pi->pardev->port, i);

        parport_frob_control(pi->pardev->port, PARPORT_CONTROL_SELECT,
                                                PARPORT_CONTROL_SELECT);
        parport_frob_control(pi->pardev->port, PARPORT_CONTROL_AUTOFD,
                                                PARPORT_CONTROL_AUTOFD);

        j = ((i & 0x08) << 4) | ((i & 0x07) << 3);
        k = parport_read_status(pi->pardev->port) & 0xB8;
        if (j != k)
                goto fail;

        parport_frob_control(pi->pardev->port, PARPORT_CONTROL_AUTOFD, 0);
        k = (parport_read_status(pi->pardev->port) & 0xB8) ^ 0xB8;
        if (j != k)
                goto fail;

        if (i & 4) {
                /* EPP */
                parport_frob_control(pi->pardev->port,
                        PARPORT_CONTROL_SELECT | PARPORT_CONTROL_INIT, 0);
        } else {
                /* PPC/ECP */
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_SELECT, 0);
        }

        pi->private = 0;

        bpck6_send_cmd(pi, ACCESS_REG | ACCESS_WRITE | REG_RAMSIZE);
        bpck6_wr_data_byte(pi, RAMSIZE_128K);

        bpck6_send_cmd(pi, ACCESS_REG | ACCESS_READ | REG_VERSION);
        if ((bpck6_rd_data_byte(pi) & 0x3F) == 0x0C)
                pi->private |= fifo_wait;

        return 1;

fail:
        parport_write_control(pi->pardev->port, pi->saved_r2);
        parport_write_data(pi->pardev->port, pi->saved_r0);

        return 0;
}

static void bpck6_deselect(struct pi_adapter *pi)
{
        if (mode_map[pi->mode] & 4) {
                /* EPP */
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_INIT,
                                     PARPORT_CONTROL_INIT);
        } else {
                /* PPC/ECP */
                parport_frob_control(pi->pardev->port, PARPORT_CONTROL_SELECT,
                                     PARPORT_CONTROL_SELECT);
        }

        parport_write_data(pi->pardev->port, pi->saved_r0);
        parport_write_control(pi->pardev->port,
                        pi->saved_r2 | PARPORT_CONTROL_SELECT);
        parport_write_control(pi->pardev->port, pi->saved_r2);
}

static void bpck6_wr_extout(struct pi_adapter *pi, u8 regdata)
{
        bpck6_send_cmd(pi, REG_VERSION | ACCESS_REG | ACCESS_WRITE);
        bpck6_wr_data_byte(pi, (u8)((regdata & 0x03) << 6));
}

static void bpck6_connect(struct pi_adapter *pi)
{
        dev_dbg(&pi->dev, "connect\n");

        bpck6_open(pi);
        bpck6_wr_extout(pi, 0x3);
}

static void bpck6_disconnect(struct pi_adapter *pi)
{
        dev_dbg(&pi->dev, "disconnect\n");
        bpck6_wr_extout(pi, 0x0);
        bpck6_deselect(pi);
}

/* check for 8-bit port */
static int bpck6_test_port(struct pi_adapter *pi)
{
        dev_dbg(&pi->dev, "PARPORT indicates modes=%x for lp=0x%lx\n",
                pi->pardev->port->modes, pi->pardev->port->base);

        /* look at the parport device to see what modes we can use */
        if (pi->pardev->port->modes & PARPORT_MODE_EPP)
                return 5; /* Can do EPP */
        if (pi->pardev->port->modes & PARPORT_MODE_TRISTATE)
                return 2;
        return 1; /* Just flat SPP */
}

static int bpck6_probe_unit(struct pi_adapter *pi)
{
        int out, saved_mode;

        dev_dbg(&pi->dev, "PROBE UNIT %x on port:%x\n", pi->unit, pi->port);

        saved_mode = pi->mode;
        /*LOWER DOWN TO UNIDIRECTIONAL*/
        pi->mode = 0;

        out = bpck6_open(pi);

        dev_dbg(&pi->dev, "ppc_open returned %2x\n", out);

        if (out) {
                bpck6_deselect(pi);
                dev_dbg(&pi->dev, "leaving probe\n");
                pi->mode = saved_mode;
                return 1;
        }

        dev_dbg(&pi->dev, "Failed open\n");
        pi->mode = saved_mode;

        return 0;
}

static void bpck6_log_adapter(struct pi_adapter *pi)
{
        char *mode_string[5] = { "4-bit", "8-bit", "EPP-8", "EPP-16", "EPP-32" };

        dev_info(&pi->dev,
                 "Micro Solutions BACKPACK Drive unit %d at 0x%x, mode:%d (%s), delay %d\n",
                 pi->unit, pi->port, pi->mode, mode_string[pi->mode], pi->delay);
}

static struct pi_protocol bpck6 = {
        .owner          = THIS_MODULE,
        .name           = "bpck6",
        .max_mode       = 5,
        .epp_first      = 2, /* 2-5 use epp (need 8 ports) */
        .max_units      = 255,
        .write_regr     = bpck6_write_regr,
        .read_regr      = bpck6_read_regr,
        .write_block    = bpck6_write_block,
        .read_block     = bpck6_read_block,
        .connect        = bpck6_connect,
        .disconnect     = bpck6_disconnect,
        .test_port      = bpck6_test_port,
        .probe_unit     = bpck6_probe_unit,
        .log_adapter    = bpck6_log_adapter,
};

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Micro Solutions Inc.");
MODULE_DESCRIPTION("Micro Solutions BACKPACK parallel port IDE adapter "
                   "(version 6 drives) protocol driver");
module_pata_parport_driver(bpck6);