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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
53c700.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：67k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

53c700.c：源码内容
  1. /* -*- mode: c; c-basic-offset: 8 -*- */
  3. /* NCR (or Symbios) 53c700 and 53c700-66 Driver
  4.  *
  5.  * Copyright (C) 2001 by James.Bottomley@HansenPartnership.com
  6. **-----------------------------------------------------------------------------
  7. **  
  8. **  This program is free software; you can redistribute it and/or modify
  9. **  it under the terms of the GNU General Public License as published by
  10. **  the Free Software Foundation; either version 2 of the License, or
  11. **  (at your option) any later version.
  12. **
  13. **  This program is distributed in the hope that it will be useful,
  14. **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. **  GNU General Public License for more details.
  17. **
  18. **  You should have received a copy of the GNU General Public License
  19. **  along with this program; if not, write to the Free Software
  20. **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21. **
  22. **-----------------------------------------------------------------------------
  23.  */
  25. /* Notes:
  26.  *
  27.  * This driver is designed exclusively for these chips (virtually the
  28.  * earliest of the scripts engine chips).  They need their own drivers
  29.  * because they are missing so many of the scripts and snazzy register
  30.  * features of their elder brothers (the 710, 720 and 770).
  31.  *
  32.  * The 700 is the lowliest of the line, it can only do async SCSI.
  33.  * The 700-66 can at least do synchronous SCSI up to 10MHz.
  34.  * 
  35.  * The 700 chip has no host bus interface logic of its own.  However,
  36.  * it is usually mapped to a location with well defined register
  37.  * offsets.  Therefore, if you can determine the base address and the
  38.  * irq your board incorporating this chip uses, you can probably use
  39.  * this driver to run it (although you'll probably have to write a
  40.  * minimal wrapper for the purpose---see the NCR_D700 driver for
  41.  * details about how to do this).
  42.  *
  43.  *
  44.  * TODO List:
  45.  *
  46.  * 1. Better statistics in the proc fs
  47.  *
  48.  * 2. Implement message queue (queues SCSI messages like commands) and make
  49.  *    the abort and device reset functions use them.
  50.  * */
  52. /* CHANGELOG
  53.  *
  54.  * Version 2.7
  55.  *
  56.  * Fixed scripts problem which caused certain devices (notably CDRWs)
  57.  * to hang on initial INQUIRY.  Updated NCR_700_readl/writel to use
  58.  * __raw_readl/writel for parisc compatibility (Thomas
  59.  * Bogendoerfer). Added missing SCp->request_bufflen initialisation
  60.  * for sense requests (Ryan Bradetich).
  61.  *
  62.  * Version 2.6
  63.  *
  64.  * Following test of the 64 bit parisc kernel by Richard Hirst,
  65.  * several problems have now been corrected.  Also adds support for
  66.  * consistent memory allocation.
  67.  *
  68.  * Version 2.5
  69.  * 
  70.  * More Compatibility changes for 710 (now actually works).  Enhanced
  71.  * support for odd clock speeds which constrain SDTR negotiations.
  72.  * correct cacheline separation for scsi messages and status for
  73.  * incoherent architectures.  Use of the pci mapping functions on
  74.  * buffers to begin support for 64 bit drivers.
  75.  *
  76.  * Version 2.4
  77.  *
  78.  * Added support for the 53c710 chip (in 53c700 emulation mode only---no 
  79.  * special 53c710 instructions or registers are used).
  80.  *
  81.  * Version 2.3
  82.  *
  83.  * More endianness/cache coherency changes.
  84.  *
  85.  * Better bad device handling (handles devices lying about tag
  86.  * queueing support and devices which fail to provide sense data on
  87.  * contingent allegiance conditions)
  88.  *
  89.  * Many thanks to Richard Hirst <rhirst@linuxcare.com> for patiently
  90.  * debugging this driver on the parisc architecture and suggesting
  91.  * many improvements and bug fixes.
  92.  *
  93.  * Thanks also go to Linuxcare Inc. for providing several PARISC
  94.  * machines for me to debug the driver on.
  95.  *
  96.  * Version 2.2
  97.  *
  98.  * Made the driver mem or io mapped; added endian invariance; added
  99.  * dma cache flushing operations for architectures which need it;
  100.  * added support for more varied clocking speeds.
  101.  *
  102.  * Version 2.1
  103.  *
  104.  * Initial modularisation from the D700.  See NCR_D700.c for the rest of
  105.  * the changelog.
  106.  * */
  107. #define NCR_700_VERSION "2.7"
  109. #include <linux/config.h>
  110. #include <linux/version.h>
  111. #include <linux/kernel.h>
  112. #include <linux/types.h>
  113. #include <linux/string.h>
  114. #include <linux/ioport.h>
  115. #include <linux/delay.h>
  116. #include <linux/spinlock.h>
  117. #include <linux/sched.h>
  118. #include <linux/proc_fs.h>
  119. #include <linux/init.h>
  120. #include <linux/mca.h>
  121. #include <asm/dma.h>
  122. #include <asm/system.h>
  123. #include <asm/io.h>
  124. #include <asm/pgtable.h>
  125. #include <asm/byteorder.h>
  126. #include <linux/blk.h>
  127. #include <linux/module.h>
  128. #include <linux/pci.h>
  130. #include "scsi.h"
  131. #include "hosts.h"
  132. #include "constants.h"
  134. #include "53c700.h"
  136. /* NOTE: For 64 bit drivers there are points in the code where we use
  137.  * a non dereferenceable pointer to point to a structure in dma-able
  138.  * memory (which is 32 bits) so that we can use all of the structure
  139.  * operations but take the address at the end.  This macro allows us
  140.  * to truncate the 64 bit pointer down to 32 bits without the compiler
  141.  * complaining */
  142. #define to32bit(x) ((__u32)((unsigned long)(x)))
  144. #ifdef NCR_700_DEBUG
  145. #define STATIC
  146. #else
  147. #define STATIC static
  148. #endif
  150. MODULE_AUTHOR("James Bottomley");
  151. MODULE_DESCRIPTION("53c700 and 53c700-66 Driver");
  152. MODULE_LICENSE("GPL");
  154. /* This is the script */
  155. #include "53c700_d.h"
  158. STATIC int NCR_700_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
  159. STATIC int NCR_700_abort(Scsi_Cmnd * SCpnt);
  160. STATIC int NCR_700_bus_reset(Scsi_Cmnd * SCpnt);
  161. STATIC int NCR_700_dev_reset(Scsi_Cmnd * SCpnt);
  162. STATIC int NCR_700_host_reset(Scsi_Cmnd * SCpnt);
  163. STATIC int NCR_700_proc_directory_info(char *, char **, off_t, int, int, int);
  164. STATIC void NCR_700_chip_setup(struct Scsi_Host *host);
  165. STATIC void NCR_700_chip_reset(struct Scsi_Host *host);
  167. static char *NCR_700_phase[] = {
  168. "",
  169. "after selection",
  170. "before command phase",
  171. "after command phase",
  172. "after status phase",
  173. "after data in phase",
  174. "after data out phase",
  175. "during data phase",
  176. };
  178. static char *NCR_700_condition[] = {
  179. "",
  180. "NOT MSG_OUT",
  181. "UNEXPECTED PHASE",
  182. "NOT MSG_IN",
  183. "UNEXPECTED MSG",
  184. "MSG_IN",
  185. "SDTR_MSG RECEIVED",
  186. "REJECT_MSG RECEIVED",
  187. "DISCONNECT_MSG RECEIVED",
  188. "MSG_OUT",
  189. "DATA_IN",
  191. };
  193. static char *NCR_700_fatal_messages[] = {
  194. "unexpected message after reselection",
  195. "still MSG_OUT after message injection",
  196. "not MSG_IN after selection",
  197. "Illegal message length received",
  198. };
  200. static char *NCR_700_SBCL_bits[] = {
  201. "IO ",
  202. "CD ",
  203. "MSG ",
  204. "ATN ",
  205. "SEL ",
  206. "BSY ",
  207. "ACK ",
  208. "REQ ",
  209. };
  211. static char *NCR_700_SBCL_to_phase[] = {
  212. "DATA_OUT",
  213. "DATA_IN",
  214. "CMD_OUT",
  215. "STATE",
  216. "ILLEGAL PHASE",
  217. "ILLEGAL PHASE",
  218. "MSG OUT",
  219. "MSG IN",
  220. };
  222. static __u8 NCR_700_SDTR_msg[] = {
  223. 0x01, /* Extended message */
  224. 0x03, /* Extended message Length */
  225. 0x01, /* SDTR Extended message */
  226. NCR_700_MIN_PERIOD,
  227. NCR_700_MAX_OFFSET
  228. };
  230. struct Scsi_Host * __init
  231. NCR_700_detect(Scsi_Host_Template *tpnt,
  232.        struct NCR_700_Host_Parameters *hostdata)
  233. {
  234. dma_addr_t pScript, pMemory, pSlots;
  235. __u8 *memory;
  236. __u32 *script;
  237. struct Scsi_Host *host;
  238. static int banner = 0;
  239. int j;
  241. #ifdef CONFIG_53C700_USE_CONSISTENT
  242. memory = pci_alloc_consistent(hostdata->pci_dev, TOTAL_MEM_SIZE,
  243.       &pMemory);
  244. hostdata->consistent = 1;
  245. if(memory == NULL ) {
  246. printk(KERN_WARNING "53c700: consistent memory allocation failedn");
  247. #endif
  248. memory = kmalloc(TOTAL_MEM_SIZE, GFP_KERNEL);
  249. if(memory == NULL) {
  250. printk(KERN_ERR "53c700: Failed to allocate memory for driver, detatchingn");
  251. return NULL;
  252. }
  253. pMemory = pci_map_single(hostdata->pci_dev, memory,
  254.  TOTAL_MEM_SIZE, PCI_DMA_BIDIRECTIONAL);
  255. #ifdef CONFIG_53C700_USE_CONSISTENT
  256. hostdata->consistent = 0;
  257. }
  258. #endif
  259. script = (__u32 *)memory;
  260. pScript = pMemory;
  261. hostdata->msgin = memory + MSGIN_OFFSET;
  262. hostdata->msgout = memory + MSGOUT_OFFSET;
  263. hostdata->status = memory + STATUS_OFFSET;
  264. hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET);
  266. pSlots = pMemory + SLOTS_OFFSET;
  268. /* Fill in the missing routines from the host template */
  269. tpnt->queuecommand = NCR_700_queuecommand;
  270. tpnt->eh_abort_handler = NCR_700_abort;
  271. tpnt->eh_device_reset_handler = NCR_700_dev_reset;
  272. tpnt->eh_bus_reset_handler = NCR_700_bus_reset;
  273. tpnt->eh_host_reset_handler = NCR_700_host_reset;
  274. tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST;
  275. tpnt->sg_tablesize = NCR_700_SG_SEGMENTS;
  276. tpnt->cmd_per_lun = NCR_700_MAX_TAGS;
  277. tpnt->use_clustering = DISABLE_CLUSTERING;
  278. tpnt->use_new_eh_code = 1;
  279. tpnt->proc_info = NCR_700_proc_directory_info;
  281. if(tpnt->name == NULL)
  282. tpnt->name = "53c700";
  283. if(tpnt->proc_name == NULL)
  284. tpnt->proc_name = "53c700";
  287. if((host = scsi_register(tpnt, 4)) == NULL)
  288. return NULL;
  289. memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot)
  290.        * NCR_700_COMMAND_SLOTS_PER_HOST);
  291. for(j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) {
  292. dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0]
  293.   - (unsigned long)&hostdata->slots[0].SG[0]);
  294. hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset));
  295. if(j == 0)
  296. hostdata->free_list = &hostdata->slots[j];
  297. else
  298. hostdata->slots[j-1].ITL_forw = &hostdata->slots[j];
  299. hostdata->slots[j].state = NCR_700_SLOT_FREE;
  300. }
  302. for(j = 0; j < sizeof(SCRIPT)/sizeof(SCRIPT[0]); j++) {
  303. script[j] = bS_to_host(SCRIPT[j]);
  304. }
  306. /* adjust all labels to be bus physical */
  307. for(j = 0; j < PATCHES; j++) {
  308. script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]);
  309. }
  310. /* now patch up fixed addresses. */
  311. script_patch_32(script, MessageLocation,
  312. pScript + MSGOUT_OFFSET);
  313. script_patch_32(script, StatusAddress,
  314. pScript + STATUS_OFFSET);
  315. script_patch_32(script, ReceiveMsgAddress,
  316. pScript + MSGIN_OFFSET);
  318. hostdata->script = script;
  319. hostdata->pScript = pScript;
  320. NCR_700_dma_cache_wback((unsigned long)script, sizeof(SCRIPT));
  321. hostdata->state = NCR_700_HOST_FREE;
  322. spin_lock_init(&hostdata->lock);
  323. hostdata->cmd = NULL;
  324. host->max_id = 7;
  325. host->max_lun = NCR_700_MAX_LUNS;
  326. host->unique_id = hostdata->base;
  327. host->base = hostdata->base;
  328. host->hostdata[0] = (unsigned long)hostdata;
  329. /* kick the chip */
  330. NCR_700_writeb(0xff, host, CTEST9_REG);
  331. if(hostdata->chip710) 
  332. hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f;
  333. else
  334. hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f;
  335. hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0);
  336. if(banner == 0) {
  337. printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.comn");
  338. banner = 1;
  339. }
  340. printk(KERN_NOTICE "scsi%d: %s rev %d %sn", host->host_no,
  341.        hostdata->chip710 ? "53c710" : 
  342.        (hostdata->fast ? "53c700-66" : "53c700"),
  343.        hostdata->rev, hostdata->differential ?
  344.        "(Differential)" : "");
  345. /* reset the chip */
  346. NCR_700_chip_reset(host);
  348. return host;
  349. }
  351. int
  352. NCR_700_release(struct Scsi_Host *host)
  353. {
  354. struct NCR_700_Host_Parameters *hostdata = 
  355. (struct NCR_700_Host_Parameters *)host->hostdata[0];
  357. #ifdef CONFIG_53C700_USE_CONSISTENT
  358. if(hostdata->consistent) {
  359. pci_free_consistent(hostdata->pci_dev, TOTAL_MEM_SIZE,
  360.     hostdata->script, hostdata->pScript);
  361. } else {
  362. #endif
  363. pci_unmap_single(hostdata->pci_dev, hostdata->pScript,
  364.  TOTAL_MEM_SIZE, PCI_DMA_BIDIRECTIONAL);
  365. kfree(hostdata->script);
  366. #ifdef CONFIG_53C700_USE_CONSISTENT
  367. }
  368. #endif
  369. return 1;
  370. }
  372. static inline __u8
  373. NCR_700_identify(int can_disconnect, __u8 lun)
  374. {
  375. return IDENTIFY_BASE |
  376. ((can_disconnect) ? 0x40 : 0) |
  377. (lun & NCR_700_LUN_MASK);
  378. }
  380. /*
  381.  * Function : static int data_residual (Scsi_Host *host)
  382.  *
  383.  * Purpose : return residual data count of what's in the chip.  If you
  384.  * really want to know what this function is doing, it's almost a
  385.  * direct transcription of the algorithm described in the 53c710
  386.  * guide, except that the DBC and DFIFO registers are only 6 bits
  387.  * wide on a 53c700.
  388.  *
  389.  * Inputs : host - SCSI host */
  390. static inline int
  391. NCR_700_data_residual (struct Scsi_Host *host) {
  392. struct NCR_700_Host_Parameters *hostdata = 
  393. (struct NCR_700_Host_Parameters *)host->hostdata[0];
  394. int count, synchronous = 0;
  395. unsigned int ddir;
  397. if(hostdata->chip710) {
  398. count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) -
  399.  (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f;
  400. } else {
  401. count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) -
  402.  (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f;
  403. }
  405. if(hostdata->fast)
  406. synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f;
  408. /* get the data direction */
  409. ddir = NCR_700_readb(host, CTEST0_REG) & 0x01;
  411. if (ddir) {
  412. /* Receive */
  413. if (synchronous) 
  414. count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4;
  415. else
  416. if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL)
  417. ++count;
  418. } else {
  419. /* Send */
  420. __u8 sstat = NCR_700_readb(host, SSTAT1_REG);
  421. if (sstat & SODL_REG_FULL)
  422. ++count;
  423. if (synchronous && (sstat & SODR_REG_FULL))
  424. ++count;
  425. }
  426. #ifdef NCR_700_DEBUG
  427. if(count)
  428. printk("RESIDUAL IS %d (ddir %d)n", count, ddir);
  429. #endif
  430. return count;
  431. }
  433. /* print out the SCSI wires and corresponding phase from the SBCL register
  434.  * in the chip */
  435. static inline char *
  436. sbcl_to_string(__u8 sbcl)
  437. {
  438. int i;
  439. static char ret[256];
  441. ret[0]='';
  442. for(i=0; i<8; i++) {
  443. if((1<<i) & sbcl) 
  444. strcat(ret, NCR_700_SBCL_bits[i]);
  445. }
  446. strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]);
  447. return ret;
  448. }
  450. static inline __u8
  451. bitmap_to_number(__u8 bitmap)
  452. {
  453. __u8 i;
  455. for(i=0; i<8 && !(bitmap &(1<<i)); i++)
  456. ;
  457. return i;
  458. }
  460. /* Pull a slot off the free list */
  461. STATIC struct NCR_700_command_slot *
  462. find_empty_slot(struct NCR_700_Host_Parameters *hostdata)
  463. {
  464. struct NCR_700_command_slot *slot = hostdata->free_list;
  466. if(slot == NULL) {
  467. /* sanity check */
  468. if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST)
  469. printk(KERN_ERR "SLOTS FULL, but count is %d, should be %dn", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST);
  470. return NULL;
  471. }
  473. if(slot->state != NCR_700_SLOT_FREE)
  474. /* should panic! */
  475. printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!n");
  478. hostdata->free_list = slot->ITL_forw;
  479. slot->ITL_forw = NULL;
  482. /* NOTE: set the state to busy here, not queued, since this
  483.  * indicates the slot is in use and cannot be run by the IRQ
  484.  * finish routine.  If we cannot queue the command when it
  485.  * is properly build, we then change to NCR_700_SLOT_QUEUED */
  486. slot->state = NCR_700_SLOT_BUSY;
  487. hostdata->command_slot_count++;
  489. return slot;
  490. }
  492. STATIC void 
  493. free_slot(struct NCR_700_command_slot *slot,
  494.   struct NCR_700_Host_Parameters *hostdata)
  495. {
  496. int hash;
  497. struct NCR_700_command_slot **forw, **back;
  500. if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) {
  501. printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!n", slot);
  502. }
  503. if(slot->state == NCR_700_SLOT_FREE) {
  504. printk(KERN_ERR "53c700: SLOT %p is FREE!!!n", slot);
  505. }
  506. /* remove from queues */
  507. if(slot->tag != NCR_700_NO_TAG) {
  508. hash = hash_ITLQ(slot->cmnd->target, slot->cmnd->lun,
  509.  slot->tag);
  510. if(slot->ITLQ_forw == NULL)
  511. back = &hostdata->ITLQ_Hash_back[hash];
  512. else
  513. back = &slot->ITLQ_forw->ITLQ_back;
  515. if(slot->ITLQ_back == NULL)
  516. forw = &hostdata->ITLQ_Hash_forw[hash];
  517. else
  518. forw = &slot->ITLQ_back->ITLQ_forw;
  520. *forw = slot->ITLQ_forw;
  521. *back = slot->ITLQ_back;
  522. }
  523. hash = hash_ITL(slot->cmnd->target, slot->cmnd->lun);
  524. if(slot->ITL_forw == NULL)
  525. back = &hostdata->ITL_Hash_back[hash];
  526. else
  527. back = &slot->ITL_forw->ITL_back;
  529. if(slot->ITL_back == NULL)
  530. forw = &hostdata->ITL_Hash_forw[hash];
  531. else
  532. forw = &slot->ITL_back->ITL_forw;
  534. *forw = slot->ITL_forw;
  535. *back = slot->ITL_back;
  537. slot->resume_offset = 0;
  538. slot->cmnd = NULL;
  539. slot->state = NCR_700_SLOT_FREE;
  540. slot->ITL_forw = hostdata->free_list;
  541. hostdata->free_list = slot;
  542. hostdata->command_slot_count--;
  543. }
  546. /* This routine really does very little.  The command is indexed on
  547.    the ITL and (if tagged) the ITLQ lists in _queuecommand */
  548. STATIC void
  549. save_for_reselection(struct NCR_700_Host_Parameters *hostdata,
  550.      Scsi_Cmnd *SCp, __u32 dsp)
  551. {
  552. /* Its just possible that this gets executed twice */
  553. if(SCp != NULL) {
  554. struct NCR_700_command_slot *slot =
  555. (struct NCR_700_command_slot *)SCp->host_scribble;
  557. slot->resume_offset = dsp;
  558. }
  559. hostdata->state = NCR_700_HOST_FREE;
  560. hostdata->cmd = NULL;
  561. }
  563. /* Most likely nexus is the oldest in each case */
  564. STATIC inline struct NCR_700_command_slot *
  565. find_ITL_Nexus(struct NCR_700_Host_Parameters *hostdata, __u8 pun, __u8 lun)
  566. {
  567. int hash = hash_ITL(pun, lun);
  568. struct NCR_700_command_slot *slot = hostdata->ITL_Hash_back[hash];
  569. while(slot != NULL && !(slot->cmnd->target == pun &&
  570. slot->cmnd->lun == lun))
  571. slot = slot->ITL_back;
  572. return slot;
  573. }
  575. STATIC inline struct NCR_700_command_slot *
  576. find_ITLQ_Nexus(struct NCR_700_Host_Parameters *hostdata, __u8 pun,
  577. __u8 lun, __u8 tag)
  578. {
  579. int hash = hash_ITLQ(pun, lun, tag);
  580. struct NCR_700_command_slot *slot = hostdata->ITLQ_Hash_back[hash];
  582. while(slot != NULL && !(slot->cmnd->target == pun 
  583.       && slot->cmnd->lun == lun && slot->tag == tag))
  584. slot = slot->ITLQ_back;
  586. #ifdef NCR_700_TAG_DEBUG
  587. if(slot != NULL) {
  588. struct NCR_700_command_slot *n = slot->ITLQ_back;
  589. while(n != NULL && n->cmnd->target != pun
  590.       && n->cmnd->lun != lun && n->tag != tag)
  591. n = n->ITLQ_back;
  593. if(n != NULL && n->cmnd->target == pun && n->cmnd->lun == lun
  594.    && n->tag == tag) {
  595. printk(KERN_WARNING "53c700: WARNING: DUPLICATE tag %dn",
  596.        tag);
  597. }
  598. }
  599. #endif
  600. return slot;
  601. }
  605. /* This translates the SDTR message offset and period to a value
  606.  * which can be loaded into the SXFER_REG.
  607.  *
  608.  * NOTE: According to SCSI-2, the true transfer period (in ns) is
  609.  *       actually four times this period value */
  610. STATIC inline __u8
  611. NCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata,
  612.        __u8 offset, __u8 period)
  613. {
  614. int XFERP;
  615. __u8 min_xferp = (hostdata->chip710
  616.   ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
  617. __u8 max_offset = (hostdata->chip710
  618.    ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET);
  619. /* NOTE: NCR_700_SDTR_msg[3] contains our offer of the minimum
  620.  * period.  It is set in NCR_700_chip_setup() */
  621. if(period < NCR_700_SDTR_msg[3]) {
  622. printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %dn", period*4, NCR_700_SDTR_msg[3]*4);
  623. period = NCR_700_SDTR_msg[3];
  624. }
  625. XFERP = (period*4 * hostdata->sync_clock)/1000 - 4;
  626. if(offset > max_offset) {
  627. printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %dn",
  628.        offset, max_offset);
  629. offset = max_offset;
  630. }
  631. if(XFERP < min_xferp) {
  632. printk(KERN_WARNING "53c700: XFERP %d is less than minium, setting to %dn",
  633.        XFERP,  min_xferp);
  634. XFERP =  min_xferp;
  635. }
  636. return (offset & 0x0f) | (XFERP & 0x07)<<4;
  637. }
  639. STATIC inline void
  640. NCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, Scsi_Cmnd *SCp,
  641.       struct NCR_700_command_slot *slot)
  642. {
  643. if(SCp->sc_data_direction != SCSI_DATA_NONE &&
  644.    SCp->sc_data_direction != SCSI_DATA_UNKNOWN) {
  645. int pci_direction = scsi_to_pci_dma_dir(SCp->sc_data_direction);
  646. if(SCp->use_sg) {
  647. pci_unmap_sg(hostdata->pci_dev, SCp->buffer,
  648.      SCp->use_sg, pci_direction);
  649. } else {
  650. pci_unmap_single(hostdata->pci_dev,
  651.  slot->dma_handle,
  652.  SCp->request_bufflen,
  653.  pci_direction);
  654. }
  655. }
  656. }
  658. STATIC inline void
  659. NCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata,
  660.        Scsi_Cmnd *SCp, int result)
  661. {
  662. hostdata->state = NCR_700_HOST_FREE;
  663. hostdata->cmd = NULL;
  665. if(SCp != NULL) {
  666. struct NCR_700_command_slot *slot = 
  667. (struct NCR_700_command_slot *)SCp->host_scribble;
  669. NCR_700_unmap(hostdata, SCp, slot);
  670. pci_unmap_single(hostdata->pci_dev, slot->pCmd,
  671.  sizeof(SCp->cmnd), PCI_DMA_TODEVICE);
  672. if(SCp->cmnd[0] == REQUEST_SENSE && SCp->cmnd[6] == NCR_700_INTERNAL_SENSE_MAGIC) {
  673. #ifdef NCR_700_DEBUG
  674. printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense isn",
  675.        SCp, SCp->cmnd[7], result);
  676. print_sense("53c700", SCp);
  678. #endif
  679. SCp->use_sg = SCp->cmnd[8];
  680. if(result == 0)
  681. result = SCp->cmnd[7];
  682. }
  684. free_slot(slot, hostdata);
  686. SCp->host_scribble = NULL;
  687. SCp->result = result;
  688. SCp->scsi_done(SCp);
  689. if(NCR_700_get_depth(SCp->device) == 0 ||
  690.    NCR_700_get_depth(SCp->device) > NCR_700_MAX_TAGS)
  691. printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %dn",
  692.        NCR_700_get_depth(SCp->device));
  693. NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1);
  694. } else {
  695. printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCpn");
  696. }
  697. }
  700. STATIC void
  701. NCR_700_internal_bus_reset(struct Scsi_Host *host)
  702. {
  703. /* Bus reset */
  704. NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG);
  705. udelay(50);
  706. NCR_700_writeb(0, host, SCNTL1_REG);
  708. }
  710. STATIC void
  711. NCR_700_chip_setup(struct Scsi_Host *host)
  712. {
  713. struct NCR_700_Host_Parameters *hostdata = 
  714. (struct NCR_700_Host_Parameters *)host->hostdata[0];
  715. __u32 dcntl_extra = 0;
  716. __u8 min_period;
  717. __u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
  719. if(hostdata->chip710) {
  720. __u8 burst_disable = hostdata->burst_disable
  721. ? BURST_DISABLE : 0;
  722. dcntl_extra = COMPAT_700_MODE;
  724. NCR_700_writeb(dcntl_extra, host, DCNTL_REG);
  725. NCR_700_writeb(BURST_LENGTH_8  | hostdata->dmode_extra,
  726.        host, DMODE_710_REG);
  727. NCR_700_writeb(burst_disable | (hostdata->differential ? 
  728. DIFF : 0), host, CTEST7_REG);
  729. NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG);
  730. NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY
  731.        | AUTO_ATN, host, SCNTL0_REG);
  732. } else {
  733. NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra,
  734.        host, DMODE_700_REG);
  735. NCR_700_writeb(hostdata->differential ? 
  736.        DIFF : 0, host, CTEST7_REG);
  737. if(hostdata->fast) {
  738. /* this is for 700-66, does nothing on 700 */
  739. NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION 
  740.        | GENERATE_RECEIVE_PARITY, host,
  741.        CTEST8_REG);
  742. } else {
  743. NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY
  744.        | PARITY | AUTO_ATN, host, SCNTL0_REG);
  745. }
  746. }
  748. NCR_700_writeb(1 << host->this_id, host, SCID_REG);
  749. NCR_700_writeb(0, host, SBCL_REG);
  750. NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG);
  752. NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT
  753.      | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG);
  755. NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG);
  756. NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG);
  757. if(hostdata->clock > 75) {
  758. printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven atn", hostdata->clock);
  759. /* do the best we can, but the async clock will be out
  760.  * of spec: sync divider 2, async divider 3 */
  761. DEBUG(("53c700: sync 2 async 3n"));
  762. NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG);
  763. NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
  764. hostdata->sync_clock = hostdata->clock/2;
  765. } else if(hostdata->clock > 50  && hostdata->clock <= 75) {
  766. /* sync divider 1.5, async divider 3 */
  767. DEBUG(("53c700: sync 1.5 async 3n"));
  768. NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG);
  769. NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
  770. hostdata->sync_clock = hostdata->clock*2;
  771. hostdata->sync_clock /= 3;
  773. } else if(hostdata->clock > 37 && hostdata->clock <= 50) {
  774. /* sync divider 1, async divider 2 */
  775. DEBUG(("53c700: sync 1 async 2n"));
  776. NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
  777. NCR_700_writeb(ASYNC_DIV_2_0 | dcntl_extra, host, DCNTL_REG);
  778. hostdata->sync_clock = hostdata->clock;
  779. } else if(hostdata->clock > 25 && hostdata->clock <=37) {
  780. /* sync divider 1, async divider 1.5 */
  781. DEBUG(("53c700: sync 1 async 1.5n"));
  782. NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
  783. NCR_700_writeb(ASYNC_DIV_1_5 | dcntl_extra, host, DCNTL_REG);
  784. hostdata->sync_clock = hostdata->clock;
  785. } else {
  786. DEBUG(("53c700: sync 1 async 1n"));
  787. NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
  788. NCR_700_writeb(ASYNC_DIV_1_0 | dcntl_extra, host, DCNTL_REG);
  789. /* sync divider 1, async divider 1 */
  790. hostdata->sync_clock = hostdata->clock;
  791. }
  792. /* Calculate the actual minimum period that can be supported
  793.  * by our synchronous clock speed.  See the 710 manual for
  794.  * exact details of this calculation which is based on a
  795.  * setting of the SXFER register */
  796. min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock);
  797. if(min_period > NCR_700_MIN_PERIOD) {
  798. NCR_700_SDTR_msg[3] = min_period;
  799. }
  800. if(hostdata->chip710)
  801. NCR_700_SDTR_msg[4] = NCR_710_MAX_OFFSET;
  802. }
  804. STATIC void
  805. NCR_700_chip_reset(struct Scsi_Host *host)
  806. {
  807. struct NCR_700_Host_Parameters *hostdata = 
  808. (struct NCR_700_Host_Parameters *)host->hostdata[0];
  809. if(hostdata->chip710) {
  810. NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG);
  811. udelay(100);
  813. NCR_700_writeb(0, host, ISTAT_REG);
  814. } else {
  815. NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG);
  816. udelay(100);
  818. NCR_700_writeb(0, host, DCNTL_REG);
  819. }
  821. mdelay(1000);
  823. NCR_700_chip_setup(host);
  824. }
  826. /* The heart of the message processing engine is that the instruction
  827.  * immediately after the INT is the normal case (and so must be CLEAR
  828.  * ACK).  If we want to do something else, we call that routine in
  829.  * scripts and set temp to be the normal case + 8 (skipping the CLEAR
  830.  * ACK) so that the routine returns correctly to resume its activity
  831.  * */
  832. STATIC __u32
  833. process_extended_message(struct Scsi_Host *host, 
  834.  struct NCR_700_Host_Parameters *hostdata,
  835.  Scsi_Cmnd *SCp, __u32 dsp, __u32 dsps)
  836. {
  837. __u32 resume_offset = dsp, temp = dsp + 8;
  838. __u8 pun = 0xff, lun = 0xff;
  840. if(SCp != NULL) {
  841. pun = SCp->target;
  842. lun = SCp->lun;
  843. }
  845. switch(hostdata->msgin[2]) {
  846. case A_SDTR_MSG:
  847. if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
  848. __u8 period = hostdata->msgin[3];
  849. __u8 offset = hostdata->msgin[4];
  850. __u8 sxfer;
  852. if(offset != 0 && period != 0)
  853. sxfer = NCR_700_offset_period_to_sxfer(hostdata, offset, period);
  854. else 
  855. sxfer = 0;
  857. if(sxfer != NCR_700_get_SXFER(SCp->device)) {
  858. printk(KERN_INFO "scsi%d: (%d:%d) Synchronous at offset %d, period %dnsn",
  859.        host->host_no, pun, lun,
  860.        offset, period*4);
  862. NCR_700_set_SXFER(SCp->device, sxfer);
  863. }
  866. NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
  867. NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
  869. NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
  870.        host, SXFER_REG);
  872. } else {
  873. /* SDTR message out of the blue, reject it */
  874. printk(KERN_WARNING "scsi%d Unexpected SDTR msgn",
  875.        host->host_no);
  876. hostdata->msgout[0] = A_REJECT_MSG;
  877. NCR_700_dma_cache_wback((unsigned long)hostdata->msgout, 1);
  878. script_patch_16(hostdata->script, MessageCount, 1);
  879. /* SendMsgOut returns, so set up the return
  880.  * address */
  881. resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
  882. }
  883. break;
  885. case A_WDTR_MSG:
  886. printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejectingn",
  887.        host->host_no, pun, lun);
  888. hostdata->msgout[0] = A_REJECT_MSG;
  889. NCR_700_dma_cache_wback((unsigned long)hostdata->msgout, 1);
  890. script_patch_16(hostdata->script, MessageCount, 1);
  891. resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
  893. break;
  895. default:
  896. printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
  897.        host->host_no, pun, lun,
  898.        NCR_700_phase[(dsps & 0xf00) >> 8]);
  899. print_msg(hostdata->msgin);
  900. printk("n");
  901. /* just reject it */
  902. hostdata->msgout[0] = A_REJECT_MSG;
  903. NCR_700_dma_cache_wback((unsigned long)hostdata->msgout, 1);
  904. script_patch_16(hostdata->script, MessageCount, 1);
  905. /* SendMsgOut returns, so set up the return
  906.  * address */
  907. resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
  908. }
  909. NCR_700_writel(temp, host, TEMP_REG);
  910. return resume_offset;
  911. }
  913. STATIC __u32
  914. process_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata,
  915. Scsi_Cmnd *SCp, __u32 dsp, __u32 dsps)
  916. {
  917. /* work out where to return to */
  918. __u32 temp = dsp + 8, resume_offset = dsp;
  919. __u8 pun = 0xff, lun = 0xff;
  921. if(SCp != NULL) {
  922. pun = SCp->target;
  923. lun = SCp->lun;
  924. }
  926. #ifdef NCR_700_DEBUG
  927. printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun,
  928.        NCR_700_phase[(dsps & 0xf00) >> 8]);
  929. print_msg(hostdata->msgin);
  930. printk("n");
  931. #endif
  933. switch(hostdata->msgin[0]) {
  935. case A_EXTENDED_MSG:
  936. resume_offset =  process_extended_message(host, hostdata, SCp,
  937.   dsp, dsps);
  938. break;
  940. case A_REJECT_MSG:
  941. if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
  942. /* Rejected our sync negotiation attempt */
  943. NCR_700_set_SXFER(SCp->device, 0);
  944. NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
  945. NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
  946. } else if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING)) {
  947. /* rejected our first simple tag message */
  948. printk(KERN_WARNING "scsi%d (%d:%d) Rejected first tag queue attempt, turning off tag queueingn", host->host_no, pun, lun);
  949. NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
  950. hostdata->tag_negotiated &= ~(1<<SCp->target);
  951. SCp->device->tagged_queue = 0;
  952. SCp->device->tagged_supported = 0;
  953. } else {
  954. printk(KERN_WARNING "scsi%d (%d:%d) Unexpected REJECT Message %sn",
  955.        host->host_no, pun, lun,
  956.        NCR_700_phase[(dsps & 0xf00) >> 8]);
  957. /* however, just ignore it */
  958. }
  959. break;
  961. case A_PARITY_ERROR_MSG:
  962. printk(KERN_ERR "scsi%d (%d:%d) Parity Error!n", host->host_no,
  963.        pun, lun);
  964. NCR_700_internal_bus_reset(host);
  965. break;
  966. case A_SIMPLE_TAG_MSG:
  967. printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %sn", host->host_no,
  968.        pun, lun, hostdata->msgin[1],
  969.        NCR_700_phase[(dsps & 0xf00) >> 8]);
  970. /* just ignore it */
  971. break;
  972. default:
  973. printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
  974.        host->host_no, pun, lun,
  975.        NCR_700_phase[(dsps & 0xf00) >> 8]);
  977. print_msg(hostdata->msgin);
  978. printk("n");
  979. /* just reject it */
  980. hostdata->msgout[0] = A_REJECT_MSG;
  981. NCR_700_dma_cache_wback((unsigned long)hostdata->msgout, 1);
  982. script_patch_16(hostdata->script, MessageCount, 1);
  983. /* SendMsgOut returns, so set up the return
  984.  * address */
  985. resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
  987. break;
  988. }
  989. NCR_700_writel(temp, host, TEMP_REG);
  990. /* set us up to receive another message */
  991. NCR_700_dma_cache_inv((unsigned long)hostdata->msgin, MSG_ARRAY_SIZE);
  992. return resume_offset;
  993. }
  995. STATIC __u32
  996. process_script_interrupt(__u32 dsps, __u32 dsp, Scsi_Cmnd *SCp,
  997.  struct Scsi_Host *host,
  998.  struct NCR_700_Host_Parameters *hostdata)
  999. {
  1000. __u32 resume_offset = 0;
  1001. __u8 pun = 0xff, lun=0xff;
  1003. if(SCp != NULL) {
  1004. pun = SCp->target;
  1005. lun = SCp->lun;
  1006. }
  1008. if(dsps == A_GOOD_STATUS_AFTER_STATUS) {
  1009. DEBUG(("  COMMAND COMPLETE, status=%02xn",
  1010.        hostdata->status[0]));
  1011. /* OK, if TCQ still on, we know it works */
  1012. NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
  1013. /* check for contingent allegiance contitions */
  1014. if(status_byte(hostdata->status[0]) == CHECK_CONDITION ||
  1015.    status_byte(hostdata->status[0]) == COMMAND_TERMINATED) {
  1016. struct NCR_700_command_slot *slot =
  1017. (struct NCR_700_command_slot *)SCp->host_scribble;
  1018. if(SCp->cmnd[0] == REQUEST_SENSE) {
  1019. /* OOPS: bad device, returning another
  1020.  * contingent allegiance condition */
  1021. printk(KERN_ERR "scsi%d (%d:%d) broken device is looping in contingent allegiance: ignoringn", host->host_no, pun, lun);
  1022. NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
  1023. } else {
  1024. #ifdef NCR_DEBUG
  1025. print_command(SCp->cmnd);
  1026. printk("  cmd %p has status %d, requesting sensen",
  1027.        SCp, hostdata->status[0]);
  1028. #endif
  1029. /* we can destroy the command here
  1030.  * because the contingent allegiance
  1031.  * condition will cause a retry which
  1032.  * will re-copy the command from the
  1033.  * saved data_cmnd.  We also unmap any
  1034.  * data associated with the command
  1035.  * here */
  1036. NCR_700_unmap(hostdata, SCp, slot);
  1038. SCp->cmnd[0] = REQUEST_SENSE;
  1039. SCp->cmnd[1] = (SCp->lun & 0x7) << 5;
  1040. SCp->cmnd[2] = 0;
  1041. SCp->cmnd[3] = 0;
  1042. SCp->cmnd[4] = sizeof(SCp->sense_buffer);
  1043. SCp->cmnd[5] = 0;
  1044. SCp->cmd_len = 6;
  1045. /* Here's a quiet hack: the
  1046.  * REQUEST_SENSE command is six bytes,
  1047.  * so store a flag indicating that
  1048.  * this was an internal sense request
  1049.  * and the original status at the end
  1050.  * of the command */
  1051. SCp->cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC;
  1052. SCp->cmnd[7] = hostdata->status[0];
  1053. SCp->cmnd[8] = SCp->use_sg;
  1054. SCp->use_sg = 0;
  1055. SCp->sc_data_direction = SCSI_DATA_READ;
  1056. pci_dma_sync_single(hostdata->pci_dev,
  1057.     slot->pCmd,
  1058.     SCp->cmd_len,
  1059.     PCI_DMA_TODEVICE);
  1060. SCp->request_bufflen = sizeof(SCp->sense_buffer);
  1061. slot->dma_handle = pci_map_single(hostdata->pci_dev, SCp->sense_buffer, sizeof(SCp->sense_buffer), PCI_DMA_FROMDEVICE);
  1062. slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | sizeof(SCp->sense_buffer));
  1063. slot->SG[0].pAddr = bS_to_host(slot->dma_handle);
  1064. slot->SG[1].ins = bS_to_host(SCRIPT_RETURN);
  1065. slot->SG[1].pAddr = 0;
  1066. slot->resume_offset = hostdata->pScript;
  1067. NCR_700_dma_cache_wback((unsigned long)slot->SG, sizeof(slot->SG[0])*2);
  1068. NCR_700_dma_cache_inv((unsigned long)SCp->sense_buffer, sizeof(SCp->sense_buffer));
  1070. /* queue the command for reissue */
  1071. slot->state = NCR_700_SLOT_QUEUED;
  1072. hostdata->state = NCR_700_HOST_FREE;
  1073. hostdata->cmd = NULL;
  1074. }
  1075. } else {
  1076. // Currently rely on the mid layer evaluation
  1077. // of the tag queuing capability
  1078. //
  1079. //if(status_byte(hostdata->status[0]) == GOOD &&
  1080. //   SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) {
  1081. // /* Piggy back the tag queueing support
  1082. //  * on this command */
  1083. // pci_dma_sync_single(hostdata->pci_dev,
  1084. //     slot->dma_handle,
  1085. //     SCp->request_bufflen,
  1086. //     PCI_DMA_FROMDEVICE);
  1087. // if(((char *)SCp->request_buffer)[7] & 0x02) {
  1088. // printk(KERN_INFO "scsi%d: (%d:%d) Enabling Tag Command Queuingn", host->host_no, pun, lun);
  1089. // hostdata->tag_negotiated |= (1<<SCp->target);
  1090. // NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
  1091. // } else {
  1092. // NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
  1093. // hostdata->tag_negotiated &= ~(1<<SCp->target);
  1094. // }
  1095. //}
  1096. NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
  1097. }
  1098. } else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) {
  1099. __u8 i = (dsps & 0xf00) >> 8;
  1101. printk(KERN_ERR "scsi%d: (%d:%d), UNEXPECTED PHASE %s (%s)n",
  1102.        host->host_no, pun, lun,
  1103.        NCR_700_phase[i],
  1104.        sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
  1105. printk(KERN_ERR "         len = %d, cmd =", SCp->cmd_len);
  1106. print_command(SCp->cmnd);
  1108. NCR_700_internal_bus_reset(host);
  1109. } else if((dsps & 0xfffff000) == A_FATAL) {
  1110. int i = (dsps & 0xfff);
  1112. printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %sn",
  1113.        host->host_no, pun, lun, NCR_700_fatal_messages[i]);
  1114. if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) {
  1115. printk(KERN_ERR "     msg begins %02x %02xn",
  1116.        hostdata->msgin[0], hostdata->msgin[1]);
  1117. }
  1118. NCR_700_internal_bus_reset(host);
  1119. } else if((dsps & 0xfffff0f0) == A_DISCONNECT) {
  1120. #ifdef NCR_700_DEBUG
  1121. __u8 i = (dsps & 0xf00) >> 8;
  1123. printk("scsi%d: (%d:%d), DISCONNECTED (%d) %sn",
  1124.        host->host_no, pun, lun,
  1125.        i, NCR_700_phase[i]);
  1126. #endif
  1127. save_for_reselection(hostdata, SCp, dsp);
  1129. } else if(dsps == A_RESELECTION_IDENTIFIED) {
  1130. __u8 lun;
  1131. struct NCR_700_command_slot *slot;
  1132. __u8 reselection_id = hostdata->reselection_id;
  1134. lun = hostdata->msgin[0] & 0x1f;
  1136. hostdata->reselection_id = 0xff;
  1137. DEBUG(("scsi%d: (%d:%d) RESELECTED!n",
  1138.        host->host_no, reselection_id, lun));
  1139. /* clear the reselection indicator */
  1140. if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) {
  1141. slot = find_ITLQ_Nexus(hostdata, reselection_id,
  1142.        lun, hostdata->msgin[2]);
  1143. } else {
  1144. slot = find_ITL_Nexus(hostdata, reselection_id, lun);
  1145. }
  1146. retry:
  1147. if(slot == NULL) {
  1148. struct NCR_700_command_slot *s = find_ITL_Nexus(hostdata, reselection_id, lun);
  1149. printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!n",
  1150.        host->host_no, reselection_id, lun,
  1151.        hostdata->msgin[0], hostdata->msgin[1],
  1152.        hostdata->msgin[2]);
  1153. printk(KERN_ERR " OUTSTANDING TAGS:");
  1154. while(s != NULL) {
  1155. if(s->cmnd->target == reselection_id &&
  1156.    s->cmnd->lun == lun) {
  1157. printk("%d ", s->tag);
  1158. if(s->tag == hostdata->msgin[2]) {
  1159. printk(" ***FOUND*** n");
  1160. slot = s;
  1161. goto retry;
  1162. }
  1164. }
  1165. s = s->ITL_back;
  1166. }
  1167. printk("n");
  1168. } else {
  1169. if(hostdata->state != NCR_700_HOST_BUSY)
  1170. printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!n",
  1171.        host->host_no);
  1172. resume_offset = slot->resume_offset;
  1173. hostdata->cmd = slot->cmnd;
  1175. /* re-patch for this command */
  1176. script_patch_32_abs(hostdata->script, CommandAddress, 
  1177.     slot->pCmd);
  1178. script_patch_16(hostdata->script,
  1179. CommandCount, slot->cmnd->cmd_len);
  1180. script_patch_32_abs(hostdata->script, SGScriptStartAddress,
  1181.     to32bit(&slot->pSG[0].ins));
  1183. /* Note: setting SXFER only works if we're
  1184.  * still in the MESSAGE phase, so it is vital
  1185.  * that ACK is still asserted when we process
  1186.  * the reselection message.  The resume offset
  1187.  * should therefore always clear ACK */
  1188. NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device),
  1189.        host, SXFER_REG);
  1190. NCR_700_dma_cache_inv((unsigned long)hostdata->msgin,
  1191.       MSG_ARRAY_SIZE);
  1192. NCR_700_dma_cache_wback((unsigned long)hostdata->msgout,
  1193. MSG_ARRAY_SIZE);
  1194. /* I'm just being paranoid here, the command should
  1195.  * already have been flushed from the cache */
  1196. NCR_700_dma_cache_wback((unsigned long)slot->cmnd->cmnd,
  1197. slot->cmnd->cmd_len);
  1201. }
  1202. } else if(dsps == A_RESELECTED_DURING_SELECTION) {
  1204. /* This section is full of debugging code because I've
  1205.  * never managed to reach it.  I think what happens is
  1206.  * that, because the 700 runs with selection
  1207.  * interrupts enabled the whole time that we take a
  1208.  * selection interrupt before we manage to get to the
  1209.  * reselected script interrupt */
  1211. __u8 reselection_id = NCR_700_readb(host, SFBR_REG);
  1212. struct NCR_700_command_slot *slot;
  1214. /* Take out our own ID */
  1215. reselection_id &= ~(1<<host->this_id);
  1217. /* I've never seen this happen, so keep this as a printk rather
  1218.  * than a debug */
  1219. printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%dn",
  1220.        host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count);
  1222. {
  1223. /* FIXME: DEBUGGING CODE */
  1224. __u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]);
  1225. int i;
  1227. for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
  1228. if(SG >= to32bit(&hostdata->slots[i].pSG[0])
  1229.    && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS]))
  1230. break;
  1231. }
  1232. printk(KERN_INFO "IDENTIFIED SG segment as being %08x in slot %p, cmd %p, slot->resume_offset=%08xn", SG, &hostdata->slots[i], hostdata->slots[i].cmnd, hostdata->slots[i].resume_offset);
  1233. SCp =  hostdata->slots[i].cmnd;
  1234. }
  1236. if(SCp != NULL) {
  1237. slot = (struct NCR_700_command_slot *)SCp->host_scribble;
  1238. /* change slot from busy to queued to redo command */
  1239. slot->state = NCR_700_SLOT_QUEUED;
  1240. }
  1241. hostdata->cmd = NULL;
  1243. if(reselection_id == 0) {
  1244. if(hostdata->reselection_id == 0xff) {
  1245. printk(KERN_ERR "scsi%d: Invalid reselection during selection!!n", host->host_no);
  1246. return 0;
  1247. } else {
  1248. printk(KERN_ERR "scsi%d: script reselected and we took a selection interruptn",
  1249.        host->host_no);
  1250. reselection_id = hostdata->reselection_id;
  1251. }
  1252. } else {
  1254. /* convert to real ID */
  1255. reselection_id = bitmap_to_number(reselection_id);
  1256. }
  1257. hostdata->reselection_id = reselection_id;
  1258. /* just in case we have a stale simple tag message, clear it */
  1259. hostdata->msgin[1] = 0;
  1260. NCR_700_dma_cache_wback_inv((unsigned long)hostdata->msgin,
  1261.     MSG_ARRAY_SIZE);
  1262. if(hostdata->tag_negotiated & (1<<reselection_id)) {
  1263. resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
  1264. } else {
  1265. resume_offset = hostdata->pScript + Ent_GetReselectionData;
  1266. }
  1267. } else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) {
  1268. /* we've just disconnected from the bus, do nothing since
  1269.  * a return here will re-run the queued command slot
  1270.  * that may have been interrupted by the initial selection */
  1271. DEBUG((" SELECTION COMPLETEDn"));
  1272. } else if((dsps & 0xfffff0f0) == A_MSG_IN) { 
  1273. resume_offset = process_message(host, hostdata, SCp,
  1274. dsp, dsps);
  1275. } else if((dsps &  0xfffff000) == 0) {
  1276. __u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8;
  1277. printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04xn",
  1278.        host->host_no, pun, lun, NCR_700_condition[i],
  1279.        NCR_700_phase[j], dsp - hostdata->pScript);
  1280. if(SCp != NULL) {
  1281. print_command(SCp->cmnd);
  1283. if(SCp->use_sg) {
  1284. for(i = 0; i < SCp->use_sg + 1; i++) {
  1285. printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08xn", i, ((struct scatterlist *)SCp->buffer)[i].length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr);
  1286. }
  1287. }
  1288. }        
  1289. NCR_700_internal_bus_reset(host);
  1290. } else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) {
  1291. printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuingn",
  1292.        host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript);
  1293. resume_offset = dsp;
  1294. } else {
  1295. printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04xn",
  1296.        host->host_no, pun, lun, dsps, dsp - hostdata->pScript);
  1297. NCR_700_internal_bus_reset(host);
  1298. }
  1299. return resume_offset;
  1300. }
  1302. /* We run the 53c700 with selection interrupts always enabled.  This
  1303.  * means that the chip may be selected as soon as the bus frees.  On a
  1304.  * busy bus, this can be before the scripts engine finishes its
  1305.  * processing.  Therefore, part of the selection processing has to be
  1306.  * to find out what the scripts engine is doing and complete the
  1307.  * function if necessary (i.e. process the pending disconnect or save
  1308.  * the interrupted initial selection */
  1309. STATIC inline __u32
  1310. process_selection(struct Scsi_Host *host, __u32 dsp)
  1311. {
  1312. __u8 id = 0; /* Squash compiler warning */
  1313. int count = 0;
  1314. __u32 resume_offset = 0;
  1315. struct NCR_700_Host_Parameters *hostdata =
  1316. (struct NCR_700_Host_Parameters *)host->hostdata[0];
  1317. Scsi_Cmnd *SCp = hostdata->cmd;
  1318. __u8 sbcl;
  1320. for(count = 0; count < 5; count++) {
  1321. id = NCR_700_readb(host, hostdata->chip710 ?
  1322.    CTEST9_REG : SFBR_REG);
  1324. /* Take out our own ID */
  1325. id &= ~(1<<host->this_id);
  1326. if(id != 0) 
  1327. break;
  1328. udelay(5);
  1329. }
  1330. sbcl = NCR_700_readb(host, SBCL_REG);
  1331. if((sbcl & SBCL_IO) == 0) {
  1332. /* mark as having been selected rather than reselected */
  1333. id = 0xff;
  1334. } else {
  1335. /* convert to real ID */
  1336. hostdata->reselection_id = id = bitmap_to_number(id);
  1337. DEBUG(("scsi%d:  Reselected by %dn",
  1338.        host->host_no, id));
  1339. }
  1340. if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) {
  1341. struct NCR_700_command_slot *slot =
  1342. (struct NCR_700_command_slot *)SCp->host_scribble;
  1343. DEBUG(("  ID %d WARNING: RESELECTION OF BUSY HOST, saving cmd %p, slot %p, addr %x [%04x], resume %x!n", id, hostdata->cmd, slot, dsp, dsp - hostdata->pScript, resume_offset));
  1345. switch(dsp - hostdata->pScript) {
  1346. case Ent_Disconnect1:
  1347. case Ent_Disconnect2:
  1348. save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript);
  1349. break;
  1350. case Ent_Disconnect3:
  1351. case Ent_Disconnect4:
  1352. save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript);
  1353. break;
  1354. case Ent_Disconnect5:
  1355. case Ent_Disconnect6:
  1356. save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript);
  1357. break;
  1358. case Ent_Disconnect7:
  1359. case Ent_Disconnect8:
  1360. save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript);
  1361. break;
  1362. case Ent_Finish1:
  1363. case Ent_Finish2:
  1364. process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata);
  1365. break;
  1367. default:
  1368. slot->state = NCR_700_SLOT_QUEUED;
  1369. break;
  1370. }
  1371. }
  1372. hostdata->state = NCR_700_HOST_BUSY;
  1373. hostdata->cmd = NULL;
  1374. /* clear any stale simple tag message */
  1375. hostdata->msgin[1] = 0;
  1376. NCR_700_dma_cache_wback_inv((unsigned long)hostdata->msgin, MSG_ARRAY_SIZE);
  1378. if(id == 0xff) {
  1379. /* Selected as target, Ignore */
  1380. resume_offset = hostdata->pScript + Ent_SelectedAsTarget;
  1381. } else if(hostdata->tag_negotiated & (1<<id)) {
  1382. resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
  1383. } else {
  1384. resume_offset = hostdata->pScript + Ent_GetReselectionData;
  1385. }
  1386. return resume_offset;
  1387. }
  1389. static inline void
  1390. NCR_700_clear_fifo(struct Scsi_Host *host) {
  1391. const struct NCR_700_Host_Parameters *hostdata
  1392. = (struct NCR_700_Host_Parameters *)host->hostdata[0];
  1393. if(hostdata->chip710) {
  1394. NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG);
  1395. } else {
  1396. NCR_700_writeb(CLR_FIFO, host, DFIFO_REG);
  1397. }
  1398. }
  1400. static inline void
  1401. NCR_700_flush_fifo(struct Scsi_Host *host) {
  1402. const struct NCR_700_Host_Parameters *hostdata
  1403. = (struct NCR_700_Host_Parameters *)host->hostdata[0];
  1404. if(hostdata->chip710) {
  1405. NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG);
  1406. udelay(10);
  1407. NCR_700_writeb(0, host, CTEST8_REG);
  1408. } else {
  1409. NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG);
  1410. udelay(10);
  1411. NCR_700_writeb(0, host, DFIFO_REG);
  1412. }
  1413. }
  1416. STATIC int
  1417. NCR_700_start_command(Scsi_Cmnd *SCp)
  1418. {
  1419. struct NCR_700_command_slot *slot =
  1420. (struct NCR_700_command_slot *)SCp->host_scribble;
  1421. struct NCR_700_Host_Parameters *hostdata =
  1422. (struct NCR_700_Host_Parameters *)SCp->host->hostdata[0];
  1423. unsigned long flags;
  1424. __u16 count = 1; /* for IDENTIFY message */
  1426. save_flags(flags);
  1427. cli();
  1428. if(hostdata->state != NCR_700_HOST_FREE) {
  1429. /* keep this inside the lock to close the race window where
  1430.  * the running command finishes on another CPU while we don't
  1431.  * change the state to queued on this one */
  1432. slot->state = NCR_700_SLOT_QUEUED;
  1433. restore_flags(flags);
  1435. DEBUG(("scsi%d: host busy, queueing command %p, slot %pn",
  1436.        SCp->host->host_no, slot->cmnd, slot));
  1437. return 0;
  1438. }
  1439. hostdata->state = NCR_700_HOST_BUSY;
  1440. hostdata->cmd = SCp;
  1441. slot->state = NCR_700_SLOT_BUSY;
  1442. /* keep interrupts disabled until we have the command correctly
  1443.  * set up so we cannot take a selection interrupt */
  1445. hostdata->msgout[0] = NCR_700_identify(SCp->cmnd[0] != REQUEST_SENSE,
  1446.        SCp->lun);
  1447. /* for INQUIRY or REQUEST_SENSE commands, we cannot be sure
  1448.  * if the negotiated transfer parameters still hold, so
  1449.  * always renegotiate them */
  1450. if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE) {
  1451. NCR_700_clear_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
  1452. }
  1454. /* REQUEST_SENSE is asking for contingent I_T_L(_Q) status.
  1455.  * If a contingent allegiance condition exists, the device
  1456.  * will refuse all tags, so send the request sense as untagged
  1457.  * */
  1458. if((hostdata->tag_negotiated & (1<<SCp->target))
  1459.    && (slot->tag != NCR_700_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE)) {
  1460. hostdata->msgout[count++] = A_SIMPLE_TAG_MSG;
  1461. hostdata->msgout[count++] = slot->tag;
  1462. }
  1464. if(hostdata->fast &&
  1465.    NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) {
  1466. memcpy(&hostdata->msgout[count], NCR_700_SDTR_msg,
  1467.        sizeof(NCR_700_SDTR_msg));
  1468. count += sizeof(NCR_700_SDTR_msg);
  1469. NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
  1470. }
  1472. script_patch_16(hostdata->script, MessageCount, count);
  1475. script_patch_ID(hostdata->script,
  1476. Device_ID, 1<<SCp->target);
  1478. script_patch_32_abs(hostdata->script, CommandAddress, 
  1479.     slot->pCmd);
  1480. script_patch_16(hostdata->script, CommandCount, SCp->cmd_len);
  1481. /* finally plumb the beginning of the SG list into the script
  1482.  * */
  1483. script_patch_32_abs(hostdata->script, SGScriptStartAddress,
  1484.     to32bit(&slot->pSG[0].ins));
  1485. NCR_700_clear_fifo(SCp->host);
  1487. if(slot->resume_offset == 0)
  1488. slot->resume_offset = hostdata->pScript;
  1489. /* now perform all the writebacks and invalidates */
  1490. NCR_700_dma_cache_wback((unsigned long)hostdata->msgout, count);
  1491. NCR_700_dma_cache_inv((unsigned long)hostdata->msgin, MSG_ARRAY_SIZE);
  1492. NCR_700_dma_cache_wback((unsigned long)SCp->cmnd, SCp->cmd_len);
  1493. NCR_700_dma_cache_inv((unsigned long)hostdata->status, 1);
  1495. /* set the synchronous period/offset */
  1496. NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
  1497.        SCp->host, SXFER_REG);
  1498. NCR_700_writel(slot->temp, SCp->host, TEMP_REG);
  1499. NCR_700_writel(slot->resume_offset, SCp->host, DSP_REG);
  1501. /* allow interrupts here so that if we're selected we can take
  1502.  * a selection interrupt.  The script start may not be
  1503.  * effective in this case, but the selection interrupt will
  1504.  * save our command in that case */
  1505. restore_flags(flags);
  1507. return 1;
  1508. }
  1510. void
  1511. NCR_700_intr(int irq, void *dev_id, struct pt_regs *regs)
  1512. {
  1513. struct Scsi_Host *host = (struct Scsi_Host *)dev_id;
  1514. struct NCR_700_Host_Parameters *hostdata =
  1515. (struct NCR_700_Host_Parameters *)host->hostdata[0];
  1516. __u8 istat;
  1517. __u32 resume_offset = 0;
  1518. __u8 pun = 0xff, lun = 0xff;
  1519. unsigned long flags;
  1521. /* Unfortunately, we have to take the io_request_lock here
  1522.  * rather than the host lock hostdata->lock because we're
  1523.  * looking to exclude queuecommand from messing with the
  1524.  * registers while we're processing the interrupt.  Since
  1525.  * queuecommand is called holding io_request_lock, and we have
  1526.  * to take io_request_lock before we call the command
  1527.  * scsi_done, we would get a deadlock if we took
  1528.  * hostdata->lock here and in queuecommand (because the order
  1529.  * of locking in queuecommand: 1) io_request_lock then 2)
  1530.  * hostdata->lock would be the reverse of taking it in this
  1531.  * routine */
  1532. spin_lock_irqsave(&io_request_lock, flags);
  1533. if((istat = NCR_700_readb(host, ISTAT_REG))
  1534.       & (SCSI_INT_PENDING | DMA_INT_PENDING)) {
  1535. __u32 dsps;
  1536. __u8 sstat0 = 0, dstat = 0;
  1537. __u32 dsp;
  1538. Scsi_Cmnd *SCp = hostdata->cmd;
  1539. enum NCR_700_Host_State state;
  1541. state = hostdata->state;
  1542. SCp = hostdata->cmd;
  1544. if(istat & SCSI_INT_PENDING) {
  1545. udelay(10);
  1547. sstat0 = NCR_700_readb(host, SSTAT0_REG);
  1548. }
  1550. if(istat & DMA_INT_PENDING) {
  1551. udelay(10);
  1553. dstat = NCR_700_readb(host, DSTAT_REG);
  1554. }
  1556. dsps = NCR_700_readl(host, DSPS_REG);
  1557. dsp = NCR_700_readl(host, DSP_REG);
  1559. DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%xn",
  1560.        host->host_no, istat, sstat0, dstat,
  1561.        (dsp - (__u32)(hostdata->pScript))/4,
  1562.        dsp, dsps));
  1564. if(SCp != NULL) {
  1565. pun = SCp->target;
  1566. lun = SCp->lun;
  1567. }
  1569. if(sstat0 & SCSI_RESET_DETECTED) {
  1570. Scsi_Device *SDp;
  1571. int i;
  1573. hostdata->state = NCR_700_HOST_BUSY;
  1575. printk(KERN_ERR "scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]n",
  1576.        host->host_no, SCp, SCp == NULL ? NULL : SCp->host_scribble, dsp, dsp - hostdata->pScript);
  1578. /* clear all the negotiated parameters */
  1579. for(SDp = host->host_queue; SDp != NULL; SDp = SDp->next)
  1580. SDp->hostdata = 0;
  1582. /* clear all the slots and their pending commands */
  1583. for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
  1584. Scsi_Cmnd *SCp;
  1585. struct NCR_700_command_slot *slot =
  1586. &hostdata->slots[i];
  1588. if(slot->state == NCR_700_SLOT_FREE)
  1589. continue;
  1591. SCp = slot->cmnd;
  1592. printk(KERN_ERR " failing command because of reset, slot %p, cmnd %pn",
  1593.        slot, SCp);
  1594. free_slot(slot, hostdata);
  1595. SCp->host_scribble = NULL;
  1596. NCR_700_set_depth(SCp->device, 0);
  1597. /* NOTE: deadlock potential here: we
  1598.  * rely on mid-layer guarantees that
  1599.  * scsi_done won't try to issue the
  1600.  * command again otherwise we'll
  1601.  * deadlock on the
  1602.  * hostdata->state_lock */
  1603. SCp->result = DID_RESET << 16;
  1604. SCp->scsi_done(SCp);
  1605. }
  1606. mdelay(25);
  1607. NCR_700_chip_setup(host);
  1609. hostdata->state = NCR_700_HOST_FREE;
  1610. hostdata->cmd = NULL;
  1611. goto out_unlock;
  1612. } else if(sstat0 & SELECTION_TIMEOUT) {
  1613. DEBUG(("scsi%d: (%d:%d) selection timeoutn",
  1614.        host->host_no, pun, lun));
  1615. NCR_700_scsi_done(hostdata, SCp, DID_NO_CONNECT<<16);
  1616. } else if(sstat0 & PHASE_MISMATCH) {
  1617. struct NCR_700_command_slot *slot = (SCp == NULL) ? NULL :
  1618. (struct NCR_700_command_slot *)SCp->host_scribble;
  1620. if(dsp == Ent_SendMessage + 8 + hostdata->pScript) {
  1621. /* It wants to reply to some part of
  1622.  * our message */
  1623. #ifdef NCR_700_DEBUG
  1624. __u32 temp = NCR_700_readl(host, TEMP_REG);
  1625. int count = (hostdata->script[Ent_SendMessage/4] & 0xffffff) - ((NCR_700_readl(host, DBC_REG) & 0xffffff) + NCR_700_data_residual(host));
  1626. printk("scsi%d (%d:%d) PHASE MISMATCH IN SEND MESSAGE %d remain, return %p[%04x], phase %sn", host->host_no, pun, lun, count, (void *)temp, temp - hostdata->pScript, sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
  1627. #endif
  1628. resume_offset = hostdata->pScript + Ent_SendMessagePhaseMismatch;
  1629. } else if(dsp >= to32bit(&slot->pSG[0].ins) &&
  1630.   dsp <= to32bit(&slot->pSG[NCR_700_SG_SEGMENTS].ins)) {
  1631. int data_transfer = NCR_700_readl(host, DBC_REG) & 0xffffff;
  1632. int SGcount = (dsp - to32bit(&slot->pSG[0].ins))/sizeof(struct NCR_700_SG_List);
  1633. int residual = NCR_700_data_residual(host);
  1634. int i;
  1635. #ifdef NCR_700_DEBUG
  1636. __u32 naddr = NCR_700_readl(host, DNAD_REG);
  1638. printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%xn",
  1639.        host->host_no, pun, lun,
  1640.        SGcount, data_transfer);
  1641. print_command(SCp->cmnd);
  1642. if(residual) {
  1643. printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %dn",
  1644.        host->host_no, pun, lun,
  1645.        SGcount, data_transfer, residual);
  1646. }
  1647. #endif
  1648. data_transfer += residual;
  1650. if(data_transfer != 0) {
  1651. int count; 
  1652. __u32 pAddr;
  1654. SGcount--;
  1656. count = (bS_to_cpu(slot->SG[SGcount].ins) & 0x00ffffff);
  1657. DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %dn", count, count-data_transfer));
  1658. slot->SG[SGcount].ins &= bS_to_host(0xff000000);
  1659. slot->SG[SGcount].ins |= bS_to_host(data_transfer);
  1660. pAddr = bS_to_cpu(slot->SG[SGcount].pAddr);
  1661. pAddr += (count - data_transfer);
  1662. #ifdef NCR_700_DEBUG
  1663. if(pAddr != naddr) {
  1664. printk("scsi%d (%d:%d) transfer mismatch pAddr=%lx, naddr=%lx, data_transfer=%d, residual=%dn", host->host_no, pun, lun, (unsigned long)pAddr, (unsigned long)naddr, data_transfer, residual);
  1665. }
  1666. #endif
  1667. slot->SG[SGcount].pAddr = bS_to_host(pAddr);
  1668. }
  1669. /* set the executed moves to nops */
  1670. for(i=0; i<SGcount; i++) {
  1671. slot->SG[i].ins = bS_to_host(SCRIPT_NOP);
  1672. slot->SG[i].pAddr = 0;
  1673. }
  1674. NCR_700_dma_cache_wback((unsigned long)slot->SG, sizeof(slot->SG));
  1675. /* and pretend we disconnected after
  1676.  * the command phase */
  1677. resume_offset = hostdata->pScript + Ent_MsgInDuringData;
  1678. /* make sure all the data is flushed */
  1679. NCR_700_flush_fifo(host);
  1680. } else {
  1681. __u8 sbcl = NCR_700_readb(host, SBCL_REG);
  1682. printk(KERN_ERR "scsi%d: (%d:%d) phase mismatch at %04x, phase %sn",
  1683.        host->host_no, pun, lun, dsp - hostdata->pScript, sbcl_to_string(sbcl));
  1684. NCR_700_internal_bus_reset(host);
  1685. }
  1687. } else if(sstat0 & SCSI_GROSS_ERROR) {
  1688. printk(KERN_ERR "scsi%d: (%d:%d) GROSS ERRORn",
  1689.        host->host_no, pun, lun);
  1690. NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
  1691. } else if(sstat0 & PARITY_ERROR) {
  1692. printk(KERN_ERR "scsi%d: (%d:%d) PARITY ERRORn",
  1693.        host->host_no, pun, lun);
  1694. NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
  1695. } else if(dstat & SCRIPT_INT_RECEIVED) {
  1696. DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====n",
  1697.        host->host_no, pun, lun));
  1698. resume_offset = process_script_interrupt(dsps, dsp, SCp, host, hostdata);
  1699. } else if(dstat & (ILGL_INST_DETECTED)) {
  1700. printk(KERN_ERR "scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!n"
  1701.        "         Please email James.Bottomley@HansenPartnership.com with the detailsn",
  1702.        host->host_no, pun, lun,
  1703.        dsp, dsp - hostdata->pScript);
  1704. NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
  1705. } else if(dstat & (WATCH_DOG_INTERRUPT|ABORTED)) {
  1706. printk(KERN_ERR "scsi%d: (%d:%d) serious DMA problem, dstat=%02xn",
  1707.        host->host_no, pun, lun, dstat);
  1708. NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
  1709. }
  1712. /* NOTE: selection interrupt processing MUST occur
  1713.  * after script interrupt processing to correctly cope
  1714.  * with the case where we process a disconnect and
  1715.  * then get reselected before we process the
  1716.  * disconnection */
  1717. if(sstat0 & SELECTED) {
  1718. /* FIXME: It currently takes at least FOUR
  1719.  * interrupts to complete a command that
  1720.  * disconnects: one for the disconnect, one
  1721.  * for the reselection, one to get the
  1722.  * reselection data and one to complete the
  1723.  * command.  If we guess the reselected
  1724.  * command here and prepare it, we only need
  1725.  * to get a reselection data interrupt if we
  1726.  * guessed wrongly.  Since the interrupt
  1727.  * overhead is much greater than the command
  1728.  * setup, this would be an efficient
  1729.  * optimisation particularly as we probably
  1730.  * only have one outstanding command on a
  1731.  * target most of the time */
  1733. resume_offset = process_selection(host, dsp);
  1735. }
  1737. }
  1739. if(resume_offset) {
  1740. if(hostdata->state != NCR_700_HOST_BUSY) {
  1741. printk(KERN_ERR "scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!n",
  1742.        host->host_no, resume_offset, resume_offset - hostdata->pScript);
  1743. hostdata->state = NCR_700_HOST_BUSY;
  1744. }
  1746. DEBUG(("Attempting to resume at %xn", resume_offset));
  1747. NCR_700_clear_fifo(host);
  1748. NCR_700_writel(resume_offset, host, DSP_REG);
  1749. } 
  1750. /* There is probably a technical no-no about this: If we're a
  1751.  * shared interrupt and we got this interrupt because the
  1752.  * other device needs servicing not us, we're still going to
  1753.  * check our queued commands here---of course, there shouldn't
  1754.  * be any outstanding.... */
  1755. if(hostdata->state == NCR_700_HOST_FREE) {
  1756. int i;
  1758. for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
  1759. /* fairness: always run the queue from the last
  1760.  * position we left off */
  1761. int j = (i + hostdata->saved_slot_position)
  1762. % NCR_700_COMMAND_SLOTS_PER_HOST;
  1764. if(hostdata->slots[j].state != NCR_700_SLOT_QUEUED)
  1765. continue;
  1766. if(NCR_700_start_command(hostdata->slots[j].cmnd)) {
  1767. DEBUG(("scsi%d: Issuing saved command slot %p, cmd %ptn",
  1768.        host->host_no, &hostdata->slots[j],
  1769.        hostdata->slots[j].cmnd));
  1770. hostdata->saved_slot_position = j + 1;
  1771. }
  1773. break;
  1774. }
  1775. }
  1776.  out_unlock:
  1777. spin_unlock_irqrestore(&io_request_lock, flags);
  1778. }
  1780. /* FIXME: Need to put some proc information in and plumb it
  1781.  * into the scsi proc system */
  1782. STATIC int
  1783. NCR_700_proc_directory_info(char *proc_buf, char **startp,
  1784.  off_t offset, int bytes_available,
  1785.  int host_no, int write)
  1786. {
  1787. static char buf[4096]; /* 1 page should be sufficient */
  1788. int len = 0;
  1789. struct Scsi_Host *host = scsi_hostlist;
  1790. struct NCR_700_Host_Parameters *hostdata;
  1791. Scsi_Device *SDp;
  1793. while(host != NULL && host->host_no != host_no)
  1794. host = host->next;
  1796. if(host == NULL)
  1797. return 0;
  1799. if(write) {
  1800. /* FIXME: Clear internal statistics here */
  1801. return 0;
  1802. }
  1803. hostdata = (struct NCR_700_Host_Parameters *)host->hostdata[0];
  1804. len += sprintf(&buf[len], "Total commands outstanding: %dn", hostdata->command_slot_count);
  1805. len += sprintf(&buf[len],"
  1806. Target Depth  Active  Next Tagn
  1807. ====== =====  ======  ========n");
  1808. for(SDp = host->host_queue; SDp != NULL; SDp = SDp->next) {
  1809. len += sprintf(&buf[len]," %2d:%2d   %4d    %4d      %4dn", SDp->id, SDp->lun, SDp->queue_depth, NCR_700_get_depth(SDp), SDp->current_tag);
  1810. }
  1811. if((len -= offset) <= 0)
  1812. return 0;
  1813. if(len > bytes_available)
  1814. len = bytes_available;
  1815. memcpy(proc_buf, buf + offset, len);
  1816. return len;
  1817. }
  1819. STATIC int
  1820. NCR_700_queuecommand(Scsi_Cmnd *SCp, void (*done)(Scsi_Cmnd *))
  1821. {
  1822. struct NCR_700_Host_Parameters *hostdata = 
  1823. (struct NCR_700_Host_Parameters *)SCp->host->hostdata[0];
  1824. __u32 move_ins;
  1825. int pci_direction;
  1826. struct NCR_700_command_slot *slot;
  1827. int hash;
  1829. if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) {
  1830. /* We're over our allocation, this should never happen
  1831.  * since we report the max allocation to the mid layer */
  1832. printk(KERN_WARNING "scsi%d: Command depth has gone over queue depthn", SCp->host->host_no);
  1833. return 1;
  1834. }
  1835. if(NCR_700_get_depth(SCp->device) != 0 && !(hostdata->tag_negotiated & (1<<SCp->target))) {
  1836. DEBUG((KERN_ERR "scsi%d (%d:%d) has non zero depth %dn",
  1837.        SCp->host->host_no, SCp->target, SCp->lun,
  1838.        NCR_700_get_depth(SCp->device)));
  1839. return 1;
  1840. }
  1841. if(NCR_700_get_depth(SCp->device) >= NCR_700_MAX_TAGS) {
  1842. DEBUG((KERN_ERR "scsi%d (%d:%d) has max tag depth %dn",
  1843.        SCp->host->host_no, SCp->target, SCp->lun,
  1844.        NCR_700_get_depth(SCp->device)));
  1845. return 1;
  1846. }
  1847. NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1);
  1849. /* begin the command here */
  1850. /* no need to check for NULL, test for command_slot_cound above
  1851.  * ensures a slot is free */
  1852. slot = find_empty_slot(hostdata);
  1854. slot->cmnd = SCp;
  1856. SCp->scsi_done = done;
  1857. SCp->host_scribble = (unsigned char *)slot;
  1858. SCp->SCp.ptr = NULL;
  1859. SCp->SCp.buffer = NULL;
  1861. #ifdef NCR_700_DEBUG
  1862. printk("53c700: scsi%d, command ", SCp->host->host_no);
  1863. print_command(SCp->cmnd);
  1864. #endif
  1865. if(SCp->device->tagged_supported && !SCp->device->tagged_queue
  1866.    && (hostdata->tag_negotiated &(1<<SCp->target)) == 0
  1867.    && NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING)) {
  1868. /* upper layer has indicated tags are supported.  We don't
  1869.  * necessarily believe it yet.
  1870.  *
  1871.  * NOTE: There is a danger here: the mid layer supports
  1872.  * tag queuing per LUN.  We only support it per PUN because
  1873.  * of potential reselection issues */
  1874. printk(KERN_INFO "scsi%d: (%d:%d) Enabling Tag Command Queuingn", SCp->device->host->host_no, SCp->target, SCp->lun);
  1875. hostdata->tag_negotiated |= (1<<SCp->target);
  1876. NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
  1877. SCp->device->tagged_queue = 1;
  1878. }
  1880. if(hostdata->tag_negotiated &(1<<SCp->target)) {
  1882. struct NCR_700_command_slot *old =
  1883. find_ITL_Nexus(hostdata, SCp->target, SCp->lun);
  1884. #ifdef NCR_700_TAG_DEBUG
  1885. struct NCR_700_command_slot *found;
  1886. #endif
  1888. if(old != NULL && old->tag == SCp->device->current_tag) {
  1889. /* On some badly starving drives, this can be
  1890.  * a frequent occurance, so print the message
  1891.  * only once */
  1892. if(NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_TAG_STARVATION_WARNED)) {
  1893. printk(KERN_WARNING "scsi%d (%d:%d) Target is suffering from tag starvation.n", SCp->host->host_no, SCp->target, SCp->lun);
  1894. NCR_700_set_flag(SCp->device, NCR_700_DEV_TAG_STARVATION_WARNED);
  1895. }
  1896. return 1;
  1897. }
  1898. slot->tag = SCp->device->current_tag++;
  1899. #ifdef NCR_700_TAG_DEBUG
  1900. while((found = find_ITLQ_Nexus(hostdata, SCp->target, SCp->lun, slot->tag)) != NULL) {
  1901. printk("nn**ERROR** already using tag %d, but oldest is %dn", slot->tag, (old == NULL) ? -1 : old->tag);
  1902. printk("  FOUND = %p, tag = %d, pun = %d, lun = %dn",
  1903.        found, found->tag, found->cmnd->target, found->cmnd->lun);
  1904. slot->tag = SCp->device->current_tag++;
  1905. printk("   Tag list is: ");
  1906. while(old != NULL) {
  1907. if(old->cmnd->target == SCp->target &&
  1908.    old->cmnd->lun == SCp->lun)
  1909. printk("%d ", old->tag);
  1910. old = old->ITL_back;
  1911. }
  1912. printk("nn");
  1913. }
  1914. #endif
  1915. hash = hash_ITLQ(SCp->target, SCp->lun, slot->tag);
  1916. /* link into the ITLQ hash queues */
  1917. slot->ITLQ_forw = hostdata->ITLQ_Hash_forw[hash];
  1918. hostdata->ITLQ_Hash_forw[hash] = slot;
  1919. #ifdef NCR_700_TAG_DEBUG
  1920. if(slot->ITLQ_forw != NULL && slot->ITLQ_forw->ITLQ_back != NULL) {
  1921. printk(KERN_ERR "scsi%d (%d:%d) ITLQ_back is not NULL!!!!n", SCp->host->host_no, SCp->target, SCp->lun);
  1922. }
  1923. #endif
  1924. if(slot->ITLQ_forw != NULL)
  1925. slot->ITLQ_forw->ITLQ_back = slot;
  1926. else
  1927. hostdata->ITLQ_Hash_back[hash] = slot;
  1928. slot->ITLQ_back = NULL;
  1929. } else {
  1930. slot->tag = NCR_700_NO_TAG;
  1931. }
  1932. /* link into the ITL hash queues */
  1933. hash = hash_ITL(SCp->target, SCp->lun);
  1934. slot->ITL_forw = hostdata->ITL_Hash_forw[hash];
  1935. hostdata->ITL_Hash_forw[hash] = slot;
  1936. #ifdef NCR_700_TAG_DEBUG
  1937. if(slot->ITL_forw != NULL && slot->ITL_forw->ITL_back != NULL) {
  1938. printk(KERN_ERR "scsi%d (%d:%d) ITL_back is not NULL!!!!n",
  1939.        SCp->host->host_no, SCp->target, SCp->lun);
  1940. }
  1941. #endif
  1942. if(slot->ITL_forw != NULL)
  1943. slot->ITL_forw->ITL_back = slot;
  1944. else
  1945. hostdata->ITL_Hash_back[hash] = slot;
  1946. slot->ITL_back = NULL;
  1948. /* sanity check: some of the commands generated by the mid-layer
  1949.  * have an eccentric idea of their sc_data_direction */
  1950. if(!SCp->use_sg && !SCp->request_bufflen 
  1951.    && SCp->sc_data_direction != SCSI_DATA_NONE) {
  1952. #ifdef NCR_700_DEBUG
  1953. printk("53c700: Command");
  1954. print_command(SCp->cmnd);
  1955. printk("Has wrong data direction %dn", SCp->sc_data_direction);
  1956. #endif
  1957. SCp->sc_data_direction = SCSI_DATA_NONE;
  1958. }
  1960. switch (SCp->cmnd[0]) {
  1961. case REQUEST_SENSE:
  1962. /* clear the internal sense magic */
  1963. SCp->cmnd[6] = 0;
  1964. /* fall through */
  1965. default:
  1966. /* OK, get it from the command */
  1967. switch(SCp->sc_data_direction) {
  1968. case SCSI_DATA_UNKNOWN:
  1969. default:
  1970. printk(KERN_ERR "53c700: Unknown command for data direction ");
  1971. print_command(SCp->cmnd);
  1973. move_ins = 0;
  1974. break;
  1975. case SCSI_DATA_NONE:
  1976. move_ins = 0;
  1977. break;
  1978. case SCSI_DATA_READ:
  1979. move_ins = SCRIPT_MOVE_DATA_IN;
  1980. break;
  1981. case SCSI_DATA_WRITE:
  1982. move_ins = SCRIPT_MOVE_DATA_OUT;
  1983. break;
  1984. }
  1985. }
  1987. /* now build the scatter gather list */
  1988. pci_direction = scsi_to_pci_dma_dir(SCp->sc_data_direction);
  1989. if(move_ins != 0) {
  1990. int i;
  1991. int sg_count;
  1992. dma_addr_t vPtr = 0;
  1993. __u32 count = 0;
  1995. if(SCp->use_sg) {
  1996. sg_count = pci_map_sg(hostdata->pci_dev, SCp->buffer,
  1997.       SCp->use_sg, pci_direction);
  1998. } else {
  1999. vPtr = pci_map_single(hostdata->pci_dev,
  2000.       SCp->request_buffer, 
  2001.       SCp->request_bufflen,
  2002.       pci_direction);
  2003. count = SCp->request_bufflen;
  2004. slot->dma_handle = vPtr;
  2005. sg_count = 1;
  2006. }
  2009. for(i = 0; i < sg_count; i++) {
  2011. if(SCp->use_sg) {
  2012. struct scatterlist *sg = SCp->buffer;
  2014. vPtr = sg_dma_address(&sg[i]);
  2015. count = sg_dma_len(&sg[i]);
  2016. }
  2018. slot->SG[i].ins = bS_to_host(move_ins | count);
  2019. DEBUG((" scatter block %d: move %d[%08x] from 0x%lxn",
  2020.        i, count, slot->SG[i].ins, (unsigned long)vPtr));
  2021. slot->SG[i].pAddr = bS_to_host(vPtr);
  2022. }
  2023. slot->SG[i].ins = bS_to_host(SCRIPT_RETURN);
  2024. slot->SG[i].pAddr = 0;
  2025. NCR_700_dma_cache_wback((unsigned long)slot->SG, sizeof(slot->SG));
  2026. DEBUG((" SETTING %08lx to %xn",
  2027.        (&slot->pSG[i].ins), 
  2028.        slot->SG[i].ins));
  2029. }
  2030. slot->resume_offset = 0;
  2031. slot->pCmd = pci_map_single(hostdata->pci_dev, SCp->cmnd,
  2032.     sizeof(SCp->cmnd), PCI_DMA_TODEVICE);
  2033. NCR_700_start_command(SCp);
  2034. return 0;
  2035. }
  2037. STATIC int
  2038. NCR_700_abort(Scsi_Cmnd * SCp)
  2039. {
  2040. struct NCR_700_command_slot *slot;
  2041. struct NCR_700_Host_Parameters *hostdata = 
  2042. (struct NCR_700_Host_Parameters *)SCp->host->hostdata[0];
  2044. printk(KERN_INFO "scsi%d (%d:%d) New error handler wants to abort commandnt",
  2045.        SCp->host->host_no, SCp->target, SCp->lun);
  2046. print_command(SCp->cmnd);
  2048. slot = find_ITL_Nexus(hostdata, SCp->target, SCp->lun);
  2049. while(slot != NULL && slot->cmnd != SCp)
  2050. slot = slot->ITL_back;
  2052. if(slot == NULL)
  2053. /* no outstanding command to abort */
  2054. return SUCCESS;
  2055. if(SCp->cmnd[0] == TEST_UNIT_READY) {
  2056. /* FIXME: This is because of a problem in the new
  2057.  * error handler.  When it is in error recovery, it
  2058.  * will send a TUR to a device it thinks may still be
  2059.  * showing a problem.  If the TUR isn't responded to,
  2060.  * it will abort it and mark the device off line.
  2061.  * Unfortunately, it does no other error recovery, so
  2062.  * this would leave us with an outstanding command
  2063.  * occupying a slot.  Rather than allow this to
  2064.  * happen, we issue a bus reset to force all
  2065.  * outstanding commands to terminate here. */
  2066. NCR_700_internal_bus_reset(SCp->host);
  2067. /* still drop through and return failed */
  2068. }
  2069. return FAILED;
  2071. }
  2073. STATIC int
  2074. NCR_700_bus_reset(Scsi_Cmnd * SCp)
  2075. {
  2076. printk(KERN_INFO "scsi%d (%d:%d) New error handler wants BUS reset, cmd %pnt",
  2077.        SCp->host->host_no, SCp->target, SCp->lun, SCp);
  2078. print_command(SCp->cmnd);
  2079. NCR_700_internal_bus_reset(SCp->host);
  2080. return SUCCESS;
  2081. }
  2083. STATIC int
  2084. NCR_700_dev_reset(Scsi_Cmnd * SCp)
  2085. {
  2086. printk(KERN_INFO "scsi%d (%d:%d) New error handler wants device resetnt",
  2087.        SCp->host->host_no, SCp->target, SCp->lun);
  2088. print_command(SCp->cmnd);
  2090. return FAILED;
  2091. }
  2093. STATIC int
  2094. NCR_700_host_reset(Scsi_Cmnd * SCp)
  2095. {
  2096. printk(KERN_INFO "scsi%d (%d:%d) New error handler wants HOST resetnt",
  2097.        SCp->host->host_no, SCp->target, SCp->lun);
  2098. print_command(SCp->cmnd);
  2100. NCR_700_internal_bus_reset(SCp->host);
  2101. NCR_700_chip_reset(SCp->host);
  2102. return SUCCESS;
  2103. }
  2105. EXPORT_SYMBOL(NCR_700_detect);
  2106. EXPORT_SYMBOL(NCR_700_release);
  2107. EXPORT_SYMBOL(NCR_700_intr);