[mirror_ubuntu-bionic-kernel.git] / drivers / nvme / host / nvme.h

/*
 * Copyright (c) 2011-2014, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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 _NVME_H
#define _NVME_H

#include <linux/nvme.h>
#include <linux/pci.h>
#include <linux/kref.h>
#include <linux/blk-mq.h>

extern unsigned char nvme_io_timeout;
#define NVME_IO_TIMEOUT	(nvme_io_timeout * HZ)

enum {
	NVME_NS_LBA		= 0,
	NVME_NS_LIGHTNVM	= 1,
};

/*
 * Represents an NVM Express device.  Each nvme_dev is a PCI function.
 */
struct nvme_dev {
	struct list_head node;
	struct nvme_queue **queues;
	struct request_queue *admin_q;
	struct blk_mq_tag_set tagset;
	struct blk_mq_tag_set admin_tagset;
	u32 __iomem *dbs;
	struct device *dev;
	struct dma_pool *prp_page_pool;
	struct dma_pool *prp_small_pool;
	int instance;
	unsigned queue_count;
	unsigned online_queues;
	unsigned max_qid;
	int q_depth;
	u32 db_stride;
	u32 ctrl_config;
	struct msix_entry *entry;
	struct nvme_bar __iomem *bar;
	struct list_head namespaces;
	struct kref kref;
	struct device *device;
	struct work_struct reset_work;
	struct work_struct probe_work;
	struct work_struct scan_work;
	char name[12];
	char serial[20];
	char model[40];
	char firmware_rev[8];
	bool subsystem;
	u32 max_hw_sectors;
	u32 stripe_size;
	u32 page_size;
	void __iomem *cmb;
	dma_addr_t cmb_dma_addr;
	u64 cmb_size;
	u32 cmbsz;
	u16 oncs;
	u16 abort_limit;
	u8 event_limit;
	u8 vwc;
};

/*
 * An NVM Express namespace is equivalent to a SCSI LUN
 */
struct nvme_ns {
	struct list_head list;

	struct nvme_dev *dev;
	struct request_queue *queue;
	struct gendisk *disk;
	struct kref kref;

	unsigned ns_id;
	int lba_shift;
	u16 ms;
	bool ext;
	u8 pi_type;
	int type;
	u64 mode_select_num_blocks;
	u32 mode_select_block_len;
};

static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector)
{
	return (sector >> (ns->lba_shift - 9));
}

int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
		void *buf, unsigned bufflen);
int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
		void *buffer, void __user *ubuffer, unsigned bufflen,
		u32 *result, unsigned timeout);
int nvme_identify_ctrl(struct nvme_dev *dev, struct nvme_id_ctrl **id);
int nvme_identify_ns(struct nvme_dev *dev, unsigned nsid,
		struct nvme_id_ns **id);
int nvme_get_log_page(struct nvme_dev *dev, struct nvme_smart_log **log);
int nvme_get_features(struct nvme_dev *dev, unsigned fid, unsigned nsid,
			dma_addr_t dma_addr, u32 *result);
int nvme_set_features(struct nvme_dev *dev, unsigned fid, unsigned dword11,
			dma_addr_t dma_addr, u32 *result);

struct sg_io_hdr;

int nvme_sg_io(struct nvme_ns *ns, struct sg_io_hdr __user *u_hdr);
int nvme_sg_io32(struct nvme_ns *ns, unsigned long arg);
int nvme_sg_get_version_num(int __user *ip);

int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id);
int nvme_nvm_register(struct request_queue *q, char *disk_name);
void nvme_nvm_unregister(struct request_queue *q, char *disk_name);

#endif /* _NVME_H */
Commit	Line	Data
f11bb3e2 CH	1	/*
	2	* Copyright (c) 2011-2014, Intel Corporation.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms and conditions of the GNU General Public License,
	6	* version 2, as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*/
	13
	14	#ifndef _NVME_H
	15	#define _NVME_H
	16
	17	#include <linux/nvme.h>
	18	#include <linux/pci.h>
	19	#include <linux/kref.h>
	20	#include <linux/blk-mq.h>
	21
	22	extern unsigned char nvme_io_timeout;
	23	#define NVME_IO_TIMEOUT (nvme_io_timeout * HZ)
	24
ca064085 MB	25	enum {
	26	NVME_NS_LBA = 0,
	27	NVME_NS_LIGHTNVM = 1,
	28	};
	29
f11bb3e2 CH	30	/*
	31	* Represents an NVM Express device. Each nvme_dev is a PCI function.
	32	*/
	33	struct nvme_dev {
	34	struct list_head node;
	35	struct nvme_queue **queues;
	36	struct request_queue *admin_q;
	37	struct blk_mq_tag_set tagset;
	38	struct blk_mq_tag_set admin_tagset;
	39	u32 __iomem *dbs;
	40	struct device *dev;
	41	struct dma_pool *prp_page_pool;
	42	struct dma_pool *prp_small_pool;
	43	int instance;
	44	unsigned queue_count;
	45	unsigned online_queues;
	46	unsigned max_qid;
	47	int q_depth;
	48	u32 db_stride;
	49	u32 ctrl_config;
	50	struct msix_entry *entry;
	51	struct nvme_bar __iomem *bar;
	52	struct list_head namespaces;
	53	struct kref kref;
	54	struct device *device;
	55	struct work_struct reset_work;
	56	struct work_struct probe_work;
	57	struct work_struct scan_work;
	58	char name[12];
	59	char serial[20];
	60	char model[40];
	61	char firmware_rev[8];
	62	bool subsystem;
	63	u32 max_hw_sectors;
	64	u32 stripe_size;
	65	u32 page_size;
	66	void __iomem *cmb;
	67	dma_addr_t cmb_dma_addr;
	68	u64 cmb_size;
	69	u32 cmbsz;
	70	u16 oncs;
	71	u16 abort_limit;
	72	u8 event_limit;
	73	u8 vwc;
	74	};
	75
	76	/*
	77	* An NVM Express namespace is equivalent to a SCSI LUN
	78	*/
	79	struct nvme_ns {
	80	struct list_head list;
	81
	82	struct nvme_dev *dev;
	83	struct request_queue *queue;
	84	struct gendisk *disk;
	85	struct kref kref;
	86
	87	unsigned ns_id;
	88	int lba_shift;
	89	u16 ms;
	90	bool ext;
	91	u8 pi_type;
ca064085	92	int type;
f11bb3e2 CH	93	u64 mode_select_num_blocks;
	94	u32 mode_select_block_len;
	95	};
	96
f11bb3e2 CH	97	static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector)
	98	{
	99	return (sector >> (ns->lba_shift - 9));
	100	}
	101
	102	int nvme_submit_sync_cmd(struct request_queue q, struct nvme_command cmd,
	103	void *buf, unsigned bufflen);
	104	int __nvme_submit_sync_cmd(struct request_queue q, struct nvme_command cmd,
	105	void buffer, void __user ubuffer, unsigned bufflen,
	106	u32 *result, unsigned timeout);
	107	int nvme_identify_ctrl(struct nvme_dev dev, struct nvme_id_ctrl *id);
	108	int nvme_identify_ns(struct nvme_dev *dev, unsigned nsid,
	109	struct nvme_id_ns **id);
	110	int nvme_get_log_page(struct nvme_dev dev, struct nvme_smart_log *log);
	111	int nvme_get_features(struct nvme_dev *dev, unsigned fid, unsigned nsid,
	112	dma_addr_t dma_addr, u32 *result);
	113	int nvme_set_features(struct nvme_dev *dev, unsigned fid, unsigned dword11,
	114	dma_addr_t dma_addr, u32 *result);
	115
	116	struct sg_io_hdr;
	117
	118	int nvme_sg_io(struct nvme_ns ns, struct sg_io_hdr __user u_hdr);
	119	int nvme_sg_io32(struct nvme_ns *ns, unsigned long arg);
	120	int nvme_sg_get_version_num(int __user *ip);
	121
ca064085 MB	122	int nvme_nvm_ns_supported(struct nvme_ns ns, struct nvme_id_ns id);
	123	int nvme_nvm_register(struct request_queue q, char disk_name);
	124	void nvme_nvm_unregister(struct request_queue q, char disk_name);
	125
f11bb3e2	126	#endif /* _NVME_H */