Merge "Remove dead tools."
This commit is contained in:
Elliott Hughes
Gerrit Code Review
commit
f3c8eb838d
|
|
@ -215,11 +215,6 @@ LOCAL_SHARED_LIBRARIES := \
|
|||
libcutils \
|
||||
libselinux \
|
||||
|
||||
# libusbhost is only used by lsusb, and that isn't usually included in toolbox.
|
||||
# The linker strips out all the unused library code in the normal case.
|
||||
LOCAL_STATIC_LIBRARIES := \
|
||||
libusbhost \
|
||||
|
||||
LOCAL_WHOLE_STATIC_LIBRARIES := $(patsubst %,libtoolbox_%,$(BSD_TOOLS))
|
||||
|
||||
LOCAL_MODULE := toolbox
|
||||
|
|
|
|||
190
toolbox/alarm.c
190
toolbox/alarm.c
|
|
@ -1,190 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include <asm/ioctl.h>
|
||||
//#include <linux/rtc.h>
|
||||
#include <linux/android_alarm.h>
|
||||
|
||||
int alarm_main(int argc, char *argv[])
|
||||
{
|
||||
int c;
|
||||
int res;
|
||||
struct tm tm;
|
||||
time_t t;
|
||||
struct timespec ts;
|
||||
// struct rtc_time rtc_time;
|
||||
char strbuf[26];
|
||||
int afd;
|
||||
int nfd;
|
||||
// struct timeval timeout = { 0, 0 };
|
||||
int wait = 0;
|
||||
fd_set rfds;
|
||||
const char wake_lock_id[] = "alarm_test";
|
||||
int waitalarmmask = 0;
|
||||
|
||||
int useutc = 0;
|
||||
android_alarm_type_t alarmtype_low = ANDROID_ALARM_RTC_WAKEUP;
|
||||
android_alarm_type_t alarmtype_high = ANDROID_ALARM_RTC_WAKEUP;
|
||||
android_alarm_type_t alarmtype = 0;
|
||||
|
||||
do {
|
||||
//c = getopt(argc, argv, "uw:");
|
||||
c = getopt(argc, argv, "uwat:");
|
||||
if (c == EOF)
|
||||
break;
|
||||
switch (c) {
|
||||
case 'u':
|
||||
useutc = 1;
|
||||
break;
|
||||
case 't':
|
||||
alarmtype_low = alarmtype_high = strtol(optarg, NULL, 0);
|
||||
break;
|
||||
case 'a':
|
||||
alarmtype_low = ANDROID_ALARM_RTC_WAKEUP;
|
||||
alarmtype_high = ANDROID_ALARM_TYPE_COUNT - 1;
|
||||
break;
|
||||
case 'w':
|
||||
//timeout.tv_sec = strtol(optarg, NULL, 0);
|
||||
wait = 1;
|
||||
break;
|
||||
case '?':
|
||||
fprintf(stderr, "%s: invalid option -%c\n",
|
||||
argv[0], optopt);
|
||||
exit(1);
|
||||
}
|
||||
} while (1);
|
||||
if(optind + 2 < argc) {
|
||||
fprintf(stderr,"%s [-uwa] [-t type] [seconds]\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
afd = open("/dev/alarm", O_RDWR);
|
||||
if(afd < 0) {
|
||||
fprintf(stderr, "Unable to open rtc: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
|
||||
if(optind == argc) {
|
||||
for(alarmtype = alarmtype_low; alarmtype <= alarmtype_high; alarmtype++) {
|
||||
waitalarmmask |= 1U << alarmtype;
|
||||
}
|
||||
#if 0
|
||||
res = ioctl(fd, RTC_ALM_READ, &tm);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "Unable to read alarm: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
#if 0
|
||||
t = timegm(&tm);
|
||||
if(useutc)
|
||||
gmtime_r(&t, &tm);
|
||||
else
|
||||
localtime_r(&t, &tm);
|
||||
#endif
|
||||
#if 0
|
||||
asctime_r(&tm, strbuf);
|
||||
printf("%s", strbuf);
|
||||
#endif
|
||||
}
|
||||
else if(optind + 1 == argc) {
|
||||
#if 0
|
||||
res = ioctl(fd, RTC_RD_TIME, &tm);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "Unable to set alarm: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
asctime_r(&tm, strbuf);
|
||||
printf("Now: %s", strbuf);
|
||||
time(&tv.tv_sec);
|
||||
#endif
|
||||
#if 0
|
||||
time(&ts.tv_sec);
|
||||
ts.tv_nsec = 0;
|
||||
|
||||
//strptime(argv[optind], NULL, &tm);
|
||||
//tv.tv_sec = mktime(&tm);
|
||||
//tv.tv_usec = 0;
|
||||
#endif
|
||||
for(alarmtype = alarmtype_low; alarmtype <= alarmtype_high; alarmtype++) {
|
||||
waitalarmmask |= 1U << alarmtype;
|
||||
res = ioctl(afd, ANDROID_ALARM_GET_TIME(alarmtype), &ts);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "Unable to get current time: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
ts.tv_sec += strtol(argv[optind], NULL, 0);
|
||||
//strtotimeval(argv[optind], &tv);
|
||||
gmtime_r(&ts.tv_sec, &tm);
|
||||
printf("time %s -> %ld.%09ld\n", argv[optind], ts.tv_sec, ts.tv_nsec);
|
||||
asctime_r(&tm, strbuf);
|
||||
printf("Requested %s", strbuf);
|
||||
|
||||
res = ioctl(afd, ANDROID_ALARM_SET(alarmtype), &ts);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "Unable to set alarm: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
#if 0
|
||||
res = ioctl(fd, RTC_ALM_SET, &tm);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "Unable to set alarm: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
res = ioctl(fd, RTC_AIE_ON);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "Unable to enable alarm: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
fprintf(stderr,"%s [-u] [date]\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if(wait) {
|
||||
while(waitalarmmask) {
|
||||
printf("wait for alarm %x\n", waitalarmmask);
|
||||
res = ioctl(afd, ANDROID_ALARM_WAIT);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "alarm wait failed\n");
|
||||
}
|
||||
printf("got alarm %x\n", res);
|
||||
waitalarmmask &= ~res;
|
||||
nfd = open("/sys/android_power/acquire_full_wake_lock", O_RDWR);
|
||||
write(nfd, wake_lock_id, sizeof(wake_lock_id) - 1);
|
||||
close(nfd);
|
||||
//sleep(5);
|
||||
nfd = open("/sys/android_power/release_wake_lock", O_RDWR);
|
||||
write(nfd, wake_lock_id, sizeof(wake_lock_id) - 1);
|
||||
close(nfd);
|
||||
}
|
||||
printf("done\n");
|
||||
}
|
||||
#if 0
|
||||
FD_ZERO(&rfds);
|
||||
FD_SET(fd, &rfds);
|
||||
res = select(fd + 1, &rfds, NULL, NULL, &timeout);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "select failed: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
if(res > 0) {
|
||||
int event;
|
||||
read(fd, &event, sizeof(event));
|
||||
fprintf(stderr, "got %x\n", event);
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "timeout waiting for alarm\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
close(afd);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int exists_main(int argc, char *argv[])
|
||||
{
|
||||
struct stat s;
|
||||
|
||||
if(argc < 2) return 1;
|
||||
|
||||
if(stat(argv[1], &s)) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
227
toolbox/lsusb.c
227
toolbox/lsusb.c
|
|
@ -1,227 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2010 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 <endian.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <usbhost/usbhost.h>
|
||||
|
||||
static int verbose = 0;
|
||||
static char str_buff[4096];
|
||||
|
||||
static const char *get_str(struct usb_device *dev, int id)
|
||||
{
|
||||
char *str = usb_device_get_string(dev, id);
|
||||
|
||||
if (id && str) {
|
||||
strlcpy(str_buff, str, sizeof(str_buff));
|
||||
free(str);
|
||||
} else {
|
||||
snprintf(str_buff, sizeof(str_buff), "%02x", id);
|
||||
}
|
||||
|
||||
return str_buff;
|
||||
}
|
||||
|
||||
|
||||
static void lsusb_parse_device_descriptor(struct usb_device *dev,
|
||||
struct usb_device_descriptor *desc)
|
||||
{
|
||||
printf(" Device Descriptor\n");
|
||||
printf("\tbcdUSB: %04x\n", letoh16(desc->bcdUSB));
|
||||
printf("\tbDeviceClass: %02x\n", desc->bDeviceClass);
|
||||
printf("\tbDeviceSubClass: %02x\n", desc->bDeviceSubClass);
|
||||
printf("\tbDeviceProtocol: %02x\n", desc->bDeviceProtocol);
|
||||
printf("\tbMaxPacketSize0: %02x\n", desc->bMaxPacketSize0);
|
||||
printf("\tidVendor: %04x\n", letoh16(desc->idVendor));
|
||||
printf("\tidProduct: %04x\n", letoh16(desc->idProduct));
|
||||
printf("\tbcdDevice: %04x\n", letoh16(desc->bcdDevice));
|
||||
printf("\tiManufacturer: %s\n", get_str(dev, desc->iManufacturer));
|
||||
printf("\tiProduct: %s\n", get_str(dev, desc->iProduct));
|
||||
printf("\tiSerialNumber: %s\n", get_str(dev,desc->iSerialNumber));
|
||||
printf("\tbNumConfiguration: %02x\n", desc->bNumConfigurations);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void lsusb_parse_config_descriptor(struct usb_device *dev,
|
||||
struct usb_config_descriptor *desc)
|
||||
{
|
||||
printf(" Config Descriptor\n");
|
||||
printf("\twTotalLength: %04x\n", letoh16(desc->wTotalLength));
|
||||
printf("\tbNumInterfaces: %02x\n", desc->bNumInterfaces);
|
||||
printf("\tbConfigurationValue: %02x\n", desc->bConfigurationValue);
|
||||
printf("\tiConfiguration: %s\n", get_str(dev, desc->iConfiguration));
|
||||
printf("\tbmAttributes: %02x\n", desc->bmAttributes);
|
||||
printf("\tbMaxPower: %d mA\n", desc->bMaxPower * 2);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void lsusb_parse_interface_descriptor(struct usb_device *dev,
|
||||
struct usb_interface_descriptor *desc)
|
||||
{
|
||||
printf(" Interface Descriptor\n");
|
||||
printf("\tbInterfaceNumber: %02x\n", desc->bInterfaceNumber);
|
||||
printf("\tbAlternateSetting: %02x\n", desc->bAlternateSetting);
|
||||
printf("\tbNumEndpoints: %02x\n", desc->bNumEndpoints);
|
||||
printf("\tbInterfaceClass: %02x\n", desc->bInterfaceClass);
|
||||
printf("\tbInterfaceSubClass: %02x\n", desc->bInterfaceSubClass);
|
||||
printf("\tbInterfaceProtocol: %02x\n", desc->bInterfaceProtocol);
|
||||
printf("\tiInterface: %s\n", get_str(dev, desc->iInterface));
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void lsusb_parse_endpoint_descriptor(struct usb_device *dev,
|
||||
struct usb_endpoint_descriptor *desc)
|
||||
{
|
||||
printf(" Endpoint Descriptor\n");
|
||||
printf("\tbEndpointAddress: %02x\n", desc->bEndpointAddress);
|
||||
printf("\tbmAttributes: %02x\n", desc->bmAttributes);
|
||||
printf("\twMaxPacketSize: %02x\n", letoh16(desc->wMaxPacketSize));
|
||||
printf("\tbInterval: %02x\n", desc->bInterval);
|
||||
printf("\tbRefresh: %02x\n", desc->bRefresh);
|
||||
printf("\tbSynchAddress: %02x\n", desc->bSynchAddress);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void lsusb_dump_descriptor(struct usb_device *dev,
|
||||
struct usb_descriptor_header *desc)
|
||||
{
|
||||
int i;
|
||||
printf(" Descriptor type %02x\n", desc->bDescriptorType);
|
||||
|
||||
for (i = 0; i < desc->bLength; i++ ) {
|
||||
if ((i % 16) == 0)
|
||||
printf("\t%02x:", i);
|
||||
printf(" %02x", ((uint8_t *)desc)[i]);
|
||||
if ((i % 16) == 15)
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
if ((i % 16) != 0)
|
||||
printf("\n");
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void lsusb_parse_descriptor(struct usb_device *dev,
|
||||
struct usb_descriptor_header *desc)
|
||||
{
|
||||
switch (desc->bDescriptorType) {
|
||||
case USB_DT_DEVICE:
|
||||
lsusb_parse_device_descriptor(dev, (struct usb_device_descriptor *) desc);
|
||||
break;
|
||||
|
||||
case USB_DT_CONFIG:
|
||||
lsusb_parse_config_descriptor(dev, (struct usb_config_descriptor *) desc);
|
||||
break;
|
||||
|
||||
case USB_DT_INTERFACE:
|
||||
lsusb_parse_interface_descriptor(dev, (struct usb_interface_descriptor *) desc);
|
||||
break;
|
||||
|
||||
case USB_DT_ENDPOINT:
|
||||
lsusb_parse_endpoint_descriptor(dev, (struct usb_endpoint_descriptor *) desc);
|
||||
break;
|
||||
|
||||
default:
|
||||
lsusb_dump_descriptor(dev, desc);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int lsusb_device_added(const char *dev_name, void *client_data)
|
||||
{
|
||||
struct usb_device *dev = usb_device_open(dev_name);
|
||||
|
||||
if (!dev) {
|
||||
fprintf(stderr, "can't open device %s: %s\n", dev_name, strerror(errno));
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (verbose) {
|
||||
struct usb_descriptor_iter iter;
|
||||
struct usb_descriptor_header *desc;
|
||||
|
||||
printf("%s:\n", dev_name);
|
||||
|
||||
usb_descriptor_iter_init(dev, &iter);
|
||||
|
||||
while ((desc = usb_descriptor_iter_next(&iter)) != NULL)
|
||||
lsusb_parse_descriptor(dev, desc);
|
||||
|
||||
} else {
|
||||
uint16_t vid, pid;
|
||||
char *mfg_name, *product_name, *serial;
|
||||
|
||||
vid = usb_device_get_vendor_id(dev);
|
||||
pid = usb_device_get_product_id(dev);
|
||||
mfg_name = usb_device_get_manufacturer_name(dev);
|
||||
product_name = usb_device_get_product_name(dev);
|
||||
serial = usb_device_get_serial(dev);
|
||||
|
||||
printf("%s: %04x:%04x %s %s %s\n", dev_name, vid, pid,
|
||||
mfg_name, product_name, serial);
|
||||
|
||||
free(mfg_name);
|
||||
free(product_name);
|
||||
free(serial);
|
||||
}
|
||||
|
||||
usb_device_close(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int lsusb_device_removed(const char *dev_name, void *client_data)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int lsusb_discovery_done(void *client_data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int lsusb_main(int argc, char **argv)
|
||||
{
|
||||
struct usb_host_context *ctx;
|
||||
|
||||
if (argc == 2 && !strcmp(argv[1], "-v"))
|
||||
verbose = 1;
|
||||
|
||||
ctx = usb_host_init();
|
||||
if (!ctx) {
|
||||
perror("usb_host_init:");
|
||||
return 1;
|
||||
}
|
||||
|
||||
usb_host_run(ctx,
|
||||
lsusb_device_added,
|
||||
lsusb_device_removed,
|
||||
lsusb_discovery_done,
|
||||
NULL);
|
||||
|
||||
usb_host_cleanup(ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,71 +0,0 @@
|
|||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/mman.h>
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <linux/fb.h>
|
||||
|
||||
|
||||
int rotatefb_main(int argc, char *argv[])
|
||||
{
|
||||
int c;
|
||||
char *fbdev = "/dev/graphics/fb0";
|
||||
int rotation = 0;
|
||||
int fd;
|
||||
int res;
|
||||
struct fb_var_screeninfo fbinfo;
|
||||
|
||||
do {
|
||||
c = getopt(argc, argv, "d:");
|
||||
if (c == EOF)
|
||||
break;
|
||||
switch (c) {
|
||||
case 'd':
|
||||
fbdev = optarg;
|
||||
break;
|
||||
case '?':
|
||||
fprintf(stderr, "%s: invalid option -%c\n",
|
||||
argv[0], optopt);
|
||||
exit(1);
|
||||
}
|
||||
} while (1);
|
||||
|
||||
if(optind + 1 != argc) {
|
||||
fprintf(stderr, "%s: specify rotation\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
rotation = atoi(argv[optind]);
|
||||
|
||||
fd = open(fbdev, O_RDWR);
|
||||
if(fd < 0) {
|
||||
fprintf(stderr, "cannot open %s\n", fbdev);
|
||||
return 1;
|
||||
}
|
||||
|
||||
res = ioctl(fd, FBIOGET_VSCREENINFO, &fbinfo);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "failed to get fbinfo: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
if((fbinfo.rotate ^ rotation) & 1) {
|
||||
unsigned int xres = fbinfo.yres;
|
||||
fbinfo.yres = fbinfo.xres;
|
||||
fbinfo.xres = xres;
|
||||
fbinfo.xres_virtual = fbinfo.xres;
|
||||
fbinfo.yres_virtual = fbinfo.yres * 2;
|
||||
if(fbinfo.yoffset == xres)
|
||||
fbinfo.yoffset = fbinfo.yres;
|
||||
}
|
||||
fbinfo.rotate = rotation;
|
||||
res = ioctl(fd, FBIOPUT_VSCREENINFO, &fbinfo);
|
||||
if(res < 0) {
|
||||
fprintf(stderr, "failed to set fbinfo: %s\n", strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
#include <linux/kd.h>
|
||||
#include <linux/vt.h>
|
||||
#include <errno.h>
|
||||
|
||||
static void setkey_usage(char *argv[])
|
||||
{
|
||||
fprintf(stderr, "%s [-t <table>] [-k <index>] [-v value] [-r] [-h]\n"
|
||||
" -t <table> Select table\n"
|
||||
" -k <index> Select key\n"
|
||||
" -v <value> Set entry\n"
|
||||
" -r Read current entry\n"
|
||||
" -h Print help\n", argv[0]);
|
||||
}
|
||||
|
||||
#define TTYDEV "/dev/tty0"
|
||||
|
||||
int setkey_main(int argc, char *argv[])
|
||||
{
|
||||
int fd;
|
||||
struct kbentry kbe;
|
||||
int did_something = 0;
|
||||
|
||||
kbe.kb_table = 0;
|
||||
kbe.kb_index = -1;
|
||||
kbe.kb_value = 0;
|
||||
|
||||
fd = open(TTYDEV, O_RDWR | O_SYNC);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "open %s: %s\n", TTYDEV, strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
|
||||
do {
|
||||
int c, ret;
|
||||
|
||||
c = getopt(argc, argv, "t:k:v:hr");
|
||||
if (c == EOF)
|
||||
break;
|
||||
|
||||
switch (c) {
|
||||
case 't':
|
||||
kbe.kb_table = strtol(optarg, NULL, 0);
|
||||
break;
|
||||
case 'k':
|
||||
kbe.kb_index = strtol(optarg, NULL, 0);
|
||||
break;
|
||||
case 'v':
|
||||
kbe.kb_value = strtol(optarg, NULL, 0);
|
||||
ret = ioctl(fd, KDSKBENT, &kbe);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "KDSKBENT %d %d %d failed: %s\n",
|
||||
kbe.kb_table, kbe.kb_index, kbe.kb_value,
|
||||
strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
did_something = 1;
|
||||
break;
|
||||
case 'r':
|
||||
ret = ioctl(fd, KDGKBENT, &kbe);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "KDGKBENT %d %d failed: %s\n",
|
||||
kbe.kb_table, kbe.kb_index, strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
printf("0x%x 0x%x 0x%x\n",
|
||||
kbe.kb_table, kbe.kb_index, kbe.kb_value);
|
||||
did_something = 1;
|
||||
break;
|
||||
case 'h':
|
||||
setkey_usage(argv);
|
||||
return 1;
|
||||
case '?':
|
||||
fprintf(stderr, "%s: invalid option -%c\n",
|
||||
argv[0], optopt);
|
||||
return 1;
|
||||
}
|
||||
} while (1);
|
||||
|
||||
if(optind != argc || !did_something) {
|
||||
setkey_usage(argv);
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
158
toolbox/syren.c
158
toolbox/syren.c
|
|
@ -1,158 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <malloc.h>
|
||||
|
||||
/* ioctl crap */
|
||||
#define SYREN_RD 101
|
||||
#define SYREN_WR 102
|
||||
#define SYREN_OLD_RD 108
|
||||
#define SYREN_OLD_WR 109
|
||||
|
||||
struct syren_io_args {
|
||||
unsigned long page;
|
||||
unsigned long addr;
|
||||
unsigned long value;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
u_char page;
|
||||
u_char addr;
|
||||
const char *name;
|
||||
} syren_reg;
|
||||
|
||||
static syren_reg registers[] = {
|
||||
{ 0, 0x04, "TOGBR1" },
|
||||
{ 0, 0x05, "TOGBR2" },
|
||||
{ 0, 0x06, "VBDCTRL" },
|
||||
{ 1, 0x07, "VBUCTRL" },
|
||||
{ 1, 0x08, "VBCTRL" },
|
||||
{ 1, 0x09, "PWDNRG" },
|
||||
{ 1, 0x0a, "VBPOP" },
|
||||
{ 1, 0x0b, "VBCTRL2" },
|
||||
{ 1, 0x0f, "VAUDCTRL" },
|
||||
{ 1, 0x10, "VAUSCTRL" },
|
||||
{ 1, 0x11, "VAUOCTRL" },
|
||||
{ 1, 0x12, "VAUDPLL" },
|
||||
{ 1, 0x17, "VRPCSIMR" },
|
||||
{ 0, 0, 0 }
|
||||
};
|
||||
|
||||
static syren_reg *find_reg(const char *name)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; registers[i].name != 0; i++) {
|
||||
if (!strcasecmp(registers[i].name, name))
|
||||
return ®isters[i];
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int usage(void)
|
||||
{
|
||||
fprintf(stderr, "usage: syren [r/w] [REGNAME | page:addr] (value)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
syren_main(int argc, char **argv)
|
||||
{
|
||||
int cmd = -1;
|
||||
syren_reg *r;
|
||||
struct syren_io_args sio;
|
||||
char name[32];
|
||||
int fd;
|
||||
|
||||
if (argc < 3) {
|
||||
return usage();
|
||||
}
|
||||
|
||||
switch(argv[1][0]) {
|
||||
case 'r':
|
||||
cmd = SYREN_RD;
|
||||
break;
|
||||
case 'w':
|
||||
cmd = SYREN_WR;
|
||||
break;
|
||||
case 'R':
|
||||
cmd = SYREN_OLD_RD;
|
||||
break;
|
||||
case 'W':
|
||||
cmd = SYREN_OLD_WR;
|
||||
break;
|
||||
default:
|
||||
return usage();
|
||||
}
|
||||
|
||||
if (cmd == SYREN_WR || cmd == SYREN_OLD_WR) {
|
||||
if (argc < 4)
|
||||
return usage();
|
||||
sio.value = strtoul(argv[3], 0, 0);
|
||||
}
|
||||
|
||||
fd = open("/dev/eac", O_RDONLY);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "can't open /dev/eac\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (strcasecmp(argv[2], "all") == 0) {
|
||||
int i;
|
||||
if (cmd != SYREN_RD && cmd != SYREN_OLD_RD) {
|
||||
fprintf(stderr, "can only read all registers\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (i = 0; registers[i].name; i++) {
|
||||
sio.page = registers[i].page;
|
||||
sio.addr = registers[i].addr;
|
||||
if (ioctl(fd, cmd, &sio) < 0) {
|
||||
fprintf(stderr, "%s: error\n", registers[i].name);
|
||||
} else {
|
||||
fprintf(stderr, "%s: %04x\n", registers[i].name, sio.value);
|
||||
}
|
||||
}
|
||||
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
r = find_reg(argv[2]);
|
||||
if (r == NULL) {
|
||||
if(strlen(argv[2]) >= sizeof(name)){
|
||||
fprintf(stderr, "REGNAME too long\n");
|
||||
return 0;
|
||||
}
|
||||
strlcpy(name, argv[2], sizeof(name));
|
||||
char *addr_str = strchr(argv[2], ':');
|
||||
if (addr_str == NULL)
|
||||
return usage();
|
||||
*addr_str++ = 0;
|
||||
sio.page = strtoul(argv[2], 0, 0);
|
||||
sio.addr = strtoul(addr_str, 0, 0);
|
||||
} else {
|
||||
strlcpy(name, r->name, sizeof(name));
|
||||
sio.page = r->page;
|
||||
sio.addr = r->addr;
|
||||
}
|
||||
|
||||
if (ioctl(fd, cmd, &sio) < 0) {
|
||||
fprintf(stderr, "ioctl(%d) failed\n", cmd);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (cmd == SYREN_RD || cmd == SYREN_OLD_RD) {
|
||||
printf("%s: %04x\n", name, sio.value);
|
||||
} else {
|
||||
printf("wrote %04x to %s\n", sio.value, name);
|
||||
}
|
||||
|
||||
close(fd);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue