Diff for /src/sys/bus/usb/hid.c between versions 1.3 and 1.4

version 1.3, 2003/08/07 21:16:47 version 1.4, 2003/12/30 01:01:44
Line 1 Line 1
/*        $NetBSD: hid.c,v 1.15 2000/04/27 15:26:46 augustss Exp $  *//*
/*        $FreeBSD: src/sys/dev/usb/hid.c,v 1.11.2.6 2002/11/06 14:03:37 joe Exp $ */ * $NetBSD: hid.c,v 1.17 2001/11/13 06:24:53 lukem Exp $
/*        $DragonFly$ */ * $FreeBSD: src/sys/dev/usb/hid.c,v 1.23 2003/08/24 17:55:54 obrien Exp $
 * $DragonFly$
  */
 /*  /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.   * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.   * All rights reserved.
Line 45 Line 46
 #include <sys/kernel.h>  #include <sys/kernel.h>
 #endif  #endif
 #include <sys/malloc.h>  #include <sys/malloc.h>
 
 #include "usb.h"  #include "usb.h"
 #include "usbhid.h"  #include "usbhid.h"
   
Line 79  struct hid_data { Line 80  struct hid_data {
 Static void  Static void
 hid_clear_local(struct hid_item *c)  hid_clear_local(struct hid_item *c)
 {  {
   
         c->usage = 0;          c->usage = 0;
         c->usage_minimum = 0;          c->usage_minimum = 0;
         c->usage_maximum = 0;          c->usage_maximum = 0;
Line 96  hid_start_parse(void *d, int len, int ki Line 98  hid_start_parse(void *d, int len, int ki
 {  {
         struct hid_data *s;          struct hid_data *s;
   
        s = malloc(sizeof *s, M_TEMP, M_WAITOK);        s = malloc(sizeof *s, M_TEMP, M_WAITOK|M_ZERO);
        memset(s, 0, sizeof *s); 
         s->start = s->p = d;          s->start = s->p = d;
         s->end = (char *)d + len;          s->end = (char *)d + len;
         s->kindset = kindset;          s->kindset = kindset;
Line 107  hid_start_parse(void *d, int len, int ki Line 108  hid_start_parse(void *d, int len, int ki
 void  void
 hid_end_parse(struct hid_data *s)  hid_end_parse(struct hid_data *s)
 {  {
   
         while (s->cur.next != NULL) {          while (s->cur.next != NULL) {
                 struct hid_item *hi = s->cur.next->next;                  struct hid_item *hi = s->cur.next->next;
                 free(s->cur.next, M_TEMP);                  free(s->cur.next, M_TEMP);
Line 189  hid_get_item(struct hid_data *s, struct Line 191  hid_get_item(struct hid_data *s, struct
                         printf("BAD LENGTH %d\n", bSize);                          printf("BAD LENGTH %d\n", bSize);
                         continue;                          continue;
                 }                  }
                
                 switch (bType) {                  switch (bType) {
                 case 0:                 /* Main */                  case 0:                 /* Main */
                         switch (bTag) {                          switch (bTag) {
Line 204  hid_get_item(struct hid_data *s, struct Line 206  hid_get_item(struct hid_data *s, struct
                                         s->multi = 0;                                          s->multi = 0;
                                         c->loc.count = 1;                                          c->loc.count = 1;
                                         if (s->minset) {                                          if (s->minset) {
                                                for (i = c->usage_minimum;                                                 for (i = c->usage_minimum;
                                                     i <= c->usage_maximum;                                                      i <= c->usage_maximum;
                                                      i++) {                                                       i++) {
                                                         s->usages[s->nu] = i;                                                          s->usages[s->nu] = i;
                                                         if (s->nu < MAXUSAGE-1)                                                          if (s->nu < MAXUSAGE-1)
Line 217  hid_get_item(struct hid_data *s, struct Line 219  hid_get_item(struct hid_data *s, struct
                                 } else {                                  } else {
                                         *h = *c;                                          *h = *c;
                                         h->next = 0;                                          h->next = 0;
                                        c->loc.pos +=                                         c->loc.pos +=
                                                 c->loc.size * c->loc.count;                                                  c->loc.size * c->loc.count;
                                         hid_clear_local(c);                                          hid_clear_local(c);
                                         s->minset = 0;                                          s->minset = 0;
Line 307  hid_get_item(struct hid_data *s, struct Line 309  hid_get_item(struct hid_data *s, struct
                 case 2:         /* Local */                  case 2:         /* Local */
                         switch (bTag) {                          switch (bTag) {
                         case 0:                          case 0:
                                if (bSize == 1)                                 if (bSize == 1)
                                         dval = c->_usage_page | (dval&0xff);                                          dval = c->_usage_page | (dval&0xff);
                                else if (bSize == 2)                                 else if (bSize == 2)
                                         dval = c->_usage_page | (dval&0xffff);                                          dval = c->_usage_page | (dval&0xffff);
                                 c->usage = dval;                                  c->usage = dval;
                                 if (s->nu < MAXUSAGE)                                  if (s->nu < MAXUSAGE)
Line 318  hid_get_item(struct hid_data *s, struct Line 320  hid_get_item(struct hid_data *s, struct
                                 break;                                  break;
                         case 1:                          case 1:
                                 s->minset = 1;                                  s->minset = 1;
                                if (bSize == 1)                                 if (bSize == 1)
                                         dval = c->_usage_page | (dval&0xff);                                          dval = c->_usage_page | (dval&0xff);
                                else if (bSize == 2)                                 else if (bSize == 2)
                                         dval = c->_usage_page | (dval&0xffff);                                          dval = c->_usage_page | (dval&0xffff);
                                 c->usage_minimum = dval;                                  c->usage_minimum = dval;
                                 break;                                  break;
                         case 2:                          case 2:
                                if (bSize == 1)                                 if (bSize == 1)
                                         dval = c->_usage_page | (dval&0xff);                                          dval = c->_usage_page | (dval&0xff);
                                else if (bSize == 2)                                 else if (bSize == 2)
                                         dval = c->_usage_page | (dval&0xffff);                                          dval = c->_usage_page | (dval&0xffff);
                                 c->usage_maximum = dval;                                  c->usage_maximum = dval;
                                 break;                                  break;
Line 421  hid_get_data(u_char *buf, struct hid_loc Line 423  hid_get_data(u_char *buf, struct hid_loc
                 return (0);                  return (0);
   
         data = 0;          data = 0;
        s = hpos / 8;         s = hpos / 8;
         for (i = hpos; i < hpos+hsize; i += 8)          for (i = hpos; i < hpos+hsize; i += 8)
                 data |= buf[i / 8] << ((i / 8 - s) * 8);                  data |= buf[i / 8] << ((i / 8 - s) * 8);
         data >>= hpos % 8;          data >>= hpos % 8;
Line 429  hid_get_data(u_char *buf, struct hid_loc Line 431  hid_get_data(u_char *buf, struct hid_loc
         hsize = 32 - hsize;          hsize = 32 - hsize;
         /* Sign extend */          /* Sign extend */
         data = ((int32_t)data << hsize) >> hsize;          data = ((int32_t)data << hsize) >> hsize;
        DPRINTFN(10,("hid_get_data: loc %d/%d = %lu\n",         DPRINTFN(10,("hid_get_data: loc %d/%d = %lu\n",
                     loc->pos, loc->size, (long)data));                      loc->pos, loc->size, (long)data));
         return (data);          return (data);
 }  }

Removed from v.1.3  
changed lines
  Added in v.1.4