Diff for /qemu/hw/pxa2xx_keypad.c between versions 1.1.1.8 and 1.1.1.9

version 1.1.1.8, 2018/04/24 19:28:37 version 1.1.1.9, 2018/04/24 19:48:28
Line 6 Line 6
  *              or  <Akuster@mvista.com>   *              or  <Akuster@mvista.com>
  *   *
  * This code is licensed under the GPLv2.   * This code is licensed under the GPLv2.
    *
    * Contributions after 2012-01-13 are licensed under the terms of the
    * GNU GPL, version 2 or (at your option) any later version.
  */   */
   
 #include "hw.h"  #include "hw.h"
Line 80 Line 83
 #define PXAKBD_MAXCOL   8  #define PXAKBD_MAXCOL   8
   
 struct PXA2xxKeyPadState {  struct PXA2xxKeyPadState {
       MemoryRegion iomem;
     qemu_irq    irq;      qemu_irq    irq;
     struct  keymap *map;      struct  keymap *map;
     int         pressed_cnt;      int         pressed_cnt;
Line 125  static void pxa27x_keyboard_event (PXA2x Line 129  static void pxa27x_keyboard_event (PXA2x
     if(!(kp->kpc & KPC_ME)) /* skip if not enabled */      if(!(kp->kpc & KPC_ME)) /* skip if not enabled */
         return;          return;
   
     if(kp->kpc & KPC_AS || kp->kpc & KPC_ASACT) {      rel = (keycode & 0x80) ? 1 : 0; /* key release from qemu */
         if(kp->kpc & KPC_AS)      keycode &= ~0x80; /* strip qemu key release bit */
             kp->kpc &= ~(KPC_AS);      if (kp->alt_code) {
           keycode |= 0x80;
         rel = (keycode & 0x80) ? 1 : 0; /* key release from qemu */          kp->alt_code = 0;
         keycode &= ~(0x80); /* strip qemu key release bit */      }
         if (kp->alt_code) {  
             keycode |= 0x80;  
             kp->alt_code = 0;  
         }  
   
         row = kp->map[keycode].row;      row = kp->map[keycode].row;
         col = kp->map[keycode].column;      col = kp->map[keycode].column;
         if(row == -1 || col == -1)      if (row == -1 || col == -1) {
             return;          return;
       }
   
         val = KPASMKPx_MKC(row, col);      val = KPASMKPx_MKC(row, col);
         if (rel) {      if (rel) {
             if (kp->kpasmkp[col / 2] & val) {          if (kp->kpasmkp[col / 2] & val) {
                 kp->kpasmkp[col / 2] &= ~val;              kp->kpasmkp[col / 2] &= ~val;
                 kp->pressed_cnt--;              kp->pressed_cnt--;
                 assert_irq = 1;              assert_irq = 1;
             }  
         } else {  
             if (!(kp->kpasmkp[col / 2] & val)) {  
                 kp->kpasmkp[col / 2] |= val;  
                 kp->pressed_cnt++;  
                 assert_irq = 1;  
             }  
         }          }
         kp->kpas = ((kp->pressed_cnt & 0x1f) << 26) | (0xf << 4) | 0xf;      } else {
         if (kp->pressed_cnt == 1) {          if (!(kp->kpasmkp[col / 2] & val)) {
             kp->kpas &= ~((0xf << 4) | 0xf);              kp->kpasmkp[col / 2] |= val;
             if (rel)              kp->pressed_cnt++;
                 pxa27x_keypad_find_pressed_key(kp, &row, &col);              assert_irq = 1;
             kp->kpas |= ((row & 0xf) << 4) | (col & 0xf);  
         }          }
         goto out;  
     }      }
     return;      kp->kpas = ((kp->pressed_cnt & 0x1f) << 26) | (0xf << 4) | 0xf;
       if (kp->pressed_cnt == 1) {
           kp->kpas &= ~((0xf << 4) | 0xf);
           if (rel) {
               pxa27x_keypad_find_pressed_key(kp, &row, &col);
           }
           kp->kpas |= ((row & 0xf) << 4) | (col & 0xf);
       }
   
       if (!(kp->kpc & (KPC_AS | KPC_ASACT)))
           assert_irq = 0;
   
 out:  
     if (assert_irq && (kp->kpc & KPC_MIE)) {      if (assert_irq && (kp->kpc & KPC_MIE)) {
         kp->kpc |= KPC_MI;          kp->kpc |= KPC_MI;
         qemu_irq_raise(kp->irq);          qemu_irq_raise(kp->irq);
Line 174  out: Line 175  out:
     return;      return;
 }  }
   
 static uint32_t pxa2xx_keypad_read(void *opaque, target_phys_addr_t offset)  static uint64_t pxa2xx_keypad_read(void *opaque, target_phys_addr_t offset,
                                      unsigned size)
 {  {
     PXA2xxKeyPadState *s = (PXA2xxKeyPadState *) opaque;      PXA2xxKeyPadState *s = (PXA2xxKeyPadState *) opaque;
     uint32_t tmp;      uint32_t tmp;
Line 235  static uint32_t pxa2xx_keypad_read(void  Line 237  static uint32_t pxa2xx_keypad_read(void 
     return 0;      return 0;
 }  }
   
 static void pxa2xx_keypad_write(void *opaque,  static void pxa2xx_keypad_write(void *opaque, target_phys_addr_t offset,
                 target_phys_addr_t offset, uint32_t value)                                  uint64_t value, unsigned size)
 {  {
     PXA2xxKeyPadState *s = (PXA2xxKeyPadState *) opaque;      PXA2xxKeyPadState *s = (PXA2xxKeyPadState *) opaque;
   
     switch (offset) {      switch (offset) {
     case KPC:      case KPC:
         s->kpc = value;          s->kpc = value;
           if (s->kpc & KPC_AS) {
               s->kpc &= ~(KPC_AS);
           }
         break;          break;
     case KPDK:      case KPDK:
         s->kpdk = value;          s->kpdk = value;
Line 277  static void pxa2xx_keypad_write(void *op Line 282  static void pxa2xx_keypad_write(void *op
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_keypad_readfn[] = {  static const MemoryRegionOps pxa2xx_keypad_ops = {
     pxa2xx_keypad_read,      .read = pxa2xx_keypad_read,
     pxa2xx_keypad_read,      .write = pxa2xx_keypad_write,
     pxa2xx_keypad_read      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_keypad_writefn[] = {  
     pxa2xx_keypad_write,  
     pxa2xx_keypad_write,  
     pxa2xx_keypad_write  
 };  };
   
 static const VMStateDescription vmstate_pxa2xx_keypad = {  static const VMStateDescription vmstate_pxa2xx_keypad = {
Line 306  static const VMStateDescription vmstate_ Line 305  static const VMStateDescription vmstate_
     }      }
 };  };
   
 PXA2xxKeyPadState *pxa27x_keypad_init(target_phys_addr_t base,  PXA2xxKeyPadState *pxa27x_keypad_init(MemoryRegion *sysmem,
         qemu_irq irq)                                        target_phys_addr_t base,
                                         qemu_irq irq)
 {  {
     int iomemtype;  
     PXA2xxKeyPadState *s;      PXA2xxKeyPadState *s;
   
     s = (PXA2xxKeyPadState *) g_malloc0(sizeof(PXA2xxKeyPadState));      s = (PXA2xxKeyPadState *) g_malloc0(sizeof(PXA2xxKeyPadState));
     s->irq = irq;      s->irq = irq;
   
     iomemtype = cpu_register_io_memory(pxa2xx_keypad_readfn,      memory_region_init_io(&s->iomem, &pxa2xx_keypad_ops, s,
                     pxa2xx_keypad_writefn, s, DEVICE_NATIVE_ENDIAN);                            "pxa2xx-keypad", 0x00100000);
     cpu_register_physical_memory(base, 0x00100000, iomemtype);      memory_region_add_subregion(sysmem, base, &s->iomem);
   
     vmstate_register(NULL, 0, &vmstate_pxa2xx_keypad, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_keypad, s);
   

Removed from v.1.1.1.8  
changed lines
  Added in v.1.1.1.9


unix.superglobalmegacorp.com