linux/drivers/gpu/drm/tegra/drm.h
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2012 Avionic Design GmbH
   3 * Copyright (C) 2012-2013 NVIDIA CORPORATION.  All rights reserved.
   4 *
   5 * This program is free software; you can redistribute it and/or modify
   6 * it under the terms of the GNU General Public License version 2 as
   7 * published by the Free Software Foundation.
   8 */
   9
  10#ifndef HOST1X_DRM_H
  11#define HOST1X_DRM_H 1
  12
  13#include <uapi/drm/tegra_drm.h>
  14#include <linux/host1x.h>
  15
  16#include <drm/drmP.h>
  17#include <drm/drm_crtc_helper.h>
  18#include <drm/drm_edid.h>
  19#include <drm/drm_fb_helper.h>
  20#include <drm/drm_fixed.h>
  21
  22#include "gem.h"
  23
  24struct reset_control;
  25
  26struct tegra_fb {
  27        struct drm_framebuffer base;
  28        struct tegra_bo **planes;
  29        unsigned int num_planes;
  30};
  31
  32#ifdef CONFIG_DRM_TEGRA_FBDEV
  33struct tegra_fbdev {
  34        struct drm_fb_helper base;
  35        struct tegra_fb *fb;
  36};
  37#endif
  38
  39struct tegra_drm {
  40        struct drm_device *drm;
  41
  42        struct iommu_domain *domain;
  43        struct drm_mm mm;
  44
  45        struct mutex clients_lock;
  46        struct list_head clients;
  47
  48#ifdef CONFIG_DRM_TEGRA_FBDEV
  49        struct tegra_fbdev *fbdev;
  50#endif
  51
  52        unsigned int pitch_align;
  53
  54        struct {
  55                struct drm_atomic_state *state;
  56                struct work_struct work;
  57                struct mutex lock;
  58        } commit;
  59};
  60
  61struct tegra_drm_client;
  62
  63struct tegra_drm_context {
  64        struct tegra_drm_client *client;
  65        struct host1x_channel *channel;
  66        struct list_head list;
  67};
  68
  69struct tegra_drm_client_ops {
  70        int (*open_channel)(struct tegra_drm_client *client,
  71                            struct tegra_drm_context *context);
  72        void (*close_channel)(struct tegra_drm_context *context);
  73        int (*is_addr_reg)(struct device *dev, u32 class, u32 offset);
  74        int (*submit)(struct tegra_drm_context *context,
  75                      struct drm_tegra_submit *args, struct drm_device *drm,
  76                      struct drm_file *file);
  77};
  78
  79int tegra_drm_submit(struct tegra_drm_context *context,
  80                     struct drm_tegra_submit *args, struct drm_device *drm,
  81                     struct drm_file *file);
  82
  83struct tegra_drm_client {
  84        struct host1x_client base;
  85        struct list_head list;
  86
  87        const struct tegra_drm_client_ops *ops;
  88};
  89
  90static inline struct tegra_drm_client *
  91host1x_to_drm_client(struct host1x_client *client)
  92{
  93        return container_of(client, struct tegra_drm_client, base);
  94}
  95
  96int tegra_drm_register_client(struct tegra_drm *tegra,
  97                              struct tegra_drm_client *client);
  98int tegra_drm_unregister_client(struct tegra_drm *tegra,
  99                                struct tegra_drm_client *client);
 100
 101int tegra_drm_init(struct tegra_drm *tegra, struct drm_device *drm);
 102int tegra_drm_exit(struct tegra_drm *tegra);
 103
 104struct tegra_dc_soc_info;
 105struct tegra_output;
 106
 107struct tegra_dc {
 108        struct host1x_client client;
 109        struct host1x_syncpt *syncpt;
 110        struct device *dev;
 111        spinlock_t lock;
 112
 113        struct drm_crtc base;
 114        int powergate;
 115        int pipe;
 116
 117        struct clk *clk;
 118        struct reset_control *rst;
 119        void __iomem *regs;
 120        int irq;
 121
 122        struct tegra_output *rgb;
 123
 124        struct list_head list;
 125
 126        struct drm_info_list *debugfs_files;
 127        struct drm_minor *minor;
 128        struct dentry *debugfs;
 129
 130        /* page-flip handling */
 131        struct drm_pending_vblank_event *event;
 132
 133        const struct tegra_dc_soc_info *soc;
 134
 135        struct iommu_domain *domain;
 136};
 137
 138static inline struct tegra_dc *
 139host1x_client_to_dc(struct host1x_client *client)
 140{
 141        return container_of(client, struct tegra_dc, client);
 142}
 143
 144static inline struct tegra_dc *to_tegra_dc(struct drm_crtc *crtc)
 145{
 146        return crtc ? container_of(crtc, struct tegra_dc, base) : NULL;
 147}
 148
 149static inline void tegra_dc_writel(struct tegra_dc *dc, u32 value,
 150                                   unsigned long offset)
 151{
 152        writel(value, dc->regs + (offset << 2));
 153}
 154
 155static inline u32 tegra_dc_readl(struct tegra_dc *dc, unsigned long offset)
 156{
 157        return readl(dc->regs + (offset << 2));
 158}
 159
 160struct tegra_dc_window {
 161        struct {
 162                unsigned int x;
 163                unsigned int y;
 164                unsigned int w;
 165                unsigned int h;
 166        } src;
 167        struct {
 168                unsigned int x;
 169                unsigned int y;
 170                unsigned int w;
 171                unsigned int h;
 172        } dst;
 173        unsigned int bits_per_pixel;
 174        unsigned int stride[2];
 175        unsigned long base[3];
 176        bool bottom_up;
 177
 178        struct tegra_bo_tiling tiling;
 179        u32 format;
 180        u32 swap;
 181};
 182
 183/* from dc.c */
 184u32 tegra_dc_get_vblank_counter(struct tegra_dc *dc);
 185void tegra_dc_enable_vblank(struct tegra_dc *dc);
 186void tegra_dc_disable_vblank(struct tegra_dc *dc);
 187void tegra_dc_cancel_page_flip(struct drm_crtc *crtc, struct drm_file *file);
 188void tegra_dc_commit(struct tegra_dc *dc);
 189int tegra_dc_state_setup_clock(struct tegra_dc *dc,
 190                               struct drm_crtc_state *crtc_state,
 191                               struct clk *clk, unsigned long pclk,
 192                               unsigned int div);
 193
 194struct tegra_output {
 195        struct device_node *of_node;
 196        struct device *dev;
 197
 198        struct drm_panel *panel;
 199        struct i2c_adapter *ddc;
 200        const struct edid *edid;
 201        unsigned int hpd_irq;
 202        int hpd_gpio;
 203
 204        struct drm_encoder encoder;
 205        struct drm_connector connector;
 206};
 207
 208static inline struct tegra_output *encoder_to_output(struct drm_encoder *e)
 209{
 210        return container_of(e, struct tegra_output, encoder);
 211}
 212
 213static inline struct tegra_output *connector_to_output(struct drm_connector *c)
 214{
 215        return container_of(c, struct tegra_output, connector);
 216}
 217
 218/* from rgb.c */
 219int tegra_dc_rgb_probe(struct tegra_dc *dc);
 220int tegra_dc_rgb_remove(struct tegra_dc *dc);
 221int tegra_dc_rgb_init(struct drm_device *drm, struct tegra_dc *dc);
 222int tegra_dc_rgb_exit(struct tegra_dc *dc);
 223
 224/* from output.c */
 225int tegra_output_probe(struct tegra_output *output);
 226void tegra_output_remove(struct tegra_output *output);
 227int tegra_output_init(struct drm_device *drm, struct tegra_output *output);
 228void tegra_output_exit(struct tegra_output *output);
 229
 230int tegra_output_connector_get_modes(struct drm_connector *connector);
 231struct drm_encoder *
 232tegra_output_connector_best_encoder(struct drm_connector *connector);
 233enum drm_connector_status
 234tegra_output_connector_detect(struct drm_connector *connector, bool force);
 235void tegra_output_connector_destroy(struct drm_connector *connector);
 236
 237void tegra_output_encoder_destroy(struct drm_encoder *encoder);
 238
 239/* from dpaux.c */
 240struct tegra_dpaux;
 241struct drm_dp_link;
 242
 243struct tegra_dpaux *tegra_dpaux_find_by_of_node(struct device_node *np);
 244enum drm_connector_status tegra_dpaux_detect(struct tegra_dpaux *dpaux);
 245int tegra_dpaux_attach(struct tegra_dpaux *dpaux, struct tegra_output *output);
 246int tegra_dpaux_detach(struct tegra_dpaux *dpaux);
 247int tegra_dpaux_enable(struct tegra_dpaux *dpaux);
 248int tegra_dpaux_disable(struct tegra_dpaux *dpaux);
 249int tegra_dpaux_prepare(struct tegra_dpaux *dpaux, u8 encoding);
 250int tegra_dpaux_train(struct tegra_dpaux *dpaux, struct drm_dp_link *link,
 251                      u8 pattern);
 252
 253/* from fb.c */
 254struct tegra_bo *tegra_fb_get_plane(struct drm_framebuffer *framebuffer,
 255                                    unsigned int index);
 256bool tegra_fb_is_bottom_up(struct drm_framebuffer *framebuffer);
 257int tegra_fb_get_tiling(struct drm_framebuffer *framebuffer,
 258                        struct tegra_bo_tiling *tiling);
 259struct drm_framebuffer *tegra_fb_create(struct drm_device *drm,
 260                                        struct drm_file *file,
 261                                        struct drm_mode_fb_cmd2 *cmd);
 262int tegra_drm_fb_prepare(struct drm_device *drm);
 263void tegra_drm_fb_free(struct drm_device *drm);
 264int tegra_drm_fb_init(struct drm_device *drm);
 265void tegra_drm_fb_exit(struct drm_device *drm);
 266#ifdef CONFIG_DRM_TEGRA_FBDEV
 267void tegra_fbdev_restore_mode(struct tegra_fbdev *fbdev);
 268void tegra_fb_output_poll_changed(struct drm_device *drm);
 269#endif
 270
 271extern struct platform_driver tegra_dc_driver;
 272extern struct platform_driver tegra_dsi_driver;
 273extern struct platform_driver tegra_sor_driver;
 274extern struct platform_driver tegra_hdmi_driver;
 275extern struct platform_driver tegra_dpaux_driver;
 276extern struct platform_driver tegra_gr2d_driver;
 277extern struct platform_driver tegra_gr3d_driver;
 278
 279#endif /* HOST1X_DRM_H */
 280