| /linux-4.4.14/drivers/hwtracing/coresight/ |
| H A D | coresight-etm3x.c | 45 static inline void etm_writel(struct etm_drvdata *drvdata, etm_writel() argument
48 if (drvdata->use_cp14) { etm_writel()
50 dev_err(drvdata->dev, etm_writel()
54 writel_relaxed(val, drvdata->base + off); etm_writel()
58 static inline unsigned int etm_readl(struct etm_drvdata *drvdata, u32 off) etm_readl() argument
62 if (drvdata->use_cp14) { etm_readl()
64 dev_err(drvdata->dev, etm_readl()
68 val = readl_relaxed(drvdata->base + off); etm_readl()
81 struct etm_drvdata *drvdata = (struct etm_drvdata *)info; etm_os_unlock() local
83 etm_writel(drvdata, 0x0, ETMOSLAR); etm_os_unlock()
87 static void etm_set_pwrdwn(struct etm_drvdata *drvdata) etm_set_pwrdwn() argument
94 etmcr = etm_readl(drvdata, ETMCR); etm_set_pwrdwn()
96 etm_writel(drvdata, etmcr, ETMCR); etm_set_pwrdwn()
99 static void etm_clr_pwrdwn(struct etm_drvdata *drvdata) etm_clr_pwrdwn() argument
103 etmcr = etm_readl(drvdata, ETMCR); etm_clr_pwrdwn()
105 etm_writel(drvdata, etmcr, ETMCR); etm_clr_pwrdwn()
111 static void etm_set_pwrup(struct etm_drvdata *drvdata) etm_set_pwrup() argument
115 etmpdcr = readl_relaxed(drvdata->base + ETMPDCR); etm_set_pwrup()
117 writel_relaxed(etmpdcr, drvdata->base + ETMPDCR); etm_set_pwrup()
123 static void etm_clr_pwrup(struct etm_drvdata *drvdata) etm_clr_pwrup() argument
130 etmpdcr = readl_relaxed(drvdata->base + ETMPDCR); etm_clr_pwrup()
132 writel_relaxed(etmpdcr, drvdata->base + ETMPDCR); etm_clr_pwrup()
137 * @drvdata: etm's private data structure.
149 static int coresight_timeout_etm(struct etm_drvdata *drvdata, u32 offset, coresight_timeout_etm() argument
156 val = etm_readl(drvdata, offset); coresight_timeout_etm()
180 static void etm_set_prog(struct etm_drvdata *drvdata) etm_set_prog() argument
184 etmcr = etm_readl(drvdata, ETMCR); etm_set_prog()
186 etm_writel(drvdata, etmcr, ETMCR); etm_set_prog()
192 if (coresight_timeout_etm(drvdata, ETMSR, ETMSR_PROG_BIT, 1)) { etm_set_prog()
193 dev_err(drvdata->dev, etm_set_prog()
199 static void etm_clr_prog(struct etm_drvdata *drvdata) etm_clr_prog() argument
203 etmcr = etm_readl(drvdata, ETMCR); etm_clr_prog()
205 etm_writel(drvdata, etmcr, ETMCR); etm_clr_prog()
211 if (coresight_timeout_etm(drvdata, ETMSR, ETMSR_PROG_BIT, 0)) { etm_clr_prog()
212 dev_err(drvdata->dev, etm_clr_prog()
218 static void etm_set_default(struct etm_drvdata *drvdata) etm_set_default() argument
222 drvdata->trigger_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
223 drvdata->enable_event = ETM_HARD_WIRE_RES_A; etm_set_default()
225 drvdata->seq_12_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
226 drvdata->seq_21_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
227 drvdata->seq_23_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
228 drvdata->seq_31_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
229 drvdata->seq_32_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
230 drvdata->seq_13_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
231 drvdata->timestamp_event = ETM_DEFAULT_EVENT_VAL; etm_set_default()
233 for (i = 0; i < drvdata->nr_cntr; i++) { etm_set_default()
234 drvdata->cntr_rld_val[i] = 0x0; etm_set_default()
235 drvdata->cntr_event[i] = ETM_DEFAULT_EVENT_VAL; etm_set_default()
236 drvdata->cntr_rld_event[i] = ETM_DEFAULT_EVENT_VAL; etm_set_default()
237 drvdata->cntr_val[i] = 0x0; etm_set_default()
240 drvdata->seq_curr_state = 0x0; etm_set_default()
241 drvdata->ctxid_idx = 0x0; etm_set_default()
242 for (i = 0; i < drvdata->nr_ctxid_cmp; i++) { etm_set_default()
243 drvdata->ctxid_pid[i] = 0x0; etm_set_default()
244 drvdata->ctxid_vpid[i] = 0x0; etm_set_default()
247 drvdata->ctxid_mask = 0x0; etm_set_default()
254 struct etm_drvdata *drvdata = info; etm_enable_hw() local
256 CS_UNLOCK(drvdata->base); etm_enable_hw()
259 etm_clr_pwrdwn(drvdata); etm_enable_hw()
261 etm_set_pwrup(drvdata); etm_enable_hw()
263 etm_os_unlock(drvdata); etm_enable_hw()
265 etm_set_prog(drvdata); etm_enable_hw()
267 etmcr = etm_readl(drvdata, ETMCR); etm_enable_hw()
269 etmcr |= drvdata->port_size; etm_enable_hw()
270 etm_writel(drvdata, drvdata->ctrl | etmcr, ETMCR); etm_enable_hw()
271 etm_writel(drvdata, drvdata->trigger_event, ETMTRIGGER); etm_enable_hw()
272 etm_writel(drvdata, drvdata->startstop_ctrl, ETMTSSCR); etm_enable_hw()
273 etm_writel(drvdata, drvdata->enable_event, ETMTEEVR); etm_enable_hw()
274 etm_writel(drvdata, drvdata->enable_ctrl1, ETMTECR1); etm_enable_hw()
275 etm_writel(drvdata, drvdata->fifofull_level, ETMFFLR); etm_enable_hw()
276 for (i = 0; i < drvdata->nr_addr_cmp; i++) { etm_enable_hw()
277 etm_writel(drvdata, drvdata->addr_val[i], ETMACVRn(i)); etm_enable_hw()
278 etm_writel(drvdata, drvdata->addr_acctype[i], ETMACTRn(i)); etm_enable_hw()
280 for (i = 0; i < drvdata->nr_cntr; i++) { etm_enable_hw()
281 etm_writel(drvdata, drvdata->cntr_rld_val[i], ETMCNTRLDVRn(i)); etm_enable_hw()
282 etm_writel(drvdata, drvdata->cntr_event[i], ETMCNTENRn(i)); etm_enable_hw()
283 etm_writel(drvdata, drvdata->cntr_rld_event[i], etm_enable_hw()
285 etm_writel(drvdata, drvdata->cntr_val[i], ETMCNTVRn(i)); etm_enable_hw()
287 etm_writel(drvdata, drvdata->seq_12_event, ETMSQ12EVR); etm_enable_hw()
288 etm_writel(drvdata, drvdata->seq_21_event, ETMSQ21EVR); etm_enable_hw()
289 etm_writel(drvdata, drvdata->seq_23_event, ETMSQ23EVR); etm_enable_hw()
290 etm_writel(drvdata, drvdata->seq_31_event, ETMSQ31EVR); etm_enable_hw()
291 etm_writel(drvdata, drvdata->seq_32_event, ETMSQ32EVR); etm_enable_hw()
292 etm_writel(drvdata, drvdata->seq_13_event, ETMSQ13EVR); etm_enable_hw()
293 etm_writel(drvdata, drvdata->seq_curr_state, ETMSQR); etm_enable_hw()
294 for (i = 0; i < drvdata->nr_ext_out; i++) etm_enable_hw()
295 etm_writel(drvdata, ETM_DEFAULT_EVENT_VAL, ETMEXTOUTEVRn(i)); etm_enable_hw()
296 for (i = 0; i < drvdata->nr_ctxid_cmp; i++) etm_enable_hw()
297 etm_writel(drvdata, drvdata->ctxid_pid[i], ETMCIDCVRn(i)); etm_enable_hw()
298 etm_writel(drvdata, drvdata->ctxid_mask, ETMCIDCMR); etm_enable_hw()
299 etm_writel(drvdata, drvdata->sync_freq, ETMSYNCFR); etm_enable_hw()
301 etm_writel(drvdata, 0x0, ETMEXTINSELR); etm_enable_hw()
302 etm_writel(drvdata, drvdata->timestamp_event, ETMTSEVR); etm_enable_hw()
304 etm_writel(drvdata, 0x0, ETMAUXCR); etm_enable_hw()
305 etm_writel(drvdata, drvdata->traceid, ETMTRACEIDR); etm_enable_hw()
307 etm_writel(drvdata, 0x0, ETMVMIDCVR); etm_enable_hw()
310 etm_writel(drvdata, drvdata->ctrl | ETMCR_ETM_EN | etmcr, ETMCR); etm_enable_hw()
312 etm_clr_prog(drvdata); etm_enable_hw()
313 CS_LOCK(drvdata->base); etm_enable_hw()
315 dev_dbg(drvdata->dev, "cpu: %d enable smp call done\n", drvdata->cpu); etm_enable_hw()
320 struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etm_trace_id() local
324 if (!drvdata->enable) etm_trace_id()
325 return drvdata->traceid; etm_trace_id()
328 spin_lock_irqsave(&drvdata->spinlock, flags); etm_trace_id()
330 CS_UNLOCK(drvdata->base); etm_trace_id()
331 trace_id = (etm_readl(drvdata, ETMTRACEIDR) & ETM_TRACEID_MASK); etm_trace_id()
332 CS_LOCK(drvdata->base); etm_trace_id()
334 spin_unlock_irqrestore(&drvdata->spinlock, flags); etm_trace_id()
342 struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etm_enable() local
346 spin_lock(&drvdata->spinlock); etm_enable()
353 if (cpu_online(drvdata->cpu)) { etm_enable()
354 ret = smp_call_function_single(drvdata->cpu, etm_enable()
355 etm_enable_hw, drvdata, 1); etm_enable()
360 drvdata->enable = true; etm_enable()
361 drvdata->sticky_enable = true; etm_enable()
363 spin_unlock(&drvdata->spinlock); etm_enable()
365 dev_info(drvdata->dev, "ETM tracing enabled\n"); etm_enable()
368 spin_unlock(&drvdata->spinlock); etm_enable()
376 struct etm_drvdata *drvdata = info; etm_disable_hw() local
378 CS_UNLOCK(drvdata->base); etm_disable_hw()
379 etm_set_prog(drvdata); etm_disable_hw()
382 etm_writel(drvdata, ETM_HARD_WIRE_RES_A | ETM_EVENT_NOT_A, ETMTEEVR); etm_disable_hw()
385 drvdata->seq_curr_state = (etm_readl(drvdata, ETMSQR) & ETM_SQR_MASK); etm_disable_hw()
387 for (i = 0; i < drvdata->nr_cntr; i++) etm_disable_hw()
388 drvdata->cntr_val[i] = etm_readl(drvdata, ETMCNTVRn(i)); etm_disable_hw()
390 etm_set_pwrdwn(drvdata); etm_disable_hw()
391 CS_LOCK(drvdata->base); etm_disable_hw()
393 dev_dbg(drvdata->dev, "cpu: %d disable smp call done\n", drvdata->cpu); etm_disable_hw()
398 struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etm_disable() local
407 spin_lock(&drvdata->spinlock); etm_disable()
413 smp_call_function_single(drvdata->cpu, etm_disable_hw, drvdata, 1); etm_disable()
414 drvdata->enable = false; etm_disable()
416 spin_unlock(&drvdata->spinlock); etm_disable()
420 dev_info(drvdata->dev, "ETM tracing disabled\n"); etm_disable()
437 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_addr_cmp_show() local
439 val = drvdata->nr_addr_cmp; nr_addr_cmp_show()
447 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_cntr_show() local
449 val = drvdata->nr_cntr; nr_cntr_show()
458 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_ctxid_cmp_show() local
460 val = drvdata->nr_ctxid_cmp; nr_ctxid_cmp_show()
469 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); etmsr_show() local
471 pm_runtime_get_sync(drvdata->dev); etmsr_show()
472 spin_lock_irqsave(&drvdata->spinlock, flags); etmsr_show()
473 CS_UNLOCK(drvdata->base); etmsr_show()
475 val = etm_readl(drvdata, ETMSR); etmsr_show()
477 CS_LOCK(drvdata->base); etmsr_show()
478 spin_unlock_irqrestore(&drvdata->spinlock, flags); etmsr_show()
479 pm_runtime_put(drvdata->dev); etmsr_show()
491 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); reset_store() local
498 spin_lock(&drvdata->spinlock); reset_store()
499 drvdata->mode = ETM_MODE_EXCLUDE; reset_store()
500 drvdata->ctrl = 0x0; reset_store()
501 drvdata->trigger_event = ETM_DEFAULT_EVENT_VAL; reset_store()
502 drvdata->startstop_ctrl = 0x0; reset_store()
503 drvdata->addr_idx = 0x0; reset_store()
504 for (i = 0; i < drvdata->nr_addr_cmp; i++) { reset_store()
505 drvdata->addr_val[i] = 0x0; reset_store()
506 drvdata->addr_acctype[i] = 0x0; reset_store()
507 drvdata->addr_type[i] = ETM_ADDR_TYPE_NONE; reset_store()
509 drvdata->cntr_idx = 0x0; reset_store()
511 etm_set_default(drvdata); reset_store()
512 spin_unlock(&drvdata->spinlock); reset_store()
523 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); mode_show() local
525 val = drvdata->mode; mode_show()
535 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); mode_store() local
541 spin_lock(&drvdata->spinlock); mode_store()
542 drvdata->mode = val & ETM_MODE_ALL; mode_store()
544 if (drvdata->mode & ETM_MODE_EXCLUDE) mode_store()
545 drvdata->enable_ctrl1 |= ETMTECR1_INC_EXC; mode_store()
547 drvdata->enable_ctrl1 &= ~ETMTECR1_INC_EXC; mode_store()
549 if (drvdata->mode & ETM_MODE_CYCACC) mode_store()
550 drvdata->ctrl |= ETMCR_CYC_ACC; mode_store()
552 drvdata->ctrl &= ~ETMCR_CYC_ACC; mode_store()
554 if (drvdata->mode & ETM_MODE_STALL) { mode_store()
555 if (!(drvdata->etmccr & ETMCCR_FIFOFULL)) { mode_store()
556 dev_warn(drvdata->dev, "stall mode not supported\n"); mode_store()
560 drvdata->ctrl |= ETMCR_STALL_MODE; mode_store()
562 drvdata->ctrl &= ~ETMCR_STALL_MODE; mode_store()
564 if (drvdata->mode & ETM_MODE_TIMESTAMP) { mode_store()
565 if (!(drvdata->etmccer & ETMCCER_TIMESTAMP)) { mode_store()
566 dev_warn(drvdata->dev, "timestamp not supported\n"); mode_store()
570 drvdata->ctrl |= ETMCR_TIMESTAMP_EN; mode_store()
572 drvdata->ctrl &= ~ETMCR_TIMESTAMP_EN; mode_store()
574 if (drvdata->mode & ETM_MODE_CTXID) mode_store()
575 drvdata->ctrl |= ETMCR_CTXID_SIZE; mode_store()
577 drvdata->ctrl &= ~ETMCR_CTXID_SIZE; mode_store()
578 spin_unlock(&drvdata->spinlock); mode_store()
583 spin_unlock(&drvdata->spinlock); mode_store()
592 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); trigger_event_show() local
594 val = drvdata->trigger_event; trigger_event_show()
604 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); trigger_event_store() local
610 drvdata->trigger_event = val & ETM_EVENT_MASK; trigger_event_store()
620 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); enable_event_show() local
622 val = drvdata->enable_event; enable_event_show()
632 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); enable_event_store() local
638 drvdata->enable_event = val & ETM_EVENT_MASK; enable_event_store()
648 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); fifofull_level_show() local
650 val = drvdata->fifofull_level; fifofull_level_show()
660 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); fifofull_level_store() local
666 drvdata->fifofull_level = val; fifofull_level_store()
676 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_idx_show() local
678 val = drvdata->addr_idx; addr_idx_show()
688 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_idx_store() local
694 if (val >= drvdata->nr_addr_cmp) addr_idx_store()
701 spin_lock(&drvdata->spinlock); addr_idx_store()
702 drvdata->addr_idx = val; addr_idx_store()
703 spin_unlock(&drvdata->spinlock); addr_idx_store()
714 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_single_show() local
716 spin_lock(&drvdata->spinlock); addr_single_show()
717 idx = drvdata->addr_idx; addr_single_show()
718 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_single_show()
719 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) { addr_single_show()
720 spin_unlock(&drvdata->spinlock); addr_single_show()
724 val = drvdata->addr_val[idx]; addr_single_show()
725 spin_unlock(&drvdata->spinlock); addr_single_show()
737 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_single_store() local
743 spin_lock(&drvdata->spinlock); addr_single_store()
744 idx = drvdata->addr_idx; addr_single_store()
745 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_single_store()
746 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) { addr_single_store()
747 spin_unlock(&drvdata->spinlock); addr_single_store()
751 drvdata->addr_val[idx] = val; addr_single_store()
752 drvdata->addr_type[idx] = ETM_ADDR_TYPE_SINGLE; addr_single_store()
753 spin_unlock(&drvdata->spinlock); addr_single_store()
764 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_range_show() local
766 spin_lock(&drvdata->spinlock); addr_range_show()
767 idx = drvdata->addr_idx; addr_range_show()
769 spin_unlock(&drvdata->spinlock); addr_range_show()
772 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE && addr_range_show()
773 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) || addr_range_show()
774 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE && addr_range_show()
775 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) { addr_range_show()
776 spin_unlock(&drvdata->spinlock); addr_range_show()
780 val1 = drvdata->addr_val[idx]; addr_range_show()
781 val2 = drvdata->addr_val[idx + 1]; addr_range_show()
782 spin_unlock(&drvdata->spinlock); addr_range_show()
793 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_range_store() local
801 spin_lock(&drvdata->spinlock); addr_range_store()
802 idx = drvdata->addr_idx; addr_range_store()
804 spin_unlock(&drvdata->spinlock); addr_range_store()
807 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE && addr_range_store()
808 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) || addr_range_store()
809 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE && addr_range_store()
810 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) { addr_range_store()
811 spin_unlock(&drvdata->spinlock); addr_range_store()
815 drvdata->addr_val[idx] = val1; addr_range_store()
816 drvdata->addr_type[idx] = ETM_ADDR_TYPE_RANGE; addr_range_store()
817 drvdata->addr_val[idx + 1] = val2; addr_range_store()
818 drvdata->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE; addr_range_store()
819 drvdata->enable_ctrl1 |= (1 << (idx/2)); addr_range_store()
820 spin_unlock(&drvdata->spinlock); addr_range_store()
831 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_start_show() local
833 spin_lock(&drvdata->spinlock); addr_start_show()
834 idx = drvdata->addr_idx; addr_start_show()
835 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_start_show()
836 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) { addr_start_show()
837 spin_unlock(&drvdata->spinlock); addr_start_show()
841 val = drvdata->addr_val[idx]; addr_start_show()
842 spin_unlock(&drvdata->spinlock); addr_start_show()
854 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_start_store() local
860 spin_lock(&drvdata->spinlock); addr_start_store()
861 idx = drvdata->addr_idx; addr_start_store()
862 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_start_store()
863 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) { addr_start_store()
864 spin_unlock(&drvdata->spinlock); addr_start_store()
868 drvdata->addr_val[idx] = val; addr_start_store()
869 drvdata->addr_type[idx] = ETM_ADDR_TYPE_START; addr_start_store()
870 drvdata->startstop_ctrl |= (1 << idx); addr_start_store()
871 drvdata->enable_ctrl1 |= BIT(25); addr_start_store()
872 spin_unlock(&drvdata->spinlock); addr_start_store()
883 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_stop_show() local
885 spin_lock(&drvdata->spinlock); addr_stop_show()
886 idx = drvdata->addr_idx; addr_stop_show()
887 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_stop_show()
888 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) { addr_stop_show()
889 spin_unlock(&drvdata->spinlock); addr_stop_show()
893 val = drvdata->addr_val[idx]; addr_stop_show()
894 spin_unlock(&drvdata->spinlock); addr_stop_show()
906 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_stop_store() local
912 spin_lock(&drvdata->spinlock); addr_stop_store()
913 idx = drvdata->addr_idx; addr_stop_store()
914 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_stop_store()
915 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) { addr_stop_store()
916 spin_unlock(&drvdata->spinlock); addr_stop_store()
920 drvdata->addr_val[idx] = val; addr_stop_store()
921 drvdata->addr_type[idx] = ETM_ADDR_TYPE_STOP; addr_stop_store()
922 drvdata->startstop_ctrl |= (1 << (idx + 16)); addr_stop_store()
923 drvdata->enable_ctrl1 |= ETMTECR1_START_STOP; addr_stop_store()
924 spin_unlock(&drvdata->spinlock); addr_stop_store()
934 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_acctype_show() local
936 spin_lock(&drvdata->spinlock); addr_acctype_show()
937 val = drvdata->addr_acctype[drvdata->addr_idx]; addr_acctype_show()
938 spin_unlock(&drvdata->spinlock); addr_acctype_show()
949 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_acctype_store() local
955 spin_lock(&drvdata->spinlock); addr_acctype_store()
956 drvdata->addr_acctype[drvdata->addr_idx] = val; addr_acctype_store()
957 spin_unlock(&drvdata->spinlock); addr_acctype_store()
967 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_idx_show() local
969 val = drvdata->cntr_idx; cntr_idx_show()
979 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_idx_store() local
985 if (val >= drvdata->nr_cntr) cntr_idx_store()
991 spin_lock(&drvdata->spinlock); cntr_idx_store()
992 drvdata->cntr_idx = val; cntr_idx_store()
993 spin_unlock(&drvdata->spinlock); cntr_idx_store()
1003 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_rld_val_show() local
1005 spin_lock(&drvdata->spinlock); cntr_rld_val_show()
1006 val = drvdata->cntr_rld_val[drvdata->cntr_idx]; cntr_rld_val_show()
1007 spin_unlock(&drvdata->spinlock); cntr_rld_val_show()
1018 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_rld_val_store() local
1024 spin_lock(&drvdata->spinlock); cntr_rld_val_store()
1025 drvdata->cntr_rld_val[drvdata->cntr_idx] = val; cntr_rld_val_store()
1026 spin_unlock(&drvdata->spinlock); cntr_rld_val_store()
1036 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_event_show() local
1038 spin_lock(&drvdata->spinlock); cntr_event_show()
1039 val = drvdata->cntr_event[drvdata->cntr_idx]; cntr_event_show()
1040 spin_unlock(&drvdata->spinlock); cntr_event_show()
1051 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_event_store() local
1057 spin_lock(&drvdata->spinlock); cntr_event_store()
1058 drvdata->cntr_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK; cntr_event_store()
1059 spin_unlock(&drvdata->spinlock); cntr_event_store()
1069 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_rld_event_show() local
1071 spin_lock(&drvdata->spinlock); cntr_rld_event_show()
1072 val = drvdata->cntr_rld_event[drvdata->cntr_idx]; cntr_rld_event_show()
1073 spin_unlock(&drvdata->spinlock); cntr_rld_event_show()
1084 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_rld_event_store() local
1090 spin_lock(&drvdata->spinlock); cntr_rld_event_store()
1091 drvdata->cntr_rld_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK; cntr_rld_event_store()
1092 spin_unlock(&drvdata->spinlock); cntr_rld_event_store()
1103 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_val_show() local
1105 if (!drvdata->enable) { cntr_val_show()
1106 spin_lock(&drvdata->spinlock); cntr_val_show()
1107 for (i = 0; i < drvdata->nr_cntr; i++) cntr_val_show()
1109 i, drvdata->cntr_val[i]); cntr_val_show()
1110 spin_unlock(&drvdata->spinlock); cntr_val_show()
1114 for (i = 0; i < drvdata->nr_cntr; i++) { cntr_val_show()
1115 val = etm_readl(drvdata, ETMCNTVRn(i)); cntr_val_show()
1128 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_val_store() local
1134 spin_lock(&drvdata->spinlock); cntr_val_store()
1135 drvdata->cntr_val[drvdata->cntr_idx] = val; cntr_val_store()
1136 spin_unlock(&drvdata->spinlock); cntr_val_store()
1146 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_12_event_show() local
1148 val = drvdata->seq_12_event; seq_12_event_show()
1158 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_12_event_store() local
1164 drvdata->seq_12_event = val & ETM_EVENT_MASK; seq_12_event_store()
1173 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_21_event_show() local
1175 val = drvdata->seq_21_event; seq_21_event_show()
1185 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_21_event_store() local
1191 drvdata->seq_21_event = val & ETM_EVENT_MASK; seq_21_event_store()
1200 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_23_event_show() local
1202 val = drvdata->seq_23_event; seq_23_event_show()
1212 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_23_event_store() local
1218 drvdata->seq_23_event = val & ETM_EVENT_MASK; seq_23_event_store()
1227 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_31_event_show() local
1229 val = drvdata->seq_31_event; seq_31_event_show()
1239 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_31_event_store() local
1245 drvdata->seq_31_event = val & ETM_EVENT_MASK; seq_31_event_store()
1254 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_32_event_show() local
1256 val = drvdata->seq_32_event; seq_32_event_show()
1266 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_32_event_store() local
1272 drvdata->seq_32_event = val & ETM_EVENT_MASK; seq_32_event_store()
1281 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_13_event_show() local
1283 val = drvdata->seq_13_event; seq_13_event_show()
1293 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_13_event_store() local
1299 drvdata->seq_13_event = val & ETM_EVENT_MASK; seq_13_event_store()
1308 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_curr_state_show() local
1310 if (!drvdata->enable) { seq_curr_state_show()
1311 val = drvdata->seq_curr_state; seq_curr_state_show()
1315 pm_runtime_get_sync(drvdata->dev); seq_curr_state_show()
1316 spin_lock_irqsave(&drvdata->spinlock, flags); seq_curr_state_show()
1318 CS_UNLOCK(drvdata->base); seq_curr_state_show()
1319 val = (etm_readl(drvdata, ETMSQR) & ETM_SQR_MASK); seq_curr_state_show()
1320 CS_LOCK(drvdata->base); seq_curr_state_show()
1322 spin_unlock_irqrestore(&drvdata->spinlock, flags); seq_curr_state_show()
1323 pm_runtime_put(drvdata->dev); seq_curr_state_show()
1334 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_curr_state_store() local
1343 drvdata->seq_curr_state = val; seq_curr_state_store()
1353 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_idx_show() local
1355 val = drvdata->ctxid_idx; ctxid_idx_show()
1365 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_idx_store() local
1371 if (val >= drvdata->nr_ctxid_cmp) ctxid_idx_store()
1378 spin_lock(&drvdata->spinlock); ctxid_idx_store()
1379 drvdata->ctxid_idx = val; ctxid_idx_store()
1380 spin_unlock(&drvdata->spinlock); ctxid_idx_store()
1390 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_pid_show() local
1392 spin_lock(&drvdata->spinlock); ctxid_pid_show()
1393 val = drvdata->ctxid_vpid[drvdata->ctxid_idx]; ctxid_pid_show()
1394 spin_unlock(&drvdata->spinlock); ctxid_pid_show()
1405 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_pid_store() local
1413 spin_lock(&drvdata->spinlock); ctxid_pid_store()
1414 drvdata->ctxid_pid[drvdata->ctxid_idx] = pid; ctxid_pid_store()
1415 drvdata->ctxid_vpid[drvdata->ctxid_idx] = vpid; ctxid_pid_store()
1416 spin_unlock(&drvdata->spinlock); ctxid_pid_store()
1426 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_mask_show() local
1428 val = drvdata->ctxid_mask; ctxid_mask_show()
1438 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_mask_store() local
1444 drvdata->ctxid_mask = val; ctxid_mask_store()
1453 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); sync_freq_show() local
1455 val = drvdata->sync_freq; sync_freq_show()
1465 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); sync_freq_store() local
1471 drvdata->sync_freq = val & ETM_SYNC_MASK; sync_freq_store()
1480 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); timestamp_event_show() local
1482 val = drvdata->timestamp_event; timestamp_event_show()
1492 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); timestamp_event_store() local
1498 drvdata->timestamp_event = val & ETM_EVENT_MASK; timestamp_event_store()
1507 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); cpu_show() local
1509 val = drvdata->cpu; cpu_show()
1519 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); traceid_show() local
1521 if (!drvdata->enable) { traceid_show()
1522 val = drvdata->traceid; traceid_show()
1526 pm_runtime_get_sync(drvdata->dev); traceid_show()
1527 spin_lock_irqsave(&drvdata->spinlock, flags); traceid_show()
1528 CS_UNLOCK(drvdata->base); traceid_show()
1530 val = (etm_readl(drvdata, ETMTRACEIDR) & ETM_TRACEID_MASK); traceid_show()
1532 CS_LOCK(drvdata->base); traceid_show()
1533 spin_unlock_irqrestore(&drvdata->spinlock, flags); traceid_show()
1534 pm_runtime_put(drvdata->dev); traceid_show()
1545 struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); traceid_store() local
1551 drvdata->traceid = val & ETM_TRACEID_MASK; traceid_store()
1598 struct etm_drvdata *drvdata = dev_get_drvdata(_dev->parent); \
1600 readl_relaxed(drvdata->base + offset)); \
1708 struct etm_drvdata *drvdata = info; etm_init_arch_data() local
1710 CS_UNLOCK(drvdata->base); etm_init_arch_data()
1713 (void)etm_readl(drvdata, ETMPDSR); etm_init_arch_data()
1715 etm_set_pwrup(drvdata); etm_init_arch_data()
1720 etm_clr_pwrdwn(drvdata); etm_init_arch_data()
1725 etm_set_prog(drvdata); etm_init_arch_data()
1728 etmidr = etm_readl(drvdata, ETMIDR); etm_init_arch_data()
1729 drvdata->arch = BMVAL(etmidr, 4, 11); etm_init_arch_data()
1730 drvdata->port_size = etm_readl(drvdata, ETMCR) & PORT_SIZE_MASK; etm_init_arch_data()
1732 drvdata->etmccer = etm_readl(drvdata, ETMCCER); etm_init_arch_data()
1733 etmccr = etm_readl(drvdata, ETMCCR); etm_init_arch_data()
1734 drvdata->etmccr = etmccr; etm_init_arch_data()
1735 drvdata->nr_addr_cmp = BMVAL(etmccr, 0, 3) * 2; etm_init_arch_data()
1736 drvdata->nr_cntr = BMVAL(etmccr, 13, 15); etm_init_arch_data()
1737 drvdata->nr_ext_inp = BMVAL(etmccr, 17, 19); etm_init_arch_data()
1738 drvdata->nr_ext_out = BMVAL(etmccr, 20, 22); etm_init_arch_data()
1739 drvdata->nr_ctxid_cmp = BMVAL(etmccr, 24, 25); etm_init_arch_data()
1741 etm_set_pwrdwn(drvdata); etm_init_arch_data()
1742 etm_clr_pwrup(drvdata); etm_init_arch_data()
1743 CS_LOCK(drvdata->base); etm_init_arch_data()
1746 static void etm_init_default_data(struct etm_drvdata *drvdata) etm_init_default_data() argument
1767 drvdata->traceid = etm3x_traceid++; etm_init_default_data()
1768 drvdata->ctrl = (ETMCR_CYC_ACC | ETMCR_TIMESTAMP_EN); etm_init_default_data()
1769 drvdata->enable_ctrl1 = ETMTECR1_ADDR_COMP_1; etm_init_default_data()
1770 if (drvdata->nr_addr_cmp >= 2) { etm_init_default_data()
1771 drvdata->addr_val[0] = (u32) _stext; etm_init_default_data()
1772 drvdata->addr_val[1] = (u32) _etext; etm_init_default_data()
1773 drvdata->addr_acctype[0] = flags; etm_init_default_data()
1774 drvdata->addr_acctype[1] = flags; etm_init_default_data()
1775 drvdata->addr_type[0] = ETM_ADDR_TYPE_RANGE; etm_init_default_data()
1776 drvdata->addr_type[1] = ETM_ADDR_TYPE_RANGE; etm_init_default_data()
1779 etm_set_default(drvdata); etm_init_default_data()
1788 struct etm_drvdata *drvdata; etm_probe() local
1797 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); etm_probe()
1798 if (!drvdata) etm_probe()
1807 drvdata->use_cp14 = of_property_read_bool(np, "arm,cp14"); etm_probe()
1810 drvdata->dev = &adev->dev; etm_probe()
1811 dev_set_drvdata(dev, drvdata); etm_probe()
1818 drvdata->base = base; etm_probe()
1820 spin_lock_init(&drvdata->spinlock); etm_probe()
1822 drvdata->atclk = devm_clk_get(&adev->dev, "atclk"); /* optional */ etm_probe()
1823 if (!IS_ERR(drvdata->atclk)) { etm_probe()
1824 ret = clk_prepare_enable(drvdata->atclk); etm_probe()
1829 drvdata->cpu = pdata ? pdata->cpu : 0; etm_probe()
1832 etmdrvdata[drvdata->cpu] = drvdata; etm_probe()
1834 if (!smp_call_function_single(drvdata->cpu, etm_os_unlock, drvdata, 1)) etm_probe()
1835 drvdata->os_unlock = true; etm_probe()
1837 if (smp_call_function_single(drvdata->cpu, etm_probe()
1838 etm_init_arch_data, drvdata, 1)) etm_probe()
1846 if (etm_arch_supported(drvdata->arch) == false) { etm_probe()
1850 etm_init_default_data(drvdata); etm_probe()
1858 drvdata->csdev = coresight_register(desc); etm_probe()
1859 if (IS_ERR(drvdata->csdev)) { etm_probe()
1860 ret = PTR_ERR(drvdata->csdev); etm_probe()
1868 coresight_enable(drvdata->csdev); etm_probe()
1869 drvdata->boot_enable = true; etm_probe()
1882 struct etm_drvdata *drvdata = amba_get_drvdata(adev); etm_remove() local
1884 coresight_unregister(drvdata->csdev); etm_remove()
1894 struct etm_drvdata *drvdata = dev_get_drvdata(dev); etm_runtime_suspend() local
1896 if (drvdata && !IS_ERR(drvdata->atclk)) etm_runtime_suspend()
1897 clk_disable_unprepare(drvdata->atclk); etm_runtime_suspend()
1904 struct etm_drvdata *drvdata = dev_get_drvdata(dev); etm_runtime_resume() local
1906 if (drvdata && !IS_ERR(drvdata->atclk)) etm_runtime_resume()
1907 clk_prepare_enable(drvdata->atclk); etm_runtime_resume()
|
| H A D | coresight-tmc.c | 134 static void tmc_wait_for_ready(struct tmc_drvdata *drvdata) tmc_wait_for_ready() argument
137 if (coresight_timeout(drvdata->base, tmc_wait_for_ready()
139 dev_err(drvdata->dev, tmc_wait_for_ready()
145 static void tmc_flush_and_stop(struct tmc_drvdata *drvdata) tmc_flush_and_stop() argument
149 ffcr = readl_relaxed(drvdata->base + TMC_FFCR); tmc_flush_and_stop()
151 writel_relaxed(ffcr, drvdata->base + TMC_FFCR); tmc_flush_and_stop()
153 writel_relaxed(ffcr, drvdata->base + TMC_FFCR); tmc_flush_and_stop()
155 if (coresight_timeout(drvdata->base, tmc_flush_and_stop()
157 dev_err(drvdata->dev, tmc_flush_and_stop()
162 tmc_wait_for_ready(drvdata); tmc_flush_and_stop()
165 static void tmc_enable_hw(struct tmc_drvdata *drvdata) tmc_enable_hw() argument
167 writel_relaxed(TMC_CTL_CAPT_EN, drvdata->base + TMC_CTL); tmc_enable_hw()
170 static void tmc_disable_hw(struct tmc_drvdata *drvdata) tmc_disable_hw() argument
172 writel_relaxed(0x0, drvdata->base + TMC_CTL); tmc_disable_hw()
175 static void tmc_etb_enable_hw(struct tmc_drvdata *drvdata) tmc_etb_enable_hw() argument
178 memset(drvdata->buf, 0, drvdata->size); tmc_etb_enable_hw()
180 CS_UNLOCK(drvdata->base); tmc_etb_enable_hw()
182 writel_relaxed(TMC_MODE_CIRCULAR_BUFFER, drvdata->base + TMC_MODE); tmc_etb_enable_hw()
186 drvdata->base + TMC_FFCR); tmc_etb_enable_hw()
188 writel_relaxed(drvdata->trigger_cntr, drvdata->base + TMC_TRG); tmc_etb_enable_hw()
189 tmc_enable_hw(drvdata); tmc_etb_enable_hw()
191 CS_LOCK(drvdata->base); tmc_etb_enable_hw()
194 static void tmc_etr_enable_hw(struct tmc_drvdata *drvdata) tmc_etr_enable_hw() argument
199 memset(drvdata->vaddr, 0, drvdata->size); tmc_etr_enable_hw()
201 CS_UNLOCK(drvdata->base); tmc_etr_enable_hw()
203 writel_relaxed(drvdata->size / 4, drvdata->base + TMC_RSZ); tmc_etr_enable_hw()
204 writel_relaxed(TMC_MODE_CIRCULAR_BUFFER, drvdata->base + TMC_MODE); tmc_etr_enable_hw()
206 axictl = readl_relaxed(drvdata->base + TMC_AXICTL); tmc_etr_enable_hw()
208 writel_relaxed(axictl, drvdata->base + TMC_AXICTL); tmc_etr_enable_hw()
210 writel_relaxed(axictl, drvdata->base + TMC_AXICTL); tmc_etr_enable_hw()
214 writel_relaxed(axictl, drvdata->base + TMC_AXICTL); tmc_etr_enable_hw()
216 writel_relaxed(drvdata->paddr, drvdata->base + TMC_DBALO); tmc_etr_enable_hw()
217 writel_relaxed(0x0, drvdata->base + TMC_DBAHI); tmc_etr_enable_hw()
221 drvdata->base + TMC_FFCR); tmc_etr_enable_hw()
222 writel_relaxed(drvdata->trigger_cntr, drvdata->base + TMC_TRG); tmc_etr_enable_hw()
223 tmc_enable_hw(drvdata); tmc_etr_enable_hw()
225 CS_LOCK(drvdata->base); tmc_etr_enable_hw()
228 static void tmc_etf_enable_hw(struct tmc_drvdata *drvdata) tmc_etf_enable_hw() argument
230 CS_UNLOCK(drvdata->base); tmc_etf_enable_hw()
232 writel_relaxed(TMC_MODE_HARDWARE_FIFO, drvdata->base + TMC_MODE); tmc_etf_enable_hw()
234 drvdata->base + TMC_FFCR); tmc_etf_enable_hw()
235 writel_relaxed(0x0, drvdata->base + TMC_BUFWM); tmc_etf_enable_hw()
236 tmc_enable_hw(drvdata); tmc_etf_enable_hw()
238 CS_LOCK(drvdata->base); tmc_etf_enable_hw()
241 static int tmc_enable(struct tmc_drvdata *drvdata, enum tmc_mode mode) tmc_enable() argument
245 pm_runtime_get_sync(drvdata->dev); tmc_enable()
247 spin_lock_irqsave(&drvdata->spinlock, flags); tmc_enable()
248 if (drvdata->reading) { tmc_enable()
249 spin_unlock_irqrestore(&drvdata->spinlock, flags); tmc_enable()
250 pm_runtime_put(drvdata->dev); tmc_enable()
254 if (drvdata->config_type == TMC_CONFIG_TYPE_ETB) { tmc_enable()
255 tmc_etb_enable_hw(drvdata); tmc_enable()
256 } else if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_enable()
257 tmc_etr_enable_hw(drvdata); tmc_enable()
260 tmc_etb_enable_hw(drvdata); tmc_enable()
262 tmc_etf_enable_hw(drvdata); tmc_enable()
264 drvdata->enable = true; tmc_enable()
265 spin_unlock_irqrestore(&drvdata->spinlock, flags); tmc_enable()
267 dev_info(drvdata->dev, "TMC enabled\n"); tmc_enable()
273 struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); tmc_enable_sink() local
275 return tmc_enable(drvdata, TMC_MODE_CIRCULAR_BUFFER); tmc_enable_sink()
281 struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); tmc_enable_link() local
283 return tmc_enable(drvdata, TMC_MODE_HARDWARE_FIFO); tmc_enable_link()
286 static void tmc_etb_dump_hw(struct tmc_drvdata *drvdata) tmc_etb_dump_hw() argument
294 memwidth = BMVAL(readl_relaxed(drvdata->base + CORESIGHT_DEVID), 8, 10); tmc_etb_dump_hw()
304 bufp = drvdata->buf; tmc_etb_dump_hw()
307 read_data = readl_relaxed(drvdata->base + TMC_RRD); tmc_etb_dump_hw()
316 static void tmc_etb_disable_hw(struct tmc_drvdata *drvdata) tmc_etb_disable_hw() argument
318 CS_UNLOCK(drvdata->base); tmc_etb_disable_hw()
320 tmc_flush_and_stop(drvdata); tmc_etb_disable_hw()
321 tmc_etb_dump_hw(drvdata); tmc_etb_disable_hw()
322 tmc_disable_hw(drvdata); tmc_etb_disable_hw()
324 CS_LOCK(drvdata->base); tmc_etb_disable_hw()
327 static void tmc_etr_dump_hw(struct tmc_drvdata *drvdata) tmc_etr_dump_hw() argument
331 rwp = readl_relaxed(drvdata->base + TMC_RWP); tmc_etr_dump_hw()
332 val = readl_relaxed(drvdata->base + TMC_STS); tmc_etr_dump_hw()
336 drvdata->buf = drvdata->vaddr + rwp - drvdata->paddr; tmc_etr_dump_hw()
338 drvdata->buf = drvdata->vaddr; tmc_etr_dump_hw()
341 static void tmc_etr_disable_hw(struct tmc_drvdata *drvdata) tmc_etr_disable_hw() argument
343 CS_UNLOCK(drvdata->base); tmc_etr_disable_hw()
345 tmc_flush_and_stop(drvdata); tmc_etr_disable_hw()
346 tmc_etr_dump_hw(drvdata); tmc_etr_disable_hw()
347 tmc_disable_hw(drvdata); tmc_etr_disable_hw()
349 CS_LOCK(drvdata->base); tmc_etr_disable_hw()
352 static void tmc_etf_disable_hw(struct tmc_drvdata *drvdata) tmc_etf_disable_hw() argument
354 CS_UNLOCK(drvdata->base); tmc_etf_disable_hw()
356 tmc_flush_and_stop(drvdata); tmc_etf_disable_hw()
357 tmc_disable_hw(drvdata); tmc_etf_disable_hw()
359 CS_LOCK(drvdata->base); tmc_etf_disable_hw()
362 static void tmc_disable(struct tmc_drvdata *drvdata, enum tmc_mode mode) tmc_disable() argument
366 spin_lock_irqsave(&drvdata->spinlock, flags); tmc_disable()
367 if (drvdata->reading) tmc_disable()
370 if (drvdata->config_type == TMC_CONFIG_TYPE_ETB) { tmc_disable()
371 tmc_etb_disable_hw(drvdata); tmc_disable()
372 } else if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_disable()
373 tmc_etr_disable_hw(drvdata); tmc_disable()
376 tmc_etb_disable_hw(drvdata); tmc_disable()
378 tmc_etf_disable_hw(drvdata); tmc_disable()
381 drvdata->enable = false; tmc_disable()
382 spin_unlock_irqrestore(&drvdata->spinlock, flags); tmc_disable()
384 pm_runtime_put(drvdata->dev); tmc_disable()
386 dev_info(drvdata->dev, "TMC disabled\n"); tmc_disable()
391 struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); tmc_disable_sink() local
393 tmc_disable(drvdata, TMC_MODE_CIRCULAR_BUFFER); tmc_disable_sink()
399 struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); tmc_disable_link() local
401 tmc_disable(drvdata, TMC_MODE_HARDWARE_FIFO); tmc_disable_link()
427 static int tmc_read_prepare(struct tmc_drvdata *drvdata) tmc_read_prepare() argument
433 spin_lock_irqsave(&drvdata->spinlock, flags); tmc_read_prepare()
434 if (!drvdata->enable) tmc_read_prepare()
437 if (drvdata->config_type == TMC_CONFIG_TYPE_ETB) { tmc_read_prepare()
438 tmc_etb_disable_hw(drvdata); tmc_read_prepare()
439 } else if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_read_prepare()
440 tmc_etr_disable_hw(drvdata); tmc_read_prepare()
442 mode = readl_relaxed(drvdata->base + TMC_MODE); tmc_read_prepare()
444 tmc_etb_disable_hw(drvdata); tmc_read_prepare()
451 drvdata->reading = true; tmc_read_prepare()
452 spin_unlock_irqrestore(&drvdata->spinlock, flags); tmc_read_prepare()
454 dev_info(drvdata->dev, "TMC read start\n"); tmc_read_prepare()
457 spin_unlock_irqrestore(&drvdata->spinlock, flags); tmc_read_prepare()
461 static void tmc_read_unprepare(struct tmc_drvdata *drvdata) tmc_read_unprepare() argument
466 spin_lock_irqsave(&drvdata->spinlock, flags); tmc_read_unprepare()
467 if (!drvdata->enable) tmc_read_unprepare()
470 if (drvdata->config_type == TMC_CONFIG_TYPE_ETB) { tmc_read_unprepare()
471 tmc_etb_enable_hw(drvdata); tmc_read_unprepare()
472 } else if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_read_unprepare()
473 tmc_etr_enable_hw(drvdata); tmc_read_unprepare()
475 mode = readl_relaxed(drvdata->base + TMC_MODE); tmc_read_unprepare()
477 tmc_etb_enable_hw(drvdata); tmc_read_unprepare()
480 drvdata->reading = false; tmc_read_unprepare()
481 spin_unlock_irqrestore(&drvdata->spinlock, flags); tmc_read_unprepare()
483 dev_info(drvdata->dev, "TMC read end\n"); tmc_read_unprepare()
488 struct tmc_drvdata *drvdata = container_of(file->private_data, tmc_open() local
492 if (drvdata->read_count++) tmc_open()
495 ret = tmc_read_prepare(drvdata); tmc_open()
501 dev_dbg(drvdata->dev, "%s: successfully opened\n", __func__); tmc_open()
508 struct tmc_drvdata *drvdata = container_of(file->private_data, tmc_read() local
510 char *bufp = drvdata->buf + *ppos; tmc_read()
512 if (*ppos + len > drvdata->size) tmc_read()
513 len = drvdata->size - *ppos; tmc_read()
515 if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_read()
516 if (bufp == (char *)(drvdata->vaddr + drvdata->size)) tmc_read()
517 bufp = drvdata->vaddr; tmc_read()
518 else if (bufp > (char *)(drvdata->vaddr + drvdata->size)) tmc_read()
519 bufp -= drvdata->size; tmc_read()
520 if ((bufp + len) > (char *)(drvdata->vaddr + drvdata->size)) tmc_read()
521 len = (char *)(drvdata->vaddr + drvdata->size) - bufp; tmc_read()
525 dev_dbg(drvdata->dev, "%s: copy_to_user failed\n", __func__); tmc_read()
531 dev_dbg(drvdata->dev, "%s: %zu bytes copied, %d bytes left\n", tmc_read()
532 __func__, len, (int)(drvdata->size - *ppos)); tmc_read()
538 struct tmc_drvdata *drvdata = container_of(file->private_data, tmc_release() local
541 if (--drvdata->read_count) { tmc_release()
542 if (drvdata->read_count < 0) { tmc_release()
543 dev_err(drvdata->dev, "mismatched close\n"); tmc_release()
544 drvdata->read_count = 0; tmc_release()
549 tmc_read_unprepare(drvdata); tmc_release()
551 dev_dbg(drvdata->dev, "%s: released\n", __func__); tmc_release()
570 struct tmc_drvdata *drvdata = dev_get_drvdata(dev->parent); status_show() local
572 pm_runtime_get_sync(drvdata->dev); status_show()
573 spin_lock_irqsave(&drvdata->spinlock, flags); status_show()
574 CS_UNLOCK(drvdata->base); status_show()
576 tmc_rsz = readl_relaxed(drvdata->base + TMC_RSZ); status_show()
577 tmc_sts = readl_relaxed(drvdata->base + TMC_STS); status_show()
578 tmc_rrp = readl_relaxed(drvdata->base + TMC_RRP); status_show()
579 tmc_rwp = readl_relaxed(drvdata->base + TMC_RWP); status_show()
580 tmc_trg = readl_relaxed(drvdata->base + TMC_TRG); status_show()
581 tmc_ctl = readl_relaxed(drvdata->base + TMC_CTL); status_show()
582 tmc_ffsr = readl_relaxed(drvdata->base + TMC_FFSR); status_show()
583 tmc_ffcr = readl_relaxed(drvdata->base + TMC_FFCR); status_show()
584 tmc_mode = readl_relaxed(drvdata->base + TMC_MODE); status_show()
585 tmc_pscr = readl_relaxed(drvdata->base + TMC_PSCR); status_show()
586 devid = readl_relaxed(drvdata->base + CORESIGHT_DEVID); status_show()
588 CS_LOCK(drvdata->base); status_show()
589 spin_unlock_irqrestore(&drvdata->spinlock, flags); status_show()
590 pm_runtime_put(drvdata->dev); status_show()
614 struct tmc_drvdata *drvdata = dev_get_drvdata(dev->parent); trigger_cntr_show() local
615 unsigned long val = drvdata->trigger_cntr; trigger_cntr_show()
626 struct tmc_drvdata *drvdata = dev_get_drvdata(dev->parent); trigger_cntr_store() local
632 drvdata->trigger_cntr = val; trigger_cntr_store()
665 struct tmc_drvdata *drvdata; tmc_probe() local
677 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); tmc_probe()
678 if (!drvdata) tmc_probe()
681 drvdata->dev = &adev->dev; tmc_probe()
682 dev_set_drvdata(dev, drvdata); tmc_probe()
689 drvdata->base = base; tmc_probe()
691 spin_lock_init(&drvdata->spinlock); tmc_probe()
693 devid = readl_relaxed(drvdata->base + CORESIGHT_DEVID); tmc_probe()
694 drvdata->config_type = BMVAL(devid, 6, 7); tmc_probe()
696 if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_probe()
700 &drvdata->size); tmc_probe()
702 drvdata->size = SZ_1M; tmc_probe()
704 drvdata->size = readl_relaxed(drvdata->base + TMC_RSZ) * 4; tmc_probe()
709 if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_probe()
710 drvdata->vaddr = dma_alloc_coherent(dev, drvdata->size, tmc_probe()
711 &drvdata->paddr, GFP_KERNEL); tmc_probe()
712 if (!drvdata->vaddr) tmc_probe()
715 memset(drvdata->vaddr, 0, drvdata->size); tmc_probe()
716 drvdata->buf = drvdata->vaddr; tmc_probe()
718 drvdata->buf = devm_kzalloc(dev, drvdata->size, GFP_KERNEL); tmc_probe()
719 if (!drvdata->buf) tmc_probe()
733 if (drvdata->config_type == TMC_CONFIG_TYPE_ETB) { tmc_probe()
737 } else if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) { tmc_probe()
748 drvdata->csdev = coresight_register(desc); tmc_probe()
749 if (IS_ERR(drvdata->csdev)) { tmc_probe()
750 ret = PTR_ERR(drvdata->csdev); tmc_probe()
754 drvdata->miscdev.name = pdata->name; tmc_probe()
755 drvdata->miscdev.minor = MISC_DYNAMIC_MINOR; tmc_probe()
756 drvdata->miscdev.fops = &tmc_fops; tmc_probe()
757 ret = misc_register(&drvdata->miscdev); tmc_probe()
765 coresight_unregister(drvdata->csdev); tmc_probe()
767 if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) tmc_probe()
768 dma_free_coherent(dev, drvdata->size, tmc_probe()
769 &drvdata->paddr, GFP_KERNEL); tmc_probe()
775 struct tmc_drvdata *drvdata = amba_get_drvdata(adev); tmc_remove() local
777 misc_deregister(&drvdata->miscdev); tmc_remove()
778 coresight_unregister(drvdata->csdev); tmc_remove()
779 if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) tmc_remove()
780 dma_free_coherent(drvdata->dev, drvdata->size, tmc_remove()
781 &drvdata->paddr, GFP_KERNEL); tmc_remove()
|
| H A D | coresight-etm4x.c | 48 struct etmv4_drvdata *drvdata = (struct etmv4_drvdata *)info; etm4_os_unlock() local
51 writel_relaxed(0x0, drvdata->base + TRCOSLAR); etm4_os_unlock()
68 struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etm4_trace_id() local
72 if (!drvdata->enable) etm4_trace_id()
73 return drvdata->trcid; etm4_trace_id()
75 pm_runtime_get_sync(drvdata->dev); etm4_trace_id()
76 spin_lock_irqsave(&drvdata->spinlock, flags); etm4_trace_id()
78 CS_UNLOCK(drvdata->base); etm4_trace_id()
79 trace_id = readl_relaxed(drvdata->base + TRCTRACEIDR); etm4_trace_id()
81 CS_LOCK(drvdata->base); etm4_trace_id()
83 spin_unlock_irqrestore(&drvdata->spinlock, flags); etm4_trace_id()
84 pm_runtime_put(drvdata->dev); etm4_trace_id()
92 struct etmv4_drvdata *drvdata = info; etm4_enable_hw() local
94 CS_UNLOCK(drvdata->base); etm4_enable_hw()
96 etm4_os_unlock(drvdata); etm4_enable_hw()
99 writel_relaxed(0, drvdata->base + TRCPRGCTLR); etm4_enable_hw()
102 if (coresight_timeout(drvdata->base, TRCSTATR, TRCSTATR_IDLE_BIT, 1)) etm4_enable_hw()
103 dev_err(drvdata->dev, etm4_enable_hw()
107 writel_relaxed(drvdata->pe_sel, drvdata->base + TRCPROCSELR); etm4_enable_hw()
108 writel_relaxed(drvdata->cfg, drvdata->base + TRCCONFIGR); etm4_enable_hw()
110 writel_relaxed(0x0, drvdata->base + TRCAUXCTLR); etm4_enable_hw()
111 writel_relaxed(drvdata->eventctrl0, drvdata->base + TRCEVENTCTL0R); etm4_enable_hw()
112 writel_relaxed(drvdata->eventctrl1, drvdata->base + TRCEVENTCTL1R); etm4_enable_hw()
113 writel_relaxed(drvdata->stall_ctrl, drvdata->base + TRCSTALLCTLR); etm4_enable_hw()
114 writel_relaxed(drvdata->ts_ctrl, drvdata->base + TRCTSCTLR); etm4_enable_hw()
115 writel_relaxed(drvdata->syncfreq, drvdata->base + TRCSYNCPR); etm4_enable_hw()
116 writel_relaxed(drvdata->ccctlr, drvdata->base + TRCCCCTLR); etm4_enable_hw()
117 writel_relaxed(drvdata->bb_ctrl, drvdata->base + TRCBBCTLR); etm4_enable_hw()
118 writel_relaxed(drvdata->trcid, drvdata->base + TRCTRACEIDR); etm4_enable_hw()
119 writel_relaxed(drvdata->vinst_ctrl, drvdata->base + TRCVICTLR); etm4_enable_hw()
120 writel_relaxed(drvdata->viiectlr, drvdata->base + TRCVIIECTLR); etm4_enable_hw()
121 writel_relaxed(drvdata->vissctlr, etm4_enable_hw()
122 drvdata->base + TRCVISSCTLR); etm4_enable_hw()
123 writel_relaxed(drvdata->vipcssctlr, etm4_enable_hw()
124 drvdata->base + TRCVIPCSSCTLR); etm4_enable_hw()
125 for (i = 0; i < drvdata->nrseqstate - 1; i++) etm4_enable_hw()
126 writel_relaxed(drvdata->seq_ctrl[i], etm4_enable_hw()
127 drvdata->base + TRCSEQEVRn(i)); etm4_enable_hw()
128 writel_relaxed(drvdata->seq_rst, drvdata->base + TRCSEQRSTEVR); etm4_enable_hw()
129 writel_relaxed(drvdata->seq_state, drvdata->base + TRCSEQSTR); etm4_enable_hw()
130 writel_relaxed(drvdata->ext_inp, drvdata->base + TRCEXTINSELR); etm4_enable_hw()
131 for (i = 0; i < drvdata->nr_cntr; i++) { etm4_enable_hw()
132 writel_relaxed(drvdata->cntrldvr[i], etm4_enable_hw()
133 drvdata->base + TRCCNTRLDVRn(i)); etm4_enable_hw()
134 writel_relaxed(drvdata->cntr_ctrl[i], etm4_enable_hw()
135 drvdata->base + TRCCNTCTLRn(i)); etm4_enable_hw()
136 writel_relaxed(drvdata->cntr_val[i], etm4_enable_hw()
137 drvdata->base + TRCCNTVRn(i)); etm4_enable_hw()
141 for (i = 2; i < drvdata->nr_resource * 2; i++) etm4_enable_hw()
142 writel_relaxed(drvdata->res_ctrl[i], etm4_enable_hw()
143 drvdata->base + TRCRSCTLRn(i)); etm4_enable_hw()
145 for (i = 0; i < drvdata->nr_ss_cmp; i++) { etm4_enable_hw()
146 writel_relaxed(drvdata->ss_ctrl[i], etm4_enable_hw()
147 drvdata->base + TRCSSCCRn(i)); etm4_enable_hw()
148 writel_relaxed(drvdata->ss_status[i], etm4_enable_hw()
149 drvdata->base + TRCSSCSRn(i)); etm4_enable_hw()
150 writel_relaxed(drvdata->ss_pe_cmp[i], etm4_enable_hw()
151 drvdata->base + TRCSSPCICRn(i)); etm4_enable_hw()
153 for (i = 0; i < drvdata->nr_addr_cmp; i++) { etm4_enable_hw()
154 writeq_relaxed(drvdata->addr_val[i], etm4_enable_hw()
155 drvdata->base + TRCACVRn(i)); etm4_enable_hw()
156 writeq_relaxed(drvdata->addr_acc[i], etm4_enable_hw()
157 drvdata->base + TRCACATRn(i)); etm4_enable_hw()
159 for (i = 0; i < drvdata->numcidc; i++) etm4_enable_hw()
160 writeq_relaxed(drvdata->ctxid_pid[i], etm4_enable_hw()
161 drvdata->base + TRCCIDCVRn(i)); etm4_enable_hw()
162 writel_relaxed(drvdata->ctxid_mask0, drvdata->base + TRCCIDCCTLR0); etm4_enable_hw()
163 writel_relaxed(drvdata->ctxid_mask1, drvdata->base + TRCCIDCCTLR1); etm4_enable_hw()
165 for (i = 0; i < drvdata->numvmidc; i++) etm4_enable_hw()
166 writeq_relaxed(drvdata->vmid_val[i], etm4_enable_hw()
167 drvdata->base + TRCVMIDCVRn(i)); etm4_enable_hw()
168 writel_relaxed(drvdata->vmid_mask0, drvdata->base + TRCVMIDCCTLR0); etm4_enable_hw()
169 writel_relaxed(drvdata->vmid_mask1, drvdata->base + TRCVMIDCCTLR1); etm4_enable_hw()
172 writel_relaxed(1, drvdata->base + TRCPRGCTLR); etm4_enable_hw()
175 if (coresight_timeout(drvdata->base, TRCSTATR, TRCSTATR_IDLE_BIT, 0)) etm4_enable_hw()
176 dev_err(drvdata->dev, etm4_enable_hw()
180 CS_LOCK(drvdata->base); etm4_enable_hw()
182 dev_dbg(drvdata->dev, "cpu: %d enable smp call done\n", drvdata->cpu); etm4_enable_hw()
187 struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etm4_enable() local
190 pm_runtime_get_sync(drvdata->dev); etm4_enable()
191 spin_lock(&drvdata->spinlock); etm4_enable()
197 ret = smp_call_function_single(drvdata->cpu, etm4_enable()
198 etm4_enable_hw, drvdata, 1); etm4_enable()
201 drvdata->enable = true; etm4_enable()
202 drvdata->sticky_enable = true; etm4_enable()
204 spin_unlock(&drvdata->spinlock); etm4_enable()
206 dev_info(drvdata->dev, "ETM tracing enabled\n"); etm4_enable()
209 spin_unlock(&drvdata->spinlock); etm4_enable()
210 pm_runtime_put(drvdata->dev); etm4_enable()
217 struct etmv4_drvdata *drvdata = info; etm4_disable_hw() local
219 CS_UNLOCK(drvdata->base); etm4_disable_hw()
221 control = readl_relaxed(drvdata->base + TRCPRGCTLR); etm4_disable_hw()
229 writel_relaxed(control, drvdata->base + TRCPRGCTLR); etm4_disable_hw()
231 CS_LOCK(drvdata->base); etm4_disable_hw()
233 dev_dbg(drvdata->dev, "cpu: %d disable smp call done\n", drvdata->cpu); etm4_disable_hw()
238 struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etm4_disable() local
247 spin_lock(&drvdata->spinlock); etm4_disable()
253 smp_call_function_single(drvdata->cpu, etm4_disable_hw, drvdata, 1); etm4_disable()
254 drvdata->enable = false; etm4_disable()
256 spin_unlock(&drvdata->spinlock); etm4_disable()
259 pm_runtime_put(drvdata->dev); etm4_disable()
261 dev_info(drvdata->dev, "ETM tracing disabled\n"); etm4_disable()
274 static int etm4_set_mode_exclude(struct etmv4_drvdata *drvdata, bool exclude) etm4_set_mode_exclude() argument
276 u8 idx = drvdata->addr_idx; etm4_set_mode_exclude()
282 if (BMVAL(drvdata->addr_acc[idx], 0, 1) == ETM_INSTR_ADDR) { etm4_set_mode_exclude()
291 if (drvdata->addr_type[idx] != ETM_ADDR_TYPE_RANGE || etm4_set_mode_exclude()
292 drvdata->addr_type[idx + 1] != ETM_ADDR_TYPE_RANGE) etm4_set_mode_exclude()
300 drvdata->viiectlr |= BIT(idx / 2 + 16); etm4_set_mode_exclude()
301 drvdata->viiectlr &= ~BIT(idx / 2); etm4_set_mode_exclude()
307 drvdata->viiectlr |= BIT(idx / 2); etm4_set_mode_exclude()
308 drvdata->viiectlr &= ~BIT(idx / 2 + 16); etm4_set_mode_exclude()
319 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_pe_cmp_show() local
321 val = drvdata->nr_pe_cmp; nr_pe_cmp_show()
331 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_addr_cmp_show() local
333 val = drvdata->nr_addr_cmp; nr_addr_cmp_show()
343 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_cntr_show() local
345 val = drvdata->nr_cntr; nr_cntr_show()
355 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_ext_inp_show() local
357 val = drvdata->nr_ext_inp; nr_ext_inp_show()
367 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); numcidc_show() local
369 val = drvdata->numcidc; numcidc_show()
379 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); numvmidc_show() local
381 val = drvdata->numvmidc; numvmidc_show()
391 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nrseqstate_show() local
393 val = drvdata->nrseqstate; nrseqstate_show()
403 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_resource_show() local
405 val = drvdata->nr_resource; nr_resource_show()
415 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); nr_ss_cmp_show() local
417 val = drvdata->nr_ss_cmp; nr_ss_cmp_show()
428 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); reset_store() local
433 spin_lock(&drvdata->spinlock); reset_store()
435 drvdata->mode = 0x0; reset_store()
438 drvdata->mode &= ~(ETM_MODE_LOAD | ETM_MODE_STORE); reset_store()
439 drvdata->cfg &= ~(BIT(1) | BIT(2)); reset_store()
442 drvdata->mode &= ~(ETM_MODE_DATA_TRACE_ADDR | reset_store()
444 drvdata->cfg &= ~(BIT(16) | BIT(17)); reset_store()
447 drvdata->eventctrl0 = 0x0; reset_store()
448 drvdata->eventctrl1 = 0x0; reset_store()
451 drvdata->ts_ctrl = 0x0; reset_store()
454 drvdata->stall_ctrl = 0x0; reset_store()
457 if (drvdata->syncpr == false) reset_store()
458 drvdata->syncfreq = 0x8; reset_store()
465 drvdata->vinst_ctrl |= BIT(0); reset_store()
466 if (drvdata->nr_addr_cmp == true) { reset_store()
467 drvdata->mode |= ETM_MODE_VIEWINST_STARTSTOP; reset_store()
469 drvdata->vinst_ctrl |= BIT(9); reset_store()
473 drvdata->viiectlr = 0x0; reset_store()
476 drvdata->vissctlr = 0x0; reset_store()
479 for (i = 0; i < drvdata->nrseqstate-1; i++) reset_store()
480 drvdata->seq_ctrl[i] = 0x0; reset_store()
481 drvdata->seq_rst = 0x0; reset_store()
482 drvdata->seq_state = 0x0; reset_store()
485 drvdata->ext_inp = 0x0; reset_store()
487 drvdata->cntr_idx = 0x0; reset_store()
488 for (i = 0; i < drvdata->nr_cntr; i++) { reset_store()
489 drvdata->cntrldvr[i] = 0x0; reset_store()
490 drvdata->cntr_ctrl[i] = 0x0; reset_store()
491 drvdata->cntr_val[i] = 0x0; reset_store()
495 drvdata->res_idx = 0x2; reset_store()
496 for (i = 2; i < drvdata->nr_resource * 2; i++) reset_store()
497 drvdata->res_ctrl[i] = 0x0; reset_store()
499 for (i = 0; i < drvdata->nr_ss_cmp; i++) { reset_store()
500 drvdata->ss_ctrl[i] = 0x0; reset_store()
501 drvdata->ss_pe_cmp[i] = 0x0; reset_store()
504 drvdata->addr_idx = 0x0; reset_store()
505 for (i = 0; i < drvdata->nr_addr_cmp * 2; i++) { reset_store()
506 drvdata->addr_val[i] = 0x0; reset_store()
507 drvdata->addr_acc[i] = 0x0; reset_store()
508 drvdata->addr_type[i] = ETM_ADDR_TYPE_NONE; reset_store()
511 drvdata->ctxid_idx = 0x0; reset_store()
512 for (i = 0; i < drvdata->numcidc; i++) { reset_store()
513 drvdata->ctxid_pid[i] = 0x0; reset_store()
514 drvdata->ctxid_vpid[i] = 0x0; reset_store()
517 drvdata->ctxid_mask0 = 0x0; reset_store()
518 drvdata->ctxid_mask1 = 0x0; reset_store()
520 drvdata->vmid_idx = 0x0; reset_store()
521 for (i = 0; i < drvdata->numvmidc; i++) reset_store()
522 drvdata->vmid_val[i] = 0x0; reset_store()
523 drvdata->vmid_mask0 = 0x0; reset_store()
524 drvdata->vmid_mask1 = 0x0; reset_store()
526 drvdata->trcid = drvdata->cpu + 1; reset_store()
527 spin_unlock(&drvdata->spinlock); reset_store()
537 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); mode_show() local
539 val = drvdata->mode; mode_show()
548 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); mode_store() local
553 spin_lock(&drvdata->spinlock); mode_store()
554 drvdata->mode = val & ETMv4_MODE_ALL; mode_store()
556 if (drvdata->mode & ETM_MODE_EXCLUDE) mode_store()
557 etm4_set_mode_exclude(drvdata, true); mode_store()
559 etm4_set_mode_exclude(drvdata, false); mode_store()
561 if (drvdata->instrp0 == true) { mode_store()
563 drvdata->cfg &= ~(BIT(1) | BIT(2)); mode_store()
564 if (drvdata->mode & ETM_MODE_LOAD) mode_store()
566 drvdata->cfg |= BIT(1); mode_store()
567 if (drvdata->mode & ETM_MODE_STORE) mode_store()
569 drvdata->cfg |= BIT(2); mode_store()
570 if (drvdata->mode & ETM_MODE_LOAD_STORE) mode_store()
575 drvdata->cfg |= BIT(1) | BIT(2); mode_store()
579 if ((drvdata->mode & ETM_MODE_BB) && (drvdata->trcbb == true)) mode_store()
580 drvdata->cfg |= BIT(3); mode_store()
582 drvdata->cfg &= ~BIT(3); mode_store()
585 if ((drvdata->mode & ETMv4_MODE_CYCACC) && mode_store()
586 (drvdata->trccci == true)) mode_store()
587 drvdata->cfg |= BIT(4); mode_store()
589 drvdata->cfg &= ~BIT(4); mode_store()
592 if ((drvdata->mode & ETMv4_MODE_CTXID) && (drvdata->ctxid_size)) mode_store()
593 drvdata->cfg |= BIT(6); mode_store()
595 drvdata->cfg &= ~BIT(6); mode_store()
597 if ((drvdata->mode & ETM_MODE_VMID) && (drvdata->vmid_size)) mode_store()
598 drvdata->cfg |= BIT(7); mode_store()
600 drvdata->cfg &= ~BIT(7); mode_store()
603 mode = ETM_MODE_COND(drvdata->mode); mode_store()
604 if (drvdata->trccond == true) { mode_store()
605 drvdata->cfg &= ~(BIT(8) | BIT(9) | BIT(10)); mode_store()
606 drvdata->cfg |= mode << 8; mode_store()
610 if ((drvdata->mode & ETMv4_MODE_TIMESTAMP) && (drvdata->ts_size)) mode_store()
611 drvdata->cfg |= BIT(11); mode_store()
613 drvdata->cfg &= ~BIT(11); mode_store()
616 if ((drvdata->mode & ETM_MODE_RETURNSTACK) && mode_store()
617 (drvdata->retstack == true)) mode_store()
618 drvdata->cfg |= BIT(12); mode_store()
620 drvdata->cfg &= ~BIT(12); mode_store()
623 mode = ETM_MODE_QELEM(drvdata->mode); mode_store()
625 drvdata->cfg &= ~(BIT(13) | BIT(14)); mode_store()
627 if ((mode & BIT(0)) && (drvdata->q_support & BIT(0))) mode_store()
628 drvdata->cfg |= BIT(13); mode_store()
633 if ((mode & BIT(1)) && (drvdata->q_support & BIT(1))) mode_store()
634 drvdata->cfg |= BIT(14); mode_store()
637 if ((drvdata->mode & ETM_MODE_ATB_TRIGGER) && mode_store()
638 (drvdata->atbtrig == true)) mode_store()
639 drvdata->eventctrl1 |= BIT(11); mode_store()
641 drvdata->eventctrl1 &= ~BIT(11); mode_store()
644 if ((drvdata->mode & ETM_MODE_LPOVERRIDE) && mode_store()
645 (drvdata->lpoverride == true)) mode_store()
646 drvdata->eventctrl1 |= BIT(12); mode_store()
648 drvdata->eventctrl1 &= ~BIT(12); mode_store()
651 if (drvdata->mode & ETM_MODE_ISTALL_EN) mode_store()
652 drvdata->stall_ctrl |= BIT(8); mode_store()
654 drvdata->stall_ctrl &= ~BIT(8); mode_store()
657 if (drvdata->mode & ETM_MODE_INSTPRIO) mode_store()
658 drvdata->stall_ctrl |= BIT(10); mode_store()
660 drvdata->stall_ctrl &= ~BIT(10); mode_store()
663 if ((drvdata->mode & ETM_MODE_NOOVERFLOW) && mode_store()
664 (drvdata->nooverflow == true)) mode_store()
665 drvdata->stall_ctrl |= BIT(13); mode_store()
667 drvdata->stall_ctrl &= ~BIT(13); mode_store()
670 if (drvdata->mode & ETM_MODE_VIEWINST_STARTSTOP) mode_store()
671 drvdata->vinst_ctrl |= BIT(9); mode_store()
673 drvdata->vinst_ctrl &= ~BIT(9); mode_store()
676 if (drvdata->mode & ETM_MODE_TRACE_RESET) mode_store()
677 drvdata->vinst_ctrl |= BIT(10); mode_store()
679 drvdata->vinst_ctrl &= ~BIT(10); mode_store()
682 if ((drvdata->mode & ETM_MODE_TRACE_ERR) && mode_store()
683 (drvdata->trc_error == true)) mode_store()
684 drvdata->vinst_ctrl |= BIT(11); mode_store()
686 drvdata->vinst_ctrl &= ~BIT(11); mode_store()
688 spin_unlock(&drvdata->spinlock); mode_store()
698 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); pe_show() local
700 val = drvdata->pe_sel; pe_show()
709 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); pe_store() local
714 spin_lock(&drvdata->spinlock); pe_store()
715 if (val > drvdata->nr_pe) { pe_store()
716 spin_unlock(&drvdata->spinlock); pe_store()
720 drvdata->pe_sel = val; pe_store()
721 spin_unlock(&drvdata->spinlock); pe_store()
731 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_show() local
733 val = drvdata->eventctrl0; event_show()
742 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_store() local
747 spin_lock(&drvdata->spinlock); event_store()
748 switch (drvdata->nr_event) { event_store()
751 drvdata->eventctrl0 = val & 0xFF; event_store()
755 drvdata->eventctrl0 = val & 0xFFFF; event_store()
759 drvdata->eventctrl0 = val & 0xFFFFFF; event_store()
763 drvdata->eventctrl0 = val; event_store()
768 spin_unlock(&drvdata->spinlock); event_store()
778 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_instren_show() local
780 val = BMVAL(drvdata->eventctrl1, 0, 3); event_instren_show()
789 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_instren_store() local
794 spin_lock(&drvdata->spinlock); event_instren_store()
796 drvdata->eventctrl1 &= ~(BIT(0) | BIT(1) | BIT(2) | BIT(3)); event_instren_store()
797 switch (drvdata->nr_event) { event_instren_store()
800 drvdata->eventctrl1 |= val & BIT(1); event_instren_store()
804 drvdata->eventctrl1 |= val & (BIT(0) | BIT(1)); event_instren_store()
808 drvdata->eventctrl1 |= val & (BIT(0) | BIT(1) | BIT(2)); event_instren_store()
812 drvdata->eventctrl1 |= val & 0xF; event_instren_store()
817 spin_unlock(&drvdata->spinlock); event_instren_store()
827 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_ts_show() local
829 val = drvdata->ts_ctrl; event_ts_show()
838 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_ts_store() local
842 if (!drvdata->ts_size) event_ts_store()
845 drvdata->ts_ctrl = val & ETMv4_EVENT_MASK; event_ts_store()
855 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); syncfreq_show() local
857 val = drvdata->syncfreq; syncfreq_show()
866 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); syncfreq_store() local
870 if (drvdata->syncpr == true) syncfreq_store()
873 drvdata->syncfreq = val & ETMv4_SYNC_MASK; syncfreq_store()
883 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cyc_threshold_show() local
885 val = drvdata->ccctlr; cyc_threshold_show()
894 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cyc_threshold_store() local
898 if (val < drvdata->ccitmin) cyc_threshold_store()
901 drvdata->ccctlr = val & ETM_CYC_THRESHOLD_MASK; cyc_threshold_store()
911 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); bb_ctrl_show() local
913 val = drvdata->bb_ctrl; bb_ctrl_show()
922 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); bb_ctrl_store() local
926 if (drvdata->trcbb == false) bb_ctrl_store()
928 if (!drvdata->nr_addr_cmp) bb_ctrl_store()
934 if (BMVAL(val, 0, 7) > drvdata->nr_addr_cmp) bb_ctrl_store()
937 drvdata->bb_ctrl = val; bb_ctrl_store()
947 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_vinst_show() local
949 val = drvdata->vinst_ctrl & ETMv4_EVENT_MASK; event_vinst_show()
958 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); event_vinst_store() local
963 spin_lock(&drvdata->spinlock); event_vinst_store()
965 drvdata->vinst_ctrl &= ~ETMv4_EVENT_MASK; event_vinst_store()
966 drvdata->vinst_ctrl |= val; event_vinst_store()
967 spin_unlock(&drvdata->spinlock); event_vinst_store()
977 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); s_exlevel_vinst_show() local
979 val = BMVAL(drvdata->vinst_ctrl, 16, 19); s_exlevel_vinst_show()
988 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); s_exlevel_vinst_store() local
993 spin_lock(&drvdata->spinlock); s_exlevel_vinst_store()
995 drvdata->vinst_ctrl &= ~(BIT(16) | BIT(17) | BIT(19)); s_exlevel_vinst_store()
997 val &= drvdata->s_ex_level; s_exlevel_vinst_store()
998 drvdata->vinst_ctrl |= (val << 16); s_exlevel_vinst_store()
999 spin_unlock(&drvdata->spinlock); s_exlevel_vinst_store()
1009 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ns_exlevel_vinst_show() local
1012 val = BMVAL(drvdata->vinst_ctrl, 20, 23); ns_exlevel_vinst_show()
1021 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ns_exlevel_vinst_store() local
1026 spin_lock(&drvdata->spinlock); ns_exlevel_vinst_store()
1028 drvdata->vinst_ctrl &= ~(BIT(20) | BIT(21) | BIT(22)); ns_exlevel_vinst_store()
1030 val &= drvdata->ns_ex_level; ns_exlevel_vinst_store()
1031 drvdata->vinst_ctrl |= (val << 20); ns_exlevel_vinst_store()
1032 spin_unlock(&drvdata->spinlock); ns_exlevel_vinst_store()
1042 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_idx_show() local
1044 val = drvdata->addr_idx; addr_idx_show()
1053 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_idx_store() local
1057 if (val >= drvdata->nr_addr_cmp * 2) addr_idx_store()
1064 spin_lock(&drvdata->spinlock); addr_idx_store()
1065 drvdata->addr_idx = val; addr_idx_store()
1066 spin_unlock(&drvdata->spinlock); addr_idx_store()
1077 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_instdatatype_show() local
1079 spin_lock(&drvdata->spinlock); addr_instdatatype_show()
1080 idx = drvdata->addr_idx; addr_instdatatype_show()
1081 val = BMVAL(drvdata->addr_acc[idx], 0, 1); addr_instdatatype_show()
1087 spin_unlock(&drvdata->spinlock); addr_instdatatype_show()
1097 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_instdatatype_store() local
1104 spin_lock(&drvdata->spinlock); addr_instdatatype_store()
1105 idx = drvdata->addr_idx; addr_instdatatype_store()
1108 drvdata->addr_acc[idx] &= ~(BIT(0) | BIT(1)); addr_instdatatype_store()
1110 spin_unlock(&drvdata->spinlock); addr_instdatatype_store()
1121 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_single_show() local
1123 idx = drvdata->addr_idx; addr_single_show()
1124 spin_lock(&drvdata->spinlock); addr_single_show()
1125 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_single_show()
1126 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) { addr_single_show()
1127 spin_unlock(&drvdata->spinlock); addr_single_show()
1130 val = (unsigned long)drvdata->addr_val[idx]; addr_single_show()
1131 spin_unlock(&drvdata->spinlock); addr_single_show()
1141 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_single_store() local
1146 spin_lock(&drvdata->spinlock); addr_single_store()
1147 idx = drvdata->addr_idx; addr_single_store()
1148 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_single_store()
1149 drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) { addr_single_store()
1150 spin_unlock(&drvdata->spinlock); addr_single_store()
1154 drvdata->addr_val[idx] = (u64)val; addr_single_store()
1155 drvdata->addr_type[idx] = ETM_ADDR_TYPE_SINGLE; addr_single_store()
1156 spin_unlock(&drvdata->spinlock); addr_single_store()
1167 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_range_show() local
1169 spin_lock(&drvdata->spinlock); addr_range_show()
1170 idx = drvdata->addr_idx; addr_range_show()
1172 spin_unlock(&drvdata->spinlock); addr_range_show()
1175 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE && addr_range_show()
1176 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) || addr_range_show()
1177 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE && addr_range_show()
1178 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) { addr_range_show()
1179 spin_unlock(&drvdata->spinlock); addr_range_show()
1183 val1 = (unsigned long)drvdata->addr_val[idx]; addr_range_show()
1184 val2 = (unsigned long)drvdata->addr_val[idx + 1]; addr_range_show()
1185 spin_unlock(&drvdata->spinlock); addr_range_show()
1195 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_range_store() local
1203 spin_lock(&drvdata->spinlock); addr_range_store()
1204 idx = drvdata->addr_idx; addr_range_store()
1206 spin_unlock(&drvdata->spinlock); addr_range_store()
1210 if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE && addr_range_store()
1211 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) || addr_range_store()
1212 (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE && addr_range_store()
1213 drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) { addr_range_store()
1214 spin_unlock(&drvdata->spinlock); addr_range_store()
1218 drvdata->addr_val[idx] = (u64)val1; addr_range_store()
1219 drvdata->addr_type[idx] = ETM_ADDR_TYPE_RANGE; addr_range_store()
1220 drvdata->addr_val[idx + 1] = (u64)val2; addr_range_store()
1221 drvdata->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE; addr_range_store()
1226 if (drvdata->mode & ETM_MODE_EXCLUDE) addr_range_store()
1227 etm4_set_mode_exclude(drvdata, true); addr_range_store()
1229 etm4_set_mode_exclude(drvdata, false); addr_range_store()
1231 spin_unlock(&drvdata->spinlock); addr_range_store()
1242 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_start_show() local
1244 spin_lock(&drvdata->spinlock); addr_start_show()
1245 idx = drvdata->addr_idx; addr_start_show()
1247 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_start_show()
1248 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) { addr_start_show()
1249 spin_unlock(&drvdata->spinlock); addr_start_show()
1253 val = (unsigned long)drvdata->addr_val[idx]; addr_start_show()
1254 spin_unlock(&drvdata->spinlock); addr_start_show()
1264 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_start_store() local
1269 spin_lock(&drvdata->spinlock); addr_start_store()
1270 idx = drvdata->addr_idx; addr_start_store()
1271 if (!drvdata->nr_addr_cmp) { addr_start_store()
1272 spin_unlock(&drvdata->spinlock); addr_start_store()
1275 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_start_store()
1276 drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) { addr_start_store()
1277 spin_unlock(&drvdata->spinlock); addr_start_store()
1281 drvdata->addr_val[idx] = (u64)val; addr_start_store()
1282 drvdata->addr_type[idx] = ETM_ADDR_TYPE_START; addr_start_store()
1283 drvdata->vissctlr |= BIT(idx); addr_start_store()
1285 drvdata->vinst_ctrl |= BIT(9); addr_start_store()
1286 spin_unlock(&drvdata->spinlock); addr_start_store()
1297 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_stop_show() local
1299 spin_lock(&drvdata->spinlock); addr_stop_show()
1300 idx = drvdata->addr_idx; addr_stop_show()
1302 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_stop_show()
1303 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) { addr_stop_show()
1304 spin_unlock(&drvdata->spinlock); addr_stop_show()
1308 val = (unsigned long)drvdata->addr_val[idx]; addr_stop_show()
1309 spin_unlock(&drvdata->spinlock); addr_stop_show()
1319 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_stop_store() local
1324 spin_lock(&drvdata->spinlock); addr_stop_store()
1325 idx = drvdata->addr_idx; addr_stop_store()
1326 if (!drvdata->nr_addr_cmp) { addr_stop_store()
1327 spin_unlock(&drvdata->spinlock); addr_stop_store()
1330 if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE || addr_stop_store()
1331 drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) { addr_stop_store()
1332 spin_unlock(&drvdata->spinlock); addr_stop_store()
1336 drvdata->addr_val[idx] = (u64)val; addr_stop_store()
1337 drvdata->addr_type[idx] = ETM_ADDR_TYPE_STOP; addr_stop_store()
1338 drvdata->vissctlr |= BIT(idx + 16); addr_stop_store()
1340 drvdata->vinst_ctrl |= BIT(9); addr_stop_store()
1341 spin_unlock(&drvdata->spinlock); addr_stop_store()
1352 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_ctxtype_show() local
1354 spin_lock(&drvdata->spinlock); addr_ctxtype_show()
1355 idx = drvdata->addr_idx; addr_ctxtype_show()
1357 val = BMVAL(drvdata->addr_acc[idx], 2, 3); addr_ctxtype_show()
1361 spin_unlock(&drvdata->spinlock); addr_ctxtype_show()
1371 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_ctxtype_store() local
1378 spin_lock(&drvdata->spinlock); addr_ctxtype_store()
1379 idx = drvdata->addr_idx; addr_ctxtype_store()
1382 drvdata->addr_acc[idx] &= ~(BIT(2) | BIT(3)); addr_ctxtype_store()
1385 if (drvdata->numcidc) { addr_ctxtype_store()
1386 drvdata->addr_acc[idx] |= BIT(2); addr_ctxtype_store()
1387 drvdata->addr_acc[idx] &= ~BIT(3); addr_ctxtype_store()
1391 if (drvdata->numvmidc) { addr_ctxtype_store()
1392 drvdata->addr_acc[idx] &= ~BIT(2); addr_ctxtype_store()
1393 drvdata->addr_acc[idx] |= BIT(3); addr_ctxtype_store()
1400 if (drvdata->numcidc) addr_ctxtype_store()
1401 drvdata->addr_acc[idx] |= BIT(2); addr_ctxtype_store()
1402 if (drvdata->numvmidc) addr_ctxtype_store()
1403 drvdata->addr_acc[idx] |= BIT(3); addr_ctxtype_store()
1405 spin_unlock(&drvdata->spinlock); addr_ctxtype_store()
1416 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_context_show() local
1418 spin_lock(&drvdata->spinlock); addr_context_show()
1419 idx = drvdata->addr_idx; addr_context_show()
1421 val = BMVAL(drvdata->addr_acc[idx], 4, 6); addr_context_show()
1422 spin_unlock(&drvdata->spinlock); addr_context_show()
1432 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); addr_context_store() local
1436 if ((drvdata->numcidc <= 1) && (drvdata->numvmidc <= 1)) addr_context_store()
1438 if (val >= (drvdata->numcidc >= drvdata->numvmidc ? addr_context_store()
1439 drvdata->numcidc : drvdata->numvmidc)) addr_context_store()
1442 spin_lock(&drvdata->spinlock); addr_context_store()
1443 idx = drvdata->addr_idx; addr_context_store()
1445 drvdata->addr_acc[idx] &= ~(BIT(4) | BIT(5) | BIT(6)); addr_context_store()
1446 drvdata->addr_acc[idx] |= (val << 4); addr_context_store()
1447 spin_unlock(&drvdata->spinlock); addr_context_store()
1457 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_idx_show() local
1459 val = drvdata->seq_idx; seq_idx_show()
1468 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_idx_store() local
1472 if (val >= drvdata->nrseqstate - 1) seq_idx_store()
1479 spin_lock(&drvdata->spinlock); seq_idx_store()
1480 drvdata->seq_idx = val; seq_idx_store()
1481 spin_unlock(&drvdata->spinlock); seq_idx_store()
1491 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_state_show() local
1493 val = drvdata->seq_state; seq_state_show()
1502 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_state_store() local
1506 if (val >= drvdata->nrseqstate) seq_state_store()
1509 drvdata->seq_state = val; seq_state_store()
1520 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_event_show() local
1522 spin_lock(&drvdata->spinlock); seq_event_show()
1523 idx = drvdata->seq_idx; seq_event_show()
1524 val = drvdata->seq_ctrl[idx]; seq_event_show()
1525 spin_unlock(&drvdata->spinlock); seq_event_show()
1535 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_event_store() local
1540 spin_lock(&drvdata->spinlock); seq_event_store()
1541 idx = drvdata->seq_idx; seq_event_store()
1543 drvdata->seq_ctrl[idx] = val & 0xFF; seq_event_store()
1544 spin_unlock(&drvdata->spinlock); seq_event_store()
1554 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_reset_event_show() local
1556 val = drvdata->seq_rst; seq_reset_event_show()
1565 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); seq_reset_event_store() local
1569 if (!(drvdata->nrseqstate)) seq_reset_event_store()
1572 drvdata->seq_rst = val & ETMv4_EVENT_MASK; seq_reset_event_store()
1582 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_idx_show() local
1584 val = drvdata->cntr_idx; cntr_idx_show()
1593 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_idx_store() local
1597 if (val >= drvdata->nr_cntr) cntr_idx_store()
1604 spin_lock(&drvdata->spinlock); cntr_idx_store()
1605 drvdata->cntr_idx = val; cntr_idx_store()
1606 spin_unlock(&drvdata->spinlock); cntr_idx_store()
1617 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntrldvr_show() local
1619 spin_lock(&drvdata->spinlock); cntrldvr_show()
1620 idx = drvdata->cntr_idx; cntrldvr_show()
1621 val = drvdata->cntrldvr[idx]; cntrldvr_show()
1622 spin_unlock(&drvdata->spinlock); cntrldvr_show()
1632 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntrldvr_store() local
1639 spin_lock(&drvdata->spinlock); cntrldvr_store()
1640 idx = drvdata->cntr_idx; cntrldvr_store()
1641 drvdata->cntrldvr[idx] = val; cntrldvr_store()
1642 spin_unlock(&drvdata->spinlock); cntrldvr_store()
1653 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_val_show() local
1655 spin_lock(&drvdata->spinlock); cntr_val_show()
1656 idx = drvdata->cntr_idx; cntr_val_show()
1657 val = drvdata->cntr_val[idx]; cntr_val_show()
1658 spin_unlock(&drvdata->spinlock); cntr_val_show()
1668 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_val_store() local
1675 spin_lock(&drvdata->spinlock); cntr_val_store()
1676 idx = drvdata->cntr_idx; cntr_val_store()
1677 drvdata->cntr_val[idx] = val; cntr_val_store()
1678 spin_unlock(&drvdata->spinlock); cntr_val_store()
1689 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_ctrl_show() local
1691 spin_lock(&drvdata->spinlock); cntr_ctrl_show()
1692 idx = drvdata->cntr_idx; cntr_ctrl_show()
1693 val = drvdata->cntr_ctrl[idx]; cntr_ctrl_show()
1694 spin_unlock(&drvdata->spinlock); cntr_ctrl_show()
1704 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cntr_ctrl_store() local
1709 spin_lock(&drvdata->spinlock); cntr_ctrl_store()
1710 idx = drvdata->cntr_idx; cntr_ctrl_store()
1711 drvdata->cntr_ctrl[idx] = val; cntr_ctrl_store()
1712 spin_unlock(&drvdata->spinlock); cntr_ctrl_store()
1722 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); res_idx_show() local
1724 val = drvdata->res_idx; res_idx_show()
1733 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); res_idx_store() local
1738 if (val < 2 || val >= drvdata->nr_resource * 2) res_idx_store()
1745 spin_lock(&drvdata->spinlock); res_idx_store()
1746 drvdata->res_idx = val; res_idx_store()
1747 spin_unlock(&drvdata->spinlock); res_idx_store()
1758 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); res_ctrl_show() local
1760 spin_lock(&drvdata->spinlock); res_ctrl_show()
1761 idx = drvdata->res_idx; res_ctrl_show()
1762 val = drvdata->res_ctrl[idx]; res_ctrl_show()
1763 spin_unlock(&drvdata->spinlock); res_ctrl_show()
1773 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); res_ctrl_store() local
1778 spin_lock(&drvdata->spinlock); res_ctrl_store()
1779 idx = drvdata->res_idx; res_ctrl_store()
1784 drvdata->res_ctrl[idx] = val; res_ctrl_store()
1785 spin_unlock(&drvdata->spinlock); res_ctrl_store()
1795 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_idx_show() local
1797 val = drvdata->ctxid_idx; ctxid_idx_show()
1806 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_idx_store() local
1810 if (val >= drvdata->numcidc) ctxid_idx_store()
1817 spin_lock(&drvdata->spinlock); ctxid_idx_store()
1818 drvdata->ctxid_idx = val; ctxid_idx_store()
1819 spin_unlock(&drvdata->spinlock); ctxid_idx_store()
1830 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_pid_show() local
1832 spin_lock(&drvdata->spinlock); ctxid_pid_show()
1833 idx = drvdata->ctxid_idx; ctxid_pid_show()
1834 val = (unsigned long)drvdata->ctxid_vpid[idx]; ctxid_pid_show()
1835 spin_unlock(&drvdata->spinlock); ctxid_pid_show()
1845 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_pid_store() local
1852 if (!drvdata->ctxid_size || !drvdata->numcidc) ctxid_pid_store()
1859 spin_lock(&drvdata->spinlock); ctxid_pid_store()
1860 idx = drvdata->ctxid_idx; ctxid_pid_store()
1861 drvdata->ctxid_pid[idx] = (u64)pid; ctxid_pid_store()
1862 drvdata->ctxid_vpid[idx] = (u64)vpid; ctxid_pid_store()
1863 spin_unlock(&drvdata->spinlock); ctxid_pid_store()
1873 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_masks_show() local
1875 spin_lock(&drvdata->spinlock); ctxid_masks_show()
1876 val1 = drvdata->ctxid_mask0; ctxid_masks_show()
1877 val2 = drvdata->ctxid_mask1; ctxid_masks_show()
1878 spin_unlock(&drvdata->spinlock); ctxid_masks_show()
1888 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); ctxid_masks_store() local
1895 if (!drvdata->ctxid_size || !drvdata->numcidc) ctxid_masks_store()
1900 spin_lock(&drvdata->spinlock); ctxid_masks_store()
1905 switch (drvdata->numcidc) { ctxid_masks_store()
1908 drvdata->ctxid_mask0 = val1 & 0xFF; ctxid_masks_store()
1912 drvdata->ctxid_mask0 = val1 & 0xFFFF; ctxid_masks_store()
1916 drvdata->ctxid_mask0 = val1 & 0xFFFFFF; ctxid_masks_store()
1920 drvdata->ctxid_mask0 = val1; ctxid_masks_store()
1924 drvdata->ctxid_mask0 = val1; ctxid_masks_store()
1925 drvdata->ctxid_mask1 = val2 & 0xFF; ctxid_masks_store()
1929 drvdata->ctxid_mask0 = val1; ctxid_masks_store()
1930 drvdata->ctxid_mask1 = val2 & 0xFFFF; ctxid_masks_store()
1934 drvdata->ctxid_mask0 = val1; ctxid_masks_store()
1935 drvdata->ctxid_mask1 = val2 & 0xFFFFFF; ctxid_masks_store()
1939 drvdata->ctxid_mask0 = val1; ctxid_masks_store()
1940 drvdata->ctxid_mask1 = val2; ctxid_masks_store()
1951 mask = drvdata->ctxid_mask0; ctxid_masks_store()
1952 for (i = 0; i < drvdata->numcidc; i++) { ctxid_masks_store()
1961 drvdata->ctxid_pid[i] &= ~(0xFF << (j * 8)); ctxid_masks_store()
1967 mask = drvdata->ctxid_mask1; ctxid_masks_store()
1972 spin_unlock(&drvdata->spinlock); ctxid_masks_store()
1982 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); vmid_idx_show() local
1984 val = drvdata->vmid_idx; vmid_idx_show()
1993 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); vmid_idx_store() local
1997 if (val >= drvdata->numvmidc) vmid_idx_store()
2004 spin_lock(&drvdata->spinlock); vmid_idx_store()
2005 drvdata->vmid_idx = val; vmid_idx_store()
2006 spin_unlock(&drvdata->spinlock); vmid_idx_store()
2016 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); vmid_val_show() local
2018 val = (unsigned long)drvdata->vmid_val[drvdata->vmid_idx]; vmid_val_show()
2027 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); vmid_val_store() local
2033 if (!drvdata->vmid_size || !drvdata->numvmidc) vmid_val_store()
2038 spin_lock(&drvdata->spinlock); vmid_val_store()
2039 drvdata->vmid_val[drvdata->vmid_idx] = (u64)val; vmid_val_store()
2040 spin_unlock(&drvdata->spinlock); vmid_val_store()
2049 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); vmid_masks_show() local
2051 spin_lock(&drvdata->spinlock); vmid_masks_show()
2052 val1 = drvdata->vmid_mask0; vmid_masks_show()
2053 val2 = drvdata->vmid_mask1; vmid_masks_show()
2054 spin_unlock(&drvdata->spinlock); vmid_masks_show()
2064 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); vmid_masks_store() local
2069 if (!drvdata->vmid_size || !drvdata->numvmidc) vmid_masks_store()
2074 spin_lock(&drvdata->spinlock); vmid_masks_store()
2080 switch (drvdata->numvmidc) { vmid_masks_store()
2083 drvdata->vmid_mask0 = val1 & 0xFF; vmid_masks_store()
2087 drvdata->vmid_mask0 = val1 & 0xFFFF; vmid_masks_store()
2091 drvdata->vmid_mask0 = val1 & 0xFFFFFF; vmid_masks_store()
2095 drvdata->vmid_mask0 = val1; vmid_masks_store()
2099 drvdata->vmid_mask0 = val1; vmid_masks_store()
2100 drvdata->vmid_mask1 = val2 & 0xFF; vmid_masks_store()
2104 drvdata->vmid_mask0 = val1; vmid_masks_store()
2105 drvdata->vmid_mask1 = val2 & 0xFFFF; vmid_masks_store()
2109 drvdata->vmid_mask0 = val1; vmid_masks_store()
2110 drvdata->vmid_mask1 = val2 & 0xFFFFFF; vmid_masks_store()
2114 drvdata->vmid_mask0 = val1; vmid_masks_store()
2115 drvdata->vmid_mask1 = val2; vmid_masks_store()
2127 mask = drvdata->vmid_mask0; vmid_masks_store()
2128 for (i = 0; i < drvdata->numvmidc; i++) { vmid_masks_store()
2137 drvdata->vmid_val[i] &= ~(0xFF << (j * 8)); vmid_masks_store()
2143 mask = drvdata->vmid_mask1; vmid_masks_store()
2147 spin_unlock(&drvdata->spinlock); vmid_masks_store()
2156 struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); cpu_show() local
2158 val = drvdata->cpu; cpu_show()
2218 struct etmv4_drvdata *drvdata = dev_get_drvdata(_dev->parent); \
2220 readl_relaxed(drvdata->base + offset)); \
2311 struct etmv4_drvdata *drvdata = info; etm4_init_arch_data() local
2313 CS_UNLOCK(drvdata->base); etm4_init_arch_data()
2316 etmidr0 = readl_relaxed(drvdata->base + TRCIDR0); etm4_init_arch_data()
2320 drvdata->instrp0 = true; etm4_init_arch_data()
2322 drvdata->instrp0 = false; etm4_init_arch_data()
2326 drvdata->trcbb = true; etm4_init_arch_data()
2328 drvdata->trcbb = false; etm4_init_arch_data()
2332 drvdata->trccond = true; etm4_init_arch_data()
2334 drvdata->trccond = false; etm4_init_arch_data()
2338 drvdata->trccci = true; etm4_init_arch_data()
2340 drvdata->trccci = false; etm4_init_arch_data()
2344 drvdata->retstack = true; etm4_init_arch_data()
2346 drvdata->retstack = false; etm4_init_arch_data()
2349 drvdata->nr_event = BMVAL(etmidr0, 10, 11); etm4_init_arch_data()
2351 drvdata->q_support = BMVAL(etmidr0, 15, 16); etm4_init_arch_data()
2353 drvdata->ts_size = BMVAL(etmidr0, 24, 28); etm4_init_arch_data()
2356 etmidr1 = readl_relaxed(drvdata->base + TRCIDR1); etm4_init_arch_data()
2361 drvdata->arch = BMVAL(etmidr1, 4, 11); etm4_init_arch_data()
2364 etmidr2 = readl_relaxed(drvdata->base + TRCIDR2); etm4_init_arch_data()
2366 drvdata->ctxid_size = BMVAL(etmidr2, 5, 9); etm4_init_arch_data()
2368 drvdata->vmid_size = BMVAL(etmidr2, 10, 14); etm4_init_arch_data()
2370 drvdata->ccsize = BMVAL(etmidr2, 25, 28); etm4_init_arch_data()
2372 etmidr3 = readl_relaxed(drvdata->base + TRCIDR3); etm4_init_arch_data()
2374 drvdata->ccitmin = BMVAL(etmidr3, 0, 11); etm4_init_arch_data()
2376 drvdata->s_ex_level = BMVAL(etmidr3, 16, 19); etm4_init_arch_data()
2378 drvdata->ns_ex_level = BMVAL(etmidr3, 20, 23); etm4_init_arch_data()
2385 drvdata->trc_error = true; etm4_init_arch_data()
2387 drvdata->trc_error = false; etm4_init_arch_data()
2391 drvdata->syncpr = true; etm4_init_arch_data()
2393 drvdata->syncpr = false; etm4_init_arch_data()
2397 drvdata->stallctl = true; etm4_init_arch_data()
2399 drvdata->stallctl = false; etm4_init_arch_data()
2403 drvdata->sysstall = true; etm4_init_arch_data()
2405 drvdata->sysstall = false; etm4_init_arch_data()
2408 drvdata->nr_pe = BMVAL(etmidr3, 28, 30); etm4_init_arch_data()
2412 drvdata->nooverflow = true; etm4_init_arch_data()
2414 drvdata->nooverflow = false; etm4_init_arch_data()
2417 etmidr4 = readl_relaxed(drvdata->base + TRCIDR4); etm4_init_arch_data()
2419 drvdata->nr_addr_cmp = BMVAL(etmidr4, 0, 3); etm4_init_arch_data()
2421 drvdata->nr_pe_cmp = BMVAL(etmidr4, 12, 15); etm4_init_arch_data()
2428 drvdata->nr_resource = BMVAL(etmidr4, 16, 19) + 1; etm4_init_arch_data()
2433 drvdata->nr_ss_cmp = BMVAL(etmidr4, 20, 23); etm4_init_arch_data()
2435 drvdata->numcidc = BMVAL(etmidr4, 24, 27); etm4_init_arch_data()
2437 drvdata->numvmidc = BMVAL(etmidr4, 28, 31); etm4_init_arch_data()
2439 etmidr5 = readl_relaxed(drvdata->base + TRCIDR5); etm4_init_arch_data()
2441 drvdata->nr_ext_inp = BMVAL(etmidr5, 0, 8); etm4_init_arch_data()
2443 drvdata->trcid_size = BMVAL(etmidr5, 16, 21); etm4_init_arch_data()
2446 drvdata->atbtrig = true; etm4_init_arch_data()
2448 drvdata->atbtrig = false; etm4_init_arch_data()
2454 drvdata->lpoverride = true; etm4_init_arch_data()
2456 drvdata->lpoverride = false; etm4_init_arch_data()
2458 drvdata->nrseqstate = BMVAL(etmidr5, 25, 27); etm4_init_arch_data()
2460 drvdata->nr_cntr = BMVAL(etmidr5, 28, 30); etm4_init_arch_data()
2461 CS_LOCK(drvdata->base); etm4_init_arch_data()
2464 static void etm4_init_default_data(struct etmv4_drvdata *drvdata) etm4_init_default_data() argument
2468 drvdata->pe_sel = 0x0; etm4_init_default_data()
2469 drvdata->cfg = (ETMv4_MODE_CTXID | ETM_MODE_VMID | etm4_init_default_data()
2473 drvdata->eventctrl0 = 0x0; etm4_init_default_data()
2474 drvdata->eventctrl1 = 0x0; etm4_init_default_data()
2477 drvdata->stall_ctrl = 0x0; etm4_init_default_data()
2480 drvdata->ts_ctrl = 0x0; etm4_init_default_data()
2483 if (drvdata->syncpr == false) etm4_init_default_data()
2484 drvdata->syncfreq = 0xC; etm4_init_default_data()
2490 drvdata->vinst_ctrl |= BIT(0); etm4_init_default_data()
2492 if (drvdata->nr_addr_cmp) etm4_init_default_data()
2493 drvdata->vinst_ctrl |= BIT(9); etm4_init_default_data()
2496 drvdata->viiectlr = 0x0; etm4_init_default_data()
2498 drvdata->vissctlr = 0x0; etm4_init_default_data()
2501 for (i = 0; i < drvdata->nrseqstate-1; i++) etm4_init_default_data()
2502 drvdata->seq_ctrl[i] = 0x0; etm4_init_default_data()
2503 drvdata->seq_rst = 0x0; etm4_init_default_data()
2504 drvdata->seq_state = 0x0; etm4_init_default_data()
2507 drvdata->ext_inp = 0x0; etm4_init_default_data()
2509 for (i = 0; i < drvdata->nr_cntr; i++) { etm4_init_default_data()
2510 drvdata->cntrldvr[i] = 0x0; etm4_init_default_data()
2511 drvdata->cntr_ctrl[i] = 0x0; etm4_init_default_data()
2512 drvdata->cntr_val[i] = 0x0; etm4_init_default_data()
2516 drvdata->res_idx = 0x2; etm4_init_default_data()
2517 for (i = 2; i < drvdata->nr_resource * 2; i++) etm4_init_default_data()
2518 drvdata->res_ctrl[i] = 0x0; etm4_init_default_data()
2520 for (i = 0; i < drvdata->nr_ss_cmp; i++) { etm4_init_default_data()
2521 drvdata->ss_ctrl[i] = 0x0; etm4_init_default_data()
2522 drvdata->ss_pe_cmp[i] = 0x0; etm4_init_default_data()
2525 if (drvdata->nr_addr_cmp >= 1) { etm4_init_default_data()
2526 drvdata->addr_val[0] = (unsigned long)_stext; etm4_init_default_data()
2527 drvdata->addr_val[1] = (unsigned long)_etext; etm4_init_default_data()
2528 drvdata->addr_type[0] = ETM_ADDR_TYPE_RANGE; etm4_init_default_data()
2529 drvdata->addr_type[1] = ETM_ADDR_TYPE_RANGE; etm4_init_default_data()
2532 for (i = 0; i < drvdata->numcidc; i++) { etm4_init_default_data()
2533 drvdata->ctxid_pid[i] = 0x0; etm4_init_default_data()
2534 drvdata->ctxid_vpid[i] = 0x0; etm4_init_default_data()
2537 drvdata->ctxid_mask0 = 0x0; etm4_init_default_data()
2538 drvdata->ctxid_mask1 = 0x0; etm4_init_default_data()
2540 for (i = 0; i < drvdata->numvmidc; i++) etm4_init_default_data()
2541 drvdata->vmid_val[i] = 0x0; etm4_init_default_data()
2542 drvdata->vmid_mask0 = 0x0; etm4_init_default_data()
2543 drvdata->vmid_mask1 = 0x0; etm4_init_default_data()
2550 drvdata->trcid = 0x20 + drvdata->cpu; etm4_init_default_data()
2601 struct etmv4_drvdata *drvdata; etm4_probe() local
2610 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); etm4_probe()
2611 if (!drvdata) etm4_probe()
2621 drvdata->dev = &adev->dev; etm4_probe()
2622 dev_set_drvdata(dev, drvdata); etm4_probe()
2629 drvdata->base = base; etm4_probe()
2631 spin_lock_init(&drvdata->spinlock); etm4_probe()
2633 drvdata->cpu = pdata ? pdata->cpu : 0; etm4_probe()
2636 etmdrvdata[drvdata->cpu] = drvdata; etm4_probe()
2638 if (!smp_call_function_single(drvdata->cpu, etm4_os_unlock, drvdata, 1)) etm4_probe()
2639 drvdata->os_unlock = true; etm4_probe()
2641 if (smp_call_function_single(drvdata->cpu, etm4_probe()
2642 etm4_init_arch_data, drvdata, 1)) etm4_probe()
2650 if (etm4_arch_supported(drvdata->arch) == false) { etm4_probe()
2654 etm4_init_default_data(drvdata); etm4_probe()
2664 drvdata->csdev = coresight_register(desc); etm4_probe()
2665 if (IS_ERR(drvdata->csdev)) { etm4_probe()
2666 ret = PTR_ERR(drvdata->csdev); etm4_probe()
2673 coresight_enable(drvdata->csdev); etm4_probe()
2674 drvdata->boot_enable = true; etm4_probe()
2689 struct etmv4_drvdata *drvdata = amba_get_drvdata(adev); etm4_remove() local
2691 coresight_unregister(drvdata->csdev); etm4_remove()
|
| H A D | coresight-etb10.c | 94 static unsigned int etb_get_buffer_depth(struct etb_drvdata *drvdata) etb_get_buffer_depth() argument
98 pm_runtime_get_sync(drvdata->dev); etb_get_buffer_depth()
101 depth = readl_relaxed(drvdata->base + ETB_RAM_DEPTH_REG); etb_get_buffer_depth()
103 pm_runtime_put(drvdata->dev); etb_get_buffer_depth()
107 static void etb_enable_hw(struct etb_drvdata *drvdata) etb_enable_hw() argument
112 CS_UNLOCK(drvdata->base); etb_enable_hw()
114 depth = drvdata->buffer_depth; etb_enable_hw()
116 writel_relaxed(0x0, drvdata->base + ETB_RAM_WRITE_POINTER); etb_enable_hw()
119 writel_relaxed(0x0, drvdata->base + ETB_RWD_REG); etb_enable_hw()
122 writel_relaxed(0x0, drvdata->base + ETB_RAM_WRITE_POINTER); etb_enable_hw()
124 writel_relaxed(0x0, drvdata->base + ETB_RAM_READ_POINTER); etb_enable_hw()
126 writel_relaxed(drvdata->trigger_cntr, drvdata->base + ETB_TRG); etb_enable_hw()
128 drvdata->base + ETB_FFCR); etb_enable_hw()
130 writel_relaxed(ETB_CTL_CAPT_EN, drvdata->base + ETB_CTL_REG); etb_enable_hw()
132 CS_LOCK(drvdata->base); etb_enable_hw()
137 struct etb_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etb_enable() local
140 pm_runtime_get_sync(drvdata->dev); etb_enable()
142 spin_lock_irqsave(&drvdata->spinlock, flags); etb_enable()
143 etb_enable_hw(drvdata); etb_enable()
144 drvdata->enable = true; etb_enable()
145 spin_unlock_irqrestore(&drvdata->spinlock, flags); etb_enable()
147 dev_info(drvdata->dev, "ETB enabled\n"); etb_enable()
151 static void etb_disable_hw(struct etb_drvdata *drvdata) etb_disable_hw() argument
155 CS_UNLOCK(drvdata->base); etb_disable_hw()
157 ffcr = readl_relaxed(drvdata->base + ETB_FFCR); etb_disable_hw()
160 writel_relaxed(ffcr, drvdata->base + ETB_FFCR); etb_disable_hw()
163 writel_relaxed(ffcr, drvdata->base + ETB_FFCR); etb_disable_hw()
165 if (coresight_timeout(drvdata->base, ETB_FFCR, ETB_FFCR_BIT, 0)) { etb_disable_hw()
166 dev_err(drvdata->dev, etb_disable_hw()
172 writel_relaxed(0x0, drvdata->base + ETB_CTL_REG); etb_disable_hw()
174 if (coresight_timeout(drvdata->base, ETB_FFSR, ETB_FFSR_BIT, 1)) { etb_disable_hw()
175 dev_err(drvdata->dev, etb_disable_hw()
180 CS_LOCK(drvdata->base); etb_disable_hw()
183 static void etb_dump_hw(struct etb_drvdata *drvdata) etb_dump_hw() argument
191 CS_UNLOCK(drvdata->base); etb_dump_hw()
193 read_ptr = readl_relaxed(drvdata->base + ETB_RAM_READ_POINTER); etb_dump_hw()
194 write_ptr = readl_relaxed(drvdata->base + ETB_RAM_WRITE_POINTER); etb_dump_hw()
199 dev_err(drvdata->dev, etb_dump_hw()
202 dev_err(drvdata->dev, "frameoff: %lu, frame_endoff: %lu\n", etb_dump_hw()
207 if ((readl_relaxed(drvdata->base + ETB_STATUS_REG) etb_dump_hw()
209 writel_relaxed(0x0, drvdata->base + ETB_RAM_READ_POINTER); etb_dump_hw()
211 writel_relaxed(write_ptr, drvdata->base + ETB_RAM_READ_POINTER); etb_dump_hw()
213 depth = drvdata->buffer_depth; etb_dump_hw()
214 buf_ptr = drvdata->buf; etb_dump_hw()
216 read_data = readl_relaxed(drvdata->base + etb_dump_hw()
234 writel_relaxed(read_ptr, drvdata->base + ETB_RAM_READ_POINTER); etb_dump_hw()
236 CS_LOCK(drvdata->base); etb_dump_hw()
241 struct etb_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); etb_disable() local
244 spin_lock_irqsave(&drvdata->spinlock, flags); etb_disable()
245 etb_disable_hw(drvdata); etb_disable()
246 etb_dump_hw(drvdata); etb_disable()
247 drvdata->enable = false; etb_disable()
248 spin_unlock_irqrestore(&drvdata->spinlock, flags); etb_disable()
250 pm_runtime_put(drvdata->dev); etb_disable()
252 dev_info(drvdata->dev, "ETB disabled\n"); etb_disable()
264 static void etb_dump(struct etb_drvdata *drvdata) etb_dump() argument
268 spin_lock_irqsave(&drvdata->spinlock, flags); etb_dump()
269 if (drvdata->enable) { etb_dump()
270 etb_disable_hw(drvdata); etb_dump()
271 etb_dump_hw(drvdata); etb_dump()
272 etb_enable_hw(drvdata); etb_dump()
274 spin_unlock_irqrestore(&drvdata->spinlock, flags); etb_dump()
276 dev_info(drvdata->dev, "ETB dumped\n"); etb_dump()
281 struct etb_drvdata *drvdata = container_of(file->private_data, etb_open() local
284 if (atomic_cmpxchg(&drvdata->in_use, 0, 1)) etb_open()
287 dev_dbg(drvdata->dev, "%s: successfully opened\n", __func__); etb_open()
295 struct etb_drvdata *drvdata = container_of(file->private_data, etb_read() local
298 etb_dump(drvdata); etb_read()
300 depth = drvdata->buffer_depth; etb_read()
304 if (copy_to_user(data, drvdata->buf + *ppos, len)) { etb_read()
305 dev_dbg(drvdata->dev, "%s: copy_to_user failed\n", __func__); etb_read()
311 dev_dbg(drvdata->dev, "%s: %zu bytes copied, %d bytes left\n", etb_read()
318 struct etb_drvdata *drvdata = container_of(file->private_data, etb_release() local
320 atomic_set(&drvdata->in_use, 0); etb_release()
322 dev_dbg(drvdata->dev, "%s: released\n", __func__); etb_release()
340 struct etb_drvdata *drvdata = dev_get_drvdata(dev->parent); status_show() local
342 pm_runtime_get_sync(drvdata->dev); status_show()
343 spin_lock_irqsave(&drvdata->spinlock, flags); status_show()
344 CS_UNLOCK(drvdata->base); status_show()
346 etb_rdr = readl_relaxed(drvdata->base + ETB_RAM_DEPTH_REG); status_show()
347 etb_sr = readl_relaxed(drvdata->base + ETB_STATUS_REG); status_show()
348 etb_rrp = readl_relaxed(drvdata->base + ETB_RAM_READ_POINTER); status_show()
349 etb_rwp = readl_relaxed(drvdata->base + ETB_RAM_WRITE_POINTER); status_show()
350 etb_trg = readl_relaxed(drvdata->base + ETB_TRG); status_show()
351 etb_cr = readl_relaxed(drvdata->base + ETB_CTL_REG); status_show()
352 etb_ffsr = readl_relaxed(drvdata->base + ETB_FFSR); status_show()
353 etb_ffcr = readl_relaxed(drvdata->base + ETB_FFCR); status_show()
355 CS_LOCK(drvdata->base); status_show()
356 spin_unlock_irqrestore(&drvdata->spinlock, flags); status_show()
358 pm_runtime_put(drvdata->dev); status_show()
379 struct etb_drvdata *drvdata = dev_get_drvdata(dev->parent); trigger_cntr_show() local
380 unsigned long val = drvdata->trigger_cntr; trigger_cntr_show()
391 struct etb_drvdata *drvdata = dev_get_drvdata(dev->parent); trigger_cntr_store() local
397 drvdata->trigger_cntr = val; trigger_cntr_store()
415 struct etb_drvdata *drvdata; etb_probe() local
427 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); etb_probe()
428 if (!drvdata) etb_probe()
431 drvdata->dev = &adev->dev; etb_probe()
432 drvdata->atclk = devm_clk_get(&adev->dev, "atclk"); /* optional */ etb_probe()
433 if (!IS_ERR(drvdata->atclk)) { etb_probe()
434 ret = clk_prepare_enable(drvdata->atclk); etb_probe()
438 dev_set_drvdata(dev, drvdata); etb_probe()
445 drvdata->base = base; etb_probe()
447 spin_lock_init(&drvdata->spinlock); etb_probe()
449 drvdata->buffer_depth = etb_get_buffer_depth(drvdata); etb_probe()
452 if (drvdata->buffer_depth & 0x80000000) etb_probe()
455 drvdata->buf = devm_kzalloc(dev, etb_probe()
456 drvdata->buffer_depth * 4, GFP_KERNEL); etb_probe()
457 if (!drvdata->buf) { etb_probe()
459 drvdata->buffer_depth * 4); etb_probe()
473 drvdata->csdev = coresight_register(desc); etb_probe()
474 if (IS_ERR(drvdata->csdev)) etb_probe()
475 return PTR_ERR(drvdata->csdev); etb_probe()
477 drvdata->miscdev.name = pdata->name; etb_probe()
478 drvdata->miscdev.minor = MISC_DYNAMIC_MINOR; etb_probe()
479 drvdata->miscdev.fops = &etb_fops; etb_probe()
480 ret = misc_register(&drvdata->miscdev); etb_probe()
488 coresight_unregister(drvdata->csdev); etb_probe()
494 struct etb_drvdata *drvdata = amba_get_drvdata(adev); etb_remove() local
496 misc_deregister(&drvdata->miscdev); etb_remove()
497 coresight_unregister(drvdata->csdev); etb_remove()
504 struct etb_drvdata *drvdata = dev_get_drvdata(dev); etb_runtime_suspend() local
506 if (drvdata && !IS_ERR(drvdata->atclk)) etb_runtime_suspend()
507 clk_disable_unprepare(drvdata->atclk); etb_runtime_suspend()
514 struct etb_drvdata *drvdata = dev_get_drvdata(dev); etb_runtime_resume() local
516 if (drvdata && !IS_ERR(drvdata->atclk)) etb_runtime_resume()
517 clk_prepare_enable(drvdata->atclk); etb_runtime_resume()
|
| H A D | coresight-replicator-qcom.c | 49 struct replicator_state *drvdata = dev_get_drvdata(csdev->dev.parent); replicator_enable() local
51 pm_runtime_get_sync(drvdata->dev); replicator_enable()
53 CS_UNLOCK(drvdata->base); replicator_enable()
61 writel_relaxed(0x00, drvdata->base + REPLICATOR_IDFILTER0); replicator_enable()
62 writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER1); replicator_enable()
64 writel_relaxed(0x00, drvdata->base + REPLICATOR_IDFILTER1); replicator_enable()
65 writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0); replicator_enable()
68 CS_LOCK(drvdata->base); replicator_enable()
70 dev_info(drvdata->dev, "REPLICATOR enabled\n"); replicator_enable()
77 struct replicator_state *drvdata = dev_get_drvdata(csdev->dev.parent); replicator_disable() local
79 CS_UNLOCK(drvdata->base); replicator_disable()
83 writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0); replicator_disable()
85 writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER1); replicator_disable()
87 CS_LOCK(drvdata->base); replicator_disable()
89 pm_runtime_put(drvdata->dev); replicator_disable()
91 dev_info(drvdata->dev, "REPLICATOR disabled\n"); replicator_disable()
109 struct replicator_state *drvdata; replicator_probe() local
121 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); replicator_probe()
122 if (!drvdata) replicator_probe()
125 drvdata->dev = &adev->dev; replicator_probe()
126 drvdata->atclk = devm_clk_get(&adev->dev, "atclk"); /* optional */ replicator_probe()
127 if (!IS_ERR(drvdata->atclk)) { replicator_probe()
128 ret = clk_prepare_enable(drvdata->atclk); replicator_probe()
138 drvdata->base = base; replicator_probe()
139 dev_set_drvdata(dev, drvdata); replicator_probe()
151 drvdata->csdev = coresight_register(desc); replicator_probe()
152 if (IS_ERR(drvdata->csdev)) replicator_probe()
153 return PTR_ERR(drvdata->csdev); replicator_probe()
161 struct replicator_state *drvdata = amba_get_drvdata(adev); replicator_remove() local
164 coresight_unregister(drvdata->csdev); replicator_remove()
171 struct replicator_state *drvdata = dev_get_drvdata(dev); replicator_runtime_suspend() local
173 if (drvdata && !IS_ERR(drvdata->atclk)) replicator_runtime_suspend()
174 clk_disable_unprepare(drvdata->atclk); replicator_runtime_suspend()
181 struct replicator_state *drvdata = dev_get_drvdata(dev); replicator_runtime_resume() local
183 if (drvdata && !IS_ERR(drvdata->atclk)) replicator_runtime_resume()
184 clk_prepare_enable(drvdata->atclk); replicator_runtime_resume()
|
| H A D | coresight-tpiu.c | 64 static void tpiu_enable_hw(struct tpiu_drvdata *drvdata) tpiu_enable_hw() argument
66 CS_UNLOCK(drvdata->base); tpiu_enable_hw()
70 CS_LOCK(drvdata->base); tpiu_enable_hw()
75 struct tpiu_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); tpiu_enable() local
78 tpiu_enable_hw(drvdata); tpiu_enable()
80 dev_info(drvdata->dev, "TPIU enabled\n"); tpiu_enable()
84 static void tpiu_disable_hw(struct tpiu_drvdata *drvdata) tpiu_disable_hw() argument
86 CS_UNLOCK(drvdata->base); tpiu_disable_hw()
89 writel_relaxed(0x0, drvdata->base + TPIU_FFCR); tpiu_disable_hw()
91 writel_relaxed(FFCR_FON_MAN, drvdata->base + TPIU_FFCR); tpiu_disable_hw()
93 CS_LOCK(drvdata->base); tpiu_disable_hw()
98 struct tpiu_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); tpiu_disable() local
100 tpiu_disable_hw(drvdata); tpiu_disable()
103 dev_info(drvdata->dev, "TPIU disabled\n"); tpiu_disable()
121 struct tpiu_drvdata *drvdata; tpiu_probe() local
133 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); tpiu_probe()
134 if (!drvdata) tpiu_probe()
137 drvdata->dev = &adev->dev; tpiu_probe()
138 drvdata->atclk = devm_clk_get(&adev->dev, "atclk"); /* optional */ tpiu_probe()
139 if (!IS_ERR(drvdata->atclk)) { tpiu_probe()
140 ret = clk_prepare_enable(drvdata->atclk); tpiu_probe()
144 dev_set_drvdata(dev, drvdata); tpiu_probe()
151 drvdata->base = base; tpiu_probe()
154 tpiu_disable_hw(drvdata); tpiu_probe()
167 drvdata->csdev = coresight_register(desc); tpiu_probe()
168 if (IS_ERR(drvdata->csdev)) tpiu_probe()
169 return PTR_ERR(drvdata->csdev); tpiu_probe()
177 struct tpiu_drvdata *drvdata = amba_get_drvdata(adev); tpiu_remove() local
179 coresight_unregister(drvdata->csdev); tpiu_remove()
186 struct tpiu_drvdata *drvdata = dev_get_drvdata(dev); tpiu_runtime_suspend() local
188 if (drvdata && !IS_ERR(drvdata->atclk)) tpiu_runtime_suspend()
189 clk_disable_unprepare(drvdata->atclk); tpiu_runtime_suspend()
196 struct tpiu_drvdata *drvdata = dev_get_drvdata(dev); tpiu_runtime_resume() local
198 if (drvdata && !IS_ERR(drvdata->atclk)) tpiu_runtime_resume()
199 clk_prepare_enable(drvdata->atclk); tpiu_runtime_resume()
|
| H A D | coresight-funnel.c | 51 static void funnel_enable_hw(struct funnel_drvdata *drvdata, int port) funnel_enable_hw() argument
55 CS_UNLOCK(drvdata->base); funnel_enable_hw()
57 functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); funnel_enable_hw()
61 writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); funnel_enable_hw()
62 writel_relaxed(drvdata->priority, drvdata->base + FUNNEL_PRICTL); funnel_enable_hw()
64 CS_LOCK(drvdata->base); funnel_enable_hw()
70 struct funnel_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); funnel_enable() local
72 pm_runtime_get_sync(drvdata->dev); funnel_enable()
73 funnel_enable_hw(drvdata, inport); funnel_enable()
75 dev_info(drvdata->dev, "FUNNEL inport %d enabled\n", inport); funnel_enable()
79 static void funnel_disable_hw(struct funnel_drvdata *drvdata, int inport) funnel_disable_hw() argument
83 CS_UNLOCK(drvdata->base); funnel_disable_hw()
85 functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); funnel_disable_hw()
87 writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); funnel_disable_hw()
89 CS_LOCK(drvdata->base); funnel_disable_hw()
95 struct funnel_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); funnel_disable() local
97 funnel_disable_hw(drvdata, inport); funnel_disable()
98 pm_runtime_put(drvdata->dev); funnel_disable()
100 dev_info(drvdata->dev, "FUNNEL inport %d disabled\n", inport); funnel_disable()
115 struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent); priority_show() local
116 unsigned long val = drvdata->priority; priority_show()
127 struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent); priority_store() local
133 drvdata->priority = val; priority_store()
138 static u32 get_funnel_ctrl_hw(struct funnel_drvdata *drvdata) get_funnel_ctrl_hw() argument
142 CS_UNLOCK(drvdata->base); get_funnel_ctrl_hw()
143 functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); get_funnel_ctrl_hw()
144 CS_LOCK(drvdata->base); get_funnel_ctrl_hw()
153 struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent); funnel_ctrl_show() local
155 pm_runtime_get_sync(drvdata->dev); funnel_ctrl_show()
157 val = get_funnel_ctrl_hw(drvdata); funnel_ctrl_show()
159 pm_runtime_put(drvdata->dev); funnel_ctrl_show()
178 struct funnel_drvdata *drvdata; funnel_probe() local
190 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); funnel_probe()
191 if (!drvdata) funnel_probe()
194 drvdata->dev = &adev->dev; funnel_probe()
195 drvdata->atclk = devm_clk_get(&adev->dev, "atclk"); /* optional */ funnel_probe()
196 if (!IS_ERR(drvdata->atclk)) { funnel_probe()
197 ret = clk_prepare_enable(drvdata->atclk); funnel_probe()
201 dev_set_drvdata(dev, drvdata); funnel_probe()
208 drvdata->base = base; funnel_probe()
221 drvdata->csdev = coresight_register(desc); funnel_probe()
222 if (IS_ERR(drvdata->csdev)) funnel_probe()
223 return PTR_ERR(drvdata->csdev); funnel_probe()
231 struct funnel_drvdata *drvdata = amba_get_drvdata(adev); funnel_remove() local
233 coresight_unregister(drvdata->csdev); funnel_remove()
240 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); funnel_runtime_suspend() local
242 if (drvdata && !IS_ERR(drvdata->atclk)) funnel_runtime_suspend()
243 clk_disable_unprepare(drvdata->atclk); funnel_runtime_suspend()
250 struct funnel_drvdata *drvdata = dev_get_drvdata(dev); funnel_runtime_resume() local
252 if (drvdata && !IS_ERR(drvdata->atclk)) funnel_runtime_resume()
253 clk_prepare_enable(drvdata->atclk); funnel_runtime_resume()
|
| H A D | coresight-replicator.c | 42 struct replicator_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); replicator_enable() local
44 pm_runtime_get_sync(drvdata->dev); replicator_enable()
45 dev_info(drvdata->dev, "REPLICATOR enabled\n"); replicator_enable()
52 struct replicator_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); replicator_disable() local
54 pm_runtime_put(drvdata->dev); replicator_disable()
55 dev_info(drvdata->dev, "REPLICATOR disabled\n"); replicator_disable()
72 struct replicator_drvdata *drvdata; replicator_probe() local
83 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); replicator_probe()
84 if (!drvdata) replicator_probe()
87 drvdata->dev = &pdev->dev; replicator_probe()
88 drvdata->atclk = devm_clk_get(&pdev->dev, "atclk"); /* optional */ replicator_probe()
89 if (!IS_ERR(drvdata->atclk)) { replicator_probe()
90 ret = clk_prepare_enable(drvdata->atclk); replicator_probe()
97 platform_set_drvdata(pdev, drvdata); replicator_probe()
110 drvdata->csdev = coresight_register(desc); replicator_probe()
111 if (IS_ERR(drvdata->csdev)) { replicator_probe()
112 ret = PTR_ERR(drvdata->csdev); replicator_probe()
122 if (!IS_ERR(drvdata->atclk)) replicator_probe()
123 clk_disable_unprepare(drvdata->atclk); replicator_probe()
132 struct replicator_drvdata *drvdata = platform_get_drvdata(pdev); replicator_remove() local
134 coresight_unregister(drvdata->csdev); replicator_remove()
136 if (!IS_ERR(drvdata->atclk)) replicator_remove()
137 clk_disable_unprepare(drvdata->atclk); replicator_remove()
147 struct replicator_drvdata *drvdata = dev_get_drvdata(dev); replicator_runtime_suspend() local
149 if (drvdata && !IS_ERR(drvdata->atclk)) replicator_runtime_suspend()
150 clk_disable_unprepare(drvdata->atclk); replicator_runtime_suspend()
157 struct replicator_drvdata *drvdata = dev_get_drvdata(dev); replicator_runtime_resume() local
159 if (drvdata && !IS_ERR(drvdata->atclk)) replicator_runtime_resume()
160 clk_prepare_enable(drvdata->atclk); replicator_runtime_resume()
|
| /linux-4.4.14/drivers/input/serio/ |
| H A D | sun4i-ps2.c | 96 struct sun4i_ps2data *drvdata = dev_id; sun4i_ps2_interrupt() local
103 spin_lock(&drvdata->lock); sun4i_ps2_interrupt()
106 intr_status = readl(drvdata->reg_base + PS2_REG_LSTS); sun4i_ps2_interrupt()
107 fifo_status = readl(drvdata->reg_base + PS2_REG_FSTS); sun4i_ps2_interrupt()
117 writel(rval, drvdata->reg_base + PS2_REG_LSTS); sun4i_ps2_interrupt()
124 writel(rval, drvdata->reg_base + PS2_REG_FSTS); sun4i_ps2_interrupt()
129 byte = readl(drvdata->reg_base + PS2_REG_DATA) & 0xff; sun4i_ps2_interrupt()
130 serio_interrupt(drvdata->serio, byte, rxflags); sun4i_ps2_interrupt()
133 writel(intr_status, drvdata->reg_base + PS2_REG_LSTS); sun4i_ps2_interrupt()
134 writel(fifo_status, drvdata->reg_base + PS2_REG_FSTS); sun4i_ps2_interrupt()
136 spin_unlock(&drvdata->lock); sun4i_ps2_interrupt()
143 struct sun4i_ps2data *drvdata = serio->port_data; sun4i_ps2_open() local
153 writel(rval, drvdata->reg_base + PS2_REG_LCTL); sun4i_ps2_open()
160 writel(rval, drvdata->reg_base + PS2_REG_FCTL); sun4i_ps2_open()
162 src_clk = clk_get_rate(drvdata->clk); sun4i_ps2_open()
167 writel(rval, drvdata->reg_base + PS2_REG_CLKDR); sun4i_ps2_open()
173 spin_lock_irqsave(&drvdata->lock, flags); sun4i_ps2_open()
174 writel(rval, drvdata->reg_base + PS2_REG_GCTL); sun4i_ps2_open()
175 spin_unlock_irqrestore(&drvdata->lock, flags); sun4i_ps2_open()
182 struct sun4i_ps2data *drvdata = serio->port_data; sun4i_ps2_close() local
186 rval = readl(drvdata->reg_base + PS2_REG_GCTL); sun4i_ps2_close()
187 writel(rval & ~(PS2_GCTL_INTEN), drvdata->reg_base + PS2_REG_GCTL); sun4i_ps2_close()
189 synchronize_irq(drvdata->irq); sun4i_ps2_close()
195 struct sun4i_ps2data *drvdata = serio->port_data; sun4i_ps2_write() local
198 if (readl(drvdata->reg_base + PS2_REG_FSTS) & PS2_FSTS_TXRDY) { sun4i_ps2_write()
199 writel(val, drvdata->reg_base + PS2_REG_DATA); sun4i_ps2_write()
210 struct sun4i_ps2data *drvdata; sun4i_ps2_probe() local
216 drvdata = kzalloc(sizeof(struct sun4i_ps2data), GFP_KERNEL); sun4i_ps2_probe()
218 if (!drvdata || !serio) { sun4i_ps2_probe()
223 spin_lock_init(&drvdata->lock); sun4i_ps2_probe()
233 drvdata->reg_base = ioremap(res->start, resource_size(res)); sun4i_ps2_probe()
234 if (!drvdata->reg_base) { sun4i_ps2_probe()
240 drvdata->clk = clk_get(dev, NULL); sun4i_ps2_probe()
241 if (IS_ERR(drvdata->clk)) { sun4i_ps2_probe()
242 error = PTR_ERR(drvdata->clk); sun4i_ps2_probe()
247 error = clk_prepare_enable(drvdata->clk); sun4i_ps2_probe()
257 serio->port_data = drvdata; sun4i_ps2_probe()
263 writel(0, drvdata->reg_base + PS2_REG_GCTL); sun4i_ps2_probe()
273 drvdata->irq = irq; sun4i_ps2_probe()
274 drvdata->serio = serio; sun4i_ps2_probe()
275 drvdata->dev = dev; sun4i_ps2_probe()
277 error = request_irq(drvdata->irq, sun4i_ps2_interrupt, 0, sun4i_ps2_probe()
278 DRIVER_NAME, drvdata); sun4i_ps2_probe()
280 dev_err(drvdata->dev, "failed to allocate interrupt %d: %d\n", sun4i_ps2_probe()
281 drvdata->irq, error); sun4i_ps2_probe()
286 platform_set_drvdata(pdev, drvdata); sun4i_ps2_probe()
291 clk_disable_unprepare(drvdata->clk); sun4i_ps2_probe()
293 clk_put(drvdata->clk); sun4i_ps2_probe()
295 iounmap(drvdata->reg_base); sun4i_ps2_probe()
298 kfree(drvdata); sun4i_ps2_probe()
304 struct sun4i_ps2data *drvdata = platform_get_drvdata(pdev); sun4i_ps2_remove() local
306 serio_unregister_port(drvdata->serio); sun4i_ps2_remove()
308 free_irq(drvdata->irq, drvdata); sun4i_ps2_remove()
310 clk_disable_unprepare(drvdata->clk); sun4i_ps2_remove()
311 clk_put(drvdata->clk); sun4i_ps2_remove()
313 iounmap(drvdata->reg_base); sun4i_ps2_remove()
315 kfree(drvdata); sun4i_ps2_remove()
|
| H A D | xilinx_ps2.c | 86 * @drvdata: pointer to ps2 device private data structure
92 static int xps2_recv(struct xps2data *drvdata, u8 *byte) xps2_recv() argument
98 sr = in_be32(drvdata->base_address + XPS2_STATUS_OFFSET); xps2_recv()
100 *byte = in_be32(drvdata->base_address + XPS2_RX_DATA_OFFSET); xps2_recv()
112 struct xps2data *drvdata = dev_id; xps2_interrupt() local
118 intr_sr = in_be32(drvdata->base_address + XPS2_IPISR_OFFSET); xps2_interrupt()
119 out_be32(drvdata->base_address + XPS2_IPISR_OFFSET, intr_sr); xps2_interrupt()
123 dev_warn(drvdata->dev, "receive overrun error\n"); xps2_interrupt()
126 drvdata->flags |= SERIO_PARITY; xps2_interrupt()
129 drvdata->flags |= SERIO_TIMEOUT; xps2_interrupt()
132 status = xps2_recv(drvdata, &c); xps2_interrupt()
136 dev_err(drvdata->dev, xps2_interrupt()
139 serio_interrupt(drvdata->serio, c, drvdata->flags); xps2_interrupt()
140 drvdata->flags = 0; xps2_interrupt()
163 struct xps2data *drvdata = pserio->port_data; sxps2_write() local
168 spin_lock_irqsave(&drvdata->lock, flags); sxps2_write()
171 sr = in_be32(drvdata->base_address + XPS2_STATUS_OFFSET); sxps2_write()
173 out_be32(drvdata->base_address + XPS2_TX_DATA_OFFSET, c); sxps2_write()
177 spin_unlock_irqrestore(&drvdata->lock, flags); sxps2_write()
190 struct xps2data *drvdata = pserio->port_data; sxps2_open() local
194 error = request_irq(drvdata->irq, &xps2_interrupt, 0, sxps2_open()
195 DRIVER_NAME, drvdata); sxps2_open()
197 dev_err(drvdata->dev, sxps2_open()
198 "Couldn't allocate interrupt %d\n", drvdata->irq); sxps2_open()
203 out_be32(drvdata->base_address + XPS2_GIER_OFFSET, XPS2_GIER_GIE_MASK); sxps2_open()
204 out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, XPS2_IPIXR_RX_ALL); sxps2_open()
205 (void)xps2_recv(drvdata, &c); sxps2_open()
218 struct xps2data *drvdata = pserio->port_data; sxps2_close() local
221 out_be32(drvdata->base_address + XPS2_GIER_OFFSET, 0x00); sxps2_close()
222 out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, 0x00); sxps2_close()
223 free_irq(drvdata->irq, drvdata); sxps2_close()
239 struct xps2data *drvdata; xps2_of_probe() local
263 drvdata = kzalloc(sizeof(struct xps2data), GFP_KERNEL); xps2_of_probe()
265 if (!drvdata || !serio) { xps2_of_probe()
270 spin_lock_init(&drvdata->lock); xps2_of_probe()
271 drvdata->irq = irq; xps2_of_probe()
272 drvdata->serio = serio; xps2_of_probe()
273 drvdata->dev = dev; xps2_of_probe()
285 drvdata->base_address = ioremap(phys_addr, remap_size); xps2_of_probe()
286 if (drvdata->base_address == NULL) { xps2_of_probe()
294 out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, 0); xps2_of_probe()
298 out_be32(drvdata->base_address + XPS2_SRST_OFFSET, XPS2_SRST_RESET); xps2_of_probe()
301 (unsigned long long)phys_addr, drvdata->base_address, xps2_of_probe()
302 drvdata->irq); xps2_of_probe()
308 serio->port_data = drvdata; xps2_of_probe()
317 platform_set_drvdata(ofdev, drvdata); xps2_of_probe()
324 kfree(drvdata); xps2_of_probe()
339 struct xps2data *drvdata = platform_get_drvdata(of_dev); xps2_of_remove() local
342 serio_unregister_port(drvdata->serio); xps2_of_remove()
343 iounmap(drvdata->base_address); xps2_of_remove()
347 dev_err(drvdata->dev, "invalid address\n"); xps2_of_remove()
351 kfree(drvdata); xps2_of_remove()
|
| /linux-4.4.14/drivers/char/xilinx_hwicap/ |
| H A D | fifo_icap.c | 88 * @drvdata: a pointer to the drvdata.
93 static inline void fifo_icap_fifo_write(struct hwicap_drvdata *drvdata, fifo_icap_fifo_write() argument
96 dev_dbg(drvdata->dev, "fifo_write: %x\n", data); fifo_icap_fifo_write()
97 out_be32(drvdata->base_address + XHI_WF_OFFSET, data); fifo_icap_fifo_write()
102 * @drvdata: a pointer to the drvdata.
106 static inline u32 fifo_icap_fifo_read(struct hwicap_drvdata *drvdata) fifo_icap_fifo_read() argument
108 u32 data = in_be32(drvdata->base_address + XHI_RF_OFFSET); fifo_icap_fifo_read()
109 dev_dbg(drvdata->dev, "fifo_read: %x\n", data); fifo_icap_fifo_read()
115 * @drvdata: a pointer to the drvdata.
118 static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata, fifo_icap_set_read_size() argument
121 out_be32(drvdata->base_address + XHI_SZ_OFFSET, data); fifo_icap_set_read_size()
126 * @drvdata: a pointer to the drvdata.
128 static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata) fifo_icap_start_config() argument
130 out_be32(drvdata->base_address + XHI_CR_OFFSET, XHI_CR_WRITE_MASK); fifo_icap_start_config()
131 dev_dbg(drvdata->dev, "configuration started\n"); fifo_icap_start_config()
136 * @drvdata: a pointer to the drvdata.
138 static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata) fifo_icap_start_readback() argument
140 out_be32(drvdata->base_address + XHI_CR_OFFSET, XHI_CR_READ_MASK); fifo_icap_start_readback()
141 dev_dbg(drvdata->dev, "readback started\n"); fifo_icap_start_readback()
146 * @drvdata: a pointer to the drvdata.
160 u32 fifo_icap_get_status(struct hwicap_drvdata *drvdata) fifo_icap_get_status() argument
162 u32 status = in_be32(drvdata->base_address + XHI_SR_OFFSET); fifo_icap_get_status()
163 dev_dbg(drvdata->dev, "Getting status = %x\n", status); fifo_icap_get_status()
169 * @drvdata: a pointer to the drvdata.
171 static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata) fifo_icap_busy() argument
173 u32 status = in_be32(drvdata->base_address + XHI_SR_OFFSET); fifo_icap_busy()
179 * @drvdata: a pointer to the drvdata.
184 struct hwicap_drvdata *drvdata) fifo_icap_write_fifo_vacancy()
186 return in_be32(drvdata->base_address + XHI_WFV_OFFSET); fifo_icap_write_fifo_vacancy()
191 * @drvdata: a pointer to the drvdata.
196 struct hwicap_drvdata *drvdata) fifo_icap_read_fifo_occupancy()
198 return in_be32(drvdata->base_address + XHI_RFO_OFFSET); fifo_icap_read_fifo_occupancy()
203 * @drvdata: a pointer to the drvdata.
213 int fifo_icap_set_configuration(struct hwicap_drvdata *drvdata, fifo_icap_set_configuration() argument
221 dev_dbg(drvdata->dev, "fifo_set_configuration\n"); fifo_icap_set_configuration()
226 if (fifo_icap_busy(drvdata)) fifo_icap_set_configuration()
240 fifo_icap_write_fifo_vacancy(drvdata); fifo_icap_set_configuration()
251 fifo_icap_fifo_write(drvdata, *frame_buffer); fifo_icap_set_configuration()
258 fifo_icap_start_config(drvdata); fifo_icap_set_configuration()
262 while (fifo_icap_busy(drvdata)) { fifo_icap_set_configuration()
268 dev_dbg(drvdata->dev, "done fifo_set_configuration\n"); fifo_icap_set_configuration()
282 * @drvdata: a pointer to the drvdata.
289 int fifo_icap_get_configuration(struct hwicap_drvdata *drvdata, fifo_icap_get_configuration() argument
299 dev_dbg(drvdata->dev, "fifo_get_configuration\n"); fifo_icap_get_configuration()
304 if (fifo_icap_busy(drvdata)) fifo_icap_get_configuration()
318 fifo_icap_set_read_size(drvdata, words_to_read); fifo_icap_get_configuration()
319 fifo_icap_start_readback(drvdata); fifo_icap_get_configuration()
325 fifo_icap_read_fifo_occupancy(drvdata); fifo_icap_get_configuration()
338 *data++ = fifo_icap_fifo_read(drvdata); fifo_icap_get_configuration()
344 dev_dbg(drvdata->dev, "done fifo_get_configuration\n"); fifo_icap_get_configuration()
351 * @drvdata: a pointer to the drvdata.
357 void fifo_icap_reset(struct hwicap_drvdata *drvdata) fifo_icap_reset() argument
364 reg_data = in_be32(drvdata->base_address + XHI_CR_OFFSET); fifo_icap_reset()
366 out_be32(drvdata->base_address + XHI_CR_OFFSET, fifo_icap_reset()
369 out_be32(drvdata->base_address + XHI_CR_OFFSET, fifo_icap_reset()
376 * @drvdata: a pointer to the drvdata.
378 void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata) fifo_icap_flush_fifo() argument
385 reg_data = in_be32(drvdata->base_address + XHI_CR_OFFSET); fifo_icap_flush_fifo()
387 out_be32(drvdata->base_address + XHI_CR_OFFSET, fifo_icap_flush_fifo()
390 out_be32(drvdata->base_address + XHI_CR_OFFSET, fifo_icap_flush_fifo()
183 fifo_icap_write_fifo_vacancy( struct hwicap_drvdata *drvdata) fifo_icap_write_fifo_vacancy() argument
195 fifo_icap_read_fifo_occupancy( struct hwicap_drvdata *drvdata) fifo_icap_read_fifo_occupancy() argument
|
| H A D | xilinx_hwicap.c | 223 * @drvdata: a pointer to the drvdata.
229 static int hwicap_command_desync(struct hwicap_drvdata *drvdata) hwicap_command_desync() argument
237 buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1; hwicap_command_desync()
246 return drvdata->config->set_configuration(drvdata, hwicap_command_desync()
252 * @drvdata: a pointer to the drvdata.
261 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata, hwicap_get_configuration_register() argument
281 status = drvdata->config->set_configuration(drvdata, hwicap_get_configuration_register()
287 status = drvdata->config->get_status(drvdata); hwicap_get_configuration_register()
300 status = drvdata->config->set_configuration(drvdata, hwicap_get_configuration_register()
308 status = drvdata->config->get_configuration(drvdata, reg_data, 1); hwicap_get_configuration_register()
315 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata) hwicap_initialize_hwicap() argument
320 dev_dbg(drvdata->dev, "initializing\n"); hwicap_initialize_hwicap()
324 dev_dbg(drvdata->dev, "Reset...\n"); hwicap_initialize_hwicap()
325 drvdata->config->reset(drvdata); hwicap_initialize_hwicap()
327 dev_dbg(drvdata->dev, "Desync...\n"); hwicap_initialize_hwicap()
328 status = hwicap_command_desync(drvdata); hwicap_initialize_hwicap()
336 dev_dbg(drvdata->dev, "Reading IDCODE...\n"); hwicap_initialize_hwicap()
338 drvdata, drvdata->config_regs->IDCODE, &idcode); hwicap_initialize_hwicap()
339 dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode); hwicap_initialize_hwicap()
343 dev_dbg(drvdata->dev, "Desync...\n"); hwicap_initialize_hwicap()
344 status = hwicap_command_desync(drvdata); hwicap_initialize_hwicap()
354 struct hwicap_drvdata *drvdata = file->private_data; hwicap_read() local
361 status = mutex_lock_interruptible(&drvdata->sem); hwicap_read()
365 if (drvdata->read_buffer_in_use) { hwicap_read()
370 (count < drvdata->read_buffer_in_use) ? count : hwicap_read()
371 drvdata->read_buffer_in_use; hwicap_read()
374 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) { hwicap_read()
378 drvdata->read_buffer_in_use -= bytes_to_read; hwicap_read()
379 memmove(drvdata->read_buffer, hwicap_read()
380 drvdata->read_buffer + bytes_to_read, hwicap_read()
409 status = drvdata->config->get_configuration(drvdata, hwicap_read()
424 memcpy(drvdata->read_buffer, hwicap_read()
427 drvdata->read_buffer_in_use = bytes_remaining; hwicap_read()
432 mutex_unlock(&drvdata->sem); hwicap_read()
440 struct hwicap_drvdata *drvdata = file->private_data; hwicap_write() local
447 status = mutex_lock_interruptible(&drvdata->sem); hwicap_write()
451 left += drvdata->write_buffer_in_use; hwicap_write()
474 if (drvdata->write_buffer_in_use) { hwicap_write()
475 memcpy(kbuf, drvdata->write_buffer, hwicap_write()
476 drvdata->write_buffer_in_use); hwicap_write()
478 (((char *)kbuf) + drvdata->write_buffer_in_use), hwicap_write()
480 len - (drvdata->write_buffer_in_use))) { hwicap_write()
493 status = drvdata->config->set_configuration(drvdata, hwicap_write()
501 if (drvdata->write_buffer_in_use) { hwicap_write()
502 len -= drvdata->write_buffer_in_use; hwicap_write()
503 left -= drvdata->write_buffer_in_use; hwicap_write()
504 drvdata->write_buffer_in_use = 0; hwicap_write()
510 if (!copy_from_user(drvdata->write_buffer, hwicap_write()
512 drvdata->write_buffer_in_use = left; hwicap_write()
521 mutex_unlock(&drvdata->sem); hwicap_write()
527 struct hwicap_drvdata *drvdata; hwicap_open() local
531 drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev); hwicap_open()
533 status = mutex_lock_interruptible(&drvdata->sem); hwicap_open()
537 if (drvdata->is_open) { hwicap_open()
542 status = hwicap_initialize_hwicap(drvdata); hwicap_open()
544 dev_err(drvdata->dev, "Failed to open file"); hwicap_open()
548 file->private_data = drvdata; hwicap_open()
549 drvdata->write_buffer_in_use = 0; hwicap_open()
550 drvdata->read_buffer_in_use = 0; hwicap_open()
551 drvdata->is_open = 1; hwicap_open()
554 mutex_unlock(&drvdata->sem); hwicap_open()
562 struct hwicap_drvdata *drvdata = file->private_data; hwicap_release() local
566 mutex_lock(&drvdata->sem); hwicap_release()
568 if (drvdata->write_buffer_in_use) { hwicap_release()
570 for (i = drvdata->write_buffer_in_use; i < 4; i++) hwicap_release()
571 drvdata->write_buffer[i] = 0; hwicap_release()
573 status = drvdata->config->set_configuration(drvdata, hwicap_release()
574 (u32 *) drvdata->write_buffer, 1); hwicap_release()
579 status = hwicap_command_desync(drvdata); hwicap_release()
584 drvdata->is_open = 0; hwicap_release()
585 mutex_unlock(&drvdata->sem); hwicap_release()
604 struct hwicap_drvdata *drvdata = NULL; hwicap_setup() local
633 drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL); hwicap_setup()
634 if (!drvdata) { hwicap_setup()
639 dev_set_drvdata(dev, (void *)drvdata); hwicap_setup()
647 drvdata->mem_start = regs_res->start; hwicap_setup()
648 drvdata->mem_end = regs_res->end; hwicap_setup()
649 drvdata->mem_size = resource_size(regs_res); hwicap_setup()
651 if (!request_mem_region(drvdata->mem_start, hwicap_setup()
652 drvdata->mem_size, DRIVER_NAME)) { hwicap_setup()
659 drvdata->devt = devt; hwicap_setup()
660 drvdata->dev = dev; hwicap_setup()
661 drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size); hwicap_setup()
662 if (!drvdata->base_address) { hwicap_setup()
668 drvdata->config = config; hwicap_setup()
669 drvdata->config_regs = config_regs; hwicap_setup()
671 mutex_init(&drvdata->sem); hwicap_setup()
672 drvdata->is_open = 0; hwicap_setup()
675 (unsigned long long) drvdata->mem_start, hwicap_setup()
676 drvdata->base_address, hwicap_setup()
677 (unsigned long long) drvdata->mem_size); hwicap_setup()
679 cdev_init(&drvdata->cdev, &hwicap_fops); hwicap_setup()
680 drvdata->cdev.owner = THIS_MODULE; hwicap_setup()
681 retval = cdev_add(&drvdata->cdev, devt, 1); hwicap_setup()
691 iounmap(drvdata->base_address); hwicap_setup()
694 release_mem_region(regs_res->start, drvdata->mem_size); hwicap_setup()
697 kfree(drvdata); hwicap_setup()
723 struct hwicap_drvdata *drvdata; hwicap_remove() local
725 drvdata = dev_get_drvdata(dev); hwicap_remove()
727 if (!drvdata) hwicap_remove()
730 device_destroy(icap_class, drvdata->devt); hwicap_remove()
731 cdev_del(&drvdata->cdev); hwicap_remove()
732 iounmap(drvdata->base_address); hwicap_remove()
733 release_mem_region(drvdata->mem_start, drvdata->mem_size); hwicap_remove()
734 kfree(drvdata); hwicap_remove()
|
| H A D | buffer_icap.c | 74 * @drvdata: a pointer to the drvdata.
88 u32 buffer_icap_get_status(struct hwicap_drvdata *drvdata) buffer_icap_get_status() argument
90 return in_be32(drvdata->base_address + XHI_STATUS_REG_OFFSET); buffer_icap_get_status()
182 * @drvdata: a pointer to the drvdata.
187 static int buffer_icap_device_read(struct hwicap_drvdata *drvdata, buffer_icap_device_read() argument
192 void __iomem *base_address = drvdata->base_address; buffer_icap_device_read()
216 * @drvdata: a pointer to the drvdata.
221 static int buffer_icap_device_write(struct hwicap_drvdata *drvdata, buffer_icap_device_write() argument
226 void __iomem *base_address = drvdata->base_address; buffer_icap_device_write()
250 * @drvdata: a pointer to the drvdata.
256 void buffer_icap_reset(struct hwicap_drvdata *drvdata) buffer_icap_reset() argument
258 out_be32(drvdata->base_address + XHI_STATUS_REG_OFFSET, 0xFEFE); buffer_icap_reset()
263 * @drvdata: a pointer to the drvdata.
267 int buffer_icap_set_configuration(struct hwicap_drvdata *drvdata, u32 *data, buffer_icap_set_configuration() argument
275 void __iomem *base_address = drvdata->base_address; buffer_icap_set_configuration()
291 drvdata, buffer_icap_set_configuration()
296 buffer_icap_reset(drvdata); buffer_icap_set_configuration()
308 status = buffer_icap_device_write(drvdata, XHI_BUFFER_START, buffer_icap_set_configuration()
312 buffer_icap_reset(drvdata); buffer_icap_set_configuration()
322 * @drvdata: a pointer to the drvdata.
326 int buffer_icap_get_configuration(struct hwicap_drvdata *drvdata, u32 *data, buffer_icap_get_configuration() argument
333 void __iomem *base_address = drvdata->base_address; buffer_icap_get_configuration()
346 drvdata, buffer_icap_get_configuration()
351 buffer_icap_reset(drvdata); buffer_icap_get_configuration()
|
| H A D | fifo_icap.h | 45 struct hwicap_drvdata *drvdata,
51 struct hwicap_drvdata *drvdata,
55 u32 fifo_icap_get_status(struct hwicap_drvdata *drvdata);
56 void fifo_icap_reset(struct hwicap_drvdata *drvdata);
57 void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata);
|
| H A D | buffer_icap.h | 44 int buffer_icap_set_configuration(struct hwicap_drvdata *drvdata, u32 *data,
48 int buffer_icap_get_configuration(struct hwicap_drvdata *drvdata, u32 *data,
51 u32 buffer_icap_get_status(struct hwicap_drvdata *drvdata);
52 void buffer_icap_reset(struct hwicap_drvdata *drvdata);
|
| H A D | xilinx_hwicap.h | 66 int (*get_configuration)(struct hwicap_drvdata *drvdata, u32 *data,
70 int (*set_configuration)(struct hwicap_drvdata *drvdata, u32 *data,
83 u32 (*get_status)(struct hwicap_drvdata *drvdata);
85 void (*reset)(struct hwicap_drvdata *drvdata);
|
| /linux-4.4.14/sound/soc/qcom/ |
| H A D | lpass-cpu.c | 33 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_set_sysclk() local
36 if (IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) lpass_cpu_daiops_set_sysclk()
39 ret = clk_set_rate(drvdata->mi2s_osr_clk[dai->driver->id], freq); lpass_cpu_daiops_set_sysclk()
50 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_startup() local
53 if (!IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) { lpass_cpu_daiops_startup()
55 drvdata->mi2s_osr_clk[dai->driver->id]); lpass_cpu_daiops_startup()
63 ret = clk_prepare_enable(drvdata->mi2s_bit_clk[dai->driver->id]); lpass_cpu_daiops_startup()
67 if (!IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) lpass_cpu_daiops_startup()
69 drvdata->mi2s_osr_clk[dai->driver->id]); lpass_cpu_daiops_startup()
79 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_shutdown() local
81 clk_disable_unprepare(drvdata->mi2s_bit_clk[dai->driver->id]); lpass_cpu_daiops_shutdown()
83 if (!IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) lpass_cpu_daiops_shutdown()
84 clk_disable_unprepare(drvdata->mi2s_osr_clk[dai->driver->id]); lpass_cpu_daiops_shutdown()
90 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_hw_params() local
150 ret = regmap_write(drvdata->lpaif_map, lpass_cpu_daiops_hw_params()
151 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), lpass_cpu_daiops_hw_params()
159 ret = clk_set_rate(drvdata->mi2s_bit_clk[dai->driver->id], lpass_cpu_daiops_hw_params()
173 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_hw_free() local
176 ret = regmap_write(drvdata->lpaif_map, lpass_cpu_daiops_hw_free()
177 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), lpass_cpu_daiops_hw_free()
189 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_prepare() local
192 ret = regmap_update_bits(drvdata->lpaif_map, lpass_cpu_daiops_prepare()
193 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), lpass_cpu_daiops_prepare()
205 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); lpass_cpu_daiops_trigger() local
212 ret = regmap_update_bits(drvdata->lpaif_map, lpass_cpu_daiops_trigger()
213 LPAIF_I2SCTL_REG(drvdata->variant, lpass_cpu_daiops_trigger()
224 ret = regmap_update_bits(drvdata->lpaif_map, lpass_cpu_daiops_trigger()
225 LPAIF_I2SCTL_REG(drvdata->variant, lpass_cpu_daiops_trigger()
251 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); asoc_qcom_lpass_cpu_dai_probe() local
255 ret = regmap_write(drvdata->lpaif_map, asoc_qcom_lpass_cpu_dai_probe()
256 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), 0); asoc_qcom_lpass_cpu_dai_probe()
271 struct lpass_data *drvdata = dev_get_drvdata(dev); lpass_cpu_regmap_writeable() local
272 struct lpass_variant *v = drvdata->variant; lpass_cpu_regmap_writeable()
302 struct lpass_data *drvdata = dev_get_drvdata(dev); lpass_cpu_regmap_readable() local
303 struct lpass_variant *v = drvdata->variant; lpass_cpu_regmap_readable()
335 struct lpass_data *drvdata = dev_get_drvdata(dev); lpass_cpu_regmap_volatile() local
336 struct lpass_variant *v = drvdata->variant; lpass_cpu_regmap_volatile()
362 struct lpass_data *drvdata; asoc_qcom_lpass_cpu_platform_probe() local
378 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct lpass_data), asoc_qcom_lpass_cpu_platform_probe()
380 if (!drvdata) asoc_qcom_lpass_cpu_platform_probe()
382 platform_set_drvdata(pdev, drvdata); asoc_qcom_lpass_cpu_platform_probe()
388 drvdata->variant = (struct lpass_variant *)match->data; asoc_qcom_lpass_cpu_platform_probe()
389 variant = drvdata->variant; asoc_qcom_lpass_cpu_platform_probe()
393 drvdata->lpaif = devm_ioremap_resource(&pdev->dev, res); asoc_qcom_lpass_cpu_platform_probe()
394 if (IS_ERR((void const __force *)drvdata->lpaif)) { asoc_qcom_lpass_cpu_platform_probe()
397 PTR_ERR((void const __force *)drvdata->lpaif)); asoc_qcom_lpass_cpu_platform_probe()
398 return PTR_ERR((void const __force *)drvdata->lpaif); asoc_qcom_lpass_cpu_platform_probe()
404 drvdata->lpaif_map = devm_regmap_init_mmio(&pdev->dev, drvdata->lpaif, asoc_qcom_lpass_cpu_platform_probe()
406 if (IS_ERR(drvdata->lpaif_map)) { asoc_qcom_lpass_cpu_platform_probe()
408 __func__, PTR_ERR(drvdata->lpaif_map)); asoc_qcom_lpass_cpu_platform_probe()
409 return PTR_ERR(drvdata->lpaif_map); asoc_qcom_lpass_cpu_platform_probe()
422 drvdata->mi2s_osr_clk[dai_id] = devm_clk_get(&pdev->dev, asoc_qcom_lpass_cpu_platform_probe()
424 if (IS_ERR(drvdata->mi2s_osr_clk[dai_id])) { asoc_qcom_lpass_cpu_platform_probe()
428 PTR_ERR(drvdata->mi2s_osr_clk[dai_id])); asoc_qcom_lpass_cpu_platform_probe()
436 drvdata->mi2s_bit_clk[dai_id] = devm_clk_get(&pdev->dev, asoc_qcom_lpass_cpu_platform_probe()
438 if (IS_ERR(drvdata->mi2s_bit_clk[dai_id])) { asoc_qcom_lpass_cpu_platform_probe()
442 PTR_ERR(drvdata->mi2s_bit_clk[dai_id])); asoc_qcom_lpass_cpu_platform_probe()
443 return PTR_ERR(drvdata->mi2s_bit_clk[dai_id]); asoc_qcom_lpass_cpu_platform_probe()
447 drvdata->ahbix_clk = devm_clk_get(&pdev->dev, "ahbix-clk"); asoc_qcom_lpass_cpu_platform_probe()
448 if (IS_ERR(drvdata->ahbix_clk)) { asoc_qcom_lpass_cpu_platform_probe()
450 __func__, PTR_ERR(drvdata->ahbix_clk)); asoc_qcom_lpass_cpu_platform_probe()
451 return PTR_ERR(drvdata->ahbix_clk); asoc_qcom_lpass_cpu_platform_probe()
454 ret = clk_set_rate(drvdata->ahbix_clk, LPASS_AHBIX_CLOCK_FREQUENCY); asoc_qcom_lpass_cpu_platform_probe()
461 clk_get_rate(drvdata->ahbix_clk)); asoc_qcom_lpass_cpu_platform_probe()
463 ret = clk_prepare_enable(drvdata->ahbix_clk); asoc_qcom_lpass_cpu_platform_probe()
490 clk_disable_unprepare(drvdata->ahbix_clk); asoc_qcom_lpass_cpu_platform_probe()
497 struct lpass_data *drvdata = platform_get_drvdata(pdev); asoc_qcom_lpass_cpu_platform_remove() local
499 if (drvdata->variant->exit) asoc_qcom_lpass_cpu_platform_remove()
500 drvdata->variant->exit(pdev); asoc_qcom_lpass_cpu_platform_remove()
502 clk_disable_unprepare(drvdata->ahbix_clk); asoc_qcom_lpass_cpu_platform_remove()
|
| H A D | lpass-apq8016.c | 136 static int apq8016_lpass_alloc_dma_channel(struct lpass_data *drvdata) apq8016_lpass_alloc_dma_channel() argument
138 struct lpass_variant *v = drvdata->variant; apq8016_lpass_alloc_dma_channel()
139 int chan = find_first_zero_bit(&drvdata->rdma_ch_bit_map, apq8016_lpass_alloc_dma_channel()
145 set_bit(chan, &drvdata->rdma_ch_bit_map); apq8016_lpass_alloc_dma_channel()
150 static int apq8016_lpass_free_dma_channel(struct lpass_data *drvdata, int chan) apq8016_lpass_free_dma_channel() argument
152 clear_bit(chan, &drvdata->rdma_ch_bit_map); apq8016_lpass_free_dma_channel()
159 struct lpass_data *drvdata = platform_get_drvdata(pdev); apq8016_lpass_init() local
163 drvdata->pcnoc_mport_clk = devm_clk_get(dev, "pcnoc-mport-clk"); apq8016_lpass_init()
164 if (IS_ERR(drvdata->pcnoc_mport_clk)) { apq8016_lpass_init()
166 __func__, PTR_ERR(drvdata->pcnoc_mport_clk)); apq8016_lpass_init()
167 return PTR_ERR(drvdata->pcnoc_mport_clk); apq8016_lpass_init()
170 ret = clk_prepare_enable(drvdata->pcnoc_mport_clk); apq8016_lpass_init()
177 drvdata->pcnoc_sway_clk = devm_clk_get(dev, "pcnoc-sway-clk"); apq8016_lpass_init()
178 if (IS_ERR(drvdata->pcnoc_sway_clk)) { apq8016_lpass_init()
180 __func__, PTR_ERR(drvdata->pcnoc_sway_clk)); apq8016_lpass_init()
181 return PTR_ERR(drvdata->pcnoc_sway_clk); apq8016_lpass_init()
184 ret = clk_prepare_enable(drvdata->pcnoc_sway_clk); apq8016_lpass_init()
196 struct lpass_data *drvdata = platform_get_drvdata(pdev); apq8016_lpass_exit() local
198 clk_disable_unprepare(drvdata->pcnoc_mport_clk); apq8016_lpass_exit()
199 clk_disable_unprepare(drvdata->pcnoc_sway_clk); apq8016_lpass_exit()
|
| H A D | lpass-platform.c | 87 struct lpass_data *drvdata = lpass_platform_pcmops_hw_params() local
89 struct lpass_variant *v = drvdata->variant; lpass_platform_pcmops_hw_params()
159 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcmops_hw_params()
174 struct lpass_data *drvdata = lpass_platform_pcmops_hw_free() local
176 struct lpass_variant *v = drvdata->variant; lpass_platform_pcmops_hw_free()
179 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcmops_hw_free()
193 struct lpass_data *drvdata = lpass_platform_pcmops_prepare() local
195 struct lpass_variant *v = drvdata->variant; lpass_platform_pcmops_prepare()
198 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcmops_prepare()
207 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcmops_prepare()
216 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcmops_prepare()
225 ret = regmap_update_bits(drvdata->lpaif_map, lpass_platform_pcmops_prepare()
242 struct lpass_data *drvdata = lpass_platform_pcmops_trigger() local
244 struct lpass_variant *v = drvdata->variant; lpass_platform_pcmops_trigger()
252 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcmops_trigger()
261 ret = regmap_update_bits(drvdata->lpaif_map, lpass_platform_pcmops_trigger()
271 ret = regmap_update_bits(drvdata->lpaif_map, lpass_platform_pcmops_trigger()
284 ret = regmap_update_bits(drvdata->lpaif_map, lpass_platform_pcmops_trigger()
294 ret = regmap_update_bits(drvdata->lpaif_map, lpass_platform_pcmops_trigger()
313 struct lpass_data *drvdata = lpass_platform_pcmops_pointer() local
315 struct lpass_variant *v = drvdata->variant; lpass_platform_pcmops_pointer()
319 ret = regmap_read(drvdata->lpaif_map, lpass_platform_pcmops_pointer()
327 ret = regmap_read(drvdata->lpaif_map, lpass_platform_pcmops_pointer()
361 struct lpass_data *drvdata, lpass_dma_interrupt_handler()
365 struct lpass_variant *v = drvdata->variant; lpass_dma_interrupt_handler()
370 rv = regmap_write(drvdata->lpaif_map, lpass_dma_interrupt_handler()
383 rv = regmap_write(drvdata->lpaif_map, lpass_dma_interrupt_handler()
397 rv = regmap_write(drvdata->lpaif_map, lpass_dma_interrupt_handler()
415 struct lpass_data *drvdata = data; lpass_platform_lpaif_irq() local
416 struct lpass_variant *v = drvdata->variant; lpass_platform_lpaif_irq()
420 rv = regmap_read(drvdata->lpaif_map, lpass_platform_lpaif_irq()
430 if (irqs & LPAIF_IRQ_ALL(chan) && drvdata->substream[chan]) { lpass_platform_lpaif_irq()
432 drvdata->substream[chan], lpass_platform_lpaif_irq()
433 drvdata, chan, irqs); lpass_platform_lpaif_irq()
481 struct lpass_data *drvdata = lpass_platform_pcm_new() local
483 struct lpass_variant *v = drvdata->variant; lpass_platform_pcm_new()
492 data->rdma_ch = v->alloc_dma_channel(drvdata); lpass_platform_pcm_new()
497 drvdata->substream[data->rdma_ch] = substream; lpass_platform_pcm_new()
509 ret = regmap_write(drvdata->lpaif_map, lpass_platform_pcm_new()
529 struct lpass_data *drvdata = lpass_platform_pcm_free() local
532 struct lpass_variant *v = drvdata->variant; lpass_platform_pcm_free()
534 drvdata->substream[data->rdma_ch] = NULL; lpass_platform_pcm_free()
537 v->free_dma_channel(drvdata, data->rdma_ch); lpass_platform_pcm_free()
550 struct lpass_data *drvdata = platform_get_drvdata(pdev); asoc_qcom_lpass_platform_register() local
551 struct lpass_variant *v = drvdata->variant; asoc_qcom_lpass_platform_register()
554 drvdata->lpaif_irq = platform_get_irq_byname(pdev, "lpass-irq-lpaif"); asoc_qcom_lpass_platform_register()
555 if (drvdata->lpaif_irq < 0) { asoc_qcom_lpass_platform_register()
557 __func__, drvdata->lpaif_irq); asoc_qcom_lpass_platform_register()
562 ret = regmap_write(drvdata->lpaif_map, asoc_qcom_lpass_platform_register()
570 ret = devm_request_irq(&pdev->dev, drvdata->lpaif_irq, asoc_qcom_lpass_platform_register()
572 "lpass-irq-lpaif", drvdata); asoc_qcom_lpass_platform_register()
359 lpass_dma_interrupt_handler( struct snd_pcm_substream *substream, struct lpass_data *drvdata, int chan, u32 interrupts) lpass_dma_interrupt_handler() argument
|
| H A D | lpass-ipq806x.c | 66 static int ipq806x_lpass_alloc_dma_channel(struct lpass_data *drvdata) ipq806x_lpass_alloc_dma_channel() argument
71 static int ipq806x_lpass_free_dma_channel(struct lpass_data *drvdata, int chan) ipq806x_lpass_free_dma_channel() argument
|
| /linux-4.4.14/drivers/video/fbdev/ |
| H A D | xilinxfb.c | 167 static void xilinx_fb_out32(struct xilinxfb_drvdata *drvdata, u32 offset, xilinx_fb_out32() argument
170 if (drvdata->flags & BUS_ACCESS_FLAG) { xilinx_fb_out32()
171 if (drvdata->flags & LITTLE_ENDIAN_ACCESS) xilinx_fb_out32()
172 iowrite32(val, drvdata->regs + (offset << 2)); xilinx_fb_out32()
174 iowrite32be(val, drvdata->regs + (offset << 2)); xilinx_fb_out32()
178 dcr_write(drvdata->dcr_host, offset, val); xilinx_fb_out32()
182 static u32 xilinx_fb_in32(struct xilinxfb_drvdata *drvdata, u32 offset) xilinx_fb_in32() argument
184 if (drvdata->flags & BUS_ACCESS_FLAG) { xilinx_fb_in32()
185 if (drvdata->flags & LITTLE_ENDIAN_ACCESS) xilinx_fb_in32()
186 return ioread32(drvdata->regs + (offset << 2)); xilinx_fb_in32()
188 return ioread32be(drvdata->regs + (offset << 2)); xilinx_fb_in32()
192 return dcr_read(drvdata->dcr_host, offset); xilinx_fb_in32()
228 struct xilinxfb_drvdata *drvdata = to_xilinxfb_drvdata(fbi); xilinx_fb_blank() local
233 xilinx_fb_out32(drvdata, REG_CTRL, drvdata->reg_ctrl_default); xilinx_fb_blank()
241 xilinx_fb_out32(drvdata, REG_CTRL, 0); xilinx_fb_blank()
264 struct xilinxfb_drvdata *drvdata, xilinxfb_assign()
271 if (drvdata->flags & BUS_ACCESS_FLAG) { xilinxfb_assign()
275 drvdata->regs = devm_ioremap_resource(&pdev->dev, res); xilinxfb_assign()
276 if (IS_ERR(drvdata->regs)) xilinxfb_assign()
277 return PTR_ERR(drvdata->regs); xilinxfb_assign()
279 drvdata->regs_phys = res->start; xilinxfb_assign()
284 drvdata->fb_phys = pdata->fb_phys; xilinxfb_assign()
285 drvdata->fb_virt = ioremap(pdata->fb_phys, fbsize); xilinxfb_assign()
287 drvdata->fb_alloced = 1; xilinxfb_assign()
288 drvdata->fb_virt = dma_alloc_coherent(dev, PAGE_ALIGN(fbsize), xilinxfb_assign()
289 &drvdata->fb_phys, GFP_KERNEL); xilinxfb_assign()
292 if (!drvdata->fb_virt) { xilinxfb_assign()
298 memset_io((void __iomem *)drvdata->fb_virt, 0, fbsize); xilinxfb_assign()
301 xilinx_fb_out32(drvdata, REG_FB_ADDR, drvdata->fb_phys); xilinxfb_assign()
302 rc = xilinx_fb_in32(drvdata, REG_FB_ADDR); xilinxfb_assign()
304 if (rc != drvdata->fb_phys) { xilinxfb_assign()
305 drvdata->flags |= LITTLE_ENDIAN_ACCESS; xilinxfb_assign()
306 xilinx_fb_out32(drvdata, REG_FB_ADDR, drvdata->fb_phys); xilinxfb_assign()
310 drvdata->reg_ctrl_default = REG_CTRL_ENABLE; xilinxfb_assign()
312 drvdata->reg_ctrl_default |= REG_CTRL_ROTATE; xilinxfb_assign()
313 xilinx_fb_out32(drvdata, REG_CTRL, xilinxfb_assign()
314 drvdata->reg_ctrl_default); xilinxfb_assign()
317 drvdata->info.device = dev; xilinxfb_assign()
318 drvdata->info.screen_base = (void __iomem *)drvdata->fb_virt; xilinxfb_assign()
319 drvdata->info.fbops = &xilinxfb_ops; xilinxfb_assign()
320 drvdata->info.fix = xilinx_fb_fix; xilinxfb_assign()
321 drvdata->info.fix.smem_start = drvdata->fb_phys; xilinxfb_assign()
322 drvdata->info.fix.smem_len = fbsize; xilinxfb_assign()
323 drvdata->info.fix.line_length = pdata->xvirt * BYTES_PER_PIXEL; xilinxfb_assign()
325 drvdata->info.pseudo_palette = drvdata->pseudo_palette; xilinxfb_assign()
326 drvdata->info.flags = FBINFO_DEFAULT; xilinxfb_assign()
327 drvdata->info.var = xilinx_fb_var; xilinxfb_assign()
328 drvdata->info.var.height = pdata->screen_height_mm; xilinxfb_assign()
329 drvdata->info.var.width = pdata->screen_width_mm; xilinxfb_assign()
330 drvdata->info.var.xres = pdata->xres; xilinxfb_assign()
331 drvdata->info.var.yres = pdata->yres; xilinxfb_assign()
332 drvdata->info.var.xres_virtual = pdata->xvirt; xilinxfb_assign()
333 drvdata->info.var.yres_virtual = pdata->yvirt; xilinxfb_assign()
336 rc = fb_alloc_cmap(&drvdata->info.cmap, PALETTE_ENTRIES_NO, 0); xilinxfb_assign()
344 rc = register_framebuffer(&drvdata->info); xilinxfb_assign()
350 if (drvdata->flags & BUS_ACCESS_FLAG) { xilinxfb_assign()
353 &drvdata->regs_phys, drvdata->regs); xilinxfb_assign()
357 (unsigned long long)drvdata->fb_phys, drvdata->fb_virt, fbsize); xilinxfb_assign()
362 fb_dealloc_cmap(&drvdata->info.cmap); xilinxfb_assign()
365 if (drvdata->fb_alloced) xilinxfb_assign()
366 dma_free_coherent(dev, PAGE_ALIGN(fbsize), drvdata->fb_virt, xilinxfb_assign()
367 drvdata->fb_phys); xilinxfb_assign()
369 iounmap(drvdata->fb_virt); xilinxfb_assign()
372 xilinx_fb_out32(drvdata, REG_CTRL, 0); xilinxfb_assign()
379 struct xilinxfb_drvdata *drvdata = dev_get_drvdata(dev); xilinxfb_release() local
382 xilinx_fb_blank(VESA_POWERDOWN, &drvdata->info); xilinxfb_release()
385 unregister_framebuffer(&drvdata->info); xilinxfb_release()
387 fb_dealloc_cmap(&drvdata->info.cmap); xilinxfb_release()
389 if (drvdata->fb_alloced) xilinxfb_release()
390 dma_free_coherent(dev, PAGE_ALIGN(drvdata->info.fix.smem_len), xilinxfb_release()
391 drvdata->fb_virt, drvdata->fb_phys); xilinxfb_release()
393 iounmap(drvdata->fb_virt); xilinxfb_release()
396 xilinx_fb_out32(drvdata, REG_CTRL, 0); xilinxfb_release()
400 if (!(drvdata->flags & BUS_ACCESS_FLAG)) xilinxfb_release()
401 dcr_unmap(drvdata->dcr_host, drvdata->dcr_len); xilinxfb_release()
417 struct xilinxfb_drvdata *drvdata; xilinxfb_of_probe() local
423 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); xilinxfb_of_probe()
424 if (!drvdata) xilinxfb_of_probe()
439 drvdata->flags |= BUS_ACCESS_FLAG; xilinxfb_of_probe()
445 drvdata->dcr_len = dcr_resource_len(pdev->dev.of_node, 0); xilinxfb_of_probe()
446 drvdata->dcr_host = dcr_map(pdev->dev.of_node, start, drvdata->dcr_len); xilinxfb_of_probe()
447 if (!DCR_MAP_OK(drvdata->dcr_host)) { xilinxfb_of_probe()
475 dev_set_drvdata(&pdev->dev, drvdata); xilinxfb_of_probe()
476 return xilinxfb_assign(pdev, drvdata, &pdata); xilinxfb_of_probe()
263 xilinxfb_assign(struct platform_device *pdev, struct xilinxfb_drvdata *drvdata, struct xilinxfb_platform_data *pdata) xilinxfb_assign() argument
|
| /linux-4.4.14/drivers/clk/x86/ |
| H A D | clk-lpt.c | 23 struct lpss_clk_data *drvdata; lpt_clk_probe() local
26 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); lpt_clk_probe()
27 if (!drvdata) lpt_clk_probe()
31 drvdata->name = "lpss_clk"; lpt_clk_probe()
32 clk = clk_register_fixed_rate(&pdev->dev, drvdata->name, NULL, lpt_clk_probe()
37 drvdata->clk = clk; lpt_clk_probe()
38 platform_set_drvdata(pdev, drvdata); lpt_clk_probe()
|
| /linux-4.4.14/drivers/leds/ |
| H A D | leds-lm3530.c | 190 static int lm3530_led_enable(struct lm3530_data *drvdata) lm3530_led_enable() argument
194 if (drvdata->enable) lm3530_led_enable()
197 ret = regulator_enable(drvdata->regulator); lm3530_led_enable()
199 dev_err(drvdata->led_dev.dev, "Failed to enable vin:%d\n", ret); lm3530_led_enable()
203 drvdata->enable = true; lm3530_led_enable()
207 static void lm3530_led_disable(struct lm3530_data *drvdata) lm3530_led_disable() argument
211 if (!drvdata->enable) lm3530_led_disable()
214 ret = regulator_disable(drvdata->regulator); lm3530_led_disable()
216 dev_err(drvdata->led_dev.dev, "Failed to disable vin:%d\n", lm3530_led_disable()
221 drvdata->enable = false; lm3530_led_disable()
224 static int lm3530_init_registers(struct lm3530_data *drvdata) lm3530_init_registers() argument
232 struct lm3530_platform_data *pdata = drvdata->pdata; lm3530_init_registers()
233 struct i2c_client *client = drvdata->client; lm3530_init_registers()
242 switch (drvdata->mode) { lm3530_init_registers()
259 if (drvdata->brightness) lm3530_init_registers()
260 brightness = drvdata->brightness; lm3530_init_registers()
262 brightness = drvdata->brightness = pdata->brt_val; lm3530_init_registers()
264 if (brightness > drvdata->led_dev.max_brightness) lm3530_init_registers()
265 brightness = drvdata->led_dev.max_brightness; lm3530_init_registers()
282 ret = lm3530_led_enable(drvdata); lm3530_init_registers()
289 drvdata->mode == LM3530_BL_MODE_PWM) { lm3530_init_registers()
292 drvdata->led_dev.max_brightness); lm3530_init_registers()
309 struct lm3530_data *drvdata = lm3530_brightness_set() local
311 struct lm3530_platform_data *pdata = drvdata->pdata; lm3530_brightness_set()
315 switch (drvdata->mode) { lm3530_brightness_set()
318 if (!drvdata->enable) { lm3530_brightness_set()
319 err = lm3530_init_registers(drvdata); lm3530_brightness_set()
321 dev_err(&drvdata->client->dev, lm3530_brightness_set()
328 err = i2c_smbus_write_byte_data(drvdata->client, lm3530_brightness_set()
331 dev_err(&drvdata->client->dev, lm3530_brightness_set()
334 drvdata->brightness = brt_val; lm3530_brightness_set()
337 lm3530_led_disable(drvdata); lm3530_brightness_set()
354 struct lm3530_data *drvdata; lm3530_mode_get() local
357 drvdata = container_of(led_cdev, struct lm3530_data, led_dev); lm3530_mode_get()
359 if (drvdata->mode == mode_map[i].mode_val) lm3530_mode_get()
373 struct lm3530_data *drvdata; lm3530_mode_set() local
378 drvdata = container_of(led_cdev, struct lm3530_data, led_dev); lm3530_mode_set()
379 pwm = &drvdata->pdata->pwm_data; lm3530_mode_set()
387 drvdata->mode = mode; lm3530_mode_set()
393 err = lm3530_init_registers(drvdata); lm3530_mode_set()
399 return sizeof(drvdata->mode); lm3530_mode_set()
413 struct lm3530_data *drvdata; lm3530_probe() local
432 drvdata = devm_kzalloc(&client->dev, sizeof(struct lm3530_data), lm3530_probe()
434 if (drvdata == NULL) lm3530_probe()
437 drvdata->mode = pdata->mode; lm3530_probe()
438 drvdata->client = client; lm3530_probe()
439 drvdata->pdata = pdata; lm3530_probe()
440 drvdata->brightness = LED_OFF; lm3530_probe()
441 drvdata->enable = false; lm3530_probe()
442 drvdata->led_dev.name = LM3530_LED_DEV; lm3530_probe()
443 drvdata->led_dev.brightness_set = lm3530_brightness_set; lm3530_probe()
444 drvdata->led_dev.max_brightness = MAX_BRIGHTNESS; lm3530_probe()
445 drvdata->led_dev.groups = lm3530_groups; lm3530_probe()
447 i2c_set_clientdata(client, drvdata); lm3530_probe()
449 drvdata->regulator = devm_regulator_get(&client->dev, "vin"); lm3530_probe()
450 if (IS_ERR(drvdata->regulator)) { lm3530_probe()
452 err = PTR_ERR(drvdata->regulator); lm3530_probe()
453 drvdata->regulator = NULL; lm3530_probe()
457 if (drvdata->pdata->brt_val) { lm3530_probe()
458 err = lm3530_init_registers(drvdata); lm3530_probe()
465 err = led_classdev_register(&client->dev, &drvdata->led_dev); lm3530_probe()
476 struct lm3530_data *drvdata = i2c_get_clientdata(client); lm3530_remove() local
478 lm3530_led_disable(drvdata); lm3530_remove()
479 led_classdev_unregister(&drvdata->led_dev); lm3530_remove()
|
| H A D | leds-wm831x-status.c | 233 struct wm831x_status *drvdata; wm831x_status_probe() local
244 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_status), wm831x_status_probe()
246 if (!drvdata) wm831x_status_probe()
248 platform_set_drvdata(pdev, drvdata); wm831x_status_probe()
250 drvdata->wm831x = wm831x; wm831x_status_probe()
251 drvdata->reg = res->start; wm831x_status_probe()
264 mutex_init(&drvdata->mutex); wm831x_status_probe()
265 INIT_WORK(&drvdata->work, wm831x_status_work); wm831x_status_probe()
266 spin_lock_init(&drvdata->value_lock); wm831x_status_probe()
270 drvdata->reg_val = wm831x_reg_read(wm831x, drvdata->reg); wm831x_status_probe()
272 if (drvdata->reg_val & WM831X_LED_MODE_MASK) wm831x_status_probe()
273 drvdata->brightness = LED_FULL; wm831x_status_probe()
275 drvdata->brightness = LED_OFF; wm831x_status_probe()
281 drvdata->src = drvdata->reg_val; wm831x_status_probe()
282 drvdata->src &= WM831X_LED_SRC_MASK; wm831x_status_probe()
283 drvdata->src >>= WM831X_LED_SRC_SHIFT; wm831x_status_probe()
285 drvdata->src = pdata.default_src - 1; wm831x_status_probe()
288 drvdata->cdev.name = pdata.name; wm831x_status_probe()
289 drvdata->cdev.default_trigger = pdata.default_trigger; wm831x_status_probe()
290 drvdata->cdev.brightness_set = wm831x_status_set; wm831x_status_probe()
291 drvdata->cdev.blink_set = wm831x_status_blink_set; wm831x_status_probe()
292 drvdata->cdev.groups = wm831x_status_groups; wm831x_status_probe()
294 ret = led_classdev_register(wm831x->dev, &drvdata->cdev); wm831x_status_probe()
305 struct wm831x_status *drvdata = platform_get_drvdata(pdev); wm831x_status_remove() local
307 led_classdev_unregister(&drvdata->cdev); wm831x_status_remove()
|
| /linux-4.4.14/drivers/watchdog/ |
| H A D | jz4740_wdt.c | 73 struct jz4740_wdt_drvdata *drvdata = watchdog_get_drvdata(wdt_dev); jz4740_wdt_ping() local
75 writew(0x0, drvdata->base + JZ_REG_WDT_TIMER_COUNTER); jz4740_wdt_ping()
82 struct jz4740_wdt_drvdata *drvdata = watchdog_get_drvdata(wdt_dev); jz4740_wdt_set_timeout() local
87 rtc_clk_rate = clk_get_rate(drvdata->rtc_clk); jz4740_wdt_set_timeout()
101 writeb(0x0, drvdata->base + JZ_REG_WDT_COUNTER_ENABLE); jz4740_wdt_set_timeout()
102 writew(clock_div, drvdata->base + JZ_REG_WDT_TIMER_CONTROL); jz4740_wdt_set_timeout()
104 writew((u16)timeout_value, drvdata->base + JZ_REG_WDT_TIMER_DATA); jz4740_wdt_set_timeout()
105 writew(0x0, drvdata->base + JZ_REG_WDT_TIMER_COUNTER); jz4740_wdt_set_timeout()
107 drvdata->base + JZ_REG_WDT_TIMER_CONTROL); jz4740_wdt_set_timeout()
109 writeb(0x1, drvdata->base + JZ_REG_WDT_COUNTER_ENABLE); jz4740_wdt_set_timeout()
125 struct jz4740_wdt_drvdata *drvdata = watchdog_get_drvdata(wdt_dev); jz4740_wdt_stop() local
128 writeb(0x0, drvdata->base + JZ_REG_WDT_COUNTER_ENABLE); jz4740_wdt_stop()
156 struct jz4740_wdt_drvdata *drvdata; jz4740_wdt_probe() local
161 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct jz4740_wdt_drvdata), jz4740_wdt_probe()
163 if (!drvdata) { jz4740_wdt_probe()
171 jz4740_wdt = &drvdata->wdt; jz4740_wdt_probe()
179 watchdog_set_drvdata(jz4740_wdt, drvdata); jz4740_wdt_probe()
182 drvdata->base = devm_ioremap_resource(&pdev->dev, res); jz4740_wdt_probe()
183 if (IS_ERR(drvdata->base)) { jz4740_wdt_probe()
184 ret = PTR_ERR(drvdata->base); jz4740_wdt_probe()
188 drvdata->rtc_clk = clk_get(&pdev->dev, "rtc"); jz4740_wdt_probe()
189 if (IS_ERR(drvdata->rtc_clk)) { jz4740_wdt_probe()
191 ret = PTR_ERR(drvdata->rtc_clk); jz4740_wdt_probe()
195 ret = watchdog_register_device(&drvdata->wdt); jz4740_wdt_probe()
199 platform_set_drvdata(pdev, drvdata); jz4740_wdt_probe()
203 clk_put(drvdata->rtc_clk); jz4740_wdt_probe()
210 struct jz4740_wdt_drvdata *drvdata = platform_get_drvdata(pdev); jz4740_wdt_remove() local
212 jz4740_wdt_stop(&drvdata->wdt); jz4740_wdt_remove()
213 watchdog_unregister_device(&drvdata->wdt); jz4740_wdt_remove()
214 clk_put(drvdata->rtc_clk); jz4740_wdt_remove()
|
| /linux-4.4.14/drivers/clk/ |
| H A D | clk-si5351.c | 48 struct si5351_driver_data *drvdata; member in struct:si5351_hw_data
87 static inline u8 si5351_reg_read(struct si5351_driver_data *drvdata, u8 reg) si5351_reg_read() argument
92 ret = regmap_read(drvdata->regmap, reg, &val); si5351_reg_read()
94 dev_err(&drvdata->client->dev, si5351_reg_read()
102 static inline int si5351_bulk_read(struct si5351_driver_data *drvdata, si5351_bulk_read() argument
105 return regmap_bulk_read(drvdata->regmap, reg, buf, count); si5351_bulk_read()
108 static inline int si5351_reg_write(struct si5351_driver_data *drvdata, si5351_reg_write() argument
111 return regmap_write(drvdata->regmap, reg, val); si5351_reg_write()
114 static inline int si5351_bulk_write(struct si5351_driver_data *drvdata, si5351_bulk_write() argument
117 return regmap_raw_write(drvdata->regmap, reg, buf, count); si5351_bulk_write()
120 static inline int si5351_set_bits(struct si5351_driver_data *drvdata, si5351_set_bits() argument
123 return regmap_update_bits(drvdata->regmap, reg, mask, val); si5351_set_bits()
133 static void si5351_read_parameters(struct si5351_driver_data *drvdata, si5351_read_parameters() argument
141 buf[0] = si5351_reg_read(drvdata, reg); si5351_read_parameters()
147 si5351_bulk_read(drvdata, reg, SI5351_PARAMETERS_LENGTH, buf); si5351_read_parameters()
155 static void si5351_write_parameters(struct si5351_driver_data *drvdata, si5351_write_parameters() argument
164 si5351_reg_write(drvdata, reg, buf[0]); si5351_write_parameters()
170 buf[2] = si5351_reg_read(drvdata, reg + 2) & ~0x03; si5351_write_parameters()
178 si5351_bulk_write(drvdata, reg, SI5351_PARAMETERS_LENGTH, buf); si5351_write_parameters()
224 struct si5351_driver_data *drvdata = si5351_xtal_prepare() local
226 si5351_set_bits(drvdata, SI5351_FANOUT_ENABLE, si5351_xtal_prepare()
233 struct si5351_driver_data *drvdata = si5351_xtal_unprepare() local
235 si5351_set_bits(drvdata, SI5351_FANOUT_ENABLE, si5351_xtal_unprepare()
249 struct si5351_driver_data *drvdata = si5351_clkin_prepare() local
251 si5351_set_bits(drvdata, SI5351_FANOUT_ENABLE, si5351_clkin_prepare()
258 struct si5351_driver_data *drvdata = si5351_clkin_unprepare() local
260 si5351_set_bits(drvdata, SI5351_FANOUT_ENABLE, si5351_clkin_unprepare()
272 struct si5351_driver_data *drvdata = si5351_clkin_recalc_rate() local
291 si5351_set_bits(drvdata, SI5351_PLL_INPUT_SOURCE, si5351_clkin_recalc_rate()
294 dev_dbg(&drvdata->client->dev, "%s - clkin div = %d, rate = %lu\n", si5351_clkin_recalc_rate()
315 dev_warn(&hwdata->drvdata->client->dev, "VXCO currently unsupported\n"); si5351_vxco_prepare()
369 static int _si5351_pll_reparent(struct si5351_driver_data *drvdata, _si5351_pll_reparent() argument
380 if (drvdata->variant != SI5351_VARIANT_C && _si5351_pll_reparent()
384 si5351_set_bits(drvdata, SI5351_PLL_INPUT_SOURCE, mask, _si5351_pll_reparent()
396 val = si5351_reg_read(hwdata->drvdata, SI5351_PLL_INPUT_SOURCE); si5351_pll_get_parent()
406 if (hwdata->drvdata->variant != SI5351_VARIANT_C && si5351_pll_set_parent()
413 return _si5351_pll_reparent(hwdata->drvdata, hwdata->num, si5351_pll_set_parent()
428 si5351_read_parameters(hwdata->drvdata, reg, &hwdata->params); si5351_pll_recalc_rate()
440 dev_dbg(&hwdata->drvdata->client->dev, si5351_pll_recalc_rate()
498 dev_dbg(&hwdata->drvdata->client->dev, si5351_pll_round_rate()
515 si5351_write_parameters(hwdata->drvdata, reg, &hwdata->params); si5351_pll_set_rate()
518 si5351_set_bits(hwdata->drvdata, SI5351_CLK6_CTRL + hwdata->num, si5351_pll_set_rate()
522 dev_dbg(&hwdata->drvdata->client->dev, si5351_pll_set_rate()
562 static int _si5351_msynth_reparent(struct si5351_driver_data *drvdata, _si5351_msynth_reparent() argument
571 si5351_set_bits(drvdata, SI5351_CLK0_CTRL + num, SI5351_CLK_PLL_SELECT, _si5351_msynth_reparent()
583 val = si5351_reg_read(hwdata->drvdata, SI5351_CLK0_CTRL + hwdata->num); si5351_msynth_get_parent()
593 return _si5351_msynth_reparent(hwdata->drvdata, hwdata->num, si5351_msynth_set_parent()
608 si5351_read_parameters(hwdata->drvdata, reg, &hwdata->params); si5351_msynth_recalc_rate()
619 } else if ((si5351_reg_read(hwdata->drvdata, reg + 2) & si5351_msynth_recalc_rate()
633 dev_dbg(&hwdata->drvdata->client->dev, si5351_msynth_recalc_rate()
746 dev_dbg(&hwdata->drvdata->client->dev, si5351_msynth_round_rate()
763 si5351_write_parameters(hwdata->drvdata, reg, &hwdata->params); si5351_msynth_set_rate()
770 si5351_set_bits(hwdata->drvdata, reg + 2, si5351_msynth_set_rate()
773 si5351_set_bits(hwdata->drvdata, SI5351_CLK0_CTRL + hwdata->num, si5351_msynth_set_rate()
778 dev_dbg(&hwdata->drvdata->client->dev, si5351_msynth_set_rate()
798 static int _si5351_clkout_reparent(struct si5351_driver_data *drvdata, _si5351_clkout_reparent() argument
821 if (drvdata->variant != SI5351_VARIANT_C) _si5351_clkout_reparent()
830 si5351_set_bits(drvdata, SI5351_CLK0_CTRL + num, _si5351_clkout_reparent()
836 struct si5351_driver_data *drvdata, int num, _si5351_clkout_set_drive_strength()
861 si5351_set_bits(drvdata, SI5351_CLK0_CTRL + num, _si5351_clkout_set_drive_strength()
867 struct si5351_driver_data *drvdata, int num, _si5351_clkout_set_disable_state()
896 si5351_set_bits(drvdata, reg, mask, val << shift); _si5351_clkout_set_disable_state()
906 si5351_set_bits(hwdata->drvdata, SI5351_CLK0_CTRL + hwdata->num, si5351_clkout_prepare()
908 si5351_set_bits(hwdata->drvdata, SI5351_OUTPUT_ENABLE_CTRL, si5351_clkout_prepare()
918 si5351_set_bits(hwdata->drvdata, SI5351_CLK0_CTRL + hwdata->num, si5351_clkout_unprepare()
920 si5351_set_bits(hwdata->drvdata, SI5351_OUTPUT_ENABLE_CTRL, si5351_clkout_unprepare()
931 val = si5351_reg_read(hwdata->drvdata, SI5351_CLK0_CTRL + hwdata->num); si5351_clkout_get_parent()
971 return _si5351_clkout_reparent(hwdata->drvdata, hwdata->num, parent); si5351_clkout_set_parent()
987 rdiv = si5351_reg_read(hwdata->drvdata, reg); si5351_clkout_recalc_rate()
1043 dev_dbg(&hwdata->drvdata->client->dev, si5351_clkout_round_rate()
1075 si5351_set_bits(hwdata->drvdata, SI5351_CLK6_7_OUTPUT_DIVIDER, si5351_clkout_set_rate()
1079 si5351_set_bits(hwdata->drvdata, SI5351_CLK6_7_OUTPUT_DIVIDER, si5351_clkout_set_rate()
1084 si5351_set_bits(hwdata->drvdata, si5351_clkout_set_rate()
1091 si5351_set_bits(hwdata->drvdata, SI5351_CLK0_CTRL + hwdata->num, si5351_clkout_set_rate()
1094 dev_dbg(&hwdata->drvdata->client->dev, si5351_clkout_set_rate()
1315 struct si5351_driver_data *drvdata; si5351_i2c_probe() local
1330 drvdata = devm_kzalloc(&client->dev, sizeof(*drvdata), GFP_KERNEL); si5351_i2c_probe()
1331 if (drvdata == NULL) { si5351_i2c_probe()
1336 i2c_set_clientdata(client, drvdata); si5351_i2c_probe()
1337 drvdata->client = client; si5351_i2c_probe()
1338 drvdata->variant = variant; si5351_i2c_probe()
1339 drvdata->pxtal = devm_clk_get(&client->dev, "xtal"); si5351_i2c_probe()
1340 drvdata->pclkin = devm_clk_get(&client->dev, "clkin"); si5351_i2c_probe()
1342 if (PTR_ERR(drvdata->pxtal) == -EPROBE_DEFER || si5351_i2c_probe()
1343 PTR_ERR(drvdata->pclkin) == -EPROBE_DEFER) si5351_i2c_probe()
1350 if (IS_ERR(drvdata->pxtal) && si5351_i2c_probe()
1351 (drvdata->variant != SI5351_VARIANT_C || IS_ERR(drvdata->pclkin))) { si5351_i2c_probe()
1356 drvdata->regmap = devm_regmap_init_i2c(client, &si5351_regmap_config); si5351_i2c_probe()
1357 if (IS_ERR(drvdata->regmap)) { si5351_i2c_probe()
1359 return PTR_ERR(drvdata->regmap); si5351_i2c_probe()
1363 si5351_reg_write(drvdata, SI5351_INTERRUPT_MASK, 0xf0); si5351_i2c_probe()
1365 if (drvdata->variant != SI5351_VARIANT_C) si5351_i2c_probe()
1366 si5351_set_bits(drvdata, SI5351_PLL_INPUT_SOURCE, si5351_i2c_probe()
1371 ret = _si5351_pll_reparent(drvdata, n, pdata->pll_src[n]); si5351_i2c_probe()
1381 ret = _si5351_msynth_reparent(drvdata, n, si5351_i2c_probe()
1390 ret = _si5351_clkout_reparent(drvdata, n, si5351_i2c_probe()
1399 ret = _si5351_clkout_set_drive_strength(drvdata, n, si5351_i2c_probe()
1408 ret = _si5351_clkout_set_disable_state(drvdata, n, si5351_i2c_probe()
1418 if (!IS_ERR(drvdata->pxtal)) si5351_i2c_probe()
1419 clk_prepare_enable(drvdata->pxtal); si5351_i2c_probe()
1420 if (!IS_ERR(drvdata->pclkin)) si5351_i2c_probe()
1421 clk_prepare_enable(drvdata->pclkin); si5351_i2c_probe()
1428 if (!IS_ERR(drvdata->pxtal)) { si5351_i2c_probe()
1429 drvdata->pxtal_name = __clk_get_name(drvdata->pxtal); si5351_i2c_probe()
1430 init.parent_names = &drvdata->pxtal_name; si5351_i2c_probe()
1433 drvdata->xtal.init = &init; si5351_i2c_probe()
1434 clk = devm_clk_register(&client->dev, &drvdata->xtal); si5351_i2c_probe()
1442 if (drvdata->variant == SI5351_VARIANT_C) { si5351_i2c_probe()
1446 if (!IS_ERR(drvdata->pclkin)) { si5351_i2c_probe()
1447 drvdata->pclkin_name = __clk_get_name(drvdata->pclkin); si5351_i2c_probe()
1448 init.parent_names = &drvdata->pclkin_name; si5351_i2c_probe()
1451 drvdata->clkin.init = &init; si5351_i2c_probe()
1452 clk = devm_clk_register(&client->dev, &drvdata->clkin); si5351_i2c_probe()
1462 num_parents = (drvdata->variant == SI5351_VARIANT_C) ? 2 : 1; si5351_i2c_probe()
1467 drvdata->pll[0].num = 0; si5351_i2c_probe()
1468 drvdata->pll[0].drvdata = drvdata; si5351_i2c_probe()
1469 drvdata->pll[0].hw.init = &init; si5351_i2c_probe()
1476 clk = devm_clk_register(&client->dev, &drvdata->pll[0].hw); si5351_i2c_probe()
1484 drvdata->pll[1].num = 1; si5351_i2c_probe()
1485 drvdata->pll[1].drvdata = drvdata; si5351_i2c_probe()
1486 drvdata->pll[1].hw.init = &init; si5351_i2c_probe()
1488 if (drvdata->variant == SI5351_VARIANT_B) { si5351_i2c_probe()
1501 clk = devm_clk_register(&client->dev, &drvdata->pll[1].hw); si5351_i2c_probe()
1509 num_clocks = (drvdata->variant == SI5351_VARIANT_A3) ? 3 : 8; si5351_i2c_probe()
1511 if (drvdata->variant == SI5351_VARIANT_B) si5351_i2c_probe()
1516 drvdata->msynth = devm_kzalloc(&client->dev, num_clocks * si5351_i2c_probe()
1517 sizeof(*drvdata->msynth), GFP_KERNEL); si5351_i2c_probe()
1518 drvdata->clkout = devm_kzalloc(&client->dev, num_clocks * si5351_i2c_probe()
1519 sizeof(*drvdata->clkout), GFP_KERNEL); si5351_i2c_probe()
1521 drvdata->onecell.clk_num = num_clocks; si5351_i2c_probe()
1522 drvdata->onecell.clks = devm_kzalloc(&client->dev, si5351_i2c_probe()
1523 num_clocks * sizeof(*drvdata->onecell.clks), GFP_KERNEL); si5351_i2c_probe()
1525 if (WARN_ON(!drvdata->msynth || !drvdata->clkout || si5351_i2c_probe()
1526 !drvdata->onecell.clks)) { si5351_i2c_probe()
1532 drvdata->msynth[n].num = n; si5351_i2c_probe()
1533 drvdata->msynth[n].drvdata = drvdata; si5351_i2c_probe()
1534 drvdata->msynth[n].hw.init = &init; si5351_i2c_probe()
1543 clk = devm_clk_register(&client->dev, &drvdata->msynth[n].hw); si5351_i2c_probe()
1552 num_parents = (drvdata->variant == SI5351_VARIANT_C) ? 4 : 3; si5351_i2c_probe()
1560 drvdata->clkout[n].num = n; si5351_i2c_probe()
1561 drvdata->clkout[n].drvdata = drvdata; si5351_i2c_probe()
1562 drvdata->clkout[n].hw.init = &init; si5351_i2c_probe()
1571 clk = devm_clk_register(&client->dev, &drvdata->clkout[n].hw); si5351_i2c_probe()
1578 drvdata->onecell.clks[n] = clk; si5351_i2c_probe()
1592 &drvdata->onecell); si5351_i2c_probe()
1601 if (!IS_ERR(drvdata->pxtal)) si5351_i2c_probe()
1602 clk_disable_unprepare(drvdata->pxtal); si5351_i2c_probe()
1603 if (!IS_ERR(drvdata->pclkin)) si5351_i2c_probe()
1604 clk_disable_unprepare(drvdata->pclkin); si5351_i2c_probe()
835 _si5351_clkout_set_drive_strength( struct si5351_driver_data *drvdata, int num, enum si5351_drive_strength drive) _si5351_clkout_set_drive_strength() argument
866 _si5351_clkout_set_disable_state( struct si5351_driver_data *drvdata, int num, enum si5351_disable_state state) _si5351_clkout_set_disable_state() argument
|
| /linux-4.4.14/sound/soc/txx9/ |
| H A D | txx9aclc-ac97.c | 42 static int txx9aclc_regready(struct txx9aclc_plat_drvdata *drvdata) txx9aclc_regready() argument
44 return __raw_readl(drvdata->base + ACINTSTS) & ACINT_REGACCRDY; txx9aclc_regready()
51 struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata; txx9aclc_ac97_read() local
52 void __iomem *base = drvdata->base; txx9aclc_ac97_read()
84 struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata; txx9aclc_ac97_write() local
85 void __iomem *base = drvdata->base; txx9aclc_ac97_write()
100 struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata; txx9aclc_ac97_cold_reset() local
101 void __iomem *base = drvdata->base; txx9aclc_ac97_cold_reset()
130 struct txx9aclc_plat_drvdata *drvdata = dev_id; txx9aclc_ac97_irq() local
131 void __iomem *base = drvdata->base; txx9aclc_ac97_irq()
146 struct txx9aclc_plat_drvdata *drvdata = snd_soc_dai_get_drvdata(dai); txx9aclc_ac97_remove() local
149 __raw_writel(ACCTL_ENLINK, drvdata->base + ACCTLDIS); txx9aclc_ac97_remove()
178 struct txx9aclc_plat_drvdata *drvdata; txx9aclc_ac97_dev_probe() local
187 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); txx9aclc_ac97_dev_probe()
188 if (!drvdata) txx9aclc_ac97_dev_probe()
192 drvdata->base = devm_ioremap_resource(&pdev->dev, r); txx9aclc_ac97_dev_probe()
193 if (IS_ERR(drvdata->base)) txx9aclc_ac97_dev_probe()
194 return PTR_ERR(drvdata->base); txx9aclc_ac97_dev_probe()
196 platform_set_drvdata(pdev, drvdata); txx9aclc_ac97_dev_probe()
197 drvdata->physbase = r->start; txx9aclc_ac97_dev_probe()
198 if (sizeof(drvdata->physbase) > sizeof(r->start) && txx9aclc_ac97_dev_probe()
201 drvdata->physbase |= 0xf00000000ull; txx9aclc_ac97_dev_probe()
203 0, dev_name(&pdev->dev), drvdata); txx9aclc_ac97_dev_probe()
|
| H A D | txx9aclc.c | 160 struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata; txx9aclc_dma_tasklet() local
161 void __iomem *base = drvdata->base; txx9aclc_dma_tasklet()
209 struct txx9aclc_plat_drvdata *drvdata =txx9aclc_drvdata; txx9aclc_pcm_trigger() local
210 void __iomem *base = drvdata->base; txx9aclc_pcm_trigger()
343 struct txx9aclc_plat_drvdata *drvdata =txx9aclc_drvdata; txx9aclc_dma_init() local
351 ds->tx_reg = drvdata->physbase + ACAUDODAT; txx9aclc_dma_init()
355 ds->rx_reg = drvdata->physbase + ACAUDIDAT; txx9aclc_dma_init()
383 struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata; txx9aclc_pcm_remove() local
384 void __iomem *base = drvdata->base; txx9aclc_pcm_remove()
|
| /linux-4.4.14/drivers/regulator/ |
| H A D | pwm-regulator.c | 46 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); pwm_regulator_get_voltage_sel() local
48 return drvdata->state; pwm_regulator_get_voltage_sel()
54 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); pwm_regulator_set_voltage_sel() local
59 pwm_reg_period = pwm_get_period(drvdata->pwm); pwm_regulator_set_voltage_sel()
62 drvdata->duty_cycle_table[selector].dutycycle) / 100; pwm_regulator_set_voltage_sel()
64 ret = pwm_config(drvdata->pwm, dutycycle, pwm_reg_period); pwm_regulator_set_voltage_sel()
70 drvdata->state = selector; pwm_regulator_set_voltage_sel()
78 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); pwm_regulator_list_voltage() local
83 return drvdata->duty_cycle_table[selector].uV; pwm_regulator_list_voltage()
88 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); pwm_regulator_enable() local
90 return pwm_enable(drvdata->pwm); pwm_regulator_enable()
95 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); pwm_regulator_disable() local
97 pwm_disable(drvdata->pwm); pwm_regulator_disable()
104 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); pwm_regulator_is_enabled() local
106 return pwm_is_enabled(drvdata->pwm); pwm_regulator_is_enabled()
123 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); pwm_regulator_get_voltage() local
125 return drvdata->volt_uV; pwm_regulator_get_voltage()
132 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); pwm_regulator_set_voltage() local
134 unsigned int period = pwm_get_period(drvdata->pwm); pwm_regulator_set_voltage()
140 ret = pwm_config(drvdata->pwm, (period / 100) * duty_cycle, period); pwm_regulator_set_voltage()
146 ret = pwm_enable(drvdata->pwm); pwm_regulator_set_voltage()
151 drvdata->volt_uV = min_uV; pwm_regulator_set_voltage()
185 struct pwm_regulator_data *drvdata) pwm_regulator_init_table()
214 drvdata->duty_cycle_table = duty_cycle_table; pwm_regulator_init_table()
222 struct pwm_regulator_data *drvdata) pwm_regulator_init_continuous()
233 struct pwm_regulator_data *drvdata; pwm_regulator_probe() local
244 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); pwm_regulator_probe()
245 if (!drvdata) pwm_regulator_probe()
249 ret = pwm_regulator_init_table(pdev, drvdata); pwm_regulator_probe()
251 ret = pwm_regulator_init_continuous(pdev, drvdata); pwm_regulator_probe()
262 config.driver_data = drvdata; pwm_regulator_probe()
265 drvdata->pwm = devm_pwm_get(&pdev->dev, NULL); pwm_regulator_probe()
266 if (IS_ERR(drvdata->pwm)) { pwm_regulator_probe()
268 return PTR_ERR(drvdata->pwm); pwm_regulator_probe()
184 pwm_regulator_init_table(struct platform_device *pdev, struct pwm_regulator_data *drvdata) pwm_regulator_init_table() argument
221 pwm_regulator_init_continuous(struct platform_device *pdev, struct pwm_regulator_data *drvdata) pwm_regulator_init_continuous() argument
|
| H A D | gpio-regulator.c | 250 struct gpio_regulator_data *drvdata; gpio_regulator_probe() local
254 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data), gpio_regulator_probe()
256 if (drvdata == NULL) gpio_regulator_probe()
261 &drvdata->desc); gpio_regulator_probe()
266 drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); gpio_regulator_probe()
267 if (drvdata->desc.name == NULL) { gpio_regulator_probe()
274 drvdata->gpios = kmemdup(config->gpios, gpio_regulator_probe()
277 if (drvdata->gpios == NULL) { gpio_regulator_probe()
283 drvdata->nr_gpios = config->nr_gpios; gpio_regulator_probe()
284 ret = gpio_request_array(drvdata->gpios, drvdata->nr_gpios); gpio_regulator_probe()
292 drvdata->states = kmemdup(config->states, gpio_regulator_probe()
296 if (drvdata->states == NULL) { gpio_regulator_probe()
301 drvdata->nr_states = config->nr_states; gpio_regulator_probe()
303 drvdata->desc.owner = THIS_MODULE; gpio_regulator_probe()
304 drvdata->desc.enable_time = config->startup_delay; gpio_regulator_probe()
309 drvdata->desc.type = REGULATOR_VOLTAGE; gpio_regulator_probe()
310 drvdata->desc.ops = &gpio_regulator_voltage_ops; gpio_regulator_probe()
311 drvdata->desc.n_voltages = config->nr_states; gpio_regulator_probe()
314 drvdata->desc.type = REGULATOR_CURRENT; gpio_regulator_probe()
315 drvdata->desc.ops = &gpio_regulator_current_ops; gpio_regulator_probe()
325 for (ptr = 0; ptr < drvdata->nr_gpios; ptr++) { gpio_regulator_probe()
329 drvdata->state = state; gpio_regulator_probe()
333 cfg.driver_data = drvdata; gpio_regulator_probe()
353 drvdata->dev = regulator_register(&drvdata->desc, &cfg); gpio_regulator_probe()
354 if (IS_ERR(drvdata->dev)) { gpio_regulator_probe()
355 ret = PTR_ERR(drvdata->dev); gpio_regulator_probe()
360 platform_set_drvdata(pdev, drvdata); gpio_regulator_probe()
365 gpio_free_array(drvdata->gpios, drvdata->nr_gpios); gpio_regulator_probe()
367 kfree(drvdata->states); gpio_regulator_probe()
369 kfree(drvdata->gpios); gpio_regulator_probe()
371 kfree(drvdata->desc.name); gpio_regulator_probe()
378 struct gpio_regulator_data *drvdata = platform_get_drvdata(pdev); gpio_regulator_remove() local
380 regulator_unregister(drvdata->dev); gpio_regulator_remove()
382 gpio_free_array(drvdata->gpios, drvdata->nr_gpios); gpio_regulator_remove()
384 kfree(drvdata->states); gpio_regulator_remove()
385 kfree(drvdata->gpios); gpio_regulator_remove()
387 kfree(drvdata->desc.name); gpio_regulator_remove()
|
| H A D | pbias-regulator.c | 145 struct pbias_regulator_data *drvdata; pbias_regulator_probe() local
161 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct pbias_regulator_data) pbias_regulator_probe()
163 if (!drvdata) pbias_regulator_probe()
196 drvdata[data_idx].syscon = syscon; pbias_regulator_probe()
197 drvdata[data_idx].info = info; pbias_regulator_probe()
198 drvdata[data_idx].desc.name = info->name; pbias_regulator_probe()
199 drvdata[data_idx].desc.owner = THIS_MODULE; pbias_regulator_probe()
200 drvdata[data_idx].desc.type = REGULATOR_VOLTAGE; pbias_regulator_probe()
201 drvdata[data_idx].desc.ops = &pbias_regulator_voltage_ops; pbias_regulator_probe()
202 drvdata[data_idx].desc.volt_table = pbias_volt_table; pbias_regulator_probe()
203 drvdata[data_idx].desc.n_voltages = 2; pbias_regulator_probe()
204 drvdata[data_idx].desc.enable_time = info->enable_time; pbias_regulator_probe()
205 drvdata[data_idx].desc.vsel_reg = offset; pbias_regulator_probe()
206 drvdata[data_idx].desc.vsel_mask = info->vmode; pbias_regulator_probe()
207 drvdata[data_idx].desc.enable_reg = offset; pbias_regulator_probe()
208 drvdata[data_idx].desc.enable_mask = info->enable_mask; pbias_regulator_probe()
209 drvdata[data_idx].desc.enable_val = info->enable; pbias_regulator_probe()
210 drvdata[data_idx].desc.disable_val = info->disable_val; pbias_regulator_probe()
213 cfg.driver_data = &drvdata[data_idx]; pbias_regulator_probe()
216 drvdata[data_idx].dev = devm_regulator_register(&pdev->dev, pbias_regulator_probe()
217 &drvdata[data_idx].desc, &cfg); pbias_regulator_probe()
218 if (IS_ERR(drvdata[data_idx].dev)) { pbias_regulator_probe()
219 ret = PTR_ERR(drvdata[data_idx].dev); pbias_regulator_probe()
227 platform_set_drvdata(pdev, drvdata); pbias_regulator_probe()
|
| H A D | fixed.c | 113 struct fixed_voltage_data *drvdata; reg_fixed_voltage_probe() local
117 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data), reg_fixed_voltage_probe()
119 if (!drvdata) reg_fixed_voltage_probe()
124 &drvdata->desc); reg_fixed_voltage_probe()
134 drvdata->desc.name = devm_kstrdup(&pdev->dev, reg_fixed_voltage_probe()
137 if (drvdata->desc.name == NULL) { reg_fixed_voltage_probe()
141 drvdata->desc.type = REGULATOR_VOLTAGE; reg_fixed_voltage_probe()
142 drvdata->desc.owner = THIS_MODULE; reg_fixed_voltage_probe()
143 drvdata->desc.ops = &fixed_voltage_ops; reg_fixed_voltage_probe()
145 drvdata->desc.enable_time = config->startup_delay; reg_fixed_voltage_probe()
148 drvdata->desc.supply_name = devm_kstrdup(&pdev->dev, reg_fixed_voltage_probe()
151 if (!drvdata->desc.supply_name) { reg_fixed_voltage_probe()
159 drvdata->desc.n_voltages = 1; reg_fixed_voltage_probe()
161 drvdata->desc.fixed_uV = config->microvolts; reg_fixed_voltage_probe()
185 cfg.driver_data = drvdata; reg_fixed_voltage_probe()
188 drvdata->dev = devm_regulator_register(&pdev->dev, &drvdata->desc, reg_fixed_voltage_probe()
190 if (IS_ERR(drvdata->dev)) { reg_fixed_voltage_probe()
191 ret = PTR_ERR(drvdata->dev); reg_fixed_voltage_probe()
196 platform_set_drvdata(pdev, drvdata); reg_fixed_voltage_probe()
198 dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name, reg_fixed_voltage_probe()
199 drvdata->desc.fixed_uV); reg_fixed_voltage_probe()
|
| H A D | userspace-consumer.c | 111 struct userspace_consumer_data *drvdata; regulator_userspace_consumer_probe() local
118 drvdata = devm_kzalloc(&pdev->dev, regulator_userspace_consumer_probe()
121 if (drvdata == NULL) regulator_userspace_consumer_probe()
124 drvdata->name = pdata->name; regulator_userspace_consumer_probe()
125 drvdata->num_supplies = pdata->num_supplies; regulator_userspace_consumer_probe()
126 drvdata->supplies = pdata->supplies; regulator_userspace_consumer_probe()
128 mutex_init(&drvdata->lock); regulator_userspace_consumer_probe()
130 ret = devm_regulator_bulk_get(&pdev->dev, drvdata->num_supplies, regulator_userspace_consumer_probe()
131 drvdata->supplies); regulator_userspace_consumer_probe()
142 ret = regulator_bulk_enable(drvdata->num_supplies, regulator_userspace_consumer_probe()
143 drvdata->supplies); regulator_userspace_consumer_probe()
151 drvdata->enabled = pdata->init_on; regulator_userspace_consumer_probe()
152 platform_set_drvdata(pdev, drvdata); regulator_userspace_consumer_probe()
|
| H A D | virtual.c | 291 struct virtual_consumer_data *drvdata; regulator_virtual_probe() local
294 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct virtual_consumer_data), regulator_virtual_probe()
296 if (drvdata == NULL) regulator_virtual_probe()
299 mutex_init(&drvdata->lock); regulator_virtual_probe()
301 drvdata->regulator = devm_regulator_get(&pdev->dev, reg_id); regulator_virtual_probe()
302 if (IS_ERR(drvdata->regulator)) { regulator_virtual_probe()
303 ret = PTR_ERR(drvdata->regulator); regulator_virtual_probe()
317 drvdata->mode = regulator_get_mode(drvdata->regulator); regulator_virtual_probe()
319 platform_set_drvdata(pdev, drvdata); regulator_virtual_probe()
326 struct virtual_consumer_data *drvdata = platform_get_drvdata(pdev); regulator_virtual_remove() local
330 if (drvdata->enabled) regulator_virtual_remove()
331 regulator_disable(drvdata->regulator); regulator_virtual_remove()
|
| H A D | twl-regulator.c | 1098 struct twl_regulator_driver_data *drvdata; twlreg_probe() local
1109 drvdata = NULL; twlreg_probe()
1121 drvdata = initdata->driver_data; twlreg_probe()
1122 if (!drvdata) twlreg_probe()
1136 if (drvdata) { twlreg_probe()
1138 info->features = drvdata->features; twlreg_probe()
1139 info->data = drvdata->data; twlreg_probe()
1140 info->set_voltage = drvdata->set_voltage; twlreg_probe()
1141 info->get_voltage = drvdata->get_voltage; twlreg_probe()
|
| H A D | ti-abb-regulator.c | 331 dev_err_ratelimited(dev, "%s: No regulator drvdata\n", ti_abb_set_voltage_sel()
390 dev_err_ratelimited(dev, "%s: No regulator drvdata\n", ti_abb_get_voltage_sel()
|
| /linux-4.4.14/sound/soc/ux500/ |
| H A D | ux500_msp_dai.c | 36 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); setup_pcm_multichan() local
40 if (drvdata->slots > 1) { setup_pcm_multichan()
47 multi->tx_channel_0_enable = drvdata->tx_mask; setup_pcm_multichan()
52 multi->rx_channel_0_enable = drvdata->rx_mask; setup_pcm_multichan()
59 __func__, drvdata->slots, multi->tx_channel_0_enable, setup_pcm_multichan()
69 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); setup_frameper() local
71 switch (drvdata->slots) { setup_frameper()
116 __func__, drvdata->slots); setup_frameper()
133 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); setup_pcm_framing() local
138 switch (drvdata->slots) { setup_pcm_framing()
157 __func__, drvdata->slots); setup_pcm_framing()
307 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); setup_msp_config() local
310 unsigned int fmt = drvdata->fmt; setup_msp_config()
315 msp_config->f_inputclk = drvdata->master_clk; setup_msp_config()
389 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_startup() local
395 ret = regulator_enable(drvdata->reg_vape); ux500_msp_dai_startup()
397 dev_err(drvdata->msp->dev, ux500_msp_dai_startup()
404 ret = clk_prepare_enable(drvdata->pclk); ux500_msp_dai_startup()
406 dev_err(drvdata->msp->dev, ux500_msp_dai_startup()
411 ret = clk_prepare_enable(drvdata->clk); ux500_msp_dai_startup()
413 dev_err(drvdata->msp->dev, ux500_msp_dai_startup()
420 clk_disable_unprepare(drvdata->pclk); ux500_msp_dai_startup()
422 regulator_disable(drvdata->reg_vape); ux500_msp_dai_startup()
430 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_shutdown() local
436 if (drvdata->vape_opp_constraint == 1) { ux500_msp_dai_shutdown()
439 drvdata->vape_opp_constraint = 0; ux500_msp_dai_shutdown()
442 if (ux500_msp_i2s_close(drvdata->msp, ux500_msp_dai_shutdown()
450 clk_disable_unprepare(drvdata->clk); ux500_msp_dai_shutdown()
451 clk_disable_unprepare(drvdata->pclk); ux500_msp_dai_shutdown()
454 ret = regulator_disable(drvdata->reg_vape); ux500_msp_dai_shutdown()
465 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_prepare() local
474 ret = ux500_msp_i2s_open(drvdata->msp, &msp_config); ux500_msp_dai_prepare()
482 if ((drvdata->fmt & SND_SOC_DAIFMT_MASTER_MASK) && ux500_msp_dai_prepare()
483 (drvdata->msp->f_bitclk > 19200000)) { ux500_msp_dai_prepare()
488 drvdata->vape_opp_constraint = 1; ux500_msp_dai_prepare()
492 drvdata->vape_opp_constraint = 0; ux500_msp_dai_prepare()
504 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_hw_params() local
509 switch (drvdata->fmt & SND_SOC_DAIFMT_FORMAT_MASK) { ux500_msp_dai_hw_params()
519 drvdata->tx_mask : ux500_msp_dai_hw_params()
520 drvdata->rx_mask; ux500_msp_dai_hw_params()
533 __func__, drvdata->fmt); ux500_msp_dai_hw_params()
543 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_set_dai_fmt() local
560 __func__, drvdata->fmt); ux500_msp_dai_set_dai_fmt()
573 __func__, drvdata->fmt); ux500_msp_dai_set_dai_fmt()
577 drvdata->fmt = fmt; ux500_msp_dai_set_dai_fmt()
586 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_set_tdm_slot() local
607 drvdata->slots = slots; ux500_msp_dai_set_tdm_slot()
614 drvdata->slot_width = slot_width; ux500_msp_dai_set_tdm_slot()
616 drvdata->tx_mask = tx_mask & cap; ux500_msp_dai_set_tdm_slot()
617 drvdata->rx_mask = rx_mask & cap; ux500_msp_dai_set_tdm_slot()
625 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_set_dai_sysclk() local
632 drvdata->master_clk = freq; ux500_msp_dai_set_dai_sysclk()
648 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_trigger() local
652 (int)drvdata->msp->id, cmd); ux500_msp_dai_trigger()
654 ret = ux500_msp_i2s_trigger(drvdata->msp, cmd, substream->stream); ux500_msp_dai_trigger()
661 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_of_probe() local
677 playback_dma_data->addr = drvdata->msp->playback_dma_data.tx_rx_addr; ux500_msp_dai_of_probe()
678 capture_dma_data->addr = drvdata->msp->capture_dma_data.tx_rx_addr; ux500_msp_dai_of_probe()
690 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(dai->dev); ux500_msp_dai_probe() local
699 drvdata->msp->playback_dma_data.data_size = drvdata->slot_width; ux500_msp_dai_probe()
700 drvdata->msp->capture_dma_data.data_size = drvdata->slot_width; ux500_msp_dai_probe()
703 &drvdata->msp->playback_dma_data, ux500_msp_dai_probe()
704 &drvdata->msp->capture_dma_data); ux500_msp_dai_probe()
743 struct ux500_msp_i2s_drvdata *drvdata; ux500_msp_drv_probe() local
753 drvdata = devm_kzalloc(&pdev->dev, ux500_msp_drv_probe()
756 if (!drvdata) ux500_msp_drv_probe()
759 drvdata->fmt = 0; ux500_msp_drv_probe()
760 drvdata->slots = 1; ux500_msp_drv_probe()
761 drvdata->tx_mask = 0x01; ux500_msp_drv_probe()
762 drvdata->rx_mask = 0x01; ux500_msp_drv_probe()
763 drvdata->slot_width = 16; ux500_msp_drv_probe()
764 drvdata->master_clk = MSP_INPUT_FREQ_APB; ux500_msp_drv_probe()
766 drvdata->reg_vape = devm_regulator_get(&pdev->dev, "v-ape"); ux500_msp_drv_probe()
767 if (IS_ERR(drvdata->reg_vape)) { ux500_msp_drv_probe()
768 ret = (int)PTR_ERR(drvdata->reg_vape); ux500_msp_drv_probe()
776 drvdata->pclk = devm_clk_get(&pdev->dev, "apb_pclk"); ux500_msp_drv_probe()
777 if (IS_ERR(drvdata->pclk)) { ux500_msp_drv_probe()
778 ret = (int)PTR_ERR(drvdata->pclk); ux500_msp_drv_probe()
785 drvdata->clk = devm_clk_get(&pdev->dev, NULL); ux500_msp_drv_probe()
786 if (IS_ERR(drvdata->clk)) { ux500_msp_drv_probe()
787 ret = (int)PTR_ERR(drvdata->clk); ux500_msp_drv_probe()
794 ret = ux500_msp_i2s_init_msp(pdev, &drvdata->msp, ux500_msp_drv_probe()
796 if (!drvdata->msp) { ux500_msp_drv_probe()
802 dev_set_drvdata(&pdev->dev, drvdata); ux500_msp_drv_probe()
808 __func__, drvdata->msp->id); ux500_msp_drv_probe()
829 struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(&pdev->dev); ux500_msp_drv_remove() local
837 ux500_msp_i2s_cleanup_msp(pdev, drvdata->msp); ux500_msp_drv_remove()
|
| H A D | mop500_ab8500.c | 88 struct mop500_ab8500_drvdata *drvdata) mop500_ab8500_set_mclk()
93 if (IS_ERR(drvdata->clk_ptr_intclk)) { mop500_ab8500_set_mclk()
99 switch (drvdata->mclk_sel) { mop500_ab8500_set_mclk()
101 clk_ptr = drvdata->clk_ptr_sysclk; mop500_ab8500_set_mclk()
104 clk_ptr = drvdata->clk_ptr_ulpclk; mop500_ab8500_set_mclk()
112 get_mclk_str(drvdata->mclk_sel)); mop500_ab8500_set_mclk()
116 status = clk_set_parent(drvdata->clk_ptr_intclk, clk_ptr); mop500_ab8500_set_mclk()
120 __func__, get_mclk_str(drvdata->mclk_sel), status); mop500_ab8500_set_mclk()
124 __func__, get_mclk_str(drvdata->mclk_sel)); mop500_ab8500_set_mclk()
137 struct mop500_ab8500_drvdata *drvdata = mclk_input_control_get() local
140 ucontrol->value.enumerated.item[0] = drvdata->mclk_sel; mclk_input_control_get()
149 struct mop500_ab8500_drvdata *drvdata = mclk_input_control_put() local
155 if (drvdata->mclk_sel == val) mclk_input_control_put()
158 drvdata->mclk_sel = val; mclk_input_control_put()
367 struct mop500_ab8500_drvdata *drvdata; mop500_ab8500_machine_init() local
373 drvdata = devm_kzalloc(dev, sizeof(struct mop500_ab8500_drvdata), mop500_ab8500_machine_init()
376 if (!drvdata) mop500_ab8500_machine_init()
379 snd_soc_card_set_drvdata(rtd->card, drvdata); mop500_ab8500_machine_init()
383 drvdata->clk_ptr_sysclk = clk_get(dev, "sysclk"); mop500_ab8500_machine_init()
384 if (IS_ERR(drvdata->clk_ptr_sysclk)) mop500_ab8500_machine_init()
387 drvdata->clk_ptr_ulpclk = clk_get(dev, "ulpclk"); mop500_ab8500_machine_init()
388 if (IS_ERR(drvdata->clk_ptr_ulpclk)) mop500_ab8500_machine_init()
391 drvdata->clk_ptr_intclk = clk_get(dev, "intclk"); mop500_ab8500_machine_init()
392 if (IS_ERR(drvdata->clk_ptr_intclk)) mop500_ab8500_machine_init()
397 drvdata->mclk_sel = MCLK_ULPCLK; mop500_ab8500_machine_init()
398 ret = mop500_ab8500_set_mclk(dev, drvdata); mop500_ab8500_machine_init()
403 drvdata->mclk_sel = MCLK_ULPCLK; mop500_ab8500_machine_init()
437 struct mop500_ab8500_drvdata *drvdata = snd_soc_card_get_drvdata(card); mop500_ab8500_remove() local
439 if (drvdata->clk_ptr_sysclk != NULL) mop500_ab8500_remove()
440 clk_put(drvdata->clk_ptr_sysclk); mop500_ab8500_remove()
441 if (drvdata->clk_ptr_ulpclk != NULL) mop500_ab8500_remove()
442 clk_put(drvdata->clk_ptr_ulpclk); mop500_ab8500_remove()
443 if (drvdata->clk_ptr_intclk != NULL) mop500_ab8500_remove()
444 clk_put(drvdata->clk_ptr_intclk); mop500_ab8500_remove()
446 snd_soc_card_set_drvdata(card, drvdata); mop500_ab8500_remove()
87 mop500_ab8500_set_mclk(struct device *dev, struct mop500_ab8500_drvdata *drvdata) mop500_ab8500_set_mclk() argument
|
| H A D | mop500.c | 116 dev_dbg(&pdev->dev, "%s: Card %s: Set platform drvdata.\n", mop500_probe()
|
| /linux-4.4.14/drivers/edac/ |
| H A D | highbank_l2_edac.c | 39 struct hb_l2_drvdata *drvdata = dci->pvt_info; highbank_l2_err_handler() local
41 if (irq == drvdata->sb_irq) { highbank_l2_err_handler()
42 writel(1, drvdata->base + SR_CLR_SB_ECC_INTR); highbank_l2_err_handler()
45 if (irq == drvdata->db_irq) { highbank_l2_err_handler()
46 writel(1, drvdata->base + SR_CLR_DB_ECC_INTR); highbank_l2_err_handler()
63 struct hb_l2_drvdata *drvdata; highbank_l2_err_probe() local
67 dci = edac_device_alloc_ctl_info(sizeof(*drvdata), "cpu", highbank_l2_err_probe()
72 drvdata = dci->pvt_info; highbank_l2_err_probe()
93 drvdata->base = devm_ioremap(&pdev->dev, r->start, resource_size(r)); highbank_l2_err_probe()
94 if (!drvdata->base) { highbank_l2_err_probe()
108 drvdata->db_irq = platform_get_irq(pdev, 0); highbank_l2_err_probe()
109 res = devm_request_irq(&pdev->dev, drvdata->db_irq, highbank_l2_err_probe()
115 drvdata->sb_irq = platform_get_irq(pdev, 1); highbank_l2_err_probe()
116 res = devm_request_irq(&pdev->dev, drvdata->sb_irq, highbank_l2_err_probe()
|
| H A D | highbank_mc_edac.c | 68 struct hb_mc_drvdata *drvdata = mci->pvt_info; highbank_mc_err_handler() local
72 status = readl(drvdata->mc_int_base + HB_DDR_ECC_INT_STATUS); highbank_mc_err_handler()
75 err_addr = readl(drvdata->mc_err_base + HB_DDR_ECC_U_ERR_ADDR); highbank_mc_err_handler()
83 u32 syndrome = readl(drvdata->mc_err_base + HB_DDR_ECC_C_ERR_STAT); highbank_mc_err_handler()
85 err_addr = readl(drvdata->mc_err_base + HB_DDR_ECC_C_ERR_ADDR); highbank_mc_err_handler()
94 writel(status, drvdata->mc_int_base + HB_DDR_ECC_INT_ACK); highbank_mc_err_handler()
162 struct hb_mc_drvdata *drvdata; highbank_mc_probe() local
186 drvdata = mci->pvt_info; highbank_mc_probe()
214 drvdata->mc_err_base = base + settings->err_offset; highbank_mc_probe()
215 drvdata->mc_int_base = base + settings->int_offset; highbank_mc_probe()
217 control = readl(drvdata->mc_err_base + HB_DDR_ECC_OPT) & 0x3; highbank_mc_probe()
|
| H A D | altera_edac.c | 81 struct altr_sdram_mc_data *drvdata = mci->pvt_info; altr_sdram_mc_err_handler() local
82 const struct altr_sdram_prv_data *priv = drvdata->data; altr_sdram_mc_err_handler()
85 regmap_read(drvdata->mc_vbase, priv->ecc_stat_offset, &status); altr_sdram_mc_err_handler()
88 regmap_read(drvdata->mc_vbase, priv->ecc_daddr_offset, altr_sdram_mc_err_handler()
91 regmap_read(drvdata->mc_vbase, priv->ecc_uecnt_offset, altr_sdram_mc_err_handler()
97 regmap_read(drvdata->mc_vbase, priv->ecc_saddr_offset, altr_sdram_mc_err_handler()
100 regmap_read(drvdata->mc_vbase, priv->ecc_cecnt_offset, altr_sdram_mc_err_handler()
107 regmap_write(drvdata->mc_vbase, priv->ecc_irq_clr_offset, altr_sdram_mc_err_handler()
120 struct altr_sdram_mc_data *drvdata = mci->pvt_info; altr_sdr_mc_err_inject_write() local
121 const struct altr_sdram_prv_data *priv = drvdata->data; altr_sdr_mc_err_inject_write()
134 regmap_read(drvdata->mc_vbase, priv->ce_ue_trgr_offset, altr_sdr_mc_err_inject_write()
145 regmap_write(drvdata->mc_vbase, priv->ce_ue_trgr_offset, altr_sdr_mc_err_inject_write()
150 regmap_write(drvdata->mc_vbase, priv->ce_ue_trgr_offset, altr_sdr_mc_err_inject_write()
158 regmap_write(drvdata->mc_vbase, priv->ce_ue_trgr_offset, read_reg); altr_sdr_mc_err_inject_write()
287 struct altr_sdram_mc_data *drvdata; altr_sdram_probe() local
373 drvdata = mci->pvt_info; altr_sdram_probe()
374 drvdata->mc_vbase = mc_vbase; altr_sdram_probe()
375 drvdata->data = priv; altr_sdram_probe()
439 if (regmap_update_bits(drvdata->mc_vbase, priv->ecc_irq_en_offset, altr_sdram_probe()
|
| /linux-4.4.14/drivers/pinctrl/samsung/ |
| H A D | pinctrl-samsung.c | 187 static int samsung_dt_subnode_to_map(struct samsung_pinctrl_drv_data *drvdata, samsung_dt_subnode_to_map() argument
267 struct samsung_pinctrl_drv_data *drvdata; samsung_dt_node_to_map() local
272 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_dt_node_to_map()
279 return samsung_dt_subnode_to_map(drvdata, pctldev->dev, samsung_dt_node_to_map()
285 ret = samsung_dt_subnode_to_map(drvdata, pctldev->dev, np, map, for_each_child_of_node()
308 struct samsung_pinctrl_drv_data *drvdata; samsung_get_functions_count() local
310 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_get_functions_count()
311 return drvdata->nr_functions; samsung_get_functions_count()
318 struct samsung_pinctrl_drv_data *drvdata; samsung_pinmux_get_fname() local
320 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_pinmux_get_fname()
321 return drvdata->pmx_functions[selector].name; samsung_pinmux_get_fname()
329 struct samsung_pinctrl_drv_data *drvdata; samsung_pinmux_get_groups() local
331 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_pinmux_get_groups()
332 *groups = drvdata->pmx_functions[selector].groups; samsung_pinmux_get_groups()
333 *num_groups = drvdata->pmx_functions[selector].num_groups; samsung_pinmux_get_groups()
341 static void pin_to_reg_bank(struct samsung_pinctrl_drv_data *drvdata, pin_to_reg_bank() argument
347 b = drvdata->pin_banks; pin_to_reg_bank()
353 *reg = drvdata->virt_base + b->pctl_offset; pin_to_reg_bank()
363 struct samsung_pinctrl_drv_data *drvdata; samsung_pinmux_setup() local
372 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_pinmux_setup()
373 func = &drvdata->pmx_functions[selector]; samsung_pinmux_setup()
374 grp = &drvdata->pin_groups[group]; samsung_pinmux_setup()
376 pin_to_reg_bank(drvdata, grp->pins[0] - drvdata->pin_base, samsung_pinmux_setup()
419 struct samsung_pinctrl_drv_data *drvdata; samsung_pinconf_rw() local
428 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_pinconf_rw()
429 pin_to_reg_bank(drvdata, pin - drvdata->pin_base, ®_base, samsung_pinconf_rw()
488 struct samsung_pinctrl_drv_data *drvdata; samsung_pinconf_group_set() local
492 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_pinconf_group_set()
493 pins = drvdata->pin_groups[group].pins; samsung_pinconf_group_set()
495 for (cnt = 0; cnt < drvdata->pin_groups[group].num_pins; cnt++) samsung_pinconf_group_set()
505 struct samsung_pinctrl_drv_data *drvdata; samsung_pinconf_group_get() local
508 drvdata = pinctrl_dev_get_drvdata(pctldev); samsung_pinconf_group_get()
509 pins = drvdata->pin_groups[group].pins; samsung_pinconf_group_get()
531 reg = bank->drvdata->virt_base + bank->pctl_offset; samsung_gpio_set()
552 reg = bank->drvdata->virt_base + bank->pctl_offset; samsung_gpio_get()
569 struct samsung_pinctrl_drv_data *drvdata; samsung_gpio_set_direction() local
576 drvdata = bank->drvdata; samsung_gpio_set_direction()
578 reg = drvdata->virt_base + bank->pctl_offset + samsung_gpio_set_direction()
635 struct samsung_pinctrl_drv_data *drvdata, samsung_pinctrl_create_groups()
638 struct pinctrl_desc *ctrldesc = &drvdata->pctl; samsung_pinctrl_create_groups()
661 struct samsung_pinctrl_drv_data *drvdata, samsung_pinctrl_create_function()
705 struct samsung_pinctrl_drv_data *drvdata, samsung_pinctrl_create_functions()
754 ret = samsung_pinctrl_create_function(dev, drvdata, for_each_child_of_node()
766 ret = samsung_pinctrl_create_function(dev, drvdata, for_each_child_of_node()
788 struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_parse_dt()
795 groups = samsung_pinctrl_create_groups(dev, drvdata, &grp_cnt); samsung_pinctrl_parse_dt()
801 functions = samsung_pinctrl_create_functions(dev, drvdata, &func_cnt); samsung_pinctrl_parse_dt()
807 drvdata->pin_groups = groups; samsung_pinctrl_parse_dt()
808 drvdata->nr_groups = grp_cnt; samsung_pinctrl_parse_dt()
809 drvdata->pmx_functions = functions; samsung_pinctrl_parse_dt()
810 drvdata->nr_functions = func_cnt; samsung_pinctrl_parse_dt()
817 struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_register()
819 struct pinctrl_desc *ctrldesc = &drvdata->pctl; samsung_pinctrl_register()
832 drvdata->nr_pins, GFP_KERNEL); samsung_pinctrl_register()
838 ctrldesc->npins = drvdata->nr_pins; samsung_pinctrl_register()
842 pdesc->number = pin + drvdata->pin_base; samsung_pinctrl_register()
849 drvdata->nr_pins, GFP_KERNEL); samsung_pinctrl_register()
856 for (bank = 0; bank < drvdata->nr_banks; bank++) { samsung_pinctrl_register()
857 pin_bank = &drvdata->pin_banks[bank]; samsung_pinctrl_register()
866 ret = samsung_pinctrl_parse_dt(pdev, drvdata); samsung_pinctrl_register()
870 drvdata->pctl_dev = pinctrl_register(ctrldesc, &pdev->dev, drvdata); samsung_pinctrl_register()
871 if (IS_ERR(drvdata->pctl_dev)) { samsung_pinctrl_register()
873 return PTR_ERR(drvdata->pctl_dev); samsung_pinctrl_register()
876 for (bank = 0; bank < drvdata->nr_banks; ++bank) { samsung_pinctrl_register()
877 pin_bank = &drvdata->pin_banks[bank]; samsung_pinctrl_register()
880 pin_bank->grange.pin_base = drvdata->pin_base samsung_pinctrl_register()
885 pinctrl_add_gpio_range(drvdata->pctl_dev, &pin_bank->grange); samsung_pinctrl_register()
904 struct samsung_pinctrl_drv_data *drvdata) samsung_gpiolib_register()
906 struct samsung_pin_bank *bank = drvdata->pin_banks; samsung_gpiolib_register()
911 for (i = 0; i < drvdata->nr_banks; ++i, ++bank) { samsung_gpiolib_register()
915 gc->base = drvdata->pin_base + bank->pin_base; samsung_gpiolib_register()
939 struct samsung_pinctrl_drv_data *drvdata) samsung_gpiolib_unregister()
941 struct samsung_pin_bank *bank = drvdata->pin_banks; samsung_gpiolib_unregister()
944 for (i = 0; i < drvdata->nr_banks; ++i, ++bank) samsung_gpiolib_unregister()
995 bank->drvdata = d; samsung_pinctrl_get_soc_data()
1020 struct samsung_pinctrl_drv_data *drvdata; samsung_pinctrl_probe() local
1031 drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); samsung_pinctrl_probe()
1032 if (!drvdata) { samsung_pinctrl_probe()
1038 ctrl = samsung_pinctrl_get_soc_data(drvdata, pdev); samsung_pinctrl_probe()
1043 drvdata->dev = dev; samsung_pinctrl_probe()
1046 drvdata->virt_base = devm_ioremap_resource(&pdev->dev, res); samsung_pinctrl_probe()
1047 if (IS_ERR(drvdata->virt_base)) samsung_pinctrl_probe()
1048 return PTR_ERR(drvdata->virt_base); samsung_pinctrl_probe()
1052 drvdata->irq = res->start; samsung_pinctrl_probe()
1054 ret = samsung_gpiolib_register(pdev, drvdata); samsung_pinctrl_probe()
1058 ret = samsung_pinctrl_register(pdev, drvdata); samsung_pinctrl_probe()
1060 samsung_gpiolib_unregister(pdev, drvdata); samsung_pinctrl_probe()
1065 ctrl->eint_gpio_init(drvdata); samsung_pinctrl_probe()
1067 ctrl->eint_wkup_init(drvdata); samsung_pinctrl_probe()
1069 platform_set_drvdata(pdev, drvdata); samsung_pinctrl_probe()
1072 list_add_tail(&drvdata->node, &drvdata_list); samsung_pinctrl_probe()
1085 struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_suspend_dev()
1087 void __iomem *virt_base = drvdata->virt_base; samsung_pinctrl_suspend_dev()
1090 for (i = 0; i < drvdata->nr_banks; i++) { samsung_pinctrl_suspend_dev()
1091 struct samsung_pin_bank *bank = &drvdata->pin_banks[i]; samsung_pinctrl_suspend_dev()
1119 if (drvdata->suspend) samsung_pinctrl_suspend_dev()
1120 drvdata->suspend(drvdata); samsung_pinctrl_suspend_dev()
1131 static void samsung_pinctrl_resume_dev(struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_resume_dev() argument
1133 void __iomem *virt_base = drvdata->virt_base; samsung_pinctrl_resume_dev()
1136 if (drvdata->resume) samsung_pinctrl_resume_dev()
1137 drvdata->resume(drvdata); samsung_pinctrl_resume_dev()
1139 for (i = 0; i < drvdata->nr_banks; i++) { samsung_pinctrl_resume_dev()
1140 struct samsung_pin_bank *bank = &drvdata->pin_banks[i]; samsung_pinctrl_resume_dev()
1178 struct samsung_pinctrl_drv_data *drvdata; samsung_pinctrl_suspend() local
1180 list_for_each_entry(drvdata, &drvdata_list, node) { samsung_pinctrl_suspend()
1181 samsung_pinctrl_suspend_dev(drvdata); samsung_pinctrl_suspend()
1194 struct samsung_pinctrl_drv_data *drvdata; samsung_pinctrl_resume() local
1196 list_for_each_entry_reverse(drvdata, &drvdata_list, node) { samsung_pinctrl_resume()
1197 samsung_pinctrl_resume_dev(drvdata); samsung_pinctrl_resume()
633 samsung_pinctrl_create_groups( struct device *dev, struct samsung_pinctrl_drv_data *drvdata, unsigned int *cnt) samsung_pinctrl_create_groups() argument
660 samsung_pinctrl_create_function(struct device *dev, struct samsung_pinctrl_drv_data *drvdata, struct device_node *func_np, struct samsung_pmx_func *func) samsung_pinctrl_create_function() argument
703 samsung_pinctrl_create_functions( struct device *dev, struct samsung_pinctrl_drv_data *drvdata, unsigned int *cnt) samsung_pinctrl_create_functions() argument
787 samsung_pinctrl_parse_dt(struct platform_device *pdev, struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_parse_dt() argument
816 samsung_pinctrl_register(struct platform_device *pdev, struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_register() argument
903 samsung_gpiolib_register(struct platform_device *pdev, struct samsung_pinctrl_drv_data *drvdata) samsung_gpiolib_register() argument
938 samsung_gpiolib_unregister(struct platform_device *pdev, struct samsung_pinctrl_drv_data *drvdata) samsung_gpiolib_unregister() argument
1084 samsung_pinctrl_suspend_dev( struct samsung_pinctrl_drv_data *drvdata) samsung_pinctrl_suspend_dev() argument
|
| H A D | pinctrl-s3c64xx.c | 202 * @drvdata: pin controller driver data
207 struct samsung_pinctrl_drv_data *drvdata; member in struct:s3c64xx_eint0_data
224 * @drvdata: pin controller driver data
228 struct samsung_pinctrl_drv_data *drvdata; member in struct:s3c64xx_eint_gpio_data
311 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c64xx_gpio_irq_set_mask()
337 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c64xx_gpio_irq_ack()
347 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c64xx_gpio_irq_set_type()
414 struct samsung_pinctrl_drv_data *drvdata = data->drvdata; s3c64xx_eint_gpio_irq() local
424 svc = readl(drvdata->virt_base + SERVICE_REG); s3c64xx_eint_gpio_irq()
497 data->drvdata = d; s3c64xx_eint_gpio_init()
521 struct samsung_pinctrl_drv_data *d = ddata->bank->drvdata; s3c64xx_eint0_irq_set_mask()
546 struct samsung_pinctrl_drv_data *d = ddata->bank->drvdata; s3c64xx_eint0_irq_ack()
557 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c64xx_eint0_irq_set_type()
605 struct samsung_pinctrl_drv_data *drvdata = data->drvdata; s3c64xx_irq_demux_eint() local
610 pend = readl(drvdata->virt_base + EINT0PEND_REG); s3c64xx_irq_demux_eint()
611 mask = readl(drvdata->virt_base + EINT0MASK_REG); s3c64xx_irq_demux_eint()
718 data->drvdata = d; s3c64xx_eint_eint0_init()
|
| H A D | pinctrl-s3c24xx.c | 89 * @drvdata: pin controller driver data
94 struct samsung_pinctrl_drv_data *drvdata; member in struct:s3c24xx_eint_data
171 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c24xx_eint_type()
262 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c2412_eint0_3_ack()
271 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c2412_eint0_3_mask()
282 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c2412_eint0_3_unmask()
322 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c24xx_eint_ack()
331 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c24xx_eint_mask()
343 struct samsung_pinctrl_drv_data *d = bank->drvdata; s3c24xx_eint_unmask()
365 struct samsung_pinctrl_drv_data *d = data->drvdata; s3c24xx_demux_eint()
501 eint_data->drvdata = d; s3c24xx_eint_init()
|
| H A D | pinctrl-exynos.c | 64 struct samsung_pinctrl_drv_data *d = bank->drvdata; exynos_irq_mask()
83 struct samsung_pinctrl_drv_data *d = bank->drvdata; exynos_irq_ack()
94 struct samsung_pinctrl_drv_data *d = bank->drvdata; exynos_irq_unmask()
124 struct samsung_pinctrl_drv_data *d = bank->drvdata; exynos_irq_set_type()
169 struct samsung_pinctrl_drv_data *d = bank->drvdata; exynos_irq_request_resources()
208 struct samsung_pinctrl_drv_data *d = bank->drvdata; exynos_irq_release_resources()
458 struct samsung_pinctrl_drv_data *d = eintd->banks[0]->drvdata; exynos_irq_demux_eint16_31()
583 struct samsung_pinctrl_drv_data *drvdata, exynos_pinctrl_suspend_bank()
587 void __iomem *regs = drvdata->virt_base; exynos_pinctrl_suspend_bank()
601 static void exynos_pinctrl_suspend(struct samsung_pinctrl_drv_data *drvdata) exynos_pinctrl_suspend() argument
603 struct samsung_pin_bank *bank = drvdata->pin_banks; exynos_pinctrl_suspend()
606 for (i = 0; i < drvdata->nr_banks; ++i, ++bank) exynos_pinctrl_suspend()
608 exynos_pinctrl_suspend_bank(drvdata, bank); exynos_pinctrl_suspend()
612 struct samsung_pinctrl_drv_data *drvdata, exynos_pinctrl_resume_bank()
616 void __iomem *regs = drvdata->virt_base; exynos_pinctrl_resume_bank()
636 static void exynos_pinctrl_resume(struct samsung_pinctrl_drv_data *drvdata) exynos_pinctrl_resume() argument
638 struct samsung_pin_bank *bank = drvdata->pin_banks; exynos_pinctrl_resume()
641 for (i = 0; i < drvdata->nr_banks; ++i, ++bank) exynos_pinctrl_resume()
643 exynos_pinctrl_resume_bank(drvdata, bank); exynos_pinctrl_resume()
582 exynos_pinctrl_suspend_bank( struct samsung_pinctrl_drv_data *drvdata, struct samsung_pin_bank *bank) exynos_pinctrl_suspend_bank() argument
611 exynos_pinctrl_resume_bank( struct samsung_pinctrl_drv_data *drvdata, struct samsung_pin_bank *bank) exynos_pinctrl_resume_bank() argument
|
| H A D | pinctrl-samsung.h | 150 * @drvdata: link to controller driver data
171 struct samsung_pinctrl_drv_data *drvdata; member in struct:samsung_pin_bank
|
| /linux-4.4.14/drivers/iommu/ |
| H A D | msm_iommu_dev.c | 133 struct msm_iommu_drvdata *drvdata; msm_iommu_probe() local
143 drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL); msm_iommu_probe()
145 if (!drvdata) { msm_iommu_probe()
209 "msm_iommu_secure_irpt_handler", drvdata); msm_iommu_probe()
216 drvdata->pclk = iommu_pclk; msm_iommu_probe()
217 drvdata->clk = iommu_clk; msm_iommu_probe()
218 drvdata->base = regs_base; msm_iommu_probe()
219 drvdata->irq = irq; msm_iommu_probe()
220 drvdata->ncb = iommu_dev->ncb; msm_iommu_probe()
225 platform_set_drvdata(pdev, drvdata); msm_iommu_probe()
242 kfree(drvdata); msm_iommu_probe()
267 struct msm_iommu_drvdata *drvdata; msm_iommu_ctx_probe() local
274 drvdata = dev_get_drvdata(pdev->dev.parent); msm_iommu_ctx_probe()
275 if (!drvdata) msm_iommu_ctx_probe()
288 ret = clk_prepare_enable(drvdata->pclk); msm_iommu_ctx_probe()
292 if (drvdata->clk) { msm_iommu_ctx_probe()
293 ret = clk_prepare_enable(drvdata->clk); msm_iommu_ctx_probe()
295 clk_disable_unprepare(drvdata->pclk); msm_iommu_ctx_probe()
306 SET_M2VCBR_N(drvdata->base, mid, 0); msm_iommu_ctx_probe()
307 SET_CBACR_N(drvdata->base, c->num, 0); msm_iommu_ctx_probe()
310 SET_VMID(drvdata->base, mid, 0); msm_iommu_ctx_probe()
313 SET_CBNDX(drvdata->base, mid, c->num); msm_iommu_ctx_probe()
316 SET_CBVMID(drvdata->base, c->num, 0); msm_iommu_ctx_probe()
319 SET_CONTEXTIDR_ASID(drvdata->base, c->num, c->num); msm_iommu_ctx_probe()
322 SET_NSCFG(drvdata->base, mid, 3); msm_iommu_ctx_probe()
325 clk_disable(drvdata->clk); msm_iommu_ctx_probe()
326 clk_disable(drvdata->pclk); msm_iommu_ctx_probe()
|
| H A D | msm_iommu.c | 63 static int __enable_clocks(struct msm_iommu_drvdata *drvdata) __enable_clocks() argument
67 ret = clk_enable(drvdata->pclk); __enable_clocks()
71 if (drvdata->clk) { __enable_clocks()
72 ret = clk_enable(drvdata->clk); __enable_clocks()
74 clk_disable(drvdata->pclk); __enable_clocks()
80 static void __disable_clocks(struct msm_iommu_drvdata *drvdata) __disable_clocks() argument
82 clk_disable(drvdata->clk); __disable_clocks()
83 clk_disable(drvdata->pclk); __disable_clocks()
638 struct msm_iommu_drvdata *drvdata = dev_id; msm_iommu_fault_handler() local
645 if (!drvdata) { msm_iommu_fault_handler()
650 base = drvdata->base; msm_iommu_fault_handler()
655 ret = __enable_clocks(drvdata); msm_iommu_fault_handler()
659 for (i = 0; i < drvdata->ncb; i++) { msm_iommu_fault_handler()
668 __disable_clocks(drvdata); msm_iommu_fault_handler()
|
| H A D | iommu-sysfs.c | 57 struct device *iommu_device_create(struct device *parent, void *drvdata, iommu_device_create() argument
74 dev_set_drvdata(dev, drvdata); iommu_device_create()
|
| H A D | tegra-smmu.c | 886 * callback via the IOMMU device's .drvdata field. tegra_smmu_probe()
|
| /linux-4.4.14/sound/soc/davinci/ |
| H A D | davinci-evm.c | 36 struct snd_soc_card_drvdata_davinci *drvdata = evm_startup() local
39 if (drvdata->mclk) evm_startup()
40 return clk_prepare_enable(drvdata->mclk); evm_startup()
49 struct snd_soc_card_drvdata_davinci *drvdata = evm_shutdown() local
52 if (drvdata->mclk) evm_shutdown()
53 clk_disable_unprepare(drvdata->mclk); evm_shutdown()
260 .drvdata = &dm6446_snd_soc_card_drvdata,
274 .drvdata = &dm355_snd_soc_card_drvdata,
287 .drvdata = &dm365_snd_soc_card_drvdata,
300 .drvdata = &dm6467_snd_soc_card_drvdata,
312 .drvdata = &da830_snd_soc_card_drvdata,
324 .drvdata = &da850_snd_soc_card_drvdata,
364 struct snd_soc_card_drvdata_davinci *drvdata = NULL; davinci_evm_probe() local
393 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); davinci_evm_probe()
394 if (!drvdata) davinci_evm_probe()
397 drvdata->mclk = mclk; davinci_evm_probe()
399 ret = of_property_read_u32(np, "ti,codec-clock-rate", &drvdata->sysclk); davinci_evm_probe()
402 if (!drvdata->mclk) { davinci_evm_probe()
407 drvdata->sysclk = clk_get_rate(drvdata->mclk); davinci_evm_probe()
408 } else if (drvdata->mclk) { davinci_evm_probe()
409 unsigned int requestd_rate = drvdata->sysclk; davinci_evm_probe()
410 clk_set_rate(drvdata->mclk, drvdata->sysclk); davinci_evm_probe()
411 drvdata->sysclk = clk_get_rate(drvdata->mclk); davinci_evm_probe()
412 if (drvdata->sysclk != requestd_rate) davinci_evm_probe()
415 requestd_rate, drvdata->sysclk); davinci_evm_probe()
418 snd_soc_card_set_drvdata(&evm_soc_card, drvdata); davinci_evm_probe()
|
| /linux-4.4.14/sound/soc/codecs/ |
| H A D | sti-sas.c | 113 struct sti_sas_data *drvdata = context; sti_sas_read_reg() local
117 status = regmap_read(drvdata->dac.regmap, reg, &val); sti_sas_read_reg()
127 struct sti_sas_data *drvdata = context; sti_sas_write_reg() local
130 status = regmap_write(drvdata->dac.regmap, reg, value); sti_sas_write_reg()
223 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev); stih416_dac_probe() local
224 struct sti_dac_audio *dac = &drvdata->dac; stih416_dac_probe()
364 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev); sti_sas_set_sysclk() local
374 drvdata->spdif.mclk = freq; sti_sas_set_sysclk()
378 drvdata->dac.mclk = freq; sti_sas_set_sysclk()
389 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev); sti_sas_prepare() local
394 if ((drvdata->spdif.mclk / runtime->rate) != 128) { sti_sas_prepare()
400 if ((drvdata->dac.mclk / runtime->rate) != 256) { sti_sas_prepare()
511 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev); sti_sas_resume() local
513 return sti_sas_init_sas_registers(codec, drvdata); sti_sas_resume()
521 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev); sti_sas_codec_probe() local
524 ret = sti_sas_init_sas_registers(codec, drvdata); sti_sas_codec_probe()
549 struct sti_sas_data *drvdata; sti_sas_driver_probe() local
553 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data), sti_sas_driver_probe()
555 if (!drvdata) sti_sas_driver_probe()
565 drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data; sti_sas_driver_probe()
568 drvdata->dev = &pdev->dev; sti_sas_driver_probe()
571 drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata, sti_sas_driver_probe()
572 drvdata->dev_data->regmap); sti_sas_driver_probe()
573 if (IS_ERR(drvdata->dac.virt_regmap)) { sti_sas_driver_probe()
575 return PTR_ERR(drvdata->dac.virt_regmap); sti_sas_driver_probe()
579 drvdata->dac.regmap = sti_sas_driver_probe()
581 if (IS_ERR(drvdata->dac.regmap)) { sti_sas_driver_probe()
583 return PTR_ERR(drvdata->dac.regmap); sti_sas_driver_probe()
585 drvdata->spdif.regmap = drvdata->dac.regmap; sti_sas_driver_probe()
588 if (drvdata->dev_data->chipid == CHIPID_STIH416) sti_sas_driver_probe()
591 sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops; sti_sas_driver_probe()
594 sti_sas_driver.dapm_widgets = drvdata->dev_data->dapm_widgets; sti_sas_driver_probe()
595 sti_sas_driver.num_dapm_widgets = drvdata->dev_data->num_dapm_widgets; sti_sas_driver_probe()
597 sti_sas_driver.dapm_routes = drvdata->dev_data->dapm_routes; sti_sas_driver_probe()
598 sti_sas_driver.num_dapm_routes = drvdata->dev_data->num_dapm_routes; sti_sas_driver_probe()
601 dev_set_drvdata(&pdev->dev, drvdata); sti_sas_driver_probe()
|
| H A D | ab8500-codec.c | 1091 struct ab8500_codec_drvdata *drvdata = dev_get_drvdata(codec->dev); anc_configure() local
1107 drvdata->anc_fir_values[par]); anc_configure()
1115 drvdata->anc_iir_values[par]); anc_configure()
1130 struct ab8500_codec_drvdata *drvdata = dev_get_drvdata(codec->dev); sid_status_control_get() local
1132 mutex_lock(&drvdata->ctrl_lock); sid_status_control_get()
1133 ucontrol->value.integer.value[0] = drvdata->sid_status; sid_status_control_get()
1134 mutex_unlock(&drvdata->ctrl_lock); sid_status_control_get()
1144 struct ab8500_codec_drvdata *drvdata = dev_get_drvdata(codec->dev); sid_status_control_put() local
1157 mutex_lock(&drvdata->ctrl_lock); sid_status_control_put()
1174 val = snd_soc_read(codec, drvdata->sid_fir_values[param]); sid_status_control_put()
1185 drvdata->sid_status = SID_FIR_CONFIGURED; sid_status_control_put()
1188 mutex_unlock(&drvdata->ctrl_lock); sid_status_control_put()
1199 struct ab8500_codec_drvdata *drvdata = dev_get_drvdata(codec->dev); anc_status_control_get() local
1201 mutex_lock(&drvdata->ctrl_lock); anc_status_control_get()
1202 ucontrol->value.integer.value[0] = drvdata->anc_status; anc_status_control_get()
1203 mutex_unlock(&drvdata->ctrl_lock); anc_status_control_get()
1213 struct ab8500_codec_drvdata *drvdata = dev_get_drvdata(codec->dev); anc_status_control_put() local
1221 mutex_lock(&drvdata->ctrl_lock); anc_status_control_put()
1250 if (drvdata->anc_status == ANC_IIR_CONFIGURED) anc_status_control_put()
1251 drvdata->anc_status = ANC_FIR_IIR_CONFIGURED; anc_status_control_put()
1252 else if (drvdata->anc_status != ANC_FIR_IIR_CONFIGURED) anc_status_control_put()
1253 drvdata->anc_status = ANC_FIR_CONFIGURED; anc_status_control_put()
1256 if (drvdata->anc_status == ANC_FIR_CONFIGURED) anc_status_control_put()
1257 drvdata->anc_status = ANC_FIR_IIR_CONFIGURED; anc_status_control_put()
1258 else if (drvdata->anc_status != ANC_FIR_IIR_CONFIGURED) anc_status_control_put()
1259 drvdata->anc_status = ANC_IIR_CONFIGURED; anc_status_control_put()
1266 mutex_unlock(&drvdata->ctrl_lock); anc_status_control_put()
1295 struct ab8500_codec_drvdata *drvdata = snd_soc_codec_get_drvdata(codec); filter_control_get() local
1300 mutex_lock(&drvdata->ctrl_lock); filter_control_get()
1303 mutex_unlock(&drvdata->ctrl_lock); filter_control_get()
1312 struct ab8500_codec_drvdata *drvdata = snd_soc_codec_get_drvdata(codec); filter_control_put() local
1317 mutex_lock(&drvdata->ctrl_lock); filter_control_put()
1320 mutex_unlock(&drvdata->ctrl_lock); filter_control_put()
2467 struct ab8500_codec_drvdata *drvdata = dev_get_drvdata(dev); ab8500_codec_probe() local
2537 drvdata->anc_fir_values = (long *)fc->value; ab8500_codec_probe()
2540 drvdata->anc_iir_values = (long *)fc->value; ab8500_codec_probe()
2543 drvdata->sid_fir_values = (long *)fc->value; ab8500_codec_probe()
2547 mutex_init(&drvdata->ctrl_lock); ab8500_codec_probe()
2565 struct ab8500_codec_drvdata *drvdata; ab8500_codec_driver_probe() local
2570 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct ab8500_codec_drvdata), ab8500_codec_driver_probe()
2572 if (!drvdata) ab8500_codec_driver_probe()
2574 drvdata->sid_status = SID_UNCONFIGURED; ab8500_codec_driver_probe()
2575 drvdata->anc_status = ANC_UNCONFIGURED; ab8500_codec_driver_probe()
2576 dev_set_drvdata(&pdev->dev, drvdata); ab8500_codec_driver_probe()
2578 drvdata->regmap = devm_regmap_init(&pdev->dev, NULL, &pdev->dev, ab8500_codec_driver_probe()
2580 if (IS_ERR(drvdata->regmap)) { ab8500_codec_driver_probe()
2581 status = PTR_ERR(drvdata->regmap); ab8500_codec_driver_probe()
|
| H A D | ak4642.c | 148 const struct ak4642_drvdata *drvdata; member in struct:ak4642_priv
382 if (extended_freq && !priv->drvdata->extended_frequencies) ak4642_dai_set_sysclk()
632 const struct ak4642_drvdata *drvdata = NULL; ak4642_i2c_probe() local
646 drvdata = of_id->data; ak4642_i2c_probe()
648 drvdata = (const struct ak4642_drvdata *)id->driver_data; ak4642_i2c_probe()
651 if (!drvdata) { ak4642_i2c_probe()
660 priv->drvdata = drvdata; ak4642_i2c_probe()
665 regmap = devm_regmap_init_i2c(i2c, drvdata->regmap_config); ak4642_i2c_probe()
|
| H A D | cs42xx8.c | 41 const struct cs42xx8_driver_data *drvdata; member in struct:cs42xx8_priv
385 switch (cs42xx8->drvdata->num_adcs) { cs42xx8_codec_probe()
457 cs42xx8->drvdata = of_id->data; cs42xx8_probe()
459 if (!cs42xx8->drvdata) { cs42xx8_probe()
520 cs42xx8_dai.name = cs42xx8->drvdata->name; cs42xx8_probe()
523 cs42xx8_dai.capture.channels_max = cs42xx8->drvdata->num_adcs * 2; cs42xx8_probe()
|
| /linux-4.4.14/drivers/hid/ |
| H A D | hid-corsair.c | 394 struct corsair_drvdata *drvdata = hid_get_drvdata(dev); k90_init_backlight() local
398 drvdata->backlight = kzalloc(sizeof(struct k90_led), GFP_KERNEL); k90_init_backlight()
399 if (!drvdata->backlight) { k90_init_backlight()
413 drvdata->backlight->removed = false; k90_init_backlight()
414 drvdata->backlight->cdev.name = name; k90_init_backlight()
415 drvdata->backlight->cdev.max_brightness = 3; k90_init_backlight()
416 drvdata->backlight->cdev.brightness_set = k90_brightness_set; k90_init_backlight()
417 drvdata->backlight->cdev.brightness_get = k90_backlight_get; k90_init_backlight()
418 INIT_WORK(&drvdata->backlight->work, k90_backlight_work); k90_init_backlight()
419 ret = led_classdev_register(&dev->dev, &drvdata->backlight->cdev); k90_init_backlight()
426 kfree(drvdata->backlight->cdev.name); k90_init_backlight()
428 kfree(drvdata->backlight); k90_init_backlight()
429 drvdata->backlight = NULL; k90_init_backlight()
437 struct corsair_drvdata *drvdata = hid_get_drvdata(dev); k90_init_macro_functions() local
447 drvdata->k90 = k90; k90_init_macro_functions()
485 drvdata->k90 = NULL; k90_init_macro_functions()
491 struct corsair_drvdata *drvdata = hid_get_drvdata(dev); k90_cleanup_backlight() local
493 if (drvdata->backlight) { k90_cleanup_backlight()
494 drvdata->backlight->removed = true; k90_cleanup_backlight()
495 led_classdev_unregister(&drvdata->backlight->cdev); k90_cleanup_backlight()
496 cancel_work_sync(&drvdata->backlight->work); k90_cleanup_backlight()
497 kfree(drvdata->backlight->cdev.name); k90_cleanup_backlight()
498 kfree(drvdata->backlight); k90_cleanup_backlight()
504 struct corsair_drvdata *drvdata = hid_get_drvdata(dev); k90_cleanup_macro_functions() local
505 struct k90_drvdata *k90 = drvdata->k90; k90_cleanup_macro_functions()
523 struct corsair_drvdata *drvdata; corsair_probe() local
526 drvdata = devm_kzalloc(&dev->dev, sizeof(struct corsair_drvdata), corsair_probe()
528 if (drvdata == NULL) corsair_probe()
530 drvdata->quirks = quirks; corsair_probe()
531 hid_set_drvdata(dev, drvdata); corsair_probe()
571 struct corsair_drvdata *drvdata = hid_get_drvdata(dev); corsair_event() local
573 if (!drvdata->k90) corsair_event()
578 drvdata->k90->record_led.brightness = 1; corsair_event()
581 drvdata->k90->record_led.brightness = 0; corsair_event()
|
| H A D | hid-uclogic.c | 638 struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev); uclogic_report_fixup() local
710 if (drvdata->rdesc != NULL) { uclogic_report_fixup()
711 rdesc = drvdata->rdesc; uclogic_report_fixup()
712 *rsize = drvdata->rsize; uclogic_report_fixup()
723 struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev); uclogic_input_mapping() local
726 if ((drvdata->ignore_pen_usage) && uclogic_input_mapping()
790 struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev); uclogic_tablet_enable() local
847 drvdata->rdesc = devm_kzalloc(&hdev->dev, uclogic_tablet_enable()
850 if (drvdata->rdesc == NULL) { uclogic_tablet_enable()
855 drvdata->rsize = sizeof(uclogic_tablet_rdesc_template); uclogic_tablet_enable()
858 memcpy(drvdata->rdesc, uclogic_tablet_rdesc_template, uclogic_tablet_enable()
859 drvdata->rsize); uclogic_tablet_enable()
860 for (p = drvdata->rdesc; uclogic_tablet_enable()
861 p <= drvdata->rdesc + drvdata->rsize - 4;) { uclogic_tablet_enable()
884 struct uclogic_drvdata *drvdata; uclogic_probe() local
894 drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL); uclogic_probe()
895 if (drvdata == NULL) uclogic_probe()
898 hid_set_drvdata(hdev, drvdata); uclogic_probe()
909 drvdata->invert_pen_inrange = true; uclogic_probe()
911 drvdata->ignore_pen_usage = true; uclogic_probe()
934 struct uclogic_drvdata *drvdata = hid_get_drvdata(hdev); uclogic_raw_event() local
936 if ((drvdata->invert_pen_inrange) && uclogic_raw_event()
|
| H A D | hid-lenovo.c | 658 * set drvdata to 1, i.e. the trackpoint. lenovo_probe_tpkbd()
815 * Only the trackpoint half of the keyboard has drvdata and stuff that lenovo_remove_tpkbd()
|
| /linux-4.4.14/drivers/mtd/nand/ |
| H A D | txx9ndfmc.c | 89 struct txx9ndfmc_drvdata *drvdata = platform_get_drvdata(dev); ndregaddr() local
92 return drvdata->base + (reg << plat->shift); ndregaddr()
229 struct txx9ndfmc_drvdata *drvdata = platform_get_drvdata(dev); txx9ndfmc_initialize() local
249 txx9ndfmc_write(dev, (drvdata->hold << 4) | drvdata->spw, TXX9_NDFSPR); txx9ndfmc_initialize()
280 struct txx9ndfmc_drvdata *drvdata; txx9ndfmc_probe() local
284 drvdata = devm_kzalloc(&dev->dev, sizeof(*drvdata), GFP_KERNEL); txx9ndfmc_probe()
285 if (!drvdata) txx9ndfmc_probe()
288 drvdata->base = devm_ioremap_resource(&dev->dev, res); txx9ndfmc_probe()
289 if (IS_ERR(drvdata->base)) txx9ndfmc_probe()
290 return PTR_ERR(drvdata->base); txx9ndfmc_probe()
301 drvdata->hold = hold; txx9ndfmc_probe()
303 drvdata->spw = spw; txx9ndfmc_probe()
307 spin_lock_init(&drvdata->hw_control.lock); txx9ndfmc_probe()
308 init_waitqueue_head(&drvdata->hw_control.wq); txx9ndfmc_probe()
310 platform_set_drvdata(dev, drvdata); txx9ndfmc_probe()
344 chip->controller = &drvdata->hw_control; txx9ndfmc_probe()
374 drvdata->mtds[i] = mtd; txx9ndfmc_probe()
382 struct txx9ndfmc_drvdata *drvdata = platform_get_drvdata(dev); txx9ndfmc_remove() local
385 if (!drvdata) txx9ndfmc_remove()
388 struct mtd_info *mtd = drvdata->mtds[i]; txx9ndfmc_remove()
|
| /linux-4.4.14/drivers/media/platform/exynos4-is/ |
| H A D | fimc-is-sensor.h | 43 * @drvdata: a pointer to the sensor's parameters data structure
48 const struct sensor_drv_data *drvdata; member in struct:fimc_is_sensor
|
| H A D | media-dev.c | 583 void *drvdata; fimc_md_register_platform_entity() local
591 drvdata = dev_get_drvdata(dev); fimc_md_register_platform_entity()
592 /* Some subdev didn't probe successfully id drvdata is NULL */ fimc_md_register_platform_entity()
593 if (drvdata) { fimc_md_register_platform_entity()
596 ret = register_fimc_entity(fmd, drvdata); fimc_md_register_platform_entity()
599 ret = register_fimc_lite_entity(fmd, drvdata); fimc_md_register_platform_entity()
602 ret = register_csis_entity(fmd, pdev, drvdata); fimc_md_register_platform_entity()
605 ret = register_fimc_is_entity(fmd, drvdata); fimc_md_register_platform_entity()
|
| H A D | fimc-is.c | 171 sensor->drvdata = fimc_is_sensor_get_drvdata(node); fimc_is_parse_sensor_config()
172 if (!sensor->drvdata) { fimc_is_parse_sensor_config()
636 mcuctl_write(sensor->drvdata->id, is, MCUCTL_REG_ISSR(2)); fimc_is_hw_open_sensor()
643 sensor->drvdata->open_timeout); fimc_is_hw_open_sensor()
|
| H A D | fimc-is-param.c | 258 switch (is->sensor->drvdata->id) { fimc_is_hw_get_sensor_max_framerate()
|
| /linux-4.4.14/include/linux/ |
| H A D | hwmon.h | 23 void *drvdata,
27 void *drvdata,
|
| H A D | cpu.h | 44 struct device *cpu_device_create(struct device *parent, void *drvdata,
|
| H A D | iommu.h | 260 struct device *iommu_device_create(struct device *parent, void *drvdata,
515 void *drvdata, iommu_device_create()
514 iommu_device_create(struct device *parent, void *drvdata, const struct attribute_group **groups, const char *fmt, ...) iommu_device_create() argument
|
| H A D | tty.h | 437 void *drvdata,
537 struct device *device, void *drvdata,
|
| H A D | device.h | 1051 dev_t devt, void *drvdata,
1055 dev_t devt, void *drvdata,
1059 struct device *parent, dev_t devt, void *drvdata,
|
| /linux-4.4.14/drivers/phy/ |
| H A D | phy-exynos-dp-video.c | 30 const struct exynos_dp_video_phy_drvdata *drvdata; member in struct:exynos_dp_video_phy
38 return regmap_update_bits(state->regs, state->drvdata->phy_ctrl_offset, exynos_dp_video_phy_power_on()
47 return regmap_update_bits(state->regs, state->drvdata->phy_ctrl_offset, exynos_dp_video_phy_power_off()
97 state->drvdata = match->data; exynos_dp_video_phy_probe()
|
| /linux-4.4.14/arch/arm/mach-s3c64xx/ |
| H A D | dev-backlight.c | 32 struct samsung_bl_drvdata *drvdata = container_of(pdata, samsung_bl_init() local
34 struct samsung_bl_gpio_info *bl_gpio_info = drvdata->gpio_info; samsung_bl_init()
51 struct samsung_bl_drvdata *drvdata = container_of(pdata, samsung_bl_exit() local
53 struct samsung_bl_gpio_info *bl_gpio_info = drvdata->gpio_info; samsung_bl_exit()
|
| /linux-4.4.14/drivers/net/can/c_can/ |
| H A D | c_can_platform.c | 260 const struct c_can_driver_data *drvdata; c_can_plat_probe() local
265 drvdata = match->data; c_can_plat_probe()
267 drvdata = (struct c_can_driver_data *) c_can_plat_probe()
302 switch (drvdata->id) { c_can_plat_probe()
360 if (id >= drvdata->raminit_num) { c_can_plat_probe()
366 raminit->bits = drvdata->raminit_bits[id]; c_can_plat_probe()
367 raminit->needs_pulse = drvdata->raminit_pulse; c_can_plat_probe()
384 priv->type = drvdata->id; c_can_plat_probe()
|
| /linux-4.4.14/drivers/hwmon/ |
| H A D | hwmon.c | 87 * @drvdata: driver data to attach to created device
97 void *drvdata, hwmon_device_register_with_groups()
122 dev_set_drvdata(&hwdev->dev, drvdata); hwmon_device_register_with_groups()
182 * @drvdata: driver data to attach to created device
190 void *drvdata, devm_hwmon_device_register_with_groups()
202 hwdev = hwmon_device_register_with_groups(dev, name, drvdata, groups); devm_hwmon_device_register_with_groups()
96 hwmon_device_register_with_groups(struct device *dev, const char *name, void *drvdata, const struct attribute_group **groups) hwmon_device_register_with_groups() argument
189 devm_hwmon_device_register_with_groups(struct device *dev, const char *name, void *drvdata, const struct attribute_group **groups) devm_hwmon_device_register_with_groups() argument
|
| H A D | max1111.c | 58 /* writing to drvdata struct is not thread safe, wait on mutex */ max1111_read()
|
| /linux-4.4.14/sound/soc/samsung/ |
| H A D | bells.c | 63 struct bells_drvdata *bells = card->drvdata; bells_set_bias_level()
104 struct bells_drvdata *bells = card->drvdata; bells_set_bias_level_post()
139 struct bells_drvdata *bells = card->drvdata; bells_late_probe()
385 .drvdata = &wm2200_drvdata,
405 .drvdata = &wm5102_drvdata,
425 .drvdata = &wm5110_drvdata,
|
| H A D | i2s.c | 1241 dev_err(&pdev->dev, "Unable to get drvdata\n"); samsung_i2s_probe()
|
| /linux-4.4.14/drivers/net/ethernet/xilinx/ |
| H A D | xilinx_emaclite.c | 151 * @drvdata: Pointer to the Emaclite device private data
156 static void xemaclite_enable_interrupts(struct net_local *drvdata) xemaclite_enable_interrupts() argument
161 reg_data = __raw_readl(drvdata->base_addr + XEL_TSR_OFFSET); xemaclite_enable_interrupts()
163 drvdata->base_addr + XEL_TSR_OFFSET); xemaclite_enable_interrupts()
166 __raw_writel(XEL_RSR_RECV_IE_MASK, drvdata->base_addr + XEL_RSR_OFFSET); xemaclite_enable_interrupts()
169 __raw_writel(XEL_GIER_GIE_MASK, drvdata->base_addr + XEL_GIER_OFFSET); xemaclite_enable_interrupts()
174 * @drvdata: Pointer to the Emaclite device private data
179 static void xemaclite_disable_interrupts(struct net_local *drvdata) xemaclite_disable_interrupts() argument
184 __raw_writel(XEL_GIER_GIE_MASK, drvdata->base_addr + XEL_GIER_OFFSET); xemaclite_disable_interrupts()
187 reg_data = __raw_readl(drvdata->base_addr + XEL_TSR_OFFSET); xemaclite_disable_interrupts()
189 drvdata->base_addr + XEL_TSR_OFFSET); xemaclite_disable_interrupts()
192 reg_data = __raw_readl(drvdata->base_addr + XEL_RSR_OFFSET); xemaclite_disable_interrupts()
194 drvdata->base_addr + XEL_RSR_OFFSET); xemaclite_disable_interrupts()
299 * @drvdata: Pointer to the Emaclite device private data
312 static int xemaclite_send_data(struct net_local *drvdata, u8 *data, xemaclite_send_data() argument
319 addr = drvdata->base_addr + drvdata->next_tx_buf_to_use; xemaclite_send_data()
331 if (drvdata->tx_ping_pong != 0) xemaclite_send_data()
332 drvdata->next_tx_buf_to_use ^= XEL_BUFFER_OFFSET; xemaclite_send_data()
333 } else if (drvdata->tx_ping_pong != 0) { xemaclite_send_data()
366 * @drvdata: Pointer to the Emaclite device private data
374 static u16 xemaclite_recv_data(struct net_local *drvdata, u8 *data) xemaclite_recv_data() argument
381 addr = (drvdata->base_addr + drvdata->next_rx_buf_to_use); xemaclite_recv_data()
387 if (drvdata->rx_ping_pong != 0) xemaclite_recv_data()
388 drvdata->next_rx_buf_to_use ^= XEL_BUFFER_OFFSET; xemaclite_recv_data()
394 if (drvdata->rx_ping_pong != 0) xemaclite_recv_data()
448 * @drvdata: Pointer to the Emaclite device private data
457 static void xemaclite_update_address(struct net_local *drvdata, xemaclite_update_address() argument
464 addr = drvdata->base_addr + drvdata->next_tx_buf_to_use; xemaclite_update_address()
|
| /linux-4.4.14/drivers/pci/host/ |
| H A D | pci-layerscape.c | 52 const struct ls_pcie_drvdata *drvdata; member in struct:ls_pcie
134 pcie->drvdata->ltssm_shift) & ls_pcie_link_up()
218 pp->ops = pcie->drvdata->ops; ls_add_pcie_port()
251 pcie->drvdata = match->data; ls_pcie_probe()
252 pcie->lut = pcie->dbi + pcie->drvdata->lut_offset; ls_pcie_probe()
|
| /linux-4.4.14/drivers/media/pci/mantis/ |
| H A D | hopper_cards.c | 161 struct mantis_pci_drvdata *drvdata; hopper_pci_probe() local
173 drvdata = (void *)pci_id->driver_data; hopper_pci_probe()
177 config = drvdata->hwconfig; hopper_pci_probe()
180 mantis->rc_map_name = drvdata->rc_map_name; hopper_pci_probe()
|
| H A D | mantis_cards.c | 171 struct mantis_pci_drvdata *drvdata; mantis_pci_probe() local
182 drvdata = (void *)pci_id->driver_data; mantis_pci_probe()
186 config = drvdata->hwconfig; mantis_pci_probe()
189 mantis->rc_map_name = drvdata->rc_map_name; mantis_pci_probe()
|
| /linux-4.4.14/drivers/nvdimm/ |
| H A D | nd.h | 196 int nd_btt_probe(struct nd_namespace_common *ndns, void *drvdata);
200 static inline int nd_btt_probe(struct nd_namespace_common *ndns, void *drvdata) nd_btt_probe() argument
218 int nd_pfn_probe(struct nd_namespace_common *ndns, void *drvdata);
223 static inline int nd_pfn_probe(struct nd_namespace_common *ndns, void *drvdata) nd_pfn_probe() argument
|
| H A D | btt_devs.c | 276 int nd_btt_probe(struct nd_namespace_common *ndns, void *drvdata) nd_btt_probe() argument
291 dev_set_drvdata(dev, drvdata); nd_btt_probe()
|
| H A D | pfn_devs.c | 304 int nd_pfn_probe(struct nd_namespace_common *ndns, void *drvdata) nd_pfn_probe() argument
320 dev_set_drvdata(dev, drvdata); nd_pfn_probe()
|
| /linux-4.4.14/drivers/base/ |
| H A D | cpu.c | 397 __cpu_device_create(struct device *parent, void *drvdata, __cpu_device_create() argument
414 dev_set_drvdata(dev, drvdata); __cpu_device_create()
431 struct device *cpu_device_create(struct device *parent, void *drvdata, cpu_device_create() argument
439 dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs); cpu_device_create()
|
| H A D | core.c | 1681 dev_t devt, void *drvdata, device_create_groups_vargs()
1703 dev_set_drvdata(dev, drvdata); device_create_groups_vargs()
1725 * @drvdata: the data to be added to the device for callbacks
1746 dev_t devt, void *drvdata, const char *fmt, device_create_vargs()
1749 return device_create_groups_vargs(class, parent, devt, drvdata, NULL, device_create_vargs()
1759 * @drvdata: the data to be added to the device for callbacks
1779 dev_t devt, void *drvdata, const char *fmt, ...) device_create()
1785 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); device_create()
1796 * @drvdata: the data to be added to the device for callbacks
1820 void *drvdata, device_create_with_groups()
1828 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, device_create_with_groups()
1680 device_create_groups_vargs(struct class *class, struct device *parent, dev_t devt, void *drvdata, const struct attribute_group **groups, const char *fmt, va_list args) device_create_groups_vargs() argument
1745 device_create_vargs(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, va_list args) device_create_vargs() argument
1778 device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...) device_create() argument
1818 device_create_with_groups(struct class *class, struct device *parent, dev_t devt, void *drvdata, const struct attribute_group **groups, const char *fmt, ...) device_create_with_groups() argument
|
| /linux-4.4.14/include/linux/bcma/ |
| H A D | bcma.h | 278 void *drvdata; member in struct:bcma_device
284 return core->drvdata; bcma_get_drvdata()
286 static inline void bcma_set_drvdata(struct bcma_device *core, void *drvdata) bcma_set_drvdata() argument
288 core->drvdata = drvdata; bcma_set_drvdata()
|
| /linux-4.4.14/drivers/pinctrl/ |
| H A D | pinctrl-rockchip.c | 101 * @drvdata: common pinctrl basedata
120 struct rockchip_pinctrl *drvdata; member in struct:rockchip_pin_bank
387 struct rockchip_pinctrl *info = bank->drvdata; rockchip_get_mux()
441 struct rockchip_pinctrl *info = bank->drvdata; rockchip_set_mux()
504 struct rockchip_pinctrl *info = bank->drvdata; rk2928_calc_pull_reg_and_bit()
524 struct rockchip_pinctrl *info = bank->drvdata; rk3188_calc_pull_reg_and_bit()
559 struct rockchip_pinctrl *info = bank->drvdata; rk3288_calc_pull_reg_and_bit()
593 struct rockchip_pinctrl *info = bank->drvdata; rk3288_calc_drv_reg_and_bit()
624 struct rockchip_pinctrl *info = bank->drvdata; rk3368_calc_pull_reg_and_bit()
655 struct rockchip_pinctrl *info = bank->drvdata; rk3368_calc_drv_reg_and_bit()
684 struct rockchip_pinctrl *info = bank->drvdata; rockchip_get_drive_perpin()
706 struct rockchip_pinctrl *info = bank->drvdata; rockchip_set_drive_perpin()
745 struct rockchip_pinctrl *info = bank->drvdata; rockchip_get_pull()
795 struct rockchip_pinctrl *info = bank->drvdata; rockchip_set_pull()
1474 dev_dbg(bank->drvdata->dev, "got irq for bank %s\n", bank->name); rockchip_irq_demux()
1488 dev_err(bank->drvdata->dev, "unmapped irq %d\n", irq); rockchip_irq_demux()
1492 dev_dbg(bank->drvdata->dev, "handling irq %d\n", irq); rockchip_irq_demux()
1892 bank->drvdata = d;
|
| /linux-4.4.14/drivers/dma/ |
| H A D | imx-sdma.c | 385 const struct sdma_driver_data *drvdata; member in struct:sdma_engine
523 u32 chnenbl0 = sdma->drvdata->chnenbl0; chnenbl_ofs()
967 if (sdmac->event_id0 >= sdmac->sdma->drvdata->num_events) sdma_config_channel()
973 if (sdmac->event_id1 >= sdmac->sdma->drvdata->num_events) sdma_config_channel()
1576 for (i = 0; i < sdma->drvdata->num_events; i++) sdma_init()
1668 const struct sdma_driver_data *drvdata = NULL; sdma_probe() local
1671 drvdata = of_id->data; sdma_probe()
1673 drvdata = (void *)pdev->id_entry->driver_data; sdma_probe()
1675 if (!drvdata) { sdma_probe()
1691 sdma->drvdata = drvdata; sdma_probe()
1762 if (sdma->drvdata->script_addrs) sdma_probe()
1763 sdma_add_scripts(sdma, sdma->drvdata->script_addrs); sdma_probe()
|
| /linux-4.4.14/drivers/tty/ |
| H A D | tty_port.c | 81 * @drvdata: Driver data to be set to device.
90 struct device *device, void *drvdata, tty_port_register_device_attr()
94 return tty_register_device_attr(driver, index, device, drvdata, tty_port_register_device_attr()
88 tty_port_register_device_attr(struct tty_port *port, struct tty_driver *driver, unsigned index, struct device *device, void *drvdata, const struct attribute_group **attr_grp) tty_port_register_device_attr() argument
|
| H A D | tty_io.c | 3265 * @drvdata: Driver data to be set to device.
3280 void *drvdata, tty_register_device_attr()
3319 dev_set_drvdata(dev, drvdata); tty_register_device_attr()
3278 tty_register_device_attr(struct tty_driver *driver, unsigned index, struct device *device, void *drvdata, const struct attribute_group **attr_grp) tty_register_device_attr() argument
|
| /linux-4.4.14/drivers/media/platform/s3c-camif/ |
| H A D | camif-core.c | 415 struct s3c_camif_drvdata *drvdata; s3c_camif_probe() local
435 drvdata = (void *)platform_get_device_id(pdev)->driver_data; s3c_camif_probe()
436 camif->variant = drvdata->variant; s3c_camif_probe()
|
| /linux-4.4.14/drivers/media/platform/soc_camera/ |
| H A D | soc_camera_platform.c | 162 /* soc-camera convention: control's drvdata points to the subdev */ soc_camera_platform_probe()
|
| H A D | mx2_camera.c | 1577 * We're done with drvdata here. Clear the pointer so that mx2_camera_probe()
1578 * v4l2 core can start using drvdata on its purpose. mx2_camera_probe()
|
| /linux-4.4.14/drivers/power/ |
| H A D | axp20x_usb_power.c | 180 dev_err(&pdev->dev, "Parent drvdata not set\n"); axp20x_usb_power_probe()
|
| /linux-4.4.14/include/linux/ssb/ |
| H A D | ssb.h | 260 /* Some kernel subsystems poke with dev->drvdata, so we must use the
281 void *drvdata; /* Per-device data */ member in struct:ssb_device
298 dev->drvdata = data; ssb_set_drvdata()
303 return dev->drvdata; ssb_get_drvdata()
|
| /linux-4.4.14/sound/pci/asihpi/ |
| H A D | hpios.h | 149 /** pci drvdata points to an instance of this struct */
|
| /linux-4.4.14/sound/soc/atmel/ |
| H A D | sam9x5_wm8731.c | 178 struct sam9x5_drvdata *priv = card->drvdata; sam9x5_wm8731_driver_remove()
|
| /linux-4.4.14/drivers/input/keyboard/ |
| H A D | gpio_keys.c | 156 * @ddata: pointer to drvdata
204 * @ddata: pointer to drvdata
|
| /linux-4.4.14/drivers/isdn/hardware/mISDN/ |
| H A D | speedfax.c | 491 pr_debug("%s: drvdata already removed\n", __func__); sfax_remove_pci()
|
| H A D | avmfritz.c | 1142 pr_info("%s: drvdata already removed\n", __func__); fritz_remove_pci()
|
| H A D | mISDNinfineon.c | 1146 pr_debug("%s: drvdata already removed\n", __func__); inf_remove()
|
| H A D | netjet.c | 1134 pr_info("%s drvdata already removed\n", __func__); nj_remove()
|
| H A D | w6692.c | 1399 pr_notice("%s: drvdata already removed\n", __func__); w6692_remove_pci()
|
| H A D | hfcpci.c | 2258 printk(KERN_DEBUG "%s: drvdata already removed\n", hfc_remove_pci()
|
| H A D | hfcmulti.c | 5294 printk(KERN_DEBUG "%s: drvdata already removed\n", hfc_remove_pci()
|
| /linux-4.4.14/drivers/media/common/saa7146/ |
| H A D | saa7146_core.c | 474 /* V4L extensions will set the pci drvdata to the v4l2_device in the saa7146_init_one()
|
| /linux-4.4.14/drivers/media/platform/marvell-ccic/ |
| H A D | mmp-driver.c | 78 * no handy unused drvdata to stash a backpointer in. So just
|
| /linux-4.4.14/drivers/ata/ |
| H A D | pata_icside.c | 587 * don't NULL out the drvdata - devres/libata wants it pata_icside_remove()
|
| /linux-4.4.14/drivers/gpio/ |
| H A D | gpio-brcmstb.c | 296 dev_err(&pdev->dev, "called %s without drvdata!\n", __func__); brcmstb_gpio_remove()
|
| /linux-4.4.14/drivers/net/ethernet/ibm/emac/ |
| H A D | core.c | 2261 void *drvdata; member in struct:emac_depentry
2303 if (deps[i].drvdata == NULL) emac_check_deps()
2304 deps[i].drvdata = platform_get_drvdata(deps[i].ofdev); emac_check_deps()
2305 if (deps[i].drvdata != NULL) emac_check_deps()
2873 /* Set our drvdata last as we don't want them visible until we are emac_probe()
|
| /linux-4.4.14/include/sound/ |
| H A D | soc.h | 1166 void *drvdata; member in struct:snd_soc_card
1468 card->drvdata = data; snd_soc_card_set_drvdata()
1473 return card->drvdata; snd_soc_card_get_drvdata()
|
| /linux-4.4.14/drivers/usb/core/ |
| H A D | hcd-pci.c | 69 * If the function's drvdata isn't set then it isn't bound to for_each_companion()
|
| /linux-4.4.14/drivers/media/platform/s5p-tv/ |
| H A D | hdmi_drv.c | 947 /* passing NULL owner prevents driver from erasing drvdata */ hdmi_probe()
|
| /linux-4.4.14/drivers/vfio/ |
| H A D | vfio.c | 685 * release call path, so we can't trust drvdata for the shortcut.
|
| /linux-4.4.14/drivers/usb/host/ |
| H A D | r8a66597-hcd.c | 430 * Only when resetting USB, it is necessary to erase drvdata. When free_usb_address()
|