qspi controller: Normal, quad and memory mapped read support

From: Matt Porter <[email protected]>

Adds a SPI master driver for the TI QSPI peripheral.

Signed-off-by Matt Porter <[email protected]>

Signed-off-by Sourav Poddar <[email protected]>

---
 drivers/spi/Makefile  |    1 +
 drivers/spi/ti_qspi.c |  262 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 263 insertions(+), 0 deletions(-)
 create mode 100644 drivers/spi/ti_qspi.c

Dear Sourav Poddar,

Quoted 11 lines · In message<[email protected]> you wrote:

From: Matt Porter<[email protected]>

Adds a SPI master driver for the TI QSPI peripheral.

Signed-off-by Matt Porter<[email protected]>

Signed-off-by Sourav Poddar<[email protected]>

---
  drivers/spi/Makefile  |    1 +
  drivers/spi/ti_qspi.c |  262 +++++++++++++++++++++++++++++++++++++++++++++++++
  2 files changed, 263 insertions(+), 0 deletions(-)

create mode 100644 drivers/spi/ti_qspi.c

when submitting a new version of a patch or patch series, it is mandatory to supply a chancgelog that desribes what you changed compareds to previous versions of the patch. This is necessary so that reviewers can see which of their hints were taken into account, etc.

This is missing in all you patches of this series.

Also, please run all your patches through checkpatch _before_ submitting. For this patch, I get some "line over 80 characters" wanings that need to be fixed. This should not happen. Please be more careful next time.

Best regards,

Wolfgang Denk

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
  drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
  1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash *flash, u32 offset,
  		else
  			read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+		unsigned long page_addr, byte_addr, page_size;
+		size_t chunk_len, actual;
+		int ret = 0;
+
+		page_size = flash->page_size;
+		page_addr = offset / page_size;
+		byte_addr = offset % page_size;
+
+		for (actual = 0; actual<  read_len; actual += chunk_len) {
+			chunk_len = min(read_len - actual, page_size - byte_addr);
+
+			cmd[1] = page_addr>>  8;
+			cmd[2] = page_addr;
+			cmd[3] = byte_addr;
+
+			ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+					data + actual, chunk_len);
+			if (ret<  0) {
+				debug("SF: read failed");
+				break;
+			}
+
+			byte_addr += chunk_len;
+			if (byte_addr == page_size) {
+				page_addr++;
+				byte_addr = 0;
+			}
+		}
+#else
  		spi_flash_addr(offset, cmd);
 
  		ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c int spi_flash_cmd_read_fast(struct spi_flash *flash, u32 offset, · line 347

Quoted 9 lines

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash *flash, u32 offset,
 			debug("SF: read failed\n");
 			break;
 		}
-
+#endif
 		offset += read_len;
 		len -= read_len;
 		data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.

Hi,

Quoted 12 lines · Sourav Poddar

drivers/mtd/spi/spi_flash.c int spi_flash_cmd_read_fast(struct spi_flash *flash, u32 offset, · line 347

Quoted 9 lines

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash *flash, u32 offset,
  			debug("SF: read failed\n");
  			break;
  		}
-
+#endif
  		offset += read_len;
  		len -= read_len;
  		data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

Quoted 2 lines

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.

constraint is 4096 *words*. If you're using anything other than 8-bits per word, your statement doesn't make sense.

+ jagan,

Quoted 61 lines · Sourav Poddar

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
  drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
  1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash 
 *flash, u32 offset,
          else
              read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<  read_len; actual += chunk_len) {
+            chunk_len = min(read_len - actual, page_size - byte_addr);
+
+            cmd[1] = page_addr>>  8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<  0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
          spi_flash_addr(offset, cmd);
 

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash 
 *flash, u32 offset,
              debug("SF: read failed\n");
              break;
          }
-
+#endif
          offset += read_len;
          len -= read_len;

Quoted 1 line

          data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read api in mtd framework.
This requires me to send the read command every time in range upto 4096 bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config as done above.

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Hi Jagan,

Quoted 78 lines · Sourav Poddar

+ jagan,

Quoted 61 lines · Sourav Poddar

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
  drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
  1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash 
 *flash, u32 offset,
          else
              read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<  read_len; actual += chunk_len) {
+            chunk_len = min(read_len - actual, page_size - byte_addr);
+
+            cmd[1] = page_addr>>  8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<  0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
          spi_flash_addr(offset, cmd);
 

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash 
 *flash, u32 offset,
              debug("SF: read failed\n");
              break;
          }
-
+#endif
          offset += read_len;
          len -= read_len;

Quoted 1 line

          data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read api in mtd framework.
This requires me to send the read command every time in range upto 4096 bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config as done above.

Quoted 5 lines

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Hi Jagan,

Quoted 84 lines · Sourav Poddar

Hi Jagan,

Quoted 81 lines · Sourav Poddar

+ jagan,

Quoted 62 lines · Sourav Poddar

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
  drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
  1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
          else
              read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<  read_len; actual += chunk_len) {
+            chunk_len = min(read_len - actual, page_size - byte_addr);
+
+            cmd[1] = page_addr>>  8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<  0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
          spi_flash_addr(offset, cmd);
 

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash *flash,
 u32 offset,
              debug("SF: read failed\n");
              break;
          }
-
+#endif
          offset += read_len;
          len -= read_len;

Quoted 1 line

          data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read api in mtd framework.
This requires me to send the read command every time in range upto 4096 bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config as done above.

Quoted 7 lines

Quoted 5 lines

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Any suggestions on the patch?

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Hi,

Quoted 90 lines · Sourav Poddar

Hi Jagan,

Quoted 87 lines · Sourav Poddar

Hi Jagan,

Quoted 75 lines · Sourav Poddar

+ jagan,

Quoted 61 lines · Sourav Poddar

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
   drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
   1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
           else
               read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<   read_len; actual += chunk_len) {
+            chunk_len = min(read_len - actual, page_size - byte_addr);
+
+            cmd[1] = page_addr>>   8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<   0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
           spi_flash_addr(offset, cmd);
 

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash *flash,
 u32 offset,
               debug("SF: read failed\n");
               break;
           }
-
+#endif
           offset += read_len;
           len -= read_len;

Quoted 1 line

           data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read api in mtd framework.
This requires me to send the read command every time in range upto 4096 bytes only.

Quoted 8 lines

To overcome this, I have updated the mtd read based on TI_QSPI config as done above.

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Quoted 6 lines

Any suggestions on the patch?

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Does linux support this ti_qspi, please point the defconfig if you have.

--
Thanks,
Jagan.

Hi Jagan,

Quoted 106 lines · Jagan Teki

Hi,

Quoted 101 lines · Sourav Poddar

Hi Jagan,

Quoted 88 lines · Sourav Poddar

Hi Jagan,

Quoted 85 lines · Sourav Poddar

+ jagan,

Quoted 63 lines · Sourav Poddar

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
   drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
   1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
           else
               read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<   read_len; actual += chunk_len) {
+            chunk_len = min(read_len - actual, page_size -
 byte_addr);
+
+            cmd[1] = page_addr>>   8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<   0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
           spi_flash_addr(offset, cmd);

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash,
 u32 offset,
               debug("SF: read failed\n");
               break;
           }
-
+#endif
           offset += read_len;

Quoted 2 lines

           len -= read_len;
           data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read
api in mtd framework.
This requires me to send the read command every time in range upto 4096 bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config as
done above.

Quoted 7 lines

Quoted 5 lines

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Any suggestions on the patch?

Quoted 8 lines

Quoted 4 lines

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Thanks for the response.

This is the link to uboot patches which I submitted to uboot mailing list.

http://patchwork.ozlabs.org/patch/260989/
http://patchwork.ozlabs.org/patch/260990/
http://patchwork.ozlabs.org/patch/260991/
http://patchwork.ozlabs.org/patch/260992/
http://patchwork.ozlabs.org/patch/260994/
http://patchwork.ozlabs.org/patch/260993/
http://patchwork.ozlabs.org/patch/260996/
http://patchwork.ozlabs.org/patch/260995/

Above are the links to uboot patches containing all def configs and uboot ti qspi driver.

As communicated earlier, there is a limitation in our qspi controller driver, wherein after every
4096 bytes CS gets de asserted. So, I had to modify the above read framework to do a page read.
Need better way to handle this limitation, so that the above patch series can get upstreamed.

Quoted 2 lines

Does linux support this ti_qspi, please point the defconfig if you have.

Patches for linux is under review and still not mainlined.
https://patchwork.kernel.org/patch/2838342/

Quoted 133 lines · Sourav Poddar

Hi Jagan,

Quoted 98 lines · Jagan Teki

Hi,

Quoted 94 lines · Sourav Poddar

Hi Jagan,

Quoted 91 lines · Sourav Poddar

Hi Jagan,

Quoted 78 lines · Sourav Poddar

+ jagan,

Quoted 62 lines · Sourav Poddar

Reading using the already supported read command is causing regression after 4k bytes, as a result doing a page by page read. Its happening, because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
    drivers/mtd/spi/spi_flash.c |   32 +++++++++++++++++++++++++++++++-
    1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
            else
                read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<    read_len; actual += chunk_len) {
+            chunk_len = min(read_len - actual, page_size -
 byte_addr);
+
+            cmd[1] = page_addr>>    8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<    0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
            spi_flash_addr(offset, cmd);

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash,
 u32 offset,
                debug("SF: read failed\n");
                break;
            }
-
+#endif
            offset += read_len;

Quoted 2 lines

            len -= read_len;
            data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read
api in mtd framework.
This requires me to send the read command every time in range upto 4096 bytes only.

Quoted 9 lines

To overcome this, I have updated the mtd read based on TI_QSPI config as
done above.

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Quoted 9 lines

Quoted 6 lines

Any suggestions on the patch?

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Thanks for the response.

This is the link to uboot patches which I submitted to uboot mailing list.

http://patchwork.ozlabs.org/patch/260989/
http://patchwork.ozlabs.org/patch/260990/
http://patchwork.ozlabs.org/patch/260991/
http://patchwork.ozlabs.org/patch/260992/
http://patchwork.ozlabs.org/patch/260994/
http://patchwork.ozlabs.org/patch/260993/
http://patchwork.ozlabs.org/patch/260996/
http://patchwork.ozlabs.org/patch/260995/

Above are the links to uboot patches containing all def configs and uboot ti qspi driver.

As communicated earlier, there is a limitation in our qspi controller driver, wherein after every
4096 bytes CS gets de asserted. So, I had to modify the above read framework to do a page read.
Need better way to handle this limitation, so that the above patch series can get upstreamed.

Quoted 4 lines

Quoted 2 lines

Does linux support this ti_qspi, please point the defconfig if you have.

Patches for linux is under review and still not mainlined.
https://patchwork.kernel.org/patch/2838342/

Thanks, please give me some time I will look at these and let u know early next week.

--
Thanks,
Jagan.

Quoted 155 lines · Jagan Teki

Quoted 152 lines · Sourav Poddar

Hi Jagan,

Quoted 112 lines · Jagan Teki

Hi,

Quoted 107 lines · Sourav Poddar

Hi Jagan,

Quoted 94 lines · Sourav Poddar

Hi Jagan,

Quoted 91 lines · Sourav Poddar

+ jagan,

Quoted 68 lines · Sourav Poddar

Reading using the already supported read command is causing regression
after 4k bytes, as a result doing a page by page read. Its happening,
because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
    drivers/mtd/spi/spi_flash.c |   32
+++++++++++++++++++++++++++++++-
    1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
            else
                read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<    read_len; actual += chunk_len)
 {
+            chunk_len = min(read_len - actual, page_size -
 byte_addr);
+
+            cmd[1] = page_addr>>    8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<    0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else

spi_flash_addr(offset, cmd);

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash,
 u32 offset,
                debug("SF: read failed\n");
                break;
            }
-
+#endif
            offset += read_len;

Quoted 2 lines

            len -= read_len;
            data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read
api in mtd framework.
This requires me to send the read command every time in range upto 4096
bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config as
done above.

Quoted 7 lines

Quoted 5 lines

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Any suggestions on the patch?

Quoted 8 lines

Quoted 4 lines

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Thanks for the response.

This is the link to uboot patches which I submitted to uboot mailing list.

http://patchwork.ozlabs.org/patch/260989/
http://patchwork.ozlabs.org/patch/260990/
http://patchwork.ozlabs.org/patch/260991/
http://patchwork.ozlabs.org/patch/260992/
http://patchwork.ozlabs.org/patch/260994/
http://patchwork.ozlabs.org/patch/260993/
http://patchwork.ozlabs.org/patch/260996/
http://patchwork.ozlabs.org/patch/260995/

Above are the links to uboot patches containing all def configs and uboot ti
qspi driver.

As communicated earlier, there is a limitation in our qspi controller driver, wherein after every
4096 bytes CS gets de asserted. So, I had to modify the above read framework
to do a page read.
Need better way to handle this limitation, so that the above patch series can get upstreamed.

Quoted 2 lines

Does linux support this ti_qspi, please point the defconfig if you have.

Quoted 6 lines

Quoted 2 lines

Patches for linux is under review and still not mainlined.
https://patchwork.kernel.org/patch/2838342/

Thanks, please give me some time I will look at these and let u know early next week.

Thanks!!

Quoted 147 lines · Sourav Poddar

Quoted 146 lines · Jagan Teki

Quoted 144 lines · Sourav Poddar

Hi Jagan,

Quoted 104 lines · Jagan Teki

Hi,

Quoted 100 lines · Sourav Poddar

Hi Jagan,

Quoted 97 lines · Sourav Poddar

Hi Jagan,

Quoted 84 lines · Sourav Poddar

+ jagan,

Quoted 67 lines · Sourav Poddar

Reading using the already supported read command is causing regression
after 4k bytes, as a result doing a page by page read. Its happening,
because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
     drivers/mtd/spi/spi_flash.c |   32
+++++++++++++++++++++++++++++++-
     1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +30 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
             else
                 read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<     read_len; actual += chunk_len)
 {
+            chunk_len = min(read_len - actual, page_size -
 byte_addr);
+
+            cmd[1] = page_addr>>     8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<     0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else

spi_flash_addr(offset, cmd);

ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

drivers/mtd/spi/spi_flash.c +1 -1

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash,
 u32 offset,
                 debug("SF: read failed\n");
                 break;
             }
-
+#endif
             offset += read_len;

Quoted 2 lines

             len -= read_len;
             data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted automatically.
As a result of this bottleneck, I am not able to use the current use read
api in mtd framework.
This requires me to send the read command every time in range upto 4096
bytes only.

Quoted 9 lines

To overcome this, I have updated the mtd read based on TI_QSPI config as
done above.

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Quoted 9 lines

Quoted 6 lines

Any suggestions on the patch?

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Thanks for the response.

This is the link to uboot patches which I submitted to uboot mailing list.

http://patchwork.ozlabs.org/patch/260989/
http://patchwork.ozlabs.org/patch/260990/
http://patchwork.ozlabs.org/patch/260991/
http://patchwork.ozlabs.org/patch/260992/
http://patchwork.ozlabs.org/patch/260994/
http://patchwork.ozlabs.org/patch/260993/
http://patchwork.ozlabs.org/patch/260996/
http://patchwork.ozlabs.org/patch/260995/

Above are the links to uboot patches containing all def configs and uboot ti
qspi driver.

As communicated earlier, there is a limitation in our qspi controller driver, wherein after every
4096 bytes CS gets de asserted. So, I had to modify the above read framework
to do a page read.
Need better way to handle this limitation, so that the above patch series can get upstreamed.

Quoted 2 lines

Does linux support this ti_qspi, please point the defconfig if you have.

Quoted 6 lines

Quoted 5 lines

Quoted 2 lines

Patches for linux is under review and still not mainlined.
https://patchwork.kernel.org/patch/2838342/

Thanks, please give me some time I will look at these and let u know early next week.

Thanks!!

You still see this issue.

Quoted 170 lines · Jagan Teki

Quoted 167 lines · Sourav Poddar

Quoted 165 lines · Jagan Teki

Quoted 161 lines · Sourav Poddar

Hi Jagan,

Quoted 116 lines · Jagan Teki

Hi,

Quoted 111 lines · Sourav Poddar

Hi Jagan,

Quoted 98 lines · Sourav Poddar

Hi Jagan,

Quoted 95 lines · Sourav Poddar

+ jagan,

Quoted 69 lines · Sourav Poddar

Reading using the already supported read command is causing regression
after 4k bytes, as a result doing a page by page read. Its happening,
because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
     drivers/mtd/spi/spi_flash.c |   32
+++++++++++++++++++++++++++++++-
     1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +11 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
             else
                 read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<     read_len; actual +=
 chunk_len)
 {
+            chunk_len = min(read_len - actual, page_size -

byte_addr);

drivers/mtd/spi/spi_flash.c +20 -1

+
+            cmd[1] = page_addr>>     8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<     0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
             spi_flash_addr(offset, cmd);
 
             ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash,
 u32 offset,
                 debug("SF: read failed\n");
                 break;
             }
-
+#endif
             offset += read_len;

Quoted 2 lines

             len -= read_len;
             data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted
automatically.
As a result of this bottleneck, I am not able to use the current use
read
api in mtd framework.
This requires me to send the read command every time in range upto 4096
bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config
as
done above.

Quoted 7 lines

Quoted 5 lines

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Any suggestions on the patch?

Quoted 8 lines

Quoted 4 lines

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Thanks for the response.

This is the link to uboot patches which I submitted to uboot mailing list.

http://patchwork.ozlabs.org/patch/260989/
http://patchwork.ozlabs.org/patch/260990/
http://patchwork.ozlabs.org/patch/260991/
http://patchwork.ozlabs.org/patch/260992/
http://patchwork.ozlabs.org/patch/260994/
http://patchwork.ozlabs.org/patch/260993/
http://patchwork.ozlabs.org/patch/260996/
http://patchwork.ozlabs.org/patch/260995/

Above are the links to uboot patches containing all def configs and uboot
ti
qspi driver.

As communicated earlier, there is a limitation in our qspi controller driver, wherein after every
4096 bytes CS gets de asserted. So, I had to modify the above read framework
to do a page read.
Need better way to handle this limitation, so that the above patch series
can get upstreamed.

Quoted 3 lines

Does linux support this ti_qspi, please point the defconfig if you have.

Patches for linux is under review and still not mainlined.
https://patchwork.kernel.org/patch/2838342/

Quoted 7 lines

Quoted 4 lines

Quoted 3 lines

Thanks, please give me some time I will look at these and let u know early next week.

Thanks!!

You still see this issue.

Please ignore this mail thread. This was due to some ip limitation.

Quoted 159 lines · Sourav Poddar

Quoted 158 lines · Jagan Teki

Quoted 156 lines · Sourav Poddar

Quoted 155 lines · Jagan Teki

Quoted 153 lines · Sourav Poddar

Hi Jagan,

Quoted 108 lines · Jagan Teki

Hi,

Quoted 104 lines · Sourav Poddar

Hi Jagan,

Quoted 101 lines · Sourav Poddar

Hi Jagan,

Quoted 92 lines · Sourav Poddar

+ jagan,

Quoted 68 lines · Sourav Poddar

Reading using the already supported read command is causing regression
after 4k bytes, as a result doing a page by page read. Its happening,
because
ti qpsi controller CS will get de asserted after 4096 bytes.

Signed-off-by Sourav Poddar<[email protected]>

---
      drivers/mtd/spi/spi_flash.c |   32
+++++++++++++++++++++++++++++++-
      1 files changed, 31 insertions(+), 1 deletions(-)

drivers/mtd/spi/spi_flash.c +11 -0

index 6a6fe37..5f8db7b 100644
@@ -303,6 +303,36 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash, u32 offset,
              else
                  read_len = remain_len;
 
+#ifdef CONFIG_TI_QSPI
+        unsigned long page_addr, byte_addr, page_size;
+        size_t chunk_len, actual;
+        int ret = 0;
+
+        page_size = flash->page_size;
+        page_addr = offset / page_size;
+        byte_addr = offset % page_size;
+
+        for (actual = 0; actual<      read_len; actual +=
 chunk_len)
 {
+            chunk_len = min(read_len - actual, page_size -

byte_addr);

drivers/mtd/spi/spi_flash.c +20 -1

+
+            cmd[1] = page_addr>>      8;
+            cmd[2] = page_addr;
+            cmd[3] = byte_addr;
+
+            ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
+                    data + actual, chunk_len);
+            if (ret<      0) {
+                debug("SF: read failed");
+                break;
+            }
+
+            byte_addr += chunk_len;
+            if (byte_addr == page_size) {
+                page_addr++;
+                byte_addr = 0;
+            }
+        }
+#else
              spi_flash_addr(offset, cmd);
 
              ret = spi_flash_read_common(flash, cmd, sizeof(cmd),

@@ -311,7 +341,7 @@ int spi_flash_cmd_read_fast(struct spi_flash
 *flash,
 u32 offset,
                  debug("SF: read failed\n");
                  break;
              }
-
+#endif
              offset += read_len;

Quoted 2 lines

              len -= read_len;
              data += read_len;

Elaborating a bit more on this,
There is a constrain on our hardware, which goes like this..

As soon as the words transfered is 4096 bytes, the CS gets deasserted
automatically.
As a result of this bottleneck, I am not able to use the current use
read
api in mtd framework.
This requires me to send the read command every time in range upto 4096
bytes only.

To overcome this, I have updated the mtd read based on TI_QSPI config
as
done above.

Quoted 5 lines

[Jagan]:
Do you have any suggestion of dealing this in a better way? I don't see a way to get around this apart from updating mtd read depending on TI_QSPI config.

Any inputs on this?

Quoted 9 lines

Quoted 6 lines

Any suggestions on the patch?

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Yes, this part is pretty much working as with other s25fl. Can you point me the respective controller driver for this.

Thanks for the response.

This is the link to uboot patches which I submitted to uboot mailing list.

http://patchwork.ozlabs.org/patch/260989/
http://patchwork.ozlabs.org/patch/260990/
http://patchwork.ozlabs.org/patch/260991/
http://patchwork.ozlabs.org/patch/260992/
http://patchwork.ozlabs.org/patch/260994/
http://patchwork.ozlabs.org/patch/260993/
http://patchwork.ozlabs.org/patch/260996/
http://patchwork.ozlabs.org/patch/260995/

Above are the links to uboot patches containing all def configs and uboot
ti
qspi driver.

As communicated earlier, there is a limitation in our qspi controller driver, wherein after every
4096 bytes CS gets de asserted. So, I had to modify the above read framework
to do a page read.
Need better way to handle this limitation, so that the above patch series
can get upstreamed.

Quoted 3 lines

Does linux support this ti_qspi, please point the defconfig if you have.

Patches for linux is under review and still not mainlined.
https://patchwork.kernel.org/patch/2838342/

Quoted 7 lines

Quoted 6 lines

Quoted 4 lines

Quoted 3 lines

Thanks, please give me some time I will look at these and let u know early next week.

Thanks!!

You still see this issue.

Please ignore this mail thread. This was due to some ip limitation.

OK.. Thread ends!

From: Ravikumar Kattekola <[email protected]>

Add Quad read mode (6 pin interface) support to spi flash and ti qspi driver.

Quad mode (0x6bh on spansion) uses two extra pins (D2 and D3) for data transfer apart from the usual D0 and D1 pins thus transfering 4 bits per cycle.

Signed-off-by Ravikumar Kattekola <[email protected]>

Signed-off-by Sourav Poddar <[email protected]>

---
 drivers/mtd/spi/spi_flash.c          |  110 +++++++++++++++++++++++++++++++++-
 drivers/mtd/spi/spi_flash_internal.h |    2 +
 drivers/spi/ti_qspi.c                |   18 ++++--
 include/configs/dra7xx_evm.h         |    1 +
 include/spi.h                        |    2 +
 5 files changed, 127 insertions(+), 6 deletions(-)

Qspi controller has a memory mapped port which can be used for data transfers. First controller need to be configured through configuration port, then for data read switch the controller to memory mapped and read from the predefined location.

Signed-off-by Sourav Poddar <[email protected]>

---
 drivers/mtd/spi/spansion.c   |    1 +
 drivers/mtd/spi/spi_flash.c  |    8 +++-
 drivers/spi/ti_qspi.c        |   85 +++++++++++++++++++++++++++++++++++-------
 include/configs/dra7xx_evm.h |    3 +-
 include/spi.h                |    3 +
 5 files changed, 84 insertions(+), 16 deletions(-)

Dear Sourav Poddar,

Quoted 5 lines · In message<[email protected]> you wrote:

Qspi controller has a memory mapped port which can be used for data transfers. First controller need to be configured through configuration port, then for data read switch the controller to memory mapped and read from the predefined location.

Quoted 8 lines

Signed-off-by Sourav Poddar<[email protected]>

---
  drivers/mtd/spi/spansion.c   |    1 +
  drivers/mtd/spi/spi_flash.c  |    8 +++-
  drivers/spi/ti_qspi.c        |   85 +++++++++++++++++++++++++++++++++++-------
  include/configs/dra7xx_evm.h |    3 +-
  include/spi.h                |    3 +
  5 files changed, 84 insertions(+), 16 deletions(-)

changelog missing, and an awful lot of checkpatch issues which need to be fixed:

ERROR: code indent should use tabs where possible
#112: FILE: drivers/mtd/spi/spansion.c:154:
+ flash->memory_map = spi->memory_map;$

WARNING: please, no spaces at the start of a line
#112: FILE: drivers/mtd/spi/spansion.c:154:
+ flash->memory_map = spi->memory_map;$

ERROR: code indent should use tabs where possible
#154: FILE: drivers/spi/ti_qspi.c:26:
+ u32 cmd;$

WARNING: please, no spaces at the start of a line
#154: FILE: drivers/spi/ti_qspi.c:26:
+ u32 cmd;$

ERROR: code indent should use tabs where possible
#155: FILE: drivers/spi/ti_qspi.c:27:
+ u32 dc;$

WARNING: please, no spaces at the start of a line
#155: FILE: drivers/spi/ti_qspi.c:27:
+ u32 dc;$

ERROR: code indent should use tabs where possible
#233: FILE: drivers/spi/ti_qspi.c:237:
+ qslave->dc = 0;$

WARNING: please, no spaces at the start of a line
#233: FILE: drivers/spi/ti_qspi.c:237:
+ qslave->dc = 0;$

ERROR: code indent should use tabs where possible
#234: FILE: drivers/spi/ti_qspi.c:238:
+ if (qslave->mode& SPI_CPHA)$

WARNING: please, no spaces at the start of a line
#234: FILE: drivers/spi/ti_qspi.c:238:
+ if (qslave->mode& SPI_CPHA)$

ERROR: code indent should use tabs where possible
#235: FILE: drivers/spi/ti_qspi.c:239:
+ qslave->dc |= QSPI_CKPHA(slave->cs);$

WARNING: please, no spaces at the start of a line
#235: FILE: drivers/spi/ti_qspi.c:239:
+ qslave->dc |= QSPI_CKPHA(slave->cs);$

ERROR: code indent should use tabs where possible
#236: FILE: drivers/spi/ti_qspi.c:240:
+ if (qslave->mode& SPI_CPOL)$

WARNING: please, no spaces at the start of a line
#236: FILE: drivers/spi/ti_qspi.c:240:
+ if (qslave->mode& SPI_CPOL)$

ERROR: code indent should use tabs where possible
#237: FILE: drivers/spi/ti_qspi.c:241:
+ qslave->dc |= QSPI_CKPOL(slave->cs);$

WARNING: please, no spaces at the start of a line
#237: FILE: drivers/spi/ti_qspi.c:241:
+ qslave->dc |= QSPI_CKPOL(slave->cs);$

ERROR: code indent should use tabs where possible
#238: FILE: drivers/spi/ti_qspi.c:242:
+ if (qslave->mode& SPI_CS_HIGH)$

WARNING: please, no spaces at the start of a line
#238: FILE: drivers/spi/ti_qspi.c:242:
+ if (qslave->mode& SPI_CS_HIGH)$

ERROR: code indent should use tabs where possible
#239: FILE: drivers/spi/ti_qspi.c:243:
+ qslave->dc |= QSPI_CSPOL(slave->cs);$

WARNING: please, no spaces at the start of a line
#239: FILE: drivers/spi/ti_qspi.c:243:
+ qslave->dc |= QSPI_CSPOL(slave->cs);$

ERROR: code indent should use tabs where possible
#241: FILE: drivers/spi/ti_qspi.c:245:
+ writel(qslave->dc,&qspi->spi_dc);$

WARNING: please, no spaces at the start of a line
#241: FILE: drivers/spi/ti_qspi.c:245:
+ writel(qslave->dc,&qspi->spi_dc);$

ERROR: code indent should use tabs where possible
#243: FILE: drivers/spi/ti_qspi.c:247:
+ if (flags == SPI_XFER_MEM_MAP) {$

WARNING: please, no spaces at the start of a line
#243: FILE: drivers/spi/ti_qspi.c:247:
+ if (flags == SPI_XFER_MEM_MAP) {$

ERROR: code indent should use tabs where possible
#244: FILE: drivers/spi/ti_qspi.c:248:
+ writel(MM_SWITCH,&qspi->spi_switch);$

WARNING: please, no spaces at the start of a line
#244: FILE: drivers/spi/ti_qspi.c:248:
+ writel(MM_SWITCH,&qspi->spi_switch);$

ERROR: code indent should use tabs where possible
#245: FILE: drivers/spi/ti_qspi.c:249:
+ val = readl(CORE_CTRL_IO);$

WARNING: please, no spaces at the start of a line
#245: FILE: drivers/spi/ti_qspi.c:249:
+ val = readl(CORE_CTRL_IO);$

ERROR: code indent should use tabs where possible
#246: FILE: drivers/spi/ti_qspi.c:250:
+ val |= MEM_CS;$

WARNING: please, no spaces at the start of a line
#246: FILE: drivers/spi/ti_qspi.c:250:
+ val |= MEM_CS;$

ERROR: code indent should use tabs where possible
#247: FILE: drivers/spi/ti_qspi.c:251:
+ writel(val, CORE_CTRL_IO);$

WARNING: please, no spaces at the start of a line
#247: FILE: drivers/spi/ti_qspi.c:251:
+ writel(val, CORE_CTRL_IO);$

ERROR: code indent should use tabs where possible
#248: FILE: drivers/spi/ti_qspi.c:252:
+ return 0;$

WARNING: please, no spaces at the start of a line
#248: FILE: drivers/spi/ti_qspi.c:252:
+ return 0;$

ERROR: code indent should use tabs where possible
#249: FILE: drivers/spi/ti_qspi.c:253:
+ } else if (flags == SPI_XFER_MEM_MAP_END) {$

WARNING: please, no spaces at the start of a line
#249: FILE: drivers/spi/ti_qspi.c:253:
+ } else if (flags == SPI_XFER_MEM_MAP_END) {$

ERROR: code indent should use tabs where possible
#250: FILE: drivers/spi/ti_qspi.c:254:
+ writel(~MM_SWITCH,&qspi->spi_switch);$

WARNING: please, no spaces at the start of a line
#250: FILE: drivers/spi/ti_qspi.c:254:
+ writel(~MM_SWITCH,&qspi->spi_switch);$

ERROR: code indent should use tabs where possible
#251: FILE: drivers/spi/ti_qspi.c:255:
+ val = readl(CORE_CTRL_IO);$

WARNING: please, no spaces at the start of a line
#251: FILE: drivers/spi/ti_qspi.c:255:
+ val = readl(CORE_CTRL_IO);$

ERROR: code indent should use tabs where possible
#252: FILE: drivers/spi/ti_qspi.c:256:
+ val&= MEM_CS_UNSELECT;$

WARNING: please, no spaces at the start of a line
#252: FILE: drivers/spi/ti_qspi.c:256:
+ val&= MEM_CS_UNSELECT;$

ERROR: code indent should use tabs where possible
#253: FILE: drivers/spi/ti_qspi.c:257:
+ writel(val, CORE_CTRL_IO);$

WARNING: please, no spaces at the start of a line
#253: FILE: drivers/spi/ti_qspi.c:257:
+ writel(val, CORE_CTRL_IO);$

ERROR: code indent should use tabs where possible
#254: FILE: drivers/spi/ti_qspi.c:258:
+ return 0;$

WARNING: please, no spaces at the start of a line
#254: FILE: drivers/spi/ti_qspi.c:258:
+ return 0;$

ERROR: code indent should use tabs where possible
#255: FILE: drivers/spi/ti_qspi.c:259:
+ }$

WARNING: please, no spaces at the start of a line
#255: FILE: drivers/spi/ti_qspi.c:259:
+ }$

ERROR: code indent should use tabs where possible
#257: FILE: drivers/spi/ti_qspi.c:261:
+ if (bitlen == 0)$

WARNING: please, no spaces at the start of a line
#257: FILE: drivers/spi/ti_qspi.c:261:
+ if (bitlen == 0)$

ERROR: code indent should use tabs where possible
#258: FILE: drivers/spi/ti_qspi.c:262:
+ return -1;$

WARNING: please, no spaces at the start of a line
#258: FILE: drivers/spi/ti_qspi.c:262:
+ return -1;$

total: 26 errors, 26 warnings, 0 checks, 177 lines checked

NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or
scripts/cleanfile

NOTE: Ignored message types: COMPLEX_MACRO CONSIDER_KSTRTO MINMAX MULTISTATEMENT_MACRO_USE_DO_WHILE NETWORKING_BLOCK_COMMENT_STYLE USLEEP_RANGE

/home/wd/Mail/U-Boot/16312 has style problems, please review.

If any of these errors are false positives, please report them to the maintainer, see CHECKPATCH in MAINTAINERS.

Best regards,

Wolfgang Denk