gth.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0
/*
 * Intel(R) Trace Hub Global Trace Hub
 *
 * Copyright (C) 2014-2015 Intel Corporation.
 */

#define pr_fmt(fmt) …

#include <linux/types.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/io.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/bitmap.h>
#include <linux/pm_runtime.h>

#include "intel_th.h"
#include "gth.h"

struct gth_device;

/**
 * struct gth_output - GTH view on an output port
 * @gth:	backlink to the GTH device
 * @output:	link to output device's output descriptor
 * @index:	output port number
 * @port_type:	one of GTH_* port type values
 * @master:	bitmap of masters configured for this output
 */
struct gth_output { … };

/**
 * struct gth_device - GTH device
 * @dev:	driver core's device
 * @base:	register window base address
 * @output_group:	attributes describing output ports
 * @master_group:	attributes describing master assignments
 * @output:		output ports
 * @master:		master/output port assignments
 * @gth_lock:		serializes accesses to GTH bits
 */
struct gth_device { … };

static void gth_output_set(struct gth_device *gth, int port,
			   unsigned int config)
{ … }

static unsigned int gth_output_get(struct gth_device *gth, int port)
{ … }

static void gth_smcfreq_set(struct gth_device *gth, int port,
			    unsigned int freq)
{ … }

static unsigned int gth_smcfreq_get(struct gth_device *gth, int port)
{ … }

/*
 * "masters" attribute group
 */

struct master_attribute { … };

static void
gth_master_set(struct gth_device *gth, unsigned int master, int port)
{ … }

static ssize_t master_attr_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{ … }

static ssize_t master_attr_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{ … }

struct output_attribute { … };

#define OUTPUT_PARM(_name, _mask, _r, _w, _what) …

static const struct output_parm { … } output_parms[] = …;

static void
gth_output_parm_set(struct gth_device *gth, int port, unsigned int parm,
		    unsigned int val)
{ … }

static unsigned int
gth_output_parm_get(struct gth_device *gth, int port, unsigned int parm)
{ … }

/*
 * Reset outputs and sources
 */
static int intel_th_gth_reset(struct gth_device *gth)
{ … }

/*
 * "outputs" attribute group
 */

static ssize_t output_attr_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{ … }

static ssize_t output_attr_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{ … }

static int intel_th_master_attributes(struct gth_device *gth)
{ … }

static int intel_th_output_attributes(struct gth_device *gth)
{ … }

/**
 * intel_th_gth_stop() - stop tracing to an output device
 * @gth:		GTH device
 * @output:		output device's descriptor
 * @capture_done:	set when no more traces will be captured
 *
 * This will stop tracing using force storeEn off signal and wait for the
 * pipelines to be empty for the corresponding output port.
 */
static void intel_th_gth_stop(struct gth_device *gth,
			      struct intel_th_output *output,
			      bool capture_done)
{ … }

/**
 * intel_th_gth_start() - start tracing to an output device
 * @gth:	GTH device
 * @output:	output device's descriptor
 *
 * This will start tracing using force storeEn signal.
 */
static void intel_th_gth_start(struct gth_device *gth,
			       struct intel_th_output *output)
{ … }

/**
 * intel_th_gth_disable() - disable tracing to an output device
 * @thdev:	GTH device
 * @output:	output device's descriptor
 *
 * This will deconfigure all masters set to output to this device,
 * disable tracing using force storeEn off signal and wait for the
 * "pipeline empty" bit for corresponding output port.
 */
static void intel_th_gth_disable(struct intel_th_device *thdev,
				 struct intel_th_output *output)
{ … }

static void gth_tscu_resync(struct gth_device *gth)
{ … }

static void intel_th_gth_prepare(struct intel_th_device *thdev,
				 struct intel_th_output *output)
{ … }

/**
 * intel_th_gth_enable() - enable tracing to an output device
 * @thdev:	GTH device
 * @output:	output device's descriptor
 *
 * This will configure all masters set to output to this device and
 * enable tracing using force storeEn signal.
 */
static void intel_th_gth_enable(struct intel_th_device *thdev,
				struct intel_th_output *output)
{ … }

/**
 * intel_th_gth_switch() - execute a switch sequence
 * @thdev:	GTH device
 * @output:	output device's descriptor
 *
 * This will execute a switch sequence that will trigger a switch window
 * when tracing to MSC in multi-block mode.
 */
static void intel_th_gth_switch(struct intel_th_device *thdev,
				struct intel_th_output *output)
{ … }

/**
 * intel_th_gth_assign() - assign output device to a GTH output port
 * @thdev:	GTH device
 * @othdev:	output device
 *
 * This will match a given output device parameters against present
 * output ports on the GTH and fill out relevant bits in output device's
 * descriptor.
 *
 * Return:	0 on success, -errno on error.
 */
static int intel_th_gth_assign(struct intel_th_device *thdev,
			       struct intel_th_device *othdev)
{ … }

/**
 * intel_th_gth_unassign() - deassociate an output device from its output port
 * @thdev:	GTH device
 * @othdev:	output device
 */
static void intel_th_gth_unassign(struct intel_th_device *thdev,
				  struct intel_th_device *othdev)
{ … }

static int
intel_th_gth_set_output(struct intel_th_device *thdev, unsigned int master)
{ … }

static int intel_th_gth_probe(struct intel_th_device *thdev)
{ … }

static void intel_th_gth_remove(struct intel_th_device *thdev)
{ … }

static struct intel_th_driver intel_th_gth_driver = …;

module_driver(…);

MODULE_ALIAS(…) …;
MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
linux/drivers/hwtracing/intel_th/gth.c
