_dochapi.h

H3 M-system NAND flash driver in Linux OS, M-DOC driver

/* Parameters:                                                          */
/*      irHandle        : Socket number (zero based)                    */
/*		irFlags			: DOCH_IPL_MODE_NORMAL_RAM                      */
/*						  DOCH_IPL_MODE_PAGED_RAM						*/
/*						  DOCH_IPL_MODE_VIRTUAL_RAM						*/
/*						  DOCH_IPL_MODE_CS_DELAY						*/
/*						  DOCH_IPL_MODE_ADDRESS_SHIFT_IN_AFFECT			*/
/*						  DOCH_IPL_MODE_ACTIVE_SWAP_BYTES				*/
/*						  DOCH_IPL_MODE_8KB_WINDOW						*/
/*						  DOCH_IPL_WRITE_FIRST_CHUNK					*/
/*		irCount			: Max IPL size						            */
/*						  Up to 32KB  for Normal Mode	                */
/*						  Up to 128KB for Virtual Mode	                */
/*						  Up to 256KB	for Paged Mode		            */
/*		irLength		: Current chunk length (in sectors)				*/
/*		irData			: Pointer to user buffer (length defined by		*/
/*						  irLength)										*/
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_EXT_DEVICE_CTRL									*/
/*			DOCH_VSCMD_WRITE_PARTITION									*/
/* ATA sub-command:														*/
/*			DOCH_SET_CUSTOM_PARAM										*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error  : 0 on success, otherwise failed                  */
/*----------------------------------------------------------------------*/
#define flDOCHWriteIPL(ioreq) bdCallDOCH(SDK_WRITE_IPL, ioreq)

/*----------------------------------------------------------------------*/
/*	           f l D O C H R e a d I P L								*/
/*                                                                      */
/* Read specified sectors from IPL partition.							*/
/*                                                                      */
/* Parameters:                                                          */
/*      irHandle        : Socket number (zero based)                    */
/*		irCount			: First sector to read	                        */
/*		irLength		: Number of sectors to read						*/
/*		irData			: Pointer to user buffer (length defined by		*/
/*						  irLength)										*/
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_EXT_DEVICE_CTRL									*/
/*			DOCH_VSCMD_WRITE_PARTITION									*/
/* ATA sub-command:														*/
/*			DOCH_SET_CUSTOM_PARAM										*/
/*																		*/
/* Returns:                                                             */
/*		irFlags		: DOCH_IPL_MODE_NORMAL_RAM							*/
/*					  DOCH_IPL_MODE_PAGED_RAM							*/
/*					  DOCH_IPL_MODE_VIRTUAL_RAM							*/
/*					  DOCH_IPL_MODE_CS_DELAY							*/
/*					  DOCH_IPL_MODE_ADDRESS_SHIFT_IN_AFFECT				*/
/*					  DOCH_IPL_MODE_ACTIVE_SWAP_BYTES					*/
/*					  DOCH_IPL_MODE_8KB_WINDOW							*/
/*      DOCH_Error  : 0 on success, otherwise failed					*/
/*----------------------------------------------------------------------*/
#define flDOCHReadIPL(ioreq) bdCallDOCH(SDK_READ_IPL, ioreq)

/*----------------------------------------------------------------------*/
/*		 f l D O C H R e a d P a r t i t i o n	S e c t o r s			*/
/*                                                                      */
/* Reads sectors by sector no from a specific partition                 */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)		        */
/*        irData          : Address of user buffer to read into         */
/*        irSectorNo      : First sector no. to read.                   */
/*        irSectorCount   : Number of consecutive sectors to read       */
/*        irFlags	      : DOCH_USE_DMA								*/
/*							DOCH_USE_BURST								*/
/*							Note: 4 methods of data transfer are		*/
/*							available:									*/
/*								Normal transfer							*/
/*								DMA    transfer							*/
/*								Burst  transfer							*/
/*								DMA & Burst transfer					*/
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_READ_PARTITION									*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error      : 0 on success, otherwise failed              */
/*        irSectorCount   : Number of sectors NOT read (in case of an	*/
/*							error - this number may not be accurate)	*/
/*----------------------------------------------------------------------*/
#define flDOCHReadPartitionSectors(ioreq) bdCallDOCH(SDK_READ_PARTITION_SECTORS, ioreq)

/*----------------------------------------------------------------------*/
/*        D O C H W r i t e P a r t i t i o n S e c t o r s				*/
/*                                                                      */
/* Writes sectors by sector no to a specific partition                  */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)		        */
/*        irData          : Address of user buffer to write from        */
/*        irSectorNo      : First sector no. to write                   */
/*        irSectorCount   : Number of consecutive sectors to write		*/
/*        irFlags	      : DOCH_USE_DMA								*/
/*							DOCH_USE_BURST								*/
/*							Note: 4 methods of data transfer are		*/
/*							available:									*/
/*								Normal transfer							*/
/*								DMA    transfer							*/
/*								Burst  transfer							*/
/*								DMA & Burst transfer					*/
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_WRITE_PARTITION									*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error      : 0 on success, otherwise failed              */
/*        irSectorCount   : Number of sectors NOT read (in case of an	*/
/*							error - this number may not be accurate)	*/
/*----------------------------------------------------------------------*/
#define flDOCHWritePartitionSectors(ioreq) bdCallDOCH(SDK_WRITE_PARTITION_SECTORS, ioreq)

/*----------------------------------------------------------------------*/
/*          f l D O C H W r i t e A n d L o c k							*/
/*                                                                      */
/* Writes sectors by sector no to a specific partition                  */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irData          : Address of user buffer to write from        */
/*        irSectorNo      : First sector no. to write                   */
/*        irSectorCount   : Number of consecutive sectors to write      */
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_WRITE_PARTITION									*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error        : 0 on success, otherwise failed            */
/*        irSectorCount   : Number of sectors NOT read (in case of an	*/
/*							error - this number may not be accurate)	*/
/*----------------------------------------------------------------------*/
#define flDOCHWriteAndLock(ioreq) bdCallDOCH(SDK_WRITE_AND_LOCK, ioreq)

/*----------------------------------------------------------------------*/
/*           f l D O C H F r e e S e c t o r s							*/
/*                                                                      */
/* Marks absolute sectors by sector no. as free to be written           */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irSectorNo      : First sector no. to delete                  */
/*        irSectorCount   : Number of consecutive sectors to delete     */
/*        irFlags		  : DOCH_NORMAL_OPERATION					    */
/*							DOCH_IMMEDIATE_OPERATION					*/
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_ERASE_PARTITION_SECTORS							*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error      : 0 on success, otherwise failed              */
/*        irSectorCount   : Number of sectors actually deleted			*/
/*----------------------------------------------------------------------*/
#define flDOCHFreeSectors(ioreq) bdCallDOCH(SDK_FREE_SECTORS, ioreq)

/*----------------------------------------------------------------------*/
/*        f l D O C H W i p e S e c t o r s								*/
/*                                                                      */
/* Securely erase data in sectors										*/
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irSectorCount   : Number of sectors to transfer (1..2).		*/
/*        irData		  : 1..2 sectors with following layout:			*/
/*								- 1st 8bytes - reserved	as zeroes		*/
/*								- (FLDWord) : First sector to delete	*/ 
/*								  (FLDWord) : # of sectors to delete	*/ 
/*								- (FLDWord) : Second sector to delete	*/ 
/*								  (FLDWord) : # of sectors to delete	*/ 
/*								- ...									*/ 
/*								- (FLDWord) : Nth sector to delete		*/ 
/*								  (FLDWord) : # of sectors to delete	*/ 
/*							* Last transaction should have both start	*/
/*							  and length fields set to 0.				*/
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_PARTITION_MANAGEMENT								*/
/* ATA sub-command:														*/
/*			DOCH_SECURE_ERASE											*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error      : 0 on success, otherwise failed              */
/*----------------------------------------------------------------------*/
#define flDOCHWipeSectors(ioreq) bdCallDOCH(SDK_WIPE_SECTORS, ioreq)

/*----------------------------------------------------------------------*/
/*         f l D O C H P r e p a r e F o r W r i t e					*/
/*                                                                      */
/*	Signal to DOCH that these sectors are going to be over-written in	*/
/*	following write command												*/
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irSectorNo      : First sector no. to write                   */
/*        irSectorCount   : Number of consecutive sectors to write      */
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_OPTIMIZE_PARTITION_SECTORS						*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error        : 0 on success, otherwise failed            */
/*----------------------------------------------------------------------*/
#define flDOCHPrepareForWrite(ioreq) bdCallDOCH(SDK_PREPARE_FOR_WRITE, ioreq)

/*	Flexi-Flash	*/

/*----------------------------------------------------------------------*/
/*	        f l D O C H W r i t e F l e x i F a s t						*/
/*                                                                      */
/* Flexi-Flash Write Fast							                    */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irData          : Address of user buffer to write from        */
/*        irSectorNo      : First sector no. to write                   */
/*        irSectorCount   : Number of consecutive sectors to write      */
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_WRITE_FLEXI										*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error        : 0 on success, otherwise failed            */
/*        irSectorCount   : Number of sectors actually written          */
/*----------------------------------------------------------------------*/
#define flDOCHWriteFlexiFast(ioreq) bdCallDOCH(SDK_WRITE_FLEXI_FAST, ioreq)

/*----------------------------------------------------------------------*/
/*	       f l D O C H W r i t e F l e x i N o r m a l					*/
/*                                                                      */
/* Flexi-Flash Write Normal							                    */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irData          : Address of user buffer to write from        */
/*        irSectorNo      : First sector no. to write                   */
/*        irSectorCount   : Number of consecutive sectors to write     */
/*                                                                      */
/* ATA command:															*/
/*			DOCH_VSCMD_WRITE_FLEXI										*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error        : 0 on success, otherwise failed            */
/*        irSectorCount   : Number of sectors actually written          */
/*----------------------------------------------------------------------*/
#define flDOCHWriteFlexiNormal(ioreq) bdCallDOCH(SDK_WRITE_FLEXI_NORMAL, ioreq)

/*----------------------------------------------------------------------*/
/*		      f l D O C H R e W r i t e N o r m a l						*/
/*                                                                      */
/* Flexi-Flash Re-Write Normal							                */
/*                                                                      */
/* Parameters:                                                          */
/*        irHandle        : Socket number (zero based)                  */
/*                          Partition number (zero based)	            */
/*        irData          : Address of user buffer to write from        */
/*        irSectorNo      : First sector no. to write                   */
/*        irSectorCount   : Number of consecutive sectors to write      */
/*                                                                      */
/* ATA command:															*/
/*																		*/
/* ATA sub-command:														*/
/*			None														*/
/*																		*/
/* Returns:                                                             */
/*        DOCH_Error        : 0 on success, otherwise failed            */
/*        irSectorCount   : Number of sectors actually re-written       */
/*----------------------------------------------------------------------*/
#define flDOCHReWriteFlexiNormal(ioreq) bdCallDOCH(SDK_REWRITE_FLEXI_NORMAL, &ioreq)


/*----------------------------------------------------------------------*/
/*       f l D O C H M a n a g e A t o m i c W r i t e S e q			*/
/*