aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRoman Zippel <zippel@linux-m68k.org>2007-05-01 16:32:36 -0400
committerLinus Torvalds <torvalds@woody.linux-foundation.org>2007-05-04 20:59:05 -0400
commitc28bda25175913c88396b643813321ef9cffe663 (patch)
tree0245b5b6fdd5914b68574359a8f1b10a8896c501
parentfb810d121bceb945c5e576356bccba11cbfad7e3 (diff)
m68k: Reformat the Atari SCSI driver
Reformat the Atari SCSI driver Signed-off-by: Roman Zippel <zippel@linux-m68k.org> Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat
-rw-r--r--drivers/scsi/atari_NCR5380.c4387
-rw-r--r--drivers/scsi/atari_scsi.c361
2 files changed, 2373 insertions, 2375 deletions
diff --git a/drivers/scsi/atari_NCR5380.c b/drivers/scsi/atari_NCR5380.c
index 1b4612c71ce2..81e4f566b6c8 100644
--- a/drivers/scsi/atari_NCR5380.c
+++ b/drivers/scsi/atari_NCR5380.c
@@ -1,19 +1,19 @@
1/* 1/*
2 * NCR 5380 generic driver routines. These should make it *trivial* 2 * NCR 5380 generic driver routines. These should make it *trivial*
3 * to implement 5380 SCSI drivers under Linux with a non-trantor 3 * to implement 5380 SCSI drivers under Linux with a non-trantor
4 * architecture. 4 * architecture.
5 * 5 *
6 * Note that these routines also work with NR53c400 family chips. 6 * Note that these routines also work with NR53c400 family chips.
7 * 7 *
8 * Copyright 1993, Drew Eckhardt 8 * Copyright 1993, Drew Eckhardt
9 * Visionary Computing 9 * Visionary Computing
10 * (Unix and Linux consulting and custom programming) 10 * (Unix and Linux consulting and custom programming)
11 * drew@colorado.edu 11 * drew@colorado.edu
12 * +1 (303) 666-5836 12 * +1 (303) 666-5836
13 * 13 *
14 * DISTRIBUTION RELEASE 6. 14 * DISTRIBUTION RELEASE 6.
15 * 15 *
16 * For more information, please consult 16 * For more information, please consult
17 * 17 *
18 * NCR 5380 Family 18 * NCR 5380 Family
19 * SCSI Protocol Controller 19 * SCSI Protocol Controller
@@ -57,7 +57,7 @@
57 * - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA 57 * - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA
58 * and USLEEP, because these were messing up readability and will never be 58 * and USLEEP, because these were messing up readability and will never be
59 * needed for Atari SCSI. 59 * needed for Atari SCSI.
60 * 60 *
61 * - I've revised the NCR5380_main() calling scheme (relax the 'main_running' 61 * - I've revised the NCR5380_main() calling scheme (relax the 'main_running'
62 * stuff), and 'main' is executed in a bottom half if awoken by an 62 * stuff), and 'main' is executed in a bottom half if awoken by an
63 * interrupt. 63 * interrupt.
@@ -69,21 +69,29 @@
69 */ 69 */
70 70
71/* 71/*
72 * Further development / testing that should be done : 72 * Further development / testing that should be done :
73 * 1. Test linked command handling code after Eric is ready with 73 * 1. Test linked command handling code after Eric is ready with
74 * the high level code. 74 * the high level code.
75 */ 75 */
76#include <scsi/scsi_dbg.h> 76#include <scsi/scsi_dbg.h>
77#include <scsi/scsi_transport_spi.h> 77#include <scsi/scsi_transport_spi.h>
78 78
79#if (NDEBUG & NDEBUG_LISTS) 79#if (NDEBUG & NDEBUG_LISTS)
80#define LIST(x,y) \ 80#define LIST(x, y) \
81 { printk("LINE:%d Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); \ 81 do { \
82 if ((x)==(y)) udelay(5); } 82 printk("LINE:%d Adding %p to %p\n", \
83#define REMOVE(w,x,y,z) \ 83 __LINE__, (void*)(x), (void*)(y)); \
84 { printk("LINE:%d Removing: %p->%p %p->%p \n", __LINE__, \ 84 if ((x) == (y)) \
85 (void*)(w), (void*)(x), (void*)(y), (void*)(z)); \ 85 udelay(5); \
86 if ((x)==(y)) udelay(5); } 86 } while (0)
87#define REMOVE(w, x, y, z) \
88 do { \
89 printk("LINE:%d Removing: %p->%p %p->%p \n", \
90 __LINE__, (void*)(w), (void*)(x), \
91 (void*)(y), (void*)(z)); \
92 if ((x) == (y)) \
93 udelay(5); \
94 } while (0)
87#else 95#else
88#define LIST(x,y) 96#define LIST(x,y)
89#define REMOVE(w,x,y,z) 97#define REMOVE(w,x,y,z)
@@ -103,62 +111,62 @@
103 * more difficult than it has to be. 111 * more difficult than it has to be.
104 * 112 *
105 * Also, many of the SCSI drivers were written before the command queuing 113 * Also, many of the SCSI drivers were written before the command queuing
106 * routines were implemented, meaning their implementations of queued 114 * routines were implemented, meaning their implementations of queued
107 * commands were hacked on rather than designed in from the start. 115 * commands were hacked on rather than designed in from the start.
108 * 116 *
109 * When I designed the Linux SCSI drivers I figured that 117 * When I designed the Linux SCSI drivers I figured that
110 * while having two different SCSI boards in a system might be useful 118 * while having two different SCSI boards in a system might be useful
111 * for debugging things, two of the same type wouldn't be used. 119 * for debugging things, two of the same type wouldn't be used.
112 * Well, I was wrong and a number of users have mailed me about running 120 * Well, I was wrong and a number of users have mailed me about running
113 * multiple high-performance SCSI boards in a server. 121 * multiple high-performance SCSI boards in a server.
114 * 122 *
115 * Finally, when I get questions from users, I have no idea what 123 * Finally, when I get questions from users, I have no idea what
116 * revision of my driver they are running. 124 * revision of my driver they are running.
117 * 125 *
118 * This driver attempts to address these problems : 126 * This driver attempts to address these problems :
119 * This is a generic 5380 driver. To use it on a different platform, 127 * This is a generic 5380 driver. To use it on a different platform,
120 * one simply writes appropriate system specific macros (ie, data 128 * one simply writes appropriate system specific macros (ie, data
121 * transfer - some PC's will use the I/O bus, 68K's must use 129 * transfer - some PC's will use the I/O bus, 68K's must use
122 * memory mapped) and drops this file in their 'C' wrapper. 130 * memory mapped) and drops this file in their 'C' wrapper.
123 * 131 *
124 * As far as command queueing, two queues are maintained for 132 * As far as command queueing, two queues are maintained for
125 * each 5380 in the system - commands that haven't been issued yet, 133 * each 5380 in the system - commands that haven't been issued yet,
126 * and commands that are currently executing. This means that an 134 * and commands that are currently executing. This means that an
127 * unlimited number of commands may be queued, letting 135 * unlimited number of commands may be queued, letting
128 * more commands propagate from the higher driver levels giving higher 136 * more commands propagate from the higher driver levels giving higher
129 * throughput. Note that both I_T_L and I_T_L_Q nexuses are supported, 137 * throughput. Note that both I_T_L and I_T_L_Q nexuses are supported,
130 * allowing multiple commands to propagate all the way to a SCSI-II device 138 * allowing multiple commands to propagate all the way to a SCSI-II device
131 * while a command is already executing. 139 * while a command is already executing.
132 * 140 *
133 * To solve the multiple-boards-in-the-same-system problem, 141 * To solve the multiple-boards-in-the-same-system problem,
134 * there is a separate instance structure for each instance 142 * there is a separate instance structure for each instance
135 * of a 5380 in the system. So, multiple NCR5380 drivers will 143 * of a 5380 in the system. So, multiple NCR5380 drivers will
136 * be able to coexist with appropriate changes to the high level 144 * be able to coexist with appropriate changes to the high level
137 * SCSI code. 145 * SCSI code.
138 * 146 *
139 * A NCR5380_PUBLIC_REVISION macro is provided, with the release 147 * A NCR5380_PUBLIC_REVISION macro is provided, with the release
140 * number (updated for each public release) printed by the 148 * number (updated for each public release) printed by the
141 * NCR5380_print_options command, which should be called from the 149 * NCR5380_print_options command, which should be called from the
142 * wrapper detect function, so that I know what release of the driver 150 * wrapper detect function, so that I know what release of the driver
143 * users are using. 151 * users are using.
144 * 152 *
145 * Issues specific to the NCR5380 : 153 * Issues specific to the NCR5380 :
146 * 154 *
147 * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead 155 * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
148 * piece of hardware that requires you to sit in a loop polling for 156 * piece of hardware that requires you to sit in a loop polling for
149 * the REQ signal as long as you are connected. Some devices are 157 * the REQ signal as long as you are connected. Some devices are
150 * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect 158 * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
151 * while doing long seek operations. 159 * while doing long seek operations.
152 * 160 *
153 * The workaround for this is to keep track of devices that have 161 * The workaround for this is to keep track of devices that have
154 * disconnected. If the device hasn't disconnected, for commands that 162 * disconnected. If the device hasn't disconnected, for commands that
155 * should disconnect, we do something like 163 * should disconnect, we do something like
156 * 164 *
157 * while (!REQ is asserted) { sleep for N usecs; poll for M usecs } 165 * while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
158 * 166 *
159 * Some tweaking of N and M needs to be done. An algorithm based 167 * Some tweaking of N and M needs to be done. An algorithm based
160 * on "time to data" would give the best results as long as short time 168 * on "time to data" would give the best results as long as short time
161 * to datas (ie, on the same track) were considered, however these 169 * to datas (ie, on the same track) were considered, however these
162 * broken devices are the exception rather than the rule and I'd rather 170 * broken devices are the exception rather than the rule and I'd rather
163 * spend my time optimizing for the normal case. 171 * spend my time optimizing for the normal case.
164 * 172 *
@@ -167,9 +175,9 @@
167 * At the heart of the design is a coroutine, NCR5380_main, 175 * At the heart of the design is a coroutine, NCR5380_main,
168 * which is started when not running by the interrupt handler, 176 * which is started when not running by the interrupt handler,
169 * timer, and queue command function. It attempts to establish 177 * timer, and queue command function. It attempts to establish
170 * I_T_L or I_T_L_Q nexuses by removing the commands from the 178 * I_T_L or I_T_L_Q nexuses by removing the commands from the
171 * issue queue and calling NCR5380_select() if a nexus 179 * issue queue and calling NCR5380_select() if a nexus
172 * is not established. 180 * is not established.
173 * 181 *
174 * Once a nexus is established, the NCR5380_information_transfer() 182 * Once a nexus is established, the NCR5380_information_transfer()
175 * phase goes through the various phases as instructed by the target. 183 * phase goes through the various phases as instructed by the target.
@@ -183,10 +191,10 @@
183 * calling NCR5380_intr() which will in turn call NCR5380_reselect 191 * calling NCR5380_intr() which will in turn call NCR5380_reselect
184 * to reestablish a nexus. This will run main if necessary. 192 * to reestablish a nexus. This will run main if necessary.
185 * 193 *
186 * On command termination, the done function will be called as 194 * On command termination, the done function will be called as
187 * appropriate. 195 * appropriate.
188 * 196 *
189 * SCSI pointers are maintained in the SCp field of SCSI command 197 * SCSI pointers are maintained in the SCp field of SCSI command
190 * structures, being initialized after the command is connected 198 * structures, being initialized after the command is connected
191 * in NCR5380_select, and set as appropriate in NCR5380_information_transfer. 199 * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
192 * Note that in violation of the standard, an implicit SAVE POINTERS operation 200 * Note that in violation of the standard, an implicit SAVE POINTERS operation
@@ -196,12 +204,12 @@
196/* 204/*
197 * Using this file : 205 * Using this file :
198 * This file a skeleton Linux SCSI driver for the NCR 5380 series 206 * This file a skeleton Linux SCSI driver for the NCR 5380 series
199 * of chips. To use it, you write an architecture specific functions 207 * of chips. To use it, you write an architecture specific functions
200 * and macros and include this file in your driver. 208 * and macros and include this file in your driver.
201 * 209 *
202 * These macros control options : 210 * These macros control options :
203 * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically 211 * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
204 * for commands that return with a CHECK CONDITION status. 212 * for commands that return with a CHECK CONDITION status.
205 * 213 *
206 * LINKED - if defined, linked commands are supported. 214 * LINKED - if defined, linked commands are supported.
207 * 215 *
@@ -210,18 +218,18 @@
210 * SUPPORT_TAGS - if defined, SCSI-2 tagged queuing is used where possible 218 * SUPPORT_TAGS - if defined, SCSI-2 tagged queuing is used where possible
211 * 219 *
212 * These macros MUST be defined : 220 * These macros MUST be defined :
213 * 221 *
214 * NCR5380_read(register) - read from the specified register 222 * NCR5380_read(register) - read from the specified register
215 * 223 *
216 * NCR5380_write(register, value) - write to the specific register 224 * NCR5380_write(register, value) - write to the specific register
217 * 225 *
218 * Either real DMA *or* pseudo DMA may be implemented 226 * Either real DMA *or* pseudo DMA may be implemented
219 * REAL functions : 227 * REAL functions :
220 * NCR5380_REAL_DMA should be defined if real DMA is to be used. 228 * NCR5380_REAL_DMA should be defined if real DMA is to be used.
221 * Note that the DMA setup functions should return the number of bytes 229 * Note that the DMA setup functions should return the number of bytes
222 * that they were able to program the controller for. 230 * that they were able to program the controller for.
223 * 231 *
224 * Also note that generic i386/PC versions of these macros are 232 * Also note that generic i386/PC versions of these macros are
225 * available as NCR5380_i386_dma_write_setup, 233 * available as NCR5380_i386_dma_write_setup,
226 * NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual. 234 * NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
227 * 235 *
@@ -234,14 +242,14 @@
234 * NCR5380_pread(instance, dst, count); 242 * NCR5380_pread(instance, dst, count);
235 * 243 *
236 * If nothing specific to this implementation needs doing (ie, with external 244 * If nothing specific to this implementation needs doing (ie, with external
237 * hardware), you must also define 245 * hardware), you must also define
238 * 246 *
239 * NCR5380_queue_command 247 * NCR5380_queue_command
240 * NCR5380_reset 248 * NCR5380_reset
241 * NCR5380_abort 249 * NCR5380_abort
242 * NCR5380_proc_info 250 * NCR5380_proc_info
243 * 251 *
244 * to be the global entry points into the specific driver, ie 252 * to be the global entry points into the specific driver, ie
245 * #define NCR5380_queue_command t128_queue_command. 253 * #define NCR5380_queue_command t128_queue_command.
246 * 254 *
247 * If this is not done, the routines will be defined as static functions 255 * If this is not done, the routines will be defined as static functions
@@ -249,7 +257,7 @@
249 * accessible wrapper function. 257 * accessible wrapper function.
250 * 258 *
251 * The generic driver is initialized by calling NCR5380_init(instance), 259 * The generic driver is initialized by calling NCR5380_init(instance),
252 * after setting the appropriate host specific fields and ID. If the 260 * after setting the appropriate host specific fields and ID. If the
253 * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance, 261 * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
254 * possible) function may be used. Before the specific driver initialization 262 * possible) function may be used. Before the specific driver initialization
255 * code finishes, NCR5380_print_options should be called. 263 * code finishes, NCR5380_print_options should be called.
@@ -312,34 +320,34 @@ static struct scsi_host_template *the_template = NULL;
312#define TAG_NONE 0xff 320#define TAG_NONE 0xff
313 321
314typedef struct { 322typedef struct {
315 DECLARE_BITMAP(allocated, MAX_TAGS); 323 DECLARE_BITMAP(allocated, MAX_TAGS);
316 int nr_allocated; 324 int nr_allocated;
317 int queue_size; 325 int queue_size;
318} TAG_ALLOC; 326} TAG_ALLOC;
319 327
320static TAG_ALLOC TagAlloc[8][8]; /* 8 targets and 8 LUNs */ 328static TAG_ALLOC TagAlloc[8][8]; /* 8 targets and 8 LUNs */
321 329
322 330
323static void __init init_tags( void ) 331static void __init init_tags(void)
324{ 332{
325 int target, lun; 333 int target, lun;
326 TAG_ALLOC *ta; 334 TAG_ALLOC *ta;
327 335
328 if (!setup_use_tagged_queuing) 336 if (!setup_use_tagged_queuing)
329 return; 337 return;
330 338
331 for( target = 0; target < 8; ++target ) { 339 for (target = 0; target < 8; ++target) {
332 for( lun = 0; lun < 8; ++lun ) { 340 for (lun = 0; lun < 8; ++lun) {
333 ta = &TagAlloc[target][lun]; 341 ta = &TagAlloc[target][lun];
334 bitmap_zero(ta->allocated, MAX_TAGS); 342 bitmap_zero(ta->allocated, MAX_TAGS);
335 ta->nr_allocated = 0; 343 ta->nr_allocated = 0;
336 /* At the beginning, assume the maximum queue size we could 344 /* At the beginning, assume the maximum queue size we could
337 * support (MAX_TAGS). This value will be decreased if the target 345 * support (MAX_TAGS). This value will be decreased if the target
338 * returns QUEUE_FULL status. 346 * returns QUEUE_FULL status.
339 */ 347 */
340 ta->queue_size = MAX_TAGS; 348 ta->queue_size = MAX_TAGS;
349 }
341 } 350 }
342 }
343} 351}
344 352
345 353
@@ -348,24 +356,24 @@ static void __init init_tags( void )
348 * check that there is a free tag and the target's queue won't overflow. This 356 * check that there is a free tag and the target's queue won't overflow. This
349 * function should be called with interrupts disabled to avoid race 357 * function should be called with interrupts disabled to avoid race
350 * conditions. 358 * conditions.
351 */ 359 */
352 360
353static int is_lun_busy( Scsi_Cmnd *cmd, int should_be_tagged ) 361static int is_lun_busy(Scsi_Cmnd *cmd, int should_be_tagged)
354{ 362{
355 SETUP_HOSTDATA(cmd->device->host); 363 SETUP_HOSTDATA(cmd->device->host);
356 364
357 if (hostdata->busy[cmd->device->id] & (1 << cmd->device->lun)) 365 if (hostdata->busy[cmd->device->id] & (1 << cmd->device->lun))
358 return( 1 ); 366 return 1;
359 if (!should_be_tagged || 367 if (!should_be_tagged ||
360 !setup_use_tagged_queuing || !cmd->device->tagged_supported) 368 !setup_use_tagged_queuing || !cmd->device->tagged_supported)
361 return( 0 ); 369 return 0;
362 if (TagAlloc[cmd->device->id][cmd->device->lun].nr_allocated >= 370 if (TagAlloc[cmd->device->id][cmd->device->lun].nr_allocated >=
363 TagAlloc[cmd->device->id][cmd->device->lun].queue_size ) { 371 TagAlloc[cmd->device->id][cmd->device->lun].queue_size) {
364 TAG_PRINTK( "scsi%d: target %d lun %d: no free tags\n", 372 TAG_PRINTK("scsi%d: target %d lun %d: no free tags\n",
365 H_NO(cmd), cmd->device->id, cmd->device->lun ); 373 H_NO(cmd), cmd->device->id, cmd->device->lun);
366 return( 1 ); 374 return 1;
367 } 375 }
368 return( 0 ); 376 return 0;
369} 377}
370 378
371 379
@@ -374,31 +382,30 @@ static int is_lun_busy( Scsi_Cmnd *cmd, int should_be_tagged )
374 * untagged. 382 * untagged.
375 */ 383 */
376 384
377static void cmd_get_tag( Scsi_Cmnd *cmd, int should_be_tagged ) 385static void cmd_get_tag(Scsi_Cmnd *cmd, int should_be_tagged)
378{ 386{
379 SETUP_HOSTDATA(cmd->device->host); 387 SETUP_HOSTDATA(cmd->device->host);
380 388
381 /* If we or the target don't support tagged queuing, allocate the LUN for 389 /* If we or the target don't support tagged queuing, allocate the LUN for
382 * an untagged command. 390 * an untagged command.
383 */ 391 */
384 if (!should_be_tagged || 392 if (!should_be_tagged ||
385 !setup_use_tagged_queuing || !cmd->device->tagged_supported) { 393 !setup_use_tagged_queuing || !cmd->device->tagged_supported) {
386 cmd->tag = TAG_NONE; 394 cmd->tag = TAG_NONE;
387 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun); 395 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
388 TAG_PRINTK( "scsi%d: target %d lun %d now allocated by untagged " 396 TAG_PRINTK("scsi%d: target %d lun %d now allocated by untagged "
389 "command\n", H_NO(cmd), cmd->device->id, cmd->device->lun ); 397 "command\n", H_NO(cmd), cmd->device->id, cmd->device->lun);
390 } 398 } else {
391 else { 399 TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
392 TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun]; 400
393 401 cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
394 cmd->tag = find_first_zero_bit( ta->allocated, MAX_TAGS ); 402 set_bit(cmd->tag, ta->allocated);
395 set_bit( cmd->tag, ta->allocated ); 403 ta->nr_allocated++;
396 ta->nr_allocated++; 404 TAG_PRINTK("scsi%d: using tag %d for target %d lun %d "
397 TAG_PRINTK( "scsi%d: using tag %d for target %d lun %d " 405 "(now %d tags in use)\n",
398 "(now %d tags in use)\n", 406 H_NO(cmd), cmd->tag, cmd->device->id,
399 H_NO(cmd), cmd->tag, cmd->device->id, cmd->device->lun, 407 cmd->device->lun, ta->nr_allocated);
400 ta->nr_allocated ); 408 }
401 }
402} 409}
403 410
404 411
@@ -406,44 +413,42 @@ static void cmd_get_tag( Scsi_Cmnd *cmd, int should_be_tagged )
406 * unlock the LUN. 413 * unlock the LUN.
407 */ 414 */
408 415
409static void cmd_free_tag( Scsi_Cmnd *cmd ) 416static void cmd_free_tag(Scsi_Cmnd *cmd)
410{ 417{
411 SETUP_HOSTDATA(cmd->device->host); 418 SETUP_HOSTDATA(cmd->device->host);
412 419
413 if (cmd->tag == TAG_NONE) { 420 if (cmd->tag == TAG_NONE) {
414 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 421 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
415 TAG_PRINTK( "scsi%d: target %d lun %d untagged cmd finished\n", 422 TAG_PRINTK("scsi%d: target %d lun %d untagged cmd finished\n",
416 H_NO(cmd), cmd->device->id, cmd->device->lun ); 423 H_NO(cmd), cmd->device->id, cmd->device->lun);
417 } 424 } else if (cmd->tag >= MAX_TAGS) {
418 else if (cmd->tag >= MAX_TAGS) { 425 printk(KERN_NOTICE "scsi%d: trying to free bad tag %d!\n",
419 printk(KERN_NOTICE "scsi%d: trying to free bad tag %d!\n", 426 H_NO(cmd), cmd->tag);
420 H_NO(cmd), cmd->tag ); 427 } else {
421 } 428 TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
422 else { 429 clear_bit(cmd->tag, ta->allocated);
423 TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun]; 430 ta->nr_allocated--;
424 clear_bit( cmd->tag, ta->allocated ); 431 TAG_PRINTK("scsi%d: freed tag %d for target %d lun %d\n",
425 ta->nr_allocated--; 432 H_NO(cmd), cmd->tag, cmd->device->id, cmd->device->lun);
426 TAG_PRINTK( "scsi%d: freed tag %d for target %d lun %d\n", 433 }
427 H_NO(cmd), cmd->tag, cmd->device->id, cmd->device->lun );
428 }
429} 434}
430 435
431 436
432static void free_all_tags( void ) 437static void free_all_tags(void)
433{ 438{
434 int target, lun; 439 int target, lun;
435 TAG_ALLOC *ta; 440 TAG_ALLOC *ta;
436 441
437 if (!setup_use_tagged_queuing) 442 if (!setup_use_tagged_queuing)
438 return; 443 return;
439 444
440 for( target = 0; target < 8; ++target ) { 445 for (target = 0; target < 8; ++target) {
441 for( lun = 0; lun < 8; ++lun ) { 446 for (lun = 0; lun < 8; ++lun) {
442 ta = &TagAlloc[target][lun]; 447 ta = &TagAlloc[target][lun];
443 bitmap_zero(ta->allocated, MAX_TAGS); 448 bitmap_zero(ta->allocated, MAX_TAGS);
444 ta->nr_allocated = 0; 449 ta->nr_allocated = 0;
450 }
445 } 451 }
446 }
447} 452}
448 453
449#endif /* SUPPORT_TAGS */ 454#endif /* SUPPORT_TAGS */
@@ -461,89 +466,94 @@ static void free_all_tags( void )
461 * assumed to be already transfered into ptr/this_residual. 466 * assumed to be already transfered into ptr/this_residual.
462 */ 467 */
463 468
464static void merge_contiguous_buffers( Scsi_Cmnd *cmd ) 469static void merge_contiguous_buffers(Scsi_Cmnd *cmd)
465{ 470{
466 unsigned long endaddr; 471 unsigned long endaddr;
467#if (NDEBUG & NDEBUG_MERGING) 472#if (NDEBUG & NDEBUG_MERGING)
468 unsigned long oldlen = cmd->SCp.this_residual; 473 unsigned long oldlen = cmd->SCp.this_residual;
469 int cnt = 1; 474 int cnt = 1;
470#endif 475#endif
471 476
472 for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1; 477 for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1;
473 cmd->SCp.buffers_residual && 478 cmd->SCp.buffers_residual &&
474 virt_to_phys(page_address(cmd->SCp.buffer[1].page)+ 479 virt_to_phys(page_address(cmd->SCp.buffer[1].page) +
475 cmd->SCp.buffer[1].offset) == endaddr; ) { 480 cmd->SCp.buffer[1].offset) == endaddr;) {
476 MER_PRINTK("VTOP(%p) == %08lx -> merging\n", 481 MER_PRINTK("VTOP(%p) == %08lx -> merging\n",
477 cmd->SCp.buffer[1].address, endaddr); 482 cmd->SCp.buffer[1].address, endaddr);
478#if (NDEBUG & NDEBUG_MERGING) 483#if (NDEBUG & NDEBUG_MERGING)
479 ++cnt; 484 ++cnt;
480#endif 485#endif
481 ++cmd->SCp.buffer; 486 ++cmd->SCp.buffer;
482 --cmd->SCp.buffers_residual; 487 --cmd->SCp.buffers_residual;
483 cmd->SCp.this_residual += cmd->SCp.buffer->length; 488 cmd->SCp.this_residual += cmd->SCp.buffer->length;
484 endaddr += cmd->SCp.buffer->length; 489 endaddr += cmd->SCp.buffer->length;
485 } 490 }
486#if (NDEBUG & NDEBUG_MERGING) 491#if (NDEBUG & NDEBUG_MERGING)
487 if (oldlen != cmd->SCp.this_residual) 492 if (oldlen != cmd->SCp.this_residual)
488 MER_PRINTK("merged %d buffers from %p, new length %08x\n", 493 MER_PRINTK("merged %d buffers from %p, new length %08x\n",
489 cnt, cmd->SCp.ptr, cmd->SCp.this_residual); 494 cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
490#endif 495#endif
491} 496}
492 497
493/* 498/*
494 * Function : void initialize_SCp(Scsi_Cmnd *cmd) 499 * Function : void initialize_SCp(Scsi_Cmnd *cmd)
495 * 500 *
496 * Purpose : initialize the saved data pointers for cmd to point to the 501 * Purpose : initialize the saved data pointers for cmd to point to the
497 * start of the buffer. 502 * start of the buffer.
498 * 503 *
499 * Inputs : cmd - Scsi_Cmnd structure to have pointers reset. 504 * Inputs : cmd - Scsi_Cmnd structure to have pointers reset.
500 */ 505 */
501 506
502static __inline__ void initialize_SCp(Scsi_Cmnd *cmd) 507static inline void initialize_SCp(Scsi_Cmnd *cmd)
503{ 508{
504 /* 509 /*
505 * Initialize the Scsi Pointer field so that all of the commands in the 510 * Initialize the Scsi Pointer field so that all of the commands in the
506 * various queues are valid. 511 * various queues are valid.
507 */
508
509 if (cmd->use_sg) {
510 cmd->SCp.buffer = (struct scatterlist *) cmd->request_buffer;
511 cmd->SCp.buffers_residual = cmd->use_sg - 1;
512 cmd->SCp.ptr = (char *)page_address(cmd->SCp.buffer->page)+
513 cmd->SCp.buffer->offset;
514 cmd->SCp.this_residual = cmd->SCp.buffer->length;
515 /* ++roman: Try to merge some scatter-buffers if they are at
516 * contiguous physical addresses.
517 */ 512 */
518 merge_contiguous_buffers( cmd ); 513
519 } else { 514 if (cmd->use_sg) {
520 cmd->SCp.buffer = NULL; 515 cmd->SCp.buffer = (struct scatterlist *)cmd->request_buffer;
521 cmd->SCp.buffers_residual = 0; 516 cmd->SCp.buffers_residual = cmd->use_sg - 1;
522 cmd->SCp.ptr = (char *) cmd->request_buffer; 517 cmd->SCp.ptr = (char *)page_address(cmd->SCp.buffer->page) +
523 cmd->SCp.this_residual = cmd->request_bufflen; 518 cmd->SCp.buffer->offset;
524 } 519 cmd->SCp.this_residual = cmd->SCp.buffer->length;
520 /* ++roman: Try to merge some scatter-buffers if they are at
521 * contiguous physical addresses.
522 */
523 merge_contiguous_buffers(cmd);
524 } else {
525 cmd->SCp.buffer = NULL;
526 cmd->SCp.buffers_residual = 0;
527 cmd->SCp.ptr = (char *)cmd->request_buffer;
528 cmd->SCp.this_residual = cmd->request_bufflen;
529 }
525} 530}
526 531
527#include <linux/delay.h> 532#include <linux/delay.h>
528 533
529#if NDEBUG 534#if NDEBUG
530static struct { 535static struct {
531 unsigned char mask; 536 unsigned char mask;
532 const char * name;} 537 const char *name;
533signals[] = {{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" }, 538} signals[] = {
534 { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" }, 539 { SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
535 { SR_SEL, "SEL" }, {0, NULL}}, 540 { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" },
536basrs[] = {{BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}}, 541 { SR_SEL, "SEL" }, {0, NULL}
537icrs[] = {{ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"}, 542}, basrs[] = {
538 {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"}, 543 {BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}
539 {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"}, 544}, icrs[] = {
540 {0, NULL}}, 545 {ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
541mrs[] = {{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"}, 546 {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"},
542 {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR, 547 {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"},
543 "MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"}, 548 {0, NULL}
544 {MR_MONITOR_BSY, "MODE MONITOR BSY"}, 549}, mrs[] = {
545 {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"}, 550 {MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
546 {0, NULL}}; 551 {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR,
552 "MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"},
553 {MR_MONITOR_BSY, "MODE MONITOR BSY"},
554 {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"},
555 {0, NULL}
556};
547 557
548/* 558/*
549 * Function : void NCR5380_print(struct Scsi_Host *instance) 559 * Function : void NCR5380_print(struct Scsi_Host *instance)
@@ -553,45 +563,47 @@ mrs[] = {{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
553 * Input : instance - which NCR5380 563 * Input : instance - which NCR5380
554 */ 564 */
555 565
556static void NCR5380_print(struct Scsi_Host *instance) { 566static void NCR5380_print(struct Scsi_Host *instance)
557 unsigned char status, data, basr, mr, icr, i; 567{
558 unsigned long flags; 568 unsigned char status, data, basr, mr, icr, i;
559 569 unsigned long flags;
560 local_irq_save(flags); 570
561 data = NCR5380_read(CURRENT_SCSI_DATA_REG); 571 local_irq_save(flags);
562 status = NCR5380_read(STATUS_REG); 572 data = NCR5380_read(CURRENT_SCSI_DATA_REG);
563 mr = NCR5380_read(MODE_REG); 573 status = NCR5380_read(STATUS_REG);
564 icr = NCR5380_read(INITIATOR_COMMAND_REG); 574 mr = NCR5380_read(MODE_REG);
565 basr = NCR5380_read(BUS_AND_STATUS_REG); 575 icr = NCR5380_read(INITIATOR_COMMAND_REG);
566 local_irq_restore(flags); 576 basr = NCR5380_read(BUS_AND_STATUS_REG);
567 printk("STATUS_REG: %02x ", status); 577 local_irq_restore(flags);
568 for (i = 0; signals[i].mask ; ++i) 578 printk("STATUS_REG: %02x ", status);
569 if (status & signals[i].mask) 579 for (i = 0; signals[i].mask; ++i)
570 printk(",%s", signals[i].name); 580 if (status & signals[i].mask)
571 printk("\nBASR: %02x ", basr); 581 printk(",%s", signals[i].name);
572 for (i = 0; basrs[i].mask ; ++i) 582 printk("\nBASR: %02x ", basr);
573 if (basr & basrs[i].mask) 583 for (i = 0; basrs[i].mask; ++i)
574 printk(",%s", basrs[i].name); 584 if (basr & basrs[i].mask)
575 printk("\nICR: %02x ", icr); 585 printk(",%s", basrs[i].name);
576 for (i = 0; icrs[i].mask; ++i) 586 printk("\nICR: %02x ", icr);
577 if (icr & icrs[i].mask) 587 for (i = 0; icrs[i].mask; ++i)
578 printk(",%s", icrs[i].name); 588 if (icr & icrs[i].mask)
579 printk("\nMODE: %02x ", mr); 589 printk(",%s", icrs[i].name);
580 for (i = 0; mrs[i].mask; ++i) 590 printk("\nMODE: %02x ", mr);
581 if (mr & mrs[i].mask) 591 for (i = 0; mrs[i].mask; ++i)
582 printk(",%s", mrs[i].name); 592 if (mr & mrs[i].mask)
583 printk("\n"); 593 printk(",%s", mrs[i].name);
594 printk("\n");
584} 595}
585 596
586static struct { 597static struct {
587 unsigned char value; 598 unsigned char value;
588 const char *name; 599 const char *name;
589} phases[] = { 600} phases[] = {
590 {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"}, 601 {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
591 {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"}, 602 {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
592 {PHASE_UNKNOWN, "UNKNOWN"}}; 603 {PHASE_UNKNOWN, "UNKNOWN"}
604};
593 605
594/* 606/*
595 * Function : void NCR5380_print_phase(struct Scsi_Host *instance) 607 * Function : void NCR5380_print_phase(struct Scsi_Host *instance)
596 * 608 *
597 * Purpose : print the current SCSI phase for debugging purposes 609 * Purpose : print the current SCSI phase for debugging purposes
@@ -601,30 +613,35 @@ static struct {
601 613
602static void NCR5380_print_phase(struct Scsi_Host *instance) 614static void NCR5380_print_phase(struct Scsi_Host *instance)
603{ 615{
604 unsigned char status; 616 unsigned char status;
605 int i; 617 int i;
606 618
607 status = NCR5380_read(STATUS_REG); 619 status = NCR5380_read(STATUS_REG);
608 if (!(status & SR_REQ)) 620 if (!(status & SR_REQ))
609 printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO); 621 printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO);
610 else { 622 else {
611 for (i = 0; (phases[i].value != PHASE_UNKNOWN) && 623 for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
612 (phases[i].value != (status & PHASE_MASK)); ++i); 624 (phases[i].value != (status & PHASE_MASK)); ++i)
613 printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name); 625 ;
614 } 626 printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name);
627 }
615} 628}
616 629
617#else /* !NDEBUG */ 630#else /* !NDEBUG */
618 631
619/* dummies... */ 632/* dummies... */
620__inline__ void NCR5380_print(struct Scsi_Host *instance) { }; 633static inline void NCR5380_print(struct Scsi_Host *instance)
621__inline__ void NCR5380_print_phase(struct Scsi_Host *instance) { }; 634{
635};
636static inline void NCR5380_print_phase(struct Scsi_Host *instance)
637{
638};
622 639
623#endif 640#endif
624 641
625/* 642/*
626 * ++roman: New scheme of calling NCR5380_main() 643 * ++roman: New scheme of calling NCR5380_main()
627 * 644 *
628 * If we're not in an interrupt, we can call our main directly, it cannot be 645 * If we're not in an interrupt, we can call our main directly, it cannot be
629 * already running. Else, we queue it on a task queue, if not 'main_running' 646 * already running. Else, we queue it on a task queue, if not 'main_running'
630 * tells us that a lower level is already executing it. This way, 647 * tells us that a lower level is already executing it. This way,
@@ -638,33 +655,33 @@ __inline__ void NCR5380_print_phase(struct Scsi_Host *instance) { };
638#include <linux/workqueue.h> 655#include <linux/workqueue.h>
639#include <linux/interrupt.h> 656#include <linux/interrupt.h>
640 657
641static volatile int main_running = 0; 658static volatile int main_running;
642static DECLARE_WORK(NCR5380_tqueue, (void (*)(void*))NCR5380_main, NULL); 659static DECLARE_WORK(NCR5380_tqueue, (void (*)(void *))NCR5380_main, NULL);
643 660
644static __inline__ void queue_main(void) 661static inline void queue_main(void)
645{ 662{
646 if (!main_running) { 663 if (!main_running) {
647 /* If in interrupt and NCR5380_main() not already running, 664 /* If in interrupt and NCR5380_main() not already running,
648 queue it on the 'immediate' task queue, to be processed 665 queue it on the 'immediate' task queue, to be processed
649 immediately after the current interrupt processing has 666 immediately after the current interrupt processing has
650 finished. */ 667 finished. */
651 schedule_work(&NCR5380_tqueue); 668 schedule_work(&NCR5380_tqueue);
652 } 669 }
653 /* else: nothing to do: the running NCR5380_main() will pick up 670 /* else: nothing to do: the running NCR5380_main() will pick up
654 any newly queued command. */ 671 any newly queued command. */
655} 672}
656 673
657 674
658static inline void NCR5380_all_init (void) 675static inline void NCR5380_all_init(void)
659{ 676{
660 static int done = 0; 677 static int done = 0;
661 if (!done) { 678 if (!done) {
662 INI_PRINTK("scsi : NCR5380_all_init()\n"); 679 INI_PRINTK("scsi : NCR5380_all_init()\n");
663 done = 1; 680 done = 1;
664 } 681 }
665} 682}
666 683
667 684
668/* 685/*
669 * Function : void NCR58380_print_options (struct Scsi_Host *instance) 686 * Function : void NCR58380_print_options (struct Scsi_Host *instance)
670 * 687 *
@@ -674,23 +691,23 @@ static inline void NCR5380_all_init (void)
674 * Inputs : instance, pointer to this instance. Unused. 691 * Inputs : instance, pointer to this instance. Unused.
675 */ 692 */
676 693
677static void __init NCR5380_print_options (struct Scsi_Host *instance) 694static void __init NCR5380_print_options(struct Scsi_Host *instance)
678{ 695{
679 printk(" generic options" 696 printk(" generic options"
680#ifdef AUTOSENSE 697#ifdef AUTOSENSE
681 " AUTOSENSE" 698 " AUTOSENSE"
682#endif 699#endif
683#ifdef REAL_DMA 700#ifdef REAL_DMA
684 " REAL DMA" 701 " REAL DMA"
685#endif 702#endif
686#ifdef PARITY 703#ifdef PARITY
687 " PARITY" 704 " PARITY"
688#endif 705#endif
689#ifdef SUPPORT_TAGS 706#ifdef SUPPORT_TAGS
690 " SCSI-2 TAGGED QUEUING" 707 " SCSI-2 TAGGED QUEUING"
691#endif 708#endif
692 ); 709 );
693 printk(" generic release=%d", NCR5380_PUBLIC_RELEASE); 710 printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
694} 711}
695 712
696/* 713/*
@@ -699,27 +716,27 @@ static void __init NCR5380_print_options (struct Scsi_Host *instance)
699 * Purpose : print commands in the various queues, called from 716 * Purpose : print commands in the various queues, called from
700 * NCR5380_abort and NCR5380_debug to aid debugging. 717 * NCR5380_abort and NCR5380_debug to aid debugging.
701 * 718 *
702 * Inputs : instance, pointer to this instance. 719 * Inputs : instance, pointer to this instance.
703 */ 720 */
704 721
705static void NCR5380_print_status (struct Scsi_Host *instance) 722static void NCR5380_print_status(struct Scsi_Host *instance)
706{ 723{
707 char *pr_bfr; 724 char *pr_bfr;
708 char *start; 725 char *start;
709 int len; 726 int len;
710 727
711 NCR_PRINT(NDEBUG_ANY); 728 NCR_PRINT(NDEBUG_ANY);
712 NCR_PRINT_PHASE(NDEBUG_ANY); 729 NCR_PRINT_PHASE(NDEBUG_ANY);
713 730
714 pr_bfr = (char *) __get_free_page(GFP_ATOMIC); 731 pr_bfr = (char *)__get_free_page(GFP_ATOMIC);
715 if (!pr_bfr) { 732 if (!pr_bfr) {
716 printk("NCR5380_print_status: no memory for print buffer\n"); 733 printk("NCR5380_print_status: no memory for print buffer\n");
717 return; 734 return;
718 } 735 }
719 len = NCR5380_proc_info(instance, pr_bfr, &start, 0, PAGE_SIZE, 0); 736 len = NCR5380_proc_info(instance, pr_bfr, &start, 0, PAGE_SIZE, 0);
720 pr_bfr[len] = 0; 737 pr_bfr[len] = 0;
721 printk("\n%s\n", pr_bfr); 738 printk("\n%s\n", pr_bfr);
722 free_page((unsigned long) pr_bfr); 739 free_page((unsigned long)pr_bfr);
723} 740}
724 741
725 742
@@ -738,146 +755,144 @@ static void NCR5380_print_status (struct Scsi_Host *instance)
738*/ 755*/
739 756
740#undef SPRINTF 757#undef SPRINTF
741#define SPRINTF(fmt,args...) \ 758#define SPRINTF(fmt,args...) \
742 do { if (pos + strlen(fmt) + 20 /* slop */ < buffer + length) \ 759 do { \
743 pos += sprintf(pos, fmt , ## args); } while(0) 760 if (pos + strlen(fmt) + 20 /* slop */ < buffer + length) \
744static 761 pos += sprintf(pos, fmt , ## args); \
745char *lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length); 762 } while(0)
746 763static char *lprint_Scsi_Cmnd(Scsi_Cmnd *cmd, char *pos, char *buffer, int length);
747static 764
748int NCR5380_proc_info (struct Scsi_Host *instance, char *buffer, char **start, off_t offset, 765static int NCR5380_proc_info(struct Scsi_Host *instance, char *buffer,
749 int length, int inout) 766 char **start, off_t offset, int length, int inout)
750{ 767{
751 char *pos = buffer; 768 char *pos = buffer;
752 struct NCR5380_hostdata *hostdata; 769 struct NCR5380_hostdata *hostdata;
753 Scsi_Cmnd *ptr; 770 Scsi_Cmnd *ptr;
754 unsigned long flags; 771 unsigned long flags;
755 off_t begin = 0; 772 off_t begin = 0;
756#define check_offset() \ 773#define check_offset() \
757 do { \ 774 do { \
758 if (pos - buffer < offset - begin) { \ 775 if (pos - buffer < offset - begin) { \
759 begin += pos - buffer; \ 776 begin += pos - buffer; \
760 pos = buffer; \ 777 pos = buffer; \
761 } \ 778 } \
762 } while (0) 779 } while (0)
763 780
764 hostdata = (struct NCR5380_hostdata *)instance->hostdata; 781 hostdata = (struct NCR5380_hostdata *)instance->hostdata;
765 782
766 if (inout) { /* Has data been written to the file ? */ 783 if (inout) /* Has data been written to the file ? */
767 return(-ENOSYS); /* Currently this is a no-op */ 784 return -ENOSYS; /* Currently this is a no-op */
768 } 785 SPRINTF("NCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE);
769 SPRINTF("NCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE); 786 check_offset();
770 check_offset(); 787 local_irq_save(flags);
771 local_irq_save(flags); 788 SPRINTF("NCR5380: coroutine is%s running.\n",
772 SPRINTF("NCR5380: coroutine is%s running.\n", main_running ? "" : "n't"); 789 main_running ? "" : "n't");
773 check_offset();
774 if (!hostdata->connected)
775 SPRINTF("scsi%d: no currently connected command\n", HOSTNO);
776 else
777 pos = lprint_Scsi_Cmnd ((Scsi_Cmnd *) hostdata->connected,
778 pos, buffer, length);
779 SPRINTF("scsi%d: issue_queue\n", HOSTNO);
780 check_offset();
781 for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; ptr = NEXT(ptr)) {
782 pos = lprint_Scsi_Cmnd (ptr, pos, buffer, length);
783 check_offset(); 790 check_offset();
784 } 791 if (!hostdata->connected)
792 SPRINTF("scsi%d: no currently connected command\n", HOSTNO);
793 else
794 pos = lprint_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected,
795 pos, buffer, length);
796 SPRINTF("scsi%d: issue_queue\n", HOSTNO);
797 check_offset();
798 for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr)) {
799 pos = lprint_Scsi_Cmnd(ptr, pos, buffer, length);
800 check_offset();
801 }
785 802
786 SPRINTF("scsi%d: disconnected_queue\n", HOSTNO); 803 SPRINTF("scsi%d: disconnected_queue\n", HOSTNO);
787 check_offset();
788 for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
789 ptr = NEXT(ptr)) {
790 pos = lprint_Scsi_Cmnd (ptr, pos, buffer, length);
791 check_offset(); 804 check_offset();
792 } 805 for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
806 ptr = NEXT(ptr)) {
807 pos = lprint_Scsi_Cmnd(ptr, pos, buffer, length);
808 check_offset();
809 }
793 810
794 local_irq_restore(flags); 811 local_irq_restore(flags);
795 *start = buffer + (offset - begin); 812 *start = buffer + (offset - begin);
796 if (pos - buffer < offset - begin) 813 if (pos - buffer < offset - begin)
797 return 0; 814 return 0;
798 else if (pos - buffer - (offset - begin) < length) 815 else if (pos - buffer - (offset - begin) < length)
799 return pos - buffer - (offset - begin); 816 return pos - buffer - (offset - begin);
800 return length; 817 return length;
801} 818}
802 819
803static char * 820static char *lprint_Scsi_Cmnd(Scsi_Cmnd *cmd, char *pos, char *buffer, int length)
804lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length)
805{ 821{
806 int i, s; 822 int i, s;
807 unsigned char *command; 823 unsigned char *command;
808 SPRINTF("scsi%d: destination target %d, lun %d\n", 824 SPRINTF("scsi%d: destination target %d, lun %d\n",
809 H_NO(cmd), cmd->device->id, cmd->device->lun); 825 H_NO(cmd), cmd->device->id, cmd->device->lun);
810 SPRINTF(" command = "); 826 SPRINTF(" command = ");
811 command = cmd->cmnd; 827 command = cmd->cmnd;
812 SPRINTF("%2d (0x%02x)", command[0], command[0]); 828 SPRINTF("%2d (0x%02x)", command[0], command[0]);
813 for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i) 829 for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
814 SPRINTF(" %02x", command[i]); 830 SPRINTF(" %02x", command[i]);
815 SPRINTF("\n"); 831 SPRINTF("\n");
816 return pos; 832 return pos;
817} 833}
818 834
819 835
820/* 836/*
821 * Function : void NCR5380_init (struct Scsi_Host *instance) 837 * Function : void NCR5380_init (struct Scsi_Host *instance)
822 * 838 *
823 * Purpose : initializes *instance and corresponding 5380 chip. 839 * Purpose : initializes *instance and corresponding 5380 chip.
824 * 840 *
825 * Inputs : instance - instantiation of the 5380 driver. 841 * Inputs : instance - instantiation of the 5380 driver.
826 * 842 *
827 * Notes : I assume that the host, hostno, and id bits have been 843 * Notes : I assume that the host, hostno, and id bits have been
828 * set correctly. I don't care about the irq and other fields. 844 * set correctly. I don't care about the irq and other fields.
829 * 845 *
830 */ 846 */
831 847
832static int NCR5380_init (struct Scsi_Host *instance, int flags) 848static int NCR5380_init(struct Scsi_Host *instance, int flags)
833{ 849{
834 int i; 850 int i;
835 SETUP_HOSTDATA(instance); 851 SETUP_HOSTDATA(instance);
836 852
837 NCR5380_all_init(); 853 NCR5380_all_init();
838 854
839 hostdata->aborted = 0; 855 hostdata->aborted = 0;
840 hostdata->id_mask = 1 << instance->this_id; 856 hostdata->id_mask = 1 << instance->this_id;
841 hostdata->id_higher_mask = 0; 857 hostdata->id_higher_mask = 0;
842 for (i = hostdata->id_mask; i <= 0x80; i <<= 1) 858 for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
843 if (i > hostdata->id_mask) 859 if (i > hostdata->id_mask)
844 hostdata->id_higher_mask |= i; 860 hostdata->id_higher_mask |= i;
845 for (i = 0; i < 8; ++i) 861 for (i = 0; i < 8; ++i)
846 hostdata->busy[i] = 0; 862 hostdata->busy[i] = 0;
847#ifdef SUPPORT_TAGS 863#ifdef SUPPORT_TAGS
848 init_tags(); 864 init_tags();
849#endif 865#endif
850#if defined (REAL_DMA) 866#if defined (REAL_DMA)
851 hostdata->dma_len = 0; 867 hostdata->dma_len = 0;
852#endif 868#endif
853 hostdata->targets_present = 0; 869 hostdata->targets_present = 0;
854 hostdata->connected = NULL; 870 hostdata->connected = NULL;
855 hostdata->issue_queue = NULL; 871 hostdata->issue_queue = NULL;
856 hostdata->disconnected_queue = NULL; 872 hostdata->disconnected_queue = NULL;
857 hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT; 873 hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT;
858 874
859 if (!the_template) { 875 if (!the_template) {
860 the_template = instance->hostt; 876 the_template = instance->hostt;
861 first_instance = instance; 877 first_instance = instance;
862 } 878 }
863
864 879
865#ifndef AUTOSENSE 880#ifndef AUTOSENSE
866 if ((instance->cmd_per_lun > 1) || (instance->can_queue > 1)) 881 if ((instance->cmd_per_lun > 1) || (instance->can_queue > 1))
867 printk("scsi%d: WARNING : support for multiple outstanding commands enabled\n" 882 printk("scsi%d: WARNING : support for multiple outstanding commands enabled\n"
868 " without AUTOSENSE option, contingent allegiance conditions may\n" 883 " without AUTOSENSE option, contingent allegiance conditions may\n"
869 " be incorrectly cleared.\n", HOSTNO); 884 " be incorrectly cleared.\n", HOSTNO);
870#endif /* def AUTOSENSE */ 885#endif /* def AUTOSENSE */
871 886
872 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 887 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
873 NCR5380_write(MODE_REG, MR_BASE); 888 NCR5380_write(MODE_REG, MR_BASE);
874 NCR5380_write(TARGET_COMMAND_REG, 0); 889 NCR5380_write(TARGET_COMMAND_REG, 0);
875 NCR5380_write(SELECT_ENABLE_REG, 0); 890 NCR5380_write(SELECT_ENABLE_REG, 0);
876 891
877 return 0; 892 return 0;
878} 893}
879 894
880/* 895/*
881 * our own old-style timeout update 896 * our own old-style timeout update
882 */ 897 */
883/* 898/*
@@ -890,331 +905,328 @@ static int NCR5380_init (struct Scsi_Host *instance, int flags)
890 905
891int atari_scsi_update_timeout(Scsi_Cmnd * SCset, int timeout) 906int atari_scsi_update_timeout(Scsi_Cmnd * SCset, int timeout)
892{ 907{
893 int rtn; 908 int rtn;
894 909
895 /* 910 /*
896 * We are using the new error handling code to actually register/deregister 911 * We are using the new error handling code to actually register/deregister
897 * timers for timeout. 912 * timers for timeout.
898 */ 913 */
899 914
900 if (!timer_pending(&SCset->eh_timeout)) { 915 if (!timer_pending(&SCset->eh_timeout))
901 rtn = 0; 916 rtn = 0;
902 } else { 917 else
903 rtn = SCset->eh_timeout.expires - jiffies; 918 rtn = SCset->eh_timeout.expires - jiffies;
904 } 919
905 920 if (timeout == 0) {
906 if (timeout == 0) { 921 del_timer(&SCset->eh_timeout);
907 del_timer(&SCset->eh_timeout); 922 SCset->eh_timeout.data = (unsigned long)NULL;
908 SCset->eh_timeout.data = (unsigned long) NULL; 923 SCset->eh_timeout.expires = 0;
909 SCset->eh_timeout.expires = 0; 924 } else {
910 } else { 925 if (SCset->eh_timeout.data != (unsigned long)NULL)
911 if (SCset->eh_timeout.data != (unsigned long) NULL) 926 del_timer(&SCset->eh_timeout);
912 del_timer(&SCset->eh_timeout); 927 SCset->eh_timeout.data = (unsigned long)SCset;
913 SCset->eh_timeout.data = (unsigned long) SCset; 928 SCset->eh_timeout.expires = jiffies + timeout;
914 SCset->eh_timeout.expires = jiffies + timeout; 929 add_timer(&SCset->eh_timeout);
915 add_timer(&SCset->eh_timeout); 930 }
916 }
917 return rtn; 931 return rtn;
918} 932}
919 933
920/* 934/*
921 * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd, 935 * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd,
922 * void (*done)(Scsi_Cmnd *)) 936 * void (*done)(Scsi_Cmnd *))
923 * 937 *
924 * Purpose : enqueues a SCSI command 938 * Purpose : enqueues a SCSI command
925 * 939 *
926 * Inputs : cmd - SCSI command, done - function called on completion, with 940 * Inputs : cmd - SCSI command, done - function called on completion, with
927 * a pointer to the command descriptor. 941 * a pointer to the command descriptor.
928 * 942 *
929 * Returns : 0 943 * Returns : 0
930 * 944 *
931 * Side effects : 945 * Side effects :
932 * cmd is added to the per instance issue_queue, with minor 946 * cmd is added to the per instance issue_queue, with minor
933 * twiddling done to the host specific fields of cmd. If the 947 * twiddling done to the host specific fields of cmd. If the
934 * main coroutine is not running, it is restarted. 948 * main coroutine is not running, it is restarted.
935 * 949 *
936 */ 950 */
937 951
938static 952static int NCR5380_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
939int NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
940{ 953{
941 SETUP_HOSTDATA(cmd->device->host); 954 SETUP_HOSTDATA(cmd->device->host);
942 Scsi_Cmnd *tmp; 955 Scsi_Cmnd *tmp;
943 int oldto; 956 int oldto;
944 unsigned long flags; 957 unsigned long flags;
945 // extern int update_timeout(Scsi_Cmnd * SCset, int timeout); 958 // extern int update_timeout(Scsi_Cmnd * SCset, int timeout);
946 959
947#if (NDEBUG & NDEBUG_NO_WRITE) 960#if (NDEBUG & NDEBUG_NO_WRITE)
948 switch (cmd->cmnd[0]) { 961 switch (cmd->cmnd[0]) {
949 case WRITE_6: 962 case WRITE_6:
950 case WRITE_10: 963 case WRITE_10:
951 printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n", 964 printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n",
952 H_NO(cmd)); 965 H_NO(cmd));
953 cmd->result = (DID_ERROR << 16); 966 cmd->result = (DID_ERROR << 16);
954 done(cmd); 967 done(cmd);
955 return 0; 968 return 0;
956 } 969 }
957#endif /* (NDEBUG & NDEBUG_NO_WRITE) */ 970#endif /* (NDEBUG & NDEBUG_NO_WRITE) */
958 971
959
960#ifdef NCR5380_STATS 972#ifdef NCR5380_STATS
961# if 0 973# if 0
962 if (!hostdata->connected && !hostdata->issue_queue && 974 if (!hostdata->connected && !hostdata->issue_queue &&
963 !hostdata->disconnected_queue) { 975 !hostdata->disconnected_queue) {
964 hostdata->timebase = jiffies; 976 hostdata->timebase = jiffies;
965 } 977 }
966# endif 978# endif
967# ifdef NCR5380_STAT_LIMIT 979# ifdef NCR5380_STAT_LIMIT
968 if (cmd->request_bufflen > NCR5380_STAT_LIMIT) 980 if (cmd->request_bufflen > NCR5380_STAT_LIMIT)
969# endif 981# endif
970 switch (cmd->cmnd[0]) 982 switch (cmd->cmnd[0]) {
971 { 983 case WRITE:
972 case WRITE: 984 case WRITE_6:
973 case WRITE_6: 985 case WRITE_10:
974 case WRITE_10: 986 hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase);
975 hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase); 987 hostdata->bytes_write[cmd->device->id] += cmd->request_bufflen;
976 hostdata->bytes_write[cmd->device->id] += cmd->request_bufflen; 988 hostdata->pendingw++;
977 hostdata->pendingw++; 989 break;
978 break; 990 case READ:
979 case READ: 991 case READ_6:
980 case READ_6: 992 case READ_10:
981 case READ_10: 993 hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase);
982 hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase); 994 hostdata->bytes_read[cmd->device->id] += cmd->request_bufflen;
983 hostdata->bytes_read[cmd->device->id] += cmd->request_bufflen; 995 hostdata->pendingr++;
984 hostdata->pendingr++; 996 break;
985 break; 997 }
986 }
987#endif 998#endif
988 999
989 /* 1000 /*
990 * We use the host_scribble field as a pointer to the next command 1001 * We use the host_scribble field as a pointer to the next command
991 * in a queue 1002 * in a queue
992 */ 1003 */
993 1004
994 NEXT(cmd) = NULL; 1005 NEXT(cmd) = NULL;
995 cmd->scsi_done = done; 1006 cmd->scsi_done = done;
996 1007
997 cmd->result = 0; 1008 cmd->result = 0;
998 1009
999 1010 /*
1000 /* 1011 * Insert the cmd into the issue queue. Note that REQUEST SENSE
1001 * Insert the cmd into the issue queue. Note that REQUEST SENSE 1012 * commands are added to the head of the queue since any command will
1002 * commands are added to the head of the queue since any command will 1013 * clear the contingent allegiance condition that exists and the
1003 * clear the contingent allegiance condition that exists and the 1014 * sense data is only guaranteed to be valid while the condition exists.
1004 * sense data is only guaranteed to be valid while the condition exists. 1015 */
1005 */ 1016
1006 1017 local_irq_save(flags);
1007 local_irq_save(flags); 1018 /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
1008 /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA. 1019 * Otherwise a running NCR5380_main may steal the lock.
1009 * Otherwise a running NCR5380_main may steal the lock. 1020 * Lock before actually inserting due to fairness reasons explained in
1010 * Lock before actually inserting due to fairness reasons explained in 1021 * atari_scsi.c. If we insert first, then it's impossible for this driver
1011 * atari_scsi.c. If we insert first, then it's impossible for this driver 1022 * to release the lock.
1012 * to release the lock. 1023 * Stop timer for this command while waiting for the lock, or timeouts
1013 * Stop timer for this command while waiting for the lock, or timeouts 1024 * may happen (and they really do), and it's no good if the command doesn't
1014 * may happen (and they really do), and it's no good if the command doesn't 1025 * appear in any of the queues.
1015 * appear in any of the queues. 1026 * ++roman: Just disabling the NCR interrupt isn't sufficient here,
1016 * ++roman: Just disabling the NCR interrupt isn't sufficient here, 1027 * because also a timer int can trigger an abort or reset, which would
1017 * because also a timer int can trigger an abort or reset, which would 1028 * alter queues and touch the lock.
1018 * alter queues and touch the lock. 1029 */
1019 */ 1030 if (!IS_A_TT()) {
1020 if (!IS_A_TT()) { 1031 oldto = atari_scsi_update_timeout(cmd, 0);
1021 oldto = atari_scsi_update_timeout(cmd, 0); 1032 falcon_get_lock();
1022 falcon_get_lock(); 1033 atari_scsi_update_timeout(cmd, oldto);
1023 atari_scsi_update_timeout(cmd, oldto); 1034 }
1024 } 1035 if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
1025 if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) { 1036 LIST(cmd, hostdata->issue_queue);
1026 LIST(cmd, hostdata->issue_queue); 1037 NEXT(cmd) = hostdata->issue_queue;
1027 NEXT(cmd) = hostdata->issue_queue; 1038 hostdata->issue_queue = cmd;
1028 hostdata->issue_queue = cmd; 1039 } else {
1029 } else { 1040 for (tmp = (Scsi_Cmnd *)hostdata->issue_queue;
1030 for (tmp = (Scsi_Cmnd *)hostdata->issue_queue; 1041 NEXT(tmp); tmp = NEXT(tmp))
1031 NEXT(tmp); tmp = NEXT(tmp)) 1042 ;
1032 ; 1043 LIST(cmd, tmp);
1033 LIST(cmd, tmp); 1044 NEXT(tmp) = cmd;
1034 NEXT(tmp) = cmd; 1045 }
1035 } 1046 local_irq_restore(flags);
1036 local_irq_restore(flags); 1047
1037 1048 QU_PRINTK("scsi%d: command added to %s of queue\n", H_NO(cmd),
1038 QU_PRINTK("scsi%d: command added to %s of queue\n", H_NO(cmd), 1049 (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
1039 (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"); 1050
1040 1051 /* If queue_command() is called from an interrupt (real one or bottom
1041 /* If queue_command() is called from an interrupt (real one or bottom 1052 * half), we let queue_main() do the job of taking care about main. If it
1042 * half), we let queue_main() do the job of taking care about main. If it 1053 * is already running, this is a no-op, else main will be queued.
1043 * is already running, this is a no-op, else main will be queued. 1054 *
1044 * 1055 * If we're not in an interrupt, we can call NCR5380_main()
1045 * If we're not in an interrupt, we can call NCR5380_main() 1056 * unconditionally, because it cannot be already running.
1046 * unconditionally, because it cannot be already running. 1057 */
1047 */ 1058 if (in_interrupt() || ((flags >> 8) & 7) >= 6)
1048 if (in_interrupt() || ((flags >> 8) & 7) >= 6) 1059 queue_main();
1049 queue_main(); 1060 else
1050 else 1061 NCR5380_main(NULL);
1051 NCR5380_main(NULL); 1062 return 0;
1052 return 0;
1053} 1063}
1054 1064
1055/* 1065/*
1056 * Function : NCR5380_main (void) 1066 * Function : NCR5380_main (void)
1057 * 1067 *
1058 * Purpose : NCR5380_main is a coroutine that runs as long as more work can 1068 * Purpose : NCR5380_main is a coroutine that runs as long as more work can
1059 * be done on the NCR5380 host adapters in a system. Both 1069 * be done on the NCR5380 host adapters in a system. Both
1060 * NCR5380_queue_command() and NCR5380_intr() will try to start it 1070 * NCR5380_queue_command() and NCR5380_intr() will try to start it
1061 * in case it is not running. 1071 * in case it is not running.
1062 * 1072 *
1063 * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should 1073 * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should
1064 * reenable them. This prevents reentrancy and kernel stack overflow. 1074 * reenable them. This prevents reentrancy and kernel stack overflow.
1065 */ 1075 */
1066 1076
1067static void NCR5380_main (void *bl) 1077static void NCR5380_main(void *bl)
1068{ 1078{
1069 Scsi_Cmnd *tmp, *prev; 1079 Scsi_Cmnd *tmp, *prev;
1070 struct Scsi_Host *instance = first_instance; 1080 struct Scsi_Host *instance = first_instance;
1071 struct NCR5380_hostdata *hostdata = HOSTDATA(instance); 1081 struct NCR5380_hostdata *hostdata = HOSTDATA(instance);
1072 int done; 1082 int done;
1073 unsigned long flags; 1083 unsigned long flags;
1074 1084
1075 /* 1085 /*
1076 * We run (with interrupts disabled) until we're sure that none of 1086 * We run (with interrupts disabled) until we're sure that none of
1077 * the host adapters have anything that can be done, at which point 1087 * the host adapters have anything that can be done, at which point
1078 * we set main_running to 0 and exit. 1088 * we set main_running to 0 and exit.
1079 * 1089 *
1080 * Interrupts are enabled before doing various other internal 1090 * Interrupts are enabled before doing various other internal
1081 * instructions, after we've decided that we need to run through 1091 * instructions, after we've decided that we need to run through
1082 * the loop again. 1092 * the loop again.
1083 * 1093 *
1084 * this should prevent any race conditions. 1094 * this should prevent any race conditions.
1085 * 1095 *
1086 * ++roman: Just disabling the NCR interrupt isn't sufficient here, 1096 * ++roman: Just disabling the NCR interrupt isn't sufficient here,
1087 * because also a timer int can trigger an abort or reset, which can 1097 * because also a timer int can trigger an abort or reset, which can
1088 * alter queues and touch the Falcon lock. 1098 * alter queues and touch the Falcon lock.
1089 */ 1099 */
1090 1100
1091 /* Tell int handlers main() is now already executing. Note that 1101 /* Tell int handlers main() is now already executing. Note that
1092 no races are possible here. If an int comes in before 1102 no races are possible here. If an int comes in before
1093 'main_running' is set here, and queues/executes main via the 1103 'main_running' is set here, and queues/executes main via the
1094 task queue, it doesn't do any harm, just this instance of main 1104 task queue, it doesn't do any harm, just this instance of main
1095 won't find any work left to do. */ 1105 won't find any work left to do. */
1096 if (main_running) 1106 if (main_running)
1097 return; 1107 return;
1098 main_running = 1; 1108 main_running = 1;
1099 1109
1100 local_save_flags(flags); 1110 local_save_flags(flags);
1101 do { 1111 do {
1102 local_irq_disable(); /* Freeze request queues */ 1112 local_irq_disable(); /* Freeze request queues */
1103 done = 1; 1113 done = 1;
1104 1114
1105 if (!hostdata->connected) { 1115 if (!hostdata->connected) {
1106 MAIN_PRINTK( "scsi%d: not connected\n", HOSTNO ); 1116 MAIN_PRINTK("scsi%d: not connected\n", HOSTNO);
1107 /* 1117 /*
1108 * Search through the issue_queue for a command destined 1118 * Search through the issue_queue for a command destined
1109 * for a target that's not busy. 1119 * for a target that's not busy.
1110 */ 1120 */
1111#if (NDEBUG & NDEBUG_LISTS) 1121#if (NDEBUG & NDEBUG_LISTS)
1112 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL; 1122 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL;
1113 tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp)) 1123 tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
1114 ; 1124 ;
1115 /*printk("%p ", tmp);*/ 1125 /*printk("%p ", tmp);*/
1116 if ((tmp == prev) && tmp) printk(" LOOP\n");/* else printk("\n");*/ 1126 if ((tmp == prev) && tmp)
1127 printk(" LOOP\n");
1128 /* else printk("\n"); */
1117#endif 1129#endif
1118 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, 1130 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue,
1119 prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp) ) { 1131 prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp)) {
1120 1132
1121#if (NDEBUG & NDEBUG_LISTS) 1133#if (NDEBUG & NDEBUG_LISTS)
1122 if (prev != tmp) 1134 if (prev != tmp)
1123 printk("MAIN tmp=%p target=%d busy=%d lun=%d\n", 1135 printk("MAIN tmp=%p target=%d busy=%d lun=%d\n",
1124 tmp, tmp->device->id, hostdata->busy[tmp->device->id], 1136 tmp, tmp->device->id, hostdata->busy[tmp->device->id],
1125 tmp->device->lun); 1137 tmp->device->lun);
1126#endif 1138#endif
1127 /* When we find one, remove it from the issue queue. */ 1139 /* When we find one, remove it from the issue queue. */
1128 /* ++guenther: possible race with Falcon locking */ 1140 /* ++guenther: possible race with Falcon locking */
1129 if ( 1141 if (
1130#ifdef SUPPORT_TAGS 1142#ifdef SUPPORT_TAGS
1131 !is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE) 1143 !is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE)
1132#else 1144#else
1133 !(hostdata->busy[tmp->device->id] & (1 << tmp->device->lun)) 1145 !(hostdata->busy[tmp->device->id] & (1 << tmp->device->lun))
1134#endif 1146#endif
1135 ) { 1147 ) {
1136 /* ++guenther: just to be sure, this must be atomic */ 1148 /* ++guenther: just to be sure, this must be atomic */
1137 local_irq_disable(); 1149 local_irq_disable();
1138 if (prev) { 1150 if (prev) {
1139 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp)); 1151 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
1140 NEXT(prev) = NEXT(tmp); 1152 NEXT(prev) = NEXT(tmp);
1141 } else { 1153 } else {
1142 REMOVE(-1, hostdata->issue_queue, tmp, NEXT(tmp)); 1154 REMOVE(-1, hostdata->issue_queue, tmp, NEXT(tmp));
1143 hostdata->issue_queue = NEXT(tmp); 1155 hostdata->issue_queue = NEXT(tmp);
1144 } 1156 }
1145 NEXT(tmp) = NULL; 1157 NEXT(tmp) = NULL;
1146 falcon_dont_release++; 1158 falcon_dont_release++;
1147 1159
1148 /* reenable interrupts after finding one */ 1160 /* reenable interrupts after finding one */
1149 local_irq_restore(flags); 1161 local_irq_restore(flags);
1150 1162
1151 /* 1163 /*
1152 * Attempt to establish an I_T_L nexus here. 1164 * Attempt to establish an I_T_L nexus here.
1153 * On success, instance->hostdata->connected is set. 1165 * On success, instance->hostdata->connected is set.
1154 * On failure, we must add the command back to the 1166 * On failure, we must add the command back to the
1155 * issue queue so we can keep trying. 1167 * issue queue so we can keep trying.
1156 */ 1168 */
1157 MAIN_PRINTK("scsi%d: main(): command for target %d " 1169 MAIN_PRINTK("scsi%d: main(): command for target %d "
1158 "lun %d removed from issue_queue\n", 1170 "lun %d removed from issue_queue\n",
1159 HOSTNO, tmp->device->id, tmp->device->lun); 1171 HOSTNO, tmp->device->id, tmp->device->lun);
1160 /* 1172 /*
1161 * REQUEST SENSE commands are issued without tagged 1173 * REQUEST SENSE commands are issued without tagged
1162 * queueing, even on SCSI-II devices because the 1174 * queueing, even on SCSI-II devices because the
1163 * contingent allegiance condition exists for the 1175 * contingent allegiance condition exists for the
1164 * entire unit. 1176 * entire unit.
1165 */ 1177 */
1166 /* ++roman: ...and the standard also requires that 1178 /* ++roman: ...and the standard also requires that
1167 * REQUEST SENSE command are untagged. 1179 * REQUEST SENSE command are untagged.
1168 */ 1180 */
1169 1181
1170#ifdef SUPPORT_TAGS 1182#ifdef SUPPORT_TAGS
1171 cmd_get_tag( tmp, tmp->cmnd[0] != REQUEST_SENSE ); 1183 cmd_get_tag(tmp, tmp->cmnd[0] != REQUEST_SENSE);
1172#endif 1184#endif
1173 if (!NCR5380_select(instance, tmp, 1185 if (!NCR5380_select(instance, tmp,
1174 (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : 1186 (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE :
1175 TAG_NEXT)) { 1187 TAG_NEXT)) {
1176 falcon_dont_release--; 1188 falcon_dont_release--;
1177 /* release if target did not response! */ 1189 /* release if target did not response! */
1178 falcon_release_lock_if_possible( hostdata ); 1190 falcon_release_lock_if_possible(hostdata);
1179 break; 1191 break;
1180 } else { 1192 } else {
1181 local_irq_disable(); 1193 local_irq_disable();
1182 LIST(tmp, hostdata->issue_queue); 1194 LIST(tmp, hostdata->issue_queue);
1183 NEXT(tmp) = hostdata->issue_queue; 1195 NEXT(tmp) = hostdata->issue_queue;
1184 hostdata->issue_queue = tmp; 1196 hostdata->issue_queue = tmp;
1185#ifdef SUPPORT_TAGS 1197#ifdef SUPPORT_TAGS
1186 cmd_free_tag( tmp ); 1198 cmd_free_tag(tmp);
1187#endif 1199#endif
1188 falcon_dont_release--; 1200 falcon_dont_release--;
1189 local_irq_restore(flags); 1201 local_irq_restore(flags);
1190 MAIN_PRINTK("scsi%d: main(): select() failed, " 1202 MAIN_PRINTK("scsi%d: main(): select() failed, "
1191 "returned to issue_queue\n", HOSTNO); 1203 "returned to issue_queue\n", HOSTNO);
1192 if (hostdata->connected) 1204 if (hostdata->connected)
1193 break; 1205 break;
1194 } 1206 }
1195 } /* if target/lun/target queue is not busy */ 1207 } /* if target/lun/target queue is not busy */
1196 } /* for issue_queue */ 1208 } /* for issue_queue */
1197 } /* if (!hostdata->connected) */ 1209 } /* if (!hostdata->connected) */
1198 1210
1199 if (hostdata->connected 1211 if (hostdata->connected
1200#ifdef REAL_DMA 1212#ifdef REAL_DMA
1201 && !hostdata->dma_len 1213 && !hostdata->dma_len
1202#endif 1214#endif
1203 ) { 1215 ) {
1204 local_irq_restore(flags); 1216 local_irq_restore(flags);
1205 MAIN_PRINTK("scsi%d: main: performing information transfer\n", 1217 MAIN_PRINTK("scsi%d: main: performing information transfer\n",
1206 HOSTNO); 1218 HOSTNO);
1207 NCR5380_information_transfer(instance); 1219 NCR5380_information_transfer(instance);
1208 MAIN_PRINTK("scsi%d: main: done set false\n", HOSTNO); 1220 MAIN_PRINTK("scsi%d: main: done set false\n", HOSTNO);
1209 done = 0; 1221 done = 0;
1210 } 1222 }
1211 } while (!done); 1223 } while (!done);
1212 1224
1213 /* Better allow ints _after_ 'main_running' has been cleared, else 1225 /* Better allow ints _after_ 'main_running' has been cleared, else
1214 an interrupt could believe we'll pick up the work it left for 1226 an interrupt could believe we'll pick up the work it left for
1215 us, but we won't see it anymore here... */ 1227 us, but we won't see it anymore here... */
1216 main_running = 0; 1228 main_running = 0;
1217 local_irq_restore(flags); 1229 local_irq_restore(flags);
1218} 1230}
1219 1231
1220 1232
@@ -1223,1441 +1235,1439 @@ static void NCR5380_main (void *bl)
1223 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance) 1235 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
1224 * 1236 *
1225 * Purpose : Called by interrupt handler when DMA finishes or a phase 1237 * Purpose : Called by interrupt handler when DMA finishes or a phase
1226 * mismatch occurs (which would finish the DMA transfer). 1238 * mismatch occurs (which would finish the DMA transfer).
1227 * 1239 *
1228 * Inputs : instance - this instance of the NCR5380. 1240 * Inputs : instance - this instance of the NCR5380.
1229 * 1241 *
1230 */ 1242 */
1231 1243
1232static void NCR5380_dma_complete( struct Scsi_Host *instance ) 1244static void NCR5380_dma_complete(struct Scsi_Host *instance)
1233{ 1245{
1234 SETUP_HOSTDATA(instance); 1246 SETUP_HOSTDATA(instance);
1235 int transfered, saved_data = 0, overrun = 0, cnt, toPIO; 1247 int transfered, saved_data = 0, overrun = 0, cnt, toPIO;
1236 unsigned char **data, p; 1248 unsigned char **data, p;
1237 volatile int *count; 1249 volatile int *count;
1238 1250
1239 if (!hostdata->connected) { 1251 if (!hostdata->connected) {
1240 printk(KERN_WARNING "scsi%d: received end of DMA interrupt with " 1252 printk(KERN_WARNING "scsi%d: received end of DMA interrupt with "
1241 "no connected cmd\n", HOSTNO); 1253 "no connected cmd\n", HOSTNO);
1242 return; 1254 return;
1243 }
1244
1245 if (atari_read_overruns) {
1246 p = hostdata->connected->SCp.phase;
1247 if (p & SR_IO) {
1248 udelay(10);
1249 if ((((NCR5380_read(BUS_AND_STATUS_REG)) &
1250 (BASR_PHASE_MATCH|BASR_ACK)) ==
1251 (BASR_PHASE_MATCH|BASR_ACK))) {
1252 saved_data = NCR5380_read(INPUT_DATA_REG);
1253 overrun = 1;
1254 DMA_PRINTK("scsi%d: read overrun handled\n", HOSTNO);
1255 }
1256 } 1255 }
1257 } 1256
1258 1257 if (atari_read_overruns) {
1259 DMA_PRINTK("scsi%d: real DMA transfer complete, basr 0x%X, sr 0x%X\n", 1258 p = hostdata->connected->SCp.phase;
1260 HOSTNO, NCR5380_read(BUS_AND_STATUS_REG), 1259 if (p & SR_IO) {
1261 NCR5380_read(STATUS_REG)); 1260 udelay(10);
1262 1261 if ((NCR5380_read(BUS_AND_STATUS_REG) &
1263 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1262 (BASR_PHASE_MATCH|BASR_ACK)) ==
1264 NCR5380_write(MODE_REG, MR_BASE); 1263 (BASR_PHASE_MATCH|BASR_ACK)) {
1265 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1264 saved_data = NCR5380_read(INPUT_DATA_REG);
1266 1265 overrun = 1;
1267 transfered = hostdata->dma_len - NCR5380_dma_residual(instance); 1266 DMA_PRINTK("scsi%d: read overrun handled\n", HOSTNO);
1268 hostdata->dma_len = 0; 1267 }
1269 1268 }
1270 data = (unsigned char **) &(hostdata->connected->SCp.ptr); 1269 }
1271 count = &(hostdata->connected->SCp.this_residual); 1270
1272 *data += transfered; 1271 DMA_PRINTK("scsi%d: real DMA transfer complete, basr 0x%X, sr 0x%X\n",
1273 *count -= transfered; 1272 HOSTNO, NCR5380_read(BUS_AND_STATUS_REG),
1274 1273 NCR5380_read(STATUS_REG));
1275 if (atari_read_overruns) { 1274
1276 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) { 1275 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1277 cnt = toPIO = atari_read_overruns; 1276 NCR5380_write(MODE_REG, MR_BASE);
1278 if (overrun) { 1277 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1279 DMA_PRINTK("Got an input overrun, using saved byte\n"); 1278
1280 *(*data)++ = saved_data; 1279 transfered = hostdata->dma_len - NCR5380_dma_residual(instance);
1281 (*count)--; 1280 hostdata->dma_len = 0;
1282 cnt--; 1281
1283 toPIO--; 1282 data = (unsigned char **)&hostdata->connected->SCp.ptr;
1284 } 1283 count = &hostdata->connected->SCp.this_residual;
1285 DMA_PRINTK("Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data); 1284 *data += transfered;
1286 NCR5380_transfer_pio(instance, &p, &cnt, data); 1285 *count -= transfered;
1287 *count -= toPIO - cnt; 1286
1287 if (atari_read_overruns) {
1288 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
1289 cnt = toPIO = atari_read_overruns;
1290 if (overrun) {
1291 DMA_PRINTK("Got an input overrun, using saved byte\n");
1292 *(*data)++ = saved_data;
1293 (*count)--;
1294 cnt--;
1295 toPIO--;
1296 }
1297 DMA_PRINTK("Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data);
1298 NCR5380_transfer_pio(instance, &p, &cnt, data);
1299 *count -= toPIO - cnt;
1300 }
1288 } 1301 }
1289 }
1290} 1302}
1291#endif /* REAL_DMA */ 1303#endif /* REAL_DMA */
1292 1304
1293 1305
1294/* 1306/*
1295 * Function : void NCR5380_intr (int irq) 1307 * Function : void NCR5380_intr (int irq)
1296 * 1308 *
1297 * Purpose : handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses 1309 * Purpose : handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
1298 * from the disconnected queue, and restarting NCR5380_main() 1310 * from the disconnected queue, and restarting NCR5380_main()
1299 * as required. 1311 * as required.
1300 * 1312 *
1301 * Inputs : int irq, irq that caused this interrupt. 1313 * Inputs : int irq, irq that caused this interrupt.
1302 * 1314 *
1303 */ 1315 */
1304 1316
1305static irqreturn_t NCR5380_intr (int irq, void *dev_id) 1317static irqreturn_t NCR5380_intr(int irq, void *dev_id)
1306{ 1318{
1307 struct Scsi_Host *instance = first_instance; 1319 struct Scsi_Host *instance = first_instance;
1308 int done = 1, handled = 0; 1320 int done = 1, handled = 0;
1309 unsigned char basr; 1321 unsigned char basr;
1310 1322
1311 INT_PRINTK("scsi%d: NCR5380 irq triggered\n", HOSTNO); 1323 INT_PRINTK("scsi%d: NCR5380 irq triggered\n", HOSTNO);
1312 1324
1313 /* Look for pending interrupts */ 1325 /* Look for pending interrupts */
1314 basr = NCR5380_read(BUS_AND_STATUS_REG); 1326 basr = NCR5380_read(BUS_AND_STATUS_REG);
1315 INT_PRINTK("scsi%d: BASR=%02x\n", HOSTNO, basr); 1327 INT_PRINTK("scsi%d: BASR=%02x\n", HOSTNO, basr);
1316 /* dispatch to appropriate routine if found and done=0 */ 1328 /* dispatch to appropriate routine if found and done=0 */
1317 if (basr & BASR_IRQ) { 1329 if (basr & BASR_IRQ) {
1318 NCR_PRINT(NDEBUG_INTR); 1330 NCR_PRINT(NDEBUG_INTR);
1319 if ((NCR5380_read(STATUS_REG) & (SR_SEL|SR_IO)) == (SR_SEL|SR_IO)) { 1331 if ((NCR5380_read(STATUS_REG) & (SR_SEL|SR_IO)) == (SR_SEL|SR_IO)) {
1320 done = 0; 1332 done = 0;
1321 ENABLE_IRQ(); 1333 ENABLE_IRQ();
1322 INT_PRINTK("scsi%d: SEL interrupt\n", HOSTNO); 1334 INT_PRINTK("scsi%d: SEL interrupt\n", HOSTNO);
1323 NCR5380_reselect(instance); 1335 NCR5380_reselect(instance);
1324 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1336 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1325 } 1337 } else if (basr & BASR_PARITY_ERROR) {
1326 else if (basr & BASR_PARITY_ERROR) { 1338 INT_PRINTK("scsi%d: PARITY interrupt\n", HOSTNO);
1327 INT_PRINTK("scsi%d: PARITY interrupt\n", HOSTNO); 1339 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1328 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1340 } else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) {
1329 } 1341 INT_PRINTK("scsi%d: RESET interrupt\n", HOSTNO);
1330 else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) { 1342 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1331 INT_PRINTK("scsi%d: RESET interrupt\n", HOSTNO); 1343 } else {
1332 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1344 /*
1333 } 1345 * The rest of the interrupt conditions can occur only during a
1334 else { 1346 * DMA transfer
1335 /* 1347 */
1336 * The rest of the interrupt conditions can occur only during a
1337 * DMA transfer
1338 */
1339 1348
1340#if defined(REAL_DMA) 1349#if defined(REAL_DMA)
1341 /* 1350 /*
1342 * We should only get PHASE MISMATCH and EOP interrupts if we have 1351 * We should only get PHASE MISMATCH and EOP interrupts if we have
1343 * DMA enabled, so do a sanity check based on the current setting 1352 * DMA enabled, so do a sanity check based on the current setting
1344 * of the MODE register. 1353 * of the MODE register.
1345 */ 1354 */
1346 1355
1347 if ((NCR5380_read(MODE_REG) & MR_DMA_MODE) && 1356 if ((NCR5380_read(MODE_REG) & MR_DMA_MODE) &&
1348 ((basr & BASR_END_DMA_TRANSFER) || 1357 ((basr & BASR_END_DMA_TRANSFER) ||
1349 !(basr & BASR_PHASE_MATCH))) { 1358 !(basr & BASR_PHASE_MATCH))) {
1350 1359
1351 INT_PRINTK("scsi%d: PHASE MISM or EOP interrupt\n", HOSTNO); 1360 INT_PRINTK("scsi%d: PHASE MISM or EOP interrupt\n", HOSTNO);
1352 NCR5380_dma_complete( instance ); 1361 NCR5380_dma_complete( instance );
1353 done = 0; 1362 done = 0;
1354 ENABLE_IRQ(); 1363 ENABLE_IRQ();
1355 } else 1364 } else
1356#endif /* REAL_DMA */ 1365#endif /* REAL_DMA */
1357 { 1366 {
1358/* MS: Ignore unknown phase mismatch interrupts (caused by EOP interrupt) */ 1367/* MS: Ignore unknown phase mismatch interrupts (caused by EOP interrupt) */
1359 if (basr & BASR_PHASE_MATCH) 1368 if (basr & BASR_PHASE_MATCH)
1360 printk(KERN_NOTICE "scsi%d: unknown interrupt, " 1369 printk(KERN_NOTICE "scsi%d: unknown interrupt, "
1361 "BASR 0x%x, MR 0x%x, SR 0x%x\n", 1370 "BASR 0x%x, MR 0x%x, SR 0x%x\n",
1362 HOSTNO, basr, NCR5380_read(MODE_REG), 1371 HOSTNO, basr, NCR5380_read(MODE_REG),
1363 NCR5380_read(STATUS_REG)); 1372 NCR5380_read(STATUS_REG));
1364 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1373 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1365 } 1374 }
1366 } /* if !(SELECTION || PARITY) */ 1375 } /* if !(SELECTION || PARITY) */
1367 handled = 1; 1376 handled = 1;
1368 } /* BASR & IRQ */ 1377 } /* BASR & IRQ */ else {
1369 else { 1378 printk(KERN_NOTICE "scsi%d: interrupt without IRQ bit set in BASR, "
1370 printk(KERN_NOTICE "scsi%d: interrupt without IRQ bit set in BASR, " 1379 "BASR 0x%X, MR 0x%X, SR 0x%x\n", HOSTNO, basr,
1371 "BASR 0x%X, MR 0x%X, SR 0x%x\n", HOSTNO, basr, 1380 NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG));
1372 NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG)); 1381 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1373 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1382 }
1374 } 1383
1375 1384 if (!done) {
1376 if (!done) { 1385 INT_PRINTK("scsi%d: in int routine, calling main\n", HOSTNO);
1377 INT_PRINTK("scsi%d: in int routine, calling main\n", HOSTNO); 1386 /* Put a call to NCR5380_main() on the queue... */
1378 /* Put a call to NCR5380_main() on the queue... */ 1387 queue_main();
1379 queue_main(); 1388 }
1380 } 1389 return IRQ_RETVAL(handled);
1381 return IRQ_RETVAL(handled);
1382} 1390}
1383 1391
1384#ifdef NCR5380_STATS 1392#ifdef NCR5380_STATS
1385static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd* cmd) 1393static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd *cmd)
1386{ 1394{
1387# ifdef NCR5380_STAT_LIMIT 1395# ifdef NCR5380_STAT_LIMIT
1388 if (cmd->request_bufflen > NCR5380_STAT_LIMIT) 1396 if (cmd->request_bufflen > NCR5380_STAT_LIMIT)
1389# endif 1397# endif
1390 switch (cmd->cmnd[0]) 1398 switch (cmd->cmnd[0]) {
1391 { 1399 case WRITE:
1392 case WRITE: 1400 case WRITE_6:
1393 case WRITE_6: 1401 case WRITE_10:
1394 case WRITE_10: 1402 hostdata->time_write[cmd->device->id] += (jiffies - hostdata->timebase);
1395 hostdata->time_write[cmd->device->id] += (jiffies - hostdata->timebase); 1403 /*hostdata->bytes_write[cmd->device->id] += cmd->request_bufflen;*/
1396 /*hostdata->bytes_write[cmd->device->id] += cmd->request_bufflen;*/ 1404 hostdata->pendingw--;
1397 hostdata->pendingw--; 1405 break;
1398 break; 1406 case READ:
1399 case READ: 1407 case READ_6:
1400 case READ_6: 1408 case READ_10:
1401 case READ_10: 1409 hostdata->time_read[cmd->device->id] += (jiffies - hostdata->timebase);
1402 hostdata->time_read[cmd->device->id] += (jiffies - hostdata->timebase); 1410 /*hostdata->bytes_read[cmd->device->id] += cmd->request_bufflen;*/
1403 /*hostdata->bytes_read[cmd->device->id] += cmd->request_bufflen;*/ 1411 hostdata->pendingr--;
1404 hostdata->pendingr--; 1412 break;
1405 break; 1413 }
1406 }
1407} 1414}
1408#endif 1415#endif
1409 1416
1410/* 1417/*
1411 * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, 1418 * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
1412 * int tag); 1419 * int tag);
1413 * 1420 *
1414 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command, 1421 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1415 * including ARBITRATION, SELECTION, and initial message out for 1422 * including ARBITRATION, SELECTION, and initial message out for
1416 * IDENTIFY and queue messages. 1423 * IDENTIFY and queue messages.
1417 * 1424 *
1418 * Inputs : instance - instantiation of the 5380 driver on which this 1425 * Inputs : instance - instantiation of the 5380 driver on which this
1419 * target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for 1426 * target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for
1420 * new tag, TAG_NONE for untagged queueing, otherwise set to the tag for 1427 * new tag, TAG_NONE for untagged queueing, otherwise set to the tag for
1421 * the command that is presently connected. 1428 * the command that is presently connected.
1422 * 1429 *
1423 * Returns : -1 if selection could not execute for some reason, 1430 * Returns : -1 if selection could not execute for some reason,
1424 * 0 if selection succeeded or failed because the target 1431 * 0 if selection succeeded or failed because the target
1425 * did not respond. 1432 * did not respond.
1426 * 1433 *
1427 * Side effects : 1434 * Side effects :
1428 * If bus busy, arbitration failed, etc, NCR5380_select() will exit 1435 * If bus busy, arbitration failed, etc, NCR5380_select() will exit
1429 * with registers as they should have been on entry - ie 1436 * with registers as they should have been on entry - ie
1430 * SELECT_ENABLE will be set appropriately, the NCR5380 1437 * SELECT_ENABLE will be set appropriately, the NCR5380
1431 * will cease to drive any SCSI bus signals. 1438 * will cease to drive any SCSI bus signals.
1432 * 1439 *
1433 * If successful : I_T_L or I_T_L_Q nexus will be established, 1440 * If successful : I_T_L or I_T_L_Q nexus will be established,
1434 * instance->connected will be set to cmd. 1441 * instance->connected will be set to cmd.
1435 * SELECT interrupt will be disabled. 1442 * SELECT interrupt will be disabled.
1436 * 1443 *
1437 * If failed (no target) : cmd->scsi_done() will be called, and the 1444 * If failed (no target) : cmd->scsi_done() will be called, and the
1438 * cmd->result host byte set to DID_BAD_TARGET. 1445 * cmd->result host byte set to DID_BAD_TARGET.
1439 */ 1446 */
1440 1447
1441static int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag) 1448static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
1442{ 1449{
1443 SETUP_HOSTDATA(instance); 1450 SETUP_HOSTDATA(instance);
1444 unsigned char tmp[3], phase; 1451 unsigned char tmp[3], phase;
1445 unsigned char *data; 1452 unsigned char *data;
1446 int len; 1453 int len;
1447 unsigned long timeout; 1454 unsigned long timeout;
1448 unsigned long flags; 1455 unsigned long flags;
1449 1456
1450 hostdata->restart_select = 0; 1457 hostdata->restart_select = 0;
1451 NCR_PRINT(NDEBUG_ARBITRATION); 1458 NCR_PRINT(NDEBUG_ARBITRATION);
1452 ARB_PRINTK("scsi%d: starting arbitration, id = %d\n", HOSTNO, 1459 ARB_PRINTK("scsi%d: starting arbitration, id = %d\n", HOSTNO,
1453 instance->this_id); 1460 instance->this_id);
1454 1461
1455 /* 1462 /*
1456 * Set the phase bits to 0, otherwise the NCR5380 won't drive the 1463 * Set the phase bits to 0, otherwise the NCR5380 won't drive the
1457 * data bus during SELECTION. 1464 * data bus during SELECTION.
1458 */ 1465 */
1459 1466
1460 local_irq_save(flags); 1467 local_irq_save(flags);
1461 if (hostdata->connected) { 1468 if (hostdata->connected) {
1462 local_irq_restore(flags); 1469 local_irq_restore(flags);
1463 return -1; 1470 return -1;
1464 } 1471 }
1465 NCR5380_write(TARGET_COMMAND_REG, 0); 1472 NCR5380_write(TARGET_COMMAND_REG, 0);
1466 1473
1474 /*
1475 * Start arbitration.
1476 */
1467 1477
1468 /* 1478 NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1469 * Start arbitration. 1479 NCR5380_write(MODE_REG, MR_ARBITRATE);
1470 */
1471
1472 NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1473 NCR5380_write(MODE_REG, MR_ARBITRATE);
1474 1480
1475 local_irq_restore(flags); 1481 local_irq_restore(flags);
1476 1482
1477 /* Wait for arbitration logic to complete */ 1483 /* Wait for arbitration logic to complete */
1478#if defined(NCR_TIMEOUT) 1484#if defined(NCR_TIMEOUT)
1479 { 1485 {
1480 unsigned long timeout = jiffies + 2*NCR_TIMEOUT; 1486 unsigned long timeout = jiffies + 2*NCR_TIMEOUT;
1481 1487
1482 while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) 1488 while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) &&
1483 && time_before(jiffies, timeout) && !hostdata->connected) 1489 time_before(jiffies, timeout) && !hostdata->connected)
1484 ; 1490 ;
1485 if (time_after_eq(jiffies, timeout)) 1491 if (time_after_eq(jiffies, timeout)) {
1486 { 1492 printk("scsi : arbitration timeout at %d\n", __LINE__);
1487 printk("scsi : arbitration timeout at %d\n", __LINE__); 1493 NCR5380_write(MODE_REG, MR_BASE);
1488 NCR5380_write(MODE_REG, MR_BASE); 1494 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1489 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1495 return -1;
1490 return -1; 1496 }
1491 } 1497 }
1492 }
1493#else /* NCR_TIMEOUT */ 1498#else /* NCR_TIMEOUT */
1494 while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) 1499 while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) &&
1495 && !hostdata->connected); 1500 !hostdata->connected)
1501 ;
1496#endif 1502#endif
1497 1503
1498 ARB_PRINTK("scsi%d: arbitration complete\n", HOSTNO); 1504 ARB_PRINTK("scsi%d: arbitration complete\n", HOSTNO);
1499 1505
1500 if (hostdata->connected) { 1506 if (hostdata->connected) {
1501 NCR5380_write(MODE_REG, MR_BASE); 1507 NCR5380_write(MODE_REG, MR_BASE);
1502 return -1; 1508 return -1;
1503 } 1509 }
1504 /* 1510 /*
1505 * The arbitration delay is 2.2us, but this is a minimum and there is 1511 * The arbitration delay is 2.2us, but this is a minimum and there is
1506 * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate 1512 * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate
1507 * the integral nature of udelay(). 1513 * the integral nature of udelay().
1508 * 1514 *
1509 */ 1515 */
1510 1516
1511 udelay(3); 1517 udelay(3);
1512 1518
1513 /* Check for lost arbitration */ 1519 /* Check for lost arbitration */
1514 if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) || 1520 if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1515 (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) || 1521 (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
1516 (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) || 1522 (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1517 hostdata->connected) { 1523 hostdata->connected) {
1518 NCR5380_write(MODE_REG, MR_BASE); 1524 NCR5380_write(MODE_REG, MR_BASE);
1519 ARB_PRINTK("scsi%d: lost arbitration, deasserting MR_ARBITRATE\n", 1525 ARB_PRINTK("scsi%d: lost arbitration, deasserting MR_ARBITRATE\n",
1520 HOSTNO); 1526 HOSTNO);
1521 return -1; 1527 return -1;
1522 } 1528 }
1523
1524 /* after/during arbitration, BSY should be asserted.
1525 IBM DPES-31080 Version S31Q works now */
1526 /* Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman) */
1527 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_SEL |
1528 ICR_ASSERT_BSY ) ;
1529
1530 if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1531 hostdata->connected) {
1532 NCR5380_write(MODE_REG, MR_BASE);
1533 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1534 ARB_PRINTK("scsi%d: lost arbitration, deasserting ICR_ASSERT_SEL\n",
1535 HOSTNO);
1536 return -1;
1537 }
1538 1529
1539 /* 1530 /* after/during arbitration, BSY should be asserted.
1540 * Again, bus clear + bus settle time is 1.2us, however, this is 1531 IBM DPES-31080 Version S31Q works now */
1541 * a minimum so we'll udelay ceil(1.2) 1532 /* Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman) */
1542 */ 1533 NCR5380_write(INITIATOR_COMMAND_REG,
1534 ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY);
1535
1536 if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1537 hostdata->connected) {
1538 NCR5380_write(MODE_REG, MR_BASE);
1539 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1540 ARB_PRINTK("scsi%d: lost arbitration, deasserting ICR_ASSERT_SEL\n",
1541 HOSTNO);
1542 return -1;
1543 }
1544
1545 /*
1546 * Again, bus clear + bus settle time is 1.2us, however, this is
1547 * a minimum so we'll udelay ceil(1.2)
1548 */
1543 1549
1544#ifdef CONFIG_ATARI_SCSI_TOSHIBA_DELAY 1550#ifdef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
1545 /* ++roman: But some targets (see above :-) seem to need a bit more... */ 1551 /* ++roman: But some targets (see above :-) seem to need a bit more... */
1546 udelay(15); 1552 udelay(15);
1547#else 1553#else
1548 udelay(2); 1554 udelay(2);
1549#endif 1555#endif
1550 1556
1551 if (hostdata->connected) { 1557 if (hostdata->connected) {
1558 NCR5380_write(MODE_REG, MR_BASE);
1559 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1560 return -1;
1561 }
1562
1563 ARB_PRINTK("scsi%d: won arbitration\n", HOSTNO);
1564
1565 /*
1566 * Now that we have won arbitration, start Selection process, asserting
1567 * the host and target ID's on the SCSI bus.
1568 */
1569
1570 NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));
1571
1572 /*
1573 * Raise ATN while SEL is true before BSY goes false from arbitration,
1574 * since this is the only way to guarantee that we'll get a MESSAGE OUT
1575 * phase immediately after selection.
1576 */
1577
1578 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY |
1579 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
1552 NCR5380_write(MODE_REG, MR_BASE); 1580 NCR5380_write(MODE_REG, MR_BASE);
1553 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1554 return -1;
1555 }
1556 1581
1557 ARB_PRINTK("scsi%d: won arbitration\n", HOSTNO); 1582 /*
1583 * Reselect interrupts must be turned off prior to the dropping of BSY,
1584 * otherwise we will trigger an interrupt.
1585 */
1586
1587 if (hostdata->connected) {
1588 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1589 return -1;
1590 }
1591
1592 NCR5380_write(SELECT_ENABLE_REG, 0);
1558 1593
1559 /* 1594 /*
1560 * Now that we have won arbitration, start Selection process, asserting 1595 * The initiator shall then wait at least two deskew delays and release
1561 * the host and target ID's on the SCSI bus. 1596 * the BSY signal.
1562 */ 1597 */
1598 udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */
1599
1600 /* Reset BSY */
1601 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA |
1602 ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1603
1604 /*
1605 * Something weird happens when we cease to drive BSY - looks
1606 * like the board/chip is letting us do another read before the
1607 * appropriate propagation delay has expired, and we're confusing
1608 * a BSY signal from ourselves as the target's response to SELECTION.
1609 *
1610 * A small delay (the 'C++' frontend breaks the pipeline with an
1611 * unnecessary jump, making it work on my 386-33/Trantor T128, the
1612 * tighter 'C' code breaks and requires this) solves the problem -
1613 * the 1 us delay is arbitrary, and only used because this delay will
1614 * be the same on other platforms and since it works here, it should
1615 * work there.
1616 *
1617 * wingel suggests that this could be due to failing to wait
1618 * one deskew delay.
1619 */
1563 1620
1564 NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id))); 1621 udelay(1);
1565 1622
1566 /* 1623 SEL_PRINTK("scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
1567 * Raise ATN while SEL is true before BSY goes false from arbitration,
1568 * since this is the only way to guarantee that we'll get a MESSAGE OUT
1569 * phase immediately after selection.
1570 */
1571 1624
1572 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY | 1625 /*
1573 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL )); 1626 * The SCSI specification calls for a 250 ms timeout for the actual
1574 NCR5380_write(MODE_REG, MR_BASE); 1627 * selection.
1628 */
1575 1629
1576 /* 1630 timeout = jiffies + 25;
1577 * Reselect interrupts must be turned off prior to the dropping of BSY,
1578 * otherwise we will trigger an interrupt.
1579 */
1580 1631
1581 if (hostdata->connected) { 1632 /*
1582 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1633 * XXX very interesting - we're seeing a bounce where the BSY we
1583 return -1; 1634 * asserted is being reflected / still asserted (propagation delay?)
1584 } 1635 * and it's detecting as true. Sigh.
1585 1636 */
1586 NCR5380_write(SELECT_ENABLE_REG, 0);
1587
1588 /*
1589 * The initiator shall then wait at least two deskew delays and release
1590 * the BSY signal.
1591 */
1592 udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */
1593
1594 /* Reset BSY */
1595 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA |
1596 ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1597
1598 /*
1599 * Something weird happens when we cease to drive BSY - looks
1600 * like the board/chip is letting us do another read before the
1601 * appropriate propagation delay has expired, and we're confusing
1602 * a BSY signal from ourselves as the target's response to SELECTION.
1603 *
1604 * A small delay (the 'C++' frontend breaks the pipeline with an
1605 * unnecessary jump, making it work on my 386-33/Trantor T128, the
1606 * tighter 'C' code breaks and requires this) solves the problem -
1607 * the 1 us delay is arbitrary, and only used because this delay will
1608 * be the same on other platforms and since it works here, it should
1609 * work there.
1610 *
1611 * wingel suggests that this could be due to failing to wait
1612 * one deskew delay.
1613 */
1614
1615 udelay(1);
1616
1617 SEL_PRINTK("scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
1618
1619 /*
1620 * The SCSI specification calls for a 250 ms timeout for the actual
1621 * selection.
1622 */
1623
1624 timeout = jiffies + 25;
1625
1626 /*
1627 * XXX very interesting - we're seeing a bounce where the BSY we
1628 * asserted is being reflected / still asserted (propagation delay?)
1629 * and it's detecting as true. Sigh.
1630 */
1631 1637
1632#if 0 1638#if 0
1633 /* ++roman: If a target conformed to the SCSI standard, it wouldn't assert 1639 /* ++roman: If a target conformed to the SCSI standard, it wouldn't assert
1634 * IO while SEL is true. But again, there are some disks out the in the 1640 * IO while SEL is true. But again, there are some disks out the in the
1635 * world that do that nevertheless. (Somebody claimed that this announces 1641 * world that do that nevertheless. (Somebody claimed that this announces
1636 * reselection capability of the target.) So we better skip that test and 1642 * reselection capability of the target.) So we better skip that test and
1637 * only wait for BSY... (Famous german words: Der Klügere gibt nach :-) 1643 * only wait for BSY... (Famous german words: Der Klügere gibt nach :-)
1638 */ 1644 */
1639 1645
1640 while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & 1646 while (time_before(jiffies, timeout) &&
1641 (SR_BSY | SR_IO))); 1647 !(NCR5380_read(STATUS_REG) & (SR_BSY | SR_IO)))
1642 1648 ;
1643 if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == 1649
1644 (SR_SEL | SR_IO)) { 1650 if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1645 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1651 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1646 NCR5380_reselect(instance); 1652 NCR5380_reselect(instance);
1647 printk (KERN_ERR "scsi%d: reselection after won arbitration?\n", 1653 printk(KERN_ERR "scsi%d: reselection after won arbitration?\n",
1648 HOSTNO); 1654 HOSTNO);
1649 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1655 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1650 return -1; 1656 return -1;
1651 } 1657 }
1652#else 1658#else
1653 while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY)); 1659 while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY))
1660 ;
1654#endif 1661#endif
1655 1662
1656 /* 1663 /*
1657 * No less than two deskew delays after the initiator detects the 1664 * No less than two deskew delays after the initiator detects the
1658 * BSY signal is true, it shall release the SEL signal and may 1665 * BSY signal is true, it shall release the SEL signal and may
1659 * change the DATA BUS. -wingel 1666 * change the DATA BUS. -wingel
1660 */ 1667 */
1661 1668
1662 udelay(1); 1669 udelay(1);
1663 1670
1664 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1671 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1665 1672
1666 if (!(NCR5380_read(STATUS_REG) & SR_BSY)) { 1673 if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
1667 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1674 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1668 if (hostdata->targets_present & (1 << cmd->device->id)) { 1675 if (hostdata->targets_present & (1 << cmd->device->id)) {
1669 printk(KERN_ERR "scsi%d: weirdness\n", HOSTNO); 1676 printk(KERN_ERR "scsi%d: weirdness\n", HOSTNO);
1670 if (hostdata->restart_select) 1677 if (hostdata->restart_select)
1671 printk(KERN_NOTICE "\trestart select\n"); 1678 printk(KERN_NOTICE "\trestart select\n");
1672 NCR_PRINT(NDEBUG_ANY); 1679 NCR_PRINT(NDEBUG_ANY);
1673 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1680 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1674 return -1; 1681 return -1;
1675 } 1682 }
1676 cmd->result = DID_BAD_TARGET << 16; 1683 cmd->result = DID_BAD_TARGET << 16;
1677#ifdef NCR5380_STATS 1684#ifdef NCR5380_STATS
1678 collect_stats(hostdata, cmd); 1685 collect_stats(hostdata, cmd);
1679#endif 1686#endif
1680#ifdef SUPPORT_TAGS 1687#ifdef SUPPORT_TAGS
1681 cmd_free_tag( cmd ); 1688 cmd_free_tag(cmd);
1682#endif 1689#endif
1683 cmd->scsi_done(cmd); 1690 cmd->scsi_done(cmd);
1684 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1691 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1685 SEL_PRINTK("scsi%d: target did not respond within 250ms\n", HOSTNO); 1692 SEL_PRINTK("scsi%d: target did not respond within 250ms\n", HOSTNO);
1686 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1693 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1687 return 0; 1694 return 0;
1688 } 1695 }
1689 1696
1690 hostdata->targets_present |= (1 << cmd->device->id); 1697 hostdata->targets_present |= (1 << cmd->device->id);
1691 1698
1692 /* 1699 /*
1693 * Since we followed the SCSI spec, and raised ATN while SEL 1700 * Since we followed the SCSI spec, and raised ATN while SEL
1694 * was true but before BSY was false during selection, the information 1701 * was true but before BSY was false during selection, the information
1695 * transfer phase should be a MESSAGE OUT phase so that we can send the 1702 * transfer phase should be a MESSAGE OUT phase so that we can send the
1696 * IDENTIFY message. 1703 * IDENTIFY message.
1697 * 1704 *
1698 * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG 1705 * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
1699 * message (2 bytes) with a tag ID that we increment with every command 1706 * message (2 bytes) with a tag ID that we increment with every command
1700 * until it wraps back to 0. 1707 * until it wraps back to 0.
1701 * 1708 *
1702 * XXX - it turns out that there are some broken SCSI-II devices, 1709 * XXX - it turns out that there are some broken SCSI-II devices,
1703 * which claim to support tagged queuing but fail when more than 1710 * which claim to support tagged queuing but fail when more than
1704 * some number of commands are issued at once. 1711 * some number of commands are issued at once.
1705 */ 1712 */
1706 1713
1707 /* Wait for start of REQ/ACK handshake */ 1714 /* Wait for start of REQ/ACK handshake */
1708 while (!(NCR5380_read(STATUS_REG) & SR_REQ)); 1715 while (!(NCR5380_read(STATUS_REG) & SR_REQ))
1709 1716 ;
1710 SEL_PRINTK("scsi%d: target %d selected, going into MESSAGE OUT phase.\n", 1717
1711 HOSTNO, cmd->device->id); 1718 SEL_PRINTK("scsi%d: target %d selected, going into MESSAGE OUT phase.\n",
1712 tmp[0] = IDENTIFY(1, cmd->device->lun); 1719 HOSTNO, cmd->device->id);
1720 tmp[0] = IDENTIFY(1, cmd->device->lun);
1713 1721
1714#ifdef SUPPORT_TAGS 1722#ifdef SUPPORT_TAGS
1715 if (cmd->tag != TAG_NONE) { 1723 if (cmd->tag != TAG_NONE) {
1716 tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG; 1724 tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG;
1717 tmp[2] = cmd->tag; 1725 tmp[2] = cmd->tag;
1718 len = 3; 1726 len = 3;
1719 } else 1727 } else
1720 len = 1; 1728 len = 1;
1721#else 1729#else
1722 len = 1; 1730 len = 1;
1723 cmd->tag=0; 1731 cmd->tag = 0;
1724#endif /* SUPPORT_TAGS */ 1732#endif /* SUPPORT_TAGS */
1725 1733
1726 /* Send message(s) */ 1734 /* Send message(s) */
1727 data = tmp; 1735 data = tmp;
1728 phase = PHASE_MSGOUT; 1736 phase = PHASE_MSGOUT;
1729 NCR5380_transfer_pio(instance, &phase, &len, &data); 1737 NCR5380_transfer_pio(instance, &phase, &len, &data);
1730 SEL_PRINTK("scsi%d: nexus established.\n", HOSTNO); 1738 SEL_PRINTK("scsi%d: nexus established.\n", HOSTNO);
1731 /* XXX need to handle errors here */ 1739 /* XXX need to handle errors here */
1732 hostdata->connected = cmd; 1740 hostdata->connected = cmd;
1733#ifndef SUPPORT_TAGS 1741#ifndef SUPPORT_TAGS
1734 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun); 1742 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
1735#endif 1743#endif
1736
1737 initialize_SCp(cmd);
1738 1744
1745 initialize_SCp(cmd);
1739 1746
1740 return 0; 1747 return 0;
1741} 1748}
1742 1749
1743/* 1750/*
1744 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 1751 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1745 * unsigned char *phase, int *count, unsigned char **data) 1752 * unsigned char *phase, int *count, unsigned char **data)
1746 * 1753 *
1747 * Purpose : transfers data in given phase using polled I/O 1754 * Purpose : transfers data in given phase using polled I/O
1748 * 1755 *
1749 * Inputs : instance - instance of driver, *phase - pointer to 1756 * Inputs : instance - instance of driver, *phase - pointer to
1750 * what phase is expected, *count - pointer to number of 1757 * what phase is expected, *count - pointer to number of
1751 * bytes to transfer, **data - pointer to data pointer. 1758 * bytes to transfer, **data - pointer to data pointer.
1752 * 1759 *
1753 * Returns : -1 when different phase is entered without transferring 1760 * Returns : -1 when different phase is entered without transferring
1754 * maximum number of bytes, 0 if all bytes are transfered or exit 1761 * maximum number of bytes, 0 if all bytes are transfered or exit
1755 * is in same phase. 1762 * is in same phase.
1756 * 1763 *
1757 * Also, *phase, *count, *data are modified in place. 1764 * Also, *phase, *count, *data are modified in place.
1758 * 1765 *
1759 * XXX Note : handling for bus free may be useful. 1766 * XXX Note : handling for bus free may be useful.
1760 */ 1767 */
1761 1768
1762/* 1769/*
1763 * Note : this code is not as quick as it could be, however it 1770 * Note : this code is not as quick as it could be, however it
1764 * IS 100% reliable, and for the actual data transfer where speed 1771 * IS 100% reliable, and for the actual data transfer where speed
1765 * counts, we will always do a pseudo DMA or DMA transfer. 1772 * counts, we will always do a pseudo DMA or DMA transfer.
1766 */ 1773 */
1767 1774
1768static int NCR5380_transfer_pio( struct Scsi_Host *instance, 1775static int NCR5380_transfer_pio(struct Scsi_Host *instance,
1769 unsigned char *phase, int *count, 1776 unsigned char *phase, int *count,
1770 unsigned char **data) 1777 unsigned char **data)
1771{ 1778{
1772 register unsigned char p = *phase, tmp; 1779 register unsigned char p = *phase, tmp;
1773 register int c = *count; 1780 register int c = *count;
1774 register unsigned char *d = *data; 1781 register unsigned char *d = *data;
1775 1782
1776 /* 1783 /*
1777 * The NCR5380 chip will only drive the SCSI bus when the 1784 * The NCR5380 chip will only drive the SCSI bus when the
1778 * phase specified in the appropriate bits of the TARGET COMMAND 1785 * phase specified in the appropriate bits of the TARGET COMMAND
1779 * REGISTER match the STATUS REGISTER 1786 * REGISTER match the STATUS REGISTER
1780 */
1781
1782 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1783
1784 do {
1785 /*
1786 * Wait for assertion of REQ, after which the phase bits will be
1787 * valid
1788 */ 1787 */
1789 while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ));
1790 1788
1791 HSH_PRINTK("scsi%d: REQ detected\n", HOSTNO); 1789 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1792 1790
1793 /* Check for phase mismatch */ 1791 do {
1794 if ((tmp & PHASE_MASK) != p) { 1792 /*
1795 PIO_PRINTK("scsi%d: phase mismatch\n", HOSTNO); 1793 * Wait for assertion of REQ, after which the phase bits will be
1796 NCR_PRINT_PHASE(NDEBUG_PIO); 1794 * valid
1797 break; 1795 */
1798 } 1796 while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ))
1797 ;
1799 1798
1800 /* Do actual transfer from SCSI bus to / from memory */ 1799 HSH_PRINTK("scsi%d: REQ detected\n", HOSTNO);
1801 if (!(p & SR_IO))
1802 NCR5380_write(OUTPUT_DATA_REG, *d);
1803 else
1804 *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1805 1800
1806 ++d; 1801 /* Check for phase mismatch */
1802 if ((tmp & PHASE_MASK) != p) {
1803 PIO_PRINTK("scsi%d: phase mismatch\n", HOSTNO);
1804 NCR_PRINT_PHASE(NDEBUG_PIO);
1805 break;
1806 }
1807 1807
1808 /* 1808 /* Do actual transfer from SCSI bus to / from memory */
1809 * The SCSI standard suggests that in MSGOUT phase, the initiator 1809 if (!(p & SR_IO))
1810 * should drop ATN on the last byte of the message phase 1810 NCR5380_write(OUTPUT_DATA_REG, *d);
1811 * after REQ has been asserted for the handshake but before 1811 else
1812 * the initiator raises ACK. 1812 *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1813 */
1814 1813
1815 if (!(p & SR_IO)) { 1814 ++d;
1816 if (!((p & SR_MSG) && c > 1)) {
1817 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1818 ICR_ASSERT_DATA);
1819 NCR_PRINT(NDEBUG_PIO);
1820 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1821 ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1822 } else {
1823 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1824 ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1825 NCR_PRINT(NDEBUG_PIO);
1826 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1827 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1828 }
1829 } else {
1830 NCR_PRINT(NDEBUG_PIO);
1831 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1832 }
1833 1815
1834 while (NCR5380_read(STATUS_REG) & SR_REQ); 1816 /*
1817 * The SCSI standard suggests that in MSGOUT phase, the initiator
1818 * should drop ATN on the last byte of the message phase
1819 * after REQ has been asserted for the handshake but before
1820 * the initiator raises ACK.
1821 */
1835 1822
1836 HSH_PRINTK("scsi%d: req false, handshake complete\n", HOSTNO); 1823 if (!(p & SR_IO)) {
1824 if (!((p & SR_MSG) && c > 1)) {
1825 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1826 NCR_PRINT(NDEBUG_PIO);
1827 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1828 ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1829 } else {
1830 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1831 ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1832 NCR_PRINT(NDEBUG_PIO);
1833 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1834 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1835 }
1836 } else {
1837 NCR_PRINT(NDEBUG_PIO);
1838 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1839 }
1837 1840
1838/* 1841 while (NCR5380_read(STATUS_REG) & SR_REQ)
1839 * We have several special cases to consider during REQ/ACK handshaking : 1842 ;
1840 * 1. We were in MSGOUT phase, and we are on the last byte of the 1843
1841 * message. ATN must be dropped as ACK is dropped. 1844 HSH_PRINTK("scsi%d: req false, handshake complete\n", HOSTNO);
1842 * 1845
1843 * 2. We are in a MSGIN phase, and we are on the last byte of the 1846 /*
1844 * message. We must exit with ACK asserted, so that the calling 1847 * We have several special cases to consider during REQ/ACK handshaking :
1845 * code may raise ATN before dropping ACK to reject the message. 1848 * 1. We were in MSGOUT phase, and we are on the last byte of the
1846 * 1849 * message. ATN must be dropped as ACK is dropped.
1847 * 3. ACK and ATN are clear and the target may proceed as normal. 1850 *
1848 */ 1851 * 2. We are in a MSGIN phase, and we are on the last byte of the
1849 if (!(p == PHASE_MSGIN && c == 1)) { 1852 * message. We must exit with ACK asserted, so that the calling
1850 if (p == PHASE_MSGOUT && c > 1) 1853 * code may raise ATN before dropping ACK to reject the message.
1851 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1854 *
1852 else 1855 * 3. ACK and ATN are clear and the target may proceed as normal.
1853 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1856 */
1854 } 1857 if (!(p == PHASE_MSGIN && c == 1)) {
1855 } while (--c); 1858 if (p == PHASE_MSGOUT && c > 1)
1856 1859 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1857 PIO_PRINTK("scsi%d: residual %d\n", HOSTNO, c); 1860 else
1858 1861 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1859 *count = c; 1862 }
1860 *data = d; 1863 } while (--c);
1861 tmp = NCR5380_read(STATUS_REG); 1864
1862 /* The phase read from the bus is valid if either REQ is (already) 1865 PIO_PRINTK("scsi%d: residual %d\n", HOSTNO, c);
1863 * asserted or if ACK hasn't been released yet. The latter is the case if 1866
1864 * we're in MSGIN and all wanted bytes have been received. */ 1867 *count = c;
1865 if ((tmp & SR_REQ) || (p == PHASE_MSGIN && c == 0)) 1868 *data = d;
1866 *phase = tmp & PHASE_MASK; 1869 tmp = NCR5380_read(STATUS_REG);
1867 else 1870 /* The phase read from the bus is valid if either REQ is (already)
1868 *phase = PHASE_UNKNOWN; 1871 * asserted or if ACK hasn't been released yet. The latter is the case if
1869 1872 * we're in MSGIN and all wanted bytes have been received.
1870 if (!c || (*phase == p)) 1873 */
1871 return 0; 1874 if ((tmp & SR_REQ) || (p == PHASE_MSGIN && c == 0))
1872 else 1875 *phase = tmp & PHASE_MASK;
1873 return -1; 1876 else
1877 *phase = PHASE_UNKNOWN;
1878
1879 if (!c || (*phase == p))
1880 return 0;
1881 else
1882 return -1;
1874} 1883}
1875 1884
1876/* 1885/*
1877 * Function : do_abort (Scsi_Host *host) 1886 * Function : do_abort (Scsi_Host *host)
1878 * 1887 *
1879 * Purpose : abort the currently established nexus. Should only be 1888 * Purpose : abort the currently established nexus. Should only be
1880 * called from a routine which can drop into a 1889 * called from a routine which can drop into a
1881 * 1890 *
1882 * Returns : 0 on success, -1 on failure. 1891 * Returns : 0 on success, -1 on failure.
1883 */ 1892 */
1884 1893
1885static int do_abort (struct Scsi_Host *host) 1894static int do_abort(struct Scsi_Host *host)
1886{ 1895{
1887 unsigned char tmp, *msgptr, phase; 1896 unsigned char tmp, *msgptr, phase;
1888 int len; 1897 int len;
1889 1898
1890 /* Request message out phase */ 1899 /* Request message out phase */
1891 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1892
1893 /*
1894 * Wait for the target to indicate a valid phase by asserting
1895 * REQ. Once this happens, we'll have either a MSGOUT phase
1896 * and can immediately send the ABORT message, or we'll have some
1897 * other phase and will have to source/sink data.
1898 *
1899 * We really don't care what value was on the bus or what value
1900 * the target sees, so we just handshake.
1901 */
1902
1903 while (!(tmp = NCR5380_read(STATUS_REG)) & SR_REQ);
1904
1905 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1906
1907 if ((tmp & PHASE_MASK) != PHASE_MSGOUT) {
1908 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
1909 ICR_ASSERT_ACK);
1910 while (NCR5380_read(STATUS_REG) & SR_REQ);
1911 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1900 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1912 } 1901
1913 1902 /*
1914 tmp = ABORT; 1903 * Wait for the target to indicate a valid phase by asserting
1915 msgptr = &tmp; 1904 * REQ. Once this happens, we'll have either a MSGOUT phase
1916 len = 1; 1905 * and can immediately send the ABORT message, or we'll have some
1917 phase = PHASE_MSGOUT; 1906 * other phase and will have to source/sink data.
1918 NCR5380_transfer_pio (host, &phase, &len, &msgptr); 1907 *
1919 1908 * We really don't care what value was on the bus or what value
1920 /* 1909 * the target sees, so we just handshake.
1921 * If we got here, and the command completed successfully, 1910 */
1922 * we're about to go into bus free state. 1911
1923 */ 1912 while (!(tmp = NCR5380_read(STATUS_REG)) & SR_REQ)
1924 1913 ;
1925 return len ? -1 : 0; 1914
1915 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1916
1917 if ((tmp & PHASE_MASK) != PHASE_MSGOUT) {
1918 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
1919 ICR_ASSERT_ACK);
1920 while (NCR5380_read(STATUS_REG) & SR_REQ)
1921 ;
1922 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1923 }
1924
1925 tmp = ABORT;
1926 msgptr = &tmp;
1927 len = 1;
1928 phase = PHASE_MSGOUT;
1929 NCR5380_transfer_pio(host, &phase, &len, &msgptr);
1930
1931 /*
1932 * If we got here, and the command completed successfully,
1933 * we're about to go into bus free state.
1934 */
1935
1936 return len ? -1 : 0;
1926} 1937}
1927 1938
1928#if defined(REAL_DMA) 1939#if defined(REAL_DMA)
1929/* 1940/*
1930 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 1941 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1931 * unsigned char *phase, int *count, unsigned char **data) 1942 * unsigned char *phase, int *count, unsigned char **data)
1932 * 1943 *
1933 * Purpose : transfers data in given phase using either real 1944 * Purpose : transfers data in given phase using either real
1934 * or pseudo DMA. 1945 * or pseudo DMA.
1935 * 1946 *
1936 * Inputs : instance - instance of driver, *phase - pointer to 1947 * Inputs : instance - instance of driver, *phase - pointer to
1937 * what phase is expected, *count - pointer to number of 1948 * what phase is expected, *count - pointer to number of
1938 * bytes to transfer, **data - pointer to data pointer. 1949 * bytes to transfer, **data - pointer to data pointer.
1939 * 1950 *
1940 * Returns : -1 when different phase is entered without transferring 1951 * Returns : -1 when different phase is entered without transferring
1941 * maximum number of bytes, 0 if all bytes or transfered or exit 1952 * maximum number of bytes, 0 if all bytes or transfered or exit
1942 * is in same phase. 1953 * is in same phase.
1943 * 1954 *
1944 * Also, *phase, *count, *data are modified in place. 1955 * Also, *phase, *count, *data are modified in place.
1945 * 1956 *
1946 */ 1957 */
1947 1958
1948 1959
1949static int NCR5380_transfer_dma( struct Scsi_Host *instance, 1960static int NCR5380_transfer_dma(struct Scsi_Host *instance,
1950 unsigned char *phase, int *count, 1961 unsigned char *phase, int *count,
1951 unsigned char **data) 1962 unsigned char **data)
1952{ 1963{
1953 SETUP_HOSTDATA(instance); 1964 SETUP_HOSTDATA(instance);
1954 register int c = *count; 1965 register int c = *count;
1955 register unsigned char p = *phase; 1966 register unsigned char p = *phase;
1956 register unsigned char *d = *data; 1967 register unsigned char *d = *data;
1957 unsigned char tmp; 1968 unsigned char tmp;
1958 unsigned long flags; 1969 unsigned long flags;
1959 1970
1960 if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) { 1971 if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1961 *phase = tmp; 1972 *phase = tmp;
1962 return -1; 1973 return -1;
1963 } 1974 }
1964 1975
1965 if (atari_read_overruns && (p & SR_IO)) { 1976 if (atari_read_overruns && (p & SR_IO))
1966 c -= atari_read_overruns; 1977 c -= atari_read_overruns;
1967 }
1968 1978
1969 DMA_PRINTK("scsi%d: initializing DMA for %s, %d bytes %s %p\n", 1979 DMA_PRINTK("scsi%d: initializing DMA for %s, %d bytes %s %p\n",
1970 HOSTNO, (p & SR_IO) ? "reading" : "writing", 1980 HOSTNO, (p & SR_IO) ? "reading" : "writing",
1971 c, (p & SR_IO) ? "to" : "from", d); 1981 c, (p & SR_IO) ? "to" : "from", d);
1972 1982
1973 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 1983 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1974 1984
1975#ifdef REAL_DMA 1985#ifdef REAL_DMA
1976 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY); 1986 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY);
1977#endif /* def REAL_DMA */ 1987#endif /* def REAL_DMA */
1978 1988
1979 if (IS_A_TT()) { 1989 if (IS_A_TT()) {
1980 /* On the Medusa, it is a must to initialize the DMA before 1990 /* On the Medusa, it is a must to initialize the DMA before
1981 * starting the NCR. This is also the cleaner way for the TT. 1991 * starting the NCR. This is also the cleaner way for the TT.
1982 */ 1992 */
1983 local_irq_save(flags); 1993 local_irq_save(flags);
1984 hostdata->dma_len = (p & SR_IO) ? 1994 hostdata->dma_len = (p & SR_IO) ?
1985 NCR5380_dma_read_setup(instance, d, c) : 1995 NCR5380_dma_read_setup(instance, d, c) :
1986 NCR5380_dma_write_setup(instance, d, c); 1996 NCR5380_dma_write_setup(instance, d, c);
1987 local_irq_restore(flags); 1997 local_irq_restore(flags);
1988 } 1998 }
1989 1999
1990 if (p & SR_IO) 2000 if (p & SR_IO)
1991 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0); 2001 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1992 else { 2002 else {
1993 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 2003 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1994 NCR5380_write(START_DMA_SEND_REG, 0); 2004 NCR5380_write(START_DMA_SEND_REG, 0);
1995 } 2005 }
1996 2006
1997 if (!IS_A_TT()) { 2007 if (!IS_A_TT()) {
1998 /* On the Falcon, the DMA setup must be done after the last */ 2008 /* On the Falcon, the DMA setup must be done after the last */
1999 /* NCR access, else the DMA setup gets trashed! 2009 /* NCR access, else the DMA setup gets trashed!
2000 */ 2010 */
2001 local_irq_save(flags); 2011 local_irq_save(flags);
2002 hostdata->dma_len = (p & SR_IO) ? 2012 hostdata->dma_len = (p & SR_IO) ?
2003 NCR5380_dma_read_setup(instance, d, c) : 2013 NCR5380_dma_read_setup(instance, d, c) :
2004 NCR5380_dma_write_setup(instance, d, c); 2014 NCR5380_dma_write_setup(instance, d, c);
2005 local_irq_restore(flags); 2015 local_irq_restore(flags);
2006 } 2016 }
2007 return 0; 2017 return 0;
2008} 2018}
2009#endif /* defined(REAL_DMA) */ 2019#endif /* defined(REAL_DMA) */
2010 2020
2011/* 2021/*
2012 * Function : NCR5380_information_transfer (struct Scsi_Host *instance) 2022 * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
2013 * 2023 *
2014 * Purpose : run through the various SCSI phases and do as the target 2024 * Purpose : run through the various SCSI phases and do as the target
2015 * directs us to. Operates on the currently connected command, 2025 * directs us to. Operates on the currently connected command,
2016 * instance->connected. 2026 * instance->connected.
2017 * 2027 *
2018 * Inputs : instance, instance for which we are doing commands 2028 * Inputs : instance, instance for which we are doing commands
2019 * 2029 *
2020 * Side effects : SCSI things happen, the disconnected queue will be 2030 * Side effects : SCSI things happen, the disconnected queue will be
2021 * modified if a command disconnects, *instance->connected will 2031 * modified if a command disconnects, *instance->connected will
2022 * change. 2032 * change.
2023 * 2033 *
2024 * XXX Note : we need to watch for bus free or a reset condition here 2034 * XXX Note : we need to watch for bus free or a reset condition here
2025 * to recover from an unexpected bus free condition. 2035 * to recover from an unexpected bus free condition.
2026 */ 2036 */
2027 2037
2028static void NCR5380_information_transfer (struct Scsi_Host *instance) 2038static void NCR5380_information_transfer(struct Scsi_Host *instance)
2029{ 2039{
2030 SETUP_HOSTDATA(instance); 2040 SETUP_HOSTDATA(instance);
2031 unsigned long flags; 2041 unsigned long flags;
2032 unsigned char msgout = NOP; 2042 unsigned char msgout = NOP;
2033 int sink = 0; 2043 int sink = 0;
2034 int len; 2044 int len;
2035#if defined(REAL_DMA) 2045#if defined(REAL_DMA)
2036 int transfersize; 2046 int transfersize;
2037#endif 2047#endif
2038 unsigned char *data; 2048 unsigned char *data;
2039 unsigned char phase, tmp, extended_msg[10], old_phase=0xff; 2049 unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
2040 Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected; 2050 Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
2051
2052 while (1) {
2053 tmp = NCR5380_read(STATUS_REG);
2054 /* We only have a valid SCSI phase when REQ is asserted */
2055 if (tmp & SR_REQ) {
2056 phase = (tmp & PHASE_MASK);
2057 if (phase != old_phase) {
2058 old_phase = phase;
2059 NCR_PRINT_PHASE(NDEBUG_INFORMATION);
2060 }
2041 2061
2042 while (1) { 2062 if (sink && (phase != PHASE_MSGOUT)) {
2043 tmp = NCR5380_read(STATUS_REG); 2063 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
2044 /* We only have a valid SCSI phase when REQ is asserted */ 2064
2045 if (tmp & SR_REQ) { 2065 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
2046 phase = (tmp & PHASE_MASK); 2066 ICR_ASSERT_ACK);
2047 if (phase != old_phase) { 2067 while (NCR5380_read(STATUS_REG) & SR_REQ)
2048 old_phase = phase; 2068 ;
2049 NCR_PRINT_PHASE(NDEBUG_INFORMATION); 2069 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2050 } 2070 ICR_ASSERT_ATN);
2051 2071 sink = 0;
2052 if (sink && (phase != PHASE_MSGOUT)) { 2072 continue;
2053 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 2073 }
2054 2074
2055 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 2075 switch (phase) {
2056 ICR_ASSERT_ACK); 2076 case PHASE_DATAOUT:
2057 while (NCR5380_read(STATUS_REG) & SR_REQ);
2058 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2059 ICR_ASSERT_ATN);
2060 sink = 0;
2061 continue;
2062 }
2063
2064 switch (phase) {
2065 case PHASE_DATAOUT:
2066#if (NDEBUG & NDEBUG_NO_DATAOUT) 2077#if (NDEBUG & NDEBUG_NO_DATAOUT)
2067 printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT " 2078 printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT "
2068 "aborted\n", HOSTNO); 2079 "aborted\n", HOSTNO);
2069 sink = 1; 2080 sink = 1;
2070 do_abort(instance); 2081 do_abort(instance);
2071 cmd->result = DID_ERROR << 16; 2082 cmd->result = DID_ERROR << 16;
2072 cmd->done(cmd); 2083 cmd->done(cmd);
2073 return; 2084 return;
2074#endif 2085#endif
2075 case PHASE_DATAIN: 2086 case PHASE_DATAIN:
2076 /* 2087 /*
2077 * If there is no room left in the current buffer in the 2088 * If there is no room left in the current buffer in the
2078 * scatter-gather list, move onto the next one. 2089 * scatter-gather list, move onto the next one.
2079 */ 2090 */
2080 2091
2081 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) { 2092 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
2082 ++cmd->SCp.buffer; 2093 ++cmd->SCp.buffer;
2083 --cmd->SCp.buffers_residual; 2094 --cmd->SCp.buffers_residual;
2084 cmd->SCp.this_residual = cmd->SCp.buffer->length; 2095 cmd->SCp.this_residual = cmd->SCp.buffer->length;
2085 cmd->SCp.ptr = page_address(cmd->SCp.buffer->page)+ 2096 cmd->SCp.ptr = page_address(cmd->SCp.buffer->page) +
2086 cmd->SCp.buffer->offset; 2097 cmd->SCp.buffer->offset;
2087 /* ++roman: Try to merge some scatter-buffers if 2098 /* ++roman: Try to merge some scatter-buffers if
2088 * they are at contiguous physical addresses. 2099 * they are at contiguous physical addresses.
2089 */ 2100 */
2090 merge_contiguous_buffers( cmd ); 2101 merge_contiguous_buffers(cmd);
2091 INF_PRINTK("scsi%d: %d bytes and %d buffers left\n", 2102 INF_PRINTK("scsi%d: %d bytes and %d buffers left\n",
2092 HOSTNO, cmd->SCp.this_residual, 2103 HOSTNO, cmd->SCp.this_residual,
2093 cmd->SCp.buffers_residual); 2104 cmd->SCp.buffers_residual);
2094 } 2105 }
2095 2106
2096 /* 2107 /*
2097 * The preferred transfer method is going to be 2108 * The preferred transfer method is going to be
2098 * PSEUDO-DMA for systems that are strictly PIO, 2109 * PSEUDO-DMA for systems that are strictly PIO,
2099 * since we can let the hardware do the handshaking. 2110 * since we can let the hardware do the handshaking.
2100 * 2111 *
2101 * For this to work, we need to know the transfersize 2112 * For this to work, we need to know the transfersize
2102 * ahead of time, since the pseudo-DMA code will sit 2113 * ahead of time, since the pseudo-DMA code will sit
2103 * in an unconditional loop. 2114 * in an unconditional loop.
2104 */ 2115 */
2105 2116
2106/* ++roman: I suggest, this should be 2117 /* ++roman: I suggest, this should be
2107 * #if def(REAL_DMA) 2118 * #if def(REAL_DMA)
2108 * instead of leaving REAL_DMA out. 2119 * instead of leaving REAL_DMA out.
2109 */ 2120 */
2110 2121
2111#if defined(REAL_DMA) 2122#if defined(REAL_DMA)
2112 if (!cmd->device->borken && 2123 if (!cmd->device->borken &&
2113 (transfersize = NCR5380_dma_xfer_len(instance,cmd,phase)) > 31) { 2124 (transfersize = NCR5380_dma_xfer_len(instance,cmd,phase)) > 31) {
2114 len = transfersize; 2125 len = transfersize;
2115 cmd->SCp.phase = phase; 2126 cmd->SCp.phase = phase;
2116 if (NCR5380_transfer_dma(instance, &phase, 2127 if (NCR5380_transfer_dma(instance, &phase,
2117 &len, (unsigned char **) &cmd->SCp.ptr)) { 2128 &len, (unsigned char **)&cmd->SCp.ptr)) {
2118 /* 2129 /*
2119 * If the watchdog timer fires, all future 2130 * If the watchdog timer fires, all future
2120 * accesses to this device will use the 2131 * accesses to this device will use the
2121 * polled-IO. */ 2132 * polled-IO. */
2122 printk(KERN_NOTICE "scsi%d: switching target %d " 2133 printk(KERN_NOTICE "scsi%d: switching target %d "
2123 "lun %d to slow handshake\n", HOSTNO, 2134 "lun %d to slow handshake\n", HOSTNO,
2124 cmd->device->id, cmd->device->lun); 2135 cmd->device->id, cmd->device->lun);
2125 cmd->device->borken = 1; 2136 cmd->device->borken = 1;
2126 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 2137 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2127 ICR_ASSERT_ATN); 2138 ICR_ASSERT_ATN);
2128 sink = 1; 2139 sink = 1;
2129 do_abort(instance); 2140 do_abort(instance);
2130 cmd->result = DID_ERROR << 16; 2141 cmd->result = DID_ERROR << 16;
2131 cmd->done(cmd); 2142 cmd->done(cmd);
2132 /* XXX - need to source or sink data here, as appropriate */ 2143 /* XXX - need to source or sink data here, as appropriate */
2133 } else { 2144 } else {
2134#ifdef REAL_DMA 2145#ifdef REAL_DMA
2135 /* ++roman: When using real DMA, 2146 /* ++roman: When using real DMA,
2136 * information_transfer() should return after 2147 * information_transfer() should return after
2137 * starting DMA since it has nothing more to 2148 * starting DMA since it has nothing more to
2138 * do. 2149 * do.
2139 */ 2150 */
2140 return; 2151 return;
2141#else 2152#else
2142 cmd->SCp.this_residual -= transfersize - len; 2153 cmd->SCp.this_residual -= transfersize - len;
2143#endif 2154#endif
2144 } 2155 }
2145 } else 2156 } else
2146#endif /* defined(REAL_DMA) */ 2157#endif /* defined(REAL_DMA) */
2147 NCR5380_transfer_pio(instance, &phase, 2158 NCR5380_transfer_pio(instance, &phase,
2148 (int *) &cmd->SCp.this_residual, (unsigned char **) 2159 (int *)&cmd->SCp.this_residual,
2149 &cmd->SCp.ptr); 2160 (unsigned char **)&cmd->SCp.ptr);
2150 break; 2161 break;
2151 case PHASE_MSGIN: 2162 case PHASE_MSGIN:
2152 len = 1; 2163 len = 1;
2153 data = &tmp; 2164 data = &tmp;
2154 NCR5380_write(SELECT_ENABLE_REG, 0); /* disable reselects */ 2165 NCR5380_write(SELECT_ENABLE_REG, 0); /* disable reselects */
2155 NCR5380_transfer_pio(instance, &phase, &len, &data); 2166 NCR5380_transfer_pio(instance, &phase, &len, &data);
2156 cmd->SCp.Message = tmp; 2167 cmd->SCp.Message = tmp;
2157 2168
2158 switch (tmp) { 2169 switch (tmp) {
2159 /* 2170 /*
2160 * Linking lets us reduce the time required to get the 2171 * Linking lets us reduce the time required to get the
2161 * next command out to the device, hopefully this will 2172 * next command out to the device, hopefully this will
2162 * mean we don't waste another revolution due to the delays 2173 * mean we don't waste another revolution due to the delays
2163 * required by ARBITRATION and another SELECTION. 2174 * required by ARBITRATION and another SELECTION.
2164 * 2175 *
2165 * In the current implementation proposal, low level drivers 2176 * In the current implementation proposal, low level drivers
2166 * merely have to start the next command, pointed to by 2177 * merely have to start the next command, pointed to by
2167 * next_link, done() is called as with unlinked commands. 2178 * next_link, done() is called as with unlinked commands.
2168 */ 2179 */
2169#ifdef LINKED 2180#ifdef LINKED
2170 case LINKED_CMD_COMPLETE: 2181 case LINKED_CMD_COMPLETE:
2171 case LINKED_FLG_CMD_COMPLETE: 2182 case LINKED_FLG_CMD_COMPLETE:
2172 /* Accept message by clearing ACK */ 2183 /* Accept message by clearing ACK */
2173 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2184 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2174 2185
2175 LNK_PRINTK("scsi%d: target %d lun %d linked command " 2186 LNK_PRINTK("scsi%d: target %d lun %d linked command "
2176 "complete.\n", HOSTNO, cmd->device->id, cmd->device->lun); 2187 "complete.\n", HOSTNO, cmd->device->id, cmd->device->lun);
2177 2188
2178 /* Enable reselect interrupts */ 2189 /* Enable reselect interrupts */
2179 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2190 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2180 /* 2191 /*
2181 * Sanity check : A linked command should only terminate 2192 * Sanity check : A linked command should only terminate
2182 * with one of these messages if there are more linked 2193 * with one of these messages if there are more linked
2183 * commands available. 2194 * commands available.
2184 */ 2195 */
2185 2196
2186 if (!cmd->next_link) { 2197 if (!cmd->next_link) {
2187 printk(KERN_NOTICE "scsi%d: target %d lun %d " 2198 printk(KERN_NOTICE "scsi%d: target %d lun %d "
2188 "linked command complete, no next_link\n", 2199 "linked command complete, no next_link\n",
2189 HOSTNO, cmd->device->id, cmd->device->lun); 2200 HOSTNO, cmd->device->id, cmd->device->lun);
2190 sink = 1; 2201 sink = 1;
2191 do_abort (instance); 2202 do_abort(instance);
2192 return; 2203 return;
2193 } 2204 }
2194 2205
2195 initialize_SCp(cmd->next_link); 2206 initialize_SCp(cmd->next_link);
2196 /* The next command is still part of this process; copy it 2207 /* The next command is still part of this process; copy it
2197 * and don't free it! */ 2208 * and don't free it! */
2198 cmd->next_link->tag = cmd->tag; 2209 cmd->next_link->tag = cmd->tag;
2199 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 2210 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2200 LNK_PRINTK("scsi%d: target %d lun %d linked request " 2211 LNK_PRINTK("scsi%d: target %d lun %d linked request "
2201 "done, calling scsi_done().\n", 2212 "done, calling scsi_done().\n",
2202 HOSTNO, cmd->device->id, cmd->device->lun); 2213 HOSTNO, cmd->device->id, cmd->device->lun);
2203#ifdef NCR5380_STATS 2214#ifdef NCR5380_STATS
2204 collect_stats(hostdata, cmd); 2215 collect_stats(hostdata, cmd);
2205#endif 2216#endif
2206 cmd->scsi_done(cmd); 2217 cmd->scsi_done(cmd);
2207 cmd = hostdata->connected; 2218 cmd = hostdata->connected;
2208 break; 2219 break;
2209#endif /* def LINKED */ 2220#endif /* def LINKED */
2210 case ABORT: 2221 case ABORT:
2211 case COMMAND_COMPLETE: 2222 case COMMAND_COMPLETE:
2212 /* Accept message by clearing ACK */ 2223 /* Accept message by clearing ACK */
2213 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2224 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2214 /* ++guenther: possible race with Falcon locking */ 2225 /* ++guenther: possible race with Falcon locking */
2215 falcon_dont_release++; 2226 falcon_dont_release++;
2216 hostdata->connected = NULL; 2227 hostdata->connected = NULL;
2217 QU_PRINTK("scsi%d: command for target %d, lun %d " 2228 QU_PRINTK("scsi%d: command for target %d, lun %d "
2218 "completed\n", HOSTNO, cmd->device->id, cmd->device->lun); 2229 "completed\n", HOSTNO, cmd->device->id, cmd->device->lun);
2219#ifdef SUPPORT_TAGS 2230#ifdef SUPPORT_TAGS
2220 cmd_free_tag( cmd ); 2231 cmd_free_tag(cmd);
2221 if (status_byte(cmd->SCp.Status) == QUEUE_FULL) { 2232 if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
2222 /* Turn a QUEUE FULL status into BUSY, I think the 2233 /* Turn a QUEUE FULL status into BUSY, I think the
2223 * mid level cannot handle QUEUE FULL :-( (The 2234 * mid level cannot handle QUEUE FULL :-( (The
2224 * command is retried after BUSY). Also update our 2235 * command is retried after BUSY). Also update our
2225 * queue size to the number of currently issued 2236 * queue size to the number of currently issued
2226 * commands now. 2237 * commands now.
2227 */ 2238 */
2228 /* ++Andreas: the mid level code knows about 2239 /* ++Andreas: the mid level code knows about
2229 QUEUE_FULL now. */ 2240 QUEUE_FULL now. */
2230 TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun]; 2241 TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
2231 TAG_PRINTK("scsi%d: target %d lun %d returned " 2242 TAG_PRINTK("scsi%d: target %d lun %d returned "
2232 "QUEUE_FULL after %d commands\n", 2243 "QUEUE_FULL after %d commands\n",
2233 HOSTNO, cmd->device->id, cmd->device->lun, 2244 HOSTNO, cmd->device->id, cmd->device->lun,
2234 ta->nr_allocated); 2245 ta->nr_allocated);
2235 if (ta->queue_size > ta->nr_allocated) 2246 if (ta->queue_size > ta->nr_allocated)
2236 ta->nr_allocated = ta->queue_size; 2247 ta->nr_allocated = ta->queue_size;
2237 } 2248 }
2238#else 2249#else
2239 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 2250 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2240#endif 2251#endif
2241 /* Enable reselect interrupts */ 2252 /* Enable reselect interrupts */
2242 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2253 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2243 2254
2244 /* 2255 /*
2245 * I'm not sure what the correct thing to do here is : 2256 * I'm not sure what the correct thing to do here is :
2246 * 2257 *
2247 * If the command that just executed is NOT a request 2258 * If the command that just executed is NOT a request
2248 * sense, the obvious thing to do is to set the result 2259 * sense, the obvious thing to do is to set the result
2249 * code to the values of the stored parameters. 2260 * code to the values of the stored parameters.
2250 * 2261 *
2251 * If it was a REQUEST SENSE command, we need some way to 2262 * If it was a REQUEST SENSE command, we need some way to
2252 * differentiate between the failure code of the original 2263 * differentiate between the failure code of the original
2253 * and the failure code of the REQUEST sense - the obvious 2264 * and the failure code of the REQUEST sense - the obvious
2254 * case is success, where we fall through and leave the 2265 * case is success, where we fall through and leave the
2255 * result code unchanged. 2266 * result code unchanged.
2256 * 2267 *
2257 * The non-obvious place is where the REQUEST SENSE failed 2268 * The non-obvious place is where the REQUEST SENSE failed
2258 */ 2269 */
2259 2270
2260 if (cmd->cmnd[0] != REQUEST_SENSE) 2271 if (cmd->cmnd[0] != REQUEST_SENSE)
2261 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 2272 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2262 else if (status_byte(cmd->SCp.Status) != GOOD) 2273 else if (status_byte(cmd->SCp.Status) != GOOD)
2263 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16); 2274 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2264
2265#ifdef AUTOSENSE
2266 if ((cmd->cmnd[0] != REQUEST_SENSE) &&
2267 (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
2268 ASEN_PRINTK("scsi%d: performing request sense\n",
2269 HOSTNO);
2270 cmd->cmnd[0] = REQUEST_SENSE;
2271 cmd->cmnd[1] &= 0xe0;
2272 cmd->cmnd[2] = 0;
2273 cmd->cmnd[3] = 0;
2274 cmd->cmnd[4] = sizeof(cmd->sense_buffer);
2275 cmd->cmnd[5] = 0;
2276 cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
2277
2278 cmd->use_sg = 0;
2279 /* this is initialized from initialize_SCp
2280 cmd->SCp.buffer = NULL;
2281 cmd->SCp.buffers_residual = 0;
2282 */
2283 cmd->request_buffer = (char *) cmd->sense_buffer;
2284 cmd->request_bufflen = sizeof(cmd->sense_buffer);
2285 2275
2286 local_irq_save(flags); 2276#ifdef AUTOSENSE
2287 LIST(cmd,hostdata->issue_queue); 2277 if ((cmd->cmnd[0] != REQUEST_SENSE) &&
2288 NEXT(cmd) = hostdata->issue_queue; 2278 (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
2289 hostdata->issue_queue = (Scsi_Cmnd *) cmd; 2279 ASEN_PRINTK("scsi%d: performing request sense\n", HOSTNO);
2290 local_irq_restore(flags); 2280 cmd->cmnd[0] = REQUEST_SENSE;
2291 QU_PRINTK("scsi%d: REQUEST SENSE added to head of " 2281 cmd->cmnd[1] &= 0xe0;
2292 "issue queue\n", H_NO(cmd)); 2282 cmd->cmnd[2] = 0;
2293 } else 2283 cmd->cmnd[3] = 0;
2284 cmd->cmnd[4] = sizeof(cmd->sense_buffer);
2285 cmd->cmnd[5] = 0;
2286 cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
2287
2288 cmd->use_sg = 0;
2289 /* this is initialized from initialize_SCp
2290 cmd->SCp.buffer = NULL;
2291 cmd->SCp.buffers_residual = 0;
2292 */
2293 cmd->request_buffer = (char *) cmd->sense_buffer;
2294 cmd->request_bufflen = sizeof(cmd->sense_buffer);
2295
2296 local_irq_save(flags);
2297 LIST(cmd,hostdata->issue_queue);
2298 NEXT(cmd) = hostdata->issue_queue;
2299 hostdata->issue_queue = (Scsi_Cmnd *) cmd;
2300 local_irq_restore(flags);
2301 QU_PRINTK("scsi%d: REQUEST SENSE added to head of "
2302 "issue queue\n", H_NO(cmd));
2303 } else
2294#endif /* def AUTOSENSE */ 2304#endif /* def AUTOSENSE */
2295 { 2305 {
2296#ifdef NCR5380_STATS 2306#ifdef NCR5380_STATS
2297 collect_stats(hostdata, cmd); 2307 collect_stats(hostdata, cmd);
2298#endif 2308#endif
2299 cmd->scsi_done(cmd); 2309 cmd->scsi_done(cmd);
2300 } 2310 }
2301 2311
2302 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2312 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2303 /* 2313 /*
2304 * Restore phase bits to 0 so an interrupted selection, 2314 * Restore phase bits to 0 so an interrupted selection,
2305 * arbitration can resume. 2315 * arbitration can resume.
2306 */ 2316 */
2307 NCR5380_write(TARGET_COMMAND_REG, 0); 2317 NCR5380_write(TARGET_COMMAND_REG, 0);
2308 2318
2309 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected) 2319 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
2310 barrier(); 2320 barrier();
2311 2321
2312 falcon_dont_release--; 2322 falcon_dont_release--;
2313 /* ++roman: For Falcon SCSI, release the lock on the 2323 /* ++roman: For Falcon SCSI, release the lock on the
2314 * ST-DMA here if no other commands are waiting on the 2324 * ST-DMA here if no other commands are waiting on the
2315 * disconnected queue. 2325 * disconnected queue.
2316 */ 2326 */
2317 falcon_release_lock_if_possible( hostdata ); 2327 falcon_release_lock_if_possible(hostdata);
2318 return; 2328 return;
2319 case MESSAGE_REJECT: 2329 case MESSAGE_REJECT:
2320 /* Accept message by clearing ACK */ 2330 /* Accept message by clearing ACK */
2321 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2331 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2322 /* Enable reselect interrupts */ 2332 /* Enable reselect interrupts */
2323 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2333 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2324 switch (hostdata->last_message) { 2334 switch (hostdata->last_message) {
2325 case HEAD_OF_QUEUE_TAG: 2335 case HEAD_OF_QUEUE_TAG:
2326 case ORDERED_QUEUE_TAG: 2336 case ORDERED_QUEUE_TAG:
2327 case SIMPLE_QUEUE_TAG: 2337 case SIMPLE_QUEUE_TAG:
2328 /* The target obviously doesn't support tagged 2338 /* The target obviously doesn't support tagged
2329 * queuing, even though it announced this ability in 2339 * queuing, even though it announced this ability in
2330 * its INQUIRY data ?!? (maybe only this LUN?) Ok, 2340 * its INQUIRY data ?!? (maybe only this LUN?) Ok,
2331 * clear 'tagged_supported' and lock the LUN, since 2341 * clear 'tagged_supported' and lock the LUN, since
2332 * the command is treated as untagged further on. 2342 * the command is treated as untagged further on.
2333 */ 2343 */
2334 cmd->device->tagged_supported = 0; 2344 cmd->device->tagged_supported = 0;
2335 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun); 2345 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
2336 cmd->tag = TAG_NONE; 2346 cmd->tag = TAG_NONE;
2337 TAG_PRINTK("scsi%d: target %d lun %d rejected " 2347 TAG_PRINTK("scsi%d: target %d lun %d rejected "
2338 "QUEUE_TAG message; tagged queuing " 2348 "QUEUE_TAG message; tagged queuing "
2339 "disabled\n", 2349 "disabled\n",
2340 HOSTNO, cmd->device->id, cmd->device->lun); 2350 HOSTNO, cmd->device->id, cmd->device->lun);
2341 break; 2351 break;
2342 } 2352 }
2343 break; 2353 break;
2344 case DISCONNECT: 2354 case DISCONNECT:
2345 /* Accept message by clearing ACK */ 2355 /* Accept message by clearing ACK */
2346 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2356 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2347 local_irq_save(flags); 2357 local_irq_save(flags);
2348 cmd->device->disconnect = 1; 2358 cmd->device->disconnect = 1;
2349 LIST(cmd,hostdata->disconnected_queue); 2359 LIST(cmd,hostdata->disconnected_queue);
2350 NEXT(cmd) = hostdata->disconnected_queue; 2360 NEXT(cmd) = hostdata->disconnected_queue;
2351 hostdata->connected = NULL; 2361 hostdata->connected = NULL;
2352 hostdata->disconnected_queue = cmd; 2362 hostdata->disconnected_queue = cmd;
2353 local_irq_restore(flags); 2363 local_irq_restore(flags);
2354 QU_PRINTK("scsi%d: command for target %d lun %d was " 2364 QU_PRINTK("scsi%d: command for target %d lun %d was "
2355 "moved from connected to the " 2365 "moved from connected to the "
2356 "disconnected_queue\n", HOSTNO, 2366 "disconnected_queue\n", HOSTNO,
2357 cmd->device->id, cmd->device->lun); 2367 cmd->device->id, cmd->device->lun);
2358 /* 2368 /*
2359 * Restore phase bits to 0 so an interrupted selection, 2369 * Restore phase bits to 0 so an interrupted selection,
2360 * arbitration can resume. 2370 * arbitration can resume.
2361 */ 2371 */
2362 NCR5380_write(TARGET_COMMAND_REG, 0); 2372 NCR5380_write(TARGET_COMMAND_REG, 0);
2363 2373
2364 /* Enable reselect interrupts */ 2374 /* Enable reselect interrupts */
2365 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2375 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2366 /* Wait for bus free to avoid nasty timeouts */ 2376 /* Wait for bus free to avoid nasty timeouts */
2367 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected) 2377 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
2368 barrier(); 2378 barrier();
2369 return; 2379 return;
2370 /* 2380 /*
2371 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect 2381 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2372 * operation, in violation of the SCSI spec so we can safely 2382 * operation, in violation of the SCSI spec so we can safely
2373 * ignore SAVE/RESTORE pointers calls. 2383 * ignore SAVE/RESTORE pointers calls.
2374 * 2384 *
2375 * Unfortunately, some disks violate the SCSI spec and 2385 * Unfortunately, some disks violate the SCSI spec and
2376 * don't issue the required SAVE_POINTERS message before 2386 * don't issue the required SAVE_POINTERS message before
2377 * disconnecting, and we have to break spec to remain 2387 * disconnecting, and we have to break spec to remain
2378 * compatible. 2388 * compatible.
2379 */ 2389 */
2380 case SAVE_POINTERS: 2390 case SAVE_POINTERS:
2381 case RESTORE_POINTERS: 2391 case RESTORE_POINTERS:
2382 /* Accept message by clearing ACK */ 2392 /* Accept message by clearing ACK */
2383 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2393 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2384 /* Enable reselect interrupts */ 2394 /* Enable reselect interrupts */
2385 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2395 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2386 break; 2396 break;
2387 case EXTENDED_MESSAGE: 2397 case EXTENDED_MESSAGE:
2388/* 2398 /*
2389 * Extended messages are sent in the following format : 2399 * Extended messages are sent in the following format :
2390 * Byte 2400 * Byte
2391 * 0 EXTENDED_MESSAGE == 1 2401 * 0 EXTENDED_MESSAGE == 1
2392 * 1 length (includes one byte for code, doesn't 2402 * 1 length (includes one byte for code, doesn't
2393 * include first two bytes) 2403 * include first two bytes)
2394 * 2 code 2404 * 2 code
2395 * 3..length+1 arguments 2405 * 3..length+1 arguments
2396 * 2406 *
2397 * Start the extended message buffer with the EXTENDED_MESSAGE 2407 * Start the extended message buffer with the EXTENDED_MESSAGE
2398 * byte, since spi_print_msg() wants the whole thing. 2408 * byte, since spi_print_msg() wants the whole thing.
2399 */ 2409 */
2400 extended_msg[0] = EXTENDED_MESSAGE; 2410 extended_msg[0] = EXTENDED_MESSAGE;
2401 /* Accept first byte by clearing ACK */ 2411 /* Accept first byte by clearing ACK */
2402 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2412 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2403 2413
2404 EXT_PRINTK("scsi%d: receiving extended message\n", HOSTNO); 2414 EXT_PRINTK("scsi%d: receiving extended message\n", HOSTNO);
2405 2415
2406 len = 2; 2416 len = 2;
2407 data = extended_msg + 1; 2417 data = extended_msg + 1;
2408 phase = PHASE_MSGIN; 2418 phase = PHASE_MSGIN;
2409 NCR5380_transfer_pio(instance, &phase, &len, &data); 2419 NCR5380_transfer_pio(instance, &phase, &len, &data);
2410 EXT_PRINTK("scsi%d: length=%d, code=0x%02x\n", HOSTNO, 2420 EXT_PRINTK("scsi%d: length=%d, code=0x%02x\n", HOSTNO,
2411 (int)extended_msg[1], (int)extended_msg[2]); 2421 (int)extended_msg[1], (int)extended_msg[2]);
2412 2422
2413 if (!len && extended_msg[1] <= 2423 if (!len && extended_msg[1] <=
2414 (sizeof (extended_msg) - 1)) { 2424 (sizeof(extended_msg) - 1)) {
2415 /* Accept third byte by clearing ACK */ 2425 /* Accept third byte by clearing ACK */
2416 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2426 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2417 len = extended_msg[1] - 1; 2427 len = extended_msg[1] - 1;
2418 data = extended_msg + 3; 2428 data = extended_msg + 3;
2419 phase = PHASE_MSGIN; 2429 phase = PHASE_MSGIN;
2420 2430
2421 NCR5380_transfer_pio(instance, &phase, &len, &data); 2431 NCR5380_transfer_pio(instance, &phase, &len, &data);
2422 EXT_PRINTK("scsi%d: message received, residual %d\n", 2432 EXT_PRINTK("scsi%d: message received, residual %d\n",
2423 HOSTNO, len); 2433 HOSTNO, len);
2424 2434
2425 switch (extended_msg[2]) { 2435 switch (extended_msg[2]) {
2426 case EXTENDED_SDTR: 2436 case EXTENDED_SDTR:
2427 case EXTENDED_WDTR: 2437 case EXTENDED_WDTR:
2428 case EXTENDED_MODIFY_DATA_POINTER: 2438 case EXTENDED_MODIFY_DATA_POINTER:
2429 case EXTENDED_EXTENDED_IDENTIFY: 2439 case EXTENDED_EXTENDED_IDENTIFY:
2430 tmp = 0; 2440 tmp = 0;
2431 } 2441 }
2432 } else if (len) { 2442 } else if (len) {
2433 printk(KERN_NOTICE "scsi%d: error receiving " 2443 printk(KERN_NOTICE "scsi%d: error receiving "
2434 "extended message\n", HOSTNO); 2444 "extended message\n", HOSTNO);
2435 tmp = 0; 2445 tmp = 0;
2436 } else { 2446 } else {
2437 printk(KERN_NOTICE "scsi%d: extended message " 2447 printk(KERN_NOTICE "scsi%d: extended message "
2438 "code %02x length %d is too long\n", 2448 "code %02x length %d is too long\n",
2439 HOSTNO, extended_msg[2], extended_msg[1]); 2449 HOSTNO, extended_msg[2], extended_msg[1]);
2440 tmp = 0; 2450 tmp = 0;
2441 } 2451 }
2442 /* Fall through to reject message */ 2452 /* Fall through to reject message */
2443 2453
2444 /* 2454 /*
2445 * If we get something weird that we aren't expecting, 2455 * If we get something weird that we aren't expecting,
2446 * reject it. 2456 * reject it.
2447 */ 2457 */
2448 default: 2458 default:
2449 if (!tmp) { 2459 if (!tmp) {
2450 printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO); 2460 printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO);
2451 spi_print_msg(extended_msg); 2461 spi_print_msg(extended_msg);
2452 printk("\n"); 2462 printk("\n");
2453 } else if (tmp != EXTENDED_MESSAGE) 2463 } else if (tmp != EXTENDED_MESSAGE)
2454 printk(KERN_DEBUG "scsi%d: rejecting unknown " 2464 printk(KERN_DEBUG "scsi%d: rejecting unknown "
2455 "message %02x from target %d, lun %d\n", 2465 "message %02x from target %d, lun %d\n",
2456 HOSTNO, tmp, cmd->device->id, cmd->device->lun); 2466 HOSTNO, tmp, cmd->device->id, cmd->device->lun);
2457 else 2467 else
2458 printk(KERN_DEBUG "scsi%d: rejecting unknown " 2468 printk(KERN_DEBUG "scsi%d: rejecting unknown "
2459 "extended message " 2469 "extended message "
2460 "code %02x, length %d from target %d, lun %d\n", 2470 "code %02x, length %d from target %d, lun %d\n",
2461 HOSTNO, extended_msg[1], extended_msg[0], 2471 HOSTNO, extended_msg[1], extended_msg[0],
2462 cmd->device->id, cmd->device->lun); 2472 cmd->device->id, cmd->device->lun);
2463 2473
2464 2474
2465 msgout = MESSAGE_REJECT; 2475 msgout = MESSAGE_REJECT;
2466 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 2476 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2467 ICR_ASSERT_ATN); 2477 break;
2468 break; 2478 } /* switch (tmp) */
2469 } /* switch (tmp) */ 2479 break;
2470 break; 2480 case PHASE_MSGOUT:
2471 case PHASE_MSGOUT: 2481 len = 1;
2472 len = 1; 2482 data = &msgout;
2473 data = &msgout; 2483 hostdata->last_message = msgout;
2474 hostdata->last_message = msgout; 2484 NCR5380_transfer_pio(instance, &phase, &len, &data);
2475 NCR5380_transfer_pio(instance, &phase, &len, &data); 2485 if (msgout == ABORT) {
2476 if (msgout == ABORT) {
2477#ifdef SUPPORT_TAGS 2486#ifdef SUPPORT_TAGS
2478 cmd_free_tag( cmd ); 2487 cmd_free_tag(cmd);
2479#else 2488#else
2480 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 2489 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2481#endif 2490#endif
2482 hostdata->connected = NULL; 2491 hostdata->connected = NULL;
2483 cmd->result = DID_ERROR << 16; 2492 cmd->result = DID_ERROR << 16;
2484#ifdef NCR5380_STATS 2493#ifdef NCR5380_STATS
2485 collect_stats(hostdata, cmd); 2494 collect_stats(hostdata, cmd);
2486#endif 2495#endif
2487 cmd->scsi_done(cmd); 2496 cmd->scsi_done(cmd);
2488 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2497 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2489 falcon_release_lock_if_possible( hostdata ); 2498 falcon_release_lock_if_possible(hostdata);
2490 return; 2499 return;
2491 } 2500 }
2492 msgout = NOP; 2501 msgout = NOP;
2493 break; 2502 break;
2494 case PHASE_CMDOUT: 2503 case PHASE_CMDOUT:
2495 len = cmd->cmd_len; 2504 len = cmd->cmd_len;
2496 data = cmd->cmnd; 2505 data = cmd->cmnd;
2497 /* 2506 /*
2498 * XXX for performance reasons, on machines with a 2507 * XXX for performance reasons, on machines with a
2499 * PSEUDO-DMA architecture we should probably 2508 * PSEUDO-DMA architecture we should probably
2500 * use the dma transfer function. 2509 * use the dma transfer function.
2501 */ 2510 */
2502 NCR5380_transfer_pio(instance, &phase, &len, 2511 NCR5380_transfer_pio(instance, &phase, &len, &data);
2503 &data); 2512 break;
2504 break; 2513 case PHASE_STATIN:
2505 case PHASE_STATIN: 2514 len = 1;
2506 len = 1; 2515 data = &tmp;
2507 data = &tmp; 2516 NCR5380_transfer_pio(instance, &phase, &len, &data);
2508 NCR5380_transfer_pio(instance, &phase, &len, &data); 2517 cmd->SCp.Status = tmp;
2509 cmd->SCp.Status = tmp; 2518 break;
2510 break; 2519 default:
2511 default: 2520 printk("scsi%d: unknown phase\n", HOSTNO);
2512 printk("scsi%d: unknown phase\n", HOSTNO); 2521 NCR_PRINT(NDEBUG_ANY);
2513 NCR_PRINT(NDEBUG_ANY); 2522 } /* switch(phase) */
2514 } /* switch(phase) */ 2523 } /* if (tmp * SR_REQ) */
2515 } /* if (tmp * SR_REQ) */ 2524 } /* while (1) */
2516 } /* while (1) */
2517} 2525}
2518 2526
2519/* 2527/*
2520 * Function : void NCR5380_reselect (struct Scsi_Host *instance) 2528 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2521 * 2529 *
2522 * Purpose : does reselection, initializing the instance->connected 2530 * Purpose : does reselection, initializing the instance->connected
2523 * field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q 2531 * field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q
2524 * nexus has been reestablished, 2532 * nexus has been reestablished,
2525 * 2533 *
2526 * Inputs : instance - this instance of the NCR5380. 2534 * Inputs : instance - this instance of the NCR5380.
2527 * 2535 *
2528 */ 2536 */
2529 2537
2530 2538
2531static void NCR5380_reselect (struct Scsi_Host *instance) 2539static void NCR5380_reselect(struct Scsi_Host *instance)
2532{ 2540{
2533 SETUP_HOSTDATA(instance); 2541 SETUP_HOSTDATA(instance);
2534 unsigned char target_mask; 2542 unsigned char target_mask;
2535 unsigned char lun, phase; 2543 unsigned char lun, phase;
2536 int len; 2544 int len;
2537#ifdef SUPPORT_TAGS 2545#ifdef SUPPORT_TAGS
2538 unsigned char tag; 2546 unsigned char tag;
2539#endif 2547#endif
2540 unsigned char msg[3]; 2548 unsigned char msg[3];
2541 unsigned char *data; 2549 unsigned char *data;
2542 Scsi_Cmnd *tmp = NULL, *prev; 2550 Scsi_Cmnd *tmp = NULL, *prev;
2543/* unsigned long flags; */ 2551/* unsigned long flags; */
2544 2552
2545 /* 2553 /*
2546 * Disable arbitration, etc. since the host adapter obviously 2554 * Disable arbitration, etc. since the host adapter obviously
2547 * lost, and tell an interrupted NCR5380_select() to restart. 2555 * lost, and tell an interrupted NCR5380_select() to restart.
2548 */ 2556 */
2549 2557
2550 NCR5380_write(MODE_REG, MR_BASE); 2558 NCR5380_write(MODE_REG, MR_BASE);
2551 hostdata->restart_select = 1; 2559 hostdata->restart_select = 1;
2552 2560
2553 target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask); 2561 target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2554 2562
2555 RSL_PRINTK("scsi%d: reselect\n", HOSTNO); 2563 RSL_PRINTK("scsi%d: reselect\n", HOSTNO);
2556 2564
2557 /* 2565 /*
2558 * At this point, we have detected that our SCSI ID is on the bus, 2566 * At this point, we have detected that our SCSI ID is on the bus,
2559 * SEL is true and BSY was false for at least one bus settle delay 2567 * SEL is true and BSY was false for at least one bus settle delay
2560 * (400 ns). 2568 * (400 ns).
2561 * 2569 *
2562 * We must assert BSY ourselves, until the target drops the SEL 2570 * We must assert BSY ourselves, until the target drops the SEL
2563 * signal. 2571 * signal.
2564 */ 2572 */
2565 2573
2566 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY); 2574 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2567 2575
2568 while (NCR5380_read(STATUS_REG) & SR_SEL); 2576 while (NCR5380_read(STATUS_REG) & SR_SEL)
2569 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2577 ;
2570 2578 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2571 /* 2579
2572 * Wait for target to go into MSGIN. 2580 /*
2573 */ 2581 * Wait for target to go into MSGIN.
2574 2582 */
2575 while (!(NCR5380_read(STATUS_REG) & SR_REQ)); 2583
2576 2584 while (!(NCR5380_read(STATUS_REG) & SR_REQ))
2577 len = 1; 2585 ;
2578 data = msg; 2586
2579 phase = PHASE_MSGIN; 2587 len = 1;
2580 NCR5380_transfer_pio(instance, &phase, &len, &data); 2588 data = msg;
2581 2589 phase = PHASE_MSGIN;
2582 if (!(msg[0] & 0x80)) { 2590 NCR5380_transfer_pio(instance, &phase, &len, &data);
2583 printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO); 2591
2584 spi_print_msg(msg); 2592 if (!(msg[0] & 0x80)) {
2585 do_abort(instance); 2593 printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
2586 return; 2594 spi_print_msg(msg);
2587 } 2595 do_abort(instance);
2588 lun = (msg[0] & 0x07); 2596 return;
2597 }
2598 lun = (msg[0] & 0x07);
2589 2599
2590#ifdef SUPPORT_TAGS 2600#ifdef SUPPORT_TAGS
2591 /* If the phase is still MSGIN, the target wants to send some more 2601 /* If the phase is still MSGIN, the target wants to send some more
2592 * messages. In case it supports tagged queuing, this is probably a 2602 * messages. In case it supports tagged queuing, this is probably a
2593 * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus. 2603 * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
2594 */ 2604 */
2595 tag = TAG_NONE; 2605 tag = TAG_NONE;
2596 if (phase == PHASE_MSGIN && setup_use_tagged_queuing) { 2606 if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
2597 /* Accept previous IDENTIFY message by clearing ACK */ 2607 /* Accept previous IDENTIFY message by clearing ACK */
2598 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE ); 2608 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2599 len = 2; 2609 len = 2;
2600 data = msg+1; 2610 data = msg + 1;
2601 if (!NCR5380_transfer_pio(instance, &phase, &len, &data) && 2611 if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
2602 msg[1] == SIMPLE_QUEUE_TAG) 2612 msg[1] == SIMPLE_QUEUE_TAG)
2603 tag = msg[2]; 2613 tag = msg[2];
2604 TAG_PRINTK("scsi%d: target mask %02x, lun %d sent tag %d at " 2614 TAG_PRINTK("scsi%d: target mask %02x, lun %d sent tag %d at "
2605 "reselection\n", HOSTNO, target_mask, lun, tag); 2615 "reselection\n", HOSTNO, target_mask, lun, tag);
2606 } 2616 }
2607#endif 2617#endif
2608 2618
2609 /* 2619 /*
2610 * Find the command corresponding to the I_T_L or I_T_L_Q nexus we 2620 * Find the command corresponding to the I_T_L or I_T_L_Q nexus we
2611 * just reestablished, and remove it from the disconnected queue. 2621 * just reestablished, and remove it from the disconnected queue.
2612 */ 2622 */
2613 2623
2614 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL; 2624 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL;
2615 tmp; prev = tmp, tmp = NEXT(tmp) ) { 2625 tmp; prev = tmp, tmp = NEXT(tmp)) {
2616 if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun) 2626 if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
2617#ifdef SUPPORT_TAGS 2627#ifdef SUPPORT_TAGS
2618 && (tag == tmp->tag) 2628 && (tag == tmp->tag)
2619#endif 2629#endif
2620 ) { 2630 ) {
2621 /* ++guenther: prevent race with falcon_release_lock */ 2631 /* ++guenther: prevent race with falcon_release_lock */
2622 falcon_dont_release++; 2632 falcon_dont_release++;
2623 if (prev) { 2633 if (prev) {
2624 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp)); 2634 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
2625 NEXT(prev) = NEXT(tmp); 2635 NEXT(prev) = NEXT(tmp);
2626 } else { 2636 } else {
2627 REMOVE(-1, hostdata->disconnected_queue, tmp, NEXT(tmp)); 2637 REMOVE(-1, hostdata->disconnected_queue, tmp, NEXT(tmp));
2628 hostdata->disconnected_queue = NEXT(tmp); 2638 hostdata->disconnected_queue = NEXT(tmp);
2629 } 2639 }
2630 NEXT(tmp) = NULL; 2640 NEXT(tmp) = NULL;
2631 break; 2641 break;
2642 }
2632 } 2643 }
2633 } 2644
2634 2645 if (!tmp) {
2635 if (!tmp) { 2646 printk(KERN_WARNING "scsi%d: warning: target bitmask %02x lun %d "
2636 printk(KERN_WARNING "scsi%d: warning: target bitmask %02x lun %d "
2637#ifdef SUPPORT_TAGS 2647#ifdef SUPPORT_TAGS
2638 "tag %d " 2648 "tag %d "
2639#endif 2649#endif
2640 "not in disconnected_queue.\n", 2650 "not in disconnected_queue.\n",
2641 HOSTNO, target_mask, lun 2651 HOSTNO, target_mask, lun
2642#ifdef SUPPORT_TAGS 2652#ifdef SUPPORT_TAGS
2643 , tag 2653 , tag
2644#endif 2654#endif
2645 ); 2655 );
2646 /* 2656 /*
2647 * Since we have an established nexus that we can't do anything 2657 * Since we have an established nexus that we can't do anything
2648 * with, we must abort it. 2658 * with, we must abort it.
2649 */ 2659 */
2650 do_abort(instance); 2660 do_abort(instance);
2651 return; 2661 return;
2652 } 2662 }
2653 2663
2654 /* Accept message by clearing ACK */ 2664 /* Accept message by clearing ACK */
2655 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2665 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2656 2666
2657 hostdata->connected = tmp; 2667 hostdata->connected = tmp;
2658 RSL_PRINTK("scsi%d: nexus established, target = %d, lun = %d, tag = %d\n", 2668 RSL_PRINTK("scsi%d: nexus established, target = %d, lun = %d, tag = %d\n",
2659 HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag); 2669 HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
2660 falcon_dont_release--; 2670 falcon_dont_release--;
2661} 2671}
2662 2672
2663 2673
@@ -2666,362 +2676,361 @@ static void NCR5380_reselect (struct Scsi_Host *instance)
2666 * 2676 *
2667 * Purpose : abort a command 2677 * Purpose : abort a command
2668 * 2678 *
2669 * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the 2679 * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the
2670 * host byte of the result field to, if zero DID_ABORTED is 2680 * host byte of the result field to, if zero DID_ABORTED is
2671 * used. 2681 * used.
2672 * 2682 *
2673 * Returns : 0 - success, -1 on failure. 2683 * Returns : 0 - success, -1 on failure.
2674 * 2684 *
2675 * XXX - there is no way to abort the command that is currently 2685 * XXX - there is no way to abort the command that is currently
2676 * connected, you have to wait for it to complete. If this is 2686 * connected, you have to wait for it to complete. If this is
2677 * a problem, we could implement longjmp() / setjmp(), setjmp() 2687 * a problem, we could implement longjmp() / setjmp(), setjmp()
2678 * called where the loop started in NCR5380_main(). 2688 * called where the loop started in NCR5380_main().
2679 */ 2689 */
2680 2690
2681static 2691static
2682int NCR5380_abort (Scsi_Cmnd *cmd) 2692int NCR5380_abort(Scsi_Cmnd *cmd)
2683{ 2693{
2684 struct Scsi_Host *instance = cmd->device->host; 2694 struct Scsi_Host *instance = cmd->device->host;
2685 SETUP_HOSTDATA(instance); 2695 SETUP_HOSTDATA(instance);
2686 Scsi_Cmnd *tmp, **prev; 2696 Scsi_Cmnd *tmp, **prev;
2687 unsigned long flags; 2697 unsigned long flags;
2688 2698
2689 printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO); 2699 printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
2690 scsi_print_command(cmd); 2700 scsi_print_command(cmd);
2691 2701
2692 NCR5380_print_status (instance); 2702 NCR5380_print_status(instance);
2703
2704 local_irq_save(flags);
2693 2705
2694 local_irq_save(flags); 2706 if (!IS_A_TT() && !falcon_got_lock)
2695 2707 printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_abort\n",
2696 if (!IS_A_TT() && !falcon_got_lock) 2708 HOSTNO);
2697 printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_abort\n",
2698 HOSTNO);
2699 2709
2700 ABRT_PRINTK("scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO, 2710 ABRT_PRINTK("scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
2701 NCR5380_read(BUS_AND_STATUS_REG), 2711 NCR5380_read(BUS_AND_STATUS_REG),
2702 NCR5380_read(STATUS_REG)); 2712 NCR5380_read(STATUS_REG));
2703 2713
2704#if 1 2714#if 1
2705/* 2715 /*
2706 * Case 1 : If the command is the currently executing command, 2716 * Case 1 : If the command is the currently executing command,
2707 * we'll set the aborted flag and return control so that 2717 * we'll set the aborted flag and return control so that
2708 * information transfer routine can exit cleanly. 2718 * information transfer routine can exit cleanly.
2709 */ 2719 */
2710 2720
2711 if (hostdata->connected == cmd) { 2721 if (hostdata->connected == cmd) {
2712 2722
2713 ABRT_PRINTK("scsi%d: aborting connected command\n", HOSTNO); 2723 ABRT_PRINTK("scsi%d: aborting connected command\n", HOSTNO);
2714/* 2724 /*
2715 * We should perform BSY checking, and make sure we haven't slipped 2725 * We should perform BSY checking, and make sure we haven't slipped
2716 * into BUS FREE. 2726 * into BUS FREE.
2717 */ 2727 */
2718 2728
2719/* NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); */ 2729 /* NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); */
2720/* 2730 /*
2721 * Since we can't change phases until we've completed the current 2731 * Since we can't change phases until we've completed the current
2722 * handshake, we have to source or sink a byte of data if the current 2732 * handshake, we have to source or sink a byte of data if the current
2723 * phase is not MSGOUT. 2733 * phase is not MSGOUT.
2724 */ 2734 */
2725 2735
2726/* 2736 /*
2727 * Return control to the executing NCR drive so we can clear the 2737 * Return control to the executing NCR drive so we can clear the
2728 * aborted flag and get back into our main loop. 2738 * aborted flag and get back into our main loop.
2729 */ 2739 */
2730 2740
2731 if (do_abort(instance) == 0) { 2741 if (do_abort(instance) == 0) {
2732 hostdata->aborted = 1; 2742 hostdata->aborted = 1;
2733 hostdata->connected = NULL; 2743 hostdata->connected = NULL;
2734 cmd->result = DID_ABORT << 16; 2744 cmd->result = DID_ABORT << 16;
2735#ifdef SUPPORT_TAGS 2745#ifdef SUPPORT_TAGS
2736 cmd_free_tag( cmd ); 2746 cmd_free_tag(cmd);
2737#else 2747#else
2738 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 2748 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2739#endif 2749#endif
2740 local_irq_restore(flags); 2750 local_irq_restore(flags);
2741 cmd->scsi_done(cmd); 2751 cmd->scsi_done(cmd);
2742 falcon_release_lock_if_possible( hostdata ); 2752 falcon_release_lock_if_possible(hostdata);
2743 return SCSI_ABORT_SUCCESS; 2753 return SCSI_ABORT_SUCCESS;
2744 } else { 2754 } else {
2745/* local_irq_restore(flags); */ 2755/* local_irq_restore(flags); */
2746 printk("scsi%d: abort of connected command failed!\n", HOSTNO); 2756 printk("scsi%d: abort of connected command failed!\n", HOSTNO);
2747 return SCSI_ABORT_ERROR; 2757 return SCSI_ABORT_ERROR;
2748 } 2758 }
2749 } 2759 }
2750#endif 2760#endif
2751 2761
2752/* 2762 /*
2753 * Case 2 : If the command hasn't been issued yet, we simply remove it 2763 * Case 2 : If the command hasn't been issued yet, we simply remove it
2754 * from the issue queue. 2764 * from the issue queue.
2755 */ 2765 */
2756 for (prev = (Scsi_Cmnd **) &(hostdata->issue_queue), 2766 for (prev = (Scsi_Cmnd **)&(hostdata->issue_queue),
2757 tmp = (Scsi_Cmnd *) hostdata->issue_queue; 2767 tmp = (Scsi_Cmnd *)hostdata->issue_queue;
2758 tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp) ) 2768 tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
2759 if (cmd == tmp) { 2769 if (cmd == tmp) {
2760 REMOVE(5, *prev, tmp, NEXT(tmp)); 2770 REMOVE(5, *prev, tmp, NEXT(tmp));
2761 (*prev) = NEXT(tmp); 2771 (*prev) = NEXT(tmp);
2762 NEXT(tmp) = NULL; 2772 NEXT(tmp) = NULL;
2763 tmp->result = DID_ABORT << 16; 2773 tmp->result = DID_ABORT << 16;
2764 local_irq_restore(flags); 2774 local_irq_restore(flags);
2765 ABRT_PRINTK("scsi%d: abort removed command from issue queue.\n", 2775 ABRT_PRINTK("scsi%d: abort removed command from issue queue.\n",
2766 HOSTNO); 2776 HOSTNO);
2767 /* Tagged queuing note: no tag to free here, hasn't been assigned 2777 /* Tagged queuing note: no tag to free here, hasn't been assigned
2768 * yet... */ 2778 * yet... */
2769 tmp->scsi_done(tmp); 2779 tmp->scsi_done(tmp);
2770 falcon_release_lock_if_possible( hostdata ); 2780 falcon_release_lock_if_possible(hostdata);
2771 return SCSI_ABORT_SUCCESS; 2781 return SCSI_ABORT_SUCCESS;
2782 }
2772 } 2783 }
2773 2784
2774/* 2785 /*
2775 * Case 3 : If any commands are connected, we're going to fail the abort 2786 * Case 3 : If any commands are connected, we're going to fail the abort
2776 * and let the high level SCSI driver retry at a later time or 2787 * and let the high level SCSI driver retry at a later time or
2777 * issue a reset. 2788 * issue a reset.
2778 * 2789 *
2779 * Timeouts, and therefore aborted commands, will be highly unlikely 2790 * Timeouts, and therefore aborted commands, will be highly unlikely
2780 * and handling them cleanly in this situation would make the common 2791 * and handling them cleanly in this situation would make the common
2781 * case of noresets less efficient, and would pollute our code. So, 2792 * case of noresets less efficient, and would pollute our code. So,
2782 * we fail. 2793 * we fail.
2783 */ 2794 */
2784 2795
2785 if (hostdata->connected) { 2796 if (hostdata->connected) {
2786 local_irq_restore(flags); 2797 local_irq_restore(flags);
2787 ABRT_PRINTK("scsi%d: abort failed, command connected.\n", HOSTNO); 2798 ABRT_PRINTK("scsi%d: abort failed, command connected.\n", HOSTNO);
2788 return SCSI_ABORT_SNOOZE; 2799 return SCSI_ABORT_SNOOZE;
2789 } 2800 }
2790 2801
2791/* 2802 /*
2792 * Case 4: If the command is currently disconnected from the bus, and 2803 * Case 4: If the command is currently disconnected from the bus, and
2793 * there are no connected commands, we reconnect the I_T_L or 2804 * there are no connected commands, we reconnect the I_T_L or
2794 * I_T_L_Q nexus associated with it, go into message out, and send 2805 * I_T_L_Q nexus associated with it, go into message out, and send
2795 * an abort message. 2806 * an abort message.
2796 * 2807 *
2797 * This case is especially ugly. In order to reestablish the nexus, we 2808 * This case is especially ugly. In order to reestablish the nexus, we
2798 * need to call NCR5380_select(). The easiest way to implement this 2809 * need to call NCR5380_select(). The easiest way to implement this
2799 * function was to abort if the bus was busy, and let the interrupt 2810 * function was to abort if the bus was busy, and let the interrupt
2800 * handler triggered on the SEL for reselect take care of lost arbitrations 2811 * handler triggered on the SEL for reselect take care of lost arbitrations
2801 * where necessary, meaning interrupts need to be enabled. 2812 * where necessary, meaning interrupts need to be enabled.
2802 * 2813 *
2803 * When interrupts are enabled, the queues may change - so we 2814 * When interrupts are enabled, the queues may change - so we
2804 * can't remove it from the disconnected queue before selecting it 2815 * can't remove it from the disconnected queue before selecting it
2805 * because that could cause a failure in hashing the nexus if that 2816 * because that could cause a failure in hashing the nexus if that
2806 * device reselected. 2817 * device reselected.
2807 * 2818 *
2808 * Since the queues may change, we can't use the pointers from when we 2819 * Since the queues may change, we can't use the pointers from when we
2809 * first locate it. 2820 * first locate it.
2810 * 2821 *
2811 * So, we must first locate the command, and if NCR5380_select() 2822 * So, we must first locate the command, and if NCR5380_select()
2812 * succeeds, then issue the abort, relocate the command and remove 2823 * succeeds, then issue the abort, relocate the command and remove
2813 * it from the disconnected queue. 2824 * it from the disconnected queue.
2814 */ 2825 */
2826
2827 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp;
2828 tmp = NEXT(tmp)) {
2829 if (cmd == tmp) {
2830 local_irq_restore(flags);
2831 ABRT_PRINTK("scsi%d: aborting disconnected command.\n", HOSTNO);
2832
2833 if (NCR5380_select(instance, cmd, (int)cmd->tag))
2834 return SCSI_ABORT_BUSY;
2815 2835
2816 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; 2836 ABRT_PRINTK("scsi%d: nexus reestablished.\n", HOSTNO);
2817 tmp = NEXT(tmp)) 2837
2818 if (cmd == tmp) { 2838 do_abort(instance);
2819 local_irq_restore(flags); 2839
2820 ABRT_PRINTK("scsi%d: aborting disconnected command.\n", HOSTNO); 2840 local_irq_save(flags);
2821 2841 for (prev = (Scsi_Cmnd **)&(hostdata->disconnected_queue),
2822 if (NCR5380_select (instance, cmd, (int) cmd->tag)) 2842 tmp = (Scsi_Cmnd *)hostdata->disconnected_queue;
2823 return SCSI_ABORT_BUSY; 2843 tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
2824 2844 if (cmd == tmp) {
2825 ABRT_PRINTK("scsi%d: nexus reestablished.\n", HOSTNO); 2845 REMOVE(5, *prev, tmp, NEXT(tmp));
2826 2846 *prev = NEXT(tmp);
2827 do_abort (instance); 2847 NEXT(tmp) = NULL;
2828 2848 tmp->result = DID_ABORT << 16;
2829 local_irq_save(flags); 2849 /* We must unlock the tag/LUN immediately here, since the
2830 for (prev = (Scsi_Cmnd **) &(hostdata->disconnected_queue), 2850 * target goes to BUS FREE and doesn't send us another
2831 tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; 2851 * message (COMMAND_COMPLETE or the like)
2832 tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp) ) 2852 */
2833 if (cmd == tmp) {
2834 REMOVE(5, *prev, tmp, NEXT(tmp));
2835 *prev = NEXT(tmp);
2836 NEXT(tmp) = NULL;
2837 tmp->result = DID_ABORT << 16;
2838 /* We must unlock the tag/LUN immediately here, since the
2839 * target goes to BUS FREE and doesn't send us another
2840 * message (COMMAND_COMPLETE or the like)
2841 */
2842#ifdef SUPPORT_TAGS 2853#ifdef SUPPORT_TAGS
2843 cmd_free_tag( tmp ); 2854 cmd_free_tag(tmp);
2844#else 2855#else
2845 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 2856 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2846#endif 2857#endif
2847 local_irq_restore(flags); 2858 local_irq_restore(flags);
2848 tmp->scsi_done(tmp); 2859 tmp->scsi_done(tmp);
2849 falcon_release_lock_if_possible( hostdata ); 2860 falcon_release_lock_if_possible(hostdata);
2850 return SCSI_ABORT_SUCCESS; 2861 return SCSI_ABORT_SUCCESS;
2862 }
2863 }
2851 } 2864 }
2852 } 2865 }
2853 2866
2854/* 2867 /*
2855 * Case 5 : If we reached this point, the command was not found in any of 2868 * Case 5 : If we reached this point, the command was not found in any of
2856 * the queues. 2869 * the queues.
2857 * 2870 *
2858 * We probably reached this point because of an unlikely race condition 2871 * We probably reached this point because of an unlikely race condition
2859 * between the command completing successfully and the abortion code, 2872 * between the command completing successfully and the abortion code,
2860 * so we won't panic, but we will notify the user in case something really 2873 * so we won't panic, but we will notify the user in case something really
2861 * broke. 2874 * broke.
2862 */ 2875 */
2863 2876
2864 local_irq_restore(flags); 2877 local_irq_restore(flags);
2865 printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully\n" 2878 printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully\n"
2866 KERN_INFO " before abortion\n", HOSTNO); 2879 KERN_INFO " before abortion\n", HOSTNO);
2867 2880
2868/* Maybe it is sufficient just to release the ST-DMA lock... (if 2881 /* Maybe it is sufficient just to release the ST-DMA lock... (if
2869 * possible at all) At least, we should check if the lock could be 2882 * possible at all) At least, we should check if the lock could be
2870 * released after the abort, in case it is kept due to some bug. 2883 * released after the abort, in case it is kept due to some bug.
2871 */ 2884 */
2872 falcon_release_lock_if_possible( hostdata ); 2885 falcon_release_lock_if_possible(hostdata);
2873 2886
2874 return SCSI_ABORT_NOT_RUNNING; 2887 return SCSI_ABORT_NOT_RUNNING;
2875} 2888}
2876 2889
2877 2890
2878/* 2891/*
2879 * Function : int NCR5380_reset (Scsi_Cmnd *cmd) 2892 * Function : int NCR5380_reset (Scsi_Cmnd *cmd)
2880 * 2893 *
2881 * Purpose : reset the SCSI bus. 2894 * Purpose : reset the SCSI bus.
2882 * 2895 *
2883 * Returns : SCSI_RESET_WAKEUP 2896 * Returns : SCSI_RESET_WAKEUP
2884 * 2897 *
2885 */ 2898 */
2886 2899
2887static int NCR5380_bus_reset( Scsi_Cmnd *cmd) 2900static int NCR5380_bus_reset(Scsi_Cmnd *cmd)
2888{ 2901{
2889 SETUP_HOSTDATA(cmd->device->host); 2902 SETUP_HOSTDATA(cmd->device->host);
2890 int i; 2903 int i;
2891 unsigned long flags; 2904 unsigned long flags;
2892#if 1 2905#if 1
2893 Scsi_Cmnd *connected, *disconnected_queue; 2906 Scsi_Cmnd *connected, *disconnected_queue;
2894#endif 2907#endif
2895 2908
2896 if (!IS_A_TT() && !falcon_got_lock) 2909 if (!IS_A_TT() && !falcon_got_lock)
2897 printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_reset\n", 2910 printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_reset\n",
2898 H_NO(cmd) ); 2911 H_NO(cmd));
2899 2912
2900 NCR5380_print_status (cmd->device->host); 2913 NCR5380_print_status(cmd->device->host);
2901 2914
2902 /* get in phase */ 2915 /* get in phase */
2903 NCR5380_write( TARGET_COMMAND_REG, 2916 NCR5380_write(TARGET_COMMAND_REG,
2904 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) )); 2917 PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG)));
2905 /* assert RST */ 2918 /* assert RST */
2906 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST ); 2919 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
2907 udelay (40); 2920 udelay(40);
2908 /* reset NCR registers */ 2921 /* reset NCR registers */
2909 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE ); 2922 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2910 NCR5380_write( MODE_REG, MR_BASE ); 2923 NCR5380_write(MODE_REG, MR_BASE);
2911 NCR5380_write( TARGET_COMMAND_REG, 0 ); 2924 NCR5380_write(TARGET_COMMAND_REG, 0);
2912 NCR5380_write( SELECT_ENABLE_REG, 0 ); 2925 NCR5380_write(SELECT_ENABLE_REG, 0);
2913 /* ++roman: reset interrupt condition! otherwise no interrupts don't get 2926 /* ++roman: reset interrupt condition! otherwise no interrupts don't get
2914 * through anymore ... */ 2927 * through anymore ... */
2915 (void)NCR5380_read( RESET_PARITY_INTERRUPT_REG ); 2928 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
2916 2929
2917#if 1 /* XXX Should now be done by midlevel code, but it's broken XXX */ 2930#if 1 /* XXX Should now be done by midlevel code, but it's broken XXX */
2918 /* XXX see below XXX */ 2931 /* XXX see below XXX */
2919 2932
2920 /* MSch: old-style reset: actually abort all command processing here */ 2933 /* MSch: old-style reset: actually abort all command processing here */
2921 2934
2922 /* After the reset, there are no more connected or disconnected commands 2935 /* After the reset, there are no more connected or disconnected commands
2923 * and no busy units; to avoid problems with re-inserting the commands 2936 * and no busy units; to avoid problems with re-inserting the commands
2924 * into the issue_queue (via scsi_done()), the aborted commands are 2937 * into the issue_queue (via scsi_done()), the aborted commands are
2925 * remembered in local variables first. 2938 * remembered in local variables first.
2926 */ 2939 */
2927 local_irq_save(flags); 2940 local_irq_save(flags);
2928 connected = (Scsi_Cmnd *)hostdata->connected; 2941 connected = (Scsi_Cmnd *)hostdata->connected;
2929 hostdata->connected = NULL; 2942 hostdata->connected = NULL;
2930 disconnected_queue = (Scsi_Cmnd *)hostdata->disconnected_queue; 2943 disconnected_queue = (Scsi_Cmnd *)hostdata->disconnected_queue;
2931 hostdata->disconnected_queue = NULL; 2944 hostdata->disconnected_queue = NULL;
2932#ifdef SUPPORT_TAGS 2945#ifdef SUPPORT_TAGS
2933 free_all_tags(); 2946 free_all_tags();
2934#endif 2947#endif
2935 for( i = 0; i < 8; ++i ) 2948 for (i = 0; i < 8; ++i)
2936 hostdata->busy[i] = 0; 2949 hostdata->busy[i] = 0;
2937#ifdef REAL_DMA 2950#ifdef REAL_DMA
2938 hostdata->dma_len = 0; 2951 hostdata->dma_len = 0;
2939#endif 2952#endif
2940 local_irq_restore(flags); 2953 local_irq_restore(flags);
2941 2954
2942 /* In order to tell the mid-level code which commands were aborted, 2955 /* In order to tell the mid-level code which commands were aborted,
2943 * set the command status to DID_RESET and call scsi_done() !!! 2956 * set the command status to DID_RESET and call scsi_done() !!!
2944 * This ultimately aborts processing of these commands in the mid-level. 2957 * This ultimately aborts processing of these commands in the mid-level.
2945 */ 2958 */
2946 2959
2947 if ((cmd = connected)) { 2960 if ((cmd = connected)) {
2948 ABRT_PRINTK("scsi%d: reset aborted a connected command\n", H_NO(cmd)); 2961 ABRT_PRINTK("scsi%d: reset aborted a connected command\n", H_NO(cmd));
2949 cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16); 2962 cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
2950 cmd->scsi_done( cmd ); 2963 cmd->scsi_done(cmd);
2951 } 2964 }
2952 2965
2953 for (i = 0; (cmd = disconnected_queue); ++i) { 2966 for (i = 0; (cmd = disconnected_queue); ++i) {
2954 disconnected_queue = NEXT(cmd); 2967 disconnected_queue = NEXT(cmd);
2955 NEXT(cmd) = NULL; 2968 NEXT(cmd) = NULL;
2956 cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16); 2969 cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
2957 cmd->scsi_done( cmd ); 2970 cmd->scsi_done(cmd);
2958 } 2971 }
2959 if (i > 0) 2972 if (i > 0)
2960 ABRT_PRINTK("scsi: reset aborted %d disconnected command(s)\n", i); 2973 ABRT_PRINTK("scsi: reset aborted %d disconnected command(s)\n", i);
2961 2974
2962/* The Falcon lock should be released after a reset... 2975 /* The Falcon lock should be released after a reset...
2963 */ 2976 */
2964/* ++guenther: moved to atari_scsi_reset(), to prevent a race between 2977 /* ++guenther: moved to atari_scsi_reset(), to prevent a race between
2965 * unlocking and enabling dma interrupt. 2978 * unlocking and enabling dma interrupt.
2966 */ 2979 */
2967/* falcon_release_lock_if_possible( hostdata );*/ 2980/* falcon_release_lock_if_possible( hostdata );*/
2968 2981
2969 /* since all commands have been explicitly terminated, we need to tell 2982 /* since all commands have been explicitly terminated, we need to tell
2970 * the midlevel code that the reset was SUCCESSFUL, and there is no 2983 * the midlevel code that the reset was SUCCESSFUL, and there is no
2971 * need to 'wake up' the commands by a request_sense 2984 * need to 'wake up' the commands by a request_sense
2972 */ 2985 */
2973 return SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET; 2986 return SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET;
2974#else /* 1 */ 2987#else /* 1 */
2975 2988
2976 /* MSch: new-style reset handling: let the mid-level do what it can */ 2989 /* MSch: new-style reset handling: let the mid-level do what it can */
2977 2990
2978 /* ++guenther: MID-LEVEL IS STILL BROKEN. 2991 /* ++guenther: MID-LEVEL IS STILL BROKEN.
2979 * Mid-level is supposed to requeue all commands that were active on the 2992 * Mid-level is supposed to requeue all commands that were active on the
2980 * various low-level queues. In fact it does this, but that's not enough 2993 * various low-level queues. In fact it does this, but that's not enough
2981 * because all these commands are subject to timeout. And if a timeout 2994 * because all these commands are subject to timeout. And if a timeout
2982 * happens for any removed command, *_abort() is called but all queues 2995 * happens for any removed command, *_abort() is called but all queues
2983 * are now empty. Abort then gives up the falcon lock, which is fatal, 2996 * are now empty. Abort then gives up the falcon lock, which is fatal,
2984 * since the mid-level will queue more commands and must have the lock 2997 * since the mid-level will queue more commands and must have the lock
2985 * (it's all happening inside timer interrupt handler!!). 2998 * (it's all happening inside timer interrupt handler!!).
2986 * Even worse, abort will return NOT_RUNNING for all those commands not 2999 * Even worse, abort will return NOT_RUNNING for all those commands not
2987 * on any queue, so they won't be retried ... 3000 * on any queue, so they won't be retried ...
2988 * 3001 *
2989 * Conclusion: either scsi.c disables timeout for all resetted commands 3002 * Conclusion: either scsi.c disables timeout for all resetted commands
2990 * immediately, or we lose! As of linux-2.0.20 it doesn't. 3003 * immediately, or we lose! As of linux-2.0.20 it doesn't.
2991 */ 3004 */
2992 3005
2993 /* After the reset, there are no more connected or disconnected commands 3006 /* After the reset, there are no more connected or disconnected commands
2994 * and no busy units; so clear the low-level status here to avoid 3007 * and no busy units; so clear the low-level status here to avoid
2995 * conflicts when the mid-level code tries to wake up the affected 3008 * conflicts when the mid-level code tries to wake up the affected
2996 * commands! 3009 * commands!
2997 */ 3010 */
2998 3011
2999 if (hostdata->issue_queue) 3012 if (hostdata->issue_queue)
3000 ABRT_PRINTK("scsi%d: reset aborted issued command(s)\n", H_NO(cmd)); 3013 ABRT_PRINTK("scsi%d: reset aborted issued command(s)\n", H_NO(cmd));
3001 if (hostdata->connected) 3014 if (hostdata->connected)
3002 ABRT_PRINTK("scsi%d: reset aborted a connected command\n", H_NO(cmd)); 3015 ABRT_PRINTK("scsi%d: reset aborted a connected command\n", H_NO(cmd));
3003 if (hostdata->disconnected_queue) 3016 if (hostdata->disconnected_queue)
3004 ABRT_PRINTK("scsi%d: reset aborted disconnected command(s)\n", H_NO(cmd)); 3017 ABRT_PRINTK("scsi%d: reset aborted disconnected command(s)\n", H_NO(cmd));
3005 3018
3006 local_irq_save(flags); 3019 local_irq_save(flags);
3007 hostdata->issue_queue = NULL; 3020 hostdata->issue_queue = NULL;
3008 hostdata->connected = NULL; 3021 hostdata->connected = NULL;
3009 hostdata->disconnected_queue = NULL; 3022 hostdata->disconnected_queue = NULL;
3010#ifdef SUPPORT_TAGS 3023#ifdef SUPPORT_TAGS
3011 free_all_tags(); 3024 free_all_tags();
3012#endif 3025#endif
3013 for( i = 0; i < 8; ++i ) 3026 for (i = 0; i < 8; ++i)
3014 hostdata->busy[i] = 0; 3027 hostdata->busy[i] = 0;
3015#ifdef REAL_DMA 3028#ifdef REAL_DMA
3016 hostdata->dma_len = 0; 3029 hostdata->dma_len = 0;
3017#endif 3030#endif
3018 local_irq_restore(flags); 3031 local_irq_restore(flags);
3019 3032
3020 /* we did no complete reset of all commands, so a wakeup is required */ 3033 /* we did no complete reset of all commands, so a wakeup is required */
3021 return SCSI_RESET_WAKEUP | SCSI_RESET_BUS_RESET; 3034 return SCSI_RESET_WAKEUP | SCSI_RESET_BUS_RESET;
3022#endif /* 1 */ 3035#endif /* 1 */
3023} 3036}
3024
3025/* Local Variables: */
3026/* tab-width: 8 */
3027/* End: */
diff --git a/drivers/scsi/atari_scsi.c b/drivers/scsi/atari_scsi.c
index 85b8acc94034..f766d0d81c99 100644
--- a/drivers/scsi/atari_scsi.c
+++ b/drivers/scsi/atari_scsi.c
@@ -186,38 +186,37 @@ static inline void DISABLE_IRQ(void)
186/***************************** Prototypes *****************************/ 186/***************************** Prototypes *****************************/
187 187
188#ifdef REAL_DMA 188#ifdef REAL_DMA
189static int scsi_dma_is_ignored_buserr( unsigned char dma_stat ); 189static int scsi_dma_is_ignored_buserr(unsigned char dma_stat);
190static void atari_scsi_fetch_restbytes( void ); 190static void atari_scsi_fetch_restbytes(void);
191static long atari_scsi_dma_residual( struct Scsi_Host *instance ); 191static long atari_scsi_dma_residual(struct Scsi_Host *instance);
192static int falcon_classify_cmd( Scsi_Cmnd *cmd ); 192static int falcon_classify_cmd(Scsi_Cmnd *cmd);
193static unsigned long atari_dma_xfer_len( unsigned long wanted_len, 193static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
194 Scsi_Cmnd *cmd, int write_flag ); 194 Scsi_Cmnd *cmd, int write_flag);
195#endif 195#endif
196static irqreturn_t scsi_tt_intr( int irq, void *dummy); 196static irqreturn_t scsi_tt_intr(int irq, void *dummy);
197static irqreturn_t scsi_falcon_intr( int irq, void *dummy); 197static irqreturn_t scsi_falcon_intr(int irq, void *dummy);
198static void falcon_release_lock_if_possible( struct NCR5380_hostdata * 198static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata);
199 hostdata ); 199static void falcon_get_lock(void);
200static void falcon_get_lock( void );
201#ifdef CONFIG_ATARI_SCSI_RESET_BOOT 200#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
202static void atari_scsi_reset_boot( void ); 201static void atari_scsi_reset_boot(void);
203#endif 202#endif
204static unsigned char atari_scsi_tt_reg_read( unsigned char reg ); 203static unsigned char atari_scsi_tt_reg_read(unsigned char reg);
205static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value); 204static void atari_scsi_tt_reg_write(unsigned char reg, unsigned char value);
206static unsigned char atari_scsi_falcon_reg_read( unsigned char reg ); 205static unsigned char atari_scsi_falcon_reg_read(unsigned char reg);
207static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value ); 206static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value);
208 207
209/************************* End of Prototypes **************************/ 208/************************* End of Prototypes **************************/
210 209
211 210
212static struct Scsi_Host *atari_scsi_host = NULL; 211static struct Scsi_Host *atari_scsi_host;
213static unsigned char (*atari_scsi_reg_read)( unsigned char reg ); 212static unsigned char (*atari_scsi_reg_read)(unsigned char reg);
214static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value ); 213static void (*atari_scsi_reg_write)(unsigned char reg, unsigned char value);
215 214
216#ifdef REAL_DMA 215#ifdef REAL_DMA
217static unsigned long atari_dma_residual, atari_dma_startaddr; 216static unsigned long atari_dma_residual, atari_dma_startaddr;
218static short atari_dma_active; 217static short atari_dma_active;
219/* pointer to the dribble buffer */ 218/* pointer to the dribble buffer */
220static char *atari_dma_buffer = NULL; 219static char *atari_dma_buffer;
221/* precalculated physical address of the dribble buffer */ 220/* precalculated physical address of the dribble buffer */
222static unsigned long atari_dma_phys_buffer; 221static unsigned long atari_dma_phys_buffer;
223/* != 0 tells the Falcon int handler to copy data from the dribble buffer */ 222/* != 0 tells the Falcon int handler to copy data from the dribble buffer */
@@ -233,7 +232,7 @@ static char *atari_dma_orig_addr;
233static unsigned long atari_dma_stram_mask; 232static unsigned long atari_dma_stram_mask;
234#define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0) 233#define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0)
235/* number of bytes to cut from a transfer to handle NCR overruns */ 234/* number of bytes to cut from a transfer to handle NCR overruns */
236static int atari_read_overruns = 0; 235static int atari_read_overruns;
237#endif 236#endif
238 237
239static int setup_can_queue = -1; 238static int setup_can_queue = -1;
@@ -256,10 +255,10 @@ module_param(setup_hostid, int, 0);
256 255
257#if defined(REAL_DMA) 256#if defined(REAL_DMA)
258 257
259static int scsi_dma_is_ignored_buserr( unsigned char dma_stat ) 258static int scsi_dma_is_ignored_buserr(unsigned char dma_stat)
260{ 259{
261 int i; 260 int i;
262 unsigned long addr = SCSI_DMA_READ_P( dma_addr ), end_addr; 261 unsigned long addr = SCSI_DMA_READ_P(dma_addr), end_addr;
263 262
264 if (dma_stat & 0x01) { 263 if (dma_stat & 0x01) {
265 264
@@ -267,15 +266,14 @@ static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
267 * physical memory chunk (DMA prefetch!), but that doesn't hurt. 266 * physical memory chunk (DMA prefetch!), but that doesn't hurt.
268 * Check for this case: 267 * Check for this case:
269 */ 268 */
270 269
271 for( i = 0; i < m68k_num_memory; ++i ) { 270 for (i = 0; i < m68k_num_memory; ++i) {
272 end_addr = m68k_memory[i].addr + 271 end_addr = m68k_memory[i].addr + m68k_memory[i].size;
273 m68k_memory[i].size;
274 if (end_addr <= addr && addr <= end_addr + 4) 272 if (end_addr <= addr && addr <= end_addr + 4)
275 return( 1 ); 273 return 1;
276 } 274 }
277 } 275 }
278 return( 0 ); 276 return 0;
279} 277}
280 278
281 279
@@ -284,28 +282,27 @@ static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
284 * end-of-DMA, both SCSI ints are triggered simultaneously, so the NCR int has 282 * end-of-DMA, both SCSI ints are triggered simultaneously, so the NCR int has
285 * to clear the DMA int pending bit before it allows other level 6 interrupts. 283 * to clear the DMA int pending bit before it allows other level 6 interrupts.
286 */ 284 */
287static void scsi_dma_buserr (int irq, void *dummy) 285static void scsi_dma_buserr(int irq, void *dummy)
288{ 286{
289 unsigned char dma_stat = tt_scsi_dma.dma_ctrl; 287 unsigned char dma_stat = tt_scsi_dma.dma_ctrl;
290 288
291 /* Don't do anything if a NCR interrupt is pending. Probably it's just 289 /* Don't do anything if a NCR interrupt is pending. Probably it's just
292 * masked... */ 290 * masked... */
293 if (atari_irq_pending( IRQ_TT_MFP_SCSI )) 291 if (atari_irq_pending(IRQ_TT_MFP_SCSI))
294 return; 292 return;
295 293
296 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n", 294 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
297 SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt)); 295 SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt));
298 if (dma_stat & 0x80) { 296 if (dma_stat & 0x80) {
299 if (!scsi_dma_is_ignored_buserr( dma_stat )) 297 if (!scsi_dma_is_ignored_buserr(dma_stat))
300 printk( "SCSI DMA bus error -- bad DMA programming!\n" ); 298 printk("SCSI DMA bus error -- bad DMA programming!\n");
301 } 299 } else {
302 else {
303 /* Under normal circumstances we never should get to this point, 300 /* Under normal circumstances we never should get to this point,
304 * since both interrupts are triggered simultaneously and the 5380 301 * since both interrupts are triggered simultaneously and the 5380
305 * int has higher priority. When this irq is handled, that DMA 302 * int has higher priority. When this irq is handled, that DMA
306 * interrupt is cleared. So a warning message is printed here. 303 * interrupt is cleared. So a warning message is printed here.
307 */ 304 */
308 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" ); 305 printk("SCSI DMA intr ?? -- this shouldn't happen!\n");
309 } 306 }
310} 307}
311#endif 308#endif
@@ -313,7 +310,7 @@ static void scsi_dma_buserr (int irq, void *dummy)
313#endif 310#endif
314 311
315 312
316static irqreturn_t scsi_tt_intr (int irq, void *dummy) 313static irqreturn_t scsi_tt_intr(int irq, void *dummy)
317{ 314{
318#ifdef REAL_DMA 315#ifdef REAL_DMA
319 int dma_stat; 316 int dma_stat;
@@ -327,7 +324,7 @@ static irqreturn_t scsi_tt_intr (int irq, void *dummy)
327 * is that a bus error occurred... 324 * is that a bus error occurred...
328 */ 325 */
329 if (dma_stat & 0x80) { 326 if (dma_stat & 0x80) {
330 if (!scsi_dma_is_ignored_buserr( dma_stat )) { 327 if (!scsi_dma_is_ignored_buserr(dma_stat)) {
331 printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n", 328 printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n",
332 SCSI_DMA_READ_P(dma_addr)); 329 SCSI_DMA_READ_P(dma_addr));
333 printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!"); 330 printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!");
@@ -344,8 +341,7 @@ static irqreturn_t scsi_tt_intr (int irq, void *dummy)
344 * data reg! 341 * data reg!
345 */ 342 */
346 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) { 343 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
347 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P( dma_addr ) - 344 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P(dma_addr) - atari_dma_startaddr);
348 atari_dma_startaddr);
349 345
350 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n", 346 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
351 atari_dma_residual); 347 atari_dma_residual);
@@ -353,28 +349,30 @@ static irqreturn_t scsi_tt_intr (int irq, void *dummy)
353 if ((signed int)atari_dma_residual < 0) 349 if ((signed int)atari_dma_residual < 0)
354 atari_dma_residual = 0; 350 atari_dma_residual = 0;
355 if ((dma_stat & 1) == 0) { 351 if ((dma_stat & 1) == 0) {
356 /* After read operations, we maybe have to 352 /*
357 transport some rest bytes */ 353 * After read operations, we maybe have to
354 * transport some rest bytes
355 */
358 atari_scsi_fetch_restbytes(); 356 atari_scsi_fetch_restbytes();
359 } 357 } else {
360 else { 358 /*
361 /* There seems to be a nasty bug in some SCSI-DMA/NCR 359 * There seems to be a nasty bug in some SCSI-DMA/NCR
362 combinations: If a target disconnects while a write 360 * combinations: If a target disconnects while a write
363 operation is going on, the address register of the 361 * operation is going on, the address register of the
364 DMA may be a few bytes farer than it actually read. 362 * DMA may be a few bytes farer than it actually read.
365 This is probably due to DMA prefetching and a delay 363 * This is probably due to DMA prefetching and a delay
366 between DMA and NCR. Experiments showed that the 364 * between DMA and NCR. Experiments showed that the
367 dma_addr is 9 bytes to high, but this could vary. 365 * dma_addr is 9 bytes to high, but this could vary.
368 The problem is, that the residual is thus calculated 366 * The problem is, that the residual is thus calculated
369 wrong and the next transfer will start behind where 367 * wrong and the next transfer will start behind where
370 it should. So we round up the residual to the next 368 * it should. So we round up the residual to the next
371 multiple of a sector size, if it isn't already a 369 * multiple of a sector size, if it isn't already a
372 multiple and the originally expected transfer size 370 * multiple and the originally expected transfer size
373 was. The latter condition is there to ensure that 371 * was. The latter condition is there to ensure that
374 the correction is taken only for "real" data 372 * the correction is taken only for "real" data
375 transfers and not for, e.g., the parameters of some 373 * transfers and not for, e.g., the parameters of some
376 other command. These shouldn't disconnect anyway. 374 * other command. These shouldn't disconnect anyway.
377 */ 375 */
378 if (atari_dma_residual & 0x1ff) { 376 if (atari_dma_residual & 0x1ff) {
379 DMA_PRINTK("SCSI DMA: DMA bug corrected, " 377 DMA_PRINTK("SCSI DMA: DMA bug corrected, "
380 "difference %ld bytes\n", 378 "difference %ld bytes\n",
@@ -394,18 +392,18 @@ static irqreturn_t scsi_tt_intr (int irq, void *dummy)
394 } 392 }
395 393
396#endif /* REAL_DMA */ 394#endif /* REAL_DMA */
397 395
398 NCR5380_intr(0, 0); 396 NCR5380_intr(0, 0);
399 397
400#if 0 398#if 0
401 /* To be sure the int is not masked */ 399 /* To be sure the int is not masked */
402 atari_enable_irq( IRQ_TT_MFP_SCSI ); 400 atari_enable_irq(IRQ_TT_MFP_SCSI);
403#endif 401#endif
404 return IRQ_HANDLED; 402 return IRQ_HANDLED;
405} 403}
406 404
407 405
408static irqreturn_t scsi_falcon_intr (int irq, void *dummy) 406static irqreturn_t scsi_falcon_intr(int irq, void *dummy)
409{ 407{
410#ifdef REAL_DMA 408#ifdef REAL_DMA
411 int dma_stat; 409 int dma_stat;
@@ -430,7 +428,7 @@ static irqreturn_t scsi_falcon_intr (int irq, void *dummy)
430 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!) 428 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
431 */ 429 */
432 if (atari_dma_active && (dma_stat & 0x02)) { 430 if (atari_dma_active && (dma_stat & 0x02)) {
433 unsigned long transferred; 431 unsigned long transferred;
434 432
435 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr; 433 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
436 /* The ST-DMA address is incremented in 2-byte steps, but the 434 /* The ST-DMA address is incremented in 2-byte steps, but the
@@ -445,8 +443,7 @@ static irqreturn_t scsi_falcon_intr (int irq, void *dummy)
445 atari_dma_residual = HOSTDATA_DMALEN - transferred; 443 atari_dma_residual = HOSTDATA_DMALEN - transferred;
446 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n", 444 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
447 atari_dma_residual); 445 atari_dma_residual);
448 } 446 } else
449 else
450 atari_dma_residual = 0; 447 atari_dma_residual = 0;
451 atari_dma_active = 0; 448 atari_dma_active = 0;
452 449
@@ -467,7 +464,7 @@ static irqreturn_t scsi_falcon_intr (int irq, void *dummy)
467 464
468 465
469#ifdef REAL_DMA 466#ifdef REAL_DMA
470static void atari_scsi_fetch_restbytes( void ) 467static void atari_scsi_fetch_restbytes(void)
471{ 468{
472 int nr; 469 int nr;
473 char *src, *dst; 470 char *src, *dst;
@@ -505,19 +502,17 @@ static int falcon_dont_release = 0;
505 * again (but others waiting longer more probably will win). 502 * again (but others waiting longer more probably will win).
506 */ 503 */
507 504
508static void 505static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata)
509falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
510{ 506{
511 unsigned long flags; 507 unsigned long flags;
512 508
513 if (IS_A_TT()) return; 509 if (IS_A_TT())
514 510 return;
511
515 local_irq_save(flags); 512 local_irq_save(flags);
516 513
517 if (falcon_got_lock && 514 if (falcon_got_lock && !hostdata->disconnected_queue &&
518 !hostdata->disconnected_queue && 515 !hostdata->issue_queue && !hostdata->connected) {
519 !hostdata->issue_queue &&
520 !hostdata->connected) {
521 516
522 if (falcon_dont_release) { 517 if (falcon_dont_release) {
523#if 0 518#if 0
@@ -528,7 +523,7 @@ falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
528 } 523 }
529 falcon_got_lock = 0; 524 falcon_got_lock = 0;
530 stdma_release(); 525 stdma_release();
531 wake_up( &falcon_fairness_wait ); 526 wake_up(&falcon_fairness_wait);
532 } 527 }
533 528
534 local_irq_restore(flags); 529 local_irq_restore(flags);
@@ -549,31 +544,31 @@ falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
549 * Complicated, complicated.... Sigh... 544 * Complicated, complicated.... Sigh...
550 */ 545 */
551 546
552static void falcon_get_lock( void ) 547static void falcon_get_lock(void)
553{ 548{
554 unsigned long flags; 549 unsigned long flags;
555 550
556 if (IS_A_TT()) return; 551 if (IS_A_TT())
552 return;
557 553
558 local_irq_save(flags); 554 local_irq_save(flags);
559 555
560 while (!in_irq() && falcon_got_lock && stdma_others_waiting()) 556 while (!in_irq() && falcon_got_lock && stdma_others_waiting())
561 sleep_on( &falcon_fairness_wait ); 557 sleep_on(&falcon_fairness_wait);
562 558
563 while (!falcon_got_lock) { 559 while (!falcon_got_lock) {
564 if (in_irq()) 560 if (in_irq())
565 panic( "Falcon SCSI hasn't ST-DMA lock in interrupt" ); 561 panic("Falcon SCSI hasn't ST-DMA lock in interrupt");
566 if (!falcon_trying_lock) { 562 if (!falcon_trying_lock) {
567 falcon_trying_lock = 1; 563 falcon_trying_lock = 1;
568 stdma_lock(scsi_falcon_intr, NULL); 564 stdma_lock(scsi_falcon_intr, NULL);
569 falcon_got_lock = 1; 565 falcon_got_lock = 1;
570 falcon_trying_lock = 0; 566 falcon_trying_lock = 0;
571 wake_up( &falcon_try_wait ); 567 wake_up(&falcon_try_wait);
572 } 568 } else {
573 else { 569 sleep_on(&falcon_try_wait);
574 sleep_on( &falcon_try_wait );
575 } 570 }
576 } 571 }
577 572
578 local_irq_restore(flags); 573 local_irq_restore(flags);
579 if (!falcon_got_lock) 574 if (!falcon_got_lock)
@@ -587,18 +582,18 @@ static void falcon_get_lock( void )
587 */ 582 */
588 583
589#if 0 584#if 0
590int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) 585int atari_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
591{ 586{
592 /* falcon_get_lock(); 587 /* falcon_get_lock();
593 * ++guenther: moved to NCR5380_queue_command() to prevent 588 * ++guenther: moved to NCR5380_queue_command() to prevent
594 * race condition, see there for an explanation. 589 * race condition, see there for an explanation.
595 */ 590 */
596 return( NCR5380_queue_command( cmd, done ) ); 591 return NCR5380_queue_command(cmd, done);
597} 592}
598#endif 593#endif
599 594
600 595
601int atari_scsi_detect (struct scsi_host_template *host) 596int atari_scsi_detect(struct scsi_host_template *host)
602{ 597{
603 static int called = 0; 598 static int called = 0;
604 struct Scsi_Host *instance; 599 struct Scsi_Host *instance;
@@ -606,7 +601,7 @@ int atari_scsi_detect (struct scsi_host_template *host)
606 if (!MACH_IS_ATARI || 601 if (!MACH_IS_ATARI ||
607 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) || 602 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
608 called) 603 called)
609 return( 0 ); 604 return 0;
610 605
611 host->proc_name = "Atari"; 606 host->proc_name = "Atari";
612 607
@@ -655,32 +650,33 @@ int atari_scsi_detect (struct scsi_host_template *host)
655 !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) { 650 !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) {
656 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI"); 651 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
657 if (!atari_dma_buffer) { 652 if (!atari_dma_buffer) {
658 printk( KERN_ERR "atari_scsi_detect: can't allocate ST-RAM " 653 printk(KERN_ERR "atari_scsi_detect: can't allocate ST-RAM "
659 "double buffer\n" ); 654 "double buffer\n");
660 return( 0 ); 655 return 0;
661 } 656 }
662 atari_dma_phys_buffer = virt_to_phys( atari_dma_buffer ); 657 atari_dma_phys_buffer = virt_to_phys(atari_dma_buffer);
663 atari_dma_orig_addr = 0; 658 atari_dma_orig_addr = 0;
664 } 659 }
665#endif 660#endif
666 instance = scsi_register (host, sizeof (struct NCR5380_hostdata)); 661 instance = scsi_register(host, sizeof(struct NCR5380_hostdata));
667 if(instance == NULL) 662 if (instance == NULL) {
668 {
669 atari_stram_free(atari_dma_buffer); 663 atari_stram_free(atari_dma_buffer);
670 atari_dma_buffer = 0; 664 atari_dma_buffer = 0;
671 return 0; 665 return 0;
672 } 666 }
673 atari_scsi_host = instance; 667 atari_scsi_host = instance;
674 /* Set irq to 0, to avoid that the mid-level code disables our interrupt 668 /*
675 * during queue_command calls. This is completely unnecessary, and even 669 * Set irq to 0, to avoid that the mid-level code disables our interrupt
676 * worse causes bad problems on the Falcon, where the int is shared with 670 * during queue_command calls. This is completely unnecessary, and even
677 * IDE and floppy! */ 671 * worse causes bad problems on the Falcon, where the int is shared with
672 * IDE and floppy!
673 */
678 instance->irq = 0; 674 instance->irq = 0;
679 675
680#ifdef CONFIG_ATARI_SCSI_RESET_BOOT 676#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
681 atari_scsi_reset_boot(); 677 atari_scsi_reset_boot();
682#endif 678#endif
683 NCR5380_init (instance, 0); 679 NCR5380_init(instance, 0);
684 680
685 if (IS_A_TT()) { 681 if (IS_A_TT()) {
686 682
@@ -727,11 +723,10 @@ int atari_scsi_detect (struct scsi_host_template *host)
727 * the rest data bug is fixed, this can be lowered to 1. 723 * the rest data bug is fixed, this can be lowered to 1.
728 */ 724 */
729 atari_read_overruns = 4; 725 atari_read_overruns = 4;
730 } 726 }
731#endif /*REAL_DMA*/ 727#endif /*REAL_DMA*/
732 } 728 } else { /* ! IS_A_TT */
733 else { /* ! IS_A_TT */ 729
734
735 /* Nothing to do for the interrupt: the ST-DMA is initialized 730 /* Nothing to do for the interrupt: the ST-DMA is initialized
736 * already by atari_init_INTS() 731 * already by atari_init_INTS()
737 */ 732 */
@@ -756,19 +751,19 @@ int atari_scsi_detect (struct scsi_host_template *host)
756 setup_use_tagged_queuing ? "yes" : "no", 751 setup_use_tagged_queuing ? "yes" : "no",
757#endif 752#endif
758 instance->hostt->this_id ); 753 instance->hostt->this_id );
759 NCR5380_print_options (instance); 754 NCR5380_print_options(instance);
760 printk ("\n"); 755 printk("\n");
761 756
762 called = 1; 757 called = 1;
763 return( 1 ); 758 return 1;
764} 759}
765 760
766int atari_scsi_release (struct Scsi_Host *sh) 761int atari_scsi_release(struct Scsi_Host *sh)
767{ 762{
768 if (IS_A_TT()) 763 if (IS_A_TT())
769 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr); 764 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
770 if (atari_dma_buffer) 765 if (atari_dma_buffer)
771 atari_stram_free (atari_dma_buffer); 766 atari_stram_free(atari_dma_buffer);
772 return 1; 767 return 1;
773} 768}
774 769
@@ -779,9 +774,9 @@ void __init atari_scsi_setup(char *str, int *ints)
779 * Defaults depend on TT or Falcon, hostid determined at run time. 774 * Defaults depend on TT or Falcon, hostid determined at run time.
780 * Negative values mean don't change. 775 * Negative values mean don't change.
781 */ 776 */
782 777
783 if (ints[0] < 1) { 778 if (ints[0] < 1) {
784 printk( "atari_scsi_setup: no arguments!\n" ); 779 printk("atari_scsi_setup: no arguments!\n");
785 return; 780 return;
786 } 781 }
787 782
@@ -807,7 +802,7 @@ void __init atari_scsi_setup(char *str, int *ints)
807 if (ints[4] >= 0 && ints[4] <= 7) 802 if (ints[4] >= 0 && ints[4] <= 7)
808 setup_hostid = ints[4]; 803 setup_hostid = ints[4];
809 else if (ints[4] > 7) 804 else if (ints[4] > 7)
810 printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] ); 805 printk("atari_scsi_setup: invalid host ID %d !\n", ints[4]);
811 } 806 }
812#ifdef SUPPORT_TAGS 807#ifdef SUPPORT_TAGS
813 if (ints[0] >= 5) { 808 if (ints[0] >= 5) {
@@ -819,7 +814,7 @@ void __init atari_scsi_setup(char *str, int *ints)
819 814
820int atari_scsi_bus_reset(Scsi_Cmnd *cmd) 815int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
821{ 816{
822 int rv; 817 int rv;
823 struct NCR5380_hostdata *hostdata = 818 struct NCR5380_hostdata *hostdata =
824 (struct NCR5380_hostdata *)cmd->device->host->hostdata; 819 (struct NCR5380_hostdata *)cmd->device->host->hostdata;
825 820
@@ -829,13 +824,12 @@ int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
829 */ 824 */
830 /* And abort a maybe active DMA transfer */ 825 /* And abort a maybe active DMA transfer */
831 if (IS_A_TT()) { 826 if (IS_A_TT()) {
832 atari_turnoff_irq( IRQ_TT_MFP_SCSI ); 827 atari_turnoff_irq(IRQ_TT_MFP_SCSI);
833#ifdef REAL_DMA 828#ifdef REAL_DMA
834 tt_scsi_dma.dma_ctrl = 0; 829 tt_scsi_dma.dma_ctrl = 0;
835#endif /* REAL_DMA */ 830#endif /* REAL_DMA */
836 } 831 } else {
837 else { 832 atari_turnoff_irq(IRQ_MFP_FSCSI);
838 atari_turnoff_irq( IRQ_MFP_FSCSI );
839#ifdef REAL_DMA 833#ifdef REAL_DMA
840 st_dma.dma_mode_status = 0x90; 834 st_dma.dma_mode_status = 0x90;
841 atari_dma_active = 0; 835 atari_dma_active = 0;
@@ -847,52 +841,51 @@ int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
847 841
848 /* Re-enable ints */ 842 /* Re-enable ints */
849 if (IS_A_TT()) { 843 if (IS_A_TT()) {
850 atari_turnon_irq( IRQ_TT_MFP_SCSI ); 844 atari_turnon_irq(IRQ_TT_MFP_SCSI);
851 } 845 } else {
852 else { 846 atari_turnon_irq(IRQ_MFP_FSCSI);
853 atari_turnon_irq( IRQ_MFP_FSCSI );
854 } 847 }
855 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS) 848 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
856 falcon_release_lock_if_possible(hostdata); 849 falcon_release_lock_if_possible(hostdata);
857 850
858 return( rv ); 851 return rv;
859} 852}
860 853
861 854
862#ifdef CONFIG_ATARI_SCSI_RESET_BOOT 855#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
863static void __init atari_scsi_reset_boot(void) 856static void __init atari_scsi_reset_boot(void)
864{ 857{
865 unsigned long end; 858 unsigned long end;
866 859
867 /* 860 /*
868 * Do a SCSI reset to clean up the bus during initialization. No messing 861 * Do a SCSI reset to clean up the bus during initialization. No messing
869 * with the queues, interrupts, or locks necessary here. 862 * with the queues, interrupts, or locks necessary here.
870 */ 863 */
871 864
872 printk( "Atari SCSI: resetting the SCSI bus..." ); 865 printk("Atari SCSI: resetting the SCSI bus...");
873 866
874 /* get in phase */ 867 /* get in phase */
875 NCR5380_write( TARGET_COMMAND_REG, 868 NCR5380_write(TARGET_COMMAND_REG,
876 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) )); 869 PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG)));
877 870
878 /* assert RST */ 871 /* assert RST */
879 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST ); 872 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
880 /* The min. reset hold time is 25us, so 40us should be enough */ 873 /* The min. reset hold time is 25us, so 40us should be enough */
881 udelay( 50 ); 874 udelay(50);
882 /* reset RST and interrupt */ 875 /* reset RST and interrupt */
883 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE ); 876 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
884 NCR5380_read( RESET_PARITY_INTERRUPT_REG ); 877 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
885 878
886 end = jiffies + AFTER_RESET_DELAY; 879 end = jiffies + AFTER_RESET_DELAY;
887 while (time_before(jiffies, end)) 880 while (time_before(jiffies, end))
888 barrier(); 881 barrier();
889 882
890 printk( " done\n" ); 883 printk(" done\n");
891} 884}
892#endif 885#endif
893 886
894 887
895const char * atari_scsi_info (struct Scsi_Host *host) 888const char *atari_scsi_info(struct Scsi_Host *host)
896{ 889{
897 /* atari_scsi_detect() is verbose enough... */ 890 /* atari_scsi_detect() is verbose enough... */
898 static const char string[] = "Atari native SCSI"; 891 static const char string[] = "Atari native SCSI";
@@ -902,10 +895,10 @@ const char * atari_scsi_info (struct Scsi_Host *host)
902 895
903#if defined(REAL_DMA) 896#if defined(REAL_DMA)
904 897
905unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data, 898unsigned long atari_scsi_dma_setup(struct Scsi_Host *instance, void *data,
906 unsigned long count, int dir ) 899 unsigned long count, int dir)
907{ 900{
908 unsigned long addr = virt_to_phys( data ); 901 unsigned long addr = virt_to_phys(data);
909 902
910 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, " 903 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
911 "dir = %d\n", instance->host_no, data, addr, count, dir); 904 "dir = %d\n", instance->host_no, data, addr, count, dir);
@@ -917,38 +910,37 @@ unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
917 * wanted address. 910 * wanted address.
918 */ 911 */
919 if (dir) 912 if (dir)
920 memcpy( atari_dma_buffer, data, count ); 913 memcpy(atari_dma_buffer, data, count);
921 else 914 else
922 atari_dma_orig_addr = data; 915 atari_dma_orig_addr = data;
923 addr = atari_dma_phys_buffer; 916 addr = atari_dma_phys_buffer;
924 } 917 }
925 918
926 atari_dma_startaddr = addr; /* Needed for calculating residual later. */ 919 atari_dma_startaddr = addr; /* Needed for calculating residual later. */
927 920
928 /* Cache cleanup stuff: On writes, push any dirty cache out before sending 921 /* Cache cleanup stuff: On writes, push any dirty cache out before sending
929 * it to the peripheral. (Must be done before DMA setup, since at least 922 * it to the peripheral. (Must be done before DMA setup, since at least
930 * the ST-DMA begins to fill internal buffers right after setup. For 923 * the ST-DMA begins to fill internal buffers right after setup. For
931 * reads, invalidate any cache, may be altered after DMA without CPU 924 * reads, invalidate any cache, may be altered after DMA without CPU
932 * knowledge. 925 * knowledge.
933 * 926 *
934 * ++roman: For the Medusa, there's no need at all for that cache stuff, 927 * ++roman: For the Medusa, there's no need at all for that cache stuff,
935 * because the hardware does bus snooping (fine!). 928 * because the hardware does bus snooping (fine!).
936 */ 929 */
937 dma_cache_maintenance( addr, count, dir ); 930 dma_cache_maintenance(addr, count, dir);
938 931
939 if (count == 0) 932 if (count == 0)
940 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n"); 933 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
941 934
942 if (IS_A_TT()) { 935 if (IS_A_TT()) {
943 tt_scsi_dma.dma_ctrl = dir; 936 tt_scsi_dma.dma_ctrl = dir;
944 SCSI_DMA_WRITE_P( dma_addr, addr ); 937 SCSI_DMA_WRITE_P(dma_addr, addr);
945 SCSI_DMA_WRITE_P( dma_cnt, count ); 938 SCSI_DMA_WRITE_P(dma_cnt, count);
946 tt_scsi_dma.dma_ctrl = dir | 2; 939 tt_scsi_dma.dma_ctrl = dir | 2;
947 } 940 } else { /* ! IS_A_TT */
948 else { /* ! IS_A_TT */ 941
949
950 /* set address */ 942 /* set address */
951 SCSI_DMA_SETADR( addr ); 943 SCSI_DMA_SETADR(addr);
952 944
953 /* toggle direction bit to clear FIFO and set DMA direction */ 945 /* toggle direction bit to clear FIFO and set DMA direction */
954 dir <<= 8; 946 dir <<= 8;
@@ -966,13 +958,13 @@ unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
966 atari_dma_active = 1; 958 atari_dma_active = 1;
967 } 959 }
968 960
969 return( count ); 961 return count;
970} 962}
971 963
972 964
973static long atari_scsi_dma_residual( struct Scsi_Host *instance ) 965static long atari_scsi_dma_residual(struct Scsi_Host *instance)
974{ 966{
975 return( atari_dma_residual ); 967 return atari_dma_residual;
976} 968}
977 969
978 970
@@ -980,13 +972,13 @@ static long atari_scsi_dma_residual( struct Scsi_Host *instance )
980#define CMD_SURELY_BYTE_MODE 1 972#define CMD_SURELY_BYTE_MODE 1
981#define CMD_MODE_UNKNOWN 2 973#define CMD_MODE_UNKNOWN 2
982 974
983static int falcon_classify_cmd( Scsi_Cmnd *cmd ) 975static int falcon_classify_cmd(Scsi_Cmnd *cmd)
984{ 976{
985 unsigned char opcode = cmd->cmnd[0]; 977 unsigned char opcode = cmd->cmnd[0];
986 978
987 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG || 979 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
988 opcode == READ_BUFFER) 980 opcode == READ_BUFFER)
989 return( CMD_SURELY_BYTE_MODE ); 981 return CMD_SURELY_BYTE_MODE;
990 else if (opcode == READ_6 || opcode == READ_10 || 982 else if (opcode == READ_6 || opcode == READ_10 ||
991 opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE || 983 opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
992 opcode == RECOVER_BUFFERED_DATA) { 984 opcode == RECOVER_BUFFERED_DATA) {
@@ -994,12 +986,11 @@ static int falcon_classify_cmd( Scsi_Cmnd *cmd )
994 * needed here: The transfer is block-mode only if the 'fixed' bit is 986 * needed here: The transfer is block-mode only if the 'fixed' bit is
995 * set! */ 987 * set! */
996 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1)) 988 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
997 return( CMD_SURELY_BYTE_MODE ); 989 return CMD_SURELY_BYTE_MODE;
998 else 990 else
999 return( CMD_SURELY_BLOCK_MODE ); 991 return CMD_SURELY_BLOCK_MODE;
1000 } 992 } else
1001 else 993 return CMD_MODE_UNKNOWN;
1002 return( CMD_MODE_UNKNOWN );
1003} 994}
1004 995
1005 996
@@ -1012,19 +1003,18 @@ static int falcon_classify_cmd( Scsi_Cmnd *cmd )
1012 * the overrun problem, so this question is academic :-) 1003 * the overrun problem, so this question is academic :-)
1013 */ 1004 */
1014 1005
1015static unsigned long atari_dma_xfer_len( unsigned long wanted_len, 1006static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
1016 Scsi_Cmnd *cmd, 1007 Scsi_Cmnd *cmd, int write_flag)
1017 int write_flag )
1018{ 1008{
1019 unsigned long possible_len, limit; 1009 unsigned long possible_len, limit;
1020#ifndef CONFIG_TT_DMA_EMUL 1010#ifndef CONFIG_TT_DMA_EMUL
1021 if (MACH_IS_HADES) 1011 if (MACH_IS_HADES)
1022 /* Hades has no SCSI DMA at all :-( Always force use of PIO */ 1012 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1023 return( 0 ); 1013 return 0;
1024#endif 1014#endif
1025 if (IS_A_TT()) 1015 if (IS_A_TT())
1026 /* TT SCSI DMA can transfer arbitrary #bytes */ 1016 /* TT SCSI DMA can transfer arbitrary #bytes */
1027 return( wanted_len ); 1017 return wanted_len;
1028 1018
1029 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max. 1019 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1030 * 255*512 bytes, but this should be enough) 1020 * 255*512 bytes, but this should be enough)
@@ -1060,8 +1050,7 @@ static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1060 * this). 1050 * this).
1061 */ 1051 */
1062 possible_len = wanted_len; 1052 possible_len = wanted_len;
1063 } 1053 } else {
1064 else {
1065 /* Read operations: if the wanted transfer length is not a multiple of 1054 /* Read operations: if the wanted transfer length is not a multiple of
1066 * 512, we cannot use DMA, since the ST-DMA cannot split transfers 1055 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1067 * (no interrupt on DMA finished!) 1056 * (no interrupt on DMA finished!)
@@ -1071,15 +1060,15 @@ static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1071 else { 1060 else {
1072 /* Now classify the command (see above) and decide whether it is 1061 /* Now classify the command (see above) and decide whether it is
1073 * allowed to do DMA at all */ 1062 * allowed to do DMA at all */
1074 switch( falcon_classify_cmd( cmd )) { 1063 switch (falcon_classify_cmd(cmd)) {
1075 case CMD_SURELY_BLOCK_MODE: 1064 case CMD_SURELY_BLOCK_MODE:
1076 possible_len = wanted_len; 1065 possible_len = wanted_len;
1077 break; 1066 break;
1078 case CMD_SURELY_BYTE_MODE: 1067 case CMD_SURELY_BYTE_MODE:
1079 possible_len = 0; /* DMA prohibited */ 1068 possible_len = 0; /* DMA prohibited */
1080 break; 1069 break;
1081 case CMD_MODE_UNKNOWN: 1070 case CMD_MODE_UNKNOWN:
1082 default: 1071 default:
1083 /* For unknown commands assume block transfers if the transfer 1072 /* For unknown commands assume block transfers if the transfer
1084 * size/allocation length is >= 1024 */ 1073 * size/allocation length is >= 1024 */
1085 possible_len = (wanted_len < 1024) ? 0 : wanted_len; 1074 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
@@ -1087,9 +1076,9 @@ static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1087 } 1076 }
1088 } 1077 }
1089 } 1078 }
1090 1079
1091 /* Last step: apply the hard limit on DMA transfers */ 1080 /* Last step: apply the hard limit on DMA transfers */
1092 limit = (atari_dma_buffer && !STRAM_ADDR( virt_to_phys(cmd->SCp.ptr) )) ? 1081 limit = (atari_dma_buffer && !STRAM_ADDR(virt_to_phys(cmd->SCp.ptr))) ?
1093 STRAM_BUFFER_SIZE : 255*512; 1082 STRAM_BUFFER_SIZE : 255*512;
1094 if (possible_len > limit) 1083 if (possible_len > limit)
1095 possible_len = limit; 1084 possible_len = limit;
@@ -1098,7 +1087,7 @@ static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1098 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes " 1087 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1099 "instead of %ld\n", possible_len, wanted_len); 1088 "instead of %ld\n", possible_len, wanted_len);
1100 1089
1101 return( possible_len ); 1090 return possible_len;
1102} 1091}
1103 1092
1104 1093
@@ -1112,23 +1101,23 @@ static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1112 * NCR5380_write call these functions via function pointers. 1101 * NCR5380_write call these functions via function pointers.
1113 */ 1102 */
1114 1103
1115static unsigned char atari_scsi_tt_reg_read( unsigned char reg ) 1104static unsigned char atari_scsi_tt_reg_read(unsigned char reg)
1116{ 1105{
1117 return( tt_scsi_regp[reg * 2] ); 1106 return tt_scsi_regp[reg * 2];
1118} 1107}
1119 1108
1120static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value ) 1109static void atari_scsi_tt_reg_write(unsigned char reg, unsigned char value)
1121{ 1110{
1122 tt_scsi_regp[reg * 2] = value; 1111 tt_scsi_regp[reg * 2] = value;
1123} 1112}
1124 1113
1125static unsigned char atari_scsi_falcon_reg_read( unsigned char reg ) 1114static unsigned char atari_scsi_falcon_reg_read(unsigned char reg)
1126{ 1115{
1127 dma_wd.dma_mode_status= (u_short)(0x88 + reg); 1116 dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1128 return( (u_char)dma_wd.fdc_acces_seccount ); 1117 return (u_char)dma_wd.fdc_acces_seccount;
1129} 1118}
1130 1119
1131static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value ) 1120static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value)
1132{ 1121{
1133 dma_wd.dma_mode_status = (u_short)(0x88 + reg); 1122 dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1134 dma_wd.fdc_acces_seccount = (u_short)value; 1123 dma_wd.fdc_acces_seccount = (u_short)value;
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-15 14:55:49 -0500