Skip to content

L
linux
Commit d23a01c0 authored by Benjamin Herrenschmidt's avatar Benjamin Herrenschmidt Committed by Linus Torvalds
Browse files
Options

[PATCH] PowerMac: cleanup of some scsi drivers 

This patch from Christoph Hellwig does much welcomes cleanup of
the old mac53c94 and mesh SCSI drivers, removing sillycaps etc...
parent 9be7dd12
Hide whitespace changes
Inline Side-by-side
Showing with 59 additions and 56 deletions
drivers/scsi/mac53c94.c
View file @ d23a01c0
......@@ -25,8 +25,11 @@
#include <asm/pci-bridge.h>
#include <asm/macio.h>
#include "scsi.h"
#include "hosts.h"
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include "mac53c94.h"
enum fsc_phase {
......@@ -44,9 +47,9 @@ struct fsc_state {
int dmaintr;
int clk_freq;
struct Scsi_Host *host;
Scsi_Cmnd *request_q;
Scsi_Cmnd *request_qtail;
Scsi_Cmnd *current_req; /* req we're currently working on */
struct scsi_cmnd *request_q;
struct scsi_cmnd *request_qtail;
struct scsi_cmnd *current_req; /* req we're currently working on */
enum fsc_phase phase; /* what we're currently trying to do */
struct dbdma_cmd *dma_cmds; /* space for dbdma commands, aligned */
void *dma_cmd_space;
......@@ -60,15 +63,15 @@ static void mac53c94_start(struct fsc_state *);
static void mac53c94_interrupt(int, void *, struct pt_regs *);
static irqreturn_t do_mac53c94_interrupt(int, void *, struct pt_regs *);
static void cmd_done(struct fsc_state *, int result);
static void set_dma_cmds(struct fsc_state *, Scsi_Cmnd *);
static void set_dma_cmds(struct fsc_state *, struct scsi_cmnd *);
static int mac53c94_queue(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
static int mac53c94_queue(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
{
struct fsc_state *state;
#if 0
if (cmd->sc_data_direction == SCSI_DATA_WRITE) {
if (cmd->sc_data_direction == DMA_TO_DEVICE) {
int i;
printk(KERN_DEBUG "mac53c94_queue %p: command is", cmd);
for (i = 0; i < cmd->cmd_len; ++i)
......@@ -95,12 +98,12 @@ static int mac53c94_queue(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
return 0;
}
static int mac53c94_abort(Scsi_Cmnd *cmd)
static int mac53c94_abort(struct scsi_cmnd *cmd)
{
return SCSI_ABORT_SNOOZE;
return FAILED;
}
static int mac53c94_host_reset(Scsi_Cmnd *cmd)
static int mac53c94_host_reset(struct scsi_cmnd *cmd)
{
struct fsc_state *state = (struct fsc_state *) cmd->device->host->hostdata;
struct mac53c94_regs *regs = state->regs;
......@@ -139,7 +142,7 @@ static void mac53c94_init(struct fsc_state *state)
*/
static void mac53c94_start(struct fsc_state *state)
{
Scsi_Cmnd *cmd;
struct scsi_cmnd *cmd;
struct mac53c94_regs *regs = state->regs;
int i;
......@@ -148,7 +151,7 @@ static void mac53c94_start(struct fsc_state *state)
if (state->request_q == NULL)
return;
state->current_req = cmd = state->request_q;
state->request_q = (Scsi_Cmnd *) cmd->host_scribble;
state->request_q = (struct scsi_cmnd *) cmd->host_scribble;
/* Off we go */
writeb(0, &regs->count_lo);
......@@ -190,10 +193,9 @@ static void mac53c94_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
struct fsc_state *state = (struct fsc_state *) dev_id;
struct mac53c94_regs *regs = state->regs;
struct dbdma_regs *dma = state->dma;
Scsi_Cmnd *cmd = state->current_req;
struct scsi_cmnd *cmd = state->current_req;
int nb, stat, seq, intr;
static int mac53c94_errors;
int dma_dir;
/*
* Apparently, reading the interrupt register unlatches
......@@ -308,14 +310,13 @@ static void mac53c94_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
printk(KERN_DEBUG "intr %x before data xfer complete\n", intr);
}
writel(RUN << 16, &dma->control); /* stop dma */
dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
if (cmd->use_sg != 0) {
pci_unmap_sg(state->pdev,
(struct scatterlist *)cmd->request_buffer,
cmd->use_sg, dma_dir);
cmd->use_sg, cmd->sc_data_direction);
} else {
pci_unmap_single(state->pdev, state->dma_addr,
cmd->request_bufflen, dma_dir);
cmd->request_bufflen, cmd->sc_data_direction);
}
/* should check dma status */
writeb(CMD_I_COMPLETE, &regs->command);
......@@ -347,7 +348,7 @@ static void mac53c94_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
static void cmd_done(struct fsc_state *state, int result)
{
Scsi_Cmnd *cmd;
struct scsi_cmnd *cmd;
cmd = state->current_req;
if (cmd != 0) {
......@@ -362,24 +363,24 @@ static void cmd_done(struct fsc_state *state, int result)
/*
* Set up DMA commands for transferring data.
*/
static void set_dma_cmds(struct fsc_state *state, Scsi_Cmnd *cmd)
static void set_dma_cmds(struct fsc_state *state, struct scsi_cmnd *cmd)
{
int i, dma_cmd, total;
struct scatterlist *scl;
struct dbdma_cmd *dcmds;
dma_addr_t dma_addr;
u32 dma_len;
int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
dma_cmd = cmd->sc_data_direction == SCSI_DATA_WRITE? OUTPUT_MORE:
INPUT_MORE;
dma_cmd = cmd->sc_data_direction == DMA_TO_DEVICE ?
OUTPUT_MORE : INPUT_MORE;
dcmds = state->dma_cmds;
if (cmd->use_sg > 0) {
int nseg;
total = 0;
scl = (struct scatterlist *) cmd->buffer;
nseg = pci_map_sg(state->pdev, scl, cmd->use_sg, dma_dir);
nseg = pci_map_sg(state->pdev, scl, cmd->use_sg,
cmd->sc_data_direction);
for (i = 0; i < nseg; ++i) {
dma_addr = sg_dma_address(scl);
dma_len = sg_dma_len(scl);
......@@ -398,7 +399,7 @@ static void set_dma_cmds(struct fsc_state *state, Scsi_Cmnd *cmd)
if (total > 0xffff)
panic("mac53c94: transfer size >= 64k");
dma_addr = pci_map_single(state->pdev, cmd->request_buffer,
total, dma_dir);
total, cmd->sc_data_direction);
state->dma_addr = dma_addr;
st_le16(&dcmds->req_count, total);
st_le32(&dcmds->phy_addr, dma_addr);
......@@ -411,7 +412,7 @@ static void set_dma_cmds(struct fsc_state *state, Scsi_Cmnd *cmd)
cmd->SCp.this_residual = total;
}
static Scsi_Host_Template mac53c94_template = {
static struct scsi_host_template mac53c94_template = {
.proc_name = "53c94",
.name = "53C94",
.queuecommand = mac53c94_queue,
......
drivers/scsi/mesh.c
View file @ d23a01c0
......@@ -44,8 +44,11 @@
#include <asm/pci-bridge.h>
#include <asm/macio.h>
#include "scsi.h"
#include "hosts.h"
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include "mesh.h"
#if 1
......@@ -131,7 +134,7 @@ struct mesh_target {
enum sdtr_phase sdtr_state;
int sync_params;
int data_goes_out; /* guess as to data direction */
Scsi_Cmnd *current_req;
struct scsi_cmnd *current_req;
u32 saved_ptr;
#ifdef MESH_DBG
int log_ix;
......@@ -147,12 +150,12 @@ struct mesh_state {
int dmaintr;
struct Scsi_Host *host;
struct mesh_state *next;
Scsi_Cmnd *request_q;
Scsi_Cmnd *request_qtail;
struct scsi_cmnd *request_q;
struct scsi_cmnd *request_qtail;
enum mesh_phase phase; /* what we're currently trying to do */
enum msg_phase msgphase;
int conn_tgt; /* target we're connected to */
Scsi_Cmnd *current_req; /* req we're currently working on */
struct scsi_cmnd *current_req; /* req we're currently working on */
int data_ptr;
int dma_started;
int dma_count;
......@@ -185,7 +188,7 @@ struct mesh_state {
static void mesh_done(struct mesh_state *ms, int start_next);
static void mesh_interrupt(int irq, void *dev_id, struct pt_regs *ptregs);
static void cmd_complete(struct mesh_state *ms);
static void set_dma_cmds(struct mesh_state *ms, Scsi_Cmnd *cmd);
static void set_dma_cmds(struct mesh_state *ms, struct scsi_cmnd *cmd);
static void halt_dma(struct mesh_state *ms);
static void phase_mismatch(struct mesh_state *ms);
......@@ -344,7 +347,7 @@ static inline void mesh_flush_io(volatile struct mesh_regs *mr)
/*
* Complete a SCSI command
*/
static void mesh_completed(struct mesh_state *ms, Scsi_Cmnd *cmd)
static void mesh_completed(struct mesh_state *ms, struct scsi_cmnd *cmd)
{
(*cmd->scsi_done)(cmd);
}
......@@ -402,14 +405,14 @@ static void mesh_init(struct mesh_state *ms)
}
static void mesh_start_cmd(struct mesh_state *ms, Scsi_Cmnd *cmd)
static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
{
volatile struct mesh_regs *mr = ms->mesh;
int t, id;
id = cmd->device->id;
ms->current_req = cmd;
ms->tgts[id].data_goes_out = cmd->sc_data_direction == SCSI_DATA_WRITE;
ms->tgts[id].data_goes_out = cmd->sc_data_direction == DMA_TO_DEVICE;
ms->tgts[id].current_req = cmd;
#if 1
......@@ -558,7 +561,7 @@ static void mesh_start_cmd(struct mesh_state *ms, Scsi_Cmnd *cmd)
*/
static void mesh_start(struct mesh_state *ms)
{
Scsi_Cmnd *cmd, *prev, *next;
struct scsi_cmnd *cmd, *prev, *next;
if (ms->phase != idle || ms->current_req != NULL) {
printk(KERN_ERR "inappropriate mesh_start (phase=%d, ms=%p)",
......@@ -568,14 +571,14 @@ static void mesh_start(struct mesh_state *ms)
while (ms->phase == idle) {
prev = NULL;
for (cmd = ms->request_q; ; cmd = (Scsi_Cmnd *) cmd->host_scribble) {
for (cmd = ms->request_q; ; cmd = (struct scsi_cmnd *) cmd->host_scribble) {
if (cmd == NULL)
return;
if (ms->tgts[cmd->device->id].current_req == NULL)
break;
prev = cmd;
}
next = (Scsi_Cmnd *) cmd->host_scribble;
next = (struct scsi_cmnd *) cmd->host_scribble;
if (prev == NULL)
ms->request_q = next;
else
......@@ -589,7 +592,7 @@ static void mesh_start(struct mesh_state *ms)
static void mesh_done(struct mesh_state *ms, int start_next)
{
Scsi_Cmnd *cmd;
struct scsi_cmnd *cmd;
struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
cmd = ms->current_req;
......@@ -679,7 +682,7 @@ static void start_phase(struct mesh_state *ms)
int i, seq, nb;
volatile struct mesh_regs *mr = ms->mesh;
volatile struct dbdma_regs *md = ms->dma;
Scsi_Cmnd *cmd = ms->current_req;
struct scsi_cmnd *cmd = ms->current_req;
struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
dlog(ms, "start_phase nmo/exc/fc/seq = %.8x",
......@@ -854,7 +857,7 @@ static inline int msgin_length(struct mesh_state *ms)
static void reselected(struct mesh_state *ms)
{
volatile struct mesh_regs *mr = ms->mesh;
Scsi_Cmnd *cmd;
struct scsi_cmnd *cmd;
struct mesh_target *tp;
int b, t, prev;
......@@ -985,7 +988,7 @@ static void handle_reset(struct mesh_state *ms)
{
int tgt;
struct mesh_target *tp;
Scsi_Cmnd *cmd;
struct scsi_cmnd *cmd;
volatile struct mesh_regs *mr = ms->mesh;
for (tgt = 0; tgt < 8; ++tgt) {
......@@ -1000,7 +1003,7 @@ static void handle_reset(struct mesh_state *ms)
}
ms->current_req = NULL;
while ((cmd = ms->request_q) != NULL) {
ms->request_q = (Scsi_Cmnd *) cmd->host_scribble;
ms->request_q = (struct scsi_cmnd *) cmd->host_scribble;
cmd->result = DID_RESET << 16;
mesh_completed(ms, cmd);
}
......@@ -1154,7 +1157,7 @@ static void handle_exception(struct mesh_state *ms)
static void handle_msgin(struct mesh_state *ms)
{
int i, code;
Scsi_Cmnd *cmd = ms->current_req;
struct scsi_cmnd *cmd = ms->current_req;
struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
if (ms->n_msgin == 0)
......@@ -1252,7 +1255,7 @@ static void handle_msgin(struct mesh_state *ms)
/*
* Set up DMA commands for transferring data.
*/
static void set_dma_cmds(struct mesh_state *ms, Scsi_Cmnd *cmd)
static void set_dma_cmds(struct mesh_state *ms, struct scsi_cmnd *cmd)
{
int i, dma_cmd, total, off, dtot;
struct scatterlist *scl;
......@@ -1270,7 +1273,7 @@ static void set_dma_cmds(struct mesh_state *ms, Scsi_Cmnd *cmd)
scl = (struct scatterlist *) cmd->buffer;
off = ms->data_ptr;
nseg = pci_map_sg(ms->pdev, scl, cmd->use_sg,
scsi_to_pci_dma_dir(cmd ->sc_data_direction));
cmd->sc_data_direction);
for (i = 0; i <nseg; ++i, ++scl) {
u32 dma_addr = sg_dma_address(scl);
u32 dma_len = sg_dma_len(scl);
......@@ -1324,7 +1327,7 @@ static void halt_dma(struct mesh_state *ms)
{
volatile struct dbdma_regs *md = ms->dma;
volatile struct mesh_regs *mr = ms->mesh;
Scsi_Cmnd *cmd = ms->current_req;
struct scsi_cmnd *cmd = ms->current_req;
int t, nb;
if (!ms->tgts[ms->conn_tgt].data_goes_out) {
......@@ -1364,8 +1367,7 @@ static void halt_dma(struct mesh_state *ms)
if (cmd->use_sg != 0) {
struct scatterlist *sg;
sg = (struct scatterlist *)cmd->request_buffer;
pci_unmap_sg(ms->pdev, sg, cmd->use_sg,
scsi_to_pci_dma_dir(cmd->sc_data_direction));
pci_unmap_sg(ms->pdev, sg, cmd->use_sg, cmd->sc_data_direction);
}
ms->dma_started = 0;
}
......@@ -1452,7 +1454,7 @@ static void phase_mismatch(struct mesh_state *ms)
static void cmd_complete(struct mesh_state *ms)
{
volatile struct mesh_regs *mr = ms->mesh;
Scsi_Cmnd *cmd = ms->current_req;
struct scsi_cmnd *cmd = ms->current_req;
struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
int seq, n, t;
......@@ -1635,7 +1637,7 @@ static void cmd_complete(struct mesh_state *ms)
* Called by midlayer with host locked to queue a new
* request
*/
static int mesh_queue(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
static int mesh_queue(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
{
struct mesh_state *ms;
......@@ -1692,7 +1694,7 @@ static void mesh_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
* queue if it isn't connected yet, and for pending command, assert
* ATN until the bus gets freed.
*/
static int mesh_abort(Scsi_Cmnd *cmd)
static int mesh_abort(struct scsi_cmnd *cmd)
{
struct mesh_state *ms = (struct mesh_state *) cmd->device->host->hostdata;
......@@ -1700,7 +1702,7 @@ static int mesh_abort(Scsi_Cmnd *cmd)
mesh_dump_regs(ms);
dumplog(ms, cmd->device->id);
dumpslog(ms);
return SCSI_ABORT_SNOOZE;
return FAILED;
}
/*
......@@ -1709,7 +1711,7 @@ static int mesh_abort(Scsi_Cmnd *cmd)
* The midlayer will wait for devices to come back, we don't need
* to do that ourselves
*/
static int mesh_host_reset(Scsi_Cmnd *cmd)
static int mesh_host_reset(struct scsi_cmnd *cmd)
{
struct mesh_state *ms = (struct mesh_state *) cmd->device->host->hostdata;
volatile struct mesh_regs *mr = ms->mesh;
......@@ -1832,7 +1834,7 @@ static int mesh_shutdown(struct macio_dev *mdev)
return 0;
}
static Scsi_Host_Template mesh_template = {
static struct scsi_host_template mesh_template = {
.proc_name = "mesh",
.name = "MESH",
.queuecommand = mesh_queue,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7