common/tisci/tisci_clock.c

   1 /*
   2  * TISCI clock ops library
   3  *
   4  * Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
   5  *      Lokesh Vutla <lokeshvutla@ti.com>
   6  *
   7  *  Redistribution and use in source and binary forms, with or without
   8  *  modification, are permitted provided that the following conditions
   9  *  are met:
  10  *
  11  *    Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  *    Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  *    Neither the name of Texas Instruments Incorporated nor the names of
  20  *    its contributors may be used to endorse or promote products derived
  21  *    from this software without specific prior written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include <string.h>
  37 #include <sec_proxy.h>
  38 #include <tisci_protocol.h>
  39 #include <tisci.h>
  40
  41 static const char clock_state[MAX_CLOCK_HW_STATES + 1][MAX_CLOCK_STATE_LENGTH] = {
  42         [MSG_CLOCK_HW_STATE_NOT_READY] = "CLK_STATE_NOT_READY",
  43         [MSG_CLOCK_HW_STATE_READY] = "CLK_STATE_READY",
  44         [MAX_CLOCK_HW_STATES] = "CLK_STATE_UNKNOWN"
  45 };
  46
  47 static int ti_sci_set_clock_state(uint32_t dev_id, uint32_t clk_id,
  48                                   uint32_t flags, uint8_t state)
  49 {
  50         struct ti_sci_msg_req_set_clock_state *req;
  51         uint8_t buf[SEC_PROXY_MAX_MSG_SIZE];
  52         struct k3_sec_proxy_msg msg;
  53
  54         memset(buf, 0, sizeof(buf));
  55         ti_sci_setup_header((struct ti_sci_msg_hdr *)buf,
  56                             TI_SCI_MSG_SET_CLOCK_STATE, flags);
  57         req = (struct ti_sci_msg_req_set_clock_state *)buf;
  58         req->dev_id = dev_id;
  59         if (clk_id < 255) {
  60                 req->clk_id = clk_id;
  61         } else {
  62                 req->clk_id = 255;
  63                 req->clk_id_32 = clk_id;
  64         }
  65         req->request_state = state;
  66
  67         msg.len = sizeof(*req);
  68         msg.buf = buf;
  69         return ti_sci_xfer_msg(&msg);
  70 }
  71
  72 int ti_sci_cmd_get_clk(uint32_t dev_id, uint32_t clk_id)
  73 {
  74         return ti_sci_set_clock_state(dev_id, clk_id,
  75                                       MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE,
  76                                       MSG_CLOCK_SW_STATE_REQ);
  77 }
  78
  79 int ti_sci_cmd_put_clk(uint32_t dev_id, uint32_t clk_id)
  80 {
  81         return ti_sci_set_clock_state(dev_id, clk_id,
  82                                       MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE,
  83                                       MSG_CLOCK_SW_STATE_UNREQ);
  84 }
  85
  86 const char *ti_sci_cmd_get_clk_state(uint32_t dev_id, uint32_t clk_id)
  87 {
  88         struct ti_sci_msg_resp_get_clock_state *resp;
  89         struct ti_sci_msg_req_get_clock_state *req;
  90         uint8_t buf[SEC_PROXY_MAX_MSG_SIZE];
  91         struct k3_sec_proxy_msg msg;
  92         int ret;
  93
  94         memset(buf, 0, sizeof(buf));
  95         ti_sci_setup_header((struct ti_sci_msg_hdr *)buf,
  96                             TI_SCI_MSG_GET_CLOCK_STATE, 0);
  97         req = (struct ti_sci_msg_req_get_clock_state *)buf;
  98         req->dev_id = dev_id;
  99         if (clk_id < 255) {
 100                 req->clk_id = clk_id;
 101         } else {
 102                 req->clk_id = 255;
 103                 req->clk_id_32 = clk_id;
 104         }
 105
 106         msg.len = sizeof(*req);
 107         msg.buf = buf;
 108         ret = ti_sci_xfer_msg(&msg);
 109         if (ret)
 110                 return NULL;
 111
 112         resp = (struct ti_sci_msg_resp_get_clock_state *)buf;
 113
 114         return clock_state[resp->current_state];
 115 }
 116
 117 int ti_sci_cmd_set_clk_freq(uint32_t dev_id, uint32_t clk_id, uint64_t freq)
 118 {
 119         struct ti_sci_msg_req_set_clock_freq *req;
 120         uint8_t buf[SEC_PROXY_MAX_MSG_SIZE];
 121         struct k3_sec_proxy_msg msg;
 122
 123         memset(buf, 0, sizeof(buf));
 124         ti_sci_setup_header((struct ti_sci_msg_hdr *)buf,
 125                             TI_SCI_MSG_SET_CLOCK_FREQ, 0);
 126         req = (struct ti_sci_msg_req_set_clock_freq *)buf;
 127         req->dev_id = dev_id;
 128         if (clk_id < 255) {
 129                 req->clk_id = clk_id;
 130         } else {
 131                 req->clk_id = 255;
 132                 req->clk_id_32 = clk_id;
 133         }
 134         /* ToDo: Get best match freq and set that freq */
 135         req->min_freq_hz = freq;
 136         req->target_freq_hz = freq;
 137         req->max_freq_hz = freq;
 138
 139         msg.len = sizeof(*req);
 140         msg.buf = buf;
 141         return ti_sci_xfer_msg(&msg);
 142 }
 143
 144 int ti_sci_cmd_get_clk_freq(uint32_t dev_id, uint32_t clk_id, uint64_t *freq)
 145 {
 146         struct ti_sci_msg_resp_get_clock_freq *resp;
 147         struct ti_sci_msg_req_get_clock_freq *req;
 148         uint8_t buf[SEC_PROXY_MAX_MSG_SIZE];
 149         struct k3_sec_proxy_msg msg;
 150         int ret;
 151
 152         memset(buf, 0, sizeof(buf));
 153         ti_sci_setup_header((struct ti_sci_msg_hdr *)buf,
 154                             TI_SCI_MSG_GET_CLOCK_FREQ, 0);
 155         req = (struct ti_sci_msg_req_get_clock_freq *)buf;
 156         req->dev_id = dev_id;
 157         if (clk_id < 255) {
 158                 req->clk_id = clk_id;
 159         } else {
 160                 req->clk_id = 255;
 161                 req->clk_id_32 = clk_id;
 162         }
 163
 164         msg.len = sizeof(*req);
 165         msg.buf = buf;
 166         ret = ti_sci_xfer_msg(&msg);
 167         if (ret)
 168                 return ret;
 169
 170         resp = (struct ti_sci_msg_resp_get_clock_freq *)buf;
 171         *freq = resp->freq_hz;
 172
 173         return 0;
 174 }