Lines Matching refs:us
149 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us);
150 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us);
152 static int init_usbat_cd(struct us_data *us);
153 static int init_usbat_flash(struct us_data *us);
214 static int usbat_get_device_type(struct us_data *us)
216 return ((struct usbat_info*)us->extra)->devicetype;
222 static int usbat_read(struct us_data *us,
227 return usb_stor_ctrl_transfer(us,
228 us->recv_ctrl_pipe,
240 static int usbat_write(struct us_data *us,
245 return usb_stor_ctrl_transfer(us,
246 us->send_ctrl_pipe,
258 static int usbat_bulk_read(struct us_data *us,
266 usb_stor_dbg(us, "len = %d\n", len);
267 return usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe, buf, len, use_sg, NULL);
273 static int usbat_bulk_write(struct us_data *us,
281 usb_stor_dbg(us, "len = %d\n", len);
282 return usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe, buf, len, use_sg, NULL);
290 static int usbat_execute_command(struct us_data *us,
294 return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
302 static int usbat_get_status(struct us_data *us, unsigned char *status)
305 rc = usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status);
307 usb_stor_dbg(us, "0x%02X\n", *status);
314 static int usbat_check_status(struct us_data *us)
316 unsigned char *reply = us->iobuf;
319 rc = usbat_get_status(us, reply);
338 static int usbat_set_shuttle_features(struct us_data *us,
346 unsigned char *command = us->iobuf;
387 return usbat_execute_command(us, command, 8);
394 static int usbat_wait_not_busy(struct us_data *us, int minutes)
398 unsigned char *status = us->iobuf;
409 result = usbat_get_status(us, status);
414 result = usbat_read(us, USBAT_ATA, 0x10, status);
421 usb_stor_dbg(us, "Waited not busy for %d steps\n", i);
435 usb_stor_dbg(us, "Waited not busy for %d minutes, timing out\n",
443 static int usbat_read_block(struct us_data *us,
449 unsigned char *command = us->iobuf;
463 result = usbat_execute_command(us, command, 8);
467 result = usbat_bulk_read(us, buf, len, use_sg);
475 static int usbat_write_block(struct us_data *us,
483 unsigned char *command = us->iobuf;
497 result = usbat_execute_command(us, command, 8);
502 result = usbat_bulk_write(us, buf, len, use_sg);
506 return usbat_wait_not_busy(us, minutes);
512 static int usbat_hp8200e_rw_block_test(struct us_data *us,
529 us->recv_bulk_pipe : us->send_bulk_pipe;
531 unsigned char *command = us->iobuf;
534 unsigned char *data = us->iobuf;
535 unsigned char *status = us->iobuf;
583 result = usbat_execute_command(us, command, cmdlen);
595 result = usbat_bulk_write(us, data, num_registers*2, 0);
601 result = usb_stor_bulk_transfer_sg(us,
632 if (usb_stor_clear_halt(us,
633 us->send_bulk_pipe) < 0)
641 result = usbat_read(us, USBAT_ATA,
653 usb_stor_dbg(us, "Redoing %s\n",
660 return usbat_wait_not_busy(us, minutes);
664 usb_stor_dbg(us, "Bummer! %s bulk data 20 times failed\n",
672 * Allows us to write specific data to any registers. The data to be written
677 static int usbat_multiple_write(struct us_data *us,
683 unsigned char *data = us->iobuf;
684 unsigned char *command = us->iobuf;
703 result = usbat_execute_command(us, command, 8);
714 result = usbat_bulk_write(us, data, num_registers*2, 0);
718 if (usbat_get_device_type(us) == USBAT_DEV_HP8200)
719 return usbat_wait_not_busy(us, 0);
726 * Allows us to read blocks from a specific data register, based upon the
736 static int usbat_read_blocks(struct us_data *us,
742 unsigned char *command = us->iobuf;
754 result = usbat_execute_command(us, command, 8);
759 result = usbat_bulk_read(us, buffer, len, use_sg);
768 * Allows us to write blocks to a specific data register, based upon the
778 static int usbat_write_blocks(struct us_data *us,
784 unsigned char *command = us->iobuf;
796 result = usbat_execute_command(us, command, 8);
801 result = usbat_bulk_write(us, buffer, len, use_sg);
811 static int usbat_read_user_io(struct us_data *us, unsigned char *data_flags)
815 result = usb_stor_ctrl_transfer(us,
816 us->recv_ctrl_pipe,
824 usb_stor_dbg(us, "UIO register reads %02X\n", *data_flags);
832 static int usbat_write_user_io(struct us_data *us,
836 return usb_stor_ctrl_transfer(us,
837 us->send_ctrl_pipe,
850 static int usbat_device_reset(struct us_data *us)
858 rc = usbat_write_user_io(us,
868 rc = usbat_write_user_io(us,
880 static int usbat_device_enable_cdt(struct us_data *us)
885 rc = usbat_write_user_io(us,
897 static int usbat_flash_check_media_present(struct us_data *us,
901 usb_stor_dbg(us, "no media detected\n");
911 static int usbat_flash_check_media_changed(struct us_data *us,
915 usb_stor_dbg(us, "media change detected\n");
925 static int usbat_flash_check_media(struct us_data *us,
929 unsigned char *uio = us->iobuf;
931 rc = usbat_read_user_io(us, uio);
936 rc = usbat_flash_check_media_present(us, uio);
945 rc = usbat_flash_check_media_changed(us, uio);
949 rc = usbat_device_reset(us);
952 rc = usbat_device_enable_cdt(us);
958 rc = usbat_read_user_io(us, uio);
976 static int usbat_identify_device(struct us_data *us,
982 if (!us || !info)
985 rc = usbat_device_reset(us);
996 rc = usbat_write(us, USBAT_ATA, USBAT_ATA_CMD, 0xA1);
1000 rc = usbat_get_status(us, &status);
1007 usb_stor_dbg(us, "Detected HP8200 CDRW\n");
1011 usb_stor_dbg(us, "Detected Flash reader/writer\n");
1021 static int usbat_set_transport(struct us_data *us,
1030 usbat_identify_device(us, info);
1037 us->transport = usbat_hp8200e_transport;
1041 us->transport = usbat_flash_transport;
1051 static int usbat_flash_get_sector_count(struct us_data *us,
1064 if (!us || !info)
1072 rc = usbat_multiple_write(us, registers, command, 3);
1074 usb_stor_dbg(us, "Gah! identify_device failed\n");
1080 if (usbat_get_status(us, &status) != USB_STOR_XFER_GOOD) {
1088 rc = usbat_read_block(us, reply, 512, 0);
1107 static int usbat_flash_read_data(struct us_data *us,
1129 result = usbat_flash_check_media(us, info);
1168 result = usbat_multiple_write(us, registers, command, 7);
1173 result = usbat_read_blocks(us, buffer, len, 0);
1177 usb_stor_dbg(us, "%d bytes\n", len);
1180 usb_stor_access_xfer_buf(buffer, len, us->srb,
1198 static int usbat_flash_write_data(struct us_data *us,
1220 result = usbat_flash_check_media(us, info);
1256 usb_stor_access_xfer_buf(buffer, len, us->srb,
1263 result = usbat_multiple_write(us, registers, command, 7);
1268 result = usbat_write_blocks(us, buffer, len, 0);
1288 static int usbat_hp8200e_handle_read10(struct us_data *us,
1300 usb_stor_dbg(us, "transfersize %d\n", srb->transfersize);
1304 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1327 usb_stor_dbg(us, "GPCMD_READ_CD: len %d\n", len);
1333 usb_stor_dbg(us, "transfersize 0, forcing %d\n",
1344 usb_stor_dbg(us, "Max read is %d bytes\n", len);
1373 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1399 static int usbat_select_and_test_registers(struct us_data *us)
1402 unsigned char *status = us->iobuf;
1406 if (usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) !=
1410 if (usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status) !=
1414 if (usbat_read(us, USBAT_ATA, USBAT_ATA_DEVICE, status) !=
1418 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1422 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1426 if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_ME, 0x55) !=
1430 if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_HI, 0xAA) !=
1434 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1438 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1449 static int init_usbat(struct us_data *us, int devicetype)
1455 unsigned char *status = us->iobuf;
1457 us->extra = kzalloc(sizeof(struct usbat_info), GFP_NOIO);
1458 if (!us->extra)
1461 info = (struct usbat_info *) (us->extra);
1464 rc = usbat_write_user_io(us,
1470 usb_stor_dbg(us, "INIT 1\n");
1474 rc = usbat_read_user_io(us, status);
1478 usb_stor_dbg(us, "INIT 2\n");
1480 rc = usbat_read_user_io(us, status);
1484 rc = usbat_read_user_io(us, status);
1488 usb_stor_dbg(us, "INIT 3\n");
1490 rc = usbat_select_and_test_registers(us);
1494 usb_stor_dbg(us, "INIT 4\n");
1496 rc = usbat_read_user_io(us, status);
1500 usb_stor_dbg(us, "INIT 5\n");
1503 rc = usbat_device_enable_cdt(us);
1507 usb_stor_dbg(us, "INIT 6\n");
1509 rc = usbat_read_user_io(us, status);
1513 usb_stor_dbg(us, "INIT 7\n");
1517 rc = usbat_read_user_io(us, status);
1521 usb_stor_dbg(us, "INIT 8\n");
1523 rc = usbat_select_and_test_registers(us);
1527 usb_stor_dbg(us, "INIT 9\n");
1530 if (usbat_set_transport(us, info, devicetype))
1533 usb_stor_dbg(us, "INIT 10\n");
1535 if (usbat_get_device_type(us) == USBAT_DEV_FLASH) {
1539 rc = usbat_set_shuttle_features(us, (USBAT_FEAT_ETEN | USBAT_FEAT_ET2 | USBAT_FEAT_ET1),
1544 usb_stor_dbg(us, "INIT 11\n");
1552 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
1555 unsigned char *status = us->iobuf;
1589 result = usbat_get_status(us, status);
1590 usb_stor_dbg(us, "Status = %02X\n", *status);
1598 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1608 usb_stor_dbg(us, "Wrote %08X bytes\n", transferred);
1616 return usbat_hp8200e_handle_read10(us, registers, data, srb);
1621 usb_stor_dbg(us, "Error: len = %08X... what do I do now?\n",
1626 result = usbat_multiple_write(us, registers, data, 7);
1641 result = usbat_write_block(us, USBAT_ATA, srb->cmnd, 12,
1653 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1660 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1670 result = usbat_read_block(us, scsi_sglist(srb), len,
1680 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
1683 struct usbat_info *info = (struct usbat_info *) (us->extra);
1685 unsigned char *ptr = us->iobuf;
1691 usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
1693 fill_inquiry_response(us, ptr, 36);
1698 rc = usbat_flash_check_media(us, info);
1702 rc = usbat_flash_get_sector_count(us, info);
1708 usb_stor_dbg(us, "READ_CAPACITY: %ld sectors, %ld bytes per sector\n",
1724 usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
1734 usb_stor_dbg(us, "READ_10: read block 0x%04lx count %ld\n",
1736 return usbat_flash_read_data(us, info, block, blocks);
1749 usb_stor_dbg(us, "READ_12: read block 0x%04lx count %ld\n",
1751 return usbat_flash_read_data(us, info, block, blocks);
1760 usb_stor_dbg(us, "WRITE_10: write block 0x%04lx count %ld\n",
1762 return usbat_flash_write_data(us, info, block, blocks);
1775 usb_stor_dbg(us, "WRITE_12: write block 0x%04lx count %ld\n",
1777 return usbat_flash_write_data(us, info, block, blocks);
1782 usb_stor_dbg(us, "TEST_UNIT_READY\n");
1784 rc = usbat_flash_check_media(us, info);
1788 return usbat_check_status(us);
1792 usb_stor_dbg(us, "REQUEST_SENSE\n");
1813 usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
1821 static int init_usbat_cd(struct us_data *us)
1823 return init_usbat(us, USBAT_DEV_HP8200);
1826 static int init_usbat_flash(struct us_data *us)
1828 return init_usbat(us, USBAT_DEV_FLASH);
1836 struct us_data *us;
1839 result = usb_stor_probe1(&us, intf, id,
1849 us->transport_name = "Shuttle USBAT";
1850 us->transport = usbat_flash_transport;
1851 us->transport_reset = usb_stor_CB_reset;
1852 us->max_lun = 0;
1854 result = usb_stor_probe2(us);