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