freebsd-nq/sys/dev/hptmv/mvSata.h

/*
 * Copyright (c) 2004-2005 MARVELL SEMICONDUCTOR ISRAEL, LTD.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */
#ifndef __INCmvSatah
#define __INCmvSatah

#ifndef SUPPORT_MV_SATA_GEN_1
#define SUPPORT_MV_SATA_GEN_1 1
#endif

#ifndef SUPPORT_MV_SATA_GEN_2
#define SUPPORT_MV_SATA_GEN_2 0
#endif

#ifndef SUPPORT_MV_SATA_GEN_2E
#define SUPPORT_MV_SATA_GEN_2E 0
#endif

#if (SUPPORT_MV_SATA_GEN_1 + SUPPORT_MV_SATA_GEN_2 + SUPPORT_MV_SATA_GEN_2E) > 1

#define MV_SATA_GEN_1(x) ((x)->sataAdapterGeneration==1)
#define MV_SATA_GEN_2(x) ((x)->sataAdapterGeneration>=2)
#define MV_SATA_GEN_2E(x) ((x)->sataAdapterGeneration==3)

#elif SUPPORT_MV_SATA_GEN_1==1

#define MV_SATA_GEN_1(x) 1
#define MV_SATA_GEN_2(x) 0
#define MV_SATA_GEN_2E(x) 0

#elif SUPPORT_MV_SATA_GEN_2==1

#define MV_SATA_GEN_1(x) 0
#define MV_SATA_GEN_2(x) 1
#define MV_SATA_GEN_2E(x) 0

#elif SUPPORT_MV_SATA_GEN_2E==1

#define MV_SATA_GEN_1(x)  0
#define MV_SATA_GEN_2(x)  1 /* gen2E impiles gen2 */
#define MV_SATA_GEN_2E(x) 1

#else 
#error "Which IC do you support?"
#endif

/* Definitions */
/* MV88SX50XX specific defines */
#define MV_SATA_VENDOR_ID		   				0x11AB
#define MV_SATA_DEVICE_ID_5080			   		0x5080
#define MV_SATA_DEVICE_ID_5081			   		0x5081
#define MV_SATA_DEVICE_ID_6080			   		0x6080
#define MV_SATA_DEVICE_ID_6081			   		0x6081

#if defined(RR2310) || defined(RR1740) || defined(RR2210) || defined (RR2522)
#define MV_SATA_CHANNELS_NUM					4
#define MV_SATA_UNITS_NUM						1
#else 
#define MV_SATA_CHANNELS_NUM					8
#define MV_SATA_UNITS_NUM						2
#endif

#define MV_SATA_PCI_BAR0_SPACE_SIZE				(1<<18) /* 256 Kb*/

#define CHANNEL_QUEUE_LENGTH					32
#define CHANNEL_QUEUE_MASK					    0x1F

#define MV_EDMA_QUEUE_LENGTH					32	/* Up to 32 outstanding	 */
                        							/* commands per SATA channel*/
#define MV_EDMA_QUEUE_MASK                      0x1F
#define MV_EDMA_REQUEST_QUEUE_SIZE				1024 /* 32*32 = 1KBytes */
#define MV_EDMA_RESPONSE_QUEUE_SIZE				256  /* 32*8 = 256 Bytes */

#define MV_EDMA_REQUEST_ENTRY_SIZE				32
#define MV_EDMA_RESPONSE_ENTRY_SIZE				8

#define MV_EDMA_PRD_ENTRY_SIZE					16		/* 16Bytes*/
#define MV_EDMA_PRD_NO_SNOOP_FLAG				0x00000001 /* MV_BIT0 */
#define MV_EDMA_PRD_EOT_FLAG					0x00008000 /* MV_BIT15 */

#define MV_ATA_IDENTIFY_DEV_DATA_LENGTH  		256	/* number of words(2 byte)*/
#define MV_ATA_MODEL_NUMBER_LEN					40
#define ATA_SECTOR_SIZE							512
/* Log messages level defines */
#define MV_DEBUG								0x1
#define MV_DEBUG_INIT							0x2
#define MV_DEBUG_INTERRUPTS						0x4
#define MV_DEBUG_SATA_LINK						0x8
#define MV_DEBUG_UDMA_COMMAND					0x10
#define MV_DEBUG_NON_UDMA_COMMAND				0x20
#define MV_DEBUG_ERROR							0x40


/* Typedefs    */
typedef enum mvUdmaType  
{
	MV_UDMA_TYPE_READ, MV_UDMA_TYPE_WRITE
} MV_UDMA_TYPE;

typedef enum mvFlushType 
{
	MV_FLUSH_TYPE_CALLBACK, MV_FLUSH_TYPE_NONE 
} MV_FLUSH_TYPE;

typedef enum mvCompletionType  
{
	MV_COMPLETION_TYPE_NORMAL, MV_COMPLETION_TYPE_ERROR,
	MV_COMPLETION_TYPE_ABORT 
} MV_COMPLETION_TYPE;

typedef enum mvEventType 
{
	MV_EVENT_TYPE_ADAPTER_ERROR, MV_EVENT_TYPE_SATA_CABLE 
} MV_EVENT_TYPE;

typedef enum mvEdmaMode 
{
	MV_EDMA_MODE_QUEUED,
	MV_EDMA_MODE_NOT_QUEUED,
	MV_EDMA_MODE_NATIVE_QUEUING
} MV_EDMA_MODE;

typedef enum mvEdmaQueueResult
{
	MV_EDMA_QUEUE_RESULT_OK = 0,
	MV_EDMA_QUEUE_RESULT_EDMA_DISABLED,
	MV_EDMA_QUEUE_RESULT_FULL,
	MV_EDMA_QUEUE_RESULT_BAD_LBA_ADDRESS,
	MV_EDMA_QUEUE_RESULT_BAD_PARAMS
} MV_EDMA_QUEUE_RESULT;

typedef enum mvQueueCommandResult
{
	MV_QUEUE_COMMAND_RESULT_OK = 0,
	MV_QUEUE_COMMAND_RESULT_QUEUED_MODE_DISABLED,
	MV_QUEUE_COMMAND_RESULT_FULL,
	MV_QUEUE_COMMAND_RESULT_BAD_LBA_ADDRESS,
	MV_QUEUE_COMMAND_RESULT_BAD_PARAMS
} MV_QUEUE_COMMAND_RESULT;

typedef enum mvNonUdmaProtocol
{
    MV_NON_UDMA_PROTOCOL_NON_DATA,
    MV_NON_UDMA_PROTOCOL_PIO_DATA_IN,
    MV_NON_UDMA_PROTOCOL_PIO_DATA_OUT
} MV_NON_UDMA_PROTOCOL;


struct mvDmaRequestQueueEntry;
struct mvDmaResponseQueueEntry;
struct mvDmaCommandEntry;

struct mvSataAdapter;
struct mvStorageDevRegisters;

typedef MV_BOOLEAN (* HPTLIBAPI mvSataCommandCompletionCallBack_t)(struct mvSataAdapter *,
														 MV_U8,
                                                         MV_COMPLETION_TYPE,
														 MV_VOID_PTR, MV_U16,
														 MV_U32,
											    struct mvStorageDevRegisters SS_SEG*);

typedef enum mvQueuedCommandType 
{
	MV_QUEUED_COMMAND_TYPE_UDMA,
	MV_QUEUED_COMMAND_TYPE_NONE_UDMA
} MV_QUEUED_COMMAND_TYPE;

typedef struct mvUdmaCommandParams 
{
	MV_UDMA_TYPE readWrite;
	MV_BOOLEAN   isEXT;
	MV_U32       lowLBAAddress;
	MV_U16       highLBAAddress;
	MV_U16       numOfSectors;
	MV_U32       prdLowAddr;
	MV_U32       prdHighAddr;
	mvSataCommandCompletionCallBack_t callBack;
	MV_VOID_PTR  commandId;
} MV_UDMA_COMMAND_PARAMS;

typedef struct mvNoneUdmaCommandParams 
{
  	MV_NON_UDMA_PROTOCOL protocolType;
	MV_BOOLEAN  isEXT;
	MV_U16_PTR	bufPtr;
	MV_U32		count;
	MV_U16		features;
	MV_U16		sectorCount;
	MV_U16		lbaLow;
	MV_U16		lbaMid;
	MV_U16		lbaHigh;
	MV_U8		device;
	MV_U8		command;
    mvSataCommandCompletionCallBack_t callBack;
	MV_VOID_PTR  commandId;
} MV_NONE_UDMA_COMMAND_PARAMS;

typedef struct mvQueueCommandInfo
{
	MV_QUEUED_COMMAND_TYPE	type;
	union
	{
		MV_UDMA_COMMAND_PARAMS		udmaCommand;
		MV_NONE_UDMA_COMMAND_PARAMS	NoneUdmaCommand;
    } commandParams;
} MV_QUEUE_COMMAND_INFO;

/* The following structure is for the Core Driver internal usage */
typedef struct mvQueuedCommandEntry 
{
    MV_BOOLEAN   isFreeEntry;
    MV_U8        commandTag;
	struct mvQueuedCommandEntry	*next;
	struct mvQueuedCommandEntry	*prev;
	MV_QUEUE_COMMAND_INFO	commandInfo;
} MV_QUEUED_COMMAND_ENTRY;

/* The following structures are part of the Core Driver API */
typedef struct mvSataChannel 
{
	/* Fields set by Intermediate Application Layer */
	MV_U8                       channelNumber;
	MV_BOOLEAN                  waitingForInterrupt;
	MV_BOOLEAN                  lba48Address; 
	MV_BOOLEAN                  maxReadTransfer;
	struct mvDmaRequestQueueEntry SS_SEG *requestQueue;
	struct mvDmaResponseQueueEntry SS_SEG *responseQueue;
	MV_U32                      requestQueuePciHiAddress;
	MV_U32                      requestQueuePciLowAddress;
	MV_U32                      responseQueuePciHiAddress;
	MV_U32                      responseQueuePciLowAddress;
	/* Fields set by CORE driver */
	struct mvSataAdapter        *mvSataAdapter;
	MV_OS_SEMAPHORE             semaphore;
	MV_U32                      eDmaRegsOffset;
	MV_U16                      identifyDevice[MV_ATA_IDENTIFY_DEV_DATA_LENGTH];
	MV_BOOLEAN                  EdmaActive;
	MV_EDMA_MODE                queuedDMA;
	MV_U8                       outstandingCommands;
	MV_BOOLEAN					workAroundDone;
	struct mvQueuedCommandEntry	commandsQueue[CHANNEL_QUEUE_LENGTH];
	struct mvQueuedCommandEntry	*commandsQueueHead;
	struct mvQueuedCommandEntry	*commandsQueueTail;
	MV_BOOLEAN					queueCommandsEnabled;
	MV_U8                       noneUdmaOutstandingCommands;
	MV_U8                       EdmaQueuedCommands;
    MV_U32                      freeIDsStack[CHANNEL_QUEUE_LENGTH];
	MV_U32                      freeIDsNum;
	MV_U32                      reqInPtr;
	MV_U32                      rspOutPtr;
} MV_SATA_CHANNEL;

typedef struct mvSataAdapter
{
	/* Fields set by Intermediate Application Layer */
	MV_U32            adapterId;
	MV_U8             pcbVersion;
    MV_U8             pciConfigRevisionId;
    MV_U16            pciConfigDeviceId;
	MV_VOID_PTR		  IALData;
	MV_BUS_ADDR_T     adapterIoBaseAddress;
	MV_U32            intCoalThre[MV_SATA_UNITS_NUM];
	MV_U32            intTimeThre[MV_SATA_UNITS_NUM];
	MV_BOOLEAN        (* HPTLIBAPI mvSataEventNotify)(struct mvSataAdapter *,
										   MV_EVENT_TYPE,
										   MV_U32, MV_U32); 
	MV_SATA_CHANNEL   *sataChannel[MV_SATA_CHANNELS_NUM];
	MV_U32            pciCommand; 
	MV_U32            pciSerrMask;
	MV_U32            pciInterruptMask;

	/* Fields set by CORE driver */
	MV_OS_SEMAPHORE   semaphore;
	MV_U32			  mainMask;	
	MV_OS_SEMAPHORE	  interruptsMaskSem;
    MV_BOOLEAN        implementA0Workarounds;
    MV_BOOLEAN        implement50XXB0Workarounds;
	MV_BOOLEAN        implement50XXB1Workarounds;
	MV_BOOLEAN        implement50XXB2Workarounds;
	MV_BOOLEAN        implement60X1A0Workarounds;
	MV_BOOLEAN        implement60X1A1Workarounds;
	MV_BOOLEAN        implement60X1B0Workarounds;
	MV_BOOLEAN		  implement7042A0Workarounds;
	MV_BOOLEAN		  implement7042A1Workarounds;
	MV_U8			  sataAdapterGeneration;
	MV_BOOLEAN		isPEX;
	MV_U8             failLEDMask;
    MV_U8			  signalAmps[MV_SATA_CHANNELS_NUM];
	MV_U8			  pre[MV_SATA_CHANNELS_NUM];
    MV_BOOLEAN        staggaredSpinup[MV_SATA_CHANNELS_NUM]; /* For 60x1 only */
} MV_SATA_ADAPTER;

typedef struct mvSataAdapterStatus
{
	/* Fields set by CORE driver */
	MV_BOOLEAN		channelConnected[MV_SATA_CHANNELS_NUM];
	MV_U32			pciDLLStatusAndControlRegister;
	MV_U32			pciCommandRegister;
	MV_U32			pciModeRegister;
	MV_U32			pciSERRMaskRegister;
	MV_U32			intCoalThre[MV_SATA_UNITS_NUM];
	MV_U32			intTimeThre[MV_SATA_UNITS_NUM];
	MV_U32			R00StatusBridgePortRegister[MV_SATA_CHANNELS_NUM];
}MV_SATA_ADAPTER_STATUS;


typedef struct mvSataChannelStatus
{
	/* Fields set by CORE driver */
	MV_BOOLEAN		isConnected;
	MV_U8			modelNumber[MV_ATA_MODEL_NUMBER_LEN];
	MV_BOOLEAN		DMAEnabled;
	MV_EDMA_MODE	queuedDMA;
	MV_U8			outstandingCommands;
	MV_U32			EdmaConfigurationRegister;
	MV_U32			EdmaRequestQueueBaseAddressHighRegister;
	MV_U32			EdmaRequestQueueInPointerRegister;
	MV_U32			EdmaRequestQueueOutPointerRegister;
	MV_U32			EdmaResponseQueueBaseAddressHighRegister;
	MV_U32			EdmaResponseQueueInPointerRegister;
	MV_U32			EdmaResponseQueueOutPointerRegister;
	MV_U32			EdmaCommandRegister;
	MV_U32			PHYModeRegister;
}MV_SATA_CHANNEL_STATUS;

/* this structure used by the IAL defines the PRD entries used by the EDMA HW */
typedef struct mvSataEdmaPRDEntry
{
	volatile MV_U32	lowBaseAddr;
	volatile MV_U16	byteCount;
	volatile MV_U16	flags;
	volatile MV_U32 highBaseAddr;
	volatile MV_U32 reserved;
}MV_SATA_EDMA_PRD_ENTRY;

/* API Functions */

/* CORE driver Adapter Management */
MV_BOOLEAN HPTLIBAPI mvSataInitAdapter(MV_SATA_ADAPTER *pAdapter);

MV_BOOLEAN HPTLIBAPI mvSataShutdownAdapter(MV_SATA_ADAPTER *pAdapter);

MV_BOOLEAN HPTLIBAPI mvSataGetAdapterStatus(MV_SATA_ADAPTER *pAdapter,
								  MV_SATA_ADAPTER_STATUS *pAdapterStatus);

MV_U32  HPTLIBAPI mvSataReadReg(MV_SATA_ADAPTER *pAdapter, MV_U32 regOffset);

MV_VOID HPTLIBAPI mvSataWriteReg(MV_SATA_ADAPTER *pAdapter, MV_U32 regOffset,  
					   MV_U32 regValue);

MV_VOID HPTLIBAPI mvEnableAutoFlush(MV_VOID);
MV_VOID HPTLIBAPI mvDisableAutoFlush(MV_VOID);


/* CORE driver SATA Channel Management */
MV_BOOLEAN HPTLIBAPI mvSataConfigureChannel(MV_SATA_ADAPTER *pAdapter,
								  MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataRemoveChannel(MV_SATA_ADAPTER *pAdapter, MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataIsStorageDeviceConnected(MV_SATA_ADAPTER *pAdapter,
										  MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataChannelHardReset(MV_SATA_ADAPTER *pAdapter,
								  MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataConfigEdmaMode(MV_SATA_ADAPTER *pAdapter, MV_U8 channelIndex,
								MV_EDMA_MODE eDmaMode, MV_U8 maxQueueDepth);

MV_BOOLEAN HPTLIBAPI mvSataEnableChannelDma(MV_SATA_ADAPTER *pAdapter,
								  MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataDisableChannelDma(MV_SATA_ADAPTER *pAdapter,
								   MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataFlushDmaQueue(MV_SATA_ADAPTER *pAdapter, MV_U8 channelIndex, 
							   MV_FLUSH_TYPE flushType);

MV_U8 HPTLIBAPI mvSataNumOfDmaCommands(MV_SATA_ADAPTER *pAdapter, MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataSetIntCoalParams (MV_SATA_ADAPTER *pAdapter, MV_U8 sataUnit,
								   MV_U32 intCoalThre, MV_U32 intTimeThre);

MV_BOOLEAN HPTLIBAPI mvSataSetChannelPhyParams(MV_SATA_ADAPTER *pAdapter,
									 MV_U8 channelIndex,
									 MV_U8 signalAmps, MV_U8 pre);

MV_BOOLEAN HPTLIBAPI mvSataChannelPhyShutdown(MV_SATA_ADAPTER *pAdapter,
									MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataChannelPhyPowerOn(MV_SATA_ADAPTER *pAdapter,
									MV_U8 channelIndex);

MV_BOOLEAN HPTLIBAPI mvSataChannelSetEdmaLoopBackMode(MV_SATA_ADAPTER *pAdapter,
											MV_U8 channelIndex,
											MV_BOOLEAN loopBackOn);

MV_BOOLEAN HPTLIBAPI mvSataGetChannelStatus(MV_SATA_ADAPTER *pAdapter, MV_U8 channelIndex,
								  MV_SATA_CHANNEL_STATUS *pChannelStatus);

MV_QUEUE_COMMAND_RESULT HPTLIBAPI mvSataQueueCommand(MV_SATA_ADAPTER *pAdapter,
										   MV_U8 channelIndex,
										   MV_QUEUE_COMMAND_INFO SS_SEG *pCommandParams);

/* Interrupt Service Routine */
MV_BOOLEAN HPTLIBAPI mvSataInterruptServiceRoutine(MV_SATA_ADAPTER *pAdapter);

MV_BOOLEAN HPTLIBAPI mvSataMaskAdapterInterrupt(MV_SATA_ADAPTER *pAdapter);

MV_BOOLEAN HPTLIBAPI mvSataUnmaskAdapterInterrupt(MV_SATA_ADAPTER *pAdapter);

/* Command Completion and Event Notification (user implemented) */
MV_BOOLEAN HPTLIBAPI mvSataEventNotify(MV_SATA_ADAPTER *, MV_EVENT_TYPE ,
							 MV_U32, MV_U32);

/*
 * Staggered spin-ip support and SATA interface speed control
 * (relevant for 60x1 adapters)
 */
MV_BOOLEAN HPTLIBAPI mvSataEnableStaggeredSpinUpAll (MV_SATA_ADAPTER *pAdapter);
MV_BOOLEAN HPTLIBAPI mvSataDisableStaggeredSpinUpAll (MV_SATA_ADAPTER *pAdapter);

#endif