开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
scsi_scan.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：28k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

scsi_scan.c：源码内容
  1. /*
  2.  *  scsi_scan.c Copyright (C) 2000 Eric Youngdale
  3.  *
  4.  *  Bus scan logic.
  5.  *
  6.  *  This used to live in scsi.c, but that file was just a laundry basket
  7.  *  full of misc stuff.  This got separated out in order to make things
  8.  *  clearer.
  9.  */
  11. #define __NO_VERSION__
  12. #include <linux/config.h>
  13. #include <linux/module.h>
  14. #include <linux/init.h>
  16. #include <linux/blk.h>
  18. #include "scsi.h"
  19. #include "hosts.h"
  20. #include "constants.h"
  22. #ifdef CONFIG_KMOD
  23. #include <linux/kmod.h>
  24. #endif
  26. /* 
  27.  * Flags for irregular SCSI devices that need special treatment 
  28.  */
  29. #define BLIST_NOLUN      0x001 /* Don't scan for LUNs */
  30. #define BLIST_FORCELUN   0x002 /* Known to have LUNs, force sanning */
  31. #define BLIST_BORKEN     0x004 /* Flag for broken handshaking */
  32. #define BLIST_KEY        0x008 /* Needs to be unlocked by special command */
  33. #define BLIST_SINGLELUN  0x010 /* LUNs should better not be used in parallel */
  34. #define BLIST_NOTQ 0x020 /* Buggy Tagged Command Queuing */
  35. #define BLIST_SPARSELUN  0x040 /* Non consecutive LUN numbering */
  36. #define BLIST_MAX5LUN 0x080 /* Avoid LUNS >= 5 */
  37. #define BLIST_ISDISK     0x100 /* Treat as (removable) disk */
  38. #define BLIST_ISROM      0x200 /* Treat as (removable) CD-ROM */
  39. #define BLIST_LARGELUN 0x400 /* LUNs larger than 7 despite reporting as SCSI 2 */
  41. static void print_inquiry(unsigned char *data);
  42. static int scan_scsis_single(unsigned int channel, unsigned int dev,
  43. unsigned int lun, int lun0_scsi_level, 
  44. unsigned int *max_scsi_dev, unsigned int *sparse_lun, 
  45. Scsi_Device ** SDpnt, struct Scsi_Host *shpnt, 
  46. char *scsi_result);
  47. static int find_lun0_scsi_level(unsigned int channel, unsigned int dev,
  48. struct Scsi_Host *shpnt);
  50. struct dev_info {
  51. const char *vendor;
  52. const char *model;
  53. const char *revision; /* Latest revision known to be bad.  Not used yet */
  54. unsigned flags;
  55. };
  57. /*
  58.  * This is what was previously known as the blacklist.  The concept
  59.  * has been expanded so that we can specify other types of things we
  60.  * need to be aware of.
  61.  */
  62. static struct dev_info device_list[] =
  63. {
  64. /* The following devices are known not to tolerate a lun != 0 scan for
  65.  * one reason or another.  Some will respond to all luns, others will
  66.  * lock up.
  67.  */
  68. {"Aashima", "IMAGERY 2400SP", "1.03", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  69. {"CHINON", "CD-ROM CDS-431", "H42", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  70. {"CHINON", "CD-ROM CDS-535", "Q14", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  71. {"DENON", "DRD-25X", "V", BLIST_NOLUN}, /* Locks up if probed for lun != 0 */
  72. {"HITACHI", "DK312C", "CM81", BLIST_NOLUN}, /* Responds to all lun - dtg */
  73. {"HITACHI", "DK314C", "CR21", BLIST_NOLUN}, /* responds to all lun */
  74. {"IMS", "CDD521/10", "2.06", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
  75. {"MAXTOR", "XT-3280", "PR02", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
  76. {"MAXTOR", "XT-4380S", "B3C", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
  77. {"MAXTOR", "MXT-1240S", "I1.2", BLIST_NOLUN}, /* Locks up when LUN>0 polled */
  78. {"MAXTOR", "XT-4170S", "B5A", BLIST_NOLUN}, /* Locks-up sometimes when LUN>0 polled. */
  79. {"MAXTOR", "XT-8760S", "B7B", BLIST_NOLUN}, /* guess what? */
  80. {"MEDIAVIS", "RENO CD-ROMX2A", "2.03", BLIST_NOLUN}, /*Responds to all lun */
  81. {"NEC", "CD-ROM DRIVE:841", "1.0", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
  82. {"PHILIPS", "PCA80SC", "V4-2", BLIST_NOLUN}, /* Responds to all lun */
  83. {"RODIME", "RO3000S", "2.33", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  84. {"SANYO", "CRD-250S", "1.20", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
  85.  * for aha152x controller, which causes
  86.  * SCSI code to reset bus.*/
  87. {"SEAGATE", "ST157N", "04|j", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
  88.  * for aha152x controller, which causes
  89.  * SCSI code to reset bus.*/
  90. {"SEAGATE", "ST296", "921", BLIST_NOLUN}, /* Responds to all lun */
  91. {"SEAGATE", "ST1581", "6538", BLIST_NOLUN}, /* Responds to all lun */
  92. {"SONY", "CD-ROM CDU-541", "4.3d", BLIST_NOLUN},
  93. {"SONY", "CD-ROM CDU-55S", "1.0i", BLIST_NOLUN},
  94. {"SONY", "CD-ROM CDU-561", "1.7x", BLIST_NOLUN},
  95. {"SONY", "CD-ROM CDU-8012", "*", BLIST_NOLUN},
  96. {"TANDBERG", "TDC 3600", "U07", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  97. {"TEAC", "CD-R55S", "1.0H", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  98. {"TEAC", "CD-ROM", "1.06", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
  99.  * for seagate controller, which causes
  100.  * SCSI code to reset bus.*/
  101. {"TEAC", "MT-2ST/45S2-27", "RV M", BLIST_NOLUN}, /* Responds to all lun */
  102. {"TEXEL", "CD-ROM", "1.06", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
  103.  * for seagate controller, which causes
  104.  * SCSI code to reset bus.*/
  105. {"QUANTUM", "LPS525S", "3110", BLIST_NOLUN}, /* Locks sometimes if polled for lun != 0 */
  106. {"QUANTUM", "PD1225S", "3110", BLIST_NOLUN}, /* Locks sometimes if polled for lun != 0 */
  107. {"QUANTUM", "FIREBALL ST4.3S", "0F0C", BLIST_NOLUN}, /* Locks up when polled for lun != 0 */
  108. {"MEDIAVIS", "CDR-H93MV", "1.31", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  109. {"SANKYO", "CP525", "6.64", BLIST_NOLUN}, /* causes failed REQ SENSE, extra reset */
  110. {"HP", "C1750A", "3226", BLIST_NOLUN}, /* scanjet iic */
  111. {"HP", "C1790A", "", BLIST_NOLUN}, /* scanjet iip */
  112. {"HP", "C2500A", "", BLIST_NOLUN}, /* scanjet iicx */
  113. {"HP", "A6188A", "*", BLIST_SPARSELUN}, /* HP Va7100 Array */
  114. {"HP", "A6189A", "*", BLIST_SPARSELUN}, /* HP Va7400 Array */
  115. {"HP", "A6189B", "*", BLIST_SPARSELUN}, /* HP Va7410 Array */
  116. {"YAMAHA", "CDR100", "1.00", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  117. {"YAMAHA", "CDR102", "1.00", BLIST_NOLUN}, /* Locks up if polled for lun != 0  
  118.  * extra reset */
  119. {"YAMAHA", "CRW8424S", "1.0", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  120. {"YAMAHA", "CRW6416S", "1.0c", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  121. {"MITSUMI", "CD-R CR-2201CS", "6119", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
  122. {"RELISYS", "Scorpio", "*", BLIST_NOLUN}, /* responds to all LUN */
  123. {"RELISYS", "VM3530+", "*", BLIST_NOLUN}, /* responds to all LUN */
  124. {"ACROSS", "", "*", BLIST_NOLUN}, /* responds to all LUN */
  125. {"MICROTEK", "ScanMaker II", "5.61", BLIST_NOLUN}, /* responds to all LUN */
  127. /*
  128.  * Other types of devices that have special flags.
  129.  */
  130. {"SONY", "CD-ROM CDU-8001", "*", BLIST_BORKEN},
  131. {"TEXEL", "CD-ROM", "1.06", BLIST_BORKEN},
  132. {"IOMEGA", "Io20S         *F", "*", BLIST_KEY},
  133. {"INSITE", "Floptical   F*8I", "*", BLIST_KEY},
  134. {"INSITE", "I325VM", "*", BLIST_KEY},
  135. {"LASOUND","CDX7405","3.10", BLIST_MAX5LUN | BLIST_SINGLELUN},
  136. {"MICROP", "4110", "*", BLIST_NOTQ}, /* Buggy Tagged Queuing */
  137. {"NRC", "MBR-7", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  138. {"NRC", "MBR-7.4", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  139. {"REGAL", "CDC-4X", "*", BLIST_MAX5LUN | BLIST_SINGLELUN},
  140. {"NAKAMICH", "MJ-4.8S", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  141. {"NAKAMICH", "MJ-5.16S", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  142. {"PIONEER", "CD-ROM DRM-600", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  143. {"PIONEER", "CD-ROM DRM-602X", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  144. {"PIONEER", "CD-ROM DRM-604X", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  145. {"EMULEX", "MD21/S2     ESDI", "*", BLIST_SINGLELUN},
  146. {"CANON", "IPUBJD", "*", BLIST_SPARSELUN},
  147. {"nCipher", "Fastness Crypto", "*", BLIST_FORCELUN},
  148. {"DEC","HSG80","*", BLIST_FORCELUN},
  149. {"COMPAQ","LOGICAL VOLUME","*", BLIST_FORCELUN},
  150. {"COMPAQ","CR3500","*", BLIST_FORCELUN},
  151. {"NEC", "PD-1 ODX654P", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  152. {"MATSHITA", "PD-1", "*", BLIST_FORCELUN | BLIST_SINGLELUN},
  153. {"iomega", "jaz 1GB", "J.86", BLIST_NOTQ | BLIST_NOLUN},
  154.   {"TOSHIBA","CDROM","*", BLIST_ISROM},
  155.   {"TOSHIBA","CD-ROM","*", BLIST_ISROM},
  156. {"MegaRAID", "LD", "*", BLIST_FORCELUN},
  157. {"DGC",  "RAID",      "*", BLIST_SPARSELUN | BLIST_LARGELUN}, // Dell PV 650F (tgt @ LUN 0)
  158. {"DGC",  "DISK",      "*", BLIST_SPARSELUN | BLIST_LARGELUN}, // Dell PV 650F (no tgt @ LUN 0) 
  159. {"DELL", "PV660F",   "*", BLIST_SPARSELUN | BLIST_LARGELUN},
  160. {"DELL", "PV660F   PSEUDO",   "*", BLIST_SPARSELUN | BLIST_LARGELUN},
  161. {"DELL", "PSEUDO DEVICE .",   "*", BLIST_SPARSELUN | BLIST_LARGELUN}, // Dell PV 530F
  162. {"DELL", "PV530F",    "*", BLIST_SPARSELUN | BLIST_LARGELUN}, // Dell PV 530F
  163. {"EMC", "SYMMETRIX", "*", BLIST_SPARSELUN | BLIST_LARGELUN | BLIST_FORCELUN},
  164. {"HP", "A6189A", "*", BLIST_SPARSELUN |  BLIST_LARGELUN}, // HP VA7400, by Alar Aun
  165. {"HP", "OPEN-", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, /* HP XP Arrays */
  166. {"CMD", "CRA-7280", "*", BLIST_SPARSELUN | BLIST_LARGELUN},   // CMD RAID Controller
  167. {"CNSI", "G7324", "*", BLIST_SPARSELUN | BLIST_LARGELUN},     // Chaparral G7324 RAID
  168. {"CNSi", "G8324", "*", BLIST_SPARSELUN},     // Chaparral G8324 RAID
  169. {"Zzyzx", "RocketStor 500S", "*", BLIST_SPARSELUN},
  170. {"Zzyzx", "RocketStor 2000", "*", BLIST_SPARSELUN},
  171. {"SONY", "TSL",       "*", BLIST_FORCELUN},  // DDS3 & DDS4 autoloaders
  172. {"DELL", "PERCRAID", "*", BLIST_FORCELUN},
  173. {"HP", "NetRAID-4M", "*", BLIST_FORCELUN},
  174. {"ADAPTEC", "AACRAID", "*", BLIST_FORCELUN},
  175. {"ADAPTEC", "Adaptec 5400S", "*", BLIST_FORCELUN},
  176. {"COMPAQ", "MSA1000", "*", BLIST_FORCELUN},
  177. {"HP", "C1557A", "*", BLIST_FORCELUN},
  178. {"IBM", "AuSaV1S2", "*", BLIST_FORCELUN},
  179. {"FSC", "CentricStor", "*", BLIST_SPARSELUN | BLIST_LARGELUN},
  180. {"DDN", "SAN DataDirector", "*", BLIST_SPARSELUN},
  181. {"HITACHI", "DF400", "*", BLIST_SPARSELUN},
  182. {"HITACHI", "DF500", "*", BLIST_SPARSELUN},
  183. {"HITACHI", "DF600", "*", BLIST_SPARSELUN},
  184. {"IBM", "ProFibre 4000R", "*", BLIST_SPARSELUN | BLIST_LARGELUN},
  186. /*
  187.  * Must be at end of list...
  188.  */
  189. {NULL, NULL, NULL}
  190. };
  192. #define MAX_SCSI_LUNS 0xFFFFFFFF
  194. #ifdef CONFIG_SCSI_MULTI_LUN
  195. static unsigned int max_scsi_luns = MAX_SCSI_LUNS;
  196. #else
  197. static unsigned int max_scsi_luns = 1;
  198. #endif
  200. #ifdef MODULE
  202. MODULE_PARM(max_scsi_luns, "i");
  203. MODULE_PARM_DESC(max_scsi_luns, "last scsi LUN (should be between 1 and 2^32-1)");
  205. #else
  207. static int __init scsi_luns_setup(char *str)
  208. {
  209. unsigned int tmp;
  211. if (get_option(&str, &tmp) == 1) {
  212. max_scsi_luns = tmp;
  213. return 1;
  214. } else {
  215. printk("scsi_luns_setup : usage max_scsi_luns=n "
  216.        "(n should be between 1 and 2^32-1)n");
  217. return 0;
  218. }
  219. }
  221. __setup("max_scsi_luns=", scsi_luns_setup);
  223. #endif
  225. static void print_inquiry(unsigned char *data)
  226. {
  227. int i;
  229. printk("  Vendor: ");
  230. for (i = 8; i < 16; i++) {
  231. if (data[i] >= 0x20 && i < data[4] + 5)
  232. printk("%c", data[i]);
  233. else
  234. printk(" ");
  235. }
  237. printk("  Model: ");
  238. for (i = 16; i < 32; i++) {
  239. if (data[i] >= 0x20 && i < data[4] + 5)
  240. printk("%c", data[i]);
  241. else
  242. printk(" ");
  243. }
  245. printk("  Rev: ");
  246. for (i = 32; i < 36; i++) {
  247. if (data[i] >= 0x20 && i < data[4] + 5)
  248. printk("%c", data[i]);
  249. else
  250. printk(" ");
  251. }
  253. printk("n");
  255. i = data[0] & 0x1f;
  257. printk("  Type:   %s ",
  258.        i < MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] : "Unknown          ");
  259. printk("                 ANSI SCSI revision: %02x", data[2] & 0x07);
  260. if ((data[2] & 0x07) == 1 && (data[3] & 0x0f) == 1)
  261. printk(" CCSn");
  262. else
  263. printk("n");
  264. }
  266. static int get_device_flags(unsigned char *response_data)
  267. {
  268. int i = 0;
  269. unsigned char *pnt;
  270. for (i = 0; 1; i++) {
  271. if (device_list[i].vendor == NULL)
  272. return 0;
  273. pnt = &response_data[8];
  274. while (*pnt && *pnt == ' ')
  275. pnt++;
  276. if (memcmp(device_list[i].vendor, pnt,
  277.    strlen(device_list[i].vendor)))
  278. continue;
  279. pnt = &response_data[16];
  280. while (*pnt && *pnt == ' ')
  281. pnt++;
  282. if (memcmp(device_list[i].model, pnt,
  283.    strlen(device_list[i].model)))
  284. continue;
  285. return device_list[i].flags;
  286. }
  287. return 0;
  288. }
  290. /*
  291.  *  Detecting SCSI devices :
  292.  *  We scan all present host adapter's busses,  from ID 0 to ID (max_id).
  293.  *  We use the INQUIRY command, determine device type, and pass the ID /
  294.  *  lun address of all sequential devices to the tape driver, all random
  295.  *  devices to the disk driver.
  296.  */
  297. void scan_scsis(struct Scsi_Host *shpnt,
  298.        uint hardcoded,
  299.        uint hchannel,
  300.        uint hid,
  301.        uint hlun)
  302. {
  303. uint channel;
  304. unsigned int dev;
  305. unsigned int lun;
  306. unsigned int max_dev_lun;
  307. unsigned char *scsi_result;
  308. unsigned char scsi_result0[256];
  309. Scsi_Device *SDpnt;
  310. Scsi_Device *SDtail;
  311. unsigned int sparse_lun;
  312. int lun0_sl;
  314. scsi_result = NULL;
  316. SDpnt = (Scsi_Device *) kmalloc(sizeof(Scsi_Device),
  317. GFP_ATOMIC);
  318. if (SDpnt) {
  319. memset(SDpnt, 0, sizeof(Scsi_Device));
  320. /*
  321.  * Register the queue for the device.  All I/O requests will
  322.  * come in through here.  We also need to register a pointer to
  323.  * ourselves, since the queue handler won't know what device
  324.  * the queue actually represents.   We could look it up, but it
  325.  * is pointless work.
  326.  */
  327. scsi_initialize_queue(SDpnt, shpnt);
  328. SDpnt->request_queue.queuedata = (void *) SDpnt;
  329. /* Make sure we have something that is valid for DMA purposes */
  330. scsi_result = ((!shpnt->unchecked_isa_dma)
  331.        ? &scsi_result0[0] : kmalloc(512, GFP_DMA));
  332. }
  334. if (scsi_result == NULL) {
  335. printk("Unable to obtain scsi_result buffern");
  336. goto leave;
  337. }
  338. /*
  339.  * We must chain ourself in the host_queue, so commands can time out 
  340.  */
  341. SDpnt->queue_depth = 1;
  342. SDpnt->host = shpnt;
  343. SDpnt->online = TRUE;
  345. initialize_merge_fn(SDpnt);
  347.         /*
  348.          * Initialize the object that we will use to wait for command blocks.
  349.          */
  350. init_waitqueue_head(&SDpnt->scpnt_wait);
  352. /*
  353.  * Next, hook the device to the host in question.
  354.  */
  355. SDpnt->prev = NULL;
  356. SDpnt->next = NULL;
  357. if (shpnt->host_queue != NULL) {
  358. SDtail = shpnt->host_queue;
  359. while (SDtail->next != NULL)
  360. SDtail = SDtail->next;
  362. SDtail->next = SDpnt;
  363. SDpnt->prev = SDtail;
  364. } else {
  365. shpnt->host_queue = SDpnt;
  366. }
  368. /*
  369.  * We need to increment the counter for this one device so we can track
  370.  * when things are quiet.
  371.  */
  372. if (hardcoded == 1) {
  373. Scsi_Device *oldSDpnt = SDpnt;
  374. struct Scsi_Device_Template *sdtpnt;
  375. channel = hchannel;
  376. if (channel > shpnt->max_channel)
  377. goto leave;
  378. dev = hid;
  379. if (dev >= shpnt->max_id)
  380. goto leave;
  381. lun = hlun;
  382. if (lun >= shpnt->max_lun)
  383. goto leave;
  384. if ((0 == lun) || (lun > 7))
  385. lun0_sl = SCSI_3; /* actually don't care for 0 == lun */
  386. else
  387. lun0_sl = find_lun0_scsi_level(channel, dev, shpnt);
  388. scan_scsis_single(channel, dev, lun, lun0_sl, &max_dev_lun, 
  389.   &sparse_lun, &SDpnt, shpnt, scsi_result);
  390. if (SDpnt != oldSDpnt) {
  392. /* it could happen the blockdevice hasn't yet been inited */
  393. /* queue_depth() moved from scsi_proc_info() so that
  394.    it is called before scsi_build_commandblocks() */
  395. if (shpnt->select_queue_depths != NULL)
  396. (shpnt->select_queue_depths)(shpnt,
  397.      shpnt->host_queue);
  399. for (sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
  400. if (sdtpnt->init && sdtpnt->dev_noticed)
  401. (*sdtpnt->init) ();
  403. for (sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next) {
  404. if (sdtpnt->attach) {
  405. (*sdtpnt->attach) (oldSDpnt);
  406. if (oldSDpnt->attached) {
  407. scsi_build_commandblocks(oldSDpnt);
  408. if (0 == oldSDpnt->has_cmdblocks) {
  409. printk("scan_scsis: DANGER, no command blocksn");
  410. /* What to do now ?? */
  411. }
  412. }
  413. }
  414. }
  415. scsi_resize_dma_pool();
  417. for (sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next) {
  418. if (sdtpnt->finish && sdtpnt->nr_dev) {
  419. (*sdtpnt->finish) ();
  420. }
  421. }
  422. }
  423. } else {
  424. /* Actual LUN. PC ordering is 0->n IBM/spec ordering is n->0 */
  425. int order_dev;
  427. for (channel = 0; channel <= shpnt->max_channel; channel++) {
  428. for (dev = 0; dev < shpnt->max_id; ++dev) {
  429. if (shpnt->reverse_ordering)
  430. /* Shift to scanning 15,14,13... or 7,6,5,4, */
  431. order_dev = shpnt->max_id - dev - 1;
  432. else
  433. order_dev = dev;
  435. if (shpnt->this_id != order_dev) {
  437. /*
  438.  * We need the for so our continue, etc. work fine. We put this in
  439.  * a variable so that we can override it during the scan if we
  440.  * detect a device *KNOWN* to have multiple logical units.
  441.  */
  442. max_dev_lun = (max_scsi_luns < shpnt->max_lun ?
  443.  max_scsi_luns : shpnt->max_lun);
  444. sparse_lun = 0;
  445. for (lun = 0, lun0_sl = SCSI_2; lun < max_dev_lun; ++lun) {
  446. /* don't probe further for luns > 7 for targets <= SCSI_2 */
  447. if ((lun0_sl < SCSI_3) && (lun > 7))
  448. break;
  450. if (!scan_scsis_single(channel, order_dev, lun, lun0_sl,
  451.          &max_dev_lun, &sparse_lun, &SDpnt, shpnt,
  452.        scsi_result)
  453.     && !sparse_lun)
  454. break; /* break means don't probe further for luns!=0 */
  455. if (SDpnt && (0 == lun)) {
  456. int bflags = get_device_flags (scsi_result);
  457. if (bflags & BLIST_LARGELUN)
  458. lun0_sl = SCSI_3; /* treat as SCSI 3 */
  459. else
  460. lun0_sl = SDpnt->scsi_level;
  461. }
  462. } /* for lun ends */
  463. } /* if this_id != id ends */
  464. } /* for dev ends */
  465. } /* for channel ends */
  466. } /* if/else hardcoded */
  468.       leave:
  470. { /* Unchain SRpnt from host_queue */
  471. Scsi_Device *prev, *next;
  472. Scsi_Device *dqptr;
  474. for (dqptr = shpnt->host_queue; dqptr != SDpnt; dqptr = dqptr->next)
  475. continue;
  476. if (dqptr) {
  477. prev = dqptr->prev;
  478. next = dqptr->next;
  479. if (prev)
  480. prev->next = next;
  481. else
  482. shpnt->host_queue = next;
  483. if (next)
  484. next->prev = prev;
  485. }
  486. }
  488. /* Last device block does not exist.  Free memory. */
  489. if (SDpnt != NULL) {
  490. blk_cleanup_queue(&SDpnt->request_queue);
  491. kfree((char *) SDpnt);
  492. }
  494. /* If we allocated a buffer so we could do DMA, free it now */
  495. if (scsi_result != &scsi_result0[0] && scsi_result != NULL) {
  496. kfree(scsi_result);
  497. } {
  498. Scsi_Device *sdev;
  499. Scsi_Cmnd *scmd;
  501. SCSI_LOG_SCAN_BUS(4, printk("Host status for host %p:n", shpnt));
  502. for (sdev = shpnt->host_queue; sdev; sdev = sdev->next) {
  503. SCSI_LOG_SCAN_BUS(4, printk("Device %d %p: ", sdev->id, sdev));
  504. for (scmd = sdev->device_queue; scmd; scmd = scmd->next) {
  505. SCSI_LOG_SCAN_BUS(4, printk("%p ", scmd));
  506. }
  507. SCSI_LOG_SCAN_BUS(4, printk("n"));
  508. }
  509. }
  510. }
  512. /*
  513.  * The worker for scan_scsis.
  514.  * Returning 0 means Please don't ask further for lun!=0, 1 means OK go on.
  515.  * Global variables used : scsi_devices(linked list)
  516.  */
  517. static int scan_scsis_single(unsigned int channel, unsigned int dev,
  518. unsigned int lun, int lun0_scsi_level,
  519. unsigned int *max_dev_lun, unsigned int *sparse_lun, 
  520. Scsi_Device ** SDpnt2, struct Scsi_Host *shpnt, 
  521. char *scsi_result)
  522. {
  523. char devname[64];
  524. unsigned char scsi_cmd[MAX_COMMAND_SIZE];
  525. struct Scsi_Device_Template *sdtpnt;
  526. Scsi_Device *SDtail, *SDpnt = *SDpnt2;
  527. Scsi_Request * SRpnt;
  528. int bflags, type = -1;
  529. extern devfs_handle_t scsi_devfs_handle;
  530. int scsi_level;
  532. SDpnt->host = shpnt;
  533. SDpnt->id = dev;
  534. SDpnt->lun = lun;
  535. SDpnt->channel = channel;
  536. SDpnt->online = TRUE;
  538. scsi_build_commandblocks(SDpnt);
  539.  
  540. /* Some low level driver could use device->type (DB) */
  541. SDpnt->type = -1;
  543. /*
  544.  * Assume that the device will have handshaking problems, and then fix
  545.  * this field later if it turns out it doesn't
  546.  */
  547. SDpnt->borken = 1;
  548. SDpnt->was_reset = 0;
  549. SDpnt->expecting_cc_ua = 0;
  550. SDpnt->starved = 0;
  552. if (NULL == (SRpnt = scsi_allocate_request(SDpnt))) {
  553. printk("scan_scsis_single: no memoryn");
  554. return 0;
  555. }
  557. /*
  558.  * We used to do a TEST_UNIT_READY before the INQUIRY but that was 
  559.  * not really necessary.  Spec recommends using INQUIRY to scan for
  560.  * devices (and TEST_UNIT_READY to poll for media change). - Paul G.
  561.  */
  563. SCSI_LOG_SCAN_BUS(3, printk("scsi: performing INQUIRYn"));
  564. /*
  565.  * Build an INQUIRY command block.
  566.  */
  567. scsi_cmd[0] = INQUIRY;
  568. if ((lun > 0) && (lun0_scsi_level <= SCSI_2))
  569. scsi_cmd[1] = (lun << 5) & 0xe0;
  570. else
  571. scsi_cmd[1] = 0; /* SCSI_3 and higher, don't touch */
  572. scsi_cmd[2] = 0;
  573. scsi_cmd[3] = 0;
  574. scsi_cmd[4] = 255;
  575. scsi_cmd[5] = 0;
  576. SRpnt->sr_cmd_len = 0;
  577. SRpnt->sr_data_direction = SCSI_DATA_READ;
  579. scsi_wait_req (SRpnt, (void *) scsi_cmd,
  580.           (void *) scsi_result,
  581.           256, SCSI_TIMEOUT+4*HZ, 3);
  583. SCSI_LOG_SCAN_BUS(3, printk("scsi: INQUIRY %s with code 0x%xn",
  584. SRpnt->sr_result ? "failed" : "successful", SRpnt->sr_result));
  586. /*
  587.  * Now that we don't do TEST_UNIT_READY anymore, we must be prepared
  588.  * for media change conditions here, so cannot require zero result.
  589.  */
  590. if (SRpnt->sr_result) {
  591. if ((driver_byte(SRpnt->sr_result) & DRIVER_SENSE) != 0 &&
  592.     (SRpnt->sr_sense_buffer[2] & 0xf) == UNIT_ATTENTION &&
  593.     SRpnt->sr_sense_buffer[12] == 0x28 &&
  594.     SRpnt->sr_sense_buffer[13] == 0) {
  595. /* not-ready to ready transition - good */
  596. } else {
  597. /* assume no peripheral if any other sort of error */
  598. scsi_release_request(SRpnt);
  599. return 0;
  600. }
  601. }
  603. /*
  604.  * Check for SPARSELUN before checking the peripheral qualifier,
  605.  * so sparse lun devices are completely scanned.
  606.  */
  608. /*
  609.  * Get any flags for this device.  
  610.  */
  611. bflags = get_device_flags (scsi_result);
  613. if (bflags & BLIST_SPARSELUN) {
  614.   *sparse_lun = 1;
  615. }
  616. /*
  617.  * Check the peripheral qualifier field - this tells us whether LUNS
  618.  * are supported here or not.
  619.  */
  620. if ((scsi_result[0] >> 5) == 3) {
  621. scsi_release_request(SRpnt);
  622. return 0; /* assume no peripheral if any sort of error */
  623. }
  624.  /*   The Toshiba ROM was "gender-changed" here as an inline hack.
  625.       This is now much more generic.
  626.       This is a mess: What we really want is to leave the scsi_result
  627.       alone, and just change the SDpnt structure. And the SDpnt is what
  628.       we want print_inquiry to print.  -- REW
  629.  */
  630. if (bflags & BLIST_ISDISK) {
  631. scsi_result[0] = TYPE_DISK;                                                
  632. scsi_result[1] |= 0x80;     /* removable */
  633. }
  635. if (bflags & BLIST_ISROM) {
  636. scsi_result[0] = TYPE_ROM;
  637. scsi_result[1] |= 0x80;     /* removable */
  638. }
  639.     
  640. memcpy(SDpnt->vendor, scsi_result + 8, 8);
  641. memcpy(SDpnt->model, scsi_result + 16, 16);
  642. memcpy(SDpnt->rev, scsi_result + 32, 4);
  644. SDpnt->removable = (0x80 & scsi_result[1]) >> 7;
  645. /* Use the peripheral qualifier field to determine online/offline */
  646. if (((scsi_result[0] >> 5) & 7) == 1)  SDpnt->online = FALSE;
  647. else SDpnt->online = TRUE;
  648. SDpnt->lockable = SDpnt->removable;
  649. SDpnt->changed = 0;
  650. SDpnt->access_count = 0;
  651. SDpnt->busy = 0;
  652. SDpnt->has_cmdblocks = 0;
  653. /*
  654.  * Currently, all sequential devices are assumed to be tapes, all random
  655.  * devices disk, with the appropriate read only flags set for ROM / WORM
  656.  * treated as RO.
  657.  */
  658. switch (type = (scsi_result[0] & 0x1f)) {
  659. case TYPE_TAPE:
  660. case TYPE_DISK:
  661. case TYPE_PRINTER:
  662. case TYPE_MOD:
  663. case TYPE_PROCESSOR:
  664. case TYPE_SCANNER:
  665. case TYPE_MEDIUM_CHANGER:
  666. case TYPE_ENCLOSURE:
  667. case TYPE_COMM:
  668. SDpnt->writeable = 1;
  669. break;
  670. case TYPE_WORM:
  671. case TYPE_ROM:
  672. SDpnt->writeable = 0;
  673. break;
  674. default:
  675. printk("scsi: unknown type %dn", type);
  676. }
  678. SDpnt->device_blocked = FALSE;
  679. SDpnt->device_busy = 0;
  680. SDpnt->single_lun = 0;
  681. SDpnt->soft_reset =
  682.     (scsi_result[7] & 1) && ((scsi_result[3] & 7) == 2);
  683. SDpnt->random = (type == TYPE_TAPE) ? 0 : 1;
  684. SDpnt->type = (type & 0x1f);
  686. print_inquiry(scsi_result);
  688.         sprintf (devname, "host%d/bus%d/target%d/lun%d",
  689.                  SDpnt->host->host_no, SDpnt->channel, SDpnt->id, SDpnt->lun);
  690.         if (SDpnt->de) printk ("DEBUG: dir: "%s" already existsn", devname);
  691.         else SDpnt->de = devfs_mk_dir (scsi_devfs_handle, devname, NULL);
  693. for (sdtpnt = scsi_devicelist; sdtpnt;
  694.      sdtpnt = sdtpnt->next)
  695. if (sdtpnt->detect)
  696. SDpnt->attached +=
  697.     (*sdtpnt->detect) (SDpnt);
  699. SDpnt->scsi_level = scsi_result[2] & 0x07;
  700. if (SDpnt->scsi_level >= 2 ||
  701.     (SDpnt->scsi_level == 1 &&
  702.      (scsi_result[3] & 0x0f) == 1))
  703. SDpnt->scsi_level++;
  704. scsi_level = SDpnt->scsi_level;
  706. /*
  707.  * Accommodate drivers that want to sleep when they should be in a polling
  708.  * loop.
  709.  */
  710. SDpnt->disconnect = 0;
  713. /*
  714.  * Set the tagged_queue flag for SCSI-II devices that purport to support
  715.  * tagged queuing in the INQUIRY data.
  716.  */
  717. SDpnt->tagged_queue = 0;
  718. if ((SDpnt->scsi_level >= SCSI_2) &&
  719.     (scsi_result[7] & 2) &&
  720.     !(bflags & BLIST_NOTQ)) {
  721. SDpnt->tagged_supported = 1;
  722. SDpnt->current_tag = 0;
  723. }
  724. /*
  725.  * Some revisions of the Texel CD ROM drives have handshaking problems when
  726.  * used with the Seagate controllers.  Before we know what type of device
  727.  * we're talking to, we assume it's borken and then change it here if it
  728.  * turns out that it isn't a TEXEL drive.
  729.  */
  730. if ((bflags & BLIST_BORKEN) == 0)
  731. SDpnt->borken = 0;
  733. /*
  734.  * If we want to only allow I/O to one of the luns attached to this device
  735.  * at a time, then we set this flag.
  736.  */
  737. if (bflags & BLIST_SINGLELUN)
  738. SDpnt->single_lun = 1;
  740. /*
  741.  * These devices need this "key" to unlock the devices so we can use it
  742.  */
  743. if ((bflags & BLIST_KEY) != 0) {
  744. printk("Unlocked floptical drive.n");
  745. SDpnt->lockable = 0;
  746. scsi_cmd[0] = MODE_SENSE;
  747. if (shpnt->max_lun <= 8)
  748. scsi_cmd[1] = (lun << 5) & 0xe0;
  749. else scsi_cmd[1] = 0; /* any other idea? */
  750. scsi_cmd[2] = 0x2e;
  751. scsi_cmd[3] = 0;
  752. scsi_cmd[4] = 0x2a;
  753. scsi_cmd[5] = 0;
  754. SRpnt->sr_cmd_len = 0;
  755. SRpnt->sr_data_direction = SCSI_DATA_READ;
  756. scsi_wait_req (SRpnt, (void *) scsi_cmd,
  757.          (void *) scsi_result, 0x2a,
  758.          SCSI_TIMEOUT, 3);
  759. }
  761. scsi_release_request(SRpnt);
  762. SRpnt = NULL;
  764. scsi_release_commandblocks(SDpnt);
  766. /*
  767.  * This device was already hooked up to the host in question,
  768.  * so at this point we just let go of it and it should be fine.  We do need to
  769.  * allocate a new one and attach it to the host so that we can further scan the bus.
  770.  */
  771. SDpnt = (Scsi_Device *) kmalloc(sizeof(Scsi_Device), GFP_ATOMIC);
  772. if (!SDpnt) {
  773. printk("scsi: scan_scsis_single: Cannot mallocn");
  774. return 0;
  775. }
  776.         memset(SDpnt, 0, sizeof(Scsi_Device));
  778. *SDpnt2 = SDpnt;
  779. SDpnt->queue_depth = 1;
  780. SDpnt->host = shpnt;
  781. SDpnt->online = TRUE;
  782. SDpnt->scsi_level = scsi_level;
  784. /*
  785.  * Register the queue for the device.  All I/O requests will come
  786.  * in through here.  We also need to register a pointer to
  787.  * ourselves, since the queue handler won't know what device
  788.  * the queue actually represents.   We could look it up, but it
  789.  * is pointless work.
  790.  */
  791. scsi_initialize_queue(SDpnt, shpnt);
  792. SDpnt->host = shpnt;
  793. initialize_merge_fn(SDpnt);
  795. /*
  796.  * Mark this device as online, or otherwise we won't be able to do much with it.
  797.  */
  798. SDpnt->online = TRUE;
  800.         /*
  801.          * Initialize the object that we will use to wait for command blocks.
  802.          */
  803. init_waitqueue_head(&SDpnt->scpnt_wait);
  805. /*
  806.  * Since we just found one device, there had damn well better be one in the list
  807.  * already.
  808.  */
  809. if (shpnt->host_queue == NULL)
  810. panic("scan_scsis_single: Host queue == NULLn");
  812. SDtail = shpnt->host_queue;
  813. while (SDtail->next) {
  814. SDtail = SDtail->next;
  815. }
  817. /* Add this device to the linked list at the end */
  818. SDtail->next = SDpnt;
  819. SDpnt->prev = SDtail;
  820. SDpnt->next = NULL;
  822. /*
  823.  * Some scsi devices cannot be polled for lun != 0 due to firmware bugs
  824.  */
  825. if (bflags & BLIST_NOLUN)
  826. return 0; /* break; */
  828. /*
  829.  * If this device is known to support sparse multiple units, override the
  830.  * other settings, and scan all of them.
  831.  */
  832. if (bflags & BLIST_SPARSELUN) {
  833. *max_dev_lun = shpnt->max_lun;
  834. *sparse_lun = 1;
  835. return 1;
  836. }
  837. /*
  838.  * If this device is known to support multiple units, override the other
  839.  * settings, and scan all of them.
  840.  */
  841. if (bflags & BLIST_FORCELUN) {
  842. /* 
  843.  * Scanning MAX_SCSI_LUNS units would be a bad idea.
  844.  * Any better idea?
  845.  * I think we need REPORT LUNS in future to avoid scanning
  846.  * of unused LUNs. But, that is another item.
  847.  */
  848. if (*max_dev_lun < shpnt->max_lun)
  849. *max_dev_lun = shpnt->max_lun;
  850. else  if ((max_scsi_luns >> 1) >= *max_dev_lun)
  851. *max_dev_lun += shpnt->max_lun;
  852. else *max_dev_lun = max_scsi_luns;
  853. return 1;
  854. }
  855. /*
  856.  * REGAL CDC-4X: avoid hang after LUN 4
  857.  */
  858. if (bflags & BLIST_MAX5LUN) {
  859. *max_dev_lun = 5;
  860. return 1;
  861. }
  863. /*
  864.  * We assume the device can't handle lun!=0 if: - it reports scsi-0
  865.  * (ANSI SCSI Revision 0) (old drives like MAXTOR XT-3280) or - it
  866.  * reports scsi-1 (ANSI SCSI Revision 1) and Response Data Format 0
  867.  */
  868. if (((scsi_result[2] & 0x07) == 0)
  869.     ||
  870.     ((scsi_result[2] & 0x07) == 1 &&
  871.      (scsi_result[3] & 0x0f) == 0))
  872. return 0;
  873. return 1;
  874. }
  876. /*
  877.  * The worker for scan_scsis.
  878.  * Returns the scsi_level of lun0 on this host, channel and dev (if already
  879.  * known), otherwise returns SCSI_2.
  880.  */
  881. static int find_lun0_scsi_level(unsigned int channel, unsigned int dev,
  882. struct Scsi_Host *shpnt)
  883. {
  884. int res = SCSI_2;
  885. Scsi_Device *SDpnt;
  887. for (SDpnt = shpnt->host_queue; SDpnt; SDpnt = SDpnt->next)
  888. {
  889. if ((0 == SDpnt->lun) && (dev == SDpnt->id) &&
  890.     (channel == SDpnt->channel))
  891. return (int)SDpnt->scsi_level;
  892. }
  893. /* haven't found lun0, should send INQUIRY but take easy route */
  894. return res;
  895. }