重要文件由usb-serial.c ; generic.c ; usb.c ; option.c

從module_init(usb_serial_init)開始

//按照tty驅(qū)動(dòng)結(jié)構(gòu)，先創(chuàng)建"tty_driver"對(duì)象
alloc_tty_driver(SERIAL_TTY_MINIOR)

注冊(cè)總線usb-serial,之后很多驅(qū)動(dòng)及設(shè)備都會(huì)注冊(cè)到該總線上
bus_register(&usb_serial_bus_type)
關(guān)于
struct bus_type usb_serial_bus_type = {
 .name =  "usb-serial",
 .match = usb_serial_device_match,
 .probe = usb_serial_device_probe,
 .remove = usb_serial_device_remove,
 .drv_attrs =  drv_attrs,
};

為什么沒有注冊(cè)這個(gè)總線設(shè)備，device_register(usb_serial_bus)??

初始化tty_driver對(duì)象
usb_serial_tty_driver->name=..
.
.
.

設(shè)置tty_driver的操作函數(shù)fops
tty_set_operation(usb_serial_tty_driver,&serial_ops)

向tty核心注冊(cè)tty驅(qū)動(dòng)
tty_register_driver(usb_serial_tty_driver)

將usb_serial_driver驅(qū)動(dòng)注冊(cè)到usb總線上
usb_register(usb_serial_driver)
關(guān)于usb_serial_driver
static struct usb_driver usb_serial_driver = {
 .name =  "usbserial",
 .probe = usb_serial_probe,
 .disconnect = usb_serial_disconnect,
 .suspend = usb_serial_suspend,
 .resume = usb_serial_resume,
 .no_dynamic_id =  1,
};

最后注冊(cè)generic驅(qū)動(dòng)
usb_serial_generic_register(debug)

分析usb_serial_generic_register(debug)

保存idVendor generic_device_ids[0].idVendor=vendor

保存idProduct generic_device_ids[0].idProduct=idProduct

匹配類型generic_device_ids[0].match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;

將usb_serial_generic_device結(jié)構(gòu)體（未知是驅(qū)動(dòng)結(jié)構(gòu)體還是設(shè)備結(jié)構(gòu)體）注冊(cè)到usb-serial總線上
usb_serial_register(&usb_serial_generic_device)
關(guān)于usb_serial_generic_device

struct usb_serial_driver usb_serial_generic_device = {
 .driver = {
  .owner = THIS_MODULE,
  .name =  "generic",
 },
 .id_table =  generic_device_ids,
 .usb_driver =   &generic_driver,
 .num_interrupt_in = NUM_DONT_CARE,
 .num_bulk_in =  NUM_DONT_CARE,
 .num_bulk_out =  NUM_DONT_CARE,
 .num_ports =  1,
 .shutdown =  usb_serial_generic_shutdown,
 .throttle =  usb_serial_generic_throttle,
 .unthrottle =  usb_serial_generic_unthrottle,
 .resume =  usb_serial_generic_resume,
};

其中，usb_serial_driver是新定義的驅(qū)動(dòng)結(jié)構(gòu)體

將"generic_driver"注冊(cè)到usb總線上，目的是當(dāng)設(shè)備插入系統(tǒng)后，通過generic_driver的generic_probe
來(lái)匹配設(shè)備。因此。已經(jīng)注冊(cè)了兩個(gè)驅(qū)動(dòng)進(jìn)了usb總線
usb_register(&generic_driver)

關(guān)于generic_driver結(jié)構(gòu)體
static struct usb_driver generic_driver = {
 .name =  "usbserial_generic", //驅(qū)動(dòng)名稱
 .probe = generic_probe, //重要的匹配函數(shù)
 .disconnect = usb_serial_disconnect,
 .id_table = generic_serial_ids, //無(wú)用
 .no_dynamic_id = 1, //不支持動(dòng)態(tài)匹配
};

 

函數(shù) usb_serial_generic_register(int _debug)已經(jīng)整體分析完，下面分析該函數(shù)里面的usb_serial_register函數(shù)

 

為usb_serial_driver添加新的操作功能(open,write,close,....)
fixup_generic(struct usb_serial_driver* device)

將usb_serial_driver添加到usb-serial總線上的驅(qū)動(dòng)列表usb_serial_driver_list上
list_add(&driver->driver_list, &usb_serial_driver_list);

注冊(cè)驅(qū)動(dòng)到usb-serial總線上
usb_serial_bus_register(driver)

 

 

在usb總線上注冊(cè)了兩個(gè)驅(qū)動(dòng)"usbserial"和"usbserial_generic",那么當(dāng)插入設(shè)備的時(shí)候
究竟是匹配哪一個(gè)驅(qū)動(dòng)呢???????????????????????

現(xiàn)在似乎usb-serial總線和usb總線沒有什么聯(lián)系，好，那么就看generic_probe函數(shù)

id_pattern = usb_match_id(interface, generic_device_ids)
初步匹配

if (id_pattern != NULL)
 return usb_serial_probe(interface, id);
繼續(xù)匹配，尋找和其匹配的驅(qū)動(dòng)

 

usb中的probe函數(shù)的工作

1.初始化用于控制usb設(shè)備的局部結(jié)構(gòu)體
2.探測(cè)端點(diǎn)類型
3.保存相關(guān)局部結(jié)構(gòu)體的信息
4.把設(shè)備注冊(cè)到USB核心,以便與用戶程序監(jiān)護(hù)信息

 

另外一個(gè)匹配函數(shù)usn_serial_probe出場(chǎng)了

int usb_serial_probe(struct usb_interface *interface,const struct usb_device_id *id)

type = search_serial_device(interface);
獲取該設(shè)備匹配的驅(qū)動(dòng)，"struct usb_serial_driver* type"

獲取到設(shè)備之后，為該設(shè)備創(chuàng)建一個(gè)"usb_serial"對(duì)象
serial = create_serial (dev, interface, type)
(一般的驅(qū)動(dòng)程序都會(huì)為自己匹配設(shè)備創(chuàng)建一個(gè)用于描述設(shè)備的對(duì)象，在以后的所有操作中，
如讀寫等都會(huì)直接從這個(gè)對(duì)象獲取相應(yīng)的信息)

iface_desc = interface->cur_altsetting  //獲取設(shè)備接口的當(dāng)前設(shè)置

endpoint = &iface_desc->endpoint[i].desc
檢查當(dāng)前接口的端點(diǎn)類型，并保存，對(duì)于usb_serial_generic設(shè)備，常見的端點(diǎn)類型為bulkin和bulkout

port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL)
用struct usb_serial_port來(lái)描述一個(gè)tty端口，因?yàn)槊總€(gè)端口都有自己的工作模式
關(guān)于 struct usb_serial_port
struct usb_serial_port {
 struct usb_serial *serial;
 struct tty_struct *tty;
 spinlock_t  lock;
 struct mutex            mutex;
 unsigned char  number;

 unsigned char  *interrupt_in_buffer;
 struct urb  *interrupt_in_urb;
 __u8   interrupt_in_endpointAddress;

 unsigned char  *interrupt_out_buffer;
 int   interrupt_out_size;
 struct urb  *interrupt_out_urb;
 __u8   interrupt_out_endpointAddress;

 unsigned char  *bulk_in_buffer;
 int   bulk_in_size;
 struct urb  *read_urb;
 __u8   bulk_in_endpointAddress;

 unsigned char  *bulk_out_buffer;
 int   bulk_out_size;
 struct urb  *write_urb;
 int   write_urb_busy;
 __u8   bulk_out_endpointAddress;

 wait_queue_head_t write_wait;
 struct work_struct work;
 int   open_count;
 char   throttled;
 char   throttle_req;
 char   console;
 struct device  dev;
};

port->serial = serial
將usb_serial對(duì)象保存到usb_serial_port中，便于通過port來(lái)訪問serial

初始化bulk_in端點(diǎn)，保存到"usb_serial_port"（port對(duì)象中）
 for (i = 0; i < num_bulk_in; ++i) {
  endpoint = bulk_in_endpoint[i];
  port = serial->port[i];
  port->read_urb = usb_alloc_urb (0, GFP_KERNEL);//分配urb
  if (!port->read_urb) {
   dev_err(&interface->dev, "No free urbs available\n");
   goto probe_error;
  }
  buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
  port->bulk_in_size = buffer_size;
  port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
  port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);//創(chuàng)建DMA緩沖區(qū)
  if (!port->bulk_in_buffer) {
   dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
   goto probe_error;
  }
  usb_fill_bulk_urb (port->read_urb, dev,
       usb_rcvbulkpipe (dev,
             endpoint->bEndpointAddress),
       port->bulk_in_buffer, buffer_size,
       serial->type->read_bulk_callback,
       port);//在提交urb之前將其正確的初始化
}

同樣的方法初始化bulk_out端點(diǎn)
-----------------------------------------------------------------------------------------

初始化輸入中斷interrupt_in端點(diǎn)
 if (serial->type->read_int_callback) {//對(duì)于generic驅(qū)動(dòng)，read_int_callback指針為空
  for (i = 0; i < num_interrupt_in; ++i) {
   endpoint = interrupt_in_endpoint[i];
   port = serial->port[i];
   port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
   if (!port->interrupt_in_urb) {
    dev_err(&interface->dev, "No free urbs available\n");
    goto probe_error;
   }
   buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
   port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
   port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
   if (!port->interrupt_in_buffer) {
    dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
    goto probe_error;
   }
   usb_fill_int_urb (port->interrupt_in_urb, dev,
       usb_rcvintpipe (dev,
         endpoint->bEndpointAddress),
       port->interrupt_in_buffer, buffer_size,
       serial->type->read_int_callback, port,
       endpoint->bInterval);
  }
 } else if (num_interrupt_in) {
  dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
 }

同樣的方法初始化interrupt_out端點(diǎn)和attach
————————————————————————————————————————————-

usbserial模塊總共支持254個(gè)設(shè)備，他為每個(gè)設(shè)備分配了一個(gè)serial_table項(xiàng)，
用于保存"usb_serial"對(duì)象，方便以后直接通過minor號(hào)獲取"usbserial"對(duì)象

serial->minor = minor

注冊(cè)所有獨(dú)立的ports到驅(qū)動(dòng)核心
 /* register all of the individual ports with the driver core */
 for (i = 0; i < num_ports; ++i) {
  port = serial->port[i];
  port->dev.parent = &interface->dev;
  port->dev.driver = NULL;
  port->dev.bus = &usb_serial_bus_type;//驅(qū)動(dòng)的總線
  port->dev.release = &port_release;

  snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number); //設(shè)置端口名稱
  dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
  retval = device_register(&port->dev);  //重要，吧設(shè)備注冊(cè)到usb核心，以便與用戶程序交互信息
  if (retval)
   dev_err(&port->dev, "Error registering port device, "
    "continuing\n");
 }

 usb_serial_console_init (debug, minor); //初始化中斷控制臺(tái)

 usb_set_intfdata (interface, serial);//把serial結(jié)構(gòu)體保存到interface接口設(shè)備中，可以調(diào)用usb_get_intfdata來(lái)獲取數(shù)據(jù)。
 
 至此，probe函數(shù)完成了4個(gè)主要工作，probe函數(shù)也走到了盡頭

--------------------------------------------------------------------------------------------

到現(xiàn)在usb_serial_bus都沒怎么用到，也沒有看到這個(gè)設(shè)備和初始化時(shí)的tty_driver
綁定，這些東西都在了probe函數(shù)最后調(diào)用的device_register中。

device_register(&port->dev);

一下分析device_driver:
int device_register(struct device *dev)
{
 device_initialize(dev);
 return device_add(dev);
}

1.device_add():把設(shè)備device注冊(cè)到相應(yīng)的總線上。并創(chuàng)建device_file，最后
調(diào)用bus_attach_device()函數(shù)

->bus_attach_device調(diào)用device_attach(dev)
->bus_for_each_drv()遍歷bus上的每個(gè)driver，當(dāng)找到一個(gè)就用__device_attach()
來(lái)判斷匹配
->driver_probe_device(dev,drv)首先如果所有的driver所在總線由nach函數(shù)則
先調(diào)用match來(lái)匹配,如果匹配,直接調(diào)用really_probe(dev,drv)
->really_probe。判斷總線，如果由probe函數(shù)則調(diào)用和匹配它
->drv->probe:它是一類設(shè)備的probe,在他里面會(huì)調(diào)用具體某個(gè)drv的probe函數(shù)，
這個(gè)函數(shù)是在我們的驅(qū)動(dòng)程序里面注冊(cè)的

 

在該device_register里，

struct bus_type usb_serial_bus_type = {
 .name =  "usb-serial",
 .match = usb_serial_device_match,
 .probe = usb_serial_device_probe,
 .remove = usb_serial_device_remove,
 .drv_attrs =  drv_attrs,
};

所以會(huì)先調(diào)用usb_serial_device_match,進(jìn)行匹配

static int usb_serial_device_match (struct device *dev, struct device_driver *drv)
{
 struct usb_serial_driver *driver;
 const struct usb_serial_port *port;

 /*
  * drivers are already assigned to ports in serial_probe so it's
  * a simple check here.
  */
 port = to_usb_serial_port(dev);
 if (!port)
  return 0;

 driver = to_usb_serial_driver(drv);

 if (driver == port->serial->type)//將設(shè)備和驅(qū)動(dòng)進(jìn)行匹配
  return 1;

 return 0;
}

接下來(lái)調(diào)用probe函數(shù)，也就是usb_serial_device_probe

static int usb_serial_device_probe (struct device *dev)
{
 struct usb_serial_driver *driver;
 struct usb_serial_port *port;
 int retval = 0;
 int minor;

 port = to_usb_serial_port(dev);
 if (!port) {
  retval = -ENODEV;
  goto exit;
 }

 driver = port->serial->type;
 if (driver->port_probe) {
  if (!try_module_get(driver->driver.owner)) {
   dev_err(dev, "module get failed, exiting\n");
   retval = -EIO;
   goto exit;
  }
  retval = driver->port_probe (port);
  module_put(driver->driver.owner);
  if (retval)
   goto exit;
 }

 retval = device_create_file(dev, &dev_attr_port_number);
 if (retval)
  goto exit;

 minor = port->number;
 tty_register_device (usb_serial_tty_driver, minor, dev);
 dev_info(&port->serial->dev->dev,
   "%s converter now attached to ttyUSB%d\n",
   driver->description, minor);

exit:
 return retval;
}

其中，調(diào)用了tty_register_device將tty_driver和device綁定，注冊(cè)該驅(qū)動(dòng)控制的設(shè)備

到了這一步完成了tty和usb的注冊(cè)，同時(shí)也在/dev目錄下創(chuàng)建了相應(yīng)的設(shè)備文件，也就是說(shuō)應(yīng)用層可以使用這個(gè)設(shè)備了。

 

 

分析玩整個(gè)注冊(cè)過程，接下來(lái)當(dāng)然時(shí)分析它的讀寫過程了，讀寫過程相對(duì)來(lái)說(shuō)
會(huì)感覺容易一點(diǎn)，因?yàn)樗麄儧]有太多錯(cuò)綜復(fù)雜的關(guān)系，各功能函數(shù)相對(duì)獨(dú)立

 

要使用設(shè)備當(dāng)然要先打開這個(gè)設(shè)備了，應(yīng)用層調(diào)用open系統(tǒng)調(diào)用來(lái)打開這個(gè)設(shè)備，他最終
調(diào)用到tty_driver的open函數(shù)

static const struct tty_operations serial_ops = {
 .open =   serial_open,
 .close =  serial_close,
 .write =  serial_write,
 .write_room =  serial_write_room,
 .ioctl =  serial_ioctl,
 .set_termios =  serial_set_termios,
 .throttle =  serial_throttle,
 .unthrottle =  serial_unthrottle,
 .break_ctl =  serial_break,
 .chars_in_buffer = serial_chars_in_buffer,
 .read_proc =  serial_read_proc,
 .tiocmget =  serial_tiocmget,
 .tiocmset =  serial_tiocmset,
};

首先看serial_open函數(shù)：

serial = usb_serial_get_by_index(tty->index) //將tty指針（終端）中獲取相應(yīng)的usb_serial結(jié)構(gòu)體上

port = serial->port[portNumber]; //獲取設(shè)備對(duì)應(yīng)的port對(duì)象

++port->port.count;記錄打開次數(shù)

tty->driver_data=port; //保存相應(yīng)的port信息到該終端(tty)的私有指針里

serial->type->open(tty,port,flip);//usb_serial_generic_device.open=usb_serial_generic_open
所以，將會(huì)調(diào)用usb_serial_generic_open函數(shù)

一下分析int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)

int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
{
   ..
   ..
   ..
   ..

 /* if we have a bulk endpoint, start reading from it */
 //如果有bulk_in端點(diǎn)，就提交這個(gè)端點(diǎn)的urb，即讓系統(tǒng)開始在這個(gè)端點(diǎn)上接收
 來(lái)自設(shè)備端發(fā)過來(lái)的數(shù)據(jù)，當(dāng)數(shù)據(jù)收到后會(huì)調(diào)用serial->type->read_bulk_callback函數(shù)
 if (serial->num_bulk_in) {
  /* Start reading from the device */
  usb_fill_bulk_urb (port->read_urb, serial->dev,
       usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
       port->read_urb->transfer_buffer,
       port->read_urb->transfer_buffer_length,
       ((serial->type->read_bulk_callback) ?
         serial->type->read_bulk_callback :
         usb_serial_generic_read_bulk_callback),
       port);

  result = usb_submit_urb(port->read_urb, GFP_KERNEL);//使用函數(shù)usb_submit_urb   //將urb提交到usb_core，成功后若接受到數(shù)據(jù)將會(huì)執(zhí)行      //usb_serial_generic_read_bulk_callback
  if (result)
   dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
 }

 return result;
}

分析usb_serial_generic_read_bulk_callback(struct urb *urb)

void usb_serial_generic_read_bulk_callback (struct urb *urb)
{
 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 unsigned char *data = urb->transfer_buffer;
 int status = urb->status;
 unsigned long flags;
  ..
  ..
 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);

 /* Throttle the device if requested by tty */
 spin_lock_irqsave(&port->lock, flags);
 if (!(port->throttled = port->throttle_req)) {
  spin_unlock_irqrestore(&port->lock, flags);
  flush_and_resubmit_read_urb(port);
 } else {
  spin_unlock_irqrestore(&port->lock, flags);
 }
}
其中，調(diào)用函數(shù)flush_and_resubmit_read_urb(port)  //將數(shù)據(jù)放入tty驅(qū)動(dòng)的緩沖區(qū)中

/* Push data to tty layer and resubmit the bulk read URB */

static void flush_and_resubmit_read_urb (struct usb_serial_port *port)
{
 struct urb *urb = port->read_urb;
 struct tty_struct *tty = port->tty;
 int room;

 /* Push data to tty */
 if (tty && urb->actual_length) {
  room = tty_buffer_request_room(tty, urb->actual_length);
  if (room) {
   tty_insert_flip_string(tty, urb->transfer_buffer, room);
   tty_flip_buffer_push(tty);
  }
 }

 resubmit_read_urb(port, GFP_ATOMIC);//繼續(xù)傳輸
}

最后調(diào)用的函數(shù)resubmit_read_urb(port, GFP_ATOMIC);

static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags)
{
 struct urb *urb = port->read_urb;
 struct usb_serial *serial = port->serial;
 int result;

 /* Continue reading from device */
 usb_fill_bulk_urb (urb, serial->dev,
      usb_rcvbulkpipe (serial->dev,
            port->bulk_in_endpointAddress),
      urb->transfer_buffer,
      urb->transfer_buffer_length,
      ((serial->type->read_bulk_callback) ?
        serial->type->read_bulk_callback :
        usb_serial_generic_read_bulk_callback), port);
 result = usb_submit_urb(urb, mem_flags);
 if (result)
  dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
}

在函數(shù)里又調(diào)用了usb_submit_urb函數(shù)，起到遞歸的作用。
 至此，打開設(shè)備和讀設(shè)備的流程已經(jīng)寫完

 

 

最后看serial_write函數(shù)，該函數(shù)對(duì)應(yīng)了usb_serial_generic_write

int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *buf, int count)
{
 struct usb_serial *serial = port->serial;
   ..
   ..
   ..

 /* only do something if we have a bulk out endpoint */
 if (serial->num_bulk_out) {
  unsigned long flags;
  spin_lock_irqsave(&port->lock, flags);
  if (port->write_urb_busy) {
   spin_unlock_irqrestore(&port->lock, flags);
   dbg("%s - already writing", __FUNCTION__);
   return 0;
  }
  port->write_urb_busy = 1;
  spin_unlock_irqrestore(&port->lock, flags);

  count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
  //將數(shù)據(jù)存放進(jìn)urb中
  memcpy (port->write_urb->transfer_buffer, buf, count);
  data = port->write_urb->transfer_buffer;
  usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, data);

  /* set up our urb */
  //初始化urb
  usb_fill_bulk_urb (port->write_urb, serial->dev,
       usb_sndbulkpipe (serial->dev,
          port->bulk_out_endpointAddress),
       port->write_urb->transfer_buffer, count,
       ((serial->type->write_bulk_callback) ?
         serial->type->write_bulk_callback :
         usb_serial_generic_write_bulk_callback), port);

  /* send the data out the bulk port */
  port->write_urb_busy = 1;
  //提交urb到usb core中
  result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
   ..
   ..
}

當(dāng)serial_write函數(shù)的urb成功提交到usb_core后，若urb被成功的傳遞到USB設(shè)備后，將會(huì)調(diào)用回調(diào)函數(shù)
usb_serial_generic_write_bulk_callback

void usb_serial_generic_write_bulk_callback (struct urb *urb)
{
 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 int status = urb->status;

 dbg("%s - port %d", __FUNCTION__, port->number);

 port->write_urb_busy = 0;
 if (status) {
  dbg("%s - nonzero write bulk status received: %d",
      __FUNCTION__, status);
  return;
 }

 usb_serial_port_softint(port); //請(qǐng)求更多的傳輸
}