1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
4 *
5 * Author: Algea Cao <algea.cao@rock-chips.com>
6 */
7
8 #include <linux/device.h>
9 #include <linux/err.h>
10 #include <linux/input.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/mfd/rk630.h>
14 #include <linux/spi/spi.h>
15
16 #define RK630_CMD_WRITE 0x00000011
17 #define RK630_CMD_WRITE_REG0 0x00010011
18 #define RK630_CMD_WRITE_REG1 0x00020011
19 #define RK630_CMD_WRITE_CTRL0 0x00030011
20 #define RK630_CMD_READ 0x00000077
21 #define RK630_CMD_READ_BEGIN 0x000000AA
22 #define RK630_CMD_QUERY 0x000000FF
23 #define RK630_CMD_QUERY_REG2 0x000001FF
24 #define RK630_CMD_QUICK_WRITE 0x00030011
25 #define RK630_OP_STATE_ID_MASK (0xffff0000)
26 #define RK630_OP_STATE_ID (0X16080000)
27 #define RK630_OP_STATE_MASK (0x0000ffff)
28 #define RK630_OP_STATE_WRITE_ERROR (0x01 << 0)
29 #define RK630_OP_STATE_WRITE_OVERFLOW (0x01 << 1)
30 #define RK630_OP_STATE_WRITE_UNFINISHED (0x01 << 2)
31 #define RK630_OP_STATE_READ_ERROR (0x01 << 8)
32 #define RK630_OP_STATE_READ_UNDERFLOW (0x01 << 9)
33 #define RK630_OP_STATE_PRE_READ_ERROR (0x01 << 10)
34 #define RK630_MAX_OP_BYTES (60000)
35
rk630_spi_ctrl_init(struct spi_device * spi)36 static int rk630_spi_ctrl_init(struct spi_device *spi)
37 {
38 u32 write_cmd = RK630_CMD_WRITE_CTRL0;
39 u32 buf = 0x00000008;
40 struct spi_transfer write_cmd_packet = {
41 .tx_buf = &write_cmd,
42 .len = 4,
43 };
44 struct spi_transfer data_packet = {
45 .tx_buf = &buf,
46 .len = 4,
47 };
48 struct spi_message m;
49
50 spi_message_init(&m);
51 spi_message_add_tail(&write_cmd_packet, &m);
52 spi_message_add_tail(&data_packet, &m);
53 return spi_sync(spi, &m);
54 }
55
rk630_spi_write(struct spi_device * spi,u32 addr,const u32 * data,size_t data_len)56 static int rk630_spi_write(struct spi_device *spi,
57 u32 addr, const u32 *data, size_t data_len)
58 {
59 int ret = 0;
60 u32 write_cmd = RK630_CMD_WRITE;
61
62 struct spi_transfer write_cmd_packet = {
63 .tx_buf = &write_cmd,
64 .len = sizeof(write_cmd),
65 };
66 struct spi_transfer addr_packet = {
67 .tx_buf = &addr,
68 .len = sizeof(addr),
69 };
70 struct spi_transfer data_packet = {
71 .tx_buf = data,
72 .len = data_len,
73 };
74 struct spi_message m;
75
76 spi_message_init(&m);
77 spi_message_add_tail(&write_cmd_packet, &m);
78 spi_message_add_tail(&addr_packet, &m);
79 spi_message_add_tail(&data_packet, &m);
80 ret = spi_sync(spi, &m);
81
82 return ret;
83 }
84
rk630_regmap_write(void * context,const void * data,size_t count)85 static int rk630_regmap_write(void *context, const void *data, size_t count)
86 {
87 struct device *dev = context;
88 struct spi_device *spi = to_spi_device(dev);
89 u32 buf[count];
90
91 if (count < 8) {
92 dev_err(&spi->dev, "regmap write err!\n");
93 return -EINVAL;
94 }
95
96 memcpy(buf, data, count);
97
98 return rk630_spi_write(spi, buf[0], &buf[1], (count - 4));
99 }
100
rk630_spi_read(struct spi_device * spi,u32 addr,u32 * data,size_t data_len)101 static int rk630_spi_read(struct spi_device *spi,
102 u32 addr, u32 *data, size_t data_len)
103 {
104 int ret;
105 u32 read_cmd = RK630_CMD_READ | (1 << 16);
106 u32 read_begin_cmd = RK630_CMD_READ_BEGIN;
107 u32 dummy = 0;
108 struct spi_transfer read_cmd_packet = {
109 .tx_buf = &read_cmd,
110 .len = sizeof(read_cmd),
111 };
112 struct spi_transfer addr_packet = {
113 .tx_buf = &addr,
114 .len = sizeof(addr),
115 };
116 struct spi_transfer read_dummy_packet = {
117 .tx_buf = &dummy,
118 .len = sizeof(dummy),
119 };
120 struct spi_transfer read_begin_cmd_packet = {
121 .tx_buf = &read_begin_cmd,
122 .len = sizeof(read_begin_cmd),
123 };
124 struct spi_transfer data_packet = {
125 .rx_buf = data,
126 .len = data_len,
127 };
128 struct spi_message m;
129
130 spi_message_init(&m);
131 spi_message_add_tail(&read_cmd_packet, &m);
132 spi_message_add_tail(&addr_packet, &m);
133 spi_message_add_tail(&read_dummy_packet, &m);
134 spi_message_add_tail(&read_begin_cmd_packet, &m);
135 spi_message_add_tail(&data_packet, &m);
136 ret = spi_sync(spi, &m);
137
138 return ret;
139 }
140
rk630_regmap_read(void * context,const void * reg,size_t reg_size,void * val,size_t val_size)141 static int rk630_regmap_read(void *context,
142 const void *reg, size_t reg_size,
143 void *val, size_t val_size)
144 {
145 struct device *dev = context;
146 struct spi_device *spi = to_spi_device(dev);
147 u32 rx_buf[2] = { 0 };
148 int ret;
149
150 if (reg_size != sizeof(u32) || val_size != sizeof(u32))
151 return -EINVAL;
152
153 /* Copy address to read from into first element of SPI buffer. */
154 memcpy(rx_buf, reg, sizeof(u32));
155 ret = rk630_spi_read(spi, rx_buf[0], &rx_buf[1], val_size);
156 if (ret < 0) {
157 dev_err(&spi->dev, "rk630 spi read err\n");
158 return ret;
159 }
160
161 memcpy(val, &rx_buf[1], val_size);
162 return 0;
163 }
164
165 static struct regmap_bus rk630_regmap = {
166 .write = rk630_regmap_write,
167 .read = rk630_regmap_read,
168 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
169 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
170 };
171
172 static int
rk630_spi_probe(struct spi_device * spi)173 rk630_spi_probe(struct spi_device *spi)
174 {
175 struct device *dev = &spi->dev;
176 struct rk630 *rk630;
177 int ret;
178
179 spi->bits_per_word = 8;
180 ret = spi_setup(spi);
181 if (ret < 0)
182 return ret;
183
184 rk630 = devm_kzalloc(dev, sizeof(*rk630), GFP_KERNEL);
185 if (!rk630)
186 return -ENOMEM;
187
188 rk630->dev = dev;
189 spi_set_drvdata(spi, rk630);
190
191 rk630->grf = devm_regmap_init(&spi->dev, &rk630_regmap,
192 &spi->dev, &rk630_grf_regmap_config);
193 if (IS_ERR(rk630->grf)) {
194 ret = PTR_ERR(rk630->grf);
195 dev_err(dev, "failed to allocate grf register map: %d\n", ret);
196 return ret;
197 }
198
199 rk630->cru = devm_regmap_init(&spi->dev, &rk630_regmap,
200 &spi->dev, &rk630_cru_regmap_config);
201 if (IS_ERR(rk630->cru)) {
202 ret = PTR_ERR(rk630->cru);
203 dev_err(dev, "failed to allocate cru register map: %d\n", ret);
204 return ret;
205 }
206
207 rk630->tve = devm_regmap_init(&spi->dev, &rk630_regmap,
208 &spi->dev, &rk630_tve_regmap_config);
209 if (IS_ERR(rk630->tve)) {
210 ret = PTR_ERR(rk630->tve);
211 dev_err(rk630->dev, "Failed to initialize tve regmap: %d\n",
212 ret);
213 return ret;
214 }
215
216 ret = rk630_core_probe(rk630);
217 if (ret)
218 return ret;
219
220 rk630_spi_ctrl_init(spi);
221
222 return 0;
223 }
224
225 static const struct of_device_id rk630_spi_of_match[] = {
226 { .compatible = "rockchip,rk630", },
227 {}
228 };
229 MODULE_DEVICE_TABLE(of, rk630_spi_of_match);
230
231 static const struct spi_device_id rk630_spi_id[] = {
232 { "rk630", 0 },
233 {}
234 };
235 MODULE_DEVICE_TABLE(spi, rk630_spi_id);
236
237 static struct spi_driver rk630_spi_driver = {
238 .driver = {
239 .name = "rk630",
240 .of_match_table = of_match_ptr(rk630_spi_of_match),
241 },
242 .probe = rk630_spi_probe,
243 .id_table = rk630_spi_id,
244 };
245 module_spi_driver(rk630_spi_driver);
246
247 MODULE_AUTHOR("Algea Cao <Algea.cao@rock-chips.com>");
248 MODULE_DESCRIPTION("Rockchip rk630 MFD SPI driver");
249 MODULE_LICENSE("GPL v2");
250