From: Jamie Lenehan <lenehan@twibble.org>
To: linux-scsi@vger.kernel.org
Cc: dc395x@twibble.org
Subject: [PATCH] dc395x [2/5] - sg list handling cleanups
Date: Tue, 9 Mar 2004 15:24:00 +1100 [thread overview]
Message-ID: <20040309042400.GB12274@twibble.org> (raw)
In-Reply-To: <20040309042300.GA12274@twibble.org>
Cleanup a lot of the sg list handling to make it easier to follow in
preparation for making this work on sparc64 (big-endian & 64bit).
diff -du -r a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
--- a/drivers/scsi/dc395x.c 2004-02-16 22:34:46.287013737 +1100
+++ b/drivers/scsi/dc395x.c 2004-02-16 22:34:36.420536329 +1100
@@ -210,11 +210,6 @@
#define DC395x_write16(acb,address,value) outw((value), acb->io_port_base + (address))
#define DC395x_write32(acb,address,value) outl((value), acb->io_port_base + (address))
-
-#define BUS_ADDR(sg) sg_dma_address(&(sg))
-#define CPU_ADDR(sg) (page_address((sg).page)+(sg).offset)
-#define PAGE_ADDRESS(sg) page_address((sg)->page)
-
/* cmd->result */
#define RES_TARGET 0x000000FF /* Target State */
#define RES_TARGET_LNX STATUS_MASK /* Only official ... */
@@ -233,6 +228,13 @@
#define TAG_NONE 255
+/*
+ * srb->segement_x is the hw sg list. It is always allocated as a
+ * DC395x_MAX_SG_LISTENTRY entries in a linear block which does not
+ * cross a page boundy.
+ */
+#define SEGMENTX_LEN (sizeof(struct SGentry)*DC395x_MAX_SG_LISTENTRY)
+
struct SGentry {
u32 address; /* bus! address */
@@ -276,21 +278,28 @@
struct ScsiReqBlk {
struct list_head list; /* next/prev ptrs for srb lists */
struct DeviceCtlBlk *dcb;
-
- /* HW scatter list (up to 64 entries) */
- struct SGentry *segment_x;
Scsi_Cmnd *cmd;
- unsigned char *virt_addr; /* set by update_sg_list */
+ struct SGentry *segment_x; /* Linear array of hw sg entries (up to 64 entries) */
+ u32 sg_bus_addr; /* Bus address of sg list (ie, of segment_x) */
- u32 total_xfer_length;
- u32 xferred; /* Backup for the already xferred len */
+ u8 sg_count; /* No of HW sg entries for this request */
+ u8 sg_index; /* Index of HW sg entry for this request */
+ u32 total_xfer_length; /* Total number of bytes remaining to be transfered */
+ unsigned char *virt_addr; /* Virtual address of current transfer position */
- u32 sg_bus_addr; /* bus address of DC395x scatterlist */
+ /*
+ * The sense buffer handling function, request_sense, uses
+ * the first hw sg entry (segment_x[0]) and the transfer
+ * length (total_xfer_length). While doing this it stores the
+ * original values into the last sg hw list
+ * (srb->segment_x[DC395x_MAX_SG_LISTENTRY - 1] and the
+ * total_xfer_length in xferred. These values are restored in
+ * pci_unmap_srb_sense. This is the only place xferred is used.
+ */
+ u32 xferred; /* Saved copy of total_xfer_length */
u16 state;
- u8 sg_count;
- u8 sg_index;
u8 msgin_buf[6];
u8 msgout_buf[6];
@@ -835,7 +844,8 @@
static void srb_waiting_append(struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb)
{
- dprintkdbg(DBG_0, "srb_waiting_append: srb %p cmd %li\n", srb, srb->cmd->pid);
+ dprintkdbg(DBG_0, "srb_waiting_append: srb %p cmd %li\n",
+ srb, srb->cmd->pid);
list_add_tail(&srb->list, &dcb->srb_waiting_list);
}
@@ -879,7 +889,8 @@
static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb)
{
- dprintkdbg(DBG_0, "srb_going_to_waiting_move: srb %p, pid = %li\n", srb, srb->cmd->pid);
+ dprintkdbg(DBG_0, "srb_going_to_waiting_move: srb %p, pid = %li\n",
+ srb, srb->cmd->pid);
list_move(&srb->list, &dcb->srb_waiting_list);
}
@@ -1021,134 +1032,97 @@
static void build_srb(Scsi_Cmnd *cmd, struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb)
{
- int i, max;
- struct SGentry *sgp;
- struct scatterlist *sl;
- u32 request_size;
- int dir;
-
+ int dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
dprintkdbg(DBG_0, "build_srb...\n");
+
srb->dcb = dcb;
srb->cmd = cmd;
- dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+ srb->sg_count = 0;
+ srb->total_xfer_length = 0;
+ srb->sg_bus_addr = 0;
+ srb->virt_addr = 0;
+ srb->sg_index = 0;
+ srb->adapter_status = 0;
+ srb->target_status = 0;
+ srb->msg_count = 0;
+ srb->status = 0;
+ srb->flag = 0;
+ srb->state = 0;
+ srb->retry_count = 0;
+ srb->tag_number = TAG_NONE;
+ srb->scsi_phase = PH_BUS_FREE; /* initial phase */
+ srb->end_message = 0;
- if (cmd->use_sg && dir != PCI_DMA_NONE) {
- unsigned int len = 0;
- /* TODO: In case usg_sg and the no of segments differ, things
- * will probably go wrong. */
- max = srb->sg_count =
- pci_map_sg(dcb->acb->dev,
- (struct scatterlist *)cmd->request_buffer,
- cmd->use_sg, dir);
- sgp = srb->segment_x;
- request_size = cmd->request_bufflen;
- dprintkdbg(DBG_SGPARANOIA,
- "BuildSRB: Bufflen = %d, buffer = %p, use_sg = %d\n",
- cmd->request_bufflen, cmd->request_buffer,
- cmd->use_sg);
- dprintkdbg(DBG_SGPARANOIA,
- "Mapped %i Segments to %i\n", cmd->use_sg,
- srb->sg_count);
- sl = (struct scatterlist *)cmd->request_buffer;
+ if (dir == PCI_DMA_NONE || !cmd->request_buffer) {
+ dprintkdbg(DBG_0, "srb[A] len=%d buf=%p use_sg=%d !MAP=%08x\n",
+ cmd->bufflen, cmd->request_buffer,
+ cmd->use_sg, srb->segment_x[0].address);
+ } else if (cmd->use_sg) {
+ int i;
+ u32 reqlen = cmd->request_bufflen;
+ struct scatterlist *sl = (struct scatterlist *)
+ cmd->request_buffer;
+ struct SGentry *sgp = srb->segment_x;
+ srb->sg_count = pci_map_sg(dcb->acb->dev, sl, cmd->use_sg,
+ dir);
+ dprintkdbg(DBG_0, "srb[B] len=%d buf=%p use_sg=%d segs=%d\n",
+ reqlen, cmd->request_buffer, cmd->use_sg,
+ srb->sg_count);
srb->virt_addr = page_address(sl->page);
- for (i = 0; i < max; i++) {
- u32 busaddr = (u32) sg_dma_address(&sl[i]);
- u32 seglen = (u32) sl[i].length;
+ for (i = 0; i < srb->sg_count; i++) {
+ u32 busaddr = (u32)sg_dma_address(&sl[i]);
+ u32 seglen = (u32)sl[i].length;
sgp[i].address = busaddr;
sgp[i].length = seglen;
- len += seglen;
- dprintkdbg(DBG_SGPARANOIA,
- "Setting up sgp %d, address = 0x%08x, length = %d, tot len = %d\n",
- i, busaddr, seglen, len);
+ srb->total_xfer_length += seglen;
}
- sgp += max - 1;
- /* Fixup for last buffer too big as it is allocated on even page boundaries */
- if (len > request_size) {
-#if debug_enabled(DBG_KG) || debug_enabled(DBG_SGPARANOIA)
- dprintkdbg(DBG_KG|DBG_SGPARANOIA,
- "Fixup SG total length: %d->%d, last seg %d->%d\n",
- len, request_size, sgp->length,
- sgp->length - (len - request_size));
-#endif
- sgp->length -= (len - request_size);
- len = request_size;
+ sgp += srb->sg_count - 1;
+
+ /*
+ * adjust last page if too big as it is allocated
+ * on even page boundaries
+ */
+ if (srb->total_xfer_length > reqlen) {
+ sgp->length -= (srb->total_xfer_length - reqlen);
+ srb->total_xfer_length = reqlen;
}
- /* WIDE padding */
- if (dcb->sync_period & WIDE_SYNC && len % 2) {
- len++;
+
+ /* Fixup for WIDE padding - make sure length is even */
+ if (dcb->sync_period & WIDE_SYNC &&
+ srb->total_xfer_length % 2) {
+ srb->total_xfer_length++;
sgp->length++;
}
- srb->total_xfer_length = len; /*? */
- /* Hopefully this does not cross a page boundary ... */
- srb->sg_bus_addr =
- pci_map_single(dcb->acb->dev, srb->segment_x,
- sizeof(struct SGentry) *
- DC395x_MAX_SG_LISTENTRY,
- PCI_DMA_TODEVICE);
- dprintkdbg(DBG_SGPARANOIA,
- "Map SG descriptor list %p (%05x) to %08x\n",
- srb->segment_x,
- sizeof(struct SGentry) * DC395x_MAX_SG_LISTENTRY,
- srb->sg_bus_addr);
+
+ srb->sg_bus_addr = pci_map_single(dcb->acb->dev,
+ srb->segment_x,
+ SEGMENTX_LEN,
+ PCI_DMA_TODEVICE);
+
+ dprintkdbg(DBG_SGPARANOIA, "srb[B] map sg %p->%08x(%05x)\n",
+ srb->segment_x, srb->sg_bus_addr, SEGMENTX_LEN);
} else {
- if (cmd->request_buffer && dir != PCI_DMA_NONE) {
- u32 len = cmd->request_bufflen; /* Actual request size */
- srb->sg_count = 1;
- srb->segment_x[0].address =
- pci_map_single(dcb->acb->dev,
- cmd->request_buffer, len, dir);
- /* WIDE padding */
- if (dcb->sync_period & WIDE_SYNC && len % 2)
- len++;
- srb->segment_x[0].length = len;
- srb->total_xfer_length = len;
- srb->virt_addr = cmd->request_buffer;
- srb->sg_bus_addr = 0;
- dprintkdbg(DBG_SGPARANOIA,
- "BuildSRB: len = %d, buffer = %p, use_sg = %d, map %08x\n",
- len, cmd->request_buffer, cmd->use_sg,
- srb->segment_x[0].address);
- } else {
- srb->sg_count = 0;
- srb->total_xfer_length = 0;
- srb->sg_bus_addr = 0;
- srb->virt_addr = 0;
- dprintkdbg(DBG_SGPARANOIA,
- "BuildSRB: buflen = %d, buffer = %p, use_sg = %d, NOMAP %08x\n",
- cmd->bufflen, cmd->request_buffer,
- cmd->use_sg, srb->segment_x[0].address);
- }
- }
+ srb->total_xfer_length = cmd->request_bufflen;
+ srb->sg_count = 1;
+ srb->segment_x[0].address =
+ pci_map_single(dcb->acb->dev, cmd->request_buffer,
+ srb->total_xfer_length, dir);
- srb->sg_index = 0;
- srb->adapter_status = 0;
- srb->target_status = 0;
- srb->msg_count = 0;
- srb->status = 0;
- srb->flag = 0;
- srb->state = 0;
- srb->retry_count = 0;
+ /* Fixup for WIDE padding - make sure length is even */
+ if (dcb->sync_period & WIDE_SYNC && srb->total_xfer_length % 2)
+ srb->total_xfer_length++;
-#if debug_enabled(DBG_TRACE|DBG_TRACEALL) && debug_enabled(DBG_SGPARANOIA)
- if ((unsigned long)srb->debugtrace & (DEBUGTRACEBUFSZ - 1)) {
- dprintkdbg(DBG_SGPARANOIA,
- "SRB %i (%p): debugtrace %p corrupt!\n",
- (srb - dcb->acb->srb_array) /
- sizeof(struct ScsiReqBlk), srb, srb->debugtrace);
+ srb->segment_x[0].length = srb->total_xfer_length;
+ srb->virt_addr = cmd->request_buffer;
+ dprintkdbg(DBG_0, "srb[C] len=%d buf=%p use_sg=%d map=%08x\n",
+ srb->total_xfer_length, cmd->request_buffer,
+ cmd->use_sg, srb->segment_x[0].address);
}
-#endif
#if debug_enabled(DBG_TRACE|DBG_TRACEALL)
srb->debugpos = 0;
srb->debugtrace = 0;
#endif
- TRACEPRINTF("pid %li(%li):%02x %02x..(%i-%i) *", cmd->pid,
- jiffies, cmd->cmnd[0], cmd->cmnd[1],
- cmd->device->id, cmd->device->lun);
- srb->tag_number = TAG_NONE;
-
- srb->scsi_phase = PH_BUS_FREE; /* initial phase */
- srb->end_message = 0;
}
@@ -1598,7 +1572,7 @@
u8 s_stat, scsicommand, i, identify_message;
u8 *ptr;
- dprintkdbg(DBG_0, "start_scsi..............\n");
+ dprintkdbg(DBG_0, "start_scsi (#%li)\n", srb->cmd->pid);
srb->tag_number = TAG_NONE; /* acb->tag_max_num: had error read in eeprom */
s_stat = DC395x_read8(acb, TRM_S1040_SCSI_SIGNAL);
@@ -1958,7 +1932,7 @@
static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
- dprintkdbg(DBG_0, "msgout_phase0...\n");
+ dprintkdbg(DBG_0, "msgout_phase0 (#%li)\n", srb->cmd->pid);
if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))
*pscsi_status = PH_BUS_FREE; /*.. initial phase */
@@ -1974,7 +1948,7 @@
u16 i;
u8 *ptr;
- dprintkdbg(DBG_0, "msgout_phase1...\n");
+ dprintkdbg(DBG_0, "msgout_phase1 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("MOP1*");
clear_fifo(acb, "MOP1");
if (!(srb->state & SRB_MSGOUT)) {
@@ -2014,6 +1988,7 @@
static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
+ dprintkdbg(DBG_0, "command_phase0 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("COP0 *");
/*1.25 */
/*clear_fifo(acb, COP0); */
@@ -2028,7 +2003,7 @@
u8 *ptr;
u16 i;
- dprintkdbg(DBG_0, "command_phase1...\n");
+ dprintkdbg(DBG_0, "command_phase1 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("COP1*");
clear_fifo(acb, "COP1");
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@@ -2058,8 +2033,11 @@
}
-/* Do sanity checks for S/G list */
-static inline void check_sg_list(struct ScsiReqBlk *srb)
+/*
+ * Verify that the remaining space in the hw sg lists is the same as
+ * the count of remaining bytes in srb->total_xfer_length
+ */
+static void sg_verify_length(struct ScsiReqBlk *srb)
{
if (debug_enabled(DBG_SGPARANOIA)) {
unsigned len = 0;
@@ -2079,75 +2057,90 @@
* Compute the next Scatter Gather list index and adjust its length
* and address if necessary; also compute virt_addr
*/
-static void update_sg_list(struct ScsiReqBlk *srb, u32 left)
+static void sg_update_list(struct ScsiReqBlk *srb, u32 left)
{
- struct SGentry *psge;
- u32 xferred = 0;
u8 idx;
- Scsi_Cmnd *cmd = srb->cmd;
struct scatterlist *sg;
+ Scsi_Cmnd *cmd = srb->cmd;
int segment = cmd->use_sg;
+ u32 xferred = srb->total_xfer_length - left; /* bytes transfered */
+ struct SGentry *psge = srb->segment_x + srb->sg_index;
- dprintkdbg(DBG_KG, "Update SG: Total %i, Left %i\n",
- srb->total_xfer_length, left);
- check_sg_list(srb);
- psge = srb->segment_x + srb->sg_index;
- /* data that has already been transferred */
- xferred = srb->total_xfer_length - left;
- if (srb->total_xfer_length != left) {
- /*check_sg_list_TX (srb, xferred); */
- /* Remaining */
- srb->total_xfer_length = left;
- /* parsing from last time disconnect SGIndex */
- for (idx = srb->sg_index; idx < srb->sg_count; idx++) {
+ dprintkdbg(DBG_0, "sg_update_list: Transfered %i of %i bytes, "
+ "%i remain\n",
+ xferred, srb->total_xfer_length, left);
+ if (xferred == 0) {
+ /* nothing to update since we did not transfer any data */
+ return;
+ }
+
+ sg_verify_length(srb);
+ srb->total_xfer_length = left; /* update remaining count */
+ for (idx = srb->sg_index; idx < srb->sg_count; idx++) {
+ if (xferred >= psge->length) {
/* Complete SG entries done */
- if (xferred >= psge->length)
- xferred -= psge->length;
- /* Partial SG entries done */
- else {
- psge->length -= xferred; /* residue data length */
- psge->address += xferred; /* residue data pointer */
- srb->sg_index = idx;
- pci_dma_sync_single(srb->dcb->
- acb->dev,
- srb->sg_bus_addr,
- sizeof(struct SGentry)
- *
- DC395x_MAX_SG_LISTENTRY,
- PCI_DMA_TODEVICE);
- break;
- }
- psge++;
+ xferred -= psge->length;
+ } else {
+ /* Partial SG entry done */
+ psge->length -= xferred;
+ psge->address += xferred;
+ srb->sg_index = idx;
+ pci_dma_sync_single(srb->dcb->
+ acb->dev,
+ srb->sg_bus_addr,
+ SEGMENTX_LEN,
+ PCI_DMA_TODEVICE);
+ break;
}
- check_sg_list(srb);
+ psge++;
}
- /* We need the corresponding virtual address sg_to_virt */
- /*dprintkl(KERN_DEBUG, "sg_to_virt: bus %08x -> virt ", psge->address); */
+ sg_verify_length(srb);
+
+ /* we need the corresponding virtual address */
if (!segment) {
srb->virt_addr += xferred;
- /*printk("%p\n", srb->virt_addr); */
return;
}
+
/* We have to walk the scatterlist to find it */
sg = (struct scatterlist *)cmd->request_buffer;
while (segment--) {
- /*printk("(%08x)%p ", BUS_ADDR(*sg), PAGE_ADDRESS(sg)); */
unsigned long mask =
~((unsigned long)sg->length - 1) & PAGE_MASK;
- if ((BUS_ADDR(*sg) & mask) == (psge->address & mask)) {
- srb->virt_addr = (PAGE_ADDRESS(sg)
+ if ((sg_dma_address(sg) & mask) == (psge->address & mask)) {
+ srb->virt_addr = (page_address(sg->page)
+ psge->address -
(psge->address & PAGE_MASK));
- /*printk("%p\n", srb->virt_addr); */
return;
}
++sg;
}
+
dprintkl(KERN_ERR, "sg_to_virt failed!\n");
srb->virt_addr = 0;
}
+/*
+ * We have transfered a single byte (PIO mode?) and need to update
+ * the count of bytes remaining (total_xfer_length) and update the sg
+ * entry to either point to next byte in the current sg entry, or of
+ * already at the end to point to the start of the next sg entry
+ */
+static void sg_subtract_one(struct ScsiReqBlk *srb)
+{
+ srb->total_xfer_length--;
+ srb->segment_x[srb->sg_index].length--;
+ if (srb->total_xfer_length &&
+ !srb->segment_x[srb->sg_index].length) {
+ if (debug_enabled(DBG_PIO))
+ printk(" (next segment)");
+ srb->sg_index++;
+ sg_update_list(srb, srb->total_xfer_length);
+ }
+}
+
+
/*
* cleanup_after_transfer
*
@@ -2190,7 +2183,7 @@
u16 scsi_status = *pscsi_status;
u32 d_left_counter = 0;
- dprintkdbg(DBG_0, "data_out_phase0...\n");
+ dprintkdbg(DBG_0, "data_out_phase0 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("DOP0*");
/*
@@ -2310,7 +2303,7 @@
srb->total_xfer_length - d_left_counter;
const int diff =
(dcb->sync_period & WIDE_SYNC) ? 2 : 1;
- update_sg_list(srb, d_left_counter);
+ sg_update_list(srb, d_left_counter);
/* KG: Most ugly hack! Apparently, this works around a chip bug */
if ((srb->segment_x[srb->sg_index].length ==
diff && srb->cmd->use_sg)
@@ -2321,7 +2314,7 @@
"Work around chip bug (%i)?\n", diff);
d_left_counter =
srb->total_xfer_length - diff;
- update_sg_list(srb, d_left_counter);
+ sg_update_list(srb, d_left_counter);
/*srb->total_xfer_length -= diff; */
/*srb->virt_addr += diff; */
/*if (srb->cmd->use_sg) */
@@ -2351,7 +2344,7 @@
static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
- dprintkdbg(DBG_0, "data_out_phase1...\n");
+ dprintkdbg(DBG_0, "data_out_phase1 (#%li)\n", srb->cmd->pid);
/*1.25 */
TRACEPRINTF("DOP1*");
clear_fifo(acb, "DOP1");
@@ -2368,7 +2361,7 @@
u16 scsi_status = *pscsi_status;
u32 d_left_counter = 0;
- dprintkdbg(DBG_0, "data_in_phase0...\n");
+ dprintkdbg(DBG_0, "data_in_phase0 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("DIP0*");
/*
@@ -2445,7 +2438,7 @@
if (d_left_counter
&& srb->total_xfer_length <= DC395x_LASTPIO) {
/*u32 addr = (srb->segment_x[srb->sg_index].address); */
- /*update_sg_list (srb, d_left_counter); */
+ /*sg_update_list (srb, d_left_counter); */
dprintkdbg(DBG_PIO, "DIP0: PIO (%i %s) to %p for remaining %i bytes:",
DC395x_read8(acb, TRM_S1040_SCSI_FIFOCNT) &
0x1f,
@@ -2458,32 +2451,19 @@
DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2,
CFG2_WIDEFIFO);
- while (DC395x_read8(acb, TRM_S1040_SCSI_FIFOCNT) !=
- 0x40) {
- u8 byte =
- DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
+ while (DC395x_read8(acb, TRM_S1040_SCSI_FIFOCNT) != 0x40) {
+ u8 byte = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
*(srb->virt_addr)++ = byte;
if (debug_enabled(DBG_PIO))
printk(" %02x", byte);
- srb->total_xfer_length--;
d_left_counter--;
- srb->segment_x[srb->sg_index].length--;
- if (srb->total_xfer_length
- && !srb->segment_x[srb->sg_index].
- length) {
- if (debug_enabled(DBG_PIO))
- printk(" (next segment)");
- srb->sg_index++;
- update_sg_list(srb,
- d_left_counter);
- }
+ sg_subtract_one(srb);
}
if (srb->dcb->sync_period & WIDE_SYNC) {
-#if 1 /* Read the last byte ... */
+#if 1
+ /* Read the last byte ... */
if (srb->total_xfer_length > 0) {
- u8 byte =
- DC395x_read8
- (acb, TRM_S1040_SCSI_FIFO);
+ u8 byte = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
*(srb->virt_addr)++ = byte;
srb->total_xfer_length--;
if (debug_enabled(DBG_PIO))
@@ -2563,7 +2543,7 @@
* there were some data residue in SCSI FIFO or
* SCSI transfer counter not empty
*/
- update_sg_list(srb, d_left_counter);
+ sg_update_list(srb, d_left_counter);
}
}
/* KG: The target may decide to disconnect: Empty FIFO before! */
@@ -2597,7 +2577,7 @@
static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
- dprintkdbg(DBG_0, "data_in_phase1...\n");
+ dprintkdbg(DBG_0, "data_in_phase1 (#%li)\n", srb->cmd->pid);
/* FIFO should be cleared, if previous phase was not DataPhase */
/*clear_fifo(acb, "DIP1"); */
/* Allow data in! */
@@ -2615,7 +2595,7 @@
struct DeviceCtlBlk *dcb = srb->dcb;
u8 bval;
- dprintkdbg(DBG_0, "DataIO_transfer %c (pid %li): len = %i, SG: %i/%i\n",
+ dprintkdbg(DBG_0, "data_io_transfer %c (#%li): len=%i, sg=(%i/%i)\n",
((io_dir & DMACMD_DIR) ? 'r' : 'w'), srb->cmd->pid,
srb->total_xfer_length, srb->sg_index,
srb->sg_count);
@@ -2623,176 +2603,151 @@
srb->sg_index, srb->sg_count);
if (srb == acb->tmp_srb)
dprintkl(KERN_ERR, "Using tmp_srb in DataPhase!\n");
- if (srb->sg_index < srb->sg_count) {
- if (srb->total_xfer_length > DC395x_LASTPIO) {
- u8 dma_status = DC395x_read8(acb, TRM_S1040_DMA_STATUS);
- /*
- * KG: What should we do: Use SCSI Cmd 0x90/0x92?
- * Maybe, even ABORTXFER would be appropriate
- */
- if (dma_status & XFERPENDING) {
- dprintkl(KERN_DEBUG, "Xfer pending! Expect trouble!!\n");
- dump_register_info(acb, dcb, srb);
- DC395x_write8(acb, TRM_S1040_DMA_CONTROL,
- CLRXFIFO);
- }
- /* clear_fifo(acb, "IO"); */
- /*
- * load what physical address of Scatter/Gather list table want to be
- * transfer
- */
- srb->state |= SRB_DATA_XFER;
- DC395x_write32(acb, TRM_S1040_DMA_XHIGHADDR, 0);
- if (srb->cmd->use_sg) { /* with S/G */
- io_dir |= DMACMD_SG;
- DC395x_write32(acb, TRM_S1040_DMA_XLOWADDR,
- srb->sg_bus_addr +
- sizeof(struct SGentry) *
- srb->sg_index);
- /* load how many bytes in the Scatter/Gather list table */
- DC395x_write32(acb, TRM_S1040_DMA_XCNT,
- ((u32)
- (srb->sg_count -
- srb->sg_index) << 3));
- } else { /* without S/G */
- io_dir &= ~DMACMD_SG;
- DC395x_write32(acb, TRM_S1040_DMA_XLOWADDR,
- srb->segment_x[0].address);
- DC395x_write32(acb, TRM_S1040_DMA_XCNT,
- srb->segment_x[0].length);
- }
- /* load total transfer length (24bits) max value 16Mbyte */
- DC395x_write32(acb, TRM_S1040_SCSI_COUNTER,
- srb->total_xfer_length);
- DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
- if (io_dir & DMACMD_DIR) { /* read */
- DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
- SCMD_DMA_IN);
- DC395x_write16(acb, TRM_S1040_DMA_COMMAND,
- io_dir);
- } else {
- DC395x_write16(acb, TRM_S1040_DMA_COMMAND,
- io_dir);
- DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
- SCMD_DMA_OUT);
- }
+ if (srb->sg_index >= srb->sg_count) {
+ /* can't happen? out of bounds error */
+ return;
+ }
+
+ if (srb->total_xfer_length > DC395x_LASTPIO) {
+ u8 dma_status = DC395x_read8(acb, TRM_S1040_DMA_STATUS);
+ /*
+ * KG: What should we do: Use SCSI Cmd 0x90/0x92?
+ * Maybe, even ABORTXFER would be appropriate
+ */
+ if (dma_status & XFERPENDING) {
+ dprintkl(KERN_DEBUG, "Xfer pending! Expect trouble!!\n");
+ dump_register_info(acb, dcb, srb);
+ DC395x_write8(acb, TRM_S1040_DMA_CONTROL, CLRXFIFO);
+ }
+ /* clear_fifo(acb, "IO"); */
+ /*
+ * load what physical address of Scatter/Gather list table
+ * want to be transfer
+ */
+ srb->state |= SRB_DATA_XFER;
+ DC395x_write32(acb, TRM_S1040_DMA_XHIGHADDR, 0);
+ if (srb->cmd->use_sg) { /* with S/G */
+ io_dir |= DMACMD_SG;
+ DC395x_write32(acb, TRM_S1040_DMA_XLOWADDR,
+ srb->sg_bus_addr +
+ sizeof(struct SGentry) *
+ srb->sg_index);
+ /* load how many bytes in the sg list table */
+ DC395x_write32(acb, TRM_S1040_DMA_XCNT,
+ ((u32)(srb->sg_count -
+ srb->sg_index) << 3));
+ } else { /* without S/G */
+ io_dir &= ~DMACMD_SG;
+ DC395x_write32(acb, TRM_S1040_DMA_XLOWADDR,
+ srb->segment_x[0].address);
+ DC395x_write32(acb, TRM_S1040_DMA_XCNT,
+ srb->segment_x[0].length);
+ }
+ /* load total transfer length (24bits) max value 16Mbyte */
+ DC395x_write32(acb, TRM_S1040_SCSI_COUNTER,
+ srb->total_xfer_length);
+ DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
+ if (io_dir & DMACMD_DIR) { /* read */
+ DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
+ SCMD_DMA_IN);
+ DC395x_write16(acb, TRM_S1040_DMA_COMMAND, io_dir);
+ } else {
+ DC395x_write16(acb, TRM_S1040_DMA_COMMAND, io_dir);
+ DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
+ SCMD_DMA_OUT);
}
+
+ }
#if DC395x_LASTPIO
- else if (srb->total_xfer_length > 0) { /* The last four bytes: Do PIO */
- /* clear_fifo(acb, "IO"); */
- /*
- * load what physical address of Scatter/Gather list table want to be
- * transfer
- */
- srb->state |= SRB_DATA_XFER;
- /* load total transfer length (24bits) max value 16Mbyte */
- DC395x_write32(acb, TRM_S1040_SCSI_COUNTER,
- srb->total_xfer_length);
- DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
- if (io_dir & DMACMD_DIR) { /* read */
- DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
- SCMD_FIFO_IN);
- } else { /* write */
- int ln = srb->total_xfer_length;
- if (srb->dcb->sync_period & WIDE_SYNC)
- DC395x_write8
- (acb, TRM_S1040_SCSI_CONFIG2,
- CFG2_WIDEFIFO);
- dprintkdbg(DBG_PIO, "DOP1: PIO %i bytes from %p:",
- srb->total_xfer_length,
- srb->virt_addr);
- while (srb->total_xfer_length) {
+ else if (srb->total_xfer_length > 0) { /* The last four bytes: Do PIO */
+ /*
+ * load what physical address of Scatter/Gather list table
+ * want to be transfer
+ */
+ srb->state |= SRB_DATA_XFER;
+ /* load total transfer length (24bits) max value 16Mbyte */
+ DC395x_write32(acb, TRM_S1040_SCSI_COUNTER,
+ srb->total_xfer_length);
+ DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
+ if (io_dir & DMACMD_DIR) { /* read */
+ DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
+ SCMD_FIFO_IN);
+ } else { /* write */
+ int ln = srb->total_xfer_length;
+ if (srb->dcb->sync_period & WIDE_SYNC)
+ DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2,
+ CFG2_WIDEFIFO);
+
+ dprintkdbg(DBG_PIO, "DOP1: PIO %i bytes from %p:",
+ srb->total_xfer_length,
+ srb->virt_addr);
+
+ while (srb->total_xfer_length) {
+ if (debug_enabled(DBG_PIO))
+ printk(" %02x", (unsigned char) *(srb->virt_addr));
+
+ DC395x_write8(acb, TRM_S1040_SCSI_FIFO,
+ *(srb->virt_addr)++);
+
+ sg_subtract_one(srb);
+ }
+ if (srb->dcb->sync_period & WIDE_SYNC) {
+ if (ln % 2) {
+ DC395x_write8(acb, TRM_S1040_SCSI_FIFO, 0);
if (debug_enabled(DBG_PIO))
- printk(" %02x", (unsigned char) *(srb->virt_addr));
- DC395x_write8
- (acb, TRM_S1040_SCSI_FIFO,
- *(srb->virt_addr)++);
- srb->total_xfer_length--;
- srb->segment_x[srb->sg_index].
- length--;
- if (srb->total_xfer_length
- && !srb->segment_x[srb->
- sg_index].
- length) {
- if (debug_enabled(DBG_PIO))
- printk(" (next segment)");
- srb->sg_index++;
- update_sg_list(srb,
- srb->total_xfer_length);
- }
- }
- if (srb->dcb->sync_period & WIDE_SYNC) {
- if (ln % 2) {
- DC395x_write8(acb, TRM_S1040_SCSI_FIFO, 0);
- if (debug_enabled(DBG_PIO))
- printk(" |00");
- }
- DC395x_write8
- (acb, TRM_S1040_SCSI_CONFIG2, 0);
+ printk(" |00");
}
- /*DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, ln); */
- if (debug_enabled(DBG_PIO))
- printk("\n");
- DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
- SCMD_FIFO_OUT);
+ DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2, 0);
}
+ /*DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, ln); */
+ if (debug_enabled(DBG_PIO))
+ printk("\n");
+ DC395x_write8(acb, TRM_S1040_SCSI_COMMAND,
+ SCMD_FIFO_OUT);
}
+ }
#endif /* DC395x_LASTPIO */
- else { /* xfer pad */
- u8 data = 0, data2 = 0;
- if (srb->sg_count) {
- srb->adapter_status = H_OVER_UNDER_RUN;
- srb->status |= OVER_RUN;
- }
- /*
- * KG: despite the fact that we are using 16 bits I/O ops
- * the SCSI FIFO is only 8 bits according to the docs
- * (we can set bit 1 in 0x8f to serialize FIFO access ...)
- */
- if (dcb->sync_period & WIDE_SYNC) {
- DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 2);
- DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2,
- CFG2_WIDEFIFO);
- if (io_dir & DMACMD_DIR) { /* read */
- data =
- DC395x_read8
- (acb, TRM_S1040_SCSI_FIFO);
- data2 =
- DC395x_read8
- (acb, TRM_S1040_SCSI_FIFO);
- /*dprintkl(KERN_DEBUG, "DataIO: Xfer pad: %02x %02x\n", data, data2); */
- } else {
- /* Danger, Robinson: If you find KGs scattered over the wide
- * disk, the driver or chip is to blame :-( */
- DC395x_write8(acb, TRM_S1040_SCSI_FIFO,
- 'K');
- DC395x_write8(acb, TRM_S1040_SCSI_FIFO,
- 'G');
- }
- DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2, 0);
+ else { /* xfer pad */
+ u8 data = 0, data2 = 0;
+ if (srb->sg_count) {
+ srb->adapter_status = H_OVER_UNDER_RUN;
+ srb->status |= OVER_RUN;
+ }
+ /*
+ * KG: despite the fact that we are using 16 bits I/O ops
+ * the SCSI FIFO is only 8 bits according to the docs
+ * (we can set bit 1 in 0x8f to serialize FIFO access ...)
+ */
+ if (dcb->sync_period & WIDE_SYNC) {
+ DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 2);
+ DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2,
+ CFG2_WIDEFIFO);
+ if (io_dir & DMACMD_DIR) {
+ data = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
+ data2 = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
} else {
- DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
- /* Danger, Robinson: If you find a collection of Ks on your disk
- * something broke :-( */
- if (io_dir & DMACMD_DIR) { /* read */
- data =
- DC395x_read8
- (acb, TRM_S1040_SCSI_FIFO);
- /*dprintkl(KERN_DEBUG, "DataIO: Xfer pad: %02x\n", data); */
- } else {
- DC395x_write8(acb, TRM_S1040_SCSI_FIFO,
- 'K');
- }
+ /* Danger, Robinson: If you find KGs
+ * scattered over the wide disk, the driver
+ * or chip is to blame :-( */
+ DC395x_write8(acb, TRM_S1040_SCSI_FIFO, 'K');
+ DC395x_write8(acb, TRM_S1040_SCSI_FIFO, 'G');
}
- srb->state |= SRB_XFERPAD;
- DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
- /* SCSI command */
- bval =
- (io_dir & DMACMD_DIR) ? SCMD_FIFO_IN :
- SCMD_FIFO_OUT;
- DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, bval);
+ DC395x_write8(acb, TRM_S1040_SCSI_CONFIG2, 0);
+ } else {
+ DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
+ /* Danger, Robinson: If you find a collection of Ks on your disk
+ * something broke :-( */
+ if (io_dir & DMACMD_DIR)
+ data = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
+ else
+ DC395x_write8(acb, TRM_S1040_SCSI_FIFO, 'K');
}
+ srb->state |= SRB_XFERPAD;
+ DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
+ /* SCSI command */
+ bval = (io_dir & DMACMD_DIR) ? SCMD_FIFO_IN : SCMD_FIFO_OUT;
+ DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, bval);
}
}
@@ -2800,7 +2755,7 @@
static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
- dprintkdbg(DBG_0, "StatusPhase0 (pid %li)\n", srb->cmd->pid);
+ dprintkdbg(DBG_0, "status_phase0 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("STP0 *");
srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); /* get message */
@@ -2817,10 +2772,8 @@
static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
- dprintkdbg(DBG_0, "StatusPhase1 (pid=%li)\n", srb->cmd->pid);
+ dprintkdbg(DBG_0, "status_phase1 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("STP1 *");
- /* Cleanup is now done at the end of DataXXPhase0 */
- /*cleanup_after_transfer (acb, srb); */
srb->state = SRB_STATUS;
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
@@ -2900,7 +2853,8 @@
struct ScsiReqBlk *srb = NULL;
struct ScsiReqBlk *i;
- dprintkdbg(DBG_0, "QTag Msg (SRB %p): %i\n", srb, tag);
+ dprintkdbg(DBG_0, "msgin_qtag (#%li) tag=%i (srb=%p)\n",
+ srb->cmd->pid, tag, srb);
if (!(dcb->tag_mask & (1 << tag)))
dprintkl(KERN_DEBUG,
"MsgIn_QTag: tag_mask (%08x) does not reserve tag %i!\n",
@@ -3147,7 +3101,7 @@
{
struct DeviceCtlBlk *dcb = acb->active_dcb;
- dprintkdbg(DBG_0, "msgin_phase0...\n");
+ dprintkdbg(DBG_0, "msgin_phase0 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("MIP0*");
srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
@@ -3275,7 +3229,7 @@
static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status)
{
- dprintkdbg(DBG_0, "msgin_phase1...\n");
+ dprintkdbg(DBG_0, "msgin_phase1 (#%li)\n", srb->cmd->pid);
TRACEPRINTF("MIP1 *");
clear_fifo(acb, "MIP1");
DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
@@ -3344,7 +3298,7 @@
}
srb = dcb->active_srb;
acb->active_dcb = NULL;
- dprintkdbg(DBG_0, "Disconnect (pid=%li)\n", srb->cmd->pid);
+ dprintkdbg(DBG_0, "disconnect (#%li)\n", srb->cmd->pid);
TRACEPRINTF("DISC *");
srb->scsi_phase = PH_BUS_FREE; /* initial phase */
@@ -3383,7 +3337,7 @@
/* Normal selection timeout */
TRACEPRINTF("SlTO *");
dprintkdbg(DBG_KG,
- "Disc: SelTO (pid=%li) for dev %02i-%i\n",
+ "Disc: SelTO (#%li) for dev %02i-%i\n",
srb->cmd->pid, dcb->target_id,
dcb->target_lun);
if (srb->retry_count++ > DC395x_MAX_RETRIES
@@ -3403,7 +3357,7 @@
/*
* SRB_DISCONNECT (This is what we expect!)
*/
- /* dprintkl(KERN_DEBUG, "DoWaitingSRB (pid=%li)\n", srb->cmd->pid); */
+ /* dprintkl(KERN_DEBUG, "DoWaitingSRB (#%li)\n", srb->cmd->pid); */
TRACEPRINTF("+*");
if (bval & 0x40) {
dprintkdbg(DBG_0, "Debug: DISC: SCSI bus stat %02x: ACK set! Other controllers?\n",
@@ -3425,7 +3379,7 @@
free_tag(dcb, srb);
dcb->active_srb = NULL;
srb->state = SRB_FREE;
- /*dprintkl(KERN_DEBUG, "done (pid=%li)\n", srb->cmd->pid); */
+ /*dprintkl(KERN_DEBUG, "done (#%li)\n", srb->cmd->pid); */
srb_done(acb, dcb, srb);
}
}
@@ -3598,12 +3552,11 @@
if (cmd->use_sg && dir != PCI_DMA_NONE) {
/* unmap DC395x SG list */
dprintkdbg(DBG_SGPARANOIA,
- "Unmap SG descriptor list %08x (%05x)\n",
+ "unmap SG list %08x(%05x)\n",
srb->sg_bus_addr,
- sizeof(struct SGentry) * DC395x_MAX_SG_LISTENTRY);
+ SEGMENTX_LEN);
pci_unmap_single(acb->dev, srb->sg_bus_addr,
- sizeof(struct SGentry) *
- DC395x_MAX_SG_LISTENTRY,
+ SEGMENTX_LEN,
PCI_DMA_TODEVICE);
dprintkdbg(DBG_SGPARANOIA, "Unmap %i SG segments from %p\n",
cmd->use_sg, cmd->request_buffer);
@@ -3612,7 +3565,7 @@
(struct scatterlist *)cmd->request_buffer,
cmd->use_sg, dir);
} else if (cmd->request_buffer && dir != PCI_DMA_NONE) {
- dprintkdbg(DBG_SGPARANOIA, "Unmap buffer at %08x (%05x)\n",
+ dprintkdbg(DBG_SGPARANOIA, "Unmap buffer %08x(%05x)\n",
srb->segment_x[0].address, cmd->request_bufflen);
pci_unmap_single(acb->dev, srb->segment_x[0].address,
cmd->request_bufflen, dir);
@@ -3656,17 +3609,19 @@
TRACEPRINTF("DONE *");
dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
- ptr = (struct ScsiInqData *)(cmd->request_buffer);
- if (cmd->use_sg)
- ptr =
- (struct ScsiInqData *)CPU_ADDR(*(struct scatterlist *)
- ptr);
+ if (cmd->use_sg) {
+ struct scatterlist* sg = (struct scatterlist *)cmd->request_buffer;
+ ptr = (struct ScsiInqData *)(page_address(sg->page) + sg->offset);
+ } else {
+ ptr = (struct ScsiInqData *)(cmd->request_buffer);
+ }
+
dprintkdbg(DBG_SGPARANOIA,
- "SRBdone SG=%i (%i/%i), req_buf = %p, adr = %p\n",
+ "srb_done sg=%i(%i/%i), buf=%p, addr=%p\n",
cmd->use_sg, srb->sg_index, srb->sg_count,
cmd->request_buffer, ptr);
dprintkdbg(DBG_KG,
- "SRBdone (pid %li, target %02i-%i): ", srb->cmd->pid,
+ "srb_done (#%li) (target %02i-%i): ", srb->cmd->pid,
srb->cmd->device->id, srb->cmd->device->lun);
status = srb->target_status;
if (srb->flag & AUTO_REQSENSE) {
@@ -3850,7 +3805,7 @@
else
srb_free_insert(acb, srb);
- dprintkdbg(DBG_0, "SRBdone: done pid %li\n", cmd->pid);
+ dprintkdbg(DBG_0, "srb_done: done (#%li)\n", cmd->pid);
if (debug_enabled(DBG_KG)) {
printk(" 0x%08x\n", cmd->result);
}
@@ -4065,9 +4020,9 @@
srb->segment_x[0].address =
pci_map_single(acb->dev, cmd->sense_buffer,
sizeof(cmd->sense_buffer), PCI_DMA_FROMDEVICE);
- dprintkdbg(DBG_SGPARANOIA, "Map sense buffer at %p (%05x) to %08x\n",
- cmd->sense_buffer, sizeof(cmd->sense_buffer),
- srb->segment_x[0].address);
+ dprintkdbg(DBG_SGPARANOIA, "Map sense buffer %p->%08x(%05x)\n",
+ cmd->sense_buffer, srb->segment_x[0].address,
+ sizeof(cmd->sense_buffer));
srb->sg_count = 1;
srb->sg_index = 0;
@@ -4673,8 +4628,7 @@
static void adapter_sg_tables_free(struct AdapterCtlBlk *acb)
{
int i;
- const unsigned srbs_per_page = PAGE_SIZE/(DC395x_MAX_SG_LISTENTRY
- *sizeof(struct SGentry));
+ const unsigned srbs_per_page = PAGE_SIZE/SEGMENTX_LEN;
for (i = 0; i < DC395x_MAX_SRB_CNT; i += srbs_per_page)
if (acb->srb_array[i].segment_x)
@@ -4688,11 +4642,9 @@
static int __init adapter_sg_tables_alloc(struct AdapterCtlBlk *acb)
{
const unsigned mem_needed = (DC395x_MAX_SRB_CNT+1)
- *DC395x_MAX_SG_LISTENTRY
- *sizeof(struct SGentry);
+ *SEGMENTX_LEN;
int pages = (mem_needed+(PAGE_SIZE-1))/PAGE_SIZE;
- const unsigned srbs_per_page = PAGE_SIZE/(DC395x_MAX_SG_LISTENTRY
- *sizeof(struct SGentry));
+ const unsigned srbs_per_page = PAGE_SIZE/SEGMENTX_LEN;
int srb_idx = 0;
unsigned i = 0;
struct SGentry *ptr;
--
Jamie Lenehan <lenehan@twibble.org>
next prev parent reply other threads:[~2004-03-09 4:24 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2004-03-09 4:23 [PATCH] dc395x [1/5] - formatting cleanups Jamie Lenehan
2004-03-09 4:24 ` Jamie Lenehan [this message]
2004-03-09 4:24 ` [PATCH] dc395x [3/5] - remove old debugging stuff Jamie Lenehan
2004-03-09 4:25 ` [PATCH] dc395x [4/5] - debugging cleanup Jamie Lenehan
2004-03-09 4:26 ` [PATCH] dc395x [5/5] - version update Jamie Lenehan
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20040309042400.GB12274@twibble.org \
--to=lenehan@twibble.org \
--cc=dc395x@twibble.org \
--cc=linux-scsi@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.