1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2011-2017, The Linux Foundation 4 */ 5 6 #include <linux/slab.h> 7 #include <linux/pm_runtime.h> 8 #include "slimbus.h" 9 10 /** 11 * slim_msg_response() - Deliver Message response received from a device to the 12 * framework. 13 * 14 * @ctrl: Controller handle 15 * @reply: Reply received from the device 16 * @len: Length of the reply 17 * @tid: Transaction ID received with which framework can associate reply. 18 * 19 * Called by controller to inform framework about the response received. 20 * This helps in making the API asynchronous, and controller-driver doesn't need 21 * to manage 1 more table other than the one managed by framework mapping TID 22 * with buffers 23 */ 24 void slim_msg_response(struct slim_controller *ctrl, u8 *reply, u8 tid, u8 len) 25 { 26 struct slim_msg_txn *txn; 27 struct slim_val_inf *msg; 28 unsigned long flags; 29 30 spin_lock_irqsave(&ctrl->txn_lock, flags); 31 txn = idr_find(&ctrl->tid_idr, tid); 32 spin_unlock_irqrestore(&ctrl->txn_lock, flags); 33 34 if (txn == NULL) 35 return; 36 37 msg = txn->msg; 38 if (msg == NULL || msg->rbuf == NULL) { 39 dev_err(ctrl->dev, "Got response to invalid TID:%d, len:%d\n", 40 tid, len); 41 return; 42 } 43 44 slim_free_txn_tid(ctrl, txn); 45 memcpy(msg->rbuf, reply, len); 46 if (txn->comp) 47 complete(txn->comp); 48 49 /* Remove runtime-pm vote now that response was received for TID txn */ 50 pm_runtime_mark_last_busy(ctrl->dev); 51 pm_runtime_put_autosuspend(ctrl->dev); 52 } 53 EXPORT_SYMBOL_GPL(slim_msg_response); 54 55 /** 56 * slim_alloc_txn_tid() - Allocate a tid to txn 57 * 58 * @ctrl: Controller handle 59 * @txn: transaction to be allocated with tid. 60 * 61 * Return: zero on success with valid txn->tid and error code on failures. 62 */ 63 int slim_alloc_txn_tid(struct slim_controller *ctrl, struct slim_msg_txn *txn) 64 { 65 unsigned long flags; 66 int ret = 0; 67 68 spin_lock_irqsave(&ctrl->txn_lock, flags); 69 ret = idr_alloc_cyclic(&ctrl->tid_idr, txn, 1, 70 SLIM_MAX_TIDS, GFP_ATOMIC); 71 if (ret < 0) { 72 spin_unlock_irqrestore(&ctrl->txn_lock, flags); 73 return ret; 74 } 75 txn->tid = ret; 76 spin_unlock_irqrestore(&ctrl->txn_lock, flags); 77 return 0; 78 } 79 EXPORT_SYMBOL_GPL(slim_alloc_txn_tid); 80 81 /** 82 * slim_free_txn_tid() - Free tid of txn 83 * 84 * @ctrl: Controller handle 85 * @txn: transaction whose tid should be freed 86 */ 87 void slim_free_txn_tid(struct slim_controller *ctrl, struct slim_msg_txn *txn) 88 { 89 unsigned long flags; 90 91 spin_lock_irqsave(&ctrl->txn_lock, flags); 92 idr_remove(&ctrl->tid_idr, txn->tid); 93 spin_unlock_irqrestore(&ctrl->txn_lock, flags); 94 } 95 EXPORT_SYMBOL_GPL(slim_free_txn_tid); 96 97 /** 98 * slim_do_transfer() - Process a SLIMbus-messaging transaction 99 * 100 * @ctrl: Controller handle 101 * @txn: Transaction to be sent over SLIMbus 102 * 103 * Called by controller to transmit messaging transactions not dealing with 104 * Interface/Value elements. (e.g. transmitting a message to assign logical 105 * address to a slave device 106 * 107 * Return: -ETIMEDOUT: If transmission of this message timed out 108 * (e.g. due to bus lines not being clocked or driven by controller) 109 */ 110 int slim_do_transfer(struct slim_controller *ctrl, struct slim_msg_txn *txn) 111 { 112 DECLARE_COMPLETION_ONSTACK(done); 113 bool need_tid = false, clk_pause_msg = false; 114 int ret, timeout; 115 116 /* 117 * do not vote for runtime-PM if the transactions are part of clock 118 * pause sequence 119 */ 120 if (ctrl->sched.clk_state == SLIM_CLK_ENTERING_PAUSE && 121 (txn->mt == SLIM_MSG_MT_CORE && 122 txn->mc >= SLIM_MSG_MC_BEGIN_RECONFIGURATION && 123 txn->mc <= SLIM_MSG_MC_RECONFIGURE_NOW)) 124 clk_pause_msg = true; 125 126 if (!clk_pause_msg) { 127 ret = pm_runtime_get_sync(ctrl->dev); 128 if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) { 129 dev_err(ctrl->dev, "ctrl wrong state:%d, ret:%d\n", 130 ctrl->sched.clk_state, ret); 131 goto slim_xfer_err; 132 } 133 } 134 /* Initialize tid to invalid value */ 135 txn->tid = 0; 136 need_tid = slim_tid_txn(txn->mt, txn->mc); 137 138 if (need_tid) { 139 ret = slim_alloc_txn_tid(ctrl, txn); 140 if (ret) 141 return ret; 142 143 if (!txn->msg->comp) 144 txn->comp = &done; 145 else 146 txn->comp = txn->comp; 147 } 148 149 ret = ctrl->xfer_msg(ctrl, txn); 150 151 if (!ret && need_tid && !txn->msg->comp) { 152 unsigned long ms = txn->rl + HZ; 153 154 timeout = wait_for_completion_timeout(txn->comp, 155 msecs_to_jiffies(ms)); 156 if (!timeout) { 157 ret = -ETIMEDOUT; 158 slim_free_txn_tid(ctrl, txn); 159 } 160 } 161 162 if (ret) 163 dev_err(ctrl->dev, "Tx:MT:0x%x, MC:0x%x, LA:0x%x failed:%d\n", 164 txn->mt, txn->mc, txn->la, ret); 165 166 slim_xfer_err: 167 if (!clk_pause_msg && (txn->tid == 0 || ret == -ETIMEDOUT)) { 168 /* 169 * remove runtime-pm vote if this was TX only, or 170 * if there was error during this transaction 171 */ 172 pm_runtime_mark_last_busy(ctrl->dev); 173 pm_runtime_put_autosuspend(ctrl->dev); 174 } 175 return ret; 176 } 177 EXPORT_SYMBOL_GPL(slim_do_transfer); 178 179 static int slim_val_inf_sanity(struct slim_controller *ctrl, 180 struct slim_val_inf *msg, u8 mc) 181 { 182 if (!msg || msg->num_bytes > 16 || 183 (msg->start_offset + msg->num_bytes) > 0xC00) 184 goto reterr; 185 switch (mc) { 186 case SLIM_MSG_MC_REQUEST_VALUE: 187 case SLIM_MSG_MC_REQUEST_INFORMATION: 188 if (msg->rbuf != NULL) 189 return 0; 190 break; 191 192 case SLIM_MSG_MC_CHANGE_VALUE: 193 case SLIM_MSG_MC_CLEAR_INFORMATION: 194 if (msg->wbuf != NULL) 195 return 0; 196 break; 197 198 case SLIM_MSG_MC_REQUEST_CHANGE_VALUE: 199 case SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION: 200 if (msg->rbuf != NULL && msg->wbuf != NULL) 201 return 0; 202 break; 203 } 204 reterr: 205 if (msg) 206 dev_err(ctrl->dev, "Sanity check failed:msg:offset:0x%x, mc:%d\n", 207 msg->start_offset, mc); 208 return -EINVAL; 209 } 210 211 static u16 slim_slicesize(int code) 212 { 213 static const u8 sizetocode[16] = { 214 0, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7 215 }; 216 217 code = clamp(code, 1, (int)ARRAY_SIZE(sizetocode)); 218 219 return sizetocode[code - 1]; 220 } 221 222 /** 223 * slim_xfer_msg() - Transfer a value info message on slim device 224 * 225 * @sbdev: slim device to which this msg has to be transfered 226 * @msg: value info message pointer 227 * @mc: message code of the message 228 * 229 * Called by drivers which want to transfer a vlaue or info elements. 230 * 231 * Return: -ETIMEDOUT: If transmission of this message timed out 232 */ 233 int slim_xfer_msg(struct slim_device *sbdev, struct slim_val_inf *msg, 234 u8 mc) 235 { 236 DEFINE_SLIM_LDEST_TXN(txn_stack, mc, 6, sbdev->laddr, msg); 237 struct slim_msg_txn *txn = &txn_stack; 238 struct slim_controller *ctrl = sbdev->ctrl; 239 int ret; 240 u16 sl; 241 242 if (!ctrl) 243 return -EINVAL; 244 245 ret = slim_val_inf_sanity(ctrl, msg, mc); 246 if (ret) 247 return ret; 248 249 sl = slim_slicesize(msg->num_bytes); 250 251 dev_dbg(ctrl->dev, "SB xfer msg:os:%x, len:%d, MC:%x, sl:%x\n", 252 msg->start_offset, msg->num_bytes, mc, sl); 253 254 txn->ec = ((sl | (1 << 3)) | ((msg->start_offset & 0xFFF) << 4)); 255 256 switch (mc) { 257 case SLIM_MSG_MC_REQUEST_CHANGE_VALUE: 258 case SLIM_MSG_MC_CHANGE_VALUE: 259 case SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION: 260 case SLIM_MSG_MC_CLEAR_INFORMATION: 261 txn->rl += msg->num_bytes; 262 break; 263 default: 264 break; 265 } 266 267 if (slim_tid_txn(txn->mt, txn->mc)) 268 txn->rl++; 269 270 return slim_do_transfer(ctrl, txn); 271 } 272 EXPORT_SYMBOL_GPL(slim_xfer_msg); 273 274 static void slim_fill_msg(struct slim_val_inf *msg, u32 addr, 275 size_t count, u8 *rbuf, u8 *wbuf) 276 { 277 msg->start_offset = addr; 278 msg->num_bytes = count; 279 msg->rbuf = rbuf; 280 msg->wbuf = wbuf; 281 msg->comp = NULL; 282 } 283 284 /** 285 * slim_read() - Read SLIMbus value element 286 * 287 * @sdev: client handle. 288 * @addr: address of value element to read. 289 * @count: number of bytes to read. Maximum bytes allowed are 16. 290 * @val: will return what the value element value was 291 * 292 * Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of 293 * this message timed out (e.g. due to bus lines not being clocked 294 * or driven by controller) 295 */ 296 int slim_read(struct slim_device *sdev, u32 addr, size_t count, u8 *val) 297 { 298 struct slim_val_inf msg; 299 300 slim_fill_msg(&msg, addr, count, val, NULL); 301 302 return slim_xfer_msg(sdev, &msg, SLIM_MSG_MC_REQUEST_VALUE); 303 } 304 EXPORT_SYMBOL_GPL(slim_read); 305 306 /** 307 * slim_readb() - Read byte from SLIMbus value element 308 * 309 * @sdev: client handle. 310 * @addr: address in the value element to read. 311 * 312 * Return: byte value of value element. 313 */ 314 int slim_readb(struct slim_device *sdev, u32 addr) 315 { 316 int ret; 317 u8 buf; 318 319 ret = slim_read(sdev, addr, 1, &buf); 320 if (ret < 0) 321 return ret; 322 else 323 return buf; 324 } 325 EXPORT_SYMBOL_GPL(slim_readb); 326 327 /** 328 * slim_write() - Write SLIMbus value element 329 * 330 * @sdev: client handle. 331 * @addr: address in the value element to write. 332 * @count: number of bytes to write. Maximum bytes allowed are 16. 333 * @val: value to write to value element 334 * 335 * Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of 336 * this message timed out (e.g. due to bus lines not being clocked 337 * or driven by controller) 338 */ 339 int slim_write(struct slim_device *sdev, u32 addr, size_t count, u8 *val) 340 { 341 struct slim_val_inf msg; 342 343 slim_fill_msg(&msg, addr, count, NULL, val); 344 345 return slim_xfer_msg(sdev, &msg, SLIM_MSG_MC_CHANGE_VALUE); 346 } 347 EXPORT_SYMBOL_GPL(slim_write); 348 349 /** 350 * slim_writeb() - Write byte to SLIMbus value element 351 * 352 * @sdev: client handle. 353 * @addr: address of value element to write. 354 * @value: value to write to value element 355 * 356 * Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of 357 * this message timed out (e.g. due to bus lines not being clocked 358 * or driven by controller) 359 * 360 */ 361 int slim_writeb(struct slim_device *sdev, u32 addr, u8 value) 362 { 363 return slim_write(sdev, addr, 1, &value); 364 } 365 EXPORT_SYMBOL_GPL(slim_writeb); 366