Index: uspace/drv/bus/usb/usbmast/bo_trans.c =================================================================== --- uspace/drv/bus/usb/usbmast/bo_trans.c (revision 89d3f3c712097d9131bb5031c9cb5f09c1a288ec) +++ uspace/drv/bus/usb/usbmast/bo_trans.c (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) @@ -42,4 +42,5 @@ #include "bo_trans.h" #include "cmdw.h" +#include "usbmast.h" bool usb_mast_verbose = false; @@ -54,4 +55,5 @@ /** Send command via bulk-only transport. * + * @param mfun Mass storage function * @param tag Command block wrapper tag (automatically compared * with answer) @@ -66,5 +68,5 @@ * @return Error code */ -static int usb_massstor_cmd(usb_device_t *dev, uint32_t tag, uint8_t lun, +static int usb_massstor_cmd(usbmast_fun_t *mfun, uint32_t tag, uint8_t lun, const void *cmd, size_t cmd_size, usb_direction_t ddir, void *dbuf, size_t dbuf_size, size_t *xferred_size) @@ -72,6 +74,6 @@ int rc; size_t act_size; - usb_pipe_t *bulk_in_pipe = dev->pipes[BULK_IN_EP].pipe; - usb_pipe_t *bulk_out_pipe = dev->pipes[BULK_OUT_EP].pipe; + usb_pipe_t *bulk_in_pipe = mfun->usb_dev->pipes[BULK_IN_EP].pipe; + usb_pipe_t *bulk_out_pipe = mfun->usb_dev->pipes[BULK_OUT_EP].pipe; /* Prepare CBW - command block wrapper */ @@ -165,4 +167,5 @@ /** Perform data-in command. * + * @param mfun Mass storage function * @param tag Command block wrapper tag (automatically compared with * answer) @@ -176,8 +179,8 @@ * @return Error code */ -int usb_massstor_data_in(usb_device_t *dev, uint32_t tag, uint8_t lun, +int usb_massstor_data_in(usbmast_fun_t *mfun, uint32_t tag, uint8_t lun, const void *cmd, size_t cmd_size, void *dbuf, size_t dbuf_size, size_t *proc_size) { - return usb_massstor_cmd(dev, tag, lun, cmd, cmd_size, USB_DIRECTION_IN, + return usb_massstor_cmd(mfun, tag, lun, cmd, cmd_size, USB_DIRECTION_IN, dbuf, dbuf_size, proc_size); } @@ -185,4 +188,5 @@ /** Perform data-out command. * + * @param mfun Mass storage function * @param tag Command block wrapper tag (automatically compared with * answer) @@ -196,9 +200,9 @@ * @return Error code */ -int usb_massstor_data_out(usb_device_t *dev, uint32_t tag, uint8_t lun, +int usb_massstor_data_out(usbmast_fun_t *mfun, uint32_t tag, uint8_t lun, const void *cmd, size_t cmd_size, const void *data, size_t data_size, size_t *proc_size) { - return usb_massstor_cmd(dev, tag, lun, cmd, cmd_size, USB_DIRECTION_OUT, + return usb_massstor_cmd(mfun, tag, lun, cmd, cmd_size, USB_DIRECTION_OUT, (void *) data, data_size, proc_size); } @@ -206,12 +210,12 @@ /** Perform bulk-only mass storage reset. * - * @param dev Device to be reseted. - * @return Error code. - */ -int usb_massstor_reset(usb_device_t *dev) -{ - return usb_control_request_set(&dev->ctrl_pipe, + * @param mfun Mass storage function + * @return Error code + */ +int usb_massstor_reset(usbmast_fun_t *mfun) +{ + return usb_control_request_set(&mfun->usb_dev->ctrl_pipe, USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, - 0xFF, 0, dev->interface_no, NULL, 0); + 0xFF, 0, mfun->usb_dev->interface_no, NULL, 0); } @@ -221,14 +225,16 @@ * would reappear on next transaction somehow. * - * @param dev Device to be reseted. - */ -void usb_massstor_reset_recovery(usb_device_t *dev) + * @param mfun Mass storage function + */ +void usb_massstor_reset_recovery(usbmast_fun_t *mfun) { /* We would ignore errors here because if this fails * we are doomed anyway and any following transaction would fail. */ - usb_massstor_reset(dev); - usb_pipe_clear_halt(&dev->ctrl_pipe, dev->pipes[BULK_IN_EP].pipe); - usb_pipe_clear_halt(&dev->ctrl_pipe, dev->pipes[BULK_OUT_EP].pipe); + usb_massstor_reset(mfun); + usb_pipe_clear_halt(&mfun->usb_dev->ctrl_pipe, + mfun->usb_dev->pipes[BULK_IN_EP].pipe); + usb_pipe_clear_halt(&mfun->usb_dev->ctrl_pipe, + mfun->usb_dev->pipes[BULK_OUT_EP].pipe); } @@ -241,14 +247,14 @@ * You shall rather use usb_masstor_get_lun_count. * - * @param dev Mass storage device. - * @return Error code of maximum LUN (index, not count). - */ -int usb_massstor_get_max_lun(usb_device_t *dev) + * @param mfun Mass storage function + * @return Error code of maximum LUN (index, not count) + */ +int usb_massstor_get_max_lun(usbmast_fun_t *mfun) { uint8_t max_lun; size_t data_recv_len; - int rc = usb_control_request_get(&dev->ctrl_pipe, + int rc = usb_control_request_get(&mfun->usb_dev->ctrl_pipe, USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, - 0xFE, 0, dev->interface_no, &max_lun, 1, &data_recv_len); + 0xFE, 0, mfun->usb_dev->interface_no, &max_lun, 1, &data_recv_len); if (rc != EOK) { return rc; @@ -265,10 +271,10 @@ * (typically that shall not be a problem). * - * @param dev Mass storage device. - * @return Number of LUNs. - */ -size_t usb_masstor_get_lun_count(usb_device_t *dev) -{ - int max_lun = usb_massstor_get_max_lun(dev); + * @param mfun Mass storage function + * @return Number of LUNs + */ +size_t usb_masstor_get_lun_count(usbmast_fun_t *mfun) +{ + int max_lun = usb_massstor_get_max_lun(mfun); if (max_lun < 0) { max_lun = 1; Index: uspace/drv/bus/usb/usbmast/bo_trans.h =================================================================== --- uspace/drv/bus/usb/usbmast/bo_trans.h (revision 89d3f3c712097d9131bb5031c9cb5f09c1a288ec) +++ uspace/drv/bus/usb/usbmast/bo_trans.h (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) @@ -42,16 +42,17 @@ #include #include +#include "usbmast.h" #define BULK_IN_EP 0 #define BULK_OUT_EP 1 -extern int usb_massstor_data_in(usb_device_t *, uint32_t, uint8_t, const void *, - size_t, void *, size_t, size_t *); -extern int usb_massstor_data_out(usb_device_t *, uint32_t, uint8_t, const void *, - size_t, const void *, size_t, size_t *); -extern int usb_massstor_reset(usb_device_t *); -extern void usb_massstor_reset_recovery(usb_device_t *); -extern int usb_massstor_get_max_lun(usb_device_t *); -extern size_t usb_masstor_get_lun_count(usb_device_t *); +extern int usb_massstor_data_in(usbmast_fun_t *, uint32_t, uint8_t, + const void *, size_t, void *, size_t, size_t *); +extern int usb_massstor_data_out(usbmast_fun_t *, uint32_t, uint8_t, + const void *, size_t, const void *, size_t, size_t *); +extern int usb_massstor_reset(usbmast_fun_t *); +extern void usb_massstor_reset_recovery(usbmast_fun_t *); +extern int usb_massstor_get_max_lun(usbmast_fun_t *); +extern size_t usb_masstor_get_lun_count(usbmast_fun_t *); #endif Index: uspace/drv/bus/usb/usbmast/main.c =================================================================== --- uspace/drv/bus/usb/usbmast/main.c (revision 89d3f3c712097d9131bb5031c9cb5f09c1a288ec) +++ uspace/drv/bus/usb/usbmast/main.c (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) @@ -48,4 +48,5 @@ #include "bo_trans.h" #include "scsi_ms.h" +#include "usbmast.h" #define NAME "usbmast" @@ -77,19 +78,4 @@ }; -/** Mass storage function. - * - * Serves as soft state for function/LUN. - */ -typedef struct { - /** DDF function */ - ddf_fun_t *ddf_fun; - /** Total number of blocks. */ - uint64_t nblocks; - /** Block size in bytes. */ - size_t block_size; - /** USB device function belongs to */ - usb_device_t *usb_dev; -} usbmast_fun_t; - static void usbmast_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg); @@ -114,4 +100,6 @@ goto error; } + + msfun->usb_dev = dev; fun = ddf_fun_create(dev->ddf_dev, fun_exposed, fun_name); @@ -136,5 +124,5 @@ usb_log_debug("Get LUN count...\n"); - size_t lun_count = usb_masstor_get_lun_count(dev); + size_t lun_count = usb_masstor_get_lun_count(msfun); /* XXX Handle more than one LUN properly. */ @@ -146,5 +134,5 @@ usb_log_debug("Inquire...\n"); usbmast_inquiry_data_t inquiry; - rc = usbmast_inquiry(dev, &inquiry); + rc = usbmast_inquiry(msfun, &inquiry); if (rc != EOK) { usb_log_warning("Failed to inquire device `%s': %s.\n", @@ -166,5 +154,5 @@ uint32_t nblocks, block_size; - rc = usbmast_read_capacity(dev, &nblocks, &block_size); + rc = usbmast_read_capacity(msfun, &nblocks, &block_size); if (rc != EOK) { usb_log_warning("Failed to read capacity, device `%s': %s.\n", @@ -179,5 +167,4 @@ msfun->nblocks = nblocks; msfun->block_size = block_size; - msfun->usb_dev = dev; rc = ddf_fun_bind(fun); @@ -252,6 +239,5 @@ ba = MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call)); cnt = IPC_GET_ARG3(call); - retval = usbmast_read(msfun->usb_dev, ba, cnt, - msfun->block_size, comm_buf); + retval = usbmast_read(msfun, ba, cnt, comm_buf); async_answer_0(callid, retval); break; @@ -259,6 +245,5 @@ ba = MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call)); cnt = IPC_GET_ARG3(call); - retval = usbmast_write(msfun->usb_dev, ba, cnt, - msfun->block_size, comm_buf); + retval = usbmast_write(msfun, ba, cnt, comm_buf); async_answer_0(callid, retval); break; Index: uspace/drv/bus/usb/usbmast/scsi_ms.c =================================================================== --- uspace/drv/bus/usb/usbmast/scsi_ms.c (revision 89d3f3c712097d9131bb5031c9cb5f09c1a288ec) +++ uspace/drv/bus/usb/usbmast/scsi_ms.c (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) @@ -49,4 +49,5 @@ #include "bo_trans.h" #include "scsi_ms.h" +#include "usbmast.h" /** Get string representation for SCSI peripheral device type. @@ -62,9 +63,9 @@ /** Perform SCSI Inquiry command on USB mass storage device. * - * @param dev USB device. - * @param inquiry_result Where to store parsed inquiry result. - * @return Error code. - */ -int usbmast_inquiry(usb_device_t *dev, usbmast_inquiry_data_t *inq_res) + * @param mfun Mass storage function + * @param inquiry_result Where to store parsed inquiry result + * @return Error code + */ +int usbmast_inquiry(usbmast_fun_t *mfun, usbmast_inquiry_data_t *inq_res) { scsi_std_inquiry_data_t inq_data; @@ -77,10 +78,10 @@ cdb.alloc_len = host2uint16_t_be(sizeof(inq_data)); - rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb, + rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb, sizeof(cdb), &inq_data, sizeof(inq_data), &response_len); if (rc != EOK) { usb_log_error("Inquiry failed, device %s: %s.\n", - dev->ddf_dev->name, str_error(rc)); + mfun->usb_dev->ddf_dev->name, str_error(rc)); return rc; } @@ -118,5 +119,5 @@ /** Perform SCSI Request Sense command on USB mass storage device. * - * @param dev USB device + * @param mfun Mass storage function * @param buf Destination buffer * @param size Size of @a buf @@ -124,5 +125,5 @@ * @return Error code. */ -int usbmast_request_sense(usb_device_t *dev, void *buf, size_t size) +int usbmast_request_sense(usbmast_fun_t *mfun, void *buf, size_t size) { scsi_cdb_request_sense_t cdb; @@ -134,10 +135,10 @@ cdb.alloc_len = min(size, SCSI_SENSE_DATA_MAX_SIZE); - rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb, + rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb, sizeof(cdb), buf, size, &data_len); if (rc != EOK) { usb_log_error("Request Sense failed, device %s: %s.\n", - dev->ddf_dev->name, str_error(rc)); + mfun->usb_dev->ddf_dev->name, str_error(rc)); return rc; } @@ -154,11 +155,11 @@ /** Perform SCSI Read Capacity command on USB mass storage device. * - * @param dev USB device. - * @param nblocks Output, number of blocks. - * @param block_size Output, block size in bytes. + * @param mfun Mass storage function + * @param nblocks Output, number of blocks + * @param block_size Output, block size in bytes * * @return Error code. */ -int usbmast_read_capacity(usb_device_t *dev, uint32_t *nblocks, +int usbmast_read_capacity(usbmast_fun_t *mfun, uint32_t *nblocks, uint32_t *block_size) { @@ -171,10 +172,10 @@ cdb.op_code = SCSI_CMD_READ_CAPACITY_10; - rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb, + rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb, sizeof(cdb), &data, sizeof(data), &data_len); if (rc != EOK) { usb_log_error("Read Capacity (10) failed, device %s: %s.\n", - dev->ddf_dev->name, str_error(rc)); + mfun->usb_dev->ddf_dev->name, str_error(rc)); return rc; } @@ -194,13 +195,11 @@ /** Perform SCSI Read command on USB mass storage device. * - * @param dev USB device. - * @param ba Address of first block. - * @param nblocks Number of blocks to read. - * @param bsize Block size. - * - * @return Error code. - */ -int usbmast_read(usb_device_t *dev, uint64_t ba, size_t nblocks, size_t bsize, - void *buf) + * @param mfun Mass storage function + * @param ba Address of first block + * @param nblocks Number of blocks to read + * + * @return Error code + */ +int usbmast_read(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, void *buf) { scsi_cdb_read_12_t cdb; @@ -213,5 +212,5 @@ return ELIMIT; - if ((uint64_t)nblocks * bsize > UINT32_MAX) + if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX) return ELIMIT; @@ -221,14 +220,14 @@ cdb.xfer_len = host2uint32_t_be(nblocks); - rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb, - sizeof(cdb), buf, nblocks * bsize, &data_len); + rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb, + sizeof(cdb), buf, nblocks * mfun->block_size, &data_len); if (rc != EOK) { usb_log_error("Read (12) failed, device %s: %s.\n", - dev->ddf_dev->name, str_error(rc)); - return rc; - } - - if (data_len < nblocks * bsize) { + mfun->usb_dev->ddf_dev->name, str_error(rc)); + return rc; + } + + if (data_len < nblocks * mfun->block_size) { usb_log_error("SCSI Read response too short (%zu).\n", data_len); @@ -241,13 +240,12 @@ /** Perform SCSI Write command on USB mass storage device. * - * @param dev USB device + * @param mfun Mass storage function * @param ba Address of first block * @param nblocks Number of blocks to read - * @param bsize Block size * @param data Data to write * * @return Error code */ -int usbmast_write(usb_device_t *dev, uint64_t ba, size_t nblocks, size_t bsize, +int usbmast_write(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, const void *data) { @@ -256,10 +254,8 @@ int rc; - /* XXX Need softstate to store block size. */ - if (ba > UINT32_MAX) return ELIMIT; - if ((uint64_t)nblocks * bsize > UINT32_MAX) + if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX) return ELIMIT; @@ -269,14 +265,14 @@ cdb.xfer_len = host2uint32_t_be(nblocks); - rc = usb_massstor_data_out(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb, - sizeof(cdb), data, nblocks * bsize, &sent_len); + rc = usb_massstor_data_out(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb, + sizeof(cdb), data, nblocks * mfun->block_size, &sent_len); if (rc != EOK) { usb_log_error("Write (12) failed, device %s: %s.\n", - dev->ddf_dev->name, str_error(rc)); - return rc; - } - - if (sent_len < nblocks * bsize) { + mfun->usb_dev->ddf_dev->name, str_error(rc)); + return rc; + } + + if (sent_len < nblocks * mfun->block_size) { usb_log_error("SCSI Write not all bytes transferred (%zu).\n", sent_len); Index: uspace/drv/bus/usb/usbmast/scsi_ms.h =================================================================== --- uspace/drv/bus/usb/usbmast/scsi_ms.h (revision 89d3f3c712097d9131bb5031c9cb5f09c1a288ec) +++ uspace/drv/bus/usb/usbmast/scsi_ms.h (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) @@ -59,10 +59,9 @@ } usbmast_inquiry_data_t; -extern int usbmast_inquiry(usb_device_t *, usbmast_inquiry_data_t *); -extern int usbmast_request_sense(usb_device_t *, void *, size_t); -extern int usbmast_read_capacity(usb_device_t *, uint32_t *, uint32_t *); -extern int usbmast_read(usb_device_t *, uint64_t, size_t, size_t, void *); -extern int usbmast_write(usb_device_t *, uint64_t, size_t, size_t, - const void *); +extern int usbmast_inquiry(usbmast_fun_t *, usbmast_inquiry_data_t *); +extern int usbmast_request_sense(usbmast_fun_t *, void *, size_t); +extern int usbmast_read_capacity(usbmast_fun_t *, uint32_t *, uint32_t *); +extern int usbmast_read(usbmast_fun_t *, uint64_t, size_t, void *); +extern int usbmast_write(usbmast_fun_t *, uint64_t, size_t, const void *); extern const char *usbmast_scsi_dev_type_str(unsigned); Index: uspace/drv/bus/usb/usbmast/usbmast.h =================================================================== --- uspace/drv/bus/usb/usbmast/usbmast.h (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) +++ uspace/drv/bus/usb/usbmast/usbmast.h (revision 7190bbc89aaedaf0490a4a0b475282502e125bfc) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup drvusbmast + * @{ + */ +/** @file + * USB mass storage commands. + */ + +#ifndef USBMAST_H_ +#define USBMAST_H_ + +#include +#include + +/** Mass storage function. + * + * Serves as soft state for function/LUN. + */ +typedef struct { + /** DDF function */ + ddf_fun_t *ddf_fun; + /** Total number of blocks. */ + uint64_t nblocks; + /** Block size in bytes. */ + size_t block_size; + /** USB device function belongs to */ + usb_device_t *usb_dev; +} usbmast_fun_t; + +#endif + +/** + * @} + */