gmane.linux.scsi

Contact me

Kang Teobeng — 2013-05-20T11:15:53



Good Day,

   I have a secured business proposal for you. contact me  for more
details of my Business Proposal.

  Your earliest response to this letter will be appreciated.
Yours Sincerely,
Mrs.Kang.


--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

CHECK.

Help Desk — 2013-05-20T08:54:48


Attention,

Important message from ADMIN- Please confirm your email address by
clicking this link:

http://feedbck.jimdo.com/

Webmaster


--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 1/5] scsi: rename return code FAST_IO_FAIL to FAST_IO

Ren Mingxin — 2013-05-20T07:14:59

The return code FAST_IO_FAIL was introduced for fast failed io
recovery. To use this code for fast timed-out io recovery as well,
we'd rename it to FAST_IO.

Signed-off-by: Ren Mingxin <renmx< at >cn.fujitsu.com>
---
 drivers/scsi/scsi_error.c           |   18 +++++++++---------
 drivers/scsi/scsi_transport_fc.c    |    4 ++--
 drivers/scsi/scsi_transport_iscsi.c |    6 +++---
 include/scsi/scsi.h                 |    2 +-
 4 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index f43de1e..9e8e37a 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
< at >< at > -1067,9 +1067,9 < at >< at > static int scsi_eh_abort_cmds(struct list_head *work_q,
   "0x%p\n", current->comm,
   scmd));
 rtn = scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd);
-if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
+if (rtn == SUCCESS || rtn == FAST_IO) {
 scmd->eh_eflags &= ~SCSI_EH_CANCEL_CMD;
-if (rtn == FAST_IO_FAIL)
+if (rtn == FAST_IO)
 scsi_eh_finish_cmd(scmd, done_q);
 else
 list_move_tail(&scmd->eh_entry, &check_list);
< at >< at > -1195,9 +1195,9 < at >< at > static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
   " 0x%p\n", current->comm,
   sdev));
 rtn = scsi_try_bus_device_reset(bdr_scmd);
-if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
+if (rtn == SUCCESS || rtn == FAST_IO) {
 if (!scsi_device_online(sdev) ||
-    rtn == FAST_IO_FAIL ||
+    rtn == FAST_IO ||
     !scsi_eh_tur(bdr_scmd)) {
 list_for_each_entry_safe(scmd, next,
  work_q, eh_entry) {
< at >< at > -1248,7 +1248,7 < at >< at > static int scsi_eh_target_reset(struct Scsi_Host *shost,
   "to target %d\n",
   current->comm, id));
 rtn = scsi_try_target_reset(scmd);
-if (rtn != SUCCESS && rtn != FAST_IO_FAIL)
+if (rtn != SUCCESS && rtn != FAST_IO)
 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Target reset"
   " failed target: "
   "%d\n",
< at >< at > -1259,7 +1259,7 < at >< at > static int scsi_eh_target_reset(struct Scsi_Host *shost,
 
 if (rtn == SUCCESS)
 list_move_tail(&scmd->eh_entry, &check_list);
-else if (rtn == FAST_IO_FAIL)
+else if (rtn == FAST_IO)
 scsi_eh_finish_cmd(scmd, done_q);
 else
 /* push back on work queue for further processing */
< at >< at > -1311,10 +1311,10 < at >< at > static int scsi_eh_bus_reset(struct Scsi_Host *shost,
   " %d\n", current->comm,
   channel));
 rtn = scsi_try_bus_reset(chan_scmd);
-if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
+if (rtn == SUCCESS || rtn == FAST_IO) {
 list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
 if (channel == scmd_channel(scmd)) {
-if (rtn == FAST_IO_FAIL)
+if (rtn == FAST_IO)
 scsi_eh_finish_cmd(scmd,
    done_q);
 else
< at >< at > -1354,7 +1354,7 < at >< at > static int scsi_eh_host_reset(struct list_head *work_q,
 rtn = scsi_try_host_reset(scmd);
 if (rtn == SUCCESS) {
 list_splice_init(work_q, &check_list);
-} else if (rtn == FAST_IO_FAIL) {
+} else if (rtn == FAST_IO) {
 list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
 scsi_eh_finish_cmd(scmd, done_q);
 }
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index e106c27..7b29e00 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
< at >< at > -3301,7 +3301,7 < at >< at > fc_scsi_scan_rport(struct work_struct *work)
  * rports which would lead to offlined SCSI devices.
  *
  * Returns: 0 if the fc_rport left the state FC_PORTSTATE_BLOCKED.
- *    FAST_IO_FAIL if the fast_io_fail_tmo fired, this should be
+ *    FAST_IO if the fast_io_fail_tmo fired, this should be
  *    passed back to scsi_eh.
  */
 int fc_block_scsi_eh(struct scsi_cmnd *cmnd)
< at >< at > -3320,7 +3320,7 < at >< at > int fc_block_scsi_eh(struct scsi_cmnd *cmnd)
 spin_unlock_irqrestore(shost->host_lock, flags);
 
 if (rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT)
-return FAST_IO_FAIL;
+return FAST_IO;
 
 return 0;
 }
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 133926b..8a88f45 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
< at >< at > -1528,8 +1528,8 < at >< at > static void iscsi_scan_session(struct work_struct *work)
  *
  * If the session is down this function will wait for the recovery
  * timer to fire or for the session to be logged back in. If the
- * recovery timer fires then FAST_IO_FAIL is returned. The caller
- * should pass this error value to the scsi eh.
+ * recovery timer fires then FAST_IO is returned. The caller should
+ * pass this error value to the scsi eh.
  */
 int iscsi_block_scsi_eh(struct scsi_cmnd *cmd)
 {
< at >< at > -1541,7 +1541,7 < at >< at > int iscsi_block_scsi_eh(struct scsi_cmnd *cmd)
 spin_lock_irqsave(&session->lock, flags);
 while (session->state != ISCSI_SESSION_LOGGED_IN) {
 if (session->state == ISCSI_SESSION_FREE) {
-ret = FAST_IO_FAIL;
+ret = FAST_IO;
 break;
 }
 spin_unlock_irqrestore(&session->lock, flags);
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index 66216c1..3e12e1e 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
< at >< at > -480,7 +480,7 < at >< at > static inline int scsi_is_wlun(unsigned int lun)
 #define ADD_TO_MLQUEUE  0x2006
 #define TIMEOUT_ERROR   0x2007
 #define SCSI_RETURN_NOT_HANDLED   0x2008
-#define FAST_IO_FAIL0x2009
+#define FAST_IO         0x2009
 #define TARGET_ERROR    0x200A
 
 /*

CHECK.

Help Desk — 2013-05-19T20:28:31



Attention,

Important message from ADMIN- Please confirm your email address by
clicking this link:

http://feedbck.jimdo.com/

Webmaster

--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: SCSI testing/USB devices are amazing

Douglas Gilbert — 2013-05-19T17:39:16

Hi,
If you are working in the WRITE SAME (WS) area, you could make
this addition: T10/Robert Elliott just added a NDOB bit
('no data-out buffer') to WS(16) and WS(32) in sbc3r35d.pdf .

Using it vastly simplifies my sg_write_same code but I don't
understand why NDOB=1,UNMAP=0 is disallowed.

Doug Gilbert


--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH v2 5/5] scsi_debug: reduce duplication between prot_verify_read and prot_verify_write

Akinobu Mita — 2013-05-19T13:42:09

In order to reduce code duplication between prot_verify_read() and
prot_verify_write(), this moves common code into the new functions.

Signed-off-by: Akinobu Mita <akinobu.mita< at >gmail.com>
Cc: "James E.J. Bottomley" <JBottomley< at >parallels.com>
Cc: Douglas Gilbert <dgilbert< at >interlog.com>
Cc: "Martin K. Petersen" <martin.petersen< at >oracle.com>
Cc: linux-scsi< at >vger.kernel.org
---

* New patch from v2

 drivers/scsi/scsi_debug.c | 135 +++++++++++++++++++---------------------------
 1 file changed, 54 insertions(+), 81 deletions(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 152ead6..bd14e12 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
< at >< at > -1710,6 +1710,50 < at >< at > static int do_device_access(struct scsi_cmnd *scmd,
 return ret;
 }
 
+static u16 dif_compute_csum(const void *buf, int len)
+{
+u16 csum;
+
+switch (scsi_debug_guard) {
+case 1:
+csum = ip_compute_csum(buf, len);
+break;
+case 0:
+csum = cpu_to_be16(crc_t10dif(buf, len));
+break;
+default:
+BUG();
+}
+return csum;
+}
+
+static int dif_verify(struct sd_dif_tuple *sdt, u16 csum, sector_t sector,
+      u32 ei_lba)
+{
+if (sdt->guard_tag != csum) {
+pr_err("%s: GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
+__func__,
+(unsigned long)sector,
+be16_to_cpu(sdt->guard_tag),
+be16_to_cpu(csum));
+return 0x01;
+}
+if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
+    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
+pr_err("%s: REF check failed on sector %lu\n",
+__func__, (unsigned long)sector);
+return 0x03;
+}
+if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
+    be32_to_cpu(sdt->ref_tag) != ei_lba) {
+pr_err("%s: REF check failed on sector %lu\n",
+__func__, (unsigned long)sector);
+dif_errors++;
+return 0x03;
+}
+return 0;
+}
+
 static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
     unsigned int sectors, u32 ei_lba)
 {
< at >< at > -1726,52 +1770,21 < at >< at > static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
 
 for (i = 0 ; i < sectors ; i++) {
 u16 csum;
+int ret;
 
 if (sdt[i].app_tag == 0xffff)
 continue;
 
 sector = start_sec + i;
 
-switch (scsi_debug_guard) {
-case 1:
-csum = ip_compute_csum(fake_storep +
-       sector * scsi_debug_sector_size,
-       scsi_debug_sector_size);
-break;
-case 0:
-csum = crc_t10dif(fake_storep +
-  sector * scsi_debug_sector_size,
-  scsi_debug_sector_size);
-csum = cpu_to_be16(csum);
-break;
-default:
-BUG();
-}
+csum = dif_compute_csum(fake_storep +
+sector * scsi_debug_sector_size,
+scsi_debug_sector_size);
 
-if (sdt[i].guard_tag != csum) {
-printk(KERN_ERR "%s: GUARD check failed on sector %lu" \
-       " rcvd 0x%04x, data 0x%04x\n", __func__,
-       (unsigned long)sector,
-       be16_to_cpu(sdt[i].guard_tag),
-       be16_to_cpu(csum));
+ret = dif_verify(&sdt[i], csum, sector, ei_lba);
+if (ret) {
 dif_errors++;
-return 0x01;
-}
-
-if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
-    be32_to_cpu(sdt[i].ref_tag) != (sector & 0xffffffff)) {
-printk(KERN_ERR "%s: REF check failed on sector %lu\n",
-       __func__, (unsigned long)sector);
-dif_errors++;
-return 0x03;
-}
-
-if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
-    be32_to_cpu(sdt[i].ref_tag) != ei_lba) {
-printk(KERN_ERR "%s: REF check failed on sector %lu\n",
-       __func__, (unsigned long)sector);
-dif_errors++;
-return 0x03;
+return ret;
 }
 
 ei_lba++;
< at >< at > -1911,50 +1924,10 < at >< at > static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
 
 sdt = paddr + ppage_offset;
 
-switch (scsi_debug_guard) {
-case 1:
-csum = ip_compute_csum(daddr,
-       scsi_debug_sector_size);
-break;
-case 0:
-csum = cpu_to_be16(crc_t10dif(daddr,
-      scsi_debug_sector_size));
-break;
-default:
-BUG();
-ret = 0;
-goto out;
-}
-
-if (sdt->guard_tag != csum) {
-printk(KERN_ERR
-       "%s: GUARD check failed on sector %lu " \
-       "rcvd 0x%04x, calculated 0x%04x\n",
-       __func__, (unsigned long)sector,
-       be16_to_cpu(sdt->guard_tag),
-       be16_to_cpu(csum));
-ret = 0x01;
-dump_sector(daddr, scsi_debug_sector_size);
-goto out;
-}
-
-if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
-    be32_to_cpu(sdt->ref_tag)
-    != (start_sec & 0xffffffff)) {
-printk(KERN_ERR
-       "%s: REF check failed on sector %lu\n",
-       __func__, (unsigned long)sector);
-ret = 0x03;
-dump_sector(daddr, scsi_debug_sector_size);
-goto out;
-}
+csum = dif_compute_csum(daddr, scsi_debug_sector_size);
 
-if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
-    be32_to_cpu(sdt->ref_tag) != ei_lba) {
-printk(KERN_ERR
-       "%s: REF check failed on sector %lu\n",
-       __func__, (unsigned long)sector);
-ret = 0x03;
+ret = dif_verify(sdt, csum, start_sec, ei_lba);
+if (ret) {
 dump_sector(daddr, scsi_debug_sector_size);
 goto out;
 }

[PATCH v2 4/5] scsi_debug: simplify offset calculation for dif_storep

Akinobu Mita — 2013-05-19T13:42:08

dif_storep is declared as pointer to unsigned char type.  But it is
actually used to store vmalloced array of struct sd_dif_tuple.

This changes the type of dif_storep to the pointer to struct sd_dif_tuple.
It simplifies offset calculation for dif_storep and enables to remove
hardcoded size of struct sd_dif_tuple.

Signed-off-by: Akinobu Mita <akinobu.mita< at >gmail.com>
Cc: "James E.J. Bottomley" <JBottomley< at >parallels.com>
Cc: Douglas Gilbert <dgilbert< at >interlog.com>
Cc: "Martin K. Petersen" <martin.petersen< at >oracle.com>
Cc: linux-scsi< at >vger.kernel.org
Acked-by: Douglas Gilbert <dgilbert< at >interlog.com>
---

* No changes from v1

 drivers/scsi/scsi_debug.c | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 631e9ab..152ead6 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
< at >< at > -258,7 +258,7 < at >< at > struct sdebug_queued_cmd {
 static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
 
 static unsigned char * fake_storep;/* ramdisk storage */
-static unsigned char *dif_storep;/* protection info */
+static struct sd_dif_tuple *dif_storep;/* protection info */
 static void *map_storep;/* provisioning map */
 
 static unsigned long map_size;
< at >< at > -277,11 +277,6 < at >< at > static char sdebug_proc_name[] = "scsi_debug";
 
 static struct bus_type pseudo_lld_bus;
 
-static inline sector_t dif_offset(sector_t sector)
-{
-return sector << 3;
-}
-
 static struct device_driver sdebug_driverfs_driver = {
 .name = sdebug_proc_name,
 .bus= &pseudo_lld_bus,
< at >< at > -1727,7 +1722,7 < at >< at > static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
 
 start_sec = do_div(tmp_sec, sdebug_store_sectors);
 
-sdt = (struct sd_dif_tuple *)(dif_storep + dif_offset(start_sec));
+sdt = dif_storep + start_sec;
 
 for (i = 0 ; i < sectors ; i++) {
 u16 csum;
< at >< at > -1782,16 +1777,17 < at >< at > static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
 ei_lba++;
 }
 
-resid = sectors * 8; /* Bytes of protection data to copy into sgl */
+/* Bytes of protection data to copy into sgl */
+resid = sectors * sizeof(*dif_storep);
 sector = start_sec;
 
 scsi_for_each_prot_sg(SCpnt, psgl, scsi_prot_sg_count(SCpnt), i) {
 int len = min(psgl->length, resid);
 
 paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
-memcpy(paddr, dif_storep + dif_offset(sector), len);
+memcpy(paddr, dif_storep + sector, len);
 
-sector += len >> 3;
+sector += len / sizeof(*dif_storep);
 if (sector >= sdebug_store_sectors) {
 /* Force wrap */
 tmp_sec = sector;
< at >< at > -1968,7 +1964,7 < at >< at > static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
  * correctness we need to verify each sector
  * before writing it to "stable" storage
  */
-memcpy(dif_storep + dif_offset(sector), sdt, 8);
+memcpy(dif_storep + sector, sdt, sizeof(*sdt));
 
 sector++;

[PATCH v2 3/5] scsi_debug: fix NULL pointer dereference with parameters dif=0 dix=1

Akinobu Mita — 2013-05-19T13:42:07

The protection info dif_storep is allocated only when parameter dif is
not zero.  But it will be accessed when reading or writing to the storage
installed with parameter dix is not zero.

So kernel crashes if scsi_debug module is loaded with parameters dix=1 and
dif=0.

This fixes it by making dif_storep available if parameter dix is not zero
instead of checking if parameter dif is not zero.

Signed-off-by: Akinobu Mita <akinobu.mita< at >gmail.com>
Cc: "James E.J. Bottomley" <JBottomley< at >parallels.com>
Cc: Douglas Gilbert <dgilbert< at >interlog.com>
Cc: "Martin K. Petersen" <martin.petersen< at >oracle.com>
Cc: linux-scsi< at >vger.kernel.org
Acked-by: Douglas Gilbert <dgilbert< at >interlog.com>
Acked-by: "Martin K. Petersen" <martin.petersen< at >oracle.com>
---

* No changes from v1

 drivers/scsi/scsi_debug.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 0a428b6..631e9ab 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
< at >< at > -3373,7 +3373,7 < at >< at > static int __init scsi_debug_init(void)
 if (scsi_debug_num_parts > 0)
 sdebug_build_parts(fake_storep, sz);
 
-if (scsi_debug_dif) {
+if (scsi_debug_dix) {
 int dif_size;
 
 dif_size = sdebug_store_sectors * sizeof(struct sd_dif_tuple);

[PATCH v2 2/5] scsi_debug: fix incorrectly nested kmap_atomic()

Akinobu Mita — 2013-05-19T13:42:06

In the function prot_verify_write(), kmap_atomic()/kunmap_atomic() for
data page and kmap_atomic()/kunmap_atomic() for protection information
page are not nested each other.

It worked perfectly before commit 3e4d3af501cccdc8a8cca41bdbe57d54ad7e7e73
("mm: stack based kmap_atomic()").  Because the kmap_atomic slot KM_IRQ0
was used for data page and the slot KM_IRQ1 was used for protection page.

But KM_types are gone and kmap_atomic() is using stack based implementation.
So two different kmap_atomic() usages must be strictly nested now.

This change ensures kmap_atomic() usage is strictly nested.

Signed-off-by: Akinobu Mita <akinobu.mita< at >gmail.com>
Cc: "James E.J. Bottomley" <JBottomley< at >parallels.com>
Cc: Douglas Gilbert <dgilbert< at >interlog.com>
Cc: "Martin K. Petersen" <martin.petersen< at >oracle.com>
Cc: linux-scsi< at >vger.kernel.org
Acked-by: Douglas Gilbert <dgilbert< at >interlog.com>
---

* New patch from v2
- Splitted from the patch "fix data integrity support on highmem machine" in v1

 drivers/scsi/scsi_debug.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index caf6a94..0a428b6 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
< at >< at > -1891,12 +1891,12 < at >< at > static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
 BUG_ON(scsi_sg_count(SCpnt) == 0);
 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
 
-paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
 ppage_offset = 0;
 
 /* For each data page */
 scsi_for_each_sg(SCpnt, dsgl, scsi_sg_count(SCpnt), i) {
 daddr = kmap_atomic(sg_page(dsgl)) + dsgl->offset;
+paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
 
 /* For each sector-sized chunk in data page */
 for (j = 0 ; j < dsgl->length ; j += scsi_debug_sector_size) {
< at >< at > -1981,19 +1981,18 < at >< at > static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
 ppage_offset += sizeof(struct sd_dif_tuple);
 }
 
+kunmap_atomic(paddr);
 kunmap_atomic(daddr - dsgl->length);
 }
 
-kunmap_atomic(paddr);
-
 dix_writes++;
 
 return 0;
 
 out:
 dif_errors++;
-kunmap_atomic(daddr);
 kunmap_atomic(paddr);
+kunmap_atomic(daddr);
 return ret;
 }

[PATCH v2 1/5] scsi_debug: fix invalid address passed to kunmap_atomic()

Akinobu Mita — 2013-05-19T13:42:05

In the function prot_verify_write(), the kmap address 'daddr' is
incremented in the loop for each data page.  Finally 'daddr' reaches
the next page boundary in the end of the loop, and the invalid address
is passed to kunmap_atomic().

Fix it by passing original value to kunmap_atomic().

Signed-off-by: Akinobu Mita <akinobu.mita< at >gmail.com>
Cc: "James E.J. Bottomley" <JBottomley< at >parallels.com>
Cc: Douglas Gilbert <dgilbert< at >interlog.com>
Cc: "Martin K. Petersen" <martin.petersen< at >oracle.com>
Cc: linux-scsi< at >vger.kernel.org
Acked-by: Douglas Gilbert <dgilbert< at >interlog.com>
---

* New patch from v2
- Splitted from the patch "fix data integrity support on highmem machine" in v1

 drivers/scsi/scsi_debug.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 0a537a0..caf6a94 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
< at >< at > -1981,7 +1981,7 < at >< at > static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
 ppage_offset += sizeof(struct sd_dif_tuple);
 }
 
-kunmap_atomic(daddr);
+kunmap_atomic(daddr - dsgl->length);
 }
 
 kunmap_atomic(paddr);

[PATCH v2 0/5] scsi_debug: bug fixes and cleanups for data integrity support

Akinobu Mita — 2013-05-19T13:42:04

This patch set includes bug fixes which I hit when I was tried testing
the data integrity support in scsi_debug on x86_32.

And it also includes cleanups which helps increasing readability and
further bug fixing in data integrity support.

* Changes from v1
- Split the patch "fix data integrity support on highmem machine" into
  two separate patches.
- Add new cleanup patch "reduce duplication between prot_verify_read and
  prot_verify_write".

Cc: "James E.J. Bottomley" <JBottomley< at >parallels.com>
Cc: Douglas Gilbert <dgilbert< at >interlog.com>
Cc: "Martin K. Petersen" <martin.petersen< at >oracle.com>
Cc: linux-scsi< at >vger.kernel.org

Akinobu Mita (5):
  scsi_debug: fix invalid address passed to kunmap_atomic()
  scsi_debug: fix incorrectly nested kmap_atomic()
  scsi_debug: fix NULL pointer dereference with parameters dif=0 dix=1
  scsi_debug: simplify offset calculation for dif_storep
  scsi_debug: reduce duplication between prot_verify_read and
    prot_verify_write

 drivers/scsi/scsi_debug.c | 164 +++++++++++++++++++---------------------------
 1 file changed, 66 insertions(+), 98 deletions(-)

[PATCH 8/8] scsi: ufs: Fix the response UPIU length setting

Santosh Y — 2013-05-19T08:21:43

From: Sujit Reddy Thumma <sthumma< at >codeaurora.org>

The response UPIU length should be in DWORD and not in bytes.

Signed-off-by: Maya Erez <merez< at >codeaurora.org>
Signed-off-by: Sujit Reddy Thumma <sthumma< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 18dead4..e9dba33 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -1159,7 +1159,7 < at >< at > static void ufshcd_host_memory_configure(struct ufs_hba *hba)
 utrdlp[i].prd_table_offset =
 cpu_to_le16((prdt_offset >> 2));
 utrdlp[i].response_upiu_length =
-cpu_to_le16(ALIGNED_UPIU_SIZE);
+cpu_to_le16(ALIGNED_UPIU_SIZE >> 2);
 
 hba->lrb[i].utr_descriptor_ptr = (utrdlp + i);
 hba->lrb[i].ucd_req_ptr =

[PATCH 7/8] scsi: ufs: Set fDeviceInit flag to initiate device initialization

Santosh Y — 2013-05-19T08:21:42

From: Dolev Raviv <draviv< at >codeaurora.org>

Allow UFS device to complete its initialization and accept
SCSI commands by setting fDeviceInit flag. The device may take
time for this operation and hence the host should poll until
fDeviceInit flag is toggled to zero. This step is mandated by
UFS device specification for device initialization completion.

Signed-off-by: Dolev Raviv <draviv< at >codeaurora.org>
Signed-off-by: Sujit Reddy Thumma <sthumma< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index 086ff03..742363d 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
< at >< at > -107,8 +107,13 < at >< at > enum {
 UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST = 0x81,
 };
 
+/* Flag idn for Query Requests*/
+enum flag_idn {
+QUERY_FLAG_IDN_FDEVICEINIT = 0x01,
+};
+
 /* UTP QUERY Transaction Specific Fields OpCode */
-enum {
+enum query_opcode {
 UPIU_QUERY_OPCODE_NOP= 0x0,
 UPIU_QUERY_OPCODE_READ_DESC= 0x1,
 UPIU_QUERY_OPCODE_WRITE_DESC= 0x2,
< at >< at > -208,6 +213,9 < at >< at > struct utp_upiu_query {
 u32 reserved[2];
 };
 
+/* Expose the flag value from utp_upiu_query.value */
+#define MASK_QUERY_UPIU_FLAG_LOC 0xFF
+
 /**
  * struct utp_upiu_req - general upiu request structure
  * < at >header:UPIU header structure DW-0 to DW-2
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index daed7387..18dead4 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -50,6 +50,15 < at >< at >
 /* Reserved tag for internal commands */
 #define INTERNAL_CMD_TAG   0
 
+/* Query request standart retries */
+#define QUERY_REQ_RETRIES 10
+/* Query request standart timeout  in seconds */
+#define QUERY_REQ_TIMEOUT 5
+/* Send Query Requst with default parameters */
+#define send_query_request(ARG1, ARG2, ARG3, ARG4)\
+ufshcd_query_request(ARG1, ARG2, ARG3, ARG4,\
+QUERY_REQ_TIMEOUT, QUERY_REQ_RETRIES)
+
 enum {
 UFSHCD_MAX_CHANNEL= 0,
 UFSHCD_MAX_ID= 1,
< at >< at > -862,6 +871,164 < at >< at > out:
 }
 
 /**
+ *  ufshcd_query_request() - Entry point for issuing query request to a
+ *  ufs device.
+ *  < at >hba: ufs driver context
+ *  < at >query: params for query request
+ *  < at >descriptor: buffer for sending/receiving descriptor
+ *  < at >response: pointer to a buffer that will contain the response code and
+ *           response upiu
+ *  < at >timeout: time limit for the command in seconds
+ *  < at >retries: number of times to try executing the command
+ *
+ *  The query request is submitted to the same request queue as the rest of
+ *  the scsi commands passed to the UFS controller. In order to use this
+ *  queue, we need to receive a tag, same as all other commands. The tags
+ *  are issued from the block layer. To simulate a request from the block
+ *  layer, we use the same interface as the SCSI layer does when it issues
+ *  commands not generated by users. To distinguish a query request from
+ *  the SCSI commands, we use a vendor specific unused SCSI command
+ *  op-code. This op-code is not part of the SCSI command subset used in
+ *  UFS. In such way it is easy to check the command in the driver and
+ *  handle it appropriately.
+ *
+ *  All necessary fields for issuing a query and receiving its response are
+ *  stored in the UFS hba struct. We can use this method since we know
+ *  there is only one active query request at all times.
+ *
+ *  The request that will pass to the device is stored in "query" argument
+ *  passed to this function, while the "response" argument (which is output
+ *  field) will hold the query response from the device along with the
+ *  response code.
+ */
+int ufshcd_query_request(struct ufs_hba *hba,
+struct ufs_query_req *query,
+u8 *descriptor,
+struct ufs_query_res *response,
+int timeout,
+int retries)
+{
+struct scsi_device *sdev;
+u8 cmd[UFS_QUERY_CMD_SIZE] = {0};
+int result;
+bool sdev_lookup = true;
+
+BUG_ON(!hba);
+if (!query || !response) {
+dev_err(hba->dev,
+"%s: NULL pointer hba = %p, query = %p response = %p\n",
+__func__, hba, query, response);
+return -EINVAL;
+}
+
+/*
+ * A SCSI command structure is composed from opcode at the
+ * begining and 0 at the end.
+ */
+cmd[0] = UFS_QUERY_RESERVED_SCSI_CMD;
+
+/* extracting the SCSI Device */
+sdev = scsi_device_lookup(hba->host, 0, 0, 0);
+if (!sdev) {
+/**
+ * There are some Query Requests that are sent during device
+ * initialization, this happens before the scsi device was
+ * initialized. If there is no scsi device, we generate a
+ * temporary device to allow the Query Request flow.
+ */
+sdev_lookup = false;
+sdev = scsi_get_host_dev(hba->host);
+}
+
+if (!sdev) {
+dev_err(hba->dev, "%s: Could not fetch scsi device\n",
+__func__);
+return -ENODEV;
+}
+
+mutex_lock(&hba->query.lock_ufs_query);
+hba->query.request = query;
+hba->query.descriptor = descriptor;
+hba->query.response = response;
+
+/* wait until request is completed */
+result = scsi_execute(sdev, cmd, DMA_NONE, NULL, 0, NULL,
+timeout, retries, 0, NULL);
+if (result) {
+dev_err(hba->dev,
+"%s: Query with opcode 0x%x, failed with result %d\n",
+__func__, query->upiu_req.opcode, result);
+result = -EIO;
+}
+
+hba->query.request = NULL;
+hba->query.descriptor = NULL;
+hba->query.response = NULL;
+mutex_unlock(&hba->query.lock_ufs_query);
+
+/* Releasing scsi device resource */
+if (sdev_lookup)
+scsi_device_put(sdev);
+else
+scsi_free_host_dev(sdev);
+
+return result;
+}
+
+/**
+ * ufshcd_query_flag() - Helper function for composing flag query requests
+ * hba: per-adapter instance
+ * query_opcode: flag query to perform
+ * idn: flag idn to access
+ * flag_res: the flag value after the query request completes
+ *
+ * Returns 0 for success, non-zero in case of failure
+ */
+int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
+enum flag_idn idn, bool *flag_res)
+{
+struct ufs_query_req query = {0};
+struct ufs_query_res response = {0};
+int err;
+
+switch (opcode) {
+case UPIU_QUERY_OPCODE_SET_FLAG:
+case UPIU_QUERY_OPCODE_CLEAR_FLAG:
+case UPIU_QUERY_OPCODE_TOGGLE_FLAG:
+query.query_func = UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST;
+break;
+case UPIU_QUERY_OPCODE_READ_FLAG:
+query.query_func = UPIU_QUERY_FUNC_STANDARD_READ_REQUEST;
+break;
+default:
+dev_err(hba->dev,
+"%s: Expected query flag opcode but got = %d\n",
+__func__, opcode);
+err = -EINVAL;
+goto out;
+}
+query.upiu_req.opcode = opcode;
+query.upiu_req.idn = idn;
+
+/* Send query request */
+err = send_query_request(hba, &query, NULL, &response);
+
+if (err) {
+dev_err(hba->dev,
+"%s: Sending flag query for idn %d failed, err = %d\n",
+__func__, idn, err);
+goto out;
+}
+
+if (flag_res)
+*flag_res = (response.upiu_res.value &
+MASK_QUERY_UPIU_FLAG_LOC) & 0x1;
+
+out:
+return err;
+}
+
+/**
  * ufshcd_memory_alloc - allocate memory for host memory space data structures
  * < at >hba: per adapter instance
  *
< at >< at > -1128,6 +1295,44 < at >< at > out:
 }
 
 /**
+ * ufshcd_validate_device_init() - checks device readines
+ * hba: per-adapter instance
+ *
+ * Set fDeviceInit flag, than, query the flag untill the device clears the
+ * flag.
+ */
+static int ufshcd_validate_device_init(struct ufs_hba *hba)
+{
+int i, err;
+bool flag_res = 0;
+
+err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
+QUERY_FLAG_IDN_FDEVICEINIT, &flag_res);
+if (err) {
+dev_err(hba->dev,
+"%s setting fDeviceInit flag failed with error %d\n",
+__func__, err);
+goto out;
+}
+
+for (i = 0; i < QUERY_REQ_RETRIES && !err && flag_res; i++) {
+err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,
+QUERY_FLAG_IDN_FDEVICEINIT, &flag_res);
+}
+if (err)
+dev_err(hba->dev,
+"%s reading fDeviceInit flag failed with error %d\n",
+__func__, err);
+else if (flag_res)
+dev_err(hba->dev,
+"%s fDeviceInit was not cleared by the device\n",
+__func__);
+
+out:
+return err;
+}
+
+/**
  * ufshcd_make_hba_operational - Make UFS controller operational
  * < at >hba: per adapter instance
  *
< at >< at > -1950,6 +2155,10 < at >< at > static void ufshcd_async_scan(void *data, async_cookie_t cookie)
 if (ret)
 goto out;
 
+ret = ufshcd_validate_device_init(hba);
+if (ret)
+goto out;
+
 scsi_scan_host(hba->host);
 out:
 return;

[PATCH 6/8] scsi: ufs: Add support for sending NOP OUT UPIU

Santosh Y — 2013-05-19T08:21:41

From: Dolev Raviv <draviv< at >codeaurora.org>

As part of device initialization sequence, sending NOP OUT UPIU and
waiting for NOP IN UPIU response is mandatory. This confirms that the
device UFS Transport (UTP) layer is functional and the host can configure
the device with further commands. Add support for sending NOP OUT UPIU to
check the device connection path and test whether the UTP layer on the
device side is functional during initialization.

Signed-off-by: Sujit Reddy Thumma <sthumma< at >codeaurora.org>
Tested-by: Dolev Raviv <draviv< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 0c570c0..daed7387 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -43,6 +43,13 < at >< at >
 /* UIC command timeout, unit: ms */
 #define UIC_CMD_TIMEOUT500
 
+/* NOP OUT retries waiting for NOP IN response */
+#define NOP_OUT_RETRIES    10
+/* Timeout after 30 msecs if NOP OUT hangs without response */
+#define NOP_OUT_TIMEOUT    30 /* msecs */
+/* Reserved tag for internal commands */
+#define INTERNAL_CMD_TAG   0
+
 enum {
 UFSHCD_MAX_CHANNEL= 0,
 UFSHCD_MAX_ID= 1,
< at >< at > -71,6 +78,39 < at >< at > enum {
 INT_AGGR_CONFIG,
 };
 
+/*
+ * ufshcd_wait_for_register - wait for register value to change
+ * < at >hba - per-adapter interface
+ * < at >reg - mmio register offset
+ * < at >mask - mask to apply to read register value
+ * < at >val - wait condition
+ * < at >interval_us - polling interval in microsecs
+ * < at >timeout_ms - timeout in millisecs
+ *
+ * Returns final register value after iteration
+ */
+static u32 ufshcd_wait_for_register(struct ufs_hba *hba, u32 reg, u32 mask,
+u32 val, unsigned long interval_us, unsigned long timeout_ms)
+{
+u32 tmp;
+ktime_t start;
+unsigned long diff;
+
+tmp = ufshcd_readl(hba, reg);
+
+start = ktime_get();
+while ((tmp & mask) == val) {
+/* wakeup within 50us of expiry */
+usleep_range(interval_us, interval_us + 50);
+tmp = ufshcd_readl(hba, reg);
+diff = ktime_to_ms(ktime_sub(ktime_get(), start));
+if (diff > timeout_ms)
+break;
+}
+
+return tmp;
+}
+
 /**
  * ufshcd_get_intr_mask - Get the interrupt bit mask
  * < at >hba - Pointer to adapter instance
< at >< at > -612,7 +652,7 < at >< at > static void ufshcd_prepare_req_desc(struct ufshcd_lrb *lrbp, u32 *upiu_flags)
 {
 struct utp_transfer_req_desc *req_desc = lrbp->utr_descriptor_ptr;
 enum dma_data_direction cmd_dir =
-lrbp->cmd->sc_data_direction;
+lrbp->cmd ? lrbp->cmd->sc_data_direction : DMA_NONE;
 u32 data_direction;
 u32 dword_0;
 
< at >< at > -629,6 +669,8 < at >< at > static void ufshcd_prepare_req_desc(struct ufshcd_lrb *lrbp, u32 *upiu_flags)
 
 dword_0 = data_direction | (lrbp->command_type
 << UPIU_COMMAND_TYPE_OFFSET);
+if (lrbp->intr_cmd)
+dword_0 |= UTP_REQ_DESC_INT_CMD;
 
 /* Transfer request descriptor header fields */
 req_desc->header.dword_0 = cpu_to_le32(dword_0);
< at >< at > -717,6 +759,18 < at >< at > static void ufshcd_prepare_utp_query_req_upiu(struct ufs_hba *hba,
 
 }
 
+static inline void ufshcd_prepare_utp_nop_upiu(struct ufshcd_lrb *lrbp)
+{
+struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
+
+memset(ucd_req_ptr, 0, sizeof(struct utp_upiu_req));
+
+/* command descriptor fields */
+ucd_req_ptr->header.dword_0 =
+UPIU_HEADER_DWORD(
+UPIU_TRANSACTION_NOP_OUT, 0, 0, lrbp->task_tag);
+}
+
 /**
  * ufshcd_compose_upiu - form UFS Protocol Information Unit(UPIU)
  * < at >hba - UFS hba
< at >< at > -731,11 +785,13 < at >< at > static int ufshcd_compose_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
 case UTP_CMD_TYPE_SCSI:
 case UTP_CMD_TYPE_DEV_MANAGE:
 ufshcd_prepare_req_desc(lrbp, &upiu_flags);
-if (lrbp->command_type == UTP_CMD_TYPE_SCSI)
+if (lrbp->cmd && lrbp->command_type == UTP_CMD_TYPE_SCSI)
 ufshcd_prepare_utp_scsi_cmd_upiu(lrbp, upiu_flags);
-else
+else if (lrbp->cmd && ufshcd_is_query_req(lrbp))
 ufshcd_prepare_utp_query_req_upiu(hba, lrbp,
 upiu_flags);
+else if (!lrbp->cmd)
+ufshcd_prepare_utp_nop_upiu(lrbp);
 break;
 case UTP_CMD_TYPE_UFS:
 /* For UFS native command implementation */
< at >< at > -784,6 +840,7 < at >< at > static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 lrbp->sense_buffer = cmd->sense_buffer;
 lrbp->task_tag = tag;
 lrbp->lun = cmd->device->lun;
+lrbp->intr_cmd = false;
 
 if (ufshcd_is_query_req(lrbp))
 lrbp->command_type = UTP_CMD_TYPE_DEV_MANAGE;
< at >< at > -972,6 +1029,104 < at >< at > static int ufshcd_dme_link_startup(struct ufs_hba *hba)
 return ret;
 }
 
+static int
+ufshcd_compose_nop_out_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+lrbp->cmd = NULL;
+lrbp->sense_bufflen = 0;
+lrbp->sense_buffer = NULL;
+lrbp->task_tag = INTERNAL_CMD_TAG;
+lrbp->lun = 0; /* NOP OUT is not specific to any LUN */
+lrbp->command_type = UTP_CMD_TYPE_DEV_MANAGE;
+lrbp->intr_cmd = true; /* No interrupt aggregation */
+
+return ufshcd_compose_upiu(hba, lrbp);
+}
+
+static int ufshcd_wait_for_nop_cmd(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+int err = 0;
+unsigned long timeout;
+unsigned long flags;
+
+timeout = wait_for_completion_timeout(
+lrbp->completion, msecs_to_jiffies(NOP_OUT_TIMEOUT));
+
+spin_lock_irqsave(hba->host->host_lock, flags);
+lrbp->completion = NULL;
+if (timeout)
+err = ufshcd_get_tr_ocs(lrbp);
+else
+err = -ETIMEDOUT;
+spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+return err;
+}
+
+/**
+ * ufshcd_validate_dev_connection() - Check device connection status
+ * < at >hba: per-adapter instance
+ *
+ * Send NOP OUT UPIU and wait for NOP IN response to check whether the
+ * device Transport Protocol (UTP) layer is ready after a reset.
+ * If the UTP layer at the device side is not initialized, it may
+ * not respond with NOP IN UPIU within timeout of %NOP_OUT_TIMEOUT
+ * and we retry sending NOP OUT for %NOP_OUT_RETRIES iterations.
+ */
+static int ufshcd_validate_dev_connection(struct ufs_hba *hba)
+{
+int err;
+struct ufshcd_lrb *lrbp;
+unsigned long flags;
+struct completion wait;
+int retries = NOP_OUT_RETRIES;
+
+retry:
+init_completion(&wait);
+
+spin_lock_irqsave(hba->host->host_lock, flags);
+lrbp = &hba->lrb[INTERNAL_CMD_TAG];
+err = ufshcd_compose_nop_out_upiu(hba, lrbp);
+if (unlikely(err)) {
+spin_unlock_irqrestore(hba->host->host_lock, flags);
+goto out;
+}
+
+lrbp->completion = &wait;
+ufshcd_send_command(hba, INTERNAL_CMD_TAG);
+spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+err = ufshcd_wait_for_nop_cmd(hba, lrbp);
+
+if (err == -ETIMEDOUT) {
+u32 reg;
+u32 mask = 1 << INTERNAL_CMD_TAG;
+
+/* clear outstanding transaction before retry */
+spin_lock_irqsave(hba->host->host_lock, flags);
+ufshcd_utrl_clear(hba, INTERNAL_CMD_TAG);
+__clear_bit(INTERNAL_CMD_TAG, &hba->outstanding_reqs);
+spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+/* poll for max. 1 sec to clear door bell register by h/w */
+reg = ufshcd_wait_for_register(hba,
+REG_UTP_TRANSFER_REQ_DOOR_BELL,
+mask, mask, 1000, 1000);
+if ((reg & mask) == mask)
+retries = 0;
+}
+
+if (err && retries--) {
+dev_dbg(hba->dev, "%s: error %d retrying\n", __func__, err);
+goto retry;
+}
+
+out:
+if (err)
+dev_err(hba->dev, "%s: NOP OUT failed %d\n", __func__, err);
+return err;
+}
+
 /**
  * ufshcd_make_hba_operational - Make UFS controller operational
  * < at >hba: per adapter instance
< at >< at > -1438,6 +1593,16 < at >< at > static void ufshcd_uic_cmd_compl(struct ufs_hba *hba)
 }
 }
 
+/*
+ * ufshcd_is_nop_out_upiu() - check if the command is NOP OUT UPIU
+ * < at >lrbp: pointer to logical reference block
+ */
+static inline bool ufshcd_is_nop_out_upiu(struct ufshcd_lrb *lrbp)
+{
+return (be32_to_cpu(lrbp->ucd_req_ptr->header.dword_0) >> 24) ==
+UPIU_TRANSACTION_NOP_OUT;
+}
+
 /**
  * ufshcd_transfer_req_compl - handle SCSI and query command completion
  * < at >hba: per adapter instance
< at >< at > -1449,6 +1614,7 < at >< at > static void ufshcd_transfer_req_compl(struct ufs_hba *hba)
 u32 tr_doorbell;
 int result;
 int index;
+bool int_aggr_reset = true;
 
 lrb = hba->lrb;
 tr_doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
< at >< at > -1456,17 +1622,21 < at >< at > static void ufshcd_transfer_req_compl(struct ufs_hba *hba)
 
 for (index = 0; index < hba->nutrs; index++) {
 if (test_bit(index, &completed_reqs)) {
-
-result = ufshcd_transfer_rsp_status(hba, &lrb[index]);
-
 if (lrb[index].cmd) {
+result = ufshcd_transfer_rsp_status(
+hba, &lrb[index]);
 scsi_dma_unmap(lrb[index].cmd);
 lrb[index].cmd->result = result;
 lrb[index].cmd->scsi_done(lrb[index].cmd);
 
 /* Mark completed command as NULL in LRB */
 lrb[index].cmd = NULL;
+} else if (ufshcd_is_nop_out_upiu(&lrb[index])) {
+if (lrb[index].completion)
+complete(lrb[index].completion);
 }
+/* Don't reset counters for interrupt cmd */
+int_aggr_reset = lrb[index].intr_cmd ? false : true;
 } /* end of if */
 } /* end of for */
 
< at >< at > -1474,7 +1644,8 < at >< at > static void ufshcd_transfer_req_compl(struct ufs_hba *hba)
 hba->outstanding_reqs ^= completed_reqs;
 
 /* Reset interrupt aggregation counters */
-ufshcd_config_int_aggr(hba, INT_AGGR_RESET);
+if (int_aggr_reset)
+ufshcd_config_int_aggr(hba, INT_AGGR_RESET);
 }
 
 /**
< at >< at > -1772,8 +1943,16 < at >< at > static void ufshcd_async_scan(void *data, async_cookie_t cookie)
 int ret;
 
 ret = ufshcd_link_startup(hba);
-if (!ret)
-scsi_scan_host(hba->host);
+if (ret)
+goto out;
+
+ret = ufshcd_validate_dev_connection(hba);
+if (ret)
+goto out;
+
+scsi_scan_host(hba->host);
+out:
+return;
 }
 
 static struct scsi_host_template ufshcd_driver_template = {
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 974bd07..558d2f4 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
< at >< at > -102,6 +102,8 < at >< at > struct uic_command {
  * < at >command_type: SCSI, UFS, Query.
  * < at >task_tag: Task tag of the command
  * < at >lun: LUN of the command
+ * < at >intr_cmd: Interrupt command (doesn't participate in interrupt aggregation)
+ * < at >completion: holds the state of completion (used for internal commands)
  */
 struct ufshcd_lrb {
 struct utp_transfer_req_desc *utr_descriptor_ptr;
< at >< at > -117,6 +119,8 < at >< at > struct ufshcd_lrb {
 int command_type;
 int task_tag;
 unsigned int lun;
+bool intr_cmd;
+struct completion *completion;
 };
 
 /**

[PATCH 5/8] scsi: ufs: rework link start-up process

Santosh Y — 2013-05-19T08:21:40

From: Seungwon Jeon <tgih.jun< at >samsung.com>

Link start-up requires long time with multiphase handshakes
between UFS host and device. This affects driver's probe time.
This patch let link start-up run asynchronously. Link start-up
will be executed at the end of prove separately.
Along with this change, the following is worked.

Defined completion time of uic command to avoid a permanent wait.
Added mutex to guarantee of uic command at a time.
Adapted some sequence of controller initialization after link statup
according to HCI standard.

Signed-off-by: Seungwon Jeon <tgih.jun< at >samsung.com>
Signed-off-by: Sujit Reddy Thumma <sthumma< at >codeaurora.org>
Tested-by: Maya Erez <merez< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index b1ac21e..0c570c0 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -33,11 +33,15 < at >< at >
  * this program.
  */
 
+#include <linux/async.h>
+
 #include "ufshcd.h"
 
 #define UFSHCD_ENABLE_INTRS(UTP_TRANSFER_REQ_COMPL |\
  UTP_TASK_REQ_COMPL |\
  UFSHCD_ERROR_MASK)
+/* UIC command timeout, unit: ms */
+#define UIC_CMD_TIMEOUT500
 
 enum {
 UFSHCD_MAX_CHANNEL= 0,
< at >< at > -401,24 +405,122 < at >< at > static inline void ufshcd_hba_capabilities(struct ufs_hba *hba)
 }
 
 /**
- * ufshcd_send_uic_command - Send UIC commands to unipro layers
+ * ufshcd_ready_for_uic_cmd - Check if controller is ready
+ *                            to accept UIC commands
  * < at >hba: per adapter instance
- * < at >uic_command: UIC command
+ * Return true on success, else false
+ */
+static inline bool ufshcd_ready_for_uic_cmd(struct ufs_hba *hba)
+{
+if (ufshcd_readl(hba, REG_CONTROLLER_STATUS) & UIC_COMMAND_READY)
+return true;
+else
+return false;
+}
+
+/**
+ * ufshcd_dispatch_uic_cmd - Dispatch UIC commands to unipro layers
+ * < at >hba: per adapter instance
+ * < at >uic_cmd: UIC command
+ *
+ * Mutex must be held.
  */
 static inline void
-ufshcd_send_uic_command(struct ufs_hba *hba, struct uic_command *uic_cmnd)
+ufshcd_dispatch_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
 {
+WARN_ON(hba->active_uic_cmd);
+
+hba->active_uic_cmd = uic_cmd;
+
 /* Write Args */
-ufshcd_writel(hba, uic_cmnd->argument1, REG_UIC_COMMAND_ARG_1);
-ufshcd_writel(hba, uic_cmnd->argument2, REG_UIC_COMMAND_ARG_2);
-ufshcd_writel(hba, uic_cmnd->argument3, REG_UIC_COMMAND_ARG_3);
+ufshcd_writel(hba, uic_cmd->argument1, REG_UIC_COMMAND_ARG_1);
+ufshcd_writel(hba, uic_cmd->argument2, REG_UIC_COMMAND_ARG_2);
+ufshcd_writel(hba, uic_cmd->argument3, REG_UIC_COMMAND_ARG_3);
 
 /* Write UIC Cmd */
-ufshcd_writel(hba, uic_cmnd->command & COMMAND_OPCODE_MASK,
+ufshcd_writel(hba, uic_cmd->command & COMMAND_OPCODE_MASK,
       REG_UIC_COMMAND);
 }
 
 /**
+ * ufshcd_wait_for_uic_cmd - Wait complectioin of UIC command
+ * < at >hba: per adapter instance
+ * < at >uic_command: UIC command
+ *
+ * Must be called with mutex held.
+ * Returns 0 only if success.
+ */
+static int
+ufshcd_wait_for_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
+{
+int ret;
+unsigned long flags;
+
+if (wait_for_completion_timeout(&uic_cmd->done,
+msecs_to_jiffies(UIC_CMD_TIMEOUT)))
+ret = uic_cmd->argument2 & MASK_UIC_COMMAND_RESULT;
+else
+ret = -ETIMEDOUT;
+
+spin_lock_irqsave(hba->host->host_lock, flags);
+hba->active_uic_cmd = NULL;
+spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+return ret;
+}
+
+/**
+ * __ufshcd_send_uic_cmd - Send UIC commands and retrieve the result
+ * < at >hba: per adapter instance
+ * < at >uic_cmd: UIC command
+ *
+ * Identical to ufshcd_send_uic_cmd() expect mutex. Must be called
+ * with mutex held.
+ * Returns 0 only if success.
+ */
+static int
+__ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
+{
+int ret;
+unsigned long flags;
+
+if (!ufshcd_ready_for_uic_cmd(hba)) {
+dev_err(hba->dev,
+"Controller not ready to accept UIC commands\n");
+return -EIO;
+}
+
+init_completion(&uic_cmd->done);
+
+spin_lock_irqsave(hba->host->host_lock, flags);
+ufshcd_dispatch_uic_cmd(hba, uic_cmd);
+spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+ret = ufshcd_wait_for_uic_cmd(hba, uic_cmd);
+
+return ret;
+}
+
+/**
+ * ufshcd_send_uic_cmd - Send UIC commands and retrieve the result
+ * < at >hba: per adapter instance
+ * < at >uic_cmd: UIC command
+ *
+ * Returns 0 only if success.
+ */
+static int
+ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
+{
+int ret;
+
+mutex_lock(&hba->uic_cmd_mutex);
+ret = __ufshcd_send_uic_cmd(hba, uic_cmd);
+mutex_unlock(&hba->uic_cmd_mutex);
+
+return ret;
+}
+
+/**
  * ufshcd_map_sg - Map scatter-gather list to prdt
  * < at >lrbp - pointer to local reference block
  *
< at >< at > -858,34 +960,16 < at >< at > static void ufshcd_host_memory_configure(struct ufs_hba *hba)
  */
 static int ufshcd_dme_link_startup(struct ufs_hba *hba)
 {
-struct uic_command *uic_cmd;
-unsigned long flags;
-
-/* check if controller is ready to accept UIC commands */
-if ((ufshcd_readl(hba, REG_CONTROLLER_STATUS) &
-    UIC_COMMAND_READY) == 0x0) {
-dev_err(hba->dev,
-"Controller not ready"
-" to accept UIC commands\n");
-return -EIO;
-}
+struct uic_command uic_cmd = {0};
+int ret;
 
-spin_lock_irqsave(hba->host->host_lock, flags);
+uic_cmd.command = UIC_CMD_DME_LINK_STARTUP;
 
-/* form UIC command */
-uic_cmd = &hba->active_uic_cmd;
-uic_cmd->command = UIC_CMD_DME_LINK_STARTUP;
-uic_cmd->argument1 = 0;
-uic_cmd->argument2 = 0;
-uic_cmd->argument3 = 0;
-
-/* enable UIC related interrupts */
-ufshcd_enable_intr(hba, UIC_COMMAND_COMPL);
-
-/* sending UIC commands to controller */
-ufshcd_send_uic_command(hba, uic_cmd);
-spin_unlock_irqrestore(hba->host->host_lock, flags);
-return 0;
+ret = ufshcd_send_uic_cmd(hba, &uic_cmd);
+if (ret)
+dev_err(hba->dev,
+"dme-link-startup: error code %d\n", ret);
+return ret;
 }
 
 /**
< at >< at > -894,9 +978,10 < at >< at > static int ufshcd_dme_link_startup(struct ufs_hba *hba)
  *
  * To bring UFS host controller to operational state,
  * 1. Check if device is present
- * 2. Configure run-stop-registers
- * 3. Enable required interrupts
- * 4. Configure interrupt aggregation
+ * 2. Enable required interrupts
+ * 3. Configure interrupt aggregation
+ * 4. Program UTRL and UTMRL base addres
+ * 5. Configure run-stop-registers
  *
  * Returns 0 on success, non-zero value on failure
  */
< at >< at > -913,6 +998,22 < at >< at > static int ufshcd_make_hba_operational(struct ufs_hba *hba)
 goto out;
 }
 
+/* Enable required interrupts */
+ufshcd_enable_intr(hba, UFSHCD_ENABLE_INTRS);
+
+/* Configure interrupt aggregation */
+ufshcd_config_int_aggr(hba, INT_AGGR_CONFIG);
+
+/* Configure UTRL and UTMRL base address registers */
+ufshcd_writel(hba, lower_32_bits(hba->utrdl_dma_addr),
+REG_UTP_TRANSFER_REQ_LIST_BASE_L);
+ufshcd_writel(hba, upper_32_bits(hba->utrdl_dma_addr),
+REG_UTP_TRANSFER_REQ_LIST_BASE_H);
+ufshcd_writel(hba, lower_32_bits(hba->utmrdl_dma_addr),
+REG_UTP_TASK_REQ_LIST_BASE_L);
+ufshcd_writel(hba, upper_32_bits(hba->utmrdl_dma_addr),
+REG_UTP_TASK_REQ_LIST_BASE_H);
+
 /*
  * UCRDY, UTMRLDY and UTRLRDY bits must be 1
  * DEI, HEI bits must be 0
< at >< at > -926,17 +1027,11 < at >< at > static int ufshcd_make_hba_operational(struct ufs_hba *hba)
 goto out;
 }
 
-/* Enable required interrupts */
-ufshcd_enable_intr(hba, UFSHCD_ENABLE_INTRS);
-
-/* Configure interrupt aggregation */
-ufshcd_config_int_aggr(hba, INT_AGGR_CONFIG);
-
 if (hba->ufshcd_state == UFSHCD_STATE_RESET)
 scsi_unblock_requests(hba->host);
 
 hba->ufshcd_state = UFSHCD_STATE_OPERATIONAL;
-scsi_scan_host(hba->host);
+
 out:
 return err;
 }
< at >< at > -1005,34 +1100,28 < at >< at > static int ufshcd_hba_enable(struct ufs_hba *hba)
 }
 
 /**
- * ufshcd_initialize_hba - start the initialization process
+ * ufshcd_link_startup - Initialize unipro link startup
  * < at >hba: per adapter instance
  *
- * 1. Enable the controller via ufshcd_hba_enable.
- * 2. Program the Transfer Request List Address with the starting address of
- * UTRDL.
- * 3. Program the Task Management Request List Address with starting address
- * of UTMRDL.
- *
- * Returns 0 on success, non-zero value on failure.
+ * Returns 0 for success, non-zero in case of failure
  */
-static int ufshcd_initialize_hba(struct ufs_hba *hba)
+static int ufshcd_link_startup(struct ufs_hba *hba)
 {
-if (ufshcd_hba_enable(hba))
-return -EIO;
+int ret;
 
-/* Configure UTRL and UTMRL base address registers */
-ufshcd_writel(hba, lower_32_bits(hba->utrdl_dma_addr),
-      REG_UTP_TRANSFER_REQ_LIST_BASE_L);
-ufshcd_writel(hba, upper_32_bits(hba->utrdl_dma_addr),
-      REG_UTP_TRANSFER_REQ_LIST_BASE_H);
-ufshcd_writel(hba, lower_32_bits(hba->utmrdl_dma_addr),
-      REG_UTP_TASK_REQ_LIST_BASE_L);
-ufshcd_writel(hba, upper_32_bits(hba->utmrdl_dma_addr),
-      REG_UTP_TASK_REQ_LIST_BASE_H);
+/* enable UIC related interrupts */
+ufshcd_enable_intr(hba, UIC_COMMAND_COMPL);
 
-/* Initialize unipro link startup procedure */
-return ufshcd_dme_link_startup(hba);
+ret = ufshcd_dme_link_startup(hba);
+if (ret)
+goto out;
+
+ret = ufshcd_make_hba_operational(hba);
+
+out:
+if (ret)
+dev_err(hba->dev, "link startup failed %d\n", ret);
+return ret;
 }
 
 /**
< at >< at > -1072,12 +1161,19 < at >< at > static int ufshcd_do_reset(struct ufs_hba *hba)
 hba->outstanding_reqs = 0;
 hba->outstanding_tasks = 0;
 
-/* start the initialization process */
-if (ufshcd_initialize_hba(hba)) {
+/* Host controller enable */
+if (ufshcd_hba_enable(hba)) {
 dev_err(hba->dev,
 "Reset: Controller initialization failed\n");
 return FAILED;
 }
+
+if (ufshcd_link_startup(hba)) {
+dev_err(hba->dev,
+"Reset: Link start-up failed\n");
+return FAILED;
+}
+
 return SUCCESS;
 }
 
< at >< at > -1330,6 +1426,19 < at >< at > ufshcd_transfer_rsp_status(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
 }
 
 /**
+ * ufshcd_uic_cmd_compl - handle completion of uic command
+ * < at >hba: per adapter instance
+ */
+static void ufshcd_uic_cmd_compl(struct ufs_hba *hba)
+{
+if (hba->active_uic_cmd) {
+hba->active_uic_cmd->argument2 |=
+ufshcd_get_uic_cmd_result(hba);
+complete(&hba->active_uic_cmd->done);
+}
+}
+
+/**
  * ufshcd_transfer_req_compl - handle SCSI and query command completion
  * < at >hba: per adapter instance
  */
< at >< at > -1369,28 +1478,6 < at >< at > static void ufshcd_transfer_req_compl(struct ufs_hba *hba)
 }
 
 /**
- * ufshcd_uic_cc_handler - handle UIC command completion
- * < at >work: pointer to a work queue structure
- *
- * Returns 0 on success, non-zero value on failure
- */
-static void ufshcd_uic_cc_handler (struct work_struct *work)
-{
-struct ufs_hba *hba;
-
-hba = container_of(work, struct ufs_hba, uic_workq);
-
-if ((hba->active_uic_cmd.command == UIC_CMD_DME_LINK_STARTUP) &&
-    !(ufshcd_get_uic_cmd_result(hba))) {
-
-if (ufshcd_make_hba_operational(hba))
-dev_err(hba->dev,
-"cc: hba not operational state\n");
-return;
-}
-}
-
-/**
  * ufshcd_fatal_err_handler - handle fatal errors
  * < at >hba: per adapter instance
  */
< at >< at > -1451,7 +1538,7 < at >< at > static void ufshcd_sl_intr(struct ufs_hba *hba, u32 intr_status)
 ufshcd_err_handler(hba);
 
 if (intr_status & UIC_COMMAND_COMPL)
-schedule_work(&hba->uic_workq);
+ufshcd_uic_cmd_compl(hba);
 
 if (intr_status & UTP_TASK_REQ_COMPL)
 ufshcd_tmc_handler(hba);
< at >< at > -1674,6 +1761,21 < at >< at > out:
 return err;
 }
 
+/**
+ * ufshcd_async_scan - asynchronous execution for link startup
+ * < at >data: data pointer to pass to this function
+ * < at >cookie: cookie data
+ */
+static void ufshcd_async_scan(void *data, async_cookie_t cookie)
+{
+struct ufs_hba *hba = (struct ufs_hba *)data;
+int ret;
+
+ret = ufshcd_link_startup(hba);
+if (!ret)
+scsi_scan_host(hba->host);
+}
+
 static struct scsi_host_template ufshcd_driver_template = {
 .module= THIS_MODULE,
 .name= UFSHCD,
< at >< at > -1835,12 +1937,14 < at >< at > int ufshcd_init(struct device *dev, struct ufs_hba **hba_handle,
 init_waitqueue_head(&hba->ufshcd_tm_wait_queue);
 
 /* Initialize work queues */
-INIT_WORK(&hba->uic_workq, ufshcd_uic_cc_handler);
 INIT_WORK(&hba->feh_workq, ufshcd_fatal_err_handler);
 
 /* Initialize mutex for query requests */
 mutex_init(&hba->query.lock_ufs_query);
 
+/* Initialize UIC command mutex */
+mutex_init(&hba->uic_cmd_mutex);
+
 /* IRQ registration */
 err = request_irq(irq, ufshcd_intr, IRQF_SHARED, UFSHCD, hba);
 if (err) {
< at >< at > -1861,14 +1965,17 < at >< at > int ufshcd_init(struct device *dev, struct ufs_hba **hba_handle,
 goto out_free_irq;
 }
 
-/* Initialization routine */
-err = ufshcd_initialize_hba(hba);
+/* Host controller enable */
+err = ufshcd_hba_enable(hba);
 if (err) {
-dev_err(hba->dev, "Initialization failed\n");
+dev_err(hba->dev, "Host controller enable failed\n");
 goto out_remove_scsi_host;
 }
+
 *hba_handle = hba;
 
+async_schedule(ufshcd_async_scan, hba);
+
 return 0;
 
 out_remove_scsi_host:
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index d98e046..974bd07 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
< at >< at > -51,6 +51,7 < at >< at >
 #include <linux/bitops.h>
 #include <linux/pm_runtime.h>
 #include <linux/clk.h>
+#include <linux/completion.h>
 
 #include <asm/irq.h>
 #include <asm/byteorder.h>
< at >< at > -76,6 +77,7 < at >< at >
  * < at >argument3: UIC command argument 3
  * < at >cmd_active: Indicate if UIC command is outstanding
  * < at >result: UIC command result
+ * < at >done: UIC command completion
  */
 struct uic_command {
 u32 command;
< at >< at > -84,6 +86,7 < at >< at > struct uic_command {
 u32 argument3;
 int cmd_active;
 int result;
+struct completion done;
 };
 
 /**
< at >< at > -150,11 +153,11 < at >< at > struct ufs_query {
  * < at >ufs_version: UFS Version to which controller complies
  * < at >irq: Irq number of the controller
  * < at >active_uic_cmd: handle of active UIC command
+ * < at >uic_cmd_mutex: mutex for uic command
  * < at >ufshcd_tm_wait_queue: wait queue for task management
  * < at >tm_condition: condition variable for task management
  * < at >ufshcd_state: UFSHCD states
  * < at >intr_mask: Interrupt Mask Bits
- * < at >uic_workq: Work queue for UIC completion handling
  * < at >feh_workq: Work queue for fatal controller error handling
  * < at >errors: HBA errors
  * < at >query: query request information
< at >< at > -186,7 +189,9 < at >< at > struct ufs_hba {
 u32 ufs_version;
 unsigned int irq;
 
-struct uic_command active_uic_cmd;
+struct uic_command *active_uic_cmd;
+struct mutex uic_cmd_mutex;
+
 wait_queue_head_t ufshcd_tm_wait_queue;
 unsigned long tm_condition;
 
< at >< at > -194,7 +199,6 < at >< at > struct ufs_hba {
 u32 intr_mask;
 
 /* Work Queues */
-struct work_struct uic_workq;
 struct work_struct feh_workq;
 
 /* HBA Errors */

[PATCH 4/8] scsi: ufs: remove version check before IS reg clear

Santosh Y — 2013-05-19T08:21:39

From: Seungwon Jeon <tgih.jun< at >samsung.com>

There is no need to check the version to clear
the interrupt status. And the order is changed
prior to actual handling.

Signed-off-by: Seungwon Jeon <tgih.jun< at >samsung.com>
Tested-by: Maya Erez <merez< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index aa2c8d2..b1ac21e 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -1478,11 +1478,8 < at >< at > static irqreturn_t ufshcd_intr(int irq, void *__hba)
 intr_status = ufshcd_readl(hba, REG_INTERRUPT_STATUS);
 
 if (intr_status) {
+ufshcd_writel(hba, intr_status, REG_INTERRUPT_STATUS);
 ufshcd_sl_intr(hba, intr_status);
-
-/* If UFSHCI 1.0 then clear interrupt status register */
-if (hba->ufs_version == UFSHCI_VERSION_10)
-ufshcd_writel(hba, intr_status, REG_INTERRUPT_STATUS);
 retval = IRQ_HANDLED;
 }
 spin_unlock(hba->host->host_lock);

[PATCH 3/8] scsi: ufs: amend interrupt configuration

Santosh Y — 2013-05-19T08:21:38

From: Seungwon Jeon <tgih.jun< at >samsung.com>

It makes interrupt setting more flexible especially
for disabling. And wrong bit mask is fixed for ver 1.0.
[17:16] is added for mask.

Signed-off-by: Seungwon Jeon <tgih.jun< at >samsung.com>
Tested-by: Maya Erez <merez< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 38412a6..aa2c8d2 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -35,6 +35,10 < at >< at >
 
 #include "ufshcd.h"
 
+#define UFSHCD_ENABLE_INTRS(UTP_TRANSFER_REQ_COMPL |\
+ UTP_TASK_REQ_COMPL |\
+ UFSHCD_ERROR_MASK)
+
 enum {
 UFSHCD_MAX_CHANNEL= 0,
 UFSHCD_MAX_ID= 1,
< at >< at > -64,6 +68,20 < at >< at > enum {
 };
 
 /**
+ * ufshcd_get_intr_mask - Get the interrupt bit mask
+ * < at >hba - Pointer to adapter instance
+ *
+ * Returns interrupt bit mask per version
+ */
+static inline u32 ufshcd_get_intr_mask(struct ufs_hba *hba)
+{
+if (hba->ufs_version == UFSHCI_VERSION_10)
+return INTERRUPT_MASK_ALL_VER_10;
+else
+return INTERRUPT_MASK_ALL_VER_11;
+}
+
+/**
  * ufshcd_get_ufs_version - Get the UFS version supported by the HBA
  * < at >hba - Pointer to adapter instance
  *
< at >< at > -441,25 +459,45 < at >< at > static int ufshcd_map_sg(struct ufshcd_lrb *lrbp)
 }
 
 /**
- * ufshcd_int_config - enable/disable interrupts
+ * ufshcd_enable_intr - enable interrupts
  * < at >hba: per adapter instance
- * < at >option: interrupt option
+ * < at >intrs: interrupt bits
  */
-static void ufshcd_int_config(struct ufs_hba *hba, u32 option)
+static void ufshcd_enable_intr(struct ufs_hba *hba, u32 intrs)
 {
-switch (option) {
-case UFSHCD_INT_ENABLE:
-ufshcd_writel(hba, hba->int_enable_mask, REG_INTERRUPT_ENABLE);
-break;
-case UFSHCD_INT_DISABLE:
-if (hba->ufs_version == UFSHCI_VERSION_10)
-ufshcd_writel(hba, INTERRUPT_DISABLE_MASK_10,
-      REG_INTERRUPT_ENABLE);
-else
-ufshcd_writel(hba, INTERRUPT_DISABLE_MASK_11,
-      REG_INTERRUPT_ENABLE);
-break;
+u32 set = ufshcd_readl(hba, REG_INTERRUPT_ENABLE);
+
+if (hba->ufs_version == UFSHCI_VERSION_10) {
+u32 rw;
+rw = set & INTERRUPT_MASK_RW_VER_10;
+set = rw | ((set ^ intrs) & intrs);
+} else {
+set |= intrs;
+}
+
+ufshcd_writel(hba, set, REG_INTERRUPT_ENABLE);
+}
+
+/**
+ * ufshcd_disable_intr - disable interrupts
+ * < at >hba: per adapter instance
+ * < at >intrs: interrupt bits
+ */
+static void ufshcd_disable_intr(struct ufs_hba *hba, u32 intrs)
+{
+u32 set = ufshcd_readl(hba, REG_INTERRUPT_ENABLE);
+
+if (hba->ufs_version == UFSHCI_VERSION_10) {
+u32 rw;
+rw = (set & INTERRUPT_MASK_RW_VER_10) &
+~(intrs & INTERRUPT_MASK_RW_VER_10);
+set = rw | ((set & intrs) & ~INTERRUPT_MASK_RW_VER_10);
+
+} else {
+set &= ~intrs;
 }
+
+ufshcd_writel(hba, set, REG_INTERRUPT_ENABLE);
 }
 
 /**
< at >< at > -842,8 +880,7 < at >< at > static int ufshcd_dme_link_startup(struct ufs_hba *hba)
 uic_cmd->argument3 = 0;
 
 /* enable UIC related interrupts */
-hba->int_enable_mask |= UIC_COMMAND_COMPL;
-ufshcd_int_config(hba, UFSHCD_INT_ENABLE);
+ufshcd_enable_intr(hba, UIC_COMMAND_COMPL);
 
 /* sending UIC commands to controller */
 ufshcd_send_uic_command(hba, uic_cmd);
< at >< at > -890,13 +927,7 < at >< at > static int ufshcd_make_hba_operational(struct ufs_hba *hba)
 }
 
 /* Enable required interrupts */
-hba->int_enable_mask |= (UTP_TRANSFER_REQ_COMPL |
- UIC_ERROR |
- UTP_TASK_REQ_COMPL |
- DEVICE_FATAL_ERROR |
- CONTROLLER_FATAL_ERROR |
- SYSTEM_BUS_FATAL_ERROR);
-ufshcd_int_config(hba, UFSHCD_INT_ENABLE);
+ufshcd_enable_intr(hba, UFSHCD_ENABLE_INTRS);
 
 /* Configure interrupt aggregation */
 ufshcd_config_int_aggr(hba, INT_AGGR_CONFIG);
< at >< at > -1724,7 +1755,7 < at >< at > static void ufshcd_hba_free(struct ufs_hba *hba)
 void ufshcd_remove(struct ufs_hba *hba)
 {
 /* disable interrupts */
-ufshcd_int_config(hba, UFSHCD_INT_DISABLE);
+ufshcd_disable_intr(hba, hba->intr_mask);
 
 ufshcd_hba_stop(hba);
 ufshcd_hba_free(hba);
< at >< at > -1782,6 +1813,9 < at >< at > int ufshcd_init(struct device *dev, struct ufs_hba **hba_handle,
 /* Get UFS version supported by the controller */
 hba->ufs_version = ufshcd_get_ufs_version(hba);
 
+/* Get Interrupt bit mask per version */
+hba->intr_mask = ufshcd_get_intr_mask(hba);
+
 /* Allocate memory for host memory space */
 err = ufshcd_memory_alloc(hba);
 if (err) {
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 6429bed..d98e046 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
< at >< at > -153,7 +153,7 < at >< at > struct ufs_query {
  * < at >ufshcd_tm_wait_queue: wait queue for task management
  * < at >tm_condition: condition variable for task management
  * < at >ufshcd_state: UFSHCD states
- * < at >int_enable_mask: Interrupt Mask Bits
+ * < at >intr_mask: Interrupt Mask Bits
  * < at >uic_workq: Work queue for UIC completion handling
  * < at >feh_workq: Work queue for fatal controller error handling
  * < at >errors: HBA errors
< at >< at > -191,7 +191,7 < at >< at > struct ufs_hba {
 unsigned long tm_condition;
 
 u32 ufshcd_state;
-u32 int_enable_mask;
+u32 intr_mask;
 
 /* Work Queues */
 struct work_struct uic_workq;
diff --git a/drivers/scsi/ufs/ufshci.h b/drivers/scsi/ufs/ufshci.h
index 4a86247..f1e1b74 100644
--- a/drivers/scsi/ufs/ufshci.h
+++ b/drivers/scsi/ufs/ufshci.h
< at >< at > -232,10 +232,11 < at >< at > enum {
 /* Interrupt disable masks */
 enum {
 /* Interrupt disable mask for UFSHCI v1.0 */
-INTERRUPT_DISABLE_MASK_10= 0xFFFF,
+INTERRUPT_MASK_ALL_VER_10= 0x30FFF,
+INTERRUPT_MASK_RW_VER_10= 0x30000,
 
 /* Interrupt disable mask for UFSHCI v1.1 */
-INTERRUPT_DISABLE_MASK_11= 0x0,
+INTERRUPT_MASK_ALL_VER_11= 0x31FFF,
 };
 
 /*

[PATCH 2/8] scsi: ufs: wrap the i/o access operations

Santosh Y — 2013-05-19T08:21:37

From: Seungwon Jeon <tgih.jun< at >samsung.com>

Simplify operations with hiding mmio_base.

Signed-off-by: Seungwon Jeon <tgih.jun< at >samsung.com>
Tested-by: Maya Erez <merez< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 4ddc8be..38412a6 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -71,7 +71,7 < at >< at > enum {
  */
 static inline u32 ufshcd_get_ufs_version(struct ufs_hba *hba)
 {
-return readl(hba->mmio_base + REG_UFS_VERSION);
+return ufshcd_readl(hba, REG_UFS_VERSION);
 }
 
 /**
< at >< at > -130,8 +130,7 < at >< at > static inline int ufshcd_get_tm_free_slot(struct ufs_hba *hba)
  */
 static inline void ufshcd_utrl_clear(struct ufs_hba *hba, u32 pos)
 {
-writel(~(1 << pos),
-(hba->mmio_base + REG_UTP_TRANSFER_REQ_LIST_CLEAR));
+ufshcd_writel(hba, ~(1 << pos), REG_UTP_TRANSFER_REQ_LIST_CLEAR);
 }
 
 /**
< at >< at > -165,7 +164,7 < at >< at > static inline int ufshcd_get_lists_status(u32 reg)
  */
 static inline int ufshcd_get_uic_cmd_result(struct ufs_hba *hba)
 {
-return readl(hba->mmio_base + REG_UIC_COMMAND_ARG_2) &
+return ufshcd_readl(hba, REG_UIC_COMMAND_ARG_2) &
        MASK_UIC_COMMAND_RESULT;
 }
 
< at >< at > -238,18 +237,15 < at >< at > ufshcd_config_int_aggr(struct ufs_hba *hba, int option)
 {
 switch (option) {
 case INT_AGGR_RESET:
-writel((INT_AGGR_ENABLE |
-INT_AGGR_COUNTER_AND_TIMER_RESET),
-(hba->mmio_base +
- REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL));
+ufshcd_writel(hba, INT_AGGR_ENABLE |
+      INT_AGGR_COUNTER_AND_TIMER_RESET,
+      REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL);
 break;
 case INT_AGGR_CONFIG:
-writel((INT_AGGR_ENABLE |
-INT_AGGR_PARAM_WRITE |
-INT_AGGR_COUNTER_THRESHOLD_VALUE |
-INT_AGGR_TIMEOUT_VALUE),
-(hba->mmio_base +
- REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL));
+ufshcd_writel(hba, INT_AGGR_ENABLE | INT_AGGR_PARAM_WRITE |
+      INT_AGGR_COUNTER_THRESHOLD_VALUE |
+      INT_AGGR_TIMEOUT_VALUE,
+      REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL);
 break;
 }
 }
< at >< at > -262,12 +258,10 < at >< at > ufshcd_config_int_aggr(struct ufs_hba *hba, int option)
  */
 static void ufshcd_enable_run_stop_reg(struct ufs_hba *hba)
 {
-writel(UTP_TASK_REQ_LIST_RUN_STOP_BIT,
-       (hba->mmio_base +
-REG_UTP_TASK_REQ_LIST_RUN_STOP));
-writel(UTP_TRANSFER_REQ_LIST_RUN_STOP_BIT,
-       (hba->mmio_base +
-REG_UTP_TRANSFER_REQ_LIST_RUN_STOP));
+ufshcd_writel(hba, UTP_TASK_REQ_LIST_RUN_STOP_BIT,
+      REG_UTP_TASK_REQ_LIST_RUN_STOP);
+ufshcd_writel(hba, UTP_TRANSFER_REQ_LIST_RUN_STOP_BIT,
+      REG_UTP_TRANSFER_REQ_LIST_RUN_STOP);
 }
 
 /**
< at >< at > -276,7 +270,7 < at >< at > static void ufshcd_enable_run_stop_reg(struct ufs_hba *hba)
  */
 static inline void ufshcd_hba_start(struct ufs_hba *hba)
 {
-writel(CONTROLLER_ENABLE , (hba->mmio_base + REG_CONTROLLER_ENABLE));
+ufshcd_writel(hba, CONTROLLER_ENABLE, REG_CONTROLLER_ENABLE);
 }
 
 /**
< at >< at > -287,7 +281,7 < at >< at > static inline void ufshcd_hba_start(struct ufs_hba *hba)
  */
 static inline int ufshcd_is_hba_active(struct ufs_hba *hba)
 {
-return (readl(hba->mmio_base + REG_CONTROLLER_ENABLE) & 0x1) ? 0 : 1;
+return (ufshcd_readl(hba, REG_CONTROLLER_ENABLE) & 0x1) ? 0 : 1;
 }
 
 /**
< at >< at > -299,8 +293,7 < at >< at > static inline
 void ufshcd_send_command(struct ufs_hba *hba, unsigned int task_tag)
 {
 __set_bit(task_tag, &hba->outstanding_reqs);
-writel((1 << task_tag),
-       (hba->mmio_base + REG_UTP_TRANSFER_REQ_DOOR_BELL));
+ufshcd_writel(hba, 1 << task_tag, REG_UTP_TRANSFER_REQ_DOOR_BELL);
 }
 
 /**
< at >< at > -381,8 +374,7 < at >< at > void ufshcd_copy_query_response(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
  */
 static inline void ufshcd_hba_capabilities(struct ufs_hba *hba)
 {
-hba->capabilities =
-readl(hba->mmio_base + REG_CONTROLLER_CAPABILITIES);
+hba->capabilities = ufshcd_readl(hba, REG_CONTROLLER_CAPABILITIES);
 
 /* nutrs and nutmrs are 0 based values */
 hba->nutrs = (hba->capabilities & MASK_TRANSFER_REQUESTS_SLOTS) + 1;
< at >< at > -399,16 +391,13 < at >< at > static inline void
 ufshcd_send_uic_command(struct ufs_hba *hba, struct uic_command *uic_cmnd)
 {
 /* Write Args */
-writel(uic_cmnd->argument1,
-      (hba->mmio_base + REG_UIC_COMMAND_ARG_1));
-writel(uic_cmnd->argument2,
-      (hba->mmio_base + REG_UIC_COMMAND_ARG_2));
-writel(uic_cmnd->argument3,
-      (hba->mmio_base + REG_UIC_COMMAND_ARG_3));
+ufshcd_writel(hba, uic_cmnd->argument1, REG_UIC_COMMAND_ARG_1);
+ufshcd_writel(hba, uic_cmnd->argument2, REG_UIC_COMMAND_ARG_2);
+ufshcd_writel(hba, uic_cmnd->argument3, REG_UIC_COMMAND_ARG_3);
 
 /* Write UIC Cmd */
-writel((uic_cmnd->command & COMMAND_OPCODE_MASK),
-       (hba->mmio_base + REG_UIC_COMMAND));
+ufshcd_writel(hba, uic_cmnd->command & COMMAND_OPCODE_MASK,
+      REG_UIC_COMMAND);
 }
 
 /**
< at >< at > -460,16 +449,15 < at >< at > static void ufshcd_int_config(struct ufs_hba *hba, u32 option)
 {
 switch (option) {
 case UFSHCD_INT_ENABLE:
-writel(hba->int_enable_mask,
-      (hba->mmio_base + REG_INTERRUPT_ENABLE));
+ufshcd_writel(hba, hba->int_enable_mask, REG_INTERRUPT_ENABLE);
 break;
 case UFSHCD_INT_DISABLE:
 if (hba->ufs_version == UFSHCI_VERSION_10)
-writel(INTERRUPT_DISABLE_MASK_10,
-      (hba->mmio_base + REG_INTERRUPT_ENABLE));
+ufshcd_writel(hba, INTERRUPT_DISABLE_MASK_10,
+      REG_INTERRUPT_ENABLE);
 else
-writel(INTERRUPT_DISABLE_MASK_11,
-       (hba->mmio_base + REG_INTERRUPT_ENABLE));
+ufshcd_writel(hba, INTERRUPT_DISABLE_MASK_11,
+      REG_INTERRUPT_ENABLE);
 break;
 }
 }
< at >< at > -836,7 +824,7 < at >< at > static int ufshcd_dme_link_startup(struct ufs_hba *hba)
 unsigned long flags;
 
 /* check if controller is ready to accept UIC commands */
-if (((readl(hba->mmio_base + REG_CONTROLLER_STATUS)) &
+if ((ufshcd_readl(hba, REG_CONTROLLER_STATUS) &
     UIC_COMMAND_READY) == 0x0) {
 dev_err(hba->dev,
 "Controller not ready"
< at >< at > -881,7 +869,7 < at >< at > static int ufshcd_make_hba_operational(struct ufs_hba *hba)
 u32 reg;
 
 /* check if device present */
-reg = readl((hba->mmio_base + REG_CONTROLLER_STATUS));
+reg = ufshcd_readl(hba, REG_CONTROLLER_STATUS);
 if (!ufshcd_is_device_present(reg)) {
 dev_err(hba->dev, "cc: Device not present\n");
 err = -ENXIO;
< at >< at > -1003,14 +991,14 < at >< at > static int ufshcd_initialize_hba(struct ufs_hba *hba)
 return -EIO;
 
 /* Configure UTRL and UTMRL base address registers */
-writel(lower_32_bits(hba->utrdl_dma_addr),
-       (hba->mmio_base + REG_UTP_TRANSFER_REQ_LIST_BASE_L));
-writel(upper_32_bits(hba->utrdl_dma_addr),
-       (hba->mmio_base + REG_UTP_TRANSFER_REQ_LIST_BASE_H));
-writel(lower_32_bits(hba->utmrdl_dma_addr),
-       (hba->mmio_base + REG_UTP_TASK_REQ_LIST_BASE_L));
-writel(upper_32_bits(hba->utmrdl_dma_addr),
-       (hba->mmio_base + REG_UTP_TASK_REQ_LIST_BASE_H));
+ufshcd_writel(hba, lower_32_bits(hba->utrdl_dma_addr),
+      REG_UTP_TRANSFER_REQ_LIST_BASE_L);
+ufshcd_writel(hba, upper_32_bits(hba->utrdl_dma_addr),
+      REG_UTP_TRANSFER_REQ_LIST_BASE_H);
+ufshcd_writel(hba, lower_32_bits(hba->utmrdl_dma_addr),
+      REG_UTP_TASK_REQ_LIST_BASE_L);
+ufshcd_writel(hba, upper_32_bits(hba->utmrdl_dma_addr),
+      REG_UTP_TASK_REQ_LIST_BASE_H);
 
 /* Initialize unipro link startup procedure */
 return ufshcd_dme_link_startup(hba);
< at >< at > -1323,8 +1311,7 < at >< at > static void ufshcd_transfer_req_compl(struct ufs_hba *hba)
 int index;
 
 lrb = hba->lrb;
-tr_doorbell =
-readl(hba->mmio_base + REG_UTP_TRANSFER_REQ_DOOR_BELL);
+tr_doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
 completed_reqs = tr_doorbell ^ hba->outstanding_reqs;
 
 for (index = 0; index < hba->nutrs; index++) {
< at >< at > -1398,9 +1385,7 < at >< at > static void ufshcd_err_handler(struct ufs_hba *hba)
 goto fatal_eh;
 
 if (hba->errors & UIC_ERROR) {
-
-reg = readl(hba->mmio_base +
-    REG_UIC_ERROR_CODE_PHY_ADAPTER_LAYER);
+reg = ufshcd_readl(hba, REG_UIC_ERROR_CODE_PHY_ADAPTER_LAYER);
 if (reg & UIC_DATA_LINK_LAYER_ERROR_PA_INIT)
 goto fatal_eh;
 }
< at >< at > -1418,7 +1403,7 < at >< at > static void ufshcd_tmc_handler(struct ufs_hba *hba)
 {
 u32 tm_doorbell;
 
-tm_doorbell = readl(hba->mmio_base + REG_UTP_TASK_REQ_DOOR_BELL);
+tm_doorbell = ufshcd_readl(hba, REG_UTP_TASK_REQ_DOOR_BELL);
 hba->tm_condition = tm_doorbell ^ hba->outstanding_tasks;
 wake_up_interruptible(&hba->ufshcd_tm_wait_queue);
 }
< at >< at > -1459,15 +1444,14 < at >< at > static irqreturn_t ufshcd_intr(int irq, void *__hba)
 struct ufs_hba *hba = __hba;
 
 spin_lock(hba->host->host_lock);
-intr_status = readl(hba->mmio_base + REG_INTERRUPT_STATUS);
+intr_status = ufshcd_readl(hba, REG_INTERRUPT_STATUS);
 
 if (intr_status) {
 ufshcd_sl_intr(hba, intr_status);
 
 /* If UFSHCI 1.0 then clear interrupt status register */
 if (hba->ufs_version == UFSHCI_VERSION_10)
-writel(intr_status,
-       (hba->mmio_base + REG_INTERRUPT_STATUS));
+ufshcd_writel(hba, intr_status, REG_INTERRUPT_STATUS);
 retval = IRQ_HANDLED;
 }
 spin_unlock(hba->host->host_lock);
< at >< at > -1532,8 +1516,7 < at >< at > ufshcd_issue_tm_cmd(struct ufs_hba *hba,
 
 /* send command to the controller */
 __set_bit(free_slot, &hba->outstanding_tasks);
-writel((1 << free_slot),
-       (hba->mmio_base + REG_UTP_TASK_REQ_DOOR_BELL));
+ufshcd_writel(hba, 1 << free_slot, REG_UTP_TASK_REQ_DOOR_BELL);
 
 spin_unlock_irqrestore(host->host_lock, flags);
 
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 336980b..6429bed 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
< at >< at > -204,6 +204,11 < at >< at > struct ufs_hba {
 struct ufs_query query;
 };
 
+#define ufshcd_writel(hba, val, reg)\
+writel((val), (hba)->mmio_base + (reg))
+#define ufshcd_readl(hba, reg)\
+readl((hba)->mmio_base + (reg))
+
 int ufshcd_init(struct device *, struct ufs_hba ** , void __iomem * ,
 unsigned int);
 void ufshcd_remove(struct ufs_hba *);
< at >< at > -214,7 +219,7 < at >< at > void ufshcd_remove(struct ufs_hba *);
  */
 static inline void ufshcd_hba_stop(struct ufs_hba *hba)
 {
-writel(CONTROLLER_DISABLE, (hba->mmio_base + REG_CONTROLLER_ENABLE));
+ufshcd_writel(hba, CONTROLLER_DISABLE,  REG_CONTROLLER_ENABLE);
 }
 
 #endif /* End of Header */

[PATCH 1/8] scsi: ufs: add support for query requests

Santosh Y — 2013-05-19T08:21:36

From: Dolev Raviv <draviv< at >codeaurora.org>

Add support for sending UFS query requests through tagged command
queuing. This design allows queuing query requests in any open slot
along with other SCSI commands. In this way there is no need to
save a slot in the requests queue and decrease its size.

A query request is posing to a SCSI command to use native flow. But
unlike normal SCSI command flow, the data and response fields are
filled in UFS host data structure instead of passing as arguments
while queuing into SCSI mlqueue (mid-layer SCSI queue, the requests
from this queue are submitted to the device queue). As per specification
only one query request is allowed to be processed by device. Hence a
mutex lock for protecting data and response fields (hba->query.request and
hba->query.response) needs to be held while query request is in
progress.

The API for submitting a query request is ufs_query_request() in
ufshcd.c. This function is responsible for:
1. Obtaining the SCSI device from the host
2. Keeping the query mutex to prevent multiple queries
3. Storing the required data for sending a query request in ufs_hba
4. Queuing a SCSI vendor specific command to trigger a query request
   in the UFS driver.

The callers of ufs_query_request() are expected to fill the query
command data fields and are to provide an allocated response field
for the driver to fill response fields after request completion.

The request and response upiu is extended in a union to enable using the
same data structure, both for command upiu and query request upiu.

The query request flow is separated from the scsi command flow in:
1. Preparing the request
2. Validating response (error) codes
3. Copying data (only used for descriptor read/write query requests)
4. Copying response/sense

Data error can't be handled in the scsi command native flow. Hence,
we pass the code as without a change back to the submitting layer.

UPIU (UFS Protocol Information Unit) size is increased to 512 bytes
from 128. The UPIU header and the transaction specific fields (SCSI
command or Query Request OSF - Op-code Specific Fields) are 32 bytes
together, the rest is used to transfer extra request data (such as
descriptor in query requests). In order to accommodate the largest
descriptor in the UFS spec (256 bytes) we need to increase the UPIU
size.

Signed-off-by: Dolev Raviv <draviv< at >codeaurora.org>
Signed-off-by: Santosh Y <santoshsy< at >gmail.com>

diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index 139bc06..086ff03 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
< at >< at > -36,10 +36,20 < at >< at >
 #ifndef _UFS_H
 #define _UFS_H
 
+#include <linux/mutex.h>
+#include <linux/types.h>
+
 #define MAX_CDB_SIZE16
+#define GENERAL_UPIU_REQUEST_SIZE 32
+#define UPIU_HEADER_DATA_SEGMENT_MAX_SIZE((ALIGNED_UPIU_SIZE) - \
+(GENERAL_UPIU_REQUEST_SIZE))
+#define QUERY_OSF_SIZE((GENERAL_UPIU_REQUEST_SIZE) - \
+(sizeof(struct utp_upiu_header)))
+#define UFS_QUERY_RESERVED_SCSI_CMD 0xCC
+#define UFS_QUERY_CMD_SIZE 10
 
 #define UPIU_HEADER_DWORD(byte3, byte2, byte1, byte0)\
-((byte3 << 24) | (byte2 << 16) |\
+cpu_to_be32((byte3 << 24) | (byte2 << 16) |\
  (byte1 << 8) | (byte0))
 
 /*
< at >< at > -62,7 +72,7 < at >< at > enum {
 UPIU_TRANSACTION_COMMAND= 0x01,
 UPIU_TRANSACTION_DATA_OUT= 0x02,
 UPIU_TRANSACTION_TASK_REQ= 0x04,
-UPIU_TRANSACTION_QUERY_REQ= 0x26,
+UPIU_TRANSACTION_QUERY_REQ= 0x16,
 };
 
 /* UTP UPIU Transaction Codes Target to Initiator */
< at >< at > -73,6 +83,7 < at >< at > enum {
 UPIU_TRANSACTION_TASK_RSP= 0x24,
 UPIU_TRANSACTION_READY_XFER= 0x31,
 UPIU_TRANSACTION_QUERY_RSP= 0x36,
+UPIU_TRANSACTION_REJECT_UPIU= 0x3F,
 };
 
 /* UPIU Read/Write flags */
< at >< at > -90,6 +101,12 < at >< at > enum {
 UPIU_TASK_ATTR_ACA= 0x03,
 };
 
+/* UPIU Query request function */
+enum {
+UPIU_QUERY_FUNC_STANDARD_READ_REQUEST = 0x01,
+UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST = 0x81,
+};
+
 /* UTP QUERY Transaction Specific Fields OpCode */
 enum {
 UPIU_QUERY_OPCODE_NOP= 0x0,
< at >< at > -103,6 +120,21 < at >< at > enum {
 UPIU_QUERY_OPCODE_TOGGLE_FLAG= 0x8,
 };
 
+/* Query response result code */
+enum {
+QUERY_RESULT_SUCCESS= 0x00,
+QUERY_RESULT_NOT_READABLE= 0xF6,
+QUERY_RESULT_NOT_WRITEABLE= 0xF7,
+QUERY_RESULT_ALREADY_WRITTEN= 0xF8,
+QUERY_RESULT_INVALID_LENGTH= 0xF9,
+QUERY_RESULT_INVALID_VALUE= 0xFA,
+QUERY_RESULT_INVALID_SELECTOR= 0xFB,
+QUERY_RESULT_INVALID_INDEX= 0xFC,
+QUERY_RESULT_INVALID_IDN= 0xFD,
+QUERY_RESULT_INVALID_OPCODE= 0xFE,
+QUERY_RESULT_GENERAL_FAILURE= 0xFF,
+};
+
 /* UTP Transfer Request Command Type (CT) */
 enum {
 UPIU_COMMAND_SET_TYPE_SCSI= 0x0,
< at >< at > -110,10 +142,17 < at >< at > enum {
 UPIU_COMMAND_SET_TYPE_QUERY= 0x2,
 };
 
+/* UTP Transfer Request Command Offset */
+#define UPIU_COMMAND_TYPE_OFFSET28
+
+/* Offset of the response code in the UPIU header */
+#define UPIU_RSP_CODE_OFFSET8
+
 enum {
 MASK_SCSI_STATUS= 0xFF,
 MASK_TASK_RESPONSE= 0xFF00,
 MASK_RSP_UPIU_RESULT= 0xFFFF,
+MASK_QUERY_DATA_SEG_LEN= 0xFFFF,
 };
 
 /* Task management service response */
< at >< at > -138,26 +177,59 < at >< at > struct utp_upiu_header {
 
 /**
  * struct utp_upiu_cmd - Command UPIU structure
- * < at >header: UPIU header structure DW-0 to DW-2
  * < at >data_transfer_len: Data Transfer Length DW-3
  * < at >cdb: Command Descriptor Block CDB DW-4 to DW-7
  */
 struct utp_upiu_cmd {
-struct utp_upiu_header header;
 u32 exp_data_transfer_len;
 u8 cdb[MAX_CDB_SIZE];
 };
 
 /**
- * struct utp_upiu_rsp - Response UPIU structure
- * < at >header: UPIU header DW-0 to DW-2
+ * struct utp_upiu_query - upiu request buffer structure for
+ * query request.
+ * < at >opcode: command to perform B-0
+ * < at >idn: a value that indicates the particular type of data B-1
+ * < at >index: Index to further identify data B-2
+ * < at >selector: Index to further identify data B-3
+ * < at >reserved_osf: spec reserved field B-4,5
+ * < at >length: number of descriptor bytes to read/write B-6,7
+ * < at >value: Attribute value to be written DW-6
+ * < at >reserved: spec reserved DW-7,8
+ */
+struct utp_upiu_query {
+u8 opcode;
+u8 idn;
+u8 index;
+u8 selector;
+u16 reserved_osf;
+u16 length;
+u32 value;
+u32 reserved[2];
+};
+
+/**
+ * struct utp_upiu_req - general upiu request structure
+ * < at >header:UPIU header structure DW-0 to DW-2
+ * < at >sc: fields structure for scsi command
+ * < at >qr: fields structure for query request
+ */
+struct utp_upiu_req {
+struct utp_upiu_header header;
+union {
+struct utp_upiu_cmd sc;
+struct utp_upiu_query qr;
+};
+};
+
+/**
+ * struct utp_cmd_rsp - Response UPIU structure
  * < at >residual_transfer_count: Residual transfer count DW-3
  * < at >reserved: Reserved double words DW-4 to DW-7
  * < at >sense_data_len: Sense data length DW-8 U16
  * < at >sense_data: Sense data field DW-8 to DW-12
  */
-struct utp_upiu_rsp {
-struct utp_upiu_header header;
+struct utp_cmd_rsp {
 u32 residual_transfer_count;
 u32 reserved[4];
 u16 sense_data_len;
< at >< at > -165,6 +237,20 < at >< at > struct utp_upiu_rsp {
 };
 
 /**
+ * struct utp_upiu_rsp - general upiu response structure
+ * < at >header: UPIU header structure DW-0 to DW-2
+ * < at >sc: fields structure for scsi command
+ * < at >qr: fields structure for query request
+ */
+struct utp_upiu_rsp {
+struct utp_upiu_header header;
+union {
+struct utp_cmd_rsp sc;
+struct utp_upiu_query qr;
+};
+};
+
+/**
  * struct utp_upiu_task_req - Task request UPIU structure
  * < at >header - UPIU header structure DW0 to DW-2
  * < at >input_param1: Input parameter 1 DW-3
< at >< at > -194,4 +280,24 < at >< at > struct utp_upiu_task_rsp {
 u32 reserved[3];
 };
 
+/**
+ * struct ufs_query_req - parameters for building a query request
+ * < at >query_func: UPIU header query function
+ * < at >upiu_req: the query request data
+ */
+struct ufs_query_req {
+u8 query_func;
+struct utp_upiu_query upiu_req;
+};
+
+/**
+ * struct ufs_query_resp - UPIU QUERY
+ * < at >response: device response code
+ * < at >upiu_res: query response data
+ */
+struct ufs_query_res {
+u8 response;
+struct utp_upiu_query upiu_res;
+};
+
 #endif /* End of Header */
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index c32a478..4ddc8be 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -202,18 +202,13 < at >< at > static inline void ufshcd_free_hba_memory(struct ufs_hba *hba)
 }
 
 /**
- * ufshcd_is_valid_req_rsp - checks if controller TR response is valid
+ * ufshcd_get_req_rsp - returns the TR response
  * < at >ucd_rsp_ptr: pointer to response UPIU
- *
- * This function checks the response UPIU for valid transaction type in
- * response field
- * Returns 0 on success, non-zero on failure
  */
 static inline int
-ufshcd_is_valid_req_rsp(struct utp_upiu_rsp *ucd_rsp_ptr)
+ufshcd_get_req_rsp(struct utp_upiu_rsp *ucd_rsp_ptr)
 {
-return ((be32_to_cpu(ucd_rsp_ptr->header.dword_0) >> 24) ==
- UPIU_TRANSACTION_RESPONSE) ? 0 : DID_ERROR << 16;
+return be32_to_cpu(ucd_rsp_ptr->header.dword_0) >> 24;
 }
 
 /**
< at >< at > -316,14 +311,71 < at >< at > static inline void ufshcd_copy_sense_data(struct ufshcd_lrb *lrbp)
 {
 int len;
 if (lrbp->sense_buffer) {
-len = be16_to_cpu(lrbp->ucd_rsp_ptr->sense_data_len);
+len = be16_to_cpu(lrbp->ucd_rsp_ptr->sc.sense_data_len);
 memcpy(lrbp->sense_buffer,
-lrbp->ucd_rsp_ptr->sense_data,
+lrbp->ucd_rsp_ptr->sc.sense_data,
 min_t(int, len, SCSI_SENSE_BUFFERSIZE));
 }
 }
 
 /**
+ * ufshcd_query_to_cpu() - formats the received buffer in to the native cpu
+ * endian
+ * < at >response: upiu query response to convert
+ */
+static inline void ufshcd_query_to_cpu(struct utp_upiu_query *response)
+{
+response->length = be16_to_cpu(response->length);
+response->value = be32_to_cpu(response->value);
+}
+
+/**
+ * ufshcd_query_to_be() - formats the buffer before sending in to big endian
+ * < at >response: upiu query request to convert
+ */
+static inline void ufshcd_query_to_be(struct utp_upiu_query *request)
+{
+request->length = cpu_to_be16(request->length);
+request->value = cpu_to_be32(request->value);
+}
+
+/**
+ * ufshcd_copy_query_response() - Copy Query Response and descriptor
+ * < at >lrb - pointer to local reference block
+ * < at >query_res - pointer to the query result
+ */
+static
+void ufshcd_copy_query_response(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+struct ufs_query_res *query_res = hba->query.response;
+
+/* Get the UPIU response */
+if (query_res) {
+query_res->response = ufshcd_get_rsp_upiu_result(
+lrbp->ucd_rsp_ptr) >> UPIU_RSP_CODE_OFFSET;
+
+memcpy(&query_res->upiu_res, &lrbp->ucd_rsp_ptr->qr,
+QUERY_OSF_SIZE);
+ufshcd_query_to_cpu(&query_res->upiu_res);
+}
+
+/* Get the descriptor */
+if (hba->query.descriptor && lrbp->ucd_rsp_ptr->qr.opcode ==
+UPIU_QUERY_OPCODE_READ_DESC) {
+u8 *descp = (u8 *)&lrbp->ucd_rsp_ptr +
+GENERAL_UPIU_REQUEST_SIZE;
+u16 len;
+
+/* data segment length */
+len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2) &
+MASK_QUERY_DATA_SEG_LEN;
+
+memcpy(hba->query.descriptor, descp,
+min_t(u16, len, UPIU_HEADER_DATA_SEGMENT_MAX_SIZE));
+}
+}
+
+/**
  * ufshcd_hba_capabilities - Read controller capabilities
  * < at >hba: per adapter instance
  */
< at >< at > -423,76 +475,154 < at >< at > static void ufshcd_int_config(struct ufs_hba *hba, u32 option)
 }
 
 /**
- * ufshcd_compose_upiu - form UFS Protocol Information Unit(UPIU)
- * < at >lrb - pointer to local reference block
+ * ufshcd_prepare_req_desc - Fills the requests header
+ * descriptor according to request
+ * lrbp: pointer to local reference block
+ * upiu_flags: flags required in the header
  */
-static void ufshcd_compose_upiu(struct ufshcd_lrb *lrbp)
+static void ufshcd_prepare_req_desc(struct ufshcd_lrb *lrbp, u32 *upiu_flags)
 {
-struct utp_transfer_req_desc *req_desc;
-struct utp_upiu_cmd *ucd_cmd_ptr;
+struct utp_transfer_req_desc *req_desc = lrbp->utr_descriptor_ptr;
+enum dma_data_direction cmd_dir =
+lrbp->cmd->sc_data_direction;
 u32 data_direction;
-u32 upiu_flags;
+u32 dword_0;
+
+if (cmd_dir == DMA_FROM_DEVICE) {
+data_direction = UTP_DEVICE_TO_HOST;
+*upiu_flags = UPIU_CMD_FLAGS_READ;
+} else if (cmd_dir == DMA_TO_DEVICE) {
+data_direction = UTP_HOST_TO_DEVICE;
+*upiu_flags = UPIU_CMD_FLAGS_WRITE;
+} else {
+data_direction = UTP_NO_DATA_TRANSFER;
+*upiu_flags = UPIU_CMD_FLAGS_NONE;
+}
 
-ucd_cmd_ptr = lrbp->ucd_cmd_ptr;
-req_desc = lrbp->utr_descriptor_ptr;
+dword_0 = data_direction | (lrbp->command_type
+<< UPIU_COMMAND_TYPE_OFFSET);
 
-switch (lrbp->command_type) {
-case UTP_CMD_TYPE_SCSI:
-if (lrbp->cmd->sc_data_direction == DMA_FROM_DEVICE) {
-data_direction = UTP_DEVICE_TO_HOST;
-upiu_flags = UPIU_CMD_FLAGS_READ;
-} else if (lrbp->cmd->sc_data_direction == DMA_TO_DEVICE) {
-data_direction = UTP_HOST_TO_DEVICE;
-upiu_flags = UPIU_CMD_FLAGS_WRITE;
-} else {
-data_direction = UTP_NO_DATA_TRANSFER;
-upiu_flags = UPIU_CMD_FLAGS_NONE;
-}
+/* Transfer request descriptor header fields */
+req_desc->header.dword_0 = cpu_to_le32(dword_0);
 
-/* Transfer request descriptor header fields */
-req_desc->header.dword_0 =
-cpu_to_le32(data_direction | UTP_SCSI_COMMAND);
+/*
+ * assigning invalid value for command status. Controller
+ * updates OCS on command completion, with the command
+ * status
+ */
+req_desc->header.dword_2 =
+cpu_to_le32(OCS_INVALID_COMMAND_STATUS);
+}
 
-/*
- * assigning invalid value for command status. Controller
- * updates OCS on command completion, with the command
- * status
- */
-req_desc->header.dword_2 =
-cpu_to_le32(OCS_INVALID_COMMAND_STATUS);
+static inline bool ufshcd_is_query_req(struct ufshcd_lrb *lrbp)
+{
+return lrbp->cmd ? lrbp->cmd->cmnd[0] == UFS_QUERY_RESERVED_SCSI_CMD :
+false;
+}
 
-/* command descriptor fields */
-ucd_cmd_ptr->header.dword_0 =
-cpu_to_be32(UPIU_HEADER_DWORD(UPIU_TRANSACTION_COMMAND,
-      upiu_flags,
-      lrbp->lun,
-      lrbp->task_tag));
-ucd_cmd_ptr->header.dword_1 =
-cpu_to_be32(
-UPIU_HEADER_DWORD(UPIU_COMMAND_SET_TYPE_SCSI,
-  0,
-  0,
-  0));
-
-/* Total EHS length and Data segment length will be zero */
-ucd_cmd_ptr->header.dword_2 = 0;
-
-ucd_cmd_ptr->exp_data_transfer_len =
-cpu_to_be32(lrbp->cmd->sdb.length);
-
-memcpy(ucd_cmd_ptr->cdb,
-       lrbp->cmd->cmnd,
-       (min_t(unsigned short,
-      lrbp->cmd->cmd_len,
-      MAX_CDB_SIZE)));
-break;
+/**
+ * ufshcd_prepare_utp_scsi_cmd_upiu() - fills the utp_transfer_req_desc,
+ * for scsi commands
+ * < at >lrbp - local reference block pointer
+ * < at >upiu_flags - flags
+ */
+static
+void ufshcd_prepare_utp_scsi_cmd_upiu(struct ufshcd_lrb *lrbp, u32 upiu_flags)
+{
+struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
+
+/* command descriptor fields */
+ucd_req_ptr->header.dword_0 = UPIU_HEADER_DWORD(
+UPIU_TRANSACTION_COMMAND, upiu_flags,
+lrbp->lun, lrbp->task_tag);
+ucd_req_ptr->header.dword_1 = UPIU_HEADER_DWORD(
+UPIU_COMMAND_SET_TYPE_SCSI, 0, 0, 0);
+
+/* Total EHS length and Data segment length will be zero */
+ucd_req_ptr->header.dword_2 = 0;
+
+ucd_req_ptr->sc.exp_data_transfer_len =
+cpu_to_be32(lrbp->cmd->sdb.length);
+
+memcpy(ucd_req_ptr->sc.cdb, lrbp->cmd->cmnd,
+(min_t(unsigned short, lrbp->cmd->cmd_len, MAX_CDB_SIZE)));
+}
+
+/**
+ * ufshcd_prepare_utp_query_req_upiu() - fills the utp_transfer_req_desc,
+ * for query requsts
+ * < at >hba: UFS hba
+ * < at >lrbp: local reference block pointer
+ * < at >upiu_flags: flags
+ */
+static void ufshcd_prepare_utp_query_req_upiu(struct ufs_hba *hba,
+struct ufshcd_lrb *lrbp,
+u32 upiu_flags)
+{
+struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
+u16 len = hba->query.request->upiu_req.length;
+u8 *descp = (u8 *)lrbp->ucd_req_ptr + GENERAL_UPIU_REQUEST_SIZE;
+
+/* Query request header */
+ucd_req_ptr->header.dword_0 = UPIU_HEADER_DWORD(
+UPIU_TRANSACTION_QUERY_REQ, upiu_flags,
+lrbp->lun, lrbp->task_tag);
+ucd_req_ptr->header.dword_1 = UPIU_HEADER_DWORD(
+0, hba->query.request->query_func, 0, 0);
+
+/* Data segment length */
+ucd_req_ptr->header.dword_2 = UPIU_HEADER_DWORD(
+0, 0, len >> 8, (u8)len);
+
+/* Copy the Query Request buffer as is */
+memcpy(&lrbp->ucd_req_ptr->qr, &hba->query.request->upiu_req,
+QUERY_OSF_SIZE);
+ufshcd_query_to_be(&lrbp->ucd_req_ptr->qr);
+
+/* Copy the Descriptor */
+if (hba->query.descriptor != NULL && len > 0 &&
+(hba->query.request->upiu_req.opcode ==
+UPIU_QUERY_OPCODE_WRITE_DESC)) {
+memcpy(descp, hba->query.descriptor,
+min_t(u16, len, UPIU_HEADER_DATA_SEGMENT_MAX_SIZE));
+}
+
+}
+
+/**
+ * ufshcd_compose_upiu - form UFS Protocol Information Unit(UPIU)
+ * < at >hba - UFS hba
+ * < at >lrb - pointer to local reference block
+ */
+static int ufshcd_compose_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+u32 upiu_flags;
+int ret = 0;
+
+switch (lrbp->command_type) {
+case UTP_CMD_TYPE_SCSI:
 case UTP_CMD_TYPE_DEV_MANAGE:
-/* For query function implementation */
+ufshcd_prepare_req_desc(lrbp, &upiu_flags);
+if (lrbp->command_type == UTP_CMD_TYPE_SCSI)
+ufshcd_prepare_utp_scsi_cmd_upiu(lrbp, upiu_flags);
+else
+ufshcd_prepare_utp_query_req_upiu(hba, lrbp,
+upiu_flags);
 break;
 case UTP_CMD_TYPE_UFS:
 /* For UFS native command implementation */
+dev_err(hba->dev, "%s: UFS native command are not supported\n",
+__func__);
+ret = -ENOTSUPP;
+break;
+default:
+ret = -ENOTSUPP;
+dev_err(hba->dev, "%s: unknown command type: 0x%x\n",
+__func__, lrbp->command_type);
 break;
 } /* end of switch */
+
+return ret;
 }
 
 /**
< at >< at > -527,10 +657,13 < at >< at > static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 lrbp->task_tag = tag;
 lrbp->lun = cmd->device->lun;
 
-lrbp->command_type = UTP_CMD_TYPE_SCSI;
+if (ufshcd_is_query_req(lrbp))
+lrbp->command_type = UTP_CMD_TYPE_DEV_MANAGE;
+else
+lrbp->command_type = UTP_CMD_TYPE_SCSI;
 
 /* form UPIU before issuing the command */
-ufshcd_compose_upiu(lrbp);
+ufshcd_compose_upiu(hba, lrbp);
 err = ufshcd_map_sg(lrbp);
 if (err)
 goto out;
< at >< at > -677,8 +810,8 < at >< at > static void ufshcd_host_memory_configure(struct ufs_hba *hba)
 cpu_to_le16(ALIGNED_UPIU_SIZE);
 
 hba->lrb[i].utr_descriptor_ptr = (utrdlp + i);
-hba->lrb[i].ucd_cmd_ptr =
-(struct utp_upiu_cmd *)(cmd_descp + i);
+hba->lrb[i].ucd_req_ptr =
+(struct utp_upiu_req *)(cmd_descp + i);
 hba->lrb[i].ucd_rsp_ptr =
 (struct utp_upiu_rsp *)cmd_descp[i].response_upiu;
 hba->lrb[i].ucd_prdt_ptr =
< at >< at > -1101,7 +1234,9 < at >< at > ufshcd_scsi_cmd_status(struct ufshcd_lrb *lrbp, int scsi_status)
  * < at >hba: per adapter instance
  * < at >lrb: pointer to local reference block of completed command
  *
- * Returns result of the command to notify SCSI midlayer
+ * Returns result of the command to notify SCSI midlayer. In
+ * case of query request specific result, returns DID_OK, and
+ * the error will be handled by the dispatcher.
  */
 static inline int
 ufshcd_transfer_rsp_status(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
< at >< at > -1115,27 +1250,46 < at >< at > ufshcd_transfer_rsp_status(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
 
 switch (ocs) {
 case OCS_SUCCESS:
-
 /* check if the returned transfer response is valid */
-result = ufshcd_is_valid_req_rsp(lrbp->ucd_rsp_ptr);
-if (result) {
+result = ufshcd_get_req_rsp(lrbp->ucd_rsp_ptr);
+
+switch (result) {
+case UPIU_TRANSACTION_RESPONSE:
+/*
+ * get the response UPIU result to extract
+ * the SCSI command status
+ */
+result = ufshcd_get_rsp_upiu_result(lrbp->ucd_rsp_ptr);
+
+/*
+ * get the result based on SCSI status response
+ * to notify the SCSI midlayer of the command status
+ */
+scsi_status = result & MASK_SCSI_STATUS;
+result = ufshcd_scsi_cmd_status(lrbp, scsi_status);
+break;
+case UPIU_TRANSACTION_QUERY_RSP:
+/*
+ *  Return result = ok, since SCSI layer wouldn't
+ *  know how to handle errors from query requests.
+ *  The result is saved with the response so that
+ *  the ufs_core layer will handle it.
+ */
+result = DID_OK << 16;
+ufshcd_copy_query_response(hba, lrbp);
+break;
+case UPIU_TRANSACTION_REJECT_UPIU:
+/* TODO: handle Reject UPIU Response */
+result = DID_ERROR << 16;
 dev_err(hba->dev,
-"Invalid response = %x\n", result);
+"Reject UPIU not fully implemented\n");
 break;
+default:
+result = DID_ERROR << 16;
+dev_err(hba->dev,
+"Unexpected request response code = %x\n",
+result);
 }
-
-/*
- * get the response UPIU result to extract
- * the SCSI command status
- */
-result = ufshcd_get_rsp_upiu_result(lrbp->ucd_rsp_ptr);
-
-/*
- * get the result based on SCSI status response
- * to notify the SCSI midlayer of the command status
- */
-scsi_status = result & MASK_SCSI_STATUS;
-result = ufshcd_scsi_cmd_status(lrbp, scsi_status);
 break;
 case OCS_ABORTED:
 result |= DID_ABORT << 16;
< at >< at > -1364,10 +1518,10 < at >< at > ufshcd_issue_tm_cmd(struct ufs_hba *hba,
 task_req_upiup =
 (struct utp_upiu_task_req *) task_req_descp->task_req_upiu;
 task_req_upiup->header.dword_0 =
-cpu_to_be32(UPIU_HEADER_DWORD(UPIU_TRANSACTION_TASK_REQ, 0,
-      lrbp->lun, lrbp->task_tag));
+UPIU_HEADER_DWORD(UPIU_TRANSACTION_TASK_REQ, 0,
+      lrbp->lun, lrbp->task_tag);
 task_req_upiup->header.dword_1 =
-cpu_to_be32(UPIU_HEADER_DWORD(0, tm_function, 0, 0));
+UPIU_HEADER_DWORD(0, tm_function, 0, 0);
 
 task_req_upiup->input_param1 = lrbp->lun;
 task_req_upiup->input_param1 =
< at >< at > -1670,6 +1824,9 < at >< at > int ufshcd_init(struct device *dev, struct ufs_hba **hba_handle,
 INIT_WORK(&hba->uic_workq, ufshcd_uic_cc_handler);
 INIT_WORK(&hba->feh_workq, ufshcd_fatal_err_handler);
 
+/* Initialize mutex for query requests */
+mutex_init(&hba->query.lock_ufs_query);
+
 /* IRQ registration */
 err = request_irq(irq, ufshcd_intr, IRQF_SHARED, UFSHCD, hba);
 if (err) {
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 6b99a42..336980b 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
< at >< at > -60,6 +60,7 < at >< at >
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_eh.h>
+#include <scsi/scsi_device.h>
 
 #include "ufs.h"
 #include "ufshci.h"
< at >< at > -88,7 +89,7 < at >< at > struct uic_command {
 /**
  * struct ufshcd_lrb - local reference block
  * < at >utr_descriptor_ptr: UTRD address of the command
- * < at >ucd_cmd_ptr: UCD address of the command
+ * < at >ucd_req_ptr: UCD address of the command
  * < at >ucd_rsp_ptr: Response UPIU address for this command
  * < at >ucd_prdt_ptr: PRDT address of the command
  * < at >cmd: pointer to SCSI command
< at >< at > -101,7 +102,7 < at >< at > struct uic_command {
  */
 struct ufshcd_lrb {
 struct utp_transfer_req_desc *utr_descriptor_ptr;
-struct utp_upiu_cmd *ucd_cmd_ptr;
+struct utp_upiu_req *ucd_req_ptr;
 struct utp_upiu_rsp *ucd_rsp_ptr;
 struct ufshcd_sg_entry *ucd_prdt_ptr;
 
< at >< at > -115,6 +116,19 < at >< at > struct ufshcd_lrb {
 unsigned int lun;
 };
 
+/**
+ * struct ufs_query - keeps the query request information
+ * < at >request: request upiu and function
+ * < at >descriptor: buffer for sending/receiving descriptor
+ * < at >response: response upiu and response
+ * < at >mutex: lock to allow one query at a time
+ */
+struct ufs_query {
+struct ufs_query_req *request;
+u8 *descriptor;
+struct ufs_query_res *response;
+struct mutex lock_ufs_query;
+};
 
 /**
  * struct ufs_hba - per adapter private structure
< at >< at > -143,6 +157,7 < at >< at > struct ufshcd_lrb {
  * < at >uic_workq: Work queue for UIC completion handling
  * < at >feh_workq: Work queue for fatal controller error handling
  * < at >errors: HBA errors
+ * < at >query: query request information
  */
 struct ufs_hba {
 void __iomem *mmio_base;
< at >< at > -184,6 +199,9 < at >< at > struct ufs_hba {
 
 /* HBA Errors */
 u32 errors;
+
+/* Query Request */
+struct ufs_query query;
 };
 
 int ufshcd_init(struct device *, struct ufs_hba ** , void __iomem * ,
diff --git a/drivers/scsi/ufs/ufshci.h b/drivers/scsi/ufs/ufshci.h
index 0c16484..4a86247 100644
--- a/drivers/scsi/ufs/ufshci.h
+++ b/drivers/scsi/ufs/ufshci.h
< at >< at > -39,7 +39,7 < at >< at >
 enum {
 TASK_REQ_UPIU_SIZE_DWORDS= 8,
 TASK_RSP_UPIU_SIZE_DWORDS= 8,
-ALIGNED_UPIU_SIZE= 128,
+ALIGNED_UPIU_SIZE= 512,
 };
 
 /* UFSHCI Registers */

[PATCH 0/8] scsi: ufs: query support and other fixes

Santosh Y — 2013-05-19T08:21:35

Hi James,

Please merge the following patches to 'misc' branch.

Thanks,
Santosh

Dolev Raviv (3):
  scsi: ufs: add support for query requests
  scsi: ufs: Add support for sending NOP OUT UPIU
  scsi: ufs: Set fDeviceInit flag to initiate device initialization

Seungwon Jeon (4):
  scsi: ufs: wrap the i/o access operations
  scsi: ufs: amend interrupt configuration
  scsi: ufs: remove version check before IS reg clear
  scsi: ufs: rework link start-up process

Sujit Reddy Thumma (1):
  scsi: ufs: Fix the response UPIU length setting

 drivers/scsi/ufs/ufs.h    |  132 ++++-
 drivers/scsi/ufs/ufshcd.c | 1172 +++++++++++++++++++++++++++++++++++----------
 drivers/scsi/ufs/ufshcd.h |   47 +-
 drivers/scsi/ufs/ufshci.h |    7 +-
 4 files changed, 1085 insertions(+), 273 deletions(-)

(unknown)

Penki šimtai tūkstančių dolerių buvo suteikta už savo elektroninio pašto ID. — 2013-05-18T20:59:08

--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html