开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
via-pmu.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：70k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

via-pmu.c：源码内容
  1. /*
  2.  * Device driver for the via-pmu on Apple Powermacs.
  3.  *
  4.  * The VIA (versatile interface adapter) interfaces to the PMU,
  5.  * a 6805 microprocessor core whose primary function is to control
  6.  * battery charging and system power on the PowerBook 3400 and 2400.
  7.  * The PMU also controls the ADB (Apple Desktop Bus) which connects
  8.  * to the keyboard and mouse, as well as the non-volatile RAM
  9.  * and the RTC (real time clock) chip.
  10.  *
  11.  * Copyright (C) 1998 Paul Mackerras and Fabio Riccardi.
  12.  * Copyright (C) 2001-2002 Benjamin Herrenschmidt
  13.  *
  14.  */
  15. #include <stdarg.h>
  16. #include <linux/config.h>
  17. #include <linux/types.h>
  18. #include <linux/errno.h>
  19. #include <linux/kernel.h>
  20. #include <linux/delay.h>
  21. #include <linux/sched.h>
  22. #include <linux/miscdevice.h>
  23. #include <linux/blkdev.h>
  24. #include <linux/pci.h>
  25. #include <linux/slab.h>
  26. #include <linux/poll.h>
  27. #include <linux/adb.h>
  28. #include <linux/pmu.h>
  29. #include <linux/cuda.h>
  30. #include <linux/smp_lock.h>
  31. #include <linux/module.h>
  32. #include <linux/spinlock.h>
  33. #include <linux/pm.h>
  34. #include <linux/proc_fs.h>
  35. #include <linux/init.h>
  36. #include <asm/prom.h>
  37. #include <asm/machdep.h>
  38. #include <asm/io.h>
  39. #include <asm/pgtable.h>
  40. #include <asm/system.h>
  41. #include <asm/sections.h>
  42. #include <asm/irq.h>
  43. #include <asm/hardirq.h>
  44. #include <asm/pmac_feature.h>
  45. #include <asm/uaccess.h>
  46. #include <asm/mmu_context.h>
  47. #include <asm/sections.h>
  48. #include <asm/cputable.h>
  49. #include <asm/time.h>
  50. #ifdef CONFIG_PMAC_BACKLIGHT
  51. #include <asm/backlight.h>
  52. #endif
  54. /* Some compile options */
  55. #undef SUSPEND_USES_PMU
  56. #define DEBUG_SLEEP
  57. #undef VERBOSE_WAKEUP
  58. #undef HACKED_PCI_SAVE
  59. #define NEW_OHARE_CODE
  61. /* Misc minor number allocated for /dev/pmu */
  62. #define PMU_MINOR 154
  64. /* How many iterations between battery polls */
  65. #define BATTERY_POLLING_COUNT 2
  67. static volatile unsigned char *via;
  69. /* VIA registers - spaced 0x200 bytes apart */
  70. #define RS 0x200 /* skip between registers */
  71. #define B 0 /* B-side data */
  72. #define A RS /* A-side data */
  73. #define DIRB (2*RS) /* B-side direction (1=output) */
  74. #define DIRA (3*RS) /* A-side direction (1=output) */
  75. #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */
  76. #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */
  77. #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */
  78. #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */
  79. #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */
  80. #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */
  81. #define SR (10*RS) /* Shift register */
  82. #define ACR (11*RS) /* Auxiliary control register */
  83. #define PCR (12*RS) /* Peripheral control register */
  84. #define IFR (13*RS) /* Interrupt flag register */
  85. #define IER (14*RS) /* Interrupt enable register */
  86. #define ANH (15*RS) /* A-side data, no handshake */
  88. /* Bits in B data register: both active low */
  89. #define TACK 0x08 /* Transfer acknowledge (input) */
  90. #define TREQ 0x10 /* Transfer request (output) */
  92. /* Bits in ACR */
  93. #define SR_CTRL 0x1c /* Shift register control bits */
  94. #define SR_EXT 0x0c /* Shift on external clock */
  95. #define SR_OUT 0x10 /* Shift out if 1 */
  97. /* Bits in IFR and IER */
  98. #define IER_SET 0x80 /* set bits in IER */
  99. #define IER_CLR 0 /* clear bits in IER */
  100. #define SR_INT 0x04 /* Shift register full/empty */
  101. #define CB2_INT 0x08
  102. #define CB1_INT 0x10 /* transition on CB1 input */
  104. static volatile enum pmu_state {
  105. idle,
  106. sending,
  107. intack,
  108. reading,
  109. reading_intr,
  110. } pmu_state;
  112. static volatile enum int_data_state {
  113. int_data_empty,
  114. int_data_fill,
  115. int_data_ready,
  116. int_data_flush
  117. } int_data_state[2] = { int_data_empty, int_data_empty };
  119. static struct adb_request *current_req;
  120. static struct adb_request *last_req;
  121. static struct adb_request *req_awaiting_reply;
  122. static unsigned char interrupt_data[2][32];
  123. static int interrupt_data_len[2];
  124. static int int_data_last;
  125. static unsigned char *reply_ptr;
  126. static int data_index;
  127. static int data_len;
  128. static volatile int adb_int_pending;
  129. static volatile int disable_poll;
  130. static struct adb_request bright_req_1, bright_req_2, bright_req_3;
  131. static struct device_node *vias;
  132. static int pmu_kind = PMU_UNKNOWN;
  133. static int pmu_fully_inited = 0;
  134. static int pmu_has_adb;
  135. static unsigned char *gpio_reg = NULL;
  136. static int gpio_irq = -1;
  137. static volatile int pmu_suspended = 0;
  138. static spinlock_t pmu_lock;
  139. static u8 pmu_intr_mask;
  140. static int pmu_version;
  141. static int drop_interrupts;
  142. #ifdef CONFIG_PMAC_PBOOK
  143. static int option_lid_wakeup = 1;
  144. static int sleep_in_progress;
  145. static int can_sleep;
  146. #endif /* CONFIG_PMAC_PBOOK */
  148. static struct proc_dir_entry *proc_pmu_root;
  149. static struct proc_dir_entry *proc_pmu_info;
  150. static struct proc_dir_entry *proc_pmu_options;
  152. #ifdef CONFIG_PMAC_PBOOK
  153. int pmu_battery_count;
  154. int pmu_cur_battery;
  155. unsigned int pmu_power_flags;
  156. struct pmu_battery_info pmu_batteries[PMU_MAX_BATTERIES];
  157. static int query_batt_timer = BATTERY_POLLING_COUNT;
  158. static struct adb_request batt_req;
  159. static struct proc_dir_entry *proc_pmu_batt[PMU_MAX_BATTERIES];
  160. #endif /* CONFIG_PMAC_PBOOK */
  162. #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
  163. extern int disable_kernel_backlight;
  164. #endif /* defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT) */
  166. int __fake_sleep;
  167. int asleep;
  168. struct notifier_block *sleep_notifier_list;
  170. #ifdef CONFIG_ADB
  171. static int adb_dev_map = 0;
  172. static int pmu_adb_flags;
  174. static int pmu_probe(void);
  175. static int pmu_init(void);
  176. static int pmu_send_request(struct adb_request *req, int sync);
  177. static int pmu_adb_autopoll(int devs);
  178. static int pmu_adb_reset_bus(void);
  179. #endif /* CONFIG_ADB */
  181. static int init_pmu(void);
  182. static int pmu_queue_request(struct adb_request *req);
  183. static void pmu_start(void);
  184. static void via_pmu_interrupt(int irq, void *arg, struct pt_regs *regs);
  185. static void gpio1_interrupt(int irq, void *arg, struct pt_regs *regs);
  186. static int proc_get_info(char *page, char **start, off_t off,
  187.   int count, int *eof, void *data);
  188. #ifdef CONFIG_PMAC_BACKLIGHT
  189. static int pmu_set_backlight_level(int level, void* data);
  190. static int pmu_set_backlight_enable(int on, int level, void* data);
  191. #endif /* CONFIG_PMAC_BACKLIGHT */
  192. #ifdef CONFIG_PMAC_PBOOK
  193. static void pmu_pass_intr(unsigned char *data, int len);
  194. static int proc_get_batt(char *page, char **start, off_t off,
  195. int count, int *eof, void *data);
  196. #endif /* CONFIG_PMAC_PBOOK */
  197. static int proc_read_options(char *page, char **start, off_t off,
  198. int count, int *eof, void *data);
  199. static int proc_write_options(struct file *file, const char *buffer,
  200. unsigned long count, void *data);
  202. #ifdef CONFIG_ADB
  203. struct adb_driver via_pmu_driver = {
  204. "PMU",
  205. pmu_probe,
  206. pmu_init,
  207. pmu_send_request,
  208. pmu_adb_autopoll,
  209. pmu_poll,
  210. pmu_adb_reset_bus
  211. };
  212. #endif /* CONFIG_ADB */
  214. extern void low_sleep_handler(void);
  215. extern void pmac_sleep_save_intrs(int);
  216. extern void pmac_sleep_restore_intrs(void);
  217. extern void openpic_sleep_save_intrs(void);
  218. extern void openpic_sleep_restore_intrs(void);
  219. extern void enable_kernel_altivec(void);
  220. extern void enable_kernel_fp(void);
  222. #if defined(DEBUG_SLEEP) || defined(DEBUG_FREQ)
  223. int pmu_polled_request(struct adb_request *req);
  224. void pmu_blink(int n);
  225. #endif
  227. #if defined(CONFIG_PMAC_PBOOK) && defined(CONFIG_PM)
  228. static int generic_notify_sleep(struct pmu_sleep_notifier *self, int when);
  229. static struct pmu_sleep_notifier generic_sleep_notifier = {
  230. generic_notify_sleep,
  231. SLEEP_LEVEL_MISC,
  232. };
  233. #endif /* defined(CONFIG_PMAC_PBOOK) && defined(CONFIG_PM) */
  235. /*
  236.  * This table indicates for each PMU opcode:
  237.  * - the number of data bytes to be sent with the command, or -1
  238.  *   if a length byte should be sent,
  239.  * - the number of response bytes which the PMU will return, or
  240.  *   -1 if it will send a length byte.
  241.  */
  242. static const s8 pmu_data_len[256][2] __openfirmwaredata = {
  243. /*    0    1    2    3    4    5    6    7  */
  244. /*00*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  245. /*08*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  246. /*10*/ { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  247. /*18*/ { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0, 0},
  248. /*20*/ {-1, 0},{ 0, 0},{ 2, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},
  249. /*28*/ { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0,-1},
  250. /*30*/ { 4, 0},{20, 0},{-1, 0},{ 3, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  251. /*38*/ { 0, 4},{ 0,20},{ 2,-1},{ 2, 1},{ 3,-1},{-1,-1},{-1,-1},{ 4, 0},
  252. /*40*/ { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  253. /*48*/ { 0, 1},{ 0, 1},{-1,-1},{ 1, 0},{ 1, 0},{-1,-1},{-1,-1},{-1,-1},
  254. /*50*/ { 1, 0},{ 0, 0},{ 2, 0},{ 2, 0},{-1, 0},{ 1, 0},{ 3, 0},{ 1, 0},
  255. /*58*/ { 0, 1},{ 1, 0},{ 0, 2},{ 0, 2},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},
  256. /*60*/ { 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  257. /*68*/ { 0, 3},{ 0, 3},{ 0, 2},{ 0, 8},{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},
  258. /*70*/ { 1, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  259. /*78*/ { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{ 5, 1},{ 4, 1},{ 4, 1},
  260. /*80*/ { 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  261. /*88*/ { 0, 5},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  262. /*90*/ { 1, 0},{ 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  263. /*98*/ { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  264. /*a0*/ { 2, 0},{ 2, 0},{ 2, 0},{ 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},
  265. /*a8*/ { 1, 1},{ 1, 0},{ 3, 0},{ 2, 0},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  266. /*b0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  267. /*b8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  268. /*c0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  269. /*c8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  270. /*d0*/ { 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  271. /*d8*/ { 1, 1},{ 1, 1},{-1,-1},{-1,-1},{ 0, 1},{ 0,-1},{-1,-1},{-1,-1},
  272. /*e0*/ {-1, 0},{ 4, 0},{ 0, 1},{-1, 0},{-1, 0},{ 4, 0},{-1, 0},{-1, 0},
  273. /*e8*/ { 3,-1},{-1,-1},{ 0, 1},{-1,-1},{ 0,-1},{-1,-1},{-1,-1},{ 0, 0},
  274. /*f0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  275. /*f8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  276. };
  278. static char *pbook_type[] = {
  279. "Unknown PowerBook",
  280. "PowerBook 2400/3400/3500(G3)",
  281. "PowerBook G3 Series",
  282. "1999 PowerBook G3",
  283. "Core99"
  284. };
  286. #ifdef CONFIG_PMAC_BACKLIGHT
  287. static struct backlight_controller pmu_backlight_controller = {
  288. pmu_set_backlight_enable,
  289. pmu_set_backlight_level
  290. };
  291. #endif /* CONFIG_PMAC_BACKLIGHT */
  293. int __openfirmware
  294. find_via_pmu()
  295. {
  296. if (via != 0)
  297. return 1;
  298. vias = find_devices("via-pmu");
  299. if (vias == 0)
  300. return 0;
  301. if (vias->next != 0)
  302. printk(KERN_WARNING "Warning: only using 1st via-pmun");
  304. if (vias->n_addrs < 1 || vias->n_intrs < 1) {
  305. printk(KERN_ERR "via-pmu: %d addresses, %d interrupts!n",
  306.        vias->n_addrs, vias->n_intrs);
  307. if (vias->n_addrs < 1 || vias->n_intrs < 1)
  308. return 0;
  309. }
  311. spin_lock_init(&pmu_lock);
  313. pmu_has_adb = 1;
  315. pmu_intr_mask = PMU_INT_PCEJECT |
  316. PMU_INT_SNDBRT |
  317. PMU_INT_ADB |
  318. PMU_INT_TICK;
  320. if (vias->parent->name && ((strcmp(vias->parent->name, "ohare") == 0)
  321.     || device_is_compatible(vias->parent, "ohare")))
  322. pmu_kind = PMU_OHARE_BASED;
  323. else if (device_is_compatible(vias->parent, "paddington"))
  324. pmu_kind = PMU_PADDINGTON_BASED;
  325. else if (device_is_compatible(vias->parent, "heathrow"))
  326. pmu_kind = PMU_HEATHROW_BASED;
  327. else if (device_is_compatible(vias->parent, "Keylargo")) {
  328. struct device_node *gpio, *gpiop;
  330. pmu_kind = PMU_KEYLARGO_BASED;
  331. pmu_has_adb = (find_type_devices("adb") != NULL);
  332. pmu_intr_mask = PMU_INT_PCEJECT |
  333. PMU_INT_SNDBRT |
  334. PMU_INT_ADB |
  335. PMU_INT_TICK |
  336. PMU_INT_ENVIRONMENT;
  338. gpiop = find_devices("gpio");
  339. if (gpiop && gpiop->n_addrs) {
  340. gpio_reg = ioremap(gpiop->addrs->address, 0x10);
  341. gpio = find_devices("extint-gpio1");
  342. if (gpio && gpio->parent == gpiop && gpio->n_intrs)
  343. gpio_irq = gpio->intrs[0].line;
  344. }
  345. } else
  346. pmu_kind = PMU_UNKNOWN;
  348. #ifdef CONFIG_PMAC_PBOOK
  349. if (pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,-1) >= 0)
  350. can_sleep = 1;
  351. #endif /* CONFIG_PMAC_PBOOK */
  353. via = (volatile unsigned char *) ioremap(vias->addrs->address, 0x2000);
  355. out_8(&via[IER], IER_CLR | 0x7f); /* disable all intrs */
  356. out_8(&via[IFR], 0x7f); /* clear IFR */
  358. pmu_state = idle;
  360. if (!init_pmu()) {
  361. via = NULL;
  362. return 0;
  363. }
  365. printk(KERN_INFO "PMU driver %d initialized for %s, firmware: %02xn",
  366.        PMU_DRIVER_VERSION, pbook_type[pmu_kind], pmu_version);
  367.        
  368. sys_ctrler = SYS_CTRLER_PMU;
  370. #if defined(CONFIG_PMAC_PBOOK) && defined(CONFIG_PM)
  371. pmu_register_sleep_notifier(&generic_sleep_notifier);
  372. pm_active = 1;
  373. #endif
  375. return 1;
  376. }
  378. #ifdef CONFIG_ADB
  379. static int __openfirmware
  380. pmu_probe()
  381. {
  382. return vias == NULL? -ENODEV: 0;
  383. }
  385. static int __openfirmware
  386. pmu_init(void)
  387. {
  388. if (vias == NULL)
  389. return -ENODEV;
  390. return 0;
  391. }
  392. #endif /* CONFIG_ADB */
  394. /*
  395.  * We can't wait until pmu_init gets called, that happens too late.
  396.  * It happens after IDE and SCSI initialization, which can take a few
  397.  * seconds, and by that time the PMU could have given up on us and
  398.  * turned us off.
  399.  * This is called from arch/ppc/kernel/pmac_setup.c:pmac_init2().
  400.  */
  401. int via_pmu_start(void)
  402. {
  403. if (vias == NULL)
  404. return -ENODEV;
  406. request_OF_resource(vias, 0, NULL);
  408. bright_req_1.complete = 1;
  409. bright_req_2.complete = 1;
  410. bright_req_3.complete = 1;
  411. #ifdef CONFIG_PMAC_PBOOK
  412. batt_req.complete = 1;
  413. #endif
  415. if (request_irq(vias->intrs[0].line, via_pmu_interrupt, 0, "VIA-PMU",
  416. (void *)0)) {
  417. printk(KERN_ERR "VIA-PMU: can't get irq %dn",
  418.        vias->intrs[0].line);
  419. return -EAGAIN;
  420. }
  422. if (pmu_kind == PMU_KEYLARGO_BASED && gpio_irq != -1) {
  423. if (request_irq(gpio_irq, gpio1_interrupt, 0, "GPIO1/ADB", (void *)0))
  424. printk(KERN_ERR "pmu: can't get irq %d (GPIO1)n", gpio_irq);
  425. }
  427. /* Enable interrupts */
  428. out_8(&via[IER], IER_SET | SR_INT | CB1_INT);
  430. pmu_fully_inited = 1;
  432. #ifdef CONFIG_PMAC_BACKLIGHT
  433. /* Enable backlight */
  434. register_backlight_controller(&pmu_backlight_controller, NULL, "pmu");
  435. #endif /* CONFIG_PMAC_BACKLIGHT */
  437. #ifdef CONFIG_PMAC_PBOOK
  438.    if (machine_is_compatible("AAPL,3400/2400") ||
  439.    machine_is_compatible("AAPL,3500"))
  440. pmu_battery_count = 1;
  441. else if (machine_is_compatible("AAPL,PowerBook1998") ||
  442. machine_is_compatible("PowerBook1,1"))
  443. pmu_battery_count = 2;
  444. else {
  445. struct device_node* prim = find_devices("power-mgt");
  446. u32 *prim_info = NULL;
  447. if (prim)
  448. prim_info = (u32 *)get_property(prim, "prim-info", NULL);
  449. if (prim_info) {
  450. /* Other stuffs here yet unknown */
  451. pmu_battery_count = (prim_info[6] >> 16) & 0xff;
  452. }
  453. }
  454. #endif /* CONFIG_PMAC_PBOOK */
  455. /* Create /proc/pmu */
  456. proc_pmu_root = proc_mkdir("pmu", 0);
  457. if (proc_pmu_root) {
  458. int i;
  459. proc_pmu_info = create_proc_read_entry("info", 0, proc_pmu_root,
  460. proc_get_info, NULL);
  461. #ifdef CONFIG_PMAC_PBOOK
  462. for (i=0; i<pmu_battery_count; i++) {
  463. char title[16];
  464. sprintf(title, "battery_%d", i);
  465. proc_pmu_batt[i] = create_proc_read_entry(title, 0, proc_pmu_root,
  466. proc_get_batt, (void *)i);
  467. }
  468. #endif /* CONFIG_PMAC_PBOOK */
  469. proc_pmu_options = create_proc_entry("options", 0600, proc_pmu_root);
  470. if (proc_pmu_options) {
  471. proc_pmu_options->nlink = 1;
  472. proc_pmu_options->read_proc = proc_read_options;
  473. proc_pmu_options->write_proc = proc_write_options;
  474. }
  475. }
  477. /* Make sure PMU settle down before continuing. This is _very_ important
  478.  * since the IDE probe may shut interrupts down for quite a bit of time. If
  479.  * a PMU communication is pending while this happens, the PMU may timeout
  480.  * Not that on Core99 machines, the PMU keeps sending us environement
  481.  * messages, we should find a way to either fix IDE or make it call
  482.  * pmu_suspend() before masking interrupts. This can also happens while
  483.  * scolling with some fbdevs.
  484.  */
  485. do {
  486. pmu_poll();
  487. } while (pmu_state != idle);
  489. return 0;
  490. }
  492. static int __openfirmware
  493. init_pmu()
  494. {
  495. int timeout;
  496. struct adb_request req;
  498. out_8(&via[B], via[B] | TREQ); /* negate TREQ */
  499. out_8(&via[DIRB], (via[DIRB] | TREQ) & ~TACK); /* TACK in, TREQ out */
  501. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
  502. timeout =  100000;
  503. while (!req.complete) {
  504. if (--timeout < 0) {
  505. printk(KERN_ERR "init_pmu: no response from PMUn");
  506. return 0;
  507. }
  508. udelay(10);
  509. pmu_poll();
  510. }
  512. /* ack all pending interrupts */
  513. timeout = 100000;
  514. interrupt_data[0][0] = 1;
  515. while (interrupt_data[0][0] || pmu_state != idle) {
  516. if (--timeout < 0) {
  517. printk(KERN_ERR "init_pmu: timed out acking intrsn");
  518. return 0;
  519. }
  520. if (pmu_state == idle)
  521. adb_int_pending = 1;
  522. via_pmu_interrupt(0, 0, 0);
  523. udelay(10);
  524. }
  526. /* Tell PMU we are ready.  */
  527. if (pmu_kind == PMU_KEYLARGO_BASED) {
  528. pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
  529. while (!req.complete)
  530. pmu_poll();
  531. }
  533. /* Read PMU version */
  534. pmu_request(&req, NULL, 1, PMU_GET_VERSION);
  535. while (!req.complete)
  536. pmu_poll();
  537. if (req.reply_len > 0)
  538. pmu_version = req.reply[0];
  540. return 1;
  541. }
  543. int
  544. pmu_get_model(void)
  545. {
  546. return pmu_kind;
  547. }
  549. static inline void wakeup_decrementer(void)
  550. {
  551. set_dec(tb_ticks_per_jiffy);
  552. /* No currently-supported powerbook has a 601,
  553.  * so use get_tbl, not native
  554.  */
  555. last_jiffy_stamp(0) = tb_last_stamp = get_tbl();
  556. }
  559. #ifdef CONFIG_PMAC_PBOOK
  561. /* 
  562.  * WARNING ! This code probably needs some debugging... -- BenH.
  563.  */
  564. #ifdef NEW_OHARE_CODE
  565. static void __pmac
  566. done_battery_state_ohare(struct adb_request* req)
  567. {
  568. unsigned int bat_flags = 0;
  569. int current = 0;
  570. unsigned int capa, max, voltage, time;
  571. int lrange[] = { 0, 275, 850, 1680, 2325, 
  572. 2765, 3160, 3500, 3830, 4115, 
  573. 4360, 4585, 4795, 4990, 5170, 
  574. 5340, 5510, 5710, 5930, 6150, 
  575. 6370, 6500
  576. };
  578. if (req->reply[0] & 0x01)
  579. pmu_power_flags |= PMU_PWR_AC_PRESENT;
  580. else
  581. pmu_power_flags &= ~PMU_PWR_AC_PRESENT;
  583. if (req->reply[0] & 0x04) {
  584. int vb, i, j, k, charge, pcharge;
  585. bat_flags |= PMU_BATT_PRESENT;
  586. vb = (req->reply[1] << 8) | req->reply[2];
  587. voltage = ((vb * 2650) + 726650)/100;
  588. vb *= 100;
  589. current = req->reply[5];
  590. if ((req->reply[0] & 0x01) == 0 && (current > 200))
  591. vb += (current - 200) * 15;
  592. else if (req->reply[0] & 0x02)
  593. vb = (vb - 2000);
  594.    i = (33000 - vb) / 10;
  595.    j = i - (i % 100);
  596. k = j/100;
  597. if (k <= 0)
  598.         charge = 0;
  599. else if (k >= 21)
  600.         charge = 650000;
  601.    else
  602. charge = (lrange[k + 1] - lrange[k]) * (i - j) + (lrange[k] * 100);
  603. charge = (1000 - charge / 650) / 10;
  604. if (req->reply[0] & 0x40) {
  605. pcharge = (req->reply[6] << 8) + req->reply[7];
  606. if (pcharge > 6500)
  607. pcharge = 6500;
  608. pcharge *= 100;
  609. pcharge = (1000 - pcharge / 650) / 10;
  610. if (pcharge < charge)
  611. charge = pcharge;
  612. }
  613. capa = charge;
  614. max = 100;
  615. time = (charge * 16440) / current;
  616. current = -current;
  618. } else
  619. capa = max = current = voltage = time = 0;
  621. if (req->reply[0] & 0x02)
  622. bat_flags |= PMU_BATT_CHARGING;
  624. pmu_batteries[pmu_cur_battery].flags = bat_flags;
  625. pmu_batteries[pmu_cur_battery].charge = capa;
  626. pmu_batteries[pmu_cur_battery].max_charge = max;
  627. pmu_batteries[pmu_cur_battery].current = current;
  628. pmu_batteries[pmu_cur_battery].voltage = voltage;
  629. pmu_batteries[pmu_cur_battery].time_remaining = time;
  630. }
  631. #else /* NEW_OHARE_CODE */
  632. static void __pmac
  633. done_battery_state_ohare(struct adb_request* req)
  634. {
  635. unsigned int bat_flags = 0;
  636. int current = 0;
  637. unsigned int capa, max, voltage, time;
  638. int lrange[] = { 0, 275, 850, 1680, 2325, 
  639. 2765, 3160, 3500, 3830, 4115, 
  640. 4360, 4585, 4795, 4990, 5170, 
  641. 5340, 5510, 5710, 5930, 6150, 
  642. 6370, 6500
  643. };
  645. if (req->reply[0] & 0x01)
  646. pmu_power_flags |= PMU_PWR_AC_PRESENT;
  647. else
  648. pmu_power_flags &= ~PMU_PWR_AC_PRESENT;
  650. if (req->reply[0] & 0x04) {
  651. int vb, i, j, charge, pcharge;
  652. bat_flags |= PMU_BATT_PRESENT;
  653. vb = (req->reply[1] << 8) | req->reply[2];
  654. voltage = ((vb * 2650) + 726650)/100;
  655. current = *((signed char *)&req->reply[5]);
  656. if ((req->reply[0] & 0x01) == 0 && (current > 200))
  657. vb += (current - 200) * 15;
  658. else if (req->reply[0] & 0x02)
  659. vb = (vb - 10) * 100;
  660.    i = (33000 - vb) / 10;
  661.    j = i - (i % 100);
  662.    if (j <= 0)
  663.         charge = 0;
  664.    else if (j >= 21)
  665.         charge = 650000;
  666.    else
  667. charge = (lrange[j + 1] - lrange[j]) * (i - j) + (lrange[j] * 100);
  668. charge = (1000 - charge / 650) / 10;
  669. if (req->reply[0] & 0x40) {
  670. pcharge = (req->reply[6] << 8) + req->reply[7];
  671. if (pcharge > 6500)
  672. pcharge = 6500;
  673. pcharge *= 100;
  674. pcharge = (1000 - pcharge / 650) / 10;
  675. if (pcharge < charge)
  676. charge = pcharge;
  677. }
  678. capa = charge;
  679. max = 100;
  680. time = (charge * 274) / current;
  681. current = -current;
  683. } else
  684. capa = max = current = voltage = time = 0;
  686. if ((req->reply[0] & 0x02) && (current > 0))
  687. bat_flags |= PMU_BATT_CHARGING;
  688. if (req->reply[0] & 0x04) /* CHECK THIS ONE */
  689. bat_flags |= PMU_BATT_PRESENT;
  691. pmu_batteries[pmu_cur_battery].flags = bat_flags;
  692. pmu_batteries[pmu_cur_battery].charge = capa;
  693. pmu_batteries[pmu_cur_battery].max_charge = max;
  694. pmu_batteries[pmu_cur_battery].current = current;
  695. pmu_batteries[pmu_cur_battery].voltage = voltage;
  696. pmu_batteries[pmu_cur_battery].time_remaining = time;
  697. }
  698. #endif /* NEW_OHARE_CODE */
  700.  static void __pmac
  701. done_battery_state_comet(struct adb_request* req)
  702. {
  703. /* format:
  704.  *  [0]    :  flags
  705.  *    0x01 :  AC indicator
  706.  *    0x02 :  charging
  707.  *    0x04 :  battery exist
  708.  *    0x08 :  
  709.  *    0x10 :  
  710.  *    0x20 :  full charged
  711.  *    0x40 :  pcharge reset
  712.  *    0x80 :  battery exist
  713.  *
  714.  *  [1][2] :  battery voltage
  715.  *  [3]    :  CPU temperature
  716.  *  [4]    :  battery temperature
  717.  *  [5]    :  current
  718.  *  [6][7] :  pcharge
  719.  *              --tkoba
  720.  */
  722. unsigned int bat_flags = 0;
  723. int current = 0;
  724. unsigned int max = 100;
  725. unsigned int charge, voltage, time;
  726. int lrange[] = { 0, 600, 750, 900, 1000, 1080, 
  727. 1180, 1250, 1300, 1340, 1360, 
  728. 1390, 1420, 1440, 1470, 1490, 
  729. 1520, 1550, 1580, 1610, 1650, 
  730. 1700
  731. };
  733. if (req->reply[0] & 0x01)
  734. pmu_power_flags |= PMU_PWR_AC_PRESENT;
  735. else
  736. pmu_power_flags &= ~PMU_PWR_AC_PRESENT;
  738. if (req->reply[0] & 0x04) { /* battery exist */
  739. int vb, i;
  740. bat_flags |= PMU_BATT_PRESENT;
  741. vb = (req->reply[1] << 8) | req->reply[2];
  742. voltage = ((vb * 2650) + 726650)/100;
  743. vb *= 10;
  744. current = req->reply[5];
  745. if ((req->reply[0] & 0x01) == 0 && (current > 200))
  746. vb += ((current - 200) * 3); /* vb = 500<->1800 */
  747. else if (req->reply[0] & 0x02)
  748. vb = ((vb - 800) * 1700/13)/100; /*  in charging vb = 1300<->2130 */
  750. if (req->reply[0] & 0x20) { /* full charged */
  751. charge = max;
  752. } else {
  753. if (lrange[21] < vb)
  754. charge = max;
  755. else {
  756. if (vb < lrange[1])
  757. charge = 0;
  758. else {
  759. for (i=21; vb < lrange[i]; --i);
  760. charge = (i * 100)/21;
  761. }
  762. }
  763. if (charge > max) charge = max;
  764. }
  765. time = (charge * 72);
  766. current = -current;
  767. } else
  768. max = current = voltage = time = 0;
  770. if (req->reply[0] & 0x02)
  771. bat_flags |= PMU_BATT_CHARGING;
  773. pmu_batteries[pmu_cur_battery].flags = bat_flags;
  774. pmu_batteries[pmu_cur_battery].charge = charge;
  775. pmu_batteries[pmu_cur_battery].max_charge = max;
  776. pmu_batteries[pmu_cur_battery].current = current;
  777. pmu_batteries[pmu_cur_battery].voltage = voltage;
  778. pmu_batteries[pmu_cur_battery].time_remaining = time;
  779. }
  781. static void __pmac
  782. done_battery_state_smart(struct adb_request* req)
  783. {
  784. /* format:
  785.  *  [0] : format of this structure (known: 3,4,5)
  786.  *  [1] : flags
  787.  *  
  788.  *  format 3 & 4:
  789.  *  
  790.  *  [2] : charge
  791.  *  [3] : max charge
  792.  *  [4] : current
  793.  *  [5] : voltage
  794.  *  
  795.  *  format 5:
  796.  *  
  797.  *  [2][3] : charge
  798.  *  [4][5] : max charge
  799.  *  [6][7] : current
  800.  *  [8][9] : voltage
  801.  */
  802.  
  803. unsigned int bat_flags = 0;
  804. int current;
  805. unsigned int capa, max, voltage;
  807. if (req->reply[1] & 0x01)
  808. pmu_power_flags |= PMU_PWR_AC_PRESENT;
  809. else
  810. pmu_power_flags &= ~PMU_PWR_AC_PRESENT;
  813. if (req->reply[1] & 0x04) {
  814. bat_flags |= PMU_BATT_PRESENT;
  815. switch(req->reply[0]) {
  816. case 3:
  817. case 4: capa = req->reply[2];
  818. max = req->reply[3];
  819. current = *((signed char *)&req->reply[4]);
  820. voltage = req->reply[5];
  821. break;
  822. case 5: capa = (req->reply[2] << 8) | req->reply[3];
  823. max = (req->reply[4] << 8) | req->reply[5];
  824. current = *((signed short *)&req->reply[6]);
  825. voltage = (req->reply[8] << 8) | req->reply[9];
  826. break;
  827. default:
  828. printk(KERN_WARNING "pmu.c : unrecognized battery info, len: %d, %02x %02x %02x %02xn",
  829. req->reply_len, req->reply[0], req->reply[1], req->reply[2], req->reply[3]);
  830. break;
  831. }
  832. } else
  833. capa = max = current = voltage = 0;
  835. if ((req->reply[1] & 0x01) && (current > 0))
  836. bat_flags |= PMU_BATT_CHARGING;
  838. pmu_batteries[pmu_cur_battery].flags = bat_flags;
  839. pmu_batteries[pmu_cur_battery].charge = capa;
  840. pmu_batteries[pmu_cur_battery].max_charge = max;
  841. pmu_batteries[pmu_cur_battery].current = current;
  842. pmu_batteries[pmu_cur_battery].voltage = voltage;
  843. if (current) {
  844. if ((req->reply[1] & 0x01) && (current > 0))
  845. pmu_batteries[pmu_cur_battery].time_remaining
  846. = ((max-capa) * 3600) / current;
  847. else
  848. pmu_batteries[pmu_cur_battery].time_remaining
  849. = (capa * 3600) / (-current);
  850. } else
  851. pmu_batteries[pmu_cur_battery].time_remaining = 0;
  853. pmu_cur_battery = (pmu_cur_battery + 1) % pmu_battery_count;
  854. }
  856. static void __pmac
  857. query_battery_state(void)
  858. {
  859. if (!batt_req.complete)
  860. return;
  861. if (pmu_kind == PMU_OHARE_BASED) {
  862. int mb = pmac_call_feature(PMAC_FTR_GET_MB_INFO,
  863. NULL, PMAC_MB_INFO_MODEL, 0);
  865. if (mb == PMAC_TYPE_COMET)
  866. pmu_request(&batt_req, done_battery_state_comet,
  867. 1, PMU_BATTERY_STATE);
  868. else
  869. pmu_request(&batt_req, done_battery_state_ohare,
  870. 1, PMU_BATTERY_STATE);
  871. } else
  872. pmu_request(&batt_req, done_battery_state_smart,
  873. 2, PMU_SMART_BATTERY_STATE, pmu_cur_battery+1);
  874. }
  876. #endif /* CONFIG_PMAC_PBOOK */
  878. static int
  879. proc_get_info(char *page, char **start, off_t off,
  880. int count, int *eof, void *data)
  881. {
  882. char* p = page;
  884. p += sprintf(p, "PMU driver version     : %dn", PMU_DRIVER_VERSION);
  885. p += sprintf(p, "PMU firmware version   : %02xn", pmu_version);
  886. #ifdef CONFIG_PMAC_PBOOK
  887. p += sprintf(p, "AC Power               : %dn",
  888. ((pmu_power_flags & PMU_PWR_AC_PRESENT) != 0));
  889. p += sprintf(p, "Battery count          : %dn", pmu_battery_count);
  890. #endif /* CONFIG_PMAC_PBOOK */
  892. return p - page;
  893. }
  895. #ifdef CONFIG_PMAC_PBOOK
  896. static int
  897. proc_get_batt(char *page, char **start, off_t off,
  898. int count, int *eof, void *data)
  899. {
  900. int batnum = (int)data;
  901. char *p = page;
  903. p += sprintf(p, "n");
  904. p += sprintf(p, "flags      : %08xn",
  905. pmu_batteries[batnum].flags);
  906. p += sprintf(p, "charge     : %dn",
  907. pmu_batteries[batnum].charge);
  908. p += sprintf(p, "max_charge : %dn",
  909. pmu_batteries[batnum].max_charge);
  910. p += sprintf(p, "current    : %dn",
  911. pmu_batteries[batnum].current);
  912. p += sprintf(p, "voltage    : %dn",
  913. pmu_batteries[batnum].voltage);
  914. p += sprintf(p, "time rem.  : %dn",
  915. pmu_batteries[batnum].time_remaining);
  917. return p - page;
  918. }
  919. #endif /* CONFIG_PMAC_PBOOK */
  921. static int
  922. proc_read_options(char *page, char **start, off_t off,
  923. int count, int *eof, void *data)
  924. {
  925. char *p = page;
  927. #ifdef CONFIG_PMAC_PBOOK
  928. if (pmu_kind == PMU_KEYLARGO_BASED && can_sleep)
  929. p += sprintf(p, "lid_wakeup=%dn", option_lid_wakeup);
  930. #endif /* CONFIG_PMAC_PBOOK */
  932. return p - page;
  933. }
  935. static int
  936. proc_write_options(struct file *file, const char *buffer,
  937. unsigned long count, void *data)
  938. {
  939. char tmp[33];
  940. char *label, *val;
  941. unsigned long fcount = count;
  943. if (!count)
  944. return -EINVAL;
  945. if (count > 32)
  946. count = 32;
  947. if (copy_from_user(tmp, buffer, count))
  948. return -EFAULT;
  949. tmp[count] = 0;
  951. label = tmp;
  952. while(*label == ' ')
  953. label++;
  954. val = label;
  955. while(*val && (*val != '=')) {
  956. if (*val == ' ')
  957. *val = 0;
  958. val++;
  959. }
  960. if ((*val) == 0)
  961. return -EINVAL;
  962. *(val++) = 0;
  963. while(*val == ' ')
  964. val++;
  965. #ifdef CONFIG_PMAC_PBOOK
  966. if (pmu_kind == PMU_KEYLARGO_BASED && can_sleep) {
  967. if (!strcmp(label, "lid_wakeup"))
  968. option_lid_wakeup = ((*val) == '1');
  969. }
  970. #endif /* CONFIG_PMAC_PBOOK */
  971. return fcount;
  972. }
  974. #ifdef CONFIG_ADB
  975. /* Send an ADB command */
  976. static int __openfirmware
  977. pmu_send_request(struct adb_request *req, int sync)
  978. {
  979. int i, ret;
  981. if ((vias == NULL) || (!pmu_fully_inited)) {
  982. req->complete = 1;
  983. return -ENXIO;
  984. }
  986. ret = -EINVAL;
  988. switch (req->data[0]) {
  989. case PMU_PACKET:
  990. for (i = 0; i < req->nbytes - 1; ++i)
  991. req->data[i] = req->data[i+1];
  992. --req->nbytes;
  993. if (pmu_data_len[req->data[0]][1] != 0) {
  994. req->reply[0] = ADB_RET_OK;
  995. req->reply_len = 1;
  996. } else
  997. req->reply_len = 0;
  998. ret = pmu_queue_request(req);
  999. break;
  1000. case CUDA_PACKET:
  1001. switch (req->data[1]) {
  1002. case CUDA_GET_TIME:
  1003. if (req->nbytes != 2)
  1004. break;
  1005. req->data[0] = PMU_READ_RTC;
  1006. req->nbytes = 1;
  1007. req->reply_len = 3;
  1008. req->reply[0] = CUDA_PACKET;
  1009. req->reply[1] = 0;
  1010. req->reply[2] = CUDA_GET_TIME;
  1011. ret = pmu_queue_request(req);
  1012. break;
  1013. case CUDA_SET_TIME:
  1014. if (req->nbytes != 6)
  1015. break;
  1016. req->data[0] = PMU_SET_RTC;
  1017. req->nbytes = 5;
  1018. for (i = 1; i <= 4; ++i)
  1019. req->data[i] = req->data[i+1];
  1020. req->reply_len = 3;
  1021. req->reply[0] = CUDA_PACKET;
  1022. req->reply[1] = 0;
  1023. req->reply[2] = CUDA_SET_TIME;
  1024. ret = pmu_queue_request(req);
  1025. break;
  1026. }
  1027. break;
  1028. case ADB_PACKET:
  1029.      if (!pmu_has_adb)
  1030.      return -ENXIO;
  1031. for (i = req->nbytes - 1; i > 1; --i)
  1032. req->data[i+2] = req->data[i];
  1033. req->data[3] = req->nbytes - 2;
  1034. req->data[2] = pmu_adb_flags;
  1035. /*req->data[1] = req->data[1];*/
  1036. req->data[0] = PMU_ADB_CMD;
  1037. req->nbytes += 2;
  1038. req->reply_expected = 1;
  1039. req->reply_len = 0;
  1040. ret = pmu_queue_request(req);
  1041. break;
  1042. }
  1043. if (ret) {
  1044. req->complete = 1;
  1045. return ret;
  1046. }
  1048. if (sync)
  1049. while (!req->complete)
  1050. pmu_poll();
  1052. return 0;
  1053. }
  1055. /* Enable/disable autopolling */
  1056. static int __openfirmware
  1057. pmu_adb_autopoll(int devs)
  1058. {
  1059. struct adb_request req;
  1061. if ((vias == NULL) || (!pmu_fully_inited) || !pmu_has_adb)
  1062. return -ENXIO;
  1064. if (devs) {
  1065. adb_dev_map = devs;
  1066. pmu_request(&req, NULL, 5, PMU_ADB_CMD, 0, 0x86,
  1067.     adb_dev_map >> 8, adb_dev_map);
  1068. pmu_adb_flags = 2;
  1069. } else {
  1070. pmu_request(&req, NULL, 1, PMU_ADB_POLL_OFF);
  1071. pmu_adb_flags = 0;
  1072. }
  1073. while (!req.complete)
  1074. pmu_poll();
  1075. return 0;
  1076. }
  1078. /* Reset the ADB bus */
  1079. static int __openfirmware
  1080. pmu_adb_reset_bus(void)
  1081. {
  1082. struct adb_request req;
  1083. int save_autopoll = adb_dev_map;
  1085. if ((vias == NULL) || (!pmu_fully_inited) || !pmu_has_adb)
  1086. return -ENXIO;
  1088. /* anyone got a better idea?? */
  1089. pmu_adb_autopoll(0);
  1091. req.nbytes = 5;
  1092. req.done = NULL;
  1093. req.data[0] = PMU_ADB_CMD;
  1094. req.data[1] = 0;
  1095. req.data[2] = ADB_BUSRESET;
  1096. req.data[3] = 0;
  1097. req.data[4] = 0;
  1098. req.reply_len = 0;
  1099. req.reply_expected = 1;
  1100. if (pmu_queue_request(&req) != 0) {
  1101. printk(KERN_ERR "pmu_adb_reset_bus: pmu_queue_request failedn");
  1102. return -EIO;
  1103. }
  1104. while (!req.complete)
  1105. pmu_poll();
  1107. if (save_autopoll != 0)
  1108. pmu_adb_autopoll(save_autopoll);
  1110. return 0;
  1111. }
  1112. #endif /* CONFIG_ADB */
  1114. /* Construct and send a pmu request */
  1115. int __openfirmware
  1116. pmu_request(struct adb_request *req, void (*done)(struct adb_request *),
  1117.     int nbytes, ...)
  1118. {
  1119. va_list list;
  1120. int i;
  1122. if (vias == NULL)
  1123. return -ENXIO;
  1125. if (nbytes < 0 || nbytes > 32) {
  1126. printk(KERN_ERR "pmu_request: bad nbytes (%d)n", nbytes);
  1127. req->complete = 1;
  1128. return -EINVAL;
  1129. }
  1130. req->nbytes = nbytes;
  1131. req->done = done;
  1132. va_start(list, nbytes);
  1133. for (i = 0; i < nbytes; ++i)
  1134. req->data[i] = va_arg(list, int);
  1135. va_end(list);
  1136. req->reply_len = 0;
  1137. req->reply_expected = 0;
  1138. return pmu_queue_request(req);
  1139. }
  1141. int __openfirmware
  1142. pmu_queue_request(struct adb_request *req)
  1143. {
  1144. unsigned long flags;
  1145. int nsend;
  1147. if (via == NULL) {
  1148. req->complete = 1;
  1149. return -ENXIO;
  1150. }
  1151. if (req->nbytes <= 0) {
  1152. req->complete = 1;
  1153. return 0;
  1154. }
  1155. nsend = pmu_data_len[req->data[0]][0];
  1156. if (nsend >= 0 && req->nbytes != nsend + 1) {
  1157. req->complete = 1;
  1158. return -EINVAL;
  1159. }
  1161. req->next = 0;
  1162. req->sent = 0;
  1163. req->complete = 0;
  1165. spin_lock_irqsave(&pmu_lock, flags);
  1166. if (current_req != 0) {
  1167. last_req->next = req;
  1168. last_req = req;
  1169. } else {
  1170. current_req = req;
  1171. last_req = req;
  1172. if (pmu_state == idle)
  1173. pmu_start();
  1174. }
  1175. spin_unlock_irqrestore(&pmu_lock, flags);
  1177. return 0;
  1178. }
  1180. static inline void
  1181. wait_for_ack(void)
  1182. {
  1183. /* Sightly increased the delay, I had one occurence of the message
  1184.  * reported
  1185.  */
  1186. int timeout = 4000;
  1187. while ((in_8(&via[B]) & TACK) == 0) {
  1188. if (--timeout < 0) {
  1189. printk(KERN_ERR "PMU not responding (!ack)n");
  1190. return;
  1191. }
  1192. udelay(10);
  1193. }
  1194. }
  1196. /* New PMU seems to be very sensitive to those timings, so we make sure
  1197.  * PCI is flushed immediately */
  1198. static inline void
  1199. send_byte(int x)
  1200. {
  1201. volatile unsigned char *v = via;
  1203. out_8(&v[ACR], in_8(&v[ACR]) | SR_OUT | SR_EXT);
  1204. out_8(&v[SR], x);
  1205. out_8(&v[B], in_8(&v[B]) & ~TREQ); /* assert TREQ */
  1206. (void)in_8(&v[B]);
  1207. }
  1209. static inline void
  1210. recv_byte(void)
  1211. {
  1212. volatile unsigned char *v = via;
  1214. out_8(&v[ACR], (in_8(&v[ACR]) & ~SR_OUT) | SR_EXT);
  1215. in_8(&v[SR]); /* resets SR */
  1216. out_8(&v[B], in_8(&v[B]) & ~TREQ);
  1217. (void)in_8(&v[B]);
  1218. }
  1220. static inline void
  1221. pmu_done(struct adb_request *req)
  1222. {
  1223. req->complete = 1;
  1224. if (req->done)
  1225. (*req->done)(req);
  1226. }
  1228. static void __openfirmware
  1229. pmu_start()
  1230. {
  1231. struct adb_request *req;
  1233. /* assert pmu_state == idle */
  1234. /* get the packet to send */
  1235. req = current_req;
  1236. if (req == 0 || pmu_state != idle
  1237.     || (/*req->reply_expected && */req_awaiting_reply))
  1238. return;
  1240. pmu_state = sending;
  1241. data_index = 1;
  1242. data_len = pmu_data_len[req->data[0]][0];
  1244. /* Sounds safer to make sure ACK is high before writing. This helped
  1245.  * kill a problem with ADB and some iBooks
  1246.  */
  1247. wait_for_ack();
  1248. /* set the shift register to shift out and send a byte */
  1249. send_byte(req->data[0]);
  1250. }
  1252. void __openfirmware
  1253. pmu_poll()
  1254. {
  1255. if (!via)
  1256. return;
  1257. if (disable_poll)
  1258. return;
  1259. /* Kicks ADB read when PMU is suspended */
  1260. if (pmu_suspended)
  1261. adb_int_pending = 1;
  1262. do {
  1263. via_pmu_interrupt(0, 0, 0);
  1264. } while (pmu_suspended && (adb_int_pending || pmu_state != idle
  1265. || req_awaiting_reply));
  1266. }
  1268. /* This function loops until the PMU is idle and prevents it from
  1269.  * anwsering to ADB interrupts. pmu_request can still be called.
  1270.  * This is done to avoid spurrious shutdowns when we know we'll have
  1271.  * interrupts switched off for a long time
  1272.  */
  1273. void __openfirmware
  1274. pmu_suspend(void)
  1275. {
  1276. unsigned long flags;
  1277. #ifdef SUSPEND_USES_PMU
  1278. struct adb_request *req;
  1279. #endif
  1280. if (!via)
  1281. return;
  1283. spin_lock_irqsave(&pmu_lock, flags);
  1284. pmu_suspended++;
  1285. if (pmu_suspended > 1) {
  1286. spin_unlock_irqrestore(&pmu_lock, flags);
  1287. return;
  1288. }
  1290. do {
  1291. spin_unlock_irqrestore(&pmu_lock, flags);
  1292. via_pmu_interrupt(0, 0, 0);
  1293. spin_lock_irqsave(&pmu_lock, flags);
  1294. if (!adb_int_pending && pmu_state == idle && !req_awaiting_reply) {
  1295. #ifdef SUSPEND_USES_PMU
  1296. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, 0);
  1297. spin_unlock_irqrestore(&pmu_lock, flags);
  1298. while(!req.complete)
  1299. pmu_poll();
  1300. #else /* SUSPEND_USES_PMU */
  1301. if (gpio_irq >= 0)
  1302. disable_irq(gpio_irq);
  1303. out_8(&via[IER], CB1_INT | IER_CLR);
  1304. spin_unlock_irqrestore(&pmu_lock, flags);
  1305. #endif /* SUSPEND_USES_PMU */
  1306. break;
  1307. }
  1308. } while (1);
  1309. }
  1311. void __openfirmware
  1312. pmu_resume(void)
  1313. {
  1314. unsigned long flags;
  1316. if (!via || (pmu_suspended < 1))
  1317. return;
  1319. spin_lock_irqsave(&pmu_lock, flags);
  1320. pmu_suspended--;
  1321. if (pmu_suspended > 0) {
  1322. spin_unlock_irqrestore(&pmu_lock, flags);
  1323. return;
  1324. }
  1325. adb_int_pending = 1;
  1326. #ifdef SUSPEND_USES_PMU
  1327. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
  1328. spin_unlock_irqrestore(&pmu_lock, flags);
  1329. while(!req.complete)
  1330. pmu_poll();
  1331. #else /* SUSPEND_USES_PMU */
  1332. if (gpio_irq >= 0)
  1333. enable_irq(gpio_irq);
  1334. out_8(&via[IER], CB1_INT | IER_SET);
  1335. spin_unlock_irqrestore(&pmu_lock, flags);
  1336. pmu_poll();
  1337. #endif /* SUSPEND_USES_PMU */
  1338. }
  1340. /* Interrupt data could be the result data from an ADB cmd */
  1341. static void __openfirmware
  1342. pmu_handle_data(unsigned char *data, int len, struct pt_regs *regs)
  1343. {
  1344. asleep = 0;
  1345. if (drop_interrupts || len < 1) {
  1346. adb_int_pending = 0;
  1347. return;
  1348. }
  1349. /* Note: for some reason, we get an interrupt with len=1,
  1350.  * data[0]==0 after each normal ADB interrupt, at least
  1351.  * on the Pismo. Still investigating...  --BenH
  1352.  */
  1353. if (data[0] & PMU_INT_ADB) {
  1354. if ((data[0] & PMU_INT_ADB_AUTO) == 0) {
  1355. struct adb_request *req = req_awaiting_reply;
  1356. if (req == 0) {
  1357. printk(KERN_ERR "PMU: extra ADB replyn");
  1358. return;
  1359. }
  1360. req_awaiting_reply = 0;
  1361. if (len <= 2)
  1362. req->reply_len = 0;
  1363. else {
  1364. memcpy(req->reply, data + 1, len - 1);
  1365. req->reply_len = len - 1;
  1366. }
  1367. pmu_done(req);
  1368. } else {
  1369. #ifdef CONFIG_XMON
  1370. if (len == 4 && data[1] == 0x2c) {
  1371. extern int xmon_wants_key, xmon_adb_keycode;
  1372. if (xmon_wants_key) {
  1373. xmon_adb_keycode = data[2];
  1374. return;
  1375. }
  1376. }
  1377. #endif /* CONFIG_XMON */
  1378. #ifdef CONFIG_ADB
  1379. /*
  1380.  * XXX On the [23]400 the PMU gives us an up
  1381.  * event for keycodes 0x74 or 0x75 when the PC
  1382.  * card eject buttons are released, so we
  1383.  * ignore those events.
  1384.  */
  1385. if (!(pmu_kind == PMU_OHARE_BASED && len == 4
  1386.       && data[1] == 0x2c && data[3] == 0xff
  1387.       && (data[2] & ~1) == 0xf4))
  1388. adb_input(data+1, len-1, regs, 1);
  1389. #endif /* CONFIG_ADB */
  1390. }
  1391. } else {
  1392. /* Sound/brightness button pressed */
  1393. if ((data[0] & PMU_INT_SNDBRT) && len == 3) {
  1394. #ifdef CONFIG_PMAC_BACKLIGHT
  1395. #ifdef CONFIG_INPUT_ADBHID
  1396. if (!disable_kernel_backlight)
  1397. #endif /* CONFIG_INPUT_ADBHID */
  1398. set_backlight_level(data[1] >> 4);
  1399. #endif /* CONFIG_PMAC_BACKLIGHT */
  1400. }
  1401. #ifdef CONFIG_PMAC_PBOOK
  1402. /* Environement or tick interrupt, query batteries */
  1403. if (pmu_battery_count && (data[0] & PMU_INT_TICK)) {
  1404. if ((--query_batt_timer) == 0) {
  1405. query_battery_state();
  1406. query_batt_timer = BATTERY_POLLING_COUNT;
  1407. }
  1408. } else if (pmu_battery_count && (data[0] & PMU_INT_ENVIRONMENT))
  1409. query_battery_state();
  1410.   if (data[0])
  1411. pmu_pass_intr(data, len);
  1412. #endif /* CONFIG_PMAC_PBOOK */
  1413. }
  1414. }
  1416. static struct adb_request* __openfirmware
  1417. pmu_sr_intr(struct pt_regs *regs)
  1418. {
  1419. struct adb_request *req;
  1420. int bite;
  1422. if (via[B] & TREQ) {
  1423. printk(KERN_ERR "PMU: spurious SR intr (%x)n", via[B]);
  1424. out_8(&via[IFR], SR_INT);
  1425. return NULL;
  1426. }
  1427. /* The ack may not yet be low when we get the interrupt */
  1428. while ((in_8(&via[B]) & TACK) != 0)
  1429. ;
  1431. /* if reading grab the byte, and reset the interrupt */
  1432. if (pmu_state == reading || pmu_state == reading_intr)
  1433. bite = in_8(&via[SR]);
  1435. /* reset TREQ and wait for TACK to go high */
  1436. out_8(&via[B], in_8(&via[B]) | TREQ);
  1437. wait_for_ack();
  1439. switch (pmu_state) {
  1440. case sending:
  1441. req = current_req;
  1442. if (data_len < 0) {
  1443. data_len = req->nbytes - 1;
  1444. send_byte(data_len);
  1445. break;
  1446. }
  1447. if (data_index <= data_len) {
  1448. send_byte(req->data[data_index++]);
  1449. break;
  1450. }
  1451. req->sent = 1;
  1452. data_len = pmu_data_len[req->data[0]][1];
  1453. if (data_len == 0) {
  1454. pmu_state = idle;
  1455. current_req = req->next;
  1456. if (req->reply_expected)
  1457. req_awaiting_reply = req;
  1458. else
  1459. return req;
  1460. } else {
  1461. pmu_state = reading;
  1462. data_index = 0;
  1463. reply_ptr = req->reply + req->reply_len;
  1464. recv_byte();
  1465. }
  1466. break;
  1468. case intack:
  1469. data_index = 0;
  1470. data_len = -1;
  1471. pmu_state = reading_intr;
  1472. reply_ptr = interrupt_data[int_data_last];
  1473. recv_byte();
  1474. break;
  1476. case reading:
  1477. case reading_intr:
  1478. if (data_len == -1) {
  1479. data_len = bite;
  1480. if (bite > 32)
  1481. printk(KERN_ERR "PMU: bad reply len %dn", bite);
  1482. } else if (data_index < 32) {
  1483. reply_ptr[data_index++] = bite;
  1484. }
  1485. if (data_index < data_len) {
  1486. recv_byte();
  1487. break;
  1488. }
  1490. if (pmu_state == reading_intr) {
  1491. pmu_state = idle;
  1492. int_data_state[int_data_last] = int_data_ready;
  1493. interrupt_data_len[int_data_last] = data_len;
  1494. } else {
  1495. req = current_req;
  1496. current_req = req->next;
  1497. req->reply_len += data_index;
  1498. pmu_state = idle;
  1499. return req;
  1500. }
  1501. break;
  1503. default:
  1504. printk(KERN_ERR "via_pmu_interrupt: unknown state %d?n",
  1505.        pmu_state);
  1506. }
  1507. return NULL;
  1508. }
  1510. static void __openfirmware
  1511. via_pmu_interrupt(int irq, void *arg, struct pt_regs *regs)
  1512. {
  1513. unsigned long flags;
  1514. int intr;
  1515. int nloop = 0;
  1516. int int_data = -1;
  1517. struct adb_request *req = NULL;
  1519. /* This is a bit brutal, we can probably do better */
  1520. spin_lock_irqsave(&pmu_lock, flags);
  1521. ++disable_poll;
  1523. for (;;) {
  1524. intr = in_8(&via[IFR]) & (SR_INT | CB1_INT);
  1525. if (intr == 0)
  1526. break;
  1527. if (++nloop > 1000) {
  1528. printk(KERN_DEBUG "PMU: stuck in intr loop, "
  1529.        "intr=%x, ier=%x pmu_state=%dn",
  1530.        intr, in_8(&via[IER]), pmu_state);
  1531. break;
  1532. }
  1533. out_8(&via[IFR], intr);
  1534. if (intr & CB1_INT)
  1535. adb_int_pending = 1;
  1536. if (intr & SR_INT) {
  1537. req = pmu_sr_intr(regs);
  1538. if (req)
  1539. break;
  1540. }
  1541. }
  1543. recheck:
  1544. if (pmu_state == idle) {
  1545. if (adb_int_pending) {
  1546. if (int_data_state[0] == int_data_empty)
  1547. int_data_last = 0;
  1548. else if (int_data_state[1] == int_data_empty)
  1549. int_data_last = 1;
  1550. else
  1551. goto no_free_slot;
  1552. pmu_state = intack;
  1553. int_data_state[int_data_last] = int_data_fill;
  1554. /* Sounds safer to make sure ACK is high before writing.
  1555.  * This helped kill a problem with ADB and some iBooks
  1556.  */
  1557. wait_for_ack();
  1558. send_byte(PMU_INT_ACK);
  1559. adb_int_pending = 0;
  1560. no_free_slot:
  1561. } else if (current_req)
  1562. pmu_start();
  1563. }
  1564. /* Mark the oldest buffer for flushing */
  1565. if (int_data_state[!int_data_last] == int_data_ready) {
  1566. int_data_state[!int_data_last] = int_data_flush;
  1567. int_data = !int_data_last;
  1568. } else if (int_data_state[int_data_last] == int_data_ready) {
  1569. int_data_state[int_data_last] = int_data_flush;
  1570. int_data = int_data_last;
  1571. }
  1572. --disable_poll;
  1573. spin_unlock_irqrestore(&pmu_lock, flags);
  1575. /* Deal with completed PMU requests outside of the lock */
  1576. if (req) {
  1577. pmu_done(req);
  1578. req = NULL;
  1579. }
  1581. /* Deal with interrupt datas outside of the lock */
  1582. if (int_data >= 0) {
  1583. pmu_handle_data(interrupt_data[int_data], interrupt_data_len[int_data], regs);
  1584. spin_lock_irqsave(&pmu_lock, flags);
  1585. ++disable_poll;
  1586. int_data_state[int_data] = int_data_empty;
  1587. int_data = -1;
  1588. goto recheck;
  1589. }
  1590. }
  1592. static void __openfirmware
  1593. gpio1_interrupt(int irq, void *arg, struct pt_regs *regs)
  1594. {
  1595. if ((in_8(gpio_reg + 0x9) & 0x02) == 0) {
  1596. adb_int_pending = 1;
  1597. via_pmu_interrupt(0, 0, 0);
  1598. }
  1599. }
  1601. #ifdef CONFIG_PMAC_BACKLIGHT
  1602. static int backlight_to_bright[] = {
  1603. 0x7f, 0x46, 0x42, 0x3e, 0x3a, 0x36, 0x32, 0x2e,
  1604. 0x2a, 0x26, 0x22, 0x1e, 0x1a, 0x16, 0x12, 0x0e
  1605. };
  1606.  
  1607. static int __openfirmware
  1608. pmu_set_backlight_enable(int on, int level, void* data)
  1609. {
  1610. struct adb_request req;
  1612. if (vias == NULL)
  1613. return -ENODEV;
  1615. if (on) {
  1616. pmu_request(&req, NULL, 2, PMU_BACKLIGHT_BRIGHT,
  1617.     backlight_to_bright[level]);
  1618. while (!req.complete)
  1619. pmu_poll();
  1620. }
  1621. pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
  1622.     PMU_POW_BACKLIGHT | (on ? PMU_POW_ON : PMU_POW_OFF));
  1623. while (!req.complete)
  1624. pmu_poll();
  1626. return 0;
  1627. }
  1629. static int __openfirmware
  1630. pmu_set_backlight_level(int level, void* data)
  1631. {
  1632. if (vias == NULL)
  1633. return -ENODEV;
  1635. if (!bright_req_1.complete)
  1636. return -EAGAIN;
  1637. pmu_request(&bright_req_1, NULL, 2, PMU_BACKLIGHT_BRIGHT,
  1638. backlight_to_bright[level]);
  1639. if (!bright_req_2.complete)
  1640. return -EAGAIN;
  1641. pmu_request(&bright_req_2, NULL, 2, PMU_POWER_CTRL, PMU_POW_BACKLIGHT
  1642. | (level > BACKLIGHT_OFF ? PMU_POW_ON : PMU_POW_OFF));
  1644. return 0;
  1645. }
  1646. #endif /* CONFIG_PMAC_BACKLIGHT */
  1648. void __openfirmware
  1649. pmu_enable_irled(int on)
  1650. {
  1651. struct adb_request req;
  1653. if (vias == NULL)
  1654. return ;
  1655. if (pmu_kind == PMU_KEYLARGO_BASED)
  1656. return ;
  1658. pmu_request(&req, NULL, 2, PMU_POWER_CTRL, PMU_POW_IRLED |
  1659.     (on ? PMU_POW_ON : PMU_POW_OFF));
  1660. while (!req.complete)
  1661. pmu_poll();
  1662. }
  1664. void __openfirmware
  1665. pmu_restart(void)
  1666. {
  1667. struct adb_request req;
  1669. local_irq_disable();
  1671. drop_interrupts = 1;
  1673. if (pmu_kind != PMU_KEYLARGO_BASED) {
  1674. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB |
  1675. PMU_INT_TICK );
  1676. while(!req.complete)
  1677. pmu_poll();
  1678. }
  1680. pmu_request(&req, NULL, 1, PMU_RESET);
  1681. while(!req.complete || (pmu_state != idle))
  1682. pmu_poll();
  1683. for (;;)
  1684. ;
  1685. }
  1687. void __openfirmware
  1688. pmu_shutdown(void)
  1689. {
  1690. struct adb_request req;
  1692. local_irq_disable();
  1694. drop_interrupts = 1;
  1696. if (pmu_kind != PMU_KEYLARGO_BASED) {
  1697. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB |
  1698. PMU_INT_TICK );
  1699. while(!req.complete)
  1700. pmu_poll();
  1701. }
  1703. pmu_request(&req, NULL, 5, PMU_SHUTDOWN,
  1704.     'M', 'A', 'T', 'T');
  1705. while(!req.complete || (pmu_state != idle))
  1706. pmu_poll();
  1707. for (;;)
  1708. ;
  1709. }
  1711. int
  1712. pmu_present(void)
  1713. {
  1714. return via != 0;
  1715. }
  1717. #if defined(DEBUG_SLEEP) || defined(DEBUG_FREQ)
  1718. /* N.B. This doesn't work on the 3400 */
  1719. void
  1720. pmu_blink(int n)
  1721. {
  1722. struct adb_request req;
  1724. memset(&req, 0, sizeof(req));
  1726. for (; n > 0; --n) {
  1727. req.nbytes = 4;
  1728. req.done = NULL;
  1729. req.data[0] = 0xee;
  1730. req.data[1] = 4;
  1731. req.data[2] = 0;
  1732. req.data[3] = 1;
  1733. req.reply[0] = ADB_RET_OK;
  1734. req.reply_len = 1;
  1735. req.reply_expected = 0;
  1736. pmu_polled_request(&req);
  1737. mdelay(50);
  1738. req.nbytes = 4;
  1739. req.done = NULL;
  1740. req.data[0] = 0xee;
  1741. req.data[1] = 4;
  1742. req.data[2] = 0;
  1743. req.data[3] = 0;
  1744. req.reply[0] = ADB_RET_OK;
  1745. req.reply_len = 1;
  1746. req.reply_expected = 0;
  1747. pmu_polled_request(&req);
  1748. mdelay(50);
  1749. }
  1750. mdelay(50);
  1751. }
  1752. #endif /* defined(DEBUG_SLEEP) || defined(DEBUG_FREQ) */
  1754. #ifdef CONFIG_PMAC_PBOOK
  1756. static LIST_HEAD(sleep_notifiers);
  1758. #ifdef CONFIG_PM
  1759. static int
  1760. generic_notify_sleep(struct pmu_sleep_notifier *self, int when)
  1761. {
  1762. switch (when) {
  1763. case PBOOK_SLEEP_NOW:
  1764. if (pm_send_all(PM_SUSPEND, (void *)3))
  1765. return PBOOK_SLEEP_REJECT;
  1766. break;
  1767. case PBOOK_WAKE:
  1768. (void) pm_send_all(PM_RESUME, (void *)0);
  1769. }
  1770. return PBOOK_SLEEP_OK;
  1771. }
  1772. #endif /* CONFIG_PM */
  1774. int
  1775. pmu_register_sleep_notifier(struct pmu_sleep_notifier *n)
  1776. {
  1777. struct list_head *list;
  1778. struct pmu_sleep_notifier *notifier;
  1780. for (list = sleep_notifiers.next; list != &sleep_notifiers;
  1781.      list = list->next) {
  1782. notifier = list_entry(list, struct pmu_sleep_notifier, list);
  1783. if (n->priority > notifier->priority)
  1784. break;
  1785. }
  1786. __list_add(&n->list, list->prev, list);
  1787. return 0;
  1788. }
  1790. int
  1791. pmu_unregister_sleep_notifier(struct pmu_sleep_notifier* n)
  1792. {
  1793. if (n->list.next == 0)
  1794. return -ENOENT;
  1795. list_del(&n->list);
  1796. n->list.next = 0;
  1797. return 0;
  1798. }
  1800. /* Sleep is broadcast last-to-first */
  1801. static int
  1802. broadcast_sleep(int when, int fallback)
  1803. {
  1804. int ret = PBOOK_SLEEP_OK;
  1805. struct list_head *list;
  1806. struct pmu_sleep_notifier *notifier;
  1808. for (list = sleep_notifiers.prev; list != &sleep_notifiers;
  1809.      list = list->prev) {
  1810. notifier = list_entry(list, struct pmu_sleep_notifier, list);
  1811. ret = notifier->notifier_call(notifier, when);
  1812. if (ret != PBOOK_SLEEP_OK) {
  1813. printk(KERN_DEBUG "sleep %d rejected by %p (%p)n",
  1814.        when, notifier, notifier->notifier_call);
  1815. for (; list != &sleep_notifiers; list = list->next) {
  1816. notifier = list_entry(list, struct pmu_sleep_notifier, list);
  1817. notifier->notifier_call(notifier, fallback);
  1818. }
  1819. return ret;
  1820. }
  1821. }
  1822. return ret;
  1823. }
  1825. /* Wake is broadcast first-to-last */
  1826. static int
  1827. broadcast_wake(void)
  1828. {
  1829. int ret = PBOOK_SLEEP_OK;
  1830. struct list_head *list;
  1831. struct pmu_sleep_notifier *notifier;
  1833. for (list = sleep_notifiers.next; list != &sleep_notifiers;
  1834.      list = list->next) {
  1835. notifier = list_entry(list, struct pmu_sleep_notifier, list);
  1836. #ifdef VERBOSE_WAKEUP
  1837. if (notifier->priority < SLEEP_LEVEL_VIDEO)
  1838. xmon_printf("wake, before notifier %xn", notifier);
  1839. #endif
  1840. notifier->notifier_call(notifier, PBOOK_WAKE);
  1841. #ifdef VERBOSE_WAKEUP
  1842. if (notifier->priority <= SLEEP_LEVEL_VIDEO)
  1843. xmon_printf("wake, after notifier %xn", notifier);
  1844. #endif
  1845. }
  1846. return ret;
  1847. }
  1849. /*
  1850.  * This struct is used to store config register values for
  1851.  * PCI devices which may get powered off when we sleep.
  1852.  */
  1853. static struct pci_save {
  1854. #ifndef HACKED_PCI_SAVE
  1855. u16 command;
  1856. u16 cache_lat;
  1857. u16 intr;
  1858. u32 rom_address;
  1859. #else
  1860. u32 config[16];
  1861. #endif
  1862. } *pbook_pci_saves;
  1863. static int pbook_npci_saves;
  1865. static void __openfirmware
  1866. pbook_alloc_pci_save(void)
  1867. {
  1868. int npci;
  1869. struct pci_dev *pd;
  1871. npci = 0;
  1872. pci_for_each_dev(pd) {
  1873. ++npci;
  1874. }
  1875. if (npci == 0)
  1876. return;
  1877. pbook_pci_saves = (struct pci_save *)
  1878. kmalloc(npci * sizeof(struct pci_save), GFP_KERNEL);
  1879. pbook_npci_saves = npci;
  1880. }
  1882. static void __openfirmware
  1883. pbook_free_pci_save(void)
  1884. {
  1885. if (pbook_pci_saves == NULL)
  1886. return;
  1887. kfree(pbook_pci_saves);
  1888. pbook_pci_saves = NULL;
  1889. pbook_npci_saves = 0;
  1890. }
  1892. static void __openfirmware
  1893. pbook_pci_save(void)
  1894. {
  1895. struct pci_save *ps = pbook_pci_saves;
  1896. struct pci_dev *pd;
  1897. int npci = pbook_npci_saves;
  1899. if (ps == NULL)
  1900. return;
  1902. pci_for_each_dev(pd) {
  1903. if (npci-- == 0)
  1904. return;
  1905. #ifndef HACKED_PCI_SAVE
  1906. pci_read_config_word(pd, PCI_COMMAND, &ps->command);
  1907. pci_read_config_word(pd, PCI_CACHE_LINE_SIZE, &ps->cache_lat);
  1908. pci_read_config_word(pd, PCI_INTERRUPT_LINE, &ps->intr);
  1909. pci_read_config_dword(pd, PCI_ROM_ADDRESS, &ps->rom_address);
  1910. #else
  1911. int i;
  1912. for (i=1;i<16;i++)
  1913. pci_read_config_dword(pd, i<<4, &ps->config[i]);
  1914. #endif
  1915. ++ps;
  1916. }
  1917. }
  1919. /* For this to work, we must take care of a few things: If gmac was enabled
  1920.  * during boot, it will be in the pci dev list. If it's disabled at this point
  1921.  * (and it will probably be), then you can't access it's config space.
  1922.  */
  1923. static void __openfirmware
  1924. pbook_pci_restore(void)
  1925. {
  1926. u16 cmd;
  1927. struct pci_save *ps = pbook_pci_saves - 1;
  1928. struct pci_dev *pd;
  1929. int npci = pbook_npci_saves;
  1930. int j;
  1932. pci_for_each_dev(pd) {
  1933. #ifdef HACKED_PCI_SAVE
  1934. int i;
  1935. if (npci-- == 0)
  1936. return;
  1937. ps++;
  1938. for (i=2;i<16;i++)
  1939. pci_write_config_dword(pd, i<<4, ps->config[i]);
  1940. pci_write_config_dword(pd, 4, ps->config[1]);
  1941. #else
  1942. if (npci-- == 0)
  1943. return;
  1944. ps++;
  1945. if (ps->command == 0)
  1946. continue;
  1947. pci_read_config_word(pd, PCI_COMMAND, &cmd);
  1948. if ((ps->command & ~cmd) == 0)
  1949. continue;
  1950. switch (pd->hdr_type) {
  1951. case PCI_HEADER_TYPE_NORMAL:
  1952. for (j = 0; j < 6; ++j)
  1953. pci_write_config_dword(pd,
  1954. PCI_BASE_ADDRESS_0 + j*4,
  1955. pd->resource[j].start);
  1956. pci_write_config_dword(pd, PCI_ROM_ADDRESS,
  1957. ps->rom_address);
  1958. pci_write_config_word(pd, PCI_CACHE_LINE_SIZE,
  1959. ps->cache_lat);
  1960. pci_write_config_word(pd, PCI_INTERRUPT_LINE,
  1961. ps->intr);
  1962. pci_write_config_word(pd, PCI_COMMAND, ps->command);
  1963. break;
  1964. }
  1965. #endif
  1966. }
  1967. }
  1969. /*
  1970.  * Put the powerbook to sleep.
  1971.  */
  1972.  
  1973. static u32 save_via[8];
  1974. static void save_via_state(void)
  1975. {
  1976. save_via[0] = in_8(&via[ANH]);
  1977. save_via[1] = in_8(&via[DIRA]);
  1978. save_via[2] = in_8(&via[B]);
  1979. save_via[3] = in_8(&via[DIRB]);
  1980. save_via[4] = in_8(&via[PCR]);
  1981. save_via[5] = in_8(&via[ACR]);
  1982. save_via[6] = in_8(&via[T1CL]);
  1983. save_via[7] = in_8(&via[T1CH]);
  1984. }
  1985. static void restore_via_state(void)
  1986. {
  1987. out_8(&via[ANH], save_via[0]);
  1988. out_8(&via[DIRA], save_via[1]);
  1989. out_8(&via[B], save_via[2]);
  1990. out_8(&via[DIRB], save_via[3]);
  1991. out_8(&via[PCR], save_via[4]);
  1992. out_8(&via[ACR], save_via[5]);
  1993. out_8(&via[T1CL], save_via[6]);
  1994. out_8(&via[T1CH], save_via[7]);
  1995. out_8(&via[IER], IER_CLR | 0x7f); /* disable all intrs */
  1996. out_8(&via[IFR], 0x7f); /* clear IFR */
  1997. out_8(&via[IER], IER_SET | SR_INT | CB1_INT);
  1998. }
  2000. #define GRACKLE_PM (1<<7)
  2001. #define GRACKLE_DOZE (1<<5)
  2002. #define GRACKLE_NAP (1<<4)
  2003. #define GRACKLE_SLEEP (1<<3)
  2005. int __openfirmware powerbook_sleep_G3(void)
  2006. {
  2007. unsigned long save_l2cr;
  2008. unsigned long wait;
  2009. unsigned short pmcr1;
  2010. struct adb_request req;
  2011. int ret;
  2012. struct pci_dev *grackle;
  2014. grackle = pci_find_slot(0, 0);
  2015. if (!grackle)
  2016. return -ENODEV;
  2018. /* Notify device drivers */
  2019. ret = broadcast_sleep(PBOOK_SLEEP_REQUEST, PBOOK_SLEEP_REJECT);
  2020. if (ret != PBOOK_SLEEP_OK) {
  2021. printk("pmu: sleep rejectedn");
  2022. return -EBUSY;
  2023. }
  2025. /* Sync the disks. */
  2026. /* XXX It would be nice to have some way to ensure that
  2027.  * nobody is dirtying any new buffers while we wait.
  2028.  * BenH: Moved to _after_ sleep request and changed video
  2029.  * drivers to vmalloc() during sleep request. This way, all
  2030.  * vmalloc's are done before actual sleep of block drivers */
  2031. fsync_dev(0);
  2033. /* Give the disks a little time to actually finish writing */
  2034. for (wait = jiffies + (HZ/2); time_before(jiffies, wait); )
  2035. mb();
  2037. /* Sleep can fail now. May not be very robust but useful for debugging */
  2038. ret = broadcast_sleep(PBOOK_SLEEP_NOW, PBOOK_WAKE);
  2039. if (ret != PBOOK_SLEEP_OK) {
  2040. printk("pmu: sleep failedn");
  2041. return -EBUSY;
  2042. }
  2044. /* Wait for completion of async backlight requests */
  2045. while (!bright_req_1.complete || !bright_req_2.complete ||
  2046. !bright_req_3.complete || !batt_req.complete)
  2047. pmu_poll();
  2049. /* Turn off various things. Darwin does some retry tests here... */
  2050. pmu_request(&req, NULL, 2, PMU_POWER_CTRL0, PMU_POW0_OFF|PMU_POW0_HARD_DRIVE);
  2051. while (!req.complete)
  2052. pmu_poll();
  2053. pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
  2054. PMU_POW_OFF|PMU_POW_BACKLIGHT|PMU_POW_IRLED|PMU_POW_MEDIABAY);
  2055. while (!req.complete)
  2056. pmu_poll();
  2058. /* Disable all interrupts */
  2059. pmac_sleep_save_intrs(-1);
  2061. /* Make sure the PMU is idle */
  2062. while (pmu_state != idle)
  2063. pmu_poll();
  2065. /* Make sure the decrementer won't interrupt us */
  2066. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  2067. /* Make sure any pending DEC interrupt occuring while we did
  2068.  * the above didn't re-enable the DEC */
  2069. mb();
  2070. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  2072. /* We can now disable MSR_EE */
  2073. local_irq_disable();
  2075. /* Giveup the FPU */
  2076. enable_kernel_fp();
  2078. /* For 750, save backside cache setting and disable it */
  2079. save_l2cr = _get_L2CR(); /* (returns -1 if not available) */
  2080. if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
  2081. _set_L2CR(save_l2cr & 0x7fffffff);
  2083. /* Ask the PMU to put us to sleep */
  2084. pmu_request(&req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
  2085. while (!req.complete)
  2086. pmu_poll();
  2088. /* The VIA is supposed not to be restored correctly*/
  2089. save_via_state();
  2090. /* We shut down some HW */
  2091. pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,1);
  2093. pci_read_config_word(grackle, 0x70, &pmcr1);
  2094. /* Apparently, MacOS uses NAP mode for Grackle ??? */
  2095. pmcr1 &= ~(GRACKLE_DOZE|GRACKLE_SLEEP); 
  2096. pmcr1 |= GRACKLE_PM|GRACKLE_NAP;
  2097. pci_write_config_word(grackle, 0x70, pmcr1);
  2099. /* Call low-level ASM sleep handler */
  2100. low_sleep_handler();
  2102. /* We're awake again, stop grackle PM */
  2103. pci_read_config_word(grackle, 0x70, &pmcr1);
  2104. pmcr1 &= ~(GRACKLE_PM|GRACKLE_DOZE|GRACKLE_SLEEP|GRACKLE_NAP); 
  2105. pci_write_config_word(grackle, 0x70, pmcr1);
  2107. /* Make sure the PMU is idle */
  2108. pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,0);
  2109. restore_via_state();
  2111. /* Restore L2 cache */
  2112. if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
  2113.   _set_L2CR(save_l2cr);
  2115. /* Restore userland MMU context */
  2116. set_context(current->active_mm->context, current->active_mm->pgd);
  2118. /* Power things up */
  2119. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, 0xfc);
  2120. while (!req.complete)
  2121. pmu_poll();
  2122. pmu_request(&req, NULL, 2, PMU_POWER_CTRL0,
  2123. PMU_POW0_ON|PMU_POW0_HARD_DRIVE);
  2124. while (!req.complete)
  2125. pmu_poll();
  2126. pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
  2127. PMU_POW_ON|PMU_POW_BACKLIGHT|PMU_POW_CHARGER|PMU_POW_IRLED|PMU_POW_MEDIABAY);
  2128. while (!req.complete)
  2129. pmu_poll();
  2131. /* reenable interrupt controller */
  2132. pmac_sleep_restore_intrs();
  2134. /* Leave some time for HW to settle down */
  2135. mdelay(100);
  2137. /* Restart jiffies & scheduling */
  2138. wakeup_decrementer();
  2140. /* Force a poll of ADB interrupts */
  2141. adb_int_pending = 1;
  2142. via_pmu_interrupt(0, 0, 0);
  2144. /* Re-enable local CPU interrupts */
  2145. local_irq_enable();
  2147. /* Notify drivers */
  2148. broadcast_wake();
  2150. return 0;
  2151. }
  2153. int __openfirmware powerbook_sleep_Core99(void)
  2154. {
  2155. unsigned long save_l2cr;
  2156. unsigned long save_l3cr;
  2157. unsigned long wait;
  2158. struct adb_request req;
  2159. int ret;
  2161. if (!can_sleep) {
  2162. printk(KERN_ERR "Sleep mode not supported on this machinen");
  2163. return -ENOSYS;
  2164. }
  2166. /* Notify device drivers */
  2167. ret = broadcast_sleep(PBOOK_SLEEP_REQUEST, PBOOK_SLEEP_REJECT);
  2168. if (ret != PBOOK_SLEEP_OK) {
  2169. printk("pmu: sleep rejectedn");
  2170. return -EBUSY;
  2171. }
  2173. /* Sync the disks. */
  2174. /* XXX It would be nice to have some way to ensure that
  2175.  * nobody is dirtying any new buffers while we wait.
  2176.  * BenH: Moved to _after_ sleep request and changed video
  2177.  * drivers to vmalloc() during sleep request. This way, all
  2178.  * vmalloc's are done before actual sleep of block drivers */
  2179. fsync_dev(0);
  2181. /* Give the disks a little time to actually finish writing */
  2182. for (wait = jiffies + HZ; time_before(jiffies, wait); )
  2183. mb();
  2185. /* Sleep can fail now. May not be very robust but useful for debugging */
  2186. ret = broadcast_sleep(PBOOK_SLEEP_NOW, PBOOK_WAKE);
  2187. if (ret != PBOOK_SLEEP_OK) {
  2188. printk("pmu: sleep failedn");
  2189. return -EBUSY;
  2190. }
  2191. /* Wait for completion of async backlight requests */
  2192. while (!bright_req_1.complete || !bright_req_2.complete ||
  2193. !bright_req_3.complete || !batt_req.complete)
  2194. pmu_poll();
  2196. /* Tell PMU what events will wake us up */
  2197. pmu_request(&req, NULL, 4, PMU_POWER_EVENTS, PMU_PWR_CLR_WAKEUP_EVENTS,
  2198. 0xff, 0xff);
  2199. while (!req.complete)
  2200. pmu_poll();
  2202. pmu_request(&req, NULL, 4, PMU_POWER_EVENTS, PMU_PWR_SET_WAKEUP_EVENTS,
  2203. 0, PMU_PWR_WAKEUP_KEY |
  2204. (option_lid_wakeup ? PMU_PWR_WAKEUP_LID_OPEN : 0));
  2205. while (!req.complete)
  2206. pmu_poll();
  2208. /* Save & disable all interrupts */
  2209. openpic_sleep_save_intrs();
  2211. /* Make sure the PMU is idle */
  2212. while (pmu_state != idle)
  2213. pmu_poll();
  2215. /* Make sure the decrementer won't interrupt us */
  2216. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  2217. /* Make sure any pending DEC interrupt occuring while we did
  2218.  * the above didn't re-enable the DEC */
  2219. mb();
  2220. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  2222. /* We can now disable MSR_EE */
  2223. local_irq_disable();
  2225. /* Giveup the FPU & vec */
  2226. enable_kernel_fp();
  2228. #ifdef CONFIG_ALTIVEC
  2229. if (cur_cpu_spec[0]->cpu_features & CPU_FTR_ALTIVEC)
  2230. enable_kernel_altivec();
  2231. #endif /* CONFIG_ALTIVEC */
  2233. /* Save & disable L2 and L3 caches*/
  2234. save_l3cr = _get_L3CR(); /* (returns -1 if not available) */
  2235. save_l2cr = _get_L2CR(); /* (returns -1 if not available) */
  2236. if (save_l3cr != 0xffffffff && (save_l3cr & L3CR_L3E) != 0)
  2237. _set_L3CR(save_l3cr & 0x7fffffff);
  2238. if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
  2239. _set_L2CR(save_l2cr & 0x7fffffff);
  2241. /* Save the state of PCI config space for some slots */
  2242. //pbook_pci_save();
  2244. if (!__fake_sleep) {
  2245. /* Ask the PMU to put us to sleep */
  2246. pmu_request(&req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
  2247. while (!req.complete && pmu_state != idle)
  2248. pmu_poll();
  2249. }
  2251. out_8(&via[B], in_8(&via[B]) | TREQ);
  2252. wait_for_ack();
  2254. /* The VIA is supposed not to be restored correctly*/
  2255. save_via_state();
  2257. /* Shut down various ASICs. There's a chance that we can no longer
  2258.  * talk to the PMU after this, so I moved it to _after_ sending the
  2259.  * sleep command to it. Still need to be checked.
  2260.  */
  2261. pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,1);
  2263. /* Call low-level ASM sleep handler */
  2264. if (__fake_sleep)
  2265. mdelay(5000);
  2266. else
  2267. low_sleep_handler();
  2269. /* Restore Apple core ASICs state */
  2270. pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,0);
  2272. /* Restore VIA */
  2273. restore_via_state();
  2275. /* Restore PCI config space. This should be overridable by PCI device
  2276.  * drivers as some of them may need special restore code. That's yet
  2277.  * another issue that should be handled by the common code properly,
  2278.  * maybe one day ?
  2279.  */
  2280. /* Don't restore PCI for now, it crashes. Maybe unnecessary on pbook */
  2281. //pbook_pci_restore();
  2283. #ifdef DEBUG_SLEEP
  2284. pmu_blink(2);
  2285. #endif
  2286. /* Restore L2 cache */
  2287. if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
  2288.   _set_L2CR(save_l2cr);
  2289. /* Restore L3 cache */
  2290. if (save_l3cr != 0xffffffff && (save_l3cr & L3CR_L3E) != 0)
  2291.   _set_L3CR(save_l3cr);
  2293. /* Restore userland MMU context */
  2294. set_context(current->active_mm->context, current->active_mm->pgd);
  2296. /* Tell PMU we are ready */
  2297. pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
  2298. while (!req.complete)
  2299. pmu_poll();
  2300. pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, 0xfc);
  2301. while (!req.complete)
  2302. pmu_poll();
  2304. /* reenable interrupt controller */
  2305. openpic_sleep_restore_intrs();
  2307. /* Leave some time for HW to settle down */
  2308. mdelay(100);
  2310. /* Restart jiffies & scheduling */
  2311. wakeup_decrementer();
  2313. /* Force a poll of ADB interrupts */
  2314. adb_int_pending = 1;
  2315. via_pmu_interrupt(0, 0, 0);
  2317. /* Re-enable local CPU interrupts */
  2318. local_irq_enable();
  2320. /* Notify drivers */
  2321. broadcast_wake();
  2323. return 0;
  2324. }
  2326. #define PB3400_MEM_CTRL 0xf8000000
  2327. #define PB3400_MEM_CTRL_SLEEP 0x70
  2329. int __openfirmware powerbook_sleep_3400(void)
  2330. {
  2331. int ret, i, x;
  2332. unsigned int hid0;
  2333. unsigned long p, wait;
  2334. struct adb_request sleep_req;
  2335. char *mem_ctrl;
  2336. unsigned int *mem_ctrl_sleep;
  2338. /* first map in the memory controller registers */
  2339. mem_ctrl = ioremap(PB3400_MEM_CTRL, 0x100);
  2340. if (mem_ctrl == NULL) {
  2341. printk("powerbook_sleep_3400: ioremap failedn");
  2342. return -ENOMEM;
  2343. }
  2344. mem_ctrl_sleep = (unsigned int *) (mem_ctrl + PB3400_MEM_CTRL_SLEEP);
  2346. /* Allocate room for PCI save */
  2347. pbook_alloc_pci_save();
  2349. /* Notify device drivers */
  2350. ret = broadcast_sleep(PBOOK_SLEEP_REQUEST, PBOOK_SLEEP_REJECT);
  2351. if (ret != PBOOK_SLEEP_OK) {
  2352. pbook_free_pci_save();
  2353. printk("pmu: sleep rejectedn");
  2354. return -EBUSY;
  2355. }
  2357. /* Sync the disks. */
  2358. /* XXX It would be nice to have some way to ensure that
  2359.  * nobody is dirtying any new buffers while we wait.
  2360.  * BenH: Moved to _after_ sleep request and changed video
  2361.  * drivers to vmalloc() during sleep request. This way, all
  2362.  * vmalloc's are done before actual sleep of block drivers */
  2363. fsync_dev(0);
  2365. /* Give the disks a little time to actually finish writing */
  2366. for (wait = jiffies + (HZ/4); time_before(jiffies, wait); )
  2367. mb();
  2369. /* Sleep can fail now. May not be very robust but useful for debugging */
  2370. ret = broadcast_sleep(PBOOK_SLEEP_NOW, PBOOK_WAKE);
  2371. if (ret != PBOOK_SLEEP_OK) {
  2372. printk("pmu: sleep failedn");
  2373. pbook_free_pci_save();
  2374. return -EBUSY;
  2375. }
  2377. /* Wait for completion of async backlight requests */
  2378. while (!bright_req_1.complete || !bright_req_2.complete ||
  2379. !bright_req_3.complete || !batt_req.complete)
  2380. pmu_poll();
  2382. /* Disable all interrupts except pmu */
  2383. pmac_sleep_save_intrs(vias->intrs[0].line);
  2385. /* Make sure the decrementer won't interrupt us */
  2386. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  2387. /* Make sure any pending DEC interrupt occuring while we did
  2388.  * the above didn't re-enable the DEC */
  2389. mb();
  2390. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  2392. /* Save the state of PCI config space for some slots */
  2393. pbook_pci_save();
  2395. /* Set the memory controller to keep the memory refreshed
  2396.    while we're asleep */
  2397. for (i = 0x403f; i >= 0x4000; --i) {
  2398. out_be32(mem_ctrl_sleep, i);
  2399. do {
  2400. x = (in_be32(mem_ctrl_sleep) >> 16) & 0x3ff;
  2401. } while (x == 0);
  2402. if (x >= 0x100)
  2403. break;
  2404. }
  2406. /* Ask the PMU to put us to sleep */
  2407. pmu_request(&sleep_req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
  2408. while (!sleep_req.complete)
  2409. mb();
  2411. pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,1);
  2413. /* displacement-flush the L2 cache - necessary? */
  2414. for (p = KERNELBASE; p < KERNELBASE + 0x100000; p += 0x1000)
  2415. i = *(volatile int *)p;
  2416. asleep = 1;
  2418. /* Put the CPU into sleep mode */
  2419. asm volatile("mfspr %0,1008" : "=r" (hid0) :);
  2420. hid0 = (hid0 & ~(HID0_NAP | HID0_DOZE)) | HID0_SLEEP;
  2421. asm volatile("mtspr 1008,%0" : : "r" (hid0));
  2422. _nmask_and_or_msr(0, MSR_POW | MSR_EE);
  2423. udelay(10);
  2425. /* OK, we're awake again, start restoring things */
  2426. out_be32(mem_ctrl_sleep, 0x3f);
  2427. pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,0);
  2428. pbook_pci_restore();
  2430. /* wait for the PMU interrupt sequence to complete */
  2431. while (asleep)
  2432. mb();
  2434. /* reenable interrupts */
  2435. pmac_sleep_restore_intrs();
  2437. /* Leave some time for HW to settle down */
  2438. mdelay(100);
  2440. /* Restart jiffies & scheduling */
  2441. wakeup_decrementer();
  2443. /* Re-enable local CPU interrupts */
  2444. local_irq_enable();
  2446. /* Notify drivers */
  2447. broadcast_wake();
  2449. pbook_free_pci_save();
  2450. iounmap(mem_ctrl);
  2451. return 0;
  2452. }
  2454. /*
  2455.  * Support for /dev/pmu device
  2456.  */
  2457. #define RB_SIZE 0x10
  2458. struct pmu_private {
  2459. struct list_head list;
  2460. int rb_get;
  2461. int rb_put;
  2462. struct rb_entry {
  2463. unsigned short len;
  2464. unsigned char data[16];
  2465. } rb_buf[RB_SIZE];
  2466. wait_queue_head_t wait;
  2467. spinlock_t lock;
  2468. #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
  2469. int backlight_locker;
  2470. #endif /* defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT) */
  2471. };
  2473. static LIST_HEAD(all_pmu_pvt);
  2474. static spinlock_t all_pvt_lock = SPIN_LOCK_UNLOCKED;
  2476. static void pmu_pass_intr(unsigned char *data, int len)
  2477. {
  2478. struct pmu_private *pp;
  2479. struct list_head *list;
  2480. int i;
  2481. unsigned long flags;
  2483. if (len > sizeof(pp->rb_buf[0].data))
  2484. len = sizeof(pp->rb_buf[0].data);
  2485. spin_lock_irqsave(&all_pvt_lock, flags);
  2486. for (list = &all_pmu_pvt; (list = list->next) != &all_pmu_pvt; ) {
  2487. pp = list_entry(list, struct pmu_private, list);
  2488. spin_lock(&pp->lock);
  2489. i = pp->rb_put + 1;
  2490. if (i >= RB_SIZE)
  2491. i = 0;
  2492. if (i != pp->rb_get) {
  2493. struct rb_entry *rp = &pp->rb_buf[pp->rb_put];
  2494. rp->len = len;
  2495. memcpy(rp->data, data, len);
  2496. pp->rb_put = i;
  2497. wake_up_interruptible(&pp->wait);
  2498. }
  2499. spin_unlock(&pp->lock);
  2500. }
  2501. spin_unlock_irqrestore(&all_pvt_lock, flags);
  2502. }
  2504. static int __openfirmware pmu_open(struct inode *inode, struct file *file)
  2505. {
  2506. struct pmu_private *pp;
  2507. unsigned long flags;
  2509. pp = kmalloc(sizeof(struct pmu_private), GFP_KERNEL);
  2510. if (pp == 0)
  2511. return -ENOMEM;
  2512. pp->rb_get = pp->rb_put = 0;
  2513. spin_lock_init(&pp->lock);
  2514. init_waitqueue_head(&pp->wait);
  2515. spin_lock_irqsave(&all_pvt_lock, flags);
  2516. #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
  2517. pp->backlight_locker = 0;
  2518. #endif /* defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT) */
  2519. list_add(&pp->list, &all_pmu_pvt);
  2520. spin_unlock_irqrestore(&all_pvt_lock, flags);
  2521. file->private_data = pp;
  2523. return 0;
  2524. }
  2526. static ssize_t __openfirmware pmu_read(struct file *file, char *buf,
  2527. size_t count, loff_t *ppos)
  2528. {
  2529. struct pmu_private *pp = file->private_data;
  2530. DECLARE_WAITQUEUE(wait, current);
  2531. unsigned long flags;
  2532. int ret;
  2534. if (count < 1 || pp == 0)
  2535. return -EINVAL;
  2536. ret = verify_area(VERIFY_WRITE, buf, count);
  2537. if (ret)
  2538. return ret;
  2540. spin_lock_irqsave(&pp->lock, flags);
  2541. add_wait_queue(&pp->wait, &wait);
  2542. current->state = TASK_INTERRUPTIBLE;
  2544. for (;;) {
  2545. ret = -EAGAIN;
  2546. if (pp->rb_get != pp->rb_put) {
  2547. int i = pp->rb_get;
  2548. struct rb_entry *rp = &pp->rb_buf[i];
  2549. ret = rp->len;
  2550. spin_unlock_irqrestore(&pp->lock, flags);
  2551. if (ret > count)
  2552. ret = count;
  2553. if (ret > 0 && copy_to_user(buf, rp->data, ret))
  2554. ret = -EFAULT;
  2555. if (++i >= RB_SIZE)
  2556. i = 0;
  2557. spin_lock_irqsave(&pp->lock, flags);
  2558. pp->rb_get = i;
  2559. }
  2560. if (ret >= 0)
  2561. break;
  2562. if (file->f_flags & O_NONBLOCK)
  2563. break;
  2564. ret = -ERESTARTSYS;
  2565. if (signal_pending(current))
  2566. break;
  2567. spin_unlock_irqrestore(&pp->lock, flags);
  2568. schedule();
  2569. spin_lock_irqsave(&pp->lock, flags);
  2570. }
  2571. current->state = TASK_RUNNING;
  2572. remove_wait_queue(&pp->wait, &wait);
  2573. spin_unlock_irqrestore(&pp->lock, flags);
  2575. return ret;
  2576. }
  2578. static ssize_t __openfirmware pmu_write(struct file *file, const char *buf,
  2579.  size_t count, loff_t *ppos)
  2580. {
  2581. return 0;
  2582. }
  2584. static unsigned int pmu_fpoll(struct file *filp, poll_table *wait)
  2585. {
  2586. struct pmu_private *pp = filp->private_data;
  2587. unsigned int mask = 0;
  2588. unsigned long flags;
  2590. if (pp == 0)
  2591. return 0;
  2592. poll_wait(filp, &pp->wait, wait);
  2593. spin_lock_irqsave(&pp->lock, flags);
  2594. if (pp->rb_get != pp->rb_put)
  2595. mask |= POLLIN;
  2596. spin_unlock_irqrestore(&pp->lock, flags);
  2597. return mask;
  2598. }
  2600. static int pmu_release(struct inode *inode, struct file *file)
  2601. {
  2602. struct pmu_private *pp = file->private_data;
  2603. unsigned long flags;
  2605. lock_kernel();
  2606. if (pp != 0) {
  2607. file->private_data = 0;
  2608. spin_lock_irqsave(&all_pvt_lock, flags);
  2609. list_del(&pp->list);
  2610. spin_unlock_irqrestore(&all_pvt_lock, flags);
  2611. #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
  2612. if (pp->backlight_locker) {
  2613. spin_lock_irqsave(&pmu_lock, flags);
  2614. disable_kernel_backlight--;
  2615. spin_unlock_irqrestore(&pmu_lock, flags);
  2616. }
  2617. #endif /* defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT) */
  2618. kfree(pp);
  2619. }
  2620. unlock_kernel();
  2621. return 0;
  2622. }
  2624. /* Note: removed __openfirmware here since it causes link errors */
  2625. static int pmu_ioctl(struct inode * inode, struct file *filp,
  2626.      u_int cmd, u_long arg)
  2627. {
  2628. struct pmu_private *pp = filp->private_data;
  2629. int error;
  2631. switch (cmd) {
  2632. case PMU_IOC_SLEEP:
  2633. if (!capable(CAP_SYS_ADMIN))
  2634. return -EACCES;
  2635. if (sleep_in_progress)
  2636. return -EBUSY;
  2637. sleep_in_progress = 1;
  2638. switch (pmu_kind) {
  2639. case PMU_OHARE_BASED:
  2640. error = powerbook_sleep_3400();
  2641. break;
  2642. case PMU_HEATHROW_BASED:
  2643. case PMU_PADDINGTON_BASED:
  2644. error = powerbook_sleep_G3();
  2645. break;
  2646. case PMU_KEYLARGO_BASED:
  2647. error = powerbook_sleep_Core99();
  2648. break;
  2649. default:
  2650. error = -ENOSYS;
  2651. }
  2652. sleep_in_progress = 0;
  2653. return error;
  2654. case PMU_IOC_CAN_SLEEP:
  2655. return put_user((u32)can_sleep, (__u32 *)arg);
  2657. #ifdef CONFIG_PMAC_BACKLIGHT
  2658. /* Backlight should have its own device or go via
  2659.  * the fbdev
  2660.  */
  2661. case PMU_IOC_GET_BACKLIGHT:
  2662. if (sleep_in_progress)
  2663. return -EBUSY;
  2664. error = get_backlight_level();
  2665. if (error < 0)
  2666. return error;
  2667. return put_user(error, (__u32 *)arg);
  2668. case PMU_IOC_SET_BACKLIGHT:
  2669. {
  2670. __u32 value;
  2671. if (sleep_in_progress)
  2672. return -EBUSY;
  2673. error = get_user(value, (__u32 *)arg);
  2674. if (!error)
  2675. error = set_backlight_level(value);
  2676. return error;
  2677. }
  2678. #ifdef CONFIG_INPUT_ADBHID
  2679. case PMU_IOC_GRAB_BACKLIGHT: {
  2680. unsigned long flags;
  2681. if (pp->backlight_locker)
  2682. return 0;
  2683. pp->backlight_locker = 1;
  2684. spin_lock_irqsave(&pmu_lock, flags);
  2685. disable_kernel_backlight++;
  2686. spin_unlock_irqrestore(&pmu_lock, flags);
  2687. return 0;
  2688. }
  2689. #endif /* CONFIG_INPUT_ADBHID */
  2690. #endif /* CONFIG_PMAC_BACKLIGHT */
  2691. case PMU_IOC_GET_MODEL:
  2692.      return put_user(pmu_kind, (__u32 *)arg);
  2693. case PMU_IOC_HAS_ADB:
  2694. return put_user(pmu_has_adb, (__u32 *)arg);
  2695. }
  2696. return -EINVAL;
  2697. }
  2699. static struct file_operations pmu_device_fops = {
  2700. read: pmu_read,
  2701. write: pmu_write,
  2702. poll: pmu_fpoll,
  2703. ioctl: pmu_ioctl,
  2704. open: pmu_open,
  2705. release: pmu_release,
  2706. };
  2708. static struct miscdevice pmu_device = {
  2709. PMU_MINOR, "pmu", &pmu_device_fops
  2710. };
  2712. void pmu_device_init(void)
  2713. {
  2714. if (via)
  2715. misc_register(&pmu_device);
  2716. }
  2717. #endif /* CONFIG_PMAC_PBOOK */
  2719. #if defined(DEBUG_SLEEP) || defined(DEBUG_FREQ)
  2720. static inline void __pmac
  2721. polled_handshake(volatile unsigned char *via)
  2722. {
  2723. via[B] &= ~TREQ; eieio();
  2724. while ((via[B] & TACK) != 0)
  2725. ;
  2726. via[B] |= TREQ; eieio();
  2727. while ((via[B] & TACK) == 0)
  2728. ;
  2729. }
  2731. static inline void __pmac
  2732. polled_send_byte(volatile unsigned char *via, int x)
  2733. {
  2734. via[ACR] |= SR_OUT | SR_EXT; eieio();
  2735. via[SR] = x; eieio();
  2736. polled_handshake(via);
  2737. }
  2739. static inline int __pmac
  2740. polled_recv_byte(volatile unsigned char *via)
  2741. {
  2742. int x;
  2744. via[ACR] = (via[ACR] & ~SR_OUT) | SR_EXT; eieio();
  2745. x = via[SR]; eieio();
  2746. polled_handshake(via);
  2747. x = via[SR]; eieio();
  2748. return x;
  2749. }
  2751. int __pmac
  2752. pmu_polled_request(struct adb_request *req)
  2753. {
  2754. unsigned long flags;
  2755. int i, l, c;
  2756. volatile unsigned char *v = via;
  2758. req->complete = 1;
  2759. c = req->data[0];
  2760. l = pmu_data_len[c][0];
  2761. if (l >= 0 && req->nbytes != l + 1)
  2762. return -EINVAL;
  2764. local_irq_save(flags);
  2765. while (pmu_state != idle)
  2766. pmu_poll();
  2768. while ((via[B] & TACK) == 0)
  2769. ;
  2770. polled_send_byte(v, c);
  2771. if (l < 0) {
  2772. l = req->nbytes - 1;
  2773. polled_send_byte(v, l);
  2774. }
  2775. for (i = 1; i <= l; ++i)
  2776. polled_send_byte(v, req->data[i]);
  2778. l = pmu_data_len[c][1];
  2779. if (l < 0)
  2780. l = polled_recv_byte(v);
  2781. for (i = 0; i < l; ++i)
  2782. req->reply[i + req->reply_len] = polled_recv_byte(v);
  2784. if (req->done)
  2785. (*req->done)(req);
  2787. local_irq_restore(flags);
  2788. return 0;
  2789. }
  2790. #endif /* defined(DEBUG_SLEEP) || defined(DEBUG_FREQ) */
  2793. EXPORT_SYMBOL(pmu_request);
  2794. EXPORT_SYMBOL(pmu_poll);
  2795. EXPORT_SYMBOL(pmu_suspend);
  2796. EXPORT_SYMBOL(pmu_resume);
  2797. #ifdef CONFIG_PMAC_PBOOK
  2798. EXPORT_SYMBOL(pmu_register_sleep_notifier);
  2799. EXPORT_SYMBOL(pmu_unregister_sleep_notifier);
  2800. EXPORT_SYMBOL(pmu_enable_irled);
  2801. EXPORT_SYMBOL(pmu_battery_count);
  2802. EXPORT_SYMBOL(pmu_batteries);
  2803. EXPORT_SYMBOL(pmu_power_flags);
  2804. #endif /* CONFIG_PMAC_PBOOK */