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

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