Lines Matching refs:us
65 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us);
66 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us);
88 static int usbat_get_device_type(struct us_data *us)
90 return ((struct usbat_info*)us->extra)->devicetype;
96 static int usbat_read(struct us_data *us,
101 return usb_stor_ctrl_transfer(us,
102 us->recv_ctrl_pipe,
114 static int usbat_write(struct us_data *us,
119 return usb_stor_ctrl_transfer(us,
120 us->send_ctrl_pipe,
132 static int usbat_bulk_read(struct us_data *us,
141 return usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe, data, len, use_sg, NULL);
147 static int usbat_bulk_write(struct us_data *us,
156 return usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe, data, len, use_sg, NULL);
164 static int usbat_execute_command(struct us_data *us,
168 return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
176 static int usbat_get_status(struct us_data *us, unsigned char *status)
179 rc = usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status);
188 static int usbat_check_status(struct us_data *us)
190 unsigned char *reply = us->iobuf;
193 if (!us)
196 rc = usbat_get_status(us, reply);
215 static int usbat_set_shuttle_features(struct us_data *us,
223 unsigned char *command = us->iobuf;
264 return usbat_execute_command(us, command, 8);
271 static int usbat_wait_not_busy(struct us_data *us, int minutes)
275 unsigned char *status = us->iobuf;
285 result = usbat_get_status(us, status);
290 result = usbat_read(us, USBAT_ATA, 0x10, status);
319 static int usbat_read_block(struct us_data *us,
325 unsigned char *command = us->iobuf;
339 result = usbat_execute_command(us, command, 8);
343 result = usbat_bulk_read(us, content, len, use_sg);
351 static int usbat_write_block(struct us_data *us,
359 unsigned char *command = us->iobuf;
373 result = usbat_execute_command(us, command, 8);
378 result = usbat_bulk_write(us, content, len, use_sg);
382 return usbat_wait_not_busy(us, minutes);
388 static int usbat_hp8200e_rw_block_test(struct us_data *us,
405 us->recv_bulk_pipe : us->send_bulk_pipe;
407 unsigned char *command = us->iobuf;
410 unsigned char *data = us->iobuf;
411 unsigned char *status = us->iobuf;
459 result = usbat_execute_command(us, command, cmdlen);
471 result = usbat_bulk_write(us, data, num_registers*2, 0);
477 result = usb_stor_bulk_transfer_sg(us,
508 if (usb_stor_clear_halt(us,
509 us->send_bulk_pipe) < 0)
517 result = usbat_read(us, USBAT_ATA,
535 return usbat_wait_not_busy(us, minutes);
547 * Allows us to write specific data to any registers. The data to be written
552 static int usbat_multiple_write(struct us_data *us,
558 unsigned char *data = us->iobuf;
559 unsigned char *command = us->iobuf;
578 result = usbat_execute_command(us, command, 8);
589 result = usbat_bulk_write(us, data, num_registers*2, 0);
593 if (usbat_get_device_type(us) == USBAT_DEV_HP8200)
594 return usbat_wait_not_busy(us, 0);
601 * Allows us to read blocks from a specific data register, based upon the
611 static int usbat_read_blocks(struct us_data *us,
617 unsigned char *command = us->iobuf;
629 result = usbat_execute_command(us, command, 8);
634 result = usbat_bulk_read(us, buffer, len, use_sg);
643 * Allows us to write blocks to a specific data register, based upon the
653 static int usbat_write_blocks(struct us_data *us,
659 unsigned char *command = us->iobuf;
671 result = usbat_execute_command(us, command, 8);
676 result = usbat_bulk_write(us, buffer, len, use_sg);
686 static int usbat_read_user_io(struct us_data *us, unsigned char *data_flags)
690 result = usb_stor_ctrl_transfer(us,
691 us->recv_ctrl_pipe,
707 static int usbat_write_user_io(struct us_data *us,
711 return usb_stor_ctrl_transfer(us,
712 us->send_ctrl_pipe,
725 static int usbat_device_reset(struct us_data *us)
733 rc = usbat_write_user_io(us,
743 rc = usbat_write_user_io(us,
755 static int usbat_device_enable_cdt(struct us_data *us)
760 rc = usbat_write_user_io(us,
798 static int usbat_flash_check_media(struct us_data *us,
802 unsigned char *uio = us->iobuf;
804 rc = usbat_read_user_io(us, uio);
822 rc = usbat_device_reset(us);
825 rc = usbat_device_enable_cdt(us);
831 rc = usbat_read_user_io(us, uio);
849 static int usbat_identify_device(struct us_data *us,
855 if (!us || !info)
858 rc = usbat_device_reset(us);
869 rc = usbat_write(us, USBAT_ATA, USBAT_ATA_CMD, 0xA1);
873 rc = usbat_get_status(us, &status);
894 static int usbat_set_transport(struct us_data *us,
903 usbat_identify_device(us, info);
910 us->transport = usbat_hp8200e_transport;
914 us->transport = usbat_flash_transport;
924 static int usbat_flash_get_sector_count(struct us_data *us,
937 if (!us || !info)
945 rc = usbat_multiple_write(us, registers, command, 3);
953 if (usbat_get_status(us, &status) != USB_STOR_XFER_GOOD) {
961 rc = usbat_read_block(us, reply, 512, 0);
980 static int usbat_flash_read_data(struct us_data *us,
1001 result = usbat_flash_check_media(us, info);
1040 result = usbat_multiple_write(us, registers, command, 7);
1045 result = usbat_read_blocks(us, buffer, len, 0);
1052 usb_stor_access_xfer_buf(buffer, len, us->srb,
1070 static int usbat_flash_write_data(struct us_data *us,
1091 result = usbat_flash_check_media(us, info);
1127 usb_stor_access_xfer_buf(buffer, len, us->srb,
1134 result = usbat_multiple_write(us, registers, command, 7);
1139 result = usbat_write_blocks(us, buffer, len, 0);
1159 static int usbat_hp8200e_handle_read10(struct us_data *us,
1176 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1248 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1274 static int usbat_select_and_test_registers(struct us_data *us)
1277 unsigned char *status = us->iobuf;
1281 if (usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) !=
1285 if (usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status) !=
1289 if (usbat_read(us, USBAT_ATA, USBAT_ATA_DEVICE, status) !=
1293 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1297 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1301 if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_ME, 0x55) !=
1305 if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_HI, 0xAA) !=
1309 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1313 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1324 static int init_usbat(struct us_data *us, int devicetype)
1330 unsigned char *status = us->iobuf;
1332 us->extra = kzalloc(sizeof(struct usbat_info), GFP_NOIO);
1333 if (!us->extra) {
1337 info = (struct usbat_info *) (us->extra);
1340 rc = usbat_write_user_io(us,
1350 rc = usbat_read_user_io(us, status);
1356 rc = usbat_read_user_io(us, status);
1360 rc = usbat_read_user_io(us, status);
1366 rc = usbat_select_and_test_registers(us);
1372 rc = usbat_read_user_io(us, status);
1379 rc = usbat_device_enable_cdt(us);
1385 rc = usbat_read_user_io(us, status);
1393 rc = usbat_read_user_io(us, status);
1399 rc = usbat_select_and_test_registers(us);
1406 if (usbat_set_transport(us, info, devicetype))
1411 if (usbat_get_device_type(us) == USBAT_DEV_FLASH) {
1415 rc = usbat_set_shuttle_features(us, (USBAT_FEAT_ETEN | USBAT_FEAT_ET2 | USBAT_FEAT_ET1),
1428 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
1431 unsigned char *status = us->iobuf;
1465 result = usbat_get_status(us, status);
1474 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1492 return usbat_hp8200e_handle_read10(us, registers, data, srb);
1502 if ( (result = usbat_multiple_write(us,
1517 if ((result = usbat_write_block(us,
1530 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1537 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1547 result = usbat_read_block(us, srb->request_buffer, len, srb->use_sg);
1572 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
1575 struct usbat_info *info = (struct usbat_info *) (us->extra);
1577 unsigned char *ptr = us->iobuf;
1585 fill_inquiry_response(us, ptr, 36);
1590 rc = usbat_flash_check_media(us, info);
1594 rc = usbat_flash_get_sector_count(us, info);
1627 return usbat_flash_read_data(us, info, block, blocks);
1641 return usbat_flash_read_data(us, info, block, blocks);
1651 return usbat_flash_write_data(us, info, block, blocks);
1665 return usbat_flash_write_data(us, info, block, blocks);
1672 rc = usbat_flash_check_media(us, info);
1676 return usbat_check_status(us);
1709 int init_usbat_cd(struct us_data *us)
1711 return init_usbat(us, USBAT_DEV_HP8200);
1715 int init_usbat_flash(struct us_data *us)
1717 return init_usbat(us, USBAT_DEV_FLASH);
1720 int init_usbat_probe(struct us_data *us)
1722 return init_usbat(us, 0);
1730 * device type and changes the us->transport ptr to the transport function
1734 int usbat_transport(struct scsi_cmnd *srb, struct us_data *us)
1736 struct usbat_info *info = (struct usbat_info*) (us->extra);
1738 if (usbat_set_transport(us, info, 0))
1741 return us->transport(srb, us);