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/device.h>
32 #include <linux/err.h>
33 #include <linux/export.h>
35 #include <linux/kernel.h>
36 #include <linux/list.h>
37 #include <linux/mailbox_client.h>
38 #include <linux/module.h>
39 #include <linux/of_address.h>
40 #include <linux/of_platform.h>
41 #include <linux/printk.h>
42 #include <linux/scpi_protocol.h>
43 #include <linux/slab.h>
44 #include <linux/sort.h>
45 #include <linux/spinlock.h>
47 #define CMD_ID_SHIFT 0
48 #define CMD_ID_MASK 0x7f
49 #define CMD_TOKEN_ID_SHIFT 8
50 #define CMD_TOKEN_ID_MASK 0xff
51 #define CMD_DATA_SIZE_SHIFT 16
52 #define CMD_DATA_SIZE_MASK 0x1ff
53 #define CMD_LEGACY_DATA_SIZE_SHIFT 20
54 #define CMD_LEGACY_DATA_SIZE_MASK 0x1ff
55 #define PACK_SCPI_CMD(cmd_id, tx_sz) \
56 ((((cmd_id) & CMD_ID_MASK) << CMD_ID_SHIFT) | \
57 (((tx_sz) & CMD_DATA_SIZE_MASK) << CMD_DATA_SIZE_SHIFT))
58 #define ADD_SCPI_TOKEN(cmd, token) \
59 ((cmd) |= (((token) & CMD_TOKEN_ID_MASK) << CMD_TOKEN_ID_SHIFT))
60 #define PACK_LEGACY_SCPI_CMD(cmd_id, tx_sz) \
61 ((((cmd_id) & CMD_ID_MASK) << CMD_ID_SHIFT) | \
62 (((tx_sz) & CMD_LEGACY_DATA_SIZE_MASK) << CMD_LEGACY_DATA_SIZE_SHIFT))
64 #define CMD_SIZE(cmd) (((cmd) >> CMD_DATA_SIZE_SHIFT) & CMD_DATA_SIZE_MASK)
65 #define CMD_LEGACY_SIZE(cmd) (((cmd) >> CMD_LEGACY_DATA_SIZE_SHIFT) & \
66 CMD_LEGACY_DATA_SIZE_MASK)
67 #define CMD_UNIQ_MASK (CMD_TOKEN_ID_MASK << CMD_TOKEN_ID_SHIFT | CMD_ID_MASK)
68 #define CMD_XTRACT_UNIQ(cmd) ((cmd) & CMD_UNIQ_MASK)
72 #define MAX_DVFS_DOMAINS 8
73 #define MAX_DVFS_OPPS 16
74 #define DVFS_LATENCY(hdr) (le32_to_cpu(hdr) >> 16)
75 #define DVFS_OPP_COUNT(hdr) ((le32_to_cpu(hdr) >> 8) & 0xff)
77 #define PROTOCOL_REV_MINOR_BITS 16
78 #define PROTOCOL_REV_MINOR_MASK ((1U << PROTOCOL_REV_MINOR_BITS) - 1)
79 #define PROTOCOL_REV_MAJOR(x) ((x) >> PROTOCOL_REV_MINOR_BITS)
80 #define PROTOCOL_REV_MINOR(x) ((x) & PROTOCOL_REV_MINOR_MASK)
82 #define FW_REV_MAJOR_BITS 24
83 #define FW_REV_MINOR_BITS 16
84 #define FW_REV_PATCH_MASK ((1U << FW_REV_MINOR_BITS) - 1)
85 #define FW_REV_MINOR_MASK ((1U << FW_REV_MAJOR_BITS) - 1)
86 #define FW_REV_MAJOR(x) ((x) >> FW_REV_MAJOR_BITS)
87 #define FW_REV_MINOR(x) (((x) & FW_REV_MINOR_MASK) >> FW_REV_MINOR_BITS)
88 #define FW_REV_PATCH(x) ((x) & FW_REV_PATCH_MASK)
90 #define MAX_RX_TIMEOUT (msecs_to_jiffies(30))
92 enum scpi_error_codes
{
93 SCPI_SUCCESS
= 0, /* Success */
94 SCPI_ERR_PARAM
= 1, /* Invalid parameter(s) */
95 SCPI_ERR_ALIGN
= 2, /* Invalid alignment */
96 SCPI_ERR_SIZE
= 3, /* Invalid size */
97 SCPI_ERR_HANDLER
= 4, /* Invalid handler/callback */
98 SCPI_ERR_ACCESS
= 5, /* Invalid access/permission denied */
99 SCPI_ERR_RANGE
= 6, /* Value out of range */
100 SCPI_ERR_TIMEOUT
= 7, /* Timeout has occurred */
101 SCPI_ERR_NOMEM
= 8, /* Invalid memory area or pointer */
102 SCPI_ERR_PWRSTATE
= 9, /* Invalid power state */
103 SCPI_ERR_SUPPORT
= 10, /* Not supported or disabled */
104 SCPI_ERR_DEVICE
= 11, /* Device error */
105 SCPI_ERR_BUSY
= 12, /* Device busy */
109 /* SCPI Standard commands */
111 SCPI_CMD_INVALID
= 0x00,
112 SCPI_CMD_SCPI_READY
= 0x01,
113 SCPI_CMD_SCPI_CAPABILITIES
= 0x02,
114 SCPI_CMD_SET_CSS_PWR_STATE
= 0x03,
115 SCPI_CMD_GET_CSS_PWR_STATE
= 0x04,
116 SCPI_CMD_SET_SYS_PWR_STATE
= 0x05,
117 SCPI_CMD_SET_CPU_TIMER
= 0x06,
118 SCPI_CMD_CANCEL_CPU_TIMER
= 0x07,
119 SCPI_CMD_DVFS_CAPABILITIES
= 0x08,
120 SCPI_CMD_GET_DVFS_INFO
= 0x09,
121 SCPI_CMD_SET_DVFS
= 0x0a,
122 SCPI_CMD_GET_DVFS
= 0x0b,
123 SCPI_CMD_GET_DVFS_STAT
= 0x0c,
124 SCPI_CMD_CLOCK_CAPABILITIES
= 0x0d,
125 SCPI_CMD_GET_CLOCK_INFO
= 0x0e,
126 SCPI_CMD_SET_CLOCK_VALUE
= 0x0f,
127 SCPI_CMD_GET_CLOCK_VALUE
= 0x10,
128 SCPI_CMD_PSU_CAPABILITIES
= 0x11,
129 SCPI_CMD_GET_PSU_INFO
= 0x12,
130 SCPI_CMD_SET_PSU
= 0x13,
131 SCPI_CMD_GET_PSU
= 0x14,
132 SCPI_CMD_SENSOR_CAPABILITIES
= 0x15,
133 SCPI_CMD_SENSOR_INFO
= 0x16,
134 SCPI_CMD_SENSOR_VALUE
= 0x17,
135 SCPI_CMD_SENSOR_CFG_PERIODIC
= 0x18,
136 SCPI_CMD_SENSOR_CFG_BOUNDS
= 0x19,
137 SCPI_CMD_SENSOR_ASYNC_VALUE
= 0x1a,
138 SCPI_CMD_SET_DEVICE_PWR_STATE
= 0x1b,
139 SCPI_CMD_GET_DEVICE_PWR_STATE
= 0x1c,
143 /* SCPI Legacy Commands */
144 enum legacy_scpi_std_cmd
{
145 LEGACY_SCPI_CMD_INVALID
= 0x00,
146 LEGACY_SCPI_CMD_SCPI_READY
= 0x01,
147 LEGACY_SCPI_CMD_SCPI_CAPABILITIES
= 0x02,
148 LEGACY_SCPI_CMD_EVENT
= 0x03,
149 LEGACY_SCPI_CMD_SET_CSS_PWR_STATE
= 0x04,
150 LEGACY_SCPI_CMD_GET_CSS_PWR_STATE
= 0x05,
151 LEGACY_SCPI_CMD_CFG_PWR_STATE_STAT
= 0x06,
152 LEGACY_SCPI_CMD_GET_PWR_STATE_STAT
= 0x07,
153 LEGACY_SCPI_CMD_SYS_PWR_STATE
= 0x08,
154 LEGACY_SCPI_CMD_L2_READY
= 0x09,
155 LEGACY_SCPI_CMD_SET_AP_TIMER
= 0x0a,
156 LEGACY_SCPI_CMD_CANCEL_AP_TIME
= 0x0b,
157 LEGACY_SCPI_CMD_DVFS_CAPABILITIES
= 0x0c,
158 LEGACY_SCPI_CMD_GET_DVFS_INFO
= 0x0d,
159 LEGACY_SCPI_CMD_SET_DVFS
= 0x0e,
160 LEGACY_SCPI_CMD_GET_DVFS
= 0x0f,
161 LEGACY_SCPI_CMD_GET_DVFS_STAT
= 0x10,
162 LEGACY_SCPI_CMD_SET_RTC
= 0x11,
163 LEGACY_SCPI_CMD_GET_RTC
= 0x12,
164 LEGACY_SCPI_CMD_CLOCK_CAPABILITIES
= 0x13,
165 LEGACY_SCPI_CMD_SET_CLOCK_INDEX
= 0x14,
166 LEGACY_SCPI_CMD_SET_CLOCK_VALUE
= 0x15,
167 LEGACY_SCPI_CMD_GET_CLOCK_VALUE
= 0x16,
168 LEGACY_SCPI_CMD_PSU_CAPABILITIES
= 0x17,
169 LEGACY_SCPI_CMD_SET_PSU
= 0x18,
170 LEGACY_SCPI_CMD_GET_PSU
= 0x19,
171 LEGACY_SCPI_CMD_SENSOR_CAPABILITIES
= 0x1a,
172 LEGACY_SCPI_CMD_SENSOR_INFO
= 0x1b,
173 LEGACY_SCPI_CMD_SENSOR_VALUE
= 0x1c,
174 LEGACY_SCPI_CMD_SENSOR_CFG_PERIODIC
= 0x1d,
175 LEGACY_SCPI_CMD_SENSOR_CFG_BOUNDS
= 0x1e,
176 LEGACY_SCPI_CMD_SENSOR_ASYNC_VALUE
= 0x1f,
177 LEGACY_SCPI_CMD_COUNT
180 /* List all commands that are required to go through the high priority link */
181 static int legacy_hpriority_cmds
[] = {
182 LEGACY_SCPI_CMD_GET_CSS_PWR_STATE
,
183 LEGACY_SCPI_CMD_CFG_PWR_STATE_STAT
,
184 LEGACY_SCPI_CMD_GET_PWR_STATE_STAT
,
185 LEGACY_SCPI_CMD_SET_DVFS
,
186 LEGACY_SCPI_CMD_GET_DVFS
,
187 LEGACY_SCPI_CMD_SET_RTC
,
188 LEGACY_SCPI_CMD_GET_RTC
,
189 LEGACY_SCPI_CMD_SET_CLOCK_INDEX
,
190 LEGACY_SCPI_CMD_SET_CLOCK_VALUE
,
191 LEGACY_SCPI_CMD_GET_CLOCK_VALUE
,
192 LEGACY_SCPI_CMD_SET_PSU
,
193 LEGACY_SCPI_CMD_GET_PSU
,
194 LEGACY_SCPI_CMD_SENSOR_CFG_PERIODIC
,
195 LEGACY_SCPI_CMD_SENSOR_CFG_BOUNDS
,
198 /* List all commands used by this driver, used as indexes */
200 CMD_SCPI_CAPABILITIES
= 0,
207 CMD_SENSOR_CAPABILITIES
,
210 CMD_SET_DEVICE_PWR_STATE
,
211 CMD_GET_DEVICE_PWR_STATE
,
215 static int scpi_std_commands
[CMD_MAX_COUNT
] = {
216 SCPI_CMD_SCPI_CAPABILITIES
,
217 SCPI_CMD_GET_CLOCK_INFO
,
218 SCPI_CMD_GET_CLOCK_VALUE
,
219 SCPI_CMD_SET_CLOCK_VALUE
,
222 SCPI_CMD_GET_DVFS_INFO
,
223 SCPI_CMD_SENSOR_CAPABILITIES
,
224 SCPI_CMD_SENSOR_INFO
,
225 SCPI_CMD_SENSOR_VALUE
,
226 SCPI_CMD_SET_DEVICE_PWR_STATE
,
227 SCPI_CMD_GET_DEVICE_PWR_STATE
,
230 static int scpi_legacy_commands
[CMD_MAX_COUNT
] = {
231 LEGACY_SCPI_CMD_SCPI_CAPABILITIES
,
232 -1, /* GET_CLOCK_INFO */
233 LEGACY_SCPI_CMD_GET_CLOCK_VALUE
,
234 LEGACY_SCPI_CMD_SET_CLOCK_VALUE
,
235 LEGACY_SCPI_CMD_GET_DVFS
,
236 LEGACY_SCPI_CMD_SET_DVFS
,
237 LEGACY_SCPI_CMD_GET_DVFS_INFO
,
238 LEGACY_SCPI_CMD_SENSOR_CAPABILITIES
,
239 LEGACY_SCPI_CMD_SENSOR_INFO
,
240 LEGACY_SCPI_CMD_SENSOR_VALUE
,
241 -1, /* SET_DEVICE_PWR_STATE */
242 -1, /* GET_DEVICE_PWR_STATE */
246 u32 slot
; /* has to be first element */
253 struct list_head node
;
254 struct completion done
;
258 struct mbox_client cl
;
259 struct mbox_chan
*chan
;
260 void __iomem
*tx_payload
;
261 void __iomem
*rx_payload
;
262 struct list_head rx_pending
;
263 struct list_head xfers_list
;
264 struct scpi_xfer
*xfers
;
265 spinlock_t rx_lock
; /* locking for the rx pending list */
266 struct mutex xfers_lock
;
270 struct scpi_drvinfo
{
271 u32 protocol_version
;
272 u32 firmware_version
;
276 DECLARE_BITMAP(cmd_priority
, LEGACY_SCPI_CMD_COUNT
);
278 struct scpi_ops
*scpi_ops
;
279 struct scpi_chan
*channels
;
280 struct scpi_dvfs_info
*dvfs
[MAX_DVFS_DOMAINS
];
284 * The SCP firmware only executes in little-endian mode, so any buffers
285 * shared through SCPI should have their contents converted to little-endian
287 struct scpi_shared_mem
{
293 struct legacy_scpi_shared_mem
{
298 struct scp_capabilities
{
299 __le32 protocol_version
;
300 __le32 event_version
;
301 __le32 platform_version
;
305 struct clk_get_info
{
313 struct clk_get_value
{
317 struct clk_set_value
{
323 struct legacy_clk_set_value
{
334 } opps
[MAX_DVFS_OPPS
];
342 struct sensor_capabilities
{
346 struct _scpi_sensor_info
{
353 struct sensor_value
{
358 struct dev_pstate_set
{
363 static struct scpi_drvinfo
*scpi_info
;
365 static int scpi_linux_errmap
[SCPI_ERR_MAX
] = {
366 /* better than switch case as long as return value is continuous */
367 0, /* SCPI_SUCCESS */
368 -EINVAL
, /* SCPI_ERR_PARAM */
369 -ENOEXEC
, /* SCPI_ERR_ALIGN */
370 -EMSGSIZE
, /* SCPI_ERR_SIZE */
371 -EINVAL
, /* SCPI_ERR_HANDLER */
372 -EACCES
, /* SCPI_ERR_ACCESS */
373 -ERANGE
, /* SCPI_ERR_RANGE */
374 -ETIMEDOUT
, /* SCPI_ERR_TIMEOUT */
375 -ENOMEM
, /* SCPI_ERR_NOMEM */
376 -EINVAL
, /* SCPI_ERR_PWRSTATE */
377 -EOPNOTSUPP
, /* SCPI_ERR_SUPPORT */
378 -EIO
, /* SCPI_ERR_DEVICE */
379 -EBUSY
, /* SCPI_ERR_BUSY */
382 static inline int scpi_to_linux_errno(int errno
)
384 if (errno
>= SCPI_SUCCESS
&& errno
< SCPI_ERR_MAX
)
385 return scpi_linux_errmap
[errno
];
389 static void scpi_process_cmd(struct scpi_chan
*ch
, u32 cmd
)
392 struct scpi_xfer
*t
, *match
= NULL
;
394 spin_lock_irqsave(&ch
->rx_lock
, flags
);
395 if (list_empty(&ch
->rx_pending
)) {
396 spin_unlock_irqrestore(&ch
->rx_lock
, flags
);
400 /* Command type is not replied by the SCP Firmware in legacy Mode
401 * We should consider that command is the head of pending RX commands
402 * if the list is not empty. In TX only mode, the list would be empty.
404 if (scpi_info
->is_legacy
) {
405 match
= list_first_entry(&ch
->rx_pending
, struct scpi_xfer
,
407 list_del(&match
->node
);
409 list_for_each_entry(t
, &ch
->rx_pending
, node
)
410 if (CMD_XTRACT_UNIQ(t
->cmd
) == CMD_XTRACT_UNIQ(cmd
)) {
416 /* check if wait_for_completion is in progress or timed-out */
417 if (match
&& !completion_done(&match
->done
)) {
420 if (scpi_info
->is_legacy
) {
421 struct legacy_scpi_shared_mem
*mem
= ch
->rx_payload
;
423 /* RX Length is not replied by the legacy Firmware */
426 match
->status
= le32_to_cpu(mem
->status
);
427 memcpy_fromio(match
->rx_buf
, mem
->payload
, len
);
429 struct scpi_shared_mem
*mem
= ch
->rx_payload
;
431 len
= min(match
->rx_len
, CMD_SIZE(cmd
));
433 match
->status
= le32_to_cpu(mem
->status
);
434 memcpy_fromio(match
->rx_buf
, mem
->payload
, len
);
437 if (match
->rx_len
> len
)
438 memset(match
->rx_buf
+ len
, 0, match
->rx_len
- len
);
439 complete(&match
->done
);
441 spin_unlock_irqrestore(&ch
->rx_lock
, flags
);
444 static void scpi_handle_remote_msg(struct mbox_client
*c
, void *msg
)
446 struct scpi_chan
*ch
= container_of(c
, struct scpi_chan
, cl
);
447 struct scpi_shared_mem
*mem
= ch
->rx_payload
;
450 if (!scpi_info
->is_legacy
)
451 cmd
= le32_to_cpu(mem
->command
);
453 scpi_process_cmd(ch
, cmd
);
456 static void scpi_tx_prepare(struct mbox_client
*c
, void *msg
)
459 struct scpi_xfer
*t
= msg
;
460 struct scpi_chan
*ch
= container_of(c
, struct scpi_chan
, cl
);
461 struct scpi_shared_mem
*mem
= (struct scpi_shared_mem
*)ch
->tx_payload
;
464 if (scpi_info
->is_legacy
)
465 memcpy_toio(ch
->tx_payload
, t
->tx_buf
, t
->tx_len
);
467 memcpy_toio(mem
->payload
, t
->tx_buf
, t
->tx_len
);
473 ADD_SCPI_TOKEN(t
->cmd
, ch
->token
);
474 spin_lock_irqsave(&ch
->rx_lock
, flags
);
475 list_add_tail(&t
->node
, &ch
->rx_pending
);
476 spin_unlock_irqrestore(&ch
->rx_lock
, flags
);
479 if (!scpi_info
->is_legacy
)
480 mem
->command
= cpu_to_le32(t
->cmd
);
483 static struct scpi_xfer
*get_scpi_xfer(struct scpi_chan
*ch
)
487 mutex_lock(&ch
->xfers_lock
);
488 if (list_empty(&ch
->xfers_list
)) {
489 mutex_unlock(&ch
->xfers_lock
);
492 t
= list_first_entry(&ch
->xfers_list
, struct scpi_xfer
, node
);
494 mutex_unlock(&ch
->xfers_lock
);
498 static void put_scpi_xfer(struct scpi_xfer
*t
, struct scpi_chan
*ch
)
500 mutex_lock(&ch
->xfers_lock
);
501 list_add_tail(&t
->node
, &ch
->xfers_list
);
502 mutex_unlock(&ch
->xfers_lock
);
505 static int scpi_send_message(u8 idx
, void *tx_buf
, unsigned int tx_len
,
506 void *rx_buf
, unsigned int rx_len
)
511 struct scpi_xfer
*msg
;
512 struct scpi_chan
*scpi_chan
;
514 if (scpi_info
->commands
[idx
] < 0)
517 cmd
= scpi_info
->commands
[idx
];
519 if (scpi_info
->is_legacy
)
520 chan
= test_bit(cmd
, scpi_info
->cmd_priority
) ? 1 : 0;
522 chan
= atomic_inc_return(&scpi_info
->next_chan
) %
523 scpi_info
->num_chans
;
524 scpi_chan
= scpi_info
->channels
+ chan
;
526 msg
= get_scpi_xfer(scpi_chan
);
530 if (scpi_info
->is_legacy
) {
531 msg
->cmd
= PACK_LEGACY_SCPI_CMD(cmd
, tx_len
);
532 msg
->slot
= msg
->cmd
;
534 msg
->slot
= BIT(SCPI_SLOT
);
535 msg
->cmd
= PACK_SCPI_CMD(cmd
, tx_len
);
537 msg
->tx_buf
= tx_buf
;
538 msg
->tx_len
= tx_len
;
539 msg
->rx_buf
= rx_buf
;
540 msg
->rx_len
= rx_len
;
541 init_completion(&msg
->done
);
543 ret
= mbox_send_message(scpi_chan
->chan
, msg
);
544 if (ret
< 0 || !rx_buf
)
547 if (!wait_for_completion_timeout(&msg
->done
, MAX_RX_TIMEOUT
))
550 /* first status word */
553 if (ret
< 0 && rx_buf
) /* remove entry from the list if timed-out */
554 scpi_process_cmd(scpi_chan
, msg
->cmd
);
556 put_scpi_xfer(msg
, scpi_chan
);
557 /* SCPI error codes > 0, translate them to Linux scale*/
558 return ret
> 0 ? scpi_to_linux_errno(ret
) : ret
;
561 static u32
scpi_get_version(void)
563 return scpi_info
->protocol_version
;
567 scpi_clk_get_range(u16 clk_id
, unsigned long *min
, unsigned long *max
)
570 struct clk_get_info clk
;
571 __le16 le_clk_id
= cpu_to_le16(clk_id
);
573 ret
= scpi_send_message(CMD_GET_CLOCK_INFO
, &le_clk_id
,
574 sizeof(le_clk_id
), &clk
, sizeof(clk
));
576 *min
= le32_to_cpu(clk
.min_rate
);
577 *max
= le32_to_cpu(clk
.max_rate
);
582 static unsigned long scpi_clk_get_val(u16 clk_id
)
585 struct clk_get_value clk
;
586 __le16 le_clk_id
= cpu_to_le16(clk_id
);
588 ret
= scpi_send_message(CMD_GET_CLOCK_VALUE
, &le_clk_id
,
589 sizeof(le_clk_id
), &clk
, sizeof(clk
));
591 return ret
? ret
: le32_to_cpu(clk
.rate
);
594 static int scpi_clk_set_val(u16 clk_id
, unsigned long rate
)
597 struct 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 legacy_scpi_clk_set_val(u16 clk_id
, unsigned long rate
)
609 struct legacy_clk_set_value clk
= {
610 .id
= cpu_to_le16(clk_id
),
611 .rate
= cpu_to_le32(rate
)
614 return scpi_send_message(CMD_SET_CLOCK_VALUE
, &clk
, sizeof(clk
),
615 &stat
, sizeof(stat
));
618 static int scpi_dvfs_get_idx(u8 domain
)
623 ret
= scpi_send_message(CMD_GET_DVFS
, &domain
, sizeof(domain
),
624 &dvfs_idx
, sizeof(dvfs_idx
));
626 return ret
? ret
: dvfs_idx
;
629 static int scpi_dvfs_set_idx(u8 domain
, u8 index
)
632 struct dvfs_set dvfs
= {domain
, index
};
634 return scpi_send_message(CMD_SET_DVFS
, &dvfs
, sizeof(dvfs
),
635 &stat
, sizeof(stat
));
638 static int opp_cmp_func(const void *opp1
, const void *opp2
)
640 const struct scpi_opp
*t1
= opp1
, *t2
= opp2
;
642 return t1
->freq
- t2
->freq
;
645 static struct scpi_dvfs_info
*scpi_dvfs_get_info(u8 domain
)
647 struct scpi_dvfs_info
*info
;
648 struct scpi_opp
*opp
;
649 struct dvfs_info buf
;
652 if (domain
>= MAX_DVFS_DOMAINS
)
653 return ERR_PTR(-EINVAL
);
655 if (scpi_info
->dvfs
[domain
]) /* data already populated */
656 return scpi_info
->dvfs
[domain
];
658 ret
= scpi_send_message(CMD_GET_DVFS_INFO
, &domain
, sizeof(domain
),
663 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
665 return ERR_PTR(-ENOMEM
);
667 info
->count
= DVFS_OPP_COUNT(buf
.header
);
668 info
->latency
= DVFS_LATENCY(buf
.header
) * 1000; /* uS to nS */
670 info
->opps
= kcalloc(info
->count
, sizeof(*opp
), GFP_KERNEL
);
673 return ERR_PTR(-ENOMEM
);
676 for (i
= 0, opp
= info
->opps
; i
< info
->count
; i
++, opp
++) {
677 opp
->freq
= le32_to_cpu(buf
.opps
[i
].freq
);
678 opp
->m_volt
= le32_to_cpu(buf
.opps
[i
].m_volt
);
681 sort(info
->opps
, info
->count
, sizeof(*opp
), opp_cmp_func
, NULL
);
683 scpi_info
->dvfs
[domain
] = info
;
687 static int scpi_sensor_get_capability(u16
*sensors
)
689 struct sensor_capabilities cap_buf
;
692 ret
= scpi_send_message(CMD_SENSOR_CAPABILITIES
, NULL
, 0, &cap_buf
,
695 *sensors
= le16_to_cpu(cap_buf
.sensors
);
700 static int scpi_sensor_get_info(u16 sensor_id
, struct scpi_sensor_info
*info
)
702 __le16 id
= cpu_to_le16(sensor_id
);
703 struct _scpi_sensor_info _info
;
706 ret
= scpi_send_message(CMD_SENSOR_INFO
, &id
, sizeof(id
),
707 &_info
, sizeof(_info
));
709 memcpy(info
, &_info
, sizeof(*info
));
710 info
->sensor_id
= le16_to_cpu(_info
.sensor_id
);
716 static int scpi_sensor_get_value(u16 sensor
, u64
*val
)
718 __le16 id
= cpu_to_le16(sensor
);
719 struct sensor_value buf
;
722 ret
= scpi_send_message(CMD_SENSOR_VALUE
, &id
, sizeof(id
),
727 if (scpi_info
->is_legacy
)
728 /* only 32-bits supported, hi_val can be junk */
729 *val
= le32_to_cpu(buf
.lo_val
);
731 *val
= (u64
)le32_to_cpu(buf
.hi_val
) << 32 |
732 le32_to_cpu(buf
.lo_val
);
737 static int scpi_device_get_power_state(u16 dev_id
)
741 __le16 id
= cpu_to_le16(dev_id
);
743 ret
= scpi_send_message(CMD_GET_DEVICE_PWR_STATE
, &id
,
744 sizeof(id
), &pstate
, sizeof(pstate
));
745 return ret
? ret
: pstate
;
748 static int scpi_device_set_power_state(u16 dev_id
, u8 pstate
)
751 struct dev_pstate_set dev_set
= {
752 .dev_id
= cpu_to_le16(dev_id
),
756 return scpi_send_message(CMD_SET_DEVICE_PWR_STATE
, &dev_set
,
757 sizeof(dev_set
), &stat
, sizeof(stat
));
760 static struct scpi_ops scpi_ops
= {
761 .get_version
= scpi_get_version
,
762 .clk_get_range
= scpi_clk_get_range
,
763 .clk_get_val
= scpi_clk_get_val
,
764 .clk_set_val
= scpi_clk_set_val
,
765 .dvfs_get_idx
= scpi_dvfs_get_idx
,
766 .dvfs_set_idx
= scpi_dvfs_set_idx
,
767 .dvfs_get_info
= scpi_dvfs_get_info
,
768 .sensor_get_capability
= scpi_sensor_get_capability
,
769 .sensor_get_info
= scpi_sensor_get_info
,
770 .sensor_get_value
= scpi_sensor_get_value
,
771 .device_get_power_state
= scpi_device_get_power_state
,
772 .device_set_power_state
= scpi_device_set_power_state
,
775 struct scpi_ops
*get_scpi_ops(void)
777 return scpi_info
? scpi_info
->scpi_ops
: NULL
;
779 EXPORT_SYMBOL_GPL(get_scpi_ops
);
781 static int scpi_init_versions(struct scpi_drvinfo
*info
)
784 struct scp_capabilities caps
;
786 ret
= scpi_send_message(CMD_SCPI_CAPABILITIES
, NULL
, 0,
787 &caps
, sizeof(caps
));
789 info
->protocol_version
= le32_to_cpu(caps
.protocol_version
);
790 info
->firmware_version
= le32_to_cpu(caps
.platform_version
);
792 /* Ignore error if not implemented */
793 if (scpi_info
->is_legacy
&& ret
== -EOPNOTSUPP
)
799 static ssize_t
protocol_version_show(struct device
*dev
,
800 struct device_attribute
*attr
, char *buf
)
802 struct scpi_drvinfo
*scpi_info
= dev_get_drvdata(dev
);
804 return sprintf(buf
, "%d.%d\n",
805 PROTOCOL_REV_MAJOR(scpi_info
->protocol_version
),
806 PROTOCOL_REV_MINOR(scpi_info
->protocol_version
));
808 static DEVICE_ATTR_RO(protocol_version
);
810 static ssize_t
firmware_version_show(struct device
*dev
,
811 struct device_attribute
*attr
, char *buf
)
813 struct scpi_drvinfo
*scpi_info
= dev_get_drvdata(dev
);
815 return sprintf(buf
, "%d.%d.%d\n",
816 FW_REV_MAJOR(scpi_info
->firmware_version
),
817 FW_REV_MINOR(scpi_info
->firmware_version
),
818 FW_REV_PATCH(scpi_info
->firmware_version
));
820 static DEVICE_ATTR_RO(firmware_version
);
822 static struct attribute
*versions_attrs
[] = {
823 &dev_attr_firmware_version
.attr
,
824 &dev_attr_protocol_version
.attr
,
827 ATTRIBUTE_GROUPS(versions
);
830 scpi_free_channels(struct device
*dev
, struct scpi_chan
*pchan
, int count
)
834 for (i
= 0; i
< count
&& pchan
->chan
; i
++, pchan
++) {
835 mbox_free_channel(pchan
->chan
);
836 devm_kfree(dev
, pchan
->xfers
);
837 devm_iounmap(dev
, pchan
->rx_payload
);
841 static int scpi_remove(struct platform_device
*pdev
)
844 struct device
*dev
= &pdev
->dev
;
845 struct scpi_drvinfo
*info
= platform_get_drvdata(pdev
);
847 scpi_info
= NULL
; /* stop exporting SCPI ops through get_scpi_ops */
849 of_platform_depopulate(dev
);
850 sysfs_remove_groups(&dev
->kobj
, versions_groups
);
851 scpi_free_channels(dev
, info
->channels
, info
->num_chans
);
852 platform_set_drvdata(pdev
, NULL
);
854 for (i
= 0; i
< MAX_DVFS_DOMAINS
&& info
->dvfs
[i
]; i
++) {
855 kfree(info
->dvfs
[i
]->opps
);
856 kfree(info
->dvfs
[i
]);
858 devm_kfree(dev
, info
->channels
);
859 devm_kfree(dev
, info
);
864 #define MAX_SCPI_XFERS 10
865 static int scpi_alloc_xfer_list(struct device
*dev
, struct scpi_chan
*ch
)
868 struct scpi_xfer
*xfers
;
870 xfers
= devm_kzalloc(dev
, MAX_SCPI_XFERS
* sizeof(*xfers
), GFP_KERNEL
);
875 for (i
= 0; i
< MAX_SCPI_XFERS
; i
++, xfers
++)
876 list_add_tail(&xfers
->node
, &ch
->xfers_list
);
880 static const struct of_device_id legacy_scpi_of_match
[] = {
881 {.compatible
= "arm,scpi-pre-1.0"},
885 static int scpi_probe(struct platform_device
*pdev
)
889 struct scpi_chan
*scpi_chan
;
890 struct device
*dev
= &pdev
->dev
;
891 struct device_node
*np
= dev
->of_node
;
893 scpi_info
= devm_kzalloc(dev
, sizeof(*scpi_info
), GFP_KERNEL
);
897 if (of_match_device(legacy_scpi_of_match
, &pdev
->dev
))
898 scpi_info
->is_legacy
= true;
900 count
= of_count_phandle_with_args(np
, "mboxes", "#mbox-cells");
902 dev_err(dev
, "no mboxes property in '%s'\n", np
->full_name
);
906 scpi_chan
= devm_kcalloc(dev
, count
, sizeof(*scpi_chan
), GFP_KERNEL
);
910 for (idx
= 0; idx
< count
; idx
++) {
911 resource_size_t size
;
912 struct scpi_chan
*pchan
= scpi_chan
+ idx
;
913 struct mbox_client
*cl
= &pchan
->cl
;
914 struct device_node
*shmem
= of_parse_phandle(np
, "shmem", idx
);
916 ret
= of_address_to_resource(shmem
, 0, &res
);
919 dev_err(dev
, "failed to get SCPI payload mem resource\n");
923 size
= resource_size(&res
);
924 pchan
->rx_payload
= devm_ioremap(dev
, res
.start
, size
);
925 if (!pchan
->rx_payload
) {
926 dev_err(dev
, "failed to ioremap SCPI payload\n");
927 ret
= -EADDRNOTAVAIL
;
930 pchan
->tx_payload
= pchan
->rx_payload
+ (size
>> 1);
933 cl
->rx_callback
= scpi_handle_remote_msg
;
934 cl
->tx_prepare
= scpi_tx_prepare
;
937 cl
->knows_txdone
= false; /* controller can't ack */
939 INIT_LIST_HEAD(&pchan
->rx_pending
);
940 INIT_LIST_HEAD(&pchan
->xfers_list
);
941 spin_lock_init(&pchan
->rx_lock
);
942 mutex_init(&pchan
->xfers_lock
);
944 ret
= scpi_alloc_xfer_list(dev
, pchan
);
946 pchan
->chan
= mbox_request_channel(cl
, idx
);
947 if (!IS_ERR(pchan
->chan
))
949 ret
= PTR_ERR(pchan
->chan
);
950 if (ret
!= -EPROBE_DEFER
)
951 dev_err(dev
, "failed to get channel%d err %d\n",
955 scpi_free_channels(dev
, scpi_chan
, idx
);
960 scpi_info
->channels
= scpi_chan
;
961 scpi_info
->num_chans
= count
;
962 scpi_info
->commands
= scpi_std_commands
;
964 platform_set_drvdata(pdev
, scpi_info
);
966 if (scpi_info
->is_legacy
) {
967 /* Replace with legacy variants */
968 scpi_ops
.clk_set_val
= legacy_scpi_clk_set_val
;
969 scpi_info
->commands
= scpi_legacy_commands
;
971 /* Fill priority bitmap */
972 for (idx
= 0; idx
< ARRAY_SIZE(legacy_hpriority_cmds
); idx
++)
973 set_bit(legacy_hpriority_cmds
[idx
],
974 scpi_info
->cmd_priority
);
977 ret
= scpi_init_versions(scpi_info
);
979 dev_err(dev
, "incorrect or no SCP firmware found\n");
984 _dev_info(dev
, "SCP Protocol %d.%d Firmware %d.%d.%d version\n",
985 PROTOCOL_REV_MAJOR(scpi_info
->protocol_version
),
986 PROTOCOL_REV_MINOR(scpi_info
->protocol_version
),
987 FW_REV_MAJOR(scpi_info
->firmware_version
),
988 FW_REV_MINOR(scpi_info
->firmware_version
),
989 FW_REV_PATCH(scpi_info
->firmware_version
));
990 scpi_info
->scpi_ops
= &scpi_ops
;
992 ret
= sysfs_create_groups(&dev
->kobj
, versions_groups
);
994 dev_err(dev
, "unable to create sysfs version group\n");
996 return of_platform_populate(dev
->of_node
, NULL
, NULL
, dev
);
999 static const struct of_device_id scpi_of_match
[] = {
1000 {.compatible
= "arm,scpi"},
1001 {.compatible
= "arm,scpi-pre-1.0"},
1005 MODULE_DEVICE_TABLE(of
, scpi_of_match
);
1007 static struct platform_driver scpi_driver
= {
1009 .name
= "scpi_protocol",
1010 .of_match_table
= scpi_of_match
,
1012 .probe
= scpi_probe
,
1013 .remove
= scpi_remove
,
1015 module_platform_driver(scpi_driver
);
1017 MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
1018 MODULE_DESCRIPTION("ARM SCPI mailbox protocol driver");
1019 MODULE_LICENSE("GPL v2");