cec148c247
Most of the protocol modules for the pata_parport driver are missing a module description, causing warnings such as: WARNING: modpost: missing MODULE_DESCRIPTION() in drivers/ata/pata_parport/aten.o when compiling with W=1. Add the missing MODULE_DESCRIPTION() definitions to avoid these warnings. While at it, also add the missing MODULE_AUTHOR() definitions. Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
465 lines
13 KiB
C
465 lines
13 KiB
C
// 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);
|