diff mbox

[v6,10/10] ARM: OMAP2+: tusb6010: generic timing calculation

Message ID C8443D0743D26F4388EA172BF4E2A7A93E9E3624@DBDE01.ent.ti.com (mailing list archive)
State New, archived
Headers show

Commit Message

Afzal Mohammed Sept. 14, 2012, 10:20 a.m. UTC 
* Mohammed, Afzal: Wednesday, September 12, 2012 3:20 PM

> But some of the tusb async values is less by one. I need
> to get it right.

Reason has been identified. It was due to rounding error,
no changes are required in the expressions. Moving
completely to picoseconds resolves the issue.

Can you please try with the attached patch ?

Once it is confirmed that issue is resolved, I will cleanup
gpmc-nand.c too (which would also take care of picoseconds)

Note: As this mail is sent via exchange, I am attaching the
patch so that it reaches you in proper way.

Regards
Afzal

Comments

Afzal Mohammed Sept. 17, 2012, 8:39 a.m. UTC | #1 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--
To unsubscribe from this list: send the line "unsubscribe linux-omap" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Tony Lindgren Sept. 17, 2012, 10:50 p.m. UTC | #2 
* Mohammed, Afzal <afzal@ti.com> [120917 01:40]:
> Hi Tony,
> 
> On Fri, Sep 14, 2012 at 15:50:02, Mohammed, Afzal wrote:
> > * Mohammed, Afzal: Wednesday, September 12, 2012 3:20 PM
> 
> > > But some of the tusb async values is less by one. I need
> > > to get it right.
> > 
> > Reason has been identified. It was due to rounding error,
> > no changes are required in the expressions. Moving
> > completely to picoseconds resolves the issue.
> > 
> > Can you please try with the attached patch ?

Gave it a quick try and it seemed to work.. But when I tried
rebasing my patches for the cbus to keep things working with
the watchdog, I ran into multiple merge conflicts with
current linux next and gave up.
 
Care to repost this series updated against current linux
next?

I'm afraid I've pretty much lost track of all the patches
and rather not start resolving the conflicts as I'm sure
I'll break something else :)

Regards,

Tony
--
To unsubscribe from this list: send the line "unsubscribe linux-omap" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Tony Lindgren Sept. 17, 2012, 11:10 p.m. UTC | #3 
* Tony Lindgren <tony@atomide.com> [120917 15:54]:
> * Mohammed, Afzal <afzal@ti.com> [120917 01:40]:
> > Hi Tony,
> > 
> > On Fri, Sep 14, 2012 at 15:50:02, Mohammed, Afzal wrote:
> > > * Mohammed, Afzal: Wednesday, September 12, 2012 3:20 PM
> > 
> > > > But some of the tusb async values is less by one. I need
> > > > to get it right.
> > > 
> > > Reason has been identified. It was due to rounding error,
> > > no changes are required in the expressions. Moving
> > > completely to picoseconds resolves the issue.
> > > 
> > > Can you please try with the attached patch ?
> 
> Gave it a quick try and it seemed to work.. But when I tried
> rebasing my patches for the cbus to keep things working with
> the watchdog, I ran into multiple merge conflicts with
> current linux next and gave up.

OK went back to my original branch without current linux
next and with the new cbus + retu driver from Aaro applied.
Confirmed it's now working on n800 tusb6010.
  
> Care to repost this series updated against current linux
> next?
> 
> I'm afraid I've pretty much lost track of all the patches
> and rather not start resolving the conflicts as I'm sure
> I'll break something else :)

You should still repost the whole updated series against
linux next.

Regards,

Tony
--
To unsubscribe from this list: send the line "unsubscribe linux-omap" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Afzal Mohammed Sept. 19, 2012, 1:43 p.m. UTC | #4 
SGkgVG9ueSwNCg0KT24gVHVlLCBTZXAgMTgsIDIwMTIgYXQgMDQ6NDA6MDIsIFRvbnkgTGluZGdy
ZW4gd3JvdGU6DQo+ICogVG9ueSBMaW5kZ3JlbiA8dG9ueUBhdG9taWRlLmNvbT4gWzEyMDkxNyAx
NTo1NF06DQoNCj4gPiA+ID4gQ2FuIHlvdSBwbGVhc2UgdHJ5IHdpdGggdGhlIGF0dGFjaGVkIHBh
dGNoID8NCj4gPiANCj4gPiBHYXZlIGl0IGEgcXVpY2sgdHJ5IGFuZCBpdCBzZWVtZWQgdG8gd29y
ay4uIEJ1dCB3aGVuIEkgdHJpZWQNCj4gPiByZWJhc2luZyBteSBwYXRjaGVzIGZvciB0aGUgY2J1
cyB0byBrZWVwIHRoaW5ncyB3b3JraW5nIHdpdGgNCj4gPiB0aGUgd2F0Y2hkb2csIEkgcmFuIGlu
dG8gbXVsdGlwbGUgbWVyZ2UgY29uZmxpY3RzIHdpdGgNCj4gPiBjdXJyZW50IGxpbnV4IG5leHQg
YW5kIGdhdmUgdXAuDQo+IA0KPiBPSyB3ZW50IGJhY2sgdG8gbXkgb3JpZ2luYWwgYnJhbmNoIHdp
dGhvdXQgY3VycmVudCBsaW51eA0KPiBuZXh0IGFuZCB3aXRoIHRoZSBuZXcgY2J1cyArIHJldHUg
ZHJpdmVyIGZyb20gQWFybyBhcHBsaWVkLg0KPiBDb25maXJtZWQgaXQncyBub3cgd29ya2luZyBv
biBuODAwIHR1c2I2MDEwLg0KDQpUaGFua3MgZm9yIGNoZWNraW5nIGFuZCBjb25maXJtaW5nLg0K
DQo+ID4gQ2FyZSB0byByZXBvc3QgdGhpcyBzZXJpZXMgdXBkYXRlZCBhZ2FpbnN0IGN1cnJlbnQg
bGludXgNCj4gPiBuZXh0Pw0KPiA+IA0KPiA+IEknbSBhZnJhaWQgSSd2ZSBwcmV0dHkgbXVjaCBs
b3N0IHRyYWNrIG9mIGFsbCB0aGUgcGF0Y2hlcw0KPiA+IGFuZCByYXRoZXIgbm90IHN0YXJ0IHJl
c29sdmluZyB0aGUgY29uZmxpY3RzIGFzIEknbSBzdXJlDQo+ID4gSSdsbCBicmVhayBzb21ldGhp
bmcgZWxzZSA6KQ0KPiANCj4gWW91IHNob3VsZCBzdGlsbCByZXBvc3QgdGhlIHdob2xlIHVwZGF0
ZWQgc2VyaWVzIGFnYWluc3QNCj4gbGludXggbmV4dC4NCg0KTmV3IHVwZGF0ZWQgdmVyc2lvbiAt
IHY3LCBiYXNlZCBvdmVyIGxpbnV4IG5leHQgaGFzIGJlZW4gcG9zdGVkLg0KDQpSZWdhcmRzDQpB
ZnphbA0K
--
To unsubscribe from this list: send the line "unsubscribe linux-omap" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
diff mbox

Patch

From 101b3d4c558bae420cbeba634f4deeae27c3b905 Mon Sep 17 00:00:00 2001
From: Afzal Mohammed <afzal@ti.com>
Date: Wed, 12 Sep 2012 19:30:27 +0530
Subject: [PATCH] gpmc: rounding error fix

Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
 arch/arm/mach-omap2/gpmc.c             |  150 +++++++++++++++-----------------
 arch/arm/plat-omap/include/plat/gpmc.h |   40 ++++----
 2 files changed, 90 insertions(+), 100 deletions(-)

diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index d8e5b08..e9d57db 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -289,11 +289,11 @@  static int set_gpmc_timing_reg(int cs, int reg, int st_bit, int end_bit,
 	if (time == 0)
 		ticks = 0;
 	else
-		ticks = gpmc_ns_to_ticks(time);
+		ticks = gpmc_ps_to_ticks(time);
 	nr_bits = end_bit - st_bit + 1;
 	if (ticks >= 1 << nr_bits) {
 #ifdef DEBUG
-		printk(KERN_INFO "GPMC CS%d: %-10s* %3d ns, %3d ticks >= %d\n",
+		pr_info("GPMC CS%d: %-10s* %3d ps, %3d ticks >= %d\n",
 				cs, name, time, ticks, 1 << nr_bits);
 #endif
 		return -1;
@@ -302,10 +302,9 @@  static int set_gpmc_timing_reg(int cs, int reg, int st_bit, int end_bit,
 	mask = (1 << nr_bits) - 1;
 	l = gpmc_cs_read_reg(cs, reg);
 #ifdef DEBUG
-	printk(KERN_INFO
-		"GPMC CS%d: %-10s: %3d ticks, %3lu ns (was %3i ticks) %3d ns\n",
-	       cs, name, ticks, gpmc_get_fclk_period() * ticks / 1000,
-			(l >> st_bit) & mask, time);
+	pr_info("GPMC CS%d: %-10s: %3d ticks, %3lu ps (was %3i ticks) %3d ps\n",
+		cs, name, ticks, gpmc_get_fclk_period() * ticks,
+		(l >> st_bit) & mask, time);
 #endif
 	l &= ~(mask << st_bit);
 	l |= ticks << st_bit;
@@ -385,8 +384,8 @@  int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t)
 	l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
 	if (l & (GPMC_CONFIG1_READTYPE_SYNC | GPMC_CONFIG1_WRITETYPE_SYNC)) {
 #ifdef DEBUG
-		printk(KERN_INFO "GPMC CS%d CLK period is %lu ns (div %d)\n",
-				cs, (div * gpmc_get_fclk_period()) / 1000, div);
+		pr_info("GPMC CS%d CLK period is %lu ps (div %d)\n",
+				cs, div * gpmc_get_fclk_period(), div);
 #endif
 		l &= ~0x03;
 		l |= (div - 1);
@@ -922,46 +921,42 @@  static int gpmc_calc_sync_read_timings(struct gpmc_timings *gpmc_t,
 		 * indirectly necessitates requirement of t_avdp_r & t_avdp_w
 		 * instead of having a single t_avdp
 		 */
-		temp = max_t(u32, temp,	gpmc_t->clk_activation * 1000 +
-							dev_t->t_avdh);
-		temp = max_t(u32,
-			(gpmc_t->adv_on + gpmc_ticks_to_ns(1)) * 1000, temp);
+		temp = max_t(u32, temp,	gpmc_t->clk_activation + dev_t->t_avdh);
+		temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
 	}
-	gpmc_t->adv_rd_off = gpmc_round_ps_to_ticks(temp) / 1000;
+	gpmc_t->adv_rd_off = gpmc_round_ps_to_ticks(temp);
 
 	/* oe_on */
 	temp = dev_t->t_oeasu; /* remove this ? */
 	if (mux) {
-		temp = max_t(u32, temp,
-			gpmc_t->clk_activation * 1000 + dev_t->t_ach);
-		temp = max_t(u32, temp, (gpmc_t->adv_rd_off +
-				gpmc_ticks_to_ns(dev_t->cyc_aavdh_oe)) * 1000);
+		temp = max_t(u32, temp,	gpmc_t->clk_activation + dev_t->t_ach);
+		temp = max_t(u32, temp, gpmc_t->adv_rd_off +
+				gpmc_ticks_to_ps(dev_t->cyc_aavdh_oe));
 	}
-	gpmc_t->oe_on = gpmc_round_ps_to_ticks(temp) / 1000;
+	gpmc_t->oe_on = gpmc_round_ps_to_ticks(temp);
 
 	/* access */
 	/* any scope for improvement ?, by combining oe_on & clk_activation,
 	 * need to check whether access = clk_activation + round to sync clk ?
 	 */
 	temp = max_t(u32, dev_t->t_iaa,	dev_t->cyc_iaa * gpmc_t->sync_clk);
-	temp += gpmc_t->clk_activation * 1000;
+	temp += gpmc_t->clk_activation;
 	if (dev_t->cyc_oe)
-		temp = max_t(u32, temp, (gpmc_t->oe_on +
-				gpmc_ticks_to_ns(dev_t->cyc_oe)) * 1000);
-	gpmc_t->access = gpmc_round_ps_to_ticks(temp) / 1000;
+		temp = max_t(u32, temp, gpmc_t->oe_on +
+				gpmc_ticks_to_ps(dev_t->cyc_oe));
+	gpmc_t->access = gpmc_round_ps_to_ticks(temp);
 
-	gpmc_t->oe_off = gpmc_t->access + gpmc_ticks_to_ns(1);
+	gpmc_t->oe_off = gpmc_t->access + gpmc_ticks_to_ps(1);
 	gpmc_t->cs_rd_off = gpmc_t->oe_off;
 
 	/* rd_cycle */
 	temp = max_t(u32, dev_t->t_cez_r, dev_t->t_oez);
 	temp = gpmc_round_ps_to_sync_clk(temp, gpmc_t->sync_clk) +
-							gpmc_t->access * 1000;
+							gpmc_t->access;
 	/* barter t_ce_rdyz with t_cez_r ? */
 	if (dev_t->t_ce_rdyz)
-		temp = max_t(u32, temp,
-				gpmc_t->cs_rd_off * 1000 + dev_t->t_ce_rdyz);
-	gpmc_t->rd_cycle = gpmc_round_ps_to_ticks(temp) / 1000;
+		temp = max_t(u32, temp,	gpmc_t->cs_rd_off + dev_t->t_ce_rdyz);
+	gpmc_t->rd_cycle = gpmc_round_ps_to_ticks(temp);
 
 	return 0;
 }
@@ -976,29 +971,28 @@  static int gpmc_calc_sync_write_timings(struct gpmc_timings *gpmc_t,
 	temp = dev_t->t_avdp_w;
 	if (mux) {
 		temp = max_t(u32, temp,
-			gpmc_t->clk_activation * 1000 + dev_t->t_avdh);
-		temp = max_t(u32,
-			(gpmc_t->adv_on + gpmc_ticks_to_ns(1)) * 1000, temp);
+			gpmc_t->clk_activation + dev_t->t_avdh);
+		temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
 	}
-	gpmc_t->adv_wr_off = gpmc_round_ps_to_ticks(temp) / 1000;
+	gpmc_t->adv_wr_off = gpmc_round_ps_to_ticks(temp);
 
 	/* wr_data_mux_bus */
 	temp = max_t(u32, dev_t->t_weasu,
-			gpmc_t->clk_activation * 1000 + dev_t->t_rdyo);
+			gpmc_t->clk_activation + dev_t->t_rdyo);
 	/* shouldn't mux be kept as a whole for wr_data_mux_bus ?,
 	 * and in that case remember to handle we_on properly
 	 */
 	if (mux) {
 		temp = max_t(u32, temp,
-			gpmc_t->adv_wr_off * 1000 + dev_t->t_aavdh);
-		temp = max_t(u32, temp, (gpmc_t->adv_wr_off +
-				gpmc_ticks_to_ns(dev_t->cyc_aavdh_we)) * 1000);
+			gpmc_t->adv_wr_off + dev_t->t_aavdh);
+		temp = max_t(u32, temp, gpmc_t->adv_wr_off +
+				gpmc_ticks_to_ps(dev_t->cyc_aavdh_we));
 	}
-	gpmc_t->wr_data_mux_bus = gpmc_round_ps_to_ticks(temp) / 1000;
+	gpmc_t->wr_data_mux_bus = gpmc_round_ps_to_ticks(temp);
 
 	/* we_on */
 	if (gpmc_capability & GPMC_HAS_WR_DATA_MUX_BUS)
-		gpmc_t->we_on = gpmc_round_ps_to_ticks(dev_t->t_weasu) / 1000;
+		gpmc_t->we_on = gpmc_round_ps_to_ticks(dev_t->t_weasu);
 	else
 		gpmc_t->we_on = gpmc_t->wr_data_mux_bus;
 
@@ -1007,24 +1001,24 @@  static int gpmc_calc_sync_write_timings(struct gpmc_timings *gpmc_t,
 	gpmc_t->wr_access = gpmc_t->access;
 
 	/* we_off */
-	temp = gpmc_t->we_on * 1000 + dev_t->t_wpl;
+	temp = gpmc_t->we_on + dev_t->t_wpl;
 	temp = max_t(u32, temp,
-			(gpmc_t->wr_access + gpmc_ticks_to_ns(1)) * 1000);
+			gpmc_t->wr_access + gpmc_ticks_to_ps(1));
 	temp = max_t(u32, temp,
-		(gpmc_t->we_on + gpmc_ticks_to_ns(dev_t->cyc_wpl)) * 1000);
-	gpmc_t->we_off = gpmc_round_ps_to_ticks(temp) / 1000;
+		gpmc_t->we_on + gpmc_ticks_to_ps(dev_t->cyc_wpl));
+	gpmc_t->we_off = gpmc_round_ps_to_ticks(temp);
 
-	gpmc_t->cs_wr_off = gpmc_round_ps_to_ticks(gpmc_t->we_off * 1000 +
-							dev_t->t_wph) / 1000;
+	gpmc_t->cs_wr_off = gpmc_round_ps_to_ticks(gpmc_t->we_off +
+							dev_t->t_wph);
 
 	/* wr_cycle */
 	temp = gpmc_round_ps_to_sync_clk(dev_t->t_cez_w, gpmc_t->sync_clk);
-	temp += gpmc_t->wr_access * 1000;
+	temp += gpmc_t->wr_access;
 	/* barter t_ce_rdyz with t_cez_w ? */
 	if (dev_t->t_ce_rdyz)
 		temp = max_t(u32, temp,
-				 gpmc_t->cs_wr_off * 1000 + dev_t->t_ce_rdyz);
-	gpmc_t->wr_cycle = gpmc_round_ps_to_ticks(temp) / 1000;
+				 gpmc_t->cs_wr_off + dev_t->t_ce_rdyz);
+	gpmc_t->wr_cycle = gpmc_round_ps_to_ticks(temp);
 
 	return 0;
 }
@@ -1038,35 +1032,33 @@  static int gpmc_calc_async_read_timings(struct gpmc_timings *gpmc_t,
 	/* adv_rd_off */
 	temp = dev_t->t_avdp_r;
 	if (mux)
-		temp = max_t(u32,
-			(gpmc_t->adv_on + gpmc_ticks_to_ns(1)) * 1000, temp);
-	gpmc_t->adv_rd_off = gpmc_round_ps_to_ticks(temp) / 1000;
+		temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
+	gpmc_t->adv_rd_off = gpmc_round_ps_to_ticks(temp);
 
 	/* oe_on */
 	temp = dev_t->t_oeasu;
 	if (mux)
 		temp = max_t(u32, temp,
-			gpmc_t->adv_rd_off * 1000 + dev_t->t_aavdh);
-	gpmc_t->oe_on = gpmc_round_ps_to_ticks(temp) / 1000;
+			gpmc_t->adv_rd_off + dev_t->t_aavdh);
+	gpmc_t->oe_on = gpmc_round_ps_to_ticks(temp);
 
 	/* access */
 	temp = max_t(u32, dev_t->t_iaa, /* remove t_iaa in async ? */
-				gpmc_t->oe_on * 1000 + dev_t->t_oe);
+				gpmc_t->oe_on + dev_t->t_oe);
 	temp = max_t(u32, temp,
-				gpmc_t->cs_on * 1000 + dev_t->t_ce);
+				gpmc_t->cs_on + dev_t->t_ce);
 	temp = max_t(u32, temp,
-				gpmc_t->adv_on * 1000 + dev_t->t_aa);
-	gpmc_t->access = gpmc_round_ps_to_ticks(temp) / 1000;
+				gpmc_t->adv_on + dev_t->t_aa);
+	gpmc_t->access = gpmc_round_ps_to_ticks(temp);
 
-	gpmc_t->oe_off = gpmc_t->access + gpmc_ticks_to_ns(1);
+	gpmc_t->oe_off = gpmc_t->access + gpmc_ticks_to_ps(1);
 	gpmc_t->cs_rd_off = gpmc_t->oe_off;
 
 	/* rd_cycle */
 	temp = max_t(u32, dev_t->t_rd_cycle,
-			gpmc_t->cs_rd_off * 1000 + dev_t->t_cez_r);
-	temp = max_t(u32, temp,
-			gpmc_t->oe_off * 1000 + dev_t->t_oez);
-	gpmc_t->rd_cycle = gpmc_round_ps_to_ticks(temp) / 1000;
+			gpmc_t->cs_rd_off + dev_t->t_cez_r);
+	temp = max_t(u32, temp, gpmc_t->oe_off + dev_t->t_oez);
+	gpmc_t->rd_cycle = gpmc_round_ps_to_ticks(temp);
 
 	return 0;
 }
@@ -1080,37 +1072,35 @@  static int gpmc_calc_async_write_timings(struct gpmc_timings *gpmc_t,
 	/* adv_wr_off */
 	temp = dev_t->t_avdp_w;
 	if (mux)
-		temp = max_t(u32,
-			(gpmc_t->adv_on + gpmc_ticks_to_ns(1)) * 1000, temp);
-	gpmc_t->adv_wr_off = gpmc_round_ps_to_ticks(temp) / 1000;
+		temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
+	gpmc_t->adv_wr_off = gpmc_round_ps_to_ticks(temp);
 
 	/* wr_data_mux_bus */
 	temp = dev_t->t_weasu;
 	if (mux) {
-		temp = max_t(u32, temp,
-			gpmc_t->adv_wr_off * 1000 + dev_t->t_aavdh);
-		temp = max_t(u32, temp, (gpmc_t->adv_wr_off +
-				gpmc_ticks_to_ns(dev_t->cyc_aavdh_we)) * 1000);
+		temp = max_t(u32, temp,	gpmc_t->adv_wr_off + dev_t->t_aavdh);
+		temp = max_t(u32, temp, gpmc_t->adv_wr_off +
+				gpmc_ticks_to_ps(dev_t->cyc_aavdh_we));
 	}
-	gpmc_t->wr_data_mux_bus = gpmc_round_ps_to_ticks(temp) / 1000;
+	gpmc_t->wr_data_mux_bus = gpmc_round_ps_to_ticks(temp);
 
 	/* we_on */
 	if (gpmc_capability & GPMC_HAS_WR_DATA_MUX_BUS)
-		gpmc_t->we_on = gpmc_round_ps_to_ticks(dev_t->t_weasu) / 1000;
+		gpmc_t->we_on = gpmc_round_ps_to_ticks(dev_t->t_weasu);
 	else
 		gpmc_t->we_on = gpmc_t->wr_data_mux_bus;
 
 	/* we_off */
-	temp = gpmc_t->we_on * 1000 + dev_t->t_wpl;
-	gpmc_t->we_off = gpmc_round_ps_to_ticks(temp) / 1000;
+	temp = gpmc_t->we_on + dev_t->t_wpl;
+	gpmc_t->we_off = gpmc_round_ps_to_ticks(temp);
 
-	gpmc_t->cs_wr_off = gpmc_round_ps_to_ticks((gpmc_t->we_off * 1000 +
-				dev_t->t_wph)) / 1000;
+	gpmc_t->cs_wr_off = gpmc_round_ps_to_ticks(gpmc_t->we_off +
+							dev_t->t_wph);
 
 	/* wr_cycle */
 	temp = max_t(u32, dev_t->t_wr_cycle,
-				gpmc_t->cs_wr_off * 1000 + dev_t->t_cez_w);
-	gpmc_t->wr_cycle = gpmc_round_ps_to_ticks(temp) / 1000;
+				gpmc_t->cs_wr_off + dev_t->t_cez_w);
+	gpmc_t->wr_cycle = gpmc_round_ps_to_ticks(temp);
 
 	return 0;
 }
@@ -1125,10 +1115,10 @@  static int gpmc_calc_sync_common_timings(struct gpmc_timings *gpmc_t,
 
 	gpmc_t->page_burst_access = gpmc_round_ps_to_sync_clk(
 					dev_t->t_bacc,
-					gpmc_t->sync_clk) / 1000;
+					gpmc_t->sync_clk);
 
 	temp = max_t(u32, dev_t->t_ces, dev_t->t_avds);
-	gpmc_t->clk_activation = gpmc_round_ps_to_ticks(temp) / 1000;
+	gpmc_t->clk_activation = gpmc_round_ps_to_ticks(temp);
 
 	if (gpmc_calc_divider(gpmc_t->sync_clk) != 1)
 		return 0;
@@ -1151,14 +1141,14 @@  static int gpmc_calc_common_timings(struct gpmc_timings *gpmc_t,
 	u32 temp;
 
 	/* cs_on */
-	gpmc_t->cs_on = gpmc_round_ns_to_ticks(dev_t->t_ceasu / 1000);
+	gpmc_t->cs_on = gpmc_round_ps_to_ticks(dev_t->t_ceasu);
 
 	/* adv_on */
 	temp = dev_t->t_avdasu;
 	if (dev_t->t_ce_avd)
 		temp = max_t(u32, temp,
-				gpmc_t->cs_on * 1000 + dev_t->t_ce_avd);
-	gpmc_t->adv_on = gpmc_round_ns_to_ticks(temp / 1000);
+				gpmc_t->cs_on + dev_t->t_ce_avd);
+	gpmc_t->adv_on = gpmc_round_ps_to_ticks(temp);
 
 	if (dev_t->sync_write || dev_t->sync_read)
 		gpmc_calc_sync_common_timings(gpmc_t, dev_t);
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index e59a932..f1d1d2e 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -116,38 +116,38 @@  struct gpmc_timings {
 	u32 sync_clk;
 
 	/* Chip-select signal timings corresponding to GPMC_CS_CONFIG2 */
-	u16 cs_on;		/* Assertion time */
-	u16 cs_rd_off;		/* Read deassertion time */
-	u16 cs_wr_off;		/* Write deassertion time */
+	u32 cs_on;		/* Assertion time */
+	u32 cs_rd_off;		/* Read deassertion time */
+	u32 cs_wr_off;		/* Write deassertion time */
 
 	/* ADV signal timings corresponding to GPMC_CONFIG3 */
-	u16 adv_on;		/* Assertion time */
-	u16 adv_rd_off;		/* Read deassertion time */
-	u16 adv_wr_off;		/* Write deassertion time */
+	u32 adv_on;		/* Assertion time */
+	u32 adv_rd_off;		/* Read deassertion time */
+	u32 adv_wr_off;		/* Write deassertion time */
 
 	/* WE signals timings corresponding to GPMC_CONFIG4 */
-	u16 we_on;		/* WE assertion time */
-	u16 we_off;		/* WE deassertion time */
+	u32 we_on;		/* WE assertion time */
+	u32 we_off;		/* WE deassertion time */
 
 	/* OE signals timings corresponding to GPMC_CONFIG4 */
-	u16 oe_on;		/* OE assertion time */
-	u16 oe_off;		/* OE deassertion time */
+	u32 oe_on;		/* OE assertion time */
+	u32 oe_off;		/* OE deassertion time */
 
 	/* Access time and cycle time timings corresponding to GPMC_CONFIG5 */
-	u16 page_burst_access;	/* Multiple access word delay */
-	u16 access;		/* Start-cycle to first data valid delay */
-	u16 rd_cycle;		/* Total read cycle time */
-	u16 wr_cycle;		/* Total write cycle time */
+	u32 page_burst_access;	/* Multiple access word delay */
+	u32 access;		/* Start-cycle to first data valid delay */
+	u32 rd_cycle;		/* Total read cycle time */
+	u32 wr_cycle;		/* Total write cycle time */
 
-	u16 bus_turnaround;
-	u16 cycle2cycle_delay;
+	u32 bus_turnaround;
+	u32 cycle2cycle_delay;
 
-	u16 wait_monitoring;
-	u16 clk_activation;
+	u32 wait_monitoring;
+	u32 clk_activation;
 
 	/* The following are only on OMAP3430 */
-	u16 wr_access;		/* WRACCESSTIME */
-	u16 wr_data_mux_bus;	/* WRDATAONADMUXBUS */
+	u32 wr_access;		/* WRACCESSTIME */
+	u32 wr_data_mux_bus;	/* WRDATAONADMUXBUS */
 
 	struct gpmc_bool_timings bool_timings;
 };
-- 
1.7.0.4