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