1 /* $NetBSD: drm_encoder_slave.c,v 1.2 2021/12/19 10:48:14 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.2 2021/12/19 10:48:14 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 const 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
Indexes created Sat Sep 20 22:09:52 GMT 2025