drivers/video/rockchip/hdmi/rockchip-hdmi-core.c

   1 #include <linux/delay.h>
   2 #include "rockchip-hdmi.h"
   3 #include "rockchip-hdmi-cec.h"
   4
   5 struct hdmi_delayed_work {
   6         struct delayed_work work;
   7         struct hdmi *hdmi;
   8         int event;
   9         void *data;
  10 };
  11
  12 struct hdmi_id_ref_info {
  13         struct hdmi *hdmi;
  14         int id;
  15         int ref;
  16 } ref_info[HDMI_MAX_ID];
  17
  18 static int uboot_vic;
  19 static void hdmi_work_queue(struct work_struct *work);
  20
  21 struct delayed_work *hdmi_submit_work(struct hdmi *hdmi,
  22                                       int event, int delay, void *data)
  23 {
  24         struct hdmi_delayed_work *work;
  25
  26         DBG("%s event %04x delay %d", __func__, event, delay);
  27
  28         work = kmalloc(sizeof(*work), GFP_ATOMIC);
  29
  30         if (work) {
  31                 INIT_DELAYED_WORK(&work->work, hdmi_work_queue);
  32                 work->hdmi = hdmi;
  33                 work->event = event;
  34                 work->data = data;
  35                 queue_delayed_work(hdmi->workqueue,
  36                                    &work->work,
  37                                    msecs_to_jiffies(delay));
  38         } else {
  39                 pr_warn("HDMI: Cannot allocate memory to create work\n");
  40                 return 0;
  41         }
  42
  43         return &work->work;
  44 }
  45
  46 static void hdmi_send_uevent(struct hdmi *hdmi, int uevent)
  47 {
  48         char *envp[3];
  49
  50         envp[0] = "INTERFACE=HDMI";
  51         envp[1] = kmalloc(32, GFP_KERNEL);
  52         if (envp[1] == NULL)
  53                 return;
  54         sprintf(envp[1], "SCREEN=%d", hdmi->ddev->property);
  55         envp[2] = NULL;
  56         kobject_uevent_env(&hdmi->ddev->dev->kobj, uevent, envp);
  57         kfree(envp[1]);
  58 }
  59
  60 static inline void hdmi_wq_set_output(struct hdmi *hdmi, int mute)
  61 {
  62         DBG("%s mute %d", __func__, mute);
  63         if (hdmi->ops->setmute)
  64                 hdmi->ops->setmute(hdmi, mute);
  65 }
  66
  67 static inline void hdmi_wq_set_audio(struct hdmi *hdmi)
  68 {
  69         DBG("%s", __func__);
  70         if (hdmi->ops->setaudio)
  71                 hdmi->ops->setaudio(hdmi, &hdmi->audio);
  72 }
  73
  74 static void hdmi_wq_set_video(struct hdmi *hdmi)
  75 {
  76         struct hdmi_video       video;
  77         int     deepcolor;
  78
  79         DBG("%s", __func__);
  80
  81         video.vic = hdmi->vic & HDMI_VIC_MASK;
  82         video.sink_hdmi = hdmi->edid.sink_hdmi;
  83         video.format_3d = hdmi->mode_3d;
  84
  85         /* For DVI, output RGB */
  86         if (hdmi->edid.sink_hdmi == 0) {
  87                 video.color_output = HDMI_COLOR_RGB_0_255;
  88         } else {
  89                 if (hdmi->colormode == HDMI_COLOR_AUTO) {
  90                         if (hdmi->edid.ycbcr444)
  91                                 video.color_output = HDMI_COLOR_YCBCR444;
  92                         else if (hdmi->edid.ycbcr422)
  93                                 video.color_output = HDMI_COLOR_YCBCR422;
  94                         else
  95                                 video.color_output = HDMI_COLOR_RGB_16_235;
  96                 } else {
  97                         video.color_output = hdmi->colormode;
  98                 }
  99         }
 100         if (hdmi->vic & HDMI_VIDEO_YUV420) {
 101                 video.color_output = HDMI_COLOR_YCBCR420;
 102                 deepcolor = hdmi->edid.deepcolor_420;
 103         } else {
 104                 deepcolor = hdmi->edid.deepcolor;
 105         }
 106         if ((hdmi->property->feature & SUPPORT_DEEP_10BIT) &&
 107             (deepcolor & HDMI_DEEP_COLOR_30BITS)) {
 108                 if (hdmi->colordepth == HDMI_DEPP_COLOR_AUTO ||
 109                     hdmi->colordepth == 10)
 110                         video.color_output_depth = 10;
 111         } else {
 112                 video.color_output_depth = 8;
 113         }
 114
 115         pr_info("hdmi output corlor mode is %d\n", video.color_output);
 116         video.color_input = HDMI_COLOR_RGB_0_255;
 117         if (hdmi->property->feature & SUPPORT_YCBCR_INPUT) {
 118                 if (video.color_output == HDMI_COLOR_YCBCR444 ||
 119                     video.color_output == HDMI_COLOR_YCBCR422)
 120                         video.color_input = HDMI_COLOR_YCBCR444;
 121                 else if (video.color_output == HDMI_COLOR_YCBCR420)
 122                         video.color_input = HDMI_COLOR_YCBCR420;
 123         }
 124         hdmi->colormode_input = video.color_input;
 125         hdmi_set_lcdc(hdmi);
 126         if (hdmi->ops->setvideo)
 127                 hdmi->ops->setvideo(hdmi, &video);
 128 }
 129
 130 static void hdmi_wq_parse_edid(struct hdmi *hdmi)
 131 {
 132         struct hdmi_edid *pedid;
 133
 134         int rc = HDMI_ERROR_SUCESS, extendblock = 0, i, trytimes;
 135
 136         if (hdmi == NULL)
 137                 return;
 138
 139         DBG("%s", __func__);
 140
 141         pedid = &(hdmi->edid);
 142         fb_destroy_modelist(&pedid->modelist);
 143         memset(pedid, 0, sizeof(struct hdmi_edid));
 144         INIT_LIST_HEAD(&pedid->modelist);
 145
 146         pedid->raw[0] = kmalloc(HDMI_EDID_BLOCK_SIZE, GFP_KERNEL);
 147         if (pedid->raw[0] == NULL) {
 148                 dev_err(hdmi->dev,
 149                         "[%s] can not allocate memory for edid buff.\n",
 150                         __func__);
 151                 rc = HDMI_ERROR_FALSE;
 152                 goto out;
 153         }
 154
 155         if (hdmi->ops->getedid == NULL) {
 156                 rc = HDMI_ERROR_FALSE;
 157                 goto out;
 158         }
 159
 160         /* Read base block edid.*/
 161         for (trytimes = 0; trytimes < 3; trytimes++) {
 162                 if (trytimes)
 163                         msleep(50);
 164                 memset(pedid->raw[0], 0 , HDMI_EDID_BLOCK_SIZE);
 165                 rc = hdmi->ops->getedid(hdmi, 0, pedid->raw[0]);
 166                 if (rc) {
 167                         dev_err(hdmi->dev,
 168                                 "[HDMI] read edid base block error\n");
 169                         continue;
 170                 }
 171
 172                 rc = hdmi_edid_parse_base(pedid->raw[0], &extendblock, pedid);
 173                 if (rc) {
 174                         dev_err(hdmi->dev,
 175                                 "[HDMI] parse edid base block error\n");
 176                         continue;
 177                 }
 178                 if (!rc)
 179                         break;
 180         }
 181         if (rc)
 182                 goto out;
 183
 184         for (i = 1; (i < extendblock + 1) && (i < HDMI_MAX_EDID_BLOCK); i++) {
 185                 pedid->raw[i] = kmalloc(HDMI_EDID_BLOCK_SIZE, GFP_KERNEL);
 186                 if (pedid->raw[i] == NULL) {
 187                         dev_err(hdmi->dev,
 188                                 "[%s] can not allocate memory for edid buff.\n",
 189                                 __func__);
 190                         rc = HDMI_ERROR_FALSE;
 191                         goto out;
 192                 }
 193                 for (trytimes = 0; trytimes < 3; trytimes++) {
 194                         if (trytimes)
 195                                 msleep(20);
 196                         memset(pedid->raw[i], 0 , HDMI_EDID_BLOCK_SIZE);
 197                         rc = hdmi->ops->getedid(hdmi, i, pedid->raw[i]);
 198                         if (rc) {
 199                                 dev_err(hdmi->dev,
 200                                         "[HDMI] read edid block %d error\n",
 201                                         i);
 202                                 continue;
 203                         }
 204
 205                         rc = hdmi_edid_parse_extensions(pedid->raw[i], pedid);
 206                         if (rc) {
 207                                 dev_err(hdmi->dev,
 208                                         "[HDMI] parse edid block %d error\n",
 209                                         i);
 210                                 continue;
 211                         }
 212
 213                         if (!rc)
 214                                 break;
 215                 }
 216         }
 217 out:
 218         rc = hdmi_ouputmode_select(hdmi, rc);
 219 }
 220
 221 static void hdmi_wq_insert(struct hdmi *hdmi)
 222 {
 223         DBG("%s", __func__);
 224         if (hdmi->ops->insert)
 225                 hdmi->ops->insert(hdmi);
 226         hdmi_wq_parse_edid(hdmi);
 227         if (hdmi->property->feature & SUPPORT_CEC)
 228                 rockchip_hdmi_cec_set_pa(hdmi->edid.cecaddress);
 229         hdmi_send_uevent(hdmi, KOBJ_ADD);
 230         if (hdmi->enable) {
 231                 /*hdmi->autoset = 0;*/
 232                 hdmi_wq_set_video(hdmi);
 233                 #ifdef CONFIG_SWITCH
 234                 switch_set_state(&(hdmi->switchdev), 1);
 235                 #endif
 236                 hdmi_wq_set_audio(hdmi);
 237                 hdmi_wq_set_output(hdmi, hdmi->mute);
 238                 if (hdmi->ops->hdcp_cb)
 239                         hdmi->ops->hdcp_cb(hdmi);
 240                 if (hdmi->ops->setcec)
 241                         hdmi->ops->setcec(hdmi);
 242         }
 243         if (hdmi->uboot)
 244                 hdmi->uboot = 0;
 245 }
 246
 247 static void hdmi_wq_remove(struct hdmi *hdmi)
 248 {
 249         struct list_head *pos, *n;
 250         struct rk_screen screen;
 251         int i;
 252
 253         DBG("%s", __func__);
 254         if (hdmi->ops->remove)
 255                 hdmi->ops->remove(hdmi);
 256         if (hdmi->hotplug == HDMI_HPD_ACTIVED) {
 257                 screen.type = SCREEN_HDMI;
 258                 rk_fb_switch_screen(&screen, 0, hdmi->lcdc->id);
 259         }
 260         #ifdef CONFIG_SWITCH
 261         switch_set_state(&(hdmi->switchdev), 0);
 262         #endif
 263         mutex_lock(&hdmi->ddev->lock);
 264         list_for_each_safe(pos, n, &hdmi->edid.modelist) {
 265                 list_del(pos);
 266                 kfree(pos);
 267         }
 268         mutex_unlock(&hdmi->ddev->lock);
 269         for (i = 0; i < HDMI_MAX_EDID_BLOCK; i++)
 270                 kfree(hdmi->edid.raw[i]);
 271         kfree(hdmi->edid.audio);
 272         if (hdmi->edid.specs) {
 273                 kfree(hdmi->edid.specs->modedb);
 274                 kfree(hdmi->edid.specs);
 275         }
 276         memset(&hdmi->edid, 0, sizeof(struct hdmi_edid));
 277         hdmi_init_modelist(hdmi);
 278         hdmi->mute      = HDMI_AV_UNMUTE;
 279         hdmi->mode_3d = HDMI_3D_NONE;
 280         hdmi->uboot = 0;
 281         hdmi->hotplug = HDMI_HPD_REMOVED;
 282         hdmi_send_uevent(hdmi, KOBJ_REMOVE);
 283 }
 284
 285 static void hdmi_work_queue(struct work_struct *work)
 286 {
 287         struct hdmi_delayed_work *hdmi_w =
 288                 container_of(work, struct hdmi_delayed_work, work.work);
 289         struct hdmi *hdmi = hdmi_w->hdmi;
 290         int event = hdmi_w->event;
 291         int hpd = HDMI_HPD_REMOVED;
 292
 293         mutex_lock(&hdmi->lock);
 294
 295         DBG("\nhdmi_work_queue() - evt= %x %d\n",
 296             (event & 0xFF00) >> 8,
 297             event & 0xFF);
 298
 299         switch (event) {
 300         case HDMI_ENABLE_CTL:
 301                 if (!hdmi->enable) {
 302                         hdmi->enable = 1;
 303                         if (!hdmi->sleep) {
 304                                 if (hdmi->ops->enable)
 305                                         hdmi->ops->enable(hdmi);
 306                                 if (hdmi->hotplug == HDMI_HPD_ACTIVED)
 307                                         hdmi_wq_insert(hdmi);
 308                         }
 309                 }
 310                 break;
 311         case HDMI_RESUME_CTL:
 312                 if (hdmi->sleep) {
 313                         if (hdmi->ops->enable)
 314                                 hdmi->ops->enable(hdmi);
 315                         hdmi->sleep = 0;
 316                 }
 317                 break;
 318         case HDMI_DISABLE_CTL:
 319                 if (hdmi->enable) {
 320                         if (!hdmi->sleep) {
 321                                 if (hdmi->ops->disable)
 322                                         hdmi->ops->disable(hdmi);
 323                                 hdmi_wq_remove(hdmi);
 324                         }
 325                         hdmi->enable = 0;
 326                 }
 327                 break;
 328         case HDMI_SUSPEND_CTL:
 329                 if (!hdmi->sleep) {
 330                         hdmi_wq_set_output(hdmi,
 331                                            HDMI_VIDEO_MUTE | HDMI_AUDIO_MUTE);
 332                         if (hdmi->ops->disable)
 333                                 hdmi->ops->disable(hdmi);
 334                         if (hdmi->enable)
 335                                 hdmi_wq_remove(hdmi);
 336                         hdmi->sleep = 1;
 337                 }
 338                 break;
 339         case HDMI_HPD_CHANGE:
 340                 if (hdmi->ops->getstatus)
 341                         hpd = hdmi->ops->getstatus(hdmi);
 342                 DBG("hdmi_work_queue() - hpd is %d hotplug is %d",
 343                     hpd, hdmi->hotplug);
 344                 if (hpd != hdmi->hotplug) {
 345                         if (hpd == HDMI_HPD_ACTIVED) {
 346                                 hdmi->hotplug = hpd;
 347                                 hdmi_wq_insert(hdmi);
 348                         } else if (hdmi->hotplug == HDMI_HPD_ACTIVED) {
 349                                 hdmi_wq_remove(hdmi);
 350                         }
 351                         hdmi->hotplug = hpd;
 352                 }
 353                 break;
 354         case HDMI_SET_VIDEO:
 355                 if (hdmi->enable && !hdmi->sleep) {
 356                         hdmi_wq_set_output(hdmi,
 357                                            HDMI_VIDEO_MUTE | HDMI_AUDIO_MUTE);
 358                         if (rk_fb_get_display_policy() == DISPLAY_POLICY_BOX)
 359                                 msleep(2000);
 360                         else
 361                                 msleep(1000);
 362                         hdmi_wq_set_video(hdmi);
 363                         hdmi_send_uevent(hdmi, KOBJ_CHANGE);
 364                         hdmi_wq_set_audio(hdmi);
 365                         hdmi_wq_set_output(hdmi, hdmi->mute);
 366                         if (hdmi->ops->hdcp_cb)
 367                                 hdmi->ops->hdcp_cb(hdmi);
 368                 }
 369                 break;
 370         case HDMI_SET_AUDIO:
 371                 if ((hdmi->mute & HDMI_AUDIO_MUTE) == 0 &&
 372                     hdmi->enable && !hdmi->sleep) {
 373                         hdmi_wq_set_output(hdmi, HDMI_AUDIO_MUTE);
 374                         hdmi_wq_set_audio(hdmi);
 375                         hdmi_wq_set_output(hdmi, hdmi->mute);
 376                 }
 377                 break;
 378         case HDMI_MUTE_AUDIO:
 379         case HDMI_UNMUTE_AUDIO:
 380                 if (hdmi->mute & HDMI_AUDIO_MUTE ||
 381                     !hdmi->enable || hdmi->sleep ||
 382                     hdmi->hotplug != HDMI_HPD_ACTIVED)
 383                         break;
 384                 if (event == HDMI_MUTE_AUDIO)
 385                         hdmi_wq_set_output(hdmi, hdmi->mute |
 386                                            HDMI_AUDIO_MUTE);
 387                 else
 388                         hdmi_wq_set_output(hdmi,
 389                                            hdmi->mute & (~HDMI_AUDIO_MUTE));
 390                 break;
 391         case HDMI_SET_3D:
 392                 if (hdmi->ops->setvsi) {
 393                         if (hdmi->mode_3d != HDMI_3D_NONE)
 394                                 hdmi->ops->setvsi(hdmi, hdmi->mode_3d,
 395                                                   HDMI_VIDEO_FORMAT_3D);
 396                         else if ((hdmi->vic & HDMI_TYPE_MASK) == 0)
 397                                 hdmi->ops->setvsi(hdmi, hdmi->vic,
 398                                                   HDMI_VIDEO_FORMAT_NORMAL);
 399                 }
 400                 break;
 401         case HDMI_SET_COLOR:
 402                 hdmi_wq_set_output(hdmi,
 403                                    HDMI_VIDEO_MUTE | HDMI_AUDIO_MUTE);
 404                 msleep(100);
 405                 hdmi_wq_set_video(hdmi);
 406                 hdmi_wq_set_output(hdmi, hdmi->mute);
 407                 break;
 408         case HDMI_ENABLE_HDCP:
 409                 if (hdmi->hotplug == HDMI_HPD_ACTIVED && hdmi->ops->hdcp_cb)
 410                         hdmi->ops->hdcp_cb(hdmi);
 411                 break;
 412         default:
 413                 pr_err("HDMI: hdmi_work_queue() unkown event\n");
 414                 break;
 415         }
 416
 417         kfree(hdmi_w->data);
 418         kfree(hdmi_w);
 419
 420         DBG("\nhdmi_work_queue() - exit evt= %x %d\n",
 421             (event & 0xFF00) >> 8,
 422             event & 0xFF);
 423         mutex_unlock(&hdmi->lock);
 424 }
 425
 426 struct hdmi *rockchip_hdmi_register(struct hdmi_property *property,
 427                                     struct hdmi_ops *ops)
 428 {
 429         struct hdmi *hdmi;
 430         char name[32];
 431         int i;
 432
 433         if (property == NULL || ops == NULL) {
 434                 pr_err("HDMI: %s invalid parameter\n", __func__);
 435                 return NULL;
 436         }
 437
 438         for (i = 0; i < HDMI_MAX_ID; i++) {
 439                 if (ref_info[i].ref == 0)
 440                         break;
 441         }
 442         if (i == HDMI_MAX_ID)
 443                 return NULL;
 444
 445         DBG("hdmi_register() - video source %d display %d",
 446             property->videosrc,  property->display);
 447
 448         hdmi = kmalloc(sizeof(*hdmi), GFP_KERNEL);
 449         if (!hdmi) {
 450                 pr_err("HDMI: no memory to allocate hdmi device.\n");
 451                 return NULL;
 452         }
 453         memset(hdmi, 0, sizeof(struct hdmi));
 454         mutex_init(&hdmi->lock);
 455
 456         hdmi->property = property;
 457         hdmi->ops = ops;
 458         hdmi->enable = false;
 459         hdmi->mute = HDMI_AV_UNMUTE;
 460         hdmi->hotplug = HDMI_HPD_REMOVED;
 461         hdmi->autoset = HDMI_AUTO_CONFIG;
 462         if (uboot_vic > 0) {
 463                 hdmi->vic = uboot_vic;
 464                 hdmi->uboot = 1;
 465                 hdmi->autoset = 0;
 466         } else if (hdmi->autoset) {
 467                 hdmi->vic = 0;
 468         } else {
 469                 hdmi->vic = hdmi->property->defaultmode;
 470         }
 471         hdmi->colormode = HDMI_VIDEO_DEFAULT_COLORMODE;
 472         hdmi->colordepth = HDMI_DEPP_COLOR_AUTO;
 473         hdmi->mode_3d = HDMI_3D_NONE;
 474         hdmi->audio.type = HDMI_AUDIO_DEFAULT_TYPE;
 475         hdmi->audio.channel = HDMI_AUDIO_DEFAULT_CHANNEL;
 476         hdmi->audio.rate = HDMI_AUDIO_DEFAULT_RATE;
 477         hdmi->audio.word_length = HDMI_AUDIO_DEFAULT_WORDLENGTH;
 478         hdmi->xscale = 100;
 479         hdmi->yscale = 100;
 480         hdmi_init_modelist(hdmi);
 481
 482         if (hdmi->property->videosrc == DISPLAY_SOURCE_LCDC0)
 483                 hdmi->lcdc = rk_get_lcdc_drv("lcdc0");
 484         else
 485                 hdmi->lcdc = rk_get_lcdc_drv("lcdc1");
 486
 487         if (hdmi->lcdc->prop == EXTEND)
 488                 hdmi->property->display = DISPLAY_AUX;
 489         else
 490                 hdmi->property->display = DISPLAY_MAIN;
 491         memset(name, 0, 32);
 492         sprintf(name, "hdmi-%s", hdmi->property->name);
 493         hdmi->workqueue = create_singlethread_workqueue(name);
 494         if (hdmi->workqueue == NULL) {
 495                 pr_err("HDMI,: create workqueue failed.\n");
 496                 goto err_create_wq;
 497         }
 498         hdmi->ddev = hdmi_register_display_sysfs(hdmi, NULL);
 499         if (hdmi->ddev == NULL) {
 500                 pr_err("HDMI : register display sysfs failed.\n");
 501                 goto err_register_display;
 502         }
 503         hdmi->id = i;
 504         #ifdef CONFIG_SWITCH
 505         if (hdmi->id == 0) {
 506                 hdmi->switchdev.name = "hdmi";
 507         } else {
 508                 hdmi->switchdev.name = kzalloc(32, GFP_KERNEL);
 509                 memset((char *)hdmi->switchdev.name, 0, 32);
 510                 sprintf((char *)hdmi->switchdev.name, "hdmi%d", hdmi->id);
 511         }
 512         switch_dev_register(&(hdmi->switchdev));
 513         #endif
 514
 515         ref_info[i].hdmi = hdmi;
 516         ref_info[i].ref = 1;
 517         return hdmi;
 518
 519 err_register_display:
 520         destroy_workqueue(hdmi->workqueue);
 521 err_create_wq:
 522         kfree(hdmi);
 523         return NULL;
 524 }
 525
 526 void rockchip_hdmi_unregister(struct hdmi *hdmi)
 527 {
 528         if (hdmi) {
 529                 flush_workqueue(hdmi->workqueue);
 530                 destroy_workqueue(hdmi->workqueue);
 531                 #ifdef CONFIG_SWITCH
 532                 switch_dev_unregister(&(hdmi->switchdev));
 533                 #endif
 534                 hdmi_unregister_display_sysfs(hdmi);
 535                 fb_destroy_modelist(&hdmi->edid.modelist);
 536                 kfree(hdmi->edid.audio);
 537                 if (hdmi->edid.specs) {
 538                         kfree(hdmi->edid.specs->modedb);
 539                         kfree(hdmi->edid.specs);
 540                 }
 541                 kfree(hdmi);
 542
 543                 ref_info[hdmi->id].ref = 0;
 544                 ref_info[hdmi->id].hdmi = NULL;
 545
 546                 hdmi = NULL;
 547         }
 548 }
 549
 550 int hdmi_get_hotplug(void)
 551 {
 552         if (ref_info[0].hdmi)
 553                 return ref_info[0].hdmi->hotplug;
 554         else
 555                 return HDMI_HPD_REMOVED;
 556 }
 557
 558 int hdmi_config_audio(struct hdmi_audio *audio)
 559 {
 560         int i;
 561         struct hdmi *hdmi;
 562
 563         if (audio == NULL)
 564                 return HDMI_ERROR_FALSE;
 565
 566         for (i = 0; i < HDMI_MAX_ID; i++) {
 567                 if (ref_info[i].ref == 0)
 568                         continue;
 569                 hdmi = ref_info[i].hdmi;
 570
 571                 /*
 572                 if (memcmp(audio, &hdmi->audio, sizeof(struct hdmi_audio)) == 0)
 573                         continue;
 574                 */
 575                 /*for (j = 0; j < hdmi->edid.audio_num; j++) {
 576                         if (audio->type == hdmi->edid.audio_num)
 577                                 break;
 578                 }*/
 579
 580                 /*if ( (j == hdmi->edid.audio_num) ||
 581                         (audio->channel > hdmi->edid.audio[j].channel) ||
 582                         ((audio->rate & hdmi->edid.audio[j].rate) == 0)||
 583                         ((audio->type == HDMI_AUDIO_LPCM) &&
 584                         ((audio->word_length &
 585                           hdmi->edid.audio[j].word_length) == 0)) ) {
 586                         pr_warn("[%s] warning : input audio type
 587                                 not supported in hdmi sink\n", __func__);
 588                         continue;
 589                 }*/
 590                 memcpy(&hdmi->audio, audio, sizeof(struct hdmi_audio));
 591                 if (hdmi->hotplug == HDMI_HPD_ACTIVED)
 592                         hdmi_submit_work(hdmi, HDMI_SET_AUDIO, 0, NULL);
 593         }
 594         return 0;
 595 }
 596
 597 void hdmi_audio_mute(int mute)
 598 {
 599         int i;
 600         struct hdmi *hdmi;
 601
 602         for (i = 0; i < HDMI_MAX_ID; i++) {
 603                 if (ref_info[i].ref == 0)
 604                         continue;
 605                 hdmi = ref_info[i].hdmi;
 606
 607                 if (mute)
 608                         hdmi_submit_work(hdmi, HDMI_MUTE_AUDIO, 0, NULL);
 609                 else
 610                         hdmi_submit_work(hdmi, HDMI_UNMUTE_AUDIO, 0, NULL);
 611         }
 612 }
 613
 614 static int __init bootloader_setup(char *str)
 615 {
 616         if (str) {
 617                 pr_info("hdmi init vic is %s\n", str);
 618                 if (kstrtoint(str, 0, &uboot_vic) < 0)
 619                         uboot_vic = 0;
 620         }
 621         return 0;
 622 }
 623
 624 early_param("hdmi.vic", bootloader_setup);
 625
 626 static int __init hdmi_class_init(void)
 627 {
 628         int i;
 629
 630         for (i = 0; i < HDMI_MAX_ID; i++) {
 631                 ref_info[i].id = i;
 632                 ref_info[i].ref = 0;
 633                 ref_info[i].hdmi = NULL;
 634         }
 635         pr_info("Rockchip hdmi driver version 2.0\n.");
 636         return 0;
 637 }
 638
 639 subsys_initcall(hdmi_class_init);