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

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

Linux/Unix编程

开发平台：

Unix_Linux

aic7xxx_osm.h：源码内容
  1. /*
  2.  * Adaptec AIC7xxx device driver for Linux.
  3.  *
  4.  * Copyright (c) 1994 John Aycock
  5.  *   The University of Calgary Department of Computer Science.
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2, or (at your option)
  10.  * any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; see the file COPYING.  If not, write to
  19.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  * 
  21.  * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.h#82 $
  22.  *
  23.  * Copyright (c) 2000-2001 Adaptec Inc.
  24.  * All rights reserved.
  25.  *
  26.  * Redistribution and use in source and binary forms, with or without
  27.  * modification, are permitted provided that the following conditions
  28.  * are met:
  29.  * 1. Redistributions of source code must retain the above copyright
  30.  *    notice, this list of conditions, and the following disclaimer,
  31.  *    without modification.
  32.  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  33.  *    substantially similar to the "NO WARRANTY" disclaimer below
  34.  *    ("Disclaimer") and any redistribution must be conditioned upon
  35.  *    including a substantially similar Disclaimer requirement for further
  36.  *    binary redistribution.
  37.  * 3. Neither the names of the above-listed copyright holders nor the names
  38.  *    of any contributors may be used to endorse or promote products derived
  39.  *    from this software without specific prior written permission.
  40.  *
  41.  * Alternatively, this software may be distributed under the terms of the
  42.  * GNU General Public License ("GPL") version 2 as published by the Free
  43.  * Software Foundation.
  44.  *
  45.  * NO WARRANTY
  46.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  47.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  48.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  49.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  50.  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  51.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  52.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  53.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  54.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  55.  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  56.  * POSSIBILITY OF SUCH DAMAGES.
  57.  *
  58.  * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.h#82 $
  59.  *
  60.  */
  61. #ifndef _AIC7XXX_LINUX_H_
  62. #define _AIC7XXX_LINUX_H_
  64. #include <linux/types.h>
  65. #include <linux/blk.h>
  66. #include <linux/blkdev.h>
  67. #include <linux/delay.h>
  68. #include <linux/ioport.h>
  69. #include <linux/pci.h>
  70. #include <linux/version.h>
  71. #ifndef AHC_MODVERSION_FILE
  72. #define __NO_VERSION__
  73. #endif
  74. #include <linux/module.h>
  75. #include <asm/byteorder.h>
  77. #ifndef KERNEL_VERSION
  78. #define KERNEL_VERSION(x,y,z) (((x)<<16)+((y)<<8)+(z))
  79. #endif
  81. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  82. #include <linux/interrupt.h> /* For tasklet support. */
  83. #include <linux/config.h>
  84. #include <linux/slab.h>
  85. #else
  86. #include <linux/malloc.h>
  87. #endif
  89. /* Core SCSI definitions */
  90. #include "../scsi.h"
  91. #include "../hosts.h"
  93. /* Name space conflict with BSD queue macros */
  94. #ifdef LIST_HEAD
  95. #undef LIST_HEAD
  96. #endif
  98. #include "cam.h"
  99. #include "queue.h"
  100. #include "scsi_message.h"
  102. /************************* Forward Declarations *******************************/
  103. struct ahc_softc;
  104. typedef struct pci_dev *ahc_dev_softc_t;
  105. typedef Scsi_Cmnd      *ahc_io_ctx_t;
  107. /******************************* Byte Order ***********************************/
  108. #define ahc_htobe16(x) cpu_to_be16(x)
  109. #define ahc_htobe32(x) cpu_to_be32(x)
  110. #define ahc_htobe64(x) cpu_to_be64(x)
  111. #define ahc_htole16(x) cpu_to_le16(x)
  112. #define ahc_htole32(x) cpu_to_le32(x)
  113. #define ahc_htole64(x) cpu_to_le64(x)
  115. #define ahc_be16toh(x) be16_to_cpu(x)
  116. #define ahc_be32toh(x) be32_to_cpu(x)
  117. #define ahc_be64toh(x) be64_to_cpu(x)
  118. #define ahc_le16toh(x) le16_to_cpu(x)
  119. #define ahc_le32toh(x) le32_to_cpu(x)
  120. #define ahc_le64toh(x) le64_to_cpu(x)
  122. #ifndef LITTLE_ENDIAN
  123. #define LITTLE_ENDIAN 1234
  124. #endif
  126. #ifndef BIG_ENDIAN
  127. #define BIG_ENDIAN 4321
  128. #endif
  130. #ifndef BYTE_ORDER
  131. #if defined(__BIG_ENDIAN)
  132. #define BYTE_ORDER BIG_ENDIAN
  133. #endif
  134. #if defined(__LITTLE_ENDIAN)
  135. #define BYTE_ORDER LITTLE_ENDIAN
  136. #endif
  137. #endif /* BYTE_ORDER */
  139. /************************* Configuration Data *********************************/
  140. extern int aic7xxx_no_probe;
  141. extern int aic7xxx_detect_complete;
  142. extern Scsi_Host_Template* aic7xxx_driver_template;
  144. /***************************** Bus Space/DMA **********************************/
  146. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,2,17)
  147. typedef dma_addr_t bus_addr_t;
  148. #else
  149. typedef uint32_t bus_addr_t;
  150. #endif
  151. typedef uint32_t bus_size_t;
  153. typedef enum {
  154. BUS_SPACE_MEMIO,
  155. BUS_SPACE_PIO
  156. } bus_space_tag_t;
  158. typedef union {
  159. u_long   ioport;
  160. volatile uint8_t *maddr;
  161. } bus_space_handle_t;
  163. typedef struct bus_dma_segment
  164. {
  165. bus_addr_t ds_addr;
  166. bus_size_t ds_len;
  167. } bus_dma_segment_t;
  169. struct ahc_linux_dma_tag
  170. {
  171. bus_size_t alignment;
  172. bus_size_t boundary;
  173. bus_size_t maxsize;
  174. };
  175. typedef struct ahc_linux_dma_tag* bus_dma_tag_t;
  177. struct ahc_linux_dmamap
  178. {
  179. bus_addr_t bus_addr;
  180. };
  181. typedef struct ahc_linux_dmamap* bus_dmamap_t;
  183. typedef int bus_dma_filter_t(void*, bus_addr_t);
  184. typedef void bus_dmamap_callback_t(void *, bus_dma_segment_t *, int, int);
  186. #define BUS_DMA_WAITOK 0x0
  187. #define BUS_DMA_NOWAIT 0x1
  188. #define BUS_DMA_ALLOCNOW 0x2
  189. #define BUS_DMA_LOAD_SEGS 0x4 /*
  190.  * Argument is an S/G list not
  191.  * a single buffer.
  192.  */
  194. #define BUS_SPACE_MAXADDR 0xFFFFFFFF
  195. #define BUS_SPACE_MAXADDR_32BIT 0xFFFFFFFF
  196. #define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF
  198. int ahc_dma_tag_create(struct ahc_softc *, bus_dma_tag_t /*parent*/,
  199.    bus_size_t /*alignment*/, bus_size_t /*boundary*/,
  200.    bus_addr_t /*lowaddr*/, bus_addr_t /*highaddr*/,
  201.    bus_dma_filter_t*/*filter*/, void */*filterarg*/,
  202.    bus_size_t /*maxsize*/, int /*nsegments*/,
  203.    bus_size_t /*maxsegsz*/, int /*flags*/,
  204.    bus_dma_tag_t */*dma_tagp*/);
  206. void ahc_dma_tag_destroy(struct ahc_softc *, bus_dma_tag_t /*tag*/);
  208. int ahc_dmamem_alloc(struct ahc_softc *, bus_dma_tag_t /*dmat*/,
  209.  void** /*vaddr*/, int /*flags*/,
  210.  bus_dmamap_t* /*mapp*/);
  212. void ahc_dmamem_free(struct ahc_softc *, bus_dma_tag_t /*dmat*/,
  213. void* /*vaddr*/, bus_dmamap_t /*map*/);
  215. void ahc_dmamap_destroy(struct ahc_softc *, bus_dma_tag_t /*tag*/,
  216.    bus_dmamap_t /*map*/);
  218. int ahc_dmamap_load(struct ahc_softc *ahc, bus_dma_tag_t /*dmat*/,
  219. bus_dmamap_t /*map*/, void * /*buf*/,
  220. bus_size_t /*buflen*/, bus_dmamap_callback_t *,
  221. void */*callback_arg*/, int /*flags*/);
  223. int ahc_dmamap_unload(struct ahc_softc *, bus_dma_tag_t, bus_dmamap_t);
  225. /*
  226.  * Operations performed by ahc_dmamap_sync().
  227.  */
  228. #define BUS_DMASYNC_PREREAD 0x01 /* pre-read synchronization */
  229. #define BUS_DMASYNC_POSTREAD 0x02 /* post-read synchronization */
  230. #define BUS_DMASYNC_PREWRITE 0x04 /* pre-write synchronization */
  231. #define BUS_DMASYNC_POSTWRITE 0x08 /* post-write synchronization */
  233. /*
  234.  * XXX
  235.  * ahc_dmamap_sync is only used on buffers allocated with
  236.  * the pci_alloc_consistent() API.  Although I'm not sure how
  237.  * this works on architectures with a write buffer, Linux does
  238.  * not have an API to sync "coherent" memory.  Perhaps we need
  239.  * to do an mb()?
  240.  */
  241. #define ahc_dmamap_sync(ahc, dma_tag, dmamap, offset, len, op)
  243. /************************** SCSI Constants/Structures *************************/
  244. #define SCSI_REV_2 2
  245. #define SCSI_STATUS_OK 0x00
  246. #define SCSI_STATUS_CHECK_COND 0x02
  247. #define SCSI_STATUS_COND_MET 0x04
  248. #define SCSI_STATUS_BUSY 0x08
  249. #define SCSI_STATUS_INTERMED 0x10
  250. #define SCSI_STATUS_INTERMED_COND_MET 0x14
  251. #define SCSI_STATUS_RESERV_CONFLICT 0x18
  252. #define SCSI_STATUS_CMD_TERMINATED 0x22
  253. #define SCSI_STATUS_QUEUE_FULL 0x28
  255. /*
  256.  * 6 byte request sense CDB format.
  257.  */
  258. struct scsi_sense
  259. {
  260. uint8_t opcode;
  261. uint8_t byte2;
  262. uint8_t unused[2];
  263. uint8_t length;
  264. uint8_t control;
  265. };
  267. struct scsi_sense_data
  268. {
  269. uint8_t error_code;
  270. uint8_t segment;
  271. uint8_t flags;
  272. uint8_t info[4];
  273. uint8_t extra_len;
  274. uint8_t cmd_spec_info[4];
  275. uint8_t add_sense_code;
  276. uint8_t add_sense_code_qual;
  277. uint8_t fru;
  278. uint8_t sense_key_spec[3];
  279. uint8_t extra_bytes[14];
  280. };
  282. struct scsi_inquiry
  283. { 
  284. u_int8_t opcode;
  285. u_int8_t byte2;
  286. #define SI_EVPD 0x01
  287. u_int8_t page_code;
  288. u_int8_t reserved;
  289. u_int8_t length;
  290. u_int8_t control;
  291. };
  293. struct scsi_inquiry_data
  294. {
  295. uint8_t device;
  296. #define SID_TYPE(inq_data) ((inq_data)->device & 0x1f)
  297. #define SID_QUAL(inq_data) (((inq_data)->device & 0xE0) >> 5)
  298. #define SID_QUAL_LU_CONNECTED 0x00 /*
  299.  * The specified peripheral device
  300.  * type is currently connected to
  301.  * logical unit.  If the target cannot
  302.  * determine whether or not a physical
  303.  * device is currently connected, it
  304.  * shall also use this peripheral
  305.  * qualifier when returning the INQUIRY
  306.  * data.  This peripheral qualifier
  307.  * does not mean that the device is
  308.  * ready for access by the initiator.
  309.  */
  310. #define SID_QUAL_LU_OFFLINE 0x01 /*
  311.  * The target is capable of supporting
  312.  * the specified peripheral device type
  313.  * on this logical unit; however, the
  314.  * physical device is not currently
  315.  * connected to this logical unit.
  316.  */
  317. #define SID_QUAL_RSVD 0x02
  318. #define SID_QUAL_BAD_LU 0x03 /*
  319.  * The target is not capable of
  320.  * supporting a physical device on
  321.  * this logical unit. For this
  322.  * peripheral qualifier the peripheral
  323.  * device type shall be set to 1Fh to
  324.  * provide compatibility with previous
  325.  * versions of SCSI. All other
  326.  * peripheral device type values are
  327.  * reserved for this peripheral
  328.  * qualifier.
  329.  */
  330. #define SID_QUAL_IS_VENDOR_UNIQUE(inq_data) ((SID_QUAL(inq_data) & 0x08) != 0)
  331. uint8_t dev_qual2;
  332. #define SID_QUAL2 0x7F
  333. #define SID_IS_REMOVABLE(inq_data) (((inq_data)->dev_qual2 & 0x80) != 0)
  334. uint8_t version;
  335. #define SID_ANSI_REV(inq_data) ((inq_data)->version & 0x07)
  336. #define SCSI_REV_0 0
  337. #define SCSI_REV_CCS 1
  338. #define SCSI_REV_2 2
  339. #define SCSI_REV_SPC 3
  340. #define SCSI_REV_SPC2 4
  342. #define SID_ECMA 0x38
  343. #define SID_ISO 0xC0
  344. uint8_t response_format;
  345. #define SID_AENC 0x80
  346. #define SID_TrmIOP 0x40
  347. uint8_t additional_length;
  348. uint8_t reserved[2];
  349. uint8_t flags;
  350. #define SID_SftRe 0x01
  351. #define SID_CmdQue 0x02
  352. #define SID_Linked 0x08
  353. #define SID_Sync 0x10
  354. #define SID_WBus16 0x20
  355. #define SID_WBus32 0x40
  356. #define SID_RelAdr 0x80
  357. #define SID_VENDOR_SIZE   8
  358. char  vendor[SID_VENDOR_SIZE];
  359. #define SID_PRODUCT_SIZE  16
  360. char  product[SID_PRODUCT_SIZE];
  361. #define SID_REVISION_SIZE 4
  362. char  revision[SID_REVISION_SIZE];
  363. /*
  364.  * The following fields were taken from SCSI Primary Commands - 2
  365.  * (SPC-2) Revision 14, Dated 11 November 1999
  366.  */
  367. #define SID_VENDOR_SPECIFIC_0_SIZE 20
  368. u_int8_t vendor_specific0[SID_VENDOR_SPECIFIC_0_SIZE];
  369. /*
  370.  * An extension of SCSI Parallel Specific Values
  371.  */
  372. #define SID_SPI_IUS 0x01
  373. #define SID_SPI_QAS 0x02
  374. #define SID_SPI_CLOCK_ST 0x00
  375. #define SID_SPI_CLOCK_DT 0x04
  376. #define SID_SPI_CLOCK_DT_ST 0x0C
  377. #define SID_SPI_MASK 0x0F
  378. uint8_t spi3data;
  379. uint8_t reserved2;
  380. /*
  381.  * Version Descriptors, stored 2 byte values.
  382.  */
  383. uint8_t version1[2];
  384. uint8_t version2[2];
  385. uint8_t version3[2];
  386. uint8_t version4[2];
  387. uint8_t version5[2];
  388. uint8_t version6[2];
  389. uint8_t version7[2];
  390. uint8_t version8[2];
  392. uint8_t reserved3[22];
  394. #define SID_VENDOR_SPECIFIC_1_SIZE 160
  395. uint8_t vendor_specific1[SID_VENDOR_SPECIFIC_1_SIZE];
  396. };
  398. /********************************** Includes **********************************/
  399. /* Host template and function declarations referenced by the template. */
  400. #include "aic7xxx_host.h"
  402. /* Core driver definitions */
  403. #include "aic7xxx.h"
  405. /* SMP support */
  406. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,17)
  407. #include <linux/spinlock.h>
  408. #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,93)
  409. #include <linux/smp.h>
  410. #endif
  412. #define AIC7XXX_DRIVER_VERSION  "6.2.8"
  414. /**************************** Front End Queues ********************************/
  415. /*
  416.  * Data structure used to cast the Linux struct scsi_cmnd to something
  417.  * that allows us to use the queue macros.  The linux structure has
  418.  * plenty of space to hold the links fields as required by the queue
  419.  * macros, but the queue macors require them to have the correct type.
  420.  */
  421. struct ahc_cmd_internal {
  422. /* Area owned by the Linux scsi layer. */
  423. uint8_t private[offsetof(struct scsi_cmnd, SCp.Status)];
  424. union {
  425. STAILQ_ENTRY(ahc_cmd) ste;
  426. LIST_ENTRY(ahc_cmd) le;
  427. TAILQ_ENTRY(ahc_cmd) tqe;
  428. } links;
  429. uint32_t end;
  430. };
  432. struct ahc_cmd {
  433. union {
  434. struct ahc_cmd_internal icmd;
  435. struct scsi_cmnd scsi_cmd;
  436. } un;
  437. };
  439. #define acmd_icmd(cmd) ((cmd)->un.icmd)
  440. #define acmd_scsi_cmd(cmd) ((cmd)->un.scsi_cmd)
  441. #define acmd_links un.icmd.links
  443. /*************************** Device Data Structures ***************************/
  444. /*
  445.  * A per probed device structure used to deal with some error recovery
  446.  * scenarios that the Linux mid-layer code just doesn't know how to
  447.  * handle.  The structure allocated for a device only becomes persistant
  448.  * after a successfully completed inquiry command to the target when
  449.  * that inquiry data indicates a lun is present.
  450.  */
  451. TAILQ_HEAD(ahc_busyq, ahc_cmd);
  452. typedef enum {
  453. AHC_DEV_UNCONFIGURED  = 0x01,
  454. AHC_DEV_FREEZE_TIL_EMPTY = 0x02, /* Freeze queue until active == 0 */
  455. AHC_DEV_TIMER_ACTIVE  = 0x04, /* Our timer is active */
  456. AHC_DEV_ON_RUN_LIST  = 0x08, /* Queued to be run later */
  457. AHC_DEV_Q_BASIC  = 0x10, /* Allow basic device queuing */
  458. AHC_DEV_Q_TAGGED  = 0x20, /* Allow full SCSI2 command queueing */
  459. AHC_DEV_PERIODIC_OTAG  = 0x40  /* Send OTAG to prevent starvation */
  460. } ahc_dev_flags;
  462. struct ahc_linux_target;
  463. struct ahc_linux_device {
  464. TAILQ_ENTRY(ahc_linux_device) links;
  465. struct ahc_busyq busyq;
  467. /*
  468.  * The number of transactions currently
  469.  * queued to the device.
  470.  */
  471. int active;
  473. /*
  474.  * The currently allowed number of 
  475.  * transactions that can be queued to
  476.  * the device.  Must be signed for
  477.  * conversion from tagged to untagged
  478.  * mode where the device may have more
  479.  * than one outstanding active transaction.
  480.  */
  481. int openings;
  483. /*
  484.  * A positive count indicates that this
  485.  * device's queue is halted.
  486.  */
  487. u_int qfrozen;
  489. /*
  490.  * Cumulative command counter.
  491.  */
  492. u_long commands_issued;
  494. /*
  495.  * The number of tagged transactions when
  496.  * running at our current opening level
  497.  * that have been successfully received by
  498.  * this device since the last QUEUE FULL.
  499.  */
  500. u_int tag_success_count;
  501. #define AHC_TAG_SUCCESS_INTERVAL 50
  503. ahc_dev_flags flags;
  505. /*
  506.  * Per device timer.
  507.  */
  508. struct timer_list timer;
  510. /*
  511.  * The high limit for the tags variable.
  512.  */
  513. u_int maxtags;
  515. /*
  516.  * The computed number of tags outstanding
  517.  * at the time of the last QUEUE FULL event.
  518.  */
  519. u_int tags_on_last_queuefull;
  521. /*
  522.  * How many times we have seen a queue full
  523.  * with the same number of tags.  This is used
  524.  * to stop our adaptive queue depth algorithm
  525.  * on devices with a fixed number of tags.
  526.  */
  527. u_int last_queuefull_same_count;
  528. #define AHC_LOCK_TAGS_COUNT 50
  530. /*
  531.  * How many transactions have been queued
  532.  * without the device going idle.  We use
  533.  * this statistic to determine when to issue
  534.  * an ordered tag to prevent transaction
  535.  * starvation.  This statistic is only updated
  536.  * if the AHC_DEV_PERIODIC_OTAG flag is set
  537.  * on this device.
  538.  */
  539. u_int commands_since_idle_or_otag;
  540. #define AHC_OTAG_THRESH 500
  542. int lun;
  543. struct ahc_linux_target *target;
  544. };
  546. struct ahc_linux_target {
  547. struct ahc_linux_device *devices[AHC_NUM_LUNS];
  548. int channel;
  549. int target;
  550. int refcount;
  551. struct ahc_transinfo last_tinfo;
  552. struct ahc_softc *ahc;
  553. };
  555. /********************* Definitions Required by the Core ***********************/
  556. /*
  557.  * Number of SG segments we require.  So long as the S/G segments for
  558.  * a particular transaction are allocated in a physically contiguous
  559.  * manner and are allocated below 4GB, the number of S/G segments is
  560.  * unrestricted.
  561.  */
  562. #define        AHC_NSEG 128
  564. /*
  565.  * Per-SCB OSM storage.
  566.  */
  567. struct scb_platform_data {
  568. struct ahc_linux_device *dev;
  569. bus_addr_t  buf_busaddr;
  570. uint32_t  xfer_len;
  571. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
  572. uint32_t  resid; /* Transfer residual */
  573. #endif
  574. };
  576. /*
  577.  * Define a structure used for each host adapter.  All members are
  578.  * aligned on a boundary >= the size of the member to honor the
  579.  * alignment restrictions of the various platforms supported by
  580.  * this driver.
  581.  */
  582. TAILQ_HEAD(ahc_completeq, ahc_cmd);
  583. struct ahc_platform_data {
  584. /*
  585.  * Fields accessed from interrupt context.
  586.  */
  587. struct ahc_linux_target *targets[AHC_NUM_TARGETS]; 
  588. TAILQ_HEAD(, ahc_linux_device) device_runq;
  589. struct ahc_completeq  completeq;
  591. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)
  592. spinlock_t  spin_lock;
  593. #endif
  594. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  595. struct tasklet_struct  runq_tasklet;
  596. #endif
  597. u_int  qfrozen;
  598. struct timer_list  reset_timer;
  599. struct semaphore  eh_sem;
  600. struct Scsi_Host        *host; /* pointer to scsi host */
  601. #define AHC_LINUX_NOIRQ ((uint32_t)~0)
  602. uint32_t  irq; /* IRQ for this adapter */
  603. uint32_t  bios_address;
  604. uint32_t  mem_busaddr; /* Mem Base Addr */
  605. bus_addr_t  hw_dma_mask;
  606. };
  608. /************************** OS Utility Wrappers *******************************/
  609. #define printf printk
  610. #define M_NOWAIT GFP_ATOMIC
  611. #define M_WAITOK 0
  612. #define malloc(size, type, flags) kmalloc(size, flags)
  613. #define free(ptr, type) kfree(ptr)
  615. static __inline void ahc_delay(long);
  616. static __inline void
  617. ahc_delay(long usec)
  618. {
  619. /*
  620.  * udelay on Linux can have problems for
  621.  * multi-millisecond waits.  Wait at most
  622.  * 1024us per call.
  623.  */
  624. while (usec > 0) {
  625. udelay(usec % 1024);
  626. usec -= 1024;
  627. }
  628. }
  631. /***************************** Low Level I/O **********************************/
  632. #if defined(__powerpc__) || defined(__i386__) || defined(__ia64__)
  633. #define MMAPIO
  634. #endif
  636. static __inline uint8_t ahc_inb(struct ahc_softc * ahc, long port);
  637. static __inline void ahc_outb(struct ahc_softc * ahc, long port, uint8_t val);
  638. static __inline void ahc_outsb(struct ahc_softc * ahc, long port,
  639.        uint8_t *, int count);
  640. static __inline void ahc_insb(struct ahc_softc * ahc, long port,
  641.        uint8_t *, int count);
  643. static __inline uint8_t
  644. ahc_inb(struct ahc_softc * ahc, long port)
  645. {
  646. uint8_t x;
  647. #ifdef MMAPIO
  649. if (ahc->tag == BUS_SPACE_MEMIO) {
  650. x = readb(ahc->bsh.maddr + port);
  651. } else {
  652. x = inb(ahc->bsh.ioport + port);
  653. }
  654. #else
  655. x = inb(ahc->bsh.ioport + port);
  656. #endif
  657. mb();
  658. return (x);
  659. }
  661. static __inline void
  662. ahc_outb(struct ahc_softc * ahc, long port, uint8_t val)
  663. {
  664. #ifdef MMAPIO
  665. if (ahc->tag == BUS_SPACE_MEMIO) {
  666. writeb(val, ahc->bsh.maddr + port);
  667. } else {
  668. outb(val, ahc->bsh.ioport + port);
  669. }
  670. #else
  671. outb(val, ahc->bsh.ioport + port);
  672. #endif
  673. mb();
  674. }
  676. static __inline void
  677. ahc_outsb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
  678. {
  679. int i;
  681. /*
  682.  * There is probably a more efficient way to do this on Linux
  683.  * but we don't use this for anything speed critical and this
  684.  * should work.
  685.  */
  686. for (i = 0; i < count; i++)
  687. ahc_outb(ahc, port, *array++);
  688. }
  690. static __inline void
  691. ahc_insb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
  692. {
  693. int i;
  695. /*
  696.  * There is probably a more efficient way to do this on Linux
  697.  * but we don't use this for anything speed critical and this
  698.  * should work.
  699.  */
  700. for (i = 0; i < count; i++)
  701. *array++ = ahc_inb(ahc, port);
  702. }
  704. /**************************** Initialization **********************************/
  705. int ahc_linux_register_host(struct ahc_softc *,
  706. Scsi_Host_Template *);
  708. uint64_t ahc_linux_get_memsize(void);
  710. /*************************** Pretty Printing **********************************/
  711. struct info_str {
  712. char *buffer;
  713. int length;
  714. off_t offset;
  715. int pos;
  716. };
  718. void ahc_format_transinfo(struct info_str *info,
  719.      struct ahc_transinfo *tinfo);
  721. /******************************** Locking *************************************/
  722. /* Lock protecting internal data structures */
  723. static __inline void ahc_lockinit(struct ahc_softc *);
  724. static __inline void ahc_lock(struct ahc_softc *, unsigned long *flags);
  725. static __inline void ahc_unlock(struct ahc_softc *, unsigned long *flags);
  727. /* Lock held during command compeletion to the upper layer */
  728. static __inline void ahc_done_lockinit(struct ahc_softc *);
  729. static __inline void ahc_done_lock(struct ahc_softc *, unsigned long *flags);
  730. static __inline void ahc_done_unlock(struct ahc_softc *, unsigned long *flags);
  732. /* Lock held during ahc_list manipulation and ahc softc frees */
  733. extern spinlock_t ahc_list_spinlock;
  734. static __inline void ahc_list_lockinit(void);
  735. static __inline void ahc_list_lock(unsigned long *flags);
  736. static __inline void ahc_list_unlock(unsigned long *flags);
  738. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,93)
  739. static __inline void
  740. ahc_lockinit(struct ahc_softc *ahc)
  741. {
  742. spin_lock_init(&ahc->platform_data->spin_lock);
  743. }
  745. static __inline void
  746. ahc_lock(struct ahc_softc *ahc, unsigned long *flags)
  747. {
  748. *flags = 0;
  749. spin_lock_irqsave(&ahc->platform_data->spin_lock, *flags);
  750. }
  752. static __inline void
  753. ahc_unlock(struct ahc_softc *ahc, unsigned long *flags)
  754. {
  755. spin_unlock_irqrestore(&ahc->platform_data->spin_lock, *flags);
  756. }
  758. static __inline void
  759. ahc_done_lockinit(struct ahc_softc *ahc)
  760. {
  761. /* We don't own the iorequest lock, so we don't initialize it. */
  762. }
  764. static __inline void
  765. ahc_done_lock(struct ahc_softc *ahc, unsigned long *flags)
  766. {
  767. *flags = 0;
  768. spin_lock_irqsave(&io_request_lock, *flags);
  769. }
  771. static __inline void
  772. ahc_done_unlock(struct ahc_softc *ahc, unsigned long *flags)
  773. {
  774. spin_unlock_irqrestore(&io_request_lock, *flags);
  775. }
  777. static __inline void
  778. ahc_list_lockinit()
  779. {
  780. spin_lock_init(&ahc_list_spinlock);
  781. }
  783. static __inline void
  784. ahc_list_lock(unsigned long *flags)
  785. {
  786. *flags = 0;
  787. spin_lock_irqsave(&ahc_list_spinlock, *flags);
  788. }
  790. static __inline void
  791. ahc_list_unlock(unsigned long *flags)
  792. {
  793. spin_unlock_irqrestore(&ahc_list_spinlock, *flags);
  794. }
  796. #else /* LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) */
  798. ahc_lockinit(struct ahc_softc *ahc)
  799. {
  800. }
  802. static __inline void
  803. ahc_lock(struct ahc_softc *ahc, unsigned long *flags)
  804. {
  805. *flags = 0;
  806. save_flags(*flags);
  807. cli();
  808. }
  810. static __inline void
  811. ahc_unlock(struct ahc_softc *ahc, unsigned long *flags)
  812. {
  813. restore_flags(*flags);
  814. }
  816. static __inline void
  817. ahc_done_lockinit(struct ahc_softc *ahc)
  818. {
  819. }
  821. static __inline void
  822. ahc_done_lock(struct ahc_softc *ahc, unsigned long *flags)
  823. {
  824. /*
  825.  * The done lock is always held while
  826.  * the ahc lock is held so blocking
  827.  * interrupts again would have no effect.
  828.  */
  829. }
  831. static __inline void
  832. ahc_done_unlock(struct ahc_softc *ahc, unsigned long *flags)
  833. {
  834. }
  836. static __inline void
  837. ahc_list_lockinit()
  838. {
  839. }
  841. static __inline void
  842. ahc_list_lock(unsigned long *flags)
  843. {
  844. *flags = 0;
  845. save_flags(*flags);
  846. cli();
  847. }
  849. static __inline void
  850. ahc_list_unlock(unsigned long *flags)
  851. {
  852. restore_flags(*flags);
  853. }
  854. #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) */
  856. /******************************* PCI Definitions ******************************/
  857. /*
  858.  * PCIM_xxx: mask to locate subfield in register
  859.  * PCIR_xxx: config register offset
  860.  * PCIC_xxx: device class
  861.  * PCIS_xxx: device subclass
  862.  * PCIP_xxx: device programming interface
  863.  * PCIV_xxx: PCI vendor ID (only required to fixup ancient devices)
  864.  * PCID_xxx: device ID
  865.  */
  866. #define PCIR_DEVVENDOR 0x00
  867. #define PCIR_VENDOR 0x00
  868. #define PCIR_DEVICE 0x02
  869. #define PCIR_COMMAND 0x04
  870. #define PCIM_CMD_PORTEN 0x0001
  871. #define PCIM_CMD_MEMEN 0x0002
  872. #define PCIM_CMD_BUSMASTEREN 0x0004
  873. #define PCIM_CMD_MWRICEN 0x0010
  874. #define PCIM_CMD_PERRESPEN 0x0040
  875. #define PCIR_STATUS 0x06
  876. #define PCIR_REVID 0x08
  877. #define PCIR_PROGIF 0x09
  878. #define PCIR_SUBCLASS 0x0a
  879. #define PCIR_CLASS 0x0b
  880. #define PCIR_CACHELNSZ 0x0c
  881. #define PCIR_LATTIMER 0x0d
  882. #define PCIR_HEADERTYPE 0x0e
  883. #define PCIM_MFDEV 0x80
  884. #define PCIR_BIST 0x0f
  885. #define PCIR_CAP_PTR 0x34
  887. /* config registers for header type 0 devices */
  888. #define PCIR_MAPS 0x10
  889. #define PCIR_SUBVEND_0 0x2c
  890. #define PCIR_SUBDEV_0 0x2e
  892. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  893. extern struct pci_driver aic7xxx_pci_driver;
  894. #endif
  896. typedef enum
  897. {
  898. AHC_POWER_STATE_D0,
  899. AHC_POWER_STATE_D1,
  900. AHC_POWER_STATE_D2,
  901. AHC_POWER_STATE_D3
  902. } ahc_power_state;
  904. void ahc_power_state_change(struct ahc_softc *ahc,
  905.     ahc_power_state new_state);
  906. /**************************** VL/EISA Routines ********************************/
  907. int  aic7770_linux_probe(Scsi_Host_Template *);
  908. int  aic7770_map_registers(struct ahc_softc *ahc,
  909.        u_int port);
  910. int  aic7770_map_int(struct ahc_softc *ahc, u_int irq);
  912. /******************************* PCI Routines *********************************/
  913. /*
  914.  * We need to use the bios32.h routines if we are kernel version 2.1.92 or less.
  915.  */
  916. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,1,92)
  917. #if defined(__sparc_v9__) || defined(__powerpc__)
  918. #error "PPC and Sparc platforms are only support under 2.1.92 and above"
  919. #endif
  920. #include <linux/bios32.h>
  921. #endif
  923. int  ahc_linux_pci_probe(Scsi_Host_Template *);
  924. int  ahc_pci_map_registers(struct ahc_softc *ahc);
  925. int  ahc_pci_map_int(struct ahc_softc *ahc);
  927. static __inline uint32_t ahc_pci_read_config(ahc_dev_softc_t pci,
  928.      int reg, int width);
  930. static __inline uint32_t
  931. ahc_pci_read_config(ahc_dev_softc_t pci, int reg, int width)
  932. {
  933. switch (width) {
  934. case 1:
  935. {
  936. uint8_t retval;
  938. pci_read_config_byte(pci, reg, &retval);
  939. return (retval);
  940. }
  941. case 2:
  942. {
  943. uint16_t retval;
  944. pci_read_config_word(pci, reg, &retval);
  945. return (retval);
  946. }
  947. case 4:
  948. {
  949. uint32_t retval;
  950. pci_read_config_dword(pci, reg, &retval);
  951. return (retval);
  952. }
  953. default:
  954. panic("ahc_pci_read_config: Read size too big");
  955. /* NOTREACHED */
  956. return (0);
  957. }
  958. }
  960. static __inline void ahc_pci_write_config(ahc_dev_softc_t pci,
  961.   int reg, uint32_t value,
  962.   int width);
  964. static __inline void
  965. ahc_pci_write_config(ahc_dev_softc_t pci, int reg, uint32_t value, int width)
  966. {
  967. switch (width) {
  968. case 1:
  969. pci_write_config_byte(pci, reg, value);
  970. break;
  971. case 2:
  972. pci_write_config_word(pci, reg, value);
  973. break;
  974. case 4:
  975. pci_write_config_dword(pci, reg, value);
  976. break;
  977. default:
  978. panic("ahc_pci_write_config: Write size too big");
  979. /* NOTREACHED */
  980. }
  981. }
  983. static __inline int ahc_get_pci_function(ahc_dev_softc_t);
  984. static __inline int
  985. ahc_get_pci_function(ahc_dev_softc_t pci)
  986. {
  987. return (PCI_FUNC(pci->devfn));
  988. }
  990. static __inline int ahc_get_pci_slot(ahc_dev_softc_t);
  991. static __inline int
  992. ahc_get_pci_slot(ahc_dev_softc_t pci)
  993. {
  994. return (PCI_SLOT(pci->devfn));
  995. }
  997. static __inline int ahc_get_pci_bus(ahc_dev_softc_t);
  998. static __inline int
  999. ahc_get_pci_bus(ahc_dev_softc_t pci)
  1000. {
  1001. return (pci->bus->number);
  1002. }
  1004. static __inline void ahc_flush_device_writes(struct ahc_softc *);
  1005. static __inline void
  1006. ahc_flush_device_writes(struct ahc_softc *ahc)
  1007. {
  1008. /* XXX Is this sufficient for all architectures??? */
  1009. ahc_inb(ahc, INTSTAT);
  1010. }
  1012. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,0)
  1013. #define pci_map_sg(pdev, sg_list, nseg, direction) (nseg)
  1014. #define pci_unmap_sg(pdev, sg_list, nseg, direction)
  1015. #define sg_dma_address(sg) (VIRT_TO_BUS((sg)->address))
  1016. #define sg_dma_len(sg) ((sg)->length)
  1017. #define pci_map_single(pdev, buffer, bufflen, direction) 
  1018. (VIRT_TO_BUS(buffer))
  1019. #define pci_unmap_single(pdev, buffer, buflen, direction)
  1020. #endif
  1022. /*********************** Transaction Access Wrappers **************************/
  1023. static __inline void ahc_set_transaction_status(struct scb *, uint32_t);
  1024. static __inline
  1025. void ahc_set_transaction_status(struct scb *scb, uint32_t status)
  1026. {
  1027. scb->io_ctx->result &= ~(CAM_STATUS_MASK << 16);
  1028. scb->io_ctx->result |= status << 16;
  1029. }
  1031. static __inline void ahc_set_scsi_status(struct scb *, uint32_t);
  1032. static __inline
  1033. void ahc_set_scsi_status(struct scb *scb, uint32_t status)
  1034. {
  1035. scb->io_ctx->result &= ~0xFFFF;
  1036. scb->io_ctx->result |= status;
  1037. }
  1039. static __inline uint32_t ahc_get_transaction_status(struct scb *);
  1040. static __inline
  1041. uint32_t ahc_get_transaction_status(struct scb *scb)
  1042. {
  1043. return ((scb->io_ctx->result >> 16) & CAM_STATUS_MASK);
  1044. }
  1046. static __inline uint32_t ahc_get_scsi_status(struct scb *);
  1047. static __inline
  1048. uint32_t ahc_get_scsi_status(struct scb *scb)
  1049. {
  1050. return (scb->io_ctx->result & 0xFFFF);
  1051. }
  1053. static __inline void ahc_set_transaction_tag(struct scb *, int, u_int);
  1054. static __inline
  1055. void ahc_set_transaction_tag(struct scb *scb, int enabled, u_int type)
  1056. {
  1057. /*
  1058.  * Nothing to do for linux as the incoming transaction
  1059.  * has no concept of tag/non tagged, etc.
  1060.  */
  1061. }
  1063. static __inline u_long ahc_get_transfer_length(struct scb *);
  1064. static __inline
  1065. u_long ahc_get_transfer_length(struct scb *scb)
  1066. {
  1067. return (scb->platform_data->xfer_len);
  1068. }
  1070. static __inline int ahc_get_transfer_dir(struct scb *);
  1071. static __inline
  1072. int ahc_get_transfer_dir(struct scb *scb)
  1073. {
  1074. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,40)
  1075. return (scb->io_ctx->sc_data_direction);
  1076. #else
  1077. if (scb->io_ctx->bufflen == 0)
  1078. return (CAM_DIR_NONE);
  1080. switch(scb->io_ctx->cmnd[0]) {
  1081. case 0x08:  /* READ(6)  */
  1082. case 0x28:  /* READ(10) */
  1083. case 0xA8:  /* READ(12) */
  1084. return (CAM_DIR_IN);
  1085.         case 0x0A:  /* WRITE(6)  */
  1086.         case 0x2A:  /* WRITE(10) */
  1087.         case 0xAA:  /* WRITE(12) */
  1088. return (CAM_DIR_OUT);
  1089.         default:
  1090. return (CAM_DIR_NONE);
  1091.         }
  1092. #endif
  1093. }
  1095. static __inline void ahc_set_residual(struct scb *, u_long);
  1096. static __inline
  1097. void ahc_set_residual(struct scb *scb, u_long resid)
  1098. {
  1099. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
  1100. scb->io_ctx->resid = resid;
  1101. #else
  1102. scb->platform_data->resid = resid;
  1103. #endif
  1104. }
  1106. static __inline void ahc_set_sense_residual(struct scb *, u_long);
  1107. static __inline
  1108. void ahc_set_sense_residual(struct scb *scb, u_long resid)
  1109. {
  1110. /* This can't be reported in Linux */
  1111. }
  1113. static __inline u_long ahc_get_residual(struct scb *);
  1114. static __inline
  1115. u_long ahc_get_residual(struct scb *scb)
  1116. {
  1117. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
  1118. return (scb->io_ctx->resid);
  1119. #else
  1120. return (scb->platform_data->resid);
  1121. #endif
  1122. }
  1124. static __inline int ahc_perform_autosense(struct scb *);
  1125. static __inline
  1126. int ahc_perform_autosense(struct scb *scb)
  1127. {
  1128. /*
  1129.  * We always perform autosense in Linux.
  1130.  * On other platforms this is set on a
  1131.  * per-transaction basis.
  1132.  */
  1133. return (1);
  1134. }
  1136. static __inline uint32_t
  1137. ahc_get_sense_bufsize(struct ahc_softc *ahc, struct scb *scb)
  1138. {
  1139. return (sizeof(struct scsi_sense_data));
  1140. }
  1142. static __inline void ahc_notify_xfer_settings_change(struct ahc_softc *,
  1143.      struct ahc_devinfo *);
  1144. static __inline void
  1145. ahc_notify_xfer_settings_change(struct ahc_softc *ahc,
  1146. struct ahc_devinfo *devinfo)
  1147. {
  1148. /* Nothing to do here for linux */
  1149. }
  1151. static __inline void ahc_platform_scb_free(struct ahc_softc *ahc,
  1152.    struct scb *scb);
  1153. static __inline void
  1154. ahc_platform_scb_free(struct ahc_softc *ahc, struct scb *scb)
  1155. {
  1156. ahc->flags &= ~AHC_RESOURCE_SHORTAGE;
  1157. }
  1159. int ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg);
  1160. void ahc_platform_free(struct ahc_softc *ahc);
  1161. void ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb);
  1162. static __inline void ahc_freeze_scb(struct scb *scb);
  1163. static __inline void
  1164. ahc_freeze_scb(struct scb *scb)
  1165. {
  1166. /* Noting to do here for linux */
  1167. }
  1169. void ahc_platform_set_tags(struct ahc_softc *ahc,
  1170.       struct ahc_devinfo *devinfo, ahc_queue_alg);
  1171. int ahc_platform_abort_scbs(struct ahc_softc *ahc, int target,
  1172. char channel, int lun, u_int tag,
  1173. role_t role, uint32_t status);
  1174. void ahc_linux_isr(int irq, void *dev_id, struct pt_regs * regs);
  1175. void ahc_platform_flushwork(struct ahc_softc *ahc);
  1176. int ahc_softc_comp(struct ahc_softc *, struct ahc_softc *);
  1177. void ahc_done(struct ahc_softc*, struct scb*);
  1178. void ahc_send_async(struct ahc_softc *, char channel,
  1179.        u_int target, u_int lun, ac_code, void *);
  1180. void ahc_print_path(struct ahc_softc *, struct scb *);
  1181. void ahc_platform_dump_card_state(struct ahc_softc *ahc);
  1183. #ifdef CONFIG_PCI
  1184. #define AHC_PCI_CONFIG 1
  1185. #else
  1186. #define AHC_PCI_CONFIG 0
  1187. #endif
  1188. #define bootverbose aic7xxx_verbose
  1189. extern int aic7xxx_verbose;
  1190. #endif /* _AIC7XXX_LINUX_H_ */