1 | /* $NetBSD: drm_encoder_slave.c,v 1.1 2015/03/05 17:42:48 riastradh Exp $ */ |
2 | |
3 | /*- |
4 | * Copyright (c) 2015 The NetBSD Foundation, Inc. |
5 | * All rights reserved. |
6 | * |
7 | * This code is derived from software contributed to The NetBSD Foundation |
8 | * by Taylor R. Campbell. |
9 | * |
10 | * Redistribution and use in source and binary forms, with or without |
11 | * modification, are permitted provided that the following conditions |
12 | * are met: |
13 | * 1. Redistributions of source code must retain the above copyright |
14 | * notice, this list of conditions and the following disclaimer. |
15 | * 2. Redistributions in binary form must reproduce the above copyright |
16 | * notice, this list of conditions and the following disclaimer in the |
17 | * documentation and/or other materials provided with the distribution. |
18 | * |
19 | * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
20 | * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
21 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
22 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
23 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
24 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
25 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
26 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
27 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
28 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
29 | * POSSIBILITY OF SUCH DAMAGE. |
30 | */ |
31 | |
32 | #include <sys/cdefs.h> |
33 | __KERNEL_RCSID(0, "$NetBSD: drm_encoder_slave.c,v 1.1 2015/03/05 17:42:48 riastradh Exp $" ); |
34 | |
35 | #include <sys/types.h> |
36 | #include <sys/atomic.h> |
37 | #include <sys/errno.h> |
38 | #include <sys/kmem.h> |
39 | #include <sys/mutex.h> |
40 | #include <sys/rbtree.h> |
41 | #include <sys/systm.h> |
42 | |
43 | #include <linux/i2c.h> |
44 | |
45 | #include <drm/drm_encoder_slave.h> |
46 | |
47 | static struct { |
48 | kmutex_t lock; |
49 | rb_tree_t tree; /* struct drm_i2c_encoder_driver */ |
50 | } drm_i2c_encoder_drivers; |
51 | |
52 | static int |
53 | compare_i2c_encoders(void *cookie __unused, const void *va, const void *vb) |
54 | { |
55 | const struct drm_i2c_encoder_driver *const da = va; |
56 | const struct drm_i2c_encoder_driver *const db = vb; |
57 | |
58 | return strncmp(da->i2c_driver.driver.name, db->i2c_driver.driver.name, |
59 | I2C_NAME_SIZE); |
60 | } |
61 | |
62 | static int |
63 | compare_i2c_encoder_key(void *cookie __unused, const void *n, const void *k) |
64 | { |
65 | const struct drm_i2c_encoder_driver *const driver = n; |
66 | const char *const name = k; |
67 | |
68 | return strncmp(driver->i2c_driver.driver.name, name, I2C_NAME_SIZE); |
69 | } |
70 | |
71 | static rb_tree_ops_t drm_i2c_encoder_rb_ops = { |
72 | .rbto_compare_nodes = &compare_i2c_encoders, |
73 | .rbto_compare_key = &compare_i2c_encoder_key, |
74 | .rbto_node_offset = offsetof(struct drm_i2c_encoder_driver, rb_node), |
75 | .rbto_context = NULL, |
76 | }; |
77 | |
78 | void |
79 | drm_i2c_encoders_init(void) |
80 | { |
81 | |
82 | mutex_init(&drm_i2c_encoder_drivers.lock, MUTEX_DEFAULT, IPL_NONE); |
83 | rb_tree_init(&drm_i2c_encoder_drivers.tree, &drm_i2c_encoder_rb_ops); |
84 | } |
85 | |
86 | void |
87 | drm_i2c_encoders_fini(void) |
88 | { |
89 | |
90 | KASSERT(RB_TREE_MIN(&drm_i2c_encoder_drivers.tree) == NULL); |
91 | #if 0 /* XXX no rb_tree_destroy */ |
92 | rb_tree_destroy(&drm_i2c_encoder_drivers.tree); |
93 | #endif |
94 | mutex_destroy(&drm_i2c_encoder_drivers.lock); |
95 | } |
96 | |
97 | int |
98 | drm_i2c_encoder_register(struct module *owner __unused, |
99 | struct drm_i2c_encoder_driver *driver) |
100 | { |
101 | struct drm_i2c_encoder_driver *collision; |
102 | int ret = 0; |
103 | |
104 | mutex_enter(&drm_i2c_encoder_drivers.lock); |
105 | collision = rb_tree_insert_node(&drm_i2c_encoder_drivers.tree, driver); |
106 | if (collision != driver) |
107 | ret = -EEXIST; |
108 | mutex_exit(&drm_i2c_encoder_drivers.lock); |
109 | |
110 | return ret; |
111 | } |
112 | |
113 | void |
114 | drm_i2c_encoder_unregister(struct drm_i2c_encoder_driver *driver) |
115 | { |
116 | |
117 | /* XXX How to guarantee? */ |
118 | KASSERT(driver->refcnt == 0); |
119 | |
120 | mutex_enter(&drm_i2c_encoder_drivers.lock); |
121 | rb_tree_remove_node(&drm_i2c_encoder_drivers.tree, driver); |
122 | mutex_exit(&drm_i2c_encoder_drivers.lock); |
123 | } |
124 | |
125 | struct drm_i2c_encoder_bus_priv { |
126 | struct i2c_client *i2c_client; |
127 | struct drm_i2c_encoder_driver *i2c_driver; |
128 | }; |
129 | |
130 | int |
131 | drm_i2c_encoder_init(struct drm_device *dev, struct drm_encoder_slave *slave, |
132 | struct i2c_adapter *adapter, const struct i2c_board_info *info) |
133 | { |
134 | struct drm_i2c_encoder_driver *driver; |
135 | struct drm_i2c_encoder_bus_priv *bus_priv; |
136 | struct i2c_client *client; |
137 | unsigned refcnt; |
138 | int ret; |
139 | |
140 | bus_priv = kmem_alloc(sizeof(*bus_priv), KM_SLEEP); |
141 | slave->bus_priv = bus_priv; |
142 | |
143 | mutex_enter(&drm_i2c_encoder_drivers.lock); |
144 | driver = rb_tree_find_node(&drm_i2c_encoder_drivers.tree, info->type); |
145 | mutex_exit(&drm_i2c_encoder_drivers.lock); |
146 | if (driver == NULL) { |
147 | ret = -ENODEV; |
148 | goto fail0; |
149 | } |
150 | do { |
151 | refcnt = driver->refcnt; |
152 | if (refcnt == UINT_MAX) { |
153 | ret = -ENFILE; |
154 | goto fail0; |
155 | } |
156 | } while (atomic_cas_uint(&driver->refcnt, refcnt, refcnt + 1) |
157 | != refcnt); |
158 | bus_priv->i2c_driver = driver; |
159 | |
160 | client = i2c_new_device(adapter, info); |
161 | KASSERT(client != NULL); |
162 | bus_priv->i2c_client = client; |
163 | |
164 | ret = (*driver->encoder_init)(client, dev, slave); |
165 | if (ret) |
166 | goto fail1; |
167 | |
168 | if (info->platform_data) |
169 | (*slave->slave_funcs->set_config)(&slave->base, |
170 | info->platform_data); |
171 | |
172 | /* Success! */ |
173 | return 0; |
174 | |
175 | fail1: bus_priv->i2c_client = NULL; |
176 | i2c_unregister_device(client); |
177 | bus_priv->i2c_driver = NULL; |
178 | atomic_dec_uint(&driver->refcnt); |
179 | fail0: KASSERT(ret < 0); |
180 | slave->bus_priv = NULL; |
181 | kmem_free(bus_priv, sizeof(*bus_priv)); |
182 | return ret; |
183 | } |
184 | |
185 | void |
186 | drm_i2c_encoder_destroy(struct drm_encoder *encoder) |
187 | { |
188 | struct drm_encoder_slave *const slave = to_encoder_slave(encoder); |
189 | struct drm_i2c_encoder_bus_priv *const bus_priv = slave->bus_priv; |
190 | struct i2c_client *const client = bus_priv->i2c_client; |
191 | struct drm_i2c_encoder_driver *const driver = bus_priv->i2c_driver; |
192 | |
193 | bus_priv->i2c_client = NULL; |
194 | i2c_unregister_device(client); |
195 | bus_priv->i2c_driver = NULL; |
196 | atomic_dec_uint(&driver->refcnt); |
197 | } |
198 | |
199 | struct i2c_client * |
200 | drm_i2c_encoder_get_client(struct drm_encoder *encoder) |
201 | { |
202 | struct drm_encoder_slave *const slave = to_encoder_slave(encoder); |
203 | struct drm_i2c_encoder_bus_priv *const bus_priv = slave->bus_priv; |
204 | |
205 | return bus_priv->i2c_client; |
206 | } |
207 | |
208 | static inline struct drm_encoder_slave_funcs * |
209 | slave_funcs(struct drm_encoder *encoder) |
210 | { |
211 | |
212 | return to_encoder_slave(encoder)->slave_funcs; |
213 | } |
214 | |
215 | void |
216 | drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode) |
217 | { |
218 | |
219 | (*slave_funcs(encoder)->dpms)(encoder, mode); |
220 | } |
221 | |
222 | void |
223 | drm_i2c_encoder_prepare(struct drm_encoder *encoder) |
224 | { |
225 | |
226 | drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_OFF); |
227 | } |
228 | |
229 | void |
230 | drm_i2c_encoder_commit(struct drm_encoder *encoder) |
231 | { |
232 | |
233 | drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_ON); |
234 | } |
235 | |
236 | bool |
237 | drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder, |
238 | const struct drm_display_mode *mode, |
239 | struct drm_display_mode *adjusted_mode) |
240 | { |
241 | |
242 | return (*slave_funcs(encoder)->mode_fixup)(encoder, mode, |
243 | adjusted_mode); |
244 | } |
245 | |
246 | void |
247 | drm_i2c_encoder_mode_set(struct drm_encoder *encoder, |
248 | struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode) |
249 | { |
250 | |
251 | return (*slave_funcs(encoder)->mode_set)(encoder, mode, adjusted_mode); |
252 | } |
253 | |
254 | enum drm_connector_status |
255 | drm_i2c_encoder_detect(struct drm_encoder *encoder, |
256 | struct drm_connector *connector) |
257 | { |
258 | |
259 | return (*slave_funcs(encoder)->detect)(encoder, connector); |
260 | } |
261 | |
262 | void |
263 | drm_i2c_encoder_save(struct drm_encoder *encoder) |
264 | { |
265 | |
266 | (*slave_funcs(encoder)->save)(encoder); |
267 | } |
268 | |
269 | void |
270 | drm_i2c_encoder_restore(struct drm_encoder *encoder) |
271 | { |
272 | |
273 | (*slave_funcs(encoder)->restore)(encoder); |
274 | } |
275 | |