[mirror_smartmontools-debian.git] / dev_areca.h

/*
 * dev_areca.h
 *
 * Home page of code is: http://www.smartmontools.org
 *
 * Copyright (C) 2012 Hank Wu <hank@areca.com.tw>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#ifndef DEV_ARECA_H
#define DEV_ARECA_H

#define DEV_ARECA_H_CVSID "$Id: dev_areca.h 4760 2018-08-19 18:45:53Z chrfranke $"

/////////////////////////////////////////////////////////////////////////////
/// Areca RAID support

/* GENERIC ARECA IO CONTROL CODE*/
enum _GENERIC_ARCMSR_CMDS
{
ARCMSR_READ_RQBUFFER = 0,
ARCMSR_WRITE_WQBUFFER,
ARCMSR_CLEAR_RQBUFFER,
ARCMSR_CLEAR_WQBUFFER,
ARCMSR_RETURN_CODE_3F,
ARCMSR_CMD_TOTAL
};

#define ARECA_SIG_STR  "ARCMSR"

#if defined(_WIN32) || defined(__CYGWIN__)
#define ARCMSR_IOCTL_READ_RQBUFFER           0x90002004
#define ARCMSR_IOCTL_WRITE_WQBUFFER          0x90002008
#define ARCMSR_IOCTL_CLEAR_RQBUFFER          0x9000200C
#define ARCMSR_IOCTL_CLEAR_WQBUFFER          0x90002010
#define ARCMSR_IOCTL_RETURN_CODE_3F          0x90002018
#elif defined(__linux__)
/*DeviceType*/
#define ARECA_SATA_RAID                      0x90000000
/*FunctionCode*/
#define FUNCTION_READ_RQBUFFER               0x0801
#define FUNCTION_WRITE_WQBUFFER              0x0802
#define FUNCTION_CLEAR_RQBUFFER              0x0803
#define FUNCTION_CLEAR_WQBUFFER              0x0804
#define FUNCTION_RETURN_CODE_3F              0x0806

/* ARECA IO CONTROL CODE*/
#define ARCMSR_IOCTL_READ_RQBUFFER           (ARECA_SATA_RAID | FUNCTION_READ_RQBUFFER)
#define ARCMSR_IOCTL_WRITE_WQBUFFER          (ARECA_SATA_RAID | FUNCTION_WRITE_WQBUFFER)
#define ARCMSR_IOCTL_CLEAR_RQBUFFER          (ARECA_SATA_RAID | FUNCTION_CLEAR_RQBUFFER)
#define ARCMSR_IOCTL_CLEAR_WQBUFFER          (ARECA_SATA_RAID | FUNCTION_CLEAR_WQBUFFER)
#define ARCMSR_IOCTL_RETURN_CODE_3F          (ARECA_SATA_RAID | FUNCTION_RETURN_CODE_3F)
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
#include <sys/ioctl.h> // _IOWR

/*FunctionCode*/
#define FUNCTION_READ_RQBUFFER               0x0801
#define FUNCTION_WRITE_WQBUFFER              0x0802
#define FUNCTION_CLEAR_RQBUFFER              0x0803
#define FUNCTION_CLEAR_WQBUFFER              0x0804
#define FUNCTION_RETURN_CODE_3F              0x0806

/* ARECA IO CONTROL CODE*/
#define ARCMSR_IOCTL_READ_RQBUFFER           _IOWR('F', FUNCTION_READ_RQBUFFER, sSRB_BUFFER)
#define ARCMSR_IOCTL_WRITE_WQBUFFER          _IOWR('F', FUNCTION_WRITE_WQBUFFER, sSRB_BUFFER)
#define ARCMSR_IOCTL_CLEAR_RQBUFFER          _IOWR('F', FUNCTION_CLEAR_RQBUFFER, sSRB_BUFFER)
#define ARCMSR_IOCTL_CLEAR_WQBUFFER          _IOWR('F', FUNCTION_CLEAR_WQBUFFER, sSRB_BUFFER)
#define ARCMSR_IOCTL_RETURN_CODE_3F          _IOWR('F', FUNCTION_RETURN_CODE_3F, sSRB_BUFFER)
#endif


// The SRB_IO_CONTROL & SRB_BUFFER structures are used to communicate(to/from) to areca driver
typedef struct _ARCMSR_IO_HDR
{
  unsigned int HeaderLength;
  unsigned char Signature[8];
  unsigned int Timeout;
  unsigned int ControlCode;
  unsigned int ReturnCode;
  unsigned int Length;
} sARCMSR_IO_HDR;

typedef struct _SRB_BUFFER
{
  sARCMSR_IO_HDR  srbioctl;
  unsigned char   ioctldatabuffer[1032]; // the buffer to put the command data to/from firmware
} sSRB_BUFFER;

class generic_areca_device :
virtual public smart_device
{
public:
  generic_areca_device(smart_interface * intf, const char * dev_name, int disknum, int encnum = 1);
  ~generic_areca_device() throw();

  /////////////////////////////////////////////////////////////////////
  // OS-dependent functions
  virtual bool arcmsr_lock() = 0;
  virtual bool arcmsr_unlock() = 0;
  virtual int arcmsr_do_scsi_io(struct scsi_cmnd_io * iop) = 0;

  /////////////////////////////////////////////////////////////////////
  // OS-independent functions
  virtual int arcmsr_command_handler(unsigned long arcmsr_cmd, unsigned char *data, int data_len);
  virtual int arcmsr_ui_handler(unsigned char *areca_packet, int areca_packet_len, unsigned char *result);
  virtual bool arcmsr_probe();
  virtual int arcmsr_get_dev_type();
  virtual int arcmsr_get_controller_type();
  virtual bool arcmsr_scsi_pass_through(scsi_cmnd_io * iop);
  virtual bool arcmsr_ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);

protected:
  generic_areca_device()
    : smart_device(never_called),
      m_disknum(-1), m_encnum(-1)
      { }

  void set_disknum(int disknum)
  {m_disknum = disknum;}

  void set_encnum(int encnum)
  {m_encnum = encnum;}

  int get_disknum()
  {return m_disknum;}

  int get_encnum()
  {return m_encnum;}

private:
  int m_disknum; ///< Disk number.
  int m_encnum;  ///< Enclosure number.
 };

// SATA(ATA) device behind Areca RAID Controller
class areca_ata_device
: public ata_device,
  public generic_areca_device
{
public:
  areca_ata_device(smart_interface * intf, const char * dev_name, int disknum, int encnum = 1);
  ~areca_ata_device() throw();
  bool arcmsr_lock() { return true; }
  bool arcmsr_unlock() { return true; }
  int arcmsr_do_scsi_io(struct scsi_cmnd_io * /* iop */)
  {
      return -1;
  }
protected:
  areca_ata_device(): smart_device(never_called)
  {
  }
  virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
};

// SAS(SCSI) device behind Areca RAID Controller
class areca_scsi_device
: public scsi_device,
  public generic_areca_device
{
public:
  areca_scsi_device(smart_interface * intf, const char * dev_name, int disknum, int encnum = 1);
  ~areca_scsi_device() throw();
  bool arcmsr_lock() { return true; }
  bool arcmsr_unlock() { return true; }
  int arcmsr_do_scsi_io(struct scsi_cmnd_io * /* iop */)
  {
      return -1;
  }
protected:
  areca_scsi_device(): smart_device(never_called)
  {
  }
  virtual bool scsi_pass_through(scsi_cmnd_io * iop);
};

#endif
Commit	Line	Data
ee38a438 GI	1	/*
	2	* dev_areca.h
	3	*
6b80b4d2	4	* Home page of code is: http://www.smartmontools.org
ee38a438 GI	5	*
	6	* Copyright (C) 2012 Hank Wu <hank@areca.com.tw>
	7	*
ff28b140	8	* SPDX-License-Identifier: GPL-2.0-or-later
ee38a438 GI	9	*/
	10
	11	#ifndef DEV_ARECA_H
	12	#define DEV_ARECA_H
	13
ff28b140	14	#define DEV_ARECA_H_CVSID "$Id: dev_areca.h 4760 2018-08-19 18:45:53Z chrfranke $"
ee38a438 GI	15
	16	/////////////////////////////////////////////////////////////////////////////
	17	/// Areca RAID support
	18
	19	/* GENERIC ARECA IO CONTROL CODE*/
	20	enum _GENERIC_ARCMSR_CMDS
	21	{
	22	ARCMSR_READ_RQBUFFER = 0,
	23	ARCMSR_WRITE_WQBUFFER,
	24	ARCMSR_CLEAR_RQBUFFER,
	25	ARCMSR_CLEAR_WQBUFFER,
	26	ARCMSR_RETURN_CODE_3F,
	27	ARCMSR_CMD_TOTAL
	28	};
	29
	30	#define ARECA_SIG_STR "ARCMSR"
	31
	32	#if defined(_WIN32) \|\| defined(__CYGWIN__)
	33	#define ARCMSR_IOCTL_READ_RQBUFFER 0x90002004
	34	#define ARCMSR_IOCTL_WRITE_WQBUFFER 0x90002008
	35	#define ARCMSR_IOCTL_CLEAR_RQBUFFER 0x9000200C
	36	#define ARCMSR_IOCTL_CLEAR_WQBUFFER 0x90002010
	37	#define ARCMSR_IOCTL_RETURN_CODE_3F 0x90002018
	38	#elif defined(__linux__)
	39	/DeviceType/
	40	#define ARECA_SATA_RAID 0x90000000
	41	/FunctionCode/
	42	#define FUNCTION_READ_RQBUFFER 0x0801
	43	#define FUNCTION_WRITE_WQBUFFER 0x0802
	44	#define FUNCTION_CLEAR_RQBUFFER 0x0803
	45	#define FUNCTION_CLEAR_WQBUFFER 0x0804
	46	#define FUNCTION_RETURN_CODE_3F 0x0806
	47
	48	/* ARECA IO CONTROL CODE*/
	49	#define ARCMSR_IOCTL_READ_RQBUFFER (ARECA_SATA_RAID \| FUNCTION_READ_RQBUFFER)
	50	#define ARCMSR_IOCTL_WRITE_WQBUFFER (ARECA_SATA_RAID \| FUNCTION_WRITE_WQBUFFER)
	51	#define ARCMSR_IOCTL_CLEAR_RQBUFFER (ARECA_SATA_RAID \| FUNCTION_CLEAR_RQBUFFER)
	52	#define ARCMSR_IOCTL_CLEAR_WQBUFFER (ARECA_SATA_RAID \| FUNCTION_CLEAR_WQBUFFER)
	53	#define ARCMSR_IOCTL_RETURN_CODE_3F (ARECA_SATA_RAID \| FUNCTION_RETURN_CODE_3F)
d2e702cf	54	#elif defined(__FreeBSD__) \|\| defined(__FreeBSD_kernel__)
ee38a438 GI	55	#include <sys/ioctl.h> // _IOWR
	56
	57	/FunctionCode/
	58	#define FUNCTION_READ_RQBUFFER 0x0801
	59	#define FUNCTION_WRITE_WQBUFFER 0x0802
	60	#define FUNCTION_CLEAR_RQBUFFER 0x0803
	61	#define FUNCTION_CLEAR_WQBUFFER 0x0804
	62	#define FUNCTION_RETURN_CODE_3F 0x0806
	63
	64	/* ARECA IO CONTROL CODE*/
	65	#define ARCMSR_IOCTL_READ_RQBUFFER _IOWR('F', FUNCTION_READ_RQBUFFER, sSRB_BUFFER)
	66	#define ARCMSR_IOCTL_WRITE_WQBUFFER _IOWR('F', FUNCTION_WRITE_WQBUFFER, sSRB_BUFFER)
	67	#define ARCMSR_IOCTL_CLEAR_RQBUFFER _IOWR('F', FUNCTION_CLEAR_RQBUFFER, sSRB_BUFFER)
	68	#define ARCMSR_IOCTL_CLEAR_WQBUFFER _IOWR('F', FUNCTION_CLEAR_WQBUFFER, sSRB_BUFFER)
	69	#define ARCMSR_IOCTL_RETURN_CODE_3F _IOWR('F', FUNCTION_RETURN_CODE_3F, sSRB_BUFFER)
	70	#endif
	71
	72
	73	// The SRB_IO_CONTROL & SRB_BUFFER structures are used to communicate(to/from) to areca driver
	74	typedef struct _ARCMSR_IO_HDR
	75	{
	76	unsigned int HeaderLength;
	77	unsigned char Signature[8];
	78	unsigned int Timeout;
	79	unsigned int ControlCode;
	80	unsigned int ReturnCode;
	81	unsigned int Length;
	82	} sARCMSR_IO_HDR;
	83
	84	typedef struct _SRB_BUFFER
	85	{
	86	sARCMSR_IO_HDR srbioctl;
	87	unsigned char ioctldatabuffer[1032]; // the buffer to put the command data to/from firmware
	88	} sSRB_BUFFER;
	89
	90	class generic_areca_device :
	91	virtual public smart_device
	92	{
	93	public:
	94	generic_areca_device(smart_interface * intf, const char * dev_name, int disknum, int encnum = 1);
	95	~generic_areca_device() throw();
	96
	97	/////////////////////////////////////////////////////////////////////
	98	// OS-dependent functions
	99	virtual bool arcmsr_lock() = 0;
	100	virtual bool arcmsr_unlock() = 0;
	101	virtual int arcmsr_do_scsi_io(struct scsi_cmnd_io * iop) = 0;
	102
	103	/////////////////////////////////////////////////////////////////////
	104	// OS-independent functions
	105	virtual int arcmsr_command_handler(unsigned long arcmsr_cmd, unsigned char *data, int data_len);
	106	virtual int arcmsr_ui_handler(unsigned char areca_packet, int areca_packet_len, unsigned char result);
	107	virtual bool arcmsr_probe();
	108	virtual int arcmsr_get_dev_type();
	109	virtual int arcmsr_get_controller_type();
	110	virtual bool arcmsr_scsi_pass_through(scsi_cmnd_io * iop);
	111	virtual bool arcmsr_ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
	112
	113	protected:
6b80b4d2 JD	114	generic_areca_device()
	115	: smart_device(never_called),
	116	m_disknum(-1), m_encnum(-1)
	117	{ }
ee38a438 GI	118
	119	void set_disknum(int disknum)
	120	{m_disknum = disknum;}
	121
	122	void set_encnum(int encnum)
	123	{m_encnum = encnum;}
	124
	125	int get_disknum()
	126	{return m_disknum;}
	127
	128	int get_encnum()
	129	{return m_encnum;}
	130
	131	private:
	132	int m_disknum; ///< Disk number.
	133	int m_encnum; ///< Enclosure number.
	134	};
	135
	136	// SATA(ATA) device behind Areca RAID Controller
	137	class areca_ata_device
	138	: public ata_device,
	139	public generic_areca_device
	140	{
	141	public:
	142	areca_ata_device(smart_interface * intf, const char * dev_name, int disknum, int encnum = 1);
	143	~areca_ata_device() throw();
	144	bool arcmsr_lock() { return true; }
	145	bool arcmsr_unlock() { return true; }
	146	int arcmsr_do_scsi_io(struct scsi_cmnd_io * /* iop */)
	147	{
	148	return -1;
	149	}
	150	protected:
	151	areca_ata_device(): smart_device(never_called)
	152	{
	153	}
	154	virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
	155	};
	156
	157	// SAS(SCSI) device behind Areca RAID Controller
	158	class areca_scsi_device
	159	: public scsi_device,
	160	public generic_areca_device
	161	{
	162	public:
	163	areca_scsi_device(smart_interface * intf, const char * dev_name, int disknum, int encnum = 1);
	164	~areca_scsi_device() throw();
	165	bool arcmsr_lock() { return true; }
	166	bool arcmsr_unlock() { return true; }
	167	int arcmsr_do_scsi_io(struct scsi_cmnd_io * /* iop */)
	168	{
	169	return -1;
	170	}
	171	protected:
	172	areca_scsi_device(): smart_device(never_called)
	173	{
	174	}
	175	virtual bool scsi_pass_through(scsi_cmnd_io * iop);
	176	};
	177
	178	#endif