p/usb-drivers
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

razer-bw-te-ctl: adjust code style

Browse Source 
And import the newer find_device() from elksmart-comm.
This commit is contained in:
Přemysl Eric Janouch 2024-11-25 04:25:57 +01:00
parent e46eee0a7f
commit 3219d87bc4
Signed by: p
GPG Key ID: A0420B94F92B9493
1 changed files with 168 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

380
razer-bw-te-ctl.c
View File

@ -34,71 +34,60 @@
// --- Utilities --------------------------------------------------------------- // --- Utilities ---------------------------------------------------------------
/** Search for a device with given vendor and product ID. */ /// Search for a device with given vendor and product ID.
/// This is quite similar to libusb_open_device_with_vid_pid().
static libusb_device_handle * static libusb_device_handle *
find_device (int vendor, int product, int *error) find_device(int vendor, int product, int *error)
{ {
libusb_device **list; libusb_device **list = NULL;
libusb_device *found = NULL;
libusb_device_handle *handle = NULL; libusb_device_handle *handle = NULL;
int err = 0; int result = 0;
ssize_t cnt = libusb_get_device_list (NULL, &list); ssize_t len = libusb_get_device_list(NULL, &list);
if (cnt < 0) if (len < 0) {
result = len;
goto out; goto out;
}
ssize_t i = 0; for (ssize_t i = 0; i < len; i++) {
for (i = 0; i < cnt; i++)
{
libusb_device *device = list[i]; libusb_device *device = list[i];
struct libusb_device_descriptor desc = {};
struct libusb_device_descriptor desc; if ((result = libusb_get_device_descriptor(device, &desc)))
if (libusb_get_device_descriptor (device, &desc)) (void) libusb_strerror(result);
else if (desc.idVendor != vendor || desc.idProduct != product)
continue; continue;
else if (!(result = libusb_open(device, &handle)))
if (desc.idVendor == vendor && desc.idProduct == product)
{
found = device;
break; break;
}
} }
if (found) libusb_free_device_list(list, true);
{
err = libusb_open (found, &handle);
if (err)
goto out_free;
}
out_free:
libusb_free_device_list(list, 1);
out: out:
if (error != NULL && err != 0) if (error != NULL && result != 0)
*error = err; *error = result;
return handle; return handle;
} }
// --- Device configuration ---------------------------------------------------- // --- Device configuration ----------------------------------------------------
#define USB_VENDOR_RAZER 0x1532 enum {
#define USB_PRODUCT_RAZER_BW_TE 0x011c USB_VENDOR_RAZER = 0x1532,
USB_PRODUCT_RAZER_BW_TE = 0x011c,
#define USB_GET_REPORT 0x01 USB_GET_REPORT = 0x01,
#define USB_SET_REPORT 0x09 USB_SET_REPORT = 0x09,
#define BW_CTL_IFACE 0 BW_CTL_IFACE = 0,
};
/** Razer logo backlight mode. */ /// Razer logo backlight mode.
enum bw_led_mode enum bw_led_mode {
{
LED_BRIGHTNESS = 0, LED_BRIGHTNESS = 0,
LED_BLINK, LED_BLINK,
LED_PULSATE LED_PULSATE
}; };
/** Overall device configuration. */ /// Overall device configuration.
struct bw_config struct bw_config {
{
enum bw_led_mode led_mode; enum bw_led_mode led_mode;
unsigned led_brightness; unsigned led_brightness;
unsigned macro_led_on : 1; unsigned macro_led_on : 1;
@ -106,71 +95,70 @@ struct bw_config
unsigned gaming_mode : 1; unsigned gaming_mode : 1;
}; };
/** Send a command to the mouse via SET_REPORT. */ /// Send a command to the mouse via SET_REPORT.
static int static int
bw_send_command (libusb_device_handle *device, bw_send_command(
unsigned char *data, uint16_t length) libusb_device_handle *device, unsigned char *data, uint16_t length)
{ {
unsigned char packet[90] = { 0x00 }; unsigned char packet[90] = {0x00};
assert (length <= sizeof packet - 5); assert(length <= sizeof packet - 5);
memcpy (packet + 5, data, length); memcpy(packet + 5, data, length);
unsigned char checksum = 0; unsigned char checksum = 0;
while (length--) while (length--)
checksum ^= data[length]; checksum ^= data[length];
packet[sizeof packet - 2] = checksum; packet[sizeof packet - 2] = checksum;
// XXX wIndex should actually be 0x0002 but that doesn't work // XXX: wIndex should actually be 0x0002 but that doesn't work.
int result = libusb_control_transfer (device, LIBUSB_ENDPOINT_OUT int result = libusb_control_transfer(device, LIBUSB_ENDPOINT_OUT |
| LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,
USB_SET_REPORT, 0x0300, 0x0000, packet, sizeof packet, 0); USB_SET_REPORT, 0x0300, 0x0000, packet, sizeof packet, 0);
return result < 0 ? result : 0; return result < 0 ? result : 0;
} }
/** Set Razer logo backlight mode. */ /// Set Razer logo backlight mode.
static int static int
bw_set_led_mode (libusb_device_handle *device, enum bw_led_mode mode) bw_set_led_mode(libusb_device_handle *device, enum bw_led_mode mode)
{ {
unsigned char cmd[] = { 0x03, 0x03, 0x02, 0x01, 0x04, mode }; unsigned char cmd[] = {0x03, 0x03, 0x02, 0x01, 0x04, mode};
return bw_send_command (device, cmd, sizeof cmd); return bw_send_command(device, cmd, sizeof cmd);
} }
/** Set Razer logo backlight brightness. */ /// Set Razer logo backlight brightness.
static int static int
bw_set_led_brightness (libusb_device_handle *device, unsigned char brightness) bw_set_led_brightness(libusb_device_handle *device, unsigned char brightness)
{ {
unsigned char cmd[] = { 0x03, 0x03, 0x03, 0x01, 0x04, brightness }; unsigned char cmd[] = {0x03, 0x03, 0x03, 0x01, 0x04, brightness};
return bw_send_command (device, cmd, sizeof cmd); return bw_send_command(device, cmd, sizeof cmd);
} }
/** Set the on/off state of the macro LED. */ /// Set the on/off state of the macro LED.
static int static int
bw_set_macro_led (libusb_device_handle *device, bool on) bw_set_macro_led(libusb_device_handle *device, bool on)
{ {
unsigned char cmd[] = { 0x03, 0x03, 0x00, 0x00, 0x07, on }; unsigned char cmd[] = {0x03, 0x03, 0x00, 0x00, 0x07, on};
return bw_send_command (device, cmd, sizeof cmd); return bw_send_command(device, cmd, sizeof cmd);
} }
/** Set whether the macro LED should blink. */ /// Set whether the macro LED should blink.
static int static int
bw_set_macro_led_blinking (libusb_device_handle *device, bool blinking) bw_set_macro_led_blinking(libusb_device_handle *device, bool blinking)
{ {
unsigned char cmd[] = { 0x03, 0x03, 0x02, 0x00, 0x07, blinking }; unsigned char cmd[] = {0x03, 0x03, 0x02, 0x00, 0x07, blinking};
return bw_send_command (device, cmd, sizeof cmd); return bw_send_command(device, cmd, sizeof cmd);
} }
/** Set the gaming mode (whether the Windows key should be ignored). */ /// Set the gaming mode (whether the Windows key should be ignored).
static int static int
bw_set_gaming_mode (libusb_device_handle *device, bool on) bw_set_gaming_mode(libusb_device_handle *device, bool on)
{ {
unsigned char cmd[] = { 0x03, 0x03, 0x00, 0x01, 0x08, on }; unsigned char cmd[] = {0x03, 0x03, 0x00, 0x01, 0x08, on};
return bw_send_command (device, cmd, sizeof cmd); return bw_send_command(device, cmd, sizeof cmd);
} }
// --- Control utility --------------------------------------------------------- // --- Control utility ---------------------------------------------------------
struct options struct options {
{
unsigned set_led_mode : 1; unsigned set_led_mode : 1;
unsigned set_led_brightness : 1; unsigned set_led_brightness : 1;
unsigned set_macro_led_on : 1; unsigned set_macro_led_on : 1;
@ -179,249 +167,217 @@ struct options
}; };
static void static void
show_usage (const char *program_name) show_usage(const char *program_name)
{ {
printf ("Usage: %s [OPTION]...\n", program_name); printf("Usage: %s [OPTION]...\n", program_name);
printf ("Configure Razer BlackWidow Tournament Edition devices.\n\n"); printf("Configure Razer BlackWidow Tournament Edition devices.\n\n");
printf (" -h, --help Show this help\n"); printf(" -h, --help Show this help\n");
printf (" --version Show program version and exit\n"); printf(" --version Show program version and exit\n");
printf (" --led-mode X Set the mode of the Razer logo LED" printf(" --led-mode X Set the mode of the Razer logo LED"
" (can be 'normal', 'blink' or 'pulsate')\n"); " (can be 'normal', 'blink' or 'pulsate')\n");
printf (" --led-brightness X Set Razer logo LED brightness" printf(" --led-brightness X Set Razer logo LED brightness"
" (from 0 to 255)\n"); " (from 0 to 255)\n");
printf (" --macro-led X Set the macro LED mode" printf(" --macro-led X Set the macro LED mode"
" ('off', 'on' or 'blink')\n"); " ('off', 'on' or 'blink')\n");
printf (" --gaming-mode BOOL Set whether the Windows key is ignored\n"); printf(" --gaming-mode BOOL Set whether the Windows key is ignored\n");
printf ("\n"); printf("\n");
} }
static void static void
parse_options (int argc, char *argv[], parse_options(int argc, char *argv[],
struct options *options, struct bw_config *new_config) struct options *options, struct bw_config *new_config)
{ {
static struct option long_opts[] = static struct option long_opts[] = {
{ {"help", no_argument, 0, 'h'},
{ "help", no_argument, 0, 'h' }, {"version", no_argument, 0, 'V'},
{ "version", no_argument, 0, 'V' }, {"led-mode", required_argument, 0, 'l'},
{ "led-mode", required_argument, 0, 'l' }, {"led-brightness", required_argument, 0, 'L'},
{ "led-brightness", required_argument, 0, 'L' }, {"macro-led", required_argument, 0, 'm'},
{ "macro-led", required_argument, 0, 'm' }, {"gaming-mode", required_argument, 0, 'g'},
{ "gaming-mode", required_argument, 0, 'g' }, {0}
{ 0, 0, 0, 0 }
}; };
if (argc == 1) if (argc == 1) {
{
show_usage (argv[0]); show_usage (argv[0]);
exit (EXIT_FAILURE); exit (EXIT_FAILURE);
} }
int c; int c;
while ((c = getopt_long (argc, argv, "h", long_opts, NULL)) != -1) while ((c = getopt_long(argc, argv, "h", long_opts, NULL)) != -1)
{ switch (c) {
switch (c)
{
case 'h': case 'h':
show_usage (argv[0]); show_usage(argv[0]);
exit (EXIT_SUCCESS); exit(EXIT_SUCCESS);
case 'V': case 'V':
printf (PROGRAM_NAME " " PROGRAM_VERSION "\n"); printf(PROGRAM_NAME " " PROGRAM_VERSION "\n");
exit (EXIT_SUCCESS); exit(EXIT_SUCCESS);
case 'l': case 'l':
if (!strcasecmp (optarg, "normal")) if (!strcasecmp(optarg, "normal")) {
new_config->led_mode = LED_BRIGHTNESS; new_config->led_mode = LED_BRIGHTNESS;
else if (!strcasecmp (optarg, "blink")) } else if (!strcasecmp(optarg, "blink")) {
new_config->led_mode = LED_BLINK; new_config->led_mode = LED_BLINK;
else if (!strcasecmp (optarg, "pulsate")) } else if (!strcasecmp(optarg, "pulsate")) {
new_config->led_mode = LED_PULSATE; new_config->led_mode = LED_PULSATE;
else } else {
{ fprintf(stderr, "Error: invalid LED mode: %s\n", optarg);
fprintf (stderr, "Error: invalid LED mode: %s\n", optarg); exit(EXIT_FAILURE);
exit (EXIT_FAILURE);
} }
options->set_led_mode = true; options->set_led_mode = true;
break; break;
case 'L': case 'L': {
{
char *end; char *end;
long bri = strtol (optarg, &end, 10); long bri = strtol(optarg, &end, 10);
if (!*optarg || *end || bri < 0 || bri > 255) if (!*optarg || *end || bri < 0 || bri > 255) {
{ fprintf(stderr, "Error: invalid LED brightness value\n");
fprintf (stderr, "Error: invalid LED brightness value\n"); exit(EXIT_FAILURE);
exit (EXIT_FAILURE);
} }
options->set_led_brightness = true; options->set_led_brightness = true;
break; break;
} }
case 'm': case 'm':
if (!strcasecmp (optarg, "off")) if (!strcasecmp(optarg, "off")) {
{
new_config->macro_led_on = false; new_config->macro_led_on = false;
new_config->macro_led_blinking = false; new_config->macro_led_blinking = false;
} } else if (!strcasecmp(optarg, "blink")) {
else if (!strcasecmp (optarg, "blink"))
{
new_config->macro_led_on = true; new_config->macro_led_on = true;
new_config->macro_led_blinking = true; new_config->macro_led_blinking = true;
} } else if (!strcasecmp(optarg, "on")) {
else if (!strcasecmp (optarg, "on"))
{
new_config->macro_led_on = true; new_config->macro_led_on = true;
new_config->macro_led_blinking = false; new_config->macro_led_blinking = false;
} } else {
else fprintf(stderr, "Error: invalid macro LED mode: %s\n", optarg);
{ exit(EXIT_FAILURE);
fprintf (stderr, "Error: invalid macro LED mode: %s\n", optarg);
exit (EXIT_FAILURE);
} }
options->set_macro_led_blinking = true; options->set_macro_led_blinking = true;
options->set_macro_led_on = true; options->set_macro_led_on = true;
break; break;
case 'g': case 'g':
if (!strcasecmp (optarg, "true") if (!strcasecmp(optarg, "true") ||
|| !strcasecmp (optarg, "on") !strcasecmp(optarg, "on") ||
|| !strcasecmp (optarg, "yes")) !strcasecmp(optarg, "yes")) {
new_config->gaming_mode = true; new_config->gaming_mode = true;
else if (!strcasecmp (optarg, "false") } else if (!strcasecmp (optarg, "false") ||
|| !strcasecmp (optarg, "off") !strcasecmp(optarg, "off") ||
|| !strcasecmp (optarg, "no")) !strcasecmp(optarg, "no")) {
new_config->gaming_mode = false; new_config->gaming_mode = false;
else } else {
{ fprintf(stderr, "Error: invalid gaming mode"
fprintf (stderr, "Error: invalid gaming mode"
" setting: %s\n", optarg); " setting: %s\n", optarg);
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
options->set_gaming_mode = true; options->set_gaming_mode = true;
break; break;
case '?': case '?':
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
}
} }
if (optind < argc) if (optind < argc) {
{ fprintf(stderr, "Error: extra parameters\n");
fprintf (stderr, "Error: extra parameters\n"); exit(EXIT_FAILURE);
exit (EXIT_FAILURE);
} }
} }
static int static int
apply_options (libusb_device_handle *device, apply_options(libusb_device_handle *device,
struct options *options, struct bw_config *new_config) struct options *options, struct bw_config *new_config)
{ {
int result; int result = 0;
if (options->set_led_mode) if (options->set_led_mode)
if ((result = bw_set_led_mode if ((result = bw_set_led_mode(
(device, new_config->led_mode))) device, new_config->led_mode)))
return result; return result;
if (options->set_led_brightness) if (options->set_led_brightness)
if ((result = bw_set_led_brightness if ((result = bw_set_led_brightness(
(device, new_config->led_brightness))) device, new_config->led_brightness)))
return result; return result;
if (options->set_macro_led_on) if (options->set_macro_led_on)
if ((result = bw_set_macro_led if ((result = bw_set_macro_led(
(device, new_config->macro_led_on))) device, new_config->macro_led_on)))
return result; return result;
if (options->set_macro_led_blinking) if (options->set_macro_led_blinking)
if ((result = bw_set_macro_led_blinking if ((result = bw_set_macro_led_blinking(
(device, new_config->macro_led_blinking))) device, new_config->macro_led_blinking)))
return result; return result;
if (options->set_gaming_mode) if (options->set_gaming_mode)
if ((result = bw_set_gaming_mode if ((result = bw_set_gaming_mode(
(device, new_config->gaming_mode))) device, new_config->gaming_mode)))
return result; return result;
return 0; return 0;
} }
#define ERROR(label, ...) \ #define ERROR(label, ...) \
do { \ do { \
fprintf (stderr, "Error: " __VA_ARGS__); \ fprintf(stderr, "Error: " __VA_ARGS__); \
status = 1; \ status = 1; \
goto label; \ goto label; \
} while (0) } while (0)
int int
main (int argc, char *argv[]) main(int argc, char *argv[])
{ {
struct options options = { 0 }; struct options options = {0};
struct bw_config new_config = { 0 }; struct bw_config new_config = {0};
parse_options (argc, argv, &options, &new_config); parse_options(argc, argv, &options, &new_config);
int result, status = 0; int result, status = 0;
if ((result = libusb_init(NULL)))
result = libusb_init (NULL); ERROR(error_0, "libusb initialisation failed: %s\n",
if (result) libusb_error_name(result));
ERROR (error_0, "libusb initialisation failed: %s\n",
libusb_error_name (result));
result = 0; result = 0;
libusb_device_handle *device = find_device libusb_device_handle *device =
(USB_VENDOR_RAZER, USB_PRODUCT_RAZER_BW_TE, &result); find_device(USB_VENDOR_RAZER, USB_PRODUCT_RAZER_BW_TE, &result);
if (!device) if (!device) {
{
if (result) if (result)
ERROR (error_1, "couldn't open device: %s\n", ERROR(error_1, "couldn't open device: %s\n",
libusb_error_name (result)); libusb_error_name(result));
else else
ERROR (error_1, "no suitable device found\n"); ERROR(error_1, "no suitable device found\n");
} }
bool reattach_driver = false; bool reattach_driver = false;
switch ((result = libusb_kernel_driver_active(device, BW_CTL_IFACE))) {
result = libusb_kernel_driver_active (device, BW_CTL_IFACE);
switch (result)
{
case 0: case 0:
case LIBUSB_ERROR_NOT_SUPPORTED: case LIBUSB_ERROR_NOT_SUPPORTED:
break; break;
case 1: case 1:
reattach_driver = true; reattach_driver = true;
result = libusb_detach_kernel_driver (device, BW_CTL_IFACE); if ((result = libusb_detach_kernel_driver(device, BW_CTL_IFACE)))
if (result) ERROR(error_2, "couldn't detach kernel driver: %s\n",
ERROR (error_2, "couldn't detach kernel driver: %s\n", libusb_error_name(result));
libusb_error_name (result));
break; break;
default: default:
ERROR (error_2, "coudn't detect kernel driver presence: %s\n", ERROR(error_2, "coudn't detect kernel driver presence: %s\n",
libusb_error_name (result)); libusb_error_name(result));
} }
result = libusb_claim_interface (device, BW_CTL_IFACE); if ((result = libusb_claim_interface(device, BW_CTL_IFACE)))
if (result) ERROR(error_3, "couldn't claim interface: %s\n",
ERROR (error_3, "couldn't claim interface: %s\n", libusb_error_name(result));
libusb_error_name (result));
result = apply_options (device, &options, &new_config); if ((result = apply_options(device, &options, &new_config)))
if (result) ERROR(error_4, "operation failed: %s\n",
ERROR (error_4, "operation failed: %s\n",
libusb_error_name (result)); libusb_error_name (result));
error_4: error_4:
result = libusb_release_interface (device, BW_CTL_IFACE); if ((result = libusb_release_interface(device, BW_CTL_IFACE)))
if (result) ERROR(error_3, "couldn't release interface: %s\n",
ERROR (error_3, "couldn't release interface: %s\n", libusb_error_name(result));
libusb_error_name (result));
error_3: error_3:
if (reattach_driver) if (reattach_driver) {
{ if ((result = libusb_attach_kernel_driver(device, BW_CTL_IFACE)))
result = libusb_attach_kernel_driver (device, BW_CTL_IFACE); ERROR(error_2, "couldn't reattach kernel driver: %s\n",
if (result) libusb_error_name(result));
ERROR (error_2, "couldn't reattach kernel driver: %s\n",
libusb_error_name (result));
} }
error_2: error_2:
libusb_close (device); libusb_close(device);
error_1: error_1:
libusb_exit (NULL); libusb_exit(NULL);
error_0: error_0:
return status; return status;
} }