| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <ctype.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <getopt.h> |
| #include <signal.h> |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| /* From Nugget OS */ |
| #include <application.h> |
| #include <app_nugget.h> |
| |
| #include <nos/device.h> |
| #include <nos/transport.h> |
| |
| /* Our connection to Citadel */ |
| static struct nos_device dev; |
| |
| /* Our big transfer buffer. Apps may have smaller size limits. */ |
| static uint8_t buf[0x4000]; |
| |
| enum { |
| BOARD_BINDER, |
| BOARD_PROTO1, |
| BOARD_EVT, |
| }; |
| |
| /* Global options */ |
| static struct option_s { |
| /* program-specific options */ |
| uint8_t app_id; |
| uint16_t param; |
| int more; |
| int ascii; |
| int binary; |
| int verbose; |
| int buttons; |
| int board; |
| /* generic connection options */ |
| const char *device; |
| } option = { |
| .board = BOARD_EVT, |
| }; |
| |
| enum no_short_opts_for_these { |
| OPT_DEVICE = 1000, |
| OPT_BUTTONS, |
| OPT_BINDER, |
| OPT_PROTO1, |
| OPT_EVT, |
| }; |
| |
| static char *short_opts = ":hi:p:m:abv"; |
| static const struct option long_opts[] = { |
| /* name hasarg *flag val */ |
| {"id", 1, NULL, 'i'}, |
| {"param", 1, NULL, 'p'}, |
| {"more", 1, NULL, 'm'}, |
| {"ascii", 0, NULL, 'a'}, |
| {"binary", 0, NULL, 'b'}, |
| {"verbose", 0, NULL, 'v'}, |
| {"buttons", 0, NULL, OPT_BUTTONS}, |
| {"binder", 0, &option.board, BOARD_BINDER}, |
| {"proto1", 0, &option.board, BOARD_PROTO1}, |
| {"evt", 0, &option.board, BOARD_EVT}, |
| {"device", 1, NULL, OPT_DEVICE}, |
| {"help", 0, NULL, 'h'}, |
| {NULL, 0, NULL, 0}, |
| }; |
| |
| static void usage(const char *progname) |
| { |
| fprintf(stderr, "\n"); |
| fprintf(stderr, "Usage: %s\n" |
| "Usage: %s test\n\n" |
| " Quick test to see if Citadel is responsive\n" |
| "\n" |
| " Options:\n" |
| " --buttons Prompt to press buttons\n" |
| " --binder | --proto1 | --evt Specify the board\n\n", |
| progname, progname); |
| fprintf(stderr, "Usage: %s tpm COMMAND [BYTE ...]\n" |
| "\n" |
| " Transmit the COMMAND and possibly any BYTEs using the\n" |
| " TPM Wait mode driver. COMMAND and BYTEs are hex values.\n" |
| "\n" |
| " Options:\n" |
| " -m, --more NUM Exchange NUM additional bytes\n\n", |
| progname); |
| fprintf(stderr, "Usage: %s app [BYTE [BYTE...]]\n" |
| "\n" |
| " Call an application function, passing any BYTEs as args\n" |
| "\n" |
| " Options:\n" |
| " -i --id HEX App ID (default 0x00)\n" |
| " -p, --param HEX Set the command Param field to HEX" |
| " (default 0x0000)\n\n", |
| progname); |
| fprintf(stderr, "Usage: %s rw ADDRESS [VALUE]\n" |
| "\n" |
| " Read or write a memory address on Citadel. Both ADDRESS\n" |
| " and VALUE are 32-bit hex numbers.\n\n", |
| progname); |
| fprintf(stderr, "Common options:\n\n" |
| " -a, --ascii Print response as ASCII string\n" |
| " -b, --binary Dump binary response to stdout\n" |
| " -v, --verbose Increase verbosity. More is noisier\n" |
| " --device PATH spidev device file to open\n" |
| " -h, --help Show this message\n" |
| "\n\n"); |
| } |
| |
| /****************************************************************************/ |
| /* Handy stuff */ |
| |
| #ifndef MIN |
| #define MIN(a, b) ((a) < (b) ? (a) : (b)) |
| #endif |
| |
| static int errorcnt; |
| static void Error(const char *format, ...) |
| { |
| va_list ap; |
| |
| va_start(ap, format); |
| fprintf(stderr, "ERROR: "); |
| vfprintf(stderr, format, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| |
| errorcnt++; |
| } |
| |
| static void debug(int lvl, const char *format, ...) |
| { |
| va_list ap; |
| |
| if (lvl > option.verbose) |
| return; |
| |
| va_start(ap, format); |
| vfprintf(stderr, format, ap); |
| va_end(ap); |
| } |
| |
| static void debug_buf(int lvl, uint8_t *buf, int bufsize) |
| { |
| int i; |
| |
| if (lvl > option.verbose) |
| return; |
| |
| if (bufsize <= 0) |
| return; |
| |
| if (option.binary) { |
| fwrite(buf, bufsize, 1, stdout); |
| return; |
| } |
| |
| if (option.ascii) { |
| for (i = 0; i < bufsize; i++) |
| printf("%c", isprint(buf[i]) ? buf[i] : '.'); |
| printf("\n"); |
| return; |
| } |
| |
| for (i = 0; i < bufsize;) { |
| if (!(i % 16)) |
| printf("0x%06x: ", i); |
| printf(" %02x", buf[i]); |
| i++; |
| if (!(i % 16)) |
| printf("\n"); |
| } |
| if (i % 16) |
| printf("\n"); |
| } |
| |
| static void debug_retval(int lvl, uint32_t retval, uint32_t replycount) |
| { |
| if (lvl > option.verbose) |
| return; |
| |
| printf("retval 0x%08x (", retval); |
| switch (retval) { |
| case APP_SUCCESS: |
| printf("success"); |
| break; |
| case APP_ERROR_BOGUS_ARGS: |
| printf("bogus args"); |
| break; |
| case APP_ERROR_INTERNAL: |
| printf("app is being stupid"); |
| break; |
| case APP_ERROR_TOO_MUCH: |
| printf("caller sent too much data"); |
| break; |
| default: |
| if (retval >= APP_SPECIFIC_ERROR && retval < APP_LINE_NUMBER_BASE) |
| printf("app-specific error #%d", retval - APP_SPECIFIC_ERROR); |
| else if (retval >= APP_LINE_NUMBER_BASE) |
| printf("error at line %d", retval - APP_LINE_NUMBER_BASE); |
| else |
| printf("unknown"); |
| } |
| printf("), replycount 0x%x (%d)\n", replycount, replycount); |
| } |
| |
| /****************************************************************************/ |
| /* Functionality */ |
| |
| static void do_tpm(int argc, char *argv[]) |
| { |
| char *e = 0; |
| int i, rv, argcount, optind = 1; |
| uint32_t command, buflen; |
| |
| /* Must have a command */ |
| if (optind < argc) { |
| command = strtoul(argv[optind], &e, 16); |
| if (e && *e) |
| Error("%s: Invalid COMMAND: \"%s\"", argv[0], argv[optind]); |
| optind++; |
| } else { |
| Error("%s: Missing required COMMAND", argv[0]); |
| return; |
| } |
| |
| /* how many bytes to exchange? */ |
| argcount = argc - optind; |
| |
| buflen = option.more + argcount; |
| if (buflen > MAX_DEVICE_TRANSFER) { |
| Error("%s: Too much to send", argv[0]); |
| return; |
| } |
| |
| /* preload BYTEs from command line */ |
| for (i = 0; i < argcount; i++) { |
| buf[i] = 0xff & strtoul(argv[optind], &e, 16); |
| if (e && *e) { |
| Error("%s: Invalid byte value: \"%s\"", argv[0], argv[optind]); |
| return; |
| } |
| optind++; |
| } |
| |
| /* Okay, let's do something */ |
| debug(1, "Command 0x%08x, buflen 0x%x\n", command, buflen); |
| |
| if (command & 0x80000000) |
| rv = dev.ops.read(dev.ctx, command, buf, buflen); |
| else |
| rv = dev.ops.write(dev.ctx, command, buf, buflen); |
| |
| if (rv != 0) |
| Error("%s: nuts", argv[0]); |
| else if (command & 0x80000000) |
| debug_buf(0, buf, buflen); |
| } |
| |
| static void do_app(int argc, char *argv[]) |
| { |
| char *e = 0; |
| int optind = 1; |
| uint32_t i, buflen, replycount, retval; |
| |
| /* preload BYTEs from command line */ |
| buflen = argc - optind; |
| for (i = 0; i < buflen; i++) { |
| buf[i] = 0xff & strtoul(argv[optind], &e, 16); |
| if (e && *e) { |
| Error("%s: Invalid byte value: \"%s\"", argv[0], argv[optind]); |
| return; |
| } |
| optind++; |
| } |
| |
| debug(1, "AppID 0x%02x, App param 0x%04x, buflen 0x%x\n", |
| option.app_id, option.param, buflen); |
| |
| replycount = sizeof(buf); |
| retval = nos_call_application(&dev, option.app_id, option.param, |
| buf, buflen, buf, &replycount); |
| debug_retval(1, retval, replycount); |
| debug_buf(0, buf, replycount); |
| } |
| |
| /****************************************************************************/ |
| /* Available for bringup/debug only. See b/65067435 */ |
| |
| static uint32_t read32(uint32_t address, uint32_t *valptr) |
| { |
| uint32_t buflen, replycount, retval; |
| |
| debug(2, "read from 0x%08x\n", address); |
| buflen = sizeof(address); |
| memcpy(buf, &address, buflen); |
| replycount = sizeof(buf); |
| retval = nos_call_application(&dev, APP_ID_NUGGET, NUGGET_PARAM_READ32, |
| buf, buflen, buf, &replycount); |
| debug_retval(2, retval, replycount); |
| if (replycount == sizeof(*valptr)) { |
| memcpy(valptr, buf, sizeof(*valptr)); |
| debug(2, "value is 0x%08x\n", *valptr); |
| } |
| |
| return retval; |
| } |
| |
| static uint32_t write32(uint32_t address, uint32_t value) |
| { |
| uint32_t buflen, replycount, retval; |
| struct nugget_app_write32 w32; |
| |
| /* Writing to address */ |
| debug(2, "write to 0x%08x with value 0x%08x\n", address, value); |
| w32.address = address; |
| w32.value = value; |
| buflen = sizeof(w32); |
| memcpy(buf, &w32, buflen); |
| replycount = sizeof(buf); |
| retval = nos_call_application(&dev, APP_ID_NUGGET, NUGGET_PARAM_WRITE32, |
| buf, buflen, buf, &replycount); |
| debug_retval(2, retval, replycount); |
| |
| return retval; |
| } |
| |
| static void do_rw(int argc, char *argv[]) |
| { |
| char *e = 0; |
| uint32_t retval, address, value; |
| |
| argc = MIN(argc, 3); /* ignore any extra args */ |
| switch (argc) { |
| case 3: |
| value = strtoul(argv[2], &e, 16); |
| if (e && *e) { |
| Error("%s: Invalid value: \"%s\"", argv[0], argv[2]); |
| return; |
| } |
| /* fall through */ |
| case 2: |
| address = strtoul(argv[1], &e, 16); |
| if (e && *e) { |
| Error("%s: Invalid address: \"%s\"", argv[0], argv[1]); |
| return; |
| } |
| break; |
| default: |
| Error("%s: Missing required address", argv[0]); |
| return; |
| } |
| |
| if (argc == 2) { |
| retval = read32(address, &value); |
| if (APP_SUCCESS != retval) |
| Error("%s: Read failed", argv[0]); |
| else |
| printf("0x%08x\n", value); |
| } else { |
| retval = write32(address, value); |
| if (APP_SUCCESS != retval) |
| Error("%s: Write failed", argv[0]); |
| } |
| } |
| |
| /****************************************************************************/ |
| /* |
| * This stuff is a quick dead-or-alive test for SMT. We assume that the Citadel |
| * chip itself will work because it's passed its own manufacturing tests, but |
| * we need to know that the chip is powered up and the SPI bus and GPIOs are |
| * working. UART passthrough will have to be tested externally. |
| */ |
| |
| /* ARM GPIO config registers */ |
| #define GPIO_DATA 0x40550000 |
| #define GPIO_DATAOUT 0x40550004 |
| #define GPIO_OUTENSET 0x40550010 |
| |
| /* Return true on success */ |
| static int write_to_file(const char *filename, const char *string) |
| { |
| int fd, rv; |
| ssize_t len, num; |
| |
| /* Assume valid input */ |
| len = strlen(string); |
| |
| fd = open(filename, O_WRONLY | O_SYNC); |
| if (fd < 0) { |
| debug(1, "can't open %s for writing: %s", filename, strerror(errno)); |
| return 0; |
| } |
| |
| num = write(fd, string, len); |
| |
| debug(2, "%s(%s, %s) wrote %d / %d\n", __func__, filename, string, num, len); |
| |
| if (len != num) { |
| debug(1, "can't write %d bytes to %s: %s", len, filename, |
| strerror(errno)); |
| rv = close(fd); |
| if (rv) |
| debug(1, "can't close the file descriptor either: %s", |
| strerror(errno)); |
| return 0; |
| } |
| |
| rv = close(fd); |
| if (rv) { |
| debug(1, "can't close the file descriptor for %s: %s", |
| filename, strerror(errno)); |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| /* Return true on success */ |
| static int read_from_file(const char *filename, char *buf, ssize_t bufsize) |
| { |
| int fd, rv; |
| ssize_t num; |
| |
| fd = open(filename, O_RDONLY); |
| if (fd < 0) { |
| debug(2, "can't open %s for reading: %s", filename, strerror(errno)); |
| return 0; |
| } |
| |
| num = read(fd, buf, bufsize - 1); /* leave room for '\0' */ |
| |
| debug(2, "%s(%s) read %d bytes\n", __func__, filename, num); |
| |
| if (num < 0) { |
| debug(1, "can't read from %s: %s", filename, strerror(errno)); |
| rv = close(fd); |
| if (rv) |
| debug(1, "can't close the file descriptor either: %s", |
| strerror(errno)); |
| return 0; |
| } |
| |
| if (num == 0) { |
| debug(1, "file %s contains no data", filename); |
| rv = close(fd); |
| if (rv) |
| debug(1, "can't close the file descriptor either: %s", |
| strerror(errno)); |
| return 0; |
| |
| } |
| |
| debug_buf(2, (unsigned char *)buf, num); |
| |
| rv = close(fd); |
| if (rv) |
| debug(1, "can't close the file descriptor for %s: %s", |
| filename, strerror(errno)); |
| |
| return 1; |
| } |
| |
| /* Returns true if we're able to export this gpio */ |
| static int is_ap_exported(uint32_t num) |
| { |
| char filename[80]; |
| char buf[80]; |
| |
| debug(1, "%s(%d)\n", __func__, num); |
| |
| /* It might already be exported. Try to read the value to see. */ |
| sprintf(filename, "/sys/class/gpio/gpio%d/value", num); |
| memset(buf, 0, sizeof(buf)); |
| if (read_from_file(filename, buf, sizeof(buf))) |
| return 1; /* yep */ |
| |
| /* Request it */ |
| sprintf(buf, "%d", num); |
| if (!write_to_file("/sys/class/gpio/export", buf)) { |
| Error("%s: Can't request export of gpio %d", __func__, num); |
| return 0; |
| } |
| |
| /* Try reading the value again */ |
| memset(buf, 0, sizeof(buf)); |
| if (read_from_file(filename, buf, sizeof(buf))) |
| return 1; /* yep */ |
| |
| Error("%s: Nuts. Can't get export of gpio %d", __func__, num); |
| return 0; |
| } |
| |
| /* Returns true if we're able to set this gpio to an output */ |
| static int is_ap_output(uint32_t num) |
| { |
| char filename[80]; |
| char buf[80]; |
| |
| debug(1, "%s(%d)\n", __func__, num); |
| |
| /* It might already be an output. Let's see. */ |
| sprintf(filename, "/sys/class/gpio/gpio%d/direction", num); |
| memset(buf, 0, sizeof(buf)); |
| if (!read_from_file(filename, buf, sizeof(buf))) { |
| debug(1, "Can't determine the direction of gpio %d", num); |
| return 0; |
| } |
| if (!strncmp("out", buf, 3)) |
| return 1; /* already an output */ |
| |
| /* Set the direction */ |
| sprintf(buf, "%s", "out"); |
| if (!write_to_file(filename, buf)) { |
| Error("%s: Can't set the direction of gpio %d", __func__, num); |
| return 0; |
| } |
| |
| /* Check again */ |
| memset(buf, 0, sizeof(buf)); |
| if (!read_from_file(filename, buf, sizeof(buf))) { |
| Error("%s: Can't determine the direction of gpio %d", __func__, num); |
| return 0; |
| } |
| if (!strncmp("out", buf, 3)) |
| return 1; /* yep, it's an output */ |
| |
| Error("%s: Nuts. Can't set the direction of gpio %d", __func__, num); |
| return 0; |
| } |
| |
| /* Return true on success */ |
| static int set_ap_value(uint32_t num, int val) |
| { |
| char filename[80]; |
| char buf[80]; |
| |
| debug(1, "%s(%d, %d)\n", __func__, num, val); |
| |
| sprintf(filename, "/sys/class/gpio/gpio%d/value", num); |
| sprintf(buf, "%d", val); |
| if (!write_to_file(filename, buf)) { |
| Error("%s: can't set gpio %d to %d", __func__, num, val); |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| /* This wiggles a GPIO on the AP and checks to make sure Citadel saw it */ |
| static void ap_wiggle(const char *name, uint32_t cit_gpio, uint32_t ap_gpio) |
| { |
| uint32_t prev, curr; |
| uint32_t cit_bit; |
| |
| cit_bit = (1 << cit_gpio); |
| |
| printf("Test %s AP gpio %d => Citadel gpio %d\n", name, ap_gpio, cit_gpio); |
| |
| /* Configure AP for output */ |
| if (!is_ap_exported(ap_gpio)) |
| return; |
| if (!is_ap_output(ap_gpio)) |
| return; |
| |
| debug(1, "cit_bit 0x%08x\n", cit_bit); |
| |
| /* drive low, confirm low */ |
| if (!set_ap_value(ap_gpio, 0)) |
| return; |
| if (0 != read32(GPIO_DATA, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| debug(1, "citadel 0x%08x\n", curr); |
| if (curr & cit_bit) |
| Error("%s: expected cit_gpio %d low, was high", __func__, cit_gpio); |
| prev = curr; |
| |
| /* Drive high, confirm high, no other bits changed */ |
| if (!set_ap_value(ap_gpio, 1)) |
| return; |
| if (0 != read32(GPIO_DATA, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| debug(1, "citadel 0x%08x\n", curr); |
| if (!(curr & cit_bit)) |
| Error("expected cit_gpio %d high, was low", cit_gpio); |
| if (prev != curr && (prev ^ curr) != cit_bit) |
| Error("unexpected GPIO change: prev 0x%08x cur 0x%08x", prev, curr); |
| prev = curr; |
| |
| /* Drive Low, confirm low again, no other bits changed */ |
| if (!set_ap_value(ap_gpio, 0)) |
| return; |
| if (0 != read32(GPIO_DATA, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| debug(1, "citadel 0x%08x\n", curr); |
| if (curr & cit_bit) |
| Error("expected cit_gpio %d low, was high", cit_gpio); |
| if (prev != curr && (prev ^ curr) != cit_bit) |
| Error("unexpected GPIO change: prev 0x%08x cur 0x%08x", prev, curr); |
| } |
| |
| static int stopped; |
| static void sig_handler(int sig) |
| { |
| stopped = 1; |
| printf("Signal %d recognized\n", sig); |
| } |
| |
| /* This prompts the user to push a button and waits for Citadel to see it */ |
| static void phys_wiggle(uint32_t cit_gpio, const char *button) |
| { |
| uint32_t prev, curr; |
| uint32_t cit_bit; |
| |
| stopped = 0; |
| signal(SIGINT, sig_handler); |
| |
| cit_bit = (1 << cit_gpio); |
| |
| debug(1, "%s(%d) cit_bit 0x%08x\n", __func__, cit_gpio, cit_bit); |
| |
| /* read initial value */ |
| if (0 != read32(GPIO_DATA, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| debug(1, "initial value 0x%08x\n", curr); |
| prev = curr; |
| |
| printf("\nPlease PRESS the %s button...\n", button); |
| do { |
| usleep(100 * 1000); |
| if (0 != read32(GPIO_DATA, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| } while (prev == curr && !stopped); |
| debug(1, "new value 0x%08x\n", curr); |
| if ((prev ^ curr) != cit_bit) |
| Error("%s: multiple cit_gpios changed: prev 0x%08x cur 0x%08x", |
| __func__, prev, curr); |
| prev = curr; |
| |
| printf("Please RELEASE the %s button...\n", button); |
| do { |
| usleep(100 * 1000); |
| if (0 != read32(GPIO_DATA, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| } while (prev == curr && !stopped); |
| debug(1, "new value 0x%08x\n", curr); |
| if ((prev ^ curr) != cit_bit) |
| Error("%s: multiple cit_gpios changed: prev 0x%08x cur 0x%08x", |
| __func__, prev, curr); |
| |
| signal(SIGINT, SIG_DFL); |
| } |
| |
| /* How long to wait for an interrupt to trigger (msecs) */ |
| #define INTERRUPT_TIMEOUT 100 |
| |
| /* Make Citadel wiggle its CTDL_AP_IRQ output, which we should notice */ |
| static void cit_interrupt(const char *name, uint32_t cit_gpio) |
| { |
| uint32_t curr; |
| uint32_t cit_bit; |
| int rv; |
| |
| printf("Test %s Citadel gpio %d => AP kernel driver\n", name, cit_gpio); |
| |
| cit_bit = (1 << cit_gpio); |
| |
| debug(1, "%s(%s, %d) cit_bit 0x%08x\n", __func__, name, cit_gpio, cit_bit); |
| |
| /* First, let's see what Citadel is driving */ |
| if (0 != read32(GPIO_DATAOUT, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| |
| debug(1, "initial value 0x%08x\n", curr); |
| if (curr & cit_bit) { |
| /* Citadel is already driving it, so we should see it immediately */ |
| rv = dev.ops.wait_for_interrupt(dev.ctx, INTERRUPT_TIMEOUT); |
| if (rv > 1) { |
| debug(2, "CTDL_AP_IRQ is already asserted\n"); |
| } else { |
| Error("%s: CTDL_AP_IRQ is 1, but wait_for_interrupt() returned %d", |
| __func__, rv); |
| return; |
| } |
| |
| /* Tell Citadel to stop driving it */ |
| if (0 != write32(GPIO_DATAOUT, curr & (~cit_bit))) { |
| Error("%s: can't write Citadel GPIOs", __func__); |
| return; |
| } |
| |
| /* Make sure it obeyed */ |
| if (0 != read32(GPIO_DATAOUT, &curr)) { |
| Error("%s: can't read Citadel GPIOs", __func__); |
| return; |
| } |
| if (curr & cit_bit) { |
| Error("%s: Citadel isn't changing its GPIOs", __func__); |
| return; |
| } |
| } |
| |
| debug(1, "there should be no immediate interrupt\n"); |
| rv = dev.ops.wait_for_interrupt(dev.ctx, INTERRUPT_TIMEOUT); |
| if (rv == 0) { |
| debug(2, "CTDL_AP_IRQ not asserted and not triggered\n"); |
| } else { |
| Error("%s: CTDL_AP_IRQ is 0, but wait_for_interrupt() returned %d", |
| __func__, rv); |
| return; |
| } |
| |
| debug(1, "tell Citadel to trigger an interrupt\n"); |
| if (0 != write32(GPIO_DATAOUT, curr | cit_bit)) { |
| Error("%s: can't write Citadel GPIOs", __func__); |
| return; |
| } |
| |
| rv = dev.ops.wait_for_interrupt(dev.ctx, INTERRUPT_TIMEOUT); |
| if (rv > 0) { |
| debug(2, "CTDL_AP_IRQ is asserted and triggered\n"); |
| } else { |
| Error("%s: CTDL_AP_IRQ is 1, but wait_for_interrupt() returned %d", |
| __func__, rv); |
| return; |
| } |
| |
| /* Tell Citadel to stop driving it */ |
| if (0 != write32(GPIO_DATAOUT, curr & (~cit_bit))) { |
| Error("%s: can't write Citadel GPIOs", __func__); |
| return; |
| } |
| } |
| |
| static void do_test(void) |
| { |
| uint32_t retval, replycount, value; |
| int ctdl_ap_irq_is_driven = 0; |
| |
| /* Using the Transport API only. Nugget OS doesn't have any Datagram apps. */ |
| printf("Get version string...\n"); |
| replycount = sizeof(buf); |
| retval = nos_call_application(&dev, APP_ID_NUGGET, NUGGET_PARAM_VERSION, |
| buf, 0, buf, &replycount); |
| if (retval != 0) { |
| Error("Get version failed with 0x%08x", retval); |
| debug_retval(0, retval, replycount); |
| goto done; |
| } |
| if (replycount < 4 || replycount > 1024) |
| Error("Get version returned %d bytes, which seems wrong", replycount); |
| /* might be okay, though */ |
| debug_buf(1, buf, replycount); |
| |
| /* |
| * We want to drive each GPIO from the AP side and just check that |
| * Citadel can see it wiggle. Citadel treats them all as inputs for |
| * now. We'll have to update our tests when that changes, of course. |
| */ |
| |
| printf("Read GPIO direction\n"); |
| retval = read32(GPIO_OUTENSET, &value); |
| if (retval != 0) { |
| Error("Reading GPIO direction failed with 0x%08x", retval); |
| goto done; |
| } |
| switch (value) { |
| case 0x00000000: |
| debug(1, "Citadel's GPIOs are all inputs\n"); |
| break; |
| case 0x00000080: |
| debug(1, "Citadel is driving CTDL_AP_IRQ\n"); |
| ctdl_ap_irq_is_driven = 1; |
| break; |
| default: |
| /* This is unexpected, but keep going */ |
| Error("GPIO direction = 0x%08x\n", value); |
| } |
| |
| /* |
| * The MSM GPIOs have moved all around with each revision. |
| * |
| * Net Name Citadel Pin BINDER B1PROTO1 B1EVT1 |
| * |
| * CTDL_AP_IRQ DIOA5 7 96 96 129 |
| * AP_CTDL_IRQ DIOA11 6 94 94 135 |
| * AP_SEC_STATE DIOB7 4 76 76 76 |
| * AP_PWR_STATE DIOB8 5 69 69 69 |
| * CCD_CABLE_DET DIOA6 8 127 126 126 |
| */ |
| |
| if (ctdl_ap_irq_is_driven) { |
| /* Citadel should interrupt us */ |
| cit_interrupt("CTDL_AP_IRQ", 7); |
| } else { |
| /* We'll wiggle the AP's GPIO and make sure Citadel sees it */ |
| if (option.board == BOARD_EVT) |
| ap_wiggle("CTDL_AP_IRQ", 7, 129); |
| else |
| ap_wiggle("CTDL_AP_IRQ", 7, 96); |
| } |
| |
| if (option.board == BOARD_EVT) |
| ap_wiggle("AP_CTDL_IRQ", 6, 135); |
| else |
| ap_wiggle("AP_CTDL_IRQ", 6, 94); |
| |
| ap_wiggle("AP_SEC_STATE", 4, 76); |
| ap_wiggle("AP_PWR_STATE", 5, 69); |
| |
| if (option.board == BOARD_BINDER) |
| ap_wiggle("CCD_CABLE_DET", 8, 127); |
| else |
| ap_wiggle("CCD_CABLE_DET", 8, 126); |
| |
| /* |
| * Citadel should be able to drive all the physical buttons under |
| * certain circumstances, but I don't know how to confirm whether the |
| * AP sees them change. We'll have to prompt the user to poke them to |
| * verify the connectivity. That's probably tested elsewhere, though. |
| */ |
| if (option.buttons) { |
| |
| if (option.board != BOARD_PROTO1) |
| /* We had to cut this trace on proto1 (b/66976641) */ |
| phys_wiggle(0, "Power"); |
| |
| phys_wiggle(1, "Volume Down"); |
| phys_wiggle(2, "Volume Up"); |
| |
| if (option.board == BOARD_BINDER) |
| /* There's only a button on the binder board */ |
| phys_wiggle(10, "Forced USB Boot"); |
| } |
| |
| /* |
| * These are harder to test. We'll have to change the UART passthrough |
| * to access the Citadel console and do these manually: |
| * |
| * Citadel GPIO 3 MSM_RST_OUT_L should wiggle when the phone reboots |
| * Citadel GPIO 9 PM_MSM_RST_L should force the AP to reboot |
| */ |
| |
| done: |
| if (errorcnt) |
| printf("\nFAIL FAIL FAIL\n\n"); |
| else |
| printf("\nPASS PASS PASS\n\n"); |
| } |
| |
| /****************************************************************************/ |
| |
| /* |
| * Any SPI bus activity will wake Citadel from deep sleep, so we'll just send |
| * it a single bogus command. If Citadel's already awake, it will ignore it. |
| * We don't bother tracking or reporting errors. The test will report any real |
| * errors. |
| */ |
| #define IGNORED_COMMAND (CMD_ID(APP_ID_TEST) | CMD_PARAM(0xffff)) |
| static void poke_citadel(void) |
| { |
| int rv; |
| |
| rv = dev.ops.write(dev.ctx, IGNORED_COMMAND, 0, 0); |
| |
| /* If Citadel was asleep, give it some time to wake up */ |
| if (rv == -EAGAIN) |
| usleep(50000); |
| } |
| |
| |
| static int stopping_citadeld_fixed_it; |
| static int connect_to_citadel(void) |
| { |
| int rv = nos_device_open(option.device, &dev); |
| |
| if (rv == -EBUSY) { |
| /* Try stopping citadeld */ |
| debug(1, "citadel device is busy, stopping citadeld...\n"); |
| if (system("setprop ctl.stop vendor.citadeld") == 0) { |
| /* See if that helped */ |
| rv = nos_device_open(option.device, &dev); |
| if (rv == 0) { |
| debug(1, " okay, that worked\n"); |
| stopping_citadeld_fixed_it = 1; |
| return rv; |
| } else { |
| debug(1, " nope, didn't help\n"); |
| } |
| } else { |
| debug(1, " huh. couldn't stop it\n"); |
| } |
| } |
| |
| if (rv) |
| Error("Unable to connect to Citadel: %s", strerror(-rv)); |
| |
| return rv; |
| } |
| |
| static void disconnect_from_citadel(void) |
| { |
| dev.ops.close(dev.ctx); |
| if (stopping_citadeld_fixed_it) { |
| debug(1, "We stopped citadeld earlier, so start it up again\n"); |
| (void)system("setprop ctl.start vendor.citadeld"); |
| } |
| } |
| |
| int main(int argc, char *argv[]) |
| { |
| int i; |
| int idx = 0; |
| char *e = 0; |
| char *this_prog; |
| |
| this_prog= strrchr(argv[0], '/'); |
| if (this_prog) |
| this_prog++; |
| else |
| this_prog = argv[0]; |
| |
| opterr = 0; /* quiet, you */ |
| while ((i = getopt_long(argc, argv, short_opts, long_opts, &idx)) != -1) { |
| switch (i) { |
| /* program-specific options */ |
| case 'i': |
| option.app_id = (uint8_t)strtoul(optarg, &e, 16); |
| if (!*optarg || (e && *e)) |
| Error("Invalid argument: \"%s\"", optarg); |
| break; |
| case 'p': |
| option.param = (uint16_t)strtoul(optarg, &e, 16); |
| if (!*optarg || (e && *e)) |
| Error("Invalid argument: \"%s\"", optarg); |
| break; |
| case 'm': |
| option.more = (uint32_t)strtoul(optarg, &e, 0); |
| if (!*optarg || (e && *e) || option.more < 0) |
| Error("Invalid argument: \"%s\"", optarg); |
| break; |
| case 'a': |
| option.ascii = 1; |
| option.binary = 0; |
| break; |
| case 'b': |
| option.ascii = 0; |
| option.binary = 1; |
| break; |
| case 'v': |
| option.verbose++; |
| break; |
| case OPT_BUTTONS: |
| option.buttons = 1; |
| break; |
| |
| /* generic options below */ |
| case OPT_DEVICE: |
| option.device = optarg; |
| break; |
| case 'h': |
| usage(this_prog); |
| return 0; |
| case 0: |
| break; |
| case '?': |
| if (optopt) |
| Error("Unrecognized option: -%c", optopt); |
| else |
| Error("Unrecognized option: %s", argv[optind - 1]); |
| usage(this_prog); |
| break; |
| case ':': |
| Error("Missing argument to %s", argv[optind - 1]); |
| break; |
| default: |
| Error("Internal error at %s:%d", __FILE__, __LINE__); |
| exit(1); |
| } |
| } |
| |
| if (errorcnt) |
| return !!errorcnt; |
| |
| if (connect_to_citadel() != 0) |
| return !!errorcnt; |
| |
| /* Wake Citadel from deep sleep */ |
| poke_citadel(); |
| |
| /* |
| * We can freely intermingle options and args, so the function should |
| * be the first non-option. Try to pick it out if it exists. |
| */ |
| if (argc > optind) { |
| if (!strcmp("tpm", argv[optind])) |
| do_tpm(argc - optind, argv + optind); |
| else if (!strcmp("app", argv[optind])) |
| do_app(argc - optind, argv + optind); |
| else if (!strcmp("rw", argv[optind])) |
| do_rw(argc - optind, argv + optind); |
| else |
| do_test(); |
| /* |
| * "test" is the default function, but it doesn't take any args |
| * so anything not listed is just silently ignored. Too bad. |
| */ |
| } else { |
| do_test(); |
| } |
| |
| disconnect_from_citadel(); |
| return !!errorcnt; |
| } |
