| /* | |
| * | |
| * Linux MegaRAID device driver | |
| * | |
| * Copyright (c) 2003-2004 LSI Logic Corporation. | |
| * | |
| * This program is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU General Public License | |
| * as published by the Free Software Foundation; either version | |
| * 2 of the License, or (at your option) any later version. | |
| * | |
| * FILE : mega_common.h | |
| * | |
| * Libaray of common routine used by all low-level megaraid drivers | |
| */ | |
| #ifndef _MEGA_COMMON_H_ | |
| #define _MEGA_COMMON_H_ | |
| #include <linux/kernel.h> | |
| #include <linux/types.h> | |
| #include <linux/pci.h> | |
| #include <linux/spinlock.h> | |
| #include <linux/interrupt.h> | |
| #include <linux/delay.h> | |
| #include <linux/blkdev.h> | |
| #include <linux/list.h> | |
| #include <linux/moduleparam.h> | |
| #include <linux/dma-mapping.h> | |
| #include <asm/semaphore.h> | |
| #include <scsi/scsi.h> | |
| #include <scsi/scsi_cmnd.h> | |
| #include <scsi/scsi_device.h> | |
| #include <scsi/scsi_host.h> | |
| #define LSI_MAX_CHANNELS 16 | |
| #define LSI_MAX_LOGICAL_DRIVES_64LD (64+1) | |
| #define HBA_SIGNATURE_64_BIT 0x299 | |
| #define PCI_CONF_AMISIG64 0xa4 | |
| #define MEGA_SCSI_INQ_EVPD 1 | |
| #define MEGA_INVALID_FIELD_IN_CDB 0x24 | |
| /** | |
| * scb_t - scsi command control block | |
| * @param ccb : command control block for individual driver | |
| * @param list : list of control blocks | |
| * @param gp : general purpose field for LLDs | |
| * @param sno : all SCBs have a serial number | |
| * @param scp : associated scsi command | |
| * @param state : current state of scb | |
| * @param dma_dir : direction of data transfer | |
| * @param dma_type : transfer with sg list, buffer, or no data transfer | |
| * @param dev_channel : actual channel on the device | |
| * @param dev_target : actual target on the device | |
| * @param status : completion status | |
| * | |
| * This is our central data structure to issue commands the each driver. | |
| * Driver specific data structures are maintained in the ccb field. | |
| * scb provides a field 'gp', which can be used by LLD for its own purposes | |
| * | |
| * dev_channel and dev_target must be initialized with the actual channel and | |
| * target on the controller. | |
| */ | |
| typedef struct { | |
| caddr_t ccb; | |
| struct list_head list; | |
| unsigned long gp; | |
| unsigned int sno; | |
| struct scsi_cmnd *scp; | |
| uint32_t state; | |
| uint32_t dma_direction; | |
| uint32_t dma_type; | |
| uint16_t dev_channel; | |
| uint16_t dev_target; | |
| uint32_t status; | |
| } scb_t; | |
| /* | |
| * SCB states as it transitions from one state to another | |
| */ | |
| #define SCB_FREE 0x0000 /* on the free list */ | |
| #define SCB_ACTIVE 0x0001 /* off the free list */ | |
| #define SCB_PENDQ 0x0002 /* on the pending queue */ | |
| #define SCB_ISSUED 0x0004 /* issued - owner f/w */ | |
| #define SCB_ABORT 0x0008 /* Got an abort for this one */ | |
| #define SCB_RESET 0x0010 /* Got a reset for this one */ | |
| /* | |
| * DMA types for scb | |
| */ | |
| #define MRAID_DMA_NONE 0x0000 /* no data transfer for this command */ | |
| #define MRAID_DMA_WSG 0x0001 /* data transfer using a sg list */ | |
| #define MRAID_DMA_WBUF 0x0002 /* data transfer using a contiguous buffer */ | |
| /** | |
| * struct adapter_t - driver's initialization structure | |
| * @param dpc_h : tasklet handle | |
| * @param pdev : pci configuration pointer for kernel | |
| * @param host : pointer to host structure of mid-layer | |
| * @param lock : synchronization lock for mid-layer and driver | |
| * @param quiescent : driver is quiescent for now. | |
| * @param outstanding_cmds : number of commands pending in the driver | |
| * @param kscb_list : pointer to the bulk of SCBs pointers for IO | |
| * @param kscb_pool : pool of free scbs for IO | |
| * @param kscb_pool_lock : lock for pool of free scbs | |
| * @param pend_list : pending commands list | |
| * @param pend_list_lock : exlusion lock for pending commands list | |
| * @param completed_list : list of completed commands | |
| * @param completed_list_lock : exclusion lock for list of completed commands | |
| * @param sglen : max sg elements supported | |
| * @param device_ids : to convert kernel device addr to our devices. | |
| * @param raid_device : raid adapter specific pointer | |
| * @param max_channel : maximum channel number supported - inclusive | |
| * @param max_target : max target supported - inclusive | |
| * @param max_lun : max lun supported - inclusive | |
| * @param unique_id : unique identifier for each adapter | |
| * @param irq : IRQ for this adapter | |
| * @param ito : internal timeout value, (-1) means no timeout | |
| * @param ibuf : buffer to issue internal commands | |
| * @param ibuf_dma_h : dma handle for the above buffer | |
| * @param uscb_list : SCB pointers for user cmds, common mgmt module | |
| * @param uscb_pool : pool of SCBs for user commands | |
| * @param uscb_pool_lock : exclusion lock for these SCBs | |
| * @param max_cmds : max outstanding commands | |
| * @param fw_version : firmware version | |
| * @param bios_version : bios version | |
| * @param max_cdb_sz : biggest CDB size supported. | |
| * @param ha : is high availability present - clustering | |
| * @param init_id : initiator ID, the default value should be 7 | |
| * @param max_sectors : max sectors per request | |
| * @param cmd_per_lun : max outstanding commands per LUN | |
| * @param being_detached : set when unloading, no more mgmt calls | |
| * | |
| * | |
| * mraid_setup_device_map() can be called anytime after the device map is | |
| * available and MRAID_GET_DEVICE_MAP() can be called whenever the mapping is | |
| * required, usually from LLD's queue entry point. The formar API sets up the | |
| * MRAID_IS_LOGICAL(adapter_t *, struct scsi_cmnd *) to find out if the | |
| * device in question is a logical drive. | |
| * | |
| * quiescent flag should be set by the driver if it is not accepting more | |
| * commands | |
| * | |
| * NOTE: The fields of this structures are placed to minimize cache misses | |
| */ | |
| // amount of space required to store the bios and firmware version strings | |
| #define VERSION_SIZE 16 | |
| typedef struct { | |
| struct tasklet_struct dpc_h; | |
| struct pci_dev *pdev; | |
| struct Scsi_Host *host; | |
| spinlock_t lock; | |
| uint8_t quiescent; | |
| int outstanding_cmds; | |
| scb_t *kscb_list; | |
| struct list_head kscb_pool; | |
| spinlock_t kscb_pool_lock; | |
| struct list_head pend_list; | |
| spinlock_t pend_list_lock; | |
| struct list_head completed_list; | |
| spinlock_t completed_list_lock; | |
| uint16_t sglen; | |
| int device_ids[LSI_MAX_CHANNELS] | |
| [LSI_MAX_LOGICAL_DRIVES_64LD]; | |
| caddr_t raid_device; | |
| uint8_t max_channel; | |
| uint16_t max_target; | |
| uint8_t max_lun; | |
| uint32_t unique_id; | |
| int irq; | |
| uint8_t ito; | |
| caddr_t ibuf; | |
| dma_addr_t ibuf_dma_h; | |
| scb_t *uscb_list; | |
| struct list_head uscb_pool; | |
| spinlock_t uscb_pool_lock; | |
| int max_cmds; | |
| uint8_t fw_version[VERSION_SIZE]; | |
| uint8_t bios_version[VERSION_SIZE]; | |
| uint8_t max_cdb_sz; | |
| uint8_t ha; | |
| uint16_t init_id; | |
| uint16_t max_sectors; | |
| uint16_t cmd_per_lun; | |
| atomic_t being_detached; | |
| } adapter_t; | |
| #define SCSI_FREE_LIST_LOCK(adapter) (&adapter->kscb_pool_lock) | |
| #define USER_FREE_LIST_LOCK(adapter) (&adapter->uscb_pool_lock) | |
| #define PENDING_LIST_LOCK(adapter) (&adapter->pend_list_lock) | |
| #define COMPLETED_LIST_LOCK(adapter) (&adapter->completed_list_lock) | |
| // conversion from scsi command | |
| #define SCP2HOST(scp) (scp)->device->host // to host | |
| #define SCP2HOSTDATA(scp) SCP2HOST(scp)->hostdata // to soft state | |
| #define SCP2CHANNEL(scp) (scp)->device->channel // to channel | |
| #define SCP2TARGET(scp) (scp)->device->id // to target | |
| #define SCP2LUN(scp) (scp)->device->lun // to LUN | |
| // generic macro to convert scsi command and host to controller's soft state | |
| #define SCSIHOST2ADAP(host) (((caddr_t *)(host->hostdata))[0]) | |
| #define SCP2ADAPTER(scp) (adapter_t *)SCSIHOST2ADAP(SCP2HOST(scp)) | |
| /** | |
| * MRAID_GET_DEVICE_MAP - device ids | |
| * @param adp - Adapter's soft state | |
| * @param scp - mid-layer scsi command pointer | |
| * @param p_chan - physical channel on the controller | |
| * @param target - target id of the device or logical drive number | |
| * @param islogical - set if the command is for the logical drive | |
| * | |
| * Macro to retrieve information about device class, logical or physical and | |
| * the corresponding physical channel and target or logical drive number | |
| **/ | |
| #define MRAID_IS_LOGICAL(adp, scp) \ | |
| (SCP2CHANNEL(scp) == (adp)->max_channel) ? 1 : 0 | |
| #define MRAID_IS_LOGICAL_SDEV(adp, sdev) \ | |
| (sdev->channel == (adp)->max_channel) ? 1 : 0 | |
| #define MRAID_GET_DEVICE_MAP(adp, scp, p_chan, target, islogical) \ | |
| /* \ | |
| * Is the request coming for the virtual channel \ | |
| */ \ | |
| islogical = MRAID_IS_LOGICAL(adp, scp); \ | |
| \ | |
| /* \ | |
| * Get an index into our table of drive ids mapping \ | |
| */ \ | |
| if (islogical) { \ | |
| p_chan = 0xFF; \ | |
| target = \ | |
| (adp)->device_ids[(adp)->max_channel][SCP2TARGET(scp)]; \ | |
| } \ | |
| else { \ | |
| p_chan = ((adp)->device_ids[SCP2CHANNEL(scp)] \ | |
| [SCP2TARGET(scp)] >> 8) & 0xFF; \ | |
| target = ((adp)->device_ids[SCP2CHANNEL(scp)] \ | |
| [SCP2TARGET(scp)] & 0xFF); \ | |
| } | |
| /* | |
| * ### Helper routines ### | |
| */ | |
| #define LSI_DBGLVL mraid_debug_level // each LLD must define a global | |
| // mraid_debug_level | |
| #ifdef DEBUG | |
| #if defined (_ASSERT_PANIC) | |
| #define ASSERT_ACTION panic | |
| #else | |
| #define ASSERT_ACTION printk | |
| #endif | |
| #define ASSERT(expression) \ | |
| if (!(expression)) { \ | |
| ASSERT_ACTION("assertion failed:(%s), file: %s, line: %d:%s\n", \ | |
| #expression, __FILE__, __LINE__, __FUNCTION__); \ | |
| } | |
| #else | |
| #define ASSERT(expression) | |
| #endif | |
| /* | |
| * struct mraid_pci_blk - structure holds DMA memory block info | |
| * @param vaddr : virtual address to a memory block | |
| * @param dma_addr : DMA handle to a memory block | |
| * | |
| * This structure is filled up for the caller. It is the responsibilty of the | |
| * caller to allocate this array big enough to store addresses for all | |
| * requested elements | |
| */ | |
| struct mraid_pci_blk { | |
| caddr_t vaddr; | |
| dma_addr_t dma_addr; | |
| }; | |
| #endif // _MEGA_COMMON_H_ | |
| // vim: set ts=8 sw=8 tw=78: |