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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
scsiglue.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：23k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

scsiglue.c：源码内容
  1. /* Driver for USB Mass Storage compliant devices
  2.  * SCSI layer glue code
  3.  *
  4.  * $Id: scsiglue.c,v 1.24 2001/11/11 03:33:58 mdharm Exp $
  5.  *
  6.  * Current development and maintenance by:
  7.  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  8.  *
  9.  * Developed with the assistance of:
  10.  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
  11.  *   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
  12.  *
  13.  * Initial work by:
  14.  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
  15.  *
  16.  * This driver is based on the 'USB Mass Storage Class' document. This
  17.  * describes in detail the protocol used to communicate with such
  18.  * devices.  Clearly, the designers had SCSI and ATAPI commands in
  19.  * mind when they created this document.  The commands are all very
  20.  * similar to commands in the SCSI-II and ATAPI specifications.
  21.  *
  22.  * It is important to note that in a number of cases this class
  23.  * exhibits class-specific exemptions from the USB specification.
  24.  * Notably the usage of NAK, STALL and ACK differs from the norm, in
  25.  * that they are used to communicate wait, failed and OK on commands.
  26.  *
  27.  * Also, for certain devices, the interrupt endpoint is used to convey
  28.  * status of a command.
  29.  *
  30.  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
  31.  * information about this driver.
  32.  *
  33.  * This program is free software; you can redistribute it and/or modify it
  34.  * under the terms of the GNU General Public License as published by the
  35.  * Free Software Foundation; either version 2, or (at your option) any
  36.  * later version.
  37.  *
  38.  * This program is distributed in the hope that it will be useful, but
  39.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  40.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  41.  * General Public License for more details.
  42.  *
  43.  * You should have received a copy of the GNU General Public License along
  44.  * with this program; if not, write to the Free Software Foundation, Inc.,
  45.  * 675 Mass Ave, Cambridge, MA 02139, USA.
  46.  */
  47. #include "scsiglue.h"
  48. #include "usb.h"
  49. #include "debug.h"
  50. #include "transport.h"
  52. #include <linux/slab.h>
  54. /*
  55.  * kernel thread actions
  56.  */
  58. #define US_ACT_COMMAND 1
  59. #define US_ACT_DEVICE_RESET 2
  60. #define US_ACT_BUS_RESET 3
  61. #define US_ACT_HOST_RESET 4
  62. #define US_ACT_EXIT 5
  64. /***********************************************************************
  65.  * Host functions 
  66.  ***********************************************************************/
  68. static const char* host_info(struct Scsi_Host *host)
  69. {
  70. return "SCSI emulation for USB Mass Storage devices";
  71. }
  73. /* detect a virtual adapter (always works) */
  74. static int detect(struct SHT *sht)
  75. {
  76. struct us_data *us;
  77. char local_name[32];
  79. /* This is not nice at all, but how else are we to get the
  80.  * data here? */
  81. us = (struct us_data *)sht->proc_dir;
  83. /* set up the name of our subdirectory under /proc/scsi/ */
  84. sprintf(local_name, "usb-storage-%d", us->host_number);
  85. sht->proc_name = kmalloc (strlen(local_name) + 1, GFP_KERNEL);
  86. if (!sht->proc_name)
  87. return 0;
  88. strcpy(sht->proc_name, local_name);
  90. /* we start with no /proc directory entry */
  91. sht->proc_dir = NULL;
  93. /* register the host */
  94. us->host = scsi_register(sht, sizeof(us));
  95. if (us->host) {
  96. us->host->hostdata[0] = (unsigned long)us;
  97. us->host_no = us->host->host_no;
  98. return 1;
  99. }
  101. /* odd... didn't register properly.  Abort and free pointers */
  102. kfree(sht->proc_name);
  103. sht->proc_name = NULL;
  104. return 0;
  105. }
  107. /* Release all resources used by the virtual host
  108.  *
  109.  * NOTE: There is no contention here, because we're already deregistered
  110.  * the driver and we're doing each virtual host in turn, not in parallel
  111.  */
  112. static int release(struct Scsi_Host *psh)
  113. {
  114. struct us_data *us = (struct us_data *)psh->hostdata[0];
  116. US_DEBUGP("release() called for host %sn", us->htmplt.name);
  118. /* Kill the control threads
  119.  *
  120.  * Enqueue the command, wake up the thread, and wait for 
  121.  * notification that it's exited.
  122.  */
  123. US_DEBUGP("-- sending US_ACT_EXIT command to threadn");
  124. us->action = US_ACT_EXIT;
  126. up(&(us->sema));
  127. wait_for_completion(&(us->notify));
  129. /* remove the pointer to the data structure we were using */
  130. (struct us_data*)psh->hostdata[0] = NULL;
  132. /* we always have a successful release */
  133. return 0;
  134. }
  136. /* run command */
  137. static int command( Scsi_Cmnd *srb )
  138. {
  139. US_DEBUGP("Bad use of us_commandn");
  141. return DID_BAD_TARGET << 16;
  142. }
  144. /* run command */
  145. static int queuecommand( Scsi_Cmnd *srb , void (*done)(Scsi_Cmnd *))
  146. {
  147. struct us_data *us = (struct us_data *)srb->host->hostdata[0];
  149. US_DEBUGP("queuecommand() calledn");
  150. srb->host_scribble = (unsigned char *)us;
  152. /* get exclusive access to the structures we want */
  153. down(&(us->queue_exclusion));
  155. /* enqueue the command */
  156. us->queue_srb = srb;
  157. srb->scsi_done = done;
  158. us->action = US_ACT_COMMAND;
  160. /* release the lock on the structure */
  161. up(&(us->queue_exclusion));
  163. /* wake up the process task */
  164. up(&(us->sema));
  166. return 0;
  167. }
  169. /***********************************************************************
  170.  * Error handling functions
  171.  ***********************************************************************/
  173. /* Command abort */
  174. static int command_abort( Scsi_Cmnd *srb )
  175. {
  176. struct us_data *us = (struct us_data *)srb->host->hostdata[0];
  178. US_DEBUGP("command_abort() calledn");
  180. /* if we're stuck waiting for an IRQ, simulate it */
  181. if (atomic_read(us->ip_wanted)) {
  182. US_DEBUGP("-- simulating missing IRQn");
  183. up(&(us->ip_waitq));
  184. }
  186. /* if the device has been removed, this worked */
  187. if (!us->pusb_dev) {
  188. US_DEBUGP("-- device removed alreadyn");
  189. return SUCCESS;
  190. }
  192. /* if we have an urb pending, let's wake the control thread up */
  193. if (us->current_urb->status == -EINPROGRESS) {
  194. /* cancel the URB -- this will automatically wake the thread */
  195. usb_unlink_urb(us->current_urb);
  197. /* wait for us to be done */
  198. wait_for_completion(&(us->notify));
  199. return SUCCESS;
  200. }
  202. US_DEBUGP ("-- nothing to abortn");
  203. return FAILED;
  204. }
  206. /* This invokes the transport reset mechanism to reset the state of the
  207.  * device */
  208. static int device_reset( Scsi_Cmnd *srb )
  209. {
  210. struct us_data *us = (struct us_data *)srb->host->hostdata[0];
  212. US_DEBUGP("device_reset() calledn" );
  213. return us->transport_reset(us);
  214. }
  216. /* This resets the device port, and simulates the device
  217.  * disconnect/reconnect for all drivers which have claimed other
  218.  * interfaces. */
  219. static int bus_reset( Scsi_Cmnd *srb )
  220. {
  221. struct us_data *us = (struct us_data *)srb->host->hostdata[0];
  222. int i;
  223. int result;
  225. /* we use the usb_reset_device() function to handle this for us */
  226. US_DEBUGP("bus_reset() calledn");
  228. /* if the device has been removed, this worked */
  229. if (!us->pusb_dev) {
  230. US_DEBUGP("-- device removed alreadyn");
  231. return SUCCESS;
  232. }
  234. /* release the IRQ, if we have one */
  235. down(&(us->irq_urb_sem));
  236. if (us->irq_urb) {
  237. US_DEBUGP("-- releasing irq URBn");
  238. result = usb_unlink_urb(us->irq_urb);
  239. US_DEBUGP("-- usb_unlink_urb() returned %dn", result);
  240. }
  241. up(&(us->irq_urb_sem));
  243. /* attempt to reset the port */
  244. if (usb_reset_device(us->pusb_dev) < 0)
  245. return FAILED;
  247. /* FIXME: This needs to lock out driver probing while it's working
  248.  * or we can have race conditions */
  249.         for (i = 0; i < us->pusb_dev->actconfig->bNumInterfaces; i++) {
  250.   struct usb_interface *intf =
  251. &us->pusb_dev->actconfig->interface[i];
  252. const struct usb_device_id *id;
  254. /* if this is an unclaimed interface, skip it */
  255. if (!intf->driver) {
  256. continue;
  257. }
  259. US_DEBUGP("Examinging driver %s...", intf->driver->name);
  260. /* skip interfaces which we've claimed */
  261. if (intf->driver == &usb_storage_driver) {
  262. US_DEBUGPX("skipping ourselves.n");
  263. continue;
  264. }
  266. /* simulate a disconnect and reconnect for all interfaces */
  267. US_DEBUGPX("simulating disconnect/reconnect.n");
  268. down(&intf->driver->serialize);
  269. intf->driver->disconnect(us->pusb_dev, intf->private_data);
  270. id = usb_match_id(us->pusb_dev, intf, intf->driver->id_table);
  271. intf->driver->probe(us->pusb_dev, i, id);
  272. up(&intf->driver->serialize);
  273. }
  275. /* re-allocate the IRQ URB and submit it to restore connectivity
  276.  * for CBI devices
  277.  */
  278. if (us->protocol == US_PR_CBI) {
  279. down(&(us->irq_urb_sem));
  280. us->irq_urb->dev = us->pusb_dev;
  281. result = usb_submit_urb(us->irq_urb);
  282. US_DEBUGP("usb_submit_urb() returns %dn", result);
  283. up(&(us->irq_urb_sem));
  284. }
  286. US_DEBUGP("bus_reset() completen");
  287. return SUCCESS;
  288. }
  290. /* FIXME: This doesn't do anything right now */
  291. static int host_reset( Scsi_Cmnd *srb )
  292. {
  293. printk(KERN_CRIT "usb-storage: host_reset() requested but not implementedn" );
  294. return FAILED;
  295. }
  297. /***********************************************************************
  298.  * /proc/scsi/ functions
  299.  ***********************************************************************/
  301. /* we use this macro to help us write into the buffer */
  302. #undef SPRINTF
  303. #define SPRINTF(args...) 
  304. do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
  306. static int proc_info (char *buffer, char **start, off_t offset, int length,
  307. int hostno, int inout)
  308. {
  309. struct us_data *us;
  310. char *pos = buffer;
  312. /* if someone is sending us data, just throw it away */
  313. if (inout)
  314. return length;
  316. /* lock the data structures */
  317. down(&us_list_semaphore);
  319. /* find our data from hostno */
  320. us = us_list;
  321. while (us) {
  322. if (us->host_no == hostno)
  323. break;
  324. us = us->next;
  325. }
  327. /* release our lock on the data structures */
  328. up(&us_list_semaphore);
  330. /* if we couldn't find it, we return an error */
  331. if (!us) {
  332. return -ESRCH;
  333. }
  335. /* print the controller name */
  336. SPRINTF("   Host scsi%d: usb-storagen", hostno);
  338. /* print product, vendor, and serial number strings */
  339. SPRINTF("       Vendor: %sn", us->vendor);
  340. SPRINTF("      Product: %sn", us->product);
  341. SPRINTF("Serial Number: %sn", us->serial);
  343. /* show the protocol and transport */
  344. SPRINTF("     Protocol: %sn", us->protocol_name);
  345. SPRINTF("    Transport: %sn", us->transport_name);
  347. /* show the GUID of the device */
  348. SPRINTF("         GUID: " GUID_FORMAT "n", GUID_ARGS(us->guid));
  349. SPRINTF("     Attached: %sn", us->pusb_dev ? "Yes" : "No");
  351. /*
  352.  * Calculate start of next buffer, and return value.
  353.  */
  354. *start = buffer + offset;
  356. if ((pos - buffer) < offset)
  357. return (0);
  358. else if ((pos - buffer - offset) < length)
  359. return (pos - buffer - offset);
  360. else
  361. return (length);
  362. }
  364. /*
  365.  * this defines our 'host'
  366.  */
  368. Scsi_Host_Template usb_stor_host_template = {
  369. name: "usb-storage",
  370. proc_info: proc_info,
  371. info: host_info,
  373. detect: detect,
  374. release: release,
  375. command: command,
  376. queuecommand: queuecommand,
  378. eh_abort_handler: command_abort,
  379. eh_device_reset_handler:device_reset,
  380. eh_bus_reset_handler: bus_reset,
  381. eh_host_reset_handler: host_reset,
  383. can_queue: 1,
  384. this_id: -1,
  386. sg_tablesize: SG_ALL,
  387. cmd_per_lun: 1,
  388. present: 0,
  389. unchecked_isa_dma: FALSE,
  390. use_clustering: TRUE,
  391. use_new_eh_code: TRUE,
  392. emulated: TRUE
  393. };
  395. unsigned char usb_stor_sense_notready[18] = {
  396. [0] = 0x70,     /* current error */
  397. [2] = 0x02,     /* not ready */
  398. [5] = 0x0a,     /* additional length */
  399. [10] = 0x04,     /* not ready */
  400. [11] = 0x03     /* manual intervention */
  401. };
  403. #define USB_STOR_SCSI_SENSE_HDRSZ 4
  404. #define USB_STOR_SCSI_SENSE_10_HDRSZ 8
  406. struct usb_stor_scsi_sense_hdr
  407. {
  408.   __u8* dataLength;
  409.   __u8* mediumType;
  410.   __u8* devSpecParms;
  411.   __u8* blkDescLength;
  412. };
  414. typedef struct usb_stor_scsi_sense_hdr Usb_Stor_Scsi_Sense_Hdr;
  416. union usb_stor_scsi_sense_hdr_u
  417. {
  418.   Usb_Stor_Scsi_Sense_Hdr hdr;
  419.   __u8* array[USB_STOR_SCSI_SENSE_HDRSZ];
  420. };
  422. typedef union usb_stor_scsi_sense_hdr_u Usb_Stor_Scsi_Sense_Hdr_u;
  424. struct usb_stor_scsi_sense_hdr_10
  425. {
  426.   __u8* dataLengthMSB;
  427.   __u8* dataLengthLSB;
  428.   __u8* mediumType;
  429.   __u8* devSpecParms;
  430.   __u8* reserved1;
  431.   __u8* reserved2;
  432.   __u8* blkDescLengthMSB;
  433.   __u8* blkDescLengthLSB;
  434. };
  436. typedef struct usb_stor_scsi_sense_hdr_10 Usb_Stor_Scsi_Sense_Hdr_10;
  438. union usb_stor_scsi_sense_hdr_10_u
  439. {
  440.   Usb_Stor_Scsi_Sense_Hdr_10 hdr;
  441.   __u8* array[USB_STOR_SCSI_SENSE_10_HDRSZ];
  442. };
  444. typedef union usb_stor_scsi_sense_hdr_10_u Usb_Stor_Scsi_Sense_Hdr_10_u;
  446. void usb_stor_scsiSenseParseBuffer( Scsi_Cmnd* , Usb_Stor_Scsi_Sense_Hdr_u*,
  447.     Usb_Stor_Scsi_Sense_Hdr_10_u*, int* );
  449. int usb_stor_scsiSense10to6( Scsi_Cmnd* the10 )
  450. {
  451.   __u8 *buffer=0;
  452.   int outputBufferSize = 0;
  453.   int length=0;
  454.   struct scatterlist *sg = 0;
  455.   int i=0, j=0, element=0;
  456.   Usb_Stor_Scsi_Sense_Hdr_u the6Locations;
  457.   Usb_Stor_Scsi_Sense_Hdr_10_u the10Locations;
  458.   int sb=0,si=0,db=0,di=0;
  459.   int sgLength=0;
  461.   US_DEBUGP("-- converting 10 byte sense data to 6 byten");
  462.   the10->cmnd[0] = the10->cmnd[0] & 0xBF;
  464.   /* Determine buffer locations */
  465.   usb_stor_scsiSenseParseBuffer( the10, &the6Locations, &the10Locations,
  466.  &length );
  468.   /* Work out minimum buffer to output */
  469.   outputBufferSize = *the10Locations.hdr.dataLengthLSB;
  470.   outputBufferSize += USB_STOR_SCSI_SENSE_HDRSZ;
  472.   /* Check to see if we need to trucate the output */
  473.   if ( outputBufferSize > length )
  474.     {
  475.       printk( KERN_WARNING USB_STORAGE 
  476.       "Had to truncate MODE_SENSE_10 buffer into MODE_SENSE.n" );
  477.       printk( KERN_WARNING USB_STORAGE
  478.       "outputBufferSize is %d and length is %d.n",
  479.       outputBufferSize, length );
  480.     }
  481.   outputBufferSize = length;
  483.   /* Data length */
  484.   if ( *the10Locations.hdr.dataLengthMSB != 0 ) /* MSB must be zero */
  485.     {
  486.       printk( KERN_WARNING USB_STORAGE 
  487.       "Command will be truncated to fit in SENSE6 buffer.n" );
  488.       *the6Locations.hdr.dataLength = 0xff;
  489.     }
  490.   else
  491.     {
  492.       *the6Locations.hdr.dataLength = *the10Locations.hdr.dataLengthLSB;
  493.     }
  495.   /* Medium type and DevSpecific parms */
  496.   *the6Locations.hdr.mediumType = *the10Locations.hdr.mediumType;
  497.   *the6Locations.hdr.devSpecParms = *the10Locations.hdr.devSpecParms;
  499.   /* Block descriptor length */
  500.   if ( *the10Locations.hdr.blkDescLengthMSB != 0 ) /* MSB must be zero */
  501.     {
  502.       printk( KERN_WARNING USB_STORAGE 
  503.       "Command will be truncated to fit in SENSE6 buffer.n" );
  504.       *the6Locations.hdr.blkDescLength = 0xff;
  505.     }
  506.   else
  507.     {
  508.       *the6Locations.hdr.blkDescLength = *the10Locations.hdr.blkDescLengthLSB;
  509.     }
  511.   if ( the10->use_sg == 0 )
  512.     {
  513.       buffer = the10->request_buffer;
  514.       /* Copy the rest of the data */
  515.       memmove( &(buffer[USB_STOR_SCSI_SENSE_HDRSZ]),
  516.        &(buffer[USB_STOR_SCSI_SENSE_10_HDRSZ]),
  517.        outputBufferSize - USB_STOR_SCSI_SENSE_HDRSZ );
  518.       /* initialise last bytes left in buffer due to smaller header */
  519.       memset( &(buffer[outputBufferSize
  520.     -(USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ)]),
  521.       0,
  522.       USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ );
  523.     }
  524.   else
  525.     {
  526.       sg = (struct scatterlist *) the10->request_buffer;
  527.       /* scan through this scatterlist and figure out starting positions */
  528.       for ( i=0; i < the10->use_sg; i++)
  529. {
  530.   sgLength = sg[i].length;
  531.   for ( j=0; j<sgLength; j++ )
  532.     {
  533.       /* get to end of header */
  534.       if ( element == USB_STOR_SCSI_SENSE_HDRSZ )
  535. {
  536.   db=i;
  537.   di=j;
  538. }
  539.       if ( element == USB_STOR_SCSI_SENSE_10_HDRSZ )
  540. {
  541.   sb=i;
  542.   si=j;
  543.   /* we've found both sets now, exit loops */
  544.   j=sgLength;
  545.   i=the10->use_sg;
  546. }
  547.       element++;
  548.     }
  549. }
  551.       /* Now we know where to start the copy from */
  552.       element = USB_STOR_SCSI_SENSE_HDRSZ;
  553.       while ( element < outputBufferSize
  554.       -(USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ) )
  555. {
  556.   /* check limits */
  557.   if ( sb >= the10->use_sg ||
  558.        si >= sg[sb].length ||
  559.        db >= the10->use_sg ||
  560.        di >= sg[db].length )
  561.     {
  562.       printk( KERN_ERR USB_STORAGE
  563.       "Buffer overrun averted, this shouldn't happen!n" );
  564.       break;
  565.     }
  567.   /* copy one byte */
  568.   sg[db].address[di] = sg[sb].address[si];
  570.   /* get next destination */
  571.   if ( sg[db].length-1 == di )
  572.     {
  573.       db++;
  574.       di=0;
  575.     }
  576.   else
  577.     {
  578.       di++;
  579.     }
  581.   /* get next source */
  582.   if ( sg[sb].length-1 == si )
  583.     {
  584.       sb++;
  585.       si=0;
  586.     }
  587.   else
  588.     {
  589.       si++;
  590.     }
  592.   element++;
  593. }
  594.       /* zero the remaining bytes */
  595.       while ( element < outputBufferSize )
  596. {
  597.   /* check limits */
  598.   if ( db >= the10->use_sg ||
  599.        di >= sg[db].length )
  600.     {
  601.       printk( KERN_ERR USB_STORAGE
  602.       "Buffer overrun averted, this shouldn't happen!n" );
  603.       break;
  604.     }
  606.   sg[db].address[di] = 0;
  608.   /* get next destination */
  609.   if ( sg[db].length-1 == di )
  610.     {
  611.       db++;
  612.       di=0;
  613.     }
  614.   else
  615.     {
  616.       di++;
  617.     }
  618.   element++;
  619. }
  620.     }
  622.   /* All done any everything was fine */
  623.   return 0;
  624. }
  626. int usb_stor_scsiSense6to10( Scsi_Cmnd* the6 )
  627. {
  628.   /* will be used to store part of buffer */  
  629.   __u8 tempBuffer[USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ],
  630.     *buffer=0;
  631.   int outputBufferSize = 0;
  632.   int length=0;
  633.   struct scatterlist *sg = 0;
  634.   int i=0, j=0, element=0;
  635.   Usb_Stor_Scsi_Sense_Hdr_u the6Locations;
  636.   Usb_Stor_Scsi_Sense_Hdr_10_u the10Locations;
  637.   int sb=0,si=0,db=0,di=0;
  638.   int lsb=0,lsi=0,ldb=0,ldi=0;
  640.   US_DEBUGP("-- converting 6 byte sense data to 10 byten");
  641.   the6->cmnd[0] = the6->cmnd[0] | 0x40;
  643.   /* Determine buffer locations */
  644.   usb_stor_scsiSenseParseBuffer( the6, &the6Locations, &the10Locations,
  645.  &length );
  647.   /* Work out minimum buffer to output */
  648.   outputBufferSize = *the6Locations.hdr.dataLength;
  649.   outputBufferSize += USB_STOR_SCSI_SENSE_10_HDRSZ;
  651.   /* Check to see if we need to trucate the output */
  652.   if ( outputBufferSize > length )
  653.     {
  654.       printk( KERN_WARNING USB_STORAGE 
  655.       "Had to truncate MODE_SENSE into MODE_SENSE_10 buffer.n" );
  656.       printk( KERN_WARNING USB_STORAGE
  657.       "outputBufferSize is %d and length is %d.n",
  658.       outputBufferSize, length );
  659.     }
  660.   outputBufferSize = length;
  662.   /* Block descriptor length - save these before overwriting */
  663.   tempBuffer[2] = *the10Locations.hdr.blkDescLengthMSB;
  664.   tempBuffer[3] = *the10Locations.hdr.blkDescLengthLSB;
  665.   *the10Locations.hdr.blkDescLengthLSB = *the6Locations.hdr.blkDescLength;
  666.   *the10Locations.hdr.blkDescLengthMSB = 0;
  668.   /* reserved - save these before overwriting */
  669.   tempBuffer[0] = *the10Locations.hdr.reserved1;
  670.   tempBuffer[1] = *the10Locations.hdr.reserved2;
  671.   *the10Locations.hdr.reserved1 = *the10Locations.hdr.reserved2 = 0;
  673.   /* Medium type and DevSpecific parms */
  674.   *the10Locations.hdr.devSpecParms = *the6Locations.hdr.devSpecParms;
  675.   *the10Locations.hdr.mediumType = *the6Locations.hdr.mediumType;
  677.   /* Data length */
  678.   *the10Locations.hdr.dataLengthLSB = *the6Locations.hdr.dataLength;
  679.   *the10Locations.hdr.dataLengthMSB = 0;
  681.   if ( !the6->use_sg )
  682.     {
  683.       buffer = the6->request_buffer;
  684.       /* Copy the rest of the data */
  685.       memmove( &(buffer[USB_STOR_SCSI_SENSE_10_HDRSZ]),
  686.       &(buffer[USB_STOR_SCSI_SENSE_HDRSZ]),
  687.       outputBufferSize-USB_STOR_SCSI_SENSE_10_HDRSZ );
  688.       /* Put the first four bytes (after header) in place */
  689.       memcpy( &(buffer[USB_STOR_SCSI_SENSE_10_HDRSZ]),
  690.       tempBuffer,
  691.       USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ );
  692.     }
  693.   else
  694.     {
  695.       sg = (struct scatterlist *) the6->request_buffer;
  696.       /* scan through this scatterlist and figure out ending positions */
  697.       for ( i=0; i < the6->use_sg; i++)
  698. {
  699.   for ( j=0; j<sg[i].length; j++ )
  700.     {
  701.       /* get to end of header */
  702.       if ( element == USB_STOR_SCSI_SENSE_HDRSZ )
  703. {
  704.   ldb=i;
  705.   ldi=j;
  706. }
  707.       if ( element == USB_STOR_SCSI_SENSE_10_HDRSZ )
  708. {
  709.   lsb=i;
  710.   lsi=j;
  711.   /* we've found both sets now, exit loops */
  712.   j=sg[i].length;
  713.   i=the6->use_sg;
  714.   break;
  715. }
  716.       element++;
  717.     }
  718. }
  719.       /* scan through this scatterlist and figure out starting positions */
  720.       element = length-1;
  721.       /* destination is the last element */
  722.       db=the6->use_sg-1;
  723.       di=sg[db].length-1;
  724.       for ( i=the6->use_sg-1; i >= 0; i--)
  725. {
  726.   for ( j=sg[i].length-1; j>=0; j-- )
  727.     {
  728.       /* get to end of header and find source for copy */
  729.       if ( element == length - 1
  730.    - (USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ) )
  731. {
  732.   sb=i;
  733.   si=j;
  734.   /* we've found both sets now, exit loops */
  735.   j=-1;
  736.   i=-1;
  737. }
  738.       element--;
  739.     }
  740. }
  741.       /* Now we know where to start the copy from */
  742.       element = length-1
  743. - (USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ);
  744.       while ( element >= USB_STOR_SCSI_SENSE_10_HDRSZ )
  745. {
  746.   /* check limits */
  747.   if ( ( sb <= lsb && si < lsi ) ||
  748.        ( db <= ldb && di < ldi ) )
  749.     {
  750.       printk( KERN_ERR USB_STORAGE
  751.       "Buffer overrun averted, this shouldn't happen!n" );
  752.       break;
  753.     }
  755.   /* copy one byte */
  756.   sg[db].address[di] = sg[sb].address[si];
  758.   /* get next destination */
  759.   if ( di == 0 )
  760.     {
  761.       db--;
  762.       di=sg[db].length-1;
  763.     }
  764.   else
  765.     {
  766.       di--;
  767.     }
  769.   /* get next source */
  770.   if ( si == 0 )
  771.     {
  772.       sb--;
  773.       si=sg[sb].length-1;
  774.     }
  775.   else
  776.     {
  777.       si--;
  778.     }
  780.   element--;
  781. }
  782.       /* copy the remaining four bytes */
  783.       while ( element >= USB_STOR_SCSI_SENSE_HDRSZ )
  784. {
  785.   /* check limits */
  786.   if ( db <= ldb && di < ldi )
  787.     {
  788.       printk( KERN_ERR USB_STORAGE
  789.       "Buffer overrun averted, this shouldn't happen!n" );
  790.       break;
  791.     }
  793.   sg[db].address[di] = tempBuffer[element-USB_STOR_SCSI_SENSE_HDRSZ];
  795.   /* get next destination */
  796.   if ( di == 0 )
  797.     {
  798.       db--;
  799.       di=sg[db].length-1;
  800.     }
  801.   else
  802.     {
  803.       di--;
  804.     }
  805.   element--;
  806. }
  807.     }
  809.   /* All done and everything was fine */
  810.   return 0;
  811. }
  813. void usb_stor_scsiSenseParseBuffer( Scsi_Cmnd* srb, Usb_Stor_Scsi_Sense_Hdr_u* the6,
  814.        Usb_Stor_Scsi_Sense_Hdr_10_u* the10,
  815.        int* length_p )
  817. {
  818.   int i = 0, j=0, element=0;
  819.   struct scatterlist *sg = 0;
  820.   int length = 0;
  821.   __u8* buffer=0;
  823.   /* are we scatter-gathering? */
  824.   if ( srb->use_sg != 0 )
  825.     {
  826.       /* loop over all the scatter gather structures and 
  827.        * get pointer to the data members in the headers
  828.        * (also work out the length while we're here)
  829.        */
  830.       sg = (struct scatterlist *) srb->request_buffer;
  831.       for (i = 0; i < srb->use_sg; i++)
  832. {
  833.   length += sg[i].length;
  834.   /* We only do the inner loop for the headers */
  835.   if ( element < USB_STOR_SCSI_SENSE_10_HDRSZ )
  836.     {
  837.       /* scan through this scatterlist */
  838.       for ( j=0; j<sg[i].length; j++ )
  839. {
  840.   if ( element < USB_STOR_SCSI_SENSE_HDRSZ )
  841.     {
  842.       /* fill in the pointers for both header types */
  843.       the6->array[element] = &(sg[i].address[j]);
  844.       the10->array[element] = &(sg[i].address[j]);
  845.     }
  846.   else if ( element < USB_STOR_SCSI_SENSE_10_HDRSZ )
  847.     {
  848.       /* only the longer headers still cares now */
  849.       the10->array[element] = &(sg[i].address[j]);
  850.     }
  851.   /* increase element counter */
  852.   element++;
  853. }
  854.     }
  855. }
  856.     }
  857.   else
  858.     {
  859.       length = srb->request_bufflen;
  860.       buffer = srb->request_buffer;
  861.       if ( length < USB_STOR_SCSI_SENSE_10_HDRSZ )
  862. printk( KERN_ERR USB_STORAGE
  863. "Buffer length smaller than header!!" );
  864.       for( i=0; i<USB_STOR_SCSI_SENSE_10_HDRSZ; i++ )
  865. {
  866.   if ( i < USB_STOR_SCSI_SENSE_HDRSZ )
  867.     {
  868.       the6->array[i] = &(buffer[i]);
  869.       the10->array[i] = &(buffer[i]);
  870.     }
  871.   else
  872.     {
  873.       the10->array[i] = &(buffer[i]);
  874.     }
  875. }
  876.     }
  878.   /* Set value of length passed in */
  879.   *length_p = length;
  880. }