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

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

嵌入式Linux

开发平台：

Unix_Linux

shuttle_usbat.c：源码内容
  1. /* Driver for SCM Microsystems USB-ATAPI cable
  2.  *
  3.  * $Id: shuttle_usbat.c,v 1.15 2001/12/08 23:32:48 mdharm Exp $
  4.  *
  5.  * Current development and maintenance by:
  6.  *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
  7.  *
  8.  * Many originally ATAPI devices were slightly modified to meet the USB
  9.  * market by using some kind of translation from ATAPI to USB on the host,
  10.  * and the peripheral would translate from USB back to ATAPI.
  11.  *
  12.  * SCM Microsystems (www.scmmicro.com) makes a device, sold to OEM's only, 
  13.  * which does the USB-to-ATAPI conversion.  By obtaining the data sheet on
  14.  * their device under nondisclosure agreement, I have been able to write
  15.  * this driver for Linux.
  16.  *
  17.  * The chip used in the device can also be used for EPP and ISA translation
  18.  * as well. This driver is only guaranteed to work with the ATAPI
  19.  * translation.
  20.  *
  21.  * The only peripheral that I know of (as of 27 Mar 2001) that uses this
  22.  * device is the Hewlett-Packard 8200e/8210e/8230e CD-Writer Plus.
  23.  *
  24.  * This program is free software; you can redistribute it and/or modify it
  25.  * under the terms of the GNU General Public License as published by the
  26.  * Free Software Foundation; either version 2, or (at your option) any
  27.  * later version.
  28.  *
  29.  * This program is distributed in the hope that it will be useful, but
  30.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  31.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  32.  * General Public License for more details.
  33.  *
  34.  * You should have received a copy of the GNU General Public License along
  35.  * with this program; if not, write to the Free Software Foundation, Inc.,
  36.  * 675 Mass Ave, Cambridge, MA 02139, USA.
  37.  */
  39. #include "transport.h"
  40. #include "protocol.h"
  41. #include "usb.h"
  42. #include "debug.h"
  43. #include "shuttle_usbat.h"
  45. #include <linux/sched.h>
  46. #include <linux/errno.h>
  47. #include <linux/slab.h>
  49. extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
  50. u8 request, u8 requesttype, u16 value, u16 index,
  51. void *data, u16 size);
  52. extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
  53. unsigned int len, unsigned int *act_len);
  55. #define short_pack(LSB,MSB) ( ((u16)(LSB)) | ( ((u16)(MSB))<<8 ) )
  56. #define LSB_of(s) ((s)&0xFF)
  57. #define MSB_of(s) ((s)>>8)
  59. int transferred = 0;
  61. /*
  62.  * Send a control message and wait for the response.
  63.  *
  64.  * us - the pointer to the us_data structure for the device to use
  65.  *
  66.  * request - the URB Setup Packet's first 6 bytes. The first byte always
  67.  *  corresponds to the request type, and the second byte always corresponds
  68.  *  to the request.  The other 4 bytes do not correspond to value and index,
  69.  *  since they are used in a custom way by the SCM protocol.
  70.  *
  71.  * xfer_data - a buffer from which to get, or to which to store, any data
  72.  *  that gets send or received, respectively, with the URB. Even though
  73.  *  it looks like we allocate a buffer in this code for the data, xfer_data
  74.  *  must contain enough allocated space.
  75.  *
  76.  * xfer_len - the number of bytes to send or receive with the URB.
  77.  *
  78.  */
  80. static int usbat_send_control(struct us_data *us,
  81. int pipe,
  82. unsigned char request,
  83. unsigned char requesttype,
  84. unsigned short value,
  85. unsigned short index,
  86. unsigned char *xfer_data,
  87. unsigned int xfer_len) {
  89. int result;
  91. // Send the URB to the device and wait for a response.
  93. /* Why are request and request type reversed in this call? */
  95. result = usb_stor_control_msg(us, pipe,
  96. request, requesttype, value, index,
  97. xfer_data, xfer_len);
  100. // Check the return code for the command.
  102. if (result < 0) {
  103. /* if the command was aborted, indicate that */
  104. if (result == -ENOENT)
  105. return USB_STOR_TRANSPORT_ABORTED;
  107. /* a stall is a fatal condition from the device */
  108. if (result == -EPIPE) {
  109. US_DEBUGP("-- Stall on control pipe. Clearingn");
  110. result = usb_clear_halt(us->pusb_dev, pipe);
  111. US_DEBUGP("-- usb_clear_halt() returns %dn", result);
  112. return USB_STOR_TRANSPORT_FAILED;
  113. }
  115. /* Uh oh... serious problem here */
  116. return USB_STOR_TRANSPORT_ERROR;
  117. }
  119. return USB_STOR_TRANSPORT_GOOD;
  120. }
  122. static int usbat_raw_bulk(struct us_data *us, 
  123. int direction,
  124. unsigned char *data,
  125. unsigned short len) {
  127. int result;
  128. int act_len;
  129. int pipe;
  131. if (direction == SCSI_DATA_READ)
  132. pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
  133. else
  134. pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
  136. result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);
  138.         /* if we stall, we need to clear it before we go on */
  139.         if (result == -EPIPE) {
  140.                 US_DEBUGP("EPIPE: clearing endpoint halt for"
  141. " pipe 0x%x, stalled at %d bytesn",
  142. pipe, act_len);
  143.                 usb_clear_halt(us->pusb_dev, pipe);
  144.         }
  146. if (result) {
  148.                 /* NAK - that means we've retried a few times already */
  149.                 if (result == -ETIMEDOUT) {
  150.                         US_DEBUGP("usbat_raw_bulk():"
  151. " device NAKedn");
  152.                         return US_BULK_TRANSFER_FAILED;
  153.                 }
  155.                 /* -ENOENT -- we canceled this transfer */
  156.                 if (result == -ENOENT) {
  157.                         US_DEBUGP("usbat_raw_bulk():"
  158. " transfer abortedn");
  159.                         return US_BULK_TRANSFER_ABORTED;
  160.                 }
  162. if (result == -EPIPE) {
  163. US_DEBUGP("usbat_raw_bulk():"
  164. " output pipe stalledn");
  165. return US_BULK_TRANSFER_SHORT;
  166. }
  168.                 /* the catch-all case */
  169.                 US_DEBUGP("us_transfer_partial(): unknown errorn");
  170.                 return US_BULK_TRANSFER_FAILED;
  171.         }
  173. if (act_len != len) {
  174. US_DEBUGP("Warning: Transferred only %d bytesn",
  175. act_len);
  176. return US_BULK_TRANSFER_SHORT;
  177. }
  179. US_DEBUGP("Transferred %s %d of %d bytesn", 
  180. direction==SCSI_DATA_READ ? "in" : "out", act_len, len);
  182. return US_BULK_TRANSFER_GOOD;
  183. }
  185. /*
  186.  * Note: direction must be set if command_len == 0.
  187.  */
  189. static int usbat_bulk_transport(struct us_data *us,
  190.   unsigned char *command,
  191.   unsigned short command_len,
  192.   int direction,
  193.   unsigned char *data,
  194.   unsigned short len,
  195.   int use_sg) {
  197. int result = USB_STOR_TRANSPORT_GOOD;
  198. int transferred = 0;
  199. int i;
  200. struct scatterlist *sg;
  202. if (len==0)
  203. return USB_STOR_TRANSPORT_GOOD;
  205. /* transfer the data payload for the command, if there is any */
  207. if (command_len != 0)
  208. direction = (command[0]&0x80) ? SCSI_DATA_READ :
  209. SCSI_DATA_WRITE;
  211. if (!use_sg)
  212. result = usbat_raw_bulk(us, direction, data, len);
  213. else {
  214. sg = (struct scatterlist *)data;
  215. for (i=0; i<use_sg && transferred<len; i++) {
  216. result = usbat_raw_bulk(us, direction,
  217. sg[i].address, 
  218. len-transferred > sg[i].length ?
  219. sg[i].length : len-transferred);
  220. if (result!=US_BULK_TRANSFER_GOOD)
  221. break;
  222. transferred += sg[i].length;
  223. }
  224. }
  226. return result;
  227. }
  229. int usbat_read(struct us_data *us,
  230.      unsigned char access,
  231.      unsigned char reg, 
  232.      unsigned char *content) {
  234. int result;
  236. result = usbat_send_control(us,
  237. usb_rcvctrlpipe(us->pusb_dev,0),
  238. access,
  239. 0xC0,
  240. (u16)reg,
  241. 0,
  242. content,
  243. 1);
  245. return result;
  246. }
  248. int usbat_write(struct us_data *us,
  249.      unsigned char access,
  250.      unsigned char reg, 
  251.      unsigned char content) {
  253. int result;
  255. result = usbat_send_control(us,
  256. usb_sndctrlpipe(us->pusb_dev,0),
  257. access|0x01,
  258. 0x40,
  259. short_pack(reg, content),
  260. 0,
  261. NULL,
  262. 0);
  264. return result;
  265. }
  267. int usbat_set_shuttle_features(struct us_data *us,
  268.      unsigned char external_trigger,
  269.      unsigned char epp_control, 
  270.      unsigned char mask_byte, 
  271.      unsigned char test_pattern, 
  272.      unsigned char subcountH, 
  273.      unsigned char subcountL) {
  275. int result;
  276. unsigned char command[8] = {
  277. 0x40, 0x81, epp_control, external_trigger,
  278. test_pattern, mask_byte, subcountL, subcountH
  279. };
  281. result = usbat_send_control(us,
  282. usb_sndctrlpipe(us->pusb_dev,0),
  283. 0x80,
  284. 0x40,
  285. 0,
  286. 0,
  287. command,
  288. 8);
  290. return result;
  291. }
  293. int usbat_read_block(struct us_data *us,
  294.      unsigned char access,
  295.      unsigned char reg, 
  296.      unsigned char *content,
  297.      unsigned short len,
  298.      int use_sg) {
  300. int result;
  301. unsigned char command[8] = {
  302. 0xC0, access|0x02, reg, 0x00, 0x00, 0x00, 
  303. LSB_of(len), MSB_of(len)
  304. };
  306. result = usbat_send_control(us,
  307. usb_sndctrlpipe(us->pusb_dev,0),
  308. 0x80,
  309. 0x40,
  310. 0,
  311. 0,
  312. command,
  313. 8);
  315. if (result != USB_STOR_TRANSPORT_GOOD)
  316. return result;
  318. result = usbat_bulk_transport(us,
  319. NULL, 0, SCSI_DATA_READ, content, len, use_sg);
  321. return result;
  322. }
  324. /*
  325.  * Block, waiting for an ATA device to become not busy or to report
  326.  * an error condition.
  327.  */
  329. int usbat_wait_not_busy(struct us_data *us, int minutes) {
  331. int i;
  332. int result;
  333. unsigned char status;
  335. /* Synchronizing cache on a CDR could take a heck of a long time,
  336.  * but probably not more than 10 minutes or so. On the other hand,
  337.  * doing a full blank on a CDRW at speed 1 will take about 75
  338.  * minutes!
  339.  */
  341. for (i=0; i<1200+minutes*60; i++) {
  343.   result = usbat_read(us, USBAT_ATA, 0x17, &status);
  345. if (result!=USB_STOR_TRANSPORT_GOOD)
  346. return result;
  347. if (status&0x01) { // check condition
  348. result = usbat_read(us, USBAT_ATA, 0x10, &status);
  349. return USB_STOR_TRANSPORT_FAILED;
  350. }
  351. if (status&0x20) // device fault
  352. return USB_STOR_TRANSPORT_FAILED;
  354. if ((status&0x80)==0x00) { // not busy
  355. US_DEBUGP("Waited not busy for %d stepsn", i);
  356. return USB_STOR_TRANSPORT_GOOD;
  357. }
  359. if (i<500)
  360. wait_ms(10); // 5 seconds
  361. else if (i<700)
  362. wait_ms(50); // 10 seconds
  363. else if (i<1200)
  364. wait_ms(100); // 50 seconds
  365. else
  366. wait_ms(1000); // X minutes
  367. }
  369. US_DEBUGP("Waited not busy for %d minutes, timing out.n",
  370. minutes);
  371. return USB_STOR_TRANSPORT_FAILED;
  372. }
  374. int usbat_write_block(struct us_data *us,
  375.      unsigned char access,
  376.      unsigned char reg, 
  377.      unsigned char *content,
  378.      unsigned short len,
  379.      int use_sg,
  380.      int minutes) {
  382. int result;
  383. unsigned char command[8] = {
  384. 0x40, access|0x03, reg, 0x00, 0x00, 0x00, 
  385. LSB_of(len), MSB_of(len)
  386. };
  388. result = usbat_send_control(us,
  389. usb_sndctrlpipe(us->pusb_dev,0),
  390. 0x80,
  391. 0x40,
  392. 0,
  393. 0,
  394. command,
  395. 8);
  397. if (result != USB_STOR_TRANSPORT_GOOD)
  398. return result;
  400. result = usbat_bulk_transport(us,
  401. NULL, 0, SCSI_DATA_WRITE, content, len, use_sg);
  403. if (result != USB_STOR_TRANSPORT_GOOD)
  404. return result;
  406. return usbat_wait_not_busy(us, minutes);
  407. }
  409. int usbat_rw_block_test(struct us_data *us,
  410.      unsigned char access,
  411.      unsigned char *registers,
  412.      unsigned char *data_out,
  413.      unsigned short num_registers,
  414.      unsigned char data_reg, 
  415.      unsigned char status_reg, 
  416.      unsigned char timeout, 
  417.      unsigned char qualifier, 
  418.      int direction,
  419.      unsigned char *content,
  420.      unsigned short len,
  421.      int use_sg,
  422.      int minutes) {
  424. int result;
  426. // Not really sure the 0x07, 0x17, 0xfc, 0xe7 is necessary here,
  427. // but that's what came out of the trace every single time.
  429. unsigned char command[16] = {
  430. 0x40, access|0x07, 0x07, 0x17, 0xfc, 0xe7,
  431. LSB_of(num_registers*2), MSB_of(num_registers*2),
  432. (direction==SCSI_DATA_WRITE ? 0x40 : 0xC0), 
  433. access|(direction==SCSI_DATA_WRITE ? 0x05 : 0x04), 
  434. data_reg, status_reg,
  435. timeout, qualifier, LSB_of(len), MSB_of(len)
  436. };
  438. int i;
  439. unsigned char data[num_registers*2];
  440. unsigned char status;
  442. for (i=0; i<num_registers; i++) {
  443. data[i<<1] = registers[i];
  444. data[1+(i<<1)] = data_out[i];
  445. }
  447. for (i=0; i<20; i++) {
  449. /*
  450.  * The first time we send the full command, which consists
  451.  * of downloading the SCSI command followed by downloading
  452.  * the data via a write-and-test.  Any other time we only
  453.  * send the command to download the data -- the SCSI command
  454.  * is still 'active' in some sense in the device.
  455.  * 
  456.  * We're only going to try sending the data 10 times. After
  457.  * that, we just return a failure.
  458.  */
  460. result = usbat_send_control(us,
  461.   usb_sndctrlpipe(us->pusb_dev,0),
  462. 0x80,
  463. 0x40,
  464. 0,
  465. 0,
  466. (i==0 ? command : command+8),
  467. (i==0 ? 16 : 8));
  469. if (result != USB_STOR_TRANSPORT_GOOD)
  470. return result;
  472. if (i==0) {
  474. result = usbat_bulk_transport(us,
  475. NULL, 0, SCSI_DATA_WRITE, 
  476. data, num_registers*2, 0);
  478. if (result!=USB_STOR_TRANSPORT_GOOD)
  479. return result;
  481. }
  484. //US_DEBUGP("Transfer %s %d bytes, sg buffers %dn",
  485. // direction == SCSI_DATA_WRITE ? "out" : "in",
  486. // len, use_sg);
  488. result = usbat_bulk_transport(us,
  489. NULL, 0, direction, content, len, use_sg);
  491. /*
  492.  * If we get a stall on the bulk download, we'll retry
  493.  * the bulk download -- but not the SCSI command because
  494.  * in some sense the SCSI command is still 'active' and
  495.  * waiting for the data. Don't ask me why this should be;
  496.  * I'm only following what the Windoze driver did.
  497.  *
  498.  * Note that a stall for the test-and-read/write command means
  499.  * that the test failed. In this case we're testing to make
  500.  * sure that the device is error-free
  501.  * (i.e. bit 0 -- CHK -- of status is 0). The most likely
  502.  * hypothesis is that the USBAT chip somehow knows what
  503.  * the device will accept, but doesn't give the device any
  504.  * data until all data is received. Thus, the device would
  505.  * still be waiting for the first byte of data if a stall
  506.  * occurs, even if the stall implies that some data was
  507.  * transferred.
  508.  */
  510. if (result == US_BULK_TRANSFER_SHORT) {
  512. /*
  513.  * If we're reading and we stalled, then clear
  514.  * the bulk output pipe only the first time.
  515.  */
  517. if (direction==SCSI_DATA_READ && i==0)
  518. usb_clear_halt(us->pusb_dev,
  519. usb_sndbulkpipe(us->pusb_dev,
  520.   us->ep_out));
  521. /*
  522.  * Read status: is the device angry, or just busy?
  523.  */
  525.   result = usbat_read(us, USBAT_ATA, 
  526. direction==SCSI_DATA_WRITE ? 0x17 : 0x0E, 
  527. &status);
  529. if (result!=USB_STOR_TRANSPORT_GOOD)
  530. return result;
  531. if (status&0x01) // check condition
  532. return USB_STOR_TRANSPORT_FAILED;
  533. if (status&0x20) // device fault
  534. return USB_STOR_TRANSPORT_FAILED;
  536. US_DEBUGP("Redoing %sn",
  537.   direction==SCSI_DATA_WRITE ? "write" : "read");
  539. } else if (result != US_BULK_TRANSFER_GOOD)
  540. return result;
  541. else
  542. return usbat_wait_not_busy(us, minutes);
  544. }
  546. US_DEBUGP("Bummer! %s bulk data 20 times failed.n",
  547. direction==SCSI_DATA_WRITE ? "Writing" : "Reading");
  549. return USB_STOR_TRANSPORT_FAILED;
  550. }
  552. /*
  553.  * Write data to multiple registers at once. Not meant for large
  554.  * transfers of data!
  555.  */
  557. int usbat_multiple_write(struct us_data *us, 
  558. unsigned char access,
  559. unsigned char *registers,
  560. unsigned char *data_out,
  561. unsigned short num_registers) {
  563. int result;
  564. unsigned char data[num_registers*2];
  565. int i;
  566. unsigned char command[8] = {
  567. 0x40, access|0x07, 0x00, 0x00, 0x00, 0x00,
  568. LSB_of(num_registers*2), MSB_of(num_registers*2)
  569. };
  571. for (i=0; i<num_registers; i++) {
  572. data[i<<1] = registers[i];
  573. data[1+(i<<1)] = data_out[i];
  574. }
  576. result = usbat_send_control(us,
  577. usb_sndctrlpipe(us->pusb_dev,0),
  578. 0x80,
  579. 0x40,
  580. 0,
  581. 0,
  582. command,
  583. 8);
  585. if (result != USB_STOR_TRANSPORT_GOOD)
  586. return result;
  588. result = usbat_bulk_transport(us,
  589. NULL, 0, SCSI_DATA_WRITE, data, num_registers*2, 0);
  591. if (result!=USB_STOR_TRANSPORT_GOOD)
  592. return result;
  594. return usbat_wait_not_busy(us, 0);
  595. }
  597. int usbat_read_user_io(struct us_data *us,
  598. unsigned char *data_flags) {
  600. int result;
  602. result = usbat_send_control(us,
  603. usb_rcvctrlpipe(us->pusb_dev,0),
  604. 0x82,
  605. 0xC0,
  606. 0,
  607. 0,
  608. data_flags,
  609. 1);
  611. return result;
  612. }
  614. int usbat_write_user_io(struct us_data *us,
  615. unsigned char enable_flags,
  616. unsigned char data_flags) {
  618. int result;
  620. result = usbat_send_control(us,
  621. usb_sndctrlpipe(us->pusb_dev,0),
  622. 0x82,
  623. 0x40,
  624. short_pack(enable_flags, data_flags),
  625. 0,
  626. NULL,
  627. 0);
  629. return result;
  630. }
  632. /*
  633.  * Squeeze a potentially huge (> 65535 byte) read10 command into
  634.  * a little ( <= 65535 byte) ATAPI pipe
  635.  */
  637. int usbat_handle_read10(struct us_data *us,
  638. unsigned char *registers,
  639. unsigned char *data,
  640. Scsi_Cmnd *srb) {
  642. int result = USB_STOR_TRANSPORT_GOOD;
  643. unsigned char *buffer;
  644. unsigned int len;
  645. unsigned int sector;
  646. unsigned int amount;
  647. struct scatterlist *sg = NULL;
  648. int sg_segment = 0;
  649. int sg_offset = 0;
  651. US_DEBUGP("handle_read10: transfersize %dn",
  652. srb->transfersize);
  654. if (srb->request_bufflen < 0x10000) {
  656. result = usbat_rw_block_test(us, USBAT_ATA, 
  657. registers, data, 19,
  658. 0x10, 0x17, 0xFD, 0x30,
  659. SCSI_DATA_READ,
  660. srb->request_buffer, 
  661. srb->request_bufflen, srb->use_sg, 1);
  663. return result;
  664. }
  666. /*
  667.  * Since we're requesting more data than we can handle in
  668.  * a single read command (max is 64k-1), we will perform
  669.  * multiple reads, but each read must be in multiples of
  670.  * a sector.  Luckily the sector size is in srb->transfersize
  671.  * (see linux/drivers/scsi/sr.c).
  672.  */
  674. if (data[7+0] == GPCMD_READ_CD) {
  675. len = short_pack(data[7+9], data[7+8]);
  676. len <<= 16;
  677. len |= data[7+7];
  678. srb->transfersize = srb->request_bufflen/len;
  679. }
  682. len = (65535/srb->transfersize) * srb->transfersize;
  683. US_DEBUGP("Max read is %d bytesn", len);
  684. buffer = kmalloc(len, GFP_NOIO);
  685. if (buffer == NULL) // bloody hell!
  686. return USB_STOR_TRANSPORT_FAILED;
  687. sector = short_pack(data[7+3], data[7+2]);
  688. sector <<= 16;
  689. sector |= short_pack(data[7+5], data[7+4]);
  690. transferred = 0;
  692. if (srb->use_sg) {
  693. sg = (struct scatterlist *)srb->request_buffer;
  694. sg_segment = 0; // for keeping track of where we are in
  695. sg_offset = 0;  // the scatter/gather list
  696. }
  698. while (transferred != srb->request_bufflen) {
  700. if (len > srb->request_bufflen - transferred)
  701. len = srb->request_bufflen - transferred;
  703. data[3] = len&0xFF;    // (cylL) = expected length (L)
  704. data[4] = (len>>8)&0xFF;  // (cylH) = expected length (H)
  706. // Fix up the SCSI command sector and num sectors
  708. data[7+2] = MSB_of(sector>>16); // SCSI command sector
  709. data[7+3] = LSB_of(sector>>16);
  710. data[7+4] = MSB_of(sector&0xFFFF);
  711. data[7+5] = LSB_of(sector&0xFFFF);
  712. if (data[7+0] == GPCMD_READ_CD)
  713. data[7+6] = 0;
  714. data[7+7] = MSB_of(len / srb->transfersize); // SCSI command
  715. data[7+8] = LSB_of(len / srb->transfersize); // num sectors
  717. result = usbat_rw_block_test(us, USBAT_ATA, 
  718. registers, data, 19,
  719. 0x10, 0x17, 0xFD, 0x30,
  720. SCSI_DATA_READ,
  721. buffer,
  722. len, 0, 1);
  724. if (result != USB_STOR_TRANSPORT_GOOD)
  725. break;
  727. // Transfer the received data into the srb buffer
  729. if (!srb->use_sg) {
  730. memcpy(srb->request_buffer+transferred, buffer, len);
  731. } else {
  732. amount = 0;
  733. while (amount<len) {
  734. if (len - amount >= 
  735.   sg[sg_segment].length-sg_offset) {
  736.   memcpy(sg[sg_segment].address + sg_offset,
  737. buffer + amount,
  738. sg[sg_segment].length - sg_offset);
  739.   amount += 
  740.   sg[sg_segment].length-sg_offset;
  741.   sg_segment++;
  742.   sg_offset=0;
  743. } else {
  744.   memcpy(sg[sg_segment].address + sg_offset,
  745. buffer + amount,
  746. len - amount);
  747.   sg_offset += (len - amount);
  748.   amount = len;
  749. }
  750. }
  751. }
  753. // Update the amount transferred and the sector number
  755. transferred += len;
  756. sector += len / srb->transfersize;
  758. } // while transferred != srb->request_bufflen
  760. kfree(buffer);
  761. return result;
  762. }
  764. static int hp_8200e_select_and_test_registers(struct us_data *us) {
  766. int result;
  767. int selector;
  768. unsigned char status;
  770. // try device = master, then device = slave.
  772. for (selector = 0xA0; selector <= 0xB0; selector += 0x10) {
  774. if ( (result = usbat_write(us, USBAT_ATA, 0x16, selector)) != 
  775. USB_STOR_TRANSPORT_GOOD)
  776. return result;
  778. if ( (result = usbat_read(us, USBAT_ATA, 0x17, &status)) != 
  779. USB_STOR_TRANSPORT_GOOD)
  780. return result;
  782. if ( (result = usbat_read(us, USBAT_ATA, 0x16, &status)) != 
  783. USB_STOR_TRANSPORT_GOOD)
  784. return result;
  786. if ( (result = usbat_read(us, USBAT_ATA, 0x14, &status)) != 
  787. USB_STOR_TRANSPORT_GOOD)
  788. return result;
  790. if ( (result = usbat_read(us, USBAT_ATA, 0x15, &status)) != 
  791. USB_STOR_TRANSPORT_GOOD)
  792. return result;
  794. if ( (result = usbat_write(us, USBAT_ATA, 0x14, 0x55)) != 
  795. USB_STOR_TRANSPORT_GOOD)
  796. return result;
  798. if ( (result = usbat_write(us, USBAT_ATA, 0x15, 0xAA)) != 
  799. USB_STOR_TRANSPORT_GOOD)
  800. return result;
  802. if ( (result = usbat_read(us, USBAT_ATA, 0x14, &status)) != 
  803. USB_STOR_TRANSPORT_GOOD)
  804. return result;
  806. if ( (result = usbat_read(us, USBAT_ATA, 0x15, &status)) != 
  807. USB_STOR_TRANSPORT_GOOD)
  808. return result;
  809. }
  811. return result;
  812. }
  814. int init_8200e(struct us_data *us) {
  816. int result;
  817. unsigned char status;
  819. // Enable peripheral control signals
  821. if ( (result = usbat_write_user_io(us,
  822.   USBAT_UIO_OE1 | USBAT_UIO_OE0,
  823.   USBAT_UIO_EPAD | USBAT_UIO_1)) != USB_STOR_TRANSPORT_GOOD)
  824. return result;
  826. US_DEBUGP("INIT 1n");
  828. wait_ms(2000);
  830. if ( (result = usbat_read_user_io(us, &status)) !=
  831. USB_STOR_TRANSPORT_GOOD)
  832. return result;
  834. US_DEBUGP("INIT 2n");
  836. if ( (result = usbat_read_user_io(us, &status)) !=
  837. USB_STOR_TRANSPORT_GOOD)
  838. return result;
  840. US_DEBUGP("INIT 3n");
  842. // Reset peripheral, enable periph control signals
  843. // (bring reset signal up)
  845. if ( (result = usbat_write_user_io(us,
  846.   USBAT_UIO_DRVRST | USBAT_UIO_OE1 | USBAT_UIO_OE0,
  847.   USBAT_UIO_EPAD | USBAT_UIO_1)) != USB_STOR_TRANSPORT_GOOD)
  848. return result;
  850. US_DEBUGP("INIT 4n");
  852. // Enable periph control signals
  853. // (bring reset signal down)
  855. if ( (result = usbat_write_user_io(us,
  856.   USBAT_UIO_OE1 | USBAT_UIO_OE0,
  857.   USBAT_UIO_EPAD | USBAT_UIO_1)) != USB_STOR_TRANSPORT_GOOD)
  858. return result;
  860. US_DEBUGP("INIT 5n");
  862. wait_ms(250);
  864. // Write 0x80 to ISA port 0x3F
  866. if ( (result = usbat_write(us, USBAT_ISA, 0x3F, 0x80)) !=
  867. USB_STOR_TRANSPORT_GOOD)
  868. return result;
  870. US_DEBUGP("INIT 6n");
  872. // Read ISA port 0x27
  874. if ( (result = usbat_read(us, USBAT_ISA, 0x27, &status)) !=
  875. USB_STOR_TRANSPORT_GOOD)
  876. return result;
  878. US_DEBUGP("INIT 7n");
  880. if ( (result = usbat_read_user_io(us, &status)) !=
  881. USB_STOR_TRANSPORT_GOOD)
  882. return result;
  884. US_DEBUGP("INIT 8n");
  886. if ( (result = hp_8200e_select_and_test_registers(us)) !=
  887.  USB_STOR_TRANSPORT_GOOD)
  888. return result;
  890. US_DEBUGP("INIT 9n");
  892. if ( (result = usbat_read_user_io(us, &status)) !=
  893. USB_STOR_TRANSPORT_GOOD)
  894. return result;
  896. US_DEBUGP("INIT 10n");
  898. // Enable periph control signals and card detect
  900. if ( (result = usbat_write_user_io(us,
  901.   USBAT_UIO_ACKD |USBAT_UIO_OE1 | USBAT_UIO_OE0,
  902.   USBAT_UIO_EPAD | USBAT_UIO_1)) != USB_STOR_TRANSPORT_GOOD)
  903. return result;
  905. US_DEBUGP("INIT 11n");
  907. if ( (result = usbat_read_user_io(us, &status)) !=
  908. USB_STOR_TRANSPORT_GOOD)
  909. return result;
  911. US_DEBUGP("INIT 12n");
  913. wait_ms(1400);
  915. if ( (result = usbat_read_user_io(us, &status)) !=
  916. USB_STOR_TRANSPORT_GOOD)
  917. return result;
  919. US_DEBUGP("INIT 13n");
  921. if ( (result = hp_8200e_select_and_test_registers(us)) !=
  922.  USB_STOR_TRANSPORT_GOOD)
  923. return result;
  925. US_DEBUGP("INIT 14n");
  927. if ( (result = usbat_set_shuttle_features(us, 
  928. 0x83, 0x00, 0x88, 0x08, 0x15, 0x14)) !=
  929.  USB_STOR_TRANSPORT_GOOD)
  930. return result;
  932. US_DEBUGP("INIT 15n");
  934. return result;
  935. }
  937. /*
  938.  * Transport for the HP 8200e
  939.  */
  940. int hp8200e_transport(Scsi_Cmnd *srb, struct us_data *us)
  941. {
  942. int result;
  943. unsigned char status;
  944. unsigned char registers[32];
  945. unsigned char data[32];
  946. unsigned int len;
  947. int i;
  948. char string[64];
  950. len = srb->request_bufflen;
  952. /* Send A0 (ATA PACKET COMMAND).
  953.    Note: I guess we're never going to get any of the ATA
  954.    commands... just ATA Packet Commands.
  955.    */
  957. registers[0] = 0x11;
  958. registers[1] = 0x12;
  959. registers[2] = 0x13;
  960. registers[3] = 0x14;
  961. registers[4] = 0x15;
  962. registers[5] = 0x16;
  963. registers[6] = 0x17;
  964. data[0] = 0x00;
  965. data[1] = 0x00;
  966. data[2] = 0x00;
  967. data[3] = len&0xFF;  // (cylL) = expected length (L)
  968. data[4] = (len>>8)&0xFF;  // (cylH) = expected length (H)
  969. data[5] = 0xB0;  // (device sel) = slave
  970. data[6] = 0xA0;  // (command) = ATA PACKET COMMAND
  972. for (i=7; i<19; i++) {
  973. registers[i] = 0x10;
  974. data[i] = (i-7 >= srb->cmd_len) ? 0 : srb->cmnd[i-7];
  975. }
  977. result = usbat_read(us, USBAT_ATA, 0x17, &status);
  978. US_DEBUGP("Status = %02Xn", status);
  980. if (srb->cmnd[0] == TEST_UNIT_READY)
  981. transferred = 0;
  983. if (srb->sc_data_direction == SCSI_DATA_WRITE) {
  985. result = usbat_rw_block_test(us, USBAT_ATA, 
  986. registers, data, 19,
  987. 0x10, 0x17, 0xFD, 0x30,
  988. SCSI_DATA_WRITE,
  989. srb->request_buffer, 
  990. len, srb->use_sg, 10);
  992. if (result == USB_STOR_TRANSPORT_GOOD) {
  993. transferred += len;
  994. US_DEBUGP("Wrote %08X bytesn", transferred);
  995. }
  997. return result;
  999. } else if (srb->cmnd[0] == READ_10 ||
  1000.    srb->cmnd[0] == GPCMD_READ_CD) {
  1002. return usbat_handle_read10(us, registers, data, srb);
  1004. }
  1006. if (len > 0xFFFF) {
  1007. US_DEBUGP("Error: len = %08X... what do I do now?n",
  1008. len);
  1009. return USB_STOR_TRANSPORT_ERROR;
  1010. }
  1012. if ( (result = usbat_multiple_write(us, 
  1013. USBAT_ATA,
  1014. registers, data, 7)) != USB_STOR_TRANSPORT_GOOD) {
  1015. return result;
  1016. }
  1018. // Write the 12-byte command header.
  1020. // If the command is BLANK then set the timer for 75 minutes.
  1021. // Otherwise set it for 10 minutes.
  1023. // NOTE: THE 8200 DOCUMENTATION STATES THAT BLANKING A CDRW
  1024. // AT SPEED 4 IS UNRELIABLE!!!
  1026. if ( (result = usbat_write_block(us, 
  1027. USBAT_ATA, 0x10, srb->cmnd, 12, 0,
  1028. srb->cmnd[0]==GPCMD_BLANK ? 75 : 10)) !=
  1029. USB_STOR_TRANSPORT_GOOD) {
  1030. return result;
  1031. }
  1033. // If there is response data to be read in 
  1034. // then do it here.
  1036. if (len != 0 && (srb->sc_data_direction == SCSI_DATA_READ)) {
  1038. // How many bytes to read in? Check cylL register
  1040. if ( (result = usbat_read(us, USBAT_ATA, 0x14, &status)) != 
  1041.     USB_STOR_TRANSPORT_GOOD) {
  1042. return result;
  1043. }
  1045. if (len>0xFF) { // need to read cylH also
  1046. len = status;
  1047. if ( (result = usbat_read(us, USBAT_ATA, 0x15,
  1048. &status)) !=
  1049.     USB_STOR_TRANSPORT_GOOD) {
  1050. return result;
  1051. }
  1052. len += ((unsigned int)status)<<8;
  1053. }
  1054. else
  1055. len = status;
  1058. result = usbat_read_block(us, USBAT_ATA, 0x10, 
  1059. srb->request_buffer, len, srb->use_sg);
  1061. /* Debug-print the first 32 bytes of the transfer */
  1063. if (!srb->use_sg) {
  1064. string[0] = 0;
  1065. for (i=0; i<len && i<32; i++) {
  1066. sprintf(string+strlen(string), "%02X ",
  1067.   ((unsigned char *)srb->request_buffer)[i]);
  1068. if ((i%16)==15) {
  1069. US_DEBUGP("%sn", string);
  1070. string[0] = 0;
  1071. }
  1072. }
  1073. if (string[0]!=0)
  1074. US_DEBUGP("%sn", string);
  1075. }
  1076. }
  1078. return result;
  1079. }