Commit | Line | Data |
---|---|---|
312416d9 MS |
1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. */ | |
3 | ||
4 | #include <linux/kernel.h> | |
5 | #include <linux/of.h> | |
6 | #include <linux/of_address.h> | |
7 | #include <linux/of_platform.h> | |
8 | #include <linux/of_reserved_mem.h> | |
9 | #include <linux/platform_device.h> | |
10 | #include <linux/types.h> | |
11 | ||
12 | #include <soc/qcom/cmd-db.h> | |
13 | ||
14 | #define NUM_PRIORITY 2 | |
15 | #define MAX_SLV_ID 8 | |
312416d9 MS |
16 | #define SLAVE_ID_MASK 0x7 |
17 | #define SLAVE_ID_SHIFT 16 | |
18 | ||
312416d9 MS |
19 | /** |
20 | * struct entry_header: header for each entry in cmddb | |
21 | * | |
22 | * @id: resource's identifier | |
23 | * @priority: unused | |
24 | * @addr: the address of the resource | |
25 | * @len: length of the data | |
26 | * @offset: offset from :@data_offset, start of the data | |
27 | */ | |
28 | struct entry_header { | |
36b0aefd SB |
29 | u8 id[8]; |
30 | __le32 priority[NUM_PRIORITY]; | |
31 | __le32 addr; | |
32 | __le16 len; | |
33 | __le16 offset; | |
312416d9 MS |
34 | }; |
35 | ||
36 | /** | |
37 | * struct rsc_hdr: resource header information | |
38 | * | |
39 | * @slv_id: id for the resource | |
40 | * @header_offset: entry's header at offset from the end of the cmd_db_header | |
41 | * @data_offset: entry's data at offset from the end of the cmd_db_header | |
42 | * @cnt: number of entries for HW type | |
43 | * @version: MSB is major, LSB is minor | |
44 | * @reserved: reserved for future use. | |
45 | */ | |
46 | struct rsc_hdr { | |
36b0aefd SB |
47 | __le16 slv_id; |
48 | __le16 header_offset; | |
49 | __le16 data_offset; | |
50 | __le16 cnt; | |
51 | __le16 version; | |
52 | __le16 reserved[3]; | |
312416d9 MS |
53 | }; |
54 | ||
55 | /** | |
56 | * struct cmd_db_header: The DB header information | |
57 | * | |
58 | * @version: The cmd db version | |
36b0aefd | 59 | * @magic: constant expected in the database |
312416d9 MS |
60 | * @header: array of resources |
61 | * @checksum: checksum for the header. Unused. | |
62 | * @reserved: reserved memory | |
63 | * @data: driver specific data | |
64 | */ | |
65 | struct cmd_db_header { | |
36b0aefd SB |
66 | __le32 version; |
67 | u8 magic[4]; | |
312416d9 | 68 | struct rsc_hdr header[MAX_SLV_ID]; |
36b0aefd SB |
69 | __le32 checksum; |
70 | __le32 reserved; | |
312416d9 MS |
71 | u8 data[]; |
72 | }; | |
73 | ||
74 | /** | |
75 | * DOC: Description of the Command DB database. | |
76 | * | |
77 | * At the start of the command DB memory is the cmd_db_header structure. | |
78 | * The cmd_db_header holds the version, checksum, magic key as well as an | |
79 | * array for header for each slave (depicted by the rsc_header). Each h/w | |
80 | * based accelerator is a 'slave' (shared resource) and has slave id indicating | |
81 | * the type of accelerator. The rsc_header is the header for such individual | |
82 | * slaves of a given type. The entries for each of these slaves begin at the | |
83 | * rsc_hdr.header_offset. In addition each slave could have auxiliary data | |
84 | * that may be needed by the driver. The data for the slave starts at the | |
85 | * entry_header.offset to the location pointed to by the rsc_hdr.data_offset. | |
86 | * | |
87 | * Drivers have a stringified key to a slave/resource. They can query the slave | |
88 | * information and get the slave id and the auxiliary data and the length of the | |
89 | * data. Using this information, they can format the request to be sent to the | |
90 | * h/w accelerator and request a resource state. | |
91 | */ | |
92 | ||
36b0aefd SB |
93 | static const u8 CMD_DB_MAGIC[] = { 0xdb, 0x30, 0x03, 0x0c }; |
94 | ||
95 | static bool cmd_db_magic_matches(const struct cmd_db_header *header) | |
96 | { | |
97 | const u8 *magic = header->magic; | |
98 | ||
99 | return memcmp(magic, CMD_DB_MAGIC, ARRAY_SIZE(CMD_DB_MAGIC)) == 0; | |
100 | } | |
101 | ||
312416d9 MS |
102 | static struct cmd_db_header *cmd_db_header; |
103 | ||
84fa36eb | 104 | static inline const void *rsc_to_entry_header(const struct rsc_hdr *hdr) |
36b0aefd SB |
105 | { |
106 | u16 offset = le16_to_cpu(hdr->header_offset); | |
107 | ||
108 | return cmd_db_header->data + offset; | |
109 | } | |
110 | ||
111 | static inline void * | |
84fa36eb | 112 | rsc_offset(const struct rsc_hdr *hdr, const struct entry_header *ent) |
36b0aefd SB |
113 | { |
114 | u16 offset = le16_to_cpu(hdr->data_offset); | |
115 | u16 loffset = le16_to_cpu(ent->offset); | |
116 | ||
117 | return cmd_db_header->data + offset + loffset; | |
118 | } | |
119 | ||
312416d9 MS |
120 | /** |
121 | * cmd_db_ready - Indicates if command DB is available | |
122 | * | |
123 | * Return: 0 on success, errno otherwise | |
124 | */ | |
125 | int cmd_db_ready(void) | |
126 | { | |
127 | if (cmd_db_header == NULL) | |
128 | return -EPROBE_DEFER; | |
36b0aefd | 129 | else if (!cmd_db_magic_matches(cmd_db_header)) |
312416d9 MS |
130 | return -EINVAL; |
131 | ||
132 | return 0; | |
133 | } | |
134 | EXPORT_SYMBOL(cmd_db_ready); | |
135 | ||
84fa36eb SB |
136 | static int cmd_db_get_header(const char *id, const struct entry_header **eh, |
137 | const struct rsc_hdr **rh) | |
312416d9 | 138 | { |
84fa36eb SB |
139 | const struct rsc_hdr *rsc_hdr; |
140 | const struct entry_header *ent; | |
312416d9 | 141 | int ret, i, j; |
36b0aefd | 142 | u8 query[8]; |
312416d9 MS |
143 | |
144 | ret = cmd_db_ready(); | |
145 | if (ret) | |
146 | return ret; | |
147 | ||
36b0aefd SB |
148 | /* Pad out query string to same length as in DB */ |
149 | strncpy(query, id, sizeof(query)); | |
150 | ||
312416d9 MS |
151 | for (i = 0; i < MAX_SLV_ID; i++) { |
152 | rsc_hdr = &cmd_db_header->header[i]; | |
153 | if (!rsc_hdr->slv_id) | |
154 | break; | |
155 | ||
36b0aefd SB |
156 | ent = rsc_to_entry_header(rsc_hdr); |
157 | for (j = 0; j < le16_to_cpu(rsc_hdr->cnt); j++, ent++) { | |
84fa36eb SB |
158 | if (memcmp(ent->id, query, sizeof(ent->id)) == 0) { |
159 | if (eh) | |
160 | *eh = ent; | |
161 | if (rh) | |
162 | *rh = rsc_hdr; | |
163 | return 0; | |
164 | } | |
312416d9 MS |
165 | } |
166 | } | |
167 | ||
168 | return -ENODEV; | |
169 | } | |
170 | ||
312416d9 MS |
171 | /** |
172 | * cmd_db_read_addr() - Query command db for resource id address. | |
173 | * | |
174 | * @id: resource id to query for address | |
175 | * | |
176 | * Return: resource address on success, 0 on error | |
177 | * | |
178 | * This is used to retrieve resource address based on resource | |
179 | * id. | |
180 | */ | |
181 | u32 cmd_db_read_addr(const char *id) | |
182 | { | |
183 | int ret; | |
84fa36eb | 184 | const struct entry_header *ent; |
312416d9 | 185 | |
84fa36eb | 186 | ret = cmd_db_get_header(id, &ent, NULL); |
312416d9 | 187 | |
84fa36eb | 188 | return ret < 0 ? 0 : le32_to_cpu(ent->addr); |
312416d9 MS |
189 | } |
190 | EXPORT_SYMBOL(cmd_db_read_addr); | |
191 | ||
192 | /** | |
193 | * cmd_db_read_aux_data() - Query command db for aux data. | |
194 | * | |
ed3cafa7 SB |
195 | * @id: Resource to retrieve AUX Data on |
196 | * @len: size of data buffer returned | |
312416d9 | 197 | * |
ed3cafa7 | 198 | * Return: pointer to data on success, error pointer otherwise |
312416d9 | 199 | */ |
ed3cafa7 | 200 | const void *cmd_db_read_aux_data(const char *id, size_t *len) |
312416d9 MS |
201 | { |
202 | int ret; | |
84fa36eb SB |
203 | const struct entry_header *ent; |
204 | const struct rsc_hdr *rsc_hdr; | |
312416d9 | 205 | |
36b0aefd | 206 | ret = cmd_db_get_header(id, &ent, &rsc_hdr); |
312416d9 | 207 | if (ret) |
ed3cafa7 | 208 | return ERR_PTR(ret); |
312416d9 | 209 | |
ed3cafa7 SB |
210 | if (len) |
211 | *len = le16_to_cpu(ent->len); | |
312416d9 | 212 | |
ed3cafa7 | 213 | return rsc_offset(rsc_hdr, ent); |
312416d9 MS |
214 | } |
215 | EXPORT_SYMBOL(cmd_db_read_aux_data); | |
216 | ||
312416d9 MS |
217 | /** |
218 | * cmd_db_read_slave_id - Get the slave ID for a given resource address | |
219 | * | |
220 | * @id: Resource id to query the DB for version | |
221 | * | |
222 | * Return: cmd_db_hw_type enum on success, CMD_DB_HW_INVALID on error | |
223 | */ | |
224 | enum cmd_db_hw_type cmd_db_read_slave_id(const char *id) | |
225 | { | |
226 | int ret; | |
84fa36eb | 227 | const struct entry_header *ent; |
36b0aefd | 228 | u32 addr; |
312416d9 | 229 | |
84fa36eb | 230 | ret = cmd_db_get_header(id, &ent, NULL); |
36b0aefd SB |
231 | if (ret < 0) |
232 | return CMD_DB_HW_INVALID; | |
312416d9 | 233 | |
84fa36eb | 234 | addr = le32_to_cpu(ent->addr); |
36b0aefd | 235 | return (addr >> SLAVE_ID_SHIFT) & SLAVE_ID_MASK; |
312416d9 MS |
236 | } |
237 | EXPORT_SYMBOL(cmd_db_read_slave_id); | |
238 | ||
239 | static int cmd_db_dev_probe(struct platform_device *pdev) | |
240 | { | |
241 | struct reserved_mem *rmem; | |
242 | int ret = 0; | |
243 | ||
244 | rmem = of_reserved_mem_lookup(pdev->dev.of_node); | |
245 | if (!rmem) { | |
246 | dev_err(&pdev->dev, "failed to acquire memory region\n"); | |
247 | return -EINVAL; | |
248 | } | |
249 | ||
250 | cmd_db_header = memremap(rmem->base, rmem->size, MEMREMAP_WB); | |
93b26052 DC |
251 | if (!cmd_db_header) { |
252 | ret = -ENOMEM; | |
312416d9 MS |
253 | cmd_db_header = NULL; |
254 | return ret; | |
255 | } | |
256 | ||
36b0aefd | 257 | if (!cmd_db_magic_matches(cmd_db_header)) { |
312416d9 MS |
258 | dev_err(&pdev->dev, "Invalid Command DB Magic\n"); |
259 | return -EINVAL; | |
260 | } | |
261 | ||
262 | return 0; | |
263 | } | |
264 | ||
265 | static const struct of_device_id cmd_db_match_table[] = { | |
266 | { .compatible = "qcom,cmd-db" }, | |
267 | { }, | |
268 | }; | |
269 | ||
270 | static struct platform_driver cmd_db_dev_driver = { | |
271 | .probe = cmd_db_dev_probe, | |
272 | .driver = { | |
273 | .name = "cmd-db", | |
274 | .of_match_table = cmd_db_match_table, | |
275 | }, | |
276 | }; | |
277 | ||
278 | static int __init cmd_db_device_init(void) | |
279 | { | |
280 | return platform_driver_register(&cmd_db_dev_driver); | |
281 | } | |
282 | arch_initcall(cmd_db_device_init); |