1 /* 2 * Copyright (C) 2009 Nokia Corporation 3 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com> 4 * 5 * Some code and ideas taken from drivers/video/omap/ driver 6 * by Imre Deak. 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License version 2 as published by 10 * the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15 * more details. 16 * 17 * You should have received a copy of the GNU General Public License along with 18 * this program. If not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #define DSS_SUBSYS_NAME "OVERLAY" 22 23 #include <linux/module.h> 24 #include <linux/err.h> 25 #include <linux/sysfs.h> 26 #include <linux/kobject.h> 27 #include <linux/platform_device.h> 28 29 #include <video/omapdss.h> 30 31 #include "dss.h" 32 #include "dss_features.h" 33 34 static ssize_t overlay_name_show(struct omap_overlay *ovl, char *buf) 35 { 36 return snprintf(buf, PAGE_SIZE, "%s\n", ovl->name); 37 } 38 39 static ssize_t overlay_manager_show(struct omap_overlay *ovl, char *buf) 40 { 41 return snprintf(buf, PAGE_SIZE, "%s\n", 42 ovl->manager ? ovl->manager->name : "<none>"); 43 } 44 45 static ssize_t overlay_manager_store(struct omap_overlay *ovl, const char *buf, 46 size_t size) 47 { 48 int i, r; 49 struct omap_overlay_manager *mgr = NULL; 50 struct omap_overlay_manager *old_mgr; 51 int len = size; 52 53 if (buf[size-1] == '\n') 54 --len; 55 56 if (len > 0) { 57 for (i = 0; i < omap_dss_get_num_overlay_managers(); ++i) { 58 mgr = omap_dss_get_overlay_manager(i); 59 60 if (sysfs_streq(buf, mgr->name)) 61 break; 62 63 mgr = NULL; 64 } 65 } 66 67 if (len > 0 && mgr == NULL) 68 return -EINVAL; 69 70 if (mgr) 71 DSSDBG("manager %s found\n", mgr->name); 72 73 if (mgr == ovl->manager) 74 return size; 75 76 old_mgr = ovl->manager; 77 78 r = dispc_runtime_get(); 79 if (r) 80 return r; 81 82 /* detach old manager */ 83 if (old_mgr) { 84 r = ovl->unset_manager(ovl); 85 if (r) { 86 DSSERR("detach failed\n"); 87 goto err; 88 } 89 90 r = old_mgr->apply(old_mgr); 91 if (r) 92 goto err; 93 } 94 95 if (mgr) { 96 r = ovl->set_manager(ovl, mgr); 97 if (r) { 98 DSSERR("Failed to attach overlay\n"); 99 goto err; 100 } 101 102 r = mgr->apply(mgr); 103 if (r) 104 goto err; 105 } 106 107 dispc_runtime_put(); 108 109 return size; 110 111 err: 112 dispc_runtime_put(); 113 return r; 114 } 115 116 static ssize_t overlay_input_size_show(struct omap_overlay *ovl, char *buf) 117 { 118 struct omap_overlay_info info; 119 120 ovl->get_overlay_info(ovl, &info); 121 122 return snprintf(buf, PAGE_SIZE, "%d,%d\n", 123 info.width, info.height); 124 } 125 126 static ssize_t overlay_screen_width_show(struct omap_overlay *ovl, char *buf) 127 { 128 struct omap_overlay_info info; 129 130 ovl->get_overlay_info(ovl, &info); 131 132 return snprintf(buf, PAGE_SIZE, "%d\n", info.screen_width); 133 } 134 135 static ssize_t overlay_position_show(struct omap_overlay *ovl, char *buf) 136 { 137 struct omap_overlay_info info; 138 139 ovl->get_overlay_info(ovl, &info); 140 141 return snprintf(buf, PAGE_SIZE, "%d,%d\n", 142 info.pos_x, info.pos_y); 143 } 144 145 static ssize_t overlay_position_store(struct omap_overlay *ovl, 146 const char *buf, size_t size) 147 { 148 int r; 149 char *last; 150 struct omap_overlay_info info; 151 152 ovl->get_overlay_info(ovl, &info); 153 154 info.pos_x = simple_strtoul(buf, &last, 10); 155 ++last; 156 if (last - buf >= size) 157 return -EINVAL; 158 159 info.pos_y = simple_strtoul(last, &last, 10); 160 161 r = ovl->set_overlay_info(ovl, &info); 162 if (r) 163 return r; 164 165 if (ovl->manager) { 166 r = ovl->manager->apply(ovl->manager); 167 if (r) 168 return r; 169 } 170 171 return size; 172 } 173 174 static ssize_t overlay_output_size_show(struct omap_overlay *ovl, char *buf) 175 { 176 struct omap_overlay_info info; 177 178 ovl->get_overlay_info(ovl, &info); 179 180 return snprintf(buf, PAGE_SIZE, "%d,%d\n", 181 info.out_width, info.out_height); 182 } 183 184 static ssize_t overlay_output_size_store(struct omap_overlay *ovl, 185 const char *buf, size_t size) 186 { 187 int r; 188 char *last; 189 struct omap_overlay_info info; 190 191 ovl->get_overlay_info(ovl, &info); 192 193 info.out_width = simple_strtoul(buf, &last, 10); 194 ++last; 195 if (last - buf >= size) 196 return -EINVAL; 197 198 info.out_height = simple_strtoul(last, &last, 10); 199 200 r = ovl->set_overlay_info(ovl, &info); 201 if (r) 202 return r; 203 204 if (ovl->manager) { 205 r = ovl->manager->apply(ovl->manager); 206 if (r) 207 return r; 208 } 209 210 return size; 211 } 212 213 static ssize_t overlay_enabled_show(struct omap_overlay *ovl, char *buf) 214 { 215 return snprintf(buf, PAGE_SIZE, "%d\n", ovl->is_enabled(ovl)); 216 } 217 218 static ssize_t overlay_enabled_store(struct omap_overlay *ovl, const char *buf, 219 size_t size) 220 { 221 int r; 222 bool enable; 223 224 r = strtobool(buf, &enable); 225 if (r) 226 return r; 227 228 if (enable) 229 r = ovl->enable(ovl); 230 else 231 r = ovl->disable(ovl); 232 233 if (r) 234 return r; 235 236 return size; 237 } 238 239 static ssize_t overlay_global_alpha_show(struct omap_overlay *ovl, char *buf) 240 { 241 struct omap_overlay_info info; 242 243 ovl->get_overlay_info(ovl, &info); 244 245 return snprintf(buf, PAGE_SIZE, "%d\n", 246 info.global_alpha); 247 } 248 249 static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl, 250 const char *buf, size_t size) 251 { 252 int r; 253 u8 alpha; 254 struct omap_overlay_info info; 255 256 if ((ovl->caps & OMAP_DSS_OVL_CAP_GLOBAL_ALPHA) == 0) 257 return -ENODEV; 258 259 r = kstrtou8(buf, 0, &alpha); 260 if (r) 261 return r; 262 263 ovl->get_overlay_info(ovl, &info); 264 265 info.global_alpha = alpha; 266 267 r = ovl->set_overlay_info(ovl, &info); 268 if (r) 269 return r; 270 271 if (ovl->manager) { 272 r = ovl->manager->apply(ovl->manager); 273 if (r) 274 return r; 275 } 276 277 return size; 278 } 279 280 static ssize_t overlay_pre_mult_alpha_show(struct omap_overlay *ovl, 281 char *buf) 282 { 283 struct omap_overlay_info info; 284 285 ovl->get_overlay_info(ovl, &info); 286 287 return snprintf(buf, PAGE_SIZE, "%d\n", 288 info.pre_mult_alpha); 289 } 290 291 static ssize_t overlay_pre_mult_alpha_store(struct omap_overlay *ovl, 292 const char *buf, size_t size) 293 { 294 int r; 295 u8 alpha; 296 struct omap_overlay_info info; 297 298 if ((ovl->caps & OMAP_DSS_OVL_CAP_PRE_MULT_ALPHA) == 0) 299 return -ENODEV; 300 301 r = kstrtou8(buf, 0, &alpha); 302 if (r) 303 return r; 304 305 ovl->get_overlay_info(ovl, &info); 306 307 info.pre_mult_alpha = alpha; 308 309 r = ovl->set_overlay_info(ovl, &info); 310 if (r) 311 return r; 312 313 if (ovl->manager) { 314 r = ovl->manager->apply(ovl->manager); 315 if (r) 316 return r; 317 } 318 319 return size; 320 } 321 322 static ssize_t overlay_zorder_show(struct omap_overlay *ovl, char *buf) 323 { 324 struct omap_overlay_info info; 325 326 ovl->get_overlay_info(ovl, &info); 327 328 return snprintf(buf, PAGE_SIZE, "%d\n", info.zorder); 329 } 330 331 static ssize_t overlay_zorder_store(struct omap_overlay *ovl, 332 const char *buf, size_t size) 333 { 334 int r; 335 u8 zorder; 336 struct omap_overlay_info info; 337 338 if ((ovl->caps & OMAP_DSS_OVL_CAP_ZORDER) == 0) 339 return -ENODEV; 340 341 r = kstrtou8(buf, 0, &zorder); 342 if (r) 343 return r; 344 345 ovl->get_overlay_info(ovl, &info); 346 347 info.zorder = zorder; 348 349 r = ovl->set_overlay_info(ovl, &info); 350 if (r) 351 return r; 352 353 if (ovl->manager) { 354 r = ovl->manager->apply(ovl->manager); 355 if (r) 356 return r; 357 } 358 359 return size; 360 } 361 362 struct overlay_attribute { 363 struct attribute attr; 364 ssize_t (*show)(struct omap_overlay *, char *); 365 ssize_t (*store)(struct omap_overlay *, const char *, size_t); 366 }; 367 368 #define OVERLAY_ATTR(_name, _mode, _show, _store) \ 369 struct overlay_attribute overlay_attr_##_name = \ 370 __ATTR(_name, _mode, _show, _store) 371 372 static OVERLAY_ATTR(name, S_IRUGO, overlay_name_show, NULL); 373 static OVERLAY_ATTR(manager, S_IRUGO|S_IWUSR, 374 overlay_manager_show, overlay_manager_store); 375 static OVERLAY_ATTR(input_size, S_IRUGO, overlay_input_size_show, NULL); 376 static OVERLAY_ATTR(screen_width, S_IRUGO, overlay_screen_width_show, NULL); 377 static OVERLAY_ATTR(position, S_IRUGO|S_IWUSR, 378 overlay_position_show, overlay_position_store); 379 static OVERLAY_ATTR(output_size, S_IRUGO|S_IWUSR, 380 overlay_output_size_show, overlay_output_size_store); 381 static OVERLAY_ATTR(enabled, S_IRUGO|S_IWUSR, 382 overlay_enabled_show, overlay_enabled_store); 383 static OVERLAY_ATTR(global_alpha, S_IRUGO|S_IWUSR, 384 overlay_global_alpha_show, overlay_global_alpha_store); 385 static OVERLAY_ATTR(pre_mult_alpha, S_IRUGO|S_IWUSR, 386 overlay_pre_mult_alpha_show, 387 overlay_pre_mult_alpha_store); 388 static OVERLAY_ATTR(zorder, S_IRUGO|S_IWUSR, 389 overlay_zorder_show, overlay_zorder_store); 390 391 static struct attribute *overlay_sysfs_attrs[] = { 392 &overlay_attr_name.attr, 393 &overlay_attr_manager.attr, 394 &overlay_attr_input_size.attr, 395 &overlay_attr_screen_width.attr, 396 &overlay_attr_position.attr, 397 &overlay_attr_output_size.attr, 398 &overlay_attr_enabled.attr, 399 &overlay_attr_global_alpha.attr, 400 &overlay_attr_pre_mult_alpha.attr, 401 &overlay_attr_zorder.attr, 402 NULL 403 }; 404 405 static ssize_t overlay_attr_show(struct kobject *kobj, struct attribute *attr, 406 char *buf) 407 { 408 struct omap_overlay *overlay; 409 struct overlay_attribute *overlay_attr; 410 411 overlay = container_of(kobj, struct omap_overlay, kobj); 412 overlay_attr = container_of(attr, struct overlay_attribute, attr); 413 414 if (!overlay_attr->show) 415 return -ENOENT; 416 417 return overlay_attr->show(overlay, buf); 418 } 419 420 static ssize_t overlay_attr_store(struct kobject *kobj, struct attribute *attr, 421 const char *buf, size_t size) 422 { 423 struct omap_overlay *overlay; 424 struct overlay_attribute *overlay_attr; 425 426 overlay = container_of(kobj, struct omap_overlay, kobj); 427 overlay_attr = container_of(attr, struct overlay_attribute, attr); 428 429 if (!overlay_attr->store) 430 return -ENOENT; 431 432 return overlay_attr->store(overlay, buf, size); 433 } 434 435 static const struct sysfs_ops overlay_sysfs_ops = { 436 .show = overlay_attr_show, 437 .store = overlay_attr_store, 438 }; 439 440 static struct kobj_type overlay_ktype = { 441 .sysfs_ops = &overlay_sysfs_ops, 442 .default_attrs = overlay_sysfs_attrs, 443 }; 444 445 int dss_overlay_kobj_init(struct omap_overlay *ovl, 446 struct platform_device *pdev) 447 { 448 return kobject_init_and_add(&ovl->kobj, &overlay_ktype, 449 &pdev->dev.kobj, "overlay%d", ovl->id); 450 } 451 452 void dss_overlay_kobj_uninit(struct omap_overlay *ovl) 453 { 454 kobject_del(&ovl->kobj); 455 kobject_put(&ovl->kobj); 456 } 457