1 /* 2 * atari_scsi.c -- Device dependent functions for the Atari generic SCSI port 3 * 4 * Copyright 1994 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de> 5 * 6 * Loosely based on the work of Robert De Vries' team and added: 7 * - working real DMA 8 * - Falcon support (untested yet!) ++bjoern fixed and now it works 9 * - lots of extensions and bug fixes. 10 * 11 * This file is subject to the terms and conditions of the GNU General Public 12 * License. See the file COPYING in the main directory of this archive 13 * for more details. 14 * 15 */ 16 17 18 /**************************************************************************/ 19 /* */ 20 /* Notes for Falcon SCSI: */ 21 /* ---------------------- */ 22 /* */ 23 /* Since the Falcon SCSI uses the ST-DMA chip, that is shared among */ 24 /* several device drivers, locking and unlocking the access to this */ 25 /* chip is required. But locking is not possible from an interrupt, */ 26 /* since it puts the process to sleep if the lock is not available. */ 27 /* This prevents "late" locking of the DMA chip, i.e. locking it just */ 28 /* before using it, since in case of disconnection-reconnection */ 29 /* commands, the DMA is started from the reselection interrupt. */ 30 /* */ 31 /* Two possible schemes for ST-DMA-locking would be: */ 32 /* 1) The lock is taken for each command separately and disconnecting */ 33 /* is forbidden (i.e. can_queue = 1). */ 34 /* 2) The DMA chip is locked when the first command comes in and */ 35 /* released when the last command is finished and all queues are */ 36 /* empty. */ 37 /* The first alternative would result in bad performance, since the */ 38 /* interleaving of commands would not be used. The second is unfair to */ 39 /* other drivers using the ST-DMA, because the queues will seldom be */ 40 /* totally empty if there is a lot of disk traffic. */ 41 /* */ 42 /* For this reasons I decided to employ a more elaborate scheme: */ 43 /* - First, we give up the lock every time we can (for fairness), this */ 44 /* means every time a command finishes and there are no other commands */ 45 /* on the disconnected queue. */ 46 /* - If there are others waiting to lock the DMA chip, we stop */ 47 /* issuing commands, i.e. moving them onto the issue queue. */ 48 /* Because of that, the disconnected queue will run empty in a */ 49 /* while. Instead we go to sleep on a 'fairness_queue'. */ 50 /* - If the lock is released, all processes waiting on the fairness */ 51 /* queue will be woken. The first of them tries to re-lock the DMA, */ 52 /* the others wait for the first to finish this task. After that, */ 53 /* they can all run on and do their commands... */ 54 /* This sounds complicated (and it is it :-(), but it seems to be a */ 55 /* good compromise between fairness and performance: As long as no one */ 56 /* else wants to work with the ST-DMA chip, SCSI can go along as */ 57 /* usual. If now someone else comes, this behaviour is changed to a */ 58 /* "fairness mode": just already initiated commands are finished and */ 59 /* then the lock is released. The other one waiting will probably win */ 60 /* the race for locking the DMA, since it was waiting for longer. And */ 61 /* after it has finished, SCSI can go ahead again. Finally: I hope I */ 62 /* have not produced any deadlock possibilities! */ 63 /* */ 64 /**************************************************************************/ 65 66 67 68 #include <linux/module.h> 69 70 #define NDEBUG (0) 71 72 #define NDEBUG_ABORT 0x800000 73 #define NDEBUG_TAGS 0x1000000 74 #define NDEBUG_MERGING 0x2000000 75 76 #define AUTOSENSE 77 /* For the Atari version, use only polled IO or REAL_DMA */ 78 #define REAL_DMA 79 /* Support tagged queuing? (on devices that are able to... :-) */ 80 #define SUPPORT_TAGS 81 #define MAX_TAGS 32 82 83 #include <linux/types.h> 84 #include <linux/stddef.h> 85 #include <linux/ctype.h> 86 #include <linux/delay.h> 87 #include <linux/mm.h> 88 #include <linux/blkdev.h> 89 #include <linux/sched.h> 90 #include <linux/interrupt.h> 91 #include <linux/init.h> 92 #include <linux/nvram.h> 93 #include <linux/bitops.h> 94 95 #include <asm/setup.h> 96 #include <asm/atarihw.h> 97 #include <asm/atariints.h> 98 #include <asm/page.h> 99 #include <asm/pgtable.h> 100 #include <asm/irq.h> 101 #include <asm/traps.h> 102 103 #include "scsi.h" 104 #include <scsi/scsi_host.h> 105 #include "atari_scsi.h" 106 #include "NCR5380.h" 107 #include <asm/atari_stdma.h> 108 #include <asm/atari_stram.h> 109 #include <asm/io.h> 110 111 #include <linux/stat.h> 112 113 #define IS_A_TT() ATARIHW_PRESENT(TT_SCSI) 114 115 #define SCSI_DMA_WRITE_P(elt,val) \ 116 do { \ 117 unsigned long v = val; \ 118 tt_scsi_dma.elt##_lo = v & 0xff; \ 119 v >>= 8; \ 120 tt_scsi_dma.elt##_lmd = v & 0xff; \ 121 v >>= 8; \ 122 tt_scsi_dma.elt##_hmd = v & 0xff; \ 123 v >>= 8; \ 124 tt_scsi_dma.elt##_hi = v & 0xff; \ 125 } while(0) 126 127 #define SCSI_DMA_READ_P(elt) \ 128 (((((((unsigned long)tt_scsi_dma.elt##_hi << 8) | \ 129 (unsigned long)tt_scsi_dma.elt##_hmd) << 8) | \ 130 (unsigned long)tt_scsi_dma.elt##_lmd) << 8) | \ 131 (unsigned long)tt_scsi_dma.elt##_lo) 132 133 134 static inline void SCSI_DMA_SETADR(unsigned long adr) 135 { 136 st_dma.dma_lo = (unsigned char)adr; 137 MFPDELAY(); 138 adr >>= 8; 139 st_dma.dma_md = (unsigned char)adr; 140 MFPDELAY(); 141 adr >>= 8; 142 st_dma.dma_hi = (unsigned char)adr; 143 MFPDELAY(); 144 } 145 146 static inline unsigned long SCSI_DMA_GETADR(void) 147 { 148 unsigned long adr; 149 adr = st_dma.dma_lo; 150 MFPDELAY(); 151 adr |= (st_dma.dma_md & 0xff) << 8; 152 MFPDELAY(); 153 adr |= (st_dma.dma_hi & 0xff) << 16; 154 MFPDELAY(); 155 return adr; 156 } 157 158 static inline void ENABLE_IRQ(void) 159 { 160 if (IS_A_TT()) 161 atari_enable_irq(IRQ_TT_MFP_SCSI); 162 else 163 atari_enable_irq(IRQ_MFP_FSCSI); 164 } 165 166 static inline void DISABLE_IRQ(void) 167 { 168 if (IS_A_TT()) 169 atari_disable_irq(IRQ_TT_MFP_SCSI); 170 else 171 atari_disable_irq(IRQ_MFP_FSCSI); 172 } 173 174 175 #define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \ 176 (atari_scsi_host->hostdata))->dma_len) 177 178 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms, 179 * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more 180 * need ten times the standard value... */ 181 #ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY 182 #define AFTER_RESET_DELAY (HZ/2) 183 #else 184 #define AFTER_RESET_DELAY (5*HZ/2) 185 #endif 186 187 /***************************** Prototypes *****************************/ 188 189 #ifdef REAL_DMA 190 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat ); 191 static void atari_scsi_fetch_restbytes( void ); 192 static long atari_scsi_dma_residual( struct Scsi_Host *instance ); 193 static int falcon_classify_cmd( Scsi_Cmnd *cmd ); 194 static unsigned long atari_dma_xfer_len( unsigned long wanted_len, 195 Scsi_Cmnd *cmd, int write_flag ); 196 #endif 197 static irqreturn_t scsi_tt_intr( int irq, void *dummy, struct pt_regs *fp); 198 static irqreturn_t scsi_falcon_intr( int irq, void *dummy, struct pt_regs *fp); 199 static void falcon_release_lock_if_possible( struct NCR5380_hostdata * 200 hostdata ); 201 static void falcon_get_lock( void ); 202 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT 203 static void atari_scsi_reset_boot( void ); 204 #endif 205 static unsigned char atari_scsi_tt_reg_read( unsigned char reg ); 206 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value); 207 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg ); 208 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value ); 209 210 /************************* End of Prototypes **************************/ 211 212 213 static struct Scsi_Host *atari_scsi_host = NULL; 214 static unsigned char (*atari_scsi_reg_read)( unsigned char reg ); 215 static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value ); 216 217 #ifdef REAL_DMA 218 static unsigned long atari_dma_residual, atari_dma_startaddr; 219 static short atari_dma_active; 220 /* pointer to the dribble buffer */ 221 static char *atari_dma_buffer = NULL; 222 /* precalculated physical address of the dribble buffer */ 223 static unsigned long atari_dma_phys_buffer; 224 /* != 0 tells the Falcon int handler to copy data from the dribble buffer */ 225 static char *atari_dma_orig_addr; 226 /* size of the dribble buffer; 4k seems enough, since the Falcon cannot use 227 * scatter-gather anyway, so most transfers are 1024 byte only. In the rare 228 * cases where requests to physical contiguous buffers have been merged, this 229 * request is <= 4k (one page). So I don't think we have to split transfers 230 * just due to this buffer size... 231 */ 232 #define STRAM_BUFFER_SIZE (4096) 233 /* mask for address bits that can't be used with the ST-DMA */ 234 static unsigned long atari_dma_stram_mask; 235 #define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0) 236 /* number of bytes to cut from a transfer to handle NCR overruns */ 237 static int atari_read_overruns = 0; 238 #endif 239 240 static int setup_can_queue = -1; 241 module_param(setup_can_queue, int, 0); 242 static int setup_cmd_per_lun = -1; 243 module_param(setup_cmd_per_lun, int, 0); 244 static int setup_sg_tablesize = -1; 245 module_param(setup_sg_tablesize, int, 0); 246 #ifdef SUPPORT_TAGS 247 static int setup_use_tagged_queuing = -1; 248 module_param(setup_use_tagged_queuing, int, 0); 249 #endif 250 static int setup_hostid = -1; 251 module_param(setup_hostid, int, 0); 252 253 254 #if defined(CONFIG_TT_DMA_EMUL) 255 #include "atari_dma_emul.c" 256 #endif 257 258 #if defined(REAL_DMA) 259 260 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat ) 261 { 262 int i; 263 unsigned long addr = SCSI_DMA_READ_P( dma_addr ), end_addr; 264 265 if (dma_stat & 0x01) { 266 267 /* A bus error happens when DMA-ing from the last page of a 268 * physical memory chunk (DMA prefetch!), but that doesn't hurt. 269 * Check for this case: 270 */ 271 272 for( i = 0; i < m68k_num_memory; ++i ) { 273 end_addr = m68k_memory[i].addr + 274 m68k_memory[i].size; 275 if (end_addr <= addr && addr <= end_addr + 4) 276 return( 1 ); 277 } 278 } 279 return( 0 ); 280 } 281 282 283 #if 0 284 /* Dead code... wasn't called anyway :-) and causes some trouble, because at 285 * end-of-DMA, both SCSI ints are triggered simultaneously, so the NCR int has 286 * to clear the DMA int pending bit before it allows other level 6 interrupts. 287 */ 288 static void scsi_dma_buserr (int irq, void *dummy, struct pt_regs *fp) 289 { 290 unsigned char dma_stat = tt_scsi_dma.dma_ctrl; 291 292 /* Don't do anything if a NCR interrupt is pending. Probably it's just 293 * masked... */ 294 if (atari_irq_pending( IRQ_TT_MFP_SCSI )) 295 return; 296 297 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n", 298 SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt)); 299 if (dma_stat & 0x80) { 300 if (!scsi_dma_is_ignored_buserr( dma_stat )) 301 printk( "SCSI DMA bus error -- bad DMA programming!\n" ); 302 } 303 else { 304 /* Under normal circumstances we never should get to this point, 305 * since both interrupts are triggered simultaneously and the 5380 306 * int has higher priority. When this irq is handled, that DMA 307 * interrupt is cleared. So a warning message is printed here. 308 */ 309 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" ); 310 } 311 } 312 #endif 313 314 #endif 315 316 317 static irqreturn_t scsi_tt_intr (int irq, void *dummy, struct pt_regs *fp) 318 { 319 #ifdef REAL_DMA 320 int dma_stat; 321 322 dma_stat = tt_scsi_dma.dma_ctrl; 323 324 INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n", 325 atari_scsi_host->host_no, dma_stat & 0xff); 326 327 /* Look if it was the DMA that has interrupted: First possibility 328 * is that a bus error occurred... 329 */ 330 if (dma_stat & 0x80) { 331 if (!scsi_dma_is_ignored_buserr( dma_stat )) { 332 printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n", 333 SCSI_DMA_READ_P(dma_addr)); 334 printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!"); 335 } 336 } 337 338 /* If the DMA is active but not finished, we have the case 339 * that some other 5380 interrupt occurred within the DMA transfer. 340 * This means we have residual bytes, if the desired end address 341 * is not yet reached. Maybe we have to fetch some bytes from the 342 * rest data register, too. The residual must be calculated from 343 * the address pointer, not the counter register, because only the 344 * addr reg counts bytes not yet written and pending in the rest 345 * data reg! 346 */ 347 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) { 348 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P( dma_addr ) - 349 atari_dma_startaddr); 350 351 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n", 352 atari_dma_residual); 353 354 if ((signed int)atari_dma_residual < 0) 355 atari_dma_residual = 0; 356 if ((dma_stat & 1) == 0) { 357 /* After read operations, we maybe have to 358 transport some rest bytes */ 359 atari_scsi_fetch_restbytes(); 360 } 361 else { 362 /* There seems to be a nasty bug in some SCSI-DMA/NCR 363 combinations: If a target disconnects while a write 364 operation is going on, the address register of the 365 DMA may be a few bytes farer than it actually read. 366 This is probably due to DMA prefetching and a delay 367 between DMA and NCR. Experiments showed that the 368 dma_addr is 9 bytes to high, but this could vary. 369 The problem is, that the residual is thus calculated 370 wrong and the next transfer will start behind where 371 it should. So we round up the residual to the next 372 multiple of a sector size, if it isn't already a 373 multiple and the originally expected transfer size 374 was. The latter condition is there to ensure that 375 the correction is taken only for "real" data 376 transfers and not for, e.g., the parameters of some 377 other command. These shouldn't disconnect anyway. 378 */ 379 if (atari_dma_residual & 0x1ff) { 380 DMA_PRINTK("SCSI DMA: DMA bug corrected, " 381 "difference %ld bytes\n", 382 512 - (atari_dma_residual & 0x1ff)); 383 atari_dma_residual = (atari_dma_residual + 511) & ~0x1ff; 384 } 385 } 386 tt_scsi_dma.dma_ctrl = 0; 387 } 388 389 /* If the DMA is finished, fetch the rest bytes and turn it off */ 390 if (dma_stat & 0x40) { 391 atari_dma_residual = 0; 392 if ((dma_stat & 1) == 0) 393 atari_scsi_fetch_restbytes(); 394 tt_scsi_dma.dma_ctrl = 0; 395 } 396 397 #endif /* REAL_DMA */ 398 399 NCR5380_intr (0, 0, 0); 400 401 #if 0 402 /* To be sure the int is not masked */ 403 atari_enable_irq( IRQ_TT_MFP_SCSI ); 404 #endif 405 return IRQ_HANDLED; 406 } 407 408 409 static irqreturn_t scsi_falcon_intr (int irq, void *dummy, struct pt_regs *fp) 410 { 411 #ifdef REAL_DMA 412 int dma_stat; 413 414 /* Turn off DMA and select sector counter register before 415 * accessing the status register (Atari recommendation!) 416 */ 417 st_dma.dma_mode_status = 0x90; 418 dma_stat = st_dma.dma_mode_status; 419 420 /* Bit 0 indicates some error in the DMA process... don't know 421 * what happened exactly (no further docu). 422 */ 423 if (!(dma_stat & 0x01)) { 424 /* DMA error */ 425 printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR()); 426 } 427 428 /* If the DMA was active, but now bit 1 is not clear, it is some 429 * other 5380 interrupt that finishes the DMA transfer. We have to 430 * calculate the number of residual bytes and give a warning if 431 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!) 432 */ 433 if (atari_dma_active && (dma_stat & 0x02)) { 434 unsigned long transferred; 435 436 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr; 437 /* The ST-DMA address is incremented in 2-byte steps, but the 438 * data are written only in 16-byte chunks. If the number of 439 * transferred bytes is not divisible by 16, the remainder is 440 * lost somewhere in outer space. 441 */ 442 if (transferred & 15) 443 printk(KERN_ERR "SCSI DMA error: %ld bytes lost in " 444 "ST-DMA fifo\n", transferred & 15); 445 446 atari_dma_residual = HOSTDATA_DMALEN - transferred; 447 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n", 448 atari_dma_residual); 449 } 450 else 451 atari_dma_residual = 0; 452 atari_dma_active = 0; 453 454 if (atari_dma_orig_addr) { 455 /* If the dribble buffer was used on a read operation, copy the DMA-ed 456 * data to the original destination address. 457 */ 458 memcpy(atari_dma_orig_addr, phys_to_virt(atari_dma_startaddr), 459 HOSTDATA_DMALEN - atari_dma_residual); 460 atari_dma_orig_addr = NULL; 461 } 462 463 #endif /* REAL_DMA */ 464 465 NCR5380_intr (0, 0, 0); 466 return IRQ_HANDLED; 467 } 468 469 470 #ifdef REAL_DMA 471 static void atari_scsi_fetch_restbytes( void ) 472 { 473 int nr; 474 char *src, *dst; 475 unsigned long phys_dst; 476 477 /* fetch rest bytes in the DMA register */ 478 phys_dst = SCSI_DMA_READ_P(dma_addr); 479 nr = phys_dst & 3; 480 if (nr) { 481 /* there are 'nr' bytes left for the last long address 482 before the DMA pointer */ 483 phys_dst ^= nr; 484 DMA_PRINTK("SCSI DMA: there are %d rest bytes for phys addr 0x%08lx", 485 nr, phys_dst); 486 /* The content of the DMA pointer is a physical address! */ 487 dst = phys_to_virt(phys_dst); 488 DMA_PRINTK(" = virt addr %p\n", dst); 489 for (src = (char *)&tt_scsi_dma.dma_restdata; nr != 0; --nr) 490 *dst++ = *src++; 491 } 492 } 493 #endif /* REAL_DMA */ 494 495 496 static int falcon_got_lock = 0; 497 static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait); 498 static int falcon_trying_lock = 0; 499 static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait); 500 static int falcon_dont_release = 0; 501 502 /* This function releases the lock on the DMA chip if there is no 503 * connected command and the disconnected queue is empty. On 504 * releasing, instances of falcon_get_lock are awoken, that put 505 * themselves to sleep for fairness. They can now try to get the lock 506 * again (but others waiting longer more probably will win). 507 */ 508 509 static void 510 falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata ) 511 { 512 unsigned long flags; 513 514 if (IS_A_TT()) return; 515 516 local_irq_save(flags); 517 518 if (falcon_got_lock && 519 !hostdata->disconnected_queue && 520 !hostdata->issue_queue && 521 !hostdata->connected) { 522 523 if (falcon_dont_release) { 524 #if 0 525 printk("WARNING: Lock release not allowed. Ignored\n"); 526 #endif 527 local_irq_restore(flags); 528 return; 529 } 530 falcon_got_lock = 0; 531 stdma_release(); 532 wake_up( &falcon_fairness_wait ); 533 } 534 535 local_irq_restore(flags); 536 } 537 538 /* This function manages the locking of the ST-DMA. 539 * If the DMA isn't locked already for SCSI, it tries to lock it by 540 * calling stdma_lock(). But if the DMA is locked by the SCSI code and 541 * there are other drivers waiting for the chip, we do not issue the 542 * command immediately but wait on 'falcon_fairness_queue'. We will be 543 * waked up when the DMA is unlocked by some SCSI interrupt. After that 544 * we try to get the lock again. 545 * But we must be prepared that more than one instance of 546 * falcon_get_lock() is waiting on the fairness queue. They should not 547 * try all at once to call stdma_lock(), one is enough! For that, the 548 * first one sets 'falcon_trying_lock', others that see that variable 549 * set wait on the queue 'falcon_try_wait'. 550 * Complicated, complicated.... Sigh... 551 */ 552 553 static void falcon_get_lock( void ) 554 { 555 unsigned long flags; 556 557 if (IS_A_TT()) return; 558 559 local_irq_save(flags); 560 561 while( !in_interrupt() && falcon_got_lock && stdma_others_waiting() ) 562 sleep_on( &falcon_fairness_wait ); 563 564 while (!falcon_got_lock) { 565 if (in_interrupt()) 566 panic( "Falcon SCSI hasn't ST-DMA lock in interrupt" ); 567 if (!falcon_trying_lock) { 568 falcon_trying_lock = 1; 569 stdma_lock(scsi_falcon_intr, NULL); 570 falcon_got_lock = 1; 571 falcon_trying_lock = 0; 572 wake_up( &falcon_try_wait ); 573 } 574 else { 575 sleep_on( &falcon_try_wait ); 576 } 577 } 578 579 local_irq_restore(flags); 580 if (!falcon_got_lock) 581 panic("Falcon SCSI: someone stole the lock :-(\n"); 582 } 583 584 585 /* This is the wrapper function for NCR5380_queue_command(). It just 586 * tries to get the lock on the ST-DMA (see above) and then calls the 587 * original function. 588 */ 589 590 #if 0 591 int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) 592 { 593 /* falcon_get_lock(); 594 * ++guenther: moved to NCR5380_queue_command() to prevent 595 * race condition, see there for an explanation. 596 */ 597 return( NCR5380_queue_command( cmd, done ) ); 598 } 599 #endif 600 601 602 int atari_scsi_detect (struct scsi_host_template *host) 603 { 604 static int called = 0; 605 struct Scsi_Host *instance; 606 607 if (!MACH_IS_ATARI || 608 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) || 609 called) 610 return( 0 ); 611 612 host->proc_name = "Atari"; 613 614 atari_scsi_reg_read = IS_A_TT() ? atari_scsi_tt_reg_read : 615 atari_scsi_falcon_reg_read; 616 atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write : 617 atari_scsi_falcon_reg_write; 618 619 /* setup variables */ 620 host->can_queue = 621 (setup_can_queue > 0) ? setup_can_queue : 622 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE; 623 host->cmd_per_lun = 624 (setup_cmd_per_lun > 0) ? setup_cmd_per_lun : 625 IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN; 626 /* Force sg_tablesize to 0 on a Falcon! */ 627 host->sg_tablesize = 628 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE : 629 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE; 630 631 if (setup_hostid >= 0) 632 host->this_id = setup_hostid; 633 else { 634 /* use 7 as default */ 635 host->this_id = 7; 636 /* Test if a host id is set in the NVRam */ 637 if (ATARIHW_PRESENT(TT_CLK) && nvram_check_checksum()) { 638 unsigned char b = nvram_read_byte( 14 ); 639 /* Arbitration enabled? (for TOS) If yes, use configured host ID */ 640 if (b & 0x80) 641 host->this_id = b & 7; 642 } 643 } 644 645 #ifdef SUPPORT_TAGS 646 if (setup_use_tagged_queuing < 0) 647 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING; 648 #endif 649 #ifdef REAL_DMA 650 /* If running on a Falcon and if there's TT-Ram (i.e., more than one 651 * memory block, since there's always ST-Ram in a Falcon), then allocate a 652 * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative 653 * Ram. 654 */ 655 if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) && 656 !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) { 657 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI"); 658 if (!atari_dma_buffer) { 659 printk( KERN_ERR "atari_scsi_detect: can't allocate ST-RAM " 660 "double buffer\n" ); 661 return( 0 ); 662 } 663 atari_dma_phys_buffer = virt_to_phys( atari_dma_buffer ); 664 atari_dma_orig_addr = 0; 665 } 666 #endif 667 instance = scsi_register (host, sizeof (struct NCR5380_hostdata)); 668 if(instance == NULL) 669 { 670 atari_stram_free(atari_dma_buffer); 671 atari_dma_buffer = 0; 672 return 0; 673 } 674 atari_scsi_host = instance; 675 /* Set irq to 0, to avoid that the mid-level code disables our interrupt 676 * during queue_command calls. This is completely unnecessary, and even 677 * worse causes bad problems on the Falcon, where the int is shared with 678 * IDE and floppy! */ 679 instance->irq = 0; 680 681 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT 682 atari_scsi_reset_boot(); 683 #endif 684 NCR5380_init (instance, 0); 685 686 if (IS_A_TT()) { 687 688 /* This int is actually "pseudo-slow", i.e. it acts like a slow 689 * interrupt after having cleared the pending flag for the DMA 690 * interrupt. */ 691 if (request_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_SLOW, 692 "SCSI NCR5380", scsi_tt_intr)) { 693 printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting",IRQ_TT_MFP_SCSI); 694 scsi_unregister(atari_scsi_host); 695 atari_stram_free(atari_dma_buffer); 696 atari_dma_buffer = 0; 697 return 0; 698 } 699 tt_mfp.active_edge |= 0x80; /* SCSI int on L->H */ 700 #ifdef REAL_DMA 701 tt_scsi_dma.dma_ctrl = 0; 702 atari_dma_residual = 0; 703 #ifdef CONFIG_TT_DMA_EMUL 704 if (MACH_IS_HADES) { 705 if (request_irq(IRQ_AUTO_2, hades_dma_emulator, 706 IRQ_TYPE_PRIO, "Hades DMA emulator", 707 hades_dma_emulator)) { 708 printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting (MACH_IS_HADES)",IRQ_AUTO_2); 709 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr); 710 scsi_unregister(atari_scsi_host); 711 atari_stram_free(atari_dma_buffer); 712 atari_dma_buffer = 0; 713 return 0; 714 } 715 } 716 #endif 717 if (MACH_IS_MEDUSA || MACH_IS_HADES) { 718 /* While the read overruns (described by Drew Eckhardt in 719 * NCR5380.c) never happened on TTs, they do in fact on the Medusa 720 * (This was the cause why SCSI didn't work right for so long 721 * there.) Since handling the overruns slows down a bit, I turned 722 * the #ifdef's into a runtime condition. 723 * 724 * In principle it should be sufficient to do max. 1 byte with 725 * PIO, but there is another problem on the Medusa with the DMA 726 * rest data register. So 'atari_read_overruns' is currently set 727 * to 4 to avoid having transfers that aren't a multiple of 4. If 728 * the rest data bug is fixed, this can be lowered to 1. 729 */ 730 atari_read_overruns = 4; 731 } 732 #endif /*REAL_DMA*/ 733 } 734 else { /* ! IS_A_TT */ 735 736 /* Nothing to do for the interrupt: the ST-DMA is initialized 737 * already by atari_init_INTS() 738 */ 739 740 #ifdef REAL_DMA 741 atari_dma_residual = 0; 742 atari_dma_active = 0; 743 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000 744 : 0xff000000); 745 #endif 746 } 747 748 printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d " 749 #ifdef SUPPORT_TAGS 750 "TAGGED-QUEUING=%s " 751 #endif 752 "HOSTID=%d", 753 instance->host_no, instance->hostt->can_queue, 754 instance->hostt->cmd_per_lun, 755 instance->hostt->sg_tablesize, 756 #ifdef SUPPORT_TAGS 757 setup_use_tagged_queuing ? "yes" : "no", 758 #endif 759 instance->hostt->this_id ); 760 NCR5380_print_options (instance); 761 printk ("\n"); 762 763 called = 1; 764 return( 1 ); 765 } 766 767 #ifdef MODULE 768 int atari_scsi_release (struct Scsi_Host *sh) 769 { 770 if (IS_A_TT()) 771 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr); 772 if (atari_dma_buffer) 773 atari_stram_free (atari_dma_buffer); 774 return 1; 775 } 776 #endif 777 778 void __init atari_scsi_setup(char *str, int *ints) 779 { 780 /* Format of atascsi parameter is: 781 * atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags> 782 * Defaults depend on TT or Falcon, hostid determined at run time. 783 * Negative values mean don't change. 784 */ 785 786 if (ints[0] < 1) { 787 printk( "atari_scsi_setup: no arguments!\n" ); 788 return; 789 } 790 791 if (ints[0] >= 1) { 792 if (ints[1] > 0) 793 /* no limits on this, just > 0 */ 794 setup_can_queue = ints[1]; 795 } 796 if (ints[0] >= 2) { 797 if (ints[2] > 0) 798 setup_cmd_per_lun = ints[2]; 799 } 800 if (ints[0] >= 3) { 801 if (ints[3] >= 0) { 802 setup_sg_tablesize = ints[3]; 803 /* Must be <= SG_ALL (255) */ 804 if (setup_sg_tablesize > SG_ALL) 805 setup_sg_tablesize = SG_ALL; 806 } 807 } 808 if (ints[0] >= 4) { 809 /* Must be between 0 and 7 */ 810 if (ints[4] >= 0 && ints[4] <= 7) 811 setup_hostid = ints[4]; 812 else if (ints[4] > 7) 813 printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] ); 814 } 815 #ifdef SUPPORT_TAGS 816 if (ints[0] >= 5) { 817 if (ints[5] >= 0) 818 setup_use_tagged_queuing = !!ints[5]; 819 } 820 #endif 821 } 822 823 int atari_scsi_bus_reset(Scsi_Cmnd *cmd) 824 { 825 int rv; 826 struct NCR5380_hostdata *hostdata = 827 (struct NCR5380_hostdata *)cmd->device->host->hostdata; 828 829 /* For doing the reset, SCSI interrupts must be disabled first, 830 * since the 5380 raises its IRQ line while _RST is active and we 831 * can't disable interrupts completely, since we need the timer. 832 */ 833 /* And abort a maybe active DMA transfer */ 834 if (IS_A_TT()) { 835 atari_turnoff_irq( IRQ_TT_MFP_SCSI ); 836 #ifdef REAL_DMA 837 tt_scsi_dma.dma_ctrl = 0; 838 #endif /* REAL_DMA */ 839 } 840 else { 841 atari_turnoff_irq( IRQ_MFP_FSCSI ); 842 #ifdef REAL_DMA 843 st_dma.dma_mode_status = 0x90; 844 atari_dma_active = 0; 845 atari_dma_orig_addr = NULL; 846 #endif /* REAL_DMA */ 847 } 848 849 rv = NCR5380_bus_reset(cmd); 850 851 /* Re-enable ints */ 852 if (IS_A_TT()) { 853 atari_turnon_irq( IRQ_TT_MFP_SCSI ); 854 } 855 else { 856 atari_turnon_irq( IRQ_MFP_FSCSI ); 857 } 858 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS) 859 falcon_release_lock_if_possible(hostdata); 860 861 return( rv ); 862 } 863 864 865 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT 866 static void __init atari_scsi_reset_boot(void) 867 { 868 unsigned long end; 869 870 /* 871 * Do a SCSI reset to clean up the bus during initialization. No messing 872 * with the queues, interrupts, or locks necessary here. 873 */ 874 875 printk( "Atari SCSI: resetting the SCSI bus..." ); 876 877 /* get in phase */ 878 NCR5380_write( TARGET_COMMAND_REG, 879 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) )); 880 881 /* assert RST */ 882 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST ); 883 /* The min. reset hold time is 25us, so 40us should be enough */ 884 udelay( 50 ); 885 /* reset RST and interrupt */ 886 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE ); 887 NCR5380_read( RESET_PARITY_INTERRUPT_REG ); 888 889 end = jiffies + AFTER_RESET_DELAY; 890 while (time_before(jiffies, end)) 891 barrier(); 892 893 printk( " done\n" ); 894 } 895 #endif 896 897 898 const char * atari_scsi_info (struct Scsi_Host *host) 899 { 900 /* atari_scsi_detect() is verbose enough... */ 901 static const char string[] = "Atari native SCSI"; 902 return string; 903 } 904 905 906 #if defined(REAL_DMA) 907 908 unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data, 909 unsigned long count, int dir ) 910 { 911 unsigned long addr = virt_to_phys( data ); 912 913 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, " 914 "dir = %d\n", instance->host_no, data, addr, count, dir); 915 916 if (!IS_A_TT() && !STRAM_ADDR(addr)) { 917 /* If we have a non-DMAable address on a Falcon, use the dribble 918 * buffer; 'orig_addr' != 0 in the read case tells the interrupt 919 * handler to copy data from the dribble buffer to the originally 920 * wanted address. 921 */ 922 if (dir) 923 memcpy( atari_dma_buffer, data, count ); 924 else 925 atari_dma_orig_addr = data; 926 addr = atari_dma_phys_buffer; 927 } 928 929 atari_dma_startaddr = addr; /* Needed for calculating residual later. */ 930 931 /* Cache cleanup stuff: On writes, push any dirty cache out before sending 932 * it to the peripheral. (Must be done before DMA setup, since at least 933 * the ST-DMA begins to fill internal buffers right after setup. For 934 * reads, invalidate any cache, may be altered after DMA without CPU 935 * knowledge. 936 * 937 * ++roman: For the Medusa, there's no need at all for that cache stuff, 938 * because the hardware does bus snooping (fine!). 939 */ 940 dma_cache_maintenance( addr, count, dir ); 941 942 if (count == 0) 943 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n"); 944 945 if (IS_A_TT()) { 946 tt_scsi_dma.dma_ctrl = dir; 947 SCSI_DMA_WRITE_P( dma_addr, addr ); 948 SCSI_DMA_WRITE_P( dma_cnt, count ); 949 tt_scsi_dma.dma_ctrl = dir | 2; 950 } 951 else { /* ! IS_A_TT */ 952 953 /* set address */ 954 SCSI_DMA_SETADR( addr ); 955 956 /* toggle direction bit to clear FIFO and set DMA direction */ 957 dir <<= 8; 958 st_dma.dma_mode_status = 0x90 | dir; 959 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100); 960 st_dma.dma_mode_status = 0x90 | dir; 961 udelay(40); 962 /* On writes, round up the transfer length to the next multiple of 512 963 * (see also comment at atari_dma_xfer_len()). */ 964 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9; 965 udelay(40); 966 st_dma.dma_mode_status = 0x10 | dir; 967 udelay(40); 968 /* need not restore value of dir, only boolean value is tested */ 969 atari_dma_active = 1; 970 } 971 972 return( count ); 973 } 974 975 976 static long atari_scsi_dma_residual( struct Scsi_Host *instance ) 977 { 978 return( atari_dma_residual ); 979 } 980 981 982 #define CMD_SURELY_BLOCK_MODE 0 983 #define CMD_SURELY_BYTE_MODE 1 984 #define CMD_MODE_UNKNOWN 2 985 986 static int falcon_classify_cmd( Scsi_Cmnd *cmd ) 987 { 988 unsigned char opcode = cmd->cmnd[0]; 989 990 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG || 991 opcode == READ_BUFFER) 992 return( CMD_SURELY_BYTE_MODE ); 993 else if (opcode == READ_6 || opcode == READ_10 || 994 opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE || 995 opcode == RECOVER_BUFFERED_DATA) { 996 /* In case of a sequential-access target (tape), special care is 997 * needed here: The transfer is block-mode only if the 'fixed' bit is 998 * set! */ 999 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1)) 1000 return( CMD_SURELY_BYTE_MODE ); 1001 else 1002 return( CMD_SURELY_BLOCK_MODE ); 1003 } 1004 else 1005 return( CMD_MODE_UNKNOWN ); 1006 } 1007 1008 1009 /* This function calculates the number of bytes that can be transferred via 1010 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the 1011 * ST-DMA chip. There are only multiples of 512 bytes possible and max. 1012 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not 1013 * possible on the Falcon, since that would require to program the DMA for 1014 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have 1015 * the overrun problem, so this question is academic :-) 1016 */ 1017 1018 static unsigned long atari_dma_xfer_len( unsigned long wanted_len, 1019 Scsi_Cmnd *cmd, 1020 int write_flag ) 1021 { 1022 unsigned long possible_len, limit; 1023 #ifndef CONFIG_TT_DMA_EMUL 1024 if (MACH_IS_HADES) 1025 /* Hades has no SCSI DMA at all :-( Always force use of PIO */ 1026 return( 0 ); 1027 #endif 1028 if (IS_A_TT()) 1029 /* TT SCSI DMA can transfer arbitrary #bytes */ 1030 return( wanted_len ); 1031 1032 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max. 1033 * 255*512 bytes, but this should be enough) 1034 * 1035 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands 1036 * that return a number of bytes which cannot be known beforehand. In this 1037 * case, the given transfer length is an "allocation length". Now it 1038 * can happen that this allocation length is a multiple of 512 bytes and 1039 * the DMA is used. But if not n*512 bytes really arrive, some input data 1040 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish 1041 * between commands that do block transfers and those that do byte 1042 * transfers. But this isn't easy... there are lots of vendor specific 1043 * commands, and the user can issue any command via the 1044 * SCSI_IOCTL_SEND_COMMAND. 1045 * 1046 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s, 1047 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1) 1048 * and 3), the thing to do is obvious: allow any number of blocks via DMA 1049 * or none. In case 2), we apply some heuristic: Byte mode is assumed if 1050 * the transfer (allocation) length is < 1024, hoping that no cmd. not 1051 * explicitly known as byte mode have such big allocation lengths... 1052 * BTW, all the discussion above applies only to reads. DMA writes are 1053 * unproblematic anyways, since the targets aborts the transfer after 1054 * receiving a sufficient number of bytes. 1055 * 1056 * Another point: If the transfer is from/to an non-ST-RAM address, we 1057 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes. 1058 */ 1059 1060 if (write_flag) { 1061 /* Write operation can always use the DMA, but the transfer size must 1062 * be rounded up to the next multiple of 512 (atari_dma_setup() does 1063 * this). 1064 */ 1065 possible_len = wanted_len; 1066 } 1067 else { 1068 /* Read operations: if the wanted transfer length is not a multiple of 1069 * 512, we cannot use DMA, since the ST-DMA cannot split transfers 1070 * (no interrupt on DMA finished!) 1071 */ 1072 if (wanted_len & 0x1ff) 1073 possible_len = 0; 1074 else { 1075 /* Now classify the command (see above) and decide whether it is 1076 * allowed to do DMA at all */ 1077 switch( falcon_classify_cmd( cmd )) { 1078 case CMD_SURELY_BLOCK_MODE: 1079 possible_len = wanted_len; 1080 break; 1081 case CMD_SURELY_BYTE_MODE: 1082 possible_len = 0; /* DMA prohibited */ 1083 break; 1084 case CMD_MODE_UNKNOWN: 1085 default: 1086 /* For unknown commands assume block transfers if the transfer 1087 * size/allocation length is >= 1024 */ 1088 possible_len = (wanted_len < 1024) ? 0 : wanted_len; 1089 break; 1090 } 1091 } 1092 } 1093 1094 /* Last step: apply the hard limit on DMA transfers */ 1095 limit = (atari_dma_buffer && !STRAM_ADDR( virt_to_phys(cmd->SCp.ptr) )) ? 1096 STRAM_BUFFER_SIZE : 255*512; 1097 if (possible_len > limit) 1098 possible_len = limit; 1099 1100 if (possible_len != wanted_len) 1101 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes " 1102 "instead of %ld\n", possible_len, wanted_len); 1103 1104 return( possible_len ); 1105 } 1106 1107 1108 #endif /* REAL_DMA */ 1109 1110 1111 /* NCR5380 register access functions 1112 * 1113 * There are separate functions for TT and Falcon, because the access 1114 * methods are quite different. The calling macros NCR5380_read and 1115 * NCR5380_write call these functions via function pointers. 1116 */ 1117 1118 static unsigned char atari_scsi_tt_reg_read( unsigned char reg ) 1119 { 1120 return( tt_scsi_regp[reg * 2] ); 1121 } 1122 1123 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value ) 1124 { 1125 tt_scsi_regp[reg * 2] = value; 1126 } 1127 1128 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg ) 1129 { 1130 dma_wd.dma_mode_status= (u_short)(0x88 + reg); 1131 return( (u_char)dma_wd.fdc_acces_seccount ); 1132 } 1133 1134 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value ) 1135 { 1136 dma_wd.dma_mode_status = (u_short)(0x88 + reg); 1137 dma_wd.fdc_acces_seccount = (u_short)value; 1138 } 1139 1140 1141 #include "atari_NCR5380.c" 1142 1143 static struct scsi_host_template driver_template = { 1144 .proc_info = atari_scsi_proc_info, 1145 .name = "Atari native SCSI", 1146 .detect = atari_scsi_detect, 1147 .release = atari_scsi_release, 1148 .info = atari_scsi_info, 1149 .queuecommand = atari_scsi_queue_command, 1150 .eh_abort_handler = atari_scsi_abort, 1151 .eh_bus_reset_handler = atari_scsi_bus_reset, 1152 .can_queue = 0, /* initialized at run-time */ 1153 .this_id = 0, /* initialized at run-time */ 1154 .sg_tablesize = 0, /* initialized at run-time */ 1155 .cmd_per_lun = 0, /* initialized at run-time */ 1156 .use_clustering = DISABLE_CLUSTERING 1157 }; 1158 1159 1160 #include "scsi_module.c" 1161 1162 MODULE_LICENSE("GPL"); 1163