MIPS: TXx9: Cache fixup
[linux-2.6.git] / arch / mips / txx9 / generic / setup.c
1 /*
2  * linux/arch/mips/txx9/generic/setup.c
3  *
4  * Based on linux/arch/mips/txx9/rbtx4938/setup.c,
5  *          and RBTX49xx patch from CELF patch archive.
6  *
7  * 2003-2005 (c) MontaVista Software, Inc.
8  * (C) Copyright TOSHIBA CORPORATION 2000-2001, 2004-2007
9  *
10  * This file is subject to the terms and conditions of the GNU General Public
11  * License.  See the file "COPYING" in the main directory of this archive
12  * for more details.
13  */
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/types.h>
17 #include <linux/interrupt.h>
18 #include <linux/string.h>
19 #include <linux/module.h>
20 #include <linux/clk.h>
21 #include <linux/err.h>
22 #include <linux/gpio.h>
23 #include <linux/platform_device.h>
24 #include <linux/serial_core.h>
25 #include <asm/bootinfo.h>
26 #include <asm/time.h>
27 #include <asm/reboot.h>
28 #include <asm/r4kcache.h>
29 #include <asm/txx9/generic.h>
30 #include <asm/txx9/pci.h>
31 #ifdef CONFIG_CPU_TX49XX
32 #include <asm/txx9/tx4938.h>
33 #endif
34
35 /* EBUSC settings of TX4927, etc. */
36 struct resource txx9_ce_res[8];
37 static char txx9_ce_res_name[8][4];     /* "CEn" */
38
39 /* pcode, internal register */
40 unsigned int txx9_pcode;
41 char txx9_pcode_str[8];
42 static struct resource txx9_reg_res = {
43         .name = txx9_pcode_str,
44         .flags = IORESOURCE_MEM,
45 };
46 void __init
47 txx9_reg_res_init(unsigned int pcode, unsigned long base, unsigned long size)
48 {
49         int i;
50
51         for (i = 0; i < ARRAY_SIZE(txx9_ce_res); i++) {
52                 sprintf(txx9_ce_res_name[i], "CE%d", i);
53                 txx9_ce_res[i].flags = IORESOURCE_MEM;
54                 txx9_ce_res[i].name = txx9_ce_res_name[i];
55         }
56
57         txx9_pcode = pcode;
58         sprintf(txx9_pcode_str, "TX%x", pcode);
59         if (base) {
60                 txx9_reg_res.start = base & 0xfffffffffULL;
61                 txx9_reg_res.end = (base & 0xfffffffffULL) + (size - 1);
62                 request_resource(&iomem_resource, &txx9_reg_res);
63         }
64 }
65
66 /* clocks */
67 unsigned int txx9_master_clock;
68 unsigned int txx9_cpu_clock;
69 unsigned int txx9_gbus_clock;
70
71 int txx9_ccfg_toeon __initdata = 1;
72
73 /* Minimum CLK support */
74
75 struct clk *clk_get(struct device *dev, const char *id)
76 {
77         if (!strcmp(id, "spi-baseclk"))
78                 return (struct clk *)((unsigned long)txx9_gbus_clock / 2 / 4);
79         if (!strcmp(id, "imbus_clk"))
80                 return (struct clk *)((unsigned long)txx9_gbus_clock / 2);
81         return ERR_PTR(-ENOENT);
82 }
83 EXPORT_SYMBOL(clk_get);
84
85 int clk_enable(struct clk *clk)
86 {
87         return 0;
88 }
89 EXPORT_SYMBOL(clk_enable);
90
91 void clk_disable(struct clk *clk)
92 {
93 }
94 EXPORT_SYMBOL(clk_disable);
95
96 unsigned long clk_get_rate(struct clk *clk)
97 {
98         return (unsigned long)clk;
99 }
100 EXPORT_SYMBOL(clk_get_rate);
101
102 void clk_put(struct clk *clk)
103 {
104 }
105 EXPORT_SYMBOL(clk_put);
106
107 /* GPIO support */
108
109 #ifdef CONFIG_GENERIC_GPIO
110 int gpio_to_irq(unsigned gpio)
111 {
112         return -EINVAL;
113 }
114 EXPORT_SYMBOL(gpio_to_irq);
115
116 int irq_to_gpio(unsigned irq)
117 {
118         return -EINVAL;
119 }
120 EXPORT_SYMBOL(irq_to_gpio);
121 #endif
122
123 #define BOARD_VEC(board)        extern struct txx9_board_vec board;
124 #include <asm/txx9/boards.h>
125 #undef BOARD_VEC
126
127 struct txx9_board_vec *txx9_board_vec __initdata;
128 static char txx9_system_type[32];
129
130 static struct txx9_board_vec *board_vecs[] __initdata = {
131 #define BOARD_VEC(board)        &board,
132 #include <asm/txx9/boards.h>
133 #undef BOARD_VEC
134 };
135
136 static struct txx9_board_vec *__init find_board_byname(const char *name)
137 {
138         int i;
139
140         /* search board_vecs table */
141         for (i = 0; i < ARRAY_SIZE(board_vecs); i++) {
142                 if (strstr(board_vecs[i]->system, name))
143                         return board_vecs[i];
144         }
145         return NULL;
146 }
147
148 static void __init prom_init_cmdline(void)
149 {
150         int argc = (int)fw_arg0;
151         int *argv32 = (int *)fw_arg1;
152         int i;                  /* Always ignore the "-c" at argv[0] */
153         char builtin[CL_SIZE];
154
155         /* ignore all built-in args if any f/w args given */
156         /*
157          * But if built-in strings was started with '+', append them
158          * to command line args.  If built-in was started with '-',
159          * ignore all f/w args.
160          */
161         builtin[0] = '\0';
162         if (arcs_cmdline[0] == '+')
163                 strcpy(builtin, arcs_cmdline + 1);
164         else if (arcs_cmdline[0] == '-') {
165                 strcpy(builtin, arcs_cmdline + 1);
166                 argc = 0;
167         } else if (argc <= 1)
168                 strcpy(builtin, arcs_cmdline);
169         arcs_cmdline[0] = '\0';
170
171         for (i = 1; i < argc; i++) {
172                 char *str = (char *)(long)argv32[i];
173                 if (i != 1)
174                         strcat(arcs_cmdline, " ");
175                 if (strchr(str, ' ')) {
176                         strcat(arcs_cmdline, "\"");
177                         strcat(arcs_cmdline, str);
178                         strcat(arcs_cmdline, "\"");
179                 } else
180                         strcat(arcs_cmdline, str);
181         }
182         /* append saved builtin args */
183         if (builtin[0]) {
184                 if (arcs_cmdline[0])
185                         strcat(arcs_cmdline, " ");
186                 strcat(arcs_cmdline, builtin);
187         }
188 }
189
190 static int txx9_ic_disable __initdata;
191 static int txx9_dc_disable __initdata;
192
193 #if defined(CONFIG_CPU_TX49XX)
194 /* flush all cache on very early stage (before 4k_cache_init) */
195 static void __init early_flush_dcache(void)
196 {
197         unsigned int conf = read_c0_config();
198         unsigned int dc_size = 1 << (12 + ((conf & CONF_DC) >> 6));
199         unsigned int linesz = 32;
200         unsigned long addr, end;
201
202         end = INDEX_BASE + dc_size / 4;
203         /* 4way, waybit=0 */
204         for (addr = INDEX_BASE; addr < end; addr += linesz) {
205                 cache_op(Index_Writeback_Inv_D, addr | 0);
206                 cache_op(Index_Writeback_Inv_D, addr | 1);
207                 cache_op(Index_Writeback_Inv_D, addr | 2);
208                 cache_op(Index_Writeback_Inv_D, addr | 3);
209         }
210 }
211
212 static void __init txx9_cache_fixup(void)
213 {
214         unsigned int conf;
215
216         conf = read_c0_config();
217         /* flush and disable */
218         if (txx9_ic_disable) {
219                 conf |= TX49_CONF_IC;
220                 write_c0_config(conf);
221         }
222         if (txx9_dc_disable) {
223                 early_flush_dcache();
224                 conf |= TX49_CONF_DC;
225                 write_c0_config(conf);
226         }
227
228         /* enable cache */
229         conf = read_c0_config();
230         if (!txx9_ic_disable)
231                 conf &= ~TX49_CONF_IC;
232         if (!txx9_dc_disable)
233                 conf &= ~TX49_CONF_DC;
234         write_c0_config(conf);
235
236         if (conf & TX49_CONF_IC)
237                 pr_info("TX49XX I-Cache disabled.\n");
238         if (conf & TX49_CONF_DC)
239                 pr_info("TX49XX D-Cache disabled.\n");
240 }
241 #elif defined(CONFIG_CPU_TX39XX)
242 /* flush all cache on very early stage (before tx39_cache_init) */
243 static void __init early_flush_dcache(void)
244 {
245         unsigned int conf = read_c0_config();
246         unsigned int dc_size = 1 << (10 + ((conf & TX39_CONF_DCS_MASK) >>
247                                            TX39_CONF_DCS_SHIFT));
248         unsigned int linesz = 16;
249         unsigned long addr, end;
250
251         end = INDEX_BASE + dc_size / 2;
252         /* 2way, waybit=0 */
253         for (addr = INDEX_BASE; addr < end; addr += linesz) {
254                 cache_op(Index_Writeback_Inv_D, addr | 0);
255                 cache_op(Index_Writeback_Inv_D, addr | 1);
256         }
257 }
258
259 static void __init txx9_cache_fixup(void)
260 {
261         unsigned int conf;
262
263         conf = read_c0_config();
264         /* flush and disable */
265         if (txx9_ic_disable) {
266                 conf &= ~TX39_CONF_ICE;
267                 write_c0_config(conf);
268         }
269         if (txx9_dc_disable) {
270                 early_flush_dcache();
271                 conf &= ~TX39_CONF_DCE;
272                 write_c0_config(conf);
273         }
274
275         /* enable cache */
276         conf = read_c0_config();
277         if (!txx9_ic_disable)
278                 conf |= TX39_CONF_ICE;
279         if (!txx9_dc_disable)
280                 conf |= TX39_CONF_DCE;
281         write_c0_config(conf);
282
283         if (!(conf & TX39_CONF_ICE))
284                 pr_info("TX39XX I-Cache disabled.\n");
285         if (!(conf & TX39_CONF_DCE))
286                 pr_info("TX39XX D-Cache disabled.\n");
287 }
288 #else
289 static inline void txx9_cache_fixup(void)
290 {
291 }
292 #endif
293
294 static void __init preprocess_cmdline(void)
295 {
296         char cmdline[CL_SIZE];
297         char *s;
298
299         strcpy(cmdline, arcs_cmdline);
300         s = cmdline;
301         arcs_cmdline[0] = '\0';
302         while (s && *s) {
303                 char *str = strsep(&s, " ");
304                 if (strncmp(str, "board=", 6) == 0) {
305                         txx9_board_vec = find_board_byname(str + 6);
306                         continue;
307                 } else if (strncmp(str, "masterclk=", 10) == 0) {
308                         unsigned long val;
309                         if (strict_strtoul(str + 10, 10, &val) == 0)
310                                 txx9_master_clock = val;
311                         continue;
312                 } else if (strcmp(str, "icdisable") == 0) {
313                         txx9_ic_disable = 1;
314                         continue;
315                 } else if (strcmp(str, "dcdisable") == 0) {
316                         txx9_dc_disable = 1;
317                         continue;
318                 }
319                 if (arcs_cmdline[0])
320                         strcat(arcs_cmdline, " ");
321                 strcat(arcs_cmdline, str);
322         }
323
324         txx9_cache_fixup();
325 }
326
327 static void __init select_board(void)
328 {
329         const char *envstr;
330
331         /* first, determine by "board=" argument in preprocess_cmdline() */
332         if (txx9_board_vec)
333                 return;
334         /* next, determine by "board" envvar */
335         envstr = prom_getenv("board");
336         if (envstr) {
337                 txx9_board_vec = find_board_byname(envstr);
338                 if (txx9_board_vec)
339                         return;
340         }
341
342         /* select "default" board */
343 #ifdef CONFIG_CPU_TX39XX
344         txx9_board_vec = &jmr3927_vec;
345 #endif
346 #ifdef CONFIG_CPU_TX49XX
347         switch (TX4938_REV_PCODE()) {
348 #ifdef CONFIG_TOSHIBA_RBTX4927
349         case 0x4927:
350                 txx9_board_vec = &rbtx4927_vec;
351                 break;
352         case 0x4937:
353                 txx9_board_vec = &rbtx4937_vec;
354                 break;
355 #endif
356 #ifdef CONFIG_TOSHIBA_RBTX4938
357         case 0x4938:
358                 txx9_board_vec = &rbtx4938_vec;
359                 break;
360 #endif
361         }
362 #endif
363 }
364
365 void __init prom_init(void)
366 {
367         prom_init_cmdline();
368         preprocess_cmdline();
369         select_board();
370
371         strcpy(txx9_system_type, txx9_board_vec->system);
372
373         txx9_board_vec->prom_init();
374 }
375
376 void __init prom_free_prom_memory(void)
377 {
378 }
379
380 const char *get_system_type(void)
381 {
382         return txx9_system_type;
383 }
384
385 char * __init prom_getcmdline(void)
386 {
387         return &(arcs_cmdline[0]);
388 }
389
390 const char *__init prom_getenv(const char *name)
391 {
392         const s32 *str = (const s32 *)fw_arg2;
393
394         if (!str)
395                 return NULL;
396         /* YAMON style ("name", "value" pairs) */
397         while (str[0] && str[1]) {
398                 if (!strcmp((const char *)(unsigned long)str[0], name))
399                         return (const char *)(unsigned long)str[1];
400                 str += 2;
401         }
402         return NULL;
403 }
404
405 static void __noreturn txx9_machine_halt(void)
406 {
407         local_irq_disable();
408         clear_c0_status(ST0_IM);
409         while (1) {
410                 if (cpu_wait) {
411                         (*cpu_wait)();
412                         if (cpu_has_counter) {
413                                 /*
414                                  * Clear counter interrupt while it
415                                  * breaks WAIT instruction even if
416                                  * masked.
417                                  */
418                                 write_c0_compare(0);
419                         }
420                 }
421         }
422 }
423
424 /* Watchdog support */
425 void __init txx9_wdt_init(unsigned long base)
426 {
427         struct resource res = {
428                 .start  = base,
429                 .end    = base + 0x100 - 1,
430                 .flags  = IORESOURCE_MEM,
431         };
432         platform_device_register_simple("txx9wdt", -1, &res, 1);
433 }
434
435 /* SPI support */
436 void __init txx9_spi_init(int busid, unsigned long base, int irq)
437 {
438         struct resource res[] = {
439                 {
440                         .start  = base,
441                         .end    = base + 0x20 - 1,
442                         .flags  = IORESOURCE_MEM,
443                 }, {
444                         .start  = irq,
445                         .flags  = IORESOURCE_IRQ,
446                 },
447         };
448         platform_device_register_simple("spi_txx9", busid,
449                                         res, ARRAY_SIZE(res));
450 }
451
452 void __init txx9_ethaddr_init(unsigned int id, unsigned char *ethaddr)
453 {
454         struct platform_device *pdev =
455                 platform_device_alloc("tc35815-mac", id);
456         if (!pdev ||
457             platform_device_add_data(pdev, ethaddr, 6) ||
458             platform_device_add(pdev))
459                 platform_device_put(pdev);
460 }
461
462 void __init txx9_sio_init(unsigned long baseaddr, int irq,
463                           unsigned int line, unsigned int sclk, int nocts)
464 {
465 #ifdef CONFIG_SERIAL_TXX9
466         struct uart_port req;
467
468         memset(&req, 0, sizeof(req));
469         req.line = line;
470         req.iotype = UPIO_MEM;
471         req.membase = ioremap(baseaddr, 0x24);
472         req.mapbase = baseaddr;
473         req.irq = irq;
474         if (!nocts)
475                 req.flags |= UPF_BUGGY_UART /*HAVE_CTS_LINE*/;
476         if (sclk) {
477                 req.flags |= UPF_MAGIC_MULTIPLIER /*USE_SCLK*/;
478                 req.uartclk = sclk;
479         } else
480                 req.uartclk = TXX9_IMCLK;
481         early_serial_txx9_setup(&req);
482 #endif /* CONFIG_SERIAL_TXX9 */
483 }
484
485 #ifdef CONFIG_EARLY_PRINTK
486 static void __init null_prom_putchar(char c)
487 {
488 }
489 void (*txx9_prom_putchar)(char c) __initdata = null_prom_putchar;
490
491 void __init prom_putchar(char c)
492 {
493         txx9_prom_putchar(c);
494 }
495
496 static void __iomem *early_txx9_sio_port;
497
498 static void __init early_txx9_sio_putchar(char c)
499 {
500 #define TXX9_SICISR     0x0c
501 #define TXX9_SITFIFO    0x1c
502 #define TXX9_SICISR_TXALS       0x00000002
503         while (!(__raw_readl(early_txx9_sio_port + TXX9_SICISR) &
504                  TXX9_SICISR_TXALS))
505                 ;
506         __raw_writel(c, early_txx9_sio_port + TXX9_SITFIFO);
507 }
508
509 void __init txx9_sio_putchar_init(unsigned long baseaddr)
510 {
511         early_txx9_sio_port = ioremap(baseaddr, 0x24);
512         txx9_prom_putchar = early_txx9_sio_putchar;
513 }
514 #endif /* CONFIG_EARLY_PRINTK */
515
516 /* wrappers */
517 void __init plat_mem_setup(void)
518 {
519         ioport_resource.start = 0;
520         ioport_resource.end = ~0UL;     /* no limit */
521         iomem_resource.start = 0;
522         iomem_resource.end = ~0UL;      /* no limit */
523
524         /* fallback restart/halt routines */
525         _machine_restart = (void (*)(char *))txx9_machine_halt;
526         _machine_halt = txx9_machine_halt;
527         pm_power_off = txx9_machine_halt;
528
529 #ifdef CONFIG_PCI
530         pcibios_plat_setup = txx9_pcibios_setup;
531 #endif
532         txx9_board_vec->mem_setup();
533 }
534
535 void __init arch_init_irq(void)
536 {
537         txx9_board_vec->irq_setup();
538 }
539
540 void __init plat_time_init(void)
541 {
542 #ifdef CONFIG_CPU_TX49XX
543         mips_hpt_frequency = txx9_cpu_clock / 2;
544 #endif
545         txx9_board_vec->time_init();
546 }
547
548 static int __init _txx9_arch_init(void)
549 {
550         if (txx9_board_vec->arch_init)
551                 txx9_board_vec->arch_init();
552         return 0;
553 }
554 arch_initcall(_txx9_arch_init);
555
556 static int __init _txx9_device_init(void)
557 {
558         if (txx9_board_vec->device_init)
559                 txx9_board_vec->device_init();
560         return 0;
561 }
562 device_initcall(_txx9_device_init);
563
564 int (*txx9_irq_dispatch)(int pending);
565 asmlinkage void plat_irq_dispatch(void)
566 {
567         int pending = read_c0_status() & read_c0_cause() & ST0_IM;
568         int irq = txx9_irq_dispatch(pending);
569
570         if (likely(irq >= 0))
571                 do_IRQ(irq);
572         else
573                 spurious_interrupt();
574 }
575
576 /* see include/asm-mips/mach-tx39xx/mangle-port.h, for example. */
577 #ifdef NEEDS_TXX9_SWIZZLE_ADDR_B
578 static unsigned long __swizzle_addr_none(unsigned long port)
579 {
580         return port;
581 }
582 unsigned long (*__swizzle_addr_b)(unsigned long port) = __swizzle_addr_none;
583 EXPORT_SYMBOL(__swizzle_addr_b);
584 #endif