arch/arm/mach-omap2/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/gpio.h>
  15 #include <linux/export.h>
  16 #include <linux/platform_data/usb-omap.h>
  17
  18 #include <linux/usb/musb.h>
  19
  20 #include "gpmc.h"
  21
  22 static u8               async_cs, sync_cs;
  23 static unsigned         refclk_psec;
  24
  25 static 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
  32 static 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
  46 static 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
  72 static 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 */
 100 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);
 121 done:
 122         return status;
 123 }
 124 EXPORT_SYMBOL_GPL(tusb6010_platform_retime);
 125
 126 static struct resource tusb_resources[] = {
 127         /* Order is significant!  The start/end fields
 128          * are updated during setup..
 129          */
 130         { /* Asynchronous access */
 131                 .flags  = IORESOURCE_MEM,
 132         },
 133         { /* Synchronous access */
 134                 .flags  = IORESOURCE_MEM,
 135         },
 136         { /* IRQ */
 137                 .name   = "mc",
 138                 .flags  = IORESOURCE_IRQ,
 139         },
 140 };
 141
 142 static u64 tusb_dmamask = ~(u32)0;
 143
 144 static struct platform_device tusb_device = {
 145         .name           = "musb-tusb",
 146         .id             = -1,
 147         .dev = {
 148                 .dma_mask               = &tusb_dmamask,
 149                 .coherent_dma_mask      = 0xffffffff,
 150         },
 151         .num_resources  = ARRAY_SIZE(tusb_resources),
 152         .resource       = tusb_resources,
 153 };
 154
 155
 156 /* this may be called only from board-*.c setup code */
 157 int __init
 158 tusb6010_setup_interface(struct musb_hdrc_platform_data *data,
 159                 unsigned ps_refclk, unsigned waitpin,
 160                 unsigned async, unsigned sync,
 161                 unsigned irq, unsigned dmachan)
 162 {
 163         int             status;
 164         static char     error[] __initdata =
 165                 KERN_ERR "tusb6010 init error %d, %d\n";
 166
 167         /* ASYNC region, primarily for PIO */
 168         status = gpmc_cs_request(async, SZ_16M, (unsigned long *)
 169                                 &tusb_resources[0].start);
 170         if (status < 0) {
 171                 printk(error, 1, status);
 172                 return status;
 173         }
 174         tusb_resources[0].end = tusb_resources[0].start + 0x9ff;
 175         tusb_async.wait_pin = waitpin;
 176         async_cs = async;
 177
 178         status = gpmc_cs_program_settings(async_cs, &tusb_async);
 179         if (status < 0)
 180                 return status;
 181
 182         /* SYNC region, primarily for DMA */
 183         status = gpmc_cs_request(sync, SZ_16M, (unsigned long *)
 184                                 &tusb_resources[1].start);
 185         if (status < 0) {
 186                 printk(error, 2, status);
 187                 return status;
 188         }
 189         tusb_resources[1].end = tusb_resources[1].start + 0x9ff;
 190         tusb_sync.wait_pin = waitpin;
 191         sync_cs = sync;
 192
 193         status = gpmc_cs_program_settings(sync_cs, &tusb_sync);
 194         if (status < 0)
 195                 return status;
 196
 197         /* IRQ */
 198         status = gpio_request_one(irq, GPIOF_IN, "TUSB6010 irq");
 199         if (status < 0) {
 200                 printk(error, 3, status);
 201                 return status;
 202         }
 203         tusb_resources[2].start = gpio_to_irq(irq);
 204
 205         /* set up memory timings ... can speed them up later */
 206         if (!ps_refclk) {
 207                 printk(error, 4, status);
 208                 return -ENODEV;
 209         }
 210         refclk_psec = ps_refclk;
 211         status = tusb6010_platform_retime(1);
 212         if (status < 0) {
 213                 printk(error, 5, status);
 214                 return status;
 215         }
 216
 217         /* finish device setup ... */
 218         if (!data) {
 219                 printk(error, 6, status);
 220                 return -ENODEV;
 221         }
 222         tusb_device.dev.platform_data = data;
 223
 224         /* so far so good ... register the device */
 225         status = platform_device_register(&tusb_device);
 226         if (status < 0) {
 227                 printk(error, 7, status);
 228                 return status;
 229         }
 230         return 0;
 231 }