280 lines
7.3 KiB
C
280 lines
7.3 KiB
C
/*
|
|
* Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#ifndef _TEGRA_VIRT_STORAGE_SPEC_H_
|
|
#define _TEGRA_VIRT_STORAGE_SPEC_H_
|
|
|
|
#include <linux/types.h> /* size_t */
|
|
|
|
#define VS_REQ_OP_F_NONE 0
|
|
|
|
enum vs_req_type {
|
|
VS_DATA_REQ = 1,
|
|
VS_CONFIGINFO_REQ = 2,
|
|
VS_UNKNOWN_CMD = 0xffffffff,
|
|
};
|
|
|
|
enum vs_dev_type {
|
|
VS_BLK_DEV = 1,
|
|
VS_MTD_DEV = 2,
|
|
VS_UNKNOWN_DEV = 0xffffffff,
|
|
};
|
|
|
|
enum mtd_cmd_op {
|
|
VS_MTD_READ = 1,
|
|
VS_MTD_WRITE = 2,
|
|
VS_MTD_ERASE = 3,
|
|
VS_MTD_IOCTL = 4,
|
|
VS_MTD_INVAL_REQ = 32,
|
|
VS_UNKNOWN_MTD_CMD = 0xffffffff,
|
|
};
|
|
|
|
/* MTD device request Operation type features supported */
|
|
#define VS_MTD_READ_OP_F (1 << VS_MTD_READ)
|
|
#define VS_MTD_WRITE_OP_F (1 << VS_MTD_WRITE)
|
|
#define VS_MTD_ERASE_OP_F (1 << VS_MTD_ERASE)
|
|
#define VS_MTD_IOCTL_OP_F (1 << VS_MTD_IOCTL)
|
|
|
|
enum blk_cmd_op {
|
|
VS_BLK_READ = 1,
|
|
VS_BLK_WRITE = 2,
|
|
VS_BLK_FLUSH = 3,
|
|
VS_BLK_IOCTL = 4,
|
|
VS_BLK_INVAL_REQ = 32,
|
|
VS_UNKNOWN_BLK_CMD = 0xffffffff,
|
|
};
|
|
|
|
/* Blk device request Operation type features supported */
|
|
#define VS_BLK_READ_OP_F (1 << VS_BLK_READ)
|
|
#define VS_BLK_WRITE_OP_F (1 << VS_BLK_WRITE)
|
|
#define VS_BLK_FLUSH_OP_F (1 << VS_BLK_FLUSH)
|
|
#define VS_BLK_IOCTL_OP_F (1 << VS_BLK_IOCTL)
|
|
|
|
#pragma pack(push)
|
|
#pragma pack(1)
|
|
|
|
struct vs_blk_request {
|
|
uint64_t blk_offset; /* Offset into storage device in terms
|
|
of blocks for block device */
|
|
uint32_t num_blks; /* Total Block number to transfer */
|
|
uint32_t data_offset; /* Offset into mempool for data region
|
|
*/
|
|
};
|
|
|
|
struct vs_mtd_request {
|
|
uint64_t offset; /* Offset into storage device in terms
|
|
of bytes in case of mtd device */
|
|
uint32_t size; /* Total number of bytes to transfer
|
|
to be used for MTD device */
|
|
uint32_t data_offset; /* Offset into mempool for data region
|
|
*/
|
|
};
|
|
|
|
struct vs_ioctl_request {
|
|
uint32_t ioctl_id; /* Id of the ioctl */
|
|
uint32_t ioctl_len; /* Length of the mempool area associated
|
|
with ioctl */
|
|
uint32_t data_offset; /* Offset into mempool for data region
|
|
*/
|
|
};
|
|
|
|
struct vs_blkdev_request {
|
|
enum blk_cmd_op req_op;
|
|
union {
|
|
struct vs_blk_request blk_req;
|
|
struct vs_ioctl_request ioctl_req;
|
|
};
|
|
};
|
|
|
|
struct vs_mtddev_request {
|
|
enum mtd_cmd_op req_op;
|
|
union {
|
|
struct vs_mtd_request mtd_req;
|
|
struct vs_ioctl_request ioctl_req;
|
|
};
|
|
};
|
|
|
|
struct vs_blk_response {
|
|
int32_t status; /* 0 for success, < 0 for error */
|
|
uint32_t num_blks;
|
|
};
|
|
|
|
struct vs_mtd_response {
|
|
int32_t status; /* 0 for success, < 0 for error */
|
|
uint32_t size; /* Number of bytes processed in case of
|
|
of mtd device*/
|
|
};
|
|
|
|
struct vs_ioctl_response {
|
|
int32_t status; /* 0 for success, < 0 for error */
|
|
};
|
|
|
|
struct vs_blkdev_response {
|
|
union {
|
|
struct vs_blk_response blk_resp;
|
|
struct vs_ioctl_response ioctl_resp;
|
|
};
|
|
};
|
|
|
|
struct vs_mtddev_response {
|
|
union {
|
|
struct vs_mtd_response mtd_resp;
|
|
struct vs_ioctl_response ioctl_resp;
|
|
};
|
|
};
|
|
|
|
struct vs_blk_dev_config {
|
|
uint32_t hardblk_size; /* Block Size */
|
|
uint32_t max_read_blks_per_io; /* Limit number of Blocks
|
|
per I/O*/
|
|
uint32_t max_write_blks_per_io; /* Limit number of Blocks
|
|
per I/O*/
|
|
uint32_t req_ops_supported; /* Allowed operations by requests */
|
|
uint64_t num_blks; /* Total number of blks */
|
|
};
|
|
|
|
struct vs_mtd_dev_config {
|
|
uint32_t max_read_bytes_per_io; /* Limit number of bytes
|
|
per I/O */
|
|
uint32_t max_write_bytes_per_io; /* Limit number of bytes
|
|
per I/O */
|
|
uint32_t erase_size; /* Erase size for mtd
|
|
device*/
|
|
uint32_t req_ops_supported; /* Allowed operations by requests */
|
|
uint64_t size; /* Total number of bytes */
|
|
};
|
|
|
|
struct vs_config_info {
|
|
uint32_t virtual_storage_ver; /* Version of virtual storage */
|
|
enum vs_dev_type type; /* Type of underlying device */
|
|
union {
|
|
struct vs_blk_dev_config blk_config;
|
|
struct vs_mtd_dev_config mtd_config;
|
|
};
|
|
};
|
|
|
|
struct vs_request {
|
|
uint32_t req_id;
|
|
enum vs_req_type type;
|
|
union {
|
|
struct vs_blkdev_request blkdev_req;
|
|
struct vs_mtddev_request mtddev_req;
|
|
};
|
|
int32_t status;
|
|
union {
|
|
struct vs_blkdev_response blkdev_resp;
|
|
struct vs_mtddev_response mtddev_resp;
|
|
struct vs_config_info config_info;
|
|
};
|
|
};
|
|
|
|
/* Defines Command Responses of Emmc/Esd as per VSC interface */
|
|
typedef enum {
|
|
RESP_TYPE_NO_RESP = 0,
|
|
RESP_TYPE_R1 = 1,
|
|
RESP_TYPE_R2 = 2,
|
|
RESP_TYPE_R3 = 3,
|
|
RESP_TYPE_R4 = 4,
|
|
RESP_TYPE_R5 = 5,
|
|
RESP_TYPE_R6 = 6,
|
|
RESP_TYPE_R7 = 7,
|
|
RESP_TYPE_R1B = 8,
|
|
RESP_TYPE_NUM,
|
|
} sdmmc_resp_type;
|
|
|
|
|
|
#define VBLK_MMC_MULTI_IOC_ID 0x1000
|
|
struct combo_cmd_t {
|
|
uint32_t cmd;
|
|
uint32_t arg;
|
|
uint32_t response[4];
|
|
uint32_t buf_offset;
|
|
uint32_t data_len;
|
|
uint32_t write_flag;
|
|
uint32_t flags;
|
|
};
|
|
|
|
struct combo_info_t {
|
|
uint32_t count;
|
|
int32_t result;
|
|
};
|
|
|
|
/* SCSI bio layer needs to handle SCSI and UFS IOCTL separately
|
|
* This flag will be ORed with IO_IOCTL to find out difference
|
|
* between SCSI and UFS IOCTL
|
|
*/
|
|
#define SCSI_IOCTL_FLAG 0x10000000
|
|
#define UFS_IOCTL_FLAG 0x20000000
|
|
/* Mask for SCSI and UFS ioctl flags, 4 MSB (bits) reserved for it Two LSB
|
|
* bits are used for SCSI and UFS, 2 MSB bits reserved for future use.
|
|
*/
|
|
#define SCSI_UFS_IOCTL_FLAG_MASK 0xF0000000
|
|
|
|
#define VBLK_SG_IO_ID (0x1001 | SCSI_IOCTL_FLAG)
|
|
#define VBLK_UFS_IO_ID (0x1002 | UFS_IOCTL_FLAG)
|
|
|
|
#define VBLK_SG_MAX_CMD_LEN 16
|
|
|
|
enum scsi_data_direction {
|
|
SCSI_BIDIRECTIONAL = 0,
|
|
SCSI_TO_DEVICE = 1,
|
|
SCSI_FROM_DEVICE = 2,
|
|
SCSI_DATA_NONE = 3,
|
|
UNKNOWN_DIRECTION = 0xffffffff,
|
|
};
|
|
|
|
struct vblk_sg_io_hdr
|
|
{
|
|
int32_t data_direction; /* [i] data transfer direction */
|
|
uint8_t cmd_len; /* [i] SCSI command length */
|
|
uint8_t mx_sb_len; /* [i] max length to write to sbp */
|
|
uint32_t dxfer_len; /* [i] byte count of data transfer */
|
|
uint32_t xfer_arg_offset; /* [i], [*io] offset to data transfer memory */
|
|
uint32_t cmdp_arg_offset; /* [i], [*i] offset to command to perform */
|
|
uint32_t sbp_arg_offset; /* [i], [*o] offset to sense_buffer memory */
|
|
uint32_t status; /* [o] scsi status */
|
|
uint8_t sb_len_wr; /* [o] byte count actually written to sbp */
|
|
uint32_t dxfer_buf_len; /* [i] Length of data transfer buffer */
|
|
};
|
|
|
|
struct vblk_ufs_ioc_query_req {
|
|
/* Query opcode to specify the type of Query operation */
|
|
uint8_t opcode;
|
|
/* idn to provide more info on specific operation. */
|
|
uint8_t idn;
|
|
/* index - optional in some cases */
|
|
uint8_t index;
|
|
/* index - optional in some cases */
|
|
uint8_t selector;
|
|
/* buf_size - buffer size in bytes pointed by buffer. */
|
|
uint16_t buf_size;
|
|
/*
|
|
* user buffer pointer for query data.
|
|
* Note:
|
|
* For Read/Write Attribute this should be of 4 bytes
|
|
* For Read Flag this should be of 1 byte
|
|
* For Descriptor Read/Write size depends on the type of the descriptor
|
|
*/
|
|
uint8_t *buffer;
|
|
/* delay after query command completion */
|
|
uint32_t delay;
|
|
/* error status for the query operation */
|
|
int32_t error_status;
|
|
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
#endif
|