Loading...
1/* SPDX-License-Identifier: MIT */
2
3#ifndef __LINUX_GUD_INTERNAL_H
4#define __LINUX_GUD_INTERNAL_H
5
6#include <linux/list.h>
7#include <linux/mutex.h>
8#include <linux/usb.h>
9#include <linux/workqueue.h>
10#include <uapi/drm/drm_fourcc.h>
11
12#include <drm/drm_modes.h>
13#include <drm/drm_simple_kms_helper.h>
14
15struct gud_device {
16 struct drm_device drm;
17 struct drm_simple_display_pipe pipe;
18 struct device *dmadev;
19 struct work_struct work;
20 u32 flags;
21 const struct drm_format_info *xrgb8888_emulation_format;
22
23 u16 *properties;
24 unsigned int num_properties;
25
26 unsigned int bulk_pipe;
27 void *bulk_buf;
28 size_t bulk_len;
29
30 u8 compression;
31 void *lz4_comp_mem;
32 void *compress_buf;
33
34 u64 stats_length;
35 u64 stats_actual_length;
36 unsigned int stats_num_errors;
37
38 struct mutex ctrl_lock; /* Serialize get/set and status transfers */
39
40 struct mutex damage_lock; /* Protects the following members: */
41 struct drm_framebuffer *fb;
42 struct drm_rect damage;
43 bool prev_flush_failed;
44};
45
46static inline struct gud_device *to_gud_device(struct drm_device *drm)
47{
48 return container_of(drm, struct gud_device, drm);
49}
50
51static inline struct usb_device *gud_to_usb_device(struct gud_device *gdrm)
52{
53 return interface_to_usbdev(to_usb_interface(gdrm->drm.dev));
54}
55
56int gud_usb_get(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len);
57int gud_usb_set(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len);
58int gud_usb_get_u8(struct gud_device *gdrm, u8 request, u16 index, u8 *val);
59int gud_usb_set_u8(struct gud_device *gdrm, u8 request, u8 val);
60
61void gud_clear_damage(struct gud_device *gdrm);
62void gud_flush_work(struct work_struct *work);
63int gud_pipe_check(struct drm_simple_display_pipe *pipe,
64 struct drm_plane_state *new_plane_state,
65 struct drm_crtc_state *new_crtc_state);
66void gud_pipe_update(struct drm_simple_display_pipe *pipe,
67 struct drm_plane_state *old_state);
68int gud_connector_fill_properties(struct drm_connector_state *connector_state,
69 struct gud_property_req *properties);
70int gud_get_connectors(struct gud_device *gdrm);
71
72/* Driver internal fourcc transfer formats */
73#define GUD_DRM_FORMAT_R1 0x00000122
74#define GUD_DRM_FORMAT_XRGB1111 0x03121722
75
76static inline u8 gud_from_fourcc(u32 fourcc)
77{
78 switch (fourcc) {
79 case GUD_DRM_FORMAT_R1:
80 return GUD_PIXEL_FORMAT_R1;
81 case GUD_DRM_FORMAT_XRGB1111:
82 return GUD_PIXEL_FORMAT_XRGB1111;
83 case DRM_FORMAT_RGB565:
84 return GUD_PIXEL_FORMAT_RGB565;
85 case DRM_FORMAT_XRGB8888:
86 return GUD_PIXEL_FORMAT_XRGB8888;
87 case DRM_FORMAT_ARGB8888:
88 return GUD_PIXEL_FORMAT_ARGB8888;
89 }
90
91 return 0;
92}
93
94static inline u32 gud_to_fourcc(u8 format)
95{
96 switch (format) {
97 case GUD_PIXEL_FORMAT_R1:
98 return GUD_DRM_FORMAT_R1;
99 case GUD_PIXEL_FORMAT_XRGB1111:
100 return GUD_DRM_FORMAT_XRGB1111;
101 case GUD_PIXEL_FORMAT_RGB565:
102 return DRM_FORMAT_RGB565;
103 case GUD_PIXEL_FORMAT_XRGB8888:
104 return DRM_FORMAT_XRGB8888;
105 case GUD_PIXEL_FORMAT_ARGB8888:
106 return DRM_FORMAT_ARGB8888;
107 }
108
109 return 0;
110}
111
112static inline void gud_from_display_mode(struct gud_display_mode_req *dst,
113 const struct drm_display_mode *src)
114{
115 u32 flags = src->flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;
116
117 if (src->type & DRM_MODE_TYPE_PREFERRED)
118 flags |= GUD_DISPLAY_MODE_FLAG_PREFERRED;
119
120 dst->clock = cpu_to_le32(src->clock);
121 dst->hdisplay = cpu_to_le16(src->hdisplay);
122 dst->hsync_start = cpu_to_le16(src->hsync_start);
123 dst->hsync_end = cpu_to_le16(src->hsync_end);
124 dst->htotal = cpu_to_le16(src->htotal);
125 dst->vdisplay = cpu_to_le16(src->vdisplay);
126 dst->vsync_start = cpu_to_le16(src->vsync_start);
127 dst->vsync_end = cpu_to_le16(src->vsync_end);
128 dst->vtotal = cpu_to_le16(src->vtotal);
129 dst->flags = cpu_to_le32(flags);
130}
131
132static inline void gud_to_display_mode(struct drm_display_mode *dst,
133 const struct gud_display_mode_req *src)
134{
135 u32 flags = le32_to_cpu(src->flags);
136
137 memset(dst, 0, sizeof(*dst));
138 dst->clock = le32_to_cpu(src->clock);
139 dst->hdisplay = le16_to_cpu(src->hdisplay);
140 dst->hsync_start = le16_to_cpu(src->hsync_start);
141 dst->hsync_end = le16_to_cpu(src->hsync_end);
142 dst->htotal = le16_to_cpu(src->htotal);
143 dst->vdisplay = le16_to_cpu(src->vdisplay);
144 dst->vsync_start = le16_to_cpu(src->vsync_start);
145 dst->vsync_end = le16_to_cpu(src->vsync_end);
146 dst->vtotal = le16_to_cpu(src->vtotal);
147 dst->flags = flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;
148 dst->type = DRM_MODE_TYPE_DRIVER;
149 if (flags & GUD_DISPLAY_MODE_FLAG_PREFERRED)
150 dst->type |= DRM_MODE_TYPE_PREFERRED;
151 drm_mode_set_name(dst);
152}
153
154#endif
1/* SPDX-License-Identifier: MIT */
2
3#ifndef __LINUX_GUD_INTERNAL_H
4#define __LINUX_GUD_INTERNAL_H
5
6#include <linux/list.h>
7#include <linux/mutex.h>
8#include <linux/scatterlist.h>
9#include <linux/usb.h>
10#include <linux/workqueue.h>
11#include <uapi/drm/drm_fourcc.h>
12
13#include <drm/drm_modes.h>
14#include <drm/drm_simple_kms_helper.h>
15
16struct gud_device {
17 struct drm_device drm;
18 struct drm_simple_display_pipe pipe;
19 struct device *dmadev;
20 struct work_struct work;
21 u32 flags;
22 const struct drm_format_info *xrgb8888_emulation_format;
23
24 u16 *properties;
25 unsigned int num_properties;
26
27 unsigned int bulk_pipe;
28 void *bulk_buf;
29 size_t bulk_len;
30 struct sg_table bulk_sgt;
31
32 u8 compression;
33 void *lz4_comp_mem;
34 void *compress_buf;
35
36 u64 stats_length;
37 u64 stats_actual_length;
38 unsigned int stats_num_errors;
39
40 struct mutex ctrl_lock; /* Serialize get/set and status transfers */
41
42 struct mutex damage_lock; /* Protects the following members: */
43 struct drm_framebuffer *fb;
44 struct drm_rect damage;
45 bool prev_flush_failed;
46};
47
48static inline struct gud_device *to_gud_device(struct drm_device *drm)
49{
50 return container_of(drm, struct gud_device, drm);
51}
52
53static inline struct usb_device *gud_to_usb_device(struct gud_device *gdrm)
54{
55 return interface_to_usbdev(to_usb_interface(gdrm->drm.dev));
56}
57
58int gud_usb_get(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len);
59int gud_usb_set(struct gud_device *gdrm, u8 request, u16 index, void *buf, size_t len);
60int gud_usb_get_u8(struct gud_device *gdrm, u8 request, u16 index, u8 *val);
61int gud_usb_set_u8(struct gud_device *gdrm, u8 request, u8 val);
62
63void gud_clear_damage(struct gud_device *gdrm);
64void gud_flush_work(struct work_struct *work);
65int gud_pipe_check(struct drm_simple_display_pipe *pipe,
66 struct drm_plane_state *new_plane_state,
67 struct drm_crtc_state *new_crtc_state);
68void gud_pipe_update(struct drm_simple_display_pipe *pipe,
69 struct drm_plane_state *old_state);
70int gud_connector_fill_properties(struct drm_connector_state *connector_state,
71 struct gud_property_req *properties);
72int gud_get_connectors(struct gud_device *gdrm);
73
74/* Driver internal fourcc transfer formats */
75#define GUD_DRM_FORMAT_R1 0x00000122
76#define GUD_DRM_FORMAT_XRGB1111 0x03121722
77
78static inline u8 gud_from_fourcc(u32 fourcc)
79{
80 switch (fourcc) {
81 case GUD_DRM_FORMAT_R1:
82 return GUD_PIXEL_FORMAT_R1;
83 case DRM_FORMAT_R8:
84 return GUD_PIXEL_FORMAT_R8;
85 case GUD_DRM_FORMAT_XRGB1111:
86 return GUD_PIXEL_FORMAT_XRGB1111;
87 case DRM_FORMAT_RGB332:
88 return GUD_PIXEL_FORMAT_RGB332;
89 case DRM_FORMAT_RGB565:
90 return GUD_PIXEL_FORMAT_RGB565;
91 case DRM_FORMAT_RGB888:
92 return GUD_PIXEL_FORMAT_RGB888;
93 case DRM_FORMAT_XRGB8888:
94 return GUD_PIXEL_FORMAT_XRGB8888;
95 case DRM_FORMAT_ARGB8888:
96 return GUD_PIXEL_FORMAT_ARGB8888;
97 }
98
99 return 0;
100}
101
102static inline u32 gud_to_fourcc(u8 format)
103{
104 switch (format) {
105 case GUD_PIXEL_FORMAT_R1:
106 return GUD_DRM_FORMAT_R1;
107 case GUD_PIXEL_FORMAT_R8:
108 return DRM_FORMAT_R8;
109 case GUD_PIXEL_FORMAT_XRGB1111:
110 return GUD_DRM_FORMAT_XRGB1111;
111 case GUD_PIXEL_FORMAT_RGB332:
112 return DRM_FORMAT_RGB332;
113 case GUD_PIXEL_FORMAT_RGB565:
114 return DRM_FORMAT_RGB565;
115 case GUD_PIXEL_FORMAT_RGB888:
116 return DRM_FORMAT_RGB888;
117 case GUD_PIXEL_FORMAT_XRGB8888:
118 return DRM_FORMAT_XRGB8888;
119 case GUD_PIXEL_FORMAT_ARGB8888:
120 return DRM_FORMAT_ARGB8888;
121 }
122
123 return 0;
124}
125
126static inline void gud_from_display_mode(struct gud_display_mode_req *dst,
127 const struct drm_display_mode *src)
128{
129 u32 flags = src->flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;
130
131 if (src->type & DRM_MODE_TYPE_PREFERRED)
132 flags |= GUD_DISPLAY_MODE_FLAG_PREFERRED;
133
134 dst->clock = cpu_to_le32(src->clock);
135 dst->hdisplay = cpu_to_le16(src->hdisplay);
136 dst->hsync_start = cpu_to_le16(src->hsync_start);
137 dst->hsync_end = cpu_to_le16(src->hsync_end);
138 dst->htotal = cpu_to_le16(src->htotal);
139 dst->vdisplay = cpu_to_le16(src->vdisplay);
140 dst->vsync_start = cpu_to_le16(src->vsync_start);
141 dst->vsync_end = cpu_to_le16(src->vsync_end);
142 dst->vtotal = cpu_to_le16(src->vtotal);
143 dst->flags = cpu_to_le32(flags);
144}
145
146static inline void gud_to_display_mode(struct drm_display_mode *dst,
147 const struct gud_display_mode_req *src)
148{
149 u32 flags = le32_to_cpu(src->flags);
150
151 memset(dst, 0, sizeof(*dst));
152 dst->clock = le32_to_cpu(src->clock);
153 dst->hdisplay = le16_to_cpu(src->hdisplay);
154 dst->hsync_start = le16_to_cpu(src->hsync_start);
155 dst->hsync_end = le16_to_cpu(src->hsync_end);
156 dst->htotal = le16_to_cpu(src->htotal);
157 dst->vdisplay = le16_to_cpu(src->vdisplay);
158 dst->vsync_start = le16_to_cpu(src->vsync_start);
159 dst->vsync_end = le16_to_cpu(src->vsync_end);
160 dst->vtotal = le16_to_cpu(src->vtotal);
161 dst->flags = flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;
162 dst->type = DRM_MODE_TYPE_DRIVER;
163 if (flags & GUD_DISPLAY_MODE_FLAG_PREFERRED)
164 dst->type |= DRM_MODE_TYPE_PREFERRED;
165 drm_mode_set_name(dst);
166}
167
168#endif