Changeset ff8922c in rtems


Ignore:
Timestamp:
Oct 12, 2014, 8:22:27 PM (5 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.11, master
Children:
65f71f84
Parents:
5ad38eac
git-author:
Joel Sherrill <joel.sherrill@…> (10/12/14 20:22:27)
git-committer:
Joel Sherrill <joel.sherrill@…> (10/13/14 15:33:31)
Message:

arm/gba/console: Fix warnings and clean up

Location:
c/src/lib/libbsp/arm/gba/console
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/arm/gba/console/conio.c

    r5ad38eac rff8922c  
    44 *  This file contains the GBA conio I/O package.
    55 */
     6
    67/*
    78 *  RTEMS GBA BSP
     
    119120 *  @return None
    120121 */
    121 void gba_putchar(char c, int textattr, int x, int y)
    122 {
    123     int       f = textattr & 0x0F;
    124     int       b = textattr >> 4;
    125     uint32_t  fmask = f | f<<8 | f<<16 | f<<24;
    126     uint32_t  bmask = b | b<<8 | b<<16 | b<<24;
    127     uint32_t  *dest = (uint32_t *)&bg_bitmap4a[((y<<1) + y) << 1][x<<2];
    128     const uint32_t  *src = (uint32_t *)&(font3x5[(int)c]);
    129     uint32_t s;
    130     s = *src++; *dest = (fmask&s) | (bmask&~s); dest += GBA_LCD_WIDTH/sizeof(uint32_t);
    131     s = *src++; *dest = (fmask&s) | (bmask&~s); dest += GBA_LCD_WIDTH/sizeof(uint32_t);
    132     s = *src++; *dest = (fmask&s) | (bmask&~s); dest += GBA_LCD_WIDTH/sizeof(uint32_t);
    133     s = *src++; *dest = (fmask&s) | (bmask&~s); dest += GBA_LCD_WIDTH/sizeof(uint32_t);
    134     s = *src++; *dest = (fmask&s) | (bmask&~s); dest += GBA_LCD_WIDTH/sizeof(uint32_t);
    135     s = *src++; *dest = (fmask&s) | (bmask&~s); dest += GBA_LCD_WIDTH/sizeof(uint32_t);
     122static void gba_putchar(char c, int textattr, int x, int y)
     123{
     124  int       f = textattr & 0x0F;
     125  int       b = textattr >> 4;
     126  uint32_t  fmask = f | f<<8 | f<<16 | f<<24;
     127  uint32_t  bmask = b | b<<8 | b<<16 | b<<24;
     128  uint32_t  *dest = (uint32_t *)&bg_bitmap4a[((y<<1) + y) << 1][x<<2];
     129  const uint32_t  *src = (uint32_t *)&(font3x5[(int)c]);
     130  uint32_t s;
     131
     132  s = *src++;
     133  *dest = (fmask&s) | (bmask&~s);
     134  dest += GBA_LCD_WIDTH/sizeof(uint32_t);
     135
     136  s = *src++;
     137  *dest = (fmask&s) | (bmask&~s);
     138  dest += GBA_LCD_WIDTH/sizeof(uint32_t);
     139
     140  s = *src++;
     141  *dest = (fmask&s) | (bmask&~s);
     142  dest += GBA_LCD_WIDTH/sizeof(uint32_t);
     143
     144  s = *src++;
     145  *dest = (fmask&s) | (bmask&~s);
     146  dest += GBA_LCD_WIDTH/sizeof(uint32_t);
     147
     148  s = *src++;
     149  *dest = (fmask&s) | (bmask&~s);
     150  dest += GBA_LCD_WIDTH/sizeof(uint32_t);
     151
     152  s = *src++;
     153  *dest = (fmask&s) | (bmask&~s);
     154  dest += GBA_LCD_WIDTH/sizeof(uint32_t);
    136155}
    137156
     
    145164void gba_textattr(int _attr)
    146165{
    147     _textattr = _attr;
     166  _textattr = _attr;
    148167}
    149168
     
    153172 *  @param  _color backround color
    154173 *  @return None
    155 
     174 *
    156175 */
    157176void gba_textbackground(int _color)
    158177{
    159     _textattr = (_textattr & 0x0F) | (_color << 4);
     178  _textattr = (_textattr & 0x0F) | (_color << 4);
    160179}
    161180
     
    168187void gba_textcolor(int _color)
    169188{
    170     _textattr = (_textattr & 0xF0) | (_color);
    171 }
    172 
    173 
    174 /**
    175  *  @brief gba_clearline function clear line nro y
     189  _textattr = (_textattr & 0xF0) | (_color);
     190}
     191
     192
     193/**
     194 *  @brief gba_clearline function clear line number y
    176195 *
    177196 *  Line is filled with spaces
     
    180199 *  @return None
    181200 */
    182 void gba_clearline(int y)
    183 {
    184     int x;
    185 
    186     for (x=0 ; x<=W ; x++) {
    187        gba_putchar(0, _textattr, x, y);
    188     }
     201static void gba_clearline(int y)
     202{
     203  int x;
     204
     205  for (x=0 ; x<=W ; x++) {
     206     gba_putchar(0, _textattr, x, y);
     207  }
    189208}
    190209
     
    195214 *  @return None
    196215 */
    197 void gba_nextline(void)
     216static void gba_nextline(void)
    198217{
    199218    _wherex = 0;
     
    227246 *  @return None
    228247 */
    229 void gba_put(char _c)
     248static void gba_put(char _c)
    230249{
    231250  /* We have save some memory with reduced fonts */
     
    335354void gba_textmode(int _mode)
    336355{
    337     switch (_mode) {
    338         case CO60:
    339         {
    340             gba_initconio();
    341             break;
    342         }
    343     }
     356  switch (_mode) {
     357    case CO60: {
     358      gba_initconio();
     359      break;
     360    }
     361  }
    344362}
    345363
     
    351369 *  @return None
    352370 */
    353 void delay_loop(unsigned int count)
    354 {
    355     int i;
    356     for (i = 0; i<count; i++) i = i;
     371static void delay_loop(unsigned int count)
     372{
     373  int i;
     374
     375  for (i = 0; i<count; i++) i = i;
    357376}
    358377
     
    361380 *  @brief gba_getch function read char from game pad keys
    362381 *
    363  *  Character input is done with GBA buttons, up-down-left-right/A/B/R/L/Select/Start
     382 *  Character input is done with GBA buttons,
     383 *      up-down-left-right/A/B/R/L/Select/Start
    364384 *  - Select-key accept selected character
    365385 *  - Start-key read CR (Enter)
     
    381401
    382402  while(1) {
    383       key = GBA_KEY();
    384       while ( (keyx=GBA_KEY())==key );
    385       switch (key)
    386       {
    387         case GBA_KEY_SELECT:
    388             gba_put(inputch);
    389             return inputch;
    390             break;
    391         case GBA_KEY_START:
    392             gba_put(' ');
    393             inputch = ASCII_CR;
    394             return inputch;
    395             break;
    396         case GBA_KEY_A:
    397             inputch = 'A';
    398             break;
    399         case GBA_KEY_B:
    400             inputch = 'Z';
    401             break;
    402         case GBA_KEY_UP:
    403             if ((inputch-1) >= 0x20) inputch--;
    404             break;
    405         case GBA_KEY_DOWN:
    406             if ((inputch+1) <=  0x7E) inputch++;
    407             break;
    408         case GBA_KEY_LEFT:
    409             if ((inputch - 0x20) >= 0x20) inputch -= 0x20;
    410             break;
    411         case GBA_KEY_RIGHT:
    412             if ((inputch + 0x20) <= 0x7E) inputch += 0x20;
    413             break;
    414         case GBA_KEY_R:
    415             inputch = '1';
    416             break;
    417         case GBA_KEY_L:
    418             inputch = '9';
    419             break;
    420         default:
    421             break;
    422       }
    423       gba_put(inputch);
    424       delay_loop(1000);
     403    key = GBA_KEY();
     404    while ( (keyx=GBA_KEY())==key );
     405    switch (key) {
     406      case GBA_KEY_SELECT:
     407        gba_put(inputch);
     408        return inputch;
     409        break;
     410      case GBA_KEY_START:
     411        gba_put(' ');
     412        inputch = ASCII_CR;
     413        return inputch;
     414        break;
     415      case GBA_KEY_A:
     416        inputch = 'A';
     417        break;
     418      case GBA_KEY_B:
     419        inputch = 'Z';
     420        break;
     421      case GBA_KEY_UP:
     422        if ((inputch-1) >= 0x20) inputch--;
     423        break;
     424      case GBA_KEY_DOWN:
     425        if ((inputch+1) <=  0x7E) inputch++;
     426        break;
     427      case GBA_KEY_LEFT:
     428        if ((inputch - 0x20) >= 0x20) inputch -= 0x20;
     429        break;
     430      case GBA_KEY_RIGHT:
     431        if ((inputch + 0x20) <= 0x7E) inputch += 0x20;
     432        break;
     433      case GBA_KEY_R:
     434        inputch = '1';
     435        break;
     436      case GBA_KEY_L:
     437        inputch = '9';
     438        break;
     439      default:
     440        break;
     441    }
     442
     443    gba_put(inputch);
     444    delay_loop(1000);
    425445  }
    426446}
  • c/src/lib/libbsp/arm/gba/console/console.c

    r5ad38eac rff8922c  
    44 *  This file contains the GBA console I/O package.
    55 */
     6
    67/*
    78 *  RTEMS GBA BSP
     
    3536static int gba_pollRead(int minor)
    3637{
    37     return(gba_getch());
     38  return (gba_getch());
    3839}
    3940
     
    5354
    5455  for (i=0;i<len;i++) {
    55      gba_putch((unsigned short)buf[i]);
     56    gba_putch((unsigned short)buf[i]);
    5657  }
    5758  return len;
     
    8687 */
    8788rtems_device_driver
    88 console_initialize(rtems_device_major_number  major,
    89                    rtems_device_minor_number  minor,
    90                    void                      *arg)
     89console_initialize(
     90  rtems_device_major_number  major,
     91  rtems_device_minor_number  minor,
     92  void                      *arg
     93)
    9194{
    9295  rtems_status_code status;
     
    9699
    97100  /* Do device-specific initialization  */
    98   /* Allready done in bspstart.c -> gba_textmode(CO60); */
     101  /* Already done in bspstart.c -> gba_textmode(CO60); */
    99102
    100103  /* Register the device */
    101104  status = rtems_io_register_name ("/dev/console", major, 0);
    102105  if (status != RTEMS_SUCCESSFUL) {
    103       printk("Error registering console device!\n");
    104       rtems_fatal_error_occurred (status);
     106    printk("Error registering console device!\n");
     107    rtems_fatal_error_occurred (status);
    105108  }
    106109
     
    120123static int console_first_open(int major, int minor, void *arg)
    121124{
    122     return 0;
     125  return 0;
    123126}
    124127
     
    133136static int console_last_close(int major, int minor, void *arg)
    134137{
    135     return 0;
    136 }
    137 
     138  return 0;
     139}
    138140
    139141/**
     
    146148 */
    147149rtems_device_driver
    148 console_open(rtems_device_major_number major,
    149              rtems_device_minor_number minor,
    150              void                      *arg)
     150console_open(
     151  rtems_device_major_number major,
     152  rtems_device_minor_number minor,
     153  void                      *arg
     154)
    151155{
    152156  rtems_status_code              status;
     
    166170
    167171  if (status != RTEMS_SUCCESSFUL) {
    168       printk("Error openning console device\n");
    169       return status;
     172    printk("Error openning console device\n");
     173    return status;
    170174  }
    171175
     
    182186 */
    183187rtems_device_driver
    184 console_close(rtems_device_major_number major,
    185               rtems_device_minor_number minor,
    186               void                      *arg)
     188console_close(
     189  rtems_device_major_number major,
     190  rtems_device_minor_number minor,
     191  void                      *arg
     192)
    187193{
    188194  rtems_device_driver res = RTEMS_SUCCESSFUL;
     
    204210 */
    205211rtems_device_driver
    206 console_read(rtems_device_major_number major,
    207              rtems_device_minor_number minor,
    208              void                      *arg)
    209 {
    210 
    211     return rtems_termios_read (arg);
    212 
     212console_read(
     213  rtems_device_major_number major,
     214  rtems_device_minor_number minor,
     215  void                      *arg
     216)
     217{
     218  return rtems_termios_read (arg);
    213219}
    214220
     
    224230*/
    225231rtems_device_driver
    226 console_write(rtems_device_major_number major,
    227               rtems_device_minor_number minor,
    228               void                      *arg)
    229 {
    230     return rtems_termios_write (arg);
     232console_write(
     233  rtems_device_major_number major,
     234  rtems_device_minor_number minor,
     235  void                      *arg
     236)
     237{
     238  return rtems_termios_write (arg);
    231239}
    232240
     
    240248 */
    241249rtems_device_driver
    242 console_control(rtems_device_major_number major,
    243                 rtems_device_minor_number minor,
    244                 void                      *arg
    245 )
    246 {
    247     return rtems_termios_ioctl (arg);
    248 }
     250console_control(
     251  rtems_device_major_number major,
     252  rtems_device_minor_number minor,
     253  void                      *arg
     254)
     255{
     256  return rtems_termios_ioctl (arg);
     257}
Note: See TracChangeset for help on using the changeset viewer.