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