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