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