hwtracing/coresight/coresight-stm.c

87 #define stm_channel_addr(drvdata, ch)	(drvdata->chs.base +	\
151 static void stm_hwevent_enable_hw(struct stm_drvdata *drvdata)
153 	CS_UNLOCK(drvdata->base);
155 	writel_relaxed(drvdata->stmhebsr, drvdata->base + STMHEBSR);
156 	writel_relaxed(drvdata->stmheter, drvdata->base + STMHETER);
157 	writel_relaxed(drvdata->stmheer, drvdata->base + STMHEER);
160 		       drvdata->base + STMHEMCR);
162 	CS_LOCK(drvdata->base);
165 static void stm_port_enable_hw(struct stm_drvdata *drvdata)
167 	CS_UNLOCK(drvdata->base);
170 		       drvdata->base + STMSPTRIGCSR);
171 	writel_relaxed(drvdata->stmspscr, drvdata->base + STMSPSCR);
172 	writel_relaxed(drvdata->stmsper, drvdata->base + STMSPER);
174 	CS_LOCK(drvdata->base);
177 static void stm_enable_hw(struct stm_drvdata *drvdata)
179 	if (drvdata->stmheer)
180 		stm_hwevent_enable_hw(drvdata);
182 	stm_port_enable_hw(drvdata);
184 	CS_UNLOCK(drvdata->base);
187 	writel_relaxed(0xFFF, drvdata->base + STMSYNCR);
188 	writel_relaxed((drvdata->traceid << 16 | /* trace id */
191 			drvdata->base + STMTCSR);
193 	CS_LOCK(drvdata->base);
200 	struct stm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
212 	spin_lock(&drvdata->spinlock);
213 	stm_enable_hw(drvdata);
214 	spin_unlock(&drvdata->spinlock);
220 static void stm_hwevent_disable_hw(struct stm_drvdata *drvdata)
222 	CS_UNLOCK(drvdata->base);
224 	writel_relaxed(0x0, drvdata->base + STMHEMCR);
225 	writel_relaxed(0x0, drvdata->base + STMHEER);
226 	writel_relaxed(0x0, drvdata->base + STMHETER);
228 	CS_LOCK(drvdata->base);
231 static void stm_port_disable_hw(struct stm_drvdata *drvdata)
233 	CS_UNLOCK(drvdata->base);
235 	writel_relaxed(0x0, drvdata->base + STMSPER);
236 	writel_relaxed(0x0, drvdata->base + STMSPTRIGCSR);
238 	CS_LOCK(drvdata->base);
241 static void stm_disable_hw(struct stm_drvdata *drvdata)
245 	CS_UNLOCK(drvdata->base);
247 	val = readl_relaxed(drvdata->base + STMTCSR);
249 	writel_relaxed(val, drvdata->base + STMTCSR);
251 	CS_LOCK(drvdata->base);
253 	stm_port_disable_hw(drvdata);
254 	if (drvdata->stmheer)
255 		stm_hwevent_disable_hw(drvdata);
261 	struct stm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
270 		spin_lock(&drvdata->spinlock);
271 		stm_disable_hw(drvdata);
272 		spin_unlock(&drvdata->spinlock);
287 	struct stm_drvdata *drvdata;
289 	drvdata = dev_get_drvdata(csdev->dev.parent);
291 	return drvdata->traceid;
343 	struct stm_drvdata *drvdata = container_of(stm_data,
345 	if (!drvdata || !drvdata->csdev)
348 	return coresight_enable_sysfs(drvdata->csdev);
354 	struct stm_drvdata *drvdata = container_of(stm_data,
356 	if (!drvdata || !drvdata->csdev)
359 	coresight_disable_sysfs(drvdata->csdev);
366 	struct stm_drvdata *drvdata = container_of(stm_data,
370 	addr = drvdata->chs.phys + channel * BYTES_PER_CHANNEL;
385 	struct stm_drvdata *drvdata = container_of(stm_data,
387 	if (!(drvdata && coresight_get_mode(drvdata->csdev)))
390 	if (channel >= drvdata->numsp)
395 		set_bit(channel, drvdata->chs.guaranteed);
399 		clear_bit(channel, drvdata->chs.guaranteed);
418 	struct stm_drvdata *drvdata = container_of(stm_data,
422 	if (!(drvdata && coresight_get_mode(drvdata->csdev)))
425 	if (channel >= drvdata->numsp)
428 	ch_addr = stm_channel_addr(drvdata, channel);
432 	stm_flags |= test_bit(channel, drvdata->chs.guaranteed) ?
435 	if (size > drvdata->write_bytes)
436 		size = drvdata->write_bytes;
449 		stm_send(ch_addr, payload, 1, drvdata->write_bytes);
457 				drvdata->write_bytes);
470 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
471 	unsigned long val = drvdata->stmheer;
480 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
488 	drvdata->stmheer = val;
490 	drvdata->stmheter = val;
499 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
500 	unsigned long val = drvdata->stmhebsr;
509 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
517 	drvdata->stmhebsr = val;
526 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
529 	if (!coresight_get_mode(drvdata->csdev)) {
530 		val = drvdata->stmspscr;
532 		spin_lock(&drvdata->spinlock);
533 		val = readl_relaxed(drvdata->base + STMSPSCR);
534 		spin_unlock(&drvdata->spinlock);
544 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
552 	spin_lock(&drvdata->spinlock);
553 	drvdata->stmspscr = val;
555 	if (coresight_get_mode(drvdata->csdev)) {
556 		CS_UNLOCK(drvdata->base);
558 		stmsper = readl_relaxed(drvdata->base + STMSPER);
559 		writel_relaxed(0x0, drvdata->base + STMSPER);
560 		writel_relaxed(drvdata->stmspscr, drvdata->base + STMSPSCR);
561 		writel_relaxed(stmsper, drvdata->base + STMSPER);
562 		CS_LOCK(drvdata->base);
564 	spin_unlock(&drvdata->spinlock);
573 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
576 	if (!coresight_get_mode(drvdata->csdev)) {
577 		val = drvdata->stmsper;
579 		spin_lock(&drvdata->spinlock);
580 		val = readl_relaxed(drvdata->base + STMSPER);
581 		spin_unlock(&drvdata->spinlock);
591 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
599 	spin_lock(&drvdata->spinlock);
600 	drvdata->stmsper = val;
602 	if (coresight_get_mode(drvdata->csdev)) {
603 		CS_UNLOCK(drvdata->base);
604 		writel_relaxed(drvdata->stmsper, drvdata->base + STMSPER);
605 		CS_LOCK(drvdata->base);
607 	spin_unlock(&drvdata->spinlock);
617 	struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent);
619 	val = drvdata->traceid;
750 static u32 stm_fundamental_data_size(struct stm_drvdata *drvdata)
757 	stmspfeat2r = readl_relaxed(drvdata->base + STMSPFEAT2R);
767 static u32 stm_num_stimulus_port(struct stm_drvdata *drvdata)
771 	numsp = readl_relaxed(drvdata->base + CORESIGHT_DEVID);
782 static void stm_init_default_data(struct stm_drvdata *drvdata)
785 	drvdata->stmspscr = 0x0;
791 	drvdata->stmsper = ~0x0;
794 	bitmap_clear(drvdata->chs.guaranteed, 0, drvdata->numsp);
797 static void stm_init_generic_data(struct stm_drvdata *drvdata,
800 	drvdata->stm.name = name;
806 	drvdata->stm.sw_start = 1;
807 	drvdata->stm.sw_end = 1;
808 	drvdata->stm.hw_override = true;
809 	drvdata->stm.sw_nchannels = drvdata->numsp;
810 	drvdata->stm.sw_mmiosz = BYTES_PER_CHANNEL;
811 	drvdata->stm.packet = stm_generic_packet;
812 	drvdata->stm.mmio_addr = stm_mmio_addr;
813 	drvdata->stm.link = stm_generic_link;
814 	drvdata->stm.unlink = stm_generic_unlink;
815 	drvdata->stm.set_options = stm_generic_set_options;
833 	struct stm_drvdata *drvdata;
841 	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
842 	if (!drvdata)
845 	drvdata->atclk = devm_clk_get(dev, "atclk"); /* optional */
846 	if (!IS_ERR(drvdata->atclk)) {
847 		ret = clk_prepare_enable(drvdata->atclk);
852 	drvdata->pclk = coresight_get_enable_apb_pclk(dev);
853 	if (IS_ERR(drvdata->pclk))
855 	dev_set_drvdata(dev, drvdata);
860 	drvdata->base = base;
866 	drvdata->chs.phys = ch_res.start;
871 	drvdata->chs.base = base;
873 	drvdata->write_bytes = stm_fundamental_data_size(drvdata);
876 		drvdata->numsp = boot_nr_channel;
878 		drvdata->numsp = stm_num_stimulus_port(drvdata);
880 	drvdata->chs.guaranteed = devm_bitmap_zalloc(dev, drvdata->numsp,
882 	if (!drvdata->chs.guaranteed)
885 	spin_lock_init(&drvdata->spinlock);
887 	stm_init_default_data(drvdata);
888 	stm_init_generic_data(drvdata, desc.name);
890 	if (stm_register_device(dev, &drvdata->stm, THIS_MODULE)) {
910 	drvdata->csdev = coresight_register(&desc);
911 	if (IS_ERR(drvdata->csdev)) {
912 		ret = PTR_ERR(drvdata->csdev);
921 	drvdata->traceid = (u8)trace_id;
923 	dev_info(&drvdata->csdev->dev, "%s initialized\n",
924 		 stm_csdev_name(drvdata->csdev));
928 	coresight_unregister(drvdata->csdev);
931 	stm_unregister_device(&drvdata->stm);
948 	struct stm_drvdata *drvdata = dev_get_drvdata(dev);
950 	coresight_trace_id_put_system_id(drvdata->traceid);
951 	coresight_unregister(drvdata->csdev);
953 	stm_unregister_device(&drvdata->stm);
964 	struct stm_drvdata *drvdata = dev_get_drvdata(dev);
966 	if (drvdata && !IS_ERR(drvdata->atclk))
967 		clk_disable_unprepare(drvdata->atclk);
969 	if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk))
970 		clk_disable_unprepare(drvdata->pclk);
976 	struct stm_drvdata *drvdata = dev_get_drvdata(dev);
978 	if (drvdata && !IS_ERR(drvdata->atclk))
979 		clk_prepare_enable(drvdata->atclk);
981 	if (drvdata && !IS_ERR_OR_NULL(drvdata->pclk))
982 		clk_prepare_enable(drvdata->pclk);
1029 	struct stm_drvdata *drvdata = dev_get_drvdata(&pdev->dev);
1031 	if (WARN_ON(!drvdata))
1036 	if (!IS_ERR_OR_NULL(drvdata->pclk))
1037 		clk_put(drvdata->pclk);