usb-tusb6010.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * linux/arch/arm/mach-omap2/usb-tusb6010.c
  4 *
  5 * Copyright (C) 2006 Nokia Corporation
  6 */
  7
  8#include <linux/err.h>
  9#include <linux/string.h>
 10#include <linux/types.h>
 11#include <linux/errno.h>
 12#include <linux/delay.h>
 13#include <linux/platform_device.h>
 14#include <linux/export.h>
 15#include <linux/platform_data/usb-omap.h>
 16
 17#include <linux/usb/musb.h>
 18
 19#include "usb-tusb6010.h"
 20#include "gpmc.h"
 21
 22static u8		async_cs, sync_cs;
 23static unsigned		refclk_psec;
 24
 25static struct gpmc_settings tusb_async = {
 26	.wait_on_read	= true,
 27	.wait_on_write	= true,
 28	.device_width	= GPMC_DEVWIDTH_16BIT,
 29	.mux_add_data	= GPMC_MUX_AD,
 30};
 31
 32static struct gpmc_settings tusb_sync = {
 33	.burst_read	= true,
 34	.burst_write	= true,
 35	.sync_read	= true,
 36	.sync_write	= true,
 37	.wait_on_read	= true,
 38	.wait_on_write	= true,
 39	.burst_len	= GPMC_BURST_16,
 40	.device_width	= GPMC_DEVWIDTH_16BIT,
 41	.mux_add_data	= GPMC_MUX_AD,
 42};
 43
 44/* NOTE:  timings are from tusb 6010 datasheet Rev 1.8, 12-Sept 2006 */
 45
 46static int tusb_set_async_mode(unsigned sysclk_ps)
 47{
 48	struct gpmc_device_timings dev_t;
 49	struct gpmc_timings	t;
 50	unsigned		t_acsnh_advnh = sysclk_ps + 3000;
 51
 52	memset(&dev_t, 0, sizeof(dev_t));
 53
 54	dev_t.t_ceasu = 8 * 1000;
 55	dev_t.t_avdasu = t_acsnh_advnh - 7000;
 56	dev_t.t_ce_avd = 1000;
 57	dev_t.t_avdp_r = t_acsnh_advnh;
 58	dev_t.t_oeasu = t_acsnh_advnh + 1000;
 59	dev_t.t_oe = 300;
 60	dev_t.t_cez_r = 7000;
 61	dev_t.t_cez_w = dev_t.t_cez_r;
 62	dev_t.t_avdp_w = t_acsnh_advnh;
 63	dev_t.t_weasu = t_acsnh_advnh + 1000;
 64	dev_t.t_wpl = 300;
 65	dev_t.cyc_aavdh_we = 1;
 66
 67	gpmc_calc_timings(&t, &tusb_async, &dev_t);
 68
 69	return gpmc_cs_set_timings(async_cs, &t, &tusb_async);
 70}
 71
 72static int tusb_set_sync_mode(unsigned sysclk_ps)
 73{
 74	struct gpmc_device_timings dev_t;
 75	struct gpmc_timings	t;
 76	unsigned		t_scsnh_advnh = sysclk_ps + 3000;
 77
 78	memset(&dev_t, 0, sizeof(dev_t));
 79
 80	dev_t.clk = 11100;
 81	dev_t.t_bacc = 1000;
 82	dev_t.t_ces = 1000;
 83	dev_t.t_ceasu = 8 * 1000;
 84	dev_t.t_avdasu = t_scsnh_advnh - 7000;
 85	dev_t.t_ce_avd = 1000;
 86	dev_t.t_avdp_r = t_scsnh_advnh;
 87	dev_t.cyc_aavdh_oe = 3;
 88	dev_t.cyc_oe = 5;
 89	dev_t.t_ce_rdyz = 7000;
 90	dev_t.t_avdp_w = t_scsnh_advnh;
 91	dev_t.cyc_aavdh_we = 3;
 92	dev_t.cyc_wpl = 6;
 93
 94	gpmc_calc_timings(&t, &tusb_sync, &dev_t);
 95
 96	return gpmc_cs_set_timings(sync_cs, &t, &tusb_sync);
 97}
 98
 99/* tusb driver calls this when it changes the chip's clocking */
100static int tusb6010_platform_retime(unsigned is_refclk)
101{
102	static const char	error[] =
103		KERN_ERR "tusb6010 %s retime error %d\n";
104
105	unsigned	sysclk_ps;
106	int		status;
107
108	if (!refclk_psec)
109		return -ENODEV;
110
111	sysclk_ps = is_refclk ? refclk_psec : TUSB6010_OSCCLK_60;
112
113	status = tusb_set_async_mode(sysclk_ps);
114	if (status < 0) {
115		printk(error, "async", status);
116		goto done;
117	}
118	status = tusb_set_sync_mode(sysclk_ps);
119	if (status < 0)
120		printk(error, "sync", status);
121done:
122	return status;
123}
124
125static struct resource tusb_resources[] = {
126	/* Order is significant!  The start/end fields
127	 * are updated during setup..
128	 */
129	{ /* Asynchronous access */
130		.flags	= IORESOURCE_MEM,
131	},
132	{ /* Synchronous access */
133		.flags	= IORESOURCE_MEM,
134	},
135};
136
137static u64 tusb_dmamask = ~(u32)0;
138
139static struct platform_device tusb_device = {
140	.name		= "musb-tusb",
141	.id		= -1,
142	.dev = {
143		.dma_mask		= &tusb_dmamask,
144		.coherent_dma_mask	= 0xffffffff,
145	},
146	.num_resources	= ARRAY_SIZE(tusb_resources),
147	.resource	= tusb_resources,
148};
149
150
151/* this may be called only from board-*.c setup code */
152int __init tusb6010_setup_interface(struct musb_hdrc_platform_data *data,
153		unsigned int ps_refclk, unsigned int waitpin,
154		unsigned int async, unsigned int sync,
155		unsigned int dmachan)
156{
157	int		status;
158	static char	error[] __initdata =
159		KERN_ERR "tusb6010 init error %d, %d\n";
160
161	/* ASYNC region, primarily for PIO */
162	status = gpmc_cs_request(async, SZ_16M, (unsigned long *)
163				&tusb_resources[0].start);
164	if (status < 0) {
165		printk(error, 1, status);
166		return status;
167	}
168	tusb_resources[0].end = tusb_resources[0].start + 0x9ff;
169	tusb_async.wait_pin = waitpin;
170	async_cs = async;
171
172	status = gpmc_cs_program_settings(async_cs, &tusb_async);
173	if (status < 0)
174		return status;
175
176	/* SYNC region, primarily for DMA */
177	status = gpmc_cs_request(sync, SZ_16M, (unsigned long *)
178				&tusb_resources[1].start);
179	if (status < 0) {
180		printk(error, 2, status);
181		return status;
182	}
183	tusb_resources[1].end = tusb_resources[1].start + 0x9ff;
184	tusb_sync.wait_pin = waitpin;
185	sync_cs = sync;
186
187	status = gpmc_cs_program_settings(sync_cs, &tusb_sync);
188	if (status < 0)
189		return status;
190
191	/* set up memory timings ... can speed them up later */
192	if (!ps_refclk) {
193		printk(error, 4, status);
194		return -ENODEV;
195	}
196	refclk_psec = ps_refclk;
197	status = tusb6010_platform_retime(1);
198	if (status < 0) {
199		printk(error, 5, status);
200		return status;
201	}
202
203	/* finish device setup ... */
204	if (!data) {
205		printk(error, 6, status);
206		return -ENODEV;
207	}
208	tusb_device.dev.platform_data = data;
209
210	/* so far so good ... register the device */
211	status = platform_device_register(&tusb_device);
212	if (status < 0) {
213		printk(error, 7, status);
214		return status;
215	}
216	return 0;
217}