sbs.c 40 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771
  1. /*
  2. * acpi_sbs.c - ACPI Smart Battery System Driver ($Revision: 1.16 $)
  3. *
  4. * Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
  5. *
  6. * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or (at
  11. * your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful, but
  14. * WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License along
  19. * with this program; if not, write to the Free Software Foundation, Inc.,
  20. * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21. *
  22. * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23. */
  24. #include <linux/init.h>
  25. #include <linux/module.h>
  26. #include <linux/moduleparam.h>
  27. #include <linux/kernel.h>
  28. #include <linux/proc_fs.h>
  29. #include <linux/seq_file.h>
  30. #include <asm/uaccess.h>
  31. #include <linux/acpi.h>
  32. #include <linux/i2c.h>
  33. #include <linux/delay.h>
  34. #include "i2c_ec.h"
  35. #define DEF_CAPACITY_UNIT 3
  36. #define MAH_CAPACITY_UNIT 1
  37. #define MWH_CAPACITY_UNIT 2
  38. #define CAPACITY_UNIT DEF_CAPACITY_UNIT
  39. #define REQUEST_UPDATE_MODE 1
  40. #define QUEUE_UPDATE_MODE 2
  41. #define DATA_TYPE_COMMON 0
  42. #define DATA_TYPE_INFO 1
  43. #define DATA_TYPE_STATE 2
  44. #define DATA_TYPE_ALARM 3
  45. #define DATA_TYPE_AC_STATE 4
  46. extern struct proc_dir_entry *acpi_lock_ac_dir(void);
  47. extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  48. extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
  49. extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  50. #define ACPI_SBS_COMPONENT 0x00080000
  51. #define ACPI_SBS_CLASS "sbs"
  52. #define ACPI_AC_CLASS "ac_adapter"
  53. #define ACPI_BATTERY_CLASS "battery"
  54. #define ACPI_SBS_HID "ACPI0002"
  55. #define ACPI_SBS_DEVICE_NAME "Smart Battery System"
  56. #define ACPI_SBS_FILE_INFO "info"
  57. #define ACPI_SBS_FILE_STATE "state"
  58. #define ACPI_SBS_FILE_ALARM "alarm"
  59. #define ACPI_BATTERY_DIR_NAME "BAT%i"
  60. #define ACPI_AC_DIR_NAME "AC0"
  61. #define ACPI_SBC_SMBUS_ADDR 0x9
  62. #define ACPI_SBSM_SMBUS_ADDR 0xa
  63. #define ACPI_SB_SMBUS_ADDR 0xb
  64. #define ACPI_SBS_AC_NOTIFY_STATUS 0x80
  65. #define ACPI_SBS_BATTERY_NOTIFY_STATUS 0x80
  66. #define ACPI_SBS_BATTERY_NOTIFY_INFO 0x81
  67. #define _COMPONENT ACPI_SBS_COMPONENT
  68. #define MAX_SBS_BAT 4
  69. #define MAX_SMBUS_ERR 1
  70. ACPI_MODULE_NAME("sbs");
  71. MODULE_AUTHOR("Rich Townsend");
  72. MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
  73. MODULE_LICENSE("GPL");
  74. static struct semaphore sbs_sem;
  75. #define UPDATE_MODE QUEUE_UPDATE_MODE
  76. /* REQUEST_UPDATE_MODE QUEUE_UPDATE_MODE */
  77. #define UPDATE_INFO_MODE 0
  78. #define UPDATE_TIME 60
  79. #define UPDATE_TIME2 0
  80. static int capacity_mode = CAPACITY_UNIT;
  81. static int update_mode = UPDATE_MODE;
  82. static int update_info_mode = UPDATE_INFO_MODE;
  83. static int update_time = UPDATE_TIME;
  84. static int update_time2 = UPDATE_TIME2;
  85. module_param(capacity_mode, int, 0);
  86. module_param(update_mode, int, 0);
  87. module_param(update_info_mode, int, 0);
  88. module_param(update_time, int, 0);
  89. module_param(update_time2, int, 0);
  90. static int acpi_sbs_add(struct acpi_device *device);
  91. static int acpi_sbs_remove(struct acpi_device *device, int type);
  92. static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus);
  93. static void acpi_sbs_update_queue(void *data);
  94. static struct acpi_driver acpi_sbs_driver = {
  95. .name = "sbs",
  96. .class = ACPI_SBS_CLASS,
  97. .ids = ACPI_SBS_HID,
  98. .ops = {
  99. .add = acpi_sbs_add,
  100. .remove = acpi_sbs_remove,
  101. },
  102. };
  103. struct acpi_battery_info {
  104. int capacity_mode;
  105. s16 full_charge_capacity;
  106. s16 design_capacity;
  107. s16 design_voltage;
  108. int vscale;
  109. int ipscale;
  110. s16 serial_number;
  111. char manufacturer_name[I2C_SMBUS_BLOCK_MAX + 3];
  112. char device_name[I2C_SMBUS_BLOCK_MAX + 3];
  113. char device_chemistry[I2C_SMBUS_BLOCK_MAX + 3];
  114. };
  115. struct acpi_battery_state {
  116. s16 voltage;
  117. s16 amperage;
  118. s16 remaining_capacity;
  119. s16 average_time_to_empty;
  120. s16 average_time_to_full;
  121. s16 battery_status;
  122. };
  123. struct acpi_battery_alarm {
  124. s16 remaining_capacity;
  125. };
  126. struct acpi_battery {
  127. int alive;
  128. int battery_present;
  129. int id;
  130. int init_state;
  131. struct acpi_sbs *sbs;
  132. struct acpi_battery_info info;
  133. struct acpi_battery_state state;
  134. struct acpi_battery_alarm alarm;
  135. struct proc_dir_entry *battery_entry;
  136. };
  137. struct acpi_sbs {
  138. acpi_handle handle;
  139. struct acpi_device *device;
  140. struct acpi_ec_smbus *smbus;
  141. int sbsm_present;
  142. int sbsm_batteries_supported;
  143. int ac_present;
  144. struct proc_dir_entry *ac_entry;
  145. struct acpi_battery battery[MAX_SBS_BAT];
  146. int update_info_mode;
  147. int zombie;
  148. int update_time;
  149. int update_time2;
  150. struct timer_list update_timer;
  151. };
  152. static void acpi_update_delay(struct acpi_sbs *sbs);
  153. static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type);
  154. /* --------------------------------------------------------------------------
  155. SMBus Communication
  156. -------------------------------------------------------------------------- */
  157. static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus)
  158. {
  159. union i2c_smbus_data data;
  160. int result = 0;
  161. char *err_str;
  162. int err_number;
  163. data.word = 0;
  164. result = smbus->adapter.algo->
  165. smbus_xfer(&smbus->adapter,
  166. ACPI_SB_SMBUS_ADDR,
  167. 0, I2C_SMBUS_READ, 0x16, I2C_SMBUS_BLOCK_DATA, &data);
  168. err_number = (data.word & 0x000f);
  169. switch (data.word & 0x000f) {
  170. case 0x0000:
  171. err_str = "unexpected bus error";
  172. break;
  173. case 0x0001:
  174. err_str = "busy";
  175. break;
  176. case 0x0002:
  177. err_str = "reserved command";
  178. break;
  179. case 0x0003:
  180. err_str = "unsupported command";
  181. break;
  182. case 0x0004:
  183. err_str = "access denied";
  184. break;
  185. case 0x0005:
  186. err_str = "overflow/underflow";
  187. break;
  188. case 0x0006:
  189. err_str = "bad size";
  190. break;
  191. case 0x0007:
  192. err_str = "unknown error";
  193. break;
  194. default:
  195. err_str = "unrecognized error";
  196. }
  197. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  198. "%s: ret %i, err %i\n", err_str, result, err_number));
  199. }
  200. static int
  201. acpi_sbs_smbus_read_word(struct acpi_ec_smbus *smbus, int addr, int func,
  202. u16 * word,
  203. void (*err_handler) (struct acpi_ec_smbus * smbus))
  204. {
  205. union i2c_smbus_data data;
  206. int result = 0;
  207. int i;
  208. if (err_handler == NULL) {
  209. err_handler = acpi_battery_smbus_err_handler;
  210. }
  211. for (i = 0; i < MAX_SMBUS_ERR; i++) {
  212. result =
  213. smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
  214. I2C_SMBUS_READ, func,
  215. I2C_SMBUS_WORD_DATA, &data);
  216. if (result) {
  217. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  218. "try %i: smbus->adapter.algo->smbus_xfer() failed\n",
  219. i));
  220. if (err_handler) {
  221. err_handler(smbus);
  222. }
  223. } else {
  224. *word = data.word;
  225. break;
  226. }
  227. }
  228. return result;
  229. }
  230. static int
  231. acpi_sbs_smbus_read_str(struct acpi_ec_smbus *smbus, int addr, int func,
  232. char *str,
  233. void (*err_handler) (struct acpi_ec_smbus * smbus))
  234. {
  235. union i2c_smbus_data data;
  236. int result = 0;
  237. int i;
  238. if (err_handler == NULL) {
  239. err_handler = acpi_battery_smbus_err_handler;
  240. }
  241. for (i = 0; i < MAX_SMBUS_ERR; i++) {
  242. result =
  243. smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
  244. I2C_SMBUS_READ, func,
  245. I2C_SMBUS_BLOCK_DATA,
  246. &data);
  247. if (result) {
  248. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  249. "try %i: smbus->adapter.algo->smbus_xfer() failed\n",
  250. i));
  251. if (err_handler) {
  252. err_handler(smbus);
  253. }
  254. } else {
  255. strncpy(str, (const char *)data.block + 1,
  256. data.block[0]);
  257. str[data.block[0]] = 0;
  258. break;
  259. }
  260. }
  261. return result;
  262. }
  263. static int
  264. acpi_sbs_smbus_write_word(struct acpi_ec_smbus *smbus, int addr, int func,
  265. int word,
  266. void (*err_handler) (struct acpi_ec_smbus * smbus))
  267. {
  268. union i2c_smbus_data data;
  269. int result = 0;
  270. int i;
  271. if (err_handler == NULL) {
  272. err_handler = acpi_battery_smbus_err_handler;
  273. }
  274. data.word = word;
  275. for (i = 0; i < MAX_SMBUS_ERR; i++) {
  276. result =
  277. smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
  278. I2C_SMBUS_WRITE, func,
  279. I2C_SMBUS_WORD_DATA, &data);
  280. if (result) {
  281. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  282. "try %i: smbus->adapter.algo"
  283. "->smbus_xfer() failed\n", i));
  284. if (err_handler) {
  285. err_handler(smbus);
  286. }
  287. } else {
  288. break;
  289. }
  290. }
  291. return result;
  292. }
  293. /* --------------------------------------------------------------------------
  294. Smart Battery System Management
  295. -------------------------------------------------------------------------- */
  296. /* Smart Battery */
  297. static int acpi_sbs_generate_event(struct acpi_device *device,
  298. int event, int state, char *bid, char *class)
  299. {
  300. char bid_saved[5];
  301. char class_saved[20];
  302. int result = 0;
  303. strcpy(bid_saved, acpi_device_bid(device));
  304. strcpy(class_saved, acpi_device_class(device));
  305. strcpy(acpi_device_bid(device), bid);
  306. strcpy(acpi_device_class(device), class);
  307. result = acpi_bus_generate_event(device, event, state);
  308. strcpy(acpi_device_bid(device), bid_saved);
  309. strcpy(acpi_device_class(device), class_saved);
  310. return result;
  311. }
  312. static int acpi_battery_get_present(struct acpi_battery *battery)
  313. {
  314. s16 state;
  315. int result = 0;
  316. int is_present = 0;
  317. result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
  318. ACPI_SBSM_SMBUS_ADDR, 0x01,
  319. &state, NULL);
  320. if (result) {
  321. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  322. "acpi_sbs_smbus_read_word() failed"));
  323. }
  324. if (!result) {
  325. is_present = (state & 0x000f) & (1 << battery->id);
  326. }
  327. battery->battery_present = is_present;
  328. return result;
  329. }
  330. static int acpi_battery_is_present(struct acpi_battery *battery)
  331. {
  332. return (battery->battery_present);
  333. }
  334. static int acpi_ac_is_present(struct acpi_sbs *sbs)
  335. {
  336. return (sbs->ac_present);
  337. }
  338. static int acpi_battery_select(struct acpi_battery *battery)
  339. {
  340. struct acpi_ec_smbus *smbus = battery->sbs->smbus;
  341. int result = 0;
  342. s16 state;
  343. int foo;
  344. if (battery->sbs->sbsm_present) {
  345. /* Take special care not to knobble other nibbles of
  346. * state (aka selector_state), since
  347. * it causes charging to halt on SBSELs */
  348. result =
  349. acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x01,
  350. &state, NULL);
  351. if (result) {
  352. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  353. "acpi_sbs_smbus_read_word() failed\n"));
  354. goto end;
  355. }
  356. foo = (state & 0x0fff) | (1 << (battery->id + 12));
  357. result =
  358. acpi_sbs_smbus_write_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x01,
  359. foo, NULL);
  360. if (result) {
  361. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  362. "acpi_sbs_smbus_write_word() failed\n"));
  363. goto end;
  364. }
  365. }
  366. end:
  367. return result;
  368. }
  369. static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
  370. {
  371. struct acpi_ec_smbus *smbus = sbs->smbus;
  372. int result = 0;
  373. s16 battery_system_info;
  374. result = acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x04,
  375. &battery_system_info, NULL);
  376. if (result) {
  377. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  378. "acpi_sbs_smbus_read_word() failed\n"));
  379. goto end;
  380. }
  381. sbs->sbsm_batteries_supported = battery_system_info & 0x000f;
  382. end:
  383. return result;
  384. }
  385. static int acpi_battery_get_info(struct acpi_battery *battery)
  386. {
  387. struct acpi_ec_smbus *smbus = battery->sbs->smbus;
  388. int result = 0;
  389. s16 battery_mode;
  390. s16 specification_info;
  391. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
  392. &battery_mode,
  393. &acpi_battery_smbus_err_handler);
  394. if (result) {
  395. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  396. "acpi_sbs_smbus_read_word() failed\n"));
  397. goto end;
  398. }
  399. battery->info.capacity_mode = (battery_mode & 0x8000) >> 15;
  400. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x10,
  401. &battery->info.full_charge_capacity,
  402. &acpi_battery_smbus_err_handler);
  403. if (result) {
  404. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  405. "acpi_sbs_smbus_read_word() failed\n"));
  406. goto end;
  407. }
  408. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x18,
  409. &battery->info.design_capacity,
  410. &acpi_battery_smbus_err_handler);
  411. if (result) {
  412. goto end;
  413. }
  414. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x19,
  415. &battery->info.design_voltage,
  416. &acpi_battery_smbus_err_handler);
  417. if (result) {
  418. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  419. "acpi_sbs_smbus_read_word() failed\n"));
  420. goto end;
  421. }
  422. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x1a,
  423. &specification_info,
  424. &acpi_battery_smbus_err_handler);
  425. if (result) {
  426. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  427. "acpi_sbs_smbus_read_word() failed\n"));
  428. goto end;
  429. }
  430. switch ((specification_info & 0x0f00) >> 8) {
  431. case 1:
  432. battery->info.vscale = 10;
  433. break;
  434. case 2:
  435. battery->info.vscale = 100;
  436. break;
  437. case 3:
  438. battery->info.vscale = 1000;
  439. break;
  440. default:
  441. battery->info.vscale = 1;
  442. }
  443. switch ((specification_info & 0xf000) >> 12) {
  444. case 1:
  445. battery->info.ipscale = 10;
  446. break;
  447. case 2:
  448. battery->info.ipscale = 100;
  449. break;
  450. case 3:
  451. battery->info.ipscale = 1000;
  452. break;
  453. default:
  454. battery->info.ipscale = 1;
  455. }
  456. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x1c,
  457. &battery->info.serial_number,
  458. &acpi_battery_smbus_err_handler);
  459. if (result) {
  460. goto end;
  461. }
  462. result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x20,
  463. battery->info.manufacturer_name,
  464. &acpi_battery_smbus_err_handler);
  465. if (result) {
  466. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  467. "acpi_sbs_smbus_read_str() failed\n"));
  468. goto end;
  469. }
  470. result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x21,
  471. battery->info.device_name,
  472. &acpi_battery_smbus_err_handler);
  473. if (result) {
  474. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  475. "acpi_sbs_smbus_read_str() failed\n"));
  476. goto end;
  477. }
  478. result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x22,
  479. battery->info.device_chemistry,
  480. &acpi_battery_smbus_err_handler);
  481. if (result) {
  482. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  483. "acpi_sbs_smbus_read_str() failed\n"));
  484. goto end;
  485. }
  486. end:
  487. return result;
  488. }
  489. static void acpi_update_delay(struct acpi_sbs *sbs)
  490. {
  491. if (sbs->zombie) {
  492. return;
  493. }
  494. if (sbs->update_time2 > 0) {
  495. msleep(sbs->update_time2 * 1000);
  496. }
  497. }
  498. static int acpi_battery_get_state(struct acpi_battery *battery)
  499. {
  500. struct acpi_ec_smbus *smbus = battery->sbs->smbus;
  501. int result = 0;
  502. acpi_update_delay(battery->sbs);
  503. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x09,
  504. &battery->state.voltage,
  505. &acpi_battery_smbus_err_handler);
  506. if (result) {
  507. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  508. "acpi_sbs_smbus_read_word() failed\n"));
  509. goto end;
  510. }
  511. acpi_update_delay(battery->sbs);
  512. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x0a,
  513. &battery->state.amperage,
  514. &acpi_battery_smbus_err_handler);
  515. if (result) {
  516. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  517. "acpi_sbs_smbus_read_word() failed\n"));
  518. goto end;
  519. }
  520. acpi_update_delay(battery->sbs);
  521. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x0f,
  522. &battery->state.remaining_capacity,
  523. &acpi_battery_smbus_err_handler);
  524. if (result) {
  525. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  526. "acpi_sbs_smbus_read_word() failed\n"));
  527. goto end;
  528. }
  529. acpi_update_delay(battery->sbs);
  530. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x12,
  531. &battery->state.average_time_to_empty,
  532. &acpi_battery_smbus_err_handler);
  533. if (result) {
  534. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  535. "acpi_sbs_smbus_read_word() failed\n"));
  536. goto end;
  537. }
  538. acpi_update_delay(battery->sbs);
  539. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x13,
  540. &battery->state.average_time_to_full,
  541. &acpi_battery_smbus_err_handler);
  542. if (result) {
  543. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  544. "acpi_sbs_smbus_read_word() failed\n"));
  545. goto end;
  546. }
  547. acpi_update_delay(battery->sbs);
  548. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x16,
  549. &battery->state.battery_status,
  550. &acpi_battery_smbus_err_handler);
  551. if (result) {
  552. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  553. "acpi_sbs_smbus_read_word() failed\n"));
  554. goto end;
  555. }
  556. acpi_update_delay(battery->sbs);
  557. end:
  558. return result;
  559. }
  560. static int acpi_battery_get_alarm(struct acpi_battery *battery)
  561. {
  562. struct acpi_ec_smbus *smbus = battery->sbs->smbus;
  563. int result = 0;
  564. result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
  565. &battery->alarm.remaining_capacity,
  566. &acpi_battery_smbus_err_handler);
  567. if (result) {
  568. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  569. "acpi_sbs_smbus_read_word() failed\n"));
  570. goto end;
  571. }
  572. acpi_update_delay(battery->sbs);
  573. end:
  574. return result;
  575. }
  576. static int acpi_battery_set_alarm(struct acpi_battery *battery,
  577. unsigned long alarm)
  578. {
  579. struct acpi_ec_smbus *smbus = battery->sbs->smbus;
  580. int result = 0;
  581. s16 battery_mode;
  582. int foo;
  583. result = acpi_battery_select(battery);
  584. if (result) {
  585. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  586. "acpi_battery_select() failed\n"));
  587. goto end;
  588. }
  589. /* If necessary, enable the alarm */
  590. if (alarm > 0) {
  591. result =
  592. acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
  593. &battery_mode,
  594. &acpi_battery_smbus_err_handler);
  595. if (result) {
  596. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  597. "acpi_sbs_smbus_read_word() failed\n"));
  598. goto end;
  599. }
  600. result =
  601. acpi_sbs_smbus_write_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
  602. battery_mode & 0xbfff,
  603. &acpi_battery_smbus_err_handler);
  604. if (result) {
  605. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  606. "acpi_sbs_smbus_write_word() failed\n"));
  607. goto end;
  608. }
  609. }
  610. foo = alarm / (battery->info.capacity_mode ? 10 : 1);
  611. result = acpi_sbs_smbus_write_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
  612. foo,
  613. &acpi_battery_smbus_err_handler);
  614. if (result) {
  615. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  616. "acpi_sbs_smbus_write_word() failed\n"));
  617. goto end;
  618. }
  619. end:
  620. return result;
  621. }
  622. static int acpi_battery_set_mode(struct acpi_battery *battery)
  623. {
  624. int result = 0;
  625. s16 battery_mode;
  626. if (capacity_mode == DEF_CAPACITY_UNIT) {
  627. goto end;
  628. }
  629. result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
  630. ACPI_SB_SMBUS_ADDR, 0x03,
  631. &battery_mode, NULL);
  632. if (result) {
  633. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  634. "acpi_sbs_smbus_read_word() failed\n"));
  635. goto end;
  636. }
  637. if (capacity_mode == MAH_CAPACITY_UNIT) {
  638. battery_mode &= 0x7fff;
  639. } else {
  640. battery_mode |= 0x8000;
  641. }
  642. result = acpi_sbs_smbus_write_word(battery->sbs->smbus,
  643. ACPI_SB_SMBUS_ADDR, 0x03,
  644. battery_mode, NULL);
  645. if (result) {
  646. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  647. "acpi_sbs_smbus_write_word() failed\n"));
  648. goto end;
  649. }
  650. result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
  651. ACPI_SB_SMBUS_ADDR, 0x03,
  652. &battery_mode, NULL);
  653. if (result) {
  654. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  655. "acpi_sbs_smbus_read_word() failed\n"));
  656. goto end;
  657. }
  658. end:
  659. return result;
  660. }
  661. static int acpi_battery_init(struct acpi_battery *battery)
  662. {
  663. int result = 0;
  664. result = acpi_battery_select(battery);
  665. if (result) {
  666. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  667. "acpi_battery_init() failed\n"));
  668. goto end;
  669. }
  670. result = acpi_battery_set_mode(battery);
  671. if (result) {
  672. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  673. "acpi_battery_set_mode() failed\n"));
  674. goto end;
  675. }
  676. result = acpi_battery_get_info(battery);
  677. if (result) {
  678. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  679. "acpi_battery_get_info() failed\n"));
  680. goto end;
  681. }
  682. result = acpi_battery_get_state(battery);
  683. if (result) {
  684. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  685. "acpi_battery_get_state() failed\n"));
  686. goto end;
  687. }
  688. result = acpi_battery_get_alarm(battery);
  689. if (result) {
  690. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  691. "acpi_battery_get_alarm() failed\n"));
  692. goto end;
  693. }
  694. end:
  695. return result;
  696. }
  697. static int acpi_ac_get_present(struct acpi_sbs *sbs)
  698. {
  699. struct acpi_ec_smbus *smbus = sbs->smbus;
  700. int result = 0;
  701. s16 charger_status;
  702. result = acpi_sbs_smbus_read_word(smbus, ACPI_SBC_SMBUS_ADDR, 0x13,
  703. &charger_status, NULL);
  704. if (result) {
  705. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  706. "acpi_sbs_smbus_read_word() failed\n"));
  707. goto end;
  708. }
  709. sbs->ac_present = (charger_status & 0x8000) >> 15;
  710. end:
  711. return result;
  712. }
  713. /* --------------------------------------------------------------------------
  714. FS Interface (/proc/acpi)
  715. -------------------------------------------------------------------------- */
  716. /* Generic Routines */
  717. static int
  718. acpi_sbs_generic_add_fs(struct proc_dir_entry **dir,
  719. struct proc_dir_entry *parent_dir,
  720. char *dir_name,
  721. struct file_operations *info_fops,
  722. struct file_operations *state_fops,
  723. struct file_operations *alarm_fops, void *data)
  724. {
  725. struct proc_dir_entry *entry = NULL;
  726. if (!*dir) {
  727. *dir = proc_mkdir(dir_name, parent_dir);
  728. if (!*dir) {
  729. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  730. "proc_mkdir() failed\n"));
  731. return -ENODEV;
  732. }
  733. (*dir)->owner = THIS_MODULE;
  734. }
  735. /* 'info' [R] */
  736. if (info_fops) {
  737. entry = create_proc_entry(ACPI_SBS_FILE_INFO, S_IRUGO, *dir);
  738. if (!entry) {
  739. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  740. "create_proc_entry() failed\n"));
  741. } else {
  742. entry->proc_fops = info_fops;
  743. entry->data = data;
  744. entry->owner = THIS_MODULE;
  745. }
  746. }
  747. /* 'state' [R] */
  748. if (state_fops) {
  749. entry = create_proc_entry(ACPI_SBS_FILE_STATE, S_IRUGO, *dir);
  750. if (!entry) {
  751. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  752. "create_proc_entry() failed\n"));
  753. } else {
  754. entry->proc_fops = state_fops;
  755. entry->data = data;
  756. entry->owner = THIS_MODULE;
  757. }
  758. }
  759. /* 'alarm' [R/W] */
  760. if (alarm_fops) {
  761. entry = create_proc_entry(ACPI_SBS_FILE_ALARM, S_IRUGO, *dir);
  762. if (!entry) {
  763. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  764. "create_proc_entry() failed\n"));
  765. } else {
  766. entry->proc_fops = alarm_fops;
  767. entry->data = data;
  768. entry->owner = THIS_MODULE;
  769. }
  770. }
  771. return 0;
  772. }
  773. static void
  774. acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir,
  775. struct proc_dir_entry *parent_dir)
  776. {
  777. if (*dir) {
  778. remove_proc_entry(ACPI_SBS_FILE_INFO, *dir);
  779. remove_proc_entry(ACPI_SBS_FILE_STATE, *dir);
  780. remove_proc_entry(ACPI_SBS_FILE_ALARM, *dir);
  781. remove_proc_entry((*dir)->name, parent_dir);
  782. *dir = NULL;
  783. }
  784. }
  785. /* Smart Battery Interface */
  786. static struct proc_dir_entry *acpi_battery_dir = NULL;
  787. static int acpi_battery_read_info(struct seq_file *seq, void *offset)
  788. {
  789. struct acpi_battery *battery = seq->private;
  790. int cscale;
  791. int result = 0;
  792. if (battery->sbs->zombie) {
  793. return -ENODEV;
  794. }
  795. down(&sbs_sem);
  796. if (update_mode == REQUEST_UPDATE_MODE) {
  797. result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_INFO);
  798. if (result) {
  799. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  800. "acpi_sbs_update_run() failed\n"));
  801. }
  802. }
  803. if (acpi_battery_is_present(battery)) {
  804. seq_printf(seq, "present: yes\n");
  805. } else {
  806. seq_printf(seq, "present: no\n");
  807. goto end;
  808. }
  809. if (battery->info.capacity_mode) {
  810. cscale = battery->info.vscale * battery->info.ipscale;
  811. } else {
  812. cscale = battery->info.ipscale;
  813. }
  814. seq_printf(seq, "design capacity: %i%s",
  815. battery->info.design_capacity * cscale,
  816. battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
  817. seq_printf(seq, "last full capacity: %i%s",
  818. battery->info.full_charge_capacity * cscale,
  819. battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
  820. seq_printf(seq, "battery technology: rechargeable\n");
  821. seq_printf(seq, "design voltage: %i mV\n",
  822. battery->info.design_voltage * battery->info.vscale);
  823. seq_printf(seq, "design capacity warning: unknown\n");
  824. seq_printf(seq, "design capacity low: unknown\n");
  825. seq_printf(seq, "capacity granularity 1: unknown\n");
  826. seq_printf(seq, "capacity granularity 2: unknown\n");
  827. seq_printf(seq, "model number: %s\n",
  828. battery->info.device_name);
  829. seq_printf(seq, "serial number: %i\n",
  830. battery->info.serial_number);
  831. seq_printf(seq, "battery type: %s\n",
  832. battery->info.device_chemistry);
  833. seq_printf(seq, "OEM info: %s\n",
  834. battery->info.manufacturer_name);
  835. end:
  836. up(&sbs_sem);
  837. return result;
  838. }
  839. static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
  840. {
  841. return single_open(file, acpi_battery_read_info, PDE(inode)->data);
  842. }
  843. static int acpi_battery_read_state(struct seq_file *seq, void *offset)
  844. {
  845. struct acpi_battery *battery = (struct acpi_battery *)seq->private;
  846. int result = 0;
  847. int cscale;
  848. int foo;
  849. if (battery->sbs->zombie) {
  850. return -ENODEV;
  851. }
  852. down(&sbs_sem);
  853. if (update_mode == REQUEST_UPDATE_MODE) {
  854. result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_STATE);
  855. if (result) {
  856. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  857. "acpi_sbs_update_run() failed\n"));
  858. }
  859. }
  860. if (acpi_battery_is_present(battery)) {
  861. seq_printf(seq, "present: yes\n");
  862. } else {
  863. seq_printf(seq, "present: no\n");
  864. goto end;
  865. }
  866. if (battery->info.capacity_mode) {
  867. cscale = battery->info.vscale * battery->info.ipscale;
  868. } else {
  869. cscale = battery->info.ipscale;
  870. }
  871. if (battery->state.battery_status & 0x0010) {
  872. seq_printf(seq, "capacity state: critical\n");
  873. } else {
  874. seq_printf(seq, "capacity state: ok\n");
  875. }
  876. foo = (s16) battery->state.amperage * battery->info.ipscale;
  877. if (battery->info.capacity_mode) {
  878. foo = foo * battery->info.design_voltage / 1000;
  879. }
  880. if (battery->state.amperage < 0) {
  881. seq_printf(seq, "charging state: discharging\n");
  882. seq_printf(seq, "present rate: %d %s\n",
  883. -foo, battery->info.capacity_mode ? "mW" : "mA");
  884. } else if (battery->state.amperage > 0) {
  885. seq_printf(seq, "charging state: charging\n");
  886. seq_printf(seq, "present rate: %d %s\n",
  887. foo, battery->info.capacity_mode ? "mW" : "mA");
  888. } else {
  889. seq_printf(seq, "charging state: charged\n");
  890. seq_printf(seq, "present rate: 0 %s\n",
  891. battery->info.capacity_mode ? "mW" : "mA");
  892. }
  893. seq_printf(seq, "remaining capacity: %i%s",
  894. battery->state.remaining_capacity * cscale,
  895. battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
  896. seq_printf(seq, "present voltage: %i mV\n",
  897. battery->state.voltage * battery->info.vscale);
  898. end:
  899. up(&sbs_sem);
  900. return result;
  901. }
  902. static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
  903. {
  904. return single_open(file, acpi_battery_read_state, PDE(inode)->data);
  905. }
  906. static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
  907. {
  908. struct acpi_battery *battery = seq->private;
  909. int result = 0;
  910. int cscale;
  911. if (battery->sbs->zombie) {
  912. return -ENODEV;
  913. }
  914. down(&sbs_sem);
  915. if (update_mode == REQUEST_UPDATE_MODE) {
  916. result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_ALARM);
  917. if (result) {
  918. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  919. "acpi_sbs_update_run() failed\n"));
  920. }
  921. }
  922. if (!acpi_battery_is_present(battery)) {
  923. seq_printf(seq, "present: no\n");
  924. goto end;
  925. }
  926. if (battery->info.capacity_mode) {
  927. cscale = battery->info.vscale * battery->info.ipscale;
  928. } else {
  929. cscale = battery->info.ipscale;
  930. }
  931. seq_printf(seq, "alarm: ");
  932. if (battery->alarm.remaining_capacity) {
  933. seq_printf(seq, "%i%s",
  934. battery->alarm.remaining_capacity * cscale,
  935. battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
  936. } else {
  937. seq_printf(seq, "disabled\n");
  938. }
  939. end:
  940. up(&sbs_sem);
  941. return result;
  942. }
  943. static ssize_t
  944. acpi_battery_write_alarm(struct file *file, const char __user * buffer,
  945. size_t count, loff_t * ppos)
  946. {
  947. struct seq_file *seq = file->private_data;
  948. struct acpi_battery *battery = seq->private;
  949. char alarm_string[12] = { '\0' };
  950. int result, old_alarm, new_alarm;
  951. if (battery->sbs->zombie) {
  952. return -ENODEV;
  953. }
  954. down(&sbs_sem);
  955. if (!acpi_battery_is_present(battery)) {
  956. result = -ENODEV;
  957. goto end;
  958. }
  959. if (count > sizeof(alarm_string) - 1) {
  960. result = -EINVAL;
  961. goto end;
  962. }
  963. if (copy_from_user(alarm_string, buffer, count)) {
  964. result = -EFAULT;
  965. goto end;
  966. }
  967. alarm_string[count] = 0;
  968. old_alarm = battery->alarm.remaining_capacity;
  969. new_alarm = simple_strtoul(alarm_string, NULL, 0);
  970. result = acpi_battery_set_alarm(battery, new_alarm);
  971. if (result) {
  972. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  973. "acpi_battery_set_alarm() failed\n"));
  974. acpi_battery_set_alarm(battery, old_alarm);
  975. goto end;
  976. }
  977. result = acpi_battery_get_alarm(battery);
  978. if (result) {
  979. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  980. "acpi_battery_get_alarm() failed\n"));
  981. acpi_battery_set_alarm(battery, old_alarm);
  982. goto end;
  983. }
  984. end:
  985. up(&sbs_sem);
  986. if (result) {
  987. return result;
  988. } else {
  989. return count;
  990. }
  991. }
  992. static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
  993. {
  994. return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
  995. }
  996. static struct file_operations acpi_battery_info_fops = {
  997. .open = acpi_battery_info_open_fs,
  998. .read = seq_read,
  999. .llseek = seq_lseek,
  1000. .release = single_release,
  1001. .owner = THIS_MODULE,
  1002. };
  1003. static struct file_operations acpi_battery_state_fops = {
  1004. .open = acpi_battery_state_open_fs,
  1005. .read = seq_read,
  1006. .llseek = seq_lseek,
  1007. .release = single_release,
  1008. .owner = THIS_MODULE,
  1009. };
  1010. static struct file_operations acpi_battery_alarm_fops = {
  1011. .open = acpi_battery_alarm_open_fs,
  1012. .read = seq_read,
  1013. .write = acpi_battery_write_alarm,
  1014. .llseek = seq_lseek,
  1015. .release = single_release,
  1016. .owner = THIS_MODULE,
  1017. };
  1018. /* Legacy AC Adapter Interface */
  1019. static struct proc_dir_entry *acpi_ac_dir = NULL;
  1020. static int acpi_ac_read_state(struct seq_file *seq, void *offset)
  1021. {
  1022. struct acpi_sbs *sbs = seq->private;
  1023. int result;
  1024. if (sbs->zombie) {
  1025. return -ENODEV;
  1026. }
  1027. down(&sbs_sem);
  1028. if (update_mode == REQUEST_UPDATE_MODE) {
  1029. result = acpi_sbs_update_run(sbs, DATA_TYPE_AC_STATE);
  1030. if (result) {
  1031. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1032. "acpi_sbs_update_run() failed\n"));
  1033. }
  1034. }
  1035. seq_printf(seq, "state: %s\n",
  1036. sbs->ac_present ? "on-line" : "off-line");
  1037. up(&sbs_sem);
  1038. return 0;
  1039. }
  1040. static int acpi_ac_state_open_fs(struct inode *inode, struct file *file)
  1041. {
  1042. return single_open(file, acpi_ac_read_state, PDE(inode)->data);
  1043. }
  1044. static struct file_operations acpi_ac_state_fops = {
  1045. .open = acpi_ac_state_open_fs,
  1046. .read = seq_read,
  1047. .llseek = seq_lseek,
  1048. .release = single_release,
  1049. .owner = THIS_MODULE,
  1050. };
  1051. /* --------------------------------------------------------------------------
  1052. Driver Interface
  1053. -------------------------------------------------------------------------- */
  1054. /* Smart Battery */
  1055. static int acpi_battery_add(struct acpi_sbs *sbs, int id)
  1056. {
  1057. int is_present;
  1058. int result;
  1059. char dir_name[32];
  1060. struct acpi_battery *battery;
  1061. battery = &sbs->battery[id];
  1062. battery->alive = 0;
  1063. battery->init_state = 0;
  1064. battery->id = id;
  1065. battery->sbs = sbs;
  1066. result = acpi_battery_select(battery);
  1067. if (result) {
  1068. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1069. "acpi_battery_select() failed\n"));
  1070. goto end;
  1071. }
  1072. result = acpi_battery_get_present(battery);
  1073. if (result) {
  1074. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1075. "acpi_battery_get_present() failed\n"));
  1076. goto end;
  1077. }
  1078. is_present = acpi_battery_is_present(battery);
  1079. if (is_present) {
  1080. result = acpi_battery_init(battery);
  1081. if (result) {
  1082. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1083. "acpi_battery_init() failed\n"));
  1084. goto end;
  1085. }
  1086. battery->init_state = 1;
  1087. }
  1088. sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
  1089. result = acpi_sbs_generic_add_fs(&battery->battery_entry,
  1090. acpi_battery_dir,
  1091. dir_name,
  1092. &acpi_battery_info_fops,
  1093. &acpi_battery_state_fops,
  1094. &acpi_battery_alarm_fops, battery);
  1095. if (result) {
  1096. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1097. "acpi_sbs_generic_add_fs() failed\n"));
  1098. goto end;
  1099. }
  1100. battery->alive = 1;
  1101. end:
  1102. return result;
  1103. }
  1104. static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
  1105. {
  1106. if (sbs->battery[id].battery_entry) {
  1107. acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry),
  1108. acpi_battery_dir);
  1109. }
  1110. }
  1111. static int acpi_ac_add(struct acpi_sbs *sbs)
  1112. {
  1113. int result;
  1114. result = acpi_ac_get_present(sbs);
  1115. if (result) {
  1116. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1117. "acpi_ac_get_present() failed\n"));
  1118. goto end;
  1119. }
  1120. result = acpi_sbs_generic_add_fs(&sbs->ac_entry,
  1121. acpi_ac_dir,
  1122. ACPI_AC_DIR_NAME,
  1123. NULL, &acpi_ac_state_fops, NULL, sbs);
  1124. if (result) {
  1125. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1126. "acpi_sbs_generic_add_fs() failed\n"));
  1127. goto end;
  1128. }
  1129. end:
  1130. return result;
  1131. }
  1132. static void acpi_ac_remove(struct acpi_sbs *sbs)
  1133. {
  1134. if (sbs->ac_entry) {
  1135. acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir);
  1136. }
  1137. }
  1138. static void acpi_sbs_update_queue_run(unsigned long data)
  1139. {
  1140. acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data);
  1141. }
  1142. static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
  1143. {
  1144. struct acpi_battery *battery;
  1145. int result = 0;
  1146. int old_ac_present;
  1147. int old_battery_present;
  1148. int new_ac_present;
  1149. int new_battery_present;
  1150. int id;
  1151. char dir_name[32];
  1152. int do_battery_init, do_ac_init;
  1153. s16 old_remaining_capacity;
  1154. if (sbs->zombie) {
  1155. goto end;
  1156. }
  1157. old_ac_present = acpi_ac_is_present(sbs);
  1158. result = acpi_ac_get_present(sbs);
  1159. if (result) {
  1160. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1161. "acpi_ac_get_present() failed\n"));
  1162. }
  1163. new_ac_present = acpi_ac_is_present(sbs);
  1164. do_ac_init = (old_ac_present != new_ac_present);
  1165. if (data_type == DATA_TYPE_AC_STATE) {
  1166. goto end;
  1167. }
  1168. for (id = 0; id < MAX_SBS_BAT; id++) {
  1169. battery = &sbs->battery[id];
  1170. if (battery->alive == 0) {
  1171. continue;
  1172. }
  1173. old_remaining_capacity = battery->state.remaining_capacity;
  1174. old_battery_present = acpi_battery_is_present(battery);
  1175. result = acpi_battery_select(battery);
  1176. if (result) {
  1177. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1178. "acpi_battery_select() failed\n"));
  1179. }
  1180. if (sbs->zombie) {
  1181. goto end;
  1182. }
  1183. result = acpi_battery_get_present(battery);
  1184. if (result) {
  1185. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1186. "acpi_battery_get_present() failed\n"));
  1187. }
  1188. if (sbs->zombie) {
  1189. goto end;
  1190. }
  1191. new_battery_present = acpi_battery_is_present(battery);
  1192. do_battery_init = ((old_battery_present != new_battery_present)
  1193. && new_battery_present);
  1194. if (sbs->zombie) {
  1195. goto end;
  1196. }
  1197. if (do_ac_init || do_battery_init ||
  1198. update_info_mode || sbs->update_info_mode) {
  1199. if (sbs->update_info_mode) {
  1200. sbs->update_info_mode = 0;
  1201. } else {
  1202. sbs->update_info_mode = 1;
  1203. }
  1204. result = acpi_battery_init(battery);
  1205. if (result) {
  1206. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1207. "acpi_battery_init() "
  1208. "failed\n"));
  1209. }
  1210. }
  1211. if (data_type == DATA_TYPE_INFO) {
  1212. continue;
  1213. }
  1214. if (sbs->zombie) {
  1215. goto end;
  1216. }
  1217. if (new_battery_present) {
  1218. result = acpi_battery_get_alarm(battery);
  1219. if (result) {
  1220. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1221. "acpi_battery_get_alarm() "
  1222. "failed\n"));
  1223. }
  1224. if (data_type == DATA_TYPE_ALARM) {
  1225. continue;
  1226. }
  1227. result = acpi_battery_get_state(battery);
  1228. if (result) {
  1229. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1230. "acpi_battery_get_state() "
  1231. "failed\n"));
  1232. }
  1233. }
  1234. if (sbs->zombie) {
  1235. goto end;
  1236. }
  1237. if (data_type != DATA_TYPE_COMMON) {
  1238. continue;
  1239. }
  1240. if (old_battery_present != new_battery_present) {
  1241. sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
  1242. result = acpi_sbs_generate_event(sbs->device,
  1243. ACPI_SBS_BATTERY_NOTIFY_STATUS,
  1244. new_battery_present,
  1245. dir_name,
  1246. ACPI_BATTERY_CLASS);
  1247. if (result) {
  1248. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1249. "acpi_sbs_generate_event() "
  1250. "failed\n"));
  1251. }
  1252. }
  1253. if (old_remaining_capacity != battery->state.remaining_capacity) {
  1254. sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
  1255. result = acpi_sbs_generate_event(sbs->device,
  1256. ACPI_SBS_BATTERY_NOTIFY_STATUS,
  1257. new_battery_present,
  1258. dir_name,
  1259. ACPI_BATTERY_CLASS);
  1260. if (result) {
  1261. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1262. "acpi_sbs_generate_event() failed\n"));
  1263. }
  1264. }
  1265. }
  1266. if (sbs->zombie) {
  1267. goto end;
  1268. }
  1269. if (data_type != DATA_TYPE_COMMON) {
  1270. goto end;
  1271. }
  1272. if (old_ac_present != new_ac_present) {
  1273. result = acpi_sbs_generate_event(sbs->device,
  1274. ACPI_SBS_AC_NOTIFY_STATUS,
  1275. new_ac_present,
  1276. ACPI_AC_DIR_NAME,
  1277. ACPI_AC_CLASS);
  1278. if (result) {
  1279. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1280. "acpi_sbs_generate_event() failed\n"));
  1281. }
  1282. }
  1283. end:
  1284. return result;
  1285. }
  1286. static void acpi_sbs_update_queue(void *data)
  1287. {
  1288. struct acpi_sbs *sbs = data;
  1289. unsigned long delay = -1;
  1290. int result;
  1291. if (sbs->zombie) {
  1292. goto end;
  1293. }
  1294. result = acpi_sbs_update_run(sbs, DATA_TYPE_COMMON);
  1295. if (result) {
  1296. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1297. "acpi_sbs_update_run() failed\n"));
  1298. }
  1299. if (sbs->zombie) {
  1300. goto end;
  1301. }
  1302. if (update_mode == REQUEST_UPDATE_MODE) {
  1303. goto end;
  1304. }
  1305. delay = jiffies + HZ * update_time;
  1306. sbs->update_timer.data = (unsigned long)data;
  1307. sbs->update_timer.function = acpi_sbs_update_queue_run;
  1308. sbs->update_timer.expires = delay;
  1309. add_timer(&sbs->update_timer);
  1310. end:
  1311. ;
  1312. }
  1313. static int acpi_sbs_add(struct acpi_device *device)
  1314. {
  1315. struct acpi_sbs *sbs = NULL;
  1316. struct acpi_ec_hc *ec_hc = NULL;
  1317. int result, remove_result = 0;
  1318. unsigned long sbs_obj;
  1319. int id, cnt;
  1320. acpi_status status = AE_OK;
  1321. sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
  1322. if (!sbs) {
  1323. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n"));
  1324. return -ENOMEM;
  1325. }
  1326. cnt = 0;
  1327. while (cnt < 10) {
  1328. cnt++;
  1329. ec_hc = acpi_get_ec_hc(device);
  1330. if (ec_hc) {
  1331. break;
  1332. }
  1333. msleep(1000);
  1334. }
  1335. if (!ec_hc) {
  1336. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1337. "acpi_get_ec_hc() failed: "
  1338. "NO driver found for EC HC SMBus\n"));
  1339. result = -ENODEV;
  1340. goto end;
  1341. }
  1342. sbs->device = device;
  1343. sbs->smbus = ec_hc->smbus;
  1344. strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
  1345. strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
  1346. acpi_driver_data(device) = sbs;
  1347. sbs->update_time = 0;
  1348. sbs->update_time2 = 0;
  1349. result = acpi_ac_add(sbs);
  1350. if (result) {
  1351. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_ac_add() failed\n"));
  1352. goto end;
  1353. }
  1354. result = acpi_evaluate_integer(device->handle, "_SBS", NULL, &sbs_obj);
  1355. if (ACPI_FAILURE(result)) {
  1356. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1357. "acpi_evaluate_integer() failed\n"));
  1358. result = -EIO;
  1359. goto end;
  1360. }
  1361. if (sbs_obj > 0) {
  1362. result = acpi_sbsm_get_info(sbs);
  1363. if (result) {
  1364. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1365. "acpi_sbsm_get_info() failed\n"));
  1366. goto end;
  1367. }
  1368. sbs->sbsm_present = 1;
  1369. }
  1370. if (sbs->sbsm_present == 0) {
  1371. result = acpi_battery_add(sbs, 0);
  1372. if (result) {
  1373. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1374. "acpi_battery_add() failed\n"));
  1375. goto end;
  1376. }
  1377. } else {
  1378. for (id = 0; id < MAX_SBS_BAT; id++) {
  1379. if ((sbs->sbsm_batteries_supported & (1 << id))) {
  1380. result = acpi_battery_add(sbs, id);
  1381. if (result) {
  1382. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1383. "acpi_battery_add() "
  1384. "failed\n"));
  1385. goto end;
  1386. }
  1387. }
  1388. }
  1389. }
  1390. sbs->handle = device->handle;
  1391. init_timer(&sbs->update_timer);
  1392. if (update_mode == QUEUE_UPDATE_MODE) {
  1393. status = acpi_os_execute(OSL_GPE_HANDLER,
  1394. acpi_sbs_update_queue, sbs);
  1395. if (status != AE_OK) {
  1396. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1397. "acpi_os_execute() failed\n"));
  1398. }
  1399. }
  1400. sbs->update_time = update_time;
  1401. sbs->update_time2 = update_time2;
  1402. printk(KERN_INFO PREFIX "%s [%s]\n",
  1403. acpi_device_name(device), acpi_device_bid(device));
  1404. end:
  1405. if (result) {
  1406. remove_result = acpi_sbs_remove(device, 0);
  1407. if (remove_result) {
  1408. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1409. "acpi_sbs_remove() failed\n"));
  1410. }
  1411. }
  1412. return result;
  1413. }
  1414. int acpi_sbs_remove(struct acpi_device *device, int type)
  1415. {
  1416. struct acpi_sbs *sbs;
  1417. int id;
  1418. if (!device) {
  1419. return -EINVAL;
  1420. }
  1421. sbs = (struct acpi_sbs *)acpi_driver_data(device);
  1422. if (!sbs) {
  1423. return -EINVAL;
  1424. }
  1425. sbs->zombie = 1;
  1426. sbs->update_time = 0;
  1427. sbs->update_time2 = 0;
  1428. del_timer_sync(&sbs->update_timer);
  1429. acpi_os_wait_events_complete(NULL);
  1430. del_timer_sync(&sbs->update_timer);
  1431. for (id = 0; id < MAX_SBS_BAT; id++) {
  1432. acpi_battery_remove(sbs, id);
  1433. }
  1434. acpi_ac_remove(sbs);
  1435. kfree(sbs);
  1436. return 0;
  1437. }
  1438. static int __init acpi_sbs_init(void)
  1439. {
  1440. int result = 0;
  1441. if (acpi_disabled)
  1442. return -ENODEV;
  1443. init_MUTEX(&sbs_sem);
  1444. if (capacity_mode != DEF_CAPACITY_UNIT
  1445. && capacity_mode != MAH_CAPACITY_UNIT
  1446. && capacity_mode != MWH_CAPACITY_UNIT) {
  1447. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: "
  1448. "invalid capacity_mode = %d\n",
  1449. capacity_mode));
  1450. return -EINVAL;
  1451. }
  1452. acpi_ac_dir = acpi_lock_ac_dir();
  1453. if (!acpi_ac_dir) {
  1454. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1455. "acpi_lock_ac_dir() failed\n"));
  1456. return -ENODEV;
  1457. }
  1458. acpi_battery_dir = acpi_lock_battery_dir();
  1459. if (!acpi_battery_dir) {
  1460. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1461. "acpi_lock_battery_dir() failed\n"));
  1462. return -ENODEV;
  1463. }
  1464. result = acpi_bus_register_driver(&acpi_sbs_driver);
  1465. if (result < 0) {
  1466. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1467. "acpi_bus_register_driver() failed\n"));
  1468. return -ENODEV;
  1469. }
  1470. return 0;
  1471. }
  1472. static void __exit acpi_sbs_exit(void)
  1473. {
  1474. acpi_bus_unregister_driver(&acpi_sbs_driver);
  1475. acpi_unlock_ac_dir(acpi_ac_dir);
  1476. acpi_ac_dir = NULL;
  1477. acpi_unlock_battery_dir(acpi_battery_dir);
  1478. acpi_battery_dir = NULL;
  1479. return;
  1480. }
  1481. module_init(acpi_sbs_init);
  1482. module_exit(acpi_sbs_exit);