aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/53c700.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/53c700.c')
-rw-r--r--drivers/scsi/53c700.c2175
1 files changed, 2175 insertions, 0 deletions
diff --git a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
new file mode 100644
index 000000000000..a591fcb8aab1
--- /dev/null
+++ b/drivers/scsi/53c700.c
@@ -0,0 +1,2175 @@
1/* -*- mode: c; c-basic-offset: 8 -*- */
2
3/* NCR (or Symbios) 53c700 and 53c700-66 Driver
4 *
5 * Copyright (C) 2001 by James.Bottomley@HansenPartnership.com
6**-----------------------------------------------------------------------------
7**
8** This program is free software; you can redistribute it and/or modify
9** it under the terms of the GNU General Public License as published by
10** the Free Software Foundation; either version 2 of the License, or
11** (at your option) any later version.
12**
13** This program is distributed in the hope that it will be useful,
14** but WITHOUT ANY WARRANTY; without even the implied warranty of
15** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16** GNU General Public License for more details.
17**
18** You should have received a copy of the GNU General Public License
19** along with this program; if not, write to the Free Software
20** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21**
22**-----------------------------------------------------------------------------
23 */
24
25/* Notes:
26 *
27 * This driver is designed exclusively for these chips (virtually the
28 * earliest of the scripts engine chips). They need their own drivers
29 * because they are missing so many of the scripts and snazzy register
30 * features of their elder brothers (the 710, 720 and 770).
31 *
32 * The 700 is the lowliest of the line, it can only do async SCSI.
33 * The 700-66 can at least do synchronous SCSI up to 10MHz.
34 *
35 * The 700 chip has no host bus interface logic of its own. However,
36 * it is usually mapped to a location with well defined register
37 * offsets. Therefore, if you can determine the base address and the
38 * irq your board incorporating this chip uses, you can probably use
39 * this driver to run it (although you'll probably have to write a
40 * minimal wrapper for the purpose---see the NCR_D700 driver for
41 * details about how to do this).
42 *
43 *
44 * TODO List:
45 *
46 * 1. Better statistics in the proc fs
47 *
48 * 2. Implement message queue (queues SCSI messages like commands) and make
49 * the abort and device reset functions use them.
50 * */
51
52/* CHANGELOG
53 *
54 * Version 2.8
55 *
56 * Fixed bad bug affecting tag starvation processing (previously the
57 * driver would hang the system if too many tags starved. Also fixed
58 * bad bug having to do with 10 byte command processing and REQUEST
59 * SENSE (the command would loop forever getting a transfer length
60 * mismatch in the CMD phase).
61 *
62 * Version 2.7
63 *
64 * Fixed scripts problem which caused certain devices (notably CDRWs)
65 * to hang on initial INQUIRY. Updated NCR_700_readl/writel to use
66 * __raw_readl/writel for parisc compatibility (Thomas
67 * Bogendoerfer). Added missing SCp->request_bufflen initialisation
68 * for sense requests (Ryan Bradetich).
69 *
70 * Version 2.6
71 *
72 * Following test of the 64 bit parisc kernel by Richard Hirst,
73 * several problems have now been corrected. Also adds support for
74 * consistent memory allocation.
75 *
76 * Version 2.5
77 *
78 * More Compatibility changes for 710 (now actually works). Enhanced
79 * support for odd clock speeds which constrain SDTR negotiations.
80 * correct cacheline separation for scsi messages and status for
81 * incoherent architectures. Use of the pci mapping functions on
82 * buffers to begin support for 64 bit drivers.
83 *
84 * Version 2.4
85 *
86 * Added support for the 53c710 chip (in 53c700 emulation mode only---no
87 * special 53c710 instructions or registers are used).
88 *
89 * Version 2.3
90 *
91 * More endianness/cache coherency changes.
92 *
93 * Better bad device handling (handles devices lying about tag
94 * queueing support and devices which fail to provide sense data on
95 * contingent allegiance conditions)
96 *
97 * Many thanks to Richard Hirst <rhirst@linuxcare.com> for patiently
98 * debugging this driver on the parisc architecture and suggesting
99 * many improvements and bug fixes.
100 *
101 * Thanks also go to Linuxcare Inc. for providing several PARISC
102 * machines for me to debug the driver on.
103 *
104 * Version 2.2
105 *
106 * Made the driver mem or io mapped; added endian invariance; added
107 * dma cache flushing operations for architectures which need it;
108 * added support for more varied clocking speeds.
109 *
110 * Version 2.1
111 *
112 * Initial modularisation from the D700. See NCR_D700.c for the rest of
113 * the changelog.
114 * */
115#define NCR_700_VERSION "2.8"
116
117#include <linux/config.h>
118#include <linux/kernel.h>
119#include <linux/types.h>
120#include <linux/string.h>
121#include <linux/ioport.h>
122#include <linux/delay.h>
123#include <linux/spinlock.h>
124#include <linux/completion.h>
125#include <linux/sched.h>
126#include <linux/init.h>
127#include <linux/proc_fs.h>
128#include <linux/blkdev.h>
129#include <linux/module.h>
130#include <linux/interrupt.h>
131#include <asm/dma.h>
132#include <asm/system.h>
133#include <asm/io.h>
134#include <asm/pgtable.h>
135#include <asm/byteorder.h>
136
137#include <scsi/scsi.h>
138#include <scsi/scsi_cmnd.h>
139#include <scsi/scsi_dbg.h>
140#include <scsi/scsi_eh.h>
141#include <scsi/scsi_host.h>
142#include <scsi/scsi_tcq.h>
143#include <scsi/scsi_transport.h>
144#include <scsi/scsi_transport_spi.h>
145
146#include "53c700.h"
147
148/* NOTE: For 64 bit drivers there are points in the code where we use
149 * a non dereferenceable pointer to point to a structure in dma-able
150 * memory (which is 32 bits) so that we can use all of the structure
151 * operations but take the address at the end. This macro allows us
152 * to truncate the 64 bit pointer down to 32 bits without the compiler
153 * complaining */
154#define to32bit(x) ((__u32)((unsigned long)(x)))
155
156#ifdef NCR_700_DEBUG
157#define STATIC
158#else
159#define STATIC static
160#endif
161
162MODULE_AUTHOR("James Bottomley");
163MODULE_DESCRIPTION("53c700 and 53c700-66 Driver");
164MODULE_LICENSE("GPL");
165
166/* This is the script */
167#include "53c700_d.h"
168
169
170STATIC int NCR_700_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
171STATIC int NCR_700_abort(struct scsi_cmnd * SCpnt);
172STATIC int NCR_700_bus_reset(struct scsi_cmnd * SCpnt);
173STATIC int NCR_700_dev_reset(struct scsi_cmnd * SCpnt);
174STATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt);
175STATIC void NCR_700_chip_setup(struct Scsi_Host *host);
176STATIC void NCR_700_chip_reset(struct Scsi_Host *host);
177STATIC int NCR_700_slave_configure(struct scsi_device *SDpnt);
178STATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt);
179static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth);
180static int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth);
181
182STATIC struct device_attribute *NCR_700_dev_attrs[];
183
184STATIC struct scsi_transport_template *NCR_700_transport_template = NULL;
185
186static char *NCR_700_phase[] = {
187 "",
188 "after selection",
189 "before command phase",
190 "after command phase",
191 "after status phase",
192 "after data in phase",
193 "after data out phase",
194 "during data phase",
195};
196
197static char *NCR_700_condition[] = {
198 "",
199 "NOT MSG_OUT",
200 "UNEXPECTED PHASE",
201 "NOT MSG_IN",
202 "UNEXPECTED MSG",
203 "MSG_IN",
204 "SDTR_MSG RECEIVED",
205 "REJECT_MSG RECEIVED",
206 "DISCONNECT_MSG RECEIVED",
207 "MSG_OUT",
208 "DATA_IN",
209
210};
211
212static char *NCR_700_fatal_messages[] = {
213 "unexpected message after reselection",
214 "still MSG_OUT after message injection",
215 "not MSG_IN after selection",
216 "Illegal message length received",
217};
218
219static char *NCR_700_SBCL_bits[] = {
220 "IO ",
221 "CD ",
222 "MSG ",
223 "ATN ",
224 "SEL ",
225 "BSY ",
226 "ACK ",
227 "REQ ",
228};
229
230static char *NCR_700_SBCL_to_phase[] = {
231 "DATA_OUT",
232 "DATA_IN",
233 "CMD_OUT",
234 "STATE",
235 "ILLEGAL PHASE",
236 "ILLEGAL PHASE",
237 "MSG OUT",
238 "MSG IN",
239};
240
241static __u8 NCR_700_SDTR_msg[] = {
242 0x01, /* Extended message */
243 0x03, /* Extended message Length */
244 0x01, /* SDTR Extended message */
245 NCR_700_MIN_PERIOD,
246 NCR_700_MAX_OFFSET
247};
248
249/* This translates the SDTR message offset and period to a value
250 * which can be loaded into the SXFER_REG.
251 *
252 * NOTE: According to SCSI-2, the true transfer period (in ns) is
253 * actually four times this period value */
254static inline __u8
255NCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata,
256 __u8 offset, __u8 period)
257{
258 int XFERP;
259
260 __u8 min_xferp = (hostdata->chip710
261 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
262 __u8 max_offset = (hostdata->chip710
263 ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET);
264
265 if(offset == 0)
266 return 0;
267
268 if(period < hostdata->min_period) {
269 printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %d\n", period*4, NCR_700_SDTR_msg[3]*4);
270 period = hostdata->min_period;
271 }
272 XFERP = (period*4 * hostdata->sync_clock)/1000 - 4;
273 if(offset > max_offset) {
274 printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %d\n",
275 offset, max_offset);
276 offset = max_offset;
277 }
278 if(XFERP < min_xferp) {
279 printk(KERN_WARNING "53c700: XFERP %d is less than minium, setting to %d\n",
280 XFERP, min_xferp);
281 XFERP = min_xferp;
282 }
283 return (offset & 0x0f) | (XFERP & 0x07)<<4;
284}
285
286static inline __u8
287NCR_700_get_SXFER(struct scsi_device *SDp)
288{
289 struct NCR_700_Host_Parameters *hostdata =
290 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
291
292 return NCR_700_offset_period_to_sxfer(hostdata,
293 spi_offset(SDp->sdev_target),
294 spi_period(SDp->sdev_target));
295}
296
297struct Scsi_Host *
298NCR_700_detect(struct scsi_host_template *tpnt,
299 struct NCR_700_Host_Parameters *hostdata, struct device *dev)
300{
301 dma_addr_t pScript, pSlots;
302 __u8 *memory;
303 __u32 *script;
304 struct Scsi_Host *host;
305 static int banner = 0;
306 int j;
307
308 if(tpnt->sdev_attrs == NULL)
309 tpnt->sdev_attrs = NCR_700_dev_attrs;
310
311 memory = dma_alloc_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
312 &pScript, GFP_KERNEL);
313 if(memory == NULL) {
314 printk(KERN_ERR "53c700: Failed to allocate memory for driver, detatching\n");
315 return NULL;
316 }
317
318 script = (__u32 *)memory;
319 hostdata->msgin = memory + MSGIN_OFFSET;
320 hostdata->msgout = memory + MSGOUT_OFFSET;
321 hostdata->status = memory + STATUS_OFFSET;
322 /* all of these offsets are L1_CACHE_BYTES separated. It is fatal
323 * if this isn't sufficient separation to avoid dma flushing issues */
324 BUG_ON(!dma_is_consistent(pScript) && L1_CACHE_BYTES < dma_get_cache_alignment());
325 hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET);
326 hostdata->dev = dev;
327
328 pSlots = pScript + SLOTS_OFFSET;
329
330 /* Fill in the missing routines from the host template */
331 tpnt->queuecommand = NCR_700_queuecommand;
332 tpnt->eh_abort_handler = NCR_700_abort;
333 tpnt->eh_device_reset_handler = NCR_700_dev_reset;
334 tpnt->eh_bus_reset_handler = NCR_700_bus_reset;
335 tpnt->eh_host_reset_handler = NCR_700_host_reset;
336 tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST;
337 tpnt->sg_tablesize = NCR_700_SG_SEGMENTS;
338 tpnt->cmd_per_lun = NCR_700_CMD_PER_LUN;
339 tpnt->use_clustering = ENABLE_CLUSTERING;
340 tpnt->slave_configure = NCR_700_slave_configure;
341 tpnt->slave_destroy = NCR_700_slave_destroy;
342 tpnt->change_queue_depth = NCR_700_change_queue_depth;
343 tpnt->change_queue_type = NCR_700_change_queue_type;
344
345 if(tpnt->name == NULL)
346 tpnt->name = "53c700";
347 if(tpnt->proc_name == NULL)
348 tpnt->proc_name = "53c700";
349
350
351 host = scsi_host_alloc(tpnt, 4);
352 if (!host)
353 return NULL;
354 memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot)
355 * NCR_700_COMMAND_SLOTS_PER_HOST);
356 for(j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) {
357 dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0]
358 - (unsigned long)&hostdata->slots[0].SG[0]);
359 hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset));
360 if(j == 0)
361 hostdata->free_list = &hostdata->slots[j];
362 else
363 hostdata->slots[j-1].ITL_forw = &hostdata->slots[j];
364 hostdata->slots[j].state = NCR_700_SLOT_FREE;
365 }
366
367 for(j = 0; j < sizeof(SCRIPT)/sizeof(SCRIPT[0]); j++) {
368 script[j] = bS_to_host(SCRIPT[j]);
369 }
370
371 /* adjust all labels to be bus physical */
372 for(j = 0; j < PATCHES; j++) {
373 script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]);
374 }
375 /* now patch up fixed addresses. */
376 script_patch_32(script, MessageLocation,
377 pScript + MSGOUT_OFFSET);
378 script_patch_32(script, StatusAddress,
379 pScript + STATUS_OFFSET);
380 script_patch_32(script, ReceiveMsgAddress,
381 pScript + MSGIN_OFFSET);
382
383 hostdata->script = script;
384 hostdata->pScript = pScript;
385 dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE);
386 hostdata->state = NCR_700_HOST_FREE;
387 hostdata->cmd = NULL;
388 host->max_id = 7;
389 host->max_lun = NCR_700_MAX_LUNS;
390 BUG_ON(NCR_700_transport_template == NULL);
391 host->transportt = NCR_700_transport_template;
392 host->unique_id = hostdata->base;
393 host->base = hostdata->base;
394 hostdata->eh_complete = NULL;
395 host->hostdata[0] = (unsigned long)hostdata;
396 /* kick the chip */
397 NCR_700_writeb(0xff, host, CTEST9_REG);
398 if(hostdata->chip710)
399 hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f;
400 else
401 hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f;
402 hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0);
403 if(banner == 0) {
404 printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.com\n");
405 banner = 1;
406 }
407 printk(KERN_NOTICE "scsi%d: %s rev %d %s\n", host->host_no,
408 hostdata->chip710 ? "53c710" :
409 (hostdata->fast ? "53c700-66" : "53c700"),
410 hostdata->rev, hostdata->differential ?
411 "(Differential)" : "");
412 /* reset the chip */
413 NCR_700_chip_reset(host);
414
415 if (scsi_add_host(host, dev)) {
416 dev_printk(KERN_ERR, dev, "53c700: scsi_add_host failed\n");
417 scsi_host_put(host);
418 return NULL;
419 }
420
421 spi_signalling(host) = hostdata->differential ? SPI_SIGNAL_HVD :
422 SPI_SIGNAL_SE;
423
424 return host;
425}
426
427int
428NCR_700_release(struct Scsi_Host *host)
429{
430 struct NCR_700_Host_Parameters *hostdata =
431 (struct NCR_700_Host_Parameters *)host->hostdata[0];
432
433 dma_free_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
434 hostdata->script, hostdata->pScript);
435 return 1;
436}
437
438static inline __u8
439NCR_700_identify(int can_disconnect, __u8 lun)
440{
441 return IDENTIFY_BASE |
442 ((can_disconnect) ? 0x40 : 0) |
443 (lun & NCR_700_LUN_MASK);
444}
445
446/*
447 * Function : static int data_residual (Scsi_Host *host)
448 *
449 * Purpose : return residual data count of what's in the chip. If you
450 * really want to know what this function is doing, it's almost a
451 * direct transcription of the algorithm described in the 53c710
452 * guide, except that the DBC and DFIFO registers are only 6 bits
453 * wide on a 53c700.
454 *
455 * Inputs : host - SCSI host */
456static inline int
457NCR_700_data_residual (struct Scsi_Host *host) {
458 struct NCR_700_Host_Parameters *hostdata =
459 (struct NCR_700_Host_Parameters *)host->hostdata[0];
460 int count, synchronous = 0;
461 unsigned int ddir;
462
463 if(hostdata->chip710) {
464 count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) -
465 (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f;
466 } else {
467 count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) -
468 (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f;
469 }
470
471 if(hostdata->fast)
472 synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f;
473
474 /* get the data direction */
475 ddir = NCR_700_readb(host, CTEST0_REG) & 0x01;
476
477 if (ddir) {
478 /* Receive */
479 if (synchronous)
480 count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4;
481 else
482 if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL)
483 ++count;
484 } else {
485 /* Send */
486 __u8 sstat = NCR_700_readb(host, SSTAT1_REG);
487 if (sstat & SODL_REG_FULL)
488 ++count;
489 if (synchronous && (sstat & SODR_REG_FULL))
490 ++count;
491 }
492#ifdef NCR_700_DEBUG
493 if(count)
494 printk("RESIDUAL IS %d (ddir %d)\n", count, ddir);
495#endif
496 return count;
497}
498
499/* print out the SCSI wires and corresponding phase from the SBCL register
500 * in the chip */
501static inline char *
502sbcl_to_string(__u8 sbcl)
503{
504 int i;
505 static char ret[256];
506
507 ret[0]='\0';
508 for(i=0; i<8; i++) {
509 if((1<<i) & sbcl)
510 strcat(ret, NCR_700_SBCL_bits[i]);
511 }
512 strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]);
513 return ret;
514}
515
516static inline __u8
517bitmap_to_number(__u8 bitmap)
518{
519 __u8 i;
520
521 for(i=0; i<8 && !(bitmap &(1<<i)); i++)
522 ;
523 return i;
524}
525
526/* Pull a slot off the free list */
527STATIC struct NCR_700_command_slot *
528find_empty_slot(struct NCR_700_Host_Parameters *hostdata)
529{
530 struct NCR_700_command_slot *slot = hostdata->free_list;
531
532 if(slot == NULL) {
533 /* sanity check */
534 if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST)
535 printk(KERN_ERR "SLOTS FULL, but count is %d, should be %d\n", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST);
536 return NULL;
537 }
538
539 if(slot->state != NCR_700_SLOT_FREE)
540 /* should panic! */
541 printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!\n");
542
543
544 hostdata->free_list = slot->ITL_forw;
545 slot->ITL_forw = NULL;
546
547
548 /* NOTE: set the state to busy here, not queued, since this
549 * indicates the slot is in use and cannot be run by the IRQ
550 * finish routine. If we cannot queue the command when it
551 * is properly build, we then change to NCR_700_SLOT_QUEUED */
552 slot->state = NCR_700_SLOT_BUSY;
553 hostdata->command_slot_count++;
554
555 return slot;
556}
557
558STATIC void
559free_slot(struct NCR_700_command_slot *slot,
560 struct NCR_700_Host_Parameters *hostdata)
561{
562 if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) {
563 printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!\n", slot);
564 }
565 if(slot->state == NCR_700_SLOT_FREE) {
566 printk(KERN_ERR "53c700: SLOT %p is FREE!!!\n", slot);
567 }
568
569 slot->resume_offset = 0;
570 slot->cmnd = NULL;
571 slot->state = NCR_700_SLOT_FREE;
572 slot->ITL_forw = hostdata->free_list;
573 hostdata->free_list = slot;
574 hostdata->command_slot_count--;
575}
576
577
578/* This routine really does very little. The command is indexed on
579 the ITL and (if tagged) the ITLQ lists in _queuecommand */
580STATIC void
581save_for_reselection(struct NCR_700_Host_Parameters *hostdata,
582 struct scsi_cmnd *SCp, __u32 dsp)
583{
584 /* Its just possible that this gets executed twice */
585 if(SCp != NULL) {
586 struct NCR_700_command_slot *slot =
587 (struct NCR_700_command_slot *)SCp->host_scribble;
588
589 slot->resume_offset = dsp;
590 }
591 hostdata->state = NCR_700_HOST_FREE;
592 hostdata->cmd = NULL;
593}
594
595STATIC inline void
596NCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, struct scsi_cmnd *SCp,
597 struct NCR_700_command_slot *slot)
598{
599 if(SCp->sc_data_direction != DMA_NONE &&
600 SCp->sc_data_direction != DMA_BIDIRECTIONAL) {
601 if(SCp->use_sg) {
602 dma_unmap_sg(hostdata->dev, SCp->buffer,
603 SCp->use_sg, SCp->sc_data_direction);
604 } else {
605 dma_unmap_single(hostdata->dev, slot->dma_handle,
606 SCp->request_bufflen,
607 SCp->sc_data_direction);
608 }
609 }
610}
611
612STATIC inline void
613NCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata,
614 struct scsi_cmnd *SCp, int result)
615{
616 hostdata->state = NCR_700_HOST_FREE;
617 hostdata->cmd = NULL;
618
619 if(SCp != NULL) {
620 struct NCR_700_command_slot *slot =
621 (struct NCR_700_command_slot *)SCp->host_scribble;
622
623 NCR_700_unmap(hostdata, SCp, slot);
624 dma_unmap_single(hostdata->dev, slot->pCmd,
625 sizeof(SCp->cmnd), DMA_TO_DEVICE);
626 if(SCp->cmnd[0] == REQUEST_SENSE && SCp->cmnd[6] == NCR_700_INTERNAL_SENSE_MAGIC) {
627#ifdef NCR_700_DEBUG
628 printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense is\n",
629 SCp, SCp->cmnd[7], result);
630 scsi_print_sense("53c700", SCp);
631
632#endif
633 /* restore the old result if the request sense was
634 * successful */
635 if(result == 0)
636 result = SCp->cmnd[7];
637 /* now restore the original command */
638 memcpy((void *) SCp->cmnd, (void *) SCp->data_cmnd,
639 sizeof(SCp->data_cmnd));
640 SCp->request_buffer = SCp->buffer;
641 SCp->request_bufflen = SCp->bufflen;
642 SCp->use_sg = SCp->old_use_sg;
643 SCp->cmd_len = SCp->old_cmd_len;
644 SCp->sc_data_direction = SCp->sc_old_data_direction;
645 SCp->underflow = SCp->old_underflow;
646
647 }
648 free_slot(slot, hostdata);
649#ifdef NCR_700_DEBUG
650 if(NCR_700_get_depth(SCp->device) == 0 ||
651 NCR_700_get_depth(SCp->device) > SCp->device->queue_depth)
652 printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %d\n",
653 NCR_700_get_depth(SCp->device));
654#endif /* NCR_700_DEBUG */
655 NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1);
656
657 SCp->host_scribble = NULL;
658 SCp->result = result;
659 SCp->scsi_done(SCp);
660 } else {
661 printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCp\n");
662 }
663}
664
665
666STATIC void
667NCR_700_internal_bus_reset(struct Scsi_Host *host)
668{
669 /* Bus reset */
670 NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG);
671 udelay(50);
672 NCR_700_writeb(0, host, SCNTL1_REG);
673
674}
675
676STATIC void
677NCR_700_chip_setup(struct Scsi_Host *host)
678{
679 struct NCR_700_Host_Parameters *hostdata =
680 (struct NCR_700_Host_Parameters *)host->hostdata[0];
681 __u32 dcntl_extra = 0;
682 __u8 min_period;
683 __u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
684
685 if(hostdata->chip710) {
686 __u8 burst_disable = hostdata->burst_disable
687 ? BURST_DISABLE : 0;
688 dcntl_extra = COMPAT_700_MODE;
689
690 NCR_700_writeb(dcntl_extra, host, DCNTL_REG);
691 NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra,
692 host, DMODE_710_REG);
693 NCR_700_writeb(burst_disable | (hostdata->differential ?
694 DIFF : 0), host, CTEST7_REG);
695 NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG);
696 NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY
697 | AUTO_ATN, host, SCNTL0_REG);
698 } else {
699 NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra,
700 host, DMODE_700_REG);
701 NCR_700_writeb(hostdata->differential ?
702 DIFF : 0, host, CTEST7_REG);
703 if(hostdata->fast) {
704 /* this is for 700-66, does nothing on 700 */
705 NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION
706 | GENERATE_RECEIVE_PARITY, host,
707 CTEST8_REG);
708 } else {
709 NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY
710 | PARITY | AUTO_ATN, host, SCNTL0_REG);
711 }
712 }
713
714 NCR_700_writeb(1 << host->this_id, host, SCID_REG);
715 NCR_700_writeb(0, host, SBCL_REG);
716 NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG);
717
718 NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT
719 | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG);
720
721 NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG);
722 NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG);
723 if(hostdata->clock > 75) {
724 printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata->clock);
725 /* do the best we can, but the async clock will be out
726 * of spec: sync divider 2, async divider 3 */
727 DEBUG(("53c700: sync 2 async 3\n"));
728 NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG);
729 NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
730 hostdata->sync_clock = hostdata->clock/2;
731 } else if(hostdata->clock > 50 && hostdata->clock <= 75) {
732 /* sync divider 1.5, async divider 3 */
733 DEBUG(("53c700: sync 1.5 async 3\n"));
734 NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG);
735 NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
736 hostdata->sync_clock = hostdata->clock*2;
737 hostdata->sync_clock /= 3;
738
739 } else if(hostdata->clock > 37 && hostdata->clock <= 50) {
740 /* sync divider 1, async divider 2 */
741 DEBUG(("53c700: sync 1 async 2\n"));
742 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
743 NCR_700_writeb(ASYNC_DIV_2_0 | dcntl_extra, host, DCNTL_REG);
744 hostdata->sync_clock = hostdata->clock;
745 } else if(hostdata->clock > 25 && hostdata->clock <=37) {
746 /* sync divider 1, async divider 1.5 */
747 DEBUG(("53c700: sync 1 async 1.5\n"));
748 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
749 NCR_700_writeb(ASYNC_DIV_1_5 | dcntl_extra, host, DCNTL_REG);
750 hostdata->sync_clock = hostdata->clock;
751 } else {
752 DEBUG(("53c700: sync 1 async 1\n"));
753 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
754 NCR_700_writeb(ASYNC_DIV_1_0 | dcntl_extra, host, DCNTL_REG);
755 /* sync divider 1, async divider 1 */
756 hostdata->sync_clock = hostdata->clock;
757 }
758 /* Calculate the actual minimum period that can be supported
759 * by our synchronous clock speed. See the 710 manual for
760 * exact details of this calculation which is based on a
761 * setting of the SXFER register */
762 min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock);
763 hostdata->min_period = NCR_700_MIN_PERIOD;
764 if(min_period > NCR_700_MIN_PERIOD)
765 hostdata->min_period = min_period;
766}
767
768STATIC void
769NCR_700_chip_reset(struct Scsi_Host *host)
770{
771 struct NCR_700_Host_Parameters *hostdata =
772 (struct NCR_700_Host_Parameters *)host->hostdata[0];
773 if(hostdata->chip710) {
774 NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG);
775 udelay(100);
776
777 NCR_700_writeb(0, host, ISTAT_REG);
778 } else {
779 NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG);
780 udelay(100);
781
782 NCR_700_writeb(0, host, DCNTL_REG);
783 }
784
785 mdelay(1000);
786
787 NCR_700_chip_setup(host);
788}
789
790/* The heart of the message processing engine is that the instruction
791 * immediately after the INT is the normal case (and so must be CLEAR
792 * ACK). If we want to do something else, we call that routine in
793 * scripts and set temp to be the normal case + 8 (skipping the CLEAR
794 * ACK) so that the routine returns correctly to resume its activity
795 * */
796STATIC __u32
797process_extended_message(struct Scsi_Host *host,
798 struct NCR_700_Host_Parameters *hostdata,
799 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
800{
801 __u32 resume_offset = dsp, temp = dsp + 8;
802 __u8 pun = 0xff, lun = 0xff;
803
804 if(SCp != NULL) {
805 pun = SCp->device->id;
806 lun = SCp->device->lun;
807 }
808
809 switch(hostdata->msgin[2]) {
810 case A_SDTR_MSG:
811 if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
812 struct scsi_target *starget = SCp->device->sdev_target;
813 __u8 period = hostdata->msgin[3];
814 __u8 offset = hostdata->msgin[4];
815
816 if(offset == 0 || period == 0) {
817 offset = 0;
818 period = 0;
819 }
820
821 spi_offset(starget) = offset;
822 spi_period(starget) = period;
823
824 if(NCR_700_is_flag_set(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION)) {
825 spi_display_xfer_agreement(starget);
826 NCR_700_clear_flag(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION);
827 }
828
829 NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
830 NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
831
832 NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
833 host, SXFER_REG);
834
835 } else {
836 /* SDTR message out of the blue, reject it */
837 printk(KERN_WARNING "scsi%d Unexpected SDTR msg\n",
838 host->host_no);
839 hostdata->msgout[0] = A_REJECT_MSG;
840 dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
841 script_patch_16(hostdata->script, MessageCount, 1);
842 /* SendMsgOut returns, so set up the return
843 * address */
844 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
845 }
846 break;
847
848 case A_WDTR_MSG:
849 printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n",
850 host->host_no, pun, lun);
851 hostdata->msgout[0] = A_REJECT_MSG;
852 dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
853 script_patch_16(hostdata->script, MessageCount, 1);
854 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
855
856 break;
857
858 default:
859 printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
860 host->host_no, pun, lun,
861 NCR_700_phase[(dsps & 0xf00) >> 8]);
862 scsi_print_msg(hostdata->msgin);
863 printk("\n");
864 /* just reject it */
865 hostdata->msgout[0] = A_REJECT_MSG;
866 dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
867 script_patch_16(hostdata->script, MessageCount, 1);
868 /* SendMsgOut returns, so set up the return
869 * address */
870 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
871 }
872 NCR_700_writel(temp, host, TEMP_REG);
873 return resume_offset;
874}
875
876STATIC __u32
877process_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata,
878 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
879{
880 /* work out where to return to */
881 __u32 temp = dsp + 8, resume_offset = dsp;
882 __u8 pun = 0xff, lun = 0xff;
883
884 if(SCp != NULL) {
885 pun = SCp->device->id;
886 lun = SCp->device->lun;
887 }
888
889#ifdef NCR_700_DEBUG
890 printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun,
891 NCR_700_phase[(dsps & 0xf00) >> 8]);
892 scsi_print_msg(hostdata->msgin);
893 printk("\n");
894#endif
895
896 switch(hostdata->msgin[0]) {
897
898 case A_EXTENDED_MSG:
899 resume_offset = process_extended_message(host, hostdata, SCp,
900 dsp, dsps);
901 break;
902
903 case A_REJECT_MSG:
904 if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
905 /* Rejected our sync negotiation attempt */
906 spi_period(SCp->device->sdev_target) =
907 spi_offset(SCp->device->sdev_target) = 0;
908 NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
909 NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
910 } else if(SCp != NULL && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) {
911 /* rejected our first simple tag message */
912 printk(KERN_WARNING "scsi%d (%d:%d) Rejected first tag queue attempt, turning off tag queueing\n", host->host_no, pun, lun);
913 /* we're done negotiating */
914 NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION);
915 hostdata->tag_negotiated &= ~(1<<SCp->device->id);
916 SCp->device->tagged_supported = 0;
917 scsi_deactivate_tcq(SCp->device, host->cmd_per_lun);
918 } else {
919 printk(KERN_WARNING "scsi%d (%d:%d) Unexpected REJECT Message %s\n",
920 host->host_no, pun, lun,
921 NCR_700_phase[(dsps & 0xf00) >> 8]);
922 /* however, just ignore it */
923 }
924 break;
925
926 case A_PARITY_ERROR_MSG:
927 printk(KERN_ERR "scsi%d (%d:%d) Parity Error!\n", host->host_no,
928 pun, lun);
929 NCR_700_internal_bus_reset(host);
930 break;
931 case A_SIMPLE_TAG_MSG:
932 printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %s\n", host->host_no,
933 pun, lun, hostdata->msgin[1],
934 NCR_700_phase[(dsps & 0xf00) >> 8]);
935 /* just ignore it */
936 break;
937 default:
938 printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
939 host->host_no, pun, lun,
940 NCR_700_phase[(dsps & 0xf00) >> 8]);
941
942 scsi_print_msg(hostdata->msgin);
943 printk("\n");
944 /* just reject it */
945 hostdata->msgout[0] = A_REJECT_MSG;
946 dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
947 script_patch_16(hostdata->script, MessageCount, 1);
948 /* SendMsgOut returns, so set up the return
949 * address */
950 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
951
952 break;
953 }
954 NCR_700_writel(temp, host, TEMP_REG);
955 /* set us up to receive another message */
956 dma_cache_sync(hostdata->msgin, MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
957 return resume_offset;
958}
959
960STATIC __u32
961process_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp,
962 struct Scsi_Host *host,
963 struct NCR_700_Host_Parameters *hostdata)
964{
965 __u32 resume_offset = 0;
966 __u8 pun = 0xff, lun=0xff;
967
968 if(SCp != NULL) {
969 pun = SCp->device->id;
970 lun = SCp->device->lun;
971 }
972
973 if(dsps == A_GOOD_STATUS_AFTER_STATUS) {
974 DEBUG((" COMMAND COMPLETE, status=%02x\n",
975 hostdata->status[0]));
976 /* OK, if TCQ still under negotiation, we now know it works */
977 if (NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION)
978 NCR_700_set_tag_neg_state(SCp->device,
979 NCR_700_FINISHED_TAG_NEGOTIATION);
980
981 /* check for contingent allegiance contitions */
982 if(status_byte(hostdata->status[0]) == CHECK_CONDITION ||
983 status_byte(hostdata->status[0]) == COMMAND_TERMINATED) {
984 struct NCR_700_command_slot *slot =
985 (struct NCR_700_command_slot *)SCp->host_scribble;
986 if(SCp->cmnd[0] == REQUEST_SENSE) {
987 /* OOPS: bad device, returning another
988 * contingent allegiance condition */
989 printk(KERN_ERR "scsi%d (%d:%d) broken device is looping in contingent allegiance: ignoring\n", host->host_no, pun, lun);
990 NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
991 } else {
992#ifdef NCR_DEBUG
993 scsi_print_command(SCp);
994 printk(" cmd %p has status %d, requesting sense\n",
995 SCp, hostdata->status[0]);
996#endif
997 /* we can destroy the command here
998 * because the contingent allegiance
999 * condition will cause a retry which
1000 * will re-copy the command from the
1001 * saved data_cmnd. We also unmap any
1002 * data associated with the command
1003 * here */
1004 NCR_700_unmap(hostdata, SCp, slot);
1005
1006 SCp->cmnd[0] = REQUEST_SENSE;
1007 SCp->cmnd[1] = (SCp->device->lun & 0x7) << 5;
1008 SCp->cmnd[2] = 0;
1009 SCp->cmnd[3] = 0;
1010 SCp->cmnd[4] = sizeof(SCp->sense_buffer);
1011 SCp->cmnd[5] = 0;
1012 SCp->cmd_len = 6;
1013 /* Here's a quiet hack: the
1014 * REQUEST_SENSE command is six bytes,
1015 * so store a flag indicating that
1016 * this was an internal sense request
1017 * and the original status at the end
1018 * of the command */
1019 SCp->cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC;
1020 SCp->cmnd[7] = hostdata->status[0];
1021 SCp->use_sg = 0;
1022 SCp->sc_data_direction = DMA_FROM_DEVICE;
1023 dma_sync_single_for_device(hostdata->dev, slot->pCmd,
1024 SCp->cmd_len, DMA_TO_DEVICE);
1025 SCp->request_bufflen = sizeof(SCp->sense_buffer);
1026 slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
1027 slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | sizeof(SCp->sense_buffer));
1028 slot->SG[0].pAddr = bS_to_host(slot->dma_handle);
1029 slot->SG[1].ins = bS_to_host(SCRIPT_RETURN);
1030 slot->SG[1].pAddr = 0;
1031 slot->resume_offset = hostdata->pScript;
1032 dma_cache_sync(slot->SG, sizeof(slot->SG[0])*2, DMA_TO_DEVICE);
1033 dma_cache_sync(SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
1034
1035 /* queue the command for reissue */
1036 slot->state = NCR_700_SLOT_QUEUED;
1037 hostdata->state = NCR_700_HOST_FREE;
1038 hostdata->cmd = NULL;
1039 }
1040 } else {
1041 // Currently rely on the mid layer evaluation
1042 // of the tag queuing capability
1043 //
1044 //if(status_byte(hostdata->status[0]) == GOOD &&
1045 // SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) {
1046 // /* Piggy back the tag queueing support
1047 // * on this command */
1048 // dma_sync_single_for_cpu(hostdata->dev,
1049 // slot->dma_handle,
1050 // SCp->request_bufflen,
1051 // DMA_FROM_DEVICE);
1052 // if(((char *)SCp->request_buffer)[7] & 0x02) {
1053 // printk(KERN_INFO "scsi%d: (%d:%d) Enabling Tag Command Queuing\n", host->host_no, pun, lun);
1054 // hostdata->tag_negotiated |= (1<<SCp->device->id);
1055 // NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1056 // } else {
1057 // NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1058 // hostdata->tag_negotiated &= ~(1<<SCp->device->id);
1059 // }
1060 //}
1061 NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
1062 }
1063 } else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) {
1064 __u8 i = (dsps & 0xf00) >> 8;
1065
1066 printk(KERN_ERR "scsi%d: (%d:%d), UNEXPECTED PHASE %s (%s)\n",
1067 host->host_no, pun, lun,
1068 NCR_700_phase[i],
1069 sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
1070 printk(KERN_ERR " len = %d, cmd =", SCp->cmd_len);
1071 scsi_print_command(SCp);
1072
1073 NCR_700_internal_bus_reset(host);
1074 } else if((dsps & 0xfffff000) == A_FATAL) {
1075 int i = (dsps & 0xfff);
1076
1077 printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %s\n",
1078 host->host_no, pun, lun, NCR_700_fatal_messages[i]);
1079 if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) {
1080 printk(KERN_ERR " msg begins %02x %02x\n",
1081 hostdata->msgin[0], hostdata->msgin[1]);
1082 }
1083 NCR_700_internal_bus_reset(host);
1084 } else if((dsps & 0xfffff0f0) == A_DISCONNECT) {
1085#ifdef NCR_700_DEBUG
1086 __u8 i = (dsps & 0xf00) >> 8;
1087
1088 printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n",
1089 host->host_no, pun, lun,
1090 i, NCR_700_phase[i]);
1091#endif
1092 save_for_reselection(hostdata, SCp, dsp);
1093
1094 } else if(dsps == A_RESELECTION_IDENTIFIED) {
1095 __u8 lun;
1096 struct NCR_700_command_slot *slot;
1097 __u8 reselection_id = hostdata->reselection_id;
1098 struct scsi_device *SDp;
1099
1100 lun = hostdata->msgin[0] & 0x1f;
1101
1102 hostdata->reselection_id = 0xff;
1103 DEBUG(("scsi%d: (%d:%d) RESELECTED!\n",
1104 host->host_no, reselection_id, lun));
1105 /* clear the reselection indicator */
1106 SDp = __scsi_device_lookup(host, 0, reselection_id, lun);
1107 if(unlikely(SDp == NULL)) {
1108 printk(KERN_ERR "scsi%d: (%d:%d) HAS NO device\n",
1109 host->host_no, reselection_id, lun);
1110 BUG();
1111 }
1112 if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) {
1113 struct scsi_cmnd *SCp = scsi_find_tag(SDp, hostdata->msgin[2]);
1114 if(unlikely(SCp == NULL)) {
1115 printk(KERN_ERR "scsi%d: (%d:%d) no saved request for tag %d\n",
1116 host->host_no, reselection_id, lun, hostdata->msgin[2]);
1117 BUG();
1118 }
1119
1120 slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1121 DEBUG(("53c700: %d:%d:%d, reselection is tag %d, slot %p(%d)\n",
1122 host->host_no, SDp->id, SDp->lun,
1123 hostdata->msgin[2], slot, slot->tag));
1124 } else {
1125 struct scsi_cmnd *SCp = scsi_find_tag(SDp, SCSI_NO_TAG);
1126 if(unlikely(SCp == NULL)) {
1127 printk(KERN_ERR "scsi%d: (%d:%d) no saved request for untagged cmd\n",
1128 host->host_no, reselection_id, lun);
1129 BUG();
1130 }
1131 slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1132 }
1133
1134 if(slot == NULL) {
1135 printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n",
1136 host->host_no, reselection_id, lun,
1137 hostdata->msgin[0], hostdata->msgin[1],
1138 hostdata->msgin[2]);
1139 } else {
1140 if(hostdata->state != NCR_700_HOST_BUSY)
1141 printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!\n",
1142 host->host_no);
1143 resume_offset = slot->resume_offset;
1144 hostdata->cmd = slot->cmnd;
1145
1146 /* re-patch for this command */
1147 script_patch_32_abs(hostdata->script, CommandAddress,
1148 slot->pCmd);
1149 script_patch_16(hostdata->script,
1150 CommandCount, slot->cmnd->cmd_len);
1151 script_patch_32_abs(hostdata->script, SGScriptStartAddress,
1152 to32bit(&slot->pSG[0].ins));
1153
1154 /* Note: setting SXFER only works if we're
1155 * still in the MESSAGE phase, so it is vital
1156 * that ACK is still asserted when we process
1157 * the reselection message. The resume offset
1158 * should therefore always clear ACK */
1159 NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device),
1160 host, SXFER_REG);
1161 dma_cache_sync(hostdata->msgin,
1162 MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
1163 dma_cache_sync(hostdata->msgout,
1164 MSG_ARRAY_SIZE, DMA_TO_DEVICE);
1165 /* I'm just being paranoid here, the command should
1166 * already have been flushed from the cache */
1167 dma_cache_sync(slot->cmnd->cmnd,
1168 slot->cmnd->cmd_len, DMA_TO_DEVICE);
1169
1170
1171
1172 }
1173 } else if(dsps == A_RESELECTED_DURING_SELECTION) {
1174
1175 /* This section is full of debugging code because I've
1176 * never managed to reach it. I think what happens is
1177 * that, because the 700 runs with selection
1178 * interrupts enabled the whole time that we take a
1179 * selection interrupt before we manage to get to the
1180 * reselected script interrupt */
1181
1182 __u8 reselection_id = NCR_700_readb(host, SFBR_REG);
1183 struct NCR_700_command_slot *slot;
1184
1185 /* Take out our own ID */
1186 reselection_id &= ~(1<<host->this_id);
1187
1188 /* I've never seen this happen, so keep this as a printk rather
1189 * than a debug */
1190 printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n",
1191 host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count);
1192
1193 {
1194 /* FIXME: DEBUGGING CODE */
1195 __u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]);
1196 int i;
1197
1198 for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1199 if(SG >= to32bit(&hostdata->slots[i].pSG[0])
1200 && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS]))
1201 break;
1202 }
1203 printk(KERN_INFO "IDENTIFIED SG segment as being %08x in slot %p, cmd %p, slot->resume_offset=%08x\n", SG, &hostdata->slots[i], hostdata->slots[i].cmnd, hostdata->slots[i].resume_offset);
1204 SCp = hostdata->slots[i].cmnd;
1205 }
1206
1207 if(SCp != NULL) {
1208 slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1209 /* change slot from busy to queued to redo command */
1210 slot->state = NCR_700_SLOT_QUEUED;
1211 }
1212 hostdata->cmd = NULL;
1213
1214 if(reselection_id == 0) {
1215 if(hostdata->reselection_id == 0xff) {
1216 printk(KERN_ERR "scsi%d: Invalid reselection during selection!!\n", host->host_no);
1217 return 0;
1218 } else {
1219 printk(KERN_ERR "scsi%d: script reselected and we took a selection interrupt\n",
1220 host->host_no);
1221 reselection_id = hostdata->reselection_id;
1222 }
1223 } else {
1224
1225 /* convert to real ID */
1226 reselection_id = bitmap_to_number(reselection_id);
1227 }
1228 hostdata->reselection_id = reselection_id;
1229 /* just in case we have a stale simple tag message, clear it */
1230 hostdata->msgin[1] = 0;
1231 dma_cache_sync(hostdata->msgin,
1232 MSG_ARRAY_SIZE, DMA_BIDIRECTIONAL);
1233 if(hostdata->tag_negotiated & (1<<reselection_id)) {
1234 resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
1235 } else {
1236 resume_offset = hostdata->pScript + Ent_GetReselectionData;
1237 }
1238 } else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) {
1239 /* we've just disconnected from the bus, do nothing since
1240 * a return here will re-run the queued command slot
1241 * that may have been interrupted by the initial selection */
1242 DEBUG((" SELECTION COMPLETED\n"));
1243 } else if((dsps & 0xfffff0f0) == A_MSG_IN) {
1244 resume_offset = process_message(host, hostdata, SCp,
1245 dsp, dsps);
1246 } else if((dsps & 0xfffff000) == 0) {
1247 __u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8;
1248 printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n",
1249 host->host_no, pun, lun, NCR_700_condition[i],
1250 NCR_700_phase[j], dsp - hostdata->pScript);
1251 if(SCp != NULL) {
1252 scsi_print_command(SCp);
1253
1254 if(SCp->use_sg) {
1255 for(i = 0; i < SCp->use_sg + 1; i++) {
1256 printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08x\n", i, ((struct scatterlist *)SCp->buffer)[i].length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr);
1257 }
1258 }
1259 }
1260 NCR_700_internal_bus_reset(host);
1261 } else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) {
1262 printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n",
1263 host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript);
1264 resume_offset = dsp;
1265 } else {
1266 printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n",
1267 host->host_no, pun, lun, dsps, dsp - hostdata->pScript);
1268 NCR_700_internal_bus_reset(host);
1269 }
1270 return resume_offset;
1271}
1272
1273/* We run the 53c700 with selection interrupts always enabled. This
1274 * means that the chip may be selected as soon as the bus frees. On a
1275 * busy bus, this can be before the scripts engine finishes its
1276 * processing. Therefore, part of the selection processing has to be
1277 * to find out what the scripts engine is doing and complete the
1278 * function if necessary (i.e. process the pending disconnect or save
1279 * the interrupted initial selection */
1280STATIC inline __u32
1281process_selection(struct Scsi_Host *host, __u32 dsp)
1282{
1283 __u8 id = 0; /* Squash compiler warning */
1284 int count = 0;
1285 __u32 resume_offset = 0;
1286 struct NCR_700_Host_Parameters *hostdata =
1287 (struct NCR_700_Host_Parameters *)host->hostdata[0];
1288 struct scsi_cmnd *SCp = hostdata->cmd;
1289 __u8 sbcl;
1290
1291 for(count = 0; count < 5; count++) {
1292 id = NCR_700_readb(host, hostdata->chip710 ?
1293 CTEST9_REG : SFBR_REG);
1294
1295 /* Take out our own ID */
1296 id &= ~(1<<host->this_id);
1297 if(id != 0)
1298 break;
1299 udelay(5);
1300 }
1301 sbcl = NCR_700_readb(host, SBCL_REG);
1302 if((sbcl & SBCL_IO) == 0) {
1303 /* mark as having been selected rather than reselected */
1304 id = 0xff;
1305 } else {
1306 /* convert to real ID */
1307 hostdata->reselection_id = id = bitmap_to_number(id);
1308 DEBUG(("scsi%d: Reselected by %d\n",
1309 host->host_no, id));
1310 }
1311 if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) {
1312 struct NCR_700_command_slot *slot =
1313 (struct NCR_700_command_slot *)SCp->host_scribble;
1314 DEBUG((" ID %d WARNING: RESELECTION OF BUSY HOST, saving cmd %p, slot %p, addr %x [%04x], resume %x!\n", id, hostdata->cmd, slot, dsp, dsp - hostdata->pScript, resume_offset));
1315
1316 switch(dsp - hostdata->pScript) {
1317 case Ent_Disconnect1:
1318 case Ent_Disconnect2:
1319 save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript);
1320 break;
1321 case Ent_Disconnect3:
1322 case Ent_Disconnect4:
1323 save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript);
1324 break;
1325 case Ent_Disconnect5:
1326 case Ent_Disconnect6:
1327 save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript);
1328 break;
1329 case Ent_Disconnect7:
1330 case Ent_Disconnect8:
1331 save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript);
1332 break;
1333 case Ent_Finish1:
1334 case Ent_Finish2:
1335 process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata);
1336 break;
1337
1338 default:
1339 slot->state = NCR_700_SLOT_QUEUED;
1340 break;
1341 }
1342 }
1343 hostdata->state = NCR_700_HOST_BUSY;
1344 hostdata->cmd = NULL;
1345 /* clear any stale simple tag message */
1346 hostdata->msgin[1] = 0;
1347 dma_cache_sync(hostdata->msgin, MSG_ARRAY_SIZE,
1348 DMA_BIDIRECTIONAL);
1349
1350 if(id == 0xff) {
1351 /* Selected as target, Ignore */
1352 resume_offset = hostdata->pScript + Ent_SelectedAsTarget;
1353 } else if(hostdata->tag_negotiated & (1<<id)) {
1354 resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
1355 } else {
1356 resume_offset = hostdata->pScript + Ent_GetReselectionData;
1357 }
1358 return resume_offset;
1359}
1360
1361static inline void
1362NCR_700_clear_fifo(struct Scsi_Host *host) {
1363 const struct NCR_700_Host_Parameters *hostdata
1364 = (struct NCR_700_Host_Parameters *)host->hostdata[0];
1365 if(hostdata->chip710) {
1366 NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG);
1367 } else {
1368 NCR_700_writeb(CLR_FIFO, host, DFIFO_REG);
1369 }
1370}
1371
1372static inline void
1373NCR_700_flush_fifo(struct Scsi_Host *host) {
1374 const struct NCR_700_Host_Parameters *hostdata
1375 = (struct NCR_700_Host_Parameters *)host->hostdata[0];
1376 if(hostdata->chip710) {
1377 NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG);
1378 udelay(10);
1379 NCR_700_writeb(0, host, CTEST8_REG);
1380 } else {
1381 NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG);
1382 udelay(10);
1383 NCR_700_writeb(0, host, DFIFO_REG);
1384 }
1385}
1386
1387
1388/* The queue lock with interrupts disabled must be held on entry to
1389 * this function */
1390STATIC int
1391NCR_700_start_command(struct scsi_cmnd *SCp)
1392{
1393 struct NCR_700_command_slot *slot =
1394 (struct NCR_700_command_slot *)SCp->host_scribble;
1395 struct NCR_700_Host_Parameters *hostdata =
1396 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1397 __u16 count = 1; /* for IDENTIFY message */
1398
1399 if(hostdata->state != NCR_700_HOST_FREE) {
1400 /* keep this inside the lock to close the race window where
1401 * the running command finishes on another CPU while we don't
1402 * change the state to queued on this one */
1403 slot->state = NCR_700_SLOT_QUEUED;
1404
1405 DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n",
1406 SCp->device->host->host_no, slot->cmnd, slot));
1407 return 0;
1408 }
1409 hostdata->state = NCR_700_HOST_BUSY;
1410 hostdata->cmd = SCp;
1411 slot->state = NCR_700_SLOT_BUSY;
1412 /* keep interrupts disabled until we have the command correctly
1413 * set up so we cannot take a selection interrupt */
1414
1415 hostdata->msgout[0] = NCR_700_identify(SCp->cmnd[0] != REQUEST_SENSE,
1416 SCp->device->lun);
1417 /* for INQUIRY or REQUEST_SENSE commands, we cannot be sure
1418 * if the negotiated transfer parameters still hold, so
1419 * always renegotiate them */
1420 if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE) {
1421 NCR_700_clear_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
1422 }
1423
1424 /* REQUEST_SENSE is asking for contingent I_T_L(_Q) status.
1425 * If a contingent allegiance condition exists, the device
1426 * will refuse all tags, so send the request sense as untagged
1427 * */
1428 if((hostdata->tag_negotiated & (1<<SCp->device->id))
1429 && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE)) {
1430 count += scsi_populate_tag_msg(SCp, &hostdata->msgout[count]);
1431 }
1432
1433 if(hostdata->fast &&
1434 NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) {
1435 memcpy(&hostdata->msgout[count], NCR_700_SDTR_msg,
1436 sizeof(NCR_700_SDTR_msg));
1437 hostdata->msgout[count+3] = spi_period(SCp->device->sdev_target);
1438 hostdata->msgout[count+4] = spi_offset(SCp->device->sdev_target);
1439 count += sizeof(NCR_700_SDTR_msg);
1440 NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
1441 }
1442
1443 script_patch_16(hostdata->script, MessageCount, count);
1444
1445
1446 script_patch_ID(hostdata->script,
1447 Device_ID, 1<<SCp->device->id);
1448
1449 script_patch_32_abs(hostdata->script, CommandAddress,
1450 slot->pCmd);
1451 script_patch_16(hostdata->script, CommandCount, SCp->cmd_len);
1452 /* finally plumb the beginning of the SG list into the script
1453 * */
1454 script_patch_32_abs(hostdata->script, SGScriptStartAddress,
1455 to32bit(&slot->pSG[0].ins));
1456 NCR_700_clear_fifo(SCp->device->host);
1457
1458 if(slot->resume_offset == 0)
1459 slot->resume_offset = hostdata->pScript;
1460 /* now perform all the writebacks and invalidates */
1461 dma_cache_sync(hostdata->msgout, count, DMA_TO_DEVICE);
1462 dma_cache_sync(hostdata->msgin, MSG_ARRAY_SIZE,
1463 DMA_FROM_DEVICE);
1464 dma_cache_sync(SCp->cmnd, SCp->cmd_len, DMA_TO_DEVICE);
1465 dma_cache_sync(hostdata->status, 1, DMA_FROM_DEVICE);
1466
1467 /* set the synchronous period/offset */
1468 NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
1469 SCp->device->host, SXFER_REG);
1470 NCR_700_writel(slot->temp, SCp->device->host, TEMP_REG);
1471 NCR_700_writel(slot->resume_offset, SCp->device->host, DSP_REG);
1472
1473 return 1;
1474}
1475
1476irqreturn_t
1477NCR_700_intr(int irq, void *dev_id, struct pt_regs *regs)
1478{
1479 struct Scsi_Host *host = (struct Scsi_Host *)dev_id;
1480 struct NCR_700_Host_Parameters *hostdata =
1481 (struct NCR_700_Host_Parameters *)host->hostdata[0];
1482 __u8 istat;
1483 __u32 resume_offset = 0;
1484 __u8 pun = 0xff, lun = 0xff;
1485 unsigned long flags;
1486 int handled = 0;
1487
1488 /* Use the host lock to serialise acess to the 53c700
1489 * hardware. Note: In future, we may need to take the queue
1490 * lock to enter the done routines. When that happens, we
1491 * need to ensure that for this driver, the host lock and the
1492 * queue lock point to the same thing. */
1493 spin_lock_irqsave(host->host_lock, flags);
1494 if((istat = NCR_700_readb(host, ISTAT_REG))
1495 & (SCSI_INT_PENDING | DMA_INT_PENDING)) {
1496 __u32 dsps;
1497 __u8 sstat0 = 0, dstat = 0;
1498 __u32 dsp;
1499 struct scsi_cmnd *SCp = hostdata->cmd;
1500 enum NCR_700_Host_State state;
1501
1502 handled = 1;
1503 state = hostdata->state;
1504 SCp = hostdata->cmd;
1505
1506 if(istat & SCSI_INT_PENDING) {
1507 udelay(10);
1508
1509 sstat0 = NCR_700_readb(host, SSTAT0_REG);
1510 }
1511
1512 if(istat & DMA_INT_PENDING) {
1513 udelay(10);
1514
1515 dstat = NCR_700_readb(host, DSTAT_REG);
1516 }
1517
1518 dsps = NCR_700_readl(host, DSPS_REG);
1519 dsp = NCR_700_readl(host, DSP_REG);
1520
1521 DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%x\n",
1522 host->host_no, istat, sstat0, dstat,
1523 (dsp - (__u32)(hostdata->pScript))/4,
1524 dsp, dsps));
1525
1526 if(SCp != NULL) {
1527 pun = SCp->device->id;
1528 lun = SCp->device->lun;
1529 }
1530
1531 if(sstat0 & SCSI_RESET_DETECTED) {
1532 struct scsi_device *SDp;
1533 int i;
1534
1535 hostdata->state = NCR_700_HOST_BUSY;
1536
1537 printk(KERN_ERR "scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]\n",
1538 host->host_no, SCp, SCp == NULL ? NULL : SCp->host_scribble, dsp, dsp - hostdata->pScript);
1539
1540 scsi_report_bus_reset(host, 0);
1541
1542 /* clear all the negotiated parameters */
1543 __shost_for_each_device(SDp, host)
1544 SDp->hostdata = NULL;
1545
1546 /* clear all the slots and their pending commands */
1547 for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1548 struct scsi_cmnd *SCp;
1549 struct NCR_700_command_slot *slot =
1550 &hostdata->slots[i];
1551
1552 if(slot->state == NCR_700_SLOT_FREE)
1553 continue;
1554
1555 SCp = slot->cmnd;
1556 printk(KERN_ERR " failing command because of reset, slot %p, cmnd %p\n",
1557 slot, SCp);
1558 free_slot(slot, hostdata);
1559 SCp->host_scribble = NULL;
1560 NCR_700_set_depth(SCp->device, 0);
1561 /* NOTE: deadlock potential here: we
1562 * rely on mid-layer guarantees that
1563 * scsi_done won't try to issue the
1564 * command again otherwise we'll
1565 * deadlock on the
1566 * hostdata->state_lock */
1567 SCp->result = DID_RESET << 16;
1568 SCp->scsi_done(SCp);
1569 }
1570 mdelay(25);
1571 NCR_700_chip_setup(host);
1572
1573 hostdata->state = NCR_700_HOST_FREE;
1574 hostdata->cmd = NULL;
1575 /* signal back if this was an eh induced reset */
1576 if(hostdata->eh_complete != NULL)
1577 complete(hostdata->eh_complete);
1578 goto out_unlock;
1579 } else if(sstat0 & SELECTION_TIMEOUT) {
1580 DEBUG(("scsi%d: (%d:%d) selection timeout\n",
1581 host->host_no, pun, lun));
1582 NCR_700_scsi_done(hostdata, SCp, DID_NO_CONNECT<<16);
1583 } else if(sstat0 & PHASE_MISMATCH) {
1584 struct NCR_700_command_slot *slot = (SCp == NULL) ? NULL :
1585 (struct NCR_700_command_slot *)SCp->host_scribble;
1586
1587 if(dsp == Ent_SendMessage + 8 + hostdata->pScript) {
1588 /* It wants to reply to some part of
1589 * our message */
1590#ifdef NCR_700_DEBUG
1591 __u32 temp = NCR_700_readl(host, TEMP_REG);
1592 int count = (hostdata->script[Ent_SendMessage/4] & 0xffffff) - ((NCR_700_readl(host, DBC_REG) & 0xffffff) + NCR_700_data_residual(host));
1593 printk("scsi%d (%d:%d) PHASE MISMATCH IN SEND MESSAGE %d remain, return %p[%04x], phase %s\n", host->host_no, pun, lun, count, (void *)temp, temp - hostdata->pScript, sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
1594#endif
1595 resume_offset = hostdata->pScript + Ent_SendMessagePhaseMismatch;
1596 } else if(dsp >= to32bit(&slot->pSG[0].ins) &&
1597 dsp <= to32bit(&slot->pSG[NCR_700_SG_SEGMENTS].ins)) {
1598 int data_transfer = NCR_700_readl(host, DBC_REG) & 0xffffff;
1599 int SGcount = (dsp - to32bit(&slot->pSG[0].ins))/sizeof(struct NCR_700_SG_List);
1600 int residual = NCR_700_data_residual(host);
1601 int i;
1602#ifdef NCR_700_DEBUG
1603 __u32 naddr = NCR_700_readl(host, DNAD_REG);
1604
1605 printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x\n",
1606 host->host_no, pun, lun,
1607 SGcount, data_transfer);
1608 scsi_print_command(SCp);
1609 if(residual) {
1610 printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %d\n",
1611 host->host_no, pun, lun,
1612 SGcount, data_transfer, residual);
1613 }
1614#endif
1615 data_transfer += residual;
1616
1617 if(data_transfer != 0) {
1618 int count;
1619 __u32 pAddr;
1620
1621 SGcount--;
1622
1623 count = (bS_to_cpu(slot->SG[SGcount].ins) & 0x00ffffff);
1624 DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %d\n", count, count-data_transfer));
1625 slot->SG[SGcount].ins &= bS_to_host(0xff000000);
1626 slot->SG[SGcount].ins |= bS_to_host(data_transfer);
1627 pAddr = bS_to_cpu(slot->SG[SGcount].pAddr);
1628 pAddr += (count - data_transfer);
1629#ifdef NCR_700_DEBUG
1630 if(pAddr != naddr) {
1631 printk("scsi%d (%d:%d) transfer mismatch pAddr=%lx, naddr=%lx, data_transfer=%d, residual=%d\n", host->host_no, pun, lun, (unsigned long)pAddr, (unsigned long)naddr, data_transfer, residual);
1632 }
1633#endif
1634 slot->SG[SGcount].pAddr = bS_to_host(pAddr);
1635 }
1636 /* set the executed moves to nops */
1637 for(i=0; i<SGcount; i++) {
1638 slot->SG[i].ins = bS_to_host(SCRIPT_NOP);
1639 slot->SG[i].pAddr = 0;
1640 }
1641 dma_cache_sync(slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
1642 /* and pretend we disconnected after
1643 * the command phase */
1644 resume_offset = hostdata->pScript + Ent_MsgInDuringData;
1645 /* make sure all the data is flushed */
1646 NCR_700_flush_fifo(host);
1647 } else {
1648 __u8 sbcl = NCR_700_readb(host, SBCL_REG);
1649 printk(KERN_ERR "scsi%d: (%d:%d) phase mismatch at %04x, phase %s\n",
1650 host->host_no, pun, lun, dsp - hostdata->pScript, sbcl_to_string(sbcl));
1651 NCR_700_internal_bus_reset(host);
1652 }
1653
1654 } else if(sstat0 & SCSI_GROSS_ERROR) {
1655 printk(KERN_ERR "scsi%d: (%d:%d) GROSS ERROR\n",
1656 host->host_no, pun, lun);
1657 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1658 } else if(sstat0 & PARITY_ERROR) {
1659 printk(KERN_ERR "scsi%d: (%d:%d) PARITY ERROR\n",
1660 host->host_no, pun, lun);
1661 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1662 } else if(dstat & SCRIPT_INT_RECEIVED) {
1663 DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====\n",
1664 host->host_no, pun, lun));
1665 resume_offset = process_script_interrupt(dsps, dsp, SCp, host, hostdata);
1666 } else if(dstat & (ILGL_INST_DETECTED)) {
1667 printk(KERN_ERR "scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!\n"
1668 " Please email James.Bottomley@HansenPartnership.com with the details\n",
1669 host->host_no, pun, lun,
1670 dsp, dsp - hostdata->pScript);
1671 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1672 } else if(dstat & (WATCH_DOG_INTERRUPT|ABORTED)) {
1673 printk(KERN_ERR "scsi%d: (%d:%d) serious DMA problem, dstat=%02x\n",
1674 host->host_no, pun, lun, dstat);
1675 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1676 }
1677
1678
1679 /* NOTE: selection interrupt processing MUST occur
1680 * after script interrupt processing to correctly cope
1681 * with the case where we process a disconnect and
1682 * then get reselected before we process the
1683 * disconnection */
1684 if(sstat0 & SELECTED) {
1685 /* FIXME: It currently takes at least FOUR
1686 * interrupts to complete a command that
1687 * disconnects: one for the disconnect, one
1688 * for the reselection, one to get the
1689 * reselection data and one to complete the
1690 * command. If we guess the reselected
1691 * command here and prepare it, we only need
1692 * to get a reselection data interrupt if we
1693 * guessed wrongly. Since the interrupt
1694 * overhead is much greater than the command
1695 * setup, this would be an efficient
1696 * optimisation particularly as we probably
1697 * only have one outstanding command on a
1698 * target most of the time */
1699
1700 resume_offset = process_selection(host, dsp);
1701
1702 }
1703
1704 }
1705
1706 if(resume_offset) {
1707 if(hostdata->state != NCR_700_HOST_BUSY) {
1708 printk(KERN_ERR "scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!\n",
1709 host->host_no, resume_offset, resume_offset - hostdata->pScript);
1710 hostdata->state = NCR_700_HOST_BUSY;
1711 }
1712
1713 DEBUG(("Attempting to resume at %x\n", resume_offset));
1714 NCR_700_clear_fifo(host);
1715 NCR_700_writel(resume_offset, host, DSP_REG);
1716 }
1717 /* There is probably a technical no-no about this: If we're a
1718 * shared interrupt and we got this interrupt because the
1719 * other device needs servicing not us, we're still going to
1720 * check our queued commands here---of course, there shouldn't
1721 * be any outstanding.... */
1722 if(hostdata->state == NCR_700_HOST_FREE) {
1723 int i;
1724
1725 for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1726 /* fairness: always run the queue from the last
1727 * position we left off */
1728 int j = (i + hostdata->saved_slot_position)
1729 % NCR_700_COMMAND_SLOTS_PER_HOST;
1730
1731 if(hostdata->slots[j].state != NCR_700_SLOT_QUEUED)
1732 continue;
1733 if(NCR_700_start_command(hostdata->slots[j].cmnd)) {
1734 DEBUG(("scsi%d: Issuing saved command slot %p, cmd %p\t\n",
1735 host->host_no, &hostdata->slots[j],
1736 hostdata->slots[j].cmnd));
1737 hostdata->saved_slot_position = j + 1;
1738 }
1739
1740 break;
1741 }
1742 }
1743 out_unlock:
1744 spin_unlock_irqrestore(host->host_lock, flags);
1745 return IRQ_RETVAL(handled);
1746}
1747
1748STATIC int
1749NCR_700_queuecommand(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *))
1750{
1751 struct NCR_700_Host_Parameters *hostdata =
1752 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1753 __u32 move_ins;
1754 enum dma_data_direction direction;
1755 struct NCR_700_command_slot *slot;
1756
1757 if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) {
1758 /* We're over our allocation, this should never happen
1759 * since we report the max allocation to the mid layer */
1760 printk(KERN_WARNING "scsi%d: Command depth has gone over queue depth\n", SCp->device->host->host_no);
1761 return 1;
1762 }
1763 /* check for untagged commands. We cannot have any outstanding
1764 * commands if we accept them. Commands could be untagged because:
1765 *
1766 * - The tag negotiated bitmap is clear
1767 * - The blk layer sent and untagged command
1768 */
1769 if(NCR_700_get_depth(SCp->device) != 0
1770 && (!(hostdata->tag_negotiated & (1<<SCp->device->id))
1771 || !blk_rq_tagged(SCp->request))) {
1772 DEBUG((KERN_ERR "scsi%d (%d:%d) has non zero depth %d\n",
1773 SCp->device->host->host_no, SCp->device->id, SCp->device->lun,
1774 NCR_700_get_depth(SCp->device)));
1775 return SCSI_MLQUEUE_DEVICE_BUSY;
1776 }
1777 if(NCR_700_get_depth(SCp->device) >= SCp->device->queue_depth) {
1778 DEBUG((KERN_ERR "scsi%d (%d:%d) has max tag depth %d\n",
1779 SCp->device->host->host_no, SCp->device->id, SCp->device->lun,
1780 NCR_700_get_depth(SCp->device)));
1781 return SCSI_MLQUEUE_DEVICE_BUSY;
1782 }
1783 NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1);
1784
1785 /* begin the command here */
1786 /* no need to check for NULL, test for command_slot_count above
1787 * ensures a slot is free */
1788 slot = find_empty_slot(hostdata);
1789
1790 slot->cmnd = SCp;
1791
1792 SCp->scsi_done = done;
1793 SCp->host_scribble = (unsigned char *)slot;
1794 SCp->SCp.ptr = NULL;
1795 SCp->SCp.buffer = NULL;
1796
1797#ifdef NCR_700_DEBUG
1798 printk("53c700: scsi%d, command ", SCp->device->host->host_no);
1799 scsi_print_command(SCp);
1800#endif
1801 if(blk_rq_tagged(SCp->request)
1802 && (hostdata->tag_negotiated &(1<<SCp->device->id)) == 0
1803 && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) {
1804 printk(KERN_ERR "scsi%d: (%d:%d) Enabling Tag Command Queuing\n", SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
1805 hostdata->tag_negotiated |= (1<<SCp->device->id);
1806 NCR_700_set_tag_neg_state(SCp->device, NCR_700_DURING_TAG_NEGOTIATION);
1807 }
1808
1809 /* here we may have to process an untagged command. The gate
1810 * above ensures that this will be the only one outstanding,
1811 * so clear the tag negotiated bit.
1812 *
1813 * FIXME: This will royally screw up on multiple LUN devices
1814 * */
1815 if(!blk_rq_tagged(SCp->request)
1816 && (hostdata->tag_negotiated &(1<<SCp->device->id))) {
1817 printk(KERN_INFO "scsi%d: (%d:%d) Disabling Tag Command Queuing\n", SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
1818 hostdata->tag_negotiated &= ~(1<<SCp->device->id);
1819 }
1820
1821 if((hostdata->tag_negotiated &(1<<SCp->device->id))
1822 && scsi_get_tag_type(SCp->device)) {
1823 slot->tag = SCp->request->tag;
1824 DEBUG(("53c700 %d:%d:%d, sending out tag %d, slot %p\n",
1825 SCp->device->host->host_no, SCp->device->id, SCp->device->lun, slot->tag,
1826 slot));
1827 } else {
1828 slot->tag = SCSI_NO_TAG;
1829 /* must populate current_cmnd for scsi_find_tag to work */
1830 SCp->device->current_cmnd = SCp;
1831 }
1832 /* sanity check: some of the commands generated by the mid-layer
1833 * have an eccentric idea of their sc_data_direction */
1834 if(!SCp->use_sg && !SCp->request_bufflen
1835 && SCp->sc_data_direction != DMA_NONE) {
1836#ifdef NCR_700_DEBUG
1837 printk("53c700: Command");
1838 scsi_print_command(SCp);
1839 printk("Has wrong data direction %d\n", SCp->sc_data_direction);
1840#endif
1841 SCp->sc_data_direction = DMA_NONE;
1842 }
1843
1844 switch (SCp->cmnd[0]) {
1845 case REQUEST_SENSE:
1846 /* clear the internal sense magic */
1847 SCp->cmnd[6] = 0;
1848 /* fall through */
1849 default:
1850 /* OK, get it from the command */
1851 switch(SCp->sc_data_direction) {
1852 case DMA_BIDIRECTIONAL:
1853 default:
1854 printk(KERN_ERR "53c700: Unknown command for data direction ");
1855 scsi_print_command(SCp);
1856
1857 move_ins = 0;
1858 break;
1859 case DMA_NONE:
1860 move_ins = 0;
1861 break;
1862 case DMA_FROM_DEVICE:
1863 move_ins = SCRIPT_MOVE_DATA_IN;
1864 break;
1865 case DMA_TO_DEVICE:
1866 move_ins = SCRIPT_MOVE_DATA_OUT;
1867 break;
1868 }
1869 }
1870
1871 /* now build the scatter gather list */
1872 direction = SCp->sc_data_direction;
1873 if(move_ins != 0) {
1874 int i;
1875 int sg_count;
1876 dma_addr_t vPtr = 0;
1877 __u32 count = 0;
1878
1879 if(SCp->use_sg) {
1880 sg_count = dma_map_sg(hostdata->dev, SCp->buffer,
1881 SCp->use_sg, direction);
1882 } else {
1883 vPtr = dma_map_single(hostdata->dev,
1884 SCp->request_buffer,
1885 SCp->request_bufflen,
1886 direction);
1887 count = SCp->request_bufflen;
1888 slot->dma_handle = vPtr;
1889 sg_count = 1;
1890 }
1891
1892
1893 for(i = 0; i < sg_count; i++) {
1894
1895 if(SCp->use_sg) {
1896 struct scatterlist *sg = SCp->buffer;
1897
1898 vPtr = sg_dma_address(&sg[i]);
1899 count = sg_dma_len(&sg[i]);
1900 }
1901
1902 slot->SG[i].ins = bS_to_host(move_ins | count);
1903 DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n",
1904 i, count, slot->SG[i].ins, (unsigned long)vPtr));
1905 slot->SG[i].pAddr = bS_to_host(vPtr);
1906 }
1907 slot->SG[i].ins = bS_to_host(SCRIPT_RETURN);
1908 slot->SG[i].pAddr = 0;
1909 dma_cache_sync(slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
1910 DEBUG((" SETTING %08lx to %x\n",
1911 (&slot->pSG[i].ins),
1912 slot->SG[i].ins));
1913 }
1914 slot->resume_offset = 0;
1915 slot->pCmd = dma_map_single(hostdata->dev, SCp->cmnd,
1916 sizeof(SCp->cmnd), DMA_TO_DEVICE);
1917 NCR_700_start_command(SCp);
1918 return 0;
1919}
1920
1921STATIC int
1922NCR_700_abort(struct scsi_cmnd * SCp)
1923{
1924 struct NCR_700_command_slot *slot;
1925
1926 printk(KERN_INFO "scsi%d (%d:%d) New error handler wants to abort command\n\t",
1927 SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
1928 scsi_print_command(SCp);
1929
1930 slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1931
1932 if(slot == NULL)
1933 /* no outstanding command to abort */
1934 return SUCCESS;
1935 if(SCp->cmnd[0] == TEST_UNIT_READY) {
1936 /* FIXME: This is because of a problem in the new
1937 * error handler. When it is in error recovery, it
1938 * will send a TUR to a device it thinks may still be
1939 * showing a problem. If the TUR isn't responded to,
1940 * it will abort it and mark the device off line.
1941 * Unfortunately, it does no other error recovery, so
1942 * this would leave us with an outstanding command
1943 * occupying a slot. Rather than allow this to
1944 * happen, we issue a bus reset to force all
1945 * outstanding commands to terminate here. */
1946 NCR_700_internal_bus_reset(SCp->device->host);
1947 /* still drop through and return failed */
1948 }
1949 return FAILED;
1950
1951}
1952
1953STATIC int
1954NCR_700_bus_reset(struct scsi_cmnd * SCp)
1955{
1956 DECLARE_COMPLETION(complete);
1957 struct NCR_700_Host_Parameters *hostdata =
1958 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1959
1960 printk(KERN_INFO "scsi%d (%d:%d) New error handler wants BUS reset, cmd %p\n\t",
1961 SCp->device->host->host_no, SCp->device->id, SCp->device->lun, SCp);
1962 scsi_print_command(SCp);
1963 /* In theory, eh_complete should always be null because the
1964 * eh is single threaded, but just in case we're handling a
1965 * reset via sg or something */
1966 while(hostdata->eh_complete != NULL) {
1967 spin_unlock_irq(SCp->device->host->host_lock);
1968 msleep_interruptible(100);
1969 spin_lock_irq(SCp->device->host->host_lock);
1970 }
1971 hostdata->eh_complete = &complete;
1972 NCR_700_internal_bus_reset(SCp->device->host);
1973 spin_unlock_irq(SCp->device->host->host_lock);
1974 wait_for_completion(&complete);
1975 spin_lock_irq(SCp->device->host->host_lock);
1976 hostdata->eh_complete = NULL;
1977 /* Revalidate the transport parameters of the failing device */
1978 if(hostdata->fast)
1979 spi_schedule_dv_device(SCp->device);
1980 return SUCCESS;
1981}
1982
1983STATIC int
1984NCR_700_dev_reset(struct scsi_cmnd * SCp)
1985{
1986 printk(KERN_INFO "scsi%d (%d:%d) New error handler wants device reset\n\t",
1987 SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
1988 scsi_print_command(SCp);
1989
1990 return FAILED;
1991}
1992
1993STATIC int
1994NCR_700_host_reset(struct scsi_cmnd * SCp)
1995{
1996 printk(KERN_INFO "scsi%d (%d:%d) New error handler wants HOST reset\n\t",
1997 SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
1998 scsi_print_command(SCp);
1999
2000 NCR_700_internal_bus_reset(SCp->device->host);
2001 NCR_700_chip_reset(SCp->device->host);
2002 return SUCCESS;
2003}
2004
2005STATIC void
2006NCR_700_set_period(struct scsi_target *STp, int period)
2007{
2008 struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
2009 struct NCR_700_Host_Parameters *hostdata =
2010 (struct NCR_700_Host_Parameters *)SHp->hostdata[0];
2011
2012 if(!hostdata->fast)
2013 return;
2014
2015 if(period < hostdata->min_period)
2016 period = hostdata->min_period;
2017
2018 spi_period(STp) = period;
2019 spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
2020 NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
2021 spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
2022}
2023
2024STATIC void
2025NCR_700_set_offset(struct scsi_target *STp, int offset)
2026{
2027 struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
2028 struct NCR_700_Host_Parameters *hostdata =
2029 (struct NCR_700_Host_Parameters *)SHp->hostdata[0];
2030 int max_offset = hostdata->chip710
2031 ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET;
2032
2033 if(!hostdata->fast)
2034 return;
2035
2036 if(offset > max_offset)
2037 offset = max_offset;
2038
2039 /* if we're currently async, make sure the period is reasonable */
2040 if(spi_offset(STp) == 0 && (spi_period(STp) < hostdata->min_period ||
2041 spi_period(STp) > 0xff))
2042 spi_period(STp) = hostdata->min_period;
2043
2044 spi_offset(STp) = offset;
2045 spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
2046 NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
2047 spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
2048}
2049
2050
2051
2052STATIC int
2053NCR_700_slave_configure(struct scsi_device *SDp)
2054{
2055 struct NCR_700_Host_Parameters *hostdata =
2056 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2057
2058 /* to do here: allocate memory; build a queue_full list */
2059 if(SDp->tagged_supported) {
2060 scsi_set_tag_type(SDp, MSG_ORDERED_TAG);
2061 scsi_activate_tcq(SDp, NCR_700_DEFAULT_TAGS);
2062 NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
2063 } else {
2064 /* initialise to default depth */
2065 scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
2066 }
2067 if(hostdata->fast) {
2068 /* Find the correct offset and period via domain validation */
2069 if (!spi_initial_dv(SDp->sdev_target))
2070 spi_dv_device(SDp);
2071 } else {
2072 spi_offset(SDp->sdev_target) = 0;
2073 spi_period(SDp->sdev_target) = 0;
2074 }
2075 return 0;
2076}
2077
2078STATIC void
2079NCR_700_slave_destroy(struct scsi_device *SDp)
2080{
2081 /* to do here: deallocate memory */
2082}
2083
2084static int
2085NCR_700_change_queue_depth(struct scsi_device *SDp, int depth)
2086{
2087 if (depth > NCR_700_MAX_TAGS)
2088 depth = NCR_700_MAX_TAGS;
2089
2090 scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth);
2091 return depth;
2092}
2093
2094static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
2095{
2096 int change_tag = ((tag_type ==0 && scsi_get_tag_type(SDp) != 0)
2097 || (tag_type != 0 && scsi_get_tag_type(SDp) == 0));
2098 struct NCR_700_Host_Parameters *hostdata =
2099 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2100
2101 scsi_set_tag_type(SDp, tag_type);
2102
2103 /* We have a global (per target) flag to track whether TCQ is
2104 * enabled, so we'll be turning it off for the entire target here.
2105 * our tag algorithm will fail if we mix tagged and untagged commands,
2106 * so quiesce the device before doing this */
2107 if (change_tag)
2108 scsi_target_quiesce(SDp->sdev_target);
2109
2110 if (!tag_type) {
2111 /* shift back to the default unqueued number of commands
2112 * (the user can still raise this) */
2113 scsi_deactivate_tcq(SDp, SDp->host->cmd_per_lun);
2114 hostdata->tag_negotiated &= ~(1 << SDp->id);
2115 } else {
2116 /* Here, we cleared the negotiation flag above, so this
2117 * will force the driver to renegotiate */
2118 scsi_activate_tcq(SDp, SDp->queue_depth);
2119 if (change_tag)
2120 NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
2121 }
2122 if (change_tag)
2123 scsi_target_resume(SDp->sdev_target);
2124
2125 return tag_type;
2126}
2127
2128static ssize_t
2129NCR_700_show_active_tags(struct device *dev, char *buf)
2130{
2131 struct scsi_device *SDp = to_scsi_device(dev);
2132
2133 return snprintf(buf, 20, "%d\n", NCR_700_get_depth(SDp));
2134}
2135
2136static struct device_attribute NCR_700_active_tags_attr = {
2137 .attr = {
2138 .name = "active_tags",
2139 .mode = S_IRUGO,
2140 },
2141 .show = NCR_700_show_active_tags,
2142};
2143
2144STATIC struct device_attribute *NCR_700_dev_attrs[] = {
2145 &NCR_700_active_tags_attr,
2146 NULL,
2147};
2148
2149EXPORT_SYMBOL(NCR_700_detect);
2150EXPORT_SYMBOL(NCR_700_release);
2151EXPORT_SYMBOL(NCR_700_intr);
2152
2153static struct spi_function_template NCR_700_transport_functions = {
2154 .set_period = NCR_700_set_period,
2155 .show_period = 1,
2156 .set_offset = NCR_700_set_offset,
2157 .show_offset = 1,
2158};
2159
2160static int __init NCR_700_init(void)
2161{
2162 NCR_700_transport_template = spi_attach_transport(&NCR_700_transport_functions);
2163 if(!NCR_700_transport_template)
2164 return -ENODEV;
2165 return 0;
2166}
2167
2168static void __exit NCR_700_exit(void)
2169{
2170 spi_release_transport(NCR_700_transport_template);
2171}
2172
2173module_init(NCR_700_init);
2174module_exit(NCR_700_exit);
2175
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-02 10:38:31 -0400