1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/bitmap.h>
18#include <linux/export.h>
19#include <linux/io.h>
20#include <linux/kernel.h>
21#include <linux/ktime.h>
22#include <linux/module.h>
23#include <linux/of_address.h>
24#include <linux/of_device.h>
25#include <linux/processor.h>
26#include <linux/slab.h>
27
28#include "common.h"
29#include "notify.h"
30
31#define CREATE_TRACE_POINTS
32#include <trace/events/scmi.h>
33
34enum scmi_error_codes {
35 SCMI_SUCCESS = 0,
36 SCMI_ERR_SUPPORT = -1,
37 SCMI_ERR_PARAMS = -2,
38 SCMI_ERR_ACCESS = -3,
39 SCMI_ERR_ENTRY = -4,
40 SCMI_ERR_RANGE = -5,
41 SCMI_ERR_BUSY = -6,
42 SCMI_ERR_COMMS = -7,
43 SCMI_ERR_GENERIC = -8,
44 SCMI_ERR_HARDWARE = -9,
45 SCMI_ERR_PROTOCOL = -10,
46 SCMI_ERR_MAX
47};
48
49
50static LIST_HEAD(scmi_list);
51
52static DEFINE_MUTEX(scmi_list_mutex);
53
54static atomic_t transfer_last_id;
55
56
57
58
59
60
61
62
63
64
65struct scmi_xfers_info {
66 struct scmi_xfer *xfer_block;
67 unsigned long *xfer_alloc_table;
68 spinlock_t xfer_lock;
69};
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88struct scmi_info {
89 struct device *dev;
90 const struct scmi_desc *desc;
91 struct scmi_revision_info version;
92 struct scmi_handle handle;
93 struct scmi_xfers_info tx_minfo;
94 struct scmi_xfers_info rx_minfo;
95 struct idr tx_idr;
96 struct idr rx_idr;
97 u8 *protocols_imp;
98 struct list_head node;
99 int users;
100};
101
102#define handle_to_scmi_info(h) container_of(h, struct scmi_info, handle)
103
104static const int scmi_linux_errmap[] = {
105
106 0,
107 -EOPNOTSUPP,
108 -EINVAL,
109 -EACCES,
110 -ENOENT,
111 -ERANGE,
112 -EBUSY,
113 -ECOMM,
114 -EIO,
115 -EREMOTEIO,
116 -EPROTO,
117};
118
119static inline int scmi_to_linux_errno(int errno)
120{
121 if (errno < SCMI_SUCCESS && errno > SCMI_ERR_MAX)
122 return scmi_linux_errmap[-errno];
123 return -EIO;
124}
125
126
127
128
129
130
131
132static inline void scmi_dump_header_dbg(struct device *dev,
133 struct scmi_msg_hdr *hdr)
134{
135 dev_dbg(dev, "Message ID: %x Sequence ID: %x Protocol: %x\n",
136 hdr->id, hdr->seq, hdr->protocol_id);
137}
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154static struct scmi_xfer *scmi_xfer_get(const struct scmi_handle *handle,
155 struct scmi_xfers_info *minfo)
156{
157 u16 xfer_id;
158 struct scmi_xfer *xfer;
159 unsigned long flags, bit_pos;
160 struct scmi_info *info = handle_to_scmi_info(handle);
161
162
163 spin_lock_irqsave(&minfo->xfer_lock, flags);
164 bit_pos = find_first_zero_bit(minfo->xfer_alloc_table,
165 info->desc->max_msg);
166 if (bit_pos == info->desc->max_msg) {
167 spin_unlock_irqrestore(&minfo->xfer_lock, flags);
168 return ERR_PTR(-ENOMEM);
169 }
170 set_bit(bit_pos, minfo->xfer_alloc_table);
171 spin_unlock_irqrestore(&minfo->xfer_lock, flags);
172
173 xfer_id = bit_pos;
174
175 xfer = &minfo->xfer_block[xfer_id];
176 xfer->hdr.seq = xfer_id;
177 reinit_completion(&xfer->done);
178 xfer->transfer_id = atomic_inc_return(&transfer_last_id);
179
180 return xfer;
181}
182
183
184
185
186
187
188
189
190
191static void
192__scmi_xfer_put(struct scmi_xfers_info *minfo, struct scmi_xfer *xfer)
193{
194 unsigned long flags;
195
196
197
198
199
200
201 spin_lock_irqsave(&minfo->xfer_lock, flags);
202 clear_bit(xfer->hdr.seq, minfo->xfer_alloc_table);
203 spin_unlock_irqrestore(&minfo->xfer_lock, flags);
204}
205
206static void scmi_handle_notification(struct scmi_chan_info *cinfo, u32 msg_hdr)
207{
208 struct scmi_xfer *xfer;
209 struct device *dev = cinfo->dev;
210 struct scmi_info *info = handle_to_scmi_info(cinfo->handle);
211 struct scmi_xfers_info *minfo = &info->rx_minfo;
212 ktime_t ts;
213
214 ts = ktime_get_boottime();
215 xfer = scmi_xfer_get(cinfo->handle, minfo);
216 if (IS_ERR(xfer)) {
217 dev_err(dev, "failed to get free message slot (%ld)\n",
218 PTR_ERR(xfer));
219 info->desc->ops->clear_channel(cinfo);
220 return;
221 }
222
223 unpack_scmi_header(msg_hdr, &xfer->hdr);
224 scmi_dump_header_dbg(dev, &xfer->hdr);
225 info->desc->ops->fetch_notification(cinfo, info->desc->max_msg_size,
226 xfer);
227 scmi_notify(cinfo->handle, xfer->hdr.protocol_id,
228 xfer->hdr.id, xfer->rx.buf, xfer->rx.len, ts);
229
230 trace_scmi_rx_done(xfer->transfer_id, xfer->hdr.id,
231 xfer->hdr.protocol_id, xfer->hdr.seq,
232 MSG_TYPE_NOTIFICATION);
233
234 __scmi_xfer_put(minfo, xfer);
235
236 info->desc->ops->clear_channel(cinfo);
237}
238
239static void scmi_handle_response(struct scmi_chan_info *cinfo,
240 u16 xfer_id, u8 msg_type)
241{
242 struct scmi_xfer *xfer;
243 struct device *dev = cinfo->dev;
244 struct scmi_info *info = handle_to_scmi_info(cinfo->handle);
245 struct scmi_xfers_info *minfo = &info->tx_minfo;
246
247
248 if (!test_bit(xfer_id, minfo->xfer_alloc_table)) {
249 dev_err(dev, "message for %d is not expected!\n", xfer_id);
250 info->desc->ops->clear_channel(cinfo);
251 return;
252 }
253
254 xfer = &minfo->xfer_block[xfer_id];
255
256
257
258
259
260
261 if (unlikely(msg_type == MSG_TYPE_DELAYED_RESP && !xfer->async_done)) {
262 dev_err(dev,
263 "Delayed Response for %d not expected! Buggy F/W ?\n",
264 xfer_id);
265 info->desc->ops->clear_channel(cinfo);
266
267 __scmi_xfer_put(minfo, xfer);
268 return;
269 }
270
271 scmi_dump_header_dbg(dev, &xfer->hdr);
272
273 info->desc->ops->fetch_response(cinfo, xfer);
274
275 trace_scmi_rx_done(xfer->transfer_id, xfer->hdr.id,
276 xfer->hdr.protocol_id, xfer->hdr.seq,
277 msg_type);
278
279 if (msg_type == MSG_TYPE_DELAYED_RESP) {
280 info->desc->ops->clear_channel(cinfo);
281 complete(xfer->async_done);
282 } else {
283 complete(&xfer->done);
284 }
285}
286
287
288
289
290
291
292
293
294
295
296
297
298
299void scmi_rx_callback(struct scmi_chan_info *cinfo, u32 msg_hdr)
300{
301 u16 xfer_id = MSG_XTRACT_TOKEN(msg_hdr);
302 u8 msg_type = MSG_XTRACT_TYPE(msg_hdr);
303
304 switch (msg_type) {
305 case MSG_TYPE_NOTIFICATION:
306 scmi_handle_notification(cinfo, msg_hdr);
307 break;
308 case MSG_TYPE_COMMAND:
309 case MSG_TYPE_DELAYED_RESP:
310 scmi_handle_response(cinfo, xfer_id, msg_type);
311 break;
312 default:
313 WARN_ONCE(1, "received unknown msg_type:%d\n", msg_type);
314 break;
315 }
316}
317
318
319
320
321
322
323
324void scmi_xfer_put(const struct scmi_handle *handle, struct scmi_xfer *xfer)
325{
326 struct scmi_info *info = handle_to_scmi_info(handle);
327
328 __scmi_xfer_put(&info->tx_minfo, xfer);
329}
330
331#define SCMI_MAX_POLL_TO_NS (100 * NSEC_PER_USEC)
332
333static bool scmi_xfer_done_no_timeout(struct scmi_chan_info *cinfo,
334 struct scmi_xfer *xfer, ktime_t stop)
335{
336 struct scmi_info *info = handle_to_scmi_info(cinfo->handle);
337
338 return info->desc->ops->poll_done(cinfo, xfer) ||
339 ktime_after(ktime_get(), stop);
340}
341
342
343
344
345
346
347
348
349
350
351
352int scmi_do_xfer(const struct scmi_handle *handle, struct scmi_xfer *xfer)
353{
354 int ret;
355 int timeout;
356 struct scmi_info *info = handle_to_scmi_info(handle);
357 struct device *dev = info->dev;
358 struct scmi_chan_info *cinfo;
359
360 cinfo = idr_find(&info->tx_idr, xfer->hdr.protocol_id);
361 if (unlikely(!cinfo))
362 return -EINVAL;
363
364 trace_scmi_xfer_begin(xfer->transfer_id, xfer->hdr.id,
365 xfer->hdr.protocol_id, xfer->hdr.seq,
366 xfer->hdr.poll_completion);
367
368 ret = info->desc->ops->send_message(cinfo, xfer);
369 if (ret < 0) {
370 dev_dbg(dev, "Failed to send message %d\n", ret);
371 return ret;
372 }
373
374 if (xfer->hdr.poll_completion) {
375 ktime_t stop = ktime_add_ns(ktime_get(), SCMI_MAX_POLL_TO_NS);
376
377 spin_until_cond(scmi_xfer_done_no_timeout(cinfo, xfer, stop));
378
379 if (ktime_before(ktime_get(), stop))
380 info->desc->ops->fetch_response(cinfo, xfer);
381 else
382 ret = -ETIMEDOUT;
383 } else {
384
385 timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms);
386 if (!wait_for_completion_timeout(&xfer->done, timeout)) {
387 dev_err(dev, "timed out in resp(caller: %pS)\n",
388 (void *)_RET_IP_);
389 ret = -ETIMEDOUT;
390 }
391 }
392
393 if (!ret && xfer->hdr.status)
394 ret = scmi_to_linux_errno(xfer->hdr.status);
395
396 if (info->desc->ops->mark_txdone)
397 info->desc->ops->mark_txdone(cinfo, ret);
398
399 trace_scmi_xfer_end(xfer->transfer_id, xfer->hdr.id,
400 xfer->hdr.protocol_id, xfer->hdr.seq, ret);
401
402 return ret;
403}
404
405void scmi_reset_rx_to_maxsz(const struct scmi_handle *handle,
406 struct scmi_xfer *xfer)
407{
408 struct scmi_info *info = handle_to_scmi_info(handle);
409
410 xfer->rx.len = info->desc->max_msg_size;
411}
412
413#define SCMI_MAX_RESPONSE_TIMEOUT (2 * MSEC_PER_SEC)
414
415
416
417
418
419
420
421
422
423
424
425int scmi_do_xfer_with_response(const struct scmi_handle *handle,
426 struct scmi_xfer *xfer)
427{
428 int ret, timeout = msecs_to_jiffies(SCMI_MAX_RESPONSE_TIMEOUT);
429 DECLARE_COMPLETION_ONSTACK(async_response);
430
431 xfer->async_done = &async_response;
432
433 ret = scmi_do_xfer(handle, xfer);
434 if (!ret && !wait_for_completion_timeout(xfer->async_done, timeout))
435 ret = -ETIMEDOUT;
436
437 xfer->async_done = NULL;
438 return ret;
439}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457int scmi_xfer_get_init(const struct scmi_handle *handle, u8 msg_id, u8 prot_id,
458 size_t tx_size, size_t rx_size, struct scmi_xfer **p)
459{
460 int ret;
461 struct scmi_xfer *xfer;
462 struct scmi_info *info = handle_to_scmi_info(handle);
463 struct scmi_xfers_info *minfo = &info->tx_minfo;
464 struct device *dev = info->dev;
465
466
467 if (rx_size > info->desc->max_msg_size ||
468 tx_size > info->desc->max_msg_size)
469 return -ERANGE;
470
471 xfer = scmi_xfer_get(handle, minfo);
472 if (IS_ERR(xfer)) {
473 ret = PTR_ERR(xfer);
474 dev_err(dev, "failed to get free message slot(%d)\n", ret);
475 return ret;
476 }
477
478 xfer->tx.len = tx_size;
479 xfer->rx.len = rx_size ? : info->desc->max_msg_size;
480 xfer->hdr.id = msg_id;
481 xfer->hdr.protocol_id = prot_id;
482 xfer->hdr.poll_completion = false;
483
484 *p = xfer;
485
486 return 0;
487}
488
489
490
491
492
493
494
495
496
497
498
499
500int scmi_version_get(const struct scmi_handle *handle, u8 protocol,
501 u32 *version)
502{
503 int ret;
504 __le32 *rev_info;
505 struct scmi_xfer *t;
506
507 ret = scmi_xfer_get_init(handle, PROTOCOL_VERSION, protocol, 0,
508 sizeof(*version), &t);
509 if (ret)
510 return ret;
511
512 ret = scmi_do_xfer(handle, t);
513 if (!ret) {
514 rev_info = t->rx.buf;
515 *version = le32_to_cpu(*rev_info);
516 }
517
518 scmi_xfer_put(handle, t);
519 return ret;
520}
521
522void scmi_setup_protocol_implemented(const struct scmi_handle *handle,
523 u8 *prot_imp)
524{
525 struct scmi_info *info = handle_to_scmi_info(handle);
526
527 info->protocols_imp = prot_imp;
528}
529
530static bool
531scmi_is_protocol_implemented(const struct scmi_handle *handle, u8 prot_id)
532{
533 int i;
534 struct scmi_info *info = handle_to_scmi_info(handle);
535
536 if (!info->protocols_imp)
537 return false;
538
539 for (i = 0; i < MAX_PROTOCOLS_IMP; i++)
540 if (info->protocols_imp[i] == prot_id)
541 return true;
542 return false;
543}
544
545
546
547
548
549
550
551
552
553
554
555
556struct scmi_handle *scmi_handle_get(struct device *dev)
557{
558 struct list_head *p;
559 struct scmi_info *info;
560 struct scmi_handle *handle = NULL;
561
562 mutex_lock(&scmi_list_mutex);
563 list_for_each(p, &scmi_list) {
564 info = list_entry(p, struct scmi_info, node);
565 if (dev->parent == info->dev) {
566 handle = &info->handle;
567 info->users++;
568 break;
569 }
570 }
571 mutex_unlock(&scmi_list_mutex);
572
573 return handle;
574}
575
576
577
578
579
580
581
582
583
584
585
586
587
588int scmi_handle_put(const struct scmi_handle *handle)
589{
590 struct scmi_info *info;
591
592 if (!handle)
593 return -EINVAL;
594
595 info = handle_to_scmi_info(handle);
596 mutex_lock(&scmi_list_mutex);
597 if (!WARN_ON(!info->users))
598 info->users--;
599 mutex_unlock(&scmi_list_mutex);
600
601 return 0;
602}
603
604static int __scmi_xfer_info_init(struct scmi_info *sinfo,
605 struct scmi_xfers_info *info)
606{
607 int i;
608 struct scmi_xfer *xfer;
609 struct device *dev = sinfo->dev;
610 const struct scmi_desc *desc = sinfo->desc;
611
612
613 if (WARN_ON(desc->max_msg >= MSG_TOKEN_MAX)) {
614 dev_err(dev, "Maximum message of %d exceeds supported %ld\n",
615 desc->max_msg, MSG_TOKEN_MAX);
616 return -EINVAL;
617 }
618
619 info->xfer_block = devm_kcalloc(dev, desc->max_msg,
620 sizeof(*info->xfer_block), GFP_KERNEL);
621 if (!info->xfer_block)
622 return -ENOMEM;
623
624 info->xfer_alloc_table = devm_kcalloc(dev, BITS_TO_LONGS(desc->max_msg),
625 sizeof(long), GFP_KERNEL);
626 if (!info->xfer_alloc_table)
627 return -ENOMEM;
628
629
630 for (i = 0, xfer = info->xfer_block; i < desc->max_msg; i++, xfer++) {
631 xfer->rx.buf = devm_kcalloc(dev, sizeof(u8), desc->max_msg_size,
632 GFP_KERNEL);
633 if (!xfer->rx.buf)
634 return -ENOMEM;
635
636 xfer->tx.buf = xfer->rx.buf;
637 init_completion(&xfer->done);
638 }
639
640 spin_lock_init(&info->xfer_lock);
641
642 return 0;
643}
644
645static int scmi_xfer_info_init(struct scmi_info *sinfo)
646{
647 int ret = __scmi_xfer_info_init(sinfo, &sinfo->tx_minfo);
648
649 if (!ret && idr_find(&sinfo->rx_idr, SCMI_PROTOCOL_BASE))
650 ret = __scmi_xfer_info_init(sinfo, &sinfo->rx_minfo);
651
652 return ret;
653}
654
655static int scmi_chan_setup(struct scmi_info *info, struct device *dev,
656 int prot_id, bool tx)
657{
658 int ret, idx;
659 struct scmi_chan_info *cinfo;
660 struct idr *idr;
661
662
663 idx = tx ? 0 : 1;
664 idr = tx ? &info->tx_idr : &info->rx_idr;
665
666
667 cinfo = idr_find(idr, prot_id);
668 if (cinfo)
669 return 0;
670
671 if (!info->desc->ops->chan_available(dev, idx)) {
672 cinfo = idr_find(idr, SCMI_PROTOCOL_BASE);
673 if (unlikely(!cinfo))
674 return -EINVAL;
675 goto idr_alloc;
676 }
677
678 cinfo = devm_kzalloc(info->dev, sizeof(*cinfo), GFP_KERNEL);
679 if (!cinfo)
680 return -ENOMEM;
681
682 cinfo->dev = dev;
683
684 ret = info->desc->ops->chan_setup(cinfo, info->dev, tx);
685 if (ret)
686 return ret;
687
688idr_alloc:
689 ret = idr_alloc(idr, cinfo, prot_id, prot_id + 1, GFP_KERNEL);
690 if (ret != prot_id) {
691 dev_err(dev, "unable to allocate SCMI idr slot err %d\n", ret);
692 return ret;
693 }
694
695 cinfo->handle = &info->handle;
696 return 0;
697}
698
699static inline int
700scmi_txrx_setup(struct scmi_info *info, struct device *dev, int prot_id)
701{
702 int ret = scmi_chan_setup(info, dev, prot_id, true);
703
704 if (!ret)
705 scmi_chan_setup(info, dev, prot_id, false);
706
707 return ret;
708}
709
710static inline void
711scmi_create_protocol_device(struct device_node *np, struct scmi_info *info,
712 int prot_id, const char *name)
713{
714 struct scmi_device *sdev;
715
716 sdev = scmi_device_create(np, info->dev, prot_id, name);
717 if (!sdev) {
718 dev_err(info->dev, "failed to create %d protocol device\n",
719 prot_id);
720 return;
721 }
722
723 if (scmi_txrx_setup(info, &sdev->dev, prot_id)) {
724 dev_err(&sdev->dev, "failed to setup transport\n");
725 scmi_device_destroy(sdev);
726 return;
727 }
728
729
730 scmi_set_handle(sdev);
731}
732
733#define MAX_SCMI_DEV_PER_PROTOCOL 2
734struct scmi_prot_devnames {
735 int protocol_id;
736 char *names[MAX_SCMI_DEV_PER_PROTOCOL];
737};
738
739static struct scmi_prot_devnames devnames[] = {
740 { SCMI_PROTOCOL_POWER, { "genpd" },},
741 { SCMI_PROTOCOL_SYSTEM, { "syspower" },},
742 { SCMI_PROTOCOL_PERF, { "cpufreq" },},
743 { SCMI_PROTOCOL_CLOCK, { "clocks" },},
744 { SCMI_PROTOCOL_SENSOR, { "hwmon" },},
745 { SCMI_PROTOCOL_RESET, { "reset" },},
746};
747
748static inline void
749scmi_create_protocol_devices(struct device_node *np, struct scmi_info *info,
750 int prot_id)
751{
752 int loop, cnt;
753
754 for (loop = 0; loop < ARRAY_SIZE(devnames); loop++) {
755 if (devnames[loop].protocol_id != prot_id)
756 continue;
757
758 for (cnt = 0; cnt < ARRAY_SIZE(devnames[loop].names); cnt++) {
759 const char *name = devnames[loop].names[cnt];
760
761 if (name)
762 scmi_create_protocol_device(np, info, prot_id,
763 name);
764 }
765 }
766}
767
768static int scmi_probe(struct platform_device *pdev)
769{
770 int ret;
771 struct scmi_handle *handle;
772 const struct scmi_desc *desc;
773 struct scmi_info *info;
774 struct device *dev = &pdev->dev;
775 struct device_node *child, *np = dev->of_node;
776
777 desc = of_device_get_match_data(dev);
778 if (!desc)
779 return -EINVAL;
780
781 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
782 if (!info)
783 return -ENOMEM;
784
785 info->dev = dev;
786 info->desc = desc;
787 INIT_LIST_HEAD(&info->node);
788
789 platform_set_drvdata(pdev, info);
790 idr_init(&info->tx_idr);
791 idr_init(&info->rx_idr);
792
793 handle = &info->handle;
794 handle->dev = info->dev;
795 handle->version = &info->version;
796
797 ret = scmi_txrx_setup(info, dev, SCMI_PROTOCOL_BASE);
798 if (ret)
799 return ret;
800
801 ret = scmi_xfer_info_init(info);
802 if (ret)
803 return ret;
804
805 if (scmi_notification_init(handle))
806 dev_err(dev, "SCMI Notifications NOT available.\n");
807
808 ret = scmi_base_protocol_init(handle);
809 if (ret) {
810 dev_err(dev, "unable to communicate with SCMI(%d)\n", ret);
811 return ret;
812 }
813
814 mutex_lock(&scmi_list_mutex);
815 list_add_tail(&info->node, &scmi_list);
816 mutex_unlock(&scmi_list_mutex);
817
818 for_each_available_child_of_node(np, child) {
819 u32 prot_id;
820
821 if (of_property_read_u32(child, "reg", &prot_id))
822 continue;
823
824 if (!FIELD_FIT(MSG_PROTOCOL_ID_MASK, prot_id))
825 dev_err(dev, "Out of range protocol %d\n", prot_id);
826
827 if (!scmi_is_protocol_implemented(handle, prot_id)) {
828 dev_err(dev, "SCMI protocol %d not implemented\n",
829 prot_id);
830 continue;
831 }
832
833 scmi_create_protocol_devices(child, info, prot_id);
834 }
835
836 return 0;
837}
838
839void scmi_free_channel(struct scmi_chan_info *cinfo, struct idr *idr, int id)
840{
841 idr_remove(idr, id);
842}
843
844static int scmi_remove(struct platform_device *pdev)
845{
846 int ret = 0;
847 struct scmi_info *info = platform_get_drvdata(pdev);
848 struct idr *idr = &info->tx_idr;
849
850 scmi_notification_exit(&info->handle);
851
852 mutex_lock(&scmi_list_mutex);
853 if (info->users)
854 ret = -EBUSY;
855 else
856 list_del(&info->node);
857 mutex_unlock(&scmi_list_mutex);
858
859 if (ret)
860 return ret;
861
862
863 ret = idr_for_each(idr, info->desc->ops->chan_free, idr);
864 idr_destroy(&info->tx_idr);
865
866 idr = &info->rx_idr;
867 ret = idr_for_each(idr, info->desc->ops->chan_free, idr);
868 idr_destroy(&info->rx_idr);
869
870 return ret;
871}
872
873static ssize_t protocol_version_show(struct device *dev,
874 struct device_attribute *attr, char *buf)
875{
876 struct scmi_info *info = dev_get_drvdata(dev);
877
878 return sprintf(buf, "%u.%u\n", info->version.major_ver,
879 info->version.minor_ver);
880}
881static DEVICE_ATTR_RO(protocol_version);
882
883static ssize_t firmware_version_show(struct device *dev,
884 struct device_attribute *attr, char *buf)
885{
886 struct scmi_info *info = dev_get_drvdata(dev);
887
888 return sprintf(buf, "0x%x\n", info->version.impl_ver);
889}
890static DEVICE_ATTR_RO(firmware_version);
891
892static ssize_t vendor_id_show(struct device *dev,
893 struct device_attribute *attr, char *buf)
894{
895 struct scmi_info *info = dev_get_drvdata(dev);
896
897 return sprintf(buf, "%s\n", info->version.vendor_id);
898}
899static DEVICE_ATTR_RO(vendor_id);
900
901static ssize_t sub_vendor_id_show(struct device *dev,
902 struct device_attribute *attr, char *buf)
903{
904 struct scmi_info *info = dev_get_drvdata(dev);
905
906 return sprintf(buf, "%s\n", info->version.sub_vendor_id);
907}
908static DEVICE_ATTR_RO(sub_vendor_id);
909
910static struct attribute *versions_attrs[] = {
911 &dev_attr_firmware_version.attr,
912 &dev_attr_protocol_version.attr,
913 &dev_attr_vendor_id.attr,
914 &dev_attr_sub_vendor_id.attr,
915 NULL,
916};
917ATTRIBUTE_GROUPS(versions);
918
919
920static const struct of_device_id scmi_of_match[] = {
921 { .compatible = "arm,scmi", .data = &scmi_mailbox_desc },
922#ifdef CONFIG_HAVE_ARM_SMCCC_DISCOVERY
923 { .compatible = "arm,scmi-smc", .data = &scmi_smc_desc},
924#endif
925 { },
926};
927
928MODULE_DEVICE_TABLE(of, scmi_of_match);
929
930static struct platform_driver scmi_driver = {
931 .driver = {
932 .name = "arm-scmi",
933 .of_match_table = scmi_of_match,
934 .dev_groups = versions_groups,
935 },
936 .probe = scmi_probe,
937 .remove = scmi_remove,
938};
939
940static int __init scmi_driver_init(void)
941{
942 scmi_bus_init();
943
944 scmi_clock_register();
945 scmi_perf_register();
946 scmi_power_register();
947 scmi_reset_register();
948 scmi_sensors_register();
949 scmi_system_register();
950
951 return platform_driver_register(&scmi_driver);
952}
953subsys_initcall(scmi_driver_init);
954
955static void __exit scmi_driver_exit(void)
956{
957 scmi_bus_exit();
958
959 scmi_clock_unregister();
960 scmi_perf_unregister();
961 scmi_power_unregister();
962 scmi_reset_unregister();
963 scmi_sensors_unregister();
964 scmi_system_unregister();
965
966 platform_driver_unregister(&scmi_driver);
967}
968module_exit(scmi_driver_exit);
969
970MODULE_ALIAS("platform: arm-scmi");
971MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
972MODULE_DESCRIPTION("ARM SCMI protocol driver");
973MODULE_LICENSE("GPL v2");
974