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