efcc92721c205402f26980c64abdd5e2a12a79e8
[firefly-linux-kernel-4.4.55.git] / drivers / mailbox / scpi_protocol.c
1 /*
2  * System Control and Power Interface (SCPI) Message Protocol driver
3  *
4  * Copyright (C) 2014 ARM Ltd.
5  * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms and conditions of the GNU General Public License,
9  * version 2, as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along with
17  * this program. If not, see <http://www.gnu.org/licenses/>.
18  */
19 #include <linux/of_device.h>
20 #include <linux/platform_device.h>
21 #include <linux/err.h>
22 #include <linux/export.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/printk.h>
26 #include <linux/mailbox_client.h>
27 #include <linux/scpi_protocol.h>
28 #include <linux/slab.h>
29 #include <linux/rockchip-mailbox.h>
30 #include <linux/rockchip/common.h>
31
32 #include "scpi_cmd.h"
33
34 #define CMD_ID_SHIFT            0
35 #define CMD_ID_MASK             0xff
36 #define CMD_SENDER_ID_SHIFT     8
37 #define CMD_SENDER_ID_MASK      0xff
38 #define CMD_DATA_SIZE_SHIFT     20
39 #define CMD_DATA_SIZE_MASK      0x1ff
40 #define PACK_SCPI_CMD(cmd, sender, txsz)                                \
41         ((((cmd) & CMD_ID_MASK) << CMD_ID_SHIFT) |                      \
42         (((sender) & CMD_SENDER_ID_MASK) << CMD_SENDER_ID_SHIFT) |      \
43         (((txsz) & CMD_DATA_SIZE_MASK) << CMD_DATA_SIZE_SHIFT))
44 #define SCPI_CMD_DEFAULT_TIMEOUT_MS  1000
45
46 #define MAX_DVFS_DOMAINS        3
47 #define MAX_DVFS_OPPS           8
48 #define DVFS_LATENCY(hdr)       ((hdr) >> 16)
49 #define DVFS_OPP_COUNT(hdr)     (((hdr) >> 8) & 0xff)
50
51 static int max_chan_num = 0;
52 static DECLARE_BITMAP(bm_mbox_chans, 4);
53 static DEFINE_MUTEX(scpi_mtx);
54
55 struct scpi_data_buf {
56         int client_id;
57         struct rockchip_mbox_msg *data;
58         struct completion complete;
59         int timeout_ms;
60 };
61
62 struct scpi_mcu_ver {
63         u32  scpi_ver;
64         char mcu_ver[16];
65 };
66
67 static int high_priority_cmds[] = {
68         SCPI_CMD_GET_CSS_PWR_STATE,
69         SCPI_CMD_CFG_PWR_STATE_STAT,
70         SCPI_CMD_GET_PWR_STATE_STAT,
71         SCPI_CMD_SET_DVFS,
72         SCPI_CMD_GET_DVFS,
73         SCPI_CMD_SET_RTC,
74         SCPI_CMD_GET_RTC,
75         SCPI_CMD_SET_CLOCK_INDEX,
76         SCPI_CMD_SET_CLOCK_VALUE,
77         SCPI_CMD_GET_CLOCK_VALUE,
78         SCPI_CMD_SET_PSU,
79         SCPI_CMD_GET_PSU,
80         SCPI_CMD_SENSOR_CFG_PERIODIC,
81         SCPI_CMD_SENSOR_CFG_BOUNDS,
82 };
83
84 static struct scpi_opp *scpi_opps[MAX_DVFS_DOMAINS];
85
86 static struct device *the_scpi_device;
87
88 static int scpi_linux_errmap[SCPI_ERR_MAX] = {
89         0, -EINVAL, -ENOEXEC, -EMSGSIZE,
90         -EINVAL, -EACCES, -ERANGE, -ETIMEDOUT,
91         -ENOMEM, -EINVAL, -EOPNOTSUPP, -EIO,
92 };
93
94 static inline int scpi_to_linux_errno(int errno)
95 {
96         if (errno >= SCPI_SUCCESS && errno < SCPI_ERR_MAX)
97                 return scpi_linux_errmap[errno];
98         return -EIO;
99 }
100
101 static bool __maybe_unused high_priority_chan_supported(int cmd)
102 {
103         int idx;
104
105         for (idx = 0; idx < ARRAY_SIZE(high_priority_cmds); idx++)
106                 if (cmd == high_priority_cmds[idx])
107                         return true;
108         return false;
109 }
110
111 static int scpi_alloc_mbox_chan(void)
112 {
113         int index;
114
115         mutex_lock(&scpi_mtx);
116
117         index = find_first_zero_bit(bm_mbox_chans, max_chan_num);
118         if (index >= max_chan_num) {
119                 pr_err("alloc mailbox channel failed\n");
120                 mutex_unlock(&scpi_mtx);
121                 return -EBUSY;
122         }
123
124         set_bit(index, bm_mbox_chans);
125
126         mutex_unlock(&scpi_mtx);
127         return index;
128 }
129
130 static void scpi_free_mbox_chan(int chan)
131 {
132         int index = chan;
133
134         mutex_lock(&scpi_mtx);
135
136         if (index < max_chan_num && index >= 0)
137                 clear_bit(index, bm_mbox_chans);
138
139         mutex_unlock(&scpi_mtx);
140 }
141
142 static void scpi_rx_callback(struct mbox_client *cl, void *msg)
143 {
144         struct rockchip_mbox_msg *data = (struct rockchip_mbox_msg *)msg;
145         struct scpi_data_buf *scpi_buf = data->cl_data;
146
147         complete(&scpi_buf->complete);
148 }
149
150 static int send_scpi_cmd(struct scpi_data_buf *scpi_buf, int index)
151 {
152         struct mbox_chan *chan;
153         struct mbox_client cl;
154         struct rockchip_mbox_msg *data = scpi_buf->data;
155         u32 status;
156         int ret;
157         int timeout = msecs_to_jiffies(scpi_buf->timeout_ms);
158
159         if (!the_scpi_device) {
160                 pr_err("Scpi initializes unsuccessfully\n");
161                 return -EIO;
162         }
163
164         cl.dev = the_scpi_device;
165         cl.rx_callback = scpi_rx_callback;
166         cl.tx_done = NULL;
167         cl.tx_block = false;
168         cl.knows_txdone = false;
169
170         chan = mbox_request_channel(&cl, index);
171         if (IS_ERR(chan)) {
172                 scpi_free_mbox_chan(index);
173                 return PTR_ERR(chan);
174         }
175
176         init_completion(&scpi_buf->complete);
177         if (mbox_send_message(chan, (void *)data) < 0) {
178                 status = SCPI_ERR_TIMEOUT;
179                 goto free_channel;
180         }
181
182         ret = wait_for_completion_timeout(&scpi_buf->complete, timeout);
183         if (ret == 0) {
184                 status = SCPI_ERR_TIMEOUT;
185                 goto free_channel;
186         }
187         status = *(u32 *)(data->rx_buf); /* read first word */
188
189 free_channel:
190         mbox_free_channel(chan);
191         scpi_free_mbox_chan(index);
192
193         return scpi_to_linux_errno(status);
194 }
195
196 #define SCPI_SETUP_DBUF(scpi_buf, mbox_buf, _client_id,\
197                         _cmd, _tx_buf, _rx_buf) \
198 do {                                            \
199         struct rockchip_mbox_msg *pdata = &mbox_buf;    \
200         pdata->cmd = _cmd;                      \
201         pdata->tx_buf = &_tx_buf;               \
202         pdata->tx_size = sizeof(_tx_buf);       \
203         pdata->rx_buf = &_rx_buf;               \
204         pdata->rx_size = sizeof(_rx_buf);       \
205         scpi_buf.client_id = _client_id;        \
206         scpi_buf.data = pdata;                  \
207         scpi_buf.timeout_ms = SCPI_CMD_DEFAULT_TIMEOUT_MS; \
208 } while (0)
209
210 static int scpi_execute_cmd(struct scpi_data_buf *scpi_buf)
211 {
212         struct rockchip_mbox_msg *data;
213         int index;
214
215         if (!scpi_buf || !scpi_buf->data)
216                 return -EINVAL;
217
218         index = scpi_alloc_mbox_chan();
219         if (index < 0)
220                 return -EBUSY;
221
222         data = scpi_buf->data;
223         data->cmd = PACK_SCPI_CMD(data->cmd, scpi_buf->client_id,
224                                   data->tx_size);
225         data->cl_data = scpi_buf;
226
227         return send_scpi_cmd(scpi_buf, index);
228 }
229
230 unsigned long scpi_clk_get_val(u16 clk_id)
231 {
232         struct scpi_data_buf sdata;
233         struct rockchip_mbox_msg mdata;
234         struct __packed {
235                 u32 status;
236                 u32 clk_rate;
237         } buf;
238
239         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_CLOCKS,
240                         SCPI_CMD_GET_CLOCK_VALUE, clk_id, buf);
241         if (scpi_execute_cmd(&sdata))
242                 return 0;
243
244         return buf.clk_rate;
245 }
246 EXPORT_SYMBOL_GPL(scpi_clk_get_val);
247
248 int scpi_clk_set_val(u16 clk_id, unsigned long rate)
249 {
250         struct scpi_data_buf sdata;
251         struct rockchip_mbox_msg mdata;
252         int stat;
253         struct __packed {
254                 u32 clk_rate;
255                 u16 clk_id;
256         } buf;
257
258         buf.clk_rate = (u32)rate;
259         buf.clk_id = clk_id;
260
261         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_CLOCKS,
262                         SCPI_CMD_SET_CLOCK_VALUE, buf, stat);
263         return scpi_execute_cmd(&sdata);
264 }
265 EXPORT_SYMBOL_GPL(scpi_clk_set_val);
266
267 struct scpi_opp *scpi_dvfs_get_opps(u8 domain)
268 {
269         struct scpi_data_buf sdata;
270         struct rockchip_mbox_msg mdata;
271         struct __packed {
272                 u32 status;
273                 u32 header;
274                 struct scpi_opp_entry opp[MAX_DVFS_OPPS];
275         } buf;
276         struct scpi_opp *opps;
277         size_t opps_sz;
278         int count, ret;
279
280         if (domain >= MAX_DVFS_DOMAINS)
281                 return ERR_PTR(-EINVAL);
282
283         if (scpi_opps[domain])  /* data already populated */
284                 return scpi_opps[domain];
285
286         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DVFS,
287                         SCPI_CMD_GET_DVFS_INFO, domain, buf);
288         ret = scpi_execute_cmd(&sdata);
289         if (ret)
290                 return ERR_PTR(ret);
291
292         opps = kmalloc(sizeof(*opps), GFP_KERNEL);
293         if (!opps)
294                 return ERR_PTR(-ENOMEM);
295
296         count = DVFS_OPP_COUNT(buf.header);
297         opps_sz = count * sizeof(*(opps->opp));
298
299         opps->count = count;
300         opps->latency = DVFS_LATENCY(buf.header);
301         opps->opp = kmalloc(opps_sz, GFP_KERNEL);
302         if (!opps->opp) {
303                 kfree(opps);
304                 return ERR_PTR(-ENOMEM);
305         }
306
307         memcpy(opps->opp, &buf.opp[0], opps_sz);
308         scpi_opps[domain] = opps;
309
310         return opps;
311 }
312 EXPORT_SYMBOL_GPL(scpi_dvfs_get_opps);
313
314 int scpi_dvfs_get_idx(u8 domain)
315 {
316         struct scpi_data_buf sdata;
317         struct rockchip_mbox_msg mdata;
318         struct __packed {
319                 u32 status;
320                 u8 dvfs_idx;
321         } buf;
322         int ret;
323
324         if (domain >= MAX_DVFS_DOMAINS)
325                 return -EINVAL;
326
327         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DVFS,
328                         SCPI_CMD_GET_DVFS, domain, buf);
329         ret = scpi_execute_cmd(&sdata);
330
331         if (!ret)
332                 ret = buf.dvfs_idx;
333         return ret;
334 }
335 EXPORT_SYMBOL_GPL(scpi_dvfs_get_idx);
336
337 int scpi_dvfs_set_idx(u8 domain, u8 idx)
338 {
339         struct scpi_data_buf sdata;
340         struct rockchip_mbox_msg mdata;
341         struct __packed {
342                 u8 dvfs_domain;
343                 u8 dvfs_idx;
344         } buf;
345         int stat;
346
347         buf.dvfs_idx = idx;
348         buf.dvfs_domain = domain;
349
350         if (domain >= MAX_DVFS_DOMAINS)
351                 return -EINVAL;
352
353         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DVFS,
354                         SCPI_CMD_SET_DVFS, buf, stat);
355         return scpi_execute_cmd(&sdata);
356 }
357 EXPORT_SYMBOL_GPL(scpi_dvfs_set_idx);
358
359 int scpi_get_sensor(char *name)
360 {
361         struct scpi_data_buf sdata;
362         struct rockchip_mbox_msg mdata;
363         struct __packed {
364                 u32 status;
365                 u16 sensors;
366         } cap_buf;
367         struct __packed {
368                 u32 status;
369                 u16 sensor;
370                 u8 class;
371                 u8 trigger;
372                 char name[20];
373         } info_buf;
374         int ret;
375         u16 sensor_id;
376
377         /* This should be handled by a generic macro */
378         do {
379                 struct rockchip_mbox_msg *pdata = &mdata;
380
381                 pdata->cmd = SCPI_CMD_SENSOR_CAPABILITIES;
382                 pdata->tx_size = 0;
383                 pdata->rx_buf = &cap_buf;
384                 pdata->rx_size = sizeof(cap_buf);
385                 sdata.client_id = SCPI_CL_THERMAL;
386                 sdata.data = pdata;
387         } while (0);
388
389         ret = scpi_execute_cmd(&sdata);
390         if (ret)
391                 goto out;
392
393         ret = -ENODEV;
394         for (sensor_id = 0; sensor_id < cap_buf.sensors; sensor_id++) {
395                 SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_THERMAL,
396                                 SCPI_CMD_SENSOR_INFO, sensor_id, info_buf);
397                 ret = scpi_execute_cmd(&sdata);
398                 if (ret)
399                         break;
400
401                 if (!strcmp(name, info_buf.name)) {
402                         ret = sensor_id;
403                         break;
404                 }
405         }
406 out:
407         return ret;
408 }
409 EXPORT_SYMBOL_GPL(scpi_get_sensor);
410
411 int scpi_get_sensor_value(u16 sensor, u32 *val)
412 {
413         struct scpi_data_buf sdata;
414         struct rockchip_mbox_msg mdata;
415         struct __packed {
416                 u32 status;
417                 u32 val;
418         } buf;
419         int ret;
420
421         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_THERMAL, SCPI_CMD_SENSOR_VALUE,
422                         sensor, buf);
423
424         ret = scpi_execute_cmd(&sdata);
425         if (ret)
426                 *val = buf.val;
427
428         return ret;
429 }
430 EXPORT_SYMBOL_GPL(scpi_get_sensor_value);
431
432 static int scpi_get_version(u32 old, struct scpi_mcu_ver *ver)
433 {
434         int ret;
435         struct scpi_data_buf sdata;
436         struct rockchip_mbox_msg mdata;
437         struct __packed {
438                 u32 status;
439                 struct scpi_mcu_ver version;
440         } buf;
441
442         memset(&buf, 0, sizeof(buf));
443         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_SYS, SCPI_SYS_GET_VERSION,
444                         old, buf);
445
446         ret = scpi_execute_cmd(&sdata);
447         if (ret) {
448                 pr_err("get scpi version from MCU failed, ret=%d\n", ret);
449                 goto OUT;
450         }
451
452         memcpy(ver, &(buf.version), sizeof(*ver));
453
454 OUT:
455         return ret;
456 }
457
458 int scpi_sys_set_mcu_state_suspend(void)
459 {
460         struct scpi_data_buf sdata;
461         struct rockchip_mbox_msg mdata;
462         struct __packed1 {
463                 u32 status;
464         } tx_buf;
465         struct __packed2 {
466                 u32 status;
467         } rx_buf;
468
469         tx_buf.status = 0;
470         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_SYS,
471                         SCPI_SYS_SET_MCU_STATE_SUSPEND, tx_buf, rx_buf);
472         return scpi_execute_cmd(&sdata);
473 }
474 EXPORT_SYMBOL_GPL(scpi_sys_set_mcu_state_suspend);
475
476 int scpi_sys_set_mcu_state_resume(void)
477 {
478         struct scpi_data_buf sdata;
479         struct rockchip_mbox_msg mdata;
480         struct __packed1 {
481                 u32 status;
482         } tx_buf;
483         struct __packed2 {
484                 u32 status;
485         } rx_buf;
486
487         tx_buf.status = 0;
488
489         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_SYS,
490                         SCPI_SYS_SET_MCU_STATE_RESUME, tx_buf, rx_buf);
491         return scpi_execute_cmd(&sdata);
492 }
493 EXPORT_SYMBOL_GPL(scpi_sys_set_mcu_state_resume);
494
495 int scpi_ddr_init(u32 dram_speed_bin, u32 freq, u32 lcdc_type, u32 addr_mcu_el3)
496 {
497         struct scpi_data_buf sdata;
498         struct rockchip_mbox_msg mdata;
499         struct __packed1 {
500                 u32 dram_speed_bin;
501                 u32 freq;
502                 u32 lcdc_type;
503                 u32 addr_mcu_el3;
504         } tx_buf;
505         struct __packed2 {
506                 u32 status;
507         } rx_buf;
508
509         tx_buf.dram_speed_bin = (u32)dram_speed_bin;
510         tx_buf.freq = (u32)freq;
511         tx_buf.lcdc_type = (u32)lcdc_type;
512         tx_buf.addr_mcu_el3 = addr_mcu_el3;
513         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DDR,
514                         SCPI_DDR_INIT, tx_buf, rx_buf);
515         return scpi_execute_cmd(&sdata);
516 }
517 EXPORT_SYMBOL_GPL(scpi_ddr_init);
518
519 int scpi_ddr_set_clk_rate(u32 rate, u32 lcdc_type)
520 {
521         struct scpi_data_buf sdata;
522         struct rockchip_mbox_msg mdata;
523         struct __packed1 {
524                 u32 clk_rate;
525                 u32 lcdc_type;
526         } tx_buf;
527         struct __packed2 {
528                 u32 status;
529         } rx_buf;
530
531         tx_buf.clk_rate = (u32)rate;
532         tx_buf.lcdc_type = (u32)lcdc_type;
533         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DDR,
534                         SCPI_DDR_SET_FREQ, tx_buf, rx_buf);
535         return scpi_execute_cmd(&sdata);
536 }
537 EXPORT_SYMBOL_GPL(scpi_ddr_set_clk_rate);
538
539 int scpi_ddr_round_rate(u32 m_hz)
540 {
541         struct scpi_data_buf sdata;
542         struct rockchip_mbox_msg mdata;
543         struct __packed1 {
544                 u32 clk_rate;
545         } tx_buf;
546         struct __packed2 {
547                 u32 status;
548                 u32 round_rate;
549         } rx_buf;
550
551         tx_buf.clk_rate = (u32)m_hz;
552
553         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DDR,
554                         SCPI_DDR_ROUND_RATE, tx_buf, rx_buf);
555         if (scpi_execute_cmd(&sdata))
556                 return 0;
557
558         return rx_buf.round_rate;
559 }
560 EXPORT_SYMBOL_GPL(scpi_ddr_round_rate);
561
562 int scpi_ddr_set_auto_self_refresh(u32 en)
563 {
564         struct scpi_data_buf sdata;
565         struct rockchip_mbox_msg mdata;
566         struct __packed1 {
567                 u32 enable;
568         } tx_buf;
569         struct __packed2 {
570                 u32 status;
571         } rx_buf;
572
573         tx_buf.enable = (u32)en;
574
575         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DDR,
576                         SCPI_DDR_AUTO_SELF_REFRESH, tx_buf, rx_buf);
577         return scpi_execute_cmd(&sdata);
578 }
579 EXPORT_SYMBOL_GPL(scpi_ddr_set_auto_self_refresh);
580
581 int scpi_ddr_bandwidth_get(struct ddr_bw_info *ddr_bw_ch0,
582                            struct ddr_bw_info *ddr_bw_ch1)
583 {
584         struct scpi_data_buf sdata;
585         struct rockchip_mbox_msg mdata;
586         struct __packed1 {
587                 u32 status;
588         } tx_buf;
589         struct __packed2 {
590                 u32 status;
591                 struct ddr_bw_info ddr_bw_ch0;
592                 struct ddr_bw_info ddr_bw_ch1;
593         } rx_buf;
594
595         tx_buf.status = 0;
596
597         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DDR,
598                         SCPI_DDR_BANDWIDTH_GET, tx_buf, rx_buf);
599         if (scpi_execute_cmd(&sdata))
600                 return 0;
601
602         memcpy(ddr_bw_ch0, &(rx_buf.ddr_bw_ch0), sizeof(rx_buf.ddr_bw_ch0));
603         memcpy(ddr_bw_ch1, &(rx_buf.ddr_bw_ch1), sizeof(rx_buf.ddr_bw_ch1));
604
605         return 0;
606 }
607 EXPORT_SYMBOL_GPL(scpi_ddr_bandwidth_get);
608
609 int scpi_ddr_get_clk_rate(void)
610 {
611         struct scpi_data_buf sdata;
612         struct rockchip_mbox_msg mdata;
613         struct __packed1 {
614                 u32 status;
615         } tx_buf;
616         struct __packed2 {
617                 u32 status;
618                 u32 clk_rate;
619         } rx_buf;
620
621         tx_buf.status = 0;
622         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_DDR,
623                         SCPI_DDR_GET_FREQ, tx_buf, rx_buf);
624         if (scpi_execute_cmd(&sdata))
625                 return 0;
626
627         return rx_buf.clk_rate;
628 }
629 EXPORT_SYMBOL_GPL(scpi_ddr_get_clk_rate);
630
631 int scpi_thermal_get_temperature(void)
632 {
633         int ret;
634         struct scpi_data_buf sdata;
635         struct rockchip_mbox_msg mdata;
636         struct __packed1 {
637                 u32 status;
638         } tx_buf;
639
640         struct __packed2 {
641                 u32 status;
642                 u32 tsadc_data;
643         } rx_buf;
644
645         tx_buf.status = 0;
646         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_THERMAL,
647                         SCPI_THERMAL_GET_TSADC_DATA, tx_buf, rx_buf);
648
649         ret = scpi_execute_cmd(&sdata);
650         if (ret) {
651                 pr_err("get temperature from MCU failed, ret=%d\n", ret);
652                 return ret;
653         }
654
655         return rx_buf.tsadc_data;
656 }
657 EXPORT_SYMBOL_GPL(scpi_thermal_get_temperature);
658
659 int scpi_thermal_set_clk_cycle(u32 cycle)
660 {
661         struct scpi_data_buf sdata;
662         struct rockchip_mbox_msg mdata;
663         struct __packed1 {
664                 u32 clk_cycle;
665         } tx_buf;
666
667         struct __packed2 {
668                 u32 status;
669         } rx_buf;
670
671         tx_buf.clk_cycle = cycle;
672         SCPI_SETUP_DBUF(sdata, mdata, SCPI_CL_THERMAL,
673                         SCPI_THERMAL_SET_TSADC_CYCLE, tx_buf, rx_buf);
674
675         return scpi_execute_cmd(&sdata);
676 }
677 EXPORT_SYMBOL_GPL(scpi_thermal_set_clk_cycle);
678
679 static struct of_device_id mobx_scpi_of_match[] = {
680         { .compatible = "rockchip,mbox-scpi"},
681         { },
682 };
683 MODULE_DEVICE_TABLE(of, mobx_scpi_of_match);
684
685 static int mobx_scpi_probe(struct platform_device *pdev)
686 {
687         int ret = 0;
688         int retry = 3;
689         int val = 0;
690         struct scpi_mcu_ver mcu_ver;
691         int check_version = 1; /*0: not check version, 1: check version*/
692
693         the_scpi_device = &pdev->dev;
694
695         /* try to get mboxes chan nums from DT */
696         if (of_property_read_u32((&pdev->dev)->of_node, "chan-nums", &val)) {
697                 dev_err(&pdev->dev, "parse mboxes chan-nums failed\n");
698                 ret = -EINVAL;
699                 goto exit;
700         }
701
702         max_chan_num = val;
703
704         /* try to check up with SCPI version from MCU */
705         while ((retry--) && (check_version != 0)) {
706                 memset(&mcu_ver, 0, sizeof(mcu_ver));
707
708                 ret = scpi_get_version(SCPI_VERSION, &mcu_ver);
709                 if ((ret == 0) && (mcu_ver.scpi_ver == SCPI_VERSION))
710                         break;
711         }
712
713         if ((retry <= 0) && (check_version != 0)) {
714                 dev_err(&pdev->dev,
715                         "Scpi verison not match:kernel ver:0x%x, MCU ver:0x%x, ret=%d\n",
716                         SCPI_VERSION, mcu_ver.scpi_ver, ret);
717                 ret = -EIO;
718                 goto exit;
719         }
720
721         dev_info(&pdev->dev, "Scpi initialize, version: 0x%x, chan nums: %d\n",
722                  mcu_ver.scpi_ver, val);
723         dev_info(&pdev->dev, "MCU version: %s\n", mcu_ver.mcu_ver);
724
725         return 0;
726 exit:
727         the_scpi_device = NULL;
728         return ret;
729 }
730
731 static struct platform_driver mbox_scpi_driver = {
732         .probe  = mobx_scpi_probe,
733         .driver = {
734                 .name = "mbox-scpi",
735                 .of_match_table = of_match_ptr(mobx_scpi_of_match),
736         },
737 };
738
739 static int __init rockchip_mbox_scpi_init(void)
740 {
741         return platform_driver_register(&mbox_scpi_driver);
742 }
743 subsys_initcall(rockchip_mbox_scpi_init);