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
47static struct {
48 kmutex_t lock;
49 rb_tree_t tree; /* struct drm_i2c_encoder_driver */
50} drm_i2c_encoder_drivers;
51
52static int
53compare_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
62static int
63compare_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
71static 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
78void
79drm_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
86void
87drm_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
97int
98drm_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
113void
114drm_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
125struct drm_i2c_encoder_bus_priv {
126 struct i2c_client *i2c_client;
127 struct drm_i2c_encoder_driver *i2c_driver;
128};
129
130int
131drm_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
175fail1: bus_priv->i2c_client = NULL;
176 i2c_unregister_device(client);
177 bus_priv->i2c_driver = NULL;
178 atomic_dec_uint(&driver->refcnt);
179fail0: KASSERT(ret < 0);
180 slave->bus_priv = NULL;
181 kmem_free(bus_priv, sizeof(*bus_priv));
182 return ret;
183}
184
185void
186drm_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
199struct i2c_client *
200drm_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
208static inline struct drm_encoder_slave_funcs *
209slave_funcs(struct drm_encoder *encoder)
210{
211
212 return to_encoder_slave(encoder)->slave_funcs;
213}
214
215void
216drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode)
217{
218
219 (*slave_funcs(encoder)->dpms)(encoder, mode);
220}
221
222void
223drm_i2c_encoder_prepare(struct drm_encoder *encoder)
224{
225
226 drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
227}
228
229void
230drm_i2c_encoder_commit(struct drm_encoder *encoder)
231{
232
233 drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
234}
235
236bool
237drm_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
246void
247drm_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
254enum drm_connector_status
255drm_i2c_encoder_detect(struct drm_encoder *encoder,
256 struct drm_connector *connector)
257{
258
259 return (*slave_funcs(encoder)->detect)(encoder, connector);
260}
261
262void
263drm_i2c_encoder_save(struct drm_encoder *encoder)
264{
265
266 (*slave_funcs(encoder)->save)(encoder);
267}
268
269void
270drm_i2c_encoder_restore(struct drm_encoder *encoder)
271{
272
273 (*slave_funcs(encoder)->restore)(encoder);
274}
275