Linux usb子系统（三）：通过usbfs操作设备的用户空间驱动

/*
* 此文件仅用于同方USB加密模块设备访问程序，供客户使用，不建议客户修改
*
* 作者：宇浩然
* 时间：2012.04.21
*
*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <linux/usbdevice_fs.h>
#include <dirent.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

#include "tf09usb.h"

//此结构为内部使用，仅在搜索设备时读取pid vid时使用
struct usb_device_descriptor {
        unsigned char bLength;
        unsigned char bDescriptorType;
        unsigned short int bcdUSB;
        unsigned char bDeviceClass;
        unsigned char bDeviceSubClass;
        unsigned char bDeviceProtocol;
        unsigned char bMaxPacketSize0;
        unsigned short int idVendor;
        unsigned short int idProduct;
        unsigned short int bcdDevice;
        unsigned char iManufacturer;
        unsigned char iProduct;
        unsigned char iSerialNumber;
        unsigned char bNumConfigurations;
} __attribute__ ((packed));

const static char * usbpath[] = {"/dev/bus/usb", "/proc/bus/usb"}; //usb devfs可能存在的位置
tf09_device *tf09Device = NULL;



//定义CBW初始化常量，用于不同USB设备初始化时的复制
const CBW cbw_init = {{‘U‘,‘S‘,‘B‘,‘C‘}, {‘T‘,‘F‘,‘0‘,‘9‘},    //固定不变，任何时候都不进行读写操作
                {0,0,0,0},    //数据长度，每次使用前都必须设定一次，以小端方式存储的32位整数，目前只用低两位
                0,    //数据方向，每次使用前都必须设定一次，
                0,16, 0xd0,    //固定不变，任何时候都不进行读写操作
                {2, 1, 5, 0},    //与协议相关的指令标识，每次使用前必须设定
                {0,{{0,0,0,0,0}},{{0,0,0}},0,0}    //与协议指令相关的参数信息，每次使用前必须设定一次
            };

/*******************************************************************************
功能：搜索系统中符合参数的所有USB设备，同时完成通信前的所有准备工作。
注意：
作者：宇浩然
时间：2012.04.21
参数：idVendor即设备的VID, idProduct即设备的PID
返回值：NULL失败
*******************************************************************************/
tf09_device * tf09_find_device(short int idVendor, short int idProduct)
{
    DIR * usb_dir, *bus_dir;
    struct dirent *bus, *dev;
    char buspath[TF09_PATH_MAX], devpath[TF09_PATH_MAX];
    struct usb_device_descriptor dev_des;
    int fd, usb_index;    //查找usb设备的总线位置


    tf09_close();    //若之前已经查找过设备，则关闭所有设备，此函数可以确保tf09Device=NULL
    for(usb_index=0;usb_index<(sizeof(usbpath)/sizeof(char*));usb_index++)    //搜索并打开总线所在目录
    {
        usb_dir = opendir(usbpath[usb_index]);
        if (NULL != usb_dir)
            break;
    }
    if(NULL == usb_dir)
        return tf09Device;
    while(NULL != (bus=readdir(usb_dir))) //读取usb devfs下的每一项，即bus
    {
        if(!strchr("1234567890", bus->d_name[0])) //bus肯定以数字开头，其实全部都是数字
            continue;
        snprintf(buspath, TF09_PATH_MAX, "%s/%s", usbpath[usb_index], bus->d_name);
        bus_dir = opendir(buspath);
        if(NULL==bus_dir)
            continue;
        while(NULL!=(dev=readdir(bus_dir))) //读取总线目录下的每一项，即usb设备
        {
            if(!strchr("1234567890", dev->d_name[0]))
                continue;
            snprintf(devpath, TF09_PATH_MAX, "%s/%s", buspath, dev->d_name);
            if((fd = open(devpath, O_RDWR))<0)
                continue;
            if(read(fd, (void *)(&dev_des), sizeof(dev_des)) > 0 &&
                dev_des.idVendor==idVendor && dev_des.idProduct==idProduct) //客户需要的设备
            {
                tf09_device *tmp = (tf09_device*)malloc(sizeof(tf09_device));
                tmp->fd = fd;

                if(0 == tf09_init(tmp)){
                    tmp->next = tf09Device;
                    tf09Device = tmp;    //将新设备添加到tf09Device单向链表中
                }else{
                    close(fd);
                    free(tmp);    //通信前的初始化工作失败，关闭设备，并释放设备内存
                }
            }else{
                close(fd);
            }
            //已经打开的句柄另行处理，不需要在此关闭
        }
        closedir(bus_dir);
    }
    closedir(usb_dir);
    return tf09Device;
}

//给设备赋值
//ad
int tf09_set_device(const tf09_device * dev)
{
    //tf09Device = NULL;
    tf09Device=dev;
    tf09_init(tf09Device);
}

/*******************************************************************************
功能：在指定的USB设备上进行bulk写操作，无16KB限制
注意：
作者：宇浩然
时间：2012.04.21
参数：dev为设备指针，data为数据缓冲地址，size为缓冲区大小，timeout为时间
返回值： <0失败；其他为实际写入的字符数
*******************************************************************************/
int tf09_bulk_write(const tf09_device * dev,const void *data, int size, int timeout)
{
    if (NULL == dev)
        dev = tf09Device;
    if (NULL == dev || dev->fd <= 0 || NULL == data)
        return -1;

    return usb_bulk(dev->fd, 1, (void *)data, size, timeout);
}

/*******************************************************************************
功能：在指定的USB设备上进行bulk读操作，无16KB限制
注意：
作者：宇浩然
时间：2012.04.21
参数：dev为设备指针，data为数据缓冲地址，size计划读取的字符数，timeout为时间
返回值： <0失败；其他为实际读取的字符数
*******************************************************************************/
int tf09_bulk_read(const tf09_device * dev, void *data, int size, int timeout)
{
    if (NULL == dev)
        dev = tf09Device;
    if (NULL == dev || dev->fd <= 0 || NULL == data)
        return -1;

    return usb_bulk(dev->fd, 129, (void *)data, size, timeout);
}

/*******************************************************************************
功能：关闭所有的USB设备，并将tf09Device置空
注意：关闭设备后，若要再次使用，需要重新执行tf09_finddevice函数
作者：宇浩然
时间：2012.04.21
参数：无
返回值：无
*******************************************************************************/
void tf09_close(void)
{
    int i = 0;
//    while( (NULL != tf09Device) && (i < TF09_USB_DEVICE_MAX) )
//    {
//        tf09_device* devtmp = tf09Device;
//        tf09Device = tf09Device->next;
//
//        tf09_release_interface(devtmp);    //释放usb设备的interface
//
//        ioctl(devtmp->fd, USBDEVFS_RESET, NULL);
//
//        close(devtmp->fd);
//
//        free(devtmp);
//
//        i++;
//    }
    tf09Device = NULL;
}

void tf09_close_delete(void)
{
    int i = 0;
    while( (NULL != tf09Device) && (i < TF09_USB_DEVICE_MAX) )
    {
        tf09_device* devtmp = tf09Device;
        tf09Device = tf09Device->next;

        tf09_release_interface(devtmp);    //释放usb设备的interface

        ioctl(devtmp->fd, USBDEVFS_RESET, NULL);

        close(devtmp->fd);

        free(devtmp);

        i++;
    }
    tf09Device = NULL;
}

/*******************************************************************************
功能：初始化指定的USB设备完成通信前的准备工作，该设备已经打开
注意：此函数不需要客户调用
作者：宇浩然
时间：2012.04.21
参数：dev为设备指针
返回值：0成功 -1失败
*******************************************************************************/
static int tf09_init(tf09_device * dev)
{
    if(0==tf09_detach_driver(dev))
    {

        ioctl(dev->fd, USBDEVFS_RESETEP, NULL);    //附加驱动卸载后，将设备重置一次

    }
    unsigned char* pa = (unsigned char*)&(dev->cbw);
    unsigned char* pb = (unsigned char*)&cbw_init;
    int i=0;
    for(i=0;i<sizeof(CBW);i++)
        pa[i] = pb[i];
    return tf09_claim_interface(dev);
}

/*******************************************************************************
功能：从指定的USB设备上卸载内核驱动
注意：固定的卸载附加在interface 0上的驱动；此函数不需要客户调用
作者：宇浩然
时间：2012.04.21
参数：dev为设备指针
返回值：0成功 其他失败***********
*******************************************************************************/
static int tf09_detach_driver(tf09_device * dev)
{
    struct usbdevfs_ioctl comm = {0, USBDEVFS_DISCONNECT, NULL};
    return ioctl(dev->fd, USBDEVFS_IOCTL, &comm);
}

/*******************************************************************************
功能：在指定的USB设备上进行bulk读写操作；此函数屏蔽了内核16KB的限制
注意：用户不应该直接调用此函数
作者：宇浩然
时间：2011.12.26
参数：fd为设备handl，ep为端点号(1或129)，data为数据缓冲地址，size为缓冲区大小，timeout为时间
返回值：<0失败；其他为实际读或写的字符数
*******************************************************************************/
static int usb_bulk(int fd, int ep, void* data, int size, int timeout)
{
    int ret, currentsize, alreadysize=0;
    struct usbdevfs_bulktransfer bulk;
    bulk.ep = ep;
    bulk.timeout = timeout;

    while (alreadysize < size)
    {
        currentsize = size-alreadysize;
        if (currentsize > TF09_MAX_USB_SIZE)
            currentsize = TF09_MAX_USB_SIZE;
        bulk.len = currentsize;
        bulk.data = data;

        ret = ioctl(fd, USBDEVFS_BULK, &bulk);
        TF09_CHECK(ret, alreadysize);

        alreadysize += ret;
        if( 129 == ep && ret < currentsize)    //读取数据时，实际读取数据未达到指定长度
            break;
        data = (char*)data + ret;
    }
    return alreadysize;
}

/*******************************************************************************
功能：claim指定的USB设备的interface
注意：仅claim interface 0；此函数不需要客户调用
作者：宇浩然
时间：2012.04.21
参数：dev为设备指针
返回值：0为成功，<0失败
*******************************************************************************/
static int tf09_claim_interface(tf09_device * dev)
{
    unsigned int interface = 0;
    return ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
}

/*******************************************************************************
功能：与claim相反的操作
注意：仅interface 0；此函数不需要客户调用
作者：宇浩然
时间：2012.04.21
参数：dev为设备指针
返回值：0为成功，<0失败
*******************************************************************************/
static int tf09_release_interface(tf09_device * dev)
{
    unsigned int interface = 0;

    return ioctl(dev->fd, USBDEVFS_RELEASEINTERFACE, &interface);
}

/*******************************************************************************
功能：返回指定USB设备对应的CBW指针
注意：
作者：宇浩然
时间：2012.05.25
参数：dev：设备，若为空，则使用默认设备；
返回值： CBW指针，若为NULL，则失败
*******************************************************************************/
CBW* tf09_get_cbw(const tf09_device* dev)
{
    return (CBW*)(dev ? &(dev->cbw) : (tf09Device ? &(tf09Device->cbw) : NULL));
}

/*******************************************************************************
功能：返回指定USB设备对应的协议参数指针
注意：
作者：宇浩然
时间：2012.05.25
参数：dev：设备，若为空，则使用默认设备；
返回值： 协议参数指针，若为NULL，则失败
*******************************************************************************/
tf09_comm_para * tf09_get_comm_para(const tf09_device* dev)
{
    CBW* cbw = tf09_get_cbw((tf09_device*)dev);
    return cbw ? &(cbw->secPara) : NULL;
}

/*******************************************************************************
功能：回指定USB设备对应的协议参数指针，同时进行初始化
注意：
作者：宇浩然
时间：2012.04.22
参数：dev：设备，若为空，则使用默认设备；
返回值： 无
*******************************************************************************/
void tf09_comm_para_init(tf09_comm_para* secPara)
{
    unsigned int i;
    for(i=0;i<6;i++)
        ((unsigned char *)secPara)[i] = 0xff;
    for(;i<sizeof(tf09_comm_para);i++)
        ((unsigned char *)secPara)[i] = 0;
}

/* 我们简单看一下使用hid驱动寻找设备的实现，然后在看一下libusb是如何寻找设备的 */

int Device_Find( )
{    
    char dir_str[100];   /* 这个变量我们用来保存设备文件的目录路径 */
    char hiddev[100];    /* 这个变量用来保存设备文件的全路径 */ 

    DIR dir; 

    /* 申请的字符串数组清空，这个编程习惯要养成 */
    memset (dir_str, 0 , sizeof(dir_str));
    memset (hiddev, 0 , sizeof(hiddev)); 

    /* hiddev 的设备描述符不在/dev/usb/hid下面，就在/dev/usb下面
    这里我们使用opendir函数来检验目录的有效性
    打开目录返回的值保存在变量dir里，dir前面有声明 */
    dir = opendir("/dev/usb/hid");

    if (dir){    
        /* 程序运行到这里，说明存在 /dev/usb/hid 路径的目录 */
        sprintf(dir_str,"/dev/usb/hid/");
        closedir(dir);
    } else {
        /* 如果不存在hid目录，那么设备文件就在/dev/usb下 */
        sprintf(dir_str,"/dev/usb/");
    }
     
    /* DEVICE_MINOR 是指设备数，HID一般是16个 */
    for(i = 0; i < DEVICE_MINOR; i++) {
        /* 获得全路径的设备文件名，一般hid设备文件名是hiddev0 到 hiddev16 */
        sprintf(hiddev, "%shiddev%d", dir_str,i);
    
        /* 打开设备文件,获得文件句柄 */
        fd = open(hiddev, O_RDWR);
        if (fd > 0) {
            /* 操作设备获得设备信息 */
            ioctl(fd, HIDIOCGDEVINFO, &info);

            /* VENDOR_ID 和 PRODUCT_ID 是标识usb设备厂家和产品ID, 
            驱动都需要这两个参数来寻找设备,到此我们寻找到了设备 */
            if(info.vendor== VENDOR_ID && info.product== PRODUCT_ID) {
               /* 这里添加设备的初始化代码 */   
               device_num++;   /* 找到的设备数 */   
            }
            close(fd);
        }
    }

    return device_num;         /* 返回寻找的设备数量 */
}

int Device_Find()
{    
    struct usb_bus *busses;
    int device_num = 0;
    device_num = 0;     /* 记录设备数量 */
    
    usb_init();         /* 初始化 */
    usb_find_busses();  /* 寻找系统上的usb总线 */
    usb_find_devices(); /* 寻找usb总线上的usb设备 */    

    /* 获得系统总线链表的句柄 */
    busses = usb_get_busses();
    
    struct usb_bus *bus;

    /* 遍历总线 */   
    for (bus = busses; bus; bus = bus->next) {
        struct usb_device *dev;

        /* 遍历总线上的设备 */
        for (dev = bus->devices; dev; dev = dev->next) {
            /* 寻找到相关设备， */
            if ((dev->descriptor.idVendor == VENDOR_ID) 
                    && (dev->descriptor.idProduct == PRODUCT_ID)) {
               /* 这里添加设备的初始化代码 */
               device_num++;  /* 找到的设备数 */
            }
        }
    }

    return device_num;        /* 返回设备数量 */
}

struct usb_bus *bus;

for (bus = usb_busses; bus; bus = bus->next) {
    struct usb_device *dev;

    for (dev = bus->devices; dev; dev = dev->next) {
        /* 这里添加设备的初始化代码 */
    }
}

/* 使用hid驱动打开设备 */
int Device_Open()
{
    int handle;

    /* 传统HID驱动调用,通过open打开设备文件就可 */
    handle = open("hiddev0", O_RDONLY);
}

/* 使用libusb打开驱动 */
int Device_Open()
{
    /* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 */
    struct usb_device * udev;
    usb_dev_handle * device_handle;

    /* 当找到设备后，通过usb_open打开设备，这里的函数就相当open函数 */
    device_handle = usb_open(udev);
}

int Device_Report(int fd, unsigned char *buffer72)
{
    int ret; /* 保存ioctl函数的返回值 */
    int index;
    unsigned char send_data[72];  /* 发送的数据 */
    unsigned char recv_data[72];  /* 接收的数据 */
    struct hiddev_usage_ref uref; /* hid驱动定义的数据包 */
    struct hiddev_report_info rinfo; /* hid驱动定义的 */
   
    memset(send_data, 0, sizeof(send_data));
    memset(recv_data, 0, sizeof(recv_data));  
    memcpy(send_data, buffer72, 72);

    /* 这在发送数据之前必须调用的，初始化设备 */
    ret = ioctl(fd, HIDIOCINITREPORT, 0);
    if (ret != 0) {
        return NOT_OPENED_DEVICE;/* NOT_OPENED_DEVICE 属于自己定义宏 */
    }

    /* HID设备每次传输一个字节的数据包 */
    for(index = 0; index < 72; index++) {
        /* 设置发送数据的状态 */
        uref.report_type = HID_REPORT_TYPE_FEATURE;
        uref.report_id = HID_REPORT_ID_FIRST;
        uref.usage_index = index;
        uref.field_index = 0;
        uref.value = send_data[index];

        ioctl(fd, HIDIOCGUCODE, &uref);

        ret = ioctl(fd, HIDIOCSUSAGE, &uref);
        if (ret != 0) {    
            return UNKNOWN_ERROR;
        }
    }

    /* 发送数据 */
    rinfo.report_type = HID_REPORT_TYPE_FEATURE;
    rinfo.report_id = HID_REPORT_ID_FIRST;
    rinfo.num_fields = 1;

    ret=ioctl(fd, HIDIOCSREPORT, &rinfo);   /* 发送数据 */
    if (ret != 0) {
        return WRITE_REPORT;
    }

    /* 接受数据 */
    ret = ioctl(fd, HIDIOCINITREPORT, 0);

    for (index = 0; index < 72; index++) {
        uref.report_type = HID_REPORT_TYPE_FEATURE;
        uref.report_id = HID_REPORT_ID_FIRST;
        uref.usage_index = index;
        uref.field_index = 0;

        ioctl(fd, HIDIOCGUCODE, &uref);

        ret = ioctl(fd, HIDIOCGUSAGE, &uref);
        if (ret != 0) {
            return UNKNOWN_ERROR;
        }

        recv_data[index] = uref.value;
    }
    memcpy(buffer72, recv_data, 72);
    return SUCCESS;
}

int Device_Report(int fd, unsigned char *buffer72)
{
    /* 定义设备句柄 */
    usb_dev_handle* Device_handle;      

    /* save the data of send and receive */
    unsigned char   send_data[72];
    unsigned char   recv_data[72];
    int             send_len;
    int             recv_len;
 
    /* 数据置空 */
    memset(send_data, 0 , sizeof(send_data));
    memset(recv_data, 0 , sizeof(recv_data));

    /* 这里的g_list是全局的数据变量，里面可以存储相关设备的所需信息， 
    当然我们 也可以从函数形参中传输进来，设备的信息在打开设备时初始化，
    我们将在后面的总结中详细描述一下 */
    Device_handle = (usb_dev_handle*)(g_list[fd].device_handle);
    if (Device_handle == NULL) {
        return NOT_OPENED_DEVICE;
    }   

    /* 这个函数前面已经说过，在操作设备前是必须调用的, 0是指用默认的设备 */
    usb_claim_interface(Device_handle, 0);       

    /* 发送数据，所用到的宏定义在usb.h可以找到，我列出来大家看一下
       #define USB_ENDPOINT_OUT     (0x00)
       #define USB_TYPE_CLASS       (0x01 << 5)
       #define USB_RECIP_INTERFACE  (0x01)
       #define HID_REPORT_SET       (0x09) */
    send_len = usb_control_msg(Device_handle,
        　　　　　　　　　　　　　　USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
        　　　　　　　　　　　　　　HID_REPORT_SET, 0x300, 0, send_data, 72, USB_TIMEOUT);

    /* 发送数据有错误 */
    if (send_len < 0) {
        return WRITE_REPORT;
    }

    if (send_len != 72) {
        return send_len;
    }       

    /* 接受数据   
       #define USB_ENDPOINT_IN         (0x80)
       #define USB_TYPE_CLASS          (0x01 << 5)
       #define USB_RECIP_INTERFACE     (0x01)
       #define HID_REPORT_GET          (0x01)
    */   
    recv_len = usb_control_msg(Device_handle,    
        　　　　　　　　　　　　　　USB_ENDPOINT_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
        　　　　　　　　　　　　　　HID_REPORT_GET, 0x300, 0, recv_data, 72, USB_TIMEOUT);

    if (recv_len < 0) {
        printf("failed to retrieve report from USB device!/n");
        return READ_REPORT;
    }
       
    if (recv_len != 72) {
        return recv_len;
    }

    /* 和usb_claim_interface对应 */
    usb_release_interface(RY2_handle, 0);
    memcpy(buffer72, recv_data, 72);

    return SUCCESS;
}

/* 使用hid驱动关闭设备 */
int Device_Close()
{
    int handle;
 
    handle = open("hiddev0", O_RDONLY);

    /* 传统HID驱动调用,通过close()设备文件就可 */
    close( handle );
}

/* 使用libusb关闭驱动 */
int Device_Close()
{
    /* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 */
    struct usb_device *  udev;
    usb_dev_handle *     device_handle;     

    device_handle = usb_open(udev);

    /* libusb库使用usb_close关闭程序 */
    usb_close(device_handle);
}

#include <usb.h>    

/* usb.h这个头文件是要包括的，里面包含了必须要用到的数据结构 */   
/* 我们将一个设备的属性用一个结构体来概括 */
typedef struct   
{   
　　struct usb_device*    udev;
    usb_dev_handle*       device_handle;
    /* 这里可以添加设备的其他属性，这里只列出每个设备要用到的属性 */
} device_descript;
     
/* 用来设置传输数据的时间延迟 */
#define USB_TIMEOUT     10000   

/* 厂家ID 和产品 ID */   
#define VENDOR_ID    0xffff
#define PRODUCT_ID   0xffff    

/* 这里定义数组来保存设备的相关属性，DEVICE_MINOR可以设置能够同
时操作的设备数量，用全局变量的目的在于方便保存属性 */
#define DEVICE_MINOR 16
int     g_num;    
device_descript g_list[ DEVICE_MINOR ];
    
/* 我们写个设备先找到设备，并把相关信息保存在 g_list 中 */
int Device_Find()
{
    struct usb_bus    *bus;
    struct usb_device *dev;
    g_num = 0;    
    usb_find_busses();
    usb_find_devices();       

    /* 寻找设备 */
    for (bus = usb_busses; bus; bus = bus->next) {
        for (dev = bus->devices; dev; dev = dev->next) {
            if(dev->descriptor.idVendor==VENDOR_ID 
                    && dev->descriptor.idProduct == PRODUCT_ID) {
                /* 保存设备信息 */   
                if (g_num < DEVICE_MINOR) {
                    g_list[g_num].udev = dev;
                    g_num ++;
                }
            }
        }
    }
    return g_num;
}    

/* 找到设备后，我们根据信息打开设备 */
int Device_Open()    
{    
    /* 根据情况打开你所需要操作的设备，这里我们仅列出伪代码 */
    if(g_list[g_num].udev != NULL) {    
        g_list[g_num].device_handle = usb_open(g_list[g_num].udev);
    }
}

/* 下面就是操作设备的函数了，我们就不列出来拉，大家可以参考上面的介绍 */
int DeviceWite(int handle)    
{    
    /* 填写相关代码，具体查看设备协议*/
}

int DeviceOpen(int handle)    
{    
    /* 填写相关代码，具体查看设备协议 */
}

/* 最后不要忘记关闭设备 */
void Device_close(int handle)
{    
    /* 调用usb_close */
}