Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 386a2a71 authored by Thierry Reding's avatar Thierry Reding
Browse files

drm/tegra: Rename host1x_drm structure to tegra_drm



The host1x and Tegra DRM drivers are currently tightly coupled. Renaming
the structure marks the boundary more clearly.

Signed-off-by: default avatarThierry Reding <treding@nvidia.com>
parent d18d3033
Loading
Loading
Loading
Loading
+1 −1
Original line number Diff line number Diff line
@@ -163,7 +163,7 @@ static int host1x_probe(struct platform_device *pdev)

	host1x_debug_init(host);

	host1x_drm_alloc(pdev);
	tegra_drm_alloc(pdev);

	return 0;

+4 −4
Original line number Diff line number Diff line
@@ -1109,7 +1109,7 @@ static const struct host1x_client_ops dc_client_ops = {

static int tegra_dc_probe(struct platform_device *pdev)
{
	struct host1x_drm *host1x = host1x_get_drm_data(pdev->dev.parent);
	struct tegra_drm *tegra = host1x_get_drm_data(pdev->dev.parent);
	struct resource *regs;
	struct tegra_dc *dc;
	int err;
@@ -1153,7 +1153,7 @@ static int tegra_dc_probe(struct platform_device *pdev)
		return err;
	}

	err = host1x_register_client(host1x, &dc->client);
	err = host1x_register_client(tegra, &dc->client);
	if (err < 0) {
		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
			err);
@@ -1167,11 +1167,11 @@ static int tegra_dc_probe(struct platform_device *pdev)

static int tegra_dc_remove(struct platform_device *pdev)
{
	struct host1x_drm *host1x = host1x_get_drm_data(pdev->dev.parent);
	struct tegra_drm *tegra = host1x_get_drm_data(pdev->dev.parent);
	struct tegra_dc *dc = platform_get_drvdata(pdev);
	int err;

	err = host1x_unregister_client(host1x, &dc->client);
	err = host1x_unregister_client(tegra, &dc->client);
	if (err < 0) {
		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
			err);
+84 −85
Original line number Diff line number Diff line
@@ -30,56 +30,55 @@
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0

struct host1x_drm_client {
struct host1x_subdev {
	struct host1x_client *client;
	struct device_node *np;
	struct list_head list;
};

static int host1x_add_drm_client(struct host1x_drm *host1x,
				 struct device_node *np)
static int host1x_subdev_add(struct tegra_drm *tegra, struct device_node *np)
{
	struct host1x_drm_client *client;
	struct host1x_subdev *subdev;

	client = kzalloc(sizeof(*client), GFP_KERNEL);
	if (!client)
	subdev = kzalloc(sizeof(*subdev), GFP_KERNEL);
	if (!subdev)
		return -ENOMEM;

	INIT_LIST_HEAD(&client->list);
	client->np = of_node_get(np);
	INIT_LIST_HEAD(&subdev->list);
	subdev->np = of_node_get(np);

	list_add_tail(&client->list, &host1x->drm_clients);
	list_add_tail(&subdev->list, &tegra->subdevs);

	return 0;
}

static int host1x_activate_drm_client(struct host1x_drm *host1x,
				      struct host1x_drm_client *drm,
static int host1x_subdev_register(struct tegra_drm *tegra,
				  struct host1x_subdev *subdev,
				  struct host1x_client *client)
{
	mutex_lock(&host1x->drm_clients_lock);
	list_del_init(&drm->list);
	list_add_tail(&drm->list, &host1x->drm_active);
	drm->client = client;
	mutex_unlock(&host1x->drm_clients_lock);
	mutex_lock(&tegra->subdevs_lock);
	list_del_init(&subdev->list);
	list_add_tail(&subdev->list, &tegra->active);
	subdev->client = client;
	mutex_unlock(&tegra->subdevs_lock);

	return 0;
}

static int host1x_remove_drm_client(struct host1x_drm *host1x,
				    struct host1x_drm_client *client)
static int host1x_subdev_unregister(struct tegra_drm *tegra,
				    struct host1x_subdev *subdev)
{
	mutex_lock(&host1x->drm_clients_lock);
	list_del_init(&client->list);
	mutex_unlock(&host1x->drm_clients_lock);
	mutex_lock(&tegra->subdevs_lock);
	list_del_init(&subdev->list);
	mutex_unlock(&tegra->subdevs_lock);

	of_node_put(client->np);
	kfree(client);
	of_node_put(subdev->np);
	kfree(subdev);

	return 0;
}

static int host1x_parse_dt(struct host1x_drm *host1x)
static int tegra_parse_dt(struct tegra_drm *tegra)
{
	static const char * const compat[] = {
		"nvidia,tegra20-dc",
@@ -95,10 +94,10 @@ static int host1x_parse_dt(struct host1x_drm *host1x)
	for (i = 0; i < ARRAY_SIZE(compat); i++) {
		struct device_node *np;

		for_each_child_of_node(host1x->dev->of_node, np) {
		for_each_child_of_node(tegra->dev->of_node, np) {
			if (of_device_is_compatible(np, compat[i]) &&
			    of_device_is_available(np)) {
				err = host1x_add_drm_client(host1x, np);
				err = host1x_subdev_add(tegra, np);
				if (err < 0)
					return err;
			}
@@ -108,108 +107,108 @@ static int host1x_parse_dt(struct host1x_drm *host1x)
	return 0;
}

int host1x_drm_alloc(struct platform_device *pdev)
int tegra_drm_alloc(struct platform_device *pdev)
{
	struct host1x_drm *host1x;
	struct tegra_drm *tegra;
	int err;

	host1x = devm_kzalloc(&pdev->dev, sizeof(*host1x), GFP_KERNEL);
	if (!host1x)
	tegra = devm_kzalloc(&pdev->dev, sizeof(*tegra), GFP_KERNEL);
	if (!tegra)
		return -ENOMEM;

	mutex_init(&host1x->drm_clients_lock);
	INIT_LIST_HEAD(&host1x->drm_clients);
	INIT_LIST_HEAD(&host1x->drm_active);
	mutex_init(&host1x->clients_lock);
	INIT_LIST_HEAD(&host1x->clients);
	host1x->dev = &pdev->dev;
	mutex_init(&tegra->subdevs_lock);
	INIT_LIST_HEAD(&tegra->subdevs);
	INIT_LIST_HEAD(&tegra->active);
	mutex_init(&tegra->clients_lock);
	INIT_LIST_HEAD(&tegra->clients);
	tegra->dev = &pdev->dev;

	err = host1x_parse_dt(host1x);
	err = tegra_parse_dt(tegra);
	if (err < 0) {
		dev_err(&pdev->dev, "failed to parse DT: %d\n", err);
		return err;
	}

	host1x_set_drm_data(&pdev->dev, host1x);
	host1x_set_drm_data(&pdev->dev, tegra);

	return 0;
}

int host1x_drm_init(struct host1x_drm *host1x, struct drm_device *drm)
int tegra_drm_init(struct tegra_drm *tegra, struct drm_device *drm)
{
	struct host1x_client *client;

	mutex_lock(&host1x->clients_lock);
	mutex_lock(&tegra->clients_lock);

	list_for_each_entry(client, &host1x->clients, list) {
	list_for_each_entry(client, &tegra->clients, list) {
		if (client->ops && client->ops->drm_init) {
			int err = client->ops->drm_init(client, drm);
			if (err < 0) {
				dev_err(host1x->dev,
				dev_err(tegra->dev,
					"DRM setup failed for %s: %d\n",
					dev_name(client->dev), err);
				mutex_unlock(&host1x->clients_lock);
				mutex_unlock(&tegra->clients_lock);
				return err;
			}
		}
	}

	mutex_unlock(&host1x->clients_lock);
	mutex_unlock(&tegra->clients_lock);

	return 0;
}

int host1x_drm_exit(struct host1x_drm *host1x)
int tegra_drm_exit(struct tegra_drm *tegra)
{
	struct platform_device *pdev = to_platform_device(host1x->dev);
	struct platform_device *pdev = to_platform_device(tegra->dev);
	struct host1x_client *client;

	if (!host1x->drm)
	if (!tegra->drm)
		return 0;

	mutex_lock(&host1x->clients_lock);
	mutex_lock(&tegra->clients_lock);

	list_for_each_entry_reverse(client, &host1x->clients, list) {
	list_for_each_entry_reverse(client, &tegra->clients, list) {
		if (client->ops && client->ops->drm_exit) {
			int err = client->ops->drm_exit(client);
			if (err < 0) {
				dev_err(host1x->dev,
				dev_err(tegra->dev,
					"DRM cleanup failed for %s: %d\n",
					dev_name(client->dev), err);
				mutex_unlock(&host1x->clients_lock);
				mutex_unlock(&tegra->clients_lock);
				return err;
			}
		}
	}

	mutex_unlock(&host1x->clients_lock);
	mutex_unlock(&tegra->clients_lock);

	drm_platform_exit(&tegra_drm_driver, pdev);
	host1x->drm = NULL;
	tegra->drm = NULL;

	return 0;
}

int host1x_register_client(struct host1x_drm *host1x,
int host1x_register_client(struct tegra_drm *tegra,
			   struct host1x_client *client)
{
	struct host1x_drm_client *drm, *tmp;
	struct host1x_subdev *subdev, *tmp;
	int err;

	mutex_lock(&host1x->clients_lock);
	list_add_tail(&client->list, &host1x->clients);
	mutex_unlock(&host1x->clients_lock);
	mutex_lock(&tegra->clients_lock);
	list_add_tail(&client->list, &tegra->clients);
	mutex_unlock(&tegra->clients_lock);

	list_for_each_entry_safe(drm, tmp, &host1x->drm_clients, list)
		if (drm->np == client->dev->of_node)
			host1x_activate_drm_client(host1x, drm, client);
	list_for_each_entry_safe(subdev, tmp, &tegra->subdevs, list)
		if (subdev->np == client->dev->of_node)
			host1x_subdev_register(tegra, subdev, client);

	if (list_empty(&host1x->drm_clients)) {
		struct platform_device *pdev = to_platform_device(host1x->dev);
	if (list_empty(&tegra->subdevs)) {
		struct platform_device *pdev = to_platform_device(tegra->dev);

		err = drm_platform_init(&tegra_drm_driver, pdev);
		if (err < 0) {
			dev_err(host1x->dev, "drm_platform_init(): %d\n", err);
			dev_err(tegra->dev, "drm_platform_init(): %d\n", err);
			return err;
		}
	}
@@ -217,45 +216,45 @@ int host1x_register_client(struct host1x_drm *host1x,
	return 0;
}

int host1x_unregister_client(struct host1x_drm *host1x,
int host1x_unregister_client(struct tegra_drm *tegra,
			     struct host1x_client *client)
{
	struct host1x_drm_client *drm, *tmp;
	struct host1x_subdev *subdev, *tmp;
	int err;

	list_for_each_entry_safe(drm, tmp, &host1x->drm_active, list) {
		if (drm->client == client) {
			err = host1x_drm_exit(host1x);
	list_for_each_entry_safe(subdev, tmp, &tegra->active, list) {
		if (subdev->client == client) {
			err = tegra_drm_exit(tegra);
			if (err < 0) {
				dev_err(host1x->dev, "host1x_drm_exit(): %d\n",
				dev_err(tegra->dev, "tegra_drm_exit(): %d\n",
					err);
				return err;
			}

			host1x_remove_drm_client(host1x, drm);
			host1x_subdev_unregister(tegra, subdev);
			break;
		}
	}

	mutex_lock(&host1x->clients_lock);
	mutex_lock(&tegra->clients_lock);
	list_del_init(&client->list);
	mutex_unlock(&host1x->clients_lock);
	mutex_unlock(&tegra->clients_lock);

	return 0;
}

static int tegra_drm_load(struct drm_device *drm, unsigned long flags)
{
	struct host1x_drm *host1x;
	struct tegra_drm *tegra;
	int err;

	host1x = host1x_get_drm_data(drm->dev);
	drm->dev_private = host1x;
	host1x->drm = drm;
	tegra = host1x_get_drm_data(drm->dev);
	drm->dev_private = tegra;
	tegra->drm = drm;

	drm_mode_config_init(drm);

	err = host1x_drm_init(host1x, drm);
	err = tegra_drm_init(tegra, drm);
	if (err < 0)
		return err;

@@ -311,9 +310,9 @@ static void host1x_drm_context_free(struct host1x_drm_context *context)

static void tegra_drm_lastclose(struct drm_device *drm)
{
	struct host1x_drm *host1x = drm->dev_private;
	struct tegra_drm *tegra = drm->dev_private;

	tegra_fbdev_restore_mode(host1x->fbdev);
	tegra_fbdev_restore_mode(tegra->fbdev);
}

#ifdef CONFIG_DRM_TEGRA_STAGING
@@ -407,18 +406,18 @@ static int tegra_syncpt_wait(struct drm_device *drm, void *data,
static int tegra_open_channel(struct drm_device *drm, void *data,
			      struct drm_file *file)
{
	struct host1x_drm_file *fpriv = file->driver_priv;
	struct tegra_drm *tegra = drm->dev_private;
	struct drm_tegra_open_channel *args = data;
	struct host1x_client *client;
	struct host1x_drm_context *context;
	struct host1x_drm_file *fpriv = file->driver_priv;
	struct host1x_drm *host1x = drm->dev_private;
	struct host1x_client *client;
	int err = -ENODEV;

	context = kzalloc(sizeof(*context), GFP_KERNEL);
	if (!context)
		return -ENOMEM;

	list_for_each_entry(client, &host1x->clients, list)
	list_for_each_entry(client, &tegra->clients, list)
		if (client->class == args->client) {
			err = client->ops->open_channel(client, context);
			if (err)
+9 −9
Original line number Diff line number Diff line
@@ -30,13 +30,13 @@ struct tegra_fbdev {
	struct tegra_fb *fb;
};

struct host1x_drm {
struct tegra_drm {
	struct drm_device *drm;
	struct device *dev;

	struct mutex drm_clients_lock;
	struct list_head drm_clients;
	struct list_head drm_active;
	struct mutex subdevs_lock;
	struct list_head subdevs;
	struct list_head active;

	struct mutex clients_lock;
	struct list_head clients;
@@ -68,7 +68,7 @@ struct host1x_drm_file {
};

struct host1x_client {
	struct host1x_drm *host1x;
	struct tegra_drm *tegra;
	struct device *dev;

	const struct host1x_client_ops *ops;
@@ -82,12 +82,12 @@ struct host1x_client {
	struct list_head list;
};

extern int host1x_drm_init(struct host1x_drm *host1x, struct drm_device *drm);
extern int host1x_drm_exit(struct host1x_drm *host1x);
extern int tegra_drm_init(struct tegra_drm *tegra, struct drm_device *drm);
extern int tegra_drm_exit(struct tegra_drm *tegra);

extern int host1x_register_client(struct host1x_drm *host1x,
extern int host1x_register_client(struct tegra_drm *tegra,
				  struct host1x_client *client);
extern int host1x_unregister_client(struct host1x_drm *host1x,
extern int host1x_unregister_client(struct tegra_drm *tegra,
				    struct host1x_client *client);

struct tegra_output;
+7 −7
Original line number Diff line number Diff line
@@ -323,10 +323,10 @@ static void tegra_fbdev_free(struct tegra_fbdev *fbdev)

static void tegra_fb_output_poll_changed(struct drm_device *drm)
{
	struct host1x_drm *host1x = drm->dev_private;
	struct tegra_drm *tegra = drm->dev_private;

	if (host1x->fbdev)
		drm_fb_helper_hotplug_event(&host1x->fbdev->base);
	if (tegra->fbdev)
		drm_fb_helper_hotplug_event(&tegra->fbdev->base);
}

static const struct drm_mode_config_funcs tegra_drm_mode_funcs = {
@@ -336,7 +336,7 @@ static const struct drm_mode_config_funcs tegra_drm_mode_funcs = {

int tegra_drm_fb_init(struct drm_device *drm)
{
	struct host1x_drm *host1x = drm->dev_private;
	struct tegra_drm *tegra = drm->dev_private;
	struct tegra_fbdev *fbdev;

	drm->mode_config.min_width = 0;
@@ -352,16 +352,16 @@ int tegra_drm_fb_init(struct drm_device *drm)
	if (IS_ERR(fbdev))
		return PTR_ERR(fbdev);

	host1x->fbdev = fbdev;
	tegra->fbdev = fbdev;

	return 0;
}

void tegra_drm_fb_exit(struct drm_device *drm)
{
	struct host1x_drm *host1x = drm->dev_private;
	struct tegra_drm *tegra = drm->dev_private;

	tegra_fbdev_free(host1x->fbdev);
	tegra_fbdev_free(tegra->fbdev);
}

void tegra_fbdev_restore_mode(struct tegra_fbdev *fbdev)
Loading