1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * System Control and Management Interface (SCMI) Message Protocol driver 4 * 5 * SCMI Message Protocol is used between the System Control Processor(SCP) 6 * and the Application Processors(AP). The Message Handling Unit(MHU) 7 * provides a mechanism for inter-processor communication between SCP's 8 * Cortex M3 and AP. 9 * 10 * SCP offers control and management of the core/cluster power states, 11 * various power domain DVFS including the core/cluster, certain system 12 * clocks configuration, thermal sensors and many others. 13 * 14 * Copyright (C) 2018 ARM Ltd. 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 34 enum scmi_error_codes { 35 SCMI_SUCCESS = 0, /* Success */ 36 SCMI_ERR_SUPPORT = -1, /* Not supported */ 37 SCMI_ERR_PARAMS = -2, /* Invalid Parameters */ 38 SCMI_ERR_ACCESS = -3, /* Invalid access/permission denied */ 39 SCMI_ERR_ENTRY = -4, /* Not found */ 40 SCMI_ERR_RANGE = -5, /* Value out of range */ 41 SCMI_ERR_BUSY = -6, /* Device busy */ 42 SCMI_ERR_COMMS = -7, /* Communication Error */ 43 SCMI_ERR_GENERIC = -8, /* Generic Error */ 44 SCMI_ERR_HARDWARE = -9, /* Hardware Error */ 45 SCMI_ERR_PROTOCOL = -10,/* Protocol Error */ 46 SCMI_ERR_MAX 47 }; 48 49 /* List of all SCMI devices active in system */ 50 static LIST_HEAD(scmi_list); 51 /* Protection for the entire list */ 52 static DEFINE_MUTEX(scmi_list_mutex); 53 /* Track the unique id for the transfers for debug & profiling purpose */ 54 static atomic_t transfer_last_id; 55 56 /** 57 * struct scmi_xfers_info - Structure to manage transfer information 58 * 59 * @xfer_block: Preallocated Message array 60 * @xfer_alloc_table: Bitmap table for allocated messages. 61 * Index of this bitmap table is also used for message 62 * sequence identifier. 63 * @xfer_lock: Protection for message allocation 64 */ 65 struct scmi_xfers_info { 66 struct scmi_xfer *xfer_block; 67 unsigned long *xfer_alloc_table; 68 spinlock_t xfer_lock; 69 }; 70 71 /** 72 * struct scmi_info - Structure representing a SCMI instance 73 * 74 * @dev: Device pointer 75 * @desc: SoC description for this instance 76 * @version: SCMI revision information containing protocol version, 77 * implementation version and (sub-)vendor identification. 78 * @handle: Instance of SCMI handle to send to clients 79 * @tx_minfo: Universal Transmit Message management info 80 * @rx_minfo: Universal Receive Message management info 81 * @tx_idr: IDR object to map protocol id to Tx channel info pointer 82 * @rx_idr: IDR object to map protocol id to Rx channel info pointer 83 * @protocols_imp: List of protocols implemented, currently maximum of 84 * MAX_PROTOCOLS_IMP elements allocated by the base protocol 85 * @node: List head 86 * @users: Number of users of this instance 87 */ 88 struct 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 104 static const int scmi_linux_errmap[] = { 105 /* better than switch case as long as return value is continuous */ 106 0, /* SCMI_SUCCESS */ 107 -EOPNOTSUPP, /* SCMI_ERR_SUPPORT */ 108 -EINVAL, /* SCMI_ERR_PARAM */ 109 -EACCES, /* SCMI_ERR_ACCESS */ 110 -ENOENT, /* SCMI_ERR_ENTRY */ 111 -ERANGE, /* SCMI_ERR_RANGE */ 112 -EBUSY, /* SCMI_ERR_BUSY */ 113 -ECOMM, /* SCMI_ERR_COMMS */ 114 -EIO, /* SCMI_ERR_GENERIC */ 115 -EREMOTEIO, /* SCMI_ERR_HARDWARE */ 116 -EPROTO, /* SCMI_ERR_PROTOCOL */ 117 }; 118 119 static 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 * scmi_dump_header_dbg() - Helper to dump a message header. 128 * 129 * @dev: Device pointer corresponding to the SCMI entity 130 * @hdr: pointer to header. 131 */ 132 static 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 * scmi_xfer_get() - Allocate one message 141 * 142 * @handle: Pointer to SCMI entity handle 143 * @minfo: Pointer to Tx/Rx Message management info based on channel type 144 * 145 * Helper function which is used by various message functions that are 146 * exposed to clients of this driver for allocating a message traffic event. 147 * 148 * This function can sleep depending on pending requests already in the system 149 * for the SCMI entity. Further, this also holds a spinlock to maintain 150 * integrity of internal data structures. 151 * 152 * Return: 0 if all went fine, else corresponding error. 153 */ 154 static 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 /* Keep the locked section as small as possible */ 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 * __scmi_xfer_put() - Release a message 185 * 186 * @minfo: Pointer to Tx/Rx Message management info based on channel type 187 * @xfer: message that was reserved by scmi_xfer_get 188 * 189 * This holds a spinlock to maintain integrity of internal data structures. 190 */ 191 static void 192 __scmi_xfer_put(struct scmi_xfers_info *minfo, struct scmi_xfer *xfer) 193 { 194 unsigned long flags; 195 196 /* 197 * Keep the locked section as small as possible 198 * NOTE: we might escape with smp_mb and no lock here.. 199 * but just be conservative and symmetric. 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 206 static 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 239 static 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 /* Are we even expecting this? */ 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 * Even if a response was indeed expected on this slot at this point, 257 * a buggy platform could wrongly reply feeding us an unexpected 258 * delayed response we're not prepared to handle: bail-out safely 259 * blaming firmware. 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 /* It was unexpected, so nobody will clear the xfer if not us */ 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 * scmi_rx_callback() - callback for receiving messages 289 * 290 * @cinfo: SCMI channel info 291 * @msg_hdr: Message header 292 * 293 * Processes one received message to appropriate transfer information and 294 * signals completion of the transfer. 295 * 296 * NOTE: This function will be invoked in IRQ context, hence should be 297 * as optimal as possible. 298 */ 299 void 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 * scmi_xfer_put() - Release a transmit message 320 * 321 * @handle: Pointer to SCMI entity handle 322 * @xfer: message that was reserved by scmi_xfer_get 323 */ 324 void 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 333 static 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 * scmi_do_xfer() - Do one transfer 344 * 345 * @handle: Pointer to SCMI entity handle 346 * @xfer: Transfer to initiate and wait for response 347 * 348 * Return: -ETIMEDOUT in case of no response, if transmit error, 349 * return corresponding error, else if all goes well, 350 * return 0. 351 */ 352 int 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 /* And we wait for the response. */ 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 405 #define SCMI_MAX_RESPONSE_TIMEOUT (2 * MSEC_PER_SEC) 406 407 /** 408 * scmi_do_xfer_with_response() - Do one transfer and wait until the delayed 409 * response is received 410 * 411 * @handle: Pointer to SCMI entity handle 412 * @xfer: Transfer to initiate and wait for response 413 * 414 * Return: -ETIMEDOUT in case of no delayed response, if transmit error, 415 * return corresponding error, else if all goes well, return 0. 416 */ 417 int scmi_do_xfer_with_response(const struct scmi_handle *handle, 418 struct scmi_xfer *xfer) 419 { 420 int ret, timeout = msecs_to_jiffies(SCMI_MAX_RESPONSE_TIMEOUT); 421 DECLARE_COMPLETION_ONSTACK(async_response); 422 423 xfer->async_done = &async_response; 424 425 ret = scmi_do_xfer(handle, xfer); 426 if (!ret && !wait_for_completion_timeout(xfer->async_done, timeout)) 427 ret = -ETIMEDOUT; 428 429 xfer->async_done = NULL; 430 return ret; 431 } 432 433 /** 434 * scmi_xfer_get_init() - Allocate and initialise one message for transmit 435 * 436 * @handle: Pointer to SCMI entity handle 437 * @msg_id: Message identifier 438 * @prot_id: Protocol identifier for the message 439 * @tx_size: transmit message size 440 * @rx_size: receive message size 441 * @p: pointer to the allocated and initialised message 442 * 443 * This function allocates the message using @scmi_xfer_get and 444 * initialise the header. 445 * 446 * Return: 0 if all went fine with @p pointing to message, else 447 * corresponding error. 448 */ 449 int scmi_xfer_get_init(const struct scmi_handle *handle, u8 msg_id, u8 prot_id, 450 size_t tx_size, size_t rx_size, struct scmi_xfer **p) 451 { 452 int ret; 453 struct scmi_xfer *xfer; 454 struct scmi_info *info = handle_to_scmi_info(handle); 455 struct scmi_xfers_info *minfo = &info->tx_minfo; 456 struct device *dev = info->dev; 457 458 /* Ensure we have sane transfer sizes */ 459 if (rx_size > info->desc->max_msg_size || 460 tx_size > info->desc->max_msg_size) 461 return -ERANGE; 462 463 xfer = scmi_xfer_get(handle, minfo); 464 if (IS_ERR(xfer)) { 465 ret = PTR_ERR(xfer); 466 dev_err(dev, "failed to get free message slot(%d)\n", ret); 467 return ret; 468 } 469 470 xfer->tx.len = tx_size; 471 xfer->rx.len = rx_size ? : info->desc->max_msg_size; 472 xfer->hdr.id = msg_id; 473 xfer->hdr.protocol_id = prot_id; 474 xfer->hdr.poll_completion = false; 475 476 *p = xfer; 477 478 return 0; 479 } 480 481 /** 482 * scmi_version_get() - command to get the revision of the SCMI entity 483 * 484 * @handle: Pointer to SCMI entity handle 485 * @protocol: Protocol identifier for the message 486 * @version: Holds returned version of protocol. 487 * 488 * Updates the SCMI information in the internal data structure. 489 * 490 * Return: 0 if all went fine, else return appropriate error. 491 */ 492 int scmi_version_get(const struct scmi_handle *handle, u8 protocol, 493 u32 *version) 494 { 495 int ret; 496 __le32 *rev_info; 497 struct scmi_xfer *t; 498 499 ret = scmi_xfer_get_init(handle, PROTOCOL_VERSION, protocol, 0, 500 sizeof(*version), &t); 501 if (ret) 502 return ret; 503 504 ret = scmi_do_xfer(handle, t); 505 if (!ret) { 506 rev_info = t->rx.buf; 507 *version = le32_to_cpu(*rev_info); 508 } 509 510 scmi_xfer_put(handle, t); 511 return ret; 512 } 513 514 void scmi_setup_protocol_implemented(const struct scmi_handle *handle, 515 u8 *prot_imp) 516 { 517 struct scmi_info *info = handle_to_scmi_info(handle); 518 519 info->protocols_imp = prot_imp; 520 } 521 522 static bool 523 scmi_is_protocol_implemented(const struct scmi_handle *handle, u8 prot_id) 524 { 525 int i; 526 struct scmi_info *info = handle_to_scmi_info(handle); 527 528 if (!info->protocols_imp) 529 return false; 530 531 for (i = 0; i < MAX_PROTOCOLS_IMP; i++) 532 if (info->protocols_imp[i] == prot_id) 533 return true; 534 return false; 535 } 536 537 /** 538 * scmi_handle_get() - Get the SCMI handle for a device 539 * 540 * @dev: pointer to device for which we want SCMI handle 541 * 542 * NOTE: The function does not track individual clients of the framework 543 * and is expected to be maintained by caller of SCMI protocol library. 544 * scmi_handle_put must be balanced with successful scmi_handle_get 545 * 546 * Return: pointer to handle if successful, NULL on error 547 */ 548 struct scmi_handle *scmi_handle_get(struct device *dev) 549 { 550 struct list_head *p; 551 struct scmi_info *info; 552 struct scmi_handle *handle = NULL; 553 554 mutex_lock(&scmi_list_mutex); 555 list_for_each(p, &scmi_list) { 556 info = list_entry(p, struct scmi_info, node); 557 if (dev->parent == info->dev) { 558 handle = &info->handle; 559 info->users++; 560 break; 561 } 562 } 563 mutex_unlock(&scmi_list_mutex); 564 565 return handle; 566 } 567 568 /** 569 * scmi_handle_put() - Release the handle acquired by scmi_handle_get 570 * 571 * @handle: handle acquired by scmi_handle_get 572 * 573 * NOTE: The function does not track individual clients of the framework 574 * and is expected to be maintained by caller of SCMI protocol library. 575 * scmi_handle_put must be balanced with successful scmi_handle_get 576 * 577 * Return: 0 is successfully released 578 * if null was passed, it returns -EINVAL; 579 */ 580 int scmi_handle_put(const struct scmi_handle *handle) 581 { 582 struct scmi_info *info; 583 584 if (!handle) 585 return -EINVAL; 586 587 info = handle_to_scmi_info(handle); 588 mutex_lock(&scmi_list_mutex); 589 if (!WARN_ON(!info->users)) 590 info->users--; 591 mutex_unlock(&scmi_list_mutex); 592 593 return 0; 594 } 595 596 static int __scmi_xfer_info_init(struct scmi_info *sinfo, 597 struct scmi_xfers_info *info) 598 { 599 int i; 600 struct scmi_xfer *xfer; 601 struct device *dev = sinfo->dev; 602 const struct scmi_desc *desc = sinfo->desc; 603 604 /* Pre-allocated messages, no more than what hdr.seq can support */ 605 if (WARN_ON(desc->max_msg >= MSG_TOKEN_MAX)) { 606 dev_err(dev, "Maximum message of %d exceeds supported %ld\n", 607 desc->max_msg, MSG_TOKEN_MAX); 608 return -EINVAL; 609 } 610 611 info->xfer_block = devm_kcalloc(dev, desc->max_msg, 612 sizeof(*info->xfer_block), GFP_KERNEL); 613 if (!info->xfer_block) 614 return -ENOMEM; 615 616 info->xfer_alloc_table = devm_kcalloc(dev, BITS_TO_LONGS(desc->max_msg), 617 sizeof(long), GFP_KERNEL); 618 if (!info->xfer_alloc_table) 619 return -ENOMEM; 620 621 /* Pre-initialize the buffer pointer to pre-allocated buffers */ 622 for (i = 0, xfer = info->xfer_block; i < desc->max_msg; i++, xfer++) { 623 xfer->rx.buf = devm_kcalloc(dev, sizeof(u8), desc->max_msg_size, 624 GFP_KERNEL); 625 if (!xfer->rx.buf) 626 return -ENOMEM; 627 628 xfer->tx.buf = xfer->rx.buf; 629 init_completion(&xfer->done); 630 } 631 632 spin_lock_init(&info->xfer_lock); 633 634 return 0; 635 } 636 637 static int scmi_xfer_info_init(struct scmi_info *sinfo) 638 { 639 int ret = __scmi_xfer_info_init(sinfo, &sinfo->tx_minfo); 640 641 if (!ret && idr_find(&sinfo->rx_idr, SCMI_PROTOCOL_BASE)) 642 ret = __scmi_xfer_info_init(sinfo, &sinfo->rx_minfo); 643 644 return ret; 645 } 646 647 static int scmi_chan_setup(struct scmi_info *info, struct device *dev, 648 int prot_id, bool tx) 649 { 650 int ret, idx; 651 struct scmi_chan_info *cinfo; 652 struct idr *idr; 653 654 /* Transmit channel is first entry i.e. index 0 */ 655 idx = tx ? 0 : 1; 656 idr = tx ? &info->tx_idr : &info->rx_idr; 657 658 /* check if already allocated, used for multiple device per protocol */ 659 cinfo = idr_find(idr, prot_id); 660 if (cinfo) 661 return 0; 662 663 if (!info->desc->ops->chan_available(dev, idx)) { 664 cinfo = idr_find(idr, SCMI_PROTOCOL_BASE); 665 if (unlikely(!cinfo)) /* Possible only if platform has no Rx */ 666 return -EINVAL; 667 goto idr_alloc; 668 } 669 670 cinfo = devm_kzalloc(info->dev, sizeof(*cinfo), GFP_KERNEL); 671 if (!cinfo) 672 return -ENOMEM; 673 674 cinfo->dev = dev; 675 676 ret = info->desc->ops->chan_setup(cinfo, info->dev, tx); 677 if (ret) 678 return ret; 679 680 idr_alloc: 681 ret = idr_alloc(idr, cinfo, prot_id, prot_id + 1, GFP_KERNEL); 682 if (ret != prot_id) { 683 dev_err(dev, "unable to allocate SCMI idr slot err %d\n", ret); 684 return ret; 685 } 686 687 cinfo->handle = &info->handle; 688 return 0; 689 } 690 691 static inline int 692 scmi_txrx_setup(struct scmi_info *info, struct device *dev, int prot_id) 693 { 694 int ret = scmi_chan_setup(info, dev, prot_id, true); 695 696 if (!ret) /* Rx is optional, hence no error check */ 697 scmi_chan_setup(info, dev, prot_id, false); 698 699 return ret; 700 } 701 702 static inline void 703 scmi_create_protocol_device(struct device_node *np, struct scmi_info *info, 704 int prot_id, const char *name) 705 { 706 struct scmi_device *sdev; 707 708 sdev = scmi_device_create(np, info->dev, prot_id, name); 709 if (!sdev) { 710 dev_err(info->dev, "failed to create %d protocol device\n", 711 prot_id); 712 return; 713 } 714 715 if (scmi_txrx_setup(info, &sdev->dev, prot_id)) { 716 dev_err(&sdev->dev, "failed to setup transport\n"); 717 scmi_device_destroy(sdev); 718 return; 719 } 720 721 /* setup handle now as the transport is ready */ 722 scmi_set_handle(sdev); 723 } 724 725 #define MAX_SCMI_DEV_PER_PROTOCOL 2 726 struct scmi_prot_devnames { 727 int protocol_id; 728 char *names[MAX_SCMI_DEV_PER_PROTOCOL]; 729 }; 730 731 static struct scmi_prot_devnames devnames[] = { 732 { SCMI_PROTOCOL_POWER, { "genpd" },}, 733 { SCMI_PROTOCOL_SYSTEM, { "syspower" },}, 734 { SCMI_PROTOCOL_PERF, { "cpufreq" },}, 735 { SCMI_PROTOCOL_CLOCK, { "clocks" },}, 736 { SCMI_PROTOCOL_SENSOR, { "hwmon" },}, 737 { SCMI_PROTOCOL_RESET, { "reset" },}, 738 }; 739 740 static inline void 741 scmi_create_protocol_devices(struct device_node *np, struct scmi_info *info, 742 int prot_id) 743 { 744 int loop, cnt; 745 746 for (loop = 0; loop < ARRAY_SIZE(devnames); loop++) { 747 if (devnames[loop].protocol_id != prot_id) 748 continue; 749 750 for (cnt = 0; cnt < ARRAY_SIZE(devnames[loop].names); cnt++) { 751 const char *name = devnames[loop].names[cnt]; 752 753 if (name) 754 scmi_create_protocol_device(np, info, prot_id, 755 name); 756 } 757 } 758 } 759 760 static int scmi_probe(struct platform_device *pdev) 761 { 762 int ret; 763 struct scmi_handle *handle; 764 const struct scmi_desc *desc; 765 struct scmi_info *info; 766 struct device *dev = &pdev->dev; 767 struct device_node *child, *np = dev->of_node; 768 769 desc = of_device_get_match_data(dev); 770 if (!desc) 771 return -EINVAL; 772 773 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); 774 if (!info) 775 return -ENOMEM; 776 777 info->dev = dev; 778 info->desc = desc; 779 INIT_LIST_HEAD(&info->node); 780 781 platform_set_drvdata(pdev, info); 782 idr_init(&info->tx_idr); 783 idr_init(&info->rx_idr); 784 785 handle = &info->handle; 786 handle->dev = info->dev; 787 handle->version = &info->version; 788 789 ret = scmi_txrx_setup(info, dev, SCMI_PROTOCOL_BASE); 790 if (ret) 791 return ret; 792 793 ret = scmi_xfer_info_init(info); 794 if (ret) 795 return ret; 796 797 if (scmi_notification_init(handle)) 798 dev_err(dev, "SCMI Notifications NOT available.\n"); 799 800 ret = scmi_base_protocol_init(handle); 801 if (ret) { 802 dev_err(dev, "unable to communicate with SCMI(%d)\n", ret); 803 return ret; 804 } 805 806 mutex_lock(&scmi_list_mutex); 807 list_add_tail(&info->node, &scmi_list); 808 mutex_unlock(&scmi_list_mutex); 809 810 for_each_available_child_of_node(np, child) { 811 u32 prot_id; 812 813 if (of_property_read_u32(child, "reg", &prot_id)) 814 continue; 815 816 if (!FIELD_FIT(MSG_PROTOCOL_ID_MASK, prot_id)) 817 dev_err(dev, "Out of range protocol %d\n", prot_id); 818 819 if (!scmi_is_protocol_implemented(handle, prot_id)) { 820 dev_err(dev, "SCMI protocol %d not implemented\n", 821 prot_id); 822 continue; 823 } 824 825 scmi_create_protocol_devices(child, info, prot_id); 826 } 827 828 return 0; 829 } 830 831 void scmi_free_channel(struct scmi_chan_info *cinfo, struct idr *idr, int id) 832 { 833 idr_remove(idr, id); 834 } 835 836 static int scmi_remove(struct platform_device *pdev) 837 { 838 int ret = 0; 839 struct scmi_info *info = platform_get_drvdata(pdev); 840 struct idr *idr = &info->tx_idr; 841 842 scmi_notification_exit(&info->handle); 843 844 mutex_lock(&scmi_list_mutex); 845 if (info->users) 846 ret = -EBUSY; 847 else 848 list_del(&info->node); 849 mutex_unlock(&scmi_list_mutex); 850 851 if (ret) 852 return ret; 853 854 /* Safe to free channels since no more users */ 855 ret = idr_for_each(idr, info->desc->ops->chan_free, idr); 856 idr_destroy(&info->tx_idr); 857 858 idr = &info->rx_idr; 859 ret = idr_for_each(idr, info->desc->ops->chan_free, idr); 860 idr_destroy(&info->rx_idr); 861 862 return ret; 863 } 864 865 static ssize_t protocol_version_show(struct device *dev, 866 struct device_attribute *attr, char *buf) 867 { 868 struct scmi_info *info = dev_get_drvdata(dev); 869 870 return sprintf(buf, "%u.%u\n", info->version.major_ver, 871 info->version.minor_ver); 872 } 873 static DEVICE_ATTR_RO(protocol_version); 874 875 static ssize_t firmware_version_show(struct device *dev, 876 struct device_attribute *attr, char *buf) 877 { 878 struct scmi_info *info = dev_get_drvdata(dev); 879 880 return sprintf(buf, "0x%x\n", info->version.impl_ver); 881 } 882 static DEVICE_ATTR_RO(firmware_version); 883 884 static ssize_t vendor_id_show(struct device *dev, 885 struct device_attribute *attr, char *buf) 886 { 887 struct scmi_info *info = dev_get_drvdata(dev); 888 889 return sprintf(buf, "%s\n", info->version.vendor_id); 890 } 891 static DEVICE_ATTR_RO(vendor_id); 892 893 static ssize_t sub_vendor_id_show(struct device *dev, 894 struct device_attribute *attr, char *buf) 895 { 896 struct scmi_info *info = dev_get_drvdata(dev); 897 898 return sprintf(buf, "%s\n", info->version.sub_vendor_id); 899 } 900 static DEVICE_ATTR_RO(sub_vendor_id); 901 902 static struct attribute *versions_attrs[] = { 903 &dev_attr_firmware_version.attr, 904 &dev_attr_protocol_version.attr, 905 &dev_attr_vendor_id.attr, 906 &dev_attr_sub_vendor_id.attr, 907 NULL, 908 }; 909 ATTRIBUTE_GROUPS(versions); 910 911 /* Each compatible listed below must have descriptor associated with it */ 912 static const struct of_device_id scmi_of_match[] = { 913 { .compatible = "arm,scmi", .data = &scmi_mailbox_desc }, 914 #ifdef CONFIG_HAVE_ARM_SMCCC_DISCOVERY 915 { .compatible = "arm,scmi-smc", .data = &scmi_smc_desc}, 916 #endif 917 { /* Sentinel */ }, 918 }; 919 920 MODULE_DEVICE_TABLE(of, scmi_of_match); 921 922 static struct platform_driver scmi_driver = { 923 .driver = { 924 .name = "arm-scmi", 925 .of_match_table = scmi_of_match, 926 .dev_groups = versions_groups, 927 }, 928 .probe = scmi_probe, 929 .remove = scmi_remove, 930 }; 931 932 static int __init scmi_driver_init(void) 933 { 934 scmi_bus_init(); 935 936 scmi_clock_register(); 937 scmi_perf_register(); 938 scmi_power_register(); 939 scmi_reset_register(); 940 scmi_sensors_register(); 941 scmi_system_register(); 942 943 return platform_driver_register(&scmi_driver); 944 } 945 subsys_initcall(scmi_driver_init); 946 947 static void __exit scmi_driver_exit(void) 948 { 949 scmi_bus_exit(); 950 951 scmi_clock_unregister(); 952 scmi_perf_unregister(); 953 scmi_power_unregister(); 954 scmi_reset_unregister(); 955 scmi_sensors_unregister(); 956 scmi_system_unregister(); 957 958 platform_driver_unregister(&scmi_driver); 959 } 960 module_exit(scmi_driver_exit); 961 962 MODULE_ALIAS("platform: arm-scmi"); 963 MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>"); 964 MODULE_DESCRIPTION("ARM SCMI protocol driver"); 965 MODULE_LICENSE("GPL v2"); 966