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

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

Linux/Unix编程

开发平台：

Unix_Linux

eata.c：源码内容
  1. /*
  2.  *      eata.c - Low-level driver for EATA/DMA SCSI host adapters.
  3.  *
  4.  *      25 Jun 2002 Rev. 6.70 for linux 2.4.19
  5.  *        + This release is the first one tested on a Big Endian platform:
  6.  *          fixed endian-ness problem due to bitfields;
  7.  *          fixed endian-ness problem in read_pio.
  8.  *        + Added new options for selectively probing ISA, EISA and PCI bus:
  9.  *
  10.  *          Boot option   Parameter name    Default according to
  11.  *
  12.  *          ip:[y|n]      isa_probe=[1|0]   CONFIG_ISA  defined
  13.  *          ep:[y|n]      eisa_probe=[1|0]  CONFIG_EISA defined
  14.  *          pp:[y|n]      pci_probe=[1|0]   CONFIG_PCI  defined
  15.  *
  16.  *          The default action is to perform probing if the corrisponding
  17.  *          bus is configured and to skip probing otherwise.
  18.  *
  19.  *        + If pci_probe is in effect and a list of I/O  ports is specified
  20.  *          as parameter or boot option, pci_enable_device() is performed
  21.  *          on all pci devices matching PCI_CLASS_STORAGE_SCSI.
  22.  *
  23.  *      21 Feb 2002 Rev. 6.52 for linux 2.4.18
  24.  *        + Backport from rev. 7.22 (use io_request_lock).
  25.  *
  26.  *      20 Feb 2002 Rev. 7.22 for linux 2.5.5
  27.  *        + Remove any reference to virt_to_bus().
  28.  *        + Fix pio hang while detecting multiple HBAs.
  29.  *        + Fixed a board detection bug: in a system with
  30.  *          multiple ISA/EISA boards, all but the first one
  31.  *          were erroneously detected as PCI.
  32.  *
  33.  *      01 Jan 2002 Rev. 7.20 for linux 2.5.1
  34.  *        + Use the dynamic DMA mapping API.
  35.  *
  36.  *      19 Dec 2001 Rev. 7.02 for linux 2.5.1
  37.  *        + Use SCpnt->sc_data_direction if set.
  38.  *        + Use sglist.page instead of sglist.address.
  39.  *
  40.  *      11 Dec 2001 Rev. 7.00 for linux 2.5.1
  41.  *        + Use host->host_lock instead of io_request_lock.
  42.  *
  43.  *       1 May 2001 Rev. 6.05 for linux 2.4.4
  44.  *        + Clean up all pci related routines.
  45.  *        + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d)
  46.  *
  47.  *      30 Jan 2001 Rev. 6.04 for linux 2.4.1
  48.  *        + Call pci_resource_start after pci_enable_device.
  49.  *
  50.  *      25 Jan 2001 Rev. 6.03 for linux 2.4.0
  51.  *        + "check_region" call replaced by "request_region".
  52.  *
  53.  *      22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11
  54.  *        + Return code checked when calling pci_enable_device.
  55.  *        + Removed old scsi error handling support.
  56.  *        + The obsolete boot option flag eh:n is silently ignored.
  57.  *        + Removed error messages while a disk drive is powered up at
  58.  *          boot time.
  59.  *        + Improved boot messages: all tagged capable device are
  60.  *          indicated as "tagged" or "soft-tagged" :
  61.  *          - "soft-tagged"  means that the driver is trying to do its
  62.  *            own tagging (i.e. the tc:y option is in effect);
  63.  *          - "tagged" means that the device supports tagged commands,
  64.  *            but the driver lets the HBA be responsible for tagging
  65.  *            support.
  66.  *
  67.  *      16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18
  68.  *        + Updated to the new __setup interface for boot command line options.
  69.  *        + When loaded as a module, accepts the new parameter boot_options
  70.  *          which value is a string with the same format of the kernel boot
  71.  *          command line options. A valid example is:
  72.  *          modprobe eata 'boot_options="0x7410,0x230,lc:y,tc:n,mq:4"'
  73.  *
  74.  *       9 Sep 1999 Rev. 5.10 for linux 2.2.12 and 2.3.17
  75.  *        + 64bit cleanup for Linux/Alpha platform support
  76.  *          (contribution from H.J. Lu).
  77.  *
  78.  *      22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11
  79.  *        + Removed pre-2.2 source code compatibility.
  80.  *        + Added call to pci_set_master.
  81.  *
  82.  *      26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111
  83.  *        + Added command line option (rs:[y|n]) to reverse the scan order
  84.  *          of PCI boards. The default is rs:y, which reverses the BIOS order
  85.  *          while registering PCI boards. The default value rs:y generates
  86.  *          the same order of all previous revisions of this driver.
  87.  *          Pls. note that "BIOS order" might have been reversed itself
  88.  *          after the 2.1.9x PCI modifications in the linux kernel.
  89.  *          The rs value is ignored when the explicit list of addresses
  90.  *          is used by the "eata=port0,port1,..." command line option.
  91.  *        + Added command line option (et:[y|n]) to force use of extended
  92.  *          translation (255 heads, 63 sectors) as disk geometry.
  93.  *          The default is et:n, which uses the disk geometry returned
  94.  *          by scsicam_bios_param. The default value et:n is compatible with
  95.  *          all previous revisions of this driver.
  96.  *
  97.  *      28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104
  98.  *          Increased busy timeout from 10 msec. to 200 msec. while
  99.  *          processing interrupts.
  100.  *
  101.  *      16 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102
  102.  *          Improved abort handling during the eh recovery process.
  103.  *
  104.  *      13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101
  105.  *          The driver is now fully SMP safe, including the
  106.  *          abort and reset routines.
  107.  *          Added command line options (eh:[y|n]) to choose between
  108.  *          new_eh_code and the old scsi code.
  109.  *          If linux version >= 2.1.101 the default is eh:y, while the eh
  110.  *          option is ignored for previous releases and the old scsi code
  111.  *          is used.
  112.  *
  113.  *      18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97
  114.  *          Reworked interrupt handler.
  115.  *
  116.  *      11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95
  117.  *          Major reliability improvement: when a batch with overlapping
  118.  *          requests is detected, requests are queued one at a time
  119.  *          eliminating any possible board or drive reordering.
  120.  *
  121.  *      10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95
  122.  *          Improved SMP support (if linux version >= 2.1.95).
  123.  *
  124.  *       9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94
  125.  *          Added support for new PCI code and IO-APIC remapping of irqs.
  126.  *          Performance improvement: when sequential i/o is detected,
  127.  *          always use direct sort instead of reverse sort.
  128.  *
  129.  *       4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92
  130.  *          io_port is now unsigned long.
  131.  *
  132.  *      17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88
  133.  *          Use new scsi error handling code (if linux version >= 2.1.88).
  134.  *          Use new interrupt code.
  135.  *
  136.  *      12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55
  137.  *          Use of udelay inside the wait loops to avoid timeout
  138.  *          problems with fast cpus.
  139.  *          Removed check about useless calls to the interrupt service
  140.  *          routine (reported on SMP systems only).
  141.  *          At initialization time "sorted/unsorted" is displayed instead
  142.  *          of "linked/unlinked" to reinforce the fact that "linking" is
  143.  *          nothing but "elevator sorting" in the actual implementation.
  144.  *
  145.  *      17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38
  146.  *          Use of serial_number_at_timeout in abort and reset processing.
  147.  *          Use of the __initfunc and __initdata macro in setup code.
  148.  *          Minor cleanups in the list_statistics code.
  149.  *          Increased controller busy timeout in order to better support
  150.  *          slow SCSI devices.
  151.  *
  152.  *      24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26
  153.  *          When loading as a module, parameter passing is now supported
  154.  *          both in 2.0 and in 2.1 style.
  155.  *          Fixed data transfer direction for some SCSI opcodes.
  156.  *          Immediate acknowledge to request sense commands.
  157.  *          Linked commands to each disk device are now reordered by elevator
  158.  *          sorting. Rare cases in which reordering of write requests could
  159.  *          cause wrong results are managed.
  160.  *          Fixed spurious timeouts caused by long simple queue tag sequences.
  161.  *          New command line option (tm:[0-3]) to choose the type of tags:
  162.  *          0 -> mixed (default); 1 -> simple; 2 -> head; 3 -> ordered.
  163.  *
  164.  *      18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28
  165.  *          Added command line options to enable/disable linked commands
  166.  *          (lc:[y|n]), tagged commands (tc:[y|n]) and to set the max queue
  167.  *          depth (mq:xx). Default is "eata=lc:n,tc:n,mq:16".
  168.  *          Improved command linking.
  169.  *          Documented how to setup RAID-0 with DPT SmartRAID boards.
  170.  *
  171.  *       8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27
  172.  *          Added linked command support.
  173.  *          Improved detection of PCI boards using ISA base addresses.
  174.  *
  175.  *       3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27
  176.  *          Added support for tagged commands and queue depth adjustment.
  177.  *
  178.  *      22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26
  179.  *          When CONFIG_PCI is defined, BIOS32 is used to include in the
  180.  *          list of i/o ports to be probed all the PCI SCSI controllers.
  181.  *          The list of i/o ports to be probed can be overwritten by the
  182.  *          "eata=port0,port1,...." boot command line option.
  183.  *          Scatter/gather lists are now allocated by a number of kmalloc
  184.  *          calls, in order to avoid the previous size limit of 64Kb.
  185.  *
  186.  *      16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25
  187.  *          Added support for EATA 2.0C, PCI, multichannel and wide SCSI.
  188.  *
  189.  *      27 Sep 1996 rev. 2.12 for linux 2.1.0
  190.  *          Portability cleanups (virtual/bus addressing, little/big endian
  191.  *          support).
  192.  *
  193.  *      09 Jul 1996 rev. 2.11 for linux 2.0.4
  194.  *          Number of internal retries is now limited.
  195.  *
  196.  *      16 Apr 1996 rev. 2.10 for linux 1.3.90
  197.  *          New argument "reset_flags" to the reset routine.
  198.  *
  199.  *       6 Jul 1995 rev. 2.01 for linux 1.3.7
  200.  *          Update required by the new /proc/scsi support.
  201.  *
  202.  *      11 Mar 1995 rev. 2.00 for linux 1.2.0
  203.  *          Fixed a bug which prevented media change detection for removable
  204.  *          disk drives.
  205.  *
  206.  *      23 Feb 1995 rev. 1.18 for linux 1.1.94
  207.  *          Added a check for scsi_register returning NULL.
  208.  *
  209.  *      11 Feb 1995 rev. 1.17 for linux 1.1.91
  210.  *          Now DEBUG_RESET is disabled by default.
  211.  *          Register a board even if it does not assert DMA protocol support
  212.  *          (DPT SK2011B does not report correctly the dmasup bit).
  213.  *
  214.  *       9 Feb 1995 rev. 1.16 for linux 1.1.90
  215.  *          Use host->wish_block instead of host->block.
  216.  *          New list of Data Out SCSI commands.
  217.  *
  218.  *       8 Feb 1995 rev. 1.15 for linux 1.1.89
  219.  *          Cleared target_time_out counter while performing a reset.
  220.  *          All external symbols renamed to avoid possible name conflicts.
  221.  *
  222.  *      28 Jan 1995 rev. 1.14 for linux 1.1.86
  223.  *          Added module support.
  224.  *          Log and do a retry when a disk drive returns a target status
  225.  *          different from zero on a recovered error.
  226.  *
  227.  *      24 Jan 1995 rev. 1.13 for linux 1.1.85
  228.  *          Use optimized board configuration, with a measured performance
  229.  *          increase in the range 10%-20% on i/o throughput.
  230.  *
  231.  *      16 Jan 1995 rev. 1.12 for linux 1.1.81
  232.  *          Fix mscp structure comments (no functional change).
  233.  *          Display a message if check_region detects a port address
  234.  *          already in use.
  235.  *
  236.  *      17 Dec 1994 rev. 1.11 for linux 1.1.74
  237.  *          Use the scsicam_bios_param routine. This allows an easy
  238.  *          migration path from disk partition tables created using
  239.  *          different SCSI drivers and non optimal disk geometry.
  240.  *
  241.  *      15 Dec 1994 rev. 1.10 for linux 1.1.74
  242.  *          Added support for ISA EATA boards (DPT PM2011, DPT PM2021).
  243.  *          The host->block flag is set for all the detected ISA boards.
  244.  *          The detect routine no longer enforces LEVEL triggering
  245.  *          for EISA boards, it just prints a warning message.
  246.  *
  247.  *      30 Nov 1994 rev. 1.09 for linux 1.1.68
  248.  *          Redo i/o on target status CHECK_CONDITION for TYPE_DISK only.
  249.  *          Added optional support for using a single board at a time.
  250.  *
  251.  *      18 Nov 1994 rev. 1.08 for linux 1.1.64
  252.  *          Forces sg_tablesize = 64 and can_queue = 64 if these
  253.  *          values are not correctly detected (DPT PM2012).
  254.  *
  255.  *      14 Nov 1994 rev. 1.07 for linux 1.1.63  Final BETA release.
  256.  *      04 Aug 1994 rev. 1.00 for linux 1.1.39  First BETA release.
  257.  *
  258.  *
  259.  *          This driver is based on the CAM (Common Access Method Committee)
  260.  *          EATA (Enhanced AT Bus Attachment) rev. 2.0A, using DMA protocol.
  261.  *
  262.  *  Copyright (C) 1994-2002 Dario Ballabio (ballabio_dario@emc.com)
  263.  *
  264.  *  Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it
  265.  *
  266.  *  Redistribution and use in source and binary forms, with or without
  267.  *  modification, are permitted provided that redistributions of source
  268.  *  code retain the above copyright notice and this comment without
  269.  *  modification.
  270.  *
  271.  */
  273. /*
  274.  *
  275.  *  Here is a brief description of the DPT SCSI host adapters.
  276.  *  All these boards provide an EATA/DMA compatible programming interface
  277.  *  and are fully supported by this driver in any configuration, including
  278.  *  multiple SCSI channels:
  279.  *
  280.  *  PM2011B/9X -  Entry Level ISA
  281.  *  PM2021A/9X -  High Performance ISA
  282.  *  PM2012A       Old EISA
  283.  *  PM2012B       Old EISA
  284.  *  PM2022A/9X -  Entry Level EISA
  285.  *  PM2122A/9X -  High Performance EISA
  286.  *  PM2322A/9X -  Extra High Performance EISA
  287.  *  PM3021     -  SmartRAID Adapter for ISA
  288.  *  PM3222     -  SmartRAID Adapter for EISA (PM3222W is 16-bit wide SCSI)
  289.  *  PM3224     -  SmartRAID Adapter for PCI  (PM3224W is 16-bit wide SCSI)
  290.  *  PM33340UW  -  SmartRAID Adapter for PCI  ultra wide multichannel
  291.  *
  292.  *  The above list is just an indication: as a matter of fact all DPT
  293.  *  boards using the EATA/DMA protocol are supported by this driver,
  294.  *  since they use exactely the same programming interface.
  295.  *
  296.  *  The DPT PM2001 provides only the EATA/PIO interface and hence is not
  297.  *  supported by this driver.
  298.  *
  299.  *  This code has been tested with up to 3 Distributed Processing Technology
  300.  *  PM2122A/9X (DPT SCSI BIOS v002.D1, firmware v05E.0) EISA controllers,
  301.  *  in any combination of private and shared IRQ.
  302.  *  PCI support has been tested using up to 2 DPT PM3224W (DPT SCSI BIOS
  303.  *  v003.D0, firmware v07G.0).
  304.  *
  305.  *  DPT SmartRAID boards support "Hardware Array" - a group of disk drives
  306.  *  which are all members of the same RAID-0, RAID-1 or RAID-5 array implemented
  307.  *  in host adapter hardware. Hardware Arrays are fully compatible with this
  308.  *  driver, since they look to it as a single disk drive.
  309.  *
  310.  *  WARNING: to create a RAID-0 "Hardware Array" you must select "Other Unix"
  311.  *  as the current OS in the DPTMGR "Initial System Installation" menu.
  312.  *  Otherwise RAID-0 is generated as an "Array Group" (i.e. software RAID-0),
  313.  *  which is not supported by the actual SCSI subsystem.
  314.  *  To get the "Array Group" functionality, the Linux MD driver must be used
  315.  *  instead of the DPT "Array Group" feature.
  316.  *
  317.  *  Multiple ISA, EISA and PCI boards can be configured in the same system.
  318.  *  It is suggested to put all the EISA boards on the same IRQ level, all
  319.  *  the PCI  boards on another IRQ level, while ISA boards cannot share
  320.  *  interrupts.
  321.  *
  322.  *  If you configure multiple boards on the same IRQ, the interrupt must
  323.  *  be _level_ triggered (not _edge_ triggered).
  324.  *
  325.  *  This driver detects EATA boards by probes at fixed port addresses,
  326.  *  so no BIOS32 or PCI BIOS support is required.
  327.  *  The suggested way to detect a generic EATA PCI board is to force on it
  328.  *  any unused EISA address, even if there are other controllers on the EISA
  329.  *  bus, or even if you system has no EISA bus at all.
  330.  *  Do not force any ISA address on EATA PCI boards.
  331.  *
  332.  *  If PCI bios support is configured into the kernel, BIOS32 is used to
  333.  *  include in the list of i/o ports to be probed all the PCI SCSI controllers.
  334.  *
  335.  *  Due to a DPT BIOS "feature", it might not be possible to force an EISA
  336.  *  address on more than a single DPT PCI board, so in this case you have to
  337.  *  let the PCI BIOS assign the addresses.
  338.  *
  339.  *  The sequence of detection probes is:
  340.  *
  341.  *  - ISA 0x1F0;
  342.  *  - PCI SCSI controllers (only if BIOS32 is available);
  343.  *  - EISA/PCI 0x1C88 through 0xFC88 (corresponding to EISA slots 1 to 15);
  344.  *  - ISA  0x170, 0x230, 0x330.
  345.  *
  346.  *  The above list of detection probes can be totally replaced by the
  347.  *  boot command line option: "eata=port0,port1,port2,...", where the
  348.  *  port0, port1... arguments are ISA/EISA/PCI addresses to be probed.
  349.  *  For example using "eata=0x7410,0x7450,0x230", the driver probes
  350.  *  only the two PCI addresses 0x7410 and 0x7450 and the ISA address 0x230,
  351.  *  in this order; "eata=0" totally disables this driver.
  352.  *
  353.  *  After the optional list of detection probes, other possible command line
  354.  *  options are:
  355.  *
  356.  *  et:y  force use of extended translation (255 heads, 63 sectors);
  357.  *  et:n  use disk geometry detected by scsicam_bios_param;
  358.  *  rs:y  reverse scan order while detecting PCI boards;
  359.  *  rs:n  use BIOS order while detecting PCI boards;
  360.  *  lc:y  enables linked commands;
  361.  *  lc:n  disables linked commands;
  362.  *  tc:y  enables tagged commands;
  363.  *  tc:n  disables tagged commands;
  364.  *  tm:0  use head/simple/ordered queue tag sequences;
  365.  *  tm:1  use only simple queue tags;
  366.  *  tm:2  use only head of queue tags;
  367.  *  tm:3  use only ordered queue tags;
  368.  *  mq:xx set the max queue depth to the value xx (2 <= xx <= 32).
  369.  *
  370.  *  The default value is: "eata=lc:n,tc:n,mq:16,tm:0,et:n,rs:n".
  371.  *  An example using the list of detection probes could be:
  372.  *  "eata=0x7410,0x230,lc:y,tc:n,mq:4,et:n".
  373.  *
  374.  *  When loading as a module, parameters can be specified as well.
  375.  *  The above example would be (use 1 in place of y and 0 in place of n):
  376.  *
  377.  *  modprobe eata io_port=0x7410,0x230 linked_comm=1 tagged_comm=0 
  378.  *                max_queue_depth=4 tag_mode=0 
  379.  *                ext_tran=0 rev_scan=1
  380.  *
  381.  *  ----------------------------------------------------------------------------
  382.  *  In this implementation, linked commands are designed to work with any DISK
  383.  *  or CD-ROM, since this linking has only the intent of clustering (time-wise)
  384.  *  and reordering by elevator sorting commands directed to each device,
  385.  *  without any relation with the actual SCSI protocol between the controller
  386.  *  and the device.
  387.  *  If Q is the queue depth reported at boot time for each device (also named
  388.  *  cmds/lun) and Q > 2, whenever there is already an active command to the
  389.  *  device all other commands to the same device  (up to Q-1) are kept waiting
  390.  *  in the elevator sorting queue. When the active command completes, the
  391.  *  commands in this queue are sorted by sector address. The sort is chosen
  392.  *  between increasing or decreasing by minimizing the seek distance between
  393.  *  the sector of the commands just completed and the sector of the first
  394.  *  command in the list to be sorted.
  395.  *  Trivial math assures that the unsorted average seek distance when doing
  396.  *  random seeks over S sectors is S/3.
  397.  *  When (Q-1) requests are uniformly distributed over S sectors, the average
  398.  *  distance between two adjacent requests is S/((Q-1) + 1), so the sorted
  399.  *  average seek distance for (Q-1) random requests over S sectors is S/Q.
  400.  *  The elevator sorting hence divides the seek distance by a factor Q/3.
  401.  *  The above pure geometric remarks are valid in all cases and the
  402.  *  driver effectively reduces the seek distance by the predicted factor
  403.  *  when there are Q concurrent read i/o operations on the device, but this
  404.  *  does not necessarily results in a noticeable performance improvement:
  405.  *  your mileage may vary....
  406.  *
  407.  *  Note: command reordering inside a batch of queued commands could cause
  408.  *        wrong results only if there is at least one write request and the
  409.  *        intersection (sector-wise) of all requests is not empty.
  410.  *        When the driver detects a batch including overlapping requests
  411.  *        (a really rare event) strict serial (pid) order is enforced.
  412.  *  ----------------------------------------------------------------------------
  413.  *  The extended translation option (et:y) is useful when using large physical
  414.  *  disks/arrays. It could also be useful when switching between Adaptec boards
  415.  *  and DPT boards without reformatting the disk.
  416.  *  When a boot disk is partitioned with extended translation, in order to
  417.  *  be able to boot it with a DPT board is could be necessary to add to
  418.  *  lilo.conf additional commands as in the following example:
  419.  *
  420.  *  fix-table
  421.  *  disk=/dev/sda bios=0x80 sectors=63 heads=128 cylindres=546
  422.  *
  423.  *  where the above geometry should be replaced with the one reported at
  424.  *  power up by the DPT controller.
  425.  *  ----------------------------------------------------------------------------
  426.  *
  427.  *  The boards are named EATA0, EATA1,... according to the detection order.
  428.  *
  429.  *  In order to support multiple ISA boards in a reliable way,
  430.  *  the driver sets host->wish_block = TRUE for all ISA boards.
  431.  */
  433. #include <linux/version.h>
  435. #ifndef LinuxVersionCode
  436. #define LinuxVersionCode(v, p, s) (((v)<<16)+((p)<<8)+(s))
  437. #endif
  439. #define MAX_INT_PARAM 10
  441. #if defined(MODULE)
  442. #include <linux/module.h>
  444. MODULE_PARM(boot_options, "s");
  445. MODULE_PARM(io_port, "1-" __MODULE_STRING(MAX_INT_PARAM) "i");
  446. MODULE_PARM(linked_comm, "i");
  447. MODULE_PARM(tagged_comm, "i");
  448. MODULE_PARM(link_statistics, "i");
  449. MODULE_PARM(max_queue_depth, "i");
  450. MODULE_PARM(tag_mode, "i");
  451. MODULE_PARM(ext_tran, "i");
  452. MODULE_PARM(rev_scan, "i");
  453. MODULE_PARM(isa_probe, "i");
  454. MODULE_PARM(eisa_probe, "i");
  455. MODULE_PARM(pci_probe, "i");
  456. MODULE_AUTHOR("Dario Ballabio");
  458. #endif
  460. #include <linux/string.h>
  461. #include <linux/sched.h>
  462. #include <linux/kernel.h>
  463. #include <linux/ioport.h>
  464. #include <linux/delay.h>
  465. #include <asm/io.h>
  466. #include <asm/system.h>
  467. #include <asm/byteorder.h>
  468. #include <linux/proc_fs.h>
  469. #include <linux/blk.h>
  470. #include "scsi.h"
  471. #include "hosts.h"
  472. #include "sd.h"
  473. #include <asm/dma.h>
  474. #include <asm/irq.h>
  475. #include "eata.h"
  476. #include <linux/stat.h>
  477. #include <linux/config.h>
  478. #include <linux/pci.h>
  479. #include <linux/init.h>
  480. #include <linux/ctype.h>
  481. #include <linux/spinlock.h>
  483. #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
  484. #error "Adjust your <asm/byteorder.h> defines"
  485. #endif
  487. /* Subversion values */
  488. #define ISA  0
  489. #define ESA 1
  491. #undef  FORCE_CONFIG
  493. #undef  DEBUG_LINKED_COMMANDS
  494. #undef  DEBUG_DETECT
  495. #undef  DEBUG_PCI_DETECT
  496. #undef  DEBUG_INTERRUPT
  497. #undef  DEBUG_RESET
  498. #undef  DEBUG_GENERATE_ERRORS
  499. #undef  DEBUG_GENERATE_ABORTS
  500. #undef  DEBUG_GEOMETRY
  502. #define MAX_ISA 4
  503. #define MAX_VESA 0
  504. #define MAX_EISA 15
  505. #define MAX_PCI 16
  506. #define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
  507. #define MAX_CHANNEL 4
  508. #define MAX_LUN 32
  509. #define MAX_TARGET 32
  510. #define MAX_MAILBOXES 64
  511. #define MAX_SGLIST 64
  512. #define MAX_LARGE_SGLIST 122
  513. #define MAX_INTERNAL_RETRIES 64
  514. #define MAX_CMD_PER_LUN 2
  515. #define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
  517. #define SKIP ULONG_MAX
  518. #define FALSE 0
  519. #define TRUE 1
  520. #define FREE 0
  521. #define IN_USE   1
  522. #define LOCKED   2
  523. #define IN_RESET 3
  524. #define IGNORE   4
  525. #define READY    5
  526. #define ABORTING 6
  527. #define NO_DMA  0xff
  528. #define MAXLOOP  10000
  529. #define TAG_MIXED    0
  530. #define TAG_SIMPLE   1
  531. #define TAG_HEAD     2
  532. #define TAG_ORDERED  3
  534. #define REG_CMD         7
  535. #define REG_STATUS      7
  536. #define REG_AUX_STATUS  8
  537. #define REG_DATA        0
  538. #define REG_DATA2       1
  539. #define REG_SEE         6
  540. #define REG_LOW         2
  541. #define REG_LM          3
  542. #define REG_MID         4
  543. #define REG_MSB         5
  544. #define REGION_SIZE     9UL
  545. #define MAX_ISA_ADDR    0x03ff
  546. #define MIN_EISA_ADDR   0x1c88
  547. #define MAX_EISA_ADDR   0xfc88
  548. #define BSY_ASSERTED      0x80
  549. #define DRQ_ASSERTED      0x08
  550. #define ABSY_ASSERTED     0x01
  551. #define IRQ_ASSERTED      0x02
  552. #define READ_CONFIG_PIO   0xf0
  553. #define SET_CONFIG_PIO    0xf1
  554. #define SEND_CP_PIO       0xf2
  555. #define RECEIVE_SP_PIO    0xf3
  556. #define TRUNCATE_XFR_PIO  0xf4
  557. #define RESET_PIO         0xf9
  558. #define READ_CONFIG_DMA   0xfd
  559. #define SET_CONFIG_DMA    0xfe
  560. #define SEND_CP_DMA       0xff
  561. #define ASOK              0x00
  562. #define ASST              0x01
  564. #define YESNO(a) ((a) ? 'y' : 'n')
  565. #define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
  567. /* "EATA", in Big Endian format */
  568. #define EATA_SIG_BE 0x45415441
  570. /* Number of valid bytes in the board config structure for EATA 2.0x */
  571. #define EATA_2_0A_SIZE 28
  572. #define EATA_2_0B_SIZE 30
  573. #define EATA_2_0C_SIZE 34
  575. /* Board info structure */
  576. struct eata_info {
  577.    u_int32_t data_len;  /* Number of valid bytes after this field */
  578.    u_int32_t sign;      /* ASCII "EATA" signature */
  580. #if defined(__BIG_ENDIAN_BITFIELD)
  581.    unchar version:4, :4;
  582.    unchar  haaval:1, ata:1, drqvld:1, dmasup:1, morsup:1, trnxfr:1, tarsup:1,
  583.            ocsena:1;
  584. #else
  585.    unchar        :4,    /* unused low nibble */
  586.           version:4;    /* EATA version, should be 0x1 */
  587.    unchar  ocsena:1,    /* Overlap Command Support Enabled */
  588.            tarsup:1,    /* Target Mode Supported */
  589.            trnxfr:1,    /* Truncate Transfer Cmd NOT Necessary */
  590.            morsup:1,    /* More Supported */
  591.            dmasup:1,    /* DMA Supported */
  592.            drqvld:1,    /* DRQ Index (DRQX) is valid */
  593.               ata:1,    /* This is an ATA device */
  594.            haaval:1;    /* Host Adapter Address Valid */
  595. #endif
  597.    ushort cp_pad_len;   /* Number of pad bytes after cp_len */
  598.    unchar host_addr[4]; /* Host Adapter SCSI ID for channels 3, 2, 1, 0 */
  599.    u_int32_t cp_len;    /* Number of valid bytes in cp */
  600.    u_int32_t sp_len;    /* Number of valid bytes in sp */
  601.    ushort queue_size;   /* Max number of cp that can be queued */
  602.    ushort unused;
  603.    ushort scatt_size;   /* Max number of entries in scatter/gather table */
  605. #if defined(__BIG_ENDIAN_BITFIELD)
  606.    unchar    drqx:2, second:1, irq_tr:1, irq:4;
  607.    unchar  sync;
  608.    unchar         :4, res1:1, large_sg:1, forcaddr:1, isaena:1;
  609.    unchar max_chan:3, max_id:5;
  610.    unchar   max_lun;
  611.    unchar     eisa:1, pci:1, idquest:1, m1:1, :4;
  612. #else
  613.    unchar     irq:4,    /* Interrupt Request assigned to this controller */
  614.            irq_tr:1,    /* 0 for edge triggered, 1 for level triggered */
  615.            second:1,    /* 1 if this is a secondary (not primary) controller */
  616.              drqx:2;    /* DRQ Index (0=DMA0, 1=DMA7, 2=DMA6, 3=DMA5) */
  617.    unchar  sync;        /* 1 if scsi target id 7...0 is running sync scsi */
  619.    /* Structure extension defined in EATA 2.0B */
  620.    unchar  isaena:1,    /* ISA i/o addressing is disabled/enabled */
  621.          forcaddr:1,    /* Port address has been forced */
  622.          large_sg:1,    /* 1 if large SG lists are supported */
  623.              res1:1,
  624.                  :4;
  625.    unchar  max_id:5,    /* Max SCSI target ID number */
  626.          max_chan:3;    /* Max SCSI channel number on this board */
  628.    /* Structure extension defined in EATA 2.0C */
  629.    unchar   max_lun;    /* Max SCSI LUN number */
  630.    unchar        :4,
  631.                m1:1,    /* This is a PCI with an M1 chip installed */
  632.           idquest:1,    /* RAIDNUM returned is questionable */
  633.               pci:1,    /* This board is PCI */
  634.              eisa:1;    /* This board is EISA */
  635. #endif
  637.    unchar   raidnum;    /* Uniquely identifies this HBA in a system */
  638.    unchar   notused;
  640.    ushort ipad[247];
  641.    };
  643. /* Board config structure */
  644. struct eata_config {
  645.    ushort len;          /* Number of bytes following this field */
  647. #if defined(__BIG_ENDIAN_BITFIELD)
  648.    unchar     :4, tarena:1, mdpena:1, ocena:1, edis:1;
  649. #else
  650.    unchar edis:1,       /* Disable EATA interface after config command */
  651.          ocena:1,       /* Overlapped Commands Enabled */
  652.         mdpena:1,       /* Transfer all Modified Data Pointer Messages */
  653.         tarena:1,       /* Target Mode Enabled for this controller */
  654.               :4;
  655. #endif
  657.    unchar cpad[511];
  658.    };
  660. /* Returned status packet structure */
  661. struct mssp {
  663. #if defined(__BIG_ENDIAN_BITFIELD)
  664.    unchar            eoc:1, adapter_status:7;
  665. #else
  666.    unchar adapter_status:7,    /* State related to current command */
  667.                      eoc:1;    /* End Of Command (1 = command completed) */
  668. #endif
  670.    unchar target_status;       /* SCSI status received after data transfer */
  671.    unchar unused[2];
  672.    u_int32_t inv_res_len;      /* Number of bytes not transferred */
  673.    u_int32_t cpp_index;        /* Index of address set in cp */
  674.    char mess[12];
  675.    };
  677. struct sg_list {
  678.    unsigned int address;                /* Segment Address */
  679.    unsigned int num_bytes;              /* Segment Length */
  680.    };
  682. /* MailBox SCSI Command Packet */
  683. struct mscp {
  685. #if defined(__BIG_ENDIAN_BITFIELD)
  686.    unchar     din:1, dout:1, interp:1, :1, sg:1, reqsen:1, init:1, sreset:1;
  687.    unchar sense_len;
  688.    unchar unused[3];
  689.    unchar        :7, fwnest:1;
  690.    unchar        :5, hbaci:1, iat:1, phsunit:1;
  691.    unchar channel:3, target:5;
  692.    unchar     one:1, dispri:1, luntar:1, lun:5;
  693. #else
  694.    unchar  sreset:1,     /* SCSI Bus Reset Signal should be asserted */
  695.              init:1,     /* Re-initialize controller and self test */
  696.            reqsen:1,     /* Transfer Request Sense Data to addr using DMA */
  697.                sg:1,     /* Use Scatter/Gather */
  698.                  :1,
  699.            interp:1,     /* The controller interprets cp, not the target */
  700.              dout:1,     /* Direction of Transfer is Out (Host to Target) */
  701.               din:1;     /* Direction of Transfer is In (Target to Host) */
  702.    unchar sense_len;     /* Request Sense Length */
  703.    unchar unused[3];
  704.    unchar  fwnest:1,     /* Send command to a component of an Array Group */
  705.                  :7;
  706.    unchar phsunit:1,     /* Send to Target Physical Unit (bypass RAID) */
  707.               iat:1,     /* Inhibit Address Translation */
  708.             hbaci:1,     /* Inhibit HBA Caching for this command */
  709.                  :5;
  710.    unchar  target:5,     /* SCSI target ID */
  711.           channel:3;     /* SCSI channel number */
  712.    unchar     lun:5,     /* SCSI logical unit number */
  713.            luntar:1,     /* This cp is for Target (not LUN) */
  714.            dispri:1,     /* Disconnect Privilege granted */
  715.               one:1;     /* 1 */
  716. #endif
  718.    unchar mess[3];       /* Massage to/from Target */
  719.    unchar cdb[12];       /* Command Descriptor Block */
  720.    u_int32_t data_len;   /* If sg=0 Data Length, if sg=1 sglist length */
  721.    u_int32_t cpp_index;  /* Index of address to be returned in sp */
  722.    u_int32_t data_address; /* If sg=0 Data Address, if sg=1 sglist address */
  723.    u_int32_t sp_dma_addr;  /* Address where sp is DMA'ed when cp completes */
  724.    u_int32_t sense_addr; /* Address where Sense Data is DMA'ed on error */
  726.    /* Additional fields begin here. */
  727.    Scsi_Cmnd *SCpnt;
  729.    /* All the cp structure is zero filled by queuecommand except the
  730.       following CP_TAIL_SIZE bytes, initialized by detect */
  731.    dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
  732.    struct sg_list *sglist; /* pointer to the allocated SG list */
  733.    };
  735. #define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
  737. struct hostdata {
  738.    struct mscp cp[MAX_MAILBOXES];       /* Mailboxes for this board */
  739.    unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
  740.    unsigned int last_cp_used;           /* Index of last mailbox used */
  741.    unsigned int iocount;                /* Total i/o done for this board */
  742.    int board_number;                    /* Number of this board */
  743.    char board_name[16];                 /* Name of this board */
  744.    int in_reset;                        /* True if board is doing a reset */
  745.    int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
  746.    int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */
  747.    unsigned int retries;                /* Number of internal retries */
  748.    unsigned long last_retried_pid;      /* Pid of last retried command */
  749.    unsigned char subversion;            /* Bus type, either ISA or EISA/PCI */
  750.    unsigned char protocol_rev;          /* EATA 2.0 rev., 'A' or 'B' or 'C' */
  751.    unsigned char is_pci;                /* TRUE is bus type is PCI */
  752.    struct pci_dev *pdev;                /* pdev for PCI bus, NULL otherwise */
  753.    struct mssp *sp_cpu_addr;            /* cpu addr for DMA buffer sp */
  754.    dma_addr_t sp_dma_addr;              /* dma handle for DMA buffer sp */
  755.    struct mssp sp;                      /* Local copy of sp buffer */
  756.    };
  758. static struct Scsi_Host *sh[MAX_BOARDS + 1];
  759. static const char *driver_name = "EATA";
  760. static char sha[MAX_BOARDS];
  762. /* Initialize num_boards so that ihdlr can work while detect is in progress */
  763. static unsigned int num_boards = MAX_BOARDS;
  765. static unsigned long io_port[] = {
  767.    /* Space for MAX_INT_PARAM ports usable while loading as a module */
  768.    SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
  769.    SKIP,    SKIP,
  771.    /* First ISA */
  772.    0x1f0,
  774.    /* Space for MAX_PCI ports possibly reported by PCI_BIOS */
  775.    SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
  776.    SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
  778.    /* MAX_EISA ports */
  779.    0x1c88, 0x2c88, 0x3c88, 0x4c88, 0x5c88, 0x6c88, 0x7c88, 0x8c88,
  780.    0x9c88, 0xac88, 0xbc88, 0xcc88, 0xdc88, 0xec88, 0xfc88,
  782.    /* Other (MAX_ISA - 1) ports */
  783.    0x170,  0x230,  0x330,
  785.    /* End of list */
  786.    0x0
  787.    };
  789. #define HD(board) ((struct hostdata *) &sh[board]->hostdata)
  790. #define BN(board) (HD(board)->board_name)
  792. /* Device is Big Endian */
  793. #define H2DEV(x)   cpu_to_be32(x)
  794. #define DEV2H(x)   be32_to_cpu(x)
  795. #define H2DEV16(x) cpu_to_be16(x)
  796. #define DEV2H16(x) be16_to_cpu(x)
  798. /* But transfer orientation from the 16 bit data register is Little Endian */
  799. #define REG2H(x)   le16_to_cpu(x)
  801. static void do_interrupt_handler(int, void *, struct pt_regs *);
  802. static void flush_dev(Scsi_Device *, unsigned long, unsigned int, unsigned int);
  803. static int do_trace = FALSE;
  804. static int setup_done = FALSE;
  805. static int link_statistics;
  806. static int tag_mode = TAG_MIXED;
  807. static int ext_tran = FALSE;
  808. static int rev_scan = TRUE;
  809. static char *boot_options;
  811. #if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE)
  812. static int tagged_comm = TRUE;
  813. #else
  814. static int tagged_comm = FALSE;
  815. #endif
  817. #if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS)
  818. static int linked_comm = TRUE;
  819. #else
  820. static int linked_comm = FALSE;
  821. #endif
  823. #if defined(CONFIG_SCSI_EATA_MAX_TAGS)
  824. static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS;
  825. #else
  826. static int max_queue_depth = MAX_CMD_PER_LUN;
  827. #endif
  829. #if defined(CONFIG_ISA)
  830. static int isa_probe = TRUE;
  831. #else
  832. static int isa_probe = FALSE;
  833. #endif
  835. #if defined(CONFIG_EISA)
  836. static int eisa_probe = TRUE;
  837. #else
  838. static int eisa_probe = FALSE;
  839. #endif
  841. #if defined(CONFIG_PCI)
  842. static int pci_probe = TRUE;
  843. #else
  844. static int pci_probe = FALSE;
  845. #endif
  847. static void select_queue_depths(struct Scsi_Host *host, Scsi_Device *devlist) {
  848.    Scsi_Device *dev;
  849.    int j, ntag = 0, nuntag = 0, tqd, utqd;
  851.    j = ((struct hostdata *) host->hostdata)->board_number;
  853.    for(dev = devlist; dev; dev = dev->next) {
  855.       if (dev->host != host) continue;
  857.       if (TLDEV(dev->type) && (dev->tagged_supported || linked_comm))
  858.          ntag++;
  859.       else
  860.          nuntag++;
  861.       }
  863.    utqd = MAX_CMD_PER_LUN;
  865.    tqd = (host->can_queue - utqd * nuntag) / (ntag ? ntag : 1);
  867.    if (tqd > max_queue_depth) tqd = max_queue_depth;
  869.    if (tqd < MAX_CMD_PER_LUN) tqd = MAX_CMD_PER_LUN;
  871.    for(dev = devlist; dev; dev = dev->next) {
  872.       char *tag_suffix = "", *link_suffix = "";
  874.       if (dev->host != host) continue;
  876.       if (TLDEV(dev->type) && (dev->tagged_supported || linked_comm))
  877.          dev->queue_depth = tqd;
  878.       else
  879.          dev->queue_depth = utqd;
  881.       if (TLDEV(dev->type)) {
  882.          if (linked_comm && dev->queue_depth > 2)
  883.             link_suffix = ", sorted";
  884.          else
  885.             link_suffix = ", unsorted";
  886.          }
  888.       if (tagged_comm && dev->tagged_supported && TLDEV(dev->type)) {
  889.          dev->tagged_queue = 1;
  890.          dev->current_tag = 1;
  891.          }
  893.       if (dev->tagged_supported && TLDEV(dev->type) && dev->tagged_queue)
  894.          tag_suffix = ", soft-tagged";
  895.       else if (dev->tagged_supported && TLDEV(dev->type))
  896.          tag_suffix = ", tagged";
  898.       printk("%s: scsi%d, channel %d, id %d, lun %d, cmds/lun %d%s%s.n",
  899.              BN(j), host->host_no, dev->channel, dev->id, dev->lun,
  900.              dev->queue_depth, link_suffix, tag_suffix);
  901.       }
  903.    return;
  904. }
  906. static inline int wait_on_busy(unsigned long iobase, unsigned int loop) {
  908.    while (inb(iobase + REG_AUX_STATUS) & ABSY_ASSERTED) {
  909.       udelay(1L);
  910.       if (--loop == 0) return TRUE;
  911.       }
  913.    return FALSE;
  914. }
  916. static inline int do_dma(unsigned long iobase, unsigned long addr, unchar cmd) {
  917.    unsigned char *byaddr;
  918.    unsigned long devaddr;
  920.    if (wait_on_busy(iobase, (addr ? MAXLOOP * 100 : MAXLOOP))) return TRUE;
  922.    if (addr) {
  923.       devaddr = H2DEV(addr);
  924.       byaddr = (unsigned char *) &devaddr;
  925.       outb(byaddr[3], iobase + REG_LOW);
  926.       outb(byaddr[2], iobase + REG_LM);
  927.       outb(byaddr[1], iobase + REG_MID);
  928.       outb(byaddr[0], iobase + REG_MSB);
  929.       }
  931.    outb(cmd, iobase + REG_CMD);
  932.    return FALSE;
  933. }
  935. static inline int read_pio(unsigned long iobase, ushort *start, ushort *end) {
  936.    unsigned int loop = MAXLOOP;
  937.    ushort *p;
  939.    for (p = start; p <= end; p++) {
  941.       while (!(inb(iobase + REG_STATUS) & DRQ_ASSERTED)) {
  942.          udelay(1L);
  943.          if (--loop == 0) return TRUE;
  944.          }
  946.       loop = MAXLOOP;
  947.       *p = REG2H(inw(iobase));
  948.       }
  950.    return FALSE;
  951. }
  953. static inline struct pci_dev *get_pci_dev(unsigned long port_base) {
  955. #if defined(CONFIG_PCI)
  957.    unsigned int addr;
  958.    struct pci_dev *dev = NULL;
  960.    if (!pci_present()) return NULL;
  962.    while((dev = pci_find_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
  963.       addr = pci_resource_start (dev, 0);
  965. #if defined(DEBUG_PCI_DETECT)
  966.       printk("%s: get_pci_dev, bus %d, devfn 0x%x, addr 0x%x.n",
  967.              driver_name, dev->bus->number, dev->devfn, addr);
  968. #endif
  970.       if (addr + PCI_BASE_ADDRESS_0 == port_base) return dev;
  971.       }
  973. #endif /* end CONFIG_PCI */
  975.    return NULL;
  976. }
  978. static void enable_pci_ports(void) {
  980. #if defined(CONFIG_PCI)
  982.    struct pci_dev *dev = NULL;
  984.    if (!pci_present()) return;
  986.    while((dev = pci_find_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
  988. #if defined(DEBUG_PCI_DETECT)
  989.       printk("%s: enable_pci_ports, bus %d, devfn 0x%x.n",
  990.              driver_name, dev->bus->number, dev->devfn);
  991. #endif
  993.       if (pci_enable_device (dev))
  994.          printk("%s: warning, pci_enable_device failed, bus %d devfn 0x%x.n",
  995.                 driver_name, dev->bus->number, dev->devfn);
  996.       }
  998. #endif /* end CONFIG_PCI */
  999. }
  1001. static inline int port_detect 
  1002.       (unsigned long port_base, unsigned int j, Scsi_Host_Template *tpnt) {
  1003.    unsigned char irq, dma_channel, subversion, i, is_pci = FALSE;
  1004.    unsigned char protocol_rev;
  1005.    struct eata_info info;
  1006.    char *bus_type, dma_name[16], tag_type;
  1007.    struct pci_dev *pdev;
  1009.    /* Allowed DMA channels for ISA (0 indicates reserved) */
  1010.    unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
  1012.    char name[16];
  1014.    sprintf(name, "%s%d", driver_name, j);
  1016.    if(!request_region(port_base, REGION_SIZE, driver_name)) {
  1017. #if defined(DEBUG_DETECT)
  1018.       printk("%s: address 0x%03lx in use, skipping probe.n", name, port_base);
  1019. #endif
  1020.       return FALSE;
  1021.       }
  1023.    if (do_dma(port_base, 0, READ_CONFIG_PIO)) {
  1024. #if defined(DEBUG_DETECT)
  1025.       printk("%s: detect, do_dma failed at 0x%03lx.n", name, port_base);
  1026. #endif
  1027.       release_region(port_base, REGION_SIZE);
  1028.       return FALSE;
  1029.       }
  1031.    /* Read the info structure */
  1032.    if (read_pio(port_base, (ushort *)&info, (ushort *)&info.ipad[0])) {
  1033. #if defined(DEBUG_DETECT)
  1034.       printk("%s: detect, read_pio failed at 0x%03lx.n", name, port_base);
  1035. #endif
  1036.       release_region(port_base, REGION_SIZE);
  1037.       return FALSE;
  1038.       }
  1040.    info.data_len = DEV2H(info.data_len);
  1041.    info.sign = DEV2H(info.sign);
  1042.    info.cp_pad_len = DEV2H16(info.cp_pad_len);
  1043.    info.cp_len = DEV2H(info.cp_len);
  1044.    info.sp_len = DEV2H(info.sp_len);
  1045.    info.scatt_size = DEV2H16(info.scatt_size);
  1046.    info.queue_size = DEV2H16(info.queue_size);
  1048.    /* Check the controller "EATA" signature */
  1049.    if (info.sign != EATA_SIG_BE) {
  1050. #if defined(DEBUG_DETECT)
  1051.       printk("%s: signature 0x%04x discarded.n", name, info.sign);
  1052. #endif
  1053.       release_region(port_base, REGION_SIZE);
  1054.       return FALSE;
  1055.       }
  1057.    if (info.data_len < EATA_2_0A_SIZE) {
  1058.       printk("%s: config structure size (%d bytes) too short, detaching.n",
  1059.              name, info.data_len);
  1060.       release_region(port_base, REGION_SIZE);
  1061.       return FALSE;
  1062.       }
  1063.    else if (info.data_len == EATA_2_0A_SIZE)
  1064.       protocol_rev = 'A';
  1065.    else if (info.data_len == EATA_2_0B_SIZE)
  1066.       protocol_rev = 'B';
  1067.    else
  1068.       protocol_rev = 'C';
  1070.    if (protocol_rev != 'A' && info.forcaddr) {
  1071.       printk("%s: warning, port address has been forced.n", name);
  1072.       bus_type = "PCI";
  1073.       is_pci = TRUE;
  1074.       subversion = ESA;
  1075.       }
  1076.    else if (port_base > MAX_EISA_ADDR || (protocol_rev == 'C' && info.pci)) {
  1077.       bus_type = "PCI";
  1078.       is_pci = TRUE;
  1079.       subversion = ESA;
  1080.       }
  1081.    else if (port_base >= MIN_EISA_ADDR || (protocol_rev == 'C' && info.eisa)) {
  1082.       bus_type = "EISA";
  1083.       subversion = ESA;
  1084.       }
  1085.    else if (protocol_rev == 'C' && !info.eisa && !info.pci) {
  1086.       bus_type = "ISA";
  1087.       subversion = ISA;
  1088.       }
  1089.    else if (port_base > MAX_ISA_ADDR) {
  1090.       bus_type = "PCI";
  1091.       is_pci = TRUE;
  1092.       subversion = ESA;
  1093.       }
  1094.    else {
  1095.       bus_type = "ISA";
  1096.       subversion = ISA;
  1097.       }
  1099.    if (!info.haaval || info.ata) {
  1100.       printk("%s: address 0x%03lx, unusable %s board (%d%d), detaching.n",
  1101.              name, port_base, bus_type, info.haaval, info.ata);
  1102.       release_region(port_base, REGION_SIZE);
  1103.       return FALSE;
  1104.       }
  1106.    if (info.drqvld) {
  1108.       if (subversion ==  ESA)
  1109.          printk("%s: warning, weird %s board using DMA.n", name, bus_type);
  1111.       subversion = ISA;
  1112.       dma_channel = dma_channel_table[3 - info.drqx];
  1113.       }
  1114.    else {
  1116.       if (subversion ==  ISA)
  1117.          printk("%s: warning, weird %s board not using DMA.n", name, bus_type);
  1119.       subversion = ESA;
  1120.       dma_channel = NO_DMA;
  1121.       }
  1123.    if (!info.dmasup)
  1124.       printk("%s: warning, DMA protocol support not asserted.n", name);
  1126.    irq = info.irq;
  1128.    if (subversion == ESA && !info.irq_tr)
  1129.       printk("%s: warning, LEVEL triggering is suggested for IRQ %u.n",
  1130.              name, irq);
  1132.    if (is_pci) {
  1133.       pdev = get_pci_dev(port_base);
  1134.       if (!pdev)
  1135.          printk("%s: warning, failed to get pci_dev structure.n", name);
  1136.       }
  1137.    else
  1138.       pdev = NULL;
  1140.    if (pdev && (irq != pdev->irq)) {
  1141.       printk("%s: IRQ %u mapped to IO-APIC IRQ %u.n", name, irq, pdev->irq);
  1142.       irq = pdev->irq;
  1143.       }
  1145.    /* Board detected, allocate its IRQ */
  1146.    if (request_irq(irq, do_interrupt_handler,
  1147.              SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0),
  1148.              driver_name, (void *) &sha[j])) {
  1149.       printk("%s: unable to allocate IRQ %u, detaching.n", name, irq);
  1150.       release_region(port_base, REGION_SIZE);
  1151.       return FALSE;
  1152.       }
  1154.    if (subversion == ISA && request_dma(dma_channel, driver_name)) {
  1155.       printk("%s: unable to allocate DMA channel %u, detaching.n",
  1156.              name, dma_channel);
  1157.       free_irq(irq, &sha[j]);
  1158.       release_region(port_base, REGION_SIZE);
  1159.       return FALSE;
  1160.       }
  1162. #if defined(FORCE_CONFIG)
  1163.    {
  1164.    struct eata_config *cf;
  1165.    dma_addr_t cf_dma_addr;
  1167.    cf = pci_alloc_consistent(pdev, sizeof(struct eata_config), &cf_dma_addr);
  1169.    if (!cf) {
  1170.       printk("%s: config, pci_alloc_consistent failed, detaching.n", name);
  1171.       release_region(port_base, REGION_SIZE);
  1172.       return FALSE;
  1173.       }
  1175.    /* Set board configuration */
  1176.    memset((char *)cf, 0, sizeof(struct eata_config));
  1177.    cf->len = (ushort) H2DEV16((ushort)510);
  1178.    cf->ocena = TRUE;
  1180.    if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
  1181.       printk("%s: busy timeout sending configuration, detaching.n", name);
  1182.       pci_free_consistent(pdev, sizeof(struct eata_config), cf, cf_dma_addr);
  1183.       release_region(port_base, REGION_SIZE);
  1184.       return FALSE;
  1185.       }
  1187.    }
  1188. #endif
  1190.    sh[j] = scsi_register(tpnt, sizeof(struct hostdata));
  1192.    if (sh[j] == NULL) {
  1193.       printk("%s: unable to register host, detaching.n", name);
  1195.       free_irq(irq, &sha[j]);
  1197.       if (subversion == ISA) free_dma(dma_channel);
  1199.       release_region(port_base, REGION_SIZE);
  1200.       return FALSE;
  1201.       }
  1203.    sh[j]->io_port = port_base;
  1204.    sh[j]->unique_id = port_base;
  1205.    sh[j]->n_io_port = REGION_SIZE;
  1206.    sh[j]->dma_channel = dma_channel;
  1207.    sh[j]->irq = irq;
  1208.    sh[j]->sg_tablesize = (ushort) info.scatt_size;
  1209.    sh[j]->this_id = (ushort) info.host_addr[3];
  1210.    sh[j]->can_queue = (ushort) info.queue_size;
  1211.    sh[j]->cmd_per_lun = MAX_CMD_PER_LUN;
  1212.    sh[j]->select_queue_depths = select_queue_depths;
  1213.    memset(HD(j), 0, sizeof(struct hostdata));
  1214.    HD(j)->subversion = subversion;
  1215.    HD(j)->protocol_rev = protocol_rev;
  1216.    HD(j)->is_pci = is_pci;
  1217.    HD(j)->pdev = pdev;
  1218.    HD(j)->board_number = j;
  1220.    if (HD(j)->subversion == ESA)
  1221.       sh[j]->unchecked_isa_dma = FALSE;
  1222.    else {
  1223.       unsigned long flags;
  1224.       scsi_register_blocked_host(sh[j]);
  1225.       sh[j]->unchecked_isa_dma = TRUE;
  1227.       flags=claim_dma_lock();
  1228.       disable_dma(dma_channel);
  1229.       clear_dma_ff(dma_channel);
  1230.       set_dma_mode(dma_channel, DMA_MODE_CASCADE);
  1231.       enable_dma(dma_channel);
  1232.       release_dma_lock(flags);
  1234.       }
  1236.    strcpy(BN(j), name);
  1238.    /* DPT PM2012 does not allow to detect sg_tablesize correctly */
  1239.    if (sh[j]->sg_tablesize > MAX_SGLIST || sh[j]->sg_tablesize < 2) {
  1240.       printk("%s: detect, wrong n. of SG lists %d, fixed.n",
  1241.              BN(j), sh[j]->sg_tablesize);
  1242.       sh[j]->sg_tablesize = MAX_SGLIST;
  1243.       }
  1245.    /* DPT PM2012 does not allow to detect can_queue correctly */
  1246.    if (sh[j]->can_queue > MAX_MAILBOXES || sh[j]->can_queue  < 2) {
  1247.       printk("%s: detect, wrong n. of mbox %d, fixed.n",
  1248.              BN(j), sh[j]->can_queue);
  1249.       sh[j]->can_queue = MAX_MAILBOXES;
  1250.       }
  1252.    if (protocol_rev != 'A') {
  1254.       if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
  1255.          sh[j]->max_channel = info.max_chan;
  1257.       if (info.max_id > 7 && info.max_id < MAX_TARGET)
  1258.          sh[j]->max_id = info.max_id + 1;
  1260.       if (info.large_sg && sh[j]->sg_tablesize == MAX_SGLIST)
  1261.          sh[j]->sg_tablesize = MAX_LARGE_SGLIST;
  1262.       }
  1264.    if (protocol_rev == 'C') {
  1266.       if (info.max_lun > 7 && info.max_lun < MAX_LUN)
  1267.          sh[j]->max_lun = info.max_lun + 1;
  1268.       }
  1270.    if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST");
  1271.    else                       sprintf(dma_name, "DMA %u", dma_channel);
  1273.    for (i = 0; i < sh[j]->can_queue; i++)
  1274.       HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev,
  1275.             &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
  1277.    for (i = 0; i < sh[j]->can_queue; i++)
  1278.       if (! ((&HD(j)->cp[i])->sglist = kmalloc(
  1279.             sh[j]->sg_tablesize * sizeof(struct sg_list),
  1280.             (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) {
  1281.          printk("%s: kmalloc SGlist failed, mbox %d, detaching.n", BN(j), i);
  1282.          eata2x_release(sh[j]);
  1283.          return FALSE;
  1284.          }
  1286.    if (! (HD(j)->sp_cpu_addr = pci_alloc_consistent(HD(j)->pdev,
  1287.          sizeof(struct mssp), &HD(j)->sp_dma_addr))) {
  1288.       printk("%s: pci_alloc_consistent failed, detaching.n", BN(j));
  1289.       eata2x_release(sh[j]);
  1290.       return FALSE;
  1291.       }
  1293.    if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
  1294.        max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
  1296.    if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN;
  1298.    if (tagged_comm) {
  1299.       if      (tag_mode == TAG_SIMPLE)  tag_type = '1';
  1300.       else if (tag_mode == TAG_HEAD)    tag_type = '2';
  1301.       else if (tag_mode == TAG_ORDERED) tag_type = '3';
  1302.       else                              tag_type = 'y';
  1303.       }
  1304.    else                                 tag_type = 'n';
  1306.    if (j == 0) {
  1307.       printk("EATA/DMA 2.0x: Copyright (C) 1994-2002 Dario Ballabio.n");
  1308.       printk("%s config options -> tc:%c, lc:%c, mq:%d, rs:%c, et:%c, "
  1309.              "ip:%c, ep:%c, pp:%c.n", driver_name, tag_type,
  1310.              YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
  1311.              YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
  1312.              YESNO(pci_probe));
  1313.       }
  1315.    printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.n",
  1316.           BN(j), HD(j)->protocol_rev, bus_type, (unsigned long)sh[j]->io_port,
  1317.           sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue);
  1319.    if (sh[j]->max_id > 8 || sh[j]->max_lun > 8)
  1320.       printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.n",
  1321.              BN(j), sh[j]->max_id, sh[j]->max_lun);
  1323.    for (i = 0; i <= sh[j]->max_channel; i++)
  1324.       printk("%s: SCSI channel %u enabled, host target ID %d.n",
  1325.              BN(j), i, info.host_addr[3 - i]);
  1327. #if defined(DEBUG_DETECT)
  1328.    printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
  1329.           "sec. %u, infol %d, cpl %d spl %d.n", name, info.version,
  1330.           info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
  1331.           info.second, info.data_len, info.cp_len,
  1332.           info.sp_len);
  1334.    if (protocol_rev == 'B' || protocol_rev == 'C')
  1335.       printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
  1336.              "large_sg %u, res1 %u.n", name, info.isaena, info.forcaddr,
  1337.              info.max_id, info.max_chan, info.large_sg, info.res1);
  1339.    if (protocol_rev == 'C')
  1340.       printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
  1341.              "raidnum %u.n", name, info.max_lun, info.m1, info.idquest,
  1342.              info.pci, info.eisa, info.raidnum);
  1343. #endif
  1345.    if (HD(j)->pdev) {
  1346.       pci_set_master(HD(j)->pdev);
  1347.       if (pci_set_dma_mask(HD(j)->pdev, 0xffffffff))
  1348.          printk("%s: warning, pci_set_dma_mask failed.n", BN(j));
  1349.       }
  1351.    return TRUE;
  1352. }
  1354. static void internal_setup(char *str, int *ints) {
  1355.    int i, argc = ints[0];
  1356.    char *cur = str, *pc;
  1358.    if (argc > 0) {
  1360.       if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM;
  1362.       for (i = 0; i < argc; i++) io_port[i] = ints[i + 1];
  1364.       io_port[i] = 0;
  1365.       setup_done = TRUE;
  1366.       }
  1368.    while (cur && (pc = strchr(cur, ':'))) {
  1369.       int val = 0, c = *++pc;
  1371.       if (c == 'n' || c == 'N') val = FALSE;
  1372.       else if (c == 'y' || c == 'Y') val = TRUE;
  1373.       else val = (int) simple_strtoul(pc, NULL, 0);
  1375.       if (!strncmp(cur, "lc:", 3)) linked_comm = val;
  1376.       else if (!strncmp(cur, "tc:", 3)) tagged_comm = val;
  1377.       else if (!strncmp(cur, "tm:", 3)) tag_mode = val;
  1378.       else if (!strncmp(cur, "mq:", 3))  max_queue_depth = val;
  1379.       else if (!strncmp(cur, "ls:", 3))  link_statistics = val;
  1380.       else if (!strncmp(cur, "et:", 3))  ext_tran = val;
  1381.       else if (!strncmp(cur, "rs:", 3))  rev_scan = val;
  1382.       else if (!strncmp(cur, "ip:", 3))  isa_probe = val;
  1383.       else if (!strncmp(cur, "ep:", 3))  eisa_probe = val;
  1384.       else if (!strncmp(cur, "pp:", 3))  pci_probe = val;
  1386.       if ((cur = strchr(cur, ','))) ++cur;
  1387.       }
  1389.    return;
  1390. }
  1392. static int option_setup(char *str) {
  1393.    int ints[MAX_INT_PARAM];
  1394.    char *cur = str;
  1395.    int i = 1;
  1397.    while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
  1398.       ints[i++] = simple_strtoul(cur, NULL, 0);
  1400.       if ((cur = strchr(cur, ',')) != NULL) cur++;
  1401.    }
  1403.    ints[0] = i - 1;
  1404.    internal_setup(cur, ints);
  1405.    return 1;
  1406. }
  1408. static void add_pci_ports(void) {
  1410. #if defined(CONFIG_PCI)
  1412.    unsigned int addr, k;
  1414.    struct pci_dev *dev = NULL;
  1416.    if (!pci_present()) return;
  1418.    for (k = 0; k < MAX_PCI; k++) {
  1420.       if (!(dev = pci_find_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) break;
  1422.       if (pci_enable_device (dev)) {
  1424. #if defined(DEBUG_PCI_DETECT)
  1425.          printk("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.n",
  1426.                 driver_name, dev->bus->number, dev->devfn);
  1427. #endif
  1429.          continue;
  1430.          }
  1432.       addr = pci_resource_start (dev, 0);
  1434. #if defined(DEBUG_PCI_DETECT)
  1435.       printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.n",
  1436.              driver_name, k, dev->bus->number, dev->devfn, addr);
  1437. #endif
  1439.       /* Order addresses according to rev_scan value */
  1440.       io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
  1441.              addr + PCI_BASE_ADDRESS_0;
  1442.       }
  1444. #endif /* end CONFIG_PCI */
  1446.    return;
  1447. }
  1449. int eata2x_detect(Scsi_Host_Template *tpnt) {
  1450.    unsigned int j = 0, k;
  1452.    tpnt->proc_name = "eata2x";
  1454.    if(boot_options) option_setup(boot_options);
  1456. #if defined(MODULE)
  1457.    /* io_port could have been modified when loading as a module */
  1458.    if(io_port[0] != SKIP) {
  1459.       setup_done = TRUE;
  1460.       io_port[MAX_INT_PARAM] = 0;
  1461.       }
  1462. #endif
  1464.    for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL;
  1466.    for (k = MAX_INT_PARAM; io_port[k]; k++)
  1467.       if (io_port[k] == SKIP) continue;
  1468.       else if (io_port[k] <= MAX_ISA_ADDR) {
  1469.          if (!isa_probe) io_port[k] = SKIP;
  1470.          }
  1471.       else if (io_port[k] >= MIN_EISA_ADDR && io_port[k] <= MAX_EISA_ADDR) {
  1472.          if (!eisa_probe) io_port[k] = SKIP;
  1473.          }
  1475.    if (pci_probe) {
  1476.       if (!setup_done) add_pci_ports();
  1477.       else          enable_pci_ports();
  1478.       }
  1480.    for (k = 0; io_port[k]; k++) {
  1482.       if (io_port[k] == SKIP) continue;
  1484.       if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++;
  1485.       }
  1487.    num_boards = j;
  1488.    return j;
  1489. }
  1491. static inline void map_dma(unsigned int i, unsigned int j) {
  1492.    unsigned int k, count, pci_dir;
  1493.    struct scatterlist *sgpnt;
  1494.    struct mscp *cpp;
  1495.    Scsi_Cmnd *SCpnt;
  1497.    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
  1498.    pci_dir = scsi_to_pci_dma_dir(SCpnt->sc_data_direction);
  1500.    if (SCpnt->sense_buffer)
  1501.       cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer,
  1502.                            sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE));
  1504.    cpp->sense_len = sizeof SCpnt->sense_buffer;
  1506.    if (!SCpnt->use_sg) {
  1508.       /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */
  1509.       if (!SCpnt->request_bufflen) pci_dir = PCI_DMA_BIDIRECTIONAL;
  1511.       if (SCpnt->request_buffer)
  1512.          cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev,
  1513.                   SCpnt->request_buffer, SCpnt->request_bufflen, pci_dir));
  1515.       cpp->data_len = H2DEV(SCpnt->request_bufflen);
  1516.       return;
  1517.       }
  1519.    sgpnt = (struct scatterlist *) SCpnt->request_buffer;
  1520.    count = pci_map_sg(HD(j)->pdev, sgpnt, SCpnt->use_sg, pci_dir);
  1522.    for (k = 0; k < count; k++) {
  1523.       cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k]));
  1524.       cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k]));
  1525.       }
  1527.    cpp->sg = TRUE;
  1528.    cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist,
  1529.                              SCpnt->use_sg * sizeof(struct sg_list), pci_dir));
  1530.    cpp->data_len = H2DEV((SCpnt->use_sg * sizeof(struct sg_list)));
  1531. }
  1533. static void unmap_dma(unsigned int i, unsigned int j) {
  1534.    unsigned int pci_dir;
  1535.    struct mscp *cpp;
  1536.    Scsi_Cmnd *SCpnt;
  1538.    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
  1539.    pci_dir = scsi_to_pci_dma_dir(SCpnt->sc_data_direction);
  1541.    if (DEV2H(cpp->sense_addr))
  1542.       pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
  1543.                        DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
  1545.    if (SCpnt->use_sg)
  1546.       pci_unmap_sg(HD(j)->pdev, SCpnt->request_buffer, SCpnt->use_sg, pci_dir);
  1548.    if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
  1550.    if (DEV2H(cpp->data_address))
  1551.       pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address),
  1552.                        DEV2H(cpp->data_len), pci_dir);
  1553. }
  1555. static void sync_dma(unsigned int i, unsigned int j) {
  1556.    unsigned int pci_dir;
  1557.    struct mscp *cpp;
  1558.    Scsi_Cmnd *SCpnt;
  1560.    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
  1561.    pci_dir = scsi_to_pci_dma_dir(SCpnt->sc_data_direction);
  1563.    if (DEV2H(cpp->sense_addr))
  1564.       pci_dma_sync_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
  1565.                           DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
  1567.    if (SCpnt->use_sg)
  1568.       pci_dma_sync_sg(HD(j)->pdev, SCpnt->request_buffer,
  1569.                          SCpnt->use_sg, pci_dir);
  1571.    if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
  1573.    if (DEV2H(cpp->data_address))
  1574.       pci_dma_sync_single(HD(j)->pdev, DEV2H(cpp->data_address),
  1575.                        DEV2H(cpp->data_len), pci_dir);
  1576. }
  1578. static inline void scsi_to_dev_dir(unsigned int i, unsigned int j) {
  1579.    unsigned int k;
  1581.    static const unsigned char data_out_cmds[] = {
  1582.       0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
  1583.       0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
  1584.       0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
  1585.       };
  1587.    static const unsigned char data_none_cmds[] = {
  1588.       0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
  1589.       0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
  1590.       0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
  1591.       };
  1593.    struct mscp *cpp;
  1594.    Scsi_Cmnd *SCpnt;
  1596.    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
  1598.    if (SCpnt->sc_data_direction == SCSI_DATA_READ) {
  1599.       cpp->din  = TRUE;
  1600.       cpp->dout = FALSE;
  1601.       return;
  1602.       }
  1603.    else if (SCpnt->sc_data_direction == SCSI_DATA_WRITE) {
  1604.       cpp->din  = FALSE;
  1605.       cpp->dout = TRUE;
  1606.       return;
  1607.       }
  1608.    else if (SCpnt->sc_data_direction == SCSI_DATA_NONE) {
  1609.       cpp->din  = FALSE;
  1610.       cpp->dout = FALSE;
  1611.       return;
  1612.       }
  1614.    if (SCpnt->sc_data_direction != SCSI_DATA_UNKNOWN)
  1615.       panic("%s: qcomm, invalid SCpnt->sc_data_direction.n", BN(j));
  1617.    for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
  1618.       if (SCpnt->cmnd[0] == data_out_cmds[k]) {
  1619.          cpp->dout = TRUE;
  1620.          break;
  1621.          }
  1623.    if ((cpp->din = !cpp->dout))
  1624.       for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
  1625.          if (SCpnt->cmnd[0] == data_none_cmds[k]) {
  1626.             cpp->din = FALSE;
  1627.             break;
  1628.             }
  1630. }
  1632. static inline int do_qcomm(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
  1633.    unsigned int i, j, k;
  1634.    struct mscp *cpp;
  1636.    /* j is the board number */
  1637.    j = ((struct hostdata *) SCpnt->host->hostdata)->board_number;
  1639.    if (SCpnt->host_scribble)
  1640.       panic("%s: qcomm, pid %ld, SCpnt %p already active.n",
  1641.             BN(j), SCpnt->pid, SCpnt);
  1643.    /* i is the mailbox number, look for the first free mailbox
  1644.       starting from last_cp_used */
  1645.    i = HD(j)->last_cp_used + 1;
  1647.    for (k = 0; k < sh[j]->can_queue; k++, i++) {
  1649.       if (i >= sh[j]->can_queue) i = 0;
  1651.       if (HD(j)->cp_stat[i] == FREE) {
  1652.          HD(j)->last_cp_used = i;
  1653.          break;
  1654.          }
  1655.       }
  1657.    if (k == sh[j]->can_queue) {
  1658.       printk("%s: qcomm, no free mailbox.n", BN(j));
  1659.       return 1;
  1660.       }
  1662.    /* Set pointer to control packet structure */
  1663.    cpp = &HD(j)->cp[i];
  1665.    memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
  1667.    /* Set pointer to status packet structure, Big Endian format */
  1668.    cpp->sp_dma_addr = H2DEV(HD(j)->sp_dma_addr);
  1670.    SCpnt->scsi_done = done;
  1671.    cpp->cpp_index = i;
  1672.    SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
  1674.    if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.n",
  1675.                         BN(j), i, SCpnt->channel, SCpnt->target,
  1676.                         SCpnt->lun, SCpnt->pid);
  1678.    cpp->reqsen = TRUE;
  1679.    cpp->dispri = TRUE;
  1680. #if 0
  1681.    if (SCpnt->device->type == TYPE_TAPE) cpp->hbaci = TRUE;
  1682. #endif
  1683.    cpp->one = TRUE;
  1684.    cpp->channel = SCpnt->channel;
  1685.    cpp->target = SCpnt->target;
  1686.    cpp->lun = SCpnt->lun;
  1687.    cpp->SCpnt = SCpnt;
  1688.    memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
  1690.    /* Use data transfer direction SCpnt->sc_data_direction */
  1691.    scsi_to_dev_dir(i, j);
  1693.    /* Map DMA buffers and SG list */
  1694.    map_dma(i, j);
  1696.    if (SCpnt->device->tagged_queue) {
  1698.       if (HD(j)->target_redo[SCpnt->target][SCpnt->channel] ||
  1699.             HD(j)->target_to[SCpnt->target][SCpnt->channel])
  1700.          cpp->mess[0] = ORDERED_QUEUE_TAG;
  1701.       else if (tag_mode == TAG_SIMPLE)  cpp->mess[0] = SIMPLE_QUEUE_TAG;
  1702.       else if (tag_mode == TAG_HEAD)    cpp->mess[0] = HEAD_OF_QUEUE_TAG;
  1703.       else if (tag_mode == TAG_ORDERED) cpp->mess[0] = ORDERED_QUEUE_TAG;
  1704.       else if (SCpnt->device->current_tag == 0)
  1705.          cpp->mess[0] = ORDERED_QUEUE_TAG;
  1706.       else if (SCpnt->device->current_tag == 1)
  1707.          cpp->mess[0] = HEAD_OF_QUEUE_TAG;
  1708.       else
  1709.          cpp->mess[0] = SIMPLE_QUEUE_TAG;
  1711.       cpp->mess[1] = SCpnt->device->current_tag++;
  1712.       }
  1714.    if (linked_comm && SCpnt->device->queue_depth > 2
  1715.                                      && TLDEV(SCpnt->device->type)) {
  1716.       HD(j)->cp_stat[i] = READY;
  1717.       flush_dev(SCpnt->device, SCpnt->request.sector, j, FALSE);
  1718.       return 0;
  1719.       }
  1721.    /* Send control packet to the board */
  1722.    if (do_dma(sh[j]->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
  1723.       unmap_dma(i, j);
  1724.       SCpnt->host_scribble = NULL;
  1725.       printk("%s: qcomm, target %d.%d:%d, pid %ld, adapter busy.n",
  1726.              BN(j), SCpnt->channel, SCpnt->target, SCpnt->lun, SCpnt->pid);
  1727.       return 1;
  1728.       }
  1730.    HD(j)->cp_stat[i] = IN_USE;
  1731.    return 0;
  1732. }
  1734. int eata2x_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
  1735.    int rtn;
  1737.    rtn = do_qcomm(SCpnt, done);
  1738.    return rtn;
  1739. }
  1741. static inline int do_abort(Scsi_Cmnd *SCarg) {
  1742.    unsigned int i, j;
  1744.    j = ((struct hostdata *) SCarg->host->hostdata)->board_number;
  1746.    if (SCarg->host_scribble == NULL) {
  1747.       printk("%s: abort, target %d.%d:%d, pid %ld inactive.n",
  1748.              BN(j), SCarg->channel, SCarg->target, SCarg->lun, SCarg->pid);
  1749.       return SUCCESS;
  1750.       }
  1752.    i = *(unsigned int *)SCarg->host_scribble;
  1753.    printk("%s: abort, mbox %d, target %d.%d:%d, pid %ld.n",
  1754.           BN(j), i, SCarg->channel, SCarg->target, SCarg->lun, SCarg->pid);
  1756.    if (i >= sh[j]->can_queue)
  1757.       panic("%s: abort, invalid SCarg->host_scribble.n", BN(j));
  1759.    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
  1760.       printk("%s: abort, timeout error.n", BN(j));
  1761.       return FAILED;
  1762.       }
  1764.    if (HD(j)->cp_stat[i] == FREE) {
  1765.       printk("%s: abort, mbox %d is free.n", BN(j), i);
  1766.       return SUCCESS;
  1767.       }
  1769.    if (HD(j)->cp_stat[i] == IN_USE) {
  1770.       printk("%s: abort, mbox %d is in use.n", BN(j), i);
  1772.       if (SCarg != HD(j)->cp[i].SCpnt)
  1773.          panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.n",
  1774.                BN(j), i, SCarg, HD(j)->cp[i].SCpnt);
  1776.       if (inb(sh[j]->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
  1777.          printk("%s: abort, mbox %d, interrupt pending.n", BN(j), i);
  1779.       if (SCarg->eh_state == SCSI_STATE_TIMEOUT) {
  1780.          unmap_dma(i, j);
  1781.          SCarg->host_scribble = NULL;
  1782.          HD(j)->cp_stat[i] = FREE;
  1783.          printk("%s, abort, mbox %d, eh_state timeout, pid %ld.n",
  1784.                 BN(j), i, SCarg->pid);
  1785.          return SUCCESS;
  1786.          }
  1788.       return FAILED;
  1789.       }
  1791.    if (HD(j)->cp_stat[i] == IN_RESET) {
  1792.       printk("%s: abort, mbox %d is in reset.n", BN(j), i);
  1793.       return FAILED;
  1794.       }
  1796.    if (HD(j)->cp_stat[i] == LOCKED) {
  1797.       printk("%s: abort, mbox %d is locked.n", BN(j), i);
  1798.       return SUCCESS;
  1799.       }
  1801.    if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
  1802.       unmap_dma(i, j);
  1803.       SCarg->result = DID_ABORT << 16;
  1804.       SCarg->host_scribble = NULL;
  1805.       HD(j)->cp_stat[i] = FREE;
  1806.       printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.n",
  1807.              BN(j), i, SCarg->pid);
  1808.       SCarg->scsi_done(SCarg);
  1809.       return SUCCESS;
  1810.       }
  1812.    panic("%s: abort, mbox %d, invalid cp_stat.n", BN(j), i);
  1813. }
  1815. int eata2x_abort(Scsi_Cmnd *SCarg) {
  1817.    return do_abort(SCarg);
  1818. }
  1820. static inline int do_reset(Scsi_Cmnd *SCarg) {
  1821.    unsigned int i, j, time, k, c, limit = 0;
  1822.    int arg_done = FALSE;
  1823.    Scsi_Cmnd *SCpnt;
  1825.    j = ((struct hostdata *) SCarg->host->hostdata)->board_number;
  1826.    printk("%s: reset, enter, target %d.%d:%d, pid %ld.n",
  1827.           BN(j), SCarg->channel, SCarg->target, SCarg->lun, SCarg->pid);
  1829.    if (SCarg->host_scribble == NULL)
  1830.       printk("%s: reset, pid %ld inactive.n", BN(j), SCarg->pid);
  1832.    if (HD(j)->in_reset) {
  1833.       printk("%s: reset, exit, already in reset.n", BN(j));
  1834.       return FAILED;
  1835.       }
  1837.    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
  1838.       printk("%s: reset, exit, timeout error.n", BN(j));
  1839.       return FAILED;
  1840.       }
  1842.    HD(j)->retries = 0;
  1844.    for (c = 0; c <= sh[j]->max_channel; c++)
  1845.       for (k = 0; k < sh[j]->max_id; k++) {
  1846.          HD(j)->target_redo[k][c] = TRUE;
  1847.          HD(j)->target_to[k][c] = 0;
  1848.          }
  1850.    for (i = 0; i < sh[j]->can_queue; i++) {
  1852.       if (HD(j)->cp_stat[i] == FREE) continue;
  1854.       if (HD(j)->cp_stat[i] == LOCKED) {
  1855.          HD(j)->cp_stat[i] = FREE;
  1856.          printk("%s: reset, locked mbox %d forced free.n", BN(j), i);
  1857.          continue;
  1858.          }
  1860.       if (!(SCpnt = HD(j)->cp[i].SCpnt))
  1861.          panic("%s: reset, mbox %d, SCpnt == NULL.n", BN(j), i);
  1863.       if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
  1864.          HD(j)->cp_stat[i] = ABORTING;
  1865.          printk("%s: reset, mbox %d aborting, pid %ld.n",
  1866.                 BN(j), i, SCpnt->pid);
  1867.          }
  1869.       else {
  1870.          HD(j)->cp_stat[i] = IN_RESET;
  1871.          printk("%s: reset, mbox %d in reset, pid %ld.n",
  1872.                 BN(j), i, SCpnt->pid);
  1873.          }
  1875.       if (SCpnt->host_scribble == NULL)
  1876.          panic("%s: reset, mbox %d, garbled SCpnt.n", BN(j), i);
  1878.       if (*(unsigned int *)SCpnt->host_scribble != i)
  1879.          panic("%s: reset, mbox %d, index mismatch.n", BN(j), i);
  1881.       if (SCpnt->scsi_done == NULL)
  1882.          panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.n", BN(j), i);
  1884.       if (SCpnt == SCarg) arg_done = TRUE;
  1885.       }
  1887.    if (do_dma(sh[j]->io_port, 0, RESET_PIO)) {
  1888.       printk("%s: reset, cannot reset, timeout error.n", BN(j));
  1889.       return FAILED;
  1890.       }
  1892.    printk("%s: reset, board reset done, enabling interrupts.n", BN(j));
  1894. #if defined(DEBUG_RESET)
  1895.    do_trace = TRUE;
  1896. #endif
  1898.    HD(j)->in_reset = TRUE;
  1900.    spin_unlock_irq(&io_request_lock);
  1901.    time = jiffies;
  1902.    while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L);
  1903.    spin_lock_irq(&io_request_lock);
  1905.    printk("%s: reset, interrupts disabled, loops %d.n", BN(j), limit);
  1907.    for (i = 0; i < sh[j]->can_queue; i++) {
  1909.       if (HD(j)->cp_stat[i] == IN_RESET) {
  1910.          SCpnt = HD(j)->cp[i].SCpnt;
  1911.          unmap_dma(i, j);
  1912.          SCpnt->result = DID_RESET << 16;
  1913.          SCpnt->host_scribble = NULL;
  1915.          /* This mailbox is still waiting for its interrupt */
  1916.          HD(j)->cp_stat[i] = LOCKED;
  1918.          printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.n",
  1919.                 BN(j), i, SCpnt->pid);
  1920.          }
  1922.       else if (HD(j)->cp_stat[i] == ABORTING) {
  1923.          SCpnt = HD(j)->cp[i].SCpnt;
  1924.          unmap_dma(i, j);
  1925.          SCpnt->result = DID_RESET << 16;
  1926.          SCpnt->host_scribble = NULL;
  1928.          /* This mailbox was never queued to the adapter */
  1929.          HD(j)->cp_stat[i] = FREE;
  1931.          printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.n",
  1932.                 BN(j), i, SCpnt->pid);
  1933.          }
  1935.       else
  1937.          /* Any other mailbox has already been set free by interrupt */
  1938.          continue;
  1940.       SCpnt->scsi_done(SCpnt);
  1941.       }
  1943.    HD(j)->in_reset = FALSE;
  1944.    do_trace = FALSE;
  1946.    if (arg_done) printk("%s: reset, exit, pid %ld done.n", BN(j), SCarg->pid);
  1947.    else          printk("%s: reset, exit.n", BN(j));
  1949.    return SUCCESS;
  1950. }
  1952. int eata2x_reset(Scsi_Cmnd *SCarg) {
  1954.    return do_reset(SCarg);
  1955. }
  1957. int eata2x_biosparam(Disk *disk, kdev_t dev, int *dkinfo) {
  1958.    int size = disk->capacity;
  1960.    if (ext_tran || (scsicam_bios_param(disk, dev, dkinfo) < 0)) {
  1961.       dkinfo[0] = 255;
  1962.       dkinfo[1] = 63;
  1963.       dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
  1964.       }
  1966. #if defined (DEBUG_GEOMETRY)
  1967.    printk ("%s: biosparam, head=%d, sec=%d, cyl=%d.n", driver_name,
  1968.            dkinfo[0], dkinfo[1], dkinfo[2]);
  1969. #endif
  1971.    return FALSE;
  1972. }
  1974. static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
  1975.                  unsigned int rev) {
  1976.    unsigned int i, j, k, y;
  1977.    unsigned long x;
  1979.    for (i = 0; i < n - 1; i++) {
  1980.       k = i;
  1982.       for (j = k + 1; j < n; j++)
  1983.          if (rev) {
  1984.             if (sk[j] > sk[k]) k = j;
  1985.             }
  1986.          else {
  1987.             if (sk[j] < sk[k]) k = j;
  1988.             }
  1990.       if (k != i) {
  1991.          x = sk[k]; sk[k] = sk[i]; sk[i] = x;
  1992.          y = da[k]; da[k] = da[i]; da[i] = y;
  1993.          }
  1994.       }
  1996.    return;
  1997.    }
  1999. static inline int reorder(unsigned int j, unsigned long cursec,
  2000.                  unsigned int ihdlr, unsigned int il[], unsigned int n_ready) {
  2001.    Scsi_Cmnd *SCpnt;
  2002.    struct mscp *cpp;
  2003.    unsigned int k, n;
  2004.    unsigned int rev = FALSE, s = TRUE, r = TRUE;
  2005.    unsigned int input_only = TRUE, overlap = FALSE;
  2006.    unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
  2007.    unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
  2008.    unsigned long ioseek = 0;
  2010.    static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
  2011.    static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
  2012.    static unsigned int readysorted = 0, revcount = 0;
  2013.    static unsigned long seeksorted = 0, seeknosort = 0;
  2015.    if (link_statistics && !(++flushcount % link_statistics))
  2016.       printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
  2017.              " av %ldK as %ldK.n", flushcount, batchcount, inputcount,
  2018.              ovlcount, readycount, readysorted, sortcount, revcount,
  2019.              seeknosort / (readycount + 1),
  2020.              seeksorted / (readycount + 1));
  2022.    if (n_ready <= 1) return FALSE;
  2024.    for (n = 0; n < n_ready; n++) {
  2025.       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
  2027.       if (!cpp->din) input_only = FALSE;
  2029.       if (SCpnt->request.sector < minsec) minsec = SCpnt->request.sector;
  2030.       if (SCpnt->request.sector > maxsec) maxsec = SCpnt->request.sector;
  2032.       sl[n] = SCpnt->request.sector;
  2033.       ioseek += SCpnt->request.nr_sectors;
  2035.       if (!n) continue;
  2037.       if (sl[n] < sl[n - 1]) s = FALSE;
  2038.       if (sl[n] > sl[n - 1]) r = FALSE;
  2040.       if (link_statistics) {
  2041.          if (sl[n] > sl[n - 1])
  2042.             seek += sl[n] - sl[n - 1];
  2043.          else
  2044.             seek += sl[n - 1] - sl[n];
  2045.          }
  2047.       }
  2049.    if (link_statistics) {
  2050.       if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec;
  2051.       }
  2053.    if (cursec > ((maxsec + minsec) / 2)) rev = TRUE;
  2055.    if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE;
  2057.    if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev);
  2059.    if (!input_only) for (n = 0; n < n_ready; n++) {
  2060.       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
  2061.       ll[n] = SCpnt->request.nr_sectors; pl[n] = SCpnt->pid;
  2063.       if (!n) continue;
  2065.       if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
  2066.           || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE;
  2067.       }
  2069.    if (overlap) sort(pl, il, n_ready, FALSE);
  2071.    if (link_statistics) {
  2072.       if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec;
  2073.       batchcount++; readycount += n_ready; seeknosort += seek / 1024;
  2074.       if (input_only) inputcount++;
  2075.       if (overlap) { ovlcount++; seeksorted += iseek / 1024; }
  2076.       else seeksorted += (iseek + maxsec - minsec) / 1024;
  2077.       if (rev && !r)     {  revcount++; readysorted += n_ready; }
  2078.       if (!rev && !s)    { sortcount++; readysorted += n_ready; }
  2079.       }
  2081. #if defined(DEBUG_LINKED_COMMANDS)
  2082.    if (link_statistics && (overlap || !(flushcount % link_statistics)))
  2083.       for (n = 0; n < n_ready; n++) {
  2084.          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
  2085.          printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"
  2086.                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.n",
  2087.                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
  2088.                 SCpnt->lun, SCpnt->pid, k, flushcount, n_ready,
  2089.                 SCpnt->request.sector, SCpnt->request.nr_sectors, cursec,
  2090.                 YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
  2091.                 YESNO(overlap), cpp->din);
  2092.          }
  2093. #endif
  2094.    return overlap;
  2095. }
  2097. static void flush_dev(Scsi_Device *dev, unsigned long cursec, unsigned int j,
  2098.                       unsigned int ihdlr) {
  2099.    Scsi_Cmnd *SCpnt;
  2100.    struct mscp *cpp;
  2101.    unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
  2103.    for (k = 0; k < sh[j]->can_queue; k++) {
  2105.       if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue;
  2107.       cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
  2109.       if (SCpnt->device != dev) continue;
  2111.       if (HD(j)->cp_stat[k] == IN_USE) return;
  2113.       il[n_ready++] = k;
  2114.       }
  2116.    if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1;
  2118.    for (n = 0; n < n_ready; n++) {
  2119.       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
  2121.       if (do_dma(sh[j]->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
  2122.          printk("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"
  2123.                 " busy, will abort.n", BN(j), (ihdlr ? "ihdlr" : "qcomm"),
  2124.                 SCpnt->channel, SCpnt->target, SCpnt->lun, SCpnt->pid, k);
  2125.          HD(j)->cp_stat[k] = ABORTING;
  2126.          continue;
  2127.          }
  2129.       HD(j)->cp_stat[k] = IN_USE;
  2130.       }
  2132. }
  2134. static inline void ihdlr(int irq, unsigned int j) {
  2135.    Scsi_Cmnd *SCpnt;
  2136.    unsigned int i, k, c, status, tstatus, reg;
  2137.    struct mssp *spp;
  2138.    struct mscp *cpp;
  2140.    if (sh[j]->irq != irq)
  2141.        panic("%s: ihdlr, irq %d, sh[j]->irq %d.n", BN(j), irq, sh[j]->irq);
  2143.    /* Check if this board need to be serviced */
  2144.    if (!(inb(sh[j]->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)) return;
  2146.    HD(j)->iocount++;
  2148.    if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.n", BN(j), irq,
  2149.                         HD(j)->iocount);
  2151.    /* Check if this board is still busy */
  2152.    if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) {
  2153.       reg = inb(sh[j]->io_port + REG_STATUS);
  2154.       printk("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.n",
  2155.              BN(j), irq, reg, HD(j)->iocount);
  2156.       return;
  2157.       }
  2159.    spp  = &HD(j)->sp;
  2161.    /* Make a local copy just before clearing the interrupt indication */
  2162.    memcpy(spp, HD(j)->sp_cpu_addr, sizeof(struct mssp));
  2164.    /* Clear the completion flag and cp pointer on the dynamic copy of sp */
  2165.    memset(HD(j)->sp_cpu_addr, 0, sizeof(struct mssp));
  2167.    /* Read the status register to clear the interrupt indication */
  2168.    reg = inb(sh[j]->io_port + REG_STATUS);
  2170. #if defined (DEBUG_INTERRUPT)
  2171.    {
  2172.    unsigned char *bytesp;
  2173.    int cnt;
  2174.    bytesp= (unsigned char *) spp;
  2175.    if (HD(j)->iocount < 200) {
  2176.       printk("sp[] =");
  2177.       for (cnt=0; cnt < 15; cnt++) printk(" 0x%x", bytesp[cnt]);
  2178.       printk("n");
  2179.       }
  2180.    }
  2181. #endif
  2183.    /* Reject any sp with supspect data */
  2184.    if (spp->eoc == FALSE && HD(j)->iocount > 1)
  2185.       printk("%s: ihdlr, spp->eoc == FALSE, irq %d, reg 0x%x, count %d.n",
  2186.              BN(j), irq, reg, HD(j)->iocount);
  2187.    if (spp->cpp_index < 0 || spp->cpp_index >= sh[j]->can_queue)
  2188.       printk("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.n",
  2189.              BN(j), spp->cpp_index, irq, reg, HD(j)->iocount);
  2190.    if (spp->eoc == FALSE || spp->cpp_index < 0
  2191.                          || spp->cpp_index >= sh[j]->can_queue) return;
  2193.    /* Find the mailbox to be serviced on this board */
  2194.    i = spp->cpp_index;
  2196.    cpp = &(HD(j)->cp[i]);
  2198. #if defined(DEBUG_GENERATE_ABORTS)
  2199.    if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) return;
  2200. #endif
  2202.    if (HD(j)->cp_stat[i] == IGNORE) {
  2203.       HD(j)->cp_stat[i] = FREE;
  2204.       return;
  2205.       }
  2206.    else if (HD(j)->cp_stat[i] == LOCKED) {
  2207.       HD(j)->cp_stat[i] = FREE;
  2208.       printk("%s: ihdlr, mbox %d unlocked, count %d.n", BN(j), i,
  2209.              HD(j)->iocount);
  2210.       return;
  2211.       }
  2212.    else if (HD(j)->cp_stat[i] == FREE) {
  2213.       printk("%s: ihdlr, mbox %d is free, count %d.n", BN(j), i,
  2214.              HD(j)->iocount);
  2215.       return;
  2216.       }
  2217.    else if (HD(j)->cp_stat[i] == IN_RESET)
  2218.       printk("%s: ihdlr, mbox %d is in reset.n", BN(j), i);
  2219.    else if (HD(j)->cp_stat[i] != IN_USE)
  2220.       panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.n",
  2221.             BN(j), i, HD(j)->cp_stat[i]);
  2223.    HD(j)->cp_stat[i] = FREE;
  2224.    SCpnt = cpp->SCpnt;
  2226.    if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.n", BN(j), i);
  2228.    if (SCpnt->host_scribble == NULL)
  2229.       panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.n", BN(j), i,
  2230.             SCpnt->pid, SCpnt);
  2232.    if (*(unsigned int *)SCpnt->host_scribble != i)
  2233.       panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.n",
  2234.             BN(j), i, SCpnt->pid, *(unsigned int *)SCpnt->host_scribble);
  2236.    sync_dma(i, j);
  2238.    if (linked_comm && SCpnt->device->queue_depth > 2
  2239.                                      && TLDEV(SCpnt->device->type))
  2240.       flush_dev(SCpnt->device, SCpnt->request.sector, j, TRUE);
  2242.    tstatus = status_byte(spp->target_status);
  2244. #if defined(DEBUG_GENERATE_ERRORS)
  2245.    if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2))
  2246.                                            spp->adapter_status = 0x01;
  2247. #endif
  2249.    switch (spp->adapter_status) {
  2250.       case ASOK:     /* status OK */
  2252.          /* Forces a reset if a disk drive keeps returning BUSY */
  2253.          if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
  2254.             status = DID_ERROR << 16;
  2256.          /* If there was a bus reset, redo operation on each target */
  2257.          else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
  2258.                   && HD(j)->target_redo[SCpnt->target][SCpnt->channel])
  2259.             status = DID_BUS_BUSY << 16;
  2261.          /* Works around a flaw in scsi.c */
  2262.          else if (tstatus == CHECK_CONDITION
  2263.                   && SCpnt->device->type == TYPE_DISK
  2264.                   && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
  2265.             status = DID_BUS_BUSY << 16;
  2267.          else
  2268.             status = DID_OK << 16;
  2270.          if (tstatus == GOOD)
  2271.             HD(j)->target_redo[SCpnt->target][SCpnt->channel] = FALSE;
  2273.          if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
  2274.              (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
  2275.                (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
  2276.             printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
  2277.                    "target_status 0x%x, sense key 0x%x.n", BN(j),
  2278.                    SCpnt->channel, SCpnt->target, SCpnt->lun,
  2279.                    SCpnt->pid, spp->target_status,
  2280.                    SCpnt->sense_buffer[2]);
  2282.          HD(j)->target_to[SCpnt->target][SCpnt->channel] = 0;
  2284.          if (HD(j)->last_retried_pid == SCpnt->pid) HD(j)->retries = 0;
  2286.          break;
  2287.       case ASST:     /* Selection Time Out */
  2288.       case 0x02:     /* Command Time Out   */
  2290.          if (HD(j)->target_to[SCpnt->target][SCpnt->channel] > 1)
  2291.             status = DID_ERROR << 16;
  2292.          else {
  2293.             status = DID_TIME_OUT << 16;
  2294.             HD(j)->target_to[SCpnt->target][SCpnt->channel]++;
  2295.             }
  2297.          break;
  2299.       /* Perform a limited number of internal retries */
  2300.       case 0x03:     /* SCSI Bus Reset Received */
  2301.       case 0x04:     /* Initial Controller Power-up */
  2303.          for (c = 0; c <= sh[j]->max_channel; c++)
  2304.             for (k = 0; k < sh[j]->max_id; k++)
  2305.                HD(j)->target_redo[k][c] = TRUE;
  2307.          if (SCpnt->device->type != TYPE_TAPE
  2308.              && HD(j)->retries < MAX_INTERNAL_RETRIES) {
  2310. #if defined(DID_SOFT_ERROR)
  2311.             status = DID_SOFT_ERROR << 16;
  2312. #else
  2313.             status = DID_BUS_BUSY << 16;
  2314. #endif
  2316.             HD(j)->retries++;
  2317.             HD(j)->last_retried_pid = SCpnt->pid;
  2318.             }
  2319.          else
  2320.             status = DID_ERROR << 16;
  2322.          break;
  2323.       case 0x05:     /* Unexpected Bus Phase */
  2324.       case 0x06:     /* Unexpected Bus Free */
  2325.       case 0x07:     /* Bus Parity Error */
  2326.       case 0x08:     /* SCSI Hung */
  2327.       case 0x09:     /* Unexpected Message Reject */
  2328.       case 0x0a:     /* SCSI Bus Reset Stuck */
  2329.       case 0x0b:     /* Auto Request-Sense Failed */
  2330.       case 0x0c:     /* Controller Ram Parity Error */
  2331.       default:
  2332.          status = DID_ERROR << 16;
  2333.          break;
  2334.       }
  2336.    SCpnt->result = status | spp->target_status;
  2338. #if defined(DEBUG_INTERRUPT)
  2339.    if (SCpnt->result || do_trace)
  2340. #else
  2341.    if ((spp->adapter_status != ASOK && HD(j)->iocount >  1000) ||
  2342.        (spp->adapter_status != ASOK &&
  2343.         spp->adapter_status != ASST && HD(j)->iocount <= 1000) ||
  2344.         do_trace || msg_byte(spp->target_status))
  2345. #endif
  2346.       printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"
  2347.              " target %d.%d:%d, pid %ld, reg 0x%x, count %d.n",
  2348.              BN(j), i, spp->adapter_status, spp->target_status,
  2349.              SCpnt->channel, SCpnt->target, SCpnt->lun, SCpnt->pid,
  2350.              reg, HD(j)->iocount);
  2352.    unmap_dma(i, j);
  2354.    /* Set the command state to inactive */
  2355.    SCpnt->host_scribble = NULL;
  2357.    SCpnt->scsi_done(SCpnt);
  2359.    if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.n", BN(j), irq,
  2360.                         HD(j)->iocount);
  2362.    return;
  2363. }
  2365. static void do_interrupt_handler(int irq, void *shap, struct pt_regs *regs) {
  2366.    unsigned int j;
  2367.    unsigned long spin_flags;
  2369.    /* Check if the interrupt must be processed by this handler */
  2370.    if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return;
  2372.    spin_lock_irqsave(&io_request_lock, spin_flags);
  2373.    ihdlr(irq, j);
  2374.    spin_unlock_irqrestore(&io_request_lock, spin_flags);
  2375. }
  2377. int eata2x_release(struct Scsi_Host *shpnt) {
  2378.    unsigned int i, j;
  2380.    for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++);
  2382.    if (sh[j] == NULL) panic("%s: release, invalid Scsi_Host pointer.n",
  2383.                             driver_name);
  2385.    if(sh[j]->unchecked_isa_dma) scsi_deregister_blocked_host(sh[j]);
  2387.    for (i = 0; i < sh[j]->can_queue; i++)
  2388.       if ((&HD(j)->cp[i])->sglist) kfree((&HD(j)->cp[i])->sglist);
  2390.    for (i = 0; i < sh[j]->can_queue; i++)
  2391.       pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr,
  2392.                      sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
  2394.    if (HD(j)->sp_cpu_addr)
  2395.       pci_free_consistent(HD(j)->pdev, sizeof(struct mssp),
  2396.                           HD(j)->sp_cpu_addr, HD(j)->sp_dma_addr);
  2398.    free_irq(sh[j]->irq, &sha[j]);
  2400.    if (sh[j]->dma_channel != NO_DMA) free_dma(sh[j]->dma_channel);
  2402.    release_region(sh[j]->io_port, sh[j]->n_io_port);
  2403.    scsi_unregister(sh[j]);
  2404.    return FALSE;
  2405. }
  2407. static Scsi_Host_Template driver_template = EATA;
  2409. #include "scsi_module.c"
  2411. #ifndef MODULE
  2412. __setup("eata=", option_setup);
  2413. #endif /* end MODULE */
  2414. MODULE_LICENSE("GPL");