1 /* -*- mode: c; c-basic-offset: 8 -*- */
3 /* NCR (or Symbios) 53c700 and 53c700-66 Driver
5 * Copyright (C) 2001 by James.Bottomley@HansenPartnership.com
6 **-----------------------------------------------------------------------------
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.
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.
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.
22 **-----------------------------------------------------------------------------
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).
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.
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).
46 * 1. Better statistics in the proc fs
48 * 2. Implement message queue (queues SCSI messages like commands) and make
49 * the abort and device reset functions use them.
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).
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).
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.
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.
86 * Added support for the 53c710 chip (in 53c700 emulation mode only---no
87 * special 53c710 instructions or registers are used).
91 * More endianness/cache coherency changes.
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)
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.
101 * Thanks also go to Linuxcare Inc. for providing several PARISC
102 * machines for me to debug the driver on.
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.
112 * Initial modularisation from the D700. See NCR_D700.c for the rest of
115 #define NCR_700_VERSION "2.8"
117 #include <linux/kernel.h>
118 #include <linux/types.h>
119 #include <linux/string.h>
120 #include <linux/slab.h>
121 #include <linux/ioport.h>
122 #include <linux/delay.h>
123 #include <linux/spinlock.h>
124 #include <linux/completion.h>
125 #include <linux/init.h>
126 #include <linux/proc_fs.h>
127 #include <linux/blkdev.h>
128 #include <linux/module.h>
129 #include <linux/interrupt.h>
130 #include <linux/device.h>
133 #include <asm/pgtable.h>
134 #include <asm/byteorder.h>
136 #include <scsi/scsi.h>
137 #include <scsi/scsi_cmnd.h>
138 #include <scsi/scsi_dbg.h>
139 #include <scsi/scsi_eh.h>
140 #include <scsi/scsi_host.h>
141 #include <scsi/scsi_tcq.h>
142 #include <scsi/scsi_transport.h>
143 #include <scsi/scsi_transport_spi.h>
147 /* NOTE: For 64 bit drivers there are points in the code where we use
148 * a non dereferenceable pointer to point to a structure in dma-able
149 * memory (which is 32 bits) so that we can use all of the structure
150 * operations but take the address at the end. This macro allows us
151 * to truncate the 64 bit pointer down to 32 bits without the compiler
153 #define to32bit(x) ((__u32)((unsigned long)(x)))
158 #define STATIC static
161 MODULE_AUTHOR("James Bottomley");
162 MODULE_DESCRIPTION("53c700 and 53c700-66 Driver");
163 MODULE_LICENSE("GPL");
165 /* This is the script */
166 #include "53c700_d.h"
169 STATIC
int NCR_700_queuecommand(struct Scsi_Host
*h
, struct scsi_cmnd
*);
170 STATIC
int NCR_700_abort(struct scsi_cmnd
* SCpnt
);
171 STATIC
int NCR_700_bus_reset(struct scsi_cmnd
* SCpnt
);
172 STATIC
int NCR_700_host_reset(struct scsi_cmnd
* SCpnt
);
173 STATIC
void NCR_700_chip_setup(struct Scsi_Host
*host
);
174 STATIC
void NCR_700_chip_reset(struct Scsi_Host
*host
);
175 STATIC
int NCR_700_slave_alloc(struct scsi_device
*SDpnt
);
176 STATIC
int NCR_700_slave_configure(struct scsi_device
*SDpnt
);
177 STATIC
void NCR_700_slave_destroy(struct scsi_device
*SDpnt
);
178 static int NCR_700_change_queue_depth(struct scsi_device
*SDpnt
, int depth
, int reason
);
179 static int NCR_700_change_queue_type(struct scsi_device
*SDpnt
, int depth
);
181 STATIC
struct device_attribute
*NCR_700_dev_attrs
[];
183 STATIC
struct scsi_transport_template
*NCR_700_transport_template
= NULL
;
185 static char *NCR_700_phase
[] = {
188 "before command phase",
189 "after command phase",
190 "after status phase",
191 "after data in phase",
192 "after data out phase",
196 static char *NCR_700_condition
[] = {
204 "REJECT_MSG RECEIVED",
205 "DISCONNECT_MSG RECEIVED",
211 static char *NCR_700_fatal_messages
[] = {
212 "unexpected message after reselection",
213 "still MSG_OUT after message injection",
214 "not MSG_IN after selection",
215 "Illegal message length received",
218 static char *NCR_700_SBCL_bits
[] = {
229 static char *NCR_700_SBCL_to_phase
[] = {
240 /* This translates the SDTR message offset and period to a value
241 * which can be loaded into the SXFER_REG.
243 * NOTE: According to SCSI-2, the true transfer period (in ns) is
244 * actually four times this period value */
246 NCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters
*hostdata
,
247 __u8 offset
, __u8 period
)
251 __u8 min_xferp
= (hostdata
->chip710
252 ? NCR_710_MIN_XFERP
: NCR_700_MIN_XFERP
);
253 __u8 max_offset
= (hostdata
->chip710
254 ? NCR_710_MAX_OFFSET
: NCR_700_MAX_OFFSET
);
259 if(period
< hostdata
->min_period
) {
260 printk(KERN_WARNING
"53c700: Period %dns is less than this chip's minimum, setting to %d\n", period
*4, NCR_700_MIN_PERIOD
*4);
261 period
= hostdata
->min_period
;
263 XFERP
= (period
*4 * hostdata
->sync_clock
)/1000 - 4;
264 if(offset
> max_offset
) {
265 printk(KERN_WARNING
"53c700: Offset %d exceeds chip maximum, setting to %d\n",
269 if(XFERP
< min_xferp
) {
272 return (offset
& 0x0f) | (XFERP
& 0x07)<<4;
276 NCR_700_get_SXFER(struct scsi_device
*SDp
)
278 struct NCR_700_Host_Parameters
*hostdata
=
279 (struct NCR_700_Host_Parameters
*)SDp
->host
->hostdata
[0];
281 return NCR_700_offset_period_to_sxfer(hostdata
,
282 spi_offset(SDp
->sdev_target
),
283 spi_period(SDp
->sdev_target
));
287 NCR_700_detect(struct scsi_host_template
*tpnt
,
288 struct NCR_700_Host_Parameters
*hostdata
, struct device
*dev
)
290 dma_addr_t pScript
, pSlots
;
293 struct Scsi_Host
*host
;
294 static int banner
= 0;
297 if(tpnt
->sdev_attrs
== NULL
)
298 tpnt
->sdev_attrs
= NCR_700_dev_attrs
;
300 memory
= dma_alloc_noncoherent(hostdata
->dev
, TOTAL_MEM_SIZE
,
301 &pScript
, GFP_KERNEL
);
303 printk(KERN_ERR
"53c700: Failed to allocate memory for driver, detatching\n");
307 script
= (__u32
*)memory
;
308 hostdata
->msgin
= memory
+ MSGIN_OFFSET
;
309 hostdata
->msgout
= memory
+ MSGOUT_OFFSET
;
310 hostdata
->status
= memory
+ STATUS_OFFSET
;
311 hostdata
->slots
= (struct NCR_700_command_slot
*)(memory
+ SLOTS_OFFSET
);
314 pSlots
= pScript
+ SLOTS_OFFSET
;
316 /* Fill in the missing routines from the host template */
317 tpnt
->queuecommand
= NCR_700_queuecommand
;
318 tpnt
->eh_abort_handler
= NCR_700_abort
;
319 tpnt
->eh_bus_reset_handler
= NCR_700_bus_reset
;
320 tpnt
->eh_host_reset_handler
= NCR_700_host_reset
;
321 tpnt
->can_queue
= NCR_700_COMMAND_SLOTS_PER_HOST
;
322 tpnt
->sg_tablesize
= NCR_700_SG_SEGMENTS
;
323 tpnt
->cmd_per_lun
= NCR_700_CMD_PER_LUN
;
324 tpnt
->use_clustering
= ENABLE_CLUSTERING
;
325 tpnt
->slave_configure
= NCR_700_slave_configure
;
326 tpnt
->slave_destroy
= NCR_700_slave_destroy
;
327 tpnt
->slave_alloc
= NCR_700_slave_alloc
;
328 tpnt
->change_queue_depth
= NCR_700_change_queue_depth
;
329 tpnt
->change_queue_type
= NCR_700_change_queue_type
;
331 if(tpnt
->name
== NULL
)
332 tpnt
->name
= "53c700";
333 if(tpnt
->proc_name
== NULL
)
334 tpnt
->proc_name
= "53c700";
336 host
= scsi_host_alloc(tpnt
, 4);
339 memset(hostdata
->slots
, 0, sizeof(struct NCR_700_command_slot
)
340 * NCR_700_COMMAND_SLOTS_PER_HOST
);
341 for (j
= 0; j
< NCR_700_COMMAND_SLOTS_PER_HOST
; j
++) {
342 dma_addr_t offset
= (dma_addr_t
)((unsigned long)&hostdata
->slots
[j
].SG
[0]
343 - (unsigned long)&hostdata
->slots
[0].SG
[0]);
344 hostdata
->slots
[j
].pSG
= (struct NCR_700_SG_List
*)((unsigned long)(pSlots
+ offset
));
346 hostdata
->free_list
= &hostdata
->slots
[j
];
348 hostdata
->slots
[j
-1].ITL_forw
= &hostdata
->slots
[j
];
349 hostdata
->slots
[j
].state
= NCR_700_SLOT_FREE
;
352 for (j
= 0; j
< ARRAY_SIZE(SCRIPT
); j
++)
353 script
[j
] = bS_to_host(SCRIPT
[j
]);
355 /* adjust all labels to be bus physical */
356 for (j
= 0; j
< PATCHES
; j
++)
357 script
[LABELPATCHES
[j
]] = bS_to_host(pScript
+ SCRIPT
[LABELPATCHES
[j
]]);
358 /* now patch up fixed addresses. */
359 script_patch_32(hostdata
->dev
, script
, MessageLocation
,
360 pScript
+ MSGOUT_OFFSET
);
361 script_patch_32(hostdata
->dev
, script
, StatusAddress
,
362 pScript
+ STATUS_OFFSET
);
363 script_patch_32(hostdata
->dev
, script
, ReceiveMsgAddress
,
364 pScript
+ MSGIN_OFFSET
);
366 hostdata
->script
= script
;
367 hostdata
->pScript
= pScript
;
368 dma_sync_single_for_device(hostdata
->dev
, pScript
, sizeof(SCRIPT
), DMA_TO_DEVICE
);
369 hostdata
->state
= NCR_700_HOST_FREE
;
370 hostdata
->cmd
= NULL
;
372 host
->max_lun
= NCR_700_MAX_LUNS
;
373 BUG_ON(NCR_700_transport_template
== NULL
);
374 host
->transportt
= NCR_700_transport_template
;
375 host
->unique_id
= (unsigned long)hostdata
->base
;
376 hostdata
->eh_complete
= NULL
;
377 host
->hostdata
[0] = (unsigned long)hostdata
;
379 NCR_700_writeb(0xff, host
, CTEST9_REG
);
380 if (hostdata
->chip710
)
381 hostdata
->rev
= (NCR_700_readb(host
, CTEST8_REG
)>>4) & 0x0f;
383 hostdata
->rev
= (NCR_700_readb(host
, CTEST7_REG
)>>4) & 0x0f;
384 hostdata
->fast
= (NCR_700_readb(host
, CTEST9_REG
) == 0);
386 printk(KERN_NOTICE
"53c700: Version " NCR_700_VERSION
" By James.Bottomley@HansenPartnership.com\n");
389 printk(KERN_NOTICE
"scsi%d: %s rev %d %s\n", host
->host_no
,
390 hostdata
->chip710
? "53c710" :
391 (hostdata
->fast
? "53c700-66" : "53c700"),
392 hostdata
->rev
, hostdata
->differential
?
393 "(Differential)" : "");
395 NCR_700_chip_reset(host
);
397 if (scsi_add_host(host
, dev
)) {
398 dev_printk(KERN_ERR
, dev
, "53c700: scsi_add_host failed\n");
403 spi_signalling(host
) = hostdata
->differential
? SPI_SIGNAL_HVD
:
410 NCR_700_release(struct Scsi_Host
*host
)
412 struct NCR_700_Host_Parameters
*hostdata
=
413 (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
415 dma_free_noncoherent(hostdata
->dev
, TOTAL_MEM_SIZE
,
416 hostdata
->script
, hostdata
->pScript
);
421 NCR_700_identify(int can_disconnect
, __u8 lun
)
423 return IDENTIFY_BASE
|
424 ((can_disconnect
) ? 0x40 : 0) |
425 (lun
& NCR_700_LUN_MASK
);
429 * Function : static int data_residual (Scsi_Host *host)
431 * Purpose : return residual data count of what's in the chip. If you
432 * really want to know what this function is doing, it's almost a
433 * direct transcription of the algorithm described in the 53c710
434 * guide, except that the DBC and DFIFO registers are only 6 bits
437 * Inputs : host - SCSI host */
439 NCR_700_data_residual (struct Scsi_Host
*host
) {
440 struct NCR_700_Host_Parameters
*hostdata
=
441 (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
442 int count
, synchronous
= 0;
445 if(hostdata
->chip710
) {
446 count
= ((NCR_700_readb(host
, DFIFO_REG
) & 0x7f) -
447 (NCR_700_readl(host
, DBC_REG
) & 0x7f)) & 0x7f;
449 count
= ((NCR_700_readb(host
, DFIFO_REG
) & 0x3f) -
450 (NCR_700_readl(host
, DBC_REG
) & 0x3f)) & 0x3f;
454 synchronous
= NCR_700_readb(host
, SXFER_REG
) & 0x0f;
456 /* get the data direction */
457 ddir
= NCR_700_readb(host
, CTEST0_REG
) & 0x01;
462 count
+= (NCR_700_readb(host
, SSTAT2_REG
) & 0xf0) >> 4;
464 if (NCR_700_readb(host
, SSTAT1_REG
) & SIDL_REG_FULL
)
468 __u8 sstat
= NCR_700_readb(host
, SSTAT1_REG
);
469 if (sstat
& SODL_REG_FULL
)
471 if (synchronous
&& (sstat
& SODR_REG_FULL
))
476 printk("RESIDUAL IS %d (ddir %d)\n", count
, ddir
);
481 /* print out the SCSI wires and corresponding phase from the SBCL register
484 sbcl_to_string(__u8 sbcl
)
487 static char ret
[256];
492 strcat(ret
, NCR_700_SBCL_bits
[i
]);
494 strcat(ret
, NCR_700_SBCL_to_phase
[sbcl
& 0x07]);
499 bitmap_to_number(__u8 bitmap
)
503 for(i
=0; i
<8 && !(bitmap
&(1<<i
)); i
++)
508 /* Pull a slot off the free list */
509 STATIC
struct NCR_700_command_slot
*
510 find_empty_slot(struct NCR_700_Host_Parameters
*hostdata
)
512 struct NCR_700_command_slot
*slot
= hostdata
->free_list
;
516 if(hostdata
->command_slot_count
!= NCR_700_COMMAND_SLOTS_PER_HOST
)
517 printk(KERN_ERR
"SLOTS FULL, but count is %d, should be %d\n", hostdata
->command_slot_count
, NCR_700_COMMAND_SLOTS_PER_HOST
);
521 if(slot
->state
!= NCR_700_SLOT_FREE
)
523 printk(KERN_ERR
"BUSY SLOT ON FREE LIST!!!\n");
526 hostdata
->free_list
= slot
->ITL_forw
;
527 slot
->ITL_forw
= NULL
;
530 /* NOTE: set the state to busy here, not queued, since this
531 * indicates the slot is in use and cannot be run by the IRQ
532 * finish routine. If we cannot queue the command when it
533 * is properly build, we then change to NCR_700_SLOT_QUEUED */
534 slot
->state
= NCR_700_SLOT_BUSY
;
536 hostdata
->command_slot_count
++;
542 free_slot(struct NCR_700_command_slot
*slot
,
543 struct NCR_700_Host_Parameters
*hostdata
)
545 if((slot
->state
& NCR_700_SLOT_MASK
) != NCR_700_SLOT_MAGIC
) {
546 printk(KERN_ERR
"53c700: SLOT %p is not MAGIC!!!\n", slot
);
548 if(slot
->state
== NCR_700_SLOT_FREE
) {
549 printk(KERN_ERR
"53c700: SLOT %p is FREE!!!\n", slot
);
552 slot
->resume_offset
= 0;
554 slot
->state
= NCR_700_SLOT_FREE
;
555 slot
->ITL_forw
= hostdata
->free_list
;
556 hostdata
->free_list
= slot
;
557 hostdata
->command_slot_count
--;
561 /* This routine really does very little. The command is indexed on
562 the ITL and (if tagged) the ITLQ lists in _queuecommand */
564 save_for_reselection(struct NCR_700_Host_Parameters
*hostdata
,
565 struct scsi_cmnd
*SCp
, __u32 dsp
)
567 /* Its just possible that this gets executed twice */
569 struct NCR_700_command_slot
*slot
=
570 (struct NCR_700_command_slot
*)SCp
->host_scribble
;
572 slot
->resume_offset
= dsp
;
574 hostdata
->state
= NCR_700_HOST_FREE
;
575 hostdata
->cmd
= NULL
;
579 NCR_700_unmap(struct NCR_700_Host_Parameters
*hostdata
, struct scsi_cmnd
*SCp
,
580 struct NCR_700_command_slot
*slot
)
582 if(SCp
->sc_data_direction
!= DMA_NONE
&&
583 SCp
->sc_data_direction
!= DMA_BIDIRECTIONAL
)
588 NCR_700_scsi_done(struct NCR_700_Host_Parameters
*hostdata
,
589 struct scsi_cmnd
*SCp
, int result
)
591 hostdata
->state
= NCR_700_HOST_FREE
;
592 hostdata
->cmd
= NULL
;
595 struct NCR_700_command_slot
*slot
=
596 (struct NCR_700_command_slot
*)SCp
->host_scribble
;
598 dma_unmap_single(hostdata
->dev
, slot
->pCmd
,
599 MAX_COMMAND_SIZE
, DMA_TO_DEVICE
);
600 if (slot
->flags
== NCR_700_FLAG_AUTOSENSE
) {
601 char *cmnd
= NCR_700_get_sense_cmnd(SCp
->device
);
603 printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense is\n",
604 SCp
, SCp
->cmnd
[7], result
);
605 scsi_print_sense("53c700", SCp
);
608 dma_unmap_single(hostdata
->dev
, slot
->dma_handle
,
609 SCSI_SENSE_BUFFERSIZE
, DMA_FROM_DEVICE
);
610 /* restore the old result if the request sense was
614 /* restore the original length */
615 SCp
->cmd_len
= cmnd
[8];
617 NCR_700_unmap(hostdata
, SCp
, slot
);
619 free_slot(slot
, hostdata
);
621 if(NCR_700_get_depth(SCp
->device
) == 0 ||
622 NCR_700_get_depth(SCp
->device
) > SCp
->device
->queue_depth
)
623 printk(KERN_ERR
"Invalid depth in NCR_700_scsi_done(): %d\n",
624 NCR_700_get_depth(SCp
->device
));
625 #endif /* NCR_700_DEBUG */
626 NCR_700_set_depth(SCp
->device
, NCR_700_get_depth(SCp
->device
) - 1);
628 SCp
->host_scribble
= NULL
;
629 SCp
->result
= result
;
632 printk(KERN_ERR
"53c700: SCSI DONE HAS NULL SCp\n");
638 NCR_700_internal_bus_reset(struct Scsi_Host
*host
)
641 NCR_700_writeb(ASSERT_RST
, host
, SCNTL1_REG
);
643 NCR_700_writeb(0, host
, SCNTL1_REG
);
648 NCR_700_chip_setup(struct Scsi_Host
*host
)
650 struct NCR_700_Host_Parameters
*hostdata
=
651 (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
653 __u8 min_xferp
= (hostdata
->chip710
? NCR_710_MIN_XFERP
: NCR_700_MIN_XFERP
);
655 if(hostdata
->chip710
) {
656 __u8 burst_disable
= 0;
657 __u8 burst_length
= 0;
659 switch (hostdata
->burst_length
) {
661 burst_length
= BURST_LENGTH_1
;
664 burst_length
= BURST_LENGTH_2
;
667 burst_length
= BURST_LENGTH_4
;
670 burst_length
= BURST_LENGTH_8
;
673 burst_disable
= BURST_DISABLE
;
676 hostdata
->dcntl_extra
|= COMPAT_700_MODE
;
678 NCR_700_writeb(hostdata
->dcntl_extra
, host
, DCNTL_REG
);
679 NCR_700_writeb(burst_length
| hostdata
->dmode_extra
,
680 host
, DMODE_710_REG
);
681 NCR_700_writeb(burst_disable
| hostdata
->ctest7_extra
|
682 (hostdata
->differential
? DIFF
: 0),
684 NCR_700_writeb(BTB_TIMER_DISABLE
, host
, CTEST0_REG
);
685 NCR_700_writeb(FULL_ARBITRATION
| ENABLE_PARITY
| PARITY
686 | AUTO_ATN
, host
, SCNTL0_REG
);
688 NCR_700_writeb(BURST_LENGTH_8
| hostdata
->dmode_extra
,
689 host
, DMODE_700_REG
);
690 NCR_700_writeb(hostdata
->differential
?
691 DIFF
: 0, host
, CTEST7_REG
);
693 /* this is for 700-66, does nothing on 700 */
694 NCR_700_writeb(LAST_DIS_ENBL
| ENABLE_ACTIVE_NEGATION
695 | GENERATE_RECEIVE_PARITY
, host
,
698 NCR_700_writeb(FULL_ARBITRATION
| ENABLE_PARITY
699 | PARITY
| AUTO_ATN
, host
, SCNTL0_REG
);
703 NCR_700_writeb(1 << host
->this_id
, host
, SCID_REG
);
704 NCR_700_writeb(0, host
, SBCL_REG
);
705 NCR_700_writeb(ASYNC_OPERATION
, host
, SXFER_REG
);
707 NCR_700_writeb(PHASE_MM_INT
| SEL_TIMEOUT_INT
| GROSS_ERR_INT
| UX_DISC_INT
708 | RST_INT
| PAR_ERR_INT
| SELECT_INT
, host
, SIEN_REG
);
710 NCR_700_writeb(ABORT_INT
| INT_INST_INT
| ILGL_INST_INT
, host
, DIEN_REG
);
711 NCR_700_writeb(ENABLE_SELECT
, host
, SCNTL1_REG
);
712 if(hostdata
->clock
> 75) {
713 printk(KERN_ERR
"53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata
->clock
);
714 /* do the best we can, but the async clock will be out
715 * of spec: sync divider 2, async divider 3 */
716 DEBUG(("53c700: sync 2 async 3\n"));
717 NCR_700_writeb(SYNC_DIV_2_0
, host
, SBCL_REG
);
718 NCR_700_writeb(ASYNC_DIV_3_0
| hostdata
->dcntl_extra
, host
, DCNTL_REG
);
719 hostdata
->sync_clock
= hostdata
->clock
/2;
720 } else if(hostdata
->clock
> 50 && hostdata
->clock
<= 75) {
721 /* sync divider 1.5, async divider 3 */
722 DEBUG(("53c700: sync 1.5 async 3\n"));
723 NCR_700_writeb(SYNC_DIV_1_5
, host
, SBCL_REG
);
724 NCR_700_writeb(ASYNC_DIV_3_0
| hostdata
->dcntl_extra
, host
, DCNTL_REG
);
725 hostdata
->sync_clock
= hostdata
->clock
*2;
726 hostdata
->sync_clock
/= 3;
728 } else if(hostdata
->clock
> 37 && hostdata
->clock
<= 50) {
729 /* sync divider 1, async divider 2 */
730 DEBUG(("53c700: sync 1 async 2\n"));
731 NCR_700_writeb(SYNC_DIV_1_0
, host
, SBCL_REG
);
732 NCR_700_writeb(ASYNC_DIV_2_0
| hostdata
->dcntl_extra
, host
, DCNTL_REG
);
733 hostdata
->sync_clock
= hostdata
->clock
;
734 } else if(hostdata
->clock
> 25 && hostdata
->clock
<=37) {
735 /* sync divider 1, async divider 1.5 */
736 DEBUG(("53c700: sync 1 async 1.5\n"));
737 NCR_700_writeb(SYNC_DIV_1_0
, host
, SBCL_REG
);
738 NCR_700_writeb(ASYNC_DIV_1_5
| hostdata
->dcntl_extra
, host
, DCNTL_REG
);
739 hostdata
->sync_clock
= hostdata
->clock
;
741 DEBUG(("53c700: sync 1 async 1\n"));
742 NCR_700_writeb(SYNC_DIV_1_0
, host
, SBCL_REG
);
743 NCR_700_writeb(ASYNC_DIV_1_0
| hostdata
->dcntl_extra
, host
, DCNTL_REG
);
744 /* sync divider 1, async divider 1 */
745 hostdata
->sync_clock
= hostdata
->clock
;
747 /* Calculate the actual minimum period that can be supported
748 * by our synchronous clock speed. See the 710 manual for
749 * exact details of this calculation which is based on a
750 * setting of the SXFER register */
751 min_period
= 1000*(4+min_xferp
)/(4*hostdata
->sync_clock
);
752 hostdata
->min_period
= NCR_700_MIN_PERIOD
;
753 if(min_period
> NCR_700_MIN_PERIOD
)
754 hostdata
->min_period
= min_period
;
758 NCR_700_chip_reset(struct Scsi_Host
*host
)
760 struct NCR_700_Host_Parameters
*hostdata
=
761 (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
762 if(hostdata
->chip710
) {
763 NCR_700_writeb(SOFTWARE_RESET_710
, host
, ISTAT_REG
);
766 NCR_700_writeb(0, host
, ISTAT_REG
);
768 NCR_700_writeb(SOFTWARE_RESET
, host
, DCNTL_REG
);
771 NCR_700_writeb(0, host
, DCNTL_REG
);
776 NCR_700_chip_setup(host
);
779 /* The heart of the message processing engine is that the instruction
780 * immediately after the INT is the normal case (and so must be CLEAR
781 * ACK). If we want to do something else, we call that routine in
782 * scripts and set temp to be the normal case + 8 (skipping the CLEAR
783 * ACK) so that the routine returns correctly to resume its activity
786 process_extended_message(struct Scsi_Host
*host
,
787 struct NCR_700_Host_Parameters
*hostdata
,
788 struct scsi_cmnd
*SCp
, __u32 dsp
, __u32 dsps
)
790 __u32 resume_offset
= dsp
, temp
= dsp
+ 8;
791 __u8 pun
= 0xff, lun
= 0xff;
794 pun
= SCp
->device
->id
;
795 lun
= SCp
->device
->lun
;
798 switch(hostdata
->msgin
[2]) {
800 if(SCp
!= NULL
&& NCR_700_is_flag_set(SCp
->device
, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
)) {
801 struct scsi_target
*starget
= SCp
->device
->sdev_target
;
802 __u8 period
= hostdata
->msgin
[3];
803 __u8 offset
= hostdata
->msgin
[4];
805 if(offset
== 0 || period
== 0) {
810 spi_offset(starget
) = offset
;
811 spi_period(starget
) = period
;
813 if(NCR_700_is_flag_set(SCp
->device
, NCR_700_DEV_PRINT_SYNC_NEGOTIATION
)) {
814 spi_display_xfer_agreement(starget
);
815 NCR_700_clear_flag(SCp
->device
, NCR_700_DEV_PRINT_SYNC_NEGOTIATION
);
818 NCR_700_set_flag(SCp
->device
, NCR_700_DEV_NEGOTIATED_SYNC
);
819 NCR_700_clear_flag(SCp
->device
, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
);
821 NCR_700_writeb(NCR_700_get_SXFER(SCp
->device
),
825 /* SDTR message out of the blue, reject it */
826 shost_printk(KERN_WARNING
, host
,
827 "Unexpected SDTR msg\n");
828 hostdata
->msgout
[0] = A_REJECT_MSG
;
829 dma_cache_sync(hostdata
->dev
, hostdata
->msgout
, 1, DMA_TO_DEVICE
);
830 script_patch_16(hostdata
->dev
, hostdata
->script
,
832 /* SendMsgOut returns, so set up the return
834 resume_offset
= hostdata
->pScript
+ Ent_SendMessageWithATN
;
839 printk(KERN_INFO
"scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n",
840 host
->host_no
, pun
, lun
);
841 hostdata
->msgout
[0] = A_REJECT_MSG
;
842 dma_cache_sync(hostdata
->dev
, hostdata
->msgout
, 1, DMA_TO_DEVICE
);
843 script_patch_16(hostdata
->dev
, hostdata
->script
, MessageCount
,
845 resume_offset
= hostdata
->pScript
+ Ent_SendMessageWithATN
;
850 printk(KERN_INFO
"scsi%d (%d:%d): Unexpected message %s: ",
851 host
->host_no
, pun
, lun
,
852 NCR_700_phase
[(dsps
& 0xf00) >> 8]);
853 spi_print_msg(hostdata
->msgin
);
856 hostdata
->msgout
[0] = A_REJECT_MSG
;
857 dma_cache_sync(hostdata
->dev
, hostdata
->msgout
, 1, DMA_TO_DEVICE
);
858 script_patch_16(hostdata
->dev
, hostdata
->script
, MessageCount
,
860 /* SendMsgOut returns, so set up the return
862 resume_offset
= hostdata
->pScript
+ Ent_SendMessageWithATN
;
864 NCR_700_writel(temp
, host
, TEMP_REG
);
865 return resume_offset
;
869 process_message(struct Scsi_Host
*host
, struct NCR_700_Host_Parameters
*hostdata
,
870 struct scsi_cmnd
*SCp
, __u32 dsp
, __u32 dsps
)
872 /* work out where to return to */
873 __u32 temp
= dsp
+ 8, resume_offset
= dsp
;
874 __u8 pun
= 0xff, lun
= 0xff;
877 pun
= SCp
->device
->id
;
878 lun
= SCp
->device
->lun
;
882 printk("scsi%d (%d:%d): message %s: ", host
->host_no
, pun
, lun
,
883 NCR_700_phase
[(dsps
& 0xf00) >> 8]);
884 spi_print_msg(hostdata
->msgin
);
888 switch(hostdata
->msgin
[0]) {
891 resume_offset
= process_extended_message(host
, hostdata
, SCp
,
896 if(SCp
!= NULL
&& NCR_700_is_flag_set(SCp
->device
, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
)) {
897 /* Rejected our sync negotiation attempt */
898 spi_period(SCp
->device
->sdev_target
) =
899 spi_offset(SCp
->device
->sdev_target
) = 0;
900 NCR_700_set_flag(SCp
->device
, NCR_700_DEV_NEGOTIATED_SYNC
);
901 NCR_700_clear_flag(SCp
->device
, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
);
902 } else if(SCp
!= NULL
&& NCR_700_get_tag_neg_state(SCp
->device
) == NCR_700_DURING_TAG_NEGOTIATION
) {
903 /* rejected our first simple tag message */
904 scmd_printk(KERN_WARNING
, SCp
,
905 "Rejected first tag queue attempt, turning off tag queueing\n");
906 /* we're done negotiating */
907 NCR_700_set_tag_neg_state(SCp
->device
, NCR_700_FINISHED_TAG_NEGOTIATION
);
908 hostdata
->tag_negotiated
&= ~(1<<scmd_id(SCp
));
909 SCp
->device
->tagged_supported
= 0;
910 scsi_deactivate_tcq(SCp
->device
, host
->cmd_per_lun
);
912 shost_printk(KERN_WARNING
, host
,
913 "(%d:%d) Unexpected REJECT Message %s\n",
915 NCR_700_phase
[(dsps
& 0xf00) >> 8]);
916 /* however, just ignore it */
920 case A_PARITY_ERROR_MSG
:
921 printk(KERN_ERR
"scsi%d (%d:%d) Parity Error!\n", host
->host_no
,
923 NCR_700_internal_bus_reset(host
);
925 case A_SIMPLE_TAG_MSG
:
926 printk(KERN_INFO
"scsi%d (%d:%d) SIMPLE TAG %d %s\n", host
->host_no
,
927 pun
, lun
, hostdata
->msgin
[1],
928 NCR_700_phase
[(dsps
& 0xf00) >> 8]);
932 printk(KERN_INFO
"scsi%d (%d:%d): Unexpected message %s: ",
933 host
->host_no
, pun
, lun
,
934 NCR_700_phase
[(dsps
& 0xf00) >> 8]);
936 spi_print_msg(hostdata
->msgin
);
939 hostdata
->msgout
[0] = A_REJECT_MSG
;
940 dma_cache_sync(hostdata
->dev
, hostdata
->msgout
, 1, DMA_TO_DEVICE
);
941 script_patch_16(hostdata
->dev
, hostdata
->script
, MessageCount
,
943 /* SendMsgOut returns, so set up the return
945 resume_offset
= hostdata
->pScript
+ Ent_SendMessageWithATN
;
949 NCR_700_writel(temp
, host
, TEMP_REG
);
950 /* set us up to receive another message */
951 dma_cache_sync(hostdata
->dev
, hostdata
->msgin
, MSG_ARRAY_SIZE
, DMA_FROM_DEVICE
);
952 return resume_offset
;
956 process_script_interrupt(__u32 dsps
, __u32 dsp
, struct scsi_cmnd
*SCp
,
957 struct Scsi_Host
*host
,
958 struct NCR_700_Host_Parameters
*hostdata
)
960 __u32 resume_offset
= 0;
961 __u8 pun
= 0xff, lun
=0xff;
964 pun
= SCp
->device
->id
;
965 lun
= SCp
->device
->lun
;
968 if(dsps
== A_GOOD_STATUS_AFTER_STATUS
) {
969 DEBUG((" COMMAND COMPLETE, status=%02x\n",
970 hostdata
->status
[0]));
971 /* OK, if TCQ still under negotiation, we now know it works */
972 if (NCR_700_get_tag_neg_state(SCp
->device
) == NCR_700_DURING_TAG_NEGOTIATION
)
973 NCR_700_set_tag_neg_state(SCp
->device
,
974 NCR_700_FINISHED_TAG_NEGOTIATION
);
976 /* check for contingent allegiance contitions */
977 if(status_byte(hostdata
->status
[0]) == CHECK_CONDITION
||
978 status_byte(hostdata
->status
[0]) == COMMAND_TERMINATED
) {
979 struct NCR_700_command_slot
*slot
=
980 (struct NCR_700_command_slot
*)SCp
->host_scribble
;
981 if(slot
->flags
== NCR_700_FLAG_AUTOSENSE
) {
982 /* OOPS: bad device, returning another
983 * contingent allegiance condition */
984 scmd_printk(KERN_ERR
, SCp
,
985 "broken device is looping in contingent allegiance: ignoring\n");
986 NCR_700_scsi_done(hostdata
, SCp
, hostdata
->status
[0]);
989 NCR_700_get_sense_cmnd(SCp
->device
);
991 scsi_print_command(SCp
);
992 printk(" cmd %p has status %d, requesting sense\n",
993 SCp
, hostdata
->status
[0]);
995 /* we can destroy the command here
996 * because the contingent allegiance
997 * condition will cause a retry which
998 * will re-copy the command from the
999 * saved data_cmnd. We also unmap any
1000 * data associated with the command
1002 NCR_700_unmap(hostdata
, SCp
, slot
);
1003 dma_unmap_single(hostdata
->dev
, slot
->pCmd
,
1007 cmnd
[0] = REQUEST_SENSE
;
1008 cmnd
[1] = (lun
& 0x7) << 5;
1011 cmnd
[4] = SCSI_SENSE_BUFFERSIZE
;
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
1019 cmnd
[6] = NCR_700_INTERNAL_SENSE_MAGIC
;
1020 cmnd
[7] = hostdata
->status
[0];
1021 cmnd
[8] = SCp
->cmd_len
;
1022 SCp
->cmd_len
= 6; /* command length for
1024 slot
->pCmd
= dma_map_single(hostdata
->dev
, cmnd
, MAX_COMMAND_SIZE
, DMA_TO_DEVICE
);
1025 slot
->dma_handle
= dma_map_single(hostdata
->dev
, SCp
->sense_buffer
, SCSI_SENSE_BUFFERSIZE
, DMA_FROM_DEVICE
);
1026 slot
->SG
[0].ins
= bS_to_host(SCRIPT_MOVE_DATA_IN
| SCSI_SENSE_BUFFERSIZE
);
1027 slot
->SG
[0].pAddr
= bS_to_host(slot
->dma_handle
);
1028 slot
->SG
[1].ins
= bS_to_host(SCRIPT_RETURN
);
1029 slot
->SG
[1].pAddr
= 0;
1030 slot
->resume_offset
= hostdata
->pScript
;
1031 dma_cache_sync(hostdata
->dev
, slot
->SG
, sizeof(slot
->SG
[0])*2, DMA_TO_DEVICE
);
1032 dma_cache_sync(hostdata
->dev
, SCp
->sense_buffer
, SCSI_SENSE_BUFFERSIZE
, DMA_FROM_DEVICE
);
1034 /* queue the command for reissue */
1035 slot
->state
= NCR_700_SLOT_QUEUED
;
1036 slot
->flags
= NCR_700_FLAG_AUTOSENSE
;
1037 hostdata
->state
= NCR_700_HOST_FREE
;
1038 hostdata
->cmd
= NULL
;
1041 // Currently rely on the mid layer evaluation
1042 // of the tag queuing capability
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 // scmd_printk(KERN_INFO, SCp,
1054 // "Enabling Tag Command Queuing\n");
1055 // hostdata->tag_negotiated |= (1<<scmd_id(SCp));
1056 // NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1058 // NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1059 // hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
1062 NCR_700_scsi_done(hostdata
, SCp
, hostdata
->status
[0]);
1064 } else if((dsps
& 0xfffff0f0) == A_UNEXPECTED_PHASE
) {
1065 __u8 i
= (dsps
& 0xf00) >> 8;
1067 scmd_printk(KERN_ERR
, SCp
, "UNEXPECTED PHASE %s (%s)\n",
1069 sbcl_to_string(NCR_700_readb(host
, SBCL_REG
)));
1070 scmd_printk(KERN_ERR
, SCp
, " len = %d, cmd =",
1072 scsi_print_command(SCp
);
1074 NCR_700_internal_bus_reset(host
);
1075 } else if((dsps
& 0xfffff000) == A_FATAL
) {
1076 int i
= (dsps
& 0xfff);
1078 printk(KERN_ERR
"scsi%d: (%d:%d) FATAL ERROR: %s\n",
1079 host
->host_no
, pun
, lun
, NCR_700_fatal_messages
[i
]);
1080 if(dsps
== A_FATAL_ILLEGAL_MSG_LENGTH
) {
1081 printk(KERN_ERR
" msg begins %02x %02x\n",
1082 hostdata
->msgin
[0], hostdata
->msgin
[1]);
1084 NCR_700_internal_bus_reset(host
);
1085 } else if((dsps
& 0xfffff0f0) == A_DISCONNECT
) {
1086 #ifdef NCR_700_DEBUG
1087 __u8 i
= (dsps
& 0xf00) >> 8;
1089 printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n",
1090 host
->host_no
, pun
, lun
,
1091 i
, NCR_700_phase
[i
]);
1093 save_for_reselection(hostdata
, SCp
, dsp
);
1095 } else if(dsps
== A_RESELECTION_IDENTIFIED
) {
1097 struct NCR_700_command_slot
*slot
;
1098 __u8 reselection_id
= hostdata
->reselection_id
;
1099 struct scsi_device
*SDp
;
1101 lun
= hostdata
->msgin
[0] & 0x1f;
1103 hostdata
->reselection_id
= 0xff;
1104 DEBUG(("scsi%d: (%d:%d) RESELECTED!\n",
1105 host
->host_no
, reselection_id
, lun
));
1106 /* clear the reselection indicator */
1107 SDp
= __scsi_device_lookup(host
, 0, reselection_id
, lun
);
1108 if(unlikely(SDp
== NULL
)) {
1109 printk(KERN_ERR
"scsi%d: (%d:%d) HAS NO device\n",
1110 host
->host_no
, reselection_id
, lun
);
1113 if(hostdata
->msgin
[1] == A_SIMPLE_TAG_MSG
) {
1114 struct scsi_cmnd
*SCp
= scsi_find_tag(SDp
, hostdata
->msgin
[2]);
1115 if(unlikely(SCp
== NULL
)) {
1116 printk(KERN_ERR
"scsi%d: (%d:%d) no saved request for tag %d\n",
1117 host
->host_no
, reselection_id
, lun
, hostdata
->msgin
[2]);
1121 slot
= (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1122 DDEBUG(KERN_DEBUG
, SDp
,
1123 "reselection is tag %d, slot %p(%d)\n",
1124 hostdata
->msgin
[2], slot
, slot
->tag
);
1126 struct scsi_cmnd
*SCp
= scsi_find_tag(SDp
, SCSI_NO_TAG
);
1127 if(unlikely(SCp
== NULL
)) {
1128 sdev_printk(KERN_ERR
, SDp
,
1129 "no saved request for untagged cmd\n");
1132 slot
= (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1136 printk(KERN_ERR
"scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n",
1137 host
->host_no
, reselection_id
, lun
,
1138 hostdata
->msgin
[0], hostdata
->msgin
[1],
1139 hostdata
->msgin
[2]);
1141 if(hostdata
->state
!= NCR_700_HOST_BUSY
)
1142 printk(KERN_ERR
"scsi%d: FATAL, host not busy during valid reselection!\n",
1144 resume_offset
= slot
->resume_offset
;
1145 hostdata
->cmd
= slot
->cmnd
;
1147 /* re-patch for this command */
1148 script_patch_32_abs(hostdata
->dev
, hostdata
->script
,
1149 CommandAddress
, slot
->pCmd
);
1150 script_patch_16(hostdata
->dev
, hostdata
->script
,
1151 CommandCount
, slot
->cmnd
->cmd_len
);
1152 script_patch_32_abs(hostdata
->dev
, hostdata
->script
,
1153 SGScriptStartAddress
,
1154 to32bit(&slot
->pSG
[0].ins
));
1156 /* Note: setting SXFER only works if we're
1157 * still in the MESSAGE phase, so it is vital
1158 * that ACK is still asserted when we process
1159 * the reselection message. The resume offset
1160 * should therefore always clear ACK */
1161 NCR_700_writeb(NCR_700_get_SXFER(hostdata
->cmd
->device
),
1163 dma_cache_sync(hostdata
->dev
, hostdata
->msgin
,
1164 MSG_ARRAY_SIZE
, DMA_FROM_DEVICE
);
1165 dma_cache_sync(hostdata
->dev
, hostdata
->msgout
,
1166 MSG_ARRAY_SIZE
, DMA_TO_DEVICE
);
1167 /* I'm just being paranoid here, the command should
1168 * already have been flushed from the cache */
1169 dma_cache_sync(hostdata
->dev
, slot
->cmnd
->cmnd
,
1170 slot
->cmnd
->cmd_len
, DMA_TO_DEVICE
);
1175 } else if(dsps
== A_RESELECTED_DURING_SELECTION
) {
1177 /* This section is full of debugging code because I've
1178 * never managed to reach it. I think what happens is
1179 * that, because the 700 runs with selection
1180 * interrupts enabled the whole time that we take a
1181 * selection interrupt before we manage to get to the
1182 * reselected script interrupt */
1184 __u8 reselection_id
= NCR_700_readb(host
, SFBR_REG
);
1185 struct NCR_700_command_slot
*slot
;
1187 /* Take out our own ID */
1188 reselection_id
&= ~(1<<host
->this_id
);
1190 /* I've never seen this happen, so keep this as a printk rather
1192 printk(KERN_INFO
"scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n",
1193 host
->host_no
, reselection_id
, lun
, dsp
, dsp
- hostdata
->pScript
, hostdata
->state
, hostdata
->command_slot_count
);
1196 /* FIXME: DEBUGGING CODE */
1197 __u32 SG
= (__u32
)bS_to_cpu(hostdata
->script
[A_SGScriptStartAddress_used
[0]]);
1200 for(i
=0; i
< NCR_700_COMMAND_SLOTS_PER_HOST
; i
++) {
1201 if(SG
>= to32bit(&hostdata
->slots
[i
].pSG
[0])
1202 && SG
<= to32bit(&hostdata
->slots
[i
].pSG
[NCR_700_SG_SEGMENTS
]))
1205 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
);
1206 SCp
= hostdata
->slots
[i
].cmnd
;
1210 slot
= (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1211 /* change slot from busy to queued to redo command */
1212 slot
->state
= NCR_700_SLOT_QUEUED
;
1214 hostdata
->cmd
= NULL
;
1216 if(reselection_id
== 0) {
1217 if(hostdata
->reselection_id
== 0xff) {
1218 printk(KERN_ERR
"scsi%d: Invalid reselection during selection!!\n", host
->host_no
);
1221 printk(KERN_ERR
"scsi%d: script reselected and we took a selection interrupt\n",
1223 reselection_id
= hostdata
->reselection_id
;
1227 /* convert to real ID */
1228 reselection_id
= bitmap_to_number(reselection_id
);
1230 hostdata
->reselection_id
= reselection_id
;
1231 /* just in case we have a stale simple tag message, clear it */
1232 hostdata
->msgin
[1] = 0;
1233 dma_cache_sync(hostdata
->dev
, hostdata
->msgin
,
1234 MSG_ARRAY_SIZE
, DMA_BIDIRECTIONAL
);
1235 if(hostdata
->tag_negotiated
& (1<<reselection_id
)) {
1236 resume_offset
= hostdata
->pScript
+ Ent_GetReselectionWithTag
;
1238 resume_offset
= hostdata
->pScript
+ Ent_GetReselectionData
;
1240 } else if(dsps
== A_COMPLETED_SELECTION_AS_TARGET
) {
1241 /* we've just disconnected from the bus, do nothing since
1242 * a return here will re-run the queued command slot
1243 * that may have been interrupted by the initial selection */
1244 DEBUG((" SELECTION COMPLETED\n"));
1245 } else if((dsps
& 0xfffff0f0) == A_MSG_IN
) {
1246 resume_offset
= process_message(host
, hostdata
, SCp
,
1248 } else if((dsps
& 0xfffff000) == 0) {
1249 __u8 i
= (dsps
& 0xf0) >> 4, j
= (dsps
& 0xf00) >> 8;
1250 printk(KERN_ERR
"scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n",
1251 host
->host_no
, pun
, lun
, NCR_700_condition
[i
],
1252 NCR_700_phase
[j
], dsp
- hostdata
->pScript
);
1254 struct scatterlist
*sg
;
1256 scsi_print_command(SCp
);
1257 scsi_for_each_sg(SCp
, sg
, scsi_sg_count(SCp
) + 1, i
) {
1258 printk(KERN_INFO
" SG[%d].length = %d, move_insn=%08x, addr %08x\n", i
, sg
->length
, ((struct NCR_700_command_slot
*)SCp
->host_scribble
)->SG
[i
].ins
, ((struct NCR_700_command_slot
*)SCp
->host_scribble
)->SG
[i
].pAddr
);
1261 NCR_700_internal_bus_reset(host
);
1262 } else if((dsps
& 0xfffff000) == A_DEBUG_INTERRUPT
) {
1263 printk(KERN_NOTICE
"scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n",
1264 host
->host_no
, pun
, lun
, dsps
& 0xfff, dsp
, dsp
- hostdata
->pScript
);
1265 resume_offset
= dsp
;
1267 printk(KERN_ERR
"scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n",
1268 host
->host_no
, pun
, lun
, dsps
, dsp
- hostdata
->pScript
);
1269 NCR_700_internal_bus_reset(host
);
1271 return resume_offset
;
1274 /* We run the 53c700 with selection interrupts always enabled. This
1275 * means that the chip may be selected as soon as the bus frees. On a
1276 * busy bus, this can be before the scripts engine finishes its
1277 * processing. Therefore, part of the selection processing has to be
1278 * to find out what the scripts engine is doing and complete the
1279 * function if necessary (i.e. process the pending disconnect or save
1280 * the interrupted initial selection */
1282 process_selection(struct Scsi_Host
*host
, __u32 dsp
)
1284 __u8 id
= 0; /* Squash compiler warning */
1286 __u32 resume_offset
= 0;
1287 struct NCR_700_Host_Parameters
*hostdata
=
1288 (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
1289 struct scsi_cmnd
*SCp
= hostdata
->cmd
;
1292 for(count
= 0; count
< 5; count
++) {
1293 id
= NCR_700_readb(host
, hostdata
->chip710
?
1294 CTEST9_REG
: SFBR_REG
);
1296 /* Take out our own ID */
1297 id
&= ~(1<<host
->this_id
);
1302 sbcl
= NCR_700_readb(host
, SBCL_REG
);
1303 if((sbcl
& SBCL_IO
) == 0) {
1304 /* mark as having been selected rather than reselected */
1307 /* convert to real ID */
1308 hostdata
->reselection_id
= id
= bitmap_to_number(id
);
1309 DEBUG(("scsi%d: Reselected by %d\n",
1310 host
->host_no
, id
));
1312 if(hostdata
->state
== NCR_700_HOST_BUSY
&& SCp
!= NULL
) {
1313 struct NCR_700_command_slot
*slot
=
1314 (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1315 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
));
1317 switch(dsp
- hostdata
->pScript
) {
1318 case Ent_Disconnect1
:
1319 case Ent_Disconnect2
:
1320 save_for_reselection(hostdata
, SCp
, Ent_Disconnect2
+ hostdata
->pScript
);
1322 case Ent_Disconnect3
:
1323 case Ent_Disconnect4
:
1324 save_for_reselection(hostdata
, SCp
, Ent_Disconnect4
+ hostdata
->pScript
);
1326 case Ent_Disconnect5
:
1327 case Ent_Disconnect6
:
1328 save_for_reselection(hostdata
, SCp
, Ent_Disconnect6
+ hostdata
->pScript
);
1330 case Ent_Disconnect7
:
1331 case Ent_Disconnect8
:
1332 save_for_reselection(hostdata
, SCp
, Ent_Disconnect8
+ hostdata
->pScript
);
1336 process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS
, dsp
, SCp
, host
, hostdata
);
1340 slot
->state
= NCR_700_SLOT_QUEUED
;
1344 hostdata
->state
= NCR_700_HOST_BUSY
;
1345 hostdata
->cmd
= NULL
;
1346 /* clear any stale simple tag message */
1347 hostdata
->msgin
[1] = 0;
1348 dma_cache_sync(hostdata
->dev
, hostdata
->msgin
, MSG_ARRAY_SIZE
,
1352 /* Selected as target, Ignore */
1353 resume_offset
= hostdata
->pScript
+ Ent_SelectedAsTarget
;
1354 } else if(hostdata
->tag_negotiated
& (1<<id
)) {
1355 resume_offset
= hostdata
->pScript
+ Ent_GetReselectionWithTag
;
1357 resume_offset
= hostdata
->pScript
+ Ent_GetReselectionData
;
1359 return resume_offset
;
1363 NCR_700_clear_fifo(struct Scsi_Host
*host
) {
1364 const struct NCR_700_Host_Parameters
*hostdata
1365 = (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
1366 if(hostdata
->chip710
) {
1367 NCR_700_writeb(CLR_FIFO_710
, host
, CTEST8_REG
);
1369 NCR_700_writeb(CLR_FIFO
, host
, DFIFO_REG
);
1374 NCR_700_flush_fifo(struct Scsi_Host
*host
) {
1375 const struct NCR_700_Host_Parameters
*hostdata
1376 = (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
1377 if(hostdata
->chip710
) {
1378 NCR_700_writeb(FLUSH_DMA_FIFO_710
, host
, CTEST8_REG
);
1380 NCR_700_writeb(0, host
, CTEST8_REG
);
1382 NCR_700_writeb(FLUSH_DMA_FIFO
, host
, DFIFO_REG
);
1384 NCR_700_writeb(0, host
, DFIFO_REG
);
1389 /* The queue lock with interrupts disabled must be held on entry to
1392 NCR_700_start_command(struct scsi_cmnd
*SCp
)
1394 struct NCR_700_command_slot
*slot
=
1395 (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1396 struct NCR_700_Host_Parameters
*hostdata
=
1397 (struct NCR_700_Host_Parameters
*)SCp
->device
->host
->hostdata
[0];
1398 __u16 count
= 1; /* for IDENTIFY message */
1399 u8 lun
= SCp
->device
->lun
;
1401 if(hostdata
->state
!= NCR_700_HOST_FREE
) {
1402 /* keep this inside the lock to close the race window where
1403 * the running command finishes on another CPU while we don't
1404 * change the state to queued on this one */
1405 slot
->state
= NCR_700_SLOT_QUEUED
;
1407 DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n",
1408 SCp
->device
->host
->host_no
, slot
->cmnd
, slot
));
1411 hostdata
->state
= NCR_700_HOST_BUSY
;
1412 hostdata
->cmd
= SCp
;
1413 slot
->state
= NCR_700_SLOT_BUSY
;
1414 /* keep interrupts disabled until we have the command correctly
1415 * set up so we cannot take a selection interrupt */
1417 hostdata
->msgout
[0] = NCR_700_identify((SCp
->cmnd
[0] != REQUEST_SENSE
&&
1418 slot
->flags
!= NCR_700_FLAG_AUTOSENSE
),
1420 /* for INQUIRY or REQUEST_SENSE commands, we cannot be sure
1421 * if the negotiated transfer parameters still hold, so
1422 * always renegotiate them */
1423 if(SCp
->cmnd
[0] == INQUIRY
|| SCp
->cmnd
[0] == REQUEST_SENSE
||
1424 slot
->flags
== NCR_700_FLAG_AUTOSENSE
) {
1425 NCR_700_clear_flag(SCp
->device
, NCR_700_DEV_NEGOTIATED_SYNC
);
1428 /* REQUEST_SENSE is asking for contingent I_T_L(_Q) status.
1429 * If a contingent allegiance condition exists, the device
1430 * will refuse all tags, so send the request sense as untagged
1432 if((hostdata
->tag_negotiated
& (1<<scmd_id(SCp
)))
1433 && (slot
->tag
!= SCSI_NO_TAG
&& SCp
->cmnd
[0] != REQUEST_SENSE
&&
1434 slot
->flags
!= NCR_700_FLAG_AUTOSENSE
)) {
1435 count
+= scsi_populate_tag_msg(SCp
, &hostdata
->msgout
[count
]);
1438 if(hostdata
->fast
&&
1439 NCR_700_is_flag_clear(SCp
->device
, NCR_700_DEV_NEGOTIATED_SYNC
)) {
1440 count
+= spi_populate_sync_msg(&hostdata
->msgout
[count
],
1441 spi_period(SCp
->device
->sdev_target
),
1442 spi_offset(SCp
->device
->sdev_target
));
1443 NCR_700_set_flag(SCp
->device
, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
);
1446 script_patch_16(hostdata
->dev
, hostdata
->script
, MessageCount
, count
);
1449 script_patch_ID(hostdata
->dev
, hostdata
->script
,
1450 Device_ID
, 1<<scmd_id(SCp
));
1452 script_patch_32_abs(hostdata
->dev
, hostdata
->script
, CommandAddress
,
1454 script_patch_16(hostdata
->dev
, hostdata
->script
, CommandCount
,
1456 /* finally plumb the beginning of the SG list into the script
1458 script_patch_32_abs(hostdata
->dev
, hostdata
->script
,
1459 SGScriptStartAddress
, to32bit(&slot
->pSG
[0].ins
));
1460 NCR_700_clear_fifo(SCp
->device
->host
);
1462 if(slot
->resume_offset
== 0)
1463 slot
->resume_offset
= hostdata
->pScript
;
1464 /* now perform all the writebacks and invalidates */
1465 dma_cache_sync(hostdata
->dev
, hostdata
->msgout
, count
, DMA_TO_DEVICE
);
1466 dma_cache_sync(hostdata
->dev
, hostdata
->msgin
, MSG_ARRAY_SIZE
,
1468 dma_cache_sync(hostdata
->dev
, SCp
->cmnd
, SCp
->cmd_len
, DMA_TO_DEVICE
);
1469 dma_cache_sync(hostdata
->dev
, hostdata
->status
, 1, DMA_FROM_DEVICE
);
1471 /* set the synchronous period/offset */
1472 NCR_700_writeb(NCR_700_get_SXFER(SCp
->device
),
1473 SCp
->device
->host
, SXFER_REG
);
1474 NCR_700_writel(slot
->temp
, SCp
->device
->host
, TEMP_REG
);
1475 NCR_700_writel(slot
->resume_offset
, SCp
->device
->host
, DSP_REG
);
1481 NCR_700_intr(int irq
, void *dev_id
)
1483 struct Scsi_Host
*host
= (struct Scsi_Host
*)dev_id
;
1484 struct NCR_700_Host_Parameters
*hostdata
=
1485 (struct NCR_700_Host_Parameters
*)host
->hostdata
[0];
1487 __u32 resume_offset
= 0;
1488 __u8 pun
= 0xff, lun
= 0xff;
1489 unsigned long flags
;
1492 /* Use the host lock to serialise access to the 53c700
1493 * hardware. Note: In future, we may need to take the queue
1494 * lock to enter the done routines. When that happens, we
1495 * need to ensure that for this driver, the host lock and the
1496 * queue lock point to the same thing. */
1497 spin_lock_irqsave(host
->host_lock
, flags
);
1498 if((istat
= NCR_700_readb(host
, ISTAT_REG
))
1499 & (SCSI_INT_PENDING
| DMA_INT_PENDING
)) {
1501 __u8 sstat0
= 0, dstat
= 0;
1503 struct scsi_cmnd
*SCp
= hostdata
->cmd
;
1504 enum NCR_700_Host_State state
;
1507 state
= hostdata
->state
;
1508 SCp
= hostdata
->cmd
;
1510 if(istat
& SCSI_INT_PENDING
) {
1513 sstat0
= NCR_700_readb(host
, SSTAT0_REG
);
1516 if(istat
& DMA_INT_PENDING
) {
1519 dstat
= NCR_700_readb(host
, DSTAT_REG
);
1522 dsps
= NCR_700_readl(host
, DSPS_REG
);
1523 dsp
= NCR_700_readl(host
, DSP_REG
);
1525 DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%x\n",
1526 host
->host_no
, istat
, sstat0
, dstat
,
1527 (dsp
- (__u32
)(hostdata
->pScript
))/4,
1531 pun
= SCp
->device
->id
;
1532 lun
= SCp
->device
->lun
;
1535 if(sstat0
& SCSI_RESET_DETECTED
) {
1536 struct scsi_device
*SDp
;
1539 hostdata
->state
= NCR_700_HOST_BUSY
;
1541 printk(KERN_ERR
"scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]\n",
1542 host
->host_no
, SCp
, SCp
== NULL
? NULL
: SCp
->host_scribble
, dsp
, dsp
- hostdata
->pScript
);
1544 scsi_report_bus_reset(host
, 0);
1546 /* clear all the negotiated parameters */
1547 __shost_for_each_device(SDp
, host
)
1548 NCR_700_clear_flag(SDp
, ~0);
1550 /* clear all the slots and their pending commands */
1551 for(i
= 0; i
< NCR_700_COMMAND_SLOTS_PER_HOST
; i
++) {
1552 struct scsi_cmnd
*SCp
;
1553 struct NCR_700_command_slot
*slot
=
1554 &hostdata
->slots
[i
];
1556 if(slot
->state
== NCR_700_SLOT_FREE
)
1560 printk(KERN_ERR
" failing command because of reset, slot %p, cmnd %p\n",
1562 free_slot(slot
, hostdata
);
1563 SCp
->host_scribble
= NULL
;
1564 NCR_700_set_depth(SCp
->device
, 0);
1565 /* NOTE: deadlock potential here: we
1566 * rely on mid-layer guarantees that
1567 * scsi_done won't try to issue the
1568 * command again otherwise we'll
1570 * hostdata->state_lock */
1571 SCp
->result
= DID_RESET
<< 16;
1572 SCp
->scsi_done(SCp
);
1575 NCR_700_chip_setup(host
);
1577 hostdata
->state
= NCR_700_HOST_FREE
;
1578 hostdata
->cmd
= NULL
;
1579 /* signal back if this was an eh induced reset */
1580 if(hostdata
->eh_complete
!= NULL
)
1581 complete(hostdata
->eh_complete
);
1583 } else if(sstat0
& SELECTION_TIMEOUT
) {
1584 DEBUG(("scsi%d: (%d:%d) selection timeout\n",
1585 host
->host_no
, pun
, lun
));
1586 NCR_700_scsi_done(hostdata
, SCp
, DID_NO_CONNECT
<<16);
1587 } else if(sstat0
& PHASE_MISMATCH
) {
1588 struct NCR_700_command_slot
*slot
= (SCp
== NULL
) ? NULL
:
1589 (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1591 if(dsp
== Ent_SendMessage
+ 8 + hostdata
->pScript
) {
1592 /* It wants to reply to some part of
1594 #ifdef NCR_700_DEBUG
1595 __u32 temp
= NCR_700_readl(host
, TEMP_REG
);
1596 int count
= (hostdata
->script
[Ent_SendMessage
/4] & 0xffffff) - ((NCR_700_readl(host
, DBC_REG
) & 0xffffff) + NCR_700_data_residual(host
));
1597 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
)));
1599 resume_offset
= hostdata
->pScript
+ Ent_SendMessagePhaseMismatch
;
1600 } else if(dsp
>= to32bit(&slot
->pSG
[0].ins
) &&
1601 dsp
<= to32bit(&slot
->pSG
[NCR_700_SG_SEGMENTS
].ins
)) {
1602 int data_transfer
= NCR_700_readl(host
, DBC_REG
) & 0xffffff;
1603 int SGcount
= (dsp
- to32bit(&slot
->pSG
[0].ins
))/sizeof(struct NCR_700_SG_List
);
1604 int residual
= NCR_700_data_residual(host
);
1606 #ifdef NCR_700_DEBUG
1607 __u32 naddr
= NCR_700_readl(host
, DNAD_REG
);
1609 printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x\n",
1610 host
->host_no
, pun
, lun
,
1611 SGcount
, data_transfer
);
1612 scsi_print_command(SCp
);
1614 printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %d\n",
1615 host
->host_no
, pun
, lun
,
1616 SGcount
, data_transfer
, residual
);
1619 data_transfer
+= residual
;
1621 if(data_transfer
!= 0) {
1627 count
= (bS_to_cpu(slot
->SG
[SGcount
].ins
) & 0x00ffffff);
1628 DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %d\n", count
, count
-data_transfer
));
1629 slot
->SG
[SGcount
].ins
&= bS_to_host(0xff000000);
1630 slot
->SG
[SGcount
].ins
|= bS_to_host(data_transfer
);
1631 pAddr
= bS_to_cpu(slot
->SG
[SGcount
].pAddr
);
1632 pAddr
+= (count
- data_transfer
);
1633 #ifdef NCR_700_DEBUG
1634 if(pAddr
!= naddr
) {
1635 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
);
1638 slot
->SG
[SGcount
].pAddr
= bS_to_host(pAddr
);
1640 /* set the executed moves to nops */
1641 for(i
=0; i
<SGcount
; i
++) {
1642 slot
->SG
[i
].ins
= bS_to_host(SCRIPT_NOP
);
1643 slot
->SG
[i
].pAddr
= 0;
1645 dma_cache_sync(hostdata
->dev
, slot
->SG
, sizeof(slot
->SG
), DMA_TO_DEVICE
);
1646 /* and pretend we disconnected after
1647 * the command phase */
1648 resume_offset
= hostdata
->pScript
+ Ent_MsgInDuringData
;
1649 /* make sure all the data is flushed */
1650 NCR_700_flush_fifo(host
);
1652 __u8 sbcl
= NCR_700_readb(host
, SBCL_REG
);
1653 printk(KERN_ERR
"scsi%d: (%d:%d) phase mismatch at %04x, phase %s\n",
1654 host
->host_no
, pun
, lun
, dsp
- hostdata
->pScript
, sbcl_to_string(sbcl
));
1655 NCR_700_internal_bus_reset(host
);
1658 } else if(sstat0
& SCSI_GROSS_ERROR
) {
1659 printk(KERN_ERR
"scsi%d: (%d:%d) GROSS ERROR\n",
1660 host
->host_no
, pun
, lun
);
1661 NCR_700_scsi_done(hostdata
, SCp
, DID_ERROR
<<16);
1662 } else if(sstat0
& PARITY_ERROR
) {
1663 printk(KERN_ERR
"scsi%d: (%d:%d) PARITY ERROR\n",
1664 host
->host_no
, pun
, lun
);
1665 NCR_700_scsi_done(hostdata
, SCp
, DID_ERROR
<<16);
1666 } else if(dstat
& SCRIPT_INT_RECEIVED
) {
1667 DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====\n",
1668 host
->host_no
, pun
, lun
));
1669 resume_offset
= process_script_interrupt(dsps
, dsp
, SCp
, host
, hostdata
);
1670 } else if(dstat
& (ILGL_INST_DETECTED
)) {
1671 printk(KERN_ERR
"scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!\n"
1672 " Please email James.Bottomley@HansenPartnership.com with the details\n",
1673 host
->host_no
, pun
, lun
,
1674 dsp
, dsp
- hostdata
->pScript
);
1675 NCR_700_scsi_done(hostdata
, SCp
, DID_ERROR
<<16);
1676 } else if(dstat
& (WATCH_DOG_INTERRUPT
|ABORTED
)) {
1677 printk(KERN_ERR
"scsi%d: (%d:%d) serious DMA problem, dstat=%02x\n",
1678 host
->host_no
, pun
, lun
, dstat
);
1679 NCR_700_scsi_done(hostdata
, SCp
, DID_ERROR
<<16);
1683 /* NOTE: selection interrupt processing MUST occur
1684 * after script interrupt processing to correctly cope
1685 * with the case where we process a disconnect and
1686 * then get reselected before we process the
1688 if(sstat0
& SELECTED
) {
1689 /* FIXME: It currently takes at least FOUR
1690 * interrupts to complete a command that
1691 * disconnects: one for the disconnect, one
1692 * for the reselection, one to get the
1693 * reselection data and one to complete the
1694 * command. If we guess the reselected
1695 * command here and prepare it, we only need
1696 * to get a reselection data interrupt if we
1697 * guessed wrongly. Since the interrupt
1698 * overhead is much greater than the command
1699 * setup, this would be an efficient
1700 * optimisation particularly as we probably
1701 * only have one outstanding command on a
1702 * target most of the time */
1704 resume_offset
= process_selection(host
, dsp
);
1711 if(hostdata
->state
!= NCR_700_HOST_BUSY
) {
1712 printk(KERN_ERR
"scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!\n",
1713 host
->host_no
, resume_offset
, resume_offset
- hostdata
->pScript
);
1714 hostdata
->state
= NCR_700_HOST_BUSY
;
1717 DEBUG(("Attempting to resume at %x\n", resume_offset
));
1718 NCR_700_clear_fifo(host
);
1719 NCR_700_writel(resume_offset
, host
, DSP_REG
);
1721 /* There is probably a technical no-no about this: If we're a
1722 * shared interrupt and we got this interrupt because the
1723 * other device needs servicing not us, we're still going to
1724 * check our queued commands here---of course, there shouldn't
1725 * be any outstanding.... */
1726 if(hostdata
->state
== NCR_700_HOST_FREE
) {
1729 for(i
= 0; i
< NCR_700_COMMAND_SLOTS_PER_HOST
; i
++) {
1730 /* fairness: always run the queue from the last
1731 * position we left off */
1732 int j
= (i
+ hostdata
->saved_slot_position
)
1733 % NCR_700_COMMAND_SLOTS_PER_HOST
;
1735 if(hostdata
->slots
[j
].state
!= NCR_700_SLOT_QUEUED
)
1737 if(NCR_700_start_command(hostdata
->slots
[j
].cmnd
)) {
1738 DEBUG(("scsi%d: Issuing saved command slot %p, cmd %p\t\n",
1739 host
->host_no
, &hostdata
->slots
[j
],
1740 hostdata
->slots
[j
].cmnd
));
1741 hostdata
->saved_slot_position
= j
+ 1;
1748 spin_unlock_irqrestore(host
->host_lock
, flags
);
1749 return IRQ_RETVAL(handled
);
1753 NCR_700_queuecommand_lck(struct scsi_cmnd
*SCp
, void (*done
)(struct scsi_cmnd
*))
1755 struct NCR_700_Host_Parameters
*hostdata
=
1756 (struct NCR_700_Host_Parameters
*)SCp
->device
->host
->hostdata
[0];
1758 enum dma_data_direction direction
;
1759 struct NCR_700_command_slot
*slot
;
1761 if(hostdata
->command_slot_count
>= NCR_700_COMMAND_SLOTS_PER_HOST
) {
1762 /* We're over our allocation, this should never happen
1763 * since we report the max allocation to the mid layer */
1764 printk(KERN_WARNING
"scsi%d: Command depth has gone over queue depth\n", SCp
->device
->host
->host_no
);
1767 /* check for untagged commands. We cannot have any outstanding
1768 * commands if we accept them. Commands could be untagged because:
1770 * - The tag negotiated bitmap is clear
1771 * - The blk layer sent and untagged command
1773 if(NCR_700_get_depth(SCp
->device
) != 0
1774 && (!(hostdata
->tag_negotiated
& (1<<scmd_id(SCp
)))
1775 || !blk_rq_tagged(SCp
->request
))) {
1776 CDEBUG(KERN_ERR
, SCp
, "has non zero depth %d\n",
1777 NCR_700_get_depth(SCp
->device
));
1778 return SCSI_MLQUEUE_DEVICE_BUSY
;
1780 if(NCR_700_get_depth(SCp
->device
) >= SCp
->device
->queue_depth
) {
1781 CDEBUG(KERN_ERR
, SCp
, "has max tag depth %d\n",
1782 NCR_700_get_depth(SCp
->device
));
1783 return SCSI_MLQUEUE_DEVICE_BUSY
;
1785 NCR_700_set_depth(SCp
->device
, NCR_700_get_depth(SCp
->device
) + 1);
1787 /* begin the command here */
1788 /* no need to check for NULL, test for command_slot_count above
1789 * ensures a slot is free */
1790 slot
= find_empty_slot(hostdata
);
1794 SCp
->scsi_done
= done
;
1795 SCp
->host_scribble
= (unsigned char *)slot
;
1796 SCp
->SCp
.ptr
= NULL
;
1797 SCp
->SCp
.buffer
= NULL
;
1799 #ifdef NCR_700_DEBUG
1800 printk("53c700: scsi%d, command ", SCp
->device
->host
->host_no
);
1801 scsi_print_command(SCp
);
1803 if(blk_rq_tagged(SCp
->request
)
1804 && (hostdata
->tag_negotiated
&(1<<scmd_id(SCp
))) == 0
1805 && NCR_700_get_tag_neg_state(SCp
->device
) == NCR_700_START_TAG_NEGOTIATION
) {
1806 scmd_printk(KERN_ERR
, SCp
, "Enabling Tag Command Queuing\n");
1807 hostdata
->tag_negotiated
|= (1<<scmd_id(SCp
));
1808 NCR_700_set_tag_neg_state(SCp
->device
, NCR_700_DURING_TAG_NEGOTIATION
);
1811 /* here we may have to process an untagged command. The gate
1812 * above ensures that this will be the only one outstanding,
1813 * so clear the tag negotiated bit.
1815 * FIXME: This will royally screw up on multiple LUN devices
1817 if(!blk_rq_tagged(SCp
->request
)
1818 && (hostdata
->tag_negotiated
&(1<<scmd_id(SCp
)))) {
1819 scmd_printk(KERN_INFO
, SCp
, "Disabling Tag Command Queuing\n");
1820 hostdata
->tag_negotiated
&= ~(1<<scmd_id(SCp
));
1823 if((hostdata
->tag_negotiated
&(1<<scmd_id(SCp
)))
1824 && scsi_get_tag_type(SCp
->device
)) {
1825 slot
->tag
= SCp
->request
->tag
;
1826 CDEBUG(KERN_DEBUG
, SCp
, "sending out tag %d, slot %p\n",
1829 slot
->tag
= SCSI_NO_TAG
;
1830 /* must populate current_cmnd for scsi_find_tag to work */
1831 SCp
->device
->current_cmnd
= SCp
;
1833 /* sanity check: some of the commands generated by the mid-layer
1834 * have an eccentric idea of their sc_data_direction */
1835 if(!scsi_sg_count(SCp
) && !scsi_bufflen(SCp
) &&
1836 SCp
->sc_data_direction
!= DMA_NONE
) {
1837 #ifdef NCR_700_DEBUG
1838 printk("53c700: Command");
1839 scsi_print_command(SCp
);
1840 printk("Has wrong data direction %d\n", SCp
->sc_data_direction
);
1842 SCp
->sc_data_direction
= DMA_NONE
;
1845 switch (SCp
->cmnd
[0]) {
1847 /* clear the internal sense magic */
1851 /* OK, get it from the command */
1852 switch(SCp
->sc_data_direction
) {
1853 case DMA_BIDIRECTIONAL
:
1855 printk(KERN_ERR
"53c700: Unknown command for data direction ");
1856 scsi_print_command(SCp
);
1863 case DMA_FROM_DEVICE
:
1864 move_ins
= SCRIPT_MOVE_DATA_IN
;
1867 move_ins
= SCRIPT_MOVE_DATA_OUT
;
1872 /* now build the scatter gather list */
1873 direction
= SCp
->sc_data_direction
;
1877 dma_addr_t vPtr
= 0;
1878 struct scatterlist
*sg
;
1881 sg_count
= scsi_dma_map(SCp
);
1882 BUG_ON(sg_count
< 0);
1884 scsi_for_each_sg(SCp
, sg
, sg_count
, i
) {
1885 vPtr
= sg_dma_address(sg
);
1886 count
= sg_dma_len(sg
);
1888 slot
->SG
[i
].ins
= bS_to_host(move_ins
| count
);
1889 DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n",
1890 i
, count
, slot
->SG
[i
].ins
, (unsigned long)vPtr
));
1891 slot
->SG
[i
].pAddr
= bS_to_host(vPtr
);
1893 slot
->SG
[i
].ins
= bS_to_host(SCRIPT_RETURN
);
1894 slot
->SG
[i
].pAddr
= 0;
1895 dma_cache_sync(hostdata
->dev
, slot
->SG
, sizeof(slot
->SG
), DMA_TO_DEVICE
);
1896 DEBUG((" SETTING %08lx to %x\n",
1897 (&slot
->pSG
[i
].ins
),
1900 slot
->resume_offset
= 0;
1901 slot
->pCmd
= dma_map_single(hostdata
->dev
, SCp
->cmnd
,
1902 MAX_COMMAND_SIZE
, DMA_TO_DEVICE
);
1903 NCR_700_start_command(SCp
);
1907 STATIC
DEF_SCSI_QCMD(NCR_700_queuecommand
)
1910 NCR_700_abort(struct scsi_cmnd
* SCp
)
1912 struct NCR_700_command_slot
*slot
;
1914 scmd_printk(KERN_INFO
, SCp
,
1915 "New error handler wants to abort command\n\t");
1916 scsi_print_command(SCp
);
1918 slot
= (struct NCR_700_command_slot
*)SCp
->host_scribble
;
1921 /* no outstanding command to abort */
1923 if(SCp
->cmnd
[0] == TEST_UNIT_READY
) {
1924 /* FIXME: This is because of a problem in the new
1925 * error handler. When it is in error recovery, it
1926 * will send a TUR to a device it thinks may still be
1927 * showing a problem. If the TUR isn't responded to,
1928 * it will abort it and mark the device off line.
1929 * Unfortunately, it does no other error recovery, so
1930 * this would leave us with an outstanding command
1931 * occupying a slot. Rather than allow this to
1932 * happen, we issue a bus reset to force all
1933 * outstanding commands to terminate here. */
1934 NCR_700_internal_bus_reset(SCp
->device
->host
);
1935 /* still drop through and return failed */
1942 NCR_700_bus_reset(struct scsi_cmnd
* SCp
)
1944 DECLARE_COMPLETION_ONSTACK(complete
);
1945 struct NCR_700_Host_Parameters
*hostdata
=
1946 (struct NCR_700_Host_Parameters
*)SCp
->device
->host
->hostdata
[0];
1948 scmd_printk(KERN_INFO
, SCp
,
1949 "New error handler wants BUS reset, cmd %p\n\t", SCp
);
1950 scsi_print_command(SCp
);
1952 /* In theory, eh_complete should always be null because the
1953 * eh is single threaded, but just in case we're handling a
1954 * reset via sg or something */
1955 spin_lock_irq(SCp
->device
->host
->host_lock
);
1956 while (hostdata
->eh_complete
!= NULL
) {
1957 spin_unlock_irq(SCp
->device
->host
->host_lock
);
1958 msleep_interruptible(100);
1959 spin_lock_irq(SCp
->device
->host
->host_lock
);
1962 hostdata
->eh_complete
= &complete
;
1963 NCR_700_internal_bus_reset(SCp
->device
->host
);
1965 spin_unlock_irq(SCp
->device
->host
->host_lock
);
1966 wait_for_completion(&complete
);
1967 spin_lock_irq(SCp
->device
->host
->host_lock
);
1969 hostdata
->eh_complete
= NULL
;
1970 /* Revalidate the transport parameters of the failing device */
1972 spi_schedule_dv_device(SCp
->device
);
1974 spin_unlock_irq(SCp
->device
->host
->host_lock
);
1979 NCR_700_host_reset(struct scsi_cmnd
* SCp
)
1981 scmd_printk(KERN_INFO
, SCp
, "New error handler wants HOST reset\n\t");
1982 scsi_print_command(SCp
);
1984 spin_lock_irq(SCp
->device
->host
->host_lock
);
1986 NCR_700_internal_bus_reset(SCp
->device
->host
);
1987 NCR_700_chip_reset(SCp
->device
->host
);
1989 spin_unlock_irq(SCp
->device
->host
->host_lock
);
1995 NCR_700_set_period(struct scsi_target
*STp
, int period
)
1997 struct Scsi_Host
*SHp
= dev_to_shost(STp
->dev
.parent
);
1998 struct NCR_700_Host_Parameters
*hostdata
=
1999 (struct NCR_700_Host_Parameters
*)SHp
->hostdata
[0];
2004 if(period
< hostdata
->min_period
)
2005 period
= hostdata
->min_period
;
2007 spi_period(STp
) = period
;
2008 spi_flags(STp
) &= ~(NCR_700_DEV_NEGOTIATED_SYNC
|
2009 NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
);
2010 spi_flags(STp
) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION
;
2014 NCR_700_set_offset(struct scsi_target
*STp
, int offset
)
2016 struct Scsi_Host
*SHp
= dev_to_shost(STp
->dev
.parent
);
2017 struct NCR_700_Host_Parameters
*hostdata
=
2018 (struct NCR_700_Host_Parameters
*)SHp
->hostdata
[0];
2019 int max_offset
= hostdata
->chip710
2020 ? NCR_710_MAX_OFFSET
: NCR_700_MAX_OFFSET
;
2025 if(offset
> max_offset
)
2026 offset
= max_offset
;
2028 /* if we're currently async, make sure the period is reasonable */
2029 if(spi_offset(STp
) == 0 && (spi_period(STp
) < hostdata
->min_period
||
2030 spi_period(STp
) > 0xff))
2031 spi_period(STp
) = hostdata
->min_period
;
2033 spi_offset(STp
) = offset
;
2034 spi_flags(STp
) &= ~(NCR_700_DEV_NEGOTIATED_SYNC
|
2035 NCR_700_DEV_BEGIN_SYNC_NEGOTIATION
);
2036 spi_flags(STp
) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION
;
2040 NCR_700_slave_alloc(struct scsi_device
*SDp
)
2042 SDp
->hostdata
= kzalloc(sizeof(struct NCR_700_Device_Parameters
),
2052 NCR_700_slave_configure(struct scsi_device
*SDp
)
2054 struct NCR_700_Host_Parameters
*hostdata
=
2055 (struct NCR_700_Host_Parameters
*)SDp
->host
->hostdata
[0];
2057 /* to do here: allocate memory; build a queue_full list */
2058 if(SDp
->tagged_supported
) {
2059 scsi_set_tag_type(SDp
, MSG_ORDERED_TAG
);
2060 scsi_activate_tcq(SDp
, NCR_700_DEFAULT_TAGS
);
2061 NCR_700_set_tag_neg_state(SDp
, NCR_700_START_TAG_NEGOTIATION
);
2063 /* initialise to default depth */
2064 scsi_adjust_queue_depth(SDp
, 0, SDp
->host
->cmd_per_lun
);
2066 if(hostdata
->fast
) {
2067 /* Find the correct offset and period via domain validation */
2068 if (!spi_initial_dv(SDp
->sdev_target
))
2071 spi_offset(SDp
->sdev_target
) = 0;
2072 spi_period(SDp
->sdev_target
) = 0;
2078 NCR_700_slave_destroy(struct scsi_device
*SDp
)
2080 kfree(SDp
->hostdata
);
2081 SDp
->hostdata
= NULL
;
2085 NCR_700_change_queue_depth(struct scsi_device
*SDp
, int depth
, int reason
)
2087 if (reason
!= SCSI_QDEPTH_DEFAULT
)
2090 if (depth
> NCR_700_MAX_TAGS
)
2091 depth
= NCR_700_MAX_TAGS
;
2093 scsi_adjust_queue_depth(SDp
, scsi_get_tag_type(SDp
), depth
);
2097 static int NCR_700_change_queue_type(struct scsi_device
*SDp
, int tag_type
)
2099 int change_tag
= ((tag_type
==0 && scsi_get_tag_type(SDp
) != 0)
2100 || (tag_type
!= 0 && scsi_get_tag_type(SDp
) == 0));
2101 struct NCR_700_Host_Parameters
*hostdata
=
2102 (struct NCR_700_Host_Parameters
*)SDp
->host
->hostdata
[0];
2104 scsi_set_tag_type(SDp
, tag_type
);
2106 /* We have a global (per target) flag to track whether TCQ is
2107 * enabled, so we'll be turning it off for the entire target here.
2108 * our tag algorithm will fail if we mix tagged and untagged commands,
2109 * so quiesce the device before doing this */
2111 scsi_target_quiesce(SDp
->sdev_target
);
2114 /* shift back to the default unqueued number of commands
2115 * (the user can still raise this) */
2116 scsi_deactivate_tcq(SDp
, SDp
->host
->cmd_per_lun
);
2117 hostdata
->tag_negotiated
&= ~(1 << sdev_id(SDp
));
2119 /* Here, we cleared the negotiation flag above, so this
2120 * will force the driver to renegotiate */
2121 scsi_activate_tcq(SDp
, SDp
->queue_depth
);
2123 NCR_700_set_tag_neg_state(SDp
, NCR_700_START_TAG_NEGOTIATION
);
2126 scsi_target_resume(SDp
->sdev_target
);
2132 NCR_700_show_active_tags(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
2134 struct scsi_device
*SDp
= to_scsi_device(dev
);
2136 return snprintf(buf
, 20, "%d\n", NCR_700_get_depth(SDp
));
2139 static struct device_attribute NCR_700_active_tags_attr
= {
2141 .name
= "active_tags",
2144 .show
= NCR_700_show_active_tags
,
2147 STATIC
struct device_attribute
*NCR_700_dev_attrs
[] = {
2148 &NCR_700_active_tags_attr
,
2152 EXPORT_SYMBOL(NCR_700_detect
);
2153 EXPORT_SYMBOL(NCR_700_release
);
2154 EXPORT_SYMBOL(NCR_700_intr
);
2156 static struct spi_function_template NCR_700_transport_functions
= {
2157 .set_period
= NCR_700_set_period
,
2159 .set_offset
= NCR_700_set_offset
,
2163 static int __init
NCR_700_init(void)
2165 NCR_700_transport_template
= spi_attach_transport(&NCR_700_transport_functions
);
2166 if(!NCR_700_transport_template
)
2171 static void __exit
NCR_700_exit(void)
2173 spi_release_transport(NCR_700_transport_template
);
2176 module_init(NCR_700_init
);
2177 module_exit(NCR_700_exit
);