dev.c 5.81 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Tegra host1x driver
 *
 * Copyright (c) 2010-2013, NVIDIA Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/module.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/clk.h>
#include <linux/io.h>

#define CREATE_TRACE_POINTS
#include <trace/events/host1x.h>

30
#include "bus.h"
31
#include "dev.h"
32
#include "intr.h"
33
#include "channel.h"
34
#include "debug.h"
35
#include "hw/host1x01.h"
36
#include "hw/host1x02.h"
37
#include "hw/host1x04.h"
38
#include "hw/host1x05.h"
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

void host1x_sync_writel(struct host1x *host1x, u32 v, u32 r)
{
	void __iomem *sync_regs = host1x->regs + host1x->info->sync_offset;

	writel(v, sync_regs + r);
}

u32 host1x_sync_readl(struct host1x *host1x, u32 r)
{
	void __iomem *sync_regs = host1x->regs + host1x->info->sync_offset;

	return readl(sync_regs + r);
}

54 55 56 57 58 59 60 61 62 63
void host1x_ch_writel(struct host1x_channel *ch, u32 v, u32 r)
{
	writel(v, ch->regs + r);
}

u32 host1x_ch_readl(struct host1x_channel *ch, u32 r)
{
	return readl(ch->regs + r);
}

64 65 66 67 68 69 70 71 72
static const struct host1x_info host1x01_info = {
	.nb_channels	= 8,
	.nb_pts		= 32,
	.nb_mlocks	= 16,
	.nb_bases	= 8,
	.init		= host1x01_init,
	.sync_offset	= 0x3000,
};

73 74 75 76 77 78 79 80 81
static const struct host1x_info host1x02_info = {
	.nb_channels = 9,
	.nb_pts = 32,
	.nb_mlocks = 16,
	.nb_bases = 12,
	.init = host1x02_init,
	.sync_offset = 0x3000,
};

82 83 84 85 86 87 88 89 90
static const struct host1x_info host1x04_info = {
	.nb_channels = 12,
	.nb_pts = 192,
	.nb_mlocks = 16,
	.nb_bases = 64,
	.init = host1x04_init,
	.sync_offset = 0x2100,
};

91 92 93 94 95 96 97 98 99
static const struct host1x_info host1x05_info = {
	.nb_channels = 14,
	.nb_pts = 192,
	.nb_mlocks = 16,
	.nb_bases = 64,
	.init = host1x05_init,
	.sync_offset = 0x2100,
};

100
static struct of_device_id host1x_of_match[] = {
101
	{ .compatible = "nvidia,tegra210-host1x", .data = &host1x05_info, },
102
	{ .compatible = "nvidia,tegra124-host1x", .data = &host1x04_info, },
103
	{ .compatible = "nvidia,tegra114-host1x", .data = &host1x02_info, },
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
	{ .compatible = "nvidia,tegra30-host1x", .data = &host1x01_info, },
	{ .compatible = "nvidia,tegra20-host1x", .data = &host1x01_info, },
	{ },
};
MODULE_DEVICE_TABLE(of, host1x_of_match);

static int host1x_probe(struct platform_device *pdev)
{
	const struct of_device_id *id;
	struct host1x *host;
	struct resource *regs;
	int syncpt_irq;
	int err;

	id = of_match_device(host1x_of_match, &pdev->dev);
	if (!id)
		return -EINVAL;

	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!regs) {
		dev_err(&pdev->dev, "failed to get registers\n");
		return -ENXIO;
	}

	syncpt_irq = platform_get_irq(pdev, 0);
	if (syncpt_irq < 0) {
		dev_err(&pdev->dev, "failed to get IRQ\n");
		return -ENXIO;
	}

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

138 139 140
	mutex_init(&host->devices_lock);
	INIT_LIST_HEAD(&host->devices);
	INIT_LIST_HEAD(&host->list);
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
	host->dev = &pdev->dev;
	host->info = id->data;

	/* set common host1x device data */
	platform_set_drvdata(pdev, host);

	host->regs = devm_ioremap_resource(&pdev->dev, regs);
	if (IS_ERR(host->regs))
		return PTR_ERR(host->regs);

	if (host->info->init) {
		err = host->info->init(host);
		if (err)
			return err;
	}

	host->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(host->clk)) {
		dev_err(&pdev->dev, "failed to get clock\n");
		err = PTR_ERR(host->clk);
		return err;
	}

164 165 166 167 168 169
	err = host1x_channel_list_init(host);
	if (err) {
		dev_err(&pdev->dev, "failed to initialize channel list\n");
		return err;
	}

170 171 172 173 174 175 176 177 178
	err = clk_prepare_enable(host->clk);
	if (err < 0) {
		dev_err(&pdev->dev, "failed to enable clock\n");
		return err;
	}

	err = host1x_syncpt_init(host);
	if (err) {
		dev_err(&pdev->dev, "failed to initialize syncpts\n");
179
		goto fail_unprepare_disable;
180 181
	}

182 183 184 185 186 187
	err = host1x_intr_init(host, syncpt_irq);
	if (err) {
		dev_err(&pdev->dev, "failed to initialize interrupts\n");
		goto fail_deinit_syncpt;
	}

188 189
	host1x_debug_init(host);

190 191 192
	err = host1x_register(host);
	if (err < 0)
		goto fail_deinit_intr;
193

194
	return 0;
195

196 197
fail_deinit_intr:
	host1x_intr_deinit(host);
198 199
fail_deinit_syncpt:
	host1x_syncpt_deinit(host);
200 201
fail_unprepare_disable:
	clk_disable_unprepare(host->clk);
202
	return err;
203 204
}

205
static int host1x_remove(struct platform_device *pdev)
206 207 208
{
	struct host1x *host = platform_get_drvdata(pdev);

209
	host1x_unregister(host);
210
	host1x_intr_deinit(host);
211 212 213 214 215 216
	host1x_syncpt_deinit(host);
	clk_disable_unprepare(host->clk);

	return 0;
}

217
static struct platform_driver tegra_host1x_driver = {
218 219 220 221
	.driver = {
		.name = "tegra-host1x",
		.of_match_table = host1x_of_match,
	},
222 223
	.probe = host1x_probe,
	.remove = host1x_remove,
224 225
};

226 227 228 229 230
static struct platform_driver * const drivers[] = {
	&tegra_host1x_driver,
	&tegra_mipi_driver,
};

231 232 233 234
static int __init tegra_host1x_init(void)
{
	int err;

235
	err = bus_register(&host1x_bus_type);
236 237 238
	if (err < 0)
		return err;

239
	err = platform_register_drivers(drivers, ARRAY_SIZE(drivers));
240
	if (err < 0)
241
		bus_unregister(&host1x_bus_type);
242

243
	return err;
244 245 246 247 248
}
module_init(tegra_host1x_init);

static void __exit tegra_host1x_exit(void)
{
249
	platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
250
	bus_unregister(&host1x_bus_type);
251 252
}
module_exit(tegra_host1x_exit);
253

254
MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
255 256 257
MODULE_AUTHOR("Terje Bergstrom <tbergstrom@nvidia.com>");
MODULE_DESCRIPTION("Host1x driver for Tegra products");
MODULE_LICENSE("GPL");