1/*-
2 * Copyright (c) 2015 Michal Meloun
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: stable/11/sys/arm/nvidia/drm2/tegra_host1x.c 310600 2016-12-26 14:36:05Z mmel $");
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/bus.h>
33#include <sys/clock.h>
34#include <sys/kernel.h>
35#include <sys/limits.h>
36#include <sys/lock.h>
37
38#include <sys/module.h>
39#include <sys/resource.h>
40#include <sys/sx.h>
41#include <sys/rman.h>
42
43#include <machine/bus.h>
44#include <machine/resource.h>
45
46#include <dev/extres/clk/clk.h>
47#include <dev/extres/hwreset/hwreset.h>
48#include <dev/drm2/drmP.h>
49#include <dev/drm2/drm_crtc_helper.h>
50#include <dev/drm2/drm_fb_helper.h>
51#include <dev/fdt/simplebus.h>
52#include <dev/ofw/ofw_bus.h>
53#include <dev/ofw/ofw_bus_subr.h>
54
55#include <arm/nvidia/drm2/tegra_drm.h>
56
57#include "fb_if.h"
58#include "tegra_drm_if.h"
59
60#define	WR4(_sc, _r, _v)	bus_rite_4((_sc)->mem_res, (_r), (_v))
61#define	RD4(_sc, _r)		bus_read_4((_sc)->mem_res, (_r))
62
63#define	LOCK(_sc)		sx_xlock(&(_sc)->lock)
64#define	UNLOCK(_sc)		sx_xunlock(&(_sc)->lock)
65#define	SLEEP(_sc, timeout)	sx_sleep(sc, &sc->lock, 0, "host1x", timeout);
66#define	LOCK_INIT(_sc)		sx_init(&_sc->lock, "host1x")
67#define	LOCK_DESTROY(_sc)	sx_destroy(&_sc->lock)
68#define	ASSERT_LOCKED(_sc)	sx_assert(&_sc->lock, SA_LOCKED)
69#define	ASSERT_UNLOCKED(_sc)	sx_assert(&_sc->lock, SA_UNLOCKED)
70
71static struct ofw_compat_data compat_data[] = {
72	{"nvidia,tegra124-host1x",	1},
73	{NULL,				0}
74};
75
76#define DRIVER_NAME "tegra"
77#define DRIVER_DESC "NVIDIA Tegra TK1"
78#define DRIVER_DATE "20151101"
79#define DRIVER_MAJOR 0
80#define DRIVER_MINOR 0
81#define DRIVER_PATCHLEVEL 0
82
83struct client_info;
84TAILQ_HEAD(client_list, client_info);
85typedef struct client_list client_list_t;
86
87struct client_info {
88	TAILQ_ENTRY(client_info) list_e;
89	device_t client;
90	int 	activated;
91};
92
93struct host1x_softc {
94	struct simplebus_softc	simplebus_sc;	/* must be first */
95	device_t		dev;
96	struct sx		lock;
97	int 			attach_done;
98
99	struct resource		*mem_res;
100	struct resource		*syncpt_irq_res;
101	void			*syncpt_irq_h;
102	struct resource		*gen_irq_res;
103	void			*gen_irq_h;
104
105	clk_t			clk;
106	hwreset_t			reset;
107	struct intr_config_hook	irq_hook;
108
109	int			drm_inited;
110	client_list_t		clients;
111
112	struct tegra_drm 	*tegra_drm;
113};
114
115
116static void
117host1x_output_poll_changed(struct drm_device *drm_dev)
118{
119	struct tegra_drm *drm;
120
121	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
122	if (drm->fb != NULL)
123		drm_fb_helper_hotplug_event(&drm->fb->fb_helper);
124}
125
126static const struct drm_mode_config_funcs mode_config_funcs = {
127	.fb_create = tegra_drm_fb_create,
128	.output_poll_changed = host1x_output_poll_changed,
129};
130
131
132static int
133host1x_drm_init(struct host1x_softc *sc)
134{
135	struct client_info *entry;
136	int rv;
137
138	LOCK(sc);
139
140	TAILQ_FOREACH(entry, &sc->clients, list_e) {
141		if (entry->activated)
142			continue;
143		rv = TEGRA_DRM_INIT_CLIENT(entry->client, sc->dev,
144		    sc->tegra_drm);
145		if (rv != 0) {
146			device_printf(sc->dev,
147			    "Cannot init DRM client %s: %d\n",
148			    device_get_name(entry->client), rv);
149			return (rv);
150		}
151		entry->activated = 1;
152	}
153	UNLOCK(sc);
154
155	return (0);
156}
157
158static int
159host1x_drm_exit(struct host1x_softc *sc)
160{
161	struct client_info *entry;
162	int rv;
163#ifdef FREEBSD_NOTYET
164	struct drm_device *dev, *tmp;
165#endif
166	LOCK(sc);
167	if (!sc->drm_inited) {
168		UNLOCK(sc);
169		return (0);
170	}
171	TAILQ_FOREACH_REVERSE(entry, &sc->clients, client_list, list_e) {
172		if (!entry->activated)
173			continue;
174		rv = TEGRA_DRM_EXIT_CLIENT(entry->client, sc->dev,
175		    sc->tegra_drm);
176		if (rv != 0) {
177			device_printf(sc->dev,
178			    "Cannot exit DRM client %s: %d\n",
179			    device_get_name(entry->client), rv);
180		}
181		entry->activated = 0;
182	}
183
184#ifdef FREEBSD_NOTYET
185	list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item)
186		drm_put_dev(dev);
187#endif
188	sc->drm_inited = 0;
189	UNLOCK(sc);
190
191	return (0);
192}
193
194static int
195host1x_drm_load(struct drm_device *drm_dev, unsigned long flags)
196{
197	struct host1x_softc *sc;
198	int rv;
199
200	sc = device_get_softc(drm_dev->dev);
201
202	drm_mode_config_init(drm_dev);
203	drm_dev->mode_config.min_width = 32;
204	drm_dev->mode_config.min_height = 32;
205	drm_dev->mode_config.max_width = 4096;
206	drm_dev->mode_config.max_height = 4096;
207	drm_dev->mode_config.funcs = &mode_config_funcs;
208
209	rv = host1x_drm_init(sc);
210	if (rv != 0)
211		goto fail_host1x;
212
213	drm_dev->irq_enabled = true;
214	drm_dev->max_vblank_count = 0xffffffff;
215	drm_dev->vblank_disable_allowed = true;
216
217	rv = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc);
218	if (rv != 0)
219		goto fail_vblank;
220
221	drm_mode_config_reset(drm_dev);
222
223	rv = tegra_drm_fb_init(drm_dev);
224	if (rv != 0)
225		goto fail_fb;
226	drm_kms_helper_poll_init(drm_dev);
227
228	return (0);
229
230fail_fb:
231	tegra_drm_fb_destroy(drm_dev);
232	drm_vblank_cleanup(drm_dev);
233fail_vblank:
234	host1x_drm_exit(sc);
235fail_host1x:
236	drm_mode_config_cleanup(drm_dev);
237
238	return (rv);
239}
240
241static int
242host1x_drm_unload(struct drm_device *drm_dev)
243{
244	struct host1x_softc *sc;
245	int rv;
246
247	sc = device_get_softc(drm_dev->dev);
248
249	drm_kms_helper_poll_fini(drm_dev);
250	tegra_drm_fb_destroy(drm_dev);
251	drm_mode_config_cleanup(drm_dev);
252
253	rv = host1x_drm_exit(sc);
254	if (rv < 0)
255		return (rv);
256	return (0);
257}
258
259static int
260host1x_drm_open(struct drm_device *drm_dev, struct drm_file *filp)
261{
262
263	return (0);
264}
265
266static void
267tegra_drm_preclose(struct drm_device *drm, struct drm_file *file)
268{
269	struct drm_crtc *crtc;
270
271	list_for_each_entry(crtc, &drm->mode_config.crtc_list, head)
272		tegra_dc_cancel_page_flip(crtc, file);
273}
274
275static void
276host1x_drm_lastclose(struct drm_device *drm_dev)
277{
278
279	struct tegra_drm *drm;
280
281	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
282	if (drm->fb  != NULL)
283		drm_fb_helper_restore_fbdev_mode(&drm->fb->fb_helper);
284}
285
286static int
287host1x_drm_enable_vblank(struct drm_device *drm_dev, int pipe)
288{
289	struct drm_crtc *crtc;
290
291	list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) {
292		if (pipe == tegra_dc_get_pipe(crtc)) {
293			tegra_dc_enable_vblank(crtc);
294			return (0);
295		}
296	}
297	return (-ENODEV);
298}
299
300static void
301host1x_drm_disable_vblank(struct drm_device *drm_dev, int pipe)
302{
303	struct drm_crtc *crtc;
304
305	list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) {
306		if (pipe == tegra_dc_get_pipe(crtc)) {
307			tegra_dc_disable_vblank(crtc);
308			return;
309		}
310	}
311}
312
313
314static struct drm_ioctl_desc host1x_drm_ioctls[] = {
315};
316
317
318struct drm_driver tegra_drm_driver = {
319	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
320	.load = host1x_drm_load,
321	.unload = host1x_drm_unload,
322	.open = host1x_drm_open,
323	.preclose = tegra_drm_preclose,
324	.lastclose = host1x_drm_lastclose,
325
326	.get_vblank_counter = drm_vblank_count,
327	.enable_vblank = host1x_drm_enable_vblank,
328	.disable_vblank = host1x_drm_disable_vblank,
329
330	/* Fields filled by tegra_bo_driver_register()
331	.gem_free_object
332	.gem_pager_ops
333	.dumb_create
334	.dumb_map_offset
335	.dumb_destroy
336	*/
337	.ioctls = host1x_drm_ioctls,
338	.num_ioctls = nitems(host1x_drm_ioctls),
339
340	.name = DRIVER_NAME,
341	.desc = DRIVER_DESC,
342	.date = DRIVER_DATE,
343	.major = DRIVER_MAJOR,
344	.minor = DRIVER_MINOR,
345	.patchlevel = DRIVER_PATCHLEVEL,
346};
347
348/*
349 * ----------------- Device methods -------------------------
350 */
351static void
352host1x_irq_hook(void *arg)
353{
354	struct host1x_softc *sc;
355	int rv;
356
357	sc = arg;
358	config_intrhook_disestablish(&sc->irq_hook);
359
360	tegra_bo_driver_register(&tegra_drm_driver);
361	rv = drm_get_platform_dev(sc->dev, &sc->tegra_drm->drm_dev,
362	    &tegra_drm_driver);
363	if (rv != 0) {
364		device_printf(sc->dev, "drm_get_platform_dev(): %d\n", rv);
365		return;
366	}
367
368	sc->drm_inited = 1;
369}
370
371static struct fb_info *
372host1x_fb_helper_getinfo(device_t dev)
373{
374	struct host1x_softc *sc;
375
376	sc = device_get_softc(dev);
377	if (sc->tegra_drm == NULL)
378		return (NULL);
379	return (tegra_drm_fb_getinfo(&sc->tegra_drm->drm_dev));
380}
381
382static int
383host1x_register_client(device_t dev, device_t client)
384{
385	struct host1x_softc *sc;
386	struct client_info *entry;
387
388	sc = device_get_softc(dev);
389
390	entry = malloc(sizeof(struct client_info), M_DEVBUF, M_WAITOK | M_ZERO);
391	entry->client = client;
392	entry->activated = 0;
393
394	LOCK(sc);
395	TAILQ_INSERT_TAIL(&sc->clients, entry, list_e);
396	UNLOCK(sc);
397
398	return (0);
399}
400
401static int
402host1x_deregister_client(device_t dev, device_t client)
403{
404	struct host1x_softc *sc;
405	struct client_info *entry;
406
407	sc = device_get_softc(dev);
408
409	LOCK(sc);
410	TAILQ_FOREACH(entry, &sc->clients, list_e) {
411		if (entry->client == client) {
412			if (entry->activated)
413				panic("Tegra DRM: Attempt to deregister "
414				    "activated client");
415			TAILQ_REMOVE(&sc->clients, entry, list_e);
416			free(entry, M_DEVBUF);
417			UNLOCK(sc);
418			return (0);
419		}
420	}
421	UNLOCK(sc);
422
423	return (0);
424}
425
426static void
427host1x_gen_intr(void *arg)
428{
429	struct host1x_softc *sc;
430
431	sc = (struct host1x_softc *)arg;
432	LOCK(sc);
433	UNLOCK(sc);
434}
435
436static void
437host1x_syncpt_intr(void *arg)
438{
439	struct host1x_softc *sc;
440
441	sc = (struct host1x_softc *)arg;
442	LOCK(sc);
443	UNLOCK(sc);
444}
445
446static void
447host1x_new_pass(device_t dev)
448{
449	struct host1x_softc *sc;
450	int rv, rid;
451	phandle_t node;
452
453	/*
454	 * We attach during BUS_PASS_BUS (because we must overcome simplebus),
455	 * but some of our FDT resources are not ready until BUS_PASS_DEFAULT
456	 */
457	sc = device_get_softc(dev);
458	if (sc->attach_done || bus_current_pass < BUS_PASS_DEFAULT) {
459		bus_generic_new_pass(dev);
460		return;
461	}
462
463	sc->attach_done = 1;
464	node = ofw_bus_get_node(dev);
465
466	/* Allocate our IRQ resource. */
467	rid = 0;
468	sc->syncpt_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
469	    RF_ACTIVE);
470	if (sc->syncpt_irq_res == NULL) {
471		device_printf(dev, "Cannot allocate interrupt.\n");
472		rv = ENXIO;
473		goto fail;
474	}
475	rid = 1;
476	sc->gen_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
477	    RF_ACTIVE);
478	if (sc->gen_irq_res == NULL) {
479		device_printf(dev, "Cannot allocate interrupt.\n");
480		rv = ENXIO;
481		goto fail;
482	}
483
484	/* FDT resources */
485	rv = hwreset_get_by_ofw_name(sc->dev, 0, "host1x", &sc->reset);
486	if (rv != 0) {
487		device_printf(dev, "Cannot get fuse reset\n");
488		goto fail;
489	}
490	rv = clk_get_by_ofw_index(sc->dev, 0, 0, &sc->clk);
491	if (rv != 0) {
492		device_printf(dev, "Cannot get i2c clock: %d\n", rv);
493		goto fail;
494	}
495
496	rv = clk_enable(sc->clk);
497	if (rv != 0) {
498		device_printf(dev, "Cannot enable clock: %d\n", rv);
499		goto fail;
500	}
501	rv = hwreset_deassert(sc->reset);
502	if (rv != 0) {
503		device_printf(sc->dev, "Cannot clear reset\n");
504		goto fail;
505	}
506
507	/* Setup  interrupts */
508	rv = bus_setup_intr(dev, sc->gen_irq_res,
509	    INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_gen_intr,
510	    sc, &sc->gen_irq_h);
511	if (rv) {
512		device_printf(dev, "Cannot setup gen interrupt.\n");
513		goto fail;
514	}
515
516	rv = bus_setup_intr(dev, sc->syncpt_irq_res,
517	    INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_syncpt_intr,
518	    sc, &sc->syncpt_irq_h);
519	if (rv) {
520		device_printf(dev, "Cannot setup syncpt interrupt.\n");
521		goto fail;
522	}
523
524	simplebus_init(dev, 0);
525	for (node = OF_child(node); node > 0; node = OF_peer(node))
526	    simplebus_add_device(dev, node, 0, NULL, -1, NULL);
527
528	sc->irq_hook.ich_func = host1x_irq_hook;
529	sc->irq_hook.ich_arg = sc;
530	config_intrhook_establish(&sc->irq_hook);
531	bus_generic_new_pass(dev);
532	return;
533
534fail:
535	device_detach(dev);
536	return;
537}
538
539static int
540host1x_probe(device_t dev)
541{
542
543	if (!ofw_bus_status_okay(dev))
544		return (ENXIO);
545
546	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
547		return (ENXIO);
548
549	return (BUS_PROBE_DEFAULT);
550}
551
552static int
553host1x_attach(device_t dev)
554{
555	int rv, rid;
556	struct host1x_softc *sc;
557
558	sc = device_get_softc(dev);
559	sc->tegra_drm = malloc(sizeof(struct tegra_drm), DRM_MEM_DRIVER,
560	    M_WAITOK | M_ZERO);
561
562	/* crosslink together all worlds */
563	sc->dev = dev;
564	sc->tegra_drm->drm_dev.dev_private = &sc->tegra_drm;
565	sc->tegra_drm->drm_dev.dev = dev;
566
567	TAILQ_INIT(&sc->clients);
568
569	LOCK_INIT(sc);
570
571	/* Get the memory resource for the register mapping. */
572	rid = 0;
573	sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
574	    RF_ACTIVE);
575	if (sc->mem_res == NULL) {
576		device_printf(dev, "Cannot map registers.\n");
577		rv = ENXIO;
578		goto fail;
579	}
580
581	return (bus_generic_attach(dev));
582
583fail:
584	if (sc->tegra_drm != NULL)
585		free(sc->tegra_drm, DRM_MEM_DRIVER);
586	if (sc->mem_res != NULL)
587		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
588	LOCK_DESTROY(sc);
589	return (rv);
590}
591
592static int
593host1x_detach(device_t dev)
594{
595	struct host1x_softc *sc;
596
597	sc = device_get_softc(dev);
598
599	host1x_drm_exit(sc);
600
601	if (sc->gen_irq_h != NULL)
602		bus_teardown_intr(dev, sc->gen_irq_res, sc->gen_irq_h);
603	if (sc->tegra_drm != NULL)
604		free(sc->tegra_drm, DRM_MEM_DRIVER);
605	if (sc->clk != NULL)
606		clk_release(sc->clk);
607	if (sc->reset != NULL)
608		hwreset_release(sc->reset);
609	if (sc->syncpt_irq_h != NULL)
610		bus_teardown_intr(dev, sc->syncpt_irq_res, sc->syncpt_irq_h);
611	if (sc->gen_irq_res != NULL)
612		bus_release_resource(dev, SYS_RES_IRQ, 1, sc->gen_irq_res);
613	if (sc->syncpt_irq_res != NULL)
614		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->syncpt_irq_res);
615	if (sc->mem_res != NULL)
616		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
617	LOCK_DESTROY(sc);
618	return (bus_generic_detach(dev));
619}
620
621static device_method_t host1x_methods[] = {
622	/* Device interface */
623	DEVMETHOD(device_probe,		host1x_probe),
624	DEVMETHOD(device_attach,	host1x_attach),
625	DEVMETHOD(device_detach,	host1x_detach),
626
627	/* Bus interface */
628	DEVMETHOD(bus_new_pass,		host1x_new_pass),
629
630	/* Framebuffer service methods */
631	DEVMETHOD(fb_getinfo,           host1x_fb_helper_getinfo),
632
633	/* tegra drm interface */
634	DEVMETHOD(tegra_drm_register_client,	host1x_register_client),
635	DEVMETHOD(tegra_drm_deregister_client,	host1x_deregister_client),
636
637	DEVMETHOD_END
638};
639
640static devclass_t host1x_devclass;
641DEFINE_CLASS_1(host1x, host1x_driver, host1x_methods,
642    sizeof(struct host1x_softc), simplebus_driver);
643EARLY_DRIVER_MODULE(host1x, simplebus, host1x_driver,
644    host1x_devclass, 0, 0,  BUS_PASS_BUS);
645
646/* Bindings for fbd device. */
647extern devclass_t fbd_devclass;
648extern driver_t fbd_driver;
649DRIVER_MODULE(fbd, host1x, fbd_driver, fbd_devclass, 0, 0);
650
651