Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=1b726a02d97cef2471521ae6947416f7374c6590
Commit:     1b726a02d97cef2471521ae6947416f7374c6590
Parent:     55d29c98418df737e87dbdfc36c78d3ed99a6698
Author:     Dmitry Torokhov <[EMAIL PROTECTED]>
AuthorDate: Thu Apr 12 01:33:00 2007 -0400
Committer:  Dmitry Torokhov <[EMAIL PROTECTED]>
CommitDate: Thu Apr 12 01:33:00 2007 -0400

    Input: gtco - handle errors from input_register_device()
    
    Also fix URB leak in gtco_probe error path, formatting fixes.
    
    Signed-off-by: Dmitry Torokhov <[EMAIL PROTECTED]>
---
 drivers/usb/input/gtco.c |  627 +++++++++++++++++++++-------------------------
 1 files changed, 289 insertions(+), 338 deletions(-)

diff --git a/drivers/usb/input/gtco.c b/drivers/usb/input/gtco.c
index 203cdc1..aa9c676 100644
--- a/drivers/usb/input/gtco.c
+++ b/drivers/usb/input/gtco.c
@@ -187,7 +187,6 @@ struct hid_descriptor
 
 
 /*
- *
  *   This is an abbreviated parser for the HID Report Descriptor.  We
  *   know what devices we are talking to, so this is by no means meant
  *   to be generic.  We can make some safe assumptions:
@@ -204,7 +203,7 @@ struct hid_descriptor
 static void parse_hid_report_descriptor(struct gtco *device, char * report,
                                        int length)
 {
-       int   x,i=0;
+       int   x, i = 0;
 
        /* Tag primitive vars */
        __u8   prefix;
@@ -215,7 +214,6 @@ static void parse_hid_report_descriptor(struct gtco 
*device, char * report,
        __u16  data16 = 0;
        __u32  data32 = 0;
 
-
        /* For parsing logic */
        int   inputnum = 0;
        __u32 usage = 0;
@@ -227,44 +225,44 @@ static void parse_hid_report_descriptor(struct gtco 
*device, char * report,
        /* Debug stuff */
        char  maintype='x';
        char  globtype[12];
-       int   indent=0;
-       char  indentstr[10]="";
-
+       int   indent = 0;
+       char  indentstr[10] = "";
 
 
        dbg("======>>>>>>PARSE<<<<<<======");
 
        /* Walk  this report and pull out the info we need */
-       while (i<length){
-               prefix=report[i];
+       while (i < length) {
+               prefix = report[i];
 
                /* Skip over prefix */
                i++;
 
                /* Determine data size and save the data in the proper variable 
*/
                size = PREF_SIZE(prefix);
-               switch(size){
+               switch (size) {
                case 1:
                        data = report[i];
                        break;
                case 2:
-                       data16 = 
le16_to_cpu(get_unaligned((__le16*)(&(report[i]))));
+                       data16 = le16_to_cpu(get_unaligned((__le16 
*)&report[i]));
                        break;
                case 3:
                        size = 4;
-                       data32 = 
le32_to_cpu(get_unaligned((__le32*)(&(report[i]))));
+                       data32 = le32_to_cpu(get_unaligned((__le32 
*)&report[i]));
+                       break;
                }
 
                /* Skip size of data */
-               i+=size;
+               i += size;
 
                /* What we do depends on the tag type */
                tag  = PREF_TAG(prefix);
                type = PREF_TYPE(prefix);
-               switch(type){
+               switch (type) {
                case TYPE_MAIN:
-                       strcpy(globtype,"");
-                       switch(tag){
+                       strcpy(globtype, "");
+                       switch (tag) {
 
                        case TAG_MAIN_INPUT:
                                /*
@@ -274,19 +272,17 @@ static void parse_hid_report_descriptor(struct gtco 
*device, char * report,
                                 * min/max values
                                 */
 
-                               maintype='I';
-                               if (data==2){
-                                       strcpy(globtype,"Variable");
-                               }
-                               if (data==3){
-                                       strcpy(globtype,"Var|Const");
-                               }
+                               maintype = 'I';
+                               if (data == 2)
+                                       strcpy(globtype, "Variable");
+                               else if (data == 3)
+                                       strcpy(globtype, "Var|Const");
 
                                dbg("::::: Saving Report: %d input #%d Max: 
0x%X(%d) Min:0x%X(%d) of %d bits",
-                                   globalval[TAG_GLOB_REPORT_ID],inputnum,
-                                   
globalval[TAG_GLOB_LOG_MAX],globalval[TAG_GLOB_LOG_MAX],
-                                   
globalval[TAG_GLOB_LOG_MIN],globalval[TAG_GLOB_LOG_MIN],
-                                   (globalval[TAG_GLOB_REPORT_SZ] * 
globalval[TAG_GLOB_REPORT_CNT]));
+                                   globalval[TAG_GLOB_REPORT_ID], inputnum,
+                                   globalval[TAG_GLOB_LOG_MAX], 
globalval[TAG_GLOB_LOG_MAX],
+                                   globalval[TAG_GLOB_LOG_MIN], 
globalval[TAG_GLOB_LOG_MIN],
+                                   globalval[TAG_GLOB_REPORT_SZ] * 
globalval[TAG_GLOB_REPORT_CNT]);
 
 
                                /*
@@ -295,43 +291,43 @@ static void parse_hid_report_descriptor(struct gtco 
*device, char * report,
                                  that, we look for everything else by
                                  local usage value
                                 */
-                               switch (inputnum){
+                               switch (inputnum) {
                                case 0:  /* X coord */
-                                       dbg("GER: X Usage: 0x%x",usage);
-                                       if (device->max_X == 0){
+                                       dbg("GER: X Usage: 0x%x", usage);
+                                       if (device->max_X == 0) {
                                                device->max_X = 
globalval[TAG_GLOB_LOG_MAX];
                                                device->min_X = 
globalval[TAG_GLOB_LOG_MIN];
                                        }
-
                                        break;
+
                                case 1:  /* Y coord */
-                                       dbg("GER: Y Usage: 0x%x",usage);
-                                       if (device->max_Y == 0){
+                                       dbg("GER: Y Usage: 0x%x", usage);
+                                       if (device->max_Y == 0) {
                                                device->max_Y = 
globalval[TAG_GLOB_LOG_MAX];
                                                device->min_Y = 
globalval[TAG_GLOB_LOG_MIN];
                                        }
                                        break;
+
                                default:
                                        /* Tilt X */
-                                       if (usage == DIGITIZER_USAGE_TILT_X){
-                                               if (device->maxtilt_X == 0){
+                                       if (usage == DIGITIZER_USAGE_TILT_X) {
+                                               if (device->maxtilt_X == 0) {
                                                        device->maxtilt_X = 
globalval[TAG_GLOB_LOG_MAX];
                                                        device->mintilt_X = 
globalval[TAG_GLOB_LOG_MIN];
                                                }
                                        }
 
                                        /* Tilt Y */
-                                       if (usage == DIGITIZER_USAGE_TILT_Y){
-                                               if (device->maxtilt_Y == 0){
+                                       if (usage == DIGITIZER_USAGE_TILT_Y) {
+                                               if (device->maxtilt_Y == 0) {
                                                        device->maxtilt_Y = 
globalval[TAG_GLOB_LOG_MAX];
                                                        device->mintilt_Y = 
globalval[TAG_GLOB_LOG_MIN];
                                                }
                                        }
 
-
                                        /* Pressure */
-                                       if (usage == 
DIGITIZER_USAGE_TIP_PRESSURE){
-                                               if (device->maxpressure == 0){
+                                       if (usage == 
DIGITIZER_USAGE_TIP_PRESSURE) {
+                                               if (device->maxpressure == 0) {
                                                        device->maxpressure = 
globalval[TAG_GLOB_LOG_MAX];
                                                        device->minpressure = 
globalval[TAG_GLOB_LOG_MIN];
                                                }
@@ -341,192 +337,206 @@ static void parse_hid_report_descriptor(struct gtco 
*device, char * report,
                                }
 
                                inputnum++;
-
-
                                break;
+
                        case TAG_MAIN_OUTPUT:
-                               maintype='O';
+                               maintype = 'O';
                                break;
+
                        case TAG_MAIN_FEATURE:
-                               maintype='F';
+                               maintype = 'F';
                                break;
+
                        case TAG_MAIN_COL_START:
-                               maintype='S';
+                               maintype = 'S';
 
-                               if (data==0){
+                               if (data == 0) {
                                        dbg("======>>>>>> Physical");
-                                       strcpy(globtype,"Physical");
-                               }else{
+                                       strcpy(globtype, "Physical");
+                               } else
                                        dbg("======>>>>>>");
-                               }
 
                                /* Indent the debug output */
                                indent++;
-                               for (x=0;x<indent;x++){
-                                       indentstr[x]='-';
-                               }
-                               indentstr[x]=0;
+                               for (x = 0; x < indent; x++)
+                                       indentstr[x] = '-';
+                               indentstr[x] = 0;
 
                                /* Save global tags */
-                               for (x=0;x<TAG_GLOB_MAX;x++){
+                               for (x = 0; x < TAG_GLOB_MAX; x++)
                                        oldval[x] = globalval[x];
-                               }
 
                                break;
+
                        case TAG_MAIN_COL_END:
                                dbg("<<<<<<======");
-                               maintype='E';
+                               maintype = 'E';
                                indent--;
-                               for (x=0;x<indent;x++){
-                                       indentstr[x]='-';
-                               }
-                               indentstr[x]=0;
+                               for (x = 0; x < indent; x++)
+                                       indentstr[x] = '-';
+                               indentstr[x] = 0;
 
                                /* Copy global tags back */
-                               for (x=0;x<TAG_GLOB_MAX;x++){
+                               for (x = 0; x < TAG_GLOB_MAX; x++)
                                        globalval[x] = oldval[x];
-                               }
 
                                break;
                        }
 
-                       switch (size){
+                       switch (size) {
                        case 1:
                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
-                                   indentstr,tag,maintype,size,globtype,data);
+                                   indentstr, tag, maintype, size, globtype, 
data);
                                break;
+
                        case 2:
                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
-                                   indentstr,tag,maintype,size,globtype, 
data16);
+                                   indentstr, tag, maintype, size, globtype, 
data16);
                                break;
+
                        case 4:
                                dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
-                                   
indentstr,tag,maintype,size,globtype,data32);
+                                   indentstr, tag, maintype, size, globtype, 
data32);
                                break;
                        }
                        break;
+
                case TYPE_GLOBAL:
-                       switch(tag){
+                       switch (tag) {
                        case TAG_GLOB_USAGE:
                                /*
                                 * First time we hit the global usage tag,
                                 * it should tell us the type of device
                                 */
-                               if (device->usage == 0){
+                               if (device->usage == 0)
                                        device->usage = data;
-                               }
-                               strcpy(globtype,"USAGE");
+
+                               strcpy(globtype, "USAGE");
                                break;
-                       case TAG_GLOB_LOG_MIN   :
-                               strcpy(globtype,"LOG_MIN");
+
+                       case TAG_GLOB_LOG_MIN:
+                               strcpy(globtype, "LOG_MIN");
                                break;
-                       case TAG_GLOB_LOG_MAX   :
-                               strcpy(globtype,"LOG_MAX");
+
+                       case TAG_GLOB_LOG_MAX:
+                               strcpy(globtype, "LOG_MAX");
                                break;
-                       case TAG_GLOB_PHYS_MIN  :
-                               strcpy(globtype,"PHYS_MIN");
+
+                       case TAG_GLOB_PHYS_MIN:
+                               strcpy(globtype, "PHYS_MIN");
                                break;
-                       case TAG_GLOB_PHYS_MAX  :
-                               strcpy(globtype,"PHYS_MAX");
+
+                       case TAG_GLOB_PHYS_MAX:
+                               strcpy(globtype, "PHYS_MAX");
                                break;
-                       case TAG_GLOB_UNIT_EXP  :
-                               strcpy(globtype,"EXP");
+
+                       case TAG_GLOB_UNIT_EXP:
+                               strcpy(globtype, "EXP");
                                break;
-                       case TAG_GLOB_UNIT      :
-                               strcpy(globtype,"UNIT");
+
+                       case TAG_GLOB_UNIT:
+                               strcpy(globtype, "UNIT");
                                break;
-                       case TAG_GLOB_REPORT_SZ :
-                               strcpy(globtype,"REPORT_SZ");
+
+                       case TAG_GLOB_REPORT_SZ:
+                               strcpy(globtype, "REPORT_SZ");
                                break;
-                       case TAG_GLOB_REPORT_ID :
-                               strcpy(globtype,"REPORT_ID");
+
+                       case TAG_GLOB_REPORT_ID:
+                               strcpy(globtype, "REPORT_ID");
                                /* New report, restart numbering */
-                               inputnum=0;
+                               inputnum = 0;
                                break;
+
                        case TAG_GLOB_REPORT_CNT:
-                               strcpy(globtype,"REPORT_CNT");
+                               strcpy(globtype, "REPORT_CNT");
                                break;
-                       case TAG_GLOB_PUSH :
-                               strcpy(globtype,"PUSH");
+
+                       case TAG_GLOB_PUSH:
+                               strcpy(globtype, "PUSH");
                                break;
+
                        case TAG_GLOB_POP:
-                               strcpy(globtype,"POP");
+                               strcpy(globtype, "POP");
                                break;
                        }
 
-
                        /* Check to make sure we have a good tag number
                           so we don't overflow array */
-                       if (tag < TAG_GLOB_MAX){
-                               switch (size){
+                       if (tag < TAG_GLOB_MAX) {
+                               switch (size) {
                                case 1:
-                                       dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 
0x%x",indentstr,globtype,tag,size,data);
-                                       globalval[tag]=data;
+                                       dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 
0x%x",
+                                           indentstr, globtype, tag, size, 
data);
+                                       globalval[tag] = data;
                                        break;
+
                                case 2:
-                                       dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 
0x%x",indentstr,globtype,tag,size,data16);
-                                       globalval[tag]=data16;
+                                       dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 
0x%x",
+                                           indentstr, globtype, tag, size, 
data16);
+                                       globalval[tag] = data16;
                                        break;
+
                                case 4:
-                                       dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 
0x%x",indentstr,globtype,tag,size,data32);
-                                       globalval[tag]=data32;
+                                       dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 
0x%x",
+                                           indentstr, globtype, tag, size, 
data32);
+                                       globalval[tag] = data32;
                                        break;
                                }
-                       }else{
+                       } else {
                                dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
-                                   indentstr,tag,size);
+                                   indentstr, tag, size);
                        }
-
-
                        break;
 
                case TYPE_LOCAL:
-                       switch(tag){
+                       switch (tag) {
                        case TAG_GLOB_USAGE:
-                               strcpy(globtype,"USAGE");
+                               strcpy(globtype, "USAGE");
                                /* Always 1 byte */
                                usage = data;
                                break;
-                       case TAG_GLOB_LOG_MIN   :
-                               strcpy(globtype,"MIN");
+
+                       case TAG_GLOB_LOG_MIN:
+                               strcpy(globtype, "MIN");
                                break;
-                       case TAG_GLOB_LOG_MAX   :
-                               strcpy(globtype,"MAX");
+
+                       case TAG_GLOB_LOG_MAX:
+                               strcpy(globtype, "MAX");
                                break;
+
                        default:
-                               strcpy(globtype,"UNKNOWN");
+                               strcpy(globtype, "UNKNOWN");
+                               break;
                        }
 
-                       switch (size){
+                       switch (size) {
                        case 1:
                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
-                                   indentstr,tag,globtype,size,data);
+                                   indentstr, tag, globtype, size, data);
                                break;
+
                        case 2:
                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
-                                   indentstr,tag,globtype,size,data16);
+                                   indentstr, tag, globtype, size, data16);
                                break;
+
                        case 4:
                                dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
-                                   indentstr,tag,globtype,size,data32);
+                                   indentstr, tag, globtype, size, data32);
                                break;
                        }
 
                        break;
                }
-
        }
-
 }
 
-
-
 /*   INPUT DRIVER Routines                               */
 
-
 /*
- *    Called when opening the input device.  This will submit the URB to
- *    the usb system so we start getting reports
+ * Called when opening the input device.  This will submit the URB to
+ * the usb system so we start getting reports
  */
 static int gtco_input_open(struct input_dev *inputdev)
 {
@@ -534,21 +544,20 @@ static int gtco_input_open(struct input_dev *inputdev)
        device = inputdev->private;
 
        device->urbinfo->dev = device->usbdev;
-       if (usb_submit_urb(device->urbinfo, GFP_KERNEL)) {
+       if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
                return -EIO;
-       }
+
        return 0;
 }
 
-/**
-    Called when closing the input device.  This will unlink the URB
-*/
+/*
+ * Called when closing the input device.  This will unlink the URB
+ */
 static void gtco_input_close(struct input_dev *inputdev)
 {
        struct gtco *device = inputdev->private;
 
        usb_kill_urb(device->urbinfo);
-
 }
 
 
@@ -564,15 +573,12 @@ static void  gtco_setup_caps(struct input_dev  *inputdev)
 {
        struct gtco *device = inputdev->private;
 
-
        /* Which events */
        inputdev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC);
 
-
        /* Misc event menu block */
        inputdev->mscbit[0] = BIT(MSC_SCAN)|BIT(MSC_SERIAL)|BIT(MSC_RAW) ;
 
-
        /* Absolute values based on HID report info */
        input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
                             0, 0);
@@ -590,17 +596,12 @@ static void  gtco_setup_caps(struct input_dev  *inputdev)
        input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
                             device->maxpressure, 0, 0);
 
-
        /* Transducer */
-       input_set_abs_params(inputdev, ABS_MISC, 0,0xFF, 0, 0);
-
+       input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
 }
 
-
-
 /*   USB Routines  */
 
-
 /*
  * URB callback routine.  Called when we get IRQ reports from the
  *  digitizer.
@@ -610,9 +611,7 @@ static void  gtco_setup_caps(struct input_dev  *inputdev)
  */
 static void gtco_urb_callback(struct urb *urbinfo)
 {
-
-
-       struct gtco     *device = urbinfo->context;
+       struct gtco *device = urbinfo->context;
        struct input_dev  *inputdev;
        int               rc;
        u32               val = 0;
@@ -621,19 +620,20 @@ static void gtco_urb_callback(struct urb *urbinfo)
 
        inputdev = device->inputdevice;
 
-
        /* Was callback OK? */
-       if ((urbinfo->status == -ECONNRESET ) ||
-           (urbinfo->status == -ENOENT ) ||
-           (urbinfo->status == -ESHUTDOWN )){
+       if (urbinfo->status == -ECONNRESET ||
+           urbinfo->status == -ENOENT ||
+           urbinfo->status == -ESHUTDOWN) {
 
                /* Shutdown is occurring. Return and don't queue up any more */
                return;
        }
 
-       if (urbinfo->status != 0 ) {
-               /* Some unknown error.  Hopefully temporary.  Just go and */
-               /* requeue an URB */
+       if (urbinfo->status != 0) {
+               /*
+                * Some unknown error.  Hopefully temporary. Just go and
+                * requeue an URB
+                */
                goto resubmit;
        }
 
@@ -642,10 +642,9 @@ static void gtco_urb_callback(struct urb *urbinfo)
         */
 
        /* PID dependent when we interpret the report */
-       if ((inputdev->id.product == PID_1000 )||
-           (inputdev->id.product == PID_1001 )||
-           (inputdev->id.product == PID_1002 ))
-       {
+       if (inputdev->id.product == PID_1000 ||
+           inputdev->id.product == PID_1001 ||
+           inputdev->id.product == PID_1002) {
 
                /*
                 * Switch on the report ID
@@ -653,10 +652,10 @@ static void gtco_urb_callback(struct urb *urbinfo)
                 * the report number.  We can just fall through the case
                 * statements if we start with the highest number report
                 */
-               switch(device->buffer[0]){
+               switch (device->buffer[0]) {
                case 5:
                        /* Pressure is 9 bits */
-                       val =  ((u16)(device->buffer[8]) << 1);
+                       val = ((u16)(device->buffer[8]) << 1);
                        val |= (u16)(device->buffer[7] >> 7);
                        input_report_abs(inputdev, ABS_PRESSURE,
                                         device->buffer[8]);
@@ -664,7 +663,6 @@ static void gtco_urb_callback(struct urb *urbinfo)
                        /* Mask out the Y tilt value used for pressure */
                        device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
 
-
                        /* Fall thru */
                case 4:
                        /* Tilt */
@@ -684,11 +682,10 @@ static void gtco_urb_callback(struct urb *urbinfo)
                        input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
 
                        /* Fall thru */
-
                case 2:
                case 3:
                        /* Convert buttons, only 5 bits possible */
-                       val = (device->buffer[5])&MASK_BUTTON;
+                       val = (device->buffer[5]) & MASK_BUTTON;
 
                        /* We don't apply any meaning to the bitmask,
                           just report */
@@ -696,132 +693,109 @@ static void gtco_urb_callback(struct urb *urbinfo)
 
                        /*  Fall thru */
                case 1:
-
                        /* All reports have X and Y coords in the same place */
-                       val = le16_to_cpu(get_unaligned((__le16 *) 
&(device->buffer[1])));
+                       val = le16_to_cpu(get_unaligned((__le16 
*)&device->buffer[1]));
                        input_report_abs(inputdev, ABS_X, val);
 
-                       val = le16_to_cpu(get_unaligned((__le16 *) 
&(device->buffer[3])));
+                       val = le16_to_cpu(get_unaligned((__le16 
*)&device->buffer[3]));
                        input_report_abs(inputdev, ABS_Y, val);
 
-
                        /* Ditto for proximity bit */
-                       if (device->buffer[5]& MASK_INRANGE){
-                               val = 1;
-                       }else{
-                               val=0;
-                       }
+                       val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
                        input_report_abs(inputdev, ABS_DISTANCE, val);
 
-
                        /* Report 1 is an exception to how we handle buttons */
                        /* Buttons are an index, not a bitmask */
-                       if (device->buffer[0] == 1){
+                       if (device->buffer[0] == 1) {
 
-                               /* Convert buttons, 5 bit index */
-                               /* Report value of index set as one,
-                                  the rest as 0 */
-                               val = device->buffer[5]& MASK_BUTTON;
+                               /*
+                                * Convert buttons, 5 bit index
+                                * Report value of index set as one,
+                                * the rest as 0
+                                */
+                               val = device->buffer[5] & MASK_BUTTON;
                                dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
-                                   val,val);
+                                   val, val);
 
                                /*
                                 * We don't apply any meaning to the button
                                 * index, just report it
                                 */
                                input_event(inputdev, EV_MSC, MSC_SERIAL, val);
-
-
                        }
-
                        break;
+
                case 7:
                        /* Menu blocks */
                        input_event(inputdev, EV_MSC, MSC_SCAN,
                                    device->buffer[1]);
-
-
                        break;
-
                }
-
-
        }
+
        /* Other pid class */
-       if ((inputdev->id.product == PID_400 )||
-           (inputdev->id.product == PID_401 ))
-       {
+       if (inputdev->id.product == PID_400 ||
+           inputdev->id.product == PID_401) {
 
                /* Report 2 */
-               if (device->buffer[0] == 2){
+               if (device->buffer[0] == 2) {
                        /* Menu blocks */
-                       input_event(inputdev, EV_MSC, MSC_SCAN,
-                                   device->buffer[1]);
+                       input_event(inputdev, EV_MSC, MSC_SCAN, 
device->buffer[1]);
                }
 
                /*  Report 1 */
-               if (device->buffer[0] == 1){
+               if (device->buffer[0] == 1) {
                        char buttonbyte;
 
-
                        /*  IF X max > 64K, we still a bit from the y report */
-                       if (device->max_X > 0x10000){
+                       if (device->max_X > 0x10000) {
 
-                               val = 
(u16)(((u16)(device->buffer[2]<<8))|((u8)(device->buffer[1])));
-                               val |= (u32)(((u8)device->buffer[3]&0x1)<< 16);
+                               val = (u16)(((u16)(device->buffer[2] << 8)) | 
(u8)device->buffer[1]);
+                               val |= (u32)(((u8)device->buffer[3] & 0x1) << 
16);
 
                                input_report_abs(inputdev, ABS_X, val);
 
-                               le_buffer[0]  = 
(u8)((u8)(device->buffer[3])>>1);
-                               le_buffer[0] |= 
(u8)((device->buffer[3]&0x1)<<7);
-
-                               le_buffer[1]  = (u8)(device->buffer[4]>>1);
-                               le_buffer[1] |= 
(u8)((device->buffer[5]&0x1)<<7);
+                               le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 
1);
+                               le_buffer[0] |= (u8)((device->buffer[3] & 0x1) 
<< 7);
 
-                               val = le16_to_cpu(get_unaligned((__le16 
*)(le_buffer)));
+                               le_buffer[1]  = (u8)(device->buffer[4] >> 1);
+                               le_buffer[1] |= (u8)((device->buffer[5] & 0x1) 
<< 7);
 
+                               val = le16_to_cpu(get_unaligned((__le16 
*)le_buffer));
                                input_report_abs(inputdev, ABS_Y, val);
 
-
                                /*
                                 * Shift the button byte right by one to
                                 * make it look like the standard report
                                 */
-                               buttonbyte = (device->buffer[5])>>1;
-                       }else{
+                               buttonbyte = device->buffer[5] >> 1;
+                       } else {
 
-                               val = le16_to_cpu(get_unaligned((__le16 *) 
(&(device->buffer[1]))));
+                               val = le16_to_cpu(get_unaligned((__le16 
*)&device->buffer[1]));
                                input_report_abs(inputdev, ABS_X, val);
 
-                               val = le16_to_cpu(get_unaligned((__le16 *) 
(&(device->buffer[3]))));
+                               val = le16_to_cpu(get_unaligned((__le16 
*)&device->buffer[3]));
                                input_report_abs(inputdev, ABS_Y, val);
 
                                buttonbyte = device->buffer[5];
-
                        }
 
-
                        /* BUTTONS and PROXIMITY */
-                       if (buttonbyte& MASK_INRANGE){
-                               val = 1;
-                       }else{
-                               val=0;
-                       }
+                       val = buttonbyte & MASK_INRANGE ? 1 : 0;
                        input_report_abs(inputdev, ABS_DISTANCE, val);
 
                        /* Convert buttons, only 4 bits possible */
-                       val = buttonbyte&0x0F;
+                       val = buttonbyte & 0x0F;
 #ifdef USE_BUTTONS
-                       for ( i=0;i<5;i++){
-                               input_report_key(inputdev, 
BTN_DIGI+i,val&(1<<i));
-                       }
+                       for (i = 0; i < 5; i++)
+                               input_report_key(inputdev, BTN_DIGI + i, val & 
(1 << i));
 #else
                        /* We don't apply any meaning to the bitmask, just 
report */
                        input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 #endif
+
                        /* TRANSDUCER */
                        input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
-
                }
        }
 
@@ -833,10 +807,8 @@ static void gtco_urb_callback(struct urb *urbinfo)
 
  resubmit:
        rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
-       if (rc != 0) {
-               err("usb_submit_urb failed rc=0x%x",rc);
-       }
-
+       if (rc != 0)
+               err("usb_submit_urb failed rc=0x%x", rc);
 }
 
 /*
@@ -854,58 +826,46 @@ static int gtco_probe(struct usb_interface *usbinterface,
                      const struct usb_device_id *id)
 {
 
-       struct gtco             *device = NULL;
-       char                    path[PATHLENGTH];
-       struct input_dev        *inputdev;
+       struct gtco             *gtco;
+       struct input_dev        *input_dev;
        struct hid_descriptor   *hid_desc;
-       char                    *report;
-       int                     result=0, retry;
+       char                    *report = NULL;
+       int                     result = 0, retry;
+       int                     error;
        struct usb_endpoint_descriptor *endpoint;
 
        /* Allocate memory for device structure */
-       device = kzalloc(sizeof(struct gtco), GFP_KERNEL);
-       if (device == NULL) {
+       gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
+       input_dev = input_allocate_device();
+       if (!gtco || !input_dev) {
                err("No more memory");
-               return -ENOMEM;
+               error = -ENOMEM;
+               goto err_free_devs;
        }
 
-
-       device->inputdevice = input_allocate_device();
-       if (!device->inputdevice){
-               kfree(device);
-               err("No more memory");
-               return -ENOMEM;
-       }
-
-       /* Get pointer to the input device */
-       inputdev = device->inputdevice;
+       /* Set pointer to the input device */
+       gtco->inputdevice = input_dev;
 
        /* Save interface information */
-       device->usbdev     = usb_get_dev(interface_to_usbdev(usbinterface));
-
+       gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
 
        /* Allocate some data for incoming reports */
-       device->buffer = usb_buffer_alloc(device->usbdev, REPORT_MAX_SIZE,
-                                          GFP_KERNEL, &(device->buf_dma));
-       if (!device->buffer){
-               input_free_device(device->inputdevice);
-               kfree(device);
-               err("No more memory");
-               return -ENOMEM;
+       gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
+                                       GFP_KERNEL, &gtco->buf_dma);
+       if (!gtco->buffer) {
+               err("No more memory for us buffers");
+               error = -ENOMEM;
+               goto err_free_devs;
        }
 
        /* Allocate URB for reports */
-       device->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
-       if (!device->urbinfo) {
-               usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
-                               device->buffer, device->buf_dma);
-               input_free_device(device->inputdevice);
-               kfree(device);
-               err("No more memory");
+       gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
+       if (!gtco->urbinfo) {
+               err("Failed to allocate URB");
                return -ENOMEM;
+               goto err_free_buf;
        }
 
-
        /*
         * The endpoint is always altsetting 0, we know this since we know
         * this device only has one interrupt endpoint
@@ -913,51 +873,43 @@ static int gtco_probe(struct usb_interface *usbinterface,
        endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 
        /* Some debug */
-       dbg("gtco # interfaces: %d",usbinterface->num_altsetting);
-       dbg("num endpoints:     
%d",usbinterface->cur_altsetting->desc.bNumEndpoints);
-       dbg("interface class:   
%d",usbinterface->cur_altsetting->desc.bInterfaceClass);
-       dbg("endpoint: attribute:0x%x 
type:0x%x",endpoint->bmAttributes,endpoint->bDescriptorType);
+       dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
+       dbg("num endpoints:     %d", 
usbinterface->cur_altsetting->desc.bNumEndpoints);
+       dbg("interface class:   %d", 
usbinterface->cur_altsetting->desc.bInterfaceClass);
+       dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, 
endpoint->bDescriptorType);
        if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 
USB_ENDPOINT_XFER_INT)
                dbg("endpoint: we have interrupt endpoint\n");
 
-       dbg("endpoint extra len:%d ",usbinterface->altsetting[0].extralen);
-
-
+       dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
 
        /*
         * Find the HID descriptor so we can find out the size of the
         * HID report descriptor
         */
        if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
-                                    HID_DEVICE_TYPE,&hid_desc) != 0){
+                                    HID_DEVICE_TYPE, &hid_desc) != 0){
                err("Can't retrieve exta USB descriptor to get hid report 
descriptor length");
-               usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
-                               device->buffer, device->buf_dma);
-               input_free_device(device->inputdevice);
-               kfree(device);
-               return -EIO;
+               error = -EIO;
+               goto err_free_urb;
        }
 
        dbg("Extra descriptor success: type:%d  len:%d",
            hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 
-       if (!(report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL))) {
-               usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
-                               device->buffer, device->buf_dma);
-
-               input_free_device(device->inputdevice);
-               kfree(device);
-               err("No more memory");
-               return -ENOMEM;
+       report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
+       if (!report) {
+               err("No more memory for report");
+               error = -ENOMEM;
+               goto err_free_urb;
        }
 
        /* Couple of tries to get reply */
-       for (retry=0;retry<3;retry++) {
-               result = usb_control_msg(device->usbdev,
-                                        usb_rcvctrlpipe(device->usbdev, 0),
+       for (retry = 0; retry < 3; retry++) {
+               result = usb_control_msg(gtco->usbdev,
+                                        usb_rcvctrlpipe(gtco->usbdev, 0),
                                         USB_REQ_GET_DESCRIPTOR,
                                         USB_RECIP_INTERFACE | USB_DIR_IN,
-                                        (REPORT_DEVICE_TYPE << 8),
+                                        REPORT_DEVICE_TYPE << 8,
                                         0, /* interface */
                                         report,
                                         hid_desc->wDescriptorLength,
@@ -969,72 +921,75 @@ static int gtco_probe(struct usb_interface *usbinterface,
 
        /* If we didn't get the report, fail */
        dbg("usb_control_msg result: :%d", result);
-       if (result != hid_desc->wDescriptorLength){
-               kfree(report);
-               usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
-                               device->buffer, device->buf_dma);
-               input_free_device(device->inputdevice);
-               kfree(device);
+       if (result != hid_desc->wDescriptorLength) {
                err("Failed to get HID Report Descriptor of size: %d",
                    hid_desc->wDescriptorLength);
-               return -EIO;
+               error = -EIO;
+               goto err_free_urb;
        }
 
-
        /* Now we parse the report */
-       parse_hid_report_descriptor(device,report,result);
+       parse_hid_report_descriptor(gtco, report, result);
 
        /* Now we delete it */
        kfree(report);
 
        /* Create a device file node */
-       usb_make_path(device->usbdev, path, PATHLENGTH);
-       sprintf(device->usbpath, "%s/input0", path);
-
+       usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
+       strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 
        /* Set Input device functions */
-       inputdev->open     = gtco_input_open;
-       inputdev->close    = gtco_input_close;
+       input_dev->open = gtco_input_open;
+       input_dev->close = gtco_input_close;
 
        /* Set input device information */
-       inputdev->name     = "GTCO_CalComp";
-       inputdev->phys     = device->usbpath;
-       inputdev->private  = device;
-
+       input_dev->name = "GTCO_CalComp";
+       input_dev->phys = gtco->usbpath;
+       input_dev->private = gtco;
 
        /* Now set up all the input device capabilities */
-       gtco_setup_caps(inputdev);
+       gtco_setup_caps(input_dev);
 
        /* Set input device required ID information */
-       usb_to_input_id(device->usbdev, &device->inputdevice->id);
-       inputdev->cdev.dev = &usbinterface->dev;
+       usb_to_input_id(gtco->usbdev, &input_dev->id);
+       input_dev->cdev.dev = &usbinterface->dev;
 
        /* Setup the URB, it will be posted later on open of input device */
        endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 
-       usb_fill_int_urb(device->urbinfo,
-                        device->usbdev,
-                        usb_rcvintpipe(device->usbdev,
+       usb_fill_int_urb(gtco->urbinfo,
+                        gtco->usbdev,
+                        usb_rcvintpipe(gtco->usbdev,
                                        endpoint->bEndpointAddress),
-                        device->buffer,
+                        gtco->buffer,
                         REPORT_MAX_SIZE,
                         gtco_urb_callback,
-                        device,
+                        gtco,
                         endpoint->bInterval);
 
-       device->urbinfo->transfer_dma = device->buf_dma;
-       device->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
+       gtco->urbinfo->transfer_dma = gtco->buf_dma;
+       gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-       /* Save device pointer in USB interface device */
-       usb_set_intfdata(usbinterface, device);
+       /* Save gtco pointer in USB interface gtco */
+       usb_set_intfdata(usbinterface, gtco);
 
        /* All done, now register the input device */
-       input_register_device(inputdev);
+       error = input_register_device(input_dev);
+       if (error)
+               goto err_free_urb;
 
-       info( "gtco driver created usb:  %s\n",  path);
        return 0;
 
+ err_free_urb:
+       usb_free_urb(gtco->urbinfo);
+ err_free_buf:
+       usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
+                       gtco->buffer, gtco->buf_dma);
+ err_free_devs:
+       kfree(report);
+       input_free_device(input_dev);
+       kfree(gtco);
+       return error;
 }
 
 /*
@@ -1044,50 +999,46 @@ static int gtco_probe(struct usb_interface *usbinterface,
  */
 static void gtco_disconnect(struct usb_interface *interface)
 {
-
        /* Grab private device ptr */
-       struct gtco    *device = usb_get_intfdata (interface);
-       struct input_dev *inputdev;
-
-       inputdev = device->inputdevice;
+       struct gtco *gtco = usb_get_intfdata(interface);
 
        /* Now reverse all the registration stuff */
-       if (device) {
-               input_unregister_device(inputdev);
-               usb_kill_urb(device->urbinfo);
-               usb_free_urb(device->urbinfo);
-               usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
-                               device->buffer, device->buf_dma);
-               kfree(device);
+       if (gtco) {
+               input_unregister_device(gtco->inputdevice);
+               usb_kill_urb(gtco->urbinfo);
+               usb_free_urb(gtco->urbinfo);
+               usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
+                               gtco->buffer, gtco->buf_dma);
+               kfree(gtco);
        }
 
        info("gtco driver disconnected");
 }
 
-
 /*   STANDARD MODULE LOAD ROUTINES  */
 
 static struct usb_driver gtco_driverinfo_table = {
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
-       .owner      = THIS_MODULE,
-#endif
-       .name       = "gtco",
-       .id_table   = gtco_usbid_table,
-       .probe      = gtco_probe,
-       .disconnect = gtco_disconnect,
+       .name           = "gtco",
+       .id_table       = gtco_usbid_table,
+       .probe          = gtco_probe,
+       .disconnect     = gtco_disconnect,
 };
+
 /*
  *  Register this module with the USB subsystem
  */
 static int __init gtco_init(void)
 {
-       int rc;
-       rc = usb_register(&gtco_driverinfo_table);
-       if (rc) {
-               err("usb_register() failed rc=0x%x", rc);
+       int error;
+
+       error = usb_register(&gtco_driverinfo_table);
+       if (error) {
+               err("usb_register() failed rc=0x%x", error);
+               return error;
        }
-       printk("GTCO usb driver version: %s",GTCO_VERSION);
-       return rc;
+
+       printk("GTCO usb driver version: %s", GTCO_VERSION);
+       return 0;
 }
 
 /*
@@ -1098,7 +1049,7 @@ static void __exit gtco_exit(void)
        usb_deregister(&gtco_driverinfo_table);
 }
 
-module_init (gtco_init);
-module_exit (gtco_exit);
+module_init(gtco_init);
+module_exit(gtco_exit);
 
 MODULE_LICENSE("GPL");
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to