From 64f5f3b05c4e82229c5834a40a640cbd6811f5b5 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 10:03:39 +0200 Subject: Adding upstream version 20200122. Signed-off-by: Daniel Baumann --- carl9170fw/tools/carlu/src/main.c | 307 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 carl9170fw/tools/carlu/src/main.c (limited to 'carl9170fw/tools/carlu/src/main.c') diff --git a/carl9170fw/tools/carlu/src/main.c b/carl9170fw/tools/carlu/src/main.c new file mode 100644 index 0000000..c1b3277 --- /dev/null +++ b/carl9170fw/tools/carlu/src/main.c @@ -0,0 +1,307 @@ +/* + * carlu - userspace testing utility for ar9170 devices + * + * main program routine + * + * Copyright 2009-2011 Christian Lamparter + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include +#include "SDL.h" +#include + +#include "debug.h" +#include "carlu.h" +#include "usb.h" +#include "frame.h" +#include "test.h" +#include "cmd.h" + +void *carlu_alloc_driver(size_t size) +{ + unsigned int i; + struct carlu *ar; + + if (size < sizeof(*ar)) { + err("bogus driver context request."); + return NULL; + } + + ar = malloc(size); + if (ar == NULL) { + err("failed to alloc driver context."); + return NULL; + } + memset(ar, 0, size); + + for (i = 0; i < __AR9170_NUM_TXQ; i++) + frame_queue_init(&ar->tx_sent_queue[i]); + ar->resp_lock = SDL_CreateMutex(); + ar->mem_lock = SDL_CreateMutex(); + ar->resp_pend = SDL_CreateCond(); + ar->tx_pending = 0; + return ar; +} + +void carlu_free_driver(struct carlu *ar) +{ + unsigned int i; + + dbg("destroy driver struct.\n"); + SDL_DestroyMutex(ar->resp_lock); + SDL_DestroyMutex(ar->mem_lock); + SDL_DestroyCond(ar->resp_pend); + + for (i = 0; i < __AR9170_NUM_TXQ; i++) + frame_queue_kill(&ar->tx_sent_queue[i]); + + free(ar); +} + +static int carlu_init() +{ + struct SDL_version compiled; + int ret; + + SDL_VERSION(&compiled); + dbg("=== SDL %d.%d.%d ===\n", compiled.major, compiled.minor, compiled.patch); + + ret = SDL_Init(SDL_INIT_TIMER); + if (ret != 0) { + err("Unable to initialize SDL: (%s)\n", SDL_GetError()); + return EXIT_FAILURE; + } + + return usb_init(); +} + +static void carlu_exit() +{ + SDL_Quit(); + usb_exit(); +} + +static int carlu_dump_eeprom(void) +{ + struct carlu *carl = NULL; + uint8_t data[8192] = { 0 }; + int err; + + err = carlu_init(); + if (err) + goto out; + + carl = carlusb_probe(); + if (IS_ERR_OR_NULL(carl)) { + err = PTR_ERR(carl); + goto out; + } + + err = carlu_cmd_mem_dump(carl, 0, sizeof(data), &data); + if (err) + goto out_close; + + print_hex_dump_bytes(INFO, "EEPROM:", data, sizeof(data)); + +out_close: + carlusb_close(carl); + +out: + carlu_exit(); + return err ? EXIT_FAILURE : EXIT_SUCCESS; +} + +static int carlu_run_gpio_test(void) +{ + struct carlu *carl = NULL; + int err; + + err = carlu_init(); + if (err) + goto out; + + carl = carlusb_probe(); + if (IS_ERR_OR_NULL(carl)) { + err = PTR_ERR(carl); + goto out; + } + + err = carlu_gpio_test(carl); + if (err) + goto out_close; + +out_close: + carlusb_close(carl); + +out: + carlu_exit(); + return err ? EXIT_FAILURE : EXIT_SUCCESS; +} + +static int carlu_run_random_test(void) +{ + struct carlu *carl = NULL; + int err; + + err = carlu_init(); + if (err) + goto out; + + carl = carlusb_probe(); + if (IS_ERR_OR_NULL(carl)) { + err = PTR_ERR(carl); + goto out; + } + + err = carlu_random_test(carl); + if (err) + goto out_close; + +out_close: + carlusb_close(carl); + +out: + carlu_exit(); + return err ? EXIT_FAILURE : EXIT_SUCCESS; +} + +static int carlu_run_loop_test(void) +{ + struct carlu *carl; + int err; + + err = carlu_init(); + if (err) + return EXIT_FAILURE; + + carl = carlusb_probe(); + if (IS_ERR_OR_NULL(carl)) { + err = PTR_ERR(carl); + goto out; + } + + carlu_cmd_write_mem(carl, AR9170_MAC_REG_BCN_PERIOD, 0xFFFFFFFF); + carlu_cmd_write_mem(carl, AR9170_MAC_REG_PRETBTT, 0xFFFFFFFF); + + /* different payload test */ + carlu_loopback_test(carl, 9000, 1000, 1566, 1566); + carlusb_close(carl); + +out: + return err ? EXIT_FAILURE : EXIT_SUCCESS; +} + +static int carlu_probe_all(void) +{ + struct carlu *carl[32] = { 0 }; + unsigned int devs; + int ret; + + ret = carlu_init(); + if (ret) + return EXIT_FAILURE; + + for (devs = 0; devs < ARRAY_SIZE(carl); devs++) { + carl[devs] = carlusb_probe(); + if (IS_ERR_OR_NULL(carl[devs])) + break; + } + + info("Found %d devices\n", devs); + + for (; devs > 0; devs--) + carlusb_close(carl[devs - 1]); + + carlu_exit(); + return EXIT_SUCCESS; +} + +struct menu_struct { + char option; + unsigned int parameters; + int (*function)(void); + char help_text[80]; +}; + +#define MENU_ITEM(op, func, helpme) \ + { \ + .option = op, \ + .parameters = 0, \ + .function = func, \ + .help_text = helpme, \ + } + +static int show_help(void); + +static const struct menu_struct menu[] = { + [0] = MENU_ITEM('h', show_help, "shows this useless help message text."), /* keep this entry at 0! */ + MENU_ITEM('e', carlu_dump_eeprom, "hexdumps eeprom content to stdout."), + MENU_ITEM('l', carlusb_print_known_devices, "list of all known ar9170 usb devices."), + MENU_ITEM('p', carlu_probe_all, "probe all possible devices."), + MENU_ITEM('t', carlu_run_loop_test, "run tx/rx test."), + MENU_ITEM('g', carlu_run_gpio_test, "flash the leds."), + MENU_ITEM('r', carlu_run_random_test, "get random numbers."), +}; + +static int show_help(void) +{ + unsigned int i; + char parameters[ARRAY_SIZE(menu) + 1]; + + for (i = 0; i < ARRAY_SIZE(menu); i++) + parameters[i] = menu[i].option; + + parameters[ARRAY_SIZE(menu)] = '\0'; + + info("usage: ar9170user -[%s]\n", parameters); + + for (i = 0; i < ARRAY_SIZE(menu); i++) + info("\t-%c\t%s\n", menu[i].option, menu[i].help_text); + + return EXIT_FAILURE; +} + +static int select_menu_item(const char arg) +{ + unsigned int i; + + for (i = ARRAY_SIZE(menu) - 1; i != 0; i--) { + if (arg == menu[i].option) + break; + } + + return menu[i].function(); +} + +int main(int argc, char *argv[]) +{ + init_debug(); + + if (argc != 2 || strlen(argv[1]) != 2 || argv[1][0] != '-') + return show_help(); + + return select_menu_item(argv[1][1]); +} -- cgit v1.2.3