2 * System Control and Power Interface (SCPI) Message Protocol driver
4 * SCPI Message Protocol is used between the System Control Processor(SCP)
5 * and the Application Processors(AP). The Message Handling Unit(MHU)
6 * provides a mechanism for inter-processor communication between SCP's
9 * SCP offers control and management of the core/cluster power states,
10 * various power domain DVFS including the core/cluster, certain system
11 * clocks configuration, thermal sensors and many others.
13 * Copyright (C) 2015 ARM Ltd.
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms and conditions of the GNU General Public License,
17 * version 2, as published by the Free Software Foundation.
19 * This program is distributed in the hope it will be useful, but WITHOUT
20 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
24 * You should have received a copy of the GNU General Public License along
25 * with this program. If not, see <http://www.gnu.org/licenses/>.
28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30 #include <linux/bitmap.h>
31 #include <linux/bitfield.h>
32 #include <linux/device.h>
33 #include <linux/err.h>
34 #include <linux/export.h>
36 #include <linux/kernel.h>
37 #include <linux/list.h>
38 #include <linux/mailbox_client.h>
39 #include <linux/module.h>
40 #include <linux/of_address.h>
41 #include <linux/of_platform.h>
42 #include <linux/printk.h>
43 #include <linux/pm_opp.h>
44 #include <linux/scpi_protocol.h>
45 #include <linux/slab.h>
46 #include <linux/sort.h>
47 #include <linux/spinlock.h>
49 #define CMD_ID_SHIFT 0
50 #define CMD_ID_MASK 0x7f
51 #define CMD_TOKEN_ID_SHIFT 8
52 #define CMD_TOKEN_ID_MASK 0xff
53 #define CMD_DATA_SIZE_SHIFT 16
54 #define CMD_DATA_SIZE_MASK 0x1ff
55 #define CMD_LEGACY_DATA_SIZE_SHIFT 20
56 #define CMD_LEGACY_DATA_SIZE_MASK 0x1ff
57 #define PACK_SCPI_CMD(cmd_id, tx_sz) \
58 ((((cmd_id) & CMD_ID_MASK) << CMD_ID_SHIFT) | \
59 (((tx_sz) & CMD_DATA_SIZE_MASK) << CMD_DATA_SIZE_SHIFT))
60 #define ADD_SCPI_TOKEN(cmd, token) \
61 ((cmd) |= (((token) & CMD_TOKEN_ID_MASK) << CMD_TOKEN_ID_SHIFT))
62 #define PACK_LEGACY_SCPI_CMD(cmd_id, tx_sz) \
63 ((((cmd_id) & CMD_ID_MASK) << CMD_ID_SHIFT) | \
64 (((tx_sz) & CMD_LEGACY_DATA_SIZE_MASK) << CMD_LEGACY_DATA_SIZE_SHIFT))
66 #define CMD_SIZE(cmd) (((cmd) >> CMD_DATA_SIZE_SHIFT) & CMD_DATA_SIZE_MASK)
67 #define CMD_LEGACY_SIZE(cmd) (((cmd) >> CMD_LEGACY_DATA_SIZE_SHIFT) & \
68 CMD_LEGACY_DATA_SIZE_MASK)
69 #define CMD_UNIQ_MASK (CMD_TOKEN_ID_MASK << CMD_TOKEN_ID_SHIFT | CMD_ID_MASK)
70 #define CMD_XTRACT_UNIQ(cmd) ((cmd) & CMD_UNIQ_MASK)
74 #define MAX_DVFS_DOMAINS 8
75 #define MAX_DVFS_OPPS 16
77 #define PROTO_REV_MAJOR_MASK GENMASK(31, 16)
78 #define PROTO_REV_MINOR_MASK GENMASK(15, 0)
80 #define FW_REV_MAJOR_MASK GENMASK(31, 24)
81 #define FW_REV_MINOR_MASK GENMASK(23, 16)
82 #define FW_REV_PATCH_MASK GENMASK(15, 0)
84 #define MAX_RX_TIMEOUT (msecs_to_jiffies(30))
86 enum scpi_error_codes
{
87 SCPI_SUCCESS
= 0, /* Success */
88 SCPI_ERR_PARAM
= 1, /* Invalid parameter(s) */
89 SCPI_ERR_ALIGN
= 2, /* Invalid alignment */
90 SCPI_ERR_SIZE
= 3, /* Invalid size */
91 SCPI_ERR_HANDLER
= 4, /* Invalid handler/callback */
92 SCPI_ERR_ACCESS
= 5, /* Invalid access/permission denied */
93 SCPI_ERR_RANGE
= 6, /* Value out of range */
94 SCPI_ERR_TIMEOUT
= 7, /* Timeout has occurred */
95 SCPI_ERR_NOMEM
= 8, /* Invalid memory area or pointer */
96 SCPI_ERR_PWRSTATE
= 9, /* Invalid power state */
97 SCPI_ERR_SUPPORT
= 10, /* Not supported or disabled */
98 SCPI_ERR_DEVICE
= 11, /* Device error */
99 SCPI_ERR_BUSY
= 12, /* Device busy */
103 /* SCPI Standard commands */
105 SCPI_CMD_INVALID
= 0x00,
106 SCPI_CMD_SCPI_READY
= 0x01,
107 SCPI_CMD_SCPI_CAPABILITIES
= 0x02,
108 SCPI_CMD_SET_CSS_PWR_STATE
= 0x03,
109 SCPI_CMD_GET_CSS_PWR_STATE
= 0x04,
110 SCPI_CMD_SET_SYS_PWR_STATE
= 0x05,
111 SCPI_CMD_SET_CPU_TIMER
= 0x06,
112 SCPI_CMD_CANCEL_CPU_TIMER
= 0x07,
113 SCPI_CMD_DVFS_CAPABILITIES
= 0x08,
114 SCPI_CMD_GET_DVFS_INFO
= 0x09,
115 SCPI_CMD_SET_DVFS
= 0x0a,
116 SCPI_CMD_GET_DVFS
= 0x0b,
117 SCPI_CMD_GET_DVFS_STAT
= 0x0c,
118 SCPI_CMD_CLOCK_CAPABILITIES
= 0x0d,
119 SCPI_CMD_GET_CLOCK_INFO
= 0x0e,
120 SCPI_CMD_SET_CLOCK_VALUE
= 0x0f,
121 SCPI_CMD_GET_CLOCK_VALUE
= 0x10,
122 SCPI_CMD_PSU_CAPABILITIES
= 0x11,
123 SCPI_CMD_GET_PSU_INFO
= 0x12,
124 SCPI_CMD_SET_PSU
= 0x13,
125 SCPI_CMD_GET_PSU
= 0x14,
126 SCPI_CMD_SENSOR_CAPABILITIES
= 0x15,
127 SCPI_CMD_SENSOR_INFO
= 0x16,
128 SCPI_CMD_SENSOR_VALUE
= 0x17,
129 SCPI_CMD_SENSOR_CFG_PERIODIC
= 0x18,
130 SCPI_CMD_SENSOR_CFG_BOUNDS
= 0x19,
131 SCPI_CMD_SENSOR_ASYNC_VALUE
= 0x1a,
132 SCPI_CMD_SET_DEVICE_PWR_STATE
= 0x1b,
133 SCPI_CMD_GET_DEVICE_PWR_STATE
= 0x1c,
137 /* SCPI Legacy Commands */
138 enum legacy_scpi_std_cmd
{
139 LEGACY_SCPI_CMD_INVALID
= 0x00,
140 LEGACY_SCPI_CMD_SCPI_READY
= 0x01,
141 LEGACY_SCPI_CMD_SCPI_CAPABILITIES
= 0x02,
142 LEGACY_SCPI_CMD_EVENT
= 0x03,
143 LEGACY_SCPI_CMD_SET_CSS_PWR_STATE
= 0x04,
144 LEGACY_SCPI_CMD_GET_CSS_PWR_STATE
= 0x05,
145 LEGACY_SCPI_CMD_CFG_PWR_STATE_STAT
= 0x06,
146 LEGACY_SCPI_CMD_GET_PWR_STATE_STAT
= 0x07,
147 LEGACY_SCPI_CMD_SYS_PWR_STATE
= 0x08,
148 LEGACY_SCPI_CMD_L2_READY
= 0x09,
149 LEGACY_SCPI_CMD_SET_AP_TIMER
= 0x0a,
150 LEGACY_SCPI_CMD_CANCEL_AP_TIME
= 0x0b,
151 LEGACY_SCPI_CMD_DVFS_CAPABILITIES
= 0x0c,
152 LEGACY_SCPI_CMD_GET_DVFS_INFO
= 0x0d,
153 LEGACY_SCPI_CMD_SET_DVFS
= 0x0e,
154 LEGACY_SCPI_CMD_GET_DVFS
= 0x0f,
155 LEGACY_SCPI_CMD_GET_DVFS_STAT
= 0x10,
156 LEGACY_SCPI_CMD_SET_RTC
= 0x11,
157 LEGACY_SCPI_CMD_GET_RTC
= 0x12,
158 LEGACY_SCPI_CMD_CLOCK_CAPABILITIES
= 0x13,
159 LEGACY_SCPI_CMD_SET_CLOCK_INDEX
= 0x14,
160 LEGACY_SCPI_CMD_SET_CLOCK_VALUE
= 0x15,
161 LEGACY_SCPI_CMD_GET_CLOCK_VALUE
= 0x16,
162 LEGACY_SCPI_CMD_PSU_CAPABILITIES
= 0x17,
163 LEGACY_SCPI_CMD_SET_PSU
= 0x18,
164 LEGACY_SCPI_CMD_GET_PSU
= 0x19,
165 LEGACY_SCPI_CMD_SENSOR_CAPABILITIES
= 0x1a,
166 LEGACY_SCPI_CMD_SENSOR_INFO
= 0x1b,
167 LEGACY_SCPI_CMD_SENSOR_VALUE
= 0x1c,
168 LEGACY_SCPI_CMD_SENSOR_CFG_PERIODIC
= 0x1d,
169 LEGACY_SCPI_CMD_SENSOR_CFG_BOUNDS
= 0x1e,
170 LEGACY_SCPI_CMD_SENSOR_ASYNC_VALUE
= 0x1f,
171 LEGACY_SCPI_CMD_COUNT
174 /* List all commands that are required to go through the high priority link */
175 static int legacy_hpriority_cmds
[] = {
176 LEGACY_SCPI_CMD_GET_CSS_PWR_STATE
,
177 LEGACY_SCPI_CMD_CFG_PWR_STATE_STAT
,
178 LEGACY_SCPI_CMD_GET_PWR_STATE_STAT
,
179 LEGACY_SCPI_CMD_SET_DVFS
,
180 LEGACY_SCPI_CMD_GET_DVFS
,
181 LEGACY_SCPI_CMD_SET_RTC
,
182 LEGACY_SCPI_CMD_GET_RTC
,
183 LEGACY_SCPI_CMD_SET_CLOCK_INDEX
,
184 LEGACY_SCPI_CMD_SET_CLOCK_VALUE
,
185 LEGACY_SCPI_CMD_GET_CLOCK_VALUE
,
186 LEGACY_SCPI_CMD_SET_PSU
,
187 LEGACY_SCPI_CMD_GET_PSU
,
188 LEGACY_SCPI_CMD_SENSOR_CFG_PERIODIC
,
189 LEGACY_SCPI_CMD_SENSOR_CFG_BOUNDS
,
192 /* List all commands used by this driver, used as indexes */
194 CMD_SCPI_CAPABILITIES
= 0,
201 CMD_SENSOR_CAPABILITIES
,
204 CMD_SET_DEVICE_PWR_STATE
,
205 CMD_GET_DEVICE_PWR_STATE
,
209 static int scpi_std_commands
[CMD_MAX_COUNT
] = {
210 SCPI_CMD_SCPI_CAPABILITIES
,
211 SCPI_CMD_GET_CLOCK_INFO
,
212 SCPI_CMD_GET_CLOCK_VALUE
,
213 SCPI_CMD_SET_CLOCK_VALUE
,
216 SCPI_CMD_GET_DVFS_INFO
,
217 SCPI_CMD_SENSOR_CAPABILITIES
,
218 SCPI_CMD_SENSOR_INFO
,
219 SCPI_CMD_SENSOR_VALUE
,
220 SCPI_CMD_SET_DEVICE_PWR_STATE
,
221 SCPI_CMD_GET_DEVICE_PWR_STATE
,
224 static int scpi_legacy_commands
[CMD_MAX_COUNT
] = {
225 LEGACY_SCPI_CMD_SCPI_CAPABILITIES
,
226 -1, /* GET_CLOCK_INFO */
227 LEGACY_SCPI_CMD_GET_CLOCK_VALUE
,
228 LEGACY_SCPI_CMD_SET_CLOCK_VALUE
,
229 LEGACY_SCPI_CMD_GET_DVFS
,
230 LEGACY_SCPI_CMD_SET_DVFS
,
231 LEGACY_SCPI_CMD_GET_DVFS_INFO
,
232 LEGACY_SCPI_CMD_SENSOR_CAPABILITIES
,
233 LEGACY_SCPI_CMD_SENSOR_INFO
,
234 LEGACY_SCPI_CMD_SENSOR_VALUE
,
235 -1, /* SET_DEVICE_PWR_STATE */
236 -1, /* GET_DEVICE_PWR_STATE */
240 u32 slot
; /* has to be first element */
247 struct list_head node
;
248 struct completion done
;
252 struct mbox_client cl
;
253 struct mbox_chan
*chan
;
254 void __iomem
*tx_payload
;
255 void __iomem
*rx_payload
;
256 struct list_head rx_pending
;
257 struct list_head xfers_list
;
258 struct scpi_xfer
*xfers
;
259 spinlock_t rx_lock
; /* locking for the rx pending list */
260 struct mutex xfers_lock
;
264 struct scpi_drvinfo
{
265 u32 protocol_version
;
266 u32 firmware_version
;
270 DECLARE_BITMAP(cmd_priority
, LEGACY_SCPI_CMD_COUNT
);
272 struct scpi_ops
*scpi_ops
;
273 struct scpi_chan
*channels
;
274 struct scpi_dvfs_info
*dvfs
[MAX_DVFS_DOMAINS
];
278 * The SCP firmware only executes in little-endian mode, so any buffers
279 * shared through SCPI should have their contents converted to little-endian
281 struct scpi_shared_mem
{
287 struct legacy_scpi_shared_mem
{
292 struct scp_capabilities
{
293 __le32 protocol_version
;
294 __le32 event_version
;
295 __le32 platform_version
;
299 struct clk_get_info
{
307 struct clk_set_value
{
313 struct legacy_clk_set_value
{
326 } opps
[MAX_DVFS_OPPS
];
334 struct sensor_capabilities
{
338 struct _scpi_sensor_info
{
345 struct dev_pstate_set
{
350 static struct scpi_drvinfo
*scpi_info
;
352 static int scpi_linux_errmap
[SCPI_ERR_MAX
] = {
353 /* better than switch case as long as return value is continuous */
354 0, /* SCPI_SUCCESS */
355 -EINVAL
, /* SCPI_ERR_PARAM */
356 -ENOEXEC
, /* SCPI_ERR_ALIGN */
357 -EMSGSIZE
, /* SCPI_ERR_SIZE */
358 -EINVAL
, /* SCPI_ERR_HANDLER */
359 -EACCES
, /* SCPI_ERR_ACCESS */
360 -ERANGE
, /* SCPI_ERR_RANGE */
361 -ETIMEDOUT
, /* SCPI_ERR_TIMEOUT */
362 -ENOMEM
, /* SCPI_ERR_NOMEM */
363 -EINVAL
, /* SCPI_ERR_PWRSTATE */
364 -EOPNOTSUPP
, /* SCPI_ERR_SUPPORT */
365 -EIO
, /* SCPI_ERR_DEVICE */
366 -EBUSY
, /* SCPI_ERR_BUSY */
369 static inline int scpi_to_linux_errno(int errno
)
371 if (errno
>= SCPI_SUCCESS
&& errno
< SCPI_ERR_MAX
)
372 return scpi_linux_errmap
[errno
];
376 static void scpi_process_cmd(struct scpi_chan
*ch
, u32 cmd
)
379 struct scpi_xfer
*t
, *match
= NULL
;
381 spin_lock_irqsave(&ch
->rx_lock
, flags
);
382 if (list_empty(&ch
->rx_pending
)) {
383 spin_unlock_irqrestore(&ch
->rx_lock
, flags
);
387 /* Command type is not replied by the SCP Firmware in legacy Mode
388 * We should consider that command is the head of pending RX commands
389 * if the list is not empty. In TX only mode, the list would be empty.
391 if (scpi_info
->is_legacy
) {
392 match
= list_first_entry(&ch
->rx_pending
, struct scpi_xfer
,
394 list_del(&match
->node
);
396 list_for_each_entry(t
, &ch
->rx_pending
, node
)
397 if (CMD_XTRACT_UNIQ(t
->cmd
) == CMD_XTRACT_UNIQ(cmd
)) {
403 /* check if wait_for_completion is in progress or timed-out */
404 if (match
&& !completion_done(&match
->done
)) {
407 if (scpi_info
->is_legacy
) {
408 struct legacy_scpi_shared_mem __iomem
*mem
=
411 /* RX Length is not replied by the legacy Firmware */
414 match
->status
= ioread32(&mem
->status
);
415 memcpy_fromio(match
->rx_buf
, mem
->payload
, len
);
417 struct scpi_shared_mem __iomem
*mem
= ch
->rx_payload
;
419 len
= min(match
->rx_len
, CMD_SIZE(cmd
));
421 match
->status
= ioread32(&mem
->status
);
422 memcpy_fromio(match
->rx_buf
, mem
->payload
, len
);
425 if (match
->rx_len
> len
)
426 memset(match
->rx_buf
+ len
, 0, match
->rx_len
- len
);
427 complete(&match
->done
);
429 spin_unlock_irqrestore(&ch
->rx_lock
, flags
);
432 static void scpi_handle_remote_msg(struct mbox_client
*c
, void *msg
)
434 struct scpi_chan
*ch
= container_of(c
, struct scpi_chan
, cl
);
435 struct scpi_shared_mem __iomem
*mem
= ch
->rx_payload
;
438 if (!scpi_info
->is_legacy
)
439 cmd
= ioread32(&mem
->command
);
441 scpi_process_cmd(ch
, cmd
);
444 static void scpi_tx_prepare(struct mbox_client
*c
, void *msg
)
447 struct scpi_xfer
*t
= msg
;
448 struct scpi_chan
*ch
= container_of(c
, struct scpi_chan
, cl
);
449 struct scpi_shared_mem __iomem
*mem
= ch
->tx_payload
;
452 if (scpi_info
->is_legacy
)
453 memcpy_toio(ch
->tx_payload
, t
->tx_buf
, t
->tx_len
);
455 memcpy_toio(mem
->payload
, t
->tx_buf
, t
->tx_len
);
461 ADD_SCPI_TOKEN(t
->cmd
, ch
->token
);
462 spin_lock_irqsave(&ch
->rx_lock
, flags
);
463 list_add_tail(&t
->node
, &ch
->rx_pending
);
464 spin_unlock_irqrestore(&ch
->rx_lock
, flags
);
467 if (!scpi_info
->is_legacy
)
468 iowrite32(t
->cmd
, &mem
->command
);
471 static struct scpi_xfer
*get_scpi_xfer(struct scpi_chan
*ch
)
475 mutex_lock(&ch
->xfers_lock
);
476 if (list_empty(&ch
->xfers_list
)) {
477 mutex_unlock(&ch
->xfers_lock
);
480 t
= list_first_entry(&ch
->xfers_list
, struct scpi_xfer
, node
);
482 mutex_unlock(&ch
->xfers_lock
);
486 static void put_scpi_xfer(struct scpi_xfer
*t
, struct scpi_chan
*ch
)
488 mutex_lock(&ch
->xfers_lock
);
489 list_add_tail(&t
->node
, &ch
->xfers_list
);
490 mutex_unlock(&ch
->xfers_lock
);
493 static int scpi_send_message(u8 idx
, void *tx_buf
, unsigned int tx_len
,
494 void *rx_buf
, unsigned int rx_len
)
499 struct scpi_xfer
*msg
;
500 struct scpi_chan
*scpi_chan
;
502 if (scpi_info
->commands
[idx
] < 0)
505 cmd
= scpi_info
->commands
[idx
];
507 if (scpi_info
->is_legacy
)
508 chan
= test_bit(cmd
, scpi_info
->cmd_priority
) ? 1 : 0;
510 chan
= atomic_inc_return(&scpi_info
->next_chan
) %
511 scpi_info
->num_chans
;
512 scpi_chan
= scpi_info
->channels
+ chan
;
514 msg
= get_scpi_xfer(scpi_chan
);
518 if (scpi_info
->is_legacy
) {
519 msg
->cmd
= PACK_LEGACY_SCPI_CMD(cmd
, tx_len
);
520 msg
->slot
= msg
->cmd
;
522 msg
->slot
= BIT(SCPI_SLOT
);
523 msg
->cmd
= PACK_SCPI_CMD(cmd
, tx_len
);
525 msg
->tx_buf
= tx_buf
;
526 msg
->tx_len
= tx_len
;
527 msg
->rx_buf
= rx_buf
;
528 msg
->rx_len
= rx_len
;
529 reinit_completion(&msg
->done
);
531 ret
= mbox_send_message(scpi_chan
->chan
, msg
);
532 if (ret
< 0 || !rx_buf
)
535 if (!wait_for_completion_timeout(&msg
->done
, MAX_RX_TIMEOUT
))
538 /* first status word */
541 if (ret
< 0 && rx_buf
) /* remove entry from the list if timed-out */
542 scpi_process_cmd(scpi_chan
, msg
->cmd
);
544 put_scpi_xfer(msg
, scpi_chan
);
545 /* SCPI error codes > 0, translate them to Linux scale*/
546 return ret
> 0 ? scpi_to_linux_errno(ret
) : ret
;
549 static u32
scpi_get_version(void)
551 return scpi_info
->protocol_version
;
555 scpi_clk_get_range(u16 clk_id
, unsigned long *min
, unsigned long *max
)
558 struct clk_get_info clk
;
559 __le16 le_clk_id
= cpu_to_le16(clk_id
);
561 ret
= scpi_send_message(CMD_GET_CLOCK_INFO
, &le_clk_id
,
562 sizeof(le_clk_id
), &clk
, sizeof(clk
));
564 *min
= le32_to_cpu(clk
.min_rate
);
565 *max
= le32_to_cpu(clk
.max_rate
);
570 static unsigned long scpi_clk_get_val(u16 clk_id
)
574 __le16 le_clk_id
= cpu_to_le16(clk_id
);
576 ret
= scpi_send_message(CMD_GET_CLOCK_VALUE
, &le_clk_id
,
577 sizeof(le_clk_id
), &rate
, sizeof(rate
));
579 return ret
? ret
: le32_to_cpu(rate
);
582 static int scpi_clk_set_val(u16 clk_id
, unsigned long rate
)
585 struct clk_set_value clk
= {
586 .id
= cpu_to_le16(clk_id
),
587 .rate
= cpu_to_le32(rate
)
590 return scpi_send_message(CMD_SET_CLOCK_VALUE
, &clk
, sizeof(clk
),
591 &stat
, sizeof(stat
));
594 static int legacy_scpi_clk_set_val(u16 clk_id
, unsigned long rate
)
597 struct legacy_clk_set_value clk
= {
598 .id
= cpu_to_le16(clk_id
),
599 .rate
= cpu_to_le32(rate
)
602 return scpi_send_message(CMD_SET_CLOCK_VALUE
, &clk
, sizeof(clk
),
603 &stat
, sizeof(stat
));
606 static int scpi_dvfs_get_idx(u8 domain
)
611 ret
= scpi_send_message(CMD_GET_DVFS
, &domain
, sizeof(domain
),
612 &dvfs_idx
, sizeof(dvfs_idx
));
614 return ret
? ret
: dvfs_idx
;
617 static int scpi_dvfs_set_idx(u8 domain
, u8 index
)
620 struct dvfs_set dvfs
= {domain
, index
};
622 return scpi_send_message(CMD_SET_DVFS
, &dvfs
, sizeof(dvfs
),
623 &stat
, sizeof(stat
));
626 static int opp_cmp_func(const void *opp1
, const void *opp2
)
628 const struct scpi_opp
*t1
= opp1
, *t2
= opp2
;
630 return t1
->freq
- t2
->freq
;
633 static struct scpi_dvfs_info
*scpi_dvfs_get_info(u8 domain
)
635 if (domain
>= MAX_DVFS_DOMAINS
)
636 return ERR_PTR(-EINVAL
);
638 return scpi_info
->dvfs
[domain
] ?: ERR_PTR(-EINVAL
);
641 static int scpi_dvfs_populate_info(struct device
*dev
, u8 domain
)
643 struct scpi_dvfs_info
*info
;
644 struct scpi_opp
*opp
;
645 struct dvfs_info buf
;
648 ret
= scpi_send_message(CMD_GET_DVFS_INFO
, &domain
, sizeof(domain
),
653 info
= devm_kmalloc(dev
, sizeof(*info
), GFP_KERNEL
);
657 info
->count
= buf
.opp_count
;
658 info
->latency
= le16_to_cpu(buf
.latency
) * 1000; /* uS to nS */
660 info
->opps
= devm_kcalloc(dev
, info
->count
, sizeof(*opp
), GFP_KERNEL
);
664 for (i
= 0, opp
= info
->opps
; i
< info
->count
; i
++, opp
++) {
665 opp
->freq
= le32_to_cpu(buf
.opps
[i
].freq
);
666 opp
->m_volt
= le32_to_cpu(buf
.opps
[i
].m_volt
);
669 sort(info
->opps
, info
->count
, sizeof(*opp
), opp_cmp_func
, NULL
);
671 scpi_info
->dvfs
[domain
] = info
;
675 static void scpi_dvfs_populate(struct device
*dev
)
679 for (domain
= 0; domain
< MAX_DVFS_DOMAINS
; domain
++)
680 scpi_dvfs_populate_info(dev
, domain
);
683 static int scpi_dev_domain_id(struct device
*dev
)
685 struct of_phandle_args clkspec
;
687 if (of_parse_phandle_with_args(dev
->of_node
, "clocks", "#clock-cells",
691 return clkspec
.args
[0];
694 static struct scpi_dvfs_info
*scpi_dvfs_info(struct device
*dev
)
696 int domain
= scpi_dev_domain_id(dev
);
699 return ERR_PTR(domain
);
701 return scpi_dvfs_get_info(domain
);
704 static int scpi_dvfs_get_transition_latency(struct device
*dev
)
706 struct scpi_dvfs_info
*info
= scpi_dvfs_info(dev
);
709 return PTR_ERR(info
);
711 return info
->latency
;
714 static int scpi_dvfs_add_opps_to_device(struct device
*dev
)
717 struct scpi_opp
*opp
;
718 struct scpi_dvfs_info
*info
= scpi_dvfs_info(dev
);
721 return PTR_ERR(info
);
726 for (opp
= info
->opps
, idx
= 0; idx
< info
->count
; idx
++, opp
++) {
727 ret
= dev_pm_opp_add(dev
, opp
->freq
, opp
->m_volt
* 1000);
729 dev_warn(dev
, "failed to add opp %uHz %umV\n",
730 opp
->freq
, opp
->m_volt
);
732 dev_pm_opp_remove(dev
, (--opp
)->freq
);
739 static int scpi_sensor_get_capability(u16
*sensors
)
741 struct sensor_capabilities cap_buf
;
744 ret
= scpi_send_message(CMD_SENSOR_CAPABILITIES
, NULL
, 0, &cap_buf
,
747 *sensors
= le16_to_cpu(cap_buf
.sensors
);
752 static int scpi_sensor_get_info(u16 sensor_id
, struct scpi_sensor_info
*info
)
754 __le16 id
= cpu_to_le16(sensor_id
);
755 struct _scpi_sensor_info _info
;
758 ret
= scpi_send_message(CMD_SENSOR_INFO
, &id
, sizeof(id
),
759 &_info
, sizeof(_info
));
761 memcpy(info
, &_info
, sizeof(*info
));
762 info
->sensor_id
= le16_to_cpu(_info
.sensor_id
);
768 static int scpi_sensor_get_value(u16 sensor
, u64
*val
)
770 __le16 id
= cpu_to_le16(sensor
);
774 ret
= scpi_send_message(CMD_SENSOR_VALUE
, &id
, sizeof(id
),
775 &value
, sizeof(value
));
779 if (scpi_info
->is_legacy
)
780 /* only 32-bits supported, upper 32 bits can be junk */
781 *val
= le32_to_cpup((__le32
*)&value
);
783 *val
= le64_to_cpu(value
);
788 static int scpi_device_get_power_state(u16 dev_id
)
792 __le16 id
= cpu_to_le16(dev_id
);
794 ret
= scpi_send_message(CMD_GET_DEVICE_PWR_STATE
, &id
,
795 sizeof(id
), &pstate
, sizeof(pstate
));
796 return ret
? ret
: pstate
;
799 static int scpi_device_set_power_state(u16 dev_id
, u8 pstate
)
802 struct dev_pstate_set dev_set
= {
803 .dev_id
= cpu_to_le16(dev_id
),
807 return scpi_send_message(CMD_SET_DEVICE_PWR_STATE
, &dev_set
,
808 sizeof(dev_set
), &stat
, sizeof(stat
));
811 static struct scpi_ops scpi_ops
= {
812 .get_version
= scpi_get_version
,
813 .clk_get_range
= scpi_clk_get_range
,
814 .clk_get_val
= scpi_clk_get_val
,
815 .clk_set_val
= scpi_clk_set_val
,
816 .dvfs_get_idx
= scpi_dvfs_get_idx
,
817 .dvfs_set_idx
= scpi_dvfs_set_idx
,
818 .dvfs_get_info
= scpi_dvfs_get_info
,
819 .device_domain_id
= scpi_dev_domain_id
,
820 .get_transition_latency
= scpi_dvfs_get_transition_latency
,
821 .add_opps_to_device
= scpi_dvfs_add_opps_to_device
,
822 .sensor_get_capability
= scpi_sensor_get_capability
,
823 .sensor_get_info
= scpi_sensor_get_info
,
824 .sensor_get_value
= scpi_sensor_get_value
,
825 .device_get_power_state
= scpi_device_get_power_state
,
826 .device_set_power_state
= scpi_device_set_power_state
,
829 struct scpi_ops
*get_scpi_ops(void)
831 return scpi_info
? scpi_info
->scpi_ops
: NULL
;
833 EXPORT_SYMBOL_GPL(get_scpi_ops
);
835 static int scpi_init_versions(struct scpi_drvinfo
*info
)
838 struct scp_capabilities caps
;
840 ret
= scpi_send_message(CMD_SCPI_CAPABILITIES
, NULL
, 0,
841 &caps
, sizeof(caps
));
843 info
->protocol_version
= le32_to_cpu(caps
.protocol_version
);
844 info
->firmware_version
= le32_to_cpu(caps
.platform_version
);
846 /* Ignore error if not implemented */
847 if (scpi_info
->is_legacy
&& ret
== -EOPNOTSUPP
)
853 static ssize_t
protocol_version_show(struct device
*dev
,
854 struct device_attribute
*attr
, char *buf
)
856 return sprintf(buf
, "%lu.%lu\n",
857 FIELD_GET(PROTO_REV_MAJOR_MASK
, scpi_info
->protocol_version
),
858 FIELD_GET(PROTO_REV_MINOR_MASK
, scpi_info
->protocol_version
));
860 static DEVICE_ATTR_RO(protocol_version
);
862 static ssize_t
firmware_version_show(struct device
*dev
,
863 struct device_attribute
*attr
, char *buf
)
865 return sprintf(buf
, "%lu.%lu.%lu\n",
866 FIELD_GET(FW_REV_MAJOR_MASK
, scpi_info
->firmware_version
),
867 FIELD_GET(FW_REV_MINOR_MASK
, scpi_info
->firmware_version
),
868 FIELD_GET(FW_REV_PATCH_MASK
, scpi_info
->firmware_version
));
870 static DEVICE_ATTR_RO(firmware_version
);
872 static struct attribute
*versions_attrs
[] = {
873 &dev_attr_firmware_version
.attr
,
874 &dev_attr_protocol_version
.attr
,
877 ATTRIBUTE_GROUPS(versions
);
879 static void scpi_free_channels(void *data
)
881 struct scpi_drvinfo
*info
= data
;
884 for (i
= 0; i
< info
->num_chans
; i
++)
885 mbox_free_channel(info
->channels
[i
].chan
);
888 #define MAX_SCPI_XFERS 10
889 static int scpi_alloc_xfer_list(struct device
*dev
, struct scpi_chan
*ch
)
892 struct scpi_xfer
*xfers
;
894 xfers
= devm_kzalloc(dev
, MAX_SCPI_XFERS
* sizeof(*xfers
), GFP_KERNEL
);
899 for (i
= 0; i
< MAX_SCPI_XFERS
; i
++, xfers
++) {
900 init_completion(&xfers
->done
);
901 list_add_tail(&xfers
->node
, &ch
->xfers_list
);
907 static const struct of_device_id legacy_scpi_of_match
[] = {
908 {.compatible
= "arm,scpi-pre-1.0"},
912 static int scpi_probe(struct platform_device
*pdev
)
916 struct device
*dev
= &pdev
->dev
;
917 struct device_node
*np
= dev
->of_node
;
919 scpi_info
= devm_kzalloc(dev
, sizeof(*scpi_info
), GFP_KERNEL
);
923 if (of_match_device(legacy_scpi_of_match
, &pdev
->dev
))
924 scpi_info
->is_legacy
= true;
926 count
= of_count_phandle_with_args(np
, "mboxes", "#mbox-cells");
928 dev_err(dev
, "no mboxes property in '%pOF'\n", np
);
932 scpi_info
->channels
= devm_kcalloc(dev
, count
, sizeof(struct scpi_chan
),
934 if (!scpi_info
->channels
)
937 ret
= devm_add_action(dev
, scpi_free_channels
, scpi_info
);
941 for (; scpi_info
->num_chans
< count
; scpi_info
->num_chans
++) {
942 resource_size_t size
;
943 int idx
= scpi_info
->num_chans
;
944 struct scpi_chan
*pchan
= scpi_info
->channels
+ idx
;
945 struct mbox_client
*cl
= &pchan
->cl
;
946 struct device_node
*shmem
= of_parse_phandle(np
, "shmem", idx
);
948 ret
= of_address_to_resource(shmem
, 0, &res
);
951 dev_err(dev
, "failed to get SCPI payload mem resource\n");
955 size
= resource_size(&res
);
956 pchan
->rx_payload
= devm_ioremap(dev
, res
.start
, size
);
957 if (!pchan
->rx_payload
) {
958 dev_err(dev
, "failed to ioremap SCPI payload\n");
959 return -EADDRNOTAVAIL
;
961 pchan
->tx_payload
= pchan
->rx_payload
+ (size
>> 1);
964 cl
->rx_callback
= scpi_handle_remote_msg
;
965 cl
->tx_prepare
= scpi_tx_prepare
;
968 cl
->knows_txdone
= false; /* controller can't ack */
970 INIT_LIST_HEAD(&pchan
->rx_pending
);
971 INIT_LIST_HEAD(&pchan
->xfers_list
);
972 spin_lock_init(&pchan
->rx_lock
);
973 mutex_init(&pchan
->xfers_lock
);
975 ret
= scpi_alloc_xfer_list(dev
, pchan
);
977 pchan
->chan
= mbox_request_channel(cl
, idx
);
978 if (!IS_ERR(pchan
->chan
))
980 ret
= PTR_ERR(pchan
->chan
);
981 if (ret
!= -EPROBE_DEFER
)
982 dev_err(dev
, "failed to get channel%d err %d\n",
988 scpi_info
->commands
= scpi_std_commands
;
989 scpi_info
->scpi_ops
= &scpi_ops
;
991 if (scpi_info
->is_legacy
) {
992 /* Replace with legacy variants */
993 scpi_ops
.clk_set_val
= legacy_scpi_clk_set_val
;
994 scpi_info
->commands
= scpi_legacy_commands
;
996 /* Fill priority bitmap */
997 for (idx
= 0; idx
< ARRAY_SIZE(legacy_hpriority_cmds
); idx
++)
998 set_bit(legacy_hpriority_cmds
[idx
],
999 scpi_info
->cmd_priority
);
1002 ret
= scpi_init_versions(scpi_info
);
1004 dev_err(dev
, "incorrect or no SCP firmware found\n");
1008 scpi_dvfs_populate(dev
);
1010 _dev_info(dev
, "SCP Protocol %lu.%lu Firmware %lu.%lu.%lu version\n",
1011 FIELD_GET(PROTO_REV_MAJOR_MASK
, scpi_info
->protocol_version
),
1012 FIELD_GET(PROTO_REV_MINOR_MASK
, scpi_info
->protocol_version
),
1013 FIELD_GET(FW_REV_MAJOR_MASK
, scpi_info
->firmware_version
),
1014 FIELD_GET(FW_REV_MINOR_MASK
, scpi_info
->firmware_version
),
1015 FIELD_GET(FW_REV_PATCH_MASK
, scpi_info
->firmware_version
));
1017 ret
= devm_device_add_groups(dev
, versions_groups
);
1019 dev_err(dev
, "unable to create sysfs version group\n");
1021 return devm_of_platform_populate(dev
);
1024 static const struct of_device_id scpi_of_match
[] = {
1025 {.compatible
= "arm,scpi"},
1026 {.compatible
= "arm,scpi-pre-1.0"},
1030 MODULE_DEVICE_TABLE(of
, scpi_of_match
);
1032 static struct platform_driver scpi_driver
= {
1034 .name
= "scpi_protocol",
1035 .of_match_table
= scpi_of_match
,
1037 .probe
= scpi_probe
,
1039 module_platform_driver(scpi_driver
);
1041 MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
1042 MODULE_DESCRIPTION("ARM SCPI mailbox protocol driver");
1043 MODULE_LICENSE("GPL v2");