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

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

Linux/Unix编程

开发平台：

Unix_Linux

via-pmu68k.c：源码内容
  1. /*
  2.  * Device driver for the PMU on 68K-based Apple PowerBooks
  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 PowerBooks.
  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.  * Adapted for 68K PMU by Joshua M. Thompson
  12.  *
  13.  * Based largely on the PowerMac PMU code by Paul Mackerras and
  14.  * Fabio Riccardi.
  15.  *
  16.  * Also based on the PMU driver from MkLinux by Apple Computer, Inc.
  17.  * and the Open Software Foundation, Inc.
  18.  */
  20. #include <stdarg.h>
  21. #include <linux/types.h>
  22. #include <linux/errno.h>
  23. #include <linux/kernel.h>
  24. #include <linux/delay.h>
  25. #include <linux/sched.h>
  26. #include <linux/miscdevice.h>
  27. #include <linux/blkdev.h>
  28. #include <linux/pci.h>
  29. #include <linux/slab.h>
  30. #include <linux/init.h>
  32. #include <linux/adb.h>
  33. #include <linux/pmu.h>
  34. #include <linux/cuda.h>
  36. #include <asm/macintosh.h>
  37. #include <asm/macints.h>
  38. #include <asm/machw.h>
  39. #include <asm/mac_via.h>
  41. #include <asm/pgtable.h>
  42. #include <asm/system.h>
  43. #include <asm/irq.h>
  44. #include <asm/uaccess.h>
  46. /* Misc minor number allocated for /dev/pmu */
  47. #define PMU_MINOR 154
  49. /* VIA registers - spaced 0x200 bytes apart */
  50. #define RS 0x200 /* skip between registers */
  51. #define B 0 /* B-side data */
  52. #define A RS /* A-side data */
  53. #define DIRB (2*RS) /* B-side direction (1=output) */
  54. #define DIRA (3*RS) /* A-side direction (1=output) */
  55. #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */
  56. #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */
  57. #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */
  58. #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */
  59. #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */
  60. #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */
  61. #define SR (10*RS) /* Shift register */
  62. #define ACR (11*RS) /* Auxiliary control register */
  63. #define PCR (12*RS) /* Peripheral control register */
  64. #define IFR (13*RS) /* Interrupt flag register */
  65. #define IER (14*RS) /* Interrupt enable register */
  66. #define ANH (15*RS) /* A-side data, no handshake */
  68. /* Bits in B data register: both active low */
  69. #define TACK 0x02 /* Transfer acknowledge (input) */
  70. #define TREQ 0x04 /* Transfer request (output) */
  72. /* Bits in ACR */
  73. #define SR_CTRL 0x1c /* Shift register control bits */
  74. #define SR_EXT 0x0c /* Shift on external clock */
  75. #define SR_OUT 0x10 /* Shift out if 1 */
  77. /* Bits in IFR and IER */
  78. #define SR_INT 0x04 /* Shift register full/empty */
  79. #define CB1_INT 0x10 /* transition on CB1 input */
  81. static enum pmu_state {
  82. idle,
  83. sending,
  84. intack,
  85. reading,
  86. reading_intr,
  87. } pmu_state;
  89. static struct adb_request *current_req;
  90. static struct adb_request *last_req;
  91. static struct adb_request *req_awaiting_reply;
  92. static unsigned char interrupt_data[32];
  93. static unsigned char *reply_ptr;
  94. static int data_index;
  95. static int data_len;
  96. static int adb_int_pending;
  97. static int pmu_adb_flags;
  98. static int adb_dev_map = 0;
  99. static struct adb_request bright_req_1, bright_req_2, bright_req_3;
  100. static int pmu_kind = PMU_UNKNOWN;
  101. static int pmu_fully_inited = 0;
  103. int asleep;
  104. struct notifier_block *sleep_notifier_list;
  106. static int pmu_probe(void);
  107. static int pmu_init(void);
  108. static void pmu_start(void);
  109. static void pmu_interrupt(int irq, void *arg, struct pt_regs *regs);
  110. static int pmu_send_request(struct adb_request *req, int sync);
  111. static int pmu_autopoll(int devs);
  112. void pmu_poll(void);
  113. static int pmu_reset_bus(void);
  114. static int pmu_queue_request(struct adb_request *req);
  116. static void pmu_start(void);
  117. static void send_byte(int x);
  118. static void recv_byte(void);
  119. static void pmu_done(struct adb_request *req);
  120. static void pmu_handle_data(unsigned char *data, int len,
  121.     struct pt_regs *regs);
  122. static void set_volume(int level);
  123. static void pmu_enable_backlight(int on);
  124. static void pmu_set_brightness(int level);
  126. struct adb_driver via_pmu_driver = {
  127. "68K PMU",
  128. pmu_probe,
  129. pmu_init,
  130. pmu_send_request,
  131. pmu_autopoll,
  132. pmu_poll,
  133. pmu_reset_bus
  134. };
  136. /*
  137.  * This table indicates for each PMU opcode:
  138.  * - the number of data bytes to be sent with the command, or -1
  139.  *   if a length byte should be sent,
  140.  * - the number of response bytes which the PMU will return, or
  141.  *   -1 if it will send a length byte.
  142.  */
  143. static s8 pmu_data_len[256][2] = {
  144. /*    0    1    2    3    4    5    6    7  */
  145. /*00*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  146. /*08*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  147. /*10*/ { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  148. /*18*/ { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0, 0},
  149. /*20*/ {-1, 0},{ 0, 0},{ 2, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},
  150. /*28*/ { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0,-1},
  151. /*30*/ { 4, 0},{20, 0},{-1, 0},{ 3, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  152. /*38*/ { 0, 4},{ 0,20},{ 2,-1},{ 2, 1},{ 3,-1},{-1,-1},{-1,-1},{ 4, 0},
  153. /*40*/ { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  154. /*48*/ { 0, 1},{ 0, 1},{-1,-1},{ 1, 0},{ 1, 0},{-1,-1},{-1,-1},{-1,-1},
  155. /*50*/ { 1, 0},{ 0, 0},{ 2, 0},{ 2, 0},{-1, 0},{ 1, 0},{ 3, 0},{ 1, 0},
  156. /*58*/ { 0, 1},{ 1, 0},{ 0, 2},{ 0, 2},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},
  157. /*60*/ { 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  158. /*68*/ { 0, 3},{ 0, 3},{ 0, 2},{ 0, 8},{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},
  159. /*70*/ { 1, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  160. /*78*/ { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{ 5, 1},{ 4, 1},{ 4, 1},
  161. /*80*/ { 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  162. /*88*/ { 0, 5},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  163. /*90*/ { 1, 0},{ 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  164. /*98*/ { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  165. /*a0*/ { 2, 0},{ 2, 0},{ 2, 0},{ 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},
  166. /*a8*/ { 1, 1},{ 1, 0},{ 3, 0},{ 2, 0},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  167. /*b0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  168. /*b8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  169. /*c0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  170. /*c8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  171. /*d0*/ { 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  172. /*d8*/ { 1, 1},{ 1, 1},{-1,-1},{-1,-1},{ 0, 1},{ 0,-1},{-1,-1},{-1,-1},
  173. /*e0*/ {-1, 0},{ 4, 0},{ 0, 1},{-1, 0},{-1, 0},{ 4, 0},{-1, 0},{-1, 0},
  174. /*e8*/ { 3,-1},{-1,-1},{ 0, 1},{-1,-1},{ 0,-1},{-1,-1},{-1,-1},{ 0, 0},
  175. /*f0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
  176. /*f8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  177. };
  179. int pmu_probe()
  180. {
  181. if (macintosh_config->adb_type == MAC_ADB_PB1) {
  182. pmu_kind = PMU_68K_V1;
  183. } else if (macintosh_config->adb_type == MAC_ADB_PB2) {
  184. pmu_kind = PMU_68K_V2;
  185. } else {
  186. return -ENODEV;
  187. }
  189. pmu_state = idle;
  191. return 0;
  192. }
  194. static int 
  195. pmu_init(void)
  196. {
  197. int timeout;
  198. volatile struct adb_request req;
  200. via2[B] |= TREQ; /* negate TREQ */
  201. via2[DIRB] = (via2[DIRB] | TREQ) & ~TACK; /* TACK in, TREQ out */
  203. pmu_request((struct adb_request *) &req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB);
  204. timeout =  100000;
  205. while (!req.complete) {
  206. if (--timeout < 0) {
  207. printk(KERN_ERR "pmu_init: no response from PMUn");
  208. return -EAGAIN;
  209. }
  210. udelay(10);
  211. pmu_poll();
  212. }
  214. /* ack all pending interrupts */
  215. timeout = 100000;
  216. interrupt_data[0] = 1;
  217. while (interrupt_data[0] || pmu_state != idle) {
  218. if (--timeout < 0) {
  219. printk(KERN_ERR "pmu_init: timed out acking intrsn");
  220. return -EAGAIN;
  221. }
  222. if (pmu_state == idle) {
  223. adb_int_pending = 1;
  224. pmu_interrupt(0, NULL, NULL);
  225. }
  226. pmu_poll();
  227. udelay(10);
  228. }
  230. pmu_request((struct adb_request *) &req, NULL, 2, PMU_SET_INTR_MASK,
  231. PMU_INT_ADB_AUTO|PMU_INT_SNDBRT|PMU_INT_ADB);
  232. timeout =  100000;
  233. while (!req.complete) {
  234. if (--timeout < 0) {
  235. printk(KERN_ERR "pmu_init: no response from PMUn");
  236. return -EAGAIN;
  237. }
  238. udelay(10);
  239. pmu_poll();
  240. }
  242. bright_req_1.complete = 1;
  243. bright_req_2.complete = 1;
  244. bright_req_3.complete = 1;
  246. if (request_irq(IRQ_MAC_ADB_SR, pmu_interrupt, 0, "pmu-shift",
  247. pmu_interrupt)) {
  248. printk(KERN_ERR "pmu_init: can't get irq %dn",
  249. IRQ_MAC_ADB_SR);
  250. return -EAGAIN;
  251. }
  252. if (request_irq(IRQ_MAC_ADB_CL, pmu_interrupt, 0, "pmu-clock",
  253. pmu_interrupt)) {
  254. printk(KERN_ERR "pmu_init: can't get irq %dn",
  255. IRQ_MAC_ADB_CL);
  256. free_irq(IRQ_MAC_ADB_SR, pmu_interrupt);
  257. return -EAGAIN;
  258. }
  260. pmu_fully_inited = 1;
  262. /* Enable backlight */
  263. pmu_enable_backlight(1);
  265. printk("adb: PMU 68K driver v0.5 for Unified ADB.n");
  267. return 0;
  268. }
  270. int
  271. pmu_get_model(void)
  272. {
  273. return pmu_kind;
  274. }
  276. /* Send an ADB command */
  277. static int 
  278. pmu_send_request(struct adb_request *req, int sync)
  279. {
  280.     int i, ret;
  282.     if (!pmu_fully_inited)
  283.     {
  284.   req->complete = 1;
  285.     return -ENXIO;
  286.    }
  288.     ret = -EINVAL;
  290.     switch (req->data[0]) {
  291.     case PMU_PACKET:
  292. for (i = 0; i < req->nbytes - 1; ++i)
  293. req->data[i] = req->data[i+1];
  294. --req->nbytes;
  295. if (pmu_data_len[req->data[0]][1] != 0) {
  296. req->reply[0] = ADB_RET_OK;
  297. req->reply_len = 1;
  298. } else
  299. req->reply_len = 0;
  300. ret = pmu_queue_request(req);
  301. break;
  302.     case CUDA_PACKET:
  303. switch (req->data[1]) {
  304. case CUDA_GET_TIME:
  305. if (req->nbytes != 2)
  306. break;
  307. req->data[0] = PMU_READ_RTC;
  308. req->nbytes = 1;
  309. req->reply_len = 3;
  310. req->reply[0] = CUDA_PACKET;
  311. req->reply[1] = 0;
  312. req->reply[2] = CUDA_GET_TIME;
  313. ret = pmu_queue_request(req);
  314. break;
  315. case CUDA_SET_TIME:
  316. if (req->nbytes != 6)
  317. break;
  318. req->data[0] = PMU_SET_RTC;
  319. req->nbytes = 5;
  320. for (i = 1; i <= 4; ++i)
  321. req->data[i] = req->data[i+1];
  322. req->reply_len = 3;
  323. req->reply[0] = CUDA_PACKET;
  324. req->reply[1] = 0;
  325. req->reply[2] = CUDA_SET_TIME;
  326. ret = pmu_queue_request(req);
  327. break;
  328. case CUDA_GET_PRAM:
  329. if (req->nbytes != 4)
  330. break;
  331. req->data[0] = PMU_READ_NVRAM;
  332. req->data[1] = req->data[2];
  333. req->data[2] = req->data[3];
  334. req->nbytes = 3;
  335. req->reply_len = 3;
  336. req->reply[0] = CUDA_PACKET;
  337. req->reply[1] = 0;
  338. req->reply[2] = CUDA_GET_PRAM;
  339. ret = pmu_queue_request(req);
  340. break;
  341. case CUDA_SET_PRAM:
  342. if (req->nbytes != 5)
  343. break;
  344. req->data[0] = PMU_WRITE_NVRAM;
  345. req->data[1] = req->data[2];
  346. req->data[2] = req->data[3];
  347. req->data[3] = req->data[4];
  348. req->nbytes = 4;
  349. req->reply_len = 3;
  350. req->reply[0] = CUDA_PACKET;
  351. req->reply[1] = 0;
  352. req->reply[2] = CUDA_SET_PRAM;
  353. ret = pmu_queue_request(req);
  354. break;
  355. }
  356. break;
  357.     case ADB_PACKET:
  358. for (i = req->nbytes - 1; i > 1; --i)
  359. req->data[i+2] = req->data[i];
  360. req->data[3] = req->nbytes - 2;
  361. req->data[2] = pmu_adb_flags;
  362. /*req->data[1] = req->data[1];*/
  363. req->data[0] = PMU_ADB_CMD;
  364. req->nbytes += 2;
  365. req->reply_expected = 1;
  366. req->reply_len = 0;
  367. ret = pmu_queue_request(req);
  368. break;
  369.     }
  370.     if (ret)
  371.     {
  372.      req->complete = 1;
  373.      return ret;
  374.     }
  375.     
  376.     if (sync) {
  377. while (!req->complete)
  378. pmu_poll();
  379.     }
  381.     return 0;
  382. }
  384. /* Enable/disable autopolling */
  385. static int 
  386. pmu_autopoll(int devs)
  387. {
  388. struct adb_request req;
  390. if (!pmu_fully_inited) return -ENXIO;
  392. if (devs) {
  393. adb_dev_map = devs;
  394. pmu_request(&req, NULL, 5, PMU_ADB_CMD, 0, 0x86,
  395.     adb_dev_map >> 8, adb_dev_map);
  396. pmu_adb_flags = 2;
  397. } else {
  398. pmu_request(&req, NULL, 1, PMU_ADB_POLL_OFF);
  399. pmu_adb_flags = 0;
  400. }
  401. while (!req.complete)
  402. pmu_poll();
  403. return 0;
  404. }
  406. /* Reset the ADB bus */
  407. static int 
  408. pmu_reset_bus(void)
  409. {
  410. struct adb_request req;
  411. long timeout;
  412. int save_autopoll = adb_dev_map;
  414. if (!pmu_fully_inited) return -ENXIO;
  416. /* anyone got a better idea?? */
  417. pmu_autopoll(0);
  419. req.nbytes = 5;
  420. req.done = NULL;
  421. req.data[0] = PMU_ADB_CMD;
  422. req.data[1] = 0;
  423. req.data[2] = 3; /* ADB_BUSRESET ??? */
  424. req.data[3] = 0;
  425. req.data[4] = 0;
  426. req.reply_len = 0;
  427. req.reply_expected = 1;
  428. if (pmu_queue_request(&req) != 0)
  429. {
  430. printk(KERN_ERR "pmu_adb_reset_bus: pmu_queue_request failedn");
  431. return -EIO;
  432. }
  433. while (!req.complete)
  434. pmu_poll();
  435. timeout = 100000;
  436. while (!req.complete) {
  437. if (--timeout < 0) {
  438. printk(KERN_ERR "pmu_adb_reset_bus (reset): no response from PMUn");
  439. return -EIO;
  440. }
  441. udelay(10);
  442. pmu_poll();
  443. }
  445. if (save_autopoll != 0)
  446. pmu_autopoll(save_autopoll);
  448. return 0;
  449. }
  451. /* Construct and send a pmu request */
  452. int 
  453. pmu_request(struct adb_request *req, void (*done)(struct adb_request *),
  454.     int nbytes, ...)
  455. {
  456. va_list list;
  457. int i;
  459. if (nbytes < 0 || nbytes > 32) {
  460. printk(KERN_ERR "pmu_request: bad nbytes (%d)n", nbytes);
  461. req->complete = 1;
  462. return -EINVAL;
  463. }
  464. req->nbytes = nbytes;
  465. req->done = done;
  466. va_start(list, nbytes);
  467. for (i = 0; i < nbytes; ++i)
  468. req->data[i] = va_arg(list, int);
  469. va_end(list);
  470. if (pmu_data_len[req->data[0]][1] != 0) {
  471. req->reply[0] = ADB_RET_OK;
  472. req->reply_len = 1;
  473. } else
  474. req->reply_len = 0;
  475. req->reply_expected = 0;
  476. return pmu_queue_request(req);
  477. }
  479. static int 
  480. pmu_queue_request(struct adb_request *req)
  481. {
  482. unsigned long flags;
  483. int nsend;
  485. if (req->nbytes <= 0) {
  486. req->complete = 1;
  487. return 0;
  488. }
  489. nsend = pmu_data_len[req->data[0]][0];
  490. if (nsend >= 0 && req->nbytes != nsend + 1) {
  491. req->complete = 1;
  492. return -EINVAL;
  493. }
  495. req->next = 0;
  496. req->sent = 0;
  497. req->complete = 0;
  498. save_flags(flags); cli();
  500. if (current_req != 0) {
  501. last_req->next = req;
  502. last_req = req;
  503. } else {
  504. current_req = req;
  505. last_req = req;
  506. if (pmu_state == idle)
  507. pmu_start();
  508. }
  510. restore_flags(flags);
  511. return 0;
  512. }
  514. static void 
  515. send_byte(int x)
  516. {
  517. via1[ACR] |= SR_CTRL;
  518. via1[SR] = x;
  519. via2[B] &= ~TREQ; /* assert TREQ */
  520. }
  522. static void 
  523. recv_byte()
  524. {
  525. char c;
  527. via1[ACR] = (via1[ACR] | SR_EXT) & ~SR_OUT;
  528. c = via1[SR]; /* resets SR */
  529. via2[B] &= ~TREQ;
  530. }
  532. static void 
  533. pmu_start()
  534. {
  535. unsigned long flags;
  536. struct adb_request *req;
  538. /* assert pmu_state == idle */
  539. /* get the packet to send */
  540. save_flags(flags); cli();
  541. req = current_req;
  542. if (req == 0 || pmu_state != idle
  543.     || (req->reply_expected && req_awaiting_reply))
  544. goto out;
  546. pmu_state = sending;
  547. data_index = 1;
  548. data_len = pmu_data_len[req->data[0]][0];
  550. /* set the shift register to shift out and send a byte */
  551. send_byte(req->data[0]);
  553. out:
  554. restore_flags(flags);
  555. }
  557. void 
  558. pmu_poll()
  559. {
  560. unsigned long cpu_flags;
  562. save_flags(cpu_flags);
  563. cli();
  564. if (via1[IFR] & SR_INT) {
  565. via1[IFR] = SR_INT;
  566. pmu_interrupt(IRQ_MAC_ADB_SR, NULL, NULL);
  567. }
  568. if (via1[IFR] & CB1_INT) {
  569. via1[IFR] = CB1_INT;
  570. pmu_interrupt(IRQ_MAC_ADB_CL, NULL, NULL);
  571. }
  572. restore_flags(cpu_flags);
  573. }
  575. static void 
  576. pmu_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  577. {
  578. struct adb_request *req;
  579. int timeout, bite = 0; /* to prevent compiler warning */
  581. #if 0
  582. printk("pmu_interrupt: irq %d state %d acr %02X, b %02X data_index %d/%d adb_int_pending %dn",
  583. irq, pmu_state, (uint) via1[ACR], (uint) via2[B], data_index, data_len, adb_int_pending);
  584. #endif
  586. if (irq == IRQ_MAC_ADB_CL) { /* CB1 interrupt */
  587. adb_int_pending = 1;
  588. } else if (irq == IRQ_MAC_ADB_SR) { /* SR interrupt  */
  589. if (via2[B] & TACK) {
  590. printk(KERN_DEBUG "PMU: SR_INT but ack still high! (%x)n", via2[B]);
  591. }
  593. /* if reading grab the byte */
  594. if ((via1[ACR] & SR_OUT) == 0) bite = via1[SR];
  596. /* reset TREQ and wait for TACK to go high */
  597. via2[B] |= TREQ;
  598. timeout = 3200;
  599. while (!(via2[B] & TACK)) {
  600. if (--timeout < 0) {
  601. printk(KERN_ERR "PMU not responding (!ack)n");
  602. goto finish;
  603. }
  604. udelay(10);
  605. }
  607. switch (pmu_state) {
  608. case sending:
  609. req = current_req;
  610. if (data_len < 0) {
  611. data_len = req->nbytes - 1;
  612. send_byte(data_len);
  613. break;
  614. }
  615. if (data_index <= data_len) {
  616. send_byte(req->data[data_index++]);
  617. break;
  618. }
  619. req->sent = 1;
  620. data_len = pmu_data_len[req->data[0]][1];
  621. if (data_len == 0) {
  622. pmu_state = idle;
  623. current_req = req->next;
  624. if (req->reply_expected)
  625. req_awaiting_reply = req;
  626. else
  627. pmu_done(req);
  628. } else {
  629. pmu_state = reading;
  630. data_index = 0;
  631. reply_ptr = req->reply + req->reply_len;
  632. recv_byte();
  633. }
  634. break;
  636. case intack:
  637. data_index = 0;
  638. data_len = -1;
  639. pmu_state = reading_intr;
  640. reply_ptr = interrupt_data;
  641. recv_byte();
  642. break;
  644. case reading:
  645. case reading_intr:
  646. if (data_len == -1) {
  647. data_len = bite;
  648. if (bite > 32)
  649. printk(KERN_ERR "PMU: bad reply len %dn",
  650.        bite);
  651. } else {
  652. reply_ptr[data_index++] = bite;
  653. }
  654. if (data_index < data_len) {
  655. recv_byte();
  656. break;
  657. }
  659. if (pmu_state == reading_intr) {
  660. pmu_handle_data(interrupt_data, data_index, regs);
  661. } else {
  662. req = current_req;
  663. current_req = req->next;
  664. req->reply_len += data_index;
  665. pmu_done(req);
  666. }
  667. pmu_state = idle;
  669. break;
  671. default:
  672. printk(KERN_ERR "pmu_interrupt: unknown state %d?n",
  673.        pmu_state);
  674. }
  675. }
  676. finish:
  677. if (pmu_state == idle) {
  678. if (adb_int_pending) {
  679. pmu_state = intack;
  680. send_byte(PMU_INT_ACK);
  681. adb_int_pending = 0;
  682. } else if (current_req) {
  683. pmu_start();
  684. }
  685. }
  687. #if 0
  688. printk("pmu_interrupt: exit state %d acr %02X, b %02X data_index %d/%d adb_int_pending %dn",
  689. pmu_state, (uint) via1[ACR], (uint) via2[B], data_index, data_len, adb_int_pending);
  690. #endif
  691. }
  693. static void 
  694. pmu_done(struct adb_request *req)
  695. {
  696. req->complete = 1;
  697. if (req->done)
  698. (*req->done)(req);
  699. }
  701. /* Interrupt data could be the result data from an ADB cmd */
  702. static void 
  703. pmu_handle_data(unsigned char *data, int len, struct pt_regs *regs)
  704. {
  705. static int show_pmu_ints = 1;
  707. asleep = 0;
  708. if (len < 1) {
  709. adb_int_pending = 0;
  710. return;
  711. }
  712. if (data[0] & PMU_INT_ADB) {
  713. if ((data[0] & PMU_INT_ADB_AUTO) == 0) {
  714. struct adb_request *req = req_awaiting_reply;
  715. if (req == 0) {
  716. printk(KERN_ERR "PMU: extra ADB replyn");
  717. return;
  718. }
  719. req_awaiting_reply = 0;
  720. if (len <= 2)
  721. req->reply_len = 0;
  722. else {
  723. memcpy(req->reply, data + 1, len - 1);
  724. req->reply_len = len - 1;
  725. }
  726. pmu_done(req);
  727. } else {
  728. adb_input(data+1, len-1, regs, 1);
  729. }
  730. } else {
  731. if (data[0] == 0x08 && len == 3) {
  732. /* sound/brightness buttons pressed */
  733. pmu_set_brightness(data[1] >> 3);
  734. set_volume(data[2]);
  735. } else if (show_pmu_ints
  736.    && !(data[0] == PMU_INT_TICK && len == 1)) {
  737. int i;
  738. printk(KERN_DEBUG "pmu intr");
  739. for (i = 0; i < len; ++i)
  740. printk(" %.2x", data[i]);
  741. printk("n");
  742. }
  743. }
  744. }
  746. int backlight_level = -1;
  747. int backlight_enabled = 0;
  749. #define LEVEL_TO_BRIGHT(lev) ((lev) < 1? 0x7f: 0x4a - ((lev) << 1))
  751. void 
  752. pmu_enable_backlight(int on)
  753. {
  754. struct adb_request req;
  756. if (on) {
  757.     /* first call: get current backlight value */
  758.     if (backlight_level < 0) {
  759. switch(pmu_kind) {
  760.     case PMU_68K_V1:
  761.     case PMU_68K_V2:
  762. pmu_request(&req, NULL, 3, PMU_READ_NVRAM, 0x14, 0xe);
  763. while (!req.complete)
  764. pmu_poll();
  765. printk(KERN_DEBUG "pmu: nvram returned bright: %dn", (int)req.reply[1]);
  766. backlight_level = req.reply[1];
  767. break;
  768.     default:
  769.         backlight_enabled = 0;
  770.         return;
  771. }
  772.     }
  773.     pmu_request(&req, NULL, 2, PMU_BACKLIGHT_BRIGHT,
  774.      LEVEL_TO_BRIGHT(backlight_level));
  775.     while (!req.complete)
  776. pmu_poll();
  777. }
  778. pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
  779.     PMU_POW_BACKLIGHT | (on ? PMU_POW_ON : PMU_POW_OFF));
  780. while (!req.complete)
  781. pmu_poll();
  782. backlight_enabled = on;
  783. }
  785. void 
  786. pmu_set_brightness(int level)
  787. {
  788. int bright;
  790. backlight_level = level;
  791. bright = LEVEL_TO_BRIGHT(level);
  792. if (!backlight_enabled)
  793. return;
  794. if (bright_req_1.complete)
  795. pmu_request(&bright_req_1, NULL, 2, PMU_BACKLIGHT_BRIGHT,
  796.     bright);
  797. if (bright_req_2.complete)
  798. pmu_request(&bright_req_2, NULL, 2, PMU_POWER_CTRL,
  799.     PMU_POW_BACKLIGHT | (bright < 0x7f ? PMU_POW_ON : PMU_POW_OFF));
  800. }
  802. void 
  803. pmu_enable_irled(int on)
  804. {
  805. struct adb_request req;
  807. pmu_request(&req, NULL, 2, PMU_POWER_CTRL, PMU_POW_IRLED |
  808.     (on ? PMU_POW_ON : PMU_POW_OFF));
  809. while (!req.complete)
  810. pmu_poll();
  811. }
  813. static void 
  814. set_volume(int level)
  815. {
  816. }
  818. int
  819. pmu_present(void)
  820. {
  821. return (pmu_kind != PMU_UNKNOWN);
  822. }
  824. #if 0 /* needs some work for 68K */
  826. /*
  827.  * This struct is used to store config register values for
  828.  * PCI devices which may get powered off when we sleep.
  829.  */
  830. static struct pci_save {
  831. u16 command;
  832. u16 cache_lat;
  833. u16 intr;
  834. } *pbook_pci_saves;
  835. static int n_pbook_pci_saves;
  837. static inline void __openfirmware
  838. pbook_pci_save(void)
  839. {
  840. int npci;
  841. struct pci_dev *pd;
  842. struct pci_save *ps;
  844. npci = 0;
  845. for (pd = pci_devices; pd != NULL; pd = pd->next)
  846. ++npci;
  847. n_pbook_pci_saves = npci;
  848. if (npci == 0)
  849. return;
  850. ps = (struct pci_save *) kmalloc(npci * sizeof(*ps), GFP_KERNEL);
  851. pbook_pci_saves = ps;
  852. if (ps == NULL)
  853. return;
  855. for (pd = pci_devices; pd != NULL && npci != 0; pd = pd->next) {
  856. pci_read_config_word(pd, PCI_COMMAND, &ps->command);
  857. pci_read_config_word(pd, PCI_CACHE_LINE_SIZE, &ps->cache_lat);
  858. pci_read_config_word(pd, PCI_INTERRUPT_LINE, &ps->intr);
  859. ++ps;
  860. --npci;
  861. }
  862. }
  864. static inline void __openfirmware
  865. pbook_pci_restore(void)
  866. {
  867. u16 cmd;
  868. struct pci_save *ps = pbook_pci_saves;
  869. struct pci_dev *pd;
  870. int j;
  872. for (pd = pci_devices; pd != NULL; pd = pd->next, ++ps) {
  873. if (ps->command == 0)
  874. continue;
  875. pci_read_config_word(pd, PCI_COMMAND, &cmd);
  876. if ((ps->command & ~cmd) == 0)
  877. continue;
  878. switch (pd->hdr_type) {
  879. case PCI_HEADER_TYPE_NORMAL:
  880. for (j = 0; j < 6; ++j)
  881. pci_write_config_dword(pd,
  882. PCI_BASE_ADDRESS_0 + j*4,
  883. pd->resource[j].start);
  884. pci_write_config_dword(pd, PCI_ROM_ADDRESS,
  885.        pd->resource[PCI_ROM_RESOURCE].start);
  886. pci_write_config_word(pd, PCI_CACHE_LINE_SIZE,
  887. ps->cache_lat);
  888. pci_write_config_word(pd, PCI_INTERRUPT_LINE,
  889. ps->intr);
  890. pci_write_config_word(pd, PCI_COMMAND, ps->command);
  891. break;
  892. /* other header types not restored at present */
  893. }
  894. }
  895. }
  897. /*
  898.  * Put the powerbook to sleep.
  899.  */
  900. #define IRQ_ENABLE ((unsigned int *)0xf3000024)
  901. #define MEM_CTRL ((unsigned int *)0xf8000070)
  903. int __openfirmware powerbook_sleep(void)
  904. {
  905. int ret, i, x;
  906. static int save_backlight;
  907. static unsigned int save_irqen;
  908. unsigned long msr;
  909. unsigned int hid0;
  910. unsigned long p, wait;
  911. struct adb_request sleep_req;
  913. /* Notify device drivers */
  914. ret = notifier_call_chain(&sleep_notifier_list, PBOOK_SLEEP, NULL);
  915. if (ret & NOTIFY_STOP_MASK)
  916. return -EBUSY;
  918. /* Sync the disks. */
  919. /* XXX It would be nice to have some way to ensure that
  920.  * nobody is dirtying any new buffers while we wait. */
  921. fsync_dev(0);
  923. /* Turn off the display backlight */
  924. save_backlight = backlight_enabled;
  925. if (save_backlight)
  926. pmu_enable_backlight(0);
  928. /* Give the disks a little time to actually finish writing */
  929. for (wait = jiffies + (HZ/4); time_before(jiffies, wait); )
  930. mb();
  932. /* Disable all interrupts except pmu */
  933. save_irqen = in_le32(IRQ_ENABLE);
  934. for (i = 0; i < 32; ++i)
  935. if (i != vias->intrs[0].line && (save_irqen & (1 << i)))
  936. disable_irq(i);
  937. asm volatile("mtdec %0" : : "r" (0x7fffffff));
  939. /* Save the state of PCI config space for some slots */
  940. pbook_pci_save();
  942. /* Set the memory controller to keep the memory refreshed
  943.    while we're asleep */
  944. for (i = 0x403f; i >= 0x4000; --i) {
  945. out_be32(MEM_CTRL, i);
  946. do {
  947. x = (in_be32(MEM_CTRL) >> 16) & 0x3ff;
  948. } while (x == 0);
  949. if (x >= 0x100)
  950. break;
  951. }
  953. /* Ask the PMU to put us to sleep */
  954. pmu_request(&sleep_req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
  955. while (!sleep_req.complete)
  956. mb();
  957. /* displacement-flush the L2 cache - necessary? */
  958. for (p = KERNELBASE; p < KERNELBASE + 0x100000; p += 0x1000)
  959. i = *(volatile int *)p;
  960. asleep = 1;
  962. /* Put the CPU into sleep mode */
  963. asm volatile("mfspr %0,1008" : "=r" (hid0) :);
  964. hid0 = (hid0 & ~(HID0_NAP | HID0_DOZE)) | HID0_SLEEP;
  965. asm volatile("mtspr 1008,%0" : : "r" (hid0));
  966. save_flags(msr);
  967. msr |= MSR_POW | MSR_EE;
  968. restore_flags(msr);
  969. udelay(10);
  971. /* OK, we're awake again, start restoring things */
  972. out_be32(MEM_CTRL, 0x3f);
  973. pbook_pci_restore();
  975. /* wait for the PMU interrupt sequence to complete */
  976. while (asleep)
  977. mb();
  979. /* reenable interrupts */
  980. for (i = 0; i < 32; ++i)
  981. if (i != vias->intrs[0].line && (save_irqen & (1 << i)))
  982. enable_irq(i);
  984. /* Notify drivers */
  985. notifier_call_chain(&sleep_notifier_list, PBOOK_WAKE, NULL);
  987. /* reenable ADB autopoll */
  988. pmu_adb_autopoll(adb_dev_map);
  990. /* Turn on the screen backlight, if it was on before */
  991. if (save_backlight)
  992. pmu_enable_backlight(1);
  994. /* Wait for the hard disk to spin up */
  996. return 0;
  997. }
  999. /*
  1000.  * Support for /dev/pmu device
  1001.  */
  1002. static int __openfirmware pmu_open(struct inode *inode, struct file *file)
  1003. {
  1004. return 0;
  1005. }
  1007. static ssize_t __openfirmware pmu_read(struct file *file, char *buf,
  1008. size_t count, loff_t *ppos)
  1009. {
  1010. return 0;
  1011. }
  1013. static ssize_t __openfirmware pmu_write(struct file *file, const char *buf,
  1014.  size_t count, loff_t *ppos)
  1015. {
  1016. return 0;
  1017. }
  1019. /* Note: removed __openfirmware here since it causes link errors */
  1020. static int /*__openfirmware*/ pmu_ioctl(struct inode * inode, struct file *filp,
  1021.      u_int cmd, u_long arg)
  1022. {
  1023. int error;
  1024. __u32 value;
  1026. switch (cmd) {
  1027.     case PMU_IOC_SLEEP:
  1028.      return -ENOSYS;
  1029.     case PMU_IOC_GET_BACKLIGHT:
  1030. return put_user(backlight_level, (__u32 *)arg);
  1031.     case PMU_IOC_SET_BACKLIGHT:
  1032. error = get_user(value, (__u32 *)arg);
  1033. if (!error)
  1034. pmu_set_brightness(value);
  1035. return error;
  1036.     case PMU_IOC_GET_MODEL:
  1037.      return put_user(pmu_kind, (__u32 *)arg);
  1038. }
  1039. return -EINVAL;
  1040. }
  1042. static struct file_operations pmu_device_fops = {
  1043. read: pmu_read,
  1044. write: pmu_write,
  1045. ioctl: pmu_ioctl,
  1046. open: pmu_open,
  1047. };
  1049. static struct miscdevice pmu_device = {
  1050. PMU_MINOR, "pmu", &pmu_device_fops
  1051. };
  1053. void pmu_device_init(void)
  1054. {
  1055. if (via)
  1056. misc_register(&pmu_device);
  1057. }
  1058. #endif /* CONFIG_PMAC_PBOOK */