Subversion Repositories HelenOS-historic

Rev

Rev 1689 | Rev 1717 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2006 Ondrej Palkovsky
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @addtogroup console
  30.  * @{
  31.  */
  32. /** @file
  33.  */
  34.  
  35. #include <ipc/fb.h>
  36. #include <ipc/ipc.h>
  37. #include <async.h>
  38. #include <stdio.h>
  39. #include <sys/mman.h>
  40. #include <string.h>
  41. #include <align.h>
  42.  
  43. #include "console.h"
  44. #include "gcons.h"
  45.  
  46. #define CONSOLE_TOP      66
  47. #define CONSOLE_MARGIN   6
  48.  
  49. #define STATUS_START    110
  50. #define STATUS_TOP      8
  51. #define STATUS_SPACE    4
  52. #define STATUS_WIDTH    48
  53. #define STATUS_HEIGHT   48
  54.  
  55. #define MAIN_COLOR      0xffffff
  56.  
  57. static int use_gcons = 0;
  58. static ipcarg_t xres,yres;
  59.  
  60. enum butstate {
  61.     CONS_DISCONNECTED = 0,
  62.     CONS_SELECTED,
  63.     CONS_IDLE,
  64.     CONS_HAS_DATA,
  65.     CONS_KERNEL,
  66.     CONS_DISCONNECTED_SEL,
  67.     CONS_LAST
  68. };
  69.  
  70. static int console_vp;
  71. static int cstatus_vp[CONSOLE_COUNT];
  72. static int cstat_row, cstat_col; /* Size of cstatus buttons */
  73. static enum butstate console_state[CONSOLE_COUNT];
  74.  
  75. static int fbphone;
  76.  
  77. /** List of pixmaps identifying these icons */
  78. static int ic_pixmaps[CONS_LAST] = {-1,-1,-1,-1,-1,-1};
  79. static int animation = -1;
  80.  
  81. static int active_console = 0;
  82.  
  83. static void vp_switch(int vp)
  84. {
  85.     async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);
  86. }
  87.  
  88. /** Create view port */
  89. static int vp_create(unsigned int x, unsigned int y,
  90.              unsigned int width, unsigned int height)
  91. {
  92.     return async_req_2(fbphone, FB_VIEWPORT_CREATE,
  93.                (x << 16) | y, (width << 16) | height,
  94.                NULL, NULL);
  95. }
  96.  
  97. static void clear(void)
  98. {
  99.     async_msg(fbphone, FB_CLEAR, 0);
  100.    
  101. }
  102.  
  103. static void set_style(int fgcolor, int bgcolor)
  104. {
  105.     async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
  106. }
  107.  
  108. /** Transparent putchar */
  109. static void tran_putch(char c, int row, int col)
  110. {
  111.     async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
  112. }
  113.  
  114. /** Redraw the button showing state of a given console */
  115. static void redraw_state(int consnum)
  116. {
  117.     char data[5];
  118.     int i;
  119.     enum butstate state = console_state[consnum];
  120.  
  121.     vp_switch(cstatus_vp[consnum]);
  122.     if (ic_pixmaps[state] != -1)
  123.         async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum], ic_pixmaps[state]);
  124.  
  125.     if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state != CONS_DISCONNECTED_SEL) {
  126.         snprintf(data, 5, "%d", consnum+1);
  127.         for (i=0;data[i];i++)
  128.             tran_putch(data[i], 1, 2+i);
  129.     }
  130. }
  131.  
  132. /** Notification run on changing console (except kernel console) */
  133. void gcons_change_console(int consnum)
  134. {
  135.     int i;
  136.  
  137.     if (!use_gcons)
  138.         return;
  139.  
  140.     if (active_console == KERNEL_CONSOLE) {
  141.         for (i=0; i < CONSOLE_COUNT; i++)
  142.             redraw_state(i);
  143.         if (animation != -1)
  144.             async_msg(fbphone, FB_ANIM_START, animation);
  145.     } else {
  146.         if (console_state[active_console] == CONS_DISCONNECTED_SEL)
  147.             console_state[active_console] = CONS_DISCONNECTED;
  148.         else
  149.             console_state[active_console] = CONS_IDLE;
  150.         redraw_state(active_console);
  151.     }
  152.     active_console = consnum;
  153.  
  154.     if (console_state[consnum] == CONS_DISCONNECTED) {
  155.         console_state[consnum] = CONS_DISCONNECTED_SEL;
  156.         redraw_state(consnum);
  157.     } else
  158.         console_state[consnum] = CONS_SELECTED;
  159.     redraw_state(consnum);
  160.  
  161.     vp_switch(console_vp);
  162. }
  163.  
  164. /** Notification function that gets called on new output to virtual console */
  165. void gcons_notify_char(int consnum)
  166. {
  167.     if (!use_gcons)
  168.         return;
  169.  
  170.     if (consnum == active_console || console_state[consnum] == CONS_HAS_DATA)
  171.         return;
  172.  
  173.     console_state[consnum] = CONS_HAS_DATA;
  174.  
  175.     if (active_console == KERNEL_CONSOLE)
  176.         return;
  177.  
  178.     redraw_state(consnum);
  179.    
  180.     vp_switch(console_vp);
  181. }
  182.  
  183. /** Notification function called on service disconnect from console */
  184. void gcons_notify_disconnect(int consnum)
  185. {
  186.     if (!use_gcons)
  187.         return;
  188.     if (active_console == consnum)
  189.         console_state[consnum] = CONS_DISCONNECTED_SEL;
  190.     else
  191.         console_state[consnum] = CONS_DISCONNECTED;
  192.  
  193.     if (active_console == KERNEL_CONSOLE)
  194.         return;
  195.  
  196.     redraw_state(consnum);
  197.     vp_switch(console_vp);
  198. }
  199.  
  200. /** Notification function called on console connect */
  201. void gcons_notify_connect(int consnum)
  202. {
  203.     if (!use_gcons)
  204.         return;
  205.     if (active_console == consnum)
  206.         console_state[consnum] = CONS_SELECTED;
  207.     else
  208.         console_state[consnum] = CONS_IDLE;
  209.  
  210.     if (active_console == KERNEL_CONSOLE)
  211.         return;
  212.  
  213.     redraw_state(consnum);
  214.     vp_switch(console_vp);
  215. }
  216.  
  217. /** Change to kernel console */
  218. void gcons_in_kernel(void)
  219. {
  220.     if (console_state[active_console] == CONS_DISCONNECTED_SEL)
  221.         console_state[active_console] = CONS_DISCONNECTED;
  222.     else
  223.         console_state[active_console] = CONS_IDLE;
  224.     redraw_state(active_console);
  225.  
  226.     if (animation != -1)
  227.         async_msg(fbphone, FB_ANIM_STOP, animation);
  228.  
  229.     active_console = KERNEL_CONSOLE; /* Set to kernel console */
  230.     vp_switch(0);
  231. }
  232.  
  233.  
  234. static inline int limit(int a,int left, int right)
  235. {
  236.     if (a < left)
  237.         a = left;
  238.     if (a >= right)
  239.         a = right - 1;
  240.     return a;
  241. }
  242.  
  243. void gcons_mouse_move(int dx, int dy)
  244. {
  245.     static int x = 0;
  246.     static int y = 0;
  247.  
  248.     x = limit(x+dx, 0, xres);
  249.     y = limit(y+dy, 0, yres);
  250.  
  251.     async_msg_2(fbphone, FB_POINTER_MOVE, x, y);
  252. }
  253.  
  254.  
  255. /** Draw a PPM pixmap to framebuffer
  256.  *
  257.  * @param logo Pointer to PPM data
  258.  * @param size Size of PPM data
  259.  * @param x Coordinate of upper left corner
  260.  * @param y Coordinate of upper left corner
  261.  */
  262. static void draw_pixmap(char *logo, size_t size, int x, int y)
  263. {
  264.     char *shm;
  265.     int rc;
  266.  
  267.     /* Create area */
  268.     shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
  269.     if (shm == MAP_FAILED)
  270.         return;
  271.  
  272.     memcpy(shm, logo, size);
  273.     /* Send area */
  274.     rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
  275.     if (rc)
  276.         goto exit;
  277.     rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
  278.     if (rc)
  279.         goto drop;
  280.     /* Draw logo */
  281.     async_msg_2(fbphone, FB_DRAW_PPM, x, y);
  282. drop:
  283.     /* Drop area */
  284.     async_msg(fbphone, FB_DROP_SHM, 0);
  285. exit:      
  286.     /* Remove area */
  287.     munmap(shm, size);
  288. }
  289.  
  290. extern char _binary_helenos_ppm_start[0];
  291. extern int _binary_helenos_ppm_size;
  292. extern char _binary_nameic_ppm_start[0];
  293. extern int _binary_nameic_ppm_size;
  294. /** Redraws console graphics  */
  295. static void gcons_redraw_console(void)
  296. {
  297.     int i;
  298.     size_t hsize = (size_t)&_binary_helenos_ppm_size;
  299.  
  300.     if (!use_gcons)
  301.         return;
  302.    
  303.     vp_switch(0);
  304.     set_style(MAIN_COLOR, MAIN_COLOR);
  305.     clear();
  306.     draw_pixmap(_binary_helenos_ppm_start, (size_t)&_binary_helenos_ppm_size, xres-66, 2);
  307.     draw_pixmap(_binary_nameic_ppm_start, (size_t)&_binary_nameic_ppm_size, 5, 17);
  308.  
  309.     for (i=0;i < CONSOLE_COUNT; i++)
  310.         redraw_state(i);
  311.     vp_switch(console_vp);
  312. }
  313.  
  314. /** Creates a pixmap on framebuffer
  315.  *
  316.  * @param data PPM data
  317.  * @param size PPM data size
  318.  * @return Pixmap identification
  319.  */
  320. static int make_pixmap(char *data, int size)
  321. {
  322.     char *shm;
  323.     int rc;
  324.     int pxid = -1;
  325.  
  326.     /* Create area */
  327.     shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
  328.     if (shm == MAP_FAILED)
  329.         return -1;
  330.  
  331.     memcpy(shm, data, size);
  332.     /* Send area */
  333.     rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
  334.     if (rc)
  335.         goto exit;
  336.     rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
  337.     if (rc)
  338.         goto drop;
  339.  
  340.     /* Obtain pixmap */
  341.     rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);
  342.     if (rc < 0)
  343.         goto drop;
  344.     pxid = rc;
  345. drop:
  346.     /* Drop area */
  347.     async_msg(fbphone, FB_DROP_SHM, 0);
  348. exit:      
  349.     /* Remove area */
  350.     munmap(shm, size);
  351.  
  352.     return pxid;
  353. }
  354.  
  355. extern char _binary_anim_1_ppm_start[0];
  356. extern int _binary_anim_1_ppm_size;
  357. extern char _binary_anim_2_ppm_start[0];
  358. extern int _binary_anim_2_ppm_size;
  359. extern char _binary_anim_3_ppm_start[0];
  360. extern int _binary_anim_3_ppm_size;
  361. extern char _binary_anim_4_ppm_start[0];
  362. extern int _binary_anim_4_ppm_size;
  363. static void make_anim(void)
  364. {
  365.     int an;
  366.     int pm;
  367.  
  368.     an = async_req(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE], NULL);
  369.     if (an < 0)
  370.         return;
  371.  
  372.     pm = make_pixmap(_binary_anim_1_ppm_start, (int)&_binary_anim_1_ppm_size);
  373.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  374.  
  375.     pm = make_pixmap(_binary_anim_2_ppm_start, (int)&_binary_anim_2_ppm_size);
  376.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  377.  
  378.     pm = make_pixmap(_binary_anim_3_ppm_start, (int)&_binary_anim_3_ppm_size);
  379.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  380.  
  381.     pm = make_pixmap(_binary_anim_4_ppm_start, (int)&_binary_anim_4_ppm_size);
  382.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  383.  
  384.     async_msg(fbphone, FB_ANIM_START, an);
  385.  
  386.     animation = an;
  387. }
  388.  
  389. extern char _binary_cons_selected_ppm_start[0];
  390. extern int _binary_cons_selected_ppm_size;
  391. extern char _binary_cons_idle_ppm_start[0];
  392. extern int _binary_cons_idle_ppm_size;
  393. extern char _binary_cons_has_data_ppm_start[0];
  394. extern int _binary_cons_has_data_ppm_size;
  395. extern char _binary_cons_kernel_ppm_start[0];
  396. extern int _binary_cons_kernel_ppm_size;
  397. /** Initialize nice graphical console environment */
  398. void gcons_init(int phone)
  399. {
  400.     int rc;
  401.     int i;
  402.     int status_start = STATUS_START;
  403.  
  404.     fbphone = phone;
  405.  
  406.     rc = async_req_2(phone, FB_GET_RESOLUTION, 0, 0, &xres, &yres);
  407.     if (rc)
  408.         return;
  409.    
  410.     if (xres < 800 || yres < 600)
  411.         return;
  412.  
  413.     /* create console viewport */
  414.     /* Align width & height to character size */
  415.     console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
  416.                    ALIGN_DOWN(xres-2*CONSOLE_MARGIN, 8),
  417.                    ALIGN_DOWN(yres-(CONSOLE_TOP+CONSOLE_MARGIN),16));
  418.     if (console_vp < 0)
  419.         return;
  420.    
  421.     /* Create status buttons */
  422.     status_start += (xres-800) / 2;
  423.     for (i=0; i < CONSOLE_COUNT; i++) {
  424.         cstatus_vp[i] = vp_create(status_start+CONSOLE_MARGIN+i*(STATUS_WIDTH+STATUS_SPACE),
  425.                       STATUS_TOP, STATUS_WIDTH, STATUS_HEIGHT);
  426.         if (cstatus_vp[i] < 0)
  427.             return;
  428.         vp_switch(cstatus_vp[i]);
  429.         set_style(0x202020, 0xffffff);
  430.     }
  431.    
  432.     /* Initialize icons */
  433.     ic_pixmaps[CONS_SELECTED] = make_pixmap(_binary_cons_selected_ppm_start,
  434.                           (int)&_binary_cons_selected_ppm_size);
  435.     ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start,
  436.                           (int)&_binary_cons_idle_ppm_size);
  437.     ic_pixmaps[CONS_HAS_DATA] = make_pixmap(_binary_cons_has_data_ppm_start,
  438.                         (int)&_binary_cons_has_data_ppm_size);
  439.     ic_pixmaps[CONS_DISCONNECTED] = make_pixmap(_binary_cons_idle_ppm_start,
  440.                           (int)&_binary_cons_idle_ppm_size);
  441.     ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,
  442.                           (int)&_binary_cons_kernel_ppm_size);
  443.     ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
  444.    
  445.     make_anim();
  446.  
  447.     use_gcons = 1;
  448.     console_state[0] = CONS_DISCONNECTED_SEL;
  449.     console_state[KERNEL_CONSOLE] = CONS_KERNEL;
  450.     gcons_redraw_console();
  451. }
  452.  
  453. /** @}
  454.  */
  455.  
  456.