1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Linux driver for RPC-IF HyperFlash
4 *
5 * Copyright (C) 2019-2020 Cogent Embedded, Inc.
6 */
7
8 #include <linux/err.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/mtd/hyperbus.h>
12 #include <linux/mtd/mtd.h>
13 #include <linux/mux/consumer.h>
14 #include <linux/of.h>
15 #include <linux/platform_device.h>
16 #include <linux/types.h>
17
18 #include <memory/renesas-rpc-if.h>
19
20 struct rpcif_hyperbus {
21 struct rpcif rpc;
22 struct hyperbus_ctlr ctlr;
23 struct hyperbus_device hbdev;
24 };
25
26 static const struct rpcif_op rpcif_op_tmpl = {
27 .cmd = {
28 .buswidth = 8,
29 .ddr = true,
30 },
31 .ocmd = {
32 .buswidth = 8,
33 .ddr = true,
34 },
35 .addr = {
36 .nbytes = 1,
37 .buswidth = 8,
38 .ddr = true,
39 },
40 .data = {
41 .buswidth = 8,
42 .ddr = true,
43 },
44 };
45
rpcif_hb_prepare_read(struct rpcif * rpc,void * to,unsigned long from,ssize_t len)46 static void rpcif_hb_prepare_read(struct rpcif *rpc, void *to,
47 unsigned long from, ssize_t len)
48 {
49 struct rpcif_op op = rpcif_op_tmpl;
50
51 op.cmd.opcode = HYPERBUS_RW_READ | HYPERBUS_AS_MEM;
52 op.addr.val = from >> 1;
53 op.dummy.buswidth = 1;
54 op.dummy.ncycles = 15;
55 op.data.dir = RPCIF_DATA_IN;
56 op.data.nbytes = len;
57 op.data.buf.in = to;
58
59 rpcif_prepare(rpc->dev, &op, NULL, NULL);
60 }
61
rpcif_hb_prepare_write(struct rpcif * rpc,unsigned long to,void * from,ssize_t len)62 static void rpcif_hb_prepare_write(struct rpcif *rpc, unsigned long to,
63 void *from, ssize_t len)
64 {
65 struct rpcif_op op = rpcif_op_tmpl;
66
67 op.cmd.opcode = HYPERBUS_RW_WRITE | HYPERBUS_AS_MEM;
68 op.addr.val = to >> 1;
69 op.data.dir = RPCIF_DATA_OUT;
70 op.data.nbytes = len;
71 op.data.buf.out = from;
72
73 rpcif_prepare(rpc->dev, &op, NULL, NULL);
74 }
75
rpcif_hb_read16(struct hyperbus_device * hbdev,unsigned long addr)76 static u16 rpcif_hb_read16(struct hyperbus_device *hbdev, unsigned long addr)
77 {
78 struct rpcif_hyperbus *hyperbus =
79 container_of(hbdev, struct rpcif_hyperbus, hbdev);
80 map_word data;
81
82 rpcif_hb_prepare_read(&hyperbus->rpc, &data, addr, 2);
83
84 rpcif_manual_xfer(hyperbus->rpc.dev);
85
86 return data.x[0];
87 }
88
rpcif_hb_write16(struct hyperbus_device * hbdev,unsigned long addr,u16 data)89 static void rpcif_hb_write16(struct hyperbus_device *hbdev, unsigned long addr,
90 u16 data)
91 {
92 struct rpcif_hyperbus *hyperbus =
93 container_of(hbdev, struct rpcif_hyperbus, hbdev);
94
95 rpcif_hb_prepare_write(&hyperbus->rpc, addr, &data, 2);
96
97 rpcif_manual_xfer(hyperbus->rpc.dev);
98 }
99
rpcif_hb_copy_from(struct hyperbus_device * hbdev,void * to,unsigned long from,ssize_t len)100 static void rpcif_hb_copy_from(struct hyperbus_device *hbdev, void *to,
101 unsigned long from, ssize_t len)
102 {
103 struct rpcif_hyperbus *hyperbus =
104 container_of(hbdev, struct rpcif_hyperbus, hbdev);
105
106 rpcif_hb_prepare_read(&hyperbus->rpc, to, from, len);
107
108 rpcif_dirmap_read(hyperbus->rpc.dev, from, len, to);
109 }
110
111 static const struct hyperbus_ops rpcif_hb_ops = {
112 .read16 = rpcif_hb_read16,
113 .write16 = rpcif_hb_write16,
114 .copy_from = rpcif_hb_copy_from,
115 };
116
rpcif_hb_probe(struct platform_device * pdev)117 static int rpcif_hb_probe(struct platform_device *pdev)
118 {
119 struct device *dev = &pdev->dev;
120 struct rpcif_hyperbus *hyperbus;
121 int error;
122
123 hyperbus = devm_kzalloc(dev, sizeof(*hyperbus), GFP_KERNEL);
124 if (!hyperbus)
125 return -ENOMEM;
126
127 error = rpcif_sw_init(&hyperbus->rpc, pdev->dev.parent);
128 if (error)
129 return error;
130
131 platform_set_drvdata(pdev, hyperbus);
132
133 pm_runtime_enable(hyperbus->rpc.dev);
134
135 error = rpcif_hw_init(hyperbus->rpc.dev, true);
136 if (error)
137 goto out_disable_rpm;
138
139 hyperbus->hbdev.map.size = hyperbus->rpc.size;
140 hyperbus->hbdev.map.virt = hyperbus->rpc.dirmap;
141
142 hyperbus->ctlr.dev = dev;
143 hyperbus->ctlr.ops = &rpcif_hb_ops;
144 hyperbus->hbdev.ctlr = &hyperbus->ctlr;
145 hyperbus->hbdev.np = of_get_next_child(pdev->dev.parent->of_node, NULL);
146 error = hyperbus_register_device(&hyperbus->hbdev);
147 if (error)
148 goto out_disable_rpm;
149
150 return 0;
151
152 out_disable_rpm:
153 pm_runtime_disable(hyperbus->rpc.dev);
154 return error;
155 }
156
rpcif_hb_remove(struct platform_device * pdev)157 static void rpcif_hb_remove(struct platform_device *pdev)
158 {
159 struct rpcif_hyperbus *hyperbus = platform_get_drvdata(pdev);
160
161 hyperbus_unregister_device(&hyperbus->hbdev);
162
163 pm_runtime_disable(hyperbus->rpc.dev);
164 }
165
166 static const struct platform_device_id rpc_if_hyperflash_id_table[] = {
167 { .name = "rpc-if-hyperflash" },
168 { /* sentinel */ }
169 };
170 MODULE_DEVICE_TABLE(platform, rpc_if_hyperflash_id_table);
171
172 static struct platform_driver rpcif_platform_driver = {
173 .probe = rpcif_hb_probe,
174 .remove = rpcif_hb_remove,
175 .id_table = rpc_if_hyperflash_id_table,
176 .driver = {
177 .name = "rpc-if-hyperflash",
178 },
179 };
180
181 module_platform_driver(rpcif_platform_driver);
182
183 MODULE_DESCRIPTION("Renesas RPC-IF HyperFlash driver");
184 MODULE_LICENSE("GPL v2");
185