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