ACPI: remove function tracing macros from drivers/acpi/*.c

a few invocations appeared due to the SBS and other patches.

Signed-off-by: Len Brown <len.brown@intel.com>

Len Brown 635227ee 3f86b832

+56 -138
+5 -9
drivers/acpi/cm_sbs.c
··· 46 47 struct proc_dir_entry *acpi_lock_ac_dir(void) 48 { 49 - ACPI_FUNCTION_TRACE("acpi_lock_ac_dir"); 50 51 down(&cm_sbs_sem); 52 if (!acpi_ac_dir) { ··· 58 "Cannot create %s\n", ACPI_AC_CLASS)); 59 } 60 up(&cm_sbs_sem); 61 - return (acpi_ac_dir); 62 } 63 64 EXPORT_SYMBOL(acpi_lock_ac_dir); 65 66 void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir_param) 67 { 68 - ACPI_FUNCTION_TRACE("acpi_unlock_ac_dir"); 69 70 down(&cm_sbs_sem); 71 if (acpi_ac_dir_param) { ··· 81 82 struct proc_dir_entry *acpi_lock_battery_dir(void) 83 { 84 - ACPI_FUNCTION_TRACE("acpi_lock_battery_dir"); 85 86 down(&cm_sbs_sem); 87 if (!acpi_battery_dir) { ··· 94 "Cannot create %s\n", ACPI_BATTERY_CLASS)); 95 } 96 up(&cm_sbs_sem); 97 - return (acpi_battery_dir); 98 } 99 100 EXPORT_SYMBOL(acpi_lock_battery_dir); 101 102 void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir_param) 103 { 104 - ACPI_FUNCTION_TRACE("acpi_unlock_battery_dir"); 105 106 down(&cm_sbs_sem); 107 if (acpi_battery_dir_param) { ··· 112 acpi_battery_dir = 0; 113 } 114 up(&cm_sbs_sem); 115 } 116 117 EXPORT_SYMBOL(acpi_unlock_battery_dir); 118 119 static int __init acpi_cm_sbs_init(void) 120 { 121 - ACPI_FUNCTION_TRACE("acpi_cm_sbs_init"); 122 123 if (acpi_disabled) 124 - return_VALUE(0); 125 126 init_MUTEX(&cm_sbs_sem); 127 128 - return_VALUE(0); 129 } 130 131 subsys_initcall(acpi_cm_sbs_init);
··· 46 47 struct proc_dir_entry *acpi_lock_ac_dir(void) 48 { 49 50 down(&cm_sbs_sem); 51 if (!acpi_ac_dir) { ··· 59 "Cannot create %s\n", ACPI_AC_CLASS)); 60 } 61 up(&cm_sbs_sem); 62 + return acpi_ac_dir; 63 } 64 65 EXPORT_SYMBOL(acpi_lock_ac_dir); 66 67 void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir_param) 68 { 69 70 down(&cm_sbs_sem); 71 if (acpi_ac_dir_param) { ··· 83 84 struct proc_dir_entry *acpi_lock_battery_dir(void) 85 { 86 87 down(&cm_sbs_sem); 88 if (!acpi_battery_dir) { ··· 97 "Cannot create %s\n", ACPI_BATTERY_CLASS)); 98 } 99 up(&cm_sbs_sem); 100 + return acpi_battery_dir; 101 } 102 103 EXPORT_SYMBOL(acpi_lock_battery_dir); 104 105 void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir_param) 106 { 107 108 down(&cm_sbs_sem); 109 if (acpi_battery_dir_param) { ··· 116 acpi_battery_dir = 0; 117 } 118 up(&cm_sbs_sem); 119 + return; 120 } 121 122 EXPORT_SYMBOL(acpi_unlock_battery_dir); 123 124 static int __init acpi_cm_sbs_init(void) 125 { 126 127 if (acpi_disabled) 128 + return 0; 129 130 init_MUTEX(&cm_sbs_sem); 131 132 + return 0; 133 } 134 135 subsys_initcall(acpi_cm_sbs_init);
+10 -24
drivers/acpi/i2c_ec.c
··· 115 u8 val; 116 int err; 117 118 - ACPI_FUNCTION_TRACE("acpi_ec_smb_read"); 119 - 120 err = ec_read(smbus->base + address, &val); 121 if (!err) { 122 *data = val; ··· 126 static int acpi_ec_smb_write(struct acpi_ec_smbus *smbus, u8 address, u8 data) 127 { 128 int err; 129 - 130 - ACPI_FUNCTION_TRACE("acpi_ec_smb_write"); 131 132 err = ec_write(smbus->base + address, data); 133 return (err); ··· 139 struct acpi_ec_smbus *smbus = adap->algo_data; 140 unsigned char protocol, len = 0, pec, temp[2] = { 0, 0 }; 141 int i; 142 - 143 - ACPI_FUNCTION_TRACE("acpi_ec_smb_access"); 144 145 if (read_write == I2C_SMBUS_READ) { 146 protocol = ACPI_EC_SMB_PRTCL_READ; ··· 284 285 static u32 acpi_ec_smb_func(struct i2c_adapter *adapter) 286 { 287 - ACPI_FUNCTION_TRACE("acpi_ec_smb_func"); 288 289 return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 290 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | ··· 305 struct acpi_ec_hc *ec_hc; 306 struct acpi_ec_smbus *smbus; 307 308 - ACPI_FUNCTION_TRACE("acpi_ec_hc_add"); 309 - 310 if (!device) { 311 - return_VALUE(-EINVAL); 312 } 313 314 ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL); 315 if (!ec_hc) { 316 - return_VALUE(-ENOMEM); 317 } 318 memset(ec_hc, 0, sizeof(struct acpi_ec_hc)); 319 320 smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL); 321 if (!smbus) { 322 kfree(ec_hc); 323 - return_VALUE(-ENOMEM); 324 } 325 memset(smbus, 0, sizeof(struct acpi_ec_smbus)); 326 ··· 332 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error obtaining _EC\n")); 333 kfree(ec_hc->smbus); 334 kfree(smbus); 335 - return_VALUE(-EIO); 336 } 337 338 smbus->ec = acpi_driver_data(device->parent); ··· 348 "EC SMBus adapter: Failed to register adapter\n")); 349 kfree(smbus); 350 kfree(ec_hc); 351 - return_VALUE(-EIO); 352 } 353 354 ec_hc->smbus = smbus; ··· 356 printk(KERN_INFO PREFIX "%s [%s]\n", 357 acpi_device_name(device), acpi_device_bid(device)); 358 359 - return_VALUE(AE_OK); 360 } 361 362 static int acpi_ec_hc_remove(struct acpi_device *device, int type) 363 { 364 struct acpi_ec_hc *ec_hc; 365 366 - ACPI_FUNCTION_TRACE("acpi_ec_hc_remove"); 367 - 368 if (!device) { 369 - return_VALUE(-EINVAL); 370 } 371 ec_hc = acpi_driver_data(device); 372 ··· 372 kfree(ec_hc->smbus); 373 kfree(ec_hc); 374 375 - return_VALUE(AE_OK); 376 } 377 378 static int __init acpi_ec_hc_init(void) 379 { 380 int result; 381 382 - ACPI_FUNCTION_TRACE("acpi_ec_hc_init"); 383 result = acpi_bus_register_driver(&acpi_ec_hc_driver); 384 if (result < 0) { 385 - return_VALUE(-ENODEV); 386 } 387 - return_VALUE(0); 388 } 389 390 static void __exit acpi_ec_hc_exit(void) 391 { 392 - ACPI_FUNCTION_TRACE("acpi_ec_hc_exit"); 393 acpi_bus_unregister_driver(&acpi_ec_hc_driver); 394 } 395 396 struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device) 397 { 398 - ACPI_FUNCTION_TRACE("acpi_get_ec_hc"); 399 return ((struct acpi_ec_hc *)acpi_driver_data(device->parent)); 400 } 401
··· 115 u8 val; 116 int err; 117 118 err = ec_read(smbus->base + address, &val); 119 if (!err) { 120 *data = val; ··· 128 static int acpi_ec_smb_write(struct acpi_ec_smbus *smbus, u8 address, u8 data) 129 { 130 int err; 131 132 err = ec_write(smbus->base + address, data); 133 return (err); ··· 143 struct acpi_ec_smbus *smbus = adap->algo_data; 144 unsigned char protocol, len = 0, pec, temp[2] = { 0, 0 }; 145 int i; 146 147 if (read_write == I2C_SMBUS_READ) { 148 protocol = ACPI_EC_SMB_PRTCL_READ; ··· 290 291 static u32 acpi_ec_smb_func(struct i2c_adapter *adapter) 292 { 293 294 return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 295 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | ··· 312 struct acpi_ec_hc *ec_hc; 313 struct acpi_ec_smbus *smbus; 314 315 if (!device) { 316 + return -EINVAL; 317 } 318 319 ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL); 320 if (!ec_hc) { 321 + return -ENOMEM; 322 } 323 memset(ec_hc, 0, sizeof(struct acpi_ec_hc)); 324 325 smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL); 326 if (!smbus) { 327 kfree(ec_hc); 328 + return -ENOMEM; 329 } 330 memset(smbus, 0, sizeof(struct acpi_ec_smbus)); 331 ··· 341 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error obtaining _EC\n")); 342 kfree(ec_hc->smbus); 343 kfree(smbus); 344 + return -EIO; 345 } 346 347 smbus->ec = acpi_driver_data(device->parent); ··· 357 "EC SMBus adapter: Failed to register adapter\n")); 358 kfree(smbus); 359 kfree(ec_hc); 360 + return -EIO; 361 } 362 363 ec_hc->smbus = smbus; ··· 365 printk(KERN_INFO PREFIX "%s [%s]\n", 366 acpi_device_name(device), acpi_device_bid(device)); 367 368 + return AE_OK; 369 } 370 371 static int acpi_ec_hc_remove(struct acpi_device *device, int type) 372 { 373 struct acpi_ec_hc *ec_hc; 374 375 if (!device) { 376 + return -EINVAL; 377 } 378 ec_hc = acpi_driver_data(device); 379 ··· 383 kfree(ec_hc->smbus); 384 kfree(ec_hc); 385 386 + return AE_OK; 387 } 388 389 static int __init acpi_ec_hc_init(void) 390 { 391 int result; 392 393 result = acpi_bus_register_driver(&acpi_ec_hc_driver); 394 if (result < 0) { 395 + return -ENODEV; 396 } 397 + return 0; 398 } 399 400 static void __exit acpi_ec_hc_exit(void) 401 { 402 acpi_bus_unregister_driver(&acpi_ec_hc_driver); 403 } 404 405 struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device) 406 { 407 return ((struct acpi_ec_hc *)acpi_driver_data(device->parent)); 408 } 409
+1 -3
drivers/acpi/numa.c
··· 259 { 260 int pxm, node = -1; 261 262 - ACPI_FUNCTION_TRACE("acpi_get_node"); 263 - 264 pxm = acpi_get_pxm(handle); 265 if (pxm >= 0) 266 node = acpi_map_pxm_to_node(pxm); 267 268 - return_VALUE(node); 269 } 270 EXPORT_SYMBOL(acpi_get_node);
··· 259 { 260 int pxm, node = -1; 261 262 pxm = acpi_get_pxm(handle); 263 if (pxm >= 0) 264 node = acpi_map_pxm_to_node(pxm); 265 266 + return node; 267 } 268 EXPORT_SYMBOL(acpi_get_node);
+40 -102
drivers/acpi/sbs.c
··· 187 char *err_str; 188 int err_number; 189 190 - ACPI_FUNCTION_TRACE("acpi_battery_smbus_err_handler"); 191 - 192 data.word = 0; 193 194 result = smbus->adapter.algo-> ··· 237 int result = 0; 238 int i; 239 240 - ACPI_FUNCTION_TRACE("acpi_sbs_smbus_read_word"); 241 - 242 if (err_handler == NULL) { 243 err_handler = acpi_battery_smbus_err_handler; 244 } ··· 259 } 260 } 261 262 - return_VALUE(result); 263 } 264 265 static int ··· 270 union i2c_smbus_data data; 271 int result = 0; 272 int i; 273 - 274 - ACPI_FUNCTION_TRACE("acpi_sbs_smbus_read_str"); 275 276 if (err_handler == NULL) { 277 err_handler = acpi_battery_smbus_err_handler; ··· 296 } 297 } 298 299 - return_VALUE(result); 300 } 301 302 static int ··· 307 union i2c_smbus_data data; 308 int result = 0; 309 int i; 310 - 311 - ACPI_FUNCTION_TRACE("acpi_sbs_smbus_write_word"); 312 313 if (err_handler == NULL) { 314 err_handler = acpi_battery_smbus_err_handler; ··· 331 } 332 } 333 334 - return_VALUE(result); 335 } 336 337 /* -------------------------------------------------------------------------- ··· 347 char class_saved[20]; 348 int result = 0; 349 350 - ACPI_FUNCTION_TRACE("acpi_sbs_generate_event"); 351 - 352 strcpy(bid_saved, acpi_device_bid(device)); 353 strcpy(class_saved, acpi_device_class(device)); 354 ··· 358 strcpy(acpi_device_bid(device), bid_saved); 359 strcpy(acpi_device_class(device), class_saved); 360 361 - return_VALUE(result); 362 } 363 364 static int acpi_battery_get_present(struct acpi_battery *battery) ··· 366 s16 state; 367 int result = 0; 368 int is_present = 0; 369 - 370 - ACPI_FUNCTION_TRACE("acpi_battery_get_present"); 371 372 result = acpi_sbs_smbus_read_word(battery->sbs->smbus, 373 ACPI_SBSM_SMBUS_ADDR, 0x01, ··· 379 } 380 battery->battery_present = is_present; 381 382 - return_VALUE(result); 383 } 384 385 static int acpi_battery_is_present(struct acpi_battery *battery) ··· 398 int result = 0; 399 s16 state; 400 int foo; 401 - 402 - ACPI_FUNCTION_TRACE("acpi_battery_select"); 403 404 if (battery->sbs->sbsm_present) { 405 ··· 426 } 427 428 end: 429 - return_VALUE(result); 430 } 431 432 static int acpi_sbsm_get_info(struct acpi_sbs *sbs) ··· 434 struct acpi_ec_smbus *smbus = sbs->smbus; 435 int result = 0; 436 s16 battery_system_info; 437 - 438 - ACPI_FUNCTION_TRACE("acpi_sbsm_get_info"); 439 440 result = acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x04, 441 &battery_system_info, NULL); ··· 447 448 end: 449 450 - return_VALUE(result); 451 } 452 453 static int acpi_battery_get_info(struct acpi_battery *battery) ··· 456 int result = 0; 457 s16 battery_mode; 458 s16 specification_info; 459 - 460 - ACPI_FUNCTION_TRACE("acpi_battery_get_info"); 461 462 result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03, 463 &battery_mode, ··· 565 } 566 567 end: 568 - return_VALUE(result); 569 } 570 571 static void acpi_update_delay(struct acpi_sbs *sbs) 572 { 573 - ACPI_FUNCTION_TRACE("acpi_update_delay"); 574 if (sbs->zombie) { 575 return; 576 } ··· 582 { 583 struct acpi_ec_smbus *smbus = battery->sbs->smbus; 584 int result = 0; 585 - 586 - ACPI_FUNCTION_TRACE("acpi_battery_get_state"); 587 588 acpi_update_delay(battery->sbs); 589 result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x09, ··· 646 acpi_update_delay(battery->sbs); 647 648 end: 649 - return_VALUE(result); 650 } 651 652 static int acpi_battery_get_alarm(struct acpi_battery *battery) 653 { 654 struct acpi_ec_smbus *smbus = battery->sbs->smbus; 655 int result = 0; 656 - 657 - ACPI_FUNCTION_TRACE("acpi_battery_get_alarm"); 658 659 result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01, 660 &battery->alarm.remaining_capacity, ··· 667 668 end: 669 670 - return_VALUE(result); 671 } 672 673 static int acpi_battery_set_alarm(struct acpi_battery *battery, ··· 677 int result = 0; 678 s16 battery_mode; 679 int foo; 680 - 681 - ACPI_FUNCTION_TRACE("acpi_battery_set_alarm"); 682 683 result = acpi_battery_select(battery); 684 if (result) { ··· 721 722 end: 723 724 - return_VALUE(result); 725 } 726 727 static int acpi_battery_set_mode(struct acpi_battery *battery) 728 { 729 int result = 0; 730 s16 battery_mode; 731 - 732 - ACPI_FUNCTION_TRACE("acpi_battery_set_mode"); 733 734 if (capacity_mode == DEF_CAPACITY_UNIT) { 735 goto end; ··· 766 } 767 768 end: 769 - return_VALUE(result); 770 } 771 772 static int acpi_battery_init(struct acpi_battery *battery) 773 { 774 int result = 0; 775 - 776 - ACPI_FUNCTION_TRACE("acpi_battery_init"); 777 778 result = acpi_battery_select(battery); 779 if (result) { ··· 809 } 810 811 end: 812 - return_VALUE(result); 813 } 814 815 static int acpi_ac_get_present(struct acpi_sbs *sbs) ··· 817 struct acpi_ec_smbus *smbus = sbs->smbus; 818 int result = 0; 819 s16 charger_status; 820 - 821 - ACPI_FUNCTION_TRACE("acpi_ac_get_present"); 822 823 result = acpi_sbs_smbus_read_word(smbus, ACPI_SBC_SMBUS_ADDR, 0x13, 824 &charger_status, NULL); ··· 831 832 end: 833 834 - return_VALUE(result); 835 } 836 837 /* -------------------------------------------------------------------------- ··· 850 { 851 struct proc_dir_entry *entry = NULL; 852 853 - ACPI_FUNCTION_TRACE("acpi_sbs_generic_add_fs"); 854 - 855 if (!*dir) { 856 *dir = proc_mkdir(dir_name, parent_dir); 857 if (!*dir) { 858 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 859 "proc_mkdir() failed\n")); 860 - return_VALUE(-ENODEV); 861 } 862 (*dir)->owner = THIS_MODULE; 863 } ··· 899 } 900 } 901 902 - return_VALUE(0); 903 } 904 905 static void 906 acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir, 907 struct proc_dir_entry *parent_dir) 908 { 909 - ACPI_FUNCTION_TRACE("acpi_sbs_generic_remove_fs"); 910 911 if (*dir) { 912 remove_proc_entry(ACPI_SBS_FILE_INFO, *dir); ··· 927 int cscale; 928 int result = 0; 929 930 - ACPI_FUNCTION_TRACE("acpi_battery_read_info"); 931 - 932 if (battery->sbs->zombie) { 933 - return_VALUE(-ENODEV); 934 } 935 936 down(&sbs_sem); ··· 987 988 up(&sbs_sem); 989 990 - return_VALUE(result); 991 } 992 993 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file) ··· 1002 int cscale; 1003 int foo; 1004 1005 - ACPI_FUNCTION_TRACE("acpi_battery_read_state"); 1006 - 1007 if (battery->sbs->zombie) { 1008 - return_VALUE(-ENODEV); 1009 } 1010 1011 down(&sbs_sem); ··· 1066 1067 up(&sbs_sem); 1068 1069 - return_VALUE(result); 1070 } 1071 1072 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file) ··· 1080 int result = 0; 1081 int cscale; 1082 1083 - ACPI_FUNCTION_TRACE("acpi_battery_read_alarm"); 1084 - 1085 if (battery->sbs->zombie) { 1086 - return_VALUE(-ENODEV); 1087 } 1088 1089 down(&sbs_sem); ··· 1118 1119 up(&sbs_sem); 1120 1121 - return_VALUE(result); 1122 } 1123 1124 static ssize_t ··· 1130 char alarm_string[12] = { '\0' }; 1131 int result, old_alarm, new_alarm; 1132 1133 - ACPI_FUNCTION_TRACE("acpi_battery_write_alarm"); 1134 - 1135 if (battery->sbs->zombie) { 1136 - return_VALUE(-ENODEV); 1137 } 1138 1139 down(&sbs_sem); ··· 1175 up(&sbs_sem); 1176 1177 if (result) { 1178 - return_VALUE(result); 1179 } else { 1180 - return_VALUE(count); 1181 } 1182 } 1183 ··· 1220 struct acpi_sbs *sbs = (struct acpi_sbs *)seq->private; 1221 int result; 1222 1223 - ACPI_FUNCTION_TRACE("acpi_ac_read_state"); 1224 - 1225 if (sbs->zombie) { 1226 - return_VALUE(-ENODEV); 1227 } 1228 1229 down(&sbs_sem); ··· 1239 1240 up(&sbs_sem); 1241 1242 - return_VALUE(0); 1243 } 1244 1245 static int acpi_ac_state_open_fs(struct inode *inode, struct file *file) ··· 1267 int result; 1268 char dir_name[32]; 1269 struct acpi_battery *battery; 1270 - 1271 - ACPI_FUNCTION_TRACE("acpi_battery_add"); 1272 1273 battery = &sbs->battery[id]; 1274 ··· 1318 battery->alive = 1; 1319 1320 end: 1321 - return_VALUE(result); 1322 } 1323 1324 static void acpi_battery_remove(struct acpi_sbs *sbs, int id) 1325 { 1326 - ACPI_FUNCTION_TRACE("acpi_battery_remove"); 1327 1328 if (sbs->battery[id].battery_entry) { 1329 acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry), ··· 1333 static int acpi_ac_add(struct acpi_sbs *sbs) 1334 { 1335 int result; 1336 - 1337 - ACPI_FUNCTION_TRACE("acpi_ac_add"); 1338 1339 result = acpi_ac_get_present(sbs); 1340 if (result) { ··· 1353 1354 end: 1355 1356 - return_VALUE(result); 1357 } 1358 1359 static void acpi_ac_remove(struct acpi_sbs *sbs) 1360 { 1361 - ACPI_FUNCTION_TRACE("acpi_ac_remove"); 1362 1363 if (sbs->ac_entry) { 1364 acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir); ··· 1366 1367 static void acpi_sbs_update_queue_run(unsigned long data) 1368 { 1369 - ACPI_FUNCTION_TRACE("acpi_sbs_update_queue_run"); 1370 acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data); 1371 } 1372 ··· 1381 char dir_name[32]; 1382 int do_battery_init, do_ac_init; 1383 s16 old_remaining_capacity; 1384 - 1385 - ACPI_FUNCTION_TRACE("acpi_sbs_update_run"); 1386 1387 if (sbs->zombie) { 1388 goto end; ··· 1531 } 1532 1533 end: 1534 - return_VALUE(result); 1535 } 1536 1537 static void acpi_sbs_update_queue(void *data) ··· 1539 struct acpi_sbs *sbs = data; 1540 unsigned long delay = -1; 1541 int result; 1542 - 1543 - ACPI_FUNCTION_TRACE("acpi_sbs_update_queue"); 1544 1545 if (sbs->zombie) { 1546 goto end; ··· 1576 int id, cnt; 1577 acpi_status status = AE_OK; 1578 1579 - ACPI_FUNCTION_TRACE("acpi_sbs_add"); 1580 - 1581 sbs = kmalloc(sizeof(struct acpi_sbs), GFP_KERNEL); 1582 if (!sbs) { 1583 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n")); 1584 - return_VALUE(-ENOMEM); 1585 } 1586 memset(sbs, 0, sizeof(struct acpi_sbs)); 1587 ··· 1680 } 1681 } 1682 1683 - return_VALUE(result); 1684 } 1685 1686 int acpi_sbs_remove(struct acpi_device *device, int type) ··· 1688 struct acpi_sbs *sbs = (struct acpi_sbs *)acpi_driver_data(device); 1689 int id; 1690 1691 - ACPI_FUNCTION_TRACE("acpi_sbs_remove"); 1692 - 1693 if (!device || !sbs) { 1694 - return_VALUE(-EINVAL); 1695 } 1696 1697 sbs->zombie = 1; ··· 1707 1708 kfree(sbs); 1709 1710 - return_VALUE(0); 1711 } 1712 1713 static int __init acpi_sbs_init(void) 1714 { 1715 int result = 0; 1716 - 1717 - ACPI_FUNCTION_TRACE("acpi_sbs_init"); 1718 1719 init_MUTEX(&sbs_sem); 1720 ··· 1722 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: " 1723 "invalid capacity_mode = %d\n", 1724 capacity_mode)); 1725 - return_VALUE(-EINVAL); 1726 } 1727 1728 acpi_ac_dir = acpi_lock_ac_dir(); 1729 if (!acpi_ac_dir) { 1730 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1731 "acpi_lock_ac_dir() failed\n")); 1732 - return_VALUE(-ENODEV); 1733 } 1734 1735 acpi_battery_dir = acpi_lock_battery_dir(); 1736 if (!acpi_battery_dir) { 1737 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1738 "acpi_lock_battery_dir() failed\n")); 1739 - return_VALUE(-ENODEV); 1740 } 1741 1742 result = acpi_bus_register_driver(&acpi_sbs_driver); 1743 if (result < 0) { 1744 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1745 "acpi_bus_register_driver() failed\n")); 1746 - return_VALUE(-ENODEV); 1747 } 1748 1749 - return_VALUE(0); 1750 } 1751 1752 static void __exit acpi_sbs_exit(void) 1753 { 1754 - ACPI_FUNCTION_TRACE("acpi_sbs_exit"); 1755 1756 acpi_bus_unregister_driver(&acpi_sbs_driver); 1757 ··· 1759 acpi_unlock_battery_dir(acpi_battery_dir); 1760 acpi_battery_dir = NULL; 1761 1762 - return_VOID; 1763 } 1764 1765 module_init(acpi_sbs_init);
··· 187 char *err_str; 188 int err_number; 189 190 data.word = 0; 191 192 result = smbus->adapter.algo-> ··· 239 int result = 0; 240 int i; 241 242 if (err_handler == NULL) { 243 err_handler = acpi_battery_smbus_err_handler; 244 } ··· 263 } 264 } 265 266 + return result; 267 } 268 269 static int ··· 274 union i2c_smbus_data data; 275 int result = 0; 276 int i; 277 278 if (err_handler == NULL) { 279 err_handler = acpi_battery_smbus_err_handler; ··· 302 } 303 } 304 305 + return result; 306 } 307 308 static int ··· 313 union i2c_smbus_data data; 314 int result = 0; 315 int i; 316 317 if (err_handler == NULL) { 318 err_handler = acpi_battery_smbus_err_handler; ··· 339 } 340 } 341 342 + return result; 343 } 344 345 /* -------------------------------------------------------------------------- ··· 355 char class_saved[20]; 356 int result = 0; 357 358 strcpy(bid_saved, acpi_device_bid(device)); 359 strcpy(class_saved, acpi_device_class(device)); 360 ··· 368 strcpy(acpi_device_bid(device), bid_saved); 369 strcpy(acpi_device_class(device), class_saved); 370 371 + return result; 372 } 373 374 static int acpi_battery_get_present(struct acpi_battery *battery) ··· 376 s16 state; 377 int result = 0; 378 int is_present = 0; 379 380 result = acpi_sbs_smbus_read_word(battery->sbs->smbus, 381 ACPI_SBSM_SMBUS_ADDR, 0x01, ··· 391 } 392 battery->battery_present = is_present; 393 394 + return result; 395 } 396 397 static int acpi_battery_is_present(struct acpi_battery *battery) ··· 410 int result = 0; 411 s16 state; 412 int foo; 413 414 if (battery->sbs->sbsm_present) { 415 ··· 440 } 441 442 end: 443 + return result; 444 } 445 446 static int acpi_sbsm_get_info(struct acpi_sbs *sbs) ··· 448 struct acpi_ec_smbus *smbus = sbs->smbus; 449 int result = 0; 450 s16 battery_system_info; 451 452 result = acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x04, 453 &battery_system_info, NULL); ··· 463 464 end: 465 466 + return result; 467 } 468 469 static int acpi_battery_get_info(struct acpi_battery *battery) ··· 472 int result = 0; 473 s16 battery_mode; 474 s16 specification_info; 475 476 result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03, 477 &battery_mode, ··· 583 } 584 585 end: 586 + return result; 587 } 588 589 static void acpi_update_delay(struct acpi_sbs *sbs) 590 { 591 if (sbs->zombie) { 592 return; 593 } ··· 601 { 602 struct acpi_ec_smbus *smbus = battery->sbs->smbus; 603 int result = 0; 604 605 acpi_update_delay(battery->sbs); 606 result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x09, ··· 667 acpi_update_delay(battery->sbs); 668 669 end: 670 + return result; 671 } 672 673 static int acpi_battery_get_alarm(struct acpi_battery *battery) 674 { 675 struct acpi_ec_smbus *smbus = battery->sbs->smbus; 676 int result = 0; 677 678 result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01, 679 &battery->alarm.remaining_capacity, ··· 690 691 end: 692 693 + return result; 694 } 695 696 static int acpi_battery_set_alarm(struct acpi_battery *battery, ··· 700 int result = 0; 701 s16 battery_mode; 702 int foo; 703 704 result = acpi_battery_select(battery); 705 if (result) { ··· 746 747 end: 748 749 + return result; 750 } 751 752 static int acpi_battery_set_mode(struct acpi_battery *battery) 753 { 754 int result = 0; 755 s16 battery_mode; 756 757 if (capacity_mode == DEF_CAPACITY_UNIT) { 758 goto end; ··· 793 } 794 795 end: 796 + return result; 797 } 798 799 static int acpi_battery_init(struct acpi_battery *battery) 800 { 801 int result = 0; 802 803 result = acpi_battery_select(battery); 804 if (result) { ··· 838 } 839 840 end: 841 + return result; 842 } 843 844 static int acpi_ac_get_present(struct acpi_sbs *sbs) ··· 846 struct acpi_ec_smbus *smbus = sbs->smbus; 847 int result = 0; 848 s16 charger_status; 849 850 result = acpi_sbs_smbus_read_word(smbus, ACPI_SBC_SMBUS_ADDR, 0x13, 851 &charger_status, NULL); ··· 862 863 end: 864 865 + return result; 866 } 867 868 /* -------------------------------------------------------------------------- ··· 881 { 882 struct proc_dir_entry *entry = NULL; 883 884 if (!*dir) { 885 *dir = proc_mkdir(dir_name, parent_dir); 886 if (!*dir) { 887 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 888 "proc_mkdir() failed\n")); 889 + return -ENODEV; 890 } 891 (*dir)->owner = THIS_MODULE; 892 } ··· 932 } 933 } 934 935 + return 0; 936 } 937 938 static void 939 acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir, 940 struct proc_dir_entry *parent_dir) 941 { 942 943 if (*dir) { 944 remove_proc_entry(ACPI_SBS_FILE_INFO, *dir); ··· 961 int cscale; 962 int result = 0; 963 964 if (battery->sbs->zombie) { 965 + return -ENODEV; 966 } 967 968 down(&sbs_sem); ··· 1023 1024 up(&sbs_sem); 1025 1026 + return result; 1027 } 1028 1029 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file) ··· 1038 int cscale; 1039 int foo; 1040 1041 if (battery->sbs->zombie) { 1042 + return -ENODEV; 1043 } 1044 1045 down(&sbs_sem); ··· 1104 1105 up(&sbs_sem); 1106 1107 + return result; 1108 } 1109 1110 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file) ··· 1118 int result = 0; 1119 int cscale; 1120 1121 if (battery->sbs->zombie) { 1122 + return -ENODEV; 1123 } 1124 1125 down(&sbs_sem); ··· 1158 1159 up(&sbs_sem); 1160 1161 + return result; 1162 } 1163 1164 static ssize_t ··· 1170 char alarm_string[12] = { '\0' }; 1171 int result, old_alarm, new_alarm; 1172 1173 if (battery->sbs->zombie) { 1174 + return -ENODEV; 1175 } 1176 1177 down(&sbs_sem); ··· 1217 up(&sbs_sem); 1218 1219 if (result) { 1220 + return result; 1221 } else { 1222 + return count; 1223 } 1224 } 1225 ··· 1262 struct acpi_sbs *sbs = (struct acpi_sbs *)seq->private; 1263 int result; 1264 1265 if (sbs->zombie) { 1266 + return -ENODEV; 1267 } 1268 1269 down(&sbs_sem); ··· 1283 1284 up(&sbs_sem); 1285 1286 + return 0; 1287 } 1288 1289 static int acpi_ac_state_open_fs(struct inode *inode, struct file *file) ··· 1311 int result; 1312 char dir_name[32]; 1313 struct acpi_battery *battery; 1314 1315 battery = &sbs->battery[id]; 1316 ··· 1364 battery->alive = 1; 1365 1366 end: 1367 + return result; 1368 } 1369 1370 static void acpi_battery_remove(struct acpi_sbs *sbs, int id) 1371 { 1372 1373 if (sbs->battery[id].battery_entry) { 1374 acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry), ··· 1380 static int acpi_ac_add(struct acpi_sbs *sbs) 1381 { 1382 int result; 1383 1384 result = acpi_ac_get_present(sbs); 1385 if (result) { ··· 1402 1403 end: 1404 1405 + return result; 1406 } 1407 1408 static void acpi_ac_remove(struct acpi_sbs *sbs) 1409 { 1410 1411 if (sbs->ac_entry) { 1412 acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir); ··· 1416 1417 static void acpi_sbs_update_queue_run(unsigned long data) 1418 { 1419 acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data); 1420 } 1421 ··· 1432 char dir_name[32]; 1433 int do_battery_init, do_ac_init; 1434 s16 old_remaining_capacity; 1435 1436 if (sbs->zombie) { 1437 goto end; ··· 1584 } 1585 1586 end: 1587 + return result; 1588 } 1589 1590 static void acpi_sbs_update_queue(void *data) ··· 1592 struct acpi_sbs *sbs = data; 1593 unsigned long delay = -1; 1594 int result; 1595 1596 if (sbs->zombie) { 1597 goto end; ··· 1631 int id, cnt; 1632 acpi_status status = AE_OK; 1633 1634 sbs = kmalloc(sizeof(struct acpi_sbs), GFP_KERNEL); 1635 if (!sbs) { 1636 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n")); 1637 + return -ENOMEM; 1638 } 1639 memset(sbs, 0, sizeof(struct acpi_sbs)); 1640 ··· 1737 } 1738 } 1739 1740 + return result; 1741 } 1742 1743 int acpi_sbs_remove(struct acpi_device *device, int type) ··· 1745 struct acpi_sbs *sbs = (struct acpi_sbs *)acpi_driver_data(device); 1746 int id; 1747 1748 if (!device || !sbs) { 1749 + return -EINVAL; 1750 } 1751 1752 sbs->zombie = 1; ··· 1766 1767 kfree(sbs); 1768 1769 + return 0; 1770 } 1771 1772 static int __init acpi_sbs_init(void) 1773 { 1774 int result = 0; 1775 1776 init_MUTEX(&sbs_sem); 1777 ··· 1783 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: " 1784 "invalid capacity_mode = %d\n", 1785 capacity_mode)); 1786 + return -EINVAL; 1787 } 1788 1789 acpi_ac_dir = acpi_lock_ac_dir(); 1790 if (!acpi_ac_dir) { 1791 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1792 "acpi_lock_ac_dir() failed\n")); 1793 + return -ENODEV; 1794 } 1795 1796 acpi_battery_dir = acpi_lock_battery_dir(); 1797 if (!acpi_battery_dir) { 1798 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1799 "acpi_lock_battery_dir() failed\n")); 1800 + return -ENODEV; 1801 } 1802 1803 result = acpi_bus_register_driver(&acpi_sbs_driver); 1804 if (result < 0) { 1805 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1806 "acpi_bus_register_driver() failed\n")); 1807 + return -ENODEV; 1808 } 1809 1810 + return 0; 1811 } 1812 1813 static void __exit acpi_sbs_exit(void) 1814 { 1815 1816 acpi_bus_unregister_driver(&acpi_sbs_driver); 1817 ··· 1821 acpi_unlock_battery_dir(acpi_battery_dir); 1822 acpi_battery_dir = NULL; 1823 1824 + return; 1825 } 1826 1827 module_init(acpi_sbs_init);