Changeset 2867

Show
Ignore:
Timestamp:
01/23/05 19:02:43 (8 years ago)
Author:
khali
Message:

Drop unused client id.

Location:
lm-sensors/trunk/kernel/chips
Files:
45 modified

Legend:

Unmodified
Added
Removed

  • lm-sensors/trunk/kernel/chips/adm1021.c

    r2837 r2867  
    178178}; 
    179179 
    180 static int adm1021_id = 0; 
    181  
    182180static int adm1021_attach_adapter(struct i2c_adapter *adapter) 
    183181{ 
    … …  
    291289        strcpy(new_client->name, client_name); 
    292290        data->type = kind; 
    293  
    294         new_client->id = adm1021_id++; 
    295291        data->valid = 0; 
    296292        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/adm1024.c

    r2784 r2867  
    211211                        int ctl_name, int *nrels_mag, long *results); 
    212212 
    213 static int adm1024_id = 0; 
    214  
    215213static struct i2c_driver adm1024_driver = { 
    216214        .name           = "ADM1024 sensor driver", 
    … …  
    374372        strcpy(new_client->name, client_name); 
    375373        data->type = kind; 
    376  
    377         new_client->id = adm1024_id++; 
    378374        data->valid = 0; 
    379375        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/adm1025.c

    r2784 r2867  
    156156static void adm1025_vrm(struct i2c_client *client, int operation, 
    157157                        int ctl_name, int *nrels_mag, long *results); 
    158  
    159 static int adm1025_id = 0; 
    160158 
    161159static struct i2c_driver adm1025_driver = { 
    … …  
    324322        strcpy(new_client->name, client_name); 
    325323        data->type = kind; 
    326  
    327         new_client->id = adm1025_id++; 
    328324        data->valid = 0; 
    329325        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/adm1031.c

    r2784 r2867  
    203203}; 
    204204 
    205 static int adm1031_id = 0; 
    206  
    207205#define TEMP_TO_REG(val)                ((val) < 0 ? (((val) - 500) / 1000) : \ 
    208206                                         (((val) + 500) / 1000)) 
    … …  
    286284 
    287285        strcpy(new_client->name, client_name); 
    288  
    289         new_client->id = adm1031_id++; 
    290286        data->valid = 0; 
    291287        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/adm9240.c

    r2784 r2867  
    209209                        int ctl_name, int *nrels_mag, long *results); 
    210210 
    211 static int adm9240_id = 0; 
    212  
    213211static struct i2c_driver adm9240_driver = { 
    214212        .name           = "ADM9240 sensor driver", 
    … …  
    371369        strcpy(new_client->name, client_name); 
    372370        data->type = kind; 
    373  
    374         new_client->id = adm9240_id++; 
    375371        data->valid = 0; 
    376372        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/bt869.c

    r2784 r2867  
    468468 
    469469 
    470 int bt869_id = 0; 
    471  
    472470static int bt869_attach_adapter(struct i2c_adapter *adapter) 
    473471{ 
    … …  
    538536        /* Fill in the remaining client fields and put it into the global list */ 
    539537        strcpy(new_client->name, client_name); 
    540  
    541         new_client->id = bt869_id++; 
    542538        data->valid = 0; 
    543539        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/ddcmon.c

    r2784 r2867  
    193193}; 
    194194 
    195 static int ddcmon_id = 0; 
    196  
    197195static int ddcmon_attach_adapter(struct i2c_adapter *adapter) 
    198196{ 
    … …  
    260258        /* Fill in the remaining client fields and put it in the global list */ 
    261259        strcpy(new_client->name, client_name); 
    262  
    263         new_client->id = ddcmon_id++; 
    264260        data->valid = 0; 
    265261        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/ds1307.c

    r2781 r2867  
    8787 
    8888        strcpy (client->name,ds1307.name); 
    89         client->id = ds1307.id; 
    9089        client->flags = I2C_CLIENT_ALLOW_USE | I2C_CLIENT_ALLOW_MULTIPLE_USE; 
    9190        client->addr = addr; 

  • lm-sensors/trunk/kernel/chips/ds1621.c

    r2854 r2867  
    153153        {0} 
    154154}; 
    155  
    156 static int ds1621_id = 0; 
    157155 
    158156static int ds1621_attach_adapter(struct i2c_adapter *adapter) 
    … …  
    242240        /* Fill in remaining client fields and put it into the global list */ 
    243241        strcpy(new_client->name, client_name); 
    244  
    245         new_client->id = ds1621_id++; 
    246242        data->valid = 0; 
    247243        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/fscher.c

    r2784 r2867  
    160160static void fscher_wdog(struct i2c_client *client, int operation, 
    161161                        int ctl_name, int *nrels_mag, long *results); 
    162  
    163 static int fscher_id = 0; 
    164162 
    165163static struct i2c_driver fscher_driver = { 
    … …  
    297295     global list */ 
    298296  strcpy(new_client->name, client_name); 
    299  
    300   new_client->id = fscher_id++; 
    301297  data->valid = 0; 
    302298  init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/fscpos.c

    r2784 r2867  
    159159static void fscpos_wdog(struct i2c_client *client, int operation, 
    160160                        int ctl_name, int *nrels_mag, long *results); 
    161  
    162 static int fscpos_id = 0; 
    163161 
    164162static struct i2c_driver fscpos_driver = { 
    … …  
    280278        /* Fill in the remaining client fields and put it into the global list */ 
    281279        strcpy(new_client->name, client_name); 
    282  
    283         new_client->id = fscpos_id++; 
    284280        data->valid = 0; 
    285281        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/fscscy.c

    r2784 r2867  
    217217static void fscscy_intrusion(struct i2c_client *client, int operation, 
    218218                        int ctl_name, int *nrels_mag, long *results); 
    219  
    220 static int fscscy_id = 0; 
    221219 
    222220static struct i2c_driver fscscy_driver = { 
    … …  
    359357        /* Fill in the remaining client fields and put it into the global list */ 
    360358        strcpy(new_client->name, client_name); 
    361  
    362         new_client->id = fscscy_id++; 
    363359        data->valid = 0; 
    364360        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/gl518sm.c

    r2784 r2867  
    346346        } 
    347347        gl518_list[i] = new_client; 
    348         new_client->id = i; 
    349348        data->valid = 0; 
    350349        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/gl520sm.c

    r2784 r2867  
    246246}; 
    247247 
    248 static int gl520_id = 0; 
    249  
    250248static int gl520_attach_adapter(struct i2c_adapter *adapter) 
    251249{ 
    … …  
    320318        strcpy(new_client->name, client_name); 
    321319        data->type = kind; 
    322  
    323         new_client->id = gl520_id++; 
    324320        data->valid = 0; 
    325321        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/icspll.c

    r2784 r2867  
    105105static u8 tempdata[MAXBLOCK_SIZE]; 
    106106 
    107 static int icspll_id = 0; 
    108107static int icspll_attach_adapter(struct i2c_adapter *adapter) 
    109108{ 
    … …  
    142141        new_client = &data->client; 
    143142        new_client->data = data; 
    144         new_client->id = icspll_id++; 
    145143        new_client->addr = address; 
    146144        new_client->adapter = adapter; 

  • lm-sensors/trunk/kernel/chips/lm75.c

    r2784 r2867  
    9494        {0} 
    9595}; 
    96  
    97 static int lm75_id = 0; 
    9896 
    9997static int lm75_attach_adapter(struct i2c_adapter *adapter) 
    … …  
    193191        /* Fill in the remaining client fields and put it into the global list */ 
    194192        strcpy(new_client->name, client_name); 
    195  
    196         new_client->id = lm75_id++; 
    197193        data->valid = 0; 
    198194        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/lm78.c

    r2784 r2867  
    174174        .detach_client  = lm78_detach_client, 
    175175}; 
    176  
    177 static int lm78_id = 0; 
    178176 
    179177/* The /proc/sys entries */ 
    … …  
    380378        strcpy(new_client->name, client_name); 
    381379        data->type = kind; 
    382  
    383         new_client->id = lm78_id++; 
    384380        data->valid = 0; 
    385381        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/lm80.c

    r2784 r2867  
    154154static void lm80_fan_div(struct i2c_client *client, int operation, 
    155155                         int ctl_name, int *nrels_mag, long *results); 
    156  
    157 static int lm80_id = 0; 
    158156 
    159157static struct i2c_driver lm80_driver = { 
    … …  
    303301        /* Fill in the remaining client fields and put it into the global list */ 
    304302        strcpy(new_client->name, client_name); 
    305  
    306         new_client->id = lm80_id++; 
    307303        data->valid = 0; 
    308304        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/lm83.c

    r2784 r2867  
    202202 
    203203/* 
    204  * Internal variables 
    205  */ 
    206  
    207 static int lm83_id = 0; 
    208  
    209 /* 
    210204 * Real code 
    211205 */ 
    … …  
    334328 
    335329        strcpy(new_client->name, client_name); 
    336         new_client->id = lm83_id++; 
    337330        data->valid = 0; 
    338331        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/lm87.c

    r2784 r2867  
    251251                        int ctl_name, int *nrels_mag, long *results); 
    252252 
    253 static int lm87_id = 0; 
    254  
    255253static struct i2c_driver LM87_driver = { 
    256254        .name           = "LM87 sensor driver", 
    … …  
    427425        strcpy(new_client->name, client_name); 
    428426        data->type = kind; 
    429  
    430         new_client->id = lm87_id++; 
    431427        data->valid = 0; 
    432428        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/lm90.c

    r2816 r2867  
    254254 
    255255/* 
    256  * Internal variables 
    257  */ 
    258  
    259 static int lm90_id = 0; 
    260  
    261 /* 
    262256 * Real code 
    263257 */ 
    … …  
    435429 
    436430        strcpy(new_client->name, client_name); 
    437         new_client->id = lm90_id++; 
    438431        data->valid = 0; 
    439432        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/lm92.c

    r2837 r2867  
    300300static int lm92_detect (struct i2c_adapter *adapter,int address,unsigned short flags,int kind) 
    301301{ 
    302         static int id = 0; 
    303302        struct i2c_client *client; 
    304303        lm92_t *data; 
    … …  
    351350        } 
    352351 
    353         client->id = id++; 
    354  
    355352        up (&mutex); 
    356353 

  • lm-sensors/trunk/kernel/chips/ltc1710.c

    r2784 r2867  
    120120}; 
    121121 
    122 static int ltc1710_id = 0; 
    123  
    124122static int ltc1710_attach_adapter(struct i2c_adapter *adapter) 
    125123{ 
    … …  
    185183        /* Fill in the remaining client fields and put it into the global list */ 
    186184        strcpy(new_client->name, client_name); 
    187  
    188         new_client->id = ltc1710_id++; 
    189185        data->valid = 0; 
    190186        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/matorb.c

    r2784 r2867  
    9292}; 
    9393 
    94 static int matorb_id = 0; 
    95  
    9694static int matorb_attach_adapter(struct i2c_adapter *adapter) 
    9795{ 
    … …  
    147145        /* Fill in the remaining client fields and put it into the global list */ 
    148146        strcpy(new_client->name, client_name); 
    149  
    150         new_client->id = matorb_id++; 
    151147        data->valid = 0; 
    152148        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/max1619.c

    r2784 r2867  
    162162 
    163163/* 
    164  * Internal variables 
    165  */ 
    166  
    167 static int max1619_id = 0; 
    168  
    169 /* 
    170164 * Real code 
    171165 */ 
    … …  
    288282 
    289283        strcpy(new_client->name, client_name); 
    290         new_client->id = max1619_id++; 
    291284        data->valid = 0; 
    292285        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/max6650.c

    r2784 r2867  
    178178 
    179179/* 
    180  * Internal variables 
    181  */ 
    182  
    183 static int max6650_id = 0; 
    184  
    185 /* 
    186180 * Real code 
    187181 */ 
    … …  
    293287 
    294288    strcpy(new_client->name, client_name); 
    295     new_client->id = max6650_id++; 
    296289    data->valid = 0; 
    297290    init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/maxilife.c

    r2839 r2867  
    312312        .detach_client  = maxi_detach_client, 
    313313}; 
    314  
    315 static int maxi_id = 0; 
    316314 
    317315/* Default firmware version. Use module option "maxi_version" 
    … …  
    602600                            lcd[i][j] = (u8) 0; 
    603601 
    604         new_client->id = maxi_id++; 
    605  
    606602        data->valid = 0; 
    607603        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/mtp008.c

    r2784 r2867  
    252252                        int ctl_name, int *nrels_mag, long *results); 
    253253static void mtp008_getsensortype(struct mtp008_data *data, u8 inp); 
    254  
    255 static int mtp008_id = 0; 
    256254 
    257255static struct i2c_driver mtp008_driver = 
    … …  
    429427        strcpy(new_client->name, client_name); 
    430428        data->type = kind; 
    431  
    432         new_client->id = mtp008_id++; 
    433429        data->valid = 0; 
    434430        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/pc87360.c

    r2784 r2867  
    266266void pc87365_temp_status(struct i2c_client *client, int operation, int ctl_name, 
    267267                         int *nrels_mag, long *results); 
    268  
    269 static int pc87360_id = 0; 
    270268 
    271269static struct i2c_driver pc87360_driver = { 
    … …  
    640638        } 
    641639        strcpy(new_client->name, client_name); 
    642  
    643         new_client->id = pc87360_id++; 
    644640        data->valid = 0; 
    645641        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/pca9540.c

    r2837 r2867  
    8686        {0} 
    8787}; 
    88  
    89 static int pca9540_id = 0; 
    9088 
    9189static int pca9540_attach_adapter(struct i2c_adapter *adapter) 
    … …  
    134132        /* Fill in the remaining client fields and put it into the global list */ 
    135133        strcpy(new_client->name, "PCA9540 chip"); 
    136         new_client->id = pca9540_id++; 
    137134        init_MUTEX(&data->update_lock); 
    138135 

  • lm-sensors/trunk/kernel/chips/pcf8574.c

    r2838 r2867  
    115115}; 
    116116 
    117 static int pcf8574_id = 0; 
    118  
    119117static int pcf8574_attach_adapter(struct i2c_adapter *adapter) 
    120118{ 
    … …  
    180178        /* Fill in the remaining client fields and put it into the global list */ 
    181179        strcpy(new_client->name, client_name); 
    182  
    183         new_client->id = pcf8574_id++; 
    184180        init_MUTEX(&data->update_lock); 
    185181 

  • lm-sensors/trunk/kernel/chips/pcf8591.c

    r2784 r2867  
    109109        .detach_client  = pcf8591_detach_client, 
    110110}; 
    111  
    112 static int pcf8591_id = 0; 
    113111 
    114112/* The /proc/sys entries */ 
    … …  
    208206        /* Fill in the remaining client fields and put it into the global list */ 
    209207        strcpy(new_client->name, client_name); 
    210  
    211         new_client->id = pcf8591_id++; 
    212208        data->valid = 0; 
    213209        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/saa1064.c

    r2826 r2867  
    184184}; 
    185185 
    186 static int saa1064_id = 0; 
    187  
    188186static int saa1064_attach_adapter(struct i2c_adapter *adapter) 
    189187{ 
    … …  
    246244        /* Fill in the remaining client fields and put it into the global list */ 
    247245        strcpy(new_client->name, client_name); 
    248  
    249         new_client->id = saa1064_id++; 
    250246        data->valid = 0; 
    251247        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/sis5595.c

    r2784 r2867  
    218218static void sis5595_fan_div(struct i2c_client *client, int operation, 
    219219                            int ctl_name, int *nrels_mag, long *results); 
    220  
    221 static int sis5595_id = 0; 
    222220 
    223221/* The driver. I choose to use type i2c_driver, as at is identical to both 
    … …  
    418416        /* Fill in the remaining client fields and put it into the global list */ 
    419417        strcpy(new_client->name, client_name); 
    420  
    421         new_client->id = sis5595_id++; 
    422418        data->valid = 0; 
    423419        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/smartbatt.c

    r2784 r2867  
    211211}; 
    212212 
    213 static int smartbatt_id = 0; 
    214  
    215213static int smartbatt_attach_adapter(struct i2c_adapter *adapter) 
    216214{ 
    … …  
    269267        /* Fill in the remaining client fields and put it into the global list */ 
    270268        strcpy(new_client->name, client_name); 
    271  
    272         new_client->id = smartbatt_id++; 
    273269        data->valid = 0; 
    274270        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/smbus-arp.c

    r2784 r2867  
    167167}; 
    168168 
    169 static int smbusarp_id = 0; 
    170  
    171169static int smbusarp_attach_adapter(struct i2c_adapter *adapter) 
    172170{ 
    … …  
    210208 
    211209        strcpy(new_client->name, client_name); 
    212  
    213         new_client->id = smbusarp_id++; 
    214210        data->valid = 0; 
    215211        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/smsc47m1.c

    r2784 r2867  
    160160static void smsc47m1_pwm(struct i2c_client *client, int operation, 
    161161                        int ctl_name, int *nrels_mag, long *results); 
    162  
    163 static int smsc47m1_id = 0; 
    164162 
    165163static struct i2c_driver smsc47m1_driver = { 
    … …  
    275273        request_region(address, SMSC_EXTENT, "smsc47m1-fans"); 
    276274        strcpy(new_client->name, client_name); 
    277  
    278         new_client->id = smsc47m1_id++; 
    279275        data->valid = 0; 
    280276        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/thmc50.c

    r2784 r2867  
    153153 
    154154 
    155 static int thmc50_id = 0; 
    156  
    157155static int thmc50_attach_adapter(struct i2c_adapter *adapter) 
    158156{ 
    … …  
    232230        /* Fill in the remaining client fields and put it into the global list */ 
    233231        strcpy(new_client->name, client_name); 
    234  
    235         new_client->id = thmc50_id++; 
    236232        data->valid = 0; 
    237233        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/via686a.c

    r2802 r2867  
    358358                            int ctl_name, int *nrels_mag, long *results); 
    359359 
    360 static int via686a_id = 0; 
    361  
    362360/* The driver. I choose to use type i2c_driver, as at is identical to both 
    363361   smbus_driver and isa_driver, and clients could be of either kind */ 
    … …  
    513511        /* Fill in the remaining client fields and put into the global list */ 
    514512        strcpy(new_client->name, "Via 686A Integrated Sensors"); 
    515  
    516         new_client->id = via686a_id++; 
    517513        data->valid = 0; 
    518514        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/vt1211.c

    r2784 r2867  
    232232static void vt1211_temp(struct i2c_client *client, int operation, 
    233233                        int ctl_name, int *nrels_mag, long *results); 
    234  
    235 static int vt1211_id = 0; 
    236234 
    237235static struct i2c_driver vt1211_driver = { 
    … …  
    424422        request_region(address, VT1211_EXTENT, "vt1211-sensors"); 
    425423        strcpy(new_client->name, client_name); 
    426  
    427         new_client->id = vt1211_id++; 
    428424        data->valid = 0; 
    429425        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/vt8231.c

    r2784 r2867  
    191191static void vt8231_temp(struct i2c_client *client, int operation, 
    192192                        int ctl_name, int *nrels_mag, long *results); 
    193  
    194 static int vt8231_id = 0; 
    195193 
    196194static struct i2c_driver vt8231_driver = { 
    … …  
    392390        /* Fill in the remaining client fields and put into the global list */ 
    393391        strcpy(new_client->name, "Via 8231 Integrated Sensors"); 
    394  
    395         new_client->id = vt8231_id++; 
    396392        data->valid = 0; 
    397393        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/w83627hf.c

    r2828 r2867  
    356356static void w83627hf_sens(struct i2c_client *client, int operation, 
    357357                         int ctl_name, int *nrels_mag, long *results); 
    358  
    359 static int w83627hf_id = 0; 
    360358 
    361359static struct i2c_driver w83627hf_driver = { 
    … …  
    701699        strcpy(new_client->name, client_name); 
    702700        data->type = kind; 
    703         new_client->id = w83627hf_id++; 
    704701        data->valid = 0; 
    705702        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/w83781d.c

    r2865 r2867  
    325325                       int ctl_name, int *nrels_mag, long *results); 
    326326#endif 
    327  
    328 static int w83781d_id = 0; 
    329327 
    330328static struct i2c_driver w83781d_driver = { 
    … …  
    939937        strcpy(new_client->name, client_name); 
    940938        data->type = kind; 
    941  
    942         new_client->id = w83781d_id++; 
    943939        data->valid = 0; 
    944940        init_MUTEX(&data->update_lock); 
    … …  
    10081004                        data->lm75[i].flags = 0; 
    10091005                        strcpy(data->lm75[i].name, client_name); 
    1010                         data->lm75[i].id = w83781d_id++; 
    10111006                        if ((err = i2c_attach_client(&(data->lm75[i])))) { 
    10121007                                printk(KERN_ERR "w83781d.o: Subclient %d registration at address 0x%x failed.\n", 

  • lm-sensors/trunk/kernel/chips/w83l785ts.c

    r2784 r2867  
    138138        {0} 
    139139}; 
    140  
    141 /* 
    142  * Internal variables 
    143  */ 
    144  
    145 static int w83l785ts_id = 0; 
    146140 
    147141/* 
    … …  
    251245 
    252246        strcpy(new_client->name, client_name); 
    253         new_client->id = w83l785ts_id++; 
    254247        data->valid = 0; 
    255248        init_MUTEX(&data->update_lock); 

  • lm-sensors/trunk/kernel/chips/xeontemp.c

    r2784 r2867  
    144144}; 
    145145 
    146 static int xeontemp_id = 0; 
    147  
    148146static int xeontemp_attach_adapter(struct i2c_adapter *adapter) 
    149147{ 
    … …  
    201199        strcpy(new_client->name, client_name); 
    202200        data->type = kind; 
    203  
    204         new_client->id = xeontemp_id++; 
    205201        data->valid = 0; 
    206202        init_MUTEX(&data->update_lock);