arch/nios2nommu/kernel/usb.c

   1 /*
   2  * arch/nios2nommu/kernel/usb.c -- platform level USB initialization
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #undef  DEBUG
  20
  21 #include <linux/module.h>
  22 #include <linux/kernel.h>
  23 #include <linux/types.h>
  24 #include <linux/errno.h>
  25 #include <linux/init.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/delay.h>
  28
  29 #include <asm/io.h>
  30 #include <asm/irq.h>
  31 #include <asm/system.h>
  32 #include <asm/nios.h>
  33
  34 #if defined(CONFIG_USB_SL811_HCD) || defined (CONFIG_USB_SL811_HCD_MODULE)
  35 #if defined(CONFIG_MICROTRONIX_STRATIX) || defined (CONFIG_MICROTRONIX_CYCLONE)
  36
  37 #include <linux/usb_sl811.h>
  38 #define SL811_ADDR ((unsigned int)na_usb)
  39 #define SL811_IRQ na_usb_irq
  40
  41 static void sl811_port_power(struct device *dev, int is_on)
  42 {
  43 }
  44
  45 static  void sl811_port_reset(struct device *dev)
  46 {
  47         writeb(0xA, (SL811_ADDR+8));
  48         mdelay(10);
  49         writeb(4, (SL811_ADDR+8));
  50 }
  51
  52 static struct resource sl811hs_resources[] = {
  53         {
  54                 .start  = (SL811_ADDR),
  55                 .end    = (SL811_ADDR + 3),
  56                 .flags  = IORESOURCE_MEM,
  57         },
  58         {
  59                 .start  = (SL811_ADDR + 4),
  60                 .end    = (SL811_ADDR + 7),
  61                 .flags  = IORESOURCE_MEM,
  62         },
  63         {
  64                 .start  = SL811_IRQ,
  65                 .flags  = IORESOURCE_IRQ,
  66         },
  67 };
  68
  69 static struct sl811_platform_data sl811_data = {
  70         .can_wakeup =   0,
  71         .potpg          =       0,
  72         .power          =       250,
  73         .port_power     =       sl811_port_power,
  74         .reset          =       sl811_port_reset,
  75 };
  76
  77 static struct platform_device sl811hs_device = {
  78         .name                   = "sl811-hcd",
  79         .id                     = -1,
  80         .dev = {
  81                 //.release              = usb_release,
  82                 //.dma_mask             = &ohci_dmamask,
  83                 .coherent_dma_mask      = 0x0fffffff,
  84                 .platform_data = &sl811_data,
  85         },
  86         .num_resources  = ARRAY_SIZE(sl811hs_resources),
  87         .resource               = sl811hs_resources,
  88 };
  89
  90
  91 static int __init mtx_kit_usb_init(void)
  92 {
  93         int status;
  94
  95         status = platform_device_register(&sl811hs_device);
  96         if (status) {
  97                 pr_debug("can't register sl811hs device, %d\n", status);
  98                 return -1;
  99         }
 100
 101         writeb(4, (SL811_ADDR+8));
 102         return 0;
 103 }
 104
 105 subsys_initcall(mtx_kit_usb_init);
 106 #endif /* (CONFIG_MICROTRONIX_STRATIX) || (CONFIG_MICROTRONIX_CYCLONE)*/
 107 #endif  /*(CONFIG_USB_SL811_HCD) ||(CONFIG_USB_SL811_HCD_MODULE) */
 108
 109 #if defined(CONFIG_USB_ISP116X_HCD) || defined (CONFIG_USB_ISP116X_HCD_MODULE)
 110
 111 #include <linux/usb_isp116x.h>
 112
 113 #define ISP116X_HCD_ADDR ((unsigned int)na_usb)
 114 #define ISP116X_HCD_IRQ na_usb_irq
 115
 116 static void isp116x_delay(struct device *dev, int delay)
 117 {
 118         ndelay(delay);
 119 }
 120
 121 static struct resource isp116x_hcd_resources[] = {
 122         {
 123                 .start  = (ISP116X_HCD_ADDR),
 124                 .end    = (ISP116X_HCD_ADDR + 3),
 125                 .flags  = IORESOURCE_MEM,
 126         },
 127         {
 128                 .start  = (ISP116X_HCD_ADDR + 4),
 129                 .end    = (ISP116X_HCD_ADDR + 7),
 130                 .flags  = IORESOURCE_MEM,
 131         },
 132         {
 133                 .start  = ISP116X_HCD_IRQ,
 134                 .flags  = IORESOURCE_IRQ,
 135         },
 136 };
 137
 138 static struct isp116x_platform_data isp116x_data = {
 139                 // Enable internal resistors on downstream ports
 140         .sel15Kres              = 0,
 141         // Clock cannot be stopped
 142         .clknotstop             = 1,
 143         // On-chip overcurrent protection
 144         .oc_enable              = 0,
 145         // INT output polarity
 146         .int_act_high           = 0,
 147         // INT edge or level triggered
 148         .int_edge_triggered     = 0,
 149         // End-of-transfer input polarity
 150         .eot_act_high           = 0,
 151         // DREQ output polarity
 152         .dreq_act_high          = 1,
 153         // WAKEUP pin connected
 154         .remote_wakeup_connected= 0,
 155         // Wakeup by devices on usb bus enabled
 156         .remote_wakeup_enable   = 0,
 157         // Switch or not to switch (keep always powered)
 158         .no_power_switching     = 1,
 159         // Ganged port power switching (0) or individual port power switching (1)
 160         .power_switching_mode   = 0,
 161         .reset                  = NULL /* isp116x_reset */,
 162         .delay                  = isp116x_delay,
 163 };
 164
 165 static struct platform_device isp116x_hcd = {
 166         .name                   = "isp116x-hcd",
 167         .id                     = -1,
 168         .dev = {
 169                 //.release              = usb_release,
 170                 //.dma_mask             = &ohci_dmamask,
 171                 .coherent_dma_mask      = 0x0fffffff,
 172                 .platform_data = &isp116x_data,
 173         },
 174         .num_resources  = ARRAY_SIZE(isp116x_hcd_resources),
 175         .resource               = isp116x_hcd_resources,
 176 };
 177
 178 static int __init usb_hcd_init(void)
 179 {
 180         int status;
 181
 182         status = platform_device_register(&isp116x_hcd);
 183         if (status) {
 184                 pr_debug("can't register isp116x host controller, %d\n", status);
 185                 return -1;
 186         }
 187
 188         return 0;
 189 }
 190 subsys_initcall(usb_hcd_init);
 191 #endif  /*(CONFIG_USB_ISP116X_HCD) ||(CONFIG_USB_ISP116X_HCD_MODULE) */
 192
 193 #if defined(CONFIG_USB_ISP1161X) || defined(CONFIG_USB_ISP1161X_MODULE)
 194 #include <linux/usb_isp116x_dc.h>
 195
 196 #define ISP116X_UDC_ADDR ((unsigned int)na_usb+8)
 197 #define ISP116X_UDC_IRQ  na_int2_usb_irq
 198
 199 static struct resource isp116x_udc_resources[] = {
 200         {
 201                 .start  = (ISP116X_UDC_ADDR),
 202                 .end    = (ISP116X_UDC_ADDR + 3),
 203                 .flags  = IORESOURCE_MEM,
 204         },
 205         {
 206                 .start  = (ISP116X_UDC_ADDR + 4),
 207                 .end    = (ISP116X_UDC_ADDR + 7),
 208                 .flags  = IORESOURCE_MEM,
 209         },
 210         {
 211                 .start  = ISP116X_UDC_IRQ,
 212                 .flags  = IORESOURCE_IRQ,
 213         },
 214 };
 215 static void isp116x_udc_delay()
 216 {
 217         __asm__ __volatile__(
 218         "1:  \n\t"
 219         "    beq    %0,zero,2f\n\t"
 220         "    addi   %0, %0, -1\n\t"
 221         "    br     1b\n\t"
 222         "2:  \n\t"
 223         :
 224         :  "r" (nasys_clock_freq_1000 * 180 / 2000000)
 225         );
 226
 227 }
 228 struct isp116x_dc_platform_data isp116x_udc_data = {
 229         .ext_pullup_enable      =0,
 230         .no_lazy                        =1,
 231         .eot_act_high           =0,
 232         .remote_wakeup_enable=1,
 233         .power_off_enable       =1,
 234         .int_edge_triggered     =0,
 235         .int_act_high           =0,
 236         .clkout_freq            =12,
 237         .delay                          = isp116x_udc_delay
 238 };
 239
 240 static struct platform_device isp116x_udc = {
 241         .name                   = "isp1161a_udc",
 242         .id                     = -1,
 243         .dev = {
 244                 //.release              = usb_release,
 245                 //.dma_mask             = &ohci_dmamask,
 246                 .coherent_dma_mask      = 0x0fffffff,
 247                 .platform_data = &isp116x_udc_data,
 248         },
 249         .num_resources  = ARRAY_SIZE(isp116x_udc_resources),
 250         .resource               = isp116x_udc_resources,
 251 };
 252
 253 static int __init usb_udc_init(void)
 254 {
 255         int status;
 256         np_pio* pio;
 257
 258         status = platform_device_register(&isp116x_udc);
 259         if (status) {
 260                 pr_debug("can't register isp116x device controller, %d\n", status);
 261                 return -1;
 262         }
 263
 264         /* enable interrupts */
 265         pio = (np_pio*)na_int2_usb;
 266         //outw(0, &pio->np_piodata);
 267         //outw(0, &pio->np_pioedgecapture);
 268         outw(1, &pio->np_piointerruptmask);
 269
 270         return 0;
 271 }
 272 subsys_initcall(usb_udc_init);
 273 #endif
 274
 275 #if defined(na_ISP1362_avalonS)  // for DE2 dev board, FIX ME otehrwise
 276 #define na_usb na_ISP1362_avalonS
 277 #define na_usb_irq na_ISP1362_avalonS_irq
 278 #endif
 279
 280 #if defined(na_ISP1362_avalon_slave_0)  // for DE2 dev board, FIX ME otehrwise
 281 #define na_usb na_ISP1362_avalon_slave_0
 282 #define na_usb_irq na_ISP1362_avalon_slave_0_irq
 283 #endif
 284
 285 #if defined(CONFIG_USB_ISP1362_HCD) && defined(na_usb)
 286
 287 #include <linux/usb_isp1362.h>
 288 #define ISP1362_HCD_ADDR ((unsigned int)na_usb)
 289 #define ISP1362_HCD_IRQ na_usb_irq
 290
 291 static struct resource isp1362_hcd_resources[] = {
 292         {
 293                 .start  = (ISP1362_HCD_ADDR),
 294                 .end    = (ISP1362_HCD_ADDR + 3),
 295                 .flags  = IORESOURCE_MEM,
 296         },
 297         {
 298                 .start  = (ISP1362_HCD_ADDR + 4),
 299                 .end    = (ISP1362_HCD_ADDR + 7),
 300                 .flags  = IORESOURCE_MEM,
 301         },
 302         {
 303                 .start  = ISP1362_HCD_IRQ,
 304                 .flags  = IORESOURCE_IRQ,
 305         },
 306 };
 307
 308 static struct isp1362_platform_data isp1362_data = {
 309                 // Enable internal resistors on downstream ports
 310         .sel15Kres      = 1,
 311         // Clock cannot be stopped
 312         .clknotstop     = 0,
 313         // On-chip overcurrent protection
 314         .oc_enable      = 0,
 315         // INT output polarity
 316         .int_act_high   = 0,
 317         // INT edge or level triggered
 318         .int_edge_triggered     = 0,
 319         // WAKEUP pin connected
 320         .remote_wakeup_connected        = 0,
 321         // Switch or not to switch (keep always powered)
 322         .no_power_switching     = 1,
 323         // Ganged port power switching (0) or individual port power switching (1)
 324         .power_switching_mode   = 0,
 325 };
 326
 327 static struct platform_device isp1362_hcd = {
 328         .name                   = "isp1362-hcd",
 329         .id                     = -1,
 330         .dev = {
 331                 //.release              = usb_release,
 332                 //.dma_mask             = &ohci_dmamask,
 333                 .coherent_dma_mask      = 0x0fffffff,
 334                 .platform_data = &isp1362_data,
 335         },
 336         .num_resources  = ARRAY_SIZE(isp1362_hcd_resources),
 337         .resource               = isp1362_hcd_resources,
 338 };
 339
 340 static int __init usb_hcd_init(void)
 341 {
 342         int status;
 343
 344         status = platform_device_register(&isp1362_hcd);
 345         if (status) {
 346                 pr_debug("can't register isp1362 host controller, %d\n", status);
 347                 return -1;
 348         }
 349
 350         return 0;
 351 }
 352 subsys_initcall(usb_hcd_init);
 353 #endif
 354