arch/mips/txx9/rbtx4927/setup.c

   1 /*
   2  * Toshiba rbtx4927 specific setup
   3  *
   4  * Author: MontaVista Software, Inc.
   5  *         source@mvista.com
   6  *
   7  * Copyright 2001-2002 MontaVista Software Inc.
   8  *
   9  * Copyright (C) 1996, 97, 2001, 04  Ralf Baechle (ralf@linux-mips.org)
  10  * Copyright (C) 2000 RidgeRun, Inc.
  11  * Author: RidgeRun, Inc.
  12  *   glonnon@ridgerun.com, skranz@ridgerun.com, stevej@ridgerun.com
  13  *
  14  * Copyright 2001 MontaVista Software Inc.
  15  * Author: jsun@mvista.com or jsun@junsun.net
  16  *
  17  * Copyright 2002 MontaVista Software Inc.
  18  * Author: Michael Pruznick, michael_pruznick@mvista.com
  19  *
  20  * Copyright (C) 2000-2001 Toshiba Corporation
  21  *
  22  * Copyright (C) 2004 MontaVista Software Inc.
  23  * Author: Manish Lachwani, mlachwani@mvista.com
  24  *
  25  *  This program is free software; you can redistribute it and/or modify it
  26  *  under the terms of the GNU General Public License as published by the
  27  *  Free Software Foundation; either version 2 of the License, or (at your
  28  *  option) any later version.
  29  *
  30  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  31  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  32  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  33  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  35  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  36  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  37  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  38  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  39  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  *  You should have received a copy of the GNU General Public License along
  42  *  with this program; if not, write to the Free Software Foundation, Inc.,
  43  *  675 Mass Ave, Cambridge, MA 02139, USA.
  44  */
  45 #include <linux/init.h>
  46 #include <linux/kernel.h>
  47 #include <linux/types.h>
  48 #include <linux/ioport.h>
  49 #include <linux/interrupt.h>
  50 #include <linux/pm.h>
  51 #include <linux/platform_device.h>
  52 #include <linux/clk.h>
  53 #include <linux/delay.h>
  54
  55 #include <asm/bootinfo.h>
  56 #include <asm/io.h>
  57 #include <asm/processor.h>
  58 #include <asm/reboot.h>
  59 #include <asm/time.h>
  60 #include <asm/txx9tmr.h>
  61 #include <asm/txx9/generic.h>
  62 #include <asm/txx9/pci.h>
  63 #include <asm/txx9/rbtx4927.h>
  64 #include <asm/txx9/tx4938.h>    /* for TX4937 */
  65 #ifdef CONFIG_SERIAL_TXX9
  66 #include <linux/serial_core.h>
  67 #endif
  68
  69 /* These functions are used for rebooting or halting the machine*/
  70 extern void toshiba_rbtx4927_restart(char *command);
  71 extern void toshiba_rbtx4927_halt(void);
  72 extern void toshiba_rbtx4927_power_off(void);
  73 extern void toshiba_rbtx4927_irq_setup(void);
  74
  75 char *prom_getcmdline(void);
  76
  77 static int tx4927_ccfg_toeon = 1;
  78
  79 char *toshiba_name = "";
  80
  81 #ifdef CONFIG_PCI
  82 static void __init tx4927_pci_setup(void)
  83 {
  84         int extarb = !(__raw_readq(&tx4927_ccfgptr->ccfg) & TX4927_CCFG_PCIARB);
  85         struct pci_controller *c = &txx9_primary_pcic;
  86
  87         register_pci_controller(c);
  88
  89         if (__raw_readq(&tx4927_ccfgptr->ccfg) & TX4927_CCFG_PCI66)
  90                 txx9_pci_option =
  91                         (txx9_pci_option & ~TXX9_PCI_OPT_CLK_MASK) |
  92                         TXX9_PCI_OPT_CLK_66; /* already configured */
  93
  94         /* Reset PCI Bus */
  95         writeb(1, rbtx4927_pcireset_addr);
  96         /* Reset PCIC */
  97         txx9_set64(&tx4927_ccfgptr->clkctr, TX4927_CLKCTR_PCIRST);
  98         if ((txx9_pci_option & TXX9_PCI_OPT_CLK_MASK) ==
  99             TXX9_PCI_OPT_CLK_66)
 100                 tx4927_pciclk66_setup();
 101         mdelay(10);
 102         /* clear PCIC reset */
 103         txx9_clear64(&tx4927_ccfgptr->clkctr, TX4927_CLKCTR_PCIRST);
 104         writeb(0, rbtx4927_pcireset_addr);
 105         iob();
 106
 107         tx4927_report_pciclk();
 108         tx4927_pcic_setup(tx4927_pcicptr, c, extarb);
 109         if ((txx9_pci_option & TXX9_PCI_OPT_CLK_MASK) ==
 110             TXX9_PCI_OPT_CLK_AUTO &&
 111             txx9_pci66_check(c, 0, 0)) {
 112                 /* Reset PCI Bus */
 113                 writeb(1, rbtx4927_pcireset_addr);
 114                 /* Reset PCIC */
 115                 txx9_set64(&tx4927_ccfgptr->clkctr, TX4927_CLKCTR_PCIRST);
 116                 tx4927_pciclk66_setup();
 117                 mdelay(10);
 118                 /* clear PCIC reset */
 119                 txx9_clear64(&tx4927_ccfgptr->clkctr, TX4927_CLKCTR_PCIRST);
 120                 writeb(0, rbtx4927_pcireset_addr);
 121                 iob();
 122                 /* Reinitialize PCIC */
 123                 tx4927_report_pciclk();
 124                 tx4927_pcic_setup(tx4927_pcicptr, c, extarb);
 125         }
 126 }
 127
 128 static void __init tx4937_pci_setup(void)
 129 {
 130         int extarb = !(__raw_readq(&tx4938_ccfgptr->ccfg) & TX4938_CCFG_PCIARB);
 131         struct pci_controller *c = &txx9_primary_pcic;
 132
 133         register_pci_controller(c);
 134
 135         if (__raw_readq(&tx4938_ccfgptr->ccfg) & TX4938_CCFG_PCI66)
 136                 txx9_pci_option =
 137                         (txx9_pci_option & ~TXX9_PCI_OPT_CLK_MASK) |
 138                         TXX9_PCI_OPT_CLK_66; /* already configured */
 139
 140         /* Reset PCI Bus */
 141         writeb(1, rbtx4927_pcireset_addr);
 142         /* Reset PCIC */
 143         txx9_set64(&tx4938_ccfgptr->clkctr, TX4938_CLKCTR_PCIRST);
 144         if ((txx9_pci_option & TXX9_PCI_OPT_CLK_MASK) ==
 145             TXX9_PCI_OPT_CLK_66)
 146                 tx4938_pciclk66_setup();
 147         mdelay(10);
 148         /* clear PCIC reset */
 149         txx9_clear64(&tx4938_ccfgptr->clkctr, TX4938_CLKCTR_PCIRST);
 150         writeb(0, rbtx4927_pcireset_addr);
 151         iob();
 152
 153         tx4938_report_pciclk();
 154         tx4927_pcic_setup(tx4938_pcicptr, c, extarb);
 155         if ((txx9_pci_option & TXX9_PCI_OPT_CLK_MASK) ==
 156             TXX9_PCI_OPT_CLK_AUTO &&
 157             txx9_pci66_check(c, 0, 0)) {
 158                 /* Reset PCI Bus */
 159                 writeb(1, rbtx4927_pcireset_addr);
 160                 /* Reset PCIC */
 161                 txx9_set64(&tx4938_ccfgptr->clkctr, TX4938_CLKCTR_PCIRST);
 162                 tx4938_pciclk66_setup();
 163                 mdelay(10);
 164                 /* clear PCIC reset */
 165                 txx9_clear64(&tx4938_ccfgptr->clkctr, TX4938_CLKCTR_PCIRST);
 166                 writeb(0, rbtx4927_pcireset_addr);
 167                 iob();
 168                 /* Reinitialize PCIC */
 169                 tx4938_report_pciclk();
 170                 tx4927_pcic_setup(tx4938_pcicptr, c, extarb);
 171         }
 172 }
 173
 174 static int __init rbtx4927_arch_init(void)
 175 {
 176         if (mips_machtype == MACH_TOSHIBA_RBTX4937)
 177                 tx4937_pci_setup();
 178         else
 179                 tx4927_pci_setup();
 180         return 0;
 181 }
 182 arch_initcall(rbtx4927_arch_init);
 183 #endif /* CONFIG_PCI */
 184
 185 static void __noreturn wait_forever(void)
 186 {
 187         while (1)
 188                 if (cpu_wait)
 189                         (*cpu_wait)();
 190 }
 191
 192 void toshiba_rbtx4927_restart(char *command)
 193 {
 194         printk(KERN_NOTICE "System Rebooting...\n");
 195
 196         /* enable the s/w reset register */
 197         writeb(RBTX4927_SW_RESET_ENABLE_SET, RBTX4927_SW_RESET_ENABLE);
 198
 199         /* wait for enable to be seen */
 200         while ((readb(RBTX4927_SW_RESET_ENABLE) &
 201                 RBTX4927_SW_RESET_ENABLE_SET) == 0x00);
 202
 203         /* do a s/w reset */
 204         writeb(RBTX4927_SW_RESET_DO_SET, RBTX4927_SW_RESET_DO);
 205
 206         /* do something passive while waiting for reset */
 207         local_irq_disable();
 208         wait_forever();
 209         /* no return */
 210 }
 211
 212 void toshiba_rbtx4927_halt(void)
 213 {
 214         printk(KERN_NOTICE "System Halted\n");
 215         local_irq_disable();
 216         wait_forever();
 217         /* no return */
 218 }
 219
 220 void toshiba_rbtx4927_power_off(void)
 221 {
 222         toshiba_rbtx4927_halt();
 223         /* no return */
 224 }
 225
 226 void __init plat_mem_setup(void)
 227 {
 228         int i;
 229         u32 cp0_config;
 230         char *argptr;
 231
 232         printk("CPU is %s\n", toshiba_name);
 233
 234         /* f/w leaves this on at startup */
 235         clear_c0_status(ST0_ERL);
 236
 237         /* enable caches -- HCP5 does this, pmon does not */
 238         cp0_config = read_c0_config();
 239         cp0_config = cp0_config & ~(TX49_CONF_IC | TX49_CONF_DC);
 240         write_c0_config(cp0_config);
 241
 242         ioport_resource.end = 0xffffffff;
 243         iomem_resource.end = 0xffffffff;
 244
 245         _machine_restart = toshiba_rbtx4927_restart;
 246         _machine_halt = toshiba_rbtx4927_halt;
 247         pm_power_off = toshiba_rbtx4927_power_off;
 248
 249         for (i = 0; i < TX4927_NR_TMR; i++)
 250                 txx9_tmr_init(TX4927_TMR_REG(0) & 0xfffffffffULL);
 251
 252 #ifdef CONFIG_PCI
 253         txx9_alloc_pci_controller(&txx9_primary_pcic,
 254                                   RBTX4927_PCIMEM, RBTX4927_PCIMEM_SIZE,
 255                                   RBTX4927_PCIIO, RBTX4927_PCIIO_SIZE);
 256 #else
 257         set_io_port_base(KSEG1 + RBTX4927_ISA_IO_OFFSET);
 258 #endif
 259
 260         /*
 261            * ASSUMPTION: PCIDIVMODE is configured for PCI 33MHz or 66MHz.
 262            *
 263            * For TX4927:
 264            * PCIDIVMODE[12:11]'s initial value is given by S9[4:3] (ON:0, OFF:1).
 265            * CPU 166MHz: PCI 66MHz : PCIDIVMODE: 00 (1/2.5)
 266            * CPU 200MHz: PCI 66MHz : PCIDIVMODE: 01 (1/3)
 267            * CPU 166MHz: PCI 33MHz : PCIDIVMODE: 10 (1/5)
 268            * CPU 200MHz: PCI 33MHz : PCIDIVMODE: 11 (1/6)
 269            * i.e. S9[3]: ON (83MHz), OFF (100MHz)
 270            *
 271            * For TX4937:
 272            * PCIDIVMODE[12:11]'s initial value is given by S1[5:4] (ON:0, OFF:1)
 273            * PCIDIVMODE[10] is 0.
 274            * CPU 266MHz: PCI 33MHz : PCIDIVMODE: 000 (1/8)
 275            * CPU 266MHz: PCI 66MHz : PCIDIVMODE: 001 (1/4)
 276            * CPU 300MHz: PCI 33MHz : PCIDIVMODE: 010 (1/9)
 277            * CPU 300MHz: PCI 66MHz : PCIDIVMODE: 011 (1/4.5)
 278            * CPU 333MHz: PCI 33MHz : PCIDIVMODE: 100 (1/10)
 279            * CPU 333MHz: PCI 66MHz : PCIDIVMODE: 101 (1/5)
 280            *
 281          */
 282         if (mips_machtype == MACH_TOSHIBA_RBTX4937)
 283                 switch ((unsigned long)__raw_readq(&tx4938_ccfgptr->ccfg) &
 284                         TX4938_CCFG_PCIDIVMODE_MASK) {
 285                 case TX4938_CCFG_PCIDIVMODE_8:
 286                 case TX4938_CCFG_PCIDIVMODE_4:
 287                         txx9_cpu_clock = 266666666;     /* 266MHz */
 288                         break;
 289                 case TX4938_CCFG_PCIDIVMODE_9:
 290                 case TX4938_CCFG_PCIDIVMODE_4_5:
 291                         txx9_cpu_clock = 300000000;     /* 300MHz */
 292                         break;
 293                 default:
 294                         txx9_cpu_clock = 333333333;     /* 333MHz */
 295                 }
 296         else
 297                 switch ((unsigned long)__raw_readq(&tx4927_ccfgptr->ccfg) &
 298                         TX4927_CCFG_PCIDIVMODE_MASK) {
 299                 case TX4927_CCFG_PCIDIVMODE_2_5:
 300                 case TX4927_CCFG_PCIDIVMODE_5:
 301                         txx9_cpu_clock = 166666666;     /* 166MHz */
 302                         break;
 303                 default:
 304                         txx9_cpu_clock = 200000000;     /* 200MHz */
 305                 }
 306         /* change default value to udelay/mdelay take reasonable time */
 307         loops_per_jiffy = txx9_cpu_clock / HZ / 2;
 308
 309         /* CCFG */
 310         /* do reset on watchdog */
 311         tx4927_ccfg_set(TX4927_CCFG_WR);
 312         /* enable Timeout BusError */
 313         if (tx4927_ccfg_toeon)
 314                 tx4927_ccfg_set(TX4927_CCFG_TOE);
 315
 316 #ifdef CONFIG_SERIAL_TXX9
 317         {
 318                 extern int early_serial_txx9_setup(struct uart_port *port);
 319                 struct uart_port req;
 320                 for(i = 0; i < 2; i++) {
 321                         memset(&req, 0, sizeof(req));
 322                         req.line = i;
 323                         req.iotype = UPIO_MEM;
 324                         req.membase = (char *)(0xff1ff300 + i * 0x100);
 325                         req.mapbase = 0xff1ff300 + i * 0x100;
 326                         req.irq = TX4927_IRQ_PIC_BEG + 8 + i;
 327                         req.flags |= UPF_BUGGY_UART /*HAVE_CTS_LINE*/;
 328                         req.uartclk = 50000000;
 329                         early_serial_txx9_setup(&req);
 330                 }
 331         }
 332 #ifdef CONFIG_SERIAL_TXX9_CONSOLE
 333         argptr = prom_getcmdline();
 334         if (strstr(argptr, "console=") == NULL) {
 335                 strcat(argptr, " console=ttyS0,38400");
 336         }
 337 #endif
 338 #endif
 339
 340 #ifdef CONFIG_ROOT_NFS
 341         argptr = prom_getcmdline();
 342         if (strstr(argptr, "root=") == NULL) {
 343                 strcat(argptr, " root=/dev/nfs rw");
 344         }
 345 #endif
 346
 347 #ifdef CONFIG_IP_PNP
 348         argptr = prom_getcmdline();
 349         if (strstr(argptr, "ip=") == NULL) {
 350                 strcat(argptr, " ip=any");
 351         }
 352 #endif
 353 }
 354
 355 void __init plat_time_init(void)
 356 {
 357         mips_hpt_frequency = txx9_cpu_clock / 2;
 358         if (____raw_readq(&tx4927_ccfgptr->ccfg) & TX4927_CCFG_TINTDIS)
 359                 txx9_clockevent_init(TX4927_TMR_REG(0) & 0xfffffffffULL,
 360                                      TXX9_IRQ_BASE + 17,
 361                                      50000000);
 362 }
 363
 364 static int __init toshiba_rbtx4927_rtc_init(void)
 365 {
 366         static struct resource __initdata res = {
 367                 .start  = 0x1c010000,
 368                 .end    = 0x1c010000 + 0x800 - 1,
 369                 .flags  = IORESOURCE_MEM,
 370         };
 371         struct platform_device *dev =
 372                 platform_device_register_simple("rtc-ds1742", -1, &res, 1);
 373         return IS_ERR(dev) ? PTR_ERR(dev) : 0;
 374 }
 375 device_initcall(toshiba_rbtx4927_rtc_init);
 376
 377 static int __init rbtx4927_ne_init(void)
 378 {
 379         static struct resource __initdata res[] = {
 380                 {
 381                         .start  = RBTX4927_RTL_8019_BASE,
 382                         .end    = RBTX4927_RTL_8019_BASE + 0x20 - 1,
 383                         .flags  = IORESOURCE_IO,
 384                 }, {
 385                         .start  = RBTX4927_RTL_8019_IRQ,
 386                         .flags  = IORESOURCE_IRQ,
 387                 }
 388         };
 389         struct platform_device *dev =
 390                 platform_device_register_simple("ne", -1,
 391                                                 res, ARRAY_SIZE(res));
 392         return IS_ERR(dev) ? PTR_ERR(dev) : 0;
 393 }
 394 device_initcall(rbtx4927_ne_init);
 395
 396 /* Watchdog support */
 397
 398 static int __init txx9_wdt_init(unsigned long base)
 399 {
 400         struct resource res = {
 401                 .start  = base,
 402                 .end    = base + 0x100 - 1,
 403                 .flags  = IORESOURCE_MEM,
 404         };
 405         struct platform_device *dev =
 406                 platform_device_register_simple("txx9wdt", -1, &res, 1);
 407         return IS_ERR(dev) ? PTR_ERR(dev) : 0;
 408 }
 409
 410 static int __init rbtx4927_wdt_init(void)
 411 {
 412         return txx9_wdt_init(TX4927_TMR_REG(2) & 0xfffffffffULL);
 413 }
 414 device_initcall(rbtx4927_wdt_init);
 415
 416 /* Minimum CLK support */
 417
 418 struct clk *clk_get(struct device *dev, const char *id)
 419 {
 420         if (!strcmp(id, "imbus_clk"))
 421                 return (struct clk *)50000000;
 422         return ERR_PTR(-ENOENT);
 423 }
 424 EXPORT_SYMBOL(clk_get);
 425
 426 int clk_enable(struct clk *clk)
 427 {
 428         return 0;
 429 }
 430 EXPORT_SYMBOL(clk_enable);
 431
 432 void clk_disable(struct clk *clk)
 433 {
 434 }
 435 EXPORT_SYMBOL(clk_disable);
 436
 437 unsigned long clk_get_rate(struct clk *clk)
 438 {
 439         return (unsigned long)clk;
 440 }
 441 EXPORT_SYMBOL(clk_get_rate);
 442
 443 void clk_put(struct clk *clk)
 444 {
 445 }
 446 EXPORT_SYMBOL(clk_put);