drivers/staging/gma500/mdfld_dsi_pkg_sender.c

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  * Jackie Li<yaodong.li@intel.com>
  25  */
  26
  27 #include <linux/freezer.h>
  28
  29 #include "mdfld_dsi_output.h"
  30 #include "mdfld_dsi_pkg_sender.h"
  31 #include "mdfld_dsi_dbi.h"
  32
  33 #define MDFLD_DSI_DBI_FIFO_TIMEOUT      100
  34
  35 static const char * const dsi_errors[] = {
  36         "RX SOT Error",
  37         "RX SOT Sync Error",
  38         "RX EOT Sync Error",
  39         "RX Escape Mode Entry Error",
  40         "RX LP TX Sync Error",
  41         "RX HS Receive Timeout Error",
  42         "RX False Control Error",
  43         "RX ECC Single Bit Error",
  44         "RX ECC Multibit Error",
  45         "RX Checksum Error",
  46         "RX DSI Data Type Not Recognised",
  47         "RX DSI VC ID Invalid",
  48         "TX False Control Error",
  49         "TX ECC Single Bit Error",
  50         "TX ECC Multibit Error",
  51         "TX Checksum Error",
  52         "TX DSI Data Type Not Recognised",
  53         "TX DSI VC ID invalid",
  54         "High Contention",
  55         "Low contention",
  56         "DPI FIFO Under run",
  57         "HS TX Timeout",
  58         "LP RX Timeout",
  59         "Turn Around ACK Timeout",
  60         "ACK With No Error",
  61         "RX Invalid TX Length",
  62         "RX Prot Violation",
  63         "HS Generic Write FIFO Full",
  64         "LP Generic Write FIFO Full",
  65         "Generic Read Data Avail",
  66         "Special Packet Sent",
  67         "Tearing Effect",
  68 };
  69
  70 static int wait_for_gen_fifo_empty(struct mdfld_dsi_pkg_sender *sender,
  71                                                                 u32 mask)
  72 {
  73         struct drm_device *dev = sender->dev;
  74         u32 gen_fifo_stat_reg = sender->mipi_gen_fifo_stat_reg;
  75         int retry = 0xffff;
  76
  77         while (retry--) {
  78                 if ((mask & REG_READ(gen_fifo_stat_reg)) == mask)
  79                         return 0;
  80                 udelay(100);
  81         }
  82         dev_err(dev->dev, "fifo is NOT empty 0x%08x\n",
  83                                         REG_READ(gen_fifo_stat_reg));
  84         return -EIO;
  85 }
  86
  87 static int wait_for_all_fifos_empty(struct mdfld_dsi_pkg_sender *sender)
  88 {
  89         return wait_for_gen_fifo_empty(sender, (1 << 2) | (1 << 10) | (1 << 18)
  90                 | (1 << 26) | (1 << 27) | (1 << 28));
  91 }
  92
  93 static int wait_for_lp_fifos_empty(struct mdfld_dsi_pkg_sender *sender)
  94 {
  95         return wait_for_gen_fifo_empty(sender, (1 << 10) | (1 << 26));
  96 }
  97
  98 static int wait_for_hs_fifos_empty(struct mdfld_dsi_pkg_sender *sender)
  99 {
 100         return wait_for_gen_fifo_empty(sender, (1 << 2) | (1 << 18));
 101 }
 102
 103 static int wait_for_dbi_fifo_empty(struct mdfld_dsi_pkg_sender *sender)
 104 {
 105         return wait_for_gen_fifo_empty(sender, (1 << 27));
 106 }
 107
 108 static int handle_dsi_error(struct mdfld_dsi_pkg_sender *sender, u32 mask)
 109 {
 110         u32 intr_stat_reg = sender->mipi_intr_stat_reg;
 111         struct drm_device *dev = sender->dev;
 112
 113         switch (mask) {
 114         case (1 << 0):
 115         case (1 << 1):
 116         case (1 << 2):
 117         case (1 << 3):
 118         case (1 << 4):
 119         case (1 << 5):
 120         case (1 << 6):
 121         case (1 << 7):
 122         case (1 << 8):
 123         case (1 << 9):
 124         case (1 << 10):
 125         case (1 << 11):
 126         case (1 << 12):
 127         case (1 << 13):
 128                 break;
 129         case (1 << 14):
 130                 /*wait for all fifo empty*/
 131                 /*wait_for_all_fifos_empty(sender)*/;
 132                 break;
 133         case (1 << 15):
 134                 break;
 135         case (1 << 16):
 136                 break;
 137         case (1 << 17):
 138                 break;
 139         case (1 << 18):
 140         case (1 << 19):
 141                 /*wait for contention recovery time*/
 142                 /*mdelay(10);*/
 143                 /*wait for all fifo empty*/
 144                 if (0)
 145                         wait_for_all_fifos_empty(sender);
 146                 break;
 147         case (1 << 20):
 148                 break;
 149         case (1 << 21):
 150                 /*wait for all fifo empty*/
 151                 /*wait_for_all_fifos_empty(sender);*/
 152                 break;
 153         case (1 << 22):
 154                 break;
 155         case (1 << 23):
 156         case (1 << 24):
 157         case (1 << 25):
 158         case (1 << 26):
 159         case (1 << 27):
 160                 /* HS Gen fifo full */
 161                 REG_WRITE(intr_stat_reg, mask);
 162                 wait_for_hs_fifos_empty(sender);
 163                 break;
 164         case (1 << 28):
 165                 /* LP Gen fifo full\n */
 166                 REG_WRITE(intr_stat_reg, mask);
 167                 wait_for_lp_fifos_empty(sender);
 168                 break;
 169         case (1 << 29):
 170         case (1 << 30):
 171         case (1 << 31):
 172                 break;
 173         }
 174
 175         if (mask & REG_READ(intr_stat_reg))
 176                 dev_warn(dev->dev, "Cannot clean interrupt 0x%08x\n", mask);
 177
 178         return 0;
 179 }
 180
 181 static int dsi_error_handler(struct mdfld_dsi_pkg_sender *sender)
 182 {
 183         struct drm_device *dev = sender->dev;
 184         u32 intr_stat_reg = sender->mipi_intr_stat_reg;
 185         u32 mask;
 186         u32 intr_stat;
 187         int i;
 188         int err = 0;
 189
 190         intr_stat = REG_READ(intr_stat_reg);
 191
 192         for (i = 0; i < 32; i++) {
 193                 mask = (0x00000001UL) << i;
 194                 if (intr_stat & mask) {
 195                         dev_dbg(dev->dev, "[DSI]: %s\n", dsi_errors[i]);
 196                         err = handle_dsi_error(sender, mask);
 197                         if (err)
 198                                 dev_err(dev->dev, "Cannot handle error\n");
 199                 }
 200         }
 201         return err;
 202 }
 203
 204 static inline int dbi_cmd_sent(struct mdfld_dsi_pkg_sender *sender)
 205 {
 206         struct drm_device *dev = sender->dev;
 207         u32 retry = 0xffff;
 208         u32 dbi_cmd_addr_reg = sender->mipi_cmd_addr_reg;
 209
 210         /* Query the command execution status */
 211         while (retry--) {
 212                 if (!(REG_READ(dbi_cmd_addr_reg) & (1 << 0)))
 213                         break;
 214         }
 215
 216         if (!retry) {
 217                 dev_err(dev->dev, "Timeout waiting for DBI Command status\n");
 218                 return -EAGAIN;
 219         }
 220         return 0;
 221 }
 222
 223 /*
 224  * NOTE: this interface is abandoned expect for write_mem_start DCS
 225  * other DCS are sent via generic pkg interfaces
 226  */
 227 static int send_dcs_pkg(struct mdfld_dsi_pkg_sender *sender,
 228                         struct mdfld_dsi_pkg *pkg)
 229 {
 230         struct drm_device *dev = sender->dev;
 231         struct mdfld_dsi_dcs_pkg *dcs_pkg = &pkg->pkg.dcs_pkg;
 232         u32 dbi_cmd_len_reg = sender->mipi_cmd_len_reg;
 233         u32 dbi_cmd_addr_reg = sender->mipi_cmd_addr_reg;
 234         u32 cb_phy = sender->dbi_cb_phy;
 235         u32 index = 0;
 236         u8 *cb = (u8 *)sender->dbi_cb_addr;
 237         int i;
 238         int ret;
 239
 240         if (!sender->dbi_pkg_support) {
 241                 dev_err(dev->dev, "Trying to send DCS on a non DBI output, abort!\n");
 242                 return -ENOTSUPP;
 243         }
 244
 245         /*wait for DBI fifo empty*/
 246         wait_for_dbi_fifo_empty(sender);
 247
 248         *(cb + (index++)) = dcs_pkg->cmd;
 249         if (dcs_pkg->param_num) {
 250                 for (i = 0; i < dcs_pkg->param_num; i++)
 251                         *(cb + (index++)) = *(dcs_pkg->param + i);
 252         }
 253
 254         REG_WRITE(dbi_cmd_len_reg, (1 + dcs_pkg->param_num));
 255         REG_WRITE(dbi_cmd_addr_reg,
 256                 (cb_phy << CMD_MEM_ADDR_OFFSET)
 257                 | (1 << 0)
 258                 | ((dcs_pkg->data_src == CMD_DATA_SRC_PIPE) ? (1 << 1) : 0));
 259
 260         ret = dbi_cmd_sent(sender);
 261         if (ret) {
 262                 dev_err(dev->dev, "command 0x%x not complete\n", dcs_pkg->cmd);
 263                 return -EAGAIN;
 264         }
 265         return 0;
 266 }
 267
 268 static int __send_short_pkg(struct mdfld_dsi_pkg_sender *sender,
 269                                 struct mdfld_dsi_pkg *pkg)
 270 {
 271         struct drm_device *dev = sender->dev;
 272         u32 hs_gen_ctrl_reg = sender->mipi_hs_gen_ctrl_reg;
 273         u32 lp_gen_ctrl_reg = sender->mipi_lp_gen_ctrl_reg;
 274         u32 gen_ctrl_val = 0;
 275         struct mdfld_dsi_gen_short_pkg *short_pkg = &pkg->pkg.short_pkg;
 276
 277         gen_ctrl_val |= short_pkg->cmd << MCS_COMMANDS_POS;
 278         gen_ctrl_val |= 0 << DCS_CHANNEL_NUMBER_POS;
 279         gen_ctrl_val |= pkg->pkg_type;
 280         gen_ctrl_val |= short_pkg->param << MCS_PARAMETER_POS;
 281
 282         if (pkg->transmission_type == MDFLD_DSI_HS_TRANSMISSION) {
 283                 /* wait for hs fifo empty */
 284                 /* wait_for_hs_fifos_empty(sender); */
 285                 /* Send pkg */
 286                 REG_WRITE(hs_gen_ctrl_reg, gen_ctrl_val);
 287         } else if (pkg->transmission_type == MDFLD_DSI_LP_TRANSMISSION) {
 288                 /* wait_for_lp_fifos_empty(sender); */
 289                 /* Send pkg*/
 290                 REG_WRITE(lp_gen_ctrl_reg, gen_ctrl_val);
 291         } else {
 292                 dev_err(dev->dev, "Unknown transmission type %d\n",
 293                                                         pkg->transmission_type);
 294                 return -EINVAL;
 295         }
 296
 297         return 0;
 298 }
 299
 300 static int __send_long_pkg(struct mdfld_dsi_pkg_sender *sender,
 301                                 struct mdfld_dsi_pkg *pkg)
 302 {
 303         struct drm_device *dev = sender->dev;
 304         u32 hs_gen_ctrl_reg = sender->mipi_hs_gen_ctrl_reg;
 305         u32 hs_gen_data_reg = sender->mipi_hs_gen_data_reg;
 306         u32 lp_gen_ctrl_reg = sender->mipi_lp_gen_ctrl_reg;
 307         u32 lp_gen_data_reg = sender->mipi_lp_gen_data_reg;
 308         u32 gen_ctrl_val = 0;
 309         u32 *dp;
 310         int i;
 311         struct mdfld_dsi_gen_long_pkg *long_pkg = &pkg->pkg.long_pkg;
 312
 313         dp = long_pkg->data;
 314
 315         /*
 316          * Set up word count for long pkg
 317          * FIXME: double check word count field.
 318          * currently, using the byte counts of the payload as the word count.
 319          * ------------------------------------------------------------
 320          * | DI |   WC   | ECC|         PAYLOAD              |CHECKSUM|
 321          * ------------------------------------------------------------
 322          */
 323         gen_ctrl_val |= (long_pkg->len << 2) << WORD_COUNTS_POS;
 324         gen_ctrl_val |= 0 << DCS_CHANNEL_NUMBER_POS;
 325         gen_ctrl_val |= pkg->pkg_type;
 326
 327         if (pkg->transmission_type == MDFLD_DSI_HS_TRANSMISSION) {
 328                 /* Wait for hs ctrl and data fifos to be empty */
 329                 /* wait_for_hs_fifos_empty(sender); */
 330                 for (i = 0; i < long_pkg->len; i++)
 331                         REG_WRITE(hs_gen_data_reg, *(dp + i));
 332                 REG_WRITE(hs_gen_ctrl_reg, gen_ctrl_val);
 333         } else if (pkg->transmission_type == MDFLD_DSI_LP_TRANSMISSION) {
 334                 /* wait_for_lp_fifos_empty(sender); */
 335                 for (i = 0; i < long_pkg->len; i++)
 336                         REG_WRITE(lp_gen_data_reg, *(dp + i));
 337                 REG_WRITE(lp_gen_ctrl_reg, gen_ctrl_val);
 338         } else {
 339                 dev_err(dev->dev, "Unknown transmission type %d\n",
 340                                                 pkg->transmission_type);
 341                 return -EINVAL;
 342         }
 343
 344         return 0;
 345
 346 }
 347
 348 static int send_mcs_short_pkg(struct mdfld_dsi_pkg_sender *sender,
 349                                 struct mdfld_dsi_pkg *pkg)
 350 {
 351         return __send_short_pkg(sender, pkg);
 352 }
 353
 354 static int send_mcs_long_pkg(struct mdfld_dsi_pkg_sender *sender,
 355                                 struct mdfld_dsi_pkg *pkg)
 356 {
 357         return __send_long_pkg(sender, pkg);
 358 }
 359
 360 static int send_gen_short_pkg(struct mdfld_dsi_pkg_sender *sender,
 361                                 struct mdfld_dsi_pkg *pkg)
 362 {
 363         return __send_short_pkg(sender, pkg);
 364 }
 365
 366 static int send_gen_long_pkg(struct mdfld_dsi_pkg_sender *sender,
 367                                 struct mdfld_dsi_pkg *pkg)
 368 {
 369         return __send_long_pkg(sender, pkg);
 370 }
 371
 372 static int send_pkg_prepare(struct mdfld_dsi_pkg_sender *sender,
 373                                 struct mdfld_dsi_pkg *pkg)
 374 {
 375         u8 cmd;
 376         u8 *data;
 377
 378         switch (pkg->pkg_type) {
 379         case MDFLD_DSI_PKG_DCS:
 380                 cmd = pkg->pkg.dcs_pkg.cmd;
 381                 break;
 382         case MDFLD_DSI_PKG_MCS_SHORT_WRITE_0:
 383         case MDFLD_DSI_PKG_MCS_SHORT_WRITE_1:
 384                 cmd = pkg->pkg.short_pkg.cmd;
 385                 break;
 386         case MDFLD_DSI_PKG_MCS_LONG_WRITE:
 387                 data = (u8 *)pkg->pkg.long_pkg.data;
 388                 cmd = *data;
 389                 break;
 390         default:
 391                 return 0;
 392         }
 393
 394         /* This prevents other package sending while doing msleep */
 395         sender->status = MDFLD_DSI_PKG_SENDER_BUSY;
 396
 397         /* Check panel mode v.s. sending command */
 398         if ((sender->panel_mode & MDFLD_DSI_PANEL_MODE_SLEEP) &&
 399                 cmd != exit_sleep_mode) {
 400                 dev_err(sender->dev->dev,
 401                                 "sending 0x%x when panel sleep in\n", cmd);
 402                 sender->status = MDFLD_DSI_PKG_SENDER_FREE;
 403                 return -EINVAL;
 404         }
 405
 406         /* Wait for 120 milliseconds in case exit_sleep_mode just be sent */
 407         if (cmd == enter_sleep_mode)
 408                 mdelay(120);
 409         return 0;
 410 }
 411
 412 static int send_pkg_done(struct mdfld_dsi_pkg_sender *sender,
 413                                 struct mdfld_dsi_pkg *pkg)
 414 {
 415         u8 cmd;
 416         u8 *data;
 417
 418         switch (pkg->pkg_type) {
 419         case MDFLD_DSI_PKG_DCS:
 420                 cmd = pkg->pkg.dcs_pkg.cmd;
 421                 break;
 422         case MDFLD_DSI_PKG_MCS_SHORT_WRITE_0:
 423         case MDFLD_DSI_PKG_MCS_SHORT_WRITE_1:
 424                 cmd = pkg->pkg.short_pkg.cmd;
 425                 break;
 426         case MDFLD_DSI_PKG_MCS_LONG_WRITE:
 427                 data = (u8 *)pkg->pkg.long_pkg.data;
 428                 cmd = *data;
 429                 break;
 430         default:
 431                 return 0;
 432         }
 433
 434         /* Update panel status */
 435         if (cmd == enter_sleep_mode) {
 436                 sender->panel_mode |= MDFLD_DSI_PANEL_MODE_SLEEP;
 437                 /*TODO: replace it with msleep later*/
 438                 mdelay(120);
 439         } else if (cmd == exit_sleep_mode) {
 440                 sender->panel_mode &= ~MDFLD_DSI_PANEL_MODE_SLEEP;
 441                 /*TODO: replace it with msleep later*/
 442                 mdelay(120);
 443         }
 444
 445         sender->status = MDFLD_DSI_PKG_SENDER_FREE;
 446         return 0;
 447
 448 }
 449
 450 static int do_send_pkg(struct mdfld_dsi_pkg_sender *sender,
 451                         struct mdfld_dsi_pkg *pkg)
 452 {
 453         int ret;
 454
 455         if (sender->status == MDFLD_DSI_PKG_SENDER_BUSY) {
 456                 dev_err(sender->dev->dev, "sender is busy\n");
 457                 return -EAGAIN;
 458         }
 459
 460         ret = send_pkg_prepare(sender, pkg);
 461         if (ret) {
 462                 dev_err(sender->dev->dev, "send_pkg_prepare error\n");
 463                 return ret;
 464         }
 465
 466         switch (pkg->pkg_type) {
 467         case MDFLD_DSI_PKG_DCS:
 468                 ret = send_dcs_pkg(sender, pkg);
 469                 break;
 470         case MDFLD_DSI_PKG_GEN_SHORT_WRITE_0:
 471         case MDFLD_DSI_PKG_GEN_SHORT_WRITE_1:
 472         case MDFLD_DSI_PKG_GEN_SHORT_WRITE_2:
 473                 ret = send_gen_short_pkg(sender, pkg);
 474                 break;
 475         case MDFLD_DSI_PKG_GEN_LONG_WRITE:
 476                 ret = send_gen_long_pkg(sender, pkg);
 477                 break;
 478         case MDFLD_DSI_PKG_MCS_SHORT_WRITE_0:
 479         case MDFLD_DSI_PKG_MCS_SHORT_WRITE_1:
 480                 ret = send_mcs_short_pkg(sender, pkg);
 481                 break;
 482         case MDFLD_DSI_PKG_MCS_LONG_WRITE:
 483                 ret = send_mcs_long_pkg(sender, pkg);
 484                 break;
 485         default:
 486                 dev_err(sender->dev->dev, "Invalid pkg type 0x%x\n",
 487                                                         pkg->pkg_type);
 488                 ret = -EINVAL;
 489         }
 490         send_pkg_done(sender, pkg);
 491         return ret;
 492 }
 493
 494 static int send_pkg(struct mdfld_dsi_pkg_sender *sender,
 495                         struct mdfld_dsi_pkg *pkg)
 496 {
 497         int err ;
 498
 499         /* Handle DSI error */
 500         err = dsi_error_handler(sender);
 501         if (err) {
 502                 dev_err(sender->dev->dev, "Error handling failed\n");
 503                 err = -EAGAIN;
 504                 goto send_pkg_err;
 505         }
 506
 507         /* Send pkg */
 508         err = do_send_pkg(sender, pkg);
 509         if (err) {
 510                 dev_err(sender->dev->dev, "sent pkg failed\n");
 511                 err = -EAGAIN;
 512                 goto send_pkg_err;
 513         }
 514
 515         /* FIXME: should I query complete and fifo empty here? */
 516 send_pkg_err:
 517         return err;
 518 }
 519
 520 static struct mdfld_dsi_pkg *pkg_sender_get_pkg_locked(
 521                                         struct mdfld_dsi_pkg_sender *sender)
 522 {
 523         struct mdfld_dsi_pkg *pkg;
 524
 525         if (list_empty(&sender->free_list)) {
 526                 dev_err(sender->dev->dev, "No free pkg left\n");
 527                 return NULL;
 528         }
 529         pkg = list_first_entry(&sender->free_list, struct mdfld_dsi_pkg, entry);
 530         /* Detach from free list */
 531         list_del_init(&pkg->entry);
 532         return pkg;
 533 }
 534
 535 static void pkg_sender_put_pkg_locked(struct mdfld_dsi_pkg_sender *sender,
 536                                         struct mdfld_dsi_pkg *pkg)
 537 {
 538         memset(pkg, 0, sizeof(struct mdfld_dsi_pkg));
 539         INIT_LIST_HEAD(&pkg->entry);
 540         list_add_tail(&pkg->entry, &sender->free_list);
 541 }
 542
 543 static int mdfld_dbi_cb_init(struct mdfld_dsi_pkg_sender *sender,
 544                                         struct psb_gtt *pg, int pipe)
 545 {
 546         unsigned long phys;
 547         void *virt_addr = NULL;
 548
 549         switch (pipe) {
 550         case 0:
 551                 phys = pg->gtt_phys_start - 0x1000;
 552                 break;
 553         case 2:
 554                 phys = pg->gtt_phys_start - 0x800;
 555                 break;
 556         default:
 557                 dev_err(sender->dev->dev, "Unsupported channel %d\n", pipe);
 558                 return -EINVAL;
 559         }
 560
 561         virt_addr = ioremap_nocache(phys, 0x800);
 562         if (!virt_addr) {
 563                 dev_err(sender->dev->dev, "Map DBI command buffer error\n");
 564                 return -ENOMEM;
 565         }
 566         sender->dbi_cb_phy = phys;
 567         sender->dbi_cb_addr = virt_addr;
 568         return 0;
 569 }
 570
 571 static void mdfld_dbi_cb_destroy(struct mdfld_dsi_pkg_sender *sender)
 572 {
 573         if (sender && sender->dbi_cb_addr)
 574                 iounmap(sender->dbi_cb_addr);
 575 }
 576
 577 static void pkg_sender_queue_pkg(struct mdfld_dsi_pkg_sender *sender,
 578                                         struct mdfld_dsi_pkg *pkg,
 579                                         int delay)
 580 {
 581         unsigned long flags;
 582
 583         spin_lock_irqsave(&sender->lock, flags);
 584
 585         if (!delay) {
 586                 send_pkg(sender, pkg);
 587                 pkg_sender_put_pkg_locked(sender, pkg);
 588         } else {
 589                 /* Queue it */
 590                 list_add_tail(&pkg->entry, &sender->pkg_list);
 591         }
 592         spin_unlock_irqrestore(&sender->lock, flags);
 593 }
 594
 595 static void process_pkg_list(struct mdfld_dsi_pkg_sender *sender)
 596 {
 597         struct mdfld_dsi_pkg *pkg;
 598         unsigned long flags;
 599
 600         spin_lock_irqsave(&sender->lock, flags);
 601
 602         while (!list_empty(&sender->pkg_list)) {
 603                 pkg = list_first_entry(&sender->pkg_list,
 604                                         struct mdfld_dsi_pkg, entry);
 605                 send_pkg(sender, pkg);
 606                 list_del_init(&pkg->entry);
 607                 pkg_sender_put_pkg_locked(sender, pkg);
 608         }
 609
 610         spin_unlock_irqrestore(&sender->lock, flags);
 611 }
 612
 613 static int mdfld_dsi_send_mcs_long(struct mdfld_dsi_pkg_sender *sender,
 614         u32 *data, u32 len, u8 transmission, int delay)
 615 {
 616         struct mdfld_dsi_pkg *pkg;
 617         unsigned long flags;
 618
 619         spin_lock_irqsave(&sender->lock, flags);
 620         pkg = pkg_sender_get_pkg_locked(sender);
 621         spin_unlock_irqrestore(&sender->lock, flags);
 622
 623         if (!pkg) {
 624                 dev_err(sender->dev->dev, "No memory\n");
 625                 return -ENOMEM;
 626         }
 627         pkg->pkg_type = MDFLD_DSI_PKG_MCS_LONG_WRITE;
 628         pkg->transmission_type = transmission;
 629         pkg->pkg.long_pkg.data = data;
 630         pkg->pkg.long_pkg.len = len;
 631         INIT_LIST_HEAD(&pkg->entry);
 632
 633         pkg_sender_queue_pkg(sender, pkg, delay);
 634         return 0;
 635 }
 636
 637 static int mdfld_dsi_send_mcs_short(struct mdfld_dsi_pkg_sender *sender,
 638                                         u8 cmd, u8 param, u8 param_num,
 639                                         u8 transmission,
 640                                         int delay)
 641 {
 642         struct mdfld_dsi_pkg *pkg;
 643         unsigned long flags;
 644
 645         spin_lock_irqsave(&sender->lock, flags);
 646         pkg = pkg_sender_get_pkg_locked(sender);
 647         spin_unlock_irqrestore(&sender->lock, flags);
 648
 649         if (!pkg) {
 650                 dev_err(sender->dev->dev, "No memory\n");
 651                 return -ENOMEM;
 652         }
 653
 654         if (param_num) {
 655                 pkg->pkg_type = MDFLD_DSI_PKG_MCS_SHORT_WRITE_1;
 656                 pkg->pkg.short_pkg.param = param;
 657         } else {
 658                 pkg->pkg_type = MDFLD_DSI_PKG_MCS_SHORT_WRITE_0;
 659                 pkg->pkg.short_pkg.param = 0;
 660         }
 661         pkg->transmission_type = transmission;
 662         pkg->pkg.short_pkg.cmd = cmd;
 663         INIT_LIST_HEAD(&pkg->entry);
 664
 665         pkg_sender_queue_pkg(sender, pkg, delay);
 666         return 0;
 667 }
 668
 669 static int mdfld_dsi_send_gen_short(struct mdfld_dsi_pkg_sender *sender,
 670                                         u8 param0, u8 param1, u8 param_num,
 671                                         u8 transmission,
 672                                         int delay)
 673 {
 674         struct mdfld_dsi_pkg *pkg;
 675         unsigned long flags;
 676
 677         spin_lock_irqsave(&sender->lock, flags);
 678         pkg = pkg_sender_get_pkg_locked(sender);
 679         spin_unlock_irqrestore(&sender->lock, flags);
 680
 681         if (!pkg) {
 682                 dev_err(sender->dev->dev, "No pkg memory\n");
 683                 return -ENOMEM;
 684         }
 685
 686         switch (param_num) {
 687         case 0:
 688                 pkg->pkg_type = MDFLD_DSI_PKG_GEN_SHORT_WRITE_0;
 689                 pkg->pkg.short_pkg.cmd = 0;
 690                 pkg->pkg.short_pkg.param = 0;
 691                 break;
 692         case 1:
 693                 pkg->pkg_type = MDFLD_DSI_PKG_GEN_SHORT_WRITE_1;
 694                 pkg->pkg.short_pkg.cmd = param0;
 695                 pkg->pkg.short_pkg.param = 0;
 696                 break;
 697         case 2:
 698                 pkg->pkg_type = MDFLD_DSI_PKG_GEN_SHORT_WRITE_2;
 699                 pkg->pkg.short_pkg.cmd = param0;
 700                 pkg->pkg.short_pkg.param = param1;
 701                 break;
 702         }
 703
 704         pkg->transmission_type = transmission;
 705         INIT_LIST_HEAD(&pkg->entry);
 706
 707         pkg_sender_queue_pkg(sender, pkg, delay);
 708         return 0;
 709 }
 710
 711 static int mdfld_dsi_send_gen_long(struct mdfld_dsi_pkg_sender *sender,
 712                                 u32 *data, u32 len, u8 transmission, int delay)
 713 {
 714         struct mdfld_dsi_pkg *pkg;
 715         unsigned long flags;
 716
 717         spin_lock_irqsave(&sender->lock, flags);
 718         pkg = pkg_sender_get_pkg_locked(sender);
 719         spin_unlock_irqrestore(&sender->lock, flags);
 720
 721         if (!pkg) {
 722                 dev_err(sender->dev->dev, "No pkg memory\n");
 723                 return -ENOMEM;
 724         }
 725
 726         pkg->pkg_type = MDFLD_DSI_PKG_GEN_LONG_WRITE;
 727         pkg->transmission_type = transmission;
 728         pkg->pkg.long_pkg.data = data;
 729         pkg->pkg.long_pkg.len = len;
 730
 731         INIT_LIST_HEAD(&pkg->entry);
 732
 733         pkg_sender_queue_pkg(sender, pkg, delay);
 734
 735         return 0;
 736 }
 737
 738 void mdfld_dsi_cmds_kick_out(struct mdfld_dsi_pkg_sender *sender)
 739 {
 740         process_pkg_list(sender);
 741 }
 742
 743 int mdfld_dsi_send_dcs(struct mdfld_dsi_pkg_sender *sender,
 744                         u8 dcs, u8 *param, u32 param_num, u8 data_src,
 745                         int delay)
 746 {
 747         struct mdfld_dsi_pkg *pkg;
 748         u32 cb_phy = sender->dbi_cb_phy;
 749         struct drm_device *dev = sender->dev;
 750         u32 index = 0;
 751         u8 *cb = (u8 *)sender->dbi_cb_addr;
 752         unsigned long flags;
 753         int retry;
 754         u8 *dst = NULL;
 755         u32 len;
 756
 757         if (!sender) {
 758                 WARN_ON(1);
 759                 return -EINVAL;
 760         }
 761
 762         if (!sender->dbi_pkg_support) {
 763                 dev_err(dev->dev, "No DBI pkg sending on this sender\n");
 764                 return -ENOTSUPP;
 765         }
 766
 767         if (param_num > MDFLD_MAX_DCS_PARAM) {
 768                 dev_err(dev->dev, "Sender only supports up to %d DCS params\n",
 769                                                         MDFLD_MAX_DCS_PARAM);
 770                 return -EINVAL;
 771         }
 772
 773         /*
 774          * If dcs is write_mem_start, send it directly using DSI adapter
 775          * interface
 776          */
 777         if (dcs == write_mem_start) {
 778                 if (!spin_trylock(&sender->lock))
 779                         return -EAGAIN;
 780
 781                 /*
 782                  * query whether DBI FIFO is empty,
 783                  * if not wait it becoming empty
 784                  */
 785                 retry = MDFLD_DSI_DBI_FIFO_TIMEOUT;
 786                 while (retry &&
 787                     !(REG_READ(sender->mipi_gen_fifo_stat_reg) & (1 << 27))) {
 788                         udelay(500);
 789                         retry--;
 790                 }
 791
 792                 /* If DBI FIFO timeout, drop this frame */
 793                 if (!retry) {
 794                         spin_unlock(&sender->lock);
 795                         return 0;
 796                 }
 797
 798                 *(cb + (index++)) = write_mem_start;
 799
 800                 REG_WRITE(sender->mipi_cmd_len_reg, 1);
 801                 REG_WRITE(sender->mipi_cmd_addr_reg,
 802                                         cb_phy | (1 << 0) | (1 << 1));
 803
 804                 retry = MDFLD_DSI_DBI_FIFO_TIMEOUT;
 805                 while (retry &&
 806                         (REG_READ(sender->mipi_cmd_addr_reg) & (1 << 0))) {
 807                         udelay(1);
 808                         retry--;
 809                 }
 810
 811                 spin_unlock(&sender->lock);
 812                 return 0;
 813         }
 814
 815         /* Get a free pkg */
 816         spin_lock_irqsave(&sender->lock, flags);
 817         pkg = pkg_sender_get_pkg_locked(sender);
 818         spin_unlock_irqrestore(&sender->lock, flags);
 819
 820         if (!pkg) {
 821                 dev_err(dev->dev, "No packages memory\n");
 822                 return -ENOMEM;
 823         }
 824
 825         dst = pkg->pkg.dcs_pkg.param;
 826         memcpy(dst, param, param_num);
 827
 828         pkg->pkg_type = MDFLD_DSI_PKG_DCS;
 829         pkg->transmission_type = MDFLD_DSI_DCS;
 830         pkg->pkg.dcs_pkg.cmd = dcs;
 831         pkg->pkg.dcs_pkg.param_num = param_num;
 832         pkg->pkg.dcs_pkg.data_src = data_src;
 833
 834         INIT_LIST_HEAD(&pkg->entry);
 835
 836         if (param_num == 0)
 837                 return mdfld_dsi_send_mcs_short_hs(sender, dcs, 0, 0, delay);
 838         else if (param_num == 1)
 839                 return mdfld_dsi_send_mcs_short_hs(sender, dcs,
 840                                                         param[0], 1, delay);
 841         else if (param_num > 1) {
 842                 len = (param_num + 1) / 4;
 843                 if ((param_num + 1) % 4)
 844                         len++;
 845                 return mdfld_dsi_send_mcs_long_hs(sender,
 846                                 (u32 *)&pkg->pkg.dcs_pkg, len, delay);
 847         }
 848         return 0;
 849 }
 850
 851 int mdfld_dsi_send_mcs_short_hs(struct mdfld_dsi_pkg_sender *sender,
 852                                 u8 cmd, u8 param, u8 param_num, int delay)
 853 {
 854         if (!sender) {
 855                 WARN_ON(1);
 856                 return -EINVAL;
 857         }
 858         return mdfld_dsi_send_mcs_short(sender, cmd, param, param_num,
 859                                         MDFLD_DSI_HS_TRANSMISSION, delay);
 860 }
 861
 862 int mdfld_dsi_send_mcs_short_lp(struct mdfld_dsi_pkg_sender *sender,
 863                                 u8 cmd, u8 param, u8 param_num, int delay)
 864 {
 865         if (!sender) {
 866                 WARN_ON(1);
 867                 return -EINVAL;
 868         }
 869         return mdfld_dsi_send_mcs_short(sender, cmd, param, param_num,
 870                                         MDFLD_DSI_LP_TRANSMISSION, delay);
 871 }
 872
 873 int mdfld_dsi_send_mcs_long_hs(struct mdfld_dsi_pkg_sender *sender,
 874                                 u32 *data,
 875                                 u32 len,
 876                                 int delay)
 877 {
 878         if (!sender || !data || !len) {
 879                 DRM_ERROR("Invalid parameters\n");
 880                 return -EINVAL;
 881         }
 882         return mdfld_dsi_send_mcs_long(sender, data, len,
 883                                         MDFLD_DSI_HS_TRANSMISSION, delay);
 884 }
 885
 886 int mdfld_dsi_send_mcs_long_lp(struct mdfld_dsi_pkg_sender *sender,
 887                                 u32 *data,
 888                                 u32 len,
 889                                 int delay)
 890 {
 891         if (!sender || !data || !len) {
 892                 WARN_ON(1);
 893                 return -EINVAL;
 894         }
 895         return mdfld_dsi_send_mcs_long(sender, data, len,
 896                                 MDFLD_DSI_LP_TRANSMISSION, delay);
 897 }
 898
 899 int mdfld_dsi_send_gen_short_hs(struct mdfld_dsi_pkg_sender *sender,
 900                                 u8 param0, u8 param1, u8 param_num, int delay)
 901 {
 902         if (!sender) {
 903                 WARN_ON(1);
 904                 return -EINVAL;
 905         }
 906         return mdfld_dsi_send_gen_short(sender, param0, param1, param_num,
 907                                         MDFLD_DSI_HS_TRANSMISSION, delay);
 908 }
 909
 910 int mdfld_dsi_send_gen_short_lp(struct mdfld_dsi_pkg_sender *sender,
 911                                 u8 param0, u8 param1, u8 param_num, int delay)
 912 {
 913         if (!sender || param_num < 0 || param_num > 2) {
 914                 WARN_ON(1);
 915                 return -EINVAL;
 916         }
 917         return mdfld_dsi_send_gen_short(sender, param0, param1, param_num,
 918                                         MDFLD_DSI_LP_TRANSMISSION, delay);
 919 }
 920
 921 int mdfld_dsi_send_gen_long_hs(struct mdfld_dsi_pkg_sender *sender,
 922                                 u32 *data,
 923                                 u32 len,
 924                                 int delay)
 925 {
 926         if (!sender || !data || !len) {
 927                 WARN_ON(1);
 928                 return -EINVAL;
 929         }
 930         return mdfld_dsi_send_gen_long(sender, data, len,
 931                                         MDFLD_DSI_HS_TRANSMISSION, delay);
 932 }
 933
 934 int mdfld_dsi_send_gen_long_lp(struct mdfld_dsi_pkg_sender *sender,
 935                                 u32 *data,
 936                                 u32 len,
 937                                 int delay)
 938 {
 939         if (!sender || !data || !len) {
 940                 WARN_ON(1);
 941                 return -EINVAL;
 942         }
 943         return mdfld_dsi_send_gen_long(sender, data, len,
 944                                         MDFLD_DSI_LP_TRANSMISSION, delay);
 945 }
 946
 947 int mdfld_dsi_pkg_sender_init(struct mdfld_dsi_connector *dsi_connector,
 948                                                                 int pipe)
 949 {
 950         int ret;
 951         struct mdfld_dsi_pkg_sender *pkg_sender;
 952         struct mdfld_dsi_config *dsi_config =
 953                                         mdfld_dsi_get_config(dsi_connector);
 954         struct drm_device *dev = dsi_config->dev;
 955         struct drm_psb_private *dev_priv = dev->dev_private;
 956         struct psb_gtt *pg = dev_priv->pg;
 957         int i;
 958         struct mdfld_dsi_pkg *pkg, *tmp;
 959
 960         if (!dsi_connector) {
 961                 WARN_ON(1);
 962                 return -EINVAL;
 963         }
 964
 965         pkg_sender = dsi_connector->pkg_sender;
 966
 967         if (!pkg_sender || IS_ERR(pkg_sender)) {
 968                 pkg_sender = kzalloc(sizeof(struct mdfld_dsi_pkg_sender),
 969                                                                 GFP_KERNEL);
 970                 if (!pkg_sender) {
 971                         dev_err(dev->dev, "Create DSI pkg sender failed\n");
 972                         return -ENOMEM;
 973                 }
 974
 975                 dsi_connector->pkg_sender = (void *)pkg_sender;
 976         }
 977
 978         pkg_sender->dev = dev;
 979         pkg_sender->dsi_connector = dsi_connector;
 980         pkg_sender->pipe = pipe;
 981         pkg_sender->pkg_num = 0;
 982         pkg_sender->panel_mode = 0;
 983         pkg_sender->status = MDFLD_DSI_PKG_SENDER_FREE;
 984
 985         /* Init dbi command buffer*/
 986
 987         if (dsi_config->type == MDFLD_DSI_ENCODER_DBI) {
 988                 pkg_sender->dbi_pkg_support = 1;
 989                 ret = mdfld_dbi_cb_init(pkg_sender, pg, pipe);
 990                 if (ret) {
 991                         dev_err(dev->dev, "DBI command buffer map failed\n");
 992                         goto mapping_err;
 993                 }
 994         }
 995
 996         /* Init regs */
 997         if (pipe == 0) {
 998                 pkg_sender->dpll_reg = MRST_DPLL_A;
 999                 pkg_sender->dspcntr_reg = DSPACNTR;
1000                 pkg_sender->pipeconf_reg = PIPEACONF;
1001                 pkg_sender->dsplinoff_reg = DSPALINOFF;
1002                 pkg_sender->dspsurf_reg = DSPASURF;
1003                 pkg_sender->pipestat_reg = PIPEASTAT;
1004
1005                 pkg_sender->mipi_intr_stat_reg = MIPIA_INTR_STAT_REG;
1006                 pkg_sender->mipi_lp_gen_data_reg = MIPIA_LP_GEN_DATA_REG;
1007                 pkg_sender->mipi_hs_gen_data_reg = MIPIA_HS_GEN_DATA_REG;
1008                 pkg_sender->mipi_lp_gen_ctrl_reg = MIPIA_LP_GEN_CTRL_REG;
1009                 pkg_sender->mipi_hs_gen_ctrl_reg = MIPIA_HS_GEN_CTRL_REG;
1010                 pkg_sender->mipi_gen_fifo_stat_reg = MIPIA_GEN_FIFO_STAT_REG;
1011                 pkg_sender->mipi_data_addr_reg = MIPIA_DATA_ADD_REG;
1012                 pkg_sender->mipi_data_len_reg = MIPIA_DATA_LEN_REG;
1013                 pkg_sender->mipi_cmd_addr_reg = MIPIA_CMD_ADD_REG;
1014                 pkg_sender->mipi_cmd_len_reg = MIPIA_CMD_LEN_REG;
1015         } else if (pipe == 2) {
1016                 pkg_sender->dpll_reg = MRST_DPLL_A;
1017                 pkg_sender->dspcntr_reg = DSPCCNTR;
1018                 pkg_sender->pipeconf_reg = PIPECCONF;
1019                 pkg_sender->dsplinoff_reg = DSPCLINOFF;
1020                 pkg_sender->dspsurf_reg = DSPCSURF;
1021                 pkg_sender->pipestat_reg = 72024;
1022
1023                 pkg_sender->mipi_intr_stat_reg =
1024                                 MIPIA_INTR_STAT_REG + MIPIC_REG_OFFSET;
1025                 pkg_sender->mipi_lp_gen_data_reg =
1026                                 MIPIA_LP_GEN_DATA_REG + MIPIC_REG_OFFSET;
1027                 pkg_sender->mipi_hs_gen_data_reg =
1028                                 MIPIA_HS_GEN_DATA_REG + MIPIC_REG_OFFSET;
1029                 pkg_sender->mipi_lp_gen_ctrl_reg =
1030                                 MIPIA_LP_GEN_CTRL_REG + MIPIC_REG_OFFSET;
1031                 pkg_sender->mipi_hs_gen_ctrl_reg =
1032                                 MIPIA_HS_GEN_CTRL_REG + MIPIC_REG_OFFSET;
1033                 pkg_sender->mipi_gen_fifo_stat_reg =
1034                                 MIPIA_GEN_FIFO_STAT_REG + MIPIC_REG_OFFSET;
1035                 pkg_sender->mipi_data_addr_reg =
1036                                 MIPIA_DATA_ADD_REG + MIPIC_REG_OFFSET;
1037                 pkg_sender->mipi_data_len_reg =
1038                                 MIPIA_DATA_LEN_REG + MIPIC_REG_OFFSET;
1039                 pkg_sender->mipi_cmd_addr_reg =
1040                                 MIPIA_CMD_ADD_REG + MIPIC_REG_OFFSET;
1041                 pkg_sender->mipi_cmd_len_reg =
1042                                 MIPIA_CMD_LEN_REG + MIPIC_REG_OFFSET;
1043         }
1044
1045         /* Init pkg list */
1046         INIT_LIST_HEAD(&pkg_sender->pkg_list);
1047         INIT_LIST_HEAD(&pkg_sender->free_list);
1048
1049         spin_lock_init(&pkg_sender->lock);
1050
1051         /* Allocate free pkg pool */
1052         for (i = 0; i < MDFLD_MAX_PKG_NUM; i++) {
1053                 pkg = kzalloc(sizeof(struct mdfld_dsi_pkg), GFP_KERNEL);
1054                 if (!pkg) {
1055                         dev_err(dev->dev, "Out of memory allocating pkg pool");
1056                         ret = -ENOMEM;
1057                         goto pkg_alloc_err;
1058                 }
1059                 INIT_LIST_HEAD(&pkg->entry);
1060                 list_add_tail(&pkg->entry, &pkg_sender->free_list);
1061         }
1062         return 0;
1063
1064 pkg_alloc_err:
1065         list_for_each_entry_safe(pkg, tmp, &pkg_sender->free_list, entry) {
1066                 list_del(&pkg->entry);
1067                 kfree(pkg);
1068         }
1069
1070         /* Free mapped command buffer */
1071         mdfld_dbi_cb_destroy(pkg_sender);
1072 mapping_err:
1073         kfree(pkg_sender);
1074         dsi_connector->pkg_sender = NULL;
1075         return ret;
1076 }
1077
1078 void mdfld_dsi_pkg_sender_destroy(struct mdfld_dsi_pkg_sender *sender)
1079 {
1080         struct mdfld_dsi_pkg *pkg, *tmp;
1081
1082         if (!sender || IS_ERR(sender))
1083                 return;
1084
1085         /* Free pkg pool */
1086         list_for_each_entry_safe(pkg, tmp, &sender->free_list, entry) {
1087                 list_del(&pkg->entry);
1088                 kfree(pkg);
1089         }
1090         /* Free pkg list */
1091         list_for_each_entry_safe(pkg, tmp, &sender->pkg_list, entry) {
1092                 list_del(&pkg->entry);
1093                 kfree(pkg);
1094         }
1095         mdfld_dbi_cb_destroy(sender);   /* free mapped command buffer */
1096         kfree(sender);
1097 }