1 /*
2  * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3  *
4  * HDF is dual licensed: you can use it either under the terms of
5  * the GPL, or the BSD license, at your option.
6  * See the LICENSE file in the root of this repository for complete details.
7  */
8 
9 #include <securec.h>
10 #include "osal_mem.h"
11 #include "hdf_log.h"
12 #include "input_config.h"
13 
14 #define CHECK_PARSER_RET(ret,  str) do { \
15     if ((ret) != HDF_SUCCESS) { \
16         HDF_LOGE("%s: %s failed, ret = %d", __func__, str, ret); \
17         return HDF_FAILURE; \
18     } \
19 } while (0)
20 
21 #define DEFAULT_I2C_SPEED 400
22 #define DEFAULT_SPI_SPEED 10000
23 #define I2C 0
24 #define SPI 1
25 
ParseInfraredConfig(const struct DeviceResourceNode * node,InfraredCfg * config)26 int32_t ParseInfraredConfig(const struct DeviceResourceNode *node, InfraredCfg *config)
27 {
28     int32_t ret;
29     struct DeviceResourceIface *parser = NULL;
30     if (node == NULL || config == NULL) {
31         HDF_LOGE("%s: param is null", __func__);
32         return HDF_FAILURE;
33     }
34 
35     parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
36     if (parser == NULL) {
37         HDF_LOGE("%s: instance parser failed", __func__);
38         return HDF_FAILURE;
39     }
40 
41     const struct DeviceResourceNode *infraredNode = node;
42     ret = parser->GetString(infraredNode, "infraredName", &config->infraredName, NULL);
43     CHECK_PARSER_RET(ret, "GetString");
44     ret = parser->GetUint8(infraredNode, "inputType", &config->devType, 0);
45     CHECK_PARSER_RET(ret, "GetUint8");
46     ret = parser->GetUint16(infraredNode, "gpioNum", &config->gpioNum, 0);
47     CHECK_PARSER_RET(ret, "GetUint16");
48     ret = parser->GetUint16(infraredNode, "irqFlag", &config->irqFlag, 0);
49     CHECK_PARSER_RET(ret, "GetUint8");
50 
51     return HDF_SUCCESS;
52 }
53 
ParseKeyConfig(const struct DeviceResourceNode * node,KeyChipCfg * config)54 int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config)
55 {
56     int32_t ret;
57     struct DeviceResourceIface *parser = NULL;
58     if (node == NULL || config == NULL) {
59         HDF_LOGE("%s: param is null", __func__);
60         return HDF_FAILURE;
61     }
62 
63     parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
64     if (parser == NULL) {
65         HDF_LOGE("%s: instance parser failed", __func__);
66         return HDF_FAILURE;
67     }
68 
69     const struct DeviceResourceNode *keyNode = node;
70     ret = parser->GetString(keyNode, "keyName", &config->keyName, NULL);
71     CHECK_PARSER_RET(ret, "GetString");
72     ret = parser->GetUint8(keyNode, "inputType", &config->devType, 0);
73     CHECK_PARSER_RET(ret, "GetUint8");
74     ret = parser->GetUint16(keyNode, "gpioNum", &config->gpioNum, 0);
75     CHECK_PARSER_RET(ret, "GetUint16");
76     ret = parser->GetUint16(keyNode, "irqFlag", &config->irqFlag, 0);
77     CHECK_PARSER_RET(ret, "GetUint8");
78     ret = parser->GetUint32(keyNode, "debounceTime", &config->debounceTime, 0);
79     CHECK_PARSER_RET(ret, "GetUint32");
80 
81     return HDF_SUCCESS;
82 }
83 
ParseEncoderConfig(const struct DeviceResourceNode * node,EncoderCfg * config)84 int32_t ParseEncoderConfig(const struct DeviceResourceNode *node, EncoderCfg *config)
85 {
86     if (node == NULL || config == NULL) {
87         HDF_LOGE("%s: param is null", __func__);
88         return HDF_FAILURE;
89     }
90 
91     struct DeviceResourceIface *parser = NULL;
92     parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
93     if (parser == NULL) {
94         HDF_LOGE("%s: instance parser failed", __func__);
95         return HDF_FAILURE;
96     }
97 
98     const struct DeviceResourceNode *encoderNode = node;
99     int32_t ret = parser->GetUint8(encoderNode, "inputType", &config->devType, 0);
100     CHECK_PARSER_RET(ret, "GetUint8");
101     ret = parser->GetUint16(encoderNode, "gpioClk", &config->gpioClk, 0);
102     CHECK_PARSER_RET(ret, "GetUint16");
103     ret = parser->GetUint16(encoderNode, "gpioDT", &config->gpioData, 0);
104     CHECK_PARSER_RET(ret, "GetUint16");
105     ret = parser->GetUint16(encoderNode, "gpioSW", &config->gpioSW, 0);
106     CHECK_PARSER_RET(ret, "GetUint16");
107 
108     return HDF_SUCCESS;
109 }
110 
ParseAttr(struct DeviceResourceIface * parser,const struct DeviceResourceNode * attrNode,BoardAttrCfg * attr)111 static int32_t ParseAttr(struct DeviceResourceIface *parser, const struct DeviceResourceNode *attrNode,
112     BoardAttrCfg *attr)
113 {
114     int32_t ret;
115     ret = parser->GetUint8(attrNode, "inputType", &attr->devType, 0);
116     CHECK_PARSER_RET(ret, "GetUint8");
117     ret = parser->GetString(attrNode, "devName", &attr->devName, NULL);
118     CHECK_PARSER_RET(ret, "GetString");
119     ret = parser->GetUint32(attrNode, "solutionX", &attr->resolutionX, 0);
120     CHECK_PARSER_RET(ret, "GetUint32");
121     ret = parser->GetUint32(attrNode, "solutionY", &attr->resolutionY, 0);
122     CHECK_PARSER_RET(ret, "GetUint32");
123     return HDF_SUCCESS;
124 }
125 
ParseBus(struct DeviceResourceIface * parser,const struct DeviceResourceNode * busNode,BoardBusCfg * bus)126 static int32_t ParseBus(struct DeviceResourceIface *parser, const struct DeviceResourceNode *busNode, BoardBusCfg *bus)
127 {
128     int32_t ret;
129     ret = parser->GetUint8(busNode, "busType", &bus->busType, 0);
130     CHECK_PARSER_RET(ret, "GetUint8");
131 
132     if (bus->busType == I2C) {
133         ret = parser->GetUint8(busNode, "busNum", &bus->i2c.busNum, 0);
134         CHECK_PARSER_RET(ret, "GetUint8");
135         ret = parser->GetUint16(busNode, "clkGpio", &bus->i2c.clkGpio, 0);
136         CHECK_PARSER_RET(ret, "GetUint16");
137         ret = parser->GetUint16(busNode, "dataGpio", &bus->i2c.dataGpio, 0);
138         CHECK_PARSER_RET(ret, "GetUint16");
139         ret = parser->GetUint32Array(busNode, "i2cClkIomux", bus->i2c.i2cClkReg, REG_CONFIG_LEN, 0);
140         CHECK_PARSER_RET(ret, "GetUint32Array");
141         ret = parser->GetUint32Array(busNode, "i2cDataIomux", bus->i2c.i2cDataReg, REG_CONFIG_LEN, 0);
142         CHECK_PARSER_RET(ret, "GetUint32Array");
143     } else if (bus->busType == SPI) {
144         ret = parser->GetUint8(busNode, "busNum", &bus->spi.busNum, 0);
145         CHECK_PARSER_RET(ret, "GetUint8");
146         ret = parser->GetUint16(busNode, "clkGpio", &bus->spi.clkGpio, 0);
147         CHECK_PARSER_RET(ret, "GetUint16");
148         ret = parser->GetUint16(busNode, "csGpio", &bus->spi.csGpio, 0);
149         CHECK_PARSER_RET(ret, "GetUint16");
150         ret = parser->GetUint16(busNode, "misoGpio", &bus->spi.misoGpio, 0);
151         CHECK_PARSER_RET(ret, "GetUint16");
152         ret = parser->GetUint16(busNode, "mosiGpio", &bus->spi.mosiGpio, 0);
153         CHECK_PARSER_RET(ret, "GetUint16");
154     } else {
155         HDF_LOGE("%s: unknown bus type", __func__);
156     }
157     return HDF_SUCCESS;
158 }
159 
ParsePins(struct DeviceResourceIface * parser,const struct DeviceResourceNode * pinsNode,BoardPinCfg * pins)160 static int32_t ParsePins(struct DeviceResourceIface *parser, const struct DeviceResourceNode *pinsNode,
161     BoardPinCfg *pins)
162 {
163     int32_t ret;
164     ret = parser->GetUint16(pinsNode, "rstGpio", &pins->rstGpio, 0);
165     CHECK_PARSER_RET(ret, "GetUint16");
166     ret = parser->GetUint16(pinsNode, "intGpio", &pins->intGpio, 0);
167     CHECK_PARSER_RET(ret, "GetUint16");
168     ret = parser->GetUint32Array(pinsNode, "rstRegCfg", pins->rstPinReg, REG_CONFIG_LEN, 0);
169     CHECK_PARSER_RET(ret, "GetUint32Array");
170     ret = parser->GetUint32Array(pinsNode, "intRegCfg", pins->intPinReg, REG_CONFIG_LEN, 0);
171     CHECK_PARSER_RET(ret, "GetUint32Array");
172     return HDF_SUCCESS;
173 }
174 
ParsePower(struct DeviceResourceIface * parser,const struct DeviceResourceNode * powerNode,BoardPwrCfg * power)175 static int32_t ParsePower(struct DeviceResourceIface *parser, const struct DeviceResourceNode *powerNode,
176     BoardPwrCfg *power)
177 {
178     int32_t ret;
179     ret = parser->GetUint16(powerNode, "vccType", &power->vcc.pwrType, 0);
180     CHECK_PARSER_RET(ret, "GetUint16");
181     ret = parser->GetUint16(powerNode, "vccNum", &power->vcc.pwrNum, 0);
182     CHECK_PARSER_RET(ret, "GetUint16");
183     ret = parser->GetUint32(powerNode, "vccValue", &power->vcc.pwrValue, 0);
184     CHECK_PARSER_RET(ret, "GetUint32");
185     ret = parser->GetUint16(powerNode, "vciType", &power->vci.pwrType, 0);
186     CHECK_PARSER_RET(ret, "GetUint16");
187     ret = parser->GetUint16(powerNode, "vciNum", &power->vci.pwrNum, 0);
188     CHECK_PARSER_RET(ret, "GetUint16");
189     ret = parser->GetUint32(powerNode, "vciValue", &power->vci.pwrValue, 0);
190     CHECK_PARSER_RET(ret, "GetUint32");
191     return HDF_SUCCESS;
192 }
193 
ParseFeature(struct DeviceResourceIface * parser,const struct DeviceResourceNode * featureNode,BoardFeatureCfg * feature)194 static int32_t ParseFeature(struct DeviceResourceIface *parser, const struct DeviceResourceNode *featureNode,
195     BoardFeatureCfg *feature)
196 {
197     int32_t ret;
198     ret = parser->GetUint8(featureNode, "capacitanceTest", &feature->capacitanceTest, 0);
199     CHECK_PARSER_RET(ret, "GetUint8");
200     ret = parser->GetUint8(featureNode, "gestureMode", &feature->gestureMode, 0);
201     CHECK_PARSER_RET(ret, "GetUint8");
202     ret = parser->GetUint8(featureNode, "gloverMOde", &feature->gloverMOde, 0);
203     CHECK_PARSER_RET(ret, "GetUint8");
204     ret = parser->GetUint8(featureNode, "coverMode", &feature->coverMode, 0);
205     CHECK_PARSER_RET(ret, "GetUint8");
206     ret = parser->GetUint8(featureNode, "chargerMode", &feature->chargeMode, 0);
207     CHECK_PARSER_RET(ret, "GetUint8");
208     ret = parser->GetUint8(featureNode, "knuckleMode", &feature->knuckleMode, 0);
209     CHECK_PARSER_RET(ret, "GetUint8");
210     return HDF_SUCCESS;
211 }
212 
ParseTouchBoardConfig(const struct DeviceResourceNode * node,TouchBoardCfg * config)213 int32_t ParseTouchBoardConfig(const struct DeviceResourceNode *node, TouchBoardCfg *config)
214 {
215     int32_t ret;
216     struct DeviceResourceIface *parser = NULL;
217 
218     if (node == NULL || config == NULL) {
219         HDF_LOGE("%s: input param is null", __func__);
220         return HDF_FAILURE;
221     }
222     parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
223     if (parser == NULL) {
224         HDF_LOGE("%s: invalid parser", __func__);
225         return HDF_FAILURE;
226     }
227     config->boardNode = node;
228     const struct DeviceResourceNode *attrNode = parser->GetChildNode(node, "inputAttr");
229     const struct DeviceResourceNode *busNode = parser->GetChildNode(node, "busConfig");
230     const struct DeviceResourceNode *pinsNode = parser->GetChildNode(node, "pinConfig");
231     const struct DeviceResourceNode *powerNode = parser->GetChildNode(node, "powerConfig");
232     const struct DeviceResourceNode *featureNode = parser->GetChildNode(node, "featureConfig");
233     if (attrNode == NULL || busNode == NULL || pinsNode == NULL || powerNode == NULL || featureNode == NULL) {
234         HDF_LOGE("%s: get child node fail!", __func__);
235         return HDF_FAILURE;
236     }
237 
238     ret = ParseAttr(parser, attrNode, &config->attr);
239     CHECK_PARSER_RET(ret, "ParseAttr");
240     ret = ParseBus(parser, busNode, &config->bus);
241     CHECK_PARSER_RET(ret, "ParseBus");
242     ret = ParsePins(parser, pinsNode, &config->pins);
243     CHECK_PARSER_RET(ret, "ParsePins");
244     ret = ParsePower(parser, powerNode, &config->power);
245     CHECK_PARSER_RET(ret, "ParsePower");
246     ret = ParseFeature(parser, featureNode, &config->feature);
247     CHECK_PARSER_RET(ret, "ParseFeature");
248     return HDF_SUCCESS;
249 }
250 
ParsePowerSequence(struct DeviceResourceIface * parser,const struct DeviceResourceNode * seqNode,ChipPwrSeq * pwrSeq)251 static int32_t ParsePowerSequence(struct DeviceResourceIface *parser, const struct DeviceResourceNode *seqNode,
252     ChipPwrSeq *pwrSeq)
253 {
254     int32_t ret;
255     uint32_t num = (uint32_t)parser->GetElemNum(seqNode, "powerOnSeq");
256     pwrSeq->pwrOn.count = num;
257     pwrSeq->pwrOn.buf = (uint32_t *)OsalMemAlloc(sizeof(uint32_t) * num);
258     if (pwrSeq->pwrOn.buf == NULL) {
259         return HDF_FAILURE;
260     }
261     (void)memset_s(pwrSeq->pwrOn.buf, sizeof(uint32_t) * num, 0, sizeof(uint32_t) * num);
262     ret = parser->GetUint32Array(seqNode, "powerOnSeq", pwrSeq->pwrOn.buf, num, 0);
263     CHECK_PARSER_RET(ret, "GetUint32Array");
264     pwrSeq->suspend.count = parser->GetElemNum(seqNode, "suspendSeq");
265     num = pwrSeq->suspend.count;
266     pwrSeq->suspend.buf = (uint32_t *)OsalMemAlloc(sizeof(uint32_t) * num);
267     if (pwrSeq->suspend.buf == NULL) {
268         OsalMemFree(pwrSeq->pwrOn.buf);
269         pwrSeq->pwrOn.buf = NULL;
270         return HDF_FAILURE;
271     }
272     (void)memset_s(pwrSeq->suspend.buf, sizeof(uint32_t) * num, 0, sizeof(uint32_t) * num);
273     ret = parser->GetUint32Array(seqNode, "suspendSeq", pwrSeq->suspend.buf, num, 0);
274     CHECK_PARSER_RET(ret, "GetUint32Array");
275     pwrSeq->resume.count = parser->GetElemNum(seqNode, "resumeSeq");
276     num = pwrSeq->resume.count;
277     pwrSeq->resume.buf = (uint32_t *)OsalMemAlloc(sizeof(uint32_t) * num);
278     if (pwrSeq->resume.buf == NULL) {
279         OsalMemFree(pwrSeq->pwrOn.buf);
280         pwrSeq->pwrOn.buf = NULL;
281         OsalMemFree(pwrSeq->suspend.buf);
282         pwrSeq->suspend.buf = NULL;
283         return HDF_FAILURE;
284     }
285     (void)memset_s(pwrSeq->resume.buf, sizeof(uint32_t) * num, 0, sizeof(uint32_t) * num);
286     ret = parser->GetUint32Array(seqNode, "resumeSeq", pwrSeq->resume.buf, num, 0);
287     CHECK_PARSER_RET(ret, "GetUint32Array");
288     pwrSeq->pwrOff.count = parser->GetElemNum(seqNode, "powerOffSeq");
289     num = pwrSeq->pwrOff.count;
290     pwrSeq->pwrOff.buf = (uint32_t *)OsalMemAlloc(sizeof(uint32_t) * num);
291     if (pwrSeq->pwrOff.buf == NULL) {
292         OsalMemFree(pwrSeq->pwrOn.buf);
293         pwrSeq->pwrOn.buf = NULL;
294         OsalMemFree(pwrSeq->suspend.buf);
295         pwrSeq->suspend.buf = NULL;
296         OsalMemFree(pwrSeq->resume.buf);
297         pwrSeq->resume.buf = NULL;
298         return HDF_FAILURE;
299     }
300     (void)memset_s(pwrSeq->pwrOff.buf, sizeof(uint32_t) * num, 0, sizeof(uint32_t) * num);
301     ret = parser->GetUint32Array(seqNode, "powerOffSeq", pwrSeq->pwrOff.buf, num, 0);
302     CHECK_PARSER_RET(ret, "GetUint32Array");
303     return HDF_SUCCESS;
304 }
305 
ParseTouchChipConfig(const struct DeviceResourceNode * node,TouchChipCfg * config)306 int32_t ParseTouchChipConfig(const struct DeviceResourceNode *node, TouchChipCfg *config)
307 {
308     int32_t ret;
309     struct DeviceResourceIface *parser = NULL;
310     if (node == NULL || config == NULL) {
311         HDF_LOGE("%s: point is null", __func__);
312         return HDF_FAILURE;
313     }
314     parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
315     if (parser == NULL) {
316         HDF_LOGE("%s: instance parser failed", __func__);
317         return HDF_FAILURE;
318     }
319 
320     config->chipNode = node;
321     ret = parser->GetString(node, "chipName", &config->chipName, NULL);
322     CHECK_PARSER_RET(ret, "GetString");
323     ret = parser->GetString(node, "vendorName", &config->vendorName, NULL);
324     CHECK_PARSER_RET(ret, "GetString");
325     ret = parser->GetString(node, "chipInfo", &config->chipInfo, NULL);
326     CHECK_PARSER_RET(ret, "GetString");
327     ret = parser->GetUint16(node, "chipVersion", &config->chipVersion, 0);
328     CHECK_PARSER_RET(ret, "GetUint16");
329     ret = parser->GetUint8(node, "busType", &config->bus.busType, 0);
330     CHECK_PARSER_RET(ret, "GetUint8");
331     if (config->bus.busType == I2C) {
332         ret = parser->GetUint16(node, "irqFlag", &config->bus.chipI2c.irqFlag, 0);
333         CHECK_PARSER_RET(ret, "GetUint16");
334         ret = parser->GetUint32(node, "deviceAddr", &config->bus.chipI2c.commAddr, 0);
335         CHECK_PARSER_RET(ret, "GetUint32");
336         ret = parser->GetUint32(node, "maxSpeed", &config->bus.chipI2c.maxSpeed, DEFAULT_I2C_SPEED);
337         CHECK_PARSER_RET(ret, "GetUint32");
338     } else {
339         ret = parser->GetUint16(node, "irqFlag", &config->bus.chipSpi.irqFlag, 0);
340         CHECK_PARSER_RET(ret, "GetUint16");
341         ret = parser->GetUint8(node, "wordMode", &config->bus.chipSpi.wordMode, 0);
342         CHECK_PARSER_RET(ret, "GetUint8");
343         ret = parser->GetUint8(node, "commMode", &config->bus.chipSpi.commMode, 0);
344         CHECK_PARSER_RET(ret, "GetUint8");
345         ret = parser->GetUint32(node, "maxSpeed", &config->bus.chipSpi.maxSpeed, DEFAULT_SPI_SPEED);
346         CHECK_PARSER_RET(ret, "GetUint32");
347     }
348     const struct DeviceResourceNode *pwrSeqNode = parser->GetChildNode(node, "powerSequence");
349     if (pwrSeqNode == NULL) {
350         HDF_LOGE("%s: get powerSequence child node failed", __func__);
351         return HDF_FAILURE;
352     }
353     if (ParsePowerSequence(parser, pwrSeqNode, &config->pwrSeq) != HDF_SUCCESS) {
354         return HDF_FAILURE;
355     }
356     return HDF_SUCCESS;
357 }