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