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