开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
atari_scsi.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：36k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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