struct spi_mem {
	struct spi_device *spi;
	void *drvpriv;
	const char *name;
};

struct spi_mem_op {
	struct {
		u8 nbytes;
		u8 buswidth;
		u16 opcode;
	} cmd;

	struct {
		u8 nbytes;
		u8 buswidth;
		u64 val;
	} addr;

	struct {
		u8 nbytes;
		u8 buswidth;
	} dummy;

	struct {
		u8 buswidth;
		enum spi_mem_data_dir dir;
		unsigned int nbytes;
		union {
			void *in;
			const void *out;
		} buf;
	} data;
};

struct spi_controller_mem_ops {
	int (*adjust_op_size)(struct spi_mem *mem, struct spi_mem_op *op);
	bool (*supports_op)(struct spi_mem *mem,
			    const struct spi_mem_op *op);
	int (*exec_op)(struct spi_mem *mem,
		       const struct spi_mem_op *op);
	const char *(*get_name)(struct spi_mem *mem);
	int (*dirmap_create)(struct spi_mem_dirmap_desc *desc);
	void (*dirmap_destroy)(struct spi_mem_dirmap_desc *desc);
	ssize_t (*dirmap_read)(struct spi_mem_dirmap_desc *desc,
			       u64 offs, size_t len, void *buf);
	ssize_t (*dirmap_write)(struct spi_mem_dirmap_desc *desc,
				u64 offs, size_t len, const void *buf);
};

struct spi_mem_driver {
	struct spi_driver spidrv;
	int (*probe)(struct spi_mem *mem);
	int (*remove)(struct spi_mem *mem);
	void (*shutdown)(struct spi_mem *mem);
};

static const struct of_device_id spi_nor_of_table[] = {
	/*
	 * Generic compatibility for SPI NOR that can be identified by the
	 * JEDEC READ ID opcode (0x9F). Use this, if possible.
	 */
	{ .compatible = "jedec,spi-nor" },
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, spi_nor_of_table);

/*
 * REVISIT: many of these chips have deep power-down modes, which
 * should clearly be entered on suspend() to minimize power use.
 * And also when they‘re otherwise idle...
 */
static struct spi_mem_driver spi_nor_driver = {
	.spidrv = {
		.driver = {
			.name = "spi-nor",
			.of_match_table = spi_nor_of_table,
		},
		.id_table = spi_nor_dev_ids,
	},
	.probe = spi_nor_probe,
	.remove = spi_nor_remove,
	.shutdown = spi_nor_shutdown,
};
module_spi_mem_driver(spi_nor_driver);

/**
 * spi_nor_spimem_exec_op() - execute a memory operation
 * @nor:        pointer to ‘struct spi_nor‘
 * @op:         pointer to ‘struct spi_mem_op‘ template for transfer
 *
 * Return: 0 on success, -error otherwise.
 */
static int spi_nor_spimem_exec_op(struct spi_nor *nor, struct spi_mem_op *op)
{
	int error;

	error = spi_mem_adjust_op_size(nor->spimem, op);
	if (error)
		return error;

	return spi_mem_exec_op(nor->spimem, op);
}

#include <linux/spi/spi.h>
#include <linux/spi/spi-mem.h>

struct demo_data_struct {
	struct device *dev;
    //添加私有属性，比如控制器的寄存器地址，时钟等
};

static int demo_setup(struct spi_device *spi)
{
    struct demo_data_struct	*f = spi_master_get_devdata(spi->master);
    //添加代码设置spi片选，速度
}

static int demo_exec_mem_op(struct spi_mem *mem, struct spi_mem_op *op)
{
    struct demo_data_struct *f = spi_controller_get_devdata(mem->spi->master);
    //添加代码执行一个spi_mem_op
}

static int demo_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op)
{
    //添加代码调整存储器操作的数据传输大小，以符合对齐要求和最大FIFO大小的约束。
}

static const char *demo_get_name(struct spi_mem *mem)
{
    struct demo_data_struct *f = spi_controller_get_devdata(mem->spi->master);
	struct device *dev = &mem->spi->dev;
	const char *name;

    /*动态分配name的内存空间，此name会写入到mem->name,并最终可能传入到mtd->name*/
	name = devm_kasprintf(dev, GFP_KERNEL,
			      "%s-%d", dev_name(f->dev),
			      mem->spi->chip_select);

	if (!name) {
		dev_err(dev, "failed to get memory for custom flash name\n");
		return ERR_PTR(-ENOMEM);
	}

	return name;
}

static int demo_dirmap_create(struct spi_mem_dirmap_desc *desc)
{
    //创建spi存储器到内存的映射，如果控制器支持将存储器的内容映射到cpu地址空间的话
}

static void demo_dirmap_destroy(struct spi_mem_dirmap_desc *desc)
{
    //dirmap_create的逆操作
}

static ssize_t demo_dirmap_read(struct spi_mem_dirmap_desc *desc, u64 offs, size_t len, void *buf)
{
    //直接从映射的内存中读取spi存储器的数据，返回实际读取的字节数，注意不要超过映射的区域
}

static ssize_t demo_dirmap_write(struct spi_mem_dirmap_desc *desc,u64 offs, size_t len, const void *buf)
{
    //和dirmap_read类似
}

static const struct spi_controller_mem_ops demo_mem_ops = {
	.exec_op = demo_exec_mem_op,
	.adjust_op_size = demo_adjust_op_size,
    .supports_op = demo_supports_op,
    .get_name = demo_get_name,
    .dirmap_create = demo_dirmap_create,
    .dirmap_destroy = demo_dirmap_destroy,
    .dirmap_read = demo_dirmap_read,
    .dirmap_write = demo_dirmap_write,
};

static int demo_probe(struct platform_device *pdev)
{
    struct spi_controller *ctlr;
    struct demo_data_struct *f;
    struct device *dev = &pdev->dev;
    struct device_node *np = dev->of_node;

    ctlr = spi_alloc_master(&pdev->dev, sizeof(*f));
	if (!master)
		return -ENOMEM;
    
    ctlr->mode_bits = SPI_RX_DUAL | SPI_RX_QUAD;//根据控制器自行修改
    ctlr->setup = demo_setup;

    f = spi_controller_get_devdata(ctlr);
	f->dev = dev;
    platform_set_drvdata(pdev, f);

    ctlr->bus_num = -1;
	ctlr->num_chipselect = 1;//片选数
	ctlr->mem_ops = &nxp_fspi_mem_ops;

    ctlr->dev.of_node = np;

    return devm_spi_register_controller(&pdev->dev, ctlr);//注册spi控制器
}

static int demo_remove(struct platform_device *pdev)
{

}

static const struct of_device_id demo_match[] = {
	{.compatible = "xxxx" },
	{},
};

static struct platform_driver demo_driver = {
	.probe	= demo_probe,
	.remove = demo_remove,
	.driver = {
		.name	= "ti-qspi",
		.of_match_table = demo_match,
	}
};

module_platform_driver(demo_driver);