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

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

Linux/Unix编程

开发平台：

Unix_Linux

sddr09.c：源码内容
  1. /* Driver for SanDisk SDDR-09 SmartMedia reader
  2.  *
  3.  * $Id: sddr09.c,v 1.23 2002/02/25 00:40:13 mdharm Exp $
  4.  *
  5.  * SDDR09 driver v0.1:
  6.  *
  7.  * First release
  8.  *
  9.  * Current development and maintenance by:
  10.  *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
  11.  *
  12.  * Developed with the assistance of:
  13.  *   (c) 2002 Alan Stern <stern@rowland.org>
  14.  *
  15.  * The SanDisk SDDR-09 SmartMedia reader uses the Shuttle EUSB-01 chip.
  16.  * This chip is a programmable USB controller. In the SDDR-09, it has
  17.  * been programmed to obey a certain limited set of SCSI commands. This
  18.  * driver translates the "real" SCSI commands to the SDDR-09 SCSI
  19.  * commands.
  20.  *
  21.  * This program is free software; you can redistribute it and/or modify it
  22.  * under the terms of the GNU General Public License as published by the
  23.  * Free Software Foundation; either version 2, or (at your option) any
  24.  * later version.
  25.  *
  26.  * This program is distributed in the hope that it will be useful, but
  27.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  28.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  29.  * General Public License for more details.
  30.  *
  31.  * You should have received a copy of the GNU General Public License along
  32.  * with this program; if not, write to the Free Software Foundation, Inc.,
  33.  * 675 Mass Ave, Cambridge, MA 02139, USA.
  34.  */
  36. #include "transport.h"
  37. #include "protocol.h"
  38. #include "usb.h"
  39. #include "debug.h"
  40. #include "sddr09.h"
  42. #include <linux/sched.h>
  43. #include <linux/errno.h>
  44. #include <linux/slab.h>
  46. #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
  47. #define LSB_of(s) ((s)&0xFF)
  48. #define MSB_of(s) ((s)>>8)
  50. /*
  51.  * Send a control message and wait for the response.
  52.  *
  53.  * us - the pointer to the us_data structure for the device to use
  54.  *
  55.  * request - the URB Setup Packet's first 6 bytes. The first byte always
  56.  *  corresponds to the request type, and the second byte always corresponds
  57.  *  to the request.  The other 4 bytes do not correspond to value and index,
  58.  *  since they are used in a custom way by the SCM protocol.
  59.  *
  60.  * xfer_data - a buffer from which to get, or to which to store, any data
  61.  *  that gets send or received, respectively, with the URB. Even though
  62.  *  it looks like we allocate a buffer in this code for the data, xfer_data
  63.  *  must contain enough allocated space.
  64.  *
  65.  * xfer_len - the number of bytes to send or receive with the URB.
  66.  *
  67.  */
  69. static int sddr09_send_control(struct us_data *us,
  70. int pipe,
  71. unsigned char request,
  72. unsigned char requesttype,
  73. unsigned short value,
  74. unsigned short index,
  75. unsigned char *xfer_data,
  76. unsigned int xfer_len) {
  78. int result;
  80. // If data is going to be sent or received with the URB,
  81. // then allocate a buffer for it. If data is to be sent,
  82. // copy the data into the buffer.
  83. /*
  84. if (xfer_len > 0) {
  85. buffer = kmalloc(xfer_len, GFP_NOIO);
  86. if (!(command[0] & USB_DIR_IN))
  87. memcpy(buffer, xfer_data, xfer_len);
  88. }
  89. */
  90. // Send the URB to the device and wait for a response.
  92. /* Why are request and request type reversed in this call? */
  94. result = usb_stor_control_msg(us, pipe,
  95. request, requesttype, value, index,
  96. xfer_data, xfer_len);
  99. // If data was sent or received with the URB, free the buffer we
  100. // allocated earlier, but not before reading the data out of the
  101. // buffer if we wanted to receive data.
  102. /*
  103. if (xfer_len > 0) {
  104. if (command[0] & USB_DIR_IN)
  105. memcpy(xfer_data, buffer, xfer_len);
  106. kfree(buffer);
  107. }
  108. */
  109. // Check the return code for the command.
  111. if (result < 0) {
  112. /* if the command was aborted, indicate that */
  113. if (result == -ENOENT)
  114. return USB_STOR_TRANSPORT_ABORTED;
  116. /* a stall is a fatal condition from the device */
  117. if (result == -EPIPE) {
  118. US_DEBUGP("-- Stall on control pipe. Clearingn");
  119. result = usb_stor_clear_halt(us, pipe);
  120. US_DEBUGP("-- usb_stor_clear_halt() returns %dn", result);
  121. return USB_STOR_TRANSPORT_FAILED;
  122. }
  124. /* Uh oh... serious problem here */
  125. return USB_STOR_TRANSPORT_ERROR;
  126. }
  128. return USB_STOR_TRANSPORT_GOOD;
  129. }
  131. static int sddr09_raw_bulk(struct us_data *us, 
  132. int direction,
  133. unsigned char *data,
  134. unsigned int len) {
  136. int result;
  137. int act_len;
  138. int pipe;
  140. if (direction == SCSI_DATA_READ)
  141. pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
  142. else
  143. pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
  145. result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);
  147.         /* if we stall, we need to clear it before we go on */
  148.         if (result == -EPIPE) {
  149.                 US_DEBUGP("EPIPE: clearing endpoint halt for"
  150. " pipe 0x%x, stalled at %d bytesn",
  151. pipe, act_len);
  152.                 usb_stor_clear_halt(us, pipe);
  153.         }
  155. if (result) {
  157.                 /* NAK - that means we've retried a few times already */
  158.                 if (result == -ETIMEDOUT) {
  159.                         US_DEBUGP("usbat_raw_bulk():"
  160. " device NAKedn");
  161.                         return US_BULK_TRANSFER_FAILED;
  162.                 }
  164.                 /* -ENOENT -- we canceled this transfer */
  165.                 if (result == -ENOENT) {
  166.                         US_DEBUGP("usbat_raw_bulk():"
  167. " transfer abortedn");
  168.                         return US_BULK_TRANSFER_ABORTED;
  169.                 }
  171. if (result == -EPIPE) {
  172. US_DEBUGP("usbat_raw_bulk():"
  173. " output pipe stalledn");
  174. return USB_STOR_TRANSPORT_FAILED;
  175. }
  177.                 /* the catch-all case */
  178.                 US_DEBUGP("us_transfer_partial(): unknown errorn");
  179.                 return US_BULK_TRANSFER_FAILED;
  180.         }
  182. if (act_len != len) {
  183. US_DEBUGP("Warning: Transferred only %d bytesn",
  184. act_len);
  185. return US_BULK_TRANSFER_SHORT;
  186. }
  188. US_DEBUGP("Transferred %d of %d bytesn", act_len, len);
  190. return US_BULK_TRANSFER_GOOD;
  191. }
  193. /*
  194.  * Note: direction must be set if command_len == 0.
  195.  */
  197. static int sddr09_bulk_transport(struct us_data *us,
  198.   int direction,
  199.   unsigned char *data,
  200.   unsigned int len,
  201.   int use_sg) {
  203. int result = USB_STOR_TRANSPORT_GOOD;
  204. int transferred = 0;
  205. int i;
  206. struct scatterlist *sg;
  207. char string[64];
  209. if (len==0)
  210. return USB_STOR_TRANSPORT_GOOD;
  213. /* transfer the data */
  215. if (direction == SCSI_DATA_WRITE) {
  217. /* Debug-print the first 48 bytes of the write transfer */
  219. if (!use_sg) {
  220. strcpy(string, "wr: ");
  221. for (i=0; i<len && i<48; i++) {
  222. sprintf(string+strlen(string), "%02X ",
  223.   data[i]);
  224. if ((i%16)==15) {
  225. US_DEBUGP("%sn", string);
  226. strcpy(string, "wr: ");
  227. }
  228. }
  229. if ((i%16)!=0)
  230. US_DEBUGP("%sn", string);
  231. }
  232. }
  235. US_DEBUGP("SCM data %s transfer %d sg buffers %dn",
  236.   ( direction==SCSI_DATA_READ ? "in" : "out"),
  237.   len, use_sg);
  239. if (!use_sg)
  240. result = sddr09_raw_bulk(us, direction, data, len);
  241. else {
  242. sg = (struct scatterlist *)data;
  243. for (i=0; i<use_sg && transferred<len; i++) {
  244. result = sddr09_raw_bulk(us, direction,
  245. sg[i].address, 
  246. len-transferred > sg[i].length ?
  247. sg[i].length : len-transferred);
  248. if (result!=US_BULK_TRANSFER_GOOD)
  249. break;
  250. transferred += sg[i].length;
  251. }
  252. }
  254. if (direction == SCSI_DATA_READ) {
  256. /* Debug-print the first 48 bytes of the read transfer */
  258. if (!use_sg) {
  259. strcpy(string, "rd: ");
  260. for (i=0; i<len && i<48; i++) {
  261. sprintf(string+strlen(string), "%02X ",
  262.   data[i]);
  263. if ((i%16)==15) {
  264. US_DEBUGP("%sn", string);
  265. strcpy(string, "rd: ");
  266. }
  267. }
  268. if ((i%16)!=0)
  269. US_DEBUGP("%sn", string);
  270. }
  271. }
  273. return result;
  274. }
  276. int sddr09_read_data(struct us_data *us,
  277. unsigned long address,
  278. unsigned short sectors,
  279. unsigned char *content,
  280. int use_sg) {
  282. int result;
  283. unsigned char command[12] = {
  284. 0xe8, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  285. };
  286. struct sddr09_card_info *info = (struct sddr09_card_info *)us->extra;
  287. unsigned int lba;
  288. unsigned int pba;
  289. unsigned short page;
  290. unsigned short pages;
  291. unsigned char *buffer = NULL;
  292. unsigned char *ptr;
  293. struct scatterlist *sg = NULL;
  294. int i;
  295. int len;
  296. int transferred;
  298. // If we're using scatter-gather, we have to create a new
  299. // buffer to read all of the data in first, since a
  300. // scatter-gather buffer could in theory start in the middle
  301. // of a page, which would be bad. A developer who wants a
  302. // challenge might want to write a limited-buffer
  303. // version of this code.
  305. len = sectors*info->pagesize;
  307. if (use_sg) {
  308. sg = (struct scatterlist *)content;
  309. buffer = kmalloc(len, GFP_NOIO);
  310. if (buffer == NULL)
  311. return USB_STOR_TRANSPORT_ERROR;
  312. ptr = buffer;
  313. } else
  314. ptr = content;
  316. // Figure out the initial LBA and page
  318. pba = address >> (info->pageshift + info->blockshift);
  319. lba = info->pba_to_lba[pba];
  320. page = (address >> info->pageshift) & info->blockmask;
  322. // This could be made much more efficient by checking for
  323. // contiguous LBA's. Another exercise left to the student.
  325. while (sectors>0) {
  327. pba = info->lba_to_pba[lba];
  329. // Read as many sectors as possible in this block
  331. pages = info->blocksize - page;
  332. if (pages > sectors)
  333. pages = sectors;
  335. US_DEBUGP("Read %02X pages, from PBA %04X"
  336. " (LBA %04X) page %02Xn",
  337. pages, pba, lba, page);
  339. address = ( (pba << info->blockshift) + page ) << 
  340. info->pageshift;
  342. // Unlike in the documentation, the address is in
  343. // words of 2 bytes.
  345. command[2] = MSB_of(address>>17);
  346. command[3] = LSB_of(address>>17); 
  347. command[4] = MSB_of((address>>1)&0xFFFF);
  348. command[5] = LSB_of((address>>1)&0xFFFF); 
  350. command[10] = MSB_of(pages);
  351. command[11] = LSB_of(pages);
  353. result = sddr09_send_control(us,
  354. usb_sndctrlpipe(us->pusb_dev,0),
  355. 0,
  356. 0x41,
  357. 0,
  358. 0,
  359. command,
  360. 12);
  362. US_DEBUGP("Result for send_control in read_data %dn",
  363. result);
  365. if (result != USB_STOR_TRANSPORT_GOOD) {
  366. if (use_sg)
  367. kfree(buffer);
  368. return result;
  369. }
  371. result = sddr09_bulk_transport(us,
  372. SCSI_DATA_READ, ptr,
  373. pages<<info->pageshift, 0);
  375. if (result != USB_STOR_TRANSPORT_GOOD) {
  376. if (use_sg)
  377. kfree(buffer);
  378. return result;
  379. }
  381. page = 0;
  382. lba++;
  383. sectors -= pages;
  384. ptr += (pages << info->pageshift);
  385. }
  387. if (use_sg) {
  388. transferred = 0;
  389. for (i=0; i<use_sg && transferred<len; i++) {
  390. memcpy(sg[i].address, buffer+transferred,
  391. len-transferred > sg[i].length ?
  392. sg[i].length : len-transferred);
  393. transferred += sg[i].length;
  394. }
  395. kfree(buffer);
  396. }
  398. return USB_STOR_TRANSPORT_GOOD;
  399. }
  401. int sddr09_read_control(struct us_data *us,
  402. unsigned long address,
  403. unsigned short blocks,
  404. unsigned char *content,
  405. int use_sg) {
  407. // Unlike in the documentation, the last two bytes are the
  408. // number of blocks, not sectors.
  410. int result;
  411. unsigned char command[12] = {
  412. 0xe8, 0x21, MSB_of(address>>16),
  413. LSB_of(address>>16), MSB_of(address&0xFFFF),
  414. LSB_of(address&0xFFFF), 0, 0, 0, 0,
  415. MSB_of(blocks), LSB_of(blocks)
  416. };
  418. US_DEBUGP("Read control address %08lX blocks %04Xn",
  419. address, blocks);
  421. result = sddr09_send_control(us,
  422. usb_sndctrlpipe(us->pusb_dev,0),
  423. 0,
  424. 0x41,
  425. 0,
  426. 0,
  427. command,
  428. 12);
  430. US_DEBUGP("Result for send_control in read_control %dn",
  431. result);
  433. if (result != USB_STOR_TRANSPORT_GOOD)
  434. return result;
  436. result = sddr09_bulk_transport(us,
  437. SCSI_DATA_READ, content,
  438. blocks<<6, use_sg); // 0x40 bytes per block
  440. US_DEBUGP("Result for bulk read in read_control %dn",
  441. result);
  443. return result;
  444. }
  446. int sddr09_read_deviceID(struct us_data *us,
  447. unsigned char *manufacturerID,
  448. unsigned char *deviceID) {
  450. int result;
  451. unsigned char command[12] = {
  452. 0xed, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  453. };
  454. unsigned char content[64];
  456. result = sddr09_send_control(us,
  457. usb_sndctrlpipe(us->pusb_dev,0),
  458. 0,
  459. 0x41,
  460. 0,
  461. 0,
  462. command,
  463. 12);
  465. US_DEBUGP("Result of send_control for device ID is %dn",
  466. result);
  468. if (result != USB_STOR_TRANSPORT_GOOD)
  469. return result;
  471. result = sddr09_bulk_transport(us,
  472. SCSI_DATA_READ, content,
  473. 64, 0);
  475. *manufacturerID = content[0];
  476. *deviceID = content[1];
  478. return result;
  479. }
  481. int sddr09_read_status(struct us_data *us,
  482. unsigned char *status) {
  484. int result;
  485. unsigned char command[12] = {
  486. 0xec, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  487. };
  489. result = sddr09_send_control(us,
  490. usb_sndctrlpipe(us->pusb_dev,0),
  491. 0,
  492. 0x41,
  493. 0,
  494. 0,
  495. command,
  496. 12);
  498. if (result != USB_STOR_TRANSPORT_GOOD)
  499. return result;
  501. result = sddr09_bulk_transport(us,
  502. SCSI_DATA_READ, status,
  503. 1, 0);
  505. return result;
  506. }
  508. int sddr09_reset(struct us_data *us) {
  510. int result;
  511. unsigned char command[12] = {
  512. 0xeb, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  513. };
  515. result = sddr09_send_control(us,
  516. usb_sndctrlpipe(us->pusb_dev,0),
  517. 0,
  518. 0x41,
  519. 0,
  520. 0,
  521. command,
  522. 12);
  524. return result;
  525. }
  527. unsigned long sddr09_get_capacity(struct us_data *us,
  528. unsigned int *pagesize, unsigned int *blocksize) {
  530. unsigned char manufacturerID;
  531. unsigned char deviceID;
  532. int result;
  534. US_DEBUGP("Reading capacity...n");
  536. result = sddr09_read_deviceID(us,
  537. &manufacturerID,
  538. &deviceID);
  540. US_DEBUGP("Result of read_deviceID is %dn",
  541. result);
  543. if (result != USB_STOR_TRANSPORT_GOOD)
  544. return 0;
  546. US_DEBUGP("Device ID = %02Xn", deviceID);
  547. US_DEBUGP("Manuf  ID = %02Xn", manufacturerID);
  549. *pagesize = 512;
  550. *blocksize = 16;
  552. switch (deviceID) {
  554. case 0x6e: // 1MB
  555. case 0xe8:
  556. case 0xec:
  557. *pagesize = 256;
  558. return 0x00100000;
  560. case 0xea: // 2MB
  561. case 0x5d: // 5d is a ROM card with pagesize 512.
  562. case 0x64:
  563. if (deviceID!=0x5D)
  564. *pagesize = 256;
  565. return 0x00200000;
  567. case 0xe3: // 4MB
  568. case 0xe5:
  569. case 0x6b:
  570. case 0xd5:
  571. return 0x00400000;
  573. case 0xe6: // 8MB
  574. case 0xd6:
  575. return 0x00800000;
  577. case 0x73: // 16MB
  578. *blocksize = 32;
  579. return 0x01000000;
  581. case 0x75: // 32MB
  582. *blocksize = 32;
  583. return 0x02000000;
  585. case 0x76: // 64MB
  586. *blocksize = 32;
  587. return 0x04000000;
  589. case 0x79: // 128MB
  590. *blocksize = 32;
  591. return 0x08000000;
  593. default: // unknown
  594. return 0;
  596. }
  597. }
  599. int sddr09_read_map(struct us_data *us) {
  601. struct scatterlist *sg;
  602. struct sddr09_card_info *info = (struct sddr09_card_info *)(us->extra);
  603. int numblocks;
  604. int i;
  605. unsigned char *ptr;
  606. unsigned short lba;
  607. unsigned char parity;
  608. unsigned char fast_parity[16] = {
  609. 0, 1, 1, 0, 1, 0, 0, 1,
  610. 1, 0, 0, 1, 0, 1, 1, 0
  611. };
  612. int result;
  613. int alloc_len;
  614. int alloc_blocks;
  616. if (!info->capacity)
  617. return -1;
  619. // read 64 (1<<6) bytes for every block 
  620. // ( 1 << ( blockshift + pageshift ) bytes)
  621. //  of capacity:
  622. // (1<<6)*capacity/(1<<(b+p)) =
  623. // ((1<<6)*capacity)>>(b+p) =
  624. // capacity>>(b+p-6)
  626. alloc_len = info->capacity >> 
  627. (info->blockshift + info->pageshift - 6);
  629. // Allocate a number of scatterlist structures according to
  630. // the number of 128k blocks in the alloc_len. Adding 128k-1
  631. // and then dividing by 128k gives the correct number of blocks.
  632. // 128k = 1<<17
  634. alloc_blocks = (alloc_len + (1<<17) - 1) >> 17;
  635. sg = kmalloc(alloc_blocks*sizeof(struct scatterlist),
  636. GFP_NOIO);
  637. if (sg == NULL)
  638. return 0;
  640. for (i=0; i<alloc_blocks; i++) {
  641. if (i<alloc_blocks-1) {
  642. sg[i].address = kmalloc( (1<<17), GFP_NOIO );
  643. sg[i].page = NULL;
  644. sg[i].length = (1<<17);
  645. } else {
  646. sg[i].address = kmalloc(alloc_len, GFP_NOIO);
  647. sg[i].page = NULL;
  648. sg[i].length = alloc_len;
  649. }
  650. alloc_len -= sg[i].length;
  651. }
  652. for (i=0; i<alloc_blocks; i++)
  653. if (sg[i].address == NULL) {
  654. for (i=0; i<alloc_blocks; i++)
  655. if (sg[i].address != NULL)
  656. kfree(sg[i].address);
  657. kfree(sg);
  658. return 0;
  659. }
  661. numblocks = info->capacity >> (info->blockshift + info->pageshift);
  663. if ( (result = sddr09_read_control(us, 0, numblocks,
  664. (unsigned char *)sg, alloc_blocks)) !=
  665. USB_STOR_TRANSPORT_GOOD) {
  666. for (i=0; i<alloc_blocks; i++)
  667. kfree(sg[i].address);
  668. kfree(sg);
  669. return -1;
  670. }
  674. if (info->lba_to_pba)
  675. kfree(info->lba_to_pba);
  676. if (info->pba_to_lba)
  677. kfree(info->pba_to_lba);
  678. info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
  679. info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
  681. if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) {
  682. if (info->lba_to_pba != NULL)
  683. kfree(info->lba_to_pba);
  684. if (info->pba_to_lba != NULL)
  685. kfree(info->pba_to_lba);
  686. info->lba_to_pba = NULL;
  687. info->pba_to_lba = NULL;
  688. for (i=0; i<alloc_blocks; i++)
  689. kfree(sg[i].address);
  690. kfree(sg);
  691. return 0;
  692. }
  694. memset(info->lba_to_pba, 0, numblocks*sizeof(int));
  695. memset(info->pba_to_lba, 0, numblocks*sizeof(int));
  697. // Each block is 64 bytes of control data, so block i is located in
  698. // scatterlist block i*64/128k = i*(2^6)*(2^-17) = i*(2^-11)
  700. for (i=0; i<numblocks; i++) {
  701. ptr = sg[i>>11].address+((i&0x7ff)<<6);
  702. if (ptr[0]!=0xFF || ptr[1]!=0xFF || ptr[2]!=0xFF ||
  703.     ptr[3]!=0xFF || ptr[4]!=0xFF || ptr[5]!=0xFF) {
  704. US_DEBUGP("PBA %04X has no logical mapping: reserved area = "
  705.   "%02X%02X%02X%02X data status %02X block status %02Xn",
  706.   i, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
  707. continue;
  708. }
  709. if ((ptr[6]>>4)!=0x01) {
  710. US_DEBUGP("PBA %04X has invalid address field %02X%02X/%02X%02Xn",
  711.   i, ptr[6], ptr[7], ptr[11], ptr[12]);
  712. continue;
  713. }
  715. /* ensure even parity */
  717. lba = short_pack(ptr[7], ptr[6]);
  718. parity = 1; // the parity of 0x1000
  719. parity ^= fast_parity[lba & 0x000F];
  720. parity ^= fast_parity[(lba>>4) & 0x000F];
  721. parity ^= fast_parity[(lba>>8) & 0x000F];
  723. if (parity) { /* bad parity bit */
  724. US_DEBUGP("Bad parity in LBA for block %04Xn", i);
  725. continue;
  726. }
  728. lba = (lba&0x07FF)>>1;
  730. /* Every 1024 physical blocks ("zone"), the LBA numbers
  731.  * go back to zero, but are within a higher
  732.  * block of LBA's. Also, there is a maximum of
  733.  * 1000 LBA's per zone. In other words, in PBA
  734.  * 1024-2047 you will find LBA 0-999 which are
  735.  * really LBA 1000-1999. Yes, this wastes 24
  736.  * physical blocks per zone. Go figure.
  737.  */
  739. lba += 1000*(i/0x400);
  741. if (lba>=numblocks) {
  742. US_DEBUGP("Bad LBA %04X for block %04Xn", lba, i);
  743. continue;
  744. }
  746. if (lba<0x10 || (lba>=0x3E0 && lba<0x3EF))
  747. US_DEBUGP("LBA %04X <-> PBA %04Xn", lba, i);
  749. info->pba_to_lba[i] = lba;
  750. info->lba_to_pba[lba] = i;
  751. }
  753. for (i=0; i<alloc_blocks; i++)
  754. kfree(sg[i].address);
  755. kfree(sg);
  756. return 0;
  757. }
  759. /*
  760. static int init_sddr09(struct us_data *us) {
  762. int result;
  763. unsigned char data[14];
  764. unsigned char command[8] = {
  765. 0xc1, 0x01, 0, 0, 0, 0, 0, 0
  766. };
  767. unsigned char command2[8] = {
  768. 0x41, 0, 0, 0, 0, 0, 0, 0
  769. };
  770. unsigned char tur[12] = {
  771. 0x03, 0x20, 0, 0, 0x0e, 0, 0, 0, 0, 0, 0, 0
  772. };
  774. // What the hey is all this for? Doesn't seem to
  775. // affect the device, so we won't do device inits.
  777. if ( (result = sddr09_send_control(us, command, data, 2)) !=
  778. USB_STOR_TRANSPORT_GOOD)
  779. return result;
  781. US_DEBUGP("SDDR09: %02X %02Xn", data[0], data[1]);
  783. command[1] = 0x08;
  785. if ( (result = sddr09_send_control(us, command, data, 2)) !=
  786. USB_STOR_TRANSPORT_GOOD)
  787. return result;
  789. US_DEBUGP("SDDR09: %02X %02Xn", data[0], data[1]);
  791. if ( (result = sddr09_send_control(us, command2, tur, 12)) !=
  792. USB_STOR_TRANSPORT_GOOD) {
  793. US_DEBUGP("SDDR09: request sense failedn");
  794. return result;
  795. }
  797. if ( (result = sddr09_raw_bulk(
  798. us, SCSI_DATA_READ, data, 14)) !=
  799. USB_STOR_TRANSPORT_GOOD) {
  800. US_DEBUGP("SDDR09: request sense bulk in failedn");
  801. return result;
  802. }
  804. US_DEBUGP("SDDR09: request sense workedn");
  806. return result;
  807. }
  808. */
  810. void sddr09_card_info_destructor(void *extra) {
  811. struct sddr09_card_info *info = (struct sddr09_card_info *)extra;
  813. if (!extra)
  814. return;
  816. if (info->lba_to_pba)
  817. kfree(info->lba_to_pba);
  818. if (info->pba_to_lba)
  819. kfree(info->pba_to_lba);
  820. }
  822. /*
  823.  * Transport for the Sandisk SDDR-09
  824.  */
  825. int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
  826. {
  827. int result;
  828. int i;
  829. char string[64];
  830. unsigned char inquiry_response[36] = {
  831. 0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00
  832. };
  833. unsigned char mode_page_01[16] = { // write-protected for now
  834. 0x03, 0x00, 0x80, 0x00,
  835. 0x01, 0x0A,
  836. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  837. };
  838. unsigned char *ptr;
  839. unsigned long capacity;
  840. unsigned int lba;
  841. unsigned int pba;
  842. unsigned int page;
  843. unsigned short pages;
  844. struct sddr09_card_info *info = (struct sddr09_card_info *)(us->extra);
  846. if (!us->extra) {
  847. us->extra = kmalloc(
  848. sizeof(struct sddr09_card_info), GFP_NOIO);
  849. if (!us->extra)
  850. return USB_STOR_TRANSPORT_ERROR;
  851. memset(us->extra, 0, sizeof(struct sddr09_card_info));
  852. us->extra_destructor = sddr09_card_info_destructor;
  853. }
  855. ptr = (unsigned char *)srb->request_buffer;
  857. /* Dummy up a response for INQUIRY since SDDR09 doesn't
  858.    respond to INQUIRY commands */
  860. if (srb->cmnd[0] == INQUIRY) {
  861. memset(inquiry_response+8, 0, 28);
  862. fill_inquiry_response(us, inquiry_response, 36);
  863. return USB_STOR_TRANSPORT_GOOD;
  864. }
  866. if (srb->cmnd[0] == READ_CAPACITY) {
  868. capacity = sddr09_get_capacity(us, &info->pagesize,
  869. &info->blocksize);
  871. if (!capacity)
  872. return USB_STOR_TRANSPORT_FAILED;
  874. info->capacity = capacity;
  875. for (info->pageshift=1; 
  876. (info->pagesize>>info->pageshift);
  877. info->pageshift++);
  878. info->pageshift--;
  879. for (info->blockshift=1; 
  880. (info->blocksize>>info->blockshift);
  881. info->blockshift++);
  882. info->blockshift--;
  883. info->blockmask = (1<<info->blockshift)-1;
  885. // Last page in the card
  887. capacity /= info->pagesize;
  888. capacity--;
  890. ptr[0] = MSB_of(capacity>>16);
  891. ptr[1] = LSB_of(capacity>>16);
  892. ptr[2] = MSB_of(capacity&0xFFFF);
  893. ptr[3] = LSB_of(capacity&0xFFFF);
  895. // The page size
  897. ptr[4] = MSB_of(info->pagesize>>16);
  898. ptr[5] = LSB_of(info->pagesize>>16);
  899. ptr[6] = MSB_of(info->pagesize&0xFFFF);
  900. ptr[7] = LSB_of(info->pagesize&0xFFFF);
  902. sddr09_read_map(us);
  904. return USB_STOR_TRANSPORT_GOOD;
  905. }
  907. if (srb->cmnd[0] == MODE_SENSE) {
  909. // Read-write error recovery page: there needs to
  910. // be a check for write-protect here
  912. if ( (srb->cmnd[2] & 0x3F) == 0x01 ) {
  914. US_DEBUGP(
  915.   "SDDR09: Dummy up request for mode page 1n");
  917. if (ptr==NULL || 
  918.   srb->request_bufflen<sizeof(mode_page_01))
  919. return USB_STOR_TRANSPORT_ERROR;
  921. memcpy(ptr, mode_page_01, sizeof(mode_page_01));
  922. return USB_STOR_TRANSPORT_GOOD;
  924. } else if ( (srb->cmnd[2] & 0x3F) == 0x3F ) {
  926. US_DEBUGP(
  927.   "SDDR09: Dummy up request for all mode pagesn");
  929. if (ptr==NULL || 
  930.   srb->request_bufflen<sizeof(mode_page_01))
  931. return USB_STOR_TRANSPORT_ERROR;
  933. memcpy(ptr, mode_page_01, sizeof(mode_page_01));
  934. return USB_STOR_TRANSPORT_GOOD;
  936. }
  938. // FIXME: sense buffer?
  940. return USB_STOR_TRANSPORT_ERROR;
  941. }
  943. if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
  945. US_DEBUGP(
  946.   "SDDR09: %s medium removal. Not that I can do"
  947.   " anything about it...n",
  948.   (srb->cmnd[4]&0x03) ? "Prevent" : "Allow");
  950. return USB_STOR_TRANSPORT_GOOD;
  952. }
  954. if (srb->cmnd[0] == READ_10) {
  956. page = short_pack(srb->cmnd[3], srb->cmnd[2]);
  957. page <<= 16;
  958. page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
  959. pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
  961. // convert page to block and page-within-block
  963. lba = page >> info->blockshift;
  964. page = page & info->blockmask;
  966. // locate physical block corresponding to logical block
  968. if (lba >=
  969. (info->capacity >> 
  970. (info->pageshift + info->blockshift) ) ) {
  972. US_DEBUGP("Error: Requested LBA %04X exceeds maximum "
  973.   "block %04lXn", lba,
  974.   (info->capacity >> (info->pageshift + info->blockshift))-1);
  976. // FIXME: sense buffer?
  978. return USB_STOR_TRANSPORT_ERROR;
  979. }
  981. pba = info->lba_to_pba[lba];
  983. // if pba is 0, either it's really 0, in which case
  984. // the pba-to-lba map for pba 0 will be the lba,
  985. // or that lba doesn't exist.
  987. if (pba==0 && info->pba_to_lba[0] != lba) {
  989. // FIXME: sense buffer?
  991. US_DEBUGP("Error: Requested LBA %04X has no physical block "
  992.   "mapping.n", lba);
  994. return USB_STOR_TRANSPORT_ERROR;
  995. }
  997. US_DEBUGP("READ_10: read block %04X (LBA %04X) page %01X"
  998. " pages %dn",
  999. pba, lba, page, pages);
  1001. return sddr09_read_data(us,
  1002. ( (pba << info->blockshift) + page) << info->pageshift,
  1003. pages, ptr, srb->use_sg);
  1004. }
  1006. // Pass TEST_UNIT_READY and REQUEST_SENSE through
  1008. if (srb->cmnd[0] != TEST_UNIT_READY &&
  1009.     srb->cmnd[0] != REQUEST_SENSE)
  1010. return USB_STOR_TRANSPORT_ERROR; // FIXME: sense buffer?
  1012. for (; srb->cmd_len<12; srb->cmd_len++)
  1013. srb->cmnd[srb->cmd_len] = 0;
  1015. srb->cmnd[1] = 0x20;
  1017. string[0] = 0;
  1018. for (i=0; i<12; i++)
  1019.   sprintf(string+strlen(string), "%02X ", srb->cmnd[i]);
  1021. US_DEBUGP("SDDR09: Send control for command %sn",
  1022. string);
  1024. if ( (result = sddr09_send_control(us,
  1025. usb_sndctrlpipe(us->pusb_dev,0),
  1026. 0,
  1027. 0x41,
  1028. 0,
  1029. 0,
  1030. srb->cmnd,
  1031. 12)) != USB_STOR_TRANSPORT_GOOD)
  1032. return result;
  1034. US_DEBUGP("SDDR09: Control for command OKn");
  1036. if (srb->request_bufflen == 0)
  1037. return USB_STOR_TRANSPORT_GOOD;
  1039. if (srb->sc_data_direction == SCSI_DATA_WRITE ||
  1040.     srb->sc_data_direction == SCSI_DATA_READ) {
  1042. US_DEBUGP("SDDR09: %s %d bytesn",
  1043. srb->sc_data_direction==SCSI_DATA_WRITE ?
  1044.   "sending" : "receiving",
  1045. srb->request_bufflen);
  1047. result = sddr09_bulk_transport(us,
  1048. srb->sc_data_direction,
  1049. srb->request_buffer, 
  1050. srb->request_bufflen, srb->use_sg);
  1052. return result;
  1054. } 
  1056. return USB_STOR_TRANSPORT_GOOD;
  1057. }