/*

* Copyright (C) 2006 Free Software Initiative of Japan

*

* Author: NIIBE Yutaka <gniibe at fsij.org>

*

* This file can be distributed under the terms and conditions of the

* GNU General Public License version 2 (or later).

*

*/

#include <errno.h>

#include <usb.h>

#include <stdio.h>

#include <string.h>

#define DEBUG_PRINT 0

#define USB_RT_HUB (USB_TYPE_CLASS | USB_RECIP_DEVICE)

#define USB_RT_PORT (USB_TYPE_CLASS | USB_RECIP_OTHER)

#define USB_PORT_FEAT_POWER 8

#define USB_PORT_FEAT_INDICATOR 22

#define USB_DIR_IN 0x80 /* to host */

#define COMMAND_SET_NONE 0

#define COMMAND_SET_LED 1

#define COMMAND_SET_POWER 2

#define HUB_LED_GREEN 2

static void

usage (const char *progname)

{

fprintf (stderr,

"Usage: %s [{-h HUBNUM | -b BUSNUM -d DEVNUM}] \\\n"

" [-P PORT] [{-p [VALUE]|-l [VALUE]}]\n", progname);

}

static void

exit_with_usage (const char *progname)

{

usage (progname);

exit (1);

}

#define HUB_CHAR_LPSM 0x0003

#define HUB_CHAR_PORTIND 0x0080

struct usb_hub_descriptor {

};

#define CTRL_TIMEOUT 1000

#define USB_STATUS_SIZE 4

#define MAX_HUBS 128

struct hub_info {

};

static struct hub_info hubs[MAX_HUBS];

static int number_of_hubs_with_feature;

static void

hub_port_status (usb_dev_handle *uh, int nport)

{

int i;

printf(" Hub Port Status:\n");

for (i = 0; i < nport; i++)

{

char buf[USB_STATUS_SIZE];

int ret;

ret = usb_control_msg (uh,

USB_ENDPOINT_IN | USB_TYPE_CLASS | USB_RECIP_OTHER,

USB_REQ_GET_STATUS,

0, i + 1,

buf, USB_STATUS_SIZE,

CTRL_TIMEOUT);

if (ret < 0)

{

fprintf (stderr,

"cannot read port %d status, %s (%d)\n",

i + 1, strerror(errno), errno);

break;

}

printf(" Port %d: %02x%02x.%02x%02x", i + 1,

buf[3], buf [2],

buf[1], buf [0]);

printf("%s%s%s%s%s",

(buf[2] & 0x10) ? " C_RESET" : "",

(buf[2] & 0x08) ? " C_OC" : "",

(buf[2] & 0x04) ? " C_SUSPEND" : "",

(buf[2] & 0x02) ? " C_ENABLE" : "",

(buf[2] & 0x01) ? " C_CONNECT" : "");

printf("%s%s%s%s%s%s%s%s%s%s\n",

(buf[1] & 0x10) ? " indicator" : "",

(buf[1] & 0x08) ? " test" : "",

(buf[1] & 0x04) ? " highspeed" : "",

(buf[1] & 0x02) ? " lowspeed" : "",

(buf[1] & 0x01) ? " power" : "",

(buf[0] & 0x10) ? " RESET" : "",

(buf[0] & 0x08) ? " oc" : "",

(buf[0] & 0x04) ? " suspend" : "",

(buf[0] & 0x02) ? " enable" : "",

(buf[0] & 0x01) ? " connect" : "");

}

}

static int

usb_find_hubs (

int *p_return_busnum //* atoi (bus->dirname)

,int *p_return_devnum

,int listing, int verbose, int busnum, int devnum, int hub)

{

struct usb_bus *busses;

struct usb_bus *bus;

number_of_hubs_with_feature = 0;

busses = usb_get_busses();

if (busses == NULL)

{

perror ("failed to access USB");

return -1;

}

for (bus = busses; bus; bus = bus->next)

{

struct usb_device *dev;

for (dev = bus->devices; dev; dev = dev->next)

{

usb_dev_handle *uh;

int print = 0;

if (dev->descriptor.bDeviceClass != USB_CLASS_HUB)

continue;

if (listing

|| (verbose

&& ((atoi (bus->dirname) == busnum && dev->devnum == devnum)

|| hub == number_of_hubs_with_feature)))

print = 1;

uh = usb_open (dev);

if (uh != NULL)

{

char buf[1024];

int len;

int nport;

struct usb_hub_descriptor *uhd = (struct usb_hub_descriptor *)buf;

if ((len = usb_control_msg (uh, USB_DIR_IN | USB_RT_HUB,

USB_REQ_GET_DESCRIPTOR,

USB_DT_HUB << 8, 0,

buf, sizeof (buf), CTRL_TIMEOUT))

> sizeof (struct usb_hub_descriptor))

{

if (!(uhd->wHubCharacteristics[0] & HUB_CHAR_PORTIND)

&& (uhd->wHubCharacteristics[0] & HUB_CHAR_LPSM) >= 2)

continue;

if (print){

#if DEBUG_PRINT

printf ("Hub #%d at %s:%03d\n",

number_of_hubs_with_feature,

bus->dirname, dev->devnum);

#endif

*p_return_busnum = atoi (bus->dirname);

*p_return_devnum = dev->devnum;

}

#if DEBUG_PRINT

switch ((uhd->wHubCharacteristics[0] & HUB_CHAR_LPSM))

{

case 0:

if (print)

fprintf (stderr, " INFO: ganged switching.\n");

break;

case 1:

if (print)

fprintf (stderr, " INFO: individual power switching.\n");

break;

case 2:

case 3:

if (print)

fprintf (stderr, " WARN: No power switching.\n");

break;

}

#endif

if (print

&& !(uhd->wHubCharacteristics[0] & HUB_CHAR_PORTIND))

fprintf (stderr, " WARN: Port indicators are NOT supported.\n");

}

else

{

perror ("Can't get hub descriptor");

usb_close (uh);

continue;

}

nport = buf[2];

hubs[number_of_hubs_with_feature].busnum = atoi (bus->dirname);

hubs[number_of_hubs_with_feature].devnum = dev->devnum;

hubs[number_of_hubs_with_feature].dev = dev;

hubs[number_of_hubs_with_feature].indicator_support =

(uhd->wHubCharacteristics[0] & HUB_CHAR_PORTIND)? 1 : 0;

hubs[number_of_hubs_with_feature].nport = nport;

number_of_hubs_with_feature++;

if (verbose)

hub_port_status (uh, nport);

usb_close (uh);

}

}

}

return number_of_hubs_with_feature;

}

int

get_hub (int busnum, int devnum)

{

int i;

for (i = 0; i < number_of_hubs_with_feature; i++)

if (hubs[i].busnum == busnum && hubs[i].devnum == devnum)

return i;

return -1;

}

/*

* HUB-CTRL - program to control port power/led of USB hub

*

* # hub-ctrl // List hubs available

* # hub-ctrl -P 1 // Power off at port 1

* # hub-ctrl -P 1 -p 1 // Power on at port 1

* # hub-ctrl -P 2 -l // LED on at port 1

*

* Requirement: USB hub which implements port power control / indicator control

*

* Work fine:

* Elecom's U2H-G4S: www.elecom.co.jp (indicator depends on power)

* 04b4:6560

*

* Sanwa Supply's USB-HUB14GPH: www.sanwa.co.jp (indicators don't)

*

* Targus, Inc.'s PAUH212: www.targus.com (indicators don't)

* 04cc:1521

*

* Hawking Technology's UH214: hawkingtech.com (indicators don't)

*

*/

int usb_hub_port1_power_ctr(int value)

//main (int argc, const char *argv[])

{

int busnum = 0, devnum = 0;

int cmd = COMMAND_SET_NONE;

int port = 1;

//int value = 0;

int request, feature, index;

int result = 0;

int listing = 0;

int verbose = 0;

int hub = -1;

usb_dev_handle *uh = NULL;

int i;

#if 0

if (argc == 1)

listing = 1;

for (i = 1; i < argc; i++)

if (argv[i][0] == '-')

switch (argv[i][1])

{

case 'h':

if (++i >= argc || busnum > 0 || devnum > 0)

exit_with_usage (argv[0]);

hub = atoi (argv[i]);

break;

case 'b':

if (++i >= argc || hub >= 0)

exit_with_usage (argv[0]);

busnum = atoi (argv[i]);

break;

case 'd':

if (++i >= argc || hub >= 0)

exit_with_usage (argv[0]);

devnum = atoi (argv[i]);

break;

case 'P':

if (++i >= argc)

exit_with_usage (argv[0]);

port = atoi (argv[i]);

break;

case 'l':

if (cmd != COMMAND_SET_NONE)

exit_with_usage (argv[0]);

if (++i < argc)

value = atoi (argv[i]);

else

value = HUB_LED_GREEN;

cmd = COMMAND_SET_LED;

break;

case 'p':

if (cmd != COMMAND_SET_NONE)

exit_with_usage (argv[0]);

if (++i < argc)

value = atoi (argv[i]);

else

value= 0;

cmd = COMMAND_SET_POWER;

break;

case 'v':

verbose = 1;

if (argc == 2)

listing = 1;

break;

default:

exit_with_usage (argv[0]);

}

else

exit_with_usage (argv[0]);

if ((busnum > 0 && devnum <= 0) || (busnum <= 0 && devnum > 0))

/* BUS is specified, but DEV is'nt, or ... */

exit_with_usage (argv[0]);

#else

listing = 1;

int return_busnum, return_devnum ;

int *p_return_busnum = & return_busnum ;

int *p_return_devnum = & return_devnum ;

#endif

/* Default is the hub #0 */

if (hub < 0 && busnum == 0)

hub = 0;

/* Default is POWER */

if (cmd == COMMAND_SET_NONE)

cmd = COMMAND_SET_POWER;

usb_init ();

usb_find_busses ();

usb_find_devices ();

if (

usb_find_hubs (

p_return_busnum,p_return_devnum

,listing, verbose, busnum, devnum, hub)

//usb_find_hubs (listing, verbose, busnum, devnum, hub)

<= 0)

{

fprintf (stderr, "No hubs found.\n");

exit (1);

}

else

{

//printf ("Hub %d:%d\n",return_busnum,return_devnum);

busnum=return_busnum;

devnum=return_devnum;

}

#if 0

if (listing)

exit (0);

#endif

if (hub < 0)

hub = get_hub (busnum, devnum);

if (hub >= 0 && hub < number_of_hubs_with_feature)

uh = usb_open (hubs[hub].dev);

if (uh == NULL)

{

fprintf (stderr, "Device not found.\n");

result = 1;

}

else

{

if (cmd == COMMAND_SET_POWER)

if (value)

{

request = USB_REQ_SET_FEATURE;

feature = USB_PORT_FEAT_POWER;

index = port;

}

else

{

request = USB_REQ_CLEAR_FEATURE;

feature = USB_PORT_FEAT_POWER;

index = port;

}

else

{

request = USB_REQ_SET_FEATURE;

feature = USB_PORT_FEAT_INDICATOR;

index = (value << 8) | port;

}

if (verbose)

printf ("Send control message (REQUEST=%d, FEATURE=%d, INDEX=%d)\n",

request, feature, index);

if (usb_control_msg (uh, USB_RT_PORT, request, feature, index,

NULL, 0, CTRL_TIMEOUT) < 0)

{

perror ("failed to control.\n");

result = 1;

}

if (verbose)

hub_port_status (uh, hubs[hub].nport);

usb_close (uh);

}

//exit (result);

return (result);

}

#if 0

int

main (int argc, const char *argv[])

{

usb_hub_port1_power_ctr(0) ; //off

//usb_hub_port1_power_ctr(1) ; //on

}

#endif