1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // RPC-IF SPI/QSPI/Octa driver 4 // 5 // Copyright (C) 2018 ~ 2019 Renesas Solutions Corp. 6 // Copyright (C) 2019 Macronix International Co., Ltd. 7 // Copyright (C) 2019 - 2020 Cogent Embedded, Inc. 8 // 9 10 #include <linux/module.h> 11 #include <linux/platform_device.h> 12 #include <linux/spi/spi.h> 13 #include <linux/spi/spi-mem.h> 14 15 #include <memory/renesas-rpc-if.h> 16 17 #include <asm/unaligned.h> 18 rpcif_spi_mem_prepare(struct spi_device * spi_dev,const struct spi_mem_op * spi_op,u64 * offs,size_t * len)19 static void rpcif_spi_mem_prepare(struct spi_device *spi_dev, 20 const struct spi_mem_op *spi_op, 21 u64 *offs, size_t *len) 22 { 23 struct rpcif *rpc = spi_controller_get_devdata(spi_dev->controller); 24 struct rpcif_op rpc_op = { }; 25 26 rpc_op.cmd.opcode = spi_op->cmd.opcode; 27 rpc_op.cmd.buswidth = spi_op->cmd.buswidth; 28 29 if (spi_op->addr.nbytes) { 30 rpc_op.addr.buswidth = spi_op->addr.buswidth; 31 rpc_op.addr.nbytes = spi_op->addr.nbytes; 32 rpc_op.addr.val = spi_op->addr.val; 33 } 34 35 if (spi_op->dummy.nbytes) { 36 rpc_op.dummy.buswidth = spi_op->dummy.buswidth; 37 rpc_op.dummy.ncycles = spi_op->dummy.nbytes * 8 / 38 spi_op->dummy.buswidth; 39 } 40 41 if (spi_op->data.nbytes || (offs && len)) { 42 rpc_op.data.buswidth = spi_op->data.buswidth; 43 rpc_op.data.nbytes = spi_op->data.nbytes; 44 switch (spi_op->data.dir) { 45 case SPI_MEM_DATA_IN: 46 rpc_op.data.dir = RPCIF_DATA_IN; 47 rpc_op.data.buf.in = spi_op->data.buf.in; 48 break; 49 case SPI_MEM_DATA_OUT: 50 rpc_op.data.dir = RPCIF_DATA_OUT; 51 rpc_op.data.buf.out = spi_op->data.buf.out; 52 break; 53 case SPI_MEM_NO_DATA: 54 rpc_op.data.dir = RPCIF_NO_DATA; 55 break; 56 } 57 } else { 58 rpc_op.data.dir = RPCIF_NO_DATA; 59 } 60 61 rpcif_prepare(rpc->dev, &rpc_op, offs, len); 62 } 63 rpcif_spi_mem_supports_op(struct spi_mem * mem,const struct spi_mem_op * op)64 static bool rpcif_spi_mem_supports_op(struct spi_mem *mem, 65 const struct spi_mem_op *op) 66 { 67 if (!spi_mem_default_supports_op(mem, op)) 68 return false; 69 70 if (op->data.buswidth > 4 || op->addr.buswidth > 4 || 71 op->dummy.buswidth > 4 || op->cmd.buswidth > 4 || 72 op->addr.nbytes > 4) 73 return false; 74 75 return true; 76 } 77 rpcif_spi_mem_dirmap_read(struct spi_mem_dirmap_desc * desc,u64 offs,size_t len,void * buf)78 static ssize_t rpcif_spi_mem_dirmap_read(struct spi_mem_dirmap_desc *desc, 79 u64 offs, size_t len, void *buf) 80 { 81 struct rpcif *rpc = 82 spi_controller_get_devdata(desc->mem->spi->controller); 83 84 if (offs + desc->info.offset + len > U32_MAX) 85 return -EINVAL; 86 87 rpcif_spi_mem_prepare(desc->mem->spi, &desc->info.op_tmpl, &offs, &len); 88 89 return rpcif_dirmap_read(rpc->dev, offs, len, buf); 90 } 91 rpcif_spi_mem_dirmap_create(struct spi_mem_dirmap_desc * desc)92 static int rpcif_spi_mem_dirmap_create(struct spi_mem_dirmap_desc *desc) 93 { 94 struct rpcif *rpc = 95 spi_controller_get_devdata(desc->mem->spi->controller); 96 97 if (desc->info.offset + desc->info.length > U32_MAX) 98 return -ENOTSUPP; 99 100 if (!rpcif_spi_mem_supports_op(desc->mem, &desc->info.op_tmpl)) 101 return -ENOTSUPP; 102 103 if (!rpc->dirmap && desc->info.op_tmpl.data.dir == SPI_MEM_DATA_IN) 104 return -ENOTSUPP; 105 106 if (desc->info.op_tmpl.data.dir == SPI_MEM_DATA_OUT) 107 return -ENOTSUPP; 108 109 return 0; 110 } 111 rpcif_spi_mem_exec_op(struct spi_mem * mem,const struct spi_mem_op * op)112 static int rpcif_spi_mem_exec_op(struct spi_mem *mem, 113 const struct spi_mem_op *op) 114 { 115 struct rpcif *rpc = 116 spi_controller_get_devdata(mem->spi->controller); 117 118 rpcif_spi_mem_prepare(mem->spi, op, NULL, NULL); 119 120 return rpcif_manual_xfer(rpc->dev); 121 } 122 123 static const struct spi_controller_mem_ops rpcif_spi_mem_ops = { 124 .supports_op = rpcif_spi_mem_supports_op, 125 .exec_op = rpcif_spi_mem_exec_op, 126 .dirmap_create = rpcif_spi_mem_dirmap_create, 127 .dirmap_read = rpcif_spi_mem_dirmap_read, 128 }; 129 rpcif_spi_probe(struct platform_device * pdev)130 static int rpcif_spi_probe(struct platform_device *pdev) 131 { 132 struct device *parent = pdev->dev.parent; 133 struct spi_controller *ctlr; 134 struct rpcif *rpc; 135 int error; 136 137 ctlr = devm_spi_alloc_host(&pdev->dev, sizeof(*rpc)); 138 if (!ctlr) 139 return -ENOMEM; 140 141 rpc = spi_controller_get_devdata(ctlr); 142 error = rpcif_sw_init(rpc, parent); 143 if (error) 144 return error; 145 146 platform_set_drvdata(pdev, ctlr); 147 148 ctlr->dev.of_node = parent->of_node; 149 150 pm_runtime_enable(rpc->dev); 151 152 ctlr->num_chipselect = 1; 153 ctlr->mem_ops = &rpcif_spi_mem_ops; 154 155 ctlr->bits_per_word_mask = SPI_BPW_MASK(8); 156 ctlr->mode_bits = SPI_CPOL | SPI_CPHA | SPI_TX_QUAD | SPI_RX_QUAD; 157 ctlr->flags = SPI_CONTROLLER_HALF_DUPLEX; 158 159 error = rpcif_hw_init(rpc->dev, false); 160 if (error) 161 goto out_disable_rpm; 162 163 error = spi_register_controller(ctlr); 164 if (error) { 165 dev_err(&pdev->dev, "spi_register_controller failed\n"); 166 goto out_disable_rpm; 167 } 168 169 return 0; 170 171 out_disable_rpm: 172 pm_runtime_disable(rpc->dev); 173 return error; 174 } 175 rpcif_spi_remove(struct platform_device * pdev)176 static void rpcif_spi_remove(struct platform_device *pdev) 177 { 178 struct spi_controller *ctlr = platform_get_drvdata(pdev); 179 struct rpcif *rpc = spi_controller_get_devdata(ctlr); 180 181 spi_unregister_controller(ctlr); 182 pm_runtime_disable(rpc->dev); 183 } 184 rpcif_spi_suspend(struct device * dev)185 static int __maybe_unused rpcif_spi_suspend(struct device *dev) 186 { 187 struct spi_controller *ctlr = dev_get_drvdata(dev); 188 189 return spi_controller_suspend(ctlr); 190 } 191 rpcif_spi_resume(struct device * dev)192 static int __maybe_unused rpcif_spi_resume(struct device *dev) 193 { 194 struct spi_controller *ctlr = dev_get_drvdata(dev); 195 196 return spi_controller_resume(ctlr); 197 } 198 199 static SIMPLE_DEV_PM_OPS(rpcif_spi_pm_ops, rpcif_spi_suspend, rpcif_spi_resume); 200 201 static const struct platform_device_id rpc_if_spi_id_table[] = { 202 { .name = "rpc-if-spi" }, 203 { /* sentinel */ } 204 }; 205 MODULE_DEVICE_TABLE(platform, rpc_if_spi_id_table); 206 207 static struct platform_driver rpcif_spi_driver = { 208 .probe = rpcif_spi_probe, 209 .remove_new = rpcif_spi_remove, 210 .id_table = rpc_if_spi_id_table, 211 .driver = { 212 .name = "rpc-if-spi", 213 #ifdef CONFIG_PM_SLEEP 214 .pm = &rpcif_spi_pm_ops, 215 #endif 216 }, 217 }; 218 module_platform_driver(rpcif_spi_driver); 219 220 MODULE_DESCRIPTION("Renesas RPC-IF SPI driver"); 221 MODULE_LICENSE("GPL v2"); 222