[linux-block.git] / tools / usb / usbip / libsrc / usbip_common.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2005-2007 Takahiro Hirofuchi
 */

#ifndef __USBIP_COMMON_H
#define __USBIP_COMMON_H

#include <libudev.h>

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <syslog.h>
#include <unistd.h>
#include <linux/usb/ch9.h>
#include <linux/usbip.h>

#ifndef USBIDS_FILE
#define USBIDS_FILE "/usr/share/hwdata/usb.ids"
#endif

#ifndef VHCI_STATE_PATH
#define VHCI_STATE_PATH "/var/run/vhci_hcd"
#endif

#define VUDC_DEVICE_DESCR_FILE "dev_desc"

/* kernel module names */
#define USBIP_CORE_MOD_NAME	"usbip-core"
#define USBIP_HOST_DRV_NAME	"usbip-host"
#define USBIP_DEVICE_DRV_NAME	"usbip-vudc"
#define USBIP_VHCI_DRV_NAME	"vhci_hcd"

/* sysfs constants */
#define SYSFS_MNT_PATH         "/sys"
#define SYSFS_BUS_NAME         "bus"
#define SYSFS_BUS_TYPE         "usb"
#define SYSFS_DRIVERS_NAME     "drivers"

#define SYSFS_PATH_MAX		256
#define SYSFS_BUS_ID_SIZE	32

extern int usbip_use_syslog;
extern int usbip_use_stderr;
extern int usbip_use_debug ;

#define PROGNAME "usbip"

#define pr_fmt(fmt)	"%s: %s: " fmt "\n", PROGNAME
#define dbg_fmt(fmt)	pr_fmt("%s:%d:[%s] " fmt), "debug",	\
		        __FILE__, __LINE__, __func__

#define err(fmt, args...)						\
	do {								\
		if (usbip_use_syslog) {					\
			syslog(LOG_ERR, pr_fmt(fmt), "error", ##args);	\
		}							\
		if (usbip_use_stderr) {					\
			fprintf(stderr, pr_fmt(fmt), "error", ##args);	\
		}							\
	} while (0)

#define info(fmt, args...)						\
	do {								\
		if (usbip_use_syslog) {					\
			syslog(LOG_INFO, pr_fmt(fmt), "info", ##args);	\
		}							\
		if (usbip_use_stderr) {					\
			fprintf(stderr, pr_fmt(fmt), "info", ##args);	\
		}							\
	} while (0)

#define dbg(fmt, args...)						\
	do {								\
	if (usbip_use_debug) {						\
		if (usbip_use_syslog) {					\
			syslog(LOG_DEBUG, dbg_fmt(fmt), ##args);	\
		}							\
		if (usbip_use_stderr) {					\
			fprintf(stderr, dbg_fmt(fmt), ##args);		\
		}							\
	}								\
	} while (0)

#define BUG()						\
	do {						\
		err("sorry, it's a bug!");		\
		abort();				\
	} while (0)

struct usbip_usb_interface {
	uint8_t bInterfaceClass;
	uint8_t bInterfaceSubClass;
	uint8_t bInterfaceProtocol;
	uint8_t padding;	/* alignment */
} __attribute__((packed));

struct usbip_usb_device {
	char path[SYSFS_PATH_MAX];
	char busid[SYSFS_BUS_ID_SIZE];

	uint32_t busnum;
	uint32_t devnum;
	uint32_t speed;

	uint16_t idVendor;
	uint16_t idProduct;
	uint16_t bcdDevice;

	uint8_t bDeviceClass;
	uint8_t bDeviceSubClass;
	uint8_t bDeviceProtocol;
	uint8_t bConfigurationValue;
	uint8_t bNumConfigurations;
	uint8_t bNumInterfaces;
} __attribute__((packed));

#define to_string(s)	#s

void dump_usb_interface(struct usbip_usb_interface *);
void dump_usb_device(struct usbip_usb_device *);
int read_usb_device(struct udev_device *sdev, struct usbip_usb_device *udev);
int read_attr_value(struct udev_device *dev, const char *name,
		    const char *format);
int read_usb_interface(struct usbip_usb_device *udev, int i,
		       struct usbip_usb_interface *uinf);

const char *usbip_speed_string(int num);
const char *usbip_status_string(int32_t status);

int usbip_names_init(char *);
void usbip_names_free(void);
void usbip_names_get_product(char *buff, size_t size, uint16_t vendor,
			     uint16_t product);
void usbip_names_get_class(char *buff, size_t size, uint8_t class,
			   uint8_t subclass, uint8_t protocol);

#endif /* __USBIP_COMMON_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
0945b4fe TH	2	/*
	3	* Copyright (C) 2005-2007 Takahiro Hirofuchi
	4	*/
	5
4fd83e84	6	#ifndef __USBIP_COMMON_H
	7	#define __USBIP_COMMON_H
	8
021aed84	9	#include <libudev.h>
0945b4fe	10
0945b4fe	11	#include <stdint.h>
0945b4fe	12	#include <stdio.h>
0945b4fe	13	#include <stdlib.h>
4fd83e84	14	#include <string.h>
0945b4fe	15
4fd83e84	16	#include <syslog.h>
4fd83e84	17	#include <unistd.h>
d1fd43d7	18	#include <linux/usb/ch9.h>
6fa9e1be	19	#include <linux/usbip.h>
0945b4fe TH	20
	21	#ifndef USBIDS_FILE
	22	#define USBIDS_FILE "/usr/share/hwdata/usb.ids"
	23	#endif
	24
	25	#ifndef VHCI_STATE_PATH
	26	#define VHCI_STATE_PATH "/var/run/vhci_hcd"
	27	#endif
	28
7b3f74f7 KO	29	#define VUDC_DEVICE_DESCR_FILE "dev_desc"
7b3f74f7 KO	30
5a285cf5	31	/* kernel module names */
	32	#define USBIP_CORE_MOD_NAME "usbip-core"
	33	#define USBIP_HOST_DRV_NAME "usbip-host"
7b3f74f7	34	#define USBIP_DEVICE_DRV_NAME "usbip-vudc"
5a285cf5	35	#define USBIP_VHCI_DRV_NAME "vhci_hcd"
5a285cf5	36
1e940319 VM	37	/* sysfs constants */
	38	#define SYSFS_MNT_PATH "/sys"
	39	#define SYSFS_BUS_NAME "bus"
	40	#define SYSFS_BUS_TYPE "usb"
	41	#define SYSFS_DRIVERS_NAME "drivers"
	42
	43	#define SYSFS_PATH_MAX 256
	44	#define SYSFS_BUS_ID_SIZE 32
	45
0945b4fe TH	46	extern int usbip_use_syslog;
	47	extern int usbip_use_stderr;
	48	extern int usbip_use_debug ;
	49
213fd4ad	50	#define PROGNAME "usbip"
	51
	52	#define pr_fmt(fmt) "%s: %s: " fmt "\n", PROGNAME
	53	#define dbg_fmt(fmt) pr_fmt("%s:%d:[%s] " fmt), "debug", \
f8628a47	54	__FILE__, __LINE__, __func__
213fd4ad	55
	56	#define err(fmt, args...) \
	57	do { \
	58	if (usbip_use_syslog) { \
	59	syslog(LOG_ERR, pr_fmt(fmt), "error", ##args); \
	60	} \
	61	if (usbip_use_stderr) { \
	62	fprintf(stderr, pr_fmt(fmt), "error", ##args); \
	63	} \
	64	} while (0)
	65
	66	#define info(fmt, args...) \
	67	do { \
	68	if (usbip_use_syslog) { \
	69	syslog(LOG_INFO, pr_fmt(fmt), "info", ##args); \
	70	} \
	71	if (usbip_use_stderr) { \
	72	fprintf(stderr, pr_fmt(fmt), "info", ##args); \
	73	} \
	74	} while (0)
	75
	76	#define dbg(fmt, args...) \
	77	do { \
	78	if (usbip_use_debug) { \
	79	if (usbip_use_syslog) { \
	80	syslog(LOG_DEBUG, dbg_fmt(fmt), ##args); \
	81	} \
	82	if (usbip_use_stderr) { \
	83	fprintf(stderr, dbg_fmt(fmt), ##args); \
	84	} \
	85	} \
	86	} while (0)
	87
	88	#define BUG() \
	89	do { \
	90	err("sorry, it's a bug!"); \
	91	abort(); \
	92	} while (0)
0945b4fe	93
35dd0c2d	94	struct usbip_usb_interface {
0945b4fe TH	95	uint8_t bInterfaceClass;
	96	uint8_t bInterfaceSubClass;
	97	uint8_t bInterfaceProtocol;
	98	uint8_t padding; /* alignment */
	99	} __attribute__((packed));
	100
35dd0c2d	101	struct usbip_usb_device {
0945b4fe TH	102	char path[SYSFS_PATH_MAX];
	103	char busid[SYSFS_BUS_ID_SIZE];
	104
	105	uint32_t busnum;
	106	uint32_t devnum;
	107	uint32_t speed;
	108
	109	uint16_t idVendor;
	110	uint16_t idProduct;
	111	uint16_t bcdDevice;
	112
	113	uint8_t bDeviceClass;
	114	uint8_t bDeviceSubClass;
	115	uint8_t bDeviceProtocol;
	116	uint8_t bConfigurationValue;
	117	uint8_t bNumConfigurations;
	118	uint8_t bNumInterfaces;
	119	} __attribute__((packed));
	120
	121	#define to_string(s) #s
	122
35dd0c2d	123	void dump_usb_interface(struct usbip_usb_interface *);
35dd0c2d	124	void dump_usb_device(struct usbip_usb_device *);
021aed84 VM	125	int read_usb_device(struct udev_device sdev, struct usbip_usb_device udev);
021aed84 VM	126	int read_attr_value(struct udev_device dev, const char name,
9db91e1b	127	const char *format);
35dd0c2d	128	int read_usb_interface(struct usbip_usb_device *udev, int i,
35dd0c2d	129	struct usbip_usb_interface *uinf);
0945b4fe TH	130
	131	const char *usbip_speed_string(int num);
	132	const char *usbip_status_string(int32_t status);
	133
	134	int usbip_names_init(char *);
	135	void usbip_names_free(void);
9db91e1b KK	136	void usbip_names_get_product(char *buff, size_t size, uint16_t vendor,
	137	uint16_t product);
	138	void usbip_names_get_class(char *buff, size_t size, uint8_t class,
	139	uint8_t subclass, uint8_t protocol);
0945b4fe	140
4fd83e84	141	#endif /* __USBIP_COMMON_H */