Lines Matching defs:drv
142 tcs_reg_addr(const struct rsc_drv *drv, int reg, int tcs_id)
144 return drv->tcs_base + RSC_DRV_TCS_OFFSET * tcs_id + reg;
148 tcs_cmd_addr(const struct rsc_drv *drv, int reg, int tcs_id, int cmd_id)
150 return tcs_reg_addr(drv, reg, tcs_id) + RSC_DRV_CMD_OFFSET * cmd_id;
153 static u32 read_tcs_cmd(const struct rsc_drv *drv, int reg, int tcs_id,
156 return readl_relaxed(tcs_cmd_addr(drv, reg, tcs_id, cmd_id));
159 static u32 read_tcs_reg(const struct rsc_drv *drv, int reg, int tcs_id)
161 return readl_relaxed(tcs_reg_addr(drv, reg, tcs_id));
164 static void write_tcs_cmd(const struct rsc_drv *drv, int reg, int tcs_id,
167 writel_relaxed(data, tcs_cmd_addr(drv, reg, tcs_id, cmd_id));
170 static void write_tcs_reg(const struct rsc_drv *drv, int reg, int tcs_id,
173 writel_relaxed(data, tcs_reg_addr(drv, reg, tcs_id));
176 static void write_tcs_reg_sync(const struct rsc_drv *drv, int reg, int tcs_id,
181 writel(data, tcs_reg_addr(drv, reg, tcs_id));
188 if (readl(tcs_reg_addr(drv, reg, tcs_id)) == data)
192 pr_err("%s: error writing %#x to %d:%#x\n", drv->name,
198 * @drv: The RSC controller.
203 * Context: Must be called with the drv->lock held.
207 static bool tcs_is_free(struct rsc_drv *drv, int tcs_id)
209 return !test_bit(tcs_id, drv->tcs_in_use);
214 * @drv: The RSC controller.
224 static void tcs_invalidate(struct rsc_drv *drv, int type)
227 struct tcs_group *tcs = &drv->tcs[type];
234 write_tcs_reg_sync(drv, RSC_DRV_CMD_ENABLE, m, 0);
235 write_tcs_reg_sync(drv, RSC_DRV_CMD_WAIT_FOR_CMPL, m, 0);
242 * @drv: The RSC controller.
248 void rpmh_rsc_invalidate(struct rsc_drv *drv)
250 tcs_invalidate(drv, SLEEP_TCS);
251 tcs_invalidate(drv, WAKE_TCS);
256 * @drv: The RSC controller.
264 static struct tcs_group *get_tcs_for_msg(struct rsc_drv *drv,
291 tcs = &drv->tcs[type];
293 tcs = &drv->tcs[WAKE_TCS];
300 * @drv: The RSC controller.
314 static const struct tcs_request *get_req_from_tcs(struct rsc_drv *drv,
321 tcs = &drv->tcs[i];
331 * @drv: The controller.
346 static void __tcs_set_trigger(struct rsc_drv *drv, int tcs_id, bool trigger)
355 enable = read_tcs_reg(drv, RSC_DRV_CONTROL, tcs_id);
357 write_tcs_reg_sync(drv, RSC_DRV_CONTROL, tcs_id, enable);
359 write_tcs_reg_sync(drv, RSC_DRV_CONTROL, tcs_id, enable);
364 write_tcs_reg_sync(drv, RSC_DRV_CONTROL, tcs_id, enable);
366 write_tcs_reg_sync(drv, RSC_DRV_CONTROL, tcs_id, enable);
372 * @drv: The controller.
379 static void enable_tcs_irq(struct rsc_drv *drv, int tcs_id, bool enable)
383 data = readl_relaxed(drv->tcs_base + RSC_DRV_IRQ_ENABLE);
388 writel_relaxed(data, drv->tcs_base + RSC_DRV_IRQ_ENABLE);
403 struct rsc_drv *drv = p;
409 irq_status = readl_relaxed(drv->tcs_base + RSC_DRV_IRQ_STATUS);
412 req = get_req_from_tcs(drv, i);
423 sts = read_tcs_cmd(drv, RSC_DRV_CMD_STATUS, i, j);
428 drv->name, cmd->addr, cmd->data);
433 trace_rpmh_tx_done(drv, i, req, err);
440 if (!drv->tcs[ACTIVE_TCS].num_tcs)
441 __tcs_set_trigger(drv, i, false);
444 write_tcs_reg(drv, RSC_DRV_CMD_ENABLE, i, 0);
445 write_tcs_reg(drv, RSC_DRV_CMD_WAIT_FOR_CMPL, i, 0);
446 writel_relaxed(BIT(i), drv->tcs_base + RSC_DRV_IRQ_CLEAR);
447 spin_lock(&drv->lock);
448 clear_bit(i, drv->tcs_in_use);
454 if (!drv->tcs[ACTIVE_TCS].num_tcs)
455 enable_tcs_irq(drv, i, false);
456 spin_unlock(&drv->lock);
457 wake_up(&drv->tcs_wait);
467 * @drv: The controller.
475 static void __tcs_buffer_write(struct rsc_drv *drv, int tcs_id, int cmd_id,
488 cmd_complete = read_tcs_reg(drv, RSC_DRV_CMD_WAIT_FOR_CMPL, tcs_id);
497 write_tcs_cmd(drv, RSC_DRV_CMD_MSGID, tcs_id, j, msgid);
498 write_tcs_cmd(drv, RSC_DRV_CMD_ADDR, tcs_id, j, cmd->addr);
499 write_tcs_cmd(drv, RSC_DRV_CMD_DATA, tcs_id, j, cmd->data);
500 trace_rpmh_send_msg_rcuidle(drv, tcs_id, j, msgid, cmd);
503 write_tcs_reg(drv, RSC_DRV_CMD_WAIT_FOR_CMPL, tcs_id, cmd_complete);
504 cmd_enable |= read_tcs_reg(drv, RSC_DRV_CMD_ENABLE, tcs_id);
505 write_tcs_reg(drv, RSC_DRV_CMD_ENABLE, tcs_id, cmd_enable);
510 * @drv: The controller.
521 * Must be called with the drv->lock held since that protects tcs_in_use.
528 static int check_for_req_inflight(struct rsc_drv *drv, struct tcs_group *tcs,
537 if (tcs_is_free(drv, tcs_id))
540 curr_enabled = read_tcs_reg(drv, RSC_DRV_CMD_ENABLE, tcs_id);
543 addr = read_tcs_cmd(drv, RSC_DRV_CMD_ADDR, tcs_id, j);
559 * Must be called with the drv->lock held since that protects tcs_in_use.
568 if (tcs_is_free(tcs->drv, tcs->offset + i))
577 * @drv: The controller.
584 * Context: Must be called with the drv->lock held since that protects
590 static int claim_tcs_for_req(struct rsc_drv *drv, struct tcs_group *tcs,
599 ret = check_for_req_inflight(drv, tcs, msg);
608 * @drv: The controller.
628 int rpmh_rsc_send_data(struct rsc_drv *drv, const struct tcs_request *msg)
634 tcs = get_tcs_for_msg(drv, msg);
638 spin_lock_irqsave(&drv->lock, flags);
641 wait_event_lock_irq(drv->tcs_wait,
642 (tcs_id = claim_tcs_for_req(drv, tcs, msg)) >= 0,
643 drv->lock);
646 set_bit(tcs_id, drv->tcs_in_use);
653 write_tcs_reg_sync(drv, RSC_DRV_CMD_ENABLE, tcs_id, 0);
654 write_tcs_reg_sync(drv, RSC_DRV_CMD_WAIT_FOR_CMPL, tcs_id, 0);
655 enable_tcs_irq(drv, tcs_id, true);
657 spin_unlock_irqrestore(&drv->lock, flags);
667 __tcs_buffer_write(drv, tcs_id, 0, msg);
668 __tcs_set_trigger(drv, tcs_id, true);
714 * @drv: The controller.
725 int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg)
731 tcs = get_tcs_for_msg(drv, msg);
738 __tcs_buffer_write(drv, tcs_id, cmd_id, msg);
745 * @drv: The controller
752 * Context: Must be called with the drv->lock held.
758 static bool rpmh_rsc_ctrlr_is_busy(struct rsc_drv *drv)
761 struct tcs_group *tcs = &drv->tcs[ACTIVE_TCS];
770 tcs = &drv->tcs[WAKE_TCS];
773 if (!tcs_is_free(drv, m))
800 struct rsc_drv *drv = container_of(nfb, struct rsc_drv, rsc_pm);
806 cpus_in_pm = atomic_inc_return(&drv->cpus_in_pm);
822 atomic_dec(&drv->cpus_in_pm);
829 * It's likely we're on the last CPU. Grab the drv->lock and write
840 if (spin_trylock(&drv->lock)) {
841 if (rpmh_rsc_ctrlr_is_busy(drv) || rpmh_flush(&drv->client))
843 spin_unlock(&drv->lock);
855 atomic_dec(&drv->cpus_in_pm);
862 struct rsc_drv *drv, void __iomem *base)
876 drv->tcs_base = base + offset;
881 max_tcs &= DRV_NUM_TCS_MASK << (DRV_NUM_TCS_SHIFT * drv->id);
882 max_tcs = max_tcs >> (DRV_NUM_TCS_SHIFT * drv->id);
908 tcs = &drv->tcs[tcs_cfg[i].type];
909 if (tcs->drv)
911 tcs->drv = drv;
928 drv->num_tcs = st;
936 struct rsc_drv *drv;
955 drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
956 if (!drv)
959 ret = of_property_read_u32(dn, "qcom,drv-id", &drv->id);
963 drv->name = of_get_property(dn, "label", NULL);
964 if (!drv->name)
965 drv->name = dev_name(&pdev->dev);
967 snprintf(drv_id, ARRAY_SIZE(drv_id), "drv-%d", drv->id);
973 ret = rpmh_probe_tcs_config(pdev, drv, base);
977 spin_lock_init(&drv->lock);
978 init_waitqueue_head(&drv->tcs_wait);
979 bitmap_zero(drv->tcs_in_use, MAX_TCS_NR);
981 irq = platform_get_irq(pdev, drv->id);
987 drv->name, drv);
1000 drv->rsc_pm.notifier_call = rpmh_rsc_cpu_pm_callback;
1001 cpu_pm_register_notifier(&drv->rsc_pm);
1005 writel_relaxed(drv->tcs[ACTIVE_TCS].mask,
1006 drv->tcs_base + RSC_DRV_IRQ_ENABLE);
1008 spin_lock_init(&drv->client.cache_lock);
1009 INIT_LIST_HEAD(&drv->client.cache);
1010 INIT_LIST_HEAD(&drv->client.batch_cache);
1012 dev_set_drvdata(&pdev->dev, drv);