#include "storage_common.c"
-
+#ifdef CONFIG_USB_CSW_HACK
+static int write_error_after_csw_sent;
+static int csw_hack_sent;
+#endif
/*-------------------------------------------------------------------------*/
struct fsg_dev;
* set).
*/
int (*thread_exits)(struct fsg_common *common);
+ /*
+ * Called prior to ejection. Negative return means error,
+ * zero means to continue with ejection, positive means not to
+ * eject.
+ */
+ int (*pre_eject)(struct fsg_common *common,
+ struct fsg_lun *lun, int num);
+ /*
+ * Called after ejection. Negative return means error, zero
+ * or positive is just a success.
+ */
+ int (*post_eject)(struct fsg_common *common,
+ struct fsg_lun *lun, int num);
};
/* Data shared by all the FSG instances. */
}
typedef void (*fsg_routine_t)(struct fsg_dev *);
+static int send_status(struct fsg_common *common);
static int exception_in_progress(struct fsg_common *common)
{
loff_t file_offset, file_offset_tmp;
unsigned int amount;
ssize_t nread;
+#ifdef CONFIG_USB_MSC_PROFILING
+ ktime_t start, diff;
+#endif
/*
* Get the starting Logical Block Address and check that it's
/* Perform the read */
file_offset_tmp = file_offset;
+
+#ifdef CONFIG_USB_MSC_PROFILING
+ start = ktime_get();
+#endif
nread = vfs_read(curlun->filp,
(char __user *)bh->buf,
amount, &file_offset_tmp);
VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
(unsigned long long)file_offset, (int)nread);
+#ifdef CONFIG_USB_MSC_PROFILING
+ diff = ktime_sub(ktime_get(), start);
+ curlun->perf.rbytes += nread;
+ curlun->perf.rtime = ktime_add(curlun->perf.rtime, diff);
+#endif
if (signal_pending(current))
return -EINTR;
ssize_t nwritten;
int rc;
+#ifdef CONFIG_USB_CSW_HACK
+ int i;
+#endif
+
+#ifdef CONFIG_USB_MSC_PROFILING
+ ktime_t start, diff;
+#endif
if (curlun->ro) {
curlun->sense_data = SS_WRITE_PROTECTED;
return -EINVAL;
bh = common->next_buffhd_to_drain;
if (bh->state == BUF_STATE_EMPTY && !get_some_more)
break; /* We stopped early */
+#ifdef CONFIG_USB_CSW_HACK
+ /*
+ * If the csw packet is already submmitted to the hardware,
+ * by marking the state of buffer as full, then by checking
+ * the residue, we make sure that this csw packet is not
+ * written on to the storage media.
+ */
+ if (bh->state == BUF_STATE_FULL && common->residue) {
+#else
if (bh->state == BUF_STATE_FULL) {
+#endif
smp_rmb();
common->next_buffhd_to_drain = bh->next;
bh->state = BUF_STATE_EMPTY;
/* Perform the write */
file_offset_tmp = file_offset;
+#ifdef CONFIG_USB_MSC_PROFILING
+ start = ktime_get();
+#endif
nwritten = vfs_write(curlun->filp,
(char __user *)bh->buf,
amount, &file_offset_tmp);
VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
(unsigned long long)file_offset, (int)nwritten);
+#ifdef CONFIG_USB_MSC_PROFILING
+ diff = ktime_sub(ktime_get(), start);
+ curlun->perf.wbytes += nwritten;
+ curlun->perf.wtime =
+ ktime_add(curlun->perf.wtime, diff);
+#endif
if (signal_pending(current))
return -EINTR; /* Interrupted! */
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
+#ifdef CONFIG_USB_CSW_HACK
+ write_error_after_csw_sent = 1;
+ goto write_error;
+#endif
break;
}
+#ifdef CONFIG_USB_CSW_HACK
+write_error:
+ if ((nwritten == amount) && !csw_hack_sent) {
+ if (write_error_after_csw_sent)
+ break;
+ /*
+ * Check if any of the buffer is in the
+ * busy state, if any buffer is in busy state,
+ * means the complete data is not received
+ * yet from the host. So there is no point in
+ * csw right away without the complete data.
+ */
+ for (i = 0; i < fsg_num_buffers; i++) {
+ if (common->buffhds[i].state ==
+ BUF_STATE_BUSY)
+ break;
+ }
+ if (!amount_left_to_req && i == fsg_num_buffers) {
+ csw_hack_sent = 1;
+ send_status(common);
+ }
+ }
+#endif
+
empty_write:
/* Did the host decide to stop early? */
if (bh->outreq->actual < bh->bulk_out_intended_length) {
if (!loej)
return 0;
+ /* Simulate an unload/eject */
+ if (common->ops && common->ops->pre_eject) {
+ int r = common->ops->pre_eject(common, curlun,
+ curlun - common->luns);
+ if (unlikely(r < 0))
+ return r;
+ else if (r)
+ return 0;
+ }
+
up_read(&common->filesem);
down_write(&common->filesem);
fsg_lun_close(curlun);
up_write(&common->filesem);
down_read(&common->filesem);
- return 0;
+ return common->ops && common->ops->post_eject
+ ? min(0, common->ops->post_eject(common, curlun,
+ curlun - common->luns))
+ : 0;
}
static int do_prevent_allow(struct fsg_common *common)
return -EINVAL;
}
- if (curlun->prevent_medium_removal && !prevent)
+ if (!curlun->nofua && curlun->prevent_medium_removal && !prevent)
fsg_lun_fsync_sub(curlun);
curlun->prevent_medium_removal = prevent;
return 0;
csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
csw->Tag = common->tag;
csw->Residue = cpu_to_le32(common->residue);
+#ifdef CONFIG_USB_CSW_HACK
+ /* Since csw is being sent early, before
+ * writing on to storage media, need to set
+ * residue to zero,assuming that write will succeed.
+ */
+ if (write_error_after_csw_sent) {
+ write_error_after_csw_sent = 0;
+ csw->Residue = cpu_to_le32(common->residue);
+ } else
+ csw->Residue = 0;
+#else
+ csw->Residue = cpu_to_le32(common->residue);
+#endif
csw->Status = status;
bh->inreq->length = US_BULK_CS_WRAP_LEN;
char *tag = "MACHINE_MODEL:";
char *pname;
#if MSC_EXT_DBG
- char tbuf[1300];
+ char tbuf[1024];
if( buf == NULL ) buf = tbuf;
#endif
memset( buf , 0 , ret );
char *fw_tag = "FIRMWARE_VER:";
#if MSC_EXT_DBG
- char tbuf[1300];
+ char tbuf[1024];
if( ver == NULL )
ver = tbuf;
#endif
if (common->data_size == 0)
common->data_dir = DATA_DIR_NONE;
common->lun = cbw->Lun;
- if (common->lun < common->nluns)
+ if (common->lun >= 0 && common->lun < common->nluns)
common->curlun = &common->luns[common->lun];
else
common->curlun = NULL;
common->state = FSG_STATE_STATUS_PHASE;
spin_unlock_irq(&common->lock);
+#ifdef CONFIG_USB_CSW_HACK
+ /* Since status is already sent for write scsi command,
+ * need to skip sending status once again if it is a
+ * write scsi command.
+ */
+ if (csw_hack_sent) {
+ csw_hack_sent = 0;
+ continue;
+ }
+#endif
if (send_status(common))
continue;
static DEVICE_ATTR(ro, 0644, fsg_show_ro, fsg_store_ro);
static DEVICE_ATTR(nofua, 0644, fsg_show_nofua, fsg_store_nofua);
static DEVICE_ATTR(file, 0644, fsg_show_file, fsg_store_file);
+#ifdef CONFIG_USB_MSC_PROFILING
+static DEVICE_ATTR(perf, 0644, fsg_show_perf, fsg_store_perf);
+#endif
static struct device_attribute dev_attr_ro_cdrom =
__ATTR(ro, 0444, fsg_show_ro, NULL);
curlun->ro = lcfg->cdrom || lcfg->ro;
curlun->initially_ro = curlun->ro;
curlun->removable = lcfg->removable;
+ curlun->nofua = lcfg->nofua;
curlun->dev.release = fsg_lun_release;
curlun->dev.parent = &gadget->dev;
/* curlun->dev.driver = &fsg_driver.driver; XXX */
rc = device_create_file(&curlun->dev, &dev_attr_nofua);
if (rc)
goto error_luns;
-
+#ifdef CONFIG_USB_MSC_PROFILING
+ rc = device_create_file(&curlun->dev, &dev_attr_perf);
+ if (rc)
+ dev_err(&gadget->dev, "failed to create sysfs entry:"
+ "(dev_attr_perf) error: %d\n", rc);
+#endif
if (lcfg->filename) {
rc = fsg_lun_open(curlun, lcfg->filename);
if (rc)
/* In error recovery common->nluns may be zero. */
for (; i; --i, ++lun) {
+#ifdef CONFIG_USB_MSC_PROFILING
+ device_remove_file(&lun->dev, &dev_attr_perf);
+#endif
device_remove_file(&lun->dev, &dev_attr_nofua);
device_remove_file(&lun->dev,
lun->cdrom
unsigned int blkbits; /* Bits of logical block size of bound block device */
unsigned int blksize; /* logical block size of bound block device */
struct device dev;
+#ifdef CONFIG_USB_MSC_PROFILING
+ spinlock_t lock;
+ struct {
+
+ unsigned long rbytes;
+ unsigned long wbytes;
+ ktime_t rtime;
+ ktime_t wtime;
+ } perf;
+
+#endif
};
static inline bool fsg_lun_is_open(struct fsg_lun *curlun)
#define EP0_BUFSIZE 256
#define DELAYED_STATUS (EP0_BUFSIZE + 999) /* An impossibly large value */
+#ifdef CONFIG_USB_CSW_HACK
+#define fsg_num_buffers 4
+#else
#ifdef CONFIG_USB_GADGET_DEBUG_FILES
static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS;
#define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS
#endif /* CONFIG_USB_DEBUG */
+#endif /* CONFIG_USB_CSW_HACK */
/* check if fsg_num_buffers is within a valid range */
static inline int fsg_num_buffers_validate(void)
return sprintf(buf, "%u\n", curlun->nofua);
}
+#ifdef CONFIG_USB_MSC_PROFILING
+static ssize_t fsg_show_perf(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct fsg_lun *curlun = fsg_lun_from_dev(dev);
+ unsigned long rbytes, wbytes;
+ int64_t rtime, wtime;
+
+ spin_lock(&curlun->lock);
+ rbytes = curlun->perf.rbytes;
+ wbytes = curlun->perf.wbytes;
+ rtime = ktime_to_us(curlun->perf.rtime);
+ wtime = ktime_to_us(curlun->perf.wtime);
+ spin_unlock(&curlun->lock);
+
+ return snprintf(buf, PAGE_SIZE, "Write performance :"
+ "%lu bytes in %lld microseconds\n"
+ "Read performance :"
+ "%lu bytes in %lld microseconds\n",
+ wbytes, wtime, rbytes, rtime);
+}
+static ssize_t fsg_store_perf(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct fsg_lun *curlun = fsg_lun_from_dev(dev);
+ int value;
+
+ sscanf(buf, "%d", &value);
+ if (!value) {
+ spin_lock(&curlun->lock);
+ memset(&curlun->perf, 0, sizeof(curlun->perf));
+ spin_unlock(&curlun->lock);
+ }
+
+ return count;
+}
+#endif
static ssize_t fsg_show_file(struct device *dev, struct device_attribute *attr,
char *buf)
{
projects / firefly-linux-kernel-4.4.55.git / commitdiff