drivers/video/omap2/dss/manager-sysfs.c

   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 "MANAGER"
  22
  23 #include <linux/kernel.h>
  24 #include <linux/slab.h>
  25 #include <linux/module.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/jiffies.h>
  28
  29 #include <video/omapdss.h>
  30
  31 #include "dss.h"
  32 #include "dss_features.h"
  33
  34 static ssize_t manager_name_show(struct omap_overlay_manager *mgr, char *buf)
  35 {
  36         return snprintf(buf, PAGE_SIZE, "%s\n", mgr->name);
  37 }
  38
  39 static ssize_t manager_display_show(struct omap_overlay_manager *mgr, char *buf)
  40 {
  41         struct omap_dss_device *dssdev = mgr->get_device(mgr);
  42
  43         return snprintf(buf, PAGE_SIZE, "%s\n", dssdev ?
  44                         dssdev->name : "<none>");
  45 }
  46
  47 static ssize_t manager_display_store(struct omap_overlay_manager *mgr,
  48                 const char *buf, size_t size)
  49 {
  50         int r = 0;
  51         size_t len = size;
  52         struct omap_dss_device *dssdev = NULL;
  53
  54         int match(struct omap_dss_device *dssdev, void *data)
  55         {
  56                 const char *str = data;
  57                 return sysfs_streq(dssdev->name, str);
  58         }
  59
  60         if (buf[size-1] == '\n')
  61                 --len;
  62
  63         if (len > 0)
  64                 dssdev = omap_dss_find_device((void *)buf, match);
  65
  66         if (len > 0 && dssdev == NULL)
  67                 return -EINVAL;
  68
  69         if (dssdev)
  70                 DSSDBG("display %s found\n", dssdev->name);
  71
  72         if (mgr->output) {
  73                 r = mgr->unset_output(mgr);
  74                 if (r) {
  75                         DSSERR("failed to unset current output\n");
  76                         goto put_device;
  77                 }
  78         }
  79
  80         if (dssdev) {
  81                 struct omap_dss_output *out = dssdev->output;
  82
  83                 /*
  84                  * a registered device should have an output connected to it
  85                  * already
  86                  */
  87                 if (!out) {
  88                         DSSERR("device has no output connected to it\n");
  89                         goto put_device;
  90                 }
  91
  92                 r = mgr->set_output(mgr, out);
  93                 if (r) {
  94                         DSSERR("failed to set manager output\n");
  95                         goto put_device;
  96                 }
  97
  98                 r = mgr->apply(mgr);
  99                 if (r) {
 100                         DSSERR("failed to apply dispc config\n");
 101                         goto put_device;
 102                 }
 103         }
 104
 105 put_device:
 106         if (dssdev)
 107                 omap_dss_put_device(dssdev);
 108
 109         return r ? r : size;
 110 }
 111
 112 static ssize_t manager_default_color_show(struct omap_overlay_manager *mgr,
 113                                           char *buf)
 114 {
 115         struct omap_overlay_manager_info info;
 116
 117         mgr->get_manager_info(mgr, &info);
 118
 119         return snprintf(buf, PAGE_SIZE, "%#x\n", info.default_color);
 120 }
 121
 122 static ssize_t manager_default_color_store(struct omap_overlay_manager *mgr,
 123                                            const char *buf, size_t size)
 124 {
 125         struct omap_overlay_manager_info info;
 126         u32 color;
 127         int r;
 128
 129         r = kstrtouint(buf, 0, &color);
 130         if (r)
 131                 return r;
 132
 133         mgr->get_manager_info(mgr, &info);
 134
 135         info.default_color = color;
 136
 137         r = mgr->set_manager_info(mgr, &info);
 138         if (r)
 139                 return r;
 140
 141         r = mgr->apply(mgr);
 142         if (r)
 143                 return r;
 144
 145         return size;
 146 }
 147
 148 static const char *trans_key_type_str[] = {
 149         "gfx-destination",
 150         "video-source",
 151 };
 152
 153 static ssize_t manager_trans_key_type_show(struct omap_overlay_manager *mgr,
 154                                            char *buf)
 155 {
 156         enum omap_dss_trans_key_type key_type;
 157         struct omap_overlay_manager_info info;
 158
 159         mgr->get_manager_info(mgr, &info);
 160
 161         key_type = info.trans_key_type;
 162         BUG_ON(key_type >= ARRAY_SIZE(trans_key_type_str));
 163
 164         return snprintf(buf, PAGE_SIZE, "%s\n", trans_key_type_str[key_type]);
 165 }
 166
 167 static ssize_t manager_trans_key_type_store(struct omap_overlay_manager *mgr,
 168                                             const char *buf, size_t size)
 169 {
 170         enum omap_dss_trans_key_type key_type;
 171         struct omap_overlay_manager_info info;
 172         int r;
 173
 174         for (key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
 175                         key_type < ARRAY_SIZE(trans_key_type_str); key_type++) {
 176                 if (sysfs_streq(buf, trans_key_type_str[key_type]))
 177                         break;
 178         }
 179
 180         if (key_type == ARRAY_SIZE(trans_key_type_str))
 181                 return -EINVAL;
 182
 183         mgr->get_manager_info(mgr, &info);
 184
 185         info.trans_key_type = key_type;
 186
 187         r = mgr->set_manager_info(mgr, &info);
 188         if (r)
 189                 return r;
 190
 191         r = mgr->apply(mgr);
 192         if (r)
 193                 return r;
 194
 195         return size;
 196 }
 197
 198 static ssize_t manager_trans_key_value_show(struct omap_overlay_manager *mgr,
 199                                             char *buf)
 200 {
 201         struct omap_overlay_manager_info info;
 202
 203         mgr->get_manager_info(mgr, &info);
 204
 205         return snprintf(buf, PAGE_SIZE, "%#x\n", info.trans_key);
 206 }
 207
 208 static ssize_t manager_trans_key_value_store(struct omap_overlay_manager *mgr,
 209                                              const char *buf, size_t size)
 210 {
 211         struct omap_overlay_manager_info info;
 212         u32 key_value;
 213         int r;
 214
 215         r = kstrtouint(buf, 0, &key_value);
 216         if (r)
 217                 return r;
 218
 219         mgr->get_manager_info(mgr, &info);
 220
 221         info.trans_key = key_value;
 222
 223         r = mgr->set_manager_info(mgr, &info);
 224         if (r)
 225                 return r;
 226
 227         r = mgr->apply(mgr);
 228         if (r)
 229                 return r;
 230
 231         return size;
 232 }
 233
 234 static ssize_t manager_trans_key_enabled_show(struct omap_overlay_manager *mgr,
 235                                               char *buf)
 236 {
 237         struct omap_overlay_manager_info info;
 238
 239         mgr->get_manager_info(mgr, &info);
 240
 241         return snprintf(buf, PAGE_SIZE, "%d\n", info.trans_enabled);
 242 }
 243
 244 static ssize_t manager_trans_key_enabled_store(struct omap_overlay_manager *mgr,
 245                                                const char *buf, size_t size)
 246 {
 247         struct omap_overlay_manager_info info;
 248         bool enable;
 249         int r;
 250
 251         r = strtobool(buf, &enable);
 252         if (r)
 253                 return r;
 254
 255         mgr->get_manager_info(mgr, &info);
 256
 257         info.trans_enabled = enable;
 258
 259         r = mgr->set_manager_info(mgr, &info);
 260         if (r)
 261                 return r;
 262
 263         r = mgr->apply(mgr);
 264         if (r)
 265                 return r;
 266
 267         return size;
 268 }
 269
 270 static ssize_t manager_alpha_blending_enabled_show(
 271                 struct omap_overlay_manager *mgr, char *buf)
 272 {
 273         struct omap_overlay_manager_info info;
 274
 275         mgr->get_manager_info(mgr, &info);
 276
 277         WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));
 278
 279         return snprintf(buf, PAGE_SIZE, "%d\n",
 280                 info.partial_alpha_enabled);
 281 }
 282
 283 static ssize_t manager_alpha_blending_enabled_store(
 284                 struct omap_overlay_manager *mgr,
 285                 const char *buf, size_t size)
 286 {
 287         struct omap_overlay_manager_info info;
 288         bool enable;
 289         int r;
 290
 291         WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));
 292
 293         r = strtobool(buf, &enable);
 294         if (r)
 295                 return r;
 296
 297         mgr->get_manager_info(mgr, &info);
 298
 299         info.partial_alpha_enabled = enable;
 300
 301         r = mgr->set_manager_info(mgr, &info);
 302         if (r)
 303                 return r;
 304
 305         r = mgr->apply(mgr);
 306         if (r)
 307                 return r;
 308
 309         return size;
 310 }
 311
 312 static ssize_t manager_cpr_enable_show(struct omap_overlay_manager *mgr,
 313                 char *buf)
 314 {
 315         struct omap_overlay_manager_info info;
 316
 317         mgr->get_manager_info(mgr, &info);
 318
 319         return snprintf(buf, PAGE_SIZE, "%d\n", info.cpr_enable);
 320 }
 321
 322 static ssize_t manager_cpr_enable_store(struct omap_overlay_manager *mgr,
 323                 const char *buf, size_t size)
 324 {
 325         struct omap_overlay_manager_info info;
 326         int r;
 327         bool enable;
 328
 329         if (!dss_has_feature(FEAT_CPR))
 330                 return -ENODEV;
 331
 332         r = strtobool(buf, &enable);
 333         if (r)
 334                 return r;
 335
 336         mgr->get_manager_info(mgr, &info);
 337
 338         if (info.cpr_enable == enable)
 339                 return size;
 340
 341         info.cpr_enable = enable;
 342
 343         r = mgr->set_manager_info(mgr, &info);
 344         if (r)
 345                 return r;
 346
 347         r = mgr->apply(mgr);
 348         if (r)
 349                 return r;
 350
 351         return size;
 352 }
 353
 354 static ssize_t manager_cpr_coef_show(struct omap_overlay_manager *mgr,
 355                 char *buf)
 356 {
 357         struct omap_overlay_manager_info info;
 358
 359         mgr->get_manager_info(mgr, &info);
 360
 361         return snprintf(buf, PAGE_SIZE,
 362                         "%d %d %d %d %d %d %d %d %d\n",
 363                         info.cpr_coefs.rr,
 364                         info.cpr_coefs.rg,
 365                         info.cpr_coefs.rb,
 366                         info.cpr_coefs.gr,
 367                         info.cpr_coefs.gg,
 368                         info.cpr_coefs.gb,
 369                         info.cpr_coefs.br,
 370                         info.cpr_coefs.bg,
 371                         info.cpr_coefs.bb);
 372 }
 373
 374 static ssize_t manager_cpr_coef_store(struct omap_overlay_manager *mgr,
 375                 const char *buf, size_t size)
 376 {
 377         struct omap_overlay_manager_info info;
 378         struct omap_dss_cpr_coefs coefs;
 379         int r, i;
 380         s16 *arr;
 381
 382         if (!dss_has_feature(FEAT_CPR))
 383                 return -ENODEV;
 384
 385         if (sscanf(buf, "%hd %hd %hd %hd %hd %hd %hd %hd %hd",
 386                                 &coefs.rr, &coefs.rg, &coefs.rb,
 387                                 &coefs.gr, &coefs.gg, &coefs.gb,
 388                                 &coefs.br, &coefs.bg, &coefs.bb) != 9)
 389                 return -EINVAL;
 390
 391         arr = (s16[]){ coefs.rr, coefs.rg, coefs.rb,
 392                 coefs.gr, coefs.gg, coefs.gb,
 393                 coefs.br, coefs.bg, coefs.bb };
 394
 395         for (i = 0; i < 9; ++i) {
 396                 if (arr[i] < -512 || arr[i] > 511)
 397                         return -EINVAL;
 398         }
 399
 400         mgr->get_manager_info(mgr, &info);
 401
 402         info.cpr_coefs = coefs;
 403
 404         r = mgr->set_manager_info(mgr, &info);
 405         if (r)
 406                 return r;
 407
 408         r = mgr->apply(mgr);
 409         if (r)
 410                 return r;
 411
 412         return size;
 413 }
 414
 415 struct manager_attribute {
 416         struct attribute attr;
 417         ssize_t (*show)(struct omap_overlay_manager *, char *);
 418         ssize_t (*store)(struct omap_overlay_manager *, const char *, size_t);
 419 };
 420
 421 #define MANAGER_ATTR(_name, _mode, _show, _store) \
 422         struct manager_attribute manager_attr_##_name = \
 423         __ATTR(_name, _mode, _show, _store)
 424
 425 static MANAGER_ATTR(name, S_IRUGO, manager_name_show, NULL);
 426 static MANAGER_ATTR(display, S_IRUGO|S_IWUSR,
 427                 manager_display_show, manager_display_store);
 428 static MANAGER_ATTR(default_color, S_IRUGO|S_IWUSR,
 429                 manager_default_color_show, manager_default_color_store);
 430 static MANAGER_ATTR(trans_key_type, S_IRUGO|S_IWUSR,
 431                 manager_trans_key_type_show, manager_trans_key_type_store);
 432 static MANAGER_ATTR(trans_key_value, S_IRUGO|S_IWUSR,
 433                 manager_trans_key_value_show, manager_trans_key_value_store);
 434 static MANAGER_ATTR(trans_key_enabled, S_IRUGO|S_IWUSR,
 435                 manager_trans_key_enabled_show,
 436                 manager_trans_key_enabled_store);
 437 static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO|S_IWUSR,
 438                 manager_alpha_blending_enabled_show,
 439                 manager_alpha_blending_enabled_store);
 440 static MANAGER_ATTR(cpr_enable, S_IRUGO|S_IWUSR,
 441                 manager_cpr_enable_show,
 442                 manager_cpr_enable_store);
 443 static MANAGER_ATTR(cpr_coef, S_IRUGO|S_IWUSR,
 444                 manager_cpr_coef_show,
 445                 manager_cpr_coef_store);
 446
 447
 448 static struct attribute *manager_sysfs_attrs[] = {
 449         &manager_attr_name.attr,
 450         &manager_attr_display.attr,
 451         &manager_attr_default_color.attr,
 452         &manager_attr_trans_key_type.attr,
 453         &manager_attr_trans_key_value.attr,
 454         &manager_attr_trans_key_enabled.attr,
 455         &manager_attr_alpha_blending_enabled.attr,
 456         &manager_attr_cpr_enable.attr,
 457         &manager_attr_cpr_coef.attr,
 458         NULL
 459 };
 460
 461 static ssize_t manager_attr_show(struct kobject *kobj, struct attribute *attr,
 462                 char *buf)
 463 {
 464         struct omap_overlay_manager *manager;
 465         struct manager_attribute *manager_attr;
 466
 467         manager = container_of(kobj, struct omap_overlay_manager, kobj);
 468         manager_attr = container_of(attr, struct manager_attribute, attr);
 469
 470         if (!manager_attr->show)
 471                 return -ENOENT;
 472
 473         return manager_attr->show(manager, buf);
 474 }
 475
 476 static ssize_t manager_attr_store(struct kobject *kobj, struct attribute *attr,
 477                 const char *buf, size_t size)
 478 {
 479         struct omap_overlay_manager *manager;
 480         struct manager_attribute *manager_attr;
 481
 482         manager = container_of(kobj, struct omap_overlay_manager, kobj);
 483         manager_attr = container_of(attr, struct manager_attribute, attr);
 484
 485         if (!manager_attr->store)
 486                 return -ENOENT;
 487
 488         return manager_attr->store(manager, buf, size);
 489 }
 490
 491 static const struct sysfs_ops manager_sysfs_ops = {
 492         .show = manager_attr_show,
 493         .store = manager_attr_store,
 494 };
 495
 496 static struct kobj_type manager_ktype = {
 497         .sysfs_ops = &manager_sysfs_ops,
 498         .default_attrs = manager_sysfs_attrs,
 499 };
 500
 501 int dss_manager_kobj_init(struct omap_overlay_manager *mgr,
 502                 struct platform_device *pdev)
 503 {
 504         return kobject_init_and_add(&mgr->kobj, &manager_ktype,
 505                         &pdev->dev.kobj, "manager%d", mgr->id);
 506 }
 507
 508 void dss_manager_kobj_uninit(struct omap_overlay_manager *mgr)
 509 {
 510         kobject_del(&mgr->kobj);
 511         kobject_put(&mgr->kobj);
 512 }