?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gma500: Fix dependencies
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / gma500 / mdfld_dsi_pkg_sender.c
blob745d4adc82b2a0f920670f3ed75bd45f23f9f25b
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->gtt;
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 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree