Lines Matching refs:req

197 static int pmu_send_request(struct adb_request *req, int sync);
231 int pmu_polled_request(struct adb_request *req);
573 struct adb_request req;
579 pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
581 while (!req.complete) {
606 pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
607 while (!req.complete)
612 pmu_request(&req, NULL, 1, PMU_GET_VERSION);
613 pmu_wait_complete(&req);
614 if (req.reply_len > 0)
615 pmu_version = req.reply[0];
619 pmu_request(&req, NULL, 2, PMU_POWER_EVENTS,
621 pmu_wait_complete(&req);
622 if (req.reply_len == 2) {
623 if (req.reply[1] & PMU_PWR_WAKEUP_AC_INSERT)
644 struct adb_request req;
650 pmu_request(&req, NULL, 2, PMU_POWER_EVENTS, PMU_PWR_GET_POWERUP_EVENTS);
651 pmu_wait_complete(&req);
652 if (req.reply_len < 2)
655 pmu_request(&req, NULL, 4, PMU_POWER_EVENTS,
657 req.reply[0], PMU_PWR_WAKEUP_AC_INSERT);
659 pmu_request(&req, NULL, 4, PMU_POWER_EVENTS,
661 req.reply[0], PMU_PWR_WAKEUP_AC_INSERT);
662 pmu_wait_complete(&req);
669 done_battery_state_ohare(struct adb_request* req)
697 if (req->reply[0] & 0x01)
714 if (req->reply[0] & 0x04) {
716 if (req->reply[0] & 0x02)
718 vb = (req->reply[1] << 8) | req->reply[2];
720 amperage = req->reply[5];
721 if ((req->reply[0] & 0x01) == 0) {
724 } else if (req->reply[0] & 0x02) {
729 if (req->reply[0] & 0x40) {
730 pcharge = (req->reply[6] << 8) + req->reply[7];
759 done_battery_state_smart(struct adb_request* req)
784 if (req->reply[1] & 0x01)
792 if (req->reply[1] & 0x04) {
794 switch(req->reply[0]) {
796 case 4: capa = req->reply[2];
797 max = req->reply[3];
798 amperage = *((signed char *)&req->reply[4]);
799 voltage = req->reply[5];
801 case 5: capa = (req->reply[2] << 8) | req->reply[3];
802 max = (req->reply[4] << 8) | req->reply[5];
803 amperage = *((signed short *)&req->reply[6]);
804 voltage = (req->reply[8] << 8) | req->reply[9];
808 "len: %d, %4ph\n", req->reply_len,
809 req->reply);
814 if ((req->reply[1] & 0x01) && (amperage > 0))
823 if ((req->reply[1] & 0x01) && (amperage > 0))
975 static int pmu_send_request(struct adb_request *req, int sync)
980 req->complete = 1;
986 switch (req->data[0]) {
988 for (i = 0; i < req->nbytes - 1; ++i)
989 req->data[i] = req->data[i+1];
990 --req->nbytes;
991 if (pmu_data_len[req->data[0]][1] != 0) {
992 req->reply[0] = ADB_RET_OK;
993 req->reply_len = 1;
995 req->reply_len = 0;
996 ret = pmu_queue_request(req);
999 switch (req->data[1]) {
1001 if (req->nbytes != 2)
1003 req->data[0] = PMU_READ_RTC;
1004 req->nbytes = 1;
1005 req->reply_len = 3;
1006 req->reply[0] = CUDA_PACKET;
1007 req->reply[1] = 0;
1008 req->reply[2] = CUDA_GET_TIME;
1009 ret = pmu_queue_request(req);
1012 if (req->nbytes != 6)
1014 req->data[0] = PMU_SET_RTC;
1015 req->nbytes = 5;
1017 req->data[i] = req->data[i+1];
1018 req->reply_len = 3;
1019 req->reply[0] = CUDA_PACKET;
1020 req->reply[1] = 0;
1021 req->reply[2] = CUDA_SET_TIME;
1022 ret = pmu_queue_request(req);
1029 for (i = req->nbytes - 1; i > 1; --i)
1030 req->data[i+2] = req->data[i];
1031 req->data[3] = req->nbytes - 2;
1032 req->data[2] = pmu_adb_flags;
1033 /*req->data[1] = req->data[1];*/
1034 req->data[0] = PMU_ADB_CMD;
1035 req->nbytes += 2;
1036 req->reply_expected = 1;
1037 req->reply_len = 0;
1038 ret = pmu_queue_request(req);
1042 req->complete = 1;
1047 while (!req->complete)
1056 struct adb_request req;
1059 pmu_request(&req, NULL, 5, PMU_ADB_CMD, 0, 0x86,
1063 pmu_request(&req, NULL, 1, PMU_ADB_POLL_OFF);
1066 while (!req.complete)
1083 struct adb_request req;
1092 req.nbytes = 4;
1093 req.done = NULL;
1094 req.data[0] = PMU_ADB_CMD;
1095 req.data[1] = ADB_BUSRESET;
1096 req.data[2] = 0;
1097 req.data[3] = 0;
1098 req.data[4] = 0;
1099 req.reply_len = 0;
1100 req.reply_expected = 1;
1101 if (pmu_queue_request(&req) != 0) {
1105 pmu_wait_complete(&req);
1116 pmu_request(struct adb_request *req, void (*done)(struct adb_request *),
1127 req->complete = 1;
1130 req->nbytes = nbytes;
1131 req->done = done;
1134 req->data[i] = va_arg(list, int);
1136 req->reply_len = 0;
1137 req->reply_expected = 0;
1138 return pmu_queue_request(req);
1142 pmu_queue_request(struct adb_request *req)
1148 req->complete = 1;
1151 if (req->nbytes <= 0) {
1152 req->complete = 1;
1155 nsend = pmu_data_len[req->data[0]][0];
1156 if (nsend >= 0 && req->nbytes != nsend + 1) {
1157 req->complete = 1;
1161 req->next = NULL;
1162 req->sent = 0;
1163 req->complete = 0;
1167 last_req->next = req;
1168 last_req = req;
1170 current_req = req;
1171 last_req = req;
1217 pmu_done(struct adb_request *req)
1219 void (*done)(struct adb_request *) = req->done;
1221 req->complete = 1;
1223 * struct request will survive to setting req->complete to 1
1226 (*done)(req);
1232 struct adb_request *req;
1236 req = current_req;
1237 if (!req || pmu_state != idle
1238 || (/*req->reply_expected && */req_awaiting_reply))
1243 data_len = pmu_data_len[req->data[0]][0];
1250 send_byte(req->data[0]);
1279 pmu_wait_complete(struct adb_request *req)
1283 while((pmu_state != idle && pmu_state != locked) || !req->complete)
1391 struct adb_request *req = req_awaiting_reply;
1392 if (!req) {
1398 req->reply_len = 0;
1400 memcpy(req->reply, data + 1, len - 1);
1401 req->reply_len = len - 1;
1403 pmu_done(req);
1469 struct adb_request *req;
1490 req = current_req;
1492 data_len = req->nbytes - 1;
1497 send_byte(req->data[data_index++]);
1500 req->sent = 1;
1501 data_len = pmu_data_len[req->data[0]][1];
1504 current_req = req->next;
1505 if (req->reply_expected)
1506 req_awaiting_reply = req;
1508 return req;
1512 reply_ptr = req->reply + req->reply_len;
1548 req = current_req;
1554 current_req = req->next;
1555 req->reply_len += data_index;
1556 if (req->data[0] == PMU_SLEEP || req->data[0] == PMU_CPU_SPEED)
1560 return req;
1578 struct adb_request *req = NULL;
1619 req = pmu_sr_intr();
1620 if (req)
1661 if (req) {
1662 pmu_done(req);
1663 req = NULL;
1715 struct adb_request req;
1722 pmu_request(&req, NULL, 2, PMU_POWER_CTRL, PMU_POW_IRLED |
1724 pmu_wait_complete(&req);
1732 struct adb_request req;
1735 if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
1737 pmu_wait_complete(&req);
1738 if (req.reply_len != 4)
1739 pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
1740 now = (req.reply[0] << 24) + (req.reply[1] << 16) +
1741 (req.reply[2] << 8) + req.reply[3];
1748 struct adb_request req;
1751 if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
1754 pmu_wait_complete(&req);
1755 if (req.reply_len != 0)
1756 pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
1763 struct adb_request req;
1773 pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB |
1775 while(!req.complete)
1779 pmu_request(&req, NULL, 1, PMU_RESET);
1780 pmu_wait_complete(&req);
1788 struct adb_request req;
1798 pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB |
1800 pmu_wait_complete(&req);
1808 pmu_request(&req, NULL, 5, PMU_SHUTDOWN,
1810 pmu_wait_complete(&req);
1866 struct adb_request req;
1874 pmu_request(&req, NULL, 2, PMU_POWER_CTRL0, PMU_POW0_OFF|PMU_POW0_HARD_DRIVE);
1875 pmu_wait_complete(&req);
1876 pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
1878 pmu_wait_complete(&req);
1885 pmu_request(&req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
1886 pmu_wait_complete(&req);
1926 pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
1927 pmu_wait_complete(&req);
1928 pmu_request(&req, NULL, 2, PMU_POWER_CTRL0,
1930 pmu_wait_complete(&req);
1931 pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
1933 pmu_wait_complete(&req);
1943 struct adb_request req;
1954 pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, 0);
1955 pmu_wait_complete(&req);
1958 pmu_request(&req, NULL, 4, PMU_POWER_EVENTS, PMU_PWR_CLR_WAKEUP_EVENTS,
1960 pmu_wait_complete(&req);
1961 pmu_request(&req, NULL, 4, PMU_POWER_EVENTS, PMU_PWR_SET_WAKEUP_EVENTS,
1964 pmu_wait_complete(&req);
1972 pmu_request(&req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
1973 pmu_wait_complete(&req);
2015 pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
2016 pmu_wait_complete(&req);
2017 pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
2018 pmu_wait_complete(&req);
2527 pmu_polled_request(struct adb_request *req)
2532 req->complete = 1;
2533 c = req->data[0];
2535 if (l >= 0 && req->nbytes != l + 1)
2546 l = req->nbytes - 1;
2550 polled_send_byte(req->data[i]);
2556 req->reply[i + req->reply_len] = polled_recv_byte();
2558 if (req->done)
2559 (*req->done)(req);
2568 struct adb_request req;
2570 memset(&req, 0, sizeof(req));
2573 req.nbytes = 4;
2574 req.done = NULL;
2575 req.data[0] = 0xee;
2576 req.data[1] = 4;
2577 req.data[2] = 0;
2578 req.data[3] = 1;
2579 req.reply[0] = ADB_RET_OK;
2580 req.reply_len = 1;
2581 req.reply_expected = 0;
2582 pmu_polled_request(&req);
2584 req.nbytes = 4;
2585 req.done = NULL;
2586 req.data[0] = 0xee;
2587 req.data[1] = 4;
2588 req.data[2] = 0;
2589 req.data[3] = 0;
2590 req.reply[0] = ADB_RET_OK;
2591 req.reply_len = 1;
2592 req.reply_expected = 0;
2593 pmu_polled_request(&req);
2619 struct adb_request req;
2625 pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
2626 pmu_wait_complete(&req);