drivers/soc/mediatek/mtk-cmdq-helper.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Copyright (c) 2018 MediaTek Inc.
   4
   5 #include <linux/completion.h>
   6 #include <linux/errno.h>
   7 #include <linux/dma-mapping.h>
   8 #include <linux/module.h>
   9 #include <linux/mailbox_controller.h>
  10 #include <linux/soc/mediatek/mtk-cmdq.h>
  11
  12 #define CMDQ_WRITE_ENABLE_MASK  BIT(0)
  13 #define CMDQ_POLL_ENABLE_MASK   BIT(0)
  14 #define CMDQ_EOC_IRQ_EN         BIT(0)
  15 #define CMDQ_REG_TYPE           1
  16 #define CMDQ_JUMP_RELATIVE      0
  17 #define CMDQ_JUMP_ABSOLUTE      1
  18
  19 struct cmdq_instruction {
  20         union {
  21                 u32 value;
  22                 u32 mask;
  23                 struct {
  24                         u16 arg_c;
  25                         u16 src_reg;
  26                 };
  27         };
  28         union {
  29                 u16 offset;
  30                 u16 event;
  31                 u16 reg_dst;
  32         };
  33         union {
  34                 u8 subsys;
  35                 struct {
  36                         u8 sop:5;
  37                         u8 arg_c_t:1;
  38                         u8 src_t:1;
  39                         u8 dst_t:1;
  40                 };
  41         };
  42         u8 op;
  43 };
  44
  45 int cmdq_dev_get_client_reg(struct device *dev,
  46                             struct cmdq_client_reg *client_reg, int idx)
  47 {
  48         struct of_phandle_args spec;
  49         int err;
  50
  51         if (!client_reg)
  52                 return -ENOENT;
  53
  54         err = of_parse_phandle_with_fixed_args(dev->of_node,
  55                                                "mediatek,gce-client-reg",
  56                                                3, idx, &spec);
  57         if (err < 0) {
  58                 dev_err(dev,
  59                         "error %d can't parse gce-client-reg property (%d)",
  60                         err, idx);
  61
  62                 return err;
  63         }
  64
  65         client_reg->subsys = (u8)spec.args[0];
  66         client_reg->offset = (u16)spec.args[1];
  67         client_reg->size = (u16)spec.args[2];
  68         of_node_put(spec.np);
  69
  70         return 0;
  71 }
  72 EXPORT_SYMBOL(cmdq_dev_get_client_reg);
  73
  74 static void cmdq_client_timeout(struct timer_list *t)
  75 {
  76         struct cmdq_client *client = from_timer(client, t, timer);
  77
  78         dev_err(client->client.dev, "cmdq timeout!\n");
  79 }
  80
  81 struct cmdq_client *cmdq_mbox_create(struct device *dev, int index, u32 timeout)
  82 {
  83         struct cmdq_client *client;
  84
  85         client = kzalloc(sizeof(*client), GFP_KERNEL);
  86         if (!client)
  87                 return (struct cmdq_client *)-ENOMEM;
  88
  89         client->timeout_ms = timeout;
  90         if (timeout != CMDQ_NO_TIMEOUT) {
  91                 spin_lock_init(&client->lock);
  92                 timer_setup(&client->timer, cmdq_client_timeout, 0);
  93         }
  94         client->pkt_cnt = 0;
  95         client->client.dev = dev;
  96         client->client.tx_block = false;
  97         client->client.knows_txdone = true;
  98         client->chan = mbox_request_channel(&client->client, index);
  99
 100         if (IS_ERR(client->chan)) {
 101                 long err;
 102
 103                 dev_err(dev, "failed to request channel\n");
 104                 err = PTR_ERR(client->chan);
 105                 kfree(client);
 106
 107                 return ERR_PTR(err);
 108         }
 109
 110         return client;
 111 }
 112 EXPORT_SYMBOL(cmdq_mbox_create);
 113
 114 void cmdq_mbox_destroy(struct cmdq_client *client)
 115 {
 116         if (client->timeout_ms != CMDQ_NO_TIMEOUT) {
 117                 spin_lock(&client->lock);
 118                 del_timer_sync(&client->timer);
 119                 spin_unlock(&client->lock);
 120         }
 121         mbox_free_channel(client->chan);
 122         kfree(client);
 123 }
 124 EXPORT_SYMBOL(cmdq_mbox_destroy);
 125
 126 struct cmdq_pkt *cmdq_pkt_create(struct cmdq_client *client, size_t size)
 127 {
 128         struct cmdq_pkt *pkt;
 129         struct device *dev;
 130         dma_addr_t dma_addr;
 131
 132         pkt = kzalloc(sizeof(*pkt), GFP_KERNEL);
 133         if (!pkt)
 134                 return ERR_PTR(-ENOMEM);
 135         pkt->va_base = kzalloc(size, GFP_KERNEL);
 136         if (!pkt->va_base) {
 137                 kfree(pkt);
 138                 return ERR_PTR(-ENOMEM);
 139         }
 140         pkt->buf_size = size;
 141         pkt->cl = (void *)client;
 142
 143         dev = client->chan->mbox->dev;
 144         dma_addr = dma_map_single(dev, pkt->va_base, pkt->buf_size,
 145                                   DMA_TO_DEVICE);
 146         if (dma_mapping_error(dev, dma_addr)) {
 147                 dev_err(dev, "dma map failed, size=%u\n", (u32)(u64)size);
 148                 kfree(pkt->va_base);
 149                 kfree(pkt);
 150                 return ERR_PTR(-ENOMEM);
 151         }
 152
 153         pkt->pa_base = dma_addr;
 154
 155         return pkt;
 156 }
 157 EXPORT_SYMBOL(cmdq_pkt_create);
 158
 159 void cmdq_pkt_destroy(struct cmdq_pkt *pkt)
 160 {
 161         struct cmdq_client *client = (struct cmdq_client *)pkt->cl;
 162
 163         dma_unmap_single(client->chan->mbox->dev, pkt->pa_base, pkt->buf_size,
 164                          DMA_TO_DEVICE);
 165         kfree(pkt->va_base);
 166         kfree(pkt);
 167 }
 168 EXPORT_SYMBOL(cmdq_pkt_destroy);
 169
 170 static int cmdq_pkt_append_command(struct cmdq_pkt *pkt,
 171                                    struct cmdq_instruction inst)
 172 {
 173         struct cmdq_instruction *cmd_ptr;
 174
 175         if (unlikely(pkt->cmd_buf_size + CMDQ_INST_SIZE > pkt->buf_size)) {
 176                 /*
 177                  * In the case of allocated buffer size (pkt->buf_size) is used
 178                  * up, the real required size (pkt->cmdq_buf_size) is still
 179                  * increased, so that the user knows how much memory should be
 180                  * ultimately allocated after appending all commands and
 181                  * flushing the command packet. Therefor, the user can call
 182                  * cmdq_pkt_create() again with the real required buffer size.
 183                  */
 184                 pkt->cmd_buf_size += CMDQ_INST_SIZE;
 185                 WARN_ONCE(1, "%s: buffer size %u is too small !\n",
 186                         __func__, (u32)pkt->buf_size);
 187                 return -ENOMEM;
 188         }
 189
 190         cmd_ptr = pkt->va_base + pkt->cmd_buf_size;
 191         *cmd_ptr = inst;
 192         pkt->cmd_buf_size += CMDQ_INST_SIZE;
 193
 194         return 0;
 195 }
 196
 197 int cmdq_pkt_write(struct cmdq_pkt *pkt, u8 subsys, u16 offset, u32 value)
 198 {
 199         struct cmdq_instruction inst;
 200
 201         inst.op = CMDQ_CODE_WRITE;
 202         inst.value = value;
 203         inst.offset = offset;
 204         inst.subsys = subsys;
 205
 206         return cmdq_pkt_append_command(pkt, inst);
 207 }
 208 EXPORT_SYMBOL(cmdq_pkt_write);
 209
 210 int cmdq_pkt_write_mask(struct cmdq_pkt *pkt, u8 subsys,
 211                         u16 offset, u32 value, u32 mask)
 212 {
 213         struct cmdq_instruction inst = { {0} };
 214         u16 offset_mask = offset;
 215         int err;
 216
 217         if (mask != 0xffffffff) {
 218                 inst.op = CMDQ_CODE_MASK;
 219                 inst.mask = ~mask;
 220                 err = cmdq_pkt_append_command(pkt, inst);
 221                 if (err < 0)
 222                         return err;
 223
 224                 offset_mask |= CMDQ_WRITE_ENABLE_MASK;
 225         }
 226         err = cmdq_pkt_write(pkt, subsys, offset_mask, value);
 227
 228         return err;
 229 }
 230 EXPORT_SYMBOL(cmdq_pkt_write_mask);
 231
 232 int cmdq_pkt_read_s(struct cmdq_pkt *pkt, u16 high_addr_reg_idx, u16 addr_low,
 233                     u16 reg_idx)
 234 {
 235         struct cmdq_instruction inst = {};
 236
 237         inst.op = CMDQ_CODE_READ_S;
 238         inst.dst_t = CMDQ_REG_TYPE;
 239         inst.sop = high_addr_reg_idx;
 240         inst.reg_dst = reg_idx;
 241         inst.src_reg = addr_low;
 242
 243         return cmdq_pkt_append_command(pkt, inst);
 244 }
 245 EXPORT_SYMBOL(cmdq_pkt_read_s);
 246
 247 int cmdq_pkt_write_s(struct cmdq_pkt *pkt, u16 high_addr_reg_idx,
 248                      u16 addr_low, u16 src_reg_idx)
 249 {
 250         struct cmdq_instruction inst = {};
 251
 252         inst.op = CMDQ_CODE_WRITE_S;
 253         inst.src_t = CMDQ_REG_TYPE;
 254         inst.sop = high_addr_reg_idx;
 255         inst.offset = addr_low;
 256         inst.src_reg = src_reg_idx;
 257
 258         return cmdq_pkt_append_command(pkt, inst);
 259 }
 260 EXPORT_SYMBOL(cmdq_pkt_write_s);
 261
 262 int cmdq_pkt_write_s_mask(struct cmdq_pkt *pkt, u16 high_addr_reg_idx,
 263                           u16 addr_low, u16 src_reg_idx, u32 mask)
 264 {
 265         struct cmdq_instruction inst = {};
 266         int err;
 267
 268         inst.op = CMDQ_CODE_MASK;
 269         inst.mask = ~mask;
 270         err = cmdq_pkt_append_command(pkt, inst);
 271         if (err < 0)
 272                 return err;
 273
 274         inst.mask = 0;
 275         inst.op = CMDQ_CODE_WRITE_S_MASK;
 276         inst.src_t = CMDQ_REG_TYPE;
 277         inst.sop = high_addr_reg_idx;
 278         inst.offset = addr_low;
 279         inst.src_reg = src_reg_idx;
 280
 281         return cmdq_pkt_append_command(pkt, inst);
 282 }
 283 EXPORT_SYMBOL(cmdq_pkt_write_s_mask);
 284
 285 int cmdq_pkt_write_s_value(struct cmdq_pkt *pkt, u8 high_addr_reg_idx,
 286                            u16 addr_low, u32 value)
 287 {
 288         struct cmdq_instruction inst = {};
 289
 290         inst.op = CMDQ_CODE_WRITE_S;
 291         inst.sop = high_addr_reg_idx;
 292         inst.offset = addr_low;
 293         inst.value = value;
 294
 295         return cmdq_pkt_append_command(pkt, inst);
 296 }
 297 EXPORT_SYMBOL(cmdq_pkt_write_s_value);
 298
 299 int cmdq_pkt_write_s_mask_value(struct cmdq_pkt *pkt, u8 high_addr_reg_idx,
 300                                 u16 addr_low, u32 value, u32 mask)
 301 {
 302         struct cmdq_instruction inst = {};
 303         int err;
 304
 305         inst.op = CMDQ_CODE_MASK;
 306         inst.mask = ~mask;
 307         err = cmdq_pkt_append_command(pkt, inst);
 308         if (err < 0)
 309                 return err;
 310
 311         inst.op = CMDQ_CODE_WRITE_S_MASK;
 312         inst.sop = high_addr_reg_idx;
 313         inst.offset = addr_low;
 314         inst.value = value;
 315
 316         return cmdq_pkt_append_command(pkt, inst);
 317 }
 318 EXPORT_SYMBOL(cmdq_pkt_write_s_mask_value);
 319
 320 int cmdq_pkt_wfe(struct cmdq_pkt *pkt, u16 event, bool clear)
 321 {
 322         struct cmdq_instruction inst = { {0} };
 323         u32 clear_option = clear ? CMDQ_WFE_UPDATE : 0;
 324
 325         if (event >= CMDQ_MAX_EVENT)
 326                 return -EINVAL;
 327
 328         inst.op = CMDQ_CODE_WFE;
 329         inst.value = CMDQ_WFE_OPTION | clear_option;
 330         inst.event = event;
 331
 332         return cmdq_pkt_append_command(pkt, inst);
 333 }
 334 EXPORT_SYMBOL(cmdq_pkt_wfe);
 335
 336 int cmdq_pkt_clear_event(struct cmdq_pkt *pkt, u16 event)
 337 {
 338         struct cmdq_instruction inst = { {0} };
 339
 340         if (event >= CMDQ_MAX_EVENT)
 341                 return -EINVAL;
 342
 343         inst.op = CMDQ_CODE_WFE;
 344         inst.value = CMDQ_WFE_UPDATE;
 345         inst.event = event;
 346
 347         return cmdq_pkt_append_command(pkt, inst);
 348 }
 349 EXPORT_SYMBOL(cmdq_pkt_clear_event);
 350
 351 int cmdq_pkt_set_event(struct cmdq_pkt *pkt, u16 event)
 352 {
 353         struct cmdq_instruction inst = {};
 354
 355         if (event >= CMDQ_MAX_EVENT)
 356                 return -EINVAL;
 357
 358         inst.op = CMDQ_CODE_WFE;
 359         inst.value = CMDQ_WFE_UPDATE | CMDQ_WFE_UPDATE_VALUE;
 360         inst.event = event;
 361
 362         return cmdq_pkt_append_command(pkt, inst);
 363 }
 364 EXPORT_SYMBOL(cmdq_pkt_set_event);
 365
 366 int cmdq_pkt_poll(struct cmdq_pkt *pkt, u8 subsys,
 367                   u16 offset, u32 value)
 368 {
 369         struct cmdq_instruction inst = { {0} };
 370         int err;
 371
 372         inst.op = CMDQ_CODE_POLL;
 373         inst.value = value;
 374         inst.offset = offset;
 375         inst.subsys = subsys;
 376         err = cmdq_pkt_append_command(pkt, inst);
 377
 378         return err;
 379 }
 380 EXPORT_SYMBOL(cmdq_pkt_poll);
 381
 382 int cmdq_pkt_poll_mask(struct cmdq_pkt *pkt, u8 subsys,
 383                        u16 offset, u32 value, u32 mask)
 384 {
 385         struct cmdq_instruction inst = { {0} };
 386         int err;
 387
 388         inst.op = CMDQ_CODE_MASK;
 389         inst.mask = ~mask;
 390         err = cmdq_pkt_append_command(pkt, inst);
 391         if (err < 0)
 392                 return err;
 393
 394         offset = offset | CMDQ_POLL_ENABLE_MASK;
 395         err = cmdq_pkt_poll(pkt, subsys, offset, value);
 396
 397         return err;
 398 }
 399 EXPORT_SYMBOL(cmdq_pkt_poll_mask);
 400
 401 int cmdq_pkt_assign(struct cmdq_pkt *pkt, u16 reg_idx, u32 value)
 402 {
 403         struct cmdq_instruction inst = {};
 404
 405         inst.op = CMDQ_CODE_LOGIC;
 406         inst.dst_t = CMDQ_REG_TYPE;
 407         inst.reg_dst = reg_idx;
 408         inst.value = value;
 409         return cmdq_pkt_append_command(pkt, inst);
 410 }
 411 EXPORT_SYMBOL(cmdq_pkt_assign);
 412
 413 int cmdq_pkt_jump(struct cmdq_pkt *pkt, dma_addr_t addr)
 414 {
 415         struct cmdq_instruction inst = {};
 416
 417         inst.op = CMDQ_CODE_JUMP;
 418         inst.offset = CMDQ_JUMP_ABSOLUTE;
 419         inst.value = addr >>
 420                 cmdq_get_shift_pa(((struct cmdq_client *)pkt->cl)->chan);
 421         return cmdq_pkt_append_command(pkt, inst);
 422 }
 423 EXPORT_SYMBOL(cmdq_pkt_jump);
 424
 425 int cmdq_pkt_finalize(struct cmdq_pkt *pkt)
 426 {
 427         struct cmdq_instruction inst = { {0} };
 428         int err;
 429
 430         /* insert EOC and generate IRQ for each command iteration */
 431         inst.op = CMDQ_CODE_EOC;
 432         inst.value = CMDQ_EOC_IRQ_EN;
 433         err = cmdq_pkt_append_command(pkt, inst);
 434         if (err < 0)
 435                 return err;
 436
 437         /* JUMP to end */
 438         inst.op = CMDQ_CODE_JUMP;
 439         inst.value = CMDQ_JUMP_PASS >>
 440                 cmdq_get_shift_pa(((struct cmdq_client *)pkt->cl)->chan);
 441         err = cmdq_pkt_append_command(pkt, inst);
 442
 443         return err;
 444 }
 445 EXPORT_SYMBOL(cmdq_pkt_finalize);
 446
 447 static void cmdq_pkt_flush_async_cb(struct cmdq_cb_data data)
 448 {
 449         struct cmdq_pkt *pkt = (struct cmdq_pkt *)data.data;
 450         struct cmdq_task_cb *cb = &pkt->cb;
 451         struct cmdq_client *client = (struct cmdq_client *)pkt->cl;
 452
 453         if (client->timeout_ms != CMDQ_NO_TIMEOUT) {
 454                 unsigned long flags = 0;
 455
 456                 spin_lock_irqsave(&client->lock, flags);
 457                 if (--client->pkt_cnt == 0)
 458                         del_timer(&client->timer);
 459                 else
 460                         mod_timer(&client->timer, jiffies +
 461                                   msecs_to_jiffies(client->timeout_ms));
 462                 spin_unlock_irqrestore(&client->lock, flags);
 463         }
 464
 465         dma_sync_single_for_cpu(client->chan->mbox->dev, pkt->pa_base,
 466                                 pkt->cmd_buf_size, DMA_TO_DEVICE);
 467         if (cb->cb) {
 468                 data.data = cb->data;
 469                 cb->cb(data);
 470         }
 471 }
 472
 473 int cmdq_pkt_flush_async(struct cmdq_pkt *pkt, cmdq_async_flush_cb cb,
 474                          void *data)
 475 {
 476         int err;
 477         unsigned long flags = 0;
 478         struct cmdq_client *client = (struct cmdq_client *)pkt->cl;
 479
 480         pkt->cb.cb = cb;
 481         pkt->cb.data = data;
 482         pkt->async_cb.cb = cmdq_pkt_flush_async_cb;
 483         pkt->async_cb.data = pkt;
 484
 485         dma_sync_single_for_device(client->chan->mbox->dev, pkt->pa_base,
 486                                    pkt->cmd_buf_size, DMA_TO_DEVICE);
 487
 488         if (client->timeout_ms != CMDQ_NO_TIMEOUT) {
 489                 spin_lock_irqsave(&client->lock, flags);
 490                 if (client->pkt_cnt++ == 0)
 491                         mod_timer(&client->timer, jiffies +
 492                                   msecs_to_jiffies(client->timeout_ms));
 493                 spin_unlock_irqrestore(&client->lock, flags);
 494         }
 495
 496         err = mbox_send_message(client->chan, pkt);
 497         if (err < 0)
 498                 return err;
 499         /* We can send next packet immediately, so just call txdone. */
 500         mbox_client_txdone(client->chan, 0);
 501
 502         return 0;
 503 }
 504 EXPORT_SYMBOL(cmdq_pkt_flush_async);
 505
 506 struct cmdq_flush_completion {
 507         struct completion cmplt;
 508         bool err;
 509 };
 510
 511 static void cmdq_pkt_flush_cb(struct cmdq_cb_data data)
 512 {
 513         struct cmdq_flush_completion *cmplt;
 514
 515         cmplt = (struct cmdq_flush_completion *)data.data;
 516         if (data.sta != CMDQ_CB_NORMAL)
 517                 cmplt->err = true;
 518         else
 519                 cmplt->err = false;
 520         complete(&cmplt->cmplt);
 521 }
 522
 523 int cmdq_pkt_flush(struct cmdq_pkt *pkt)
 524 {
 525         struct cmdq_flush_completion cmplt;
 526         int err;
 527
 528         init_completion(&cmplt.cmplt);
 529         err = cmdq_pkt_flush_async(pkt, cmdq_pkt_flush_cb, &cmplt);
 530         if (err < 0)
 531                 return err;
 532         wait_for_completion(&cmplt.cmplt);
 533
 534         return cmplt.err ? -EFAULT : 0;
 535 }
 536 EXPORT_SYMBOL(cmdq_pkt_flush);
 537
 538 MODULE_LICENSE("GPL v2");