For (channel = 0; channel

　　/* 对一个适配器的每个通道中的设备进行识别 */

　　…

　　For (id=0; id

　　/* 对一个通道中的每个ID对应设备进行识别 */

　　…

　　　　For (lun=1; lun

　　　　/* 对一个ID对应设备的每个LUN进行识别 */

　　　　…

　　　　}

　　}

}

struct scsi_device {

struct Scsi_Host *host;                     /* 与scsi device相关的scsi host */

struct request_queue *request_queue;         /* 块设备接口的请求队列 */

unsigned int device_busy;                    /* 命令执行标记 */

struct list_head cmd_list;                     /* scsi_cmnd队列 */

struct scsi_cmnd *current_cmnd;        /* 当前执行的命令 */

unsigned int id, lun, channel;              /* SCSI设备的标识 */

void *hostdata;               /* 通常指向low-level driver定义的scsi device */

…

} __attribute__((aligned(sizeof(unsigned long))));

static int scsi_probe_and_add_lun(struct scsi_target *starget,

uint lun, int *bflagsp,

struct scsi_device **sdevp, int rescan,

void *hostdata)

{

struct scsi_device *sdev;

unsigned char *result;

int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

/*

* The rescan flag is used as an optimization, the first scan of a

* host adapter calls into here with rescan == 0.

*/

sdev = scsi_device_lookup_by_target(starget, lun);

if (sdev) {

if (rescan || sdev->sdev_state != SDEV_CREATED) {

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

"scsi scan: device exists on %s/n",

sdev->sdev_gendev.bus_id));

if (sdevp)

*sdevp = sdev;

else

scsi_device_put(sdev);

if (bflagsp)

*bflagsp = scsi_get_device_flags(sdev,

sdev->vendor,

sdev->model);

return SCSI_SCAN_LUN_PRESENT;

}

scsi_device_put(sdev);

} else

sdev = scsi_alloc_sdev(starget, lun, hostdata);

if (!sdev)

goto out;

result = kmalloc(result_len, GFP_ATOMIC |

((shost->unchecked_isa_dma) ? __GFP_DMA : 0));

if (!result)

goto out_free_sdev;

if (scsi_probe_lun(sdev, result, result_len, &bflags))

goto out_free_result;

if (bflagsp)

*bflagsp = bflags;

/*

* result contains valid SCSI INQUIRY data.

*/

if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {

/*

* For a Peripheral qualifier 3 (011b), the SCSI

* spec says: The device server is not capable of

* supporting a physical device on this logical

* unit.

*

* For disks, this implies that there is no

* logical disk configured at sdev->lun, but there

* is a target id responding.

*/

SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"

" peripheral qualifier of 3, device not"

" added/n"))

if (lun == 0) {

SCSI_LOG_SCAN_BUS(1, {

unsigned char vend[9];

unsigned char mod[17];

sdev_printk(KERN_INFO, sdev,

"scsi scan: consider passing scsi_mod."

"dev_flags=%s:%s:0x240 or 0x800240/n",

scsi_inq_str(vend, result, 8, 16),

scsi_inq_str(mod, result, 16, 32));

});

}

res = SCSI_SCAN_TARGET_PRESENT;

goto out_free_result;

}

/*

* Non-standard SCSI targets may set the PDT to 0x1f (unknown or

* no device type) instead of using the Peripheral Qualifier to

* indicate that no LUN is present.  For example, USB UFI does this.

*/

if (starget->pdt_1f_for_no_lun && (result[0] & 0x1f) == 0x1f) {

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

"scsi scan: peripheral device type"

" of 31, no device added/n"));

res = SCSI_SCAN_TARGET_PRESENT;

goto out_free_result;

}

res = scsi_add_lun(sdev, result, &bflags);

if (res == SCSI_SCAN_LUN_PRESENT) {

if (bflags & BLIST_KEY) {

sdev->lockable = 0;

scsi_unlock_floptical(sdev, result);

}

}

out_free_result:

kfree(result);

out_free_sdev:

if (res == SCSI_SCAN_LUN_PRESENT) {

if (sdevp) {

if (scsi_device_get(sdev) == 0) {

*sdevp = sdev;

} else {

__scsi_remove_device(sdev);

res = SCSI_SCAN_NO_RESPONSE;

}

}

} else

scsi_destroy_sdev(sdev);

out:

return res;

}

struct scsi_target {

struct scsi_device   *starget_sdev_user;              /* 当前活动的scsi device */

struct list_head       siblings;

struct list_head       devices;                        /* scsi device链表 */

struct device          dev;

unsigned int           reap_ref;

unsigned int           channel;                      /* 当前channel号 */

unsigned int           id;                           /* scsi target的ID号 */

…

} __attribute__((aligned(sizeof(unsigned long))));

struct Scsi_Host {

struct list_head       __devices;                    /* scsi device链表 */

struct list_head       __targets;

struct scsi_host_template *hostt;                /* scsi host操作接口方法 */

struct scsi_transport_template *transportt;        /* scsi host transport方法 */

unsigned int host_busy;                       /* scsi host忙标记 */

unsigned int host_failed;                      /* commands that failed. */

unsigned int max_id;                         /* 最大的scsi node数量 */

unsigned int max_lun;                        /* 最大的lun数量 */

unsigned int max_channel;                     /* 最大的channel数量 */

unsigned char max_cmd_len;                   /* scsi命令的长度 */

int this_id;                                  /* scsi host在总线的id */

int can_queue;                    /* scsi cmd是否可以queue在host标记 */

short cmd_per_lun;                /* 每个lun可以queue多少scsi cmd */

short unsigned int sg_tablesize;       /* scatter-gather table大小 */

short unsigned int max_sectors;

……

};

struct scsi_host_template {

/* scsi middle level层驱动通过该函数将scsi command提交给low level层驱动，并且告 诉low level驱动完成scsi命令之后需要调用done（）函数 */

int (* queuecommand)(struct scsi_cmnd *,

void (*done)(struct scsi_cmnd *));

……

/* scsi host出错处理函数 */

int (* eh_abort_handler)(struct scsi_cmnd *);

int (* eh_device_reset_handler)(struct scsi_cmnd *);

int (* eh_bus_reset_handler)(struct scsi_cmnd *);

int (* eh_host_reset_handler)(struct scsi_cmnd *);

/* 更改scsi设备的队列深度 */

int (* change_queue_depth)(struct scsi_device *, int);

int can_queue;                      /* scsi host队列深度 */

int this_id;                           /* scsi host的ID号 */

unsigned short sg_tablesize;   /* scatter-gather table的容量 */

short cmd_per_lun;                     /* 每个lun能够queue的命令数 */

unsigned emulated:1;             /* 虚拟scsi host flag */

};

struct scsi_host_template usb_stor_host_template = {

/* basic userland interface stuff */

.name =                        "usb-storage",

.proc_name =                "usb-storage",

.proc_info =                 proc_info,

.info =                         host_info,

/* command interface -- queued only */

.queuecommand =                queuecommand,

/* error and abort handlers */

.eh_abort_handler =              command_abort,

.eh_device_reset_handler =    device_reset,

.eh_bus_reset_handler =        bus_reset,

/* queue commands only, only one command per LUN */

.can_queue =                1,

.cmd_per_lun =                    1,

/* unknown initiator id */

.this_id =               -1,

.slave_alloc =                slave_alloc,

.slave_configure =         slave_configure,

/* lots of sg segments can be handled */

.sg_tablesize =                     SG_ALL,

/* limit the total size of a transfer to 120 KB */

.max_sectors =                  240,

/* merge commands... this seems to help performance, but

* periodically someone should test to see which setting is more

* optimal.

*/

.use_clustering =           1,

/* emulated HBA */

.emulated =                  1,

/* we do our own delay after a device or bus reset */

.skip_settle_delay =              1,

/* sysfs device attributes */

.sdev_attrs =                 sysfs_device_attr_list,

/* module management */

.module =                     THIS_MODULE

};