?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.25-rc4
[linux-2.6/next.git] / arch / mips / tx4938 / toshiba_rbtx4938 / setup.c
blob61249f049cd6d3c1c348d9ea7c149eb3b1d4ce7a
1 /*
2 * linux/arch/mips/tx4938/toshiba_rbtx4938/setup.c
3 *
4 * Setup pointers to hardware-dependent routines.
5 * Copyright (C) 2000-2001 Toshiba Corporation
6 *
7 * 2003-2005 (c) MontaVista Software, Inc. This file is licensed under the
8 * terms of the GNU General Public License version 2. This program is
9 * licensed "as is" without any warranty of any kind, whether express
10 * or implied.
11 *
12 * Support for TX4938 in 2.6 - Manish Lachwani (mlachwani@mvista.com)
13 */
14 #include <linux/init.h>
15 #include <linux/types.h>
16 #include <linux/ioport.h>
17 #include <linux/delay.h>
18 #include <linux/interrupt.h>
19 #include <linux/console.h>
20 #include <linux/pci.h>
21 #include <linux/pm.h>
22 #include <linux/platform_device.h>
23 #include <linux/clk.h>
24
25 #include <asm/wbflush.h>
26 #include <asm/reboot.h>
27 #include <asm/time.h>
28 #include <asm/txx9tmr.h>
29 #include <asm/io.h>
30 #include <asm/bootinfo.h>
31 #include <asm/tx4938/rbtx4938.h>
32 #ifdef CONFIG_SERIAL_TXX9
33 #include <linux/serial_core.h>
34 #endif
35 #include <linux/spi/spi.h>
36 #include <asm/tx4938/spi.h>
37 #include <asm/gpio.h>
38
39 extern char * __init prom_getcmdline(void);
40 static inline void tx4938_report_pcic_status1(struct tx4938_pcic_reg *pcicptr);
41
42 /* These functions are used for rebooting or halting the machine*/
43 extern void rbtx4938_machine_restart(char *command);
44 extern void rbtx4938_machine_halt(void);
45 extern void rbtx4938_machine_power_off(void);
46
47 /* clocks */
48 unsigned int txx9_master_clock;
49 unsigned int txx9_cpu_clock;
50 unsigned int txx9_gbus_clock;
51
52 unsigned long rbtx4938_ce_base[8];
53 unsigned long rbtx4938_ce_size[8];
54 int txboard_pci66_mode;
55 static int tx4938_pcic_trdyto; /* default: disabled */
56 static int tx4938_pcic_retryto; /* default: disabled */
57 static int tx4938_ccfg_toeon = 1;
58
59 struct tx4938_pcic_reg *pcicptrs[4] = {
60 tx4938_pcicptr /* default setting for TX4938 */
61 };
62
63 static struct {
64 unsigned long base;
65 unsigned long size;
66 } phys_regions[16] __initdata;
67 static int num_phys_regions __initdata;
68
69 #define PHYS_REGION_MINSIZE 0x10000
70
71 void rbtx4938_machine_halt(void)
72 {
73 printk(KERN_NOTICE "System Halted\n");
74 local_irq_disable();
75
76 while (1)
77 __asm__(".set\tmips3\n\t"
78 "wait\n\t"
79 ".set\tmips0");
80 }
81
82 void rbtx4938_machine_power_off(void)
83 {
84 rbtx4938_machine_halt();
85 /* no return */
86 }
87
88 void rbtx4938_machine_restart(char *command)
89 {
90 local_irq_disable();
91
92 printk("Rebooting...");
93 *rbtx4938_softresetlock_ptr = 1;
94 *rbtx4938_sfvol_ptr = 1;
95 *rbtx4938_softreset_ptr = 1;
96 wbflush();
97
98 while(1);
99 }
100
101 void __init
102 txboard_add_phys_region(unsigned long base, unsigned long size)
103 {
104 if (num_phys_regions >= ARRAY_SIZE(phys_regions)) {
105 printk("phys_region overflow\n");
106 return;
107 }
108 phys_regions[num_phys_regions].base = base;
109 phys_regions[num_phys_regions].size = size;
110 num_phys_regions++;
111 }
112 unsigned long __init
113 txboard_find_free_phys_region(unsigned long begin, unsigned long end,
114 unsigned long size)
115 {
116 unsigned long base;
117 int i;
118
119 for (base = begin / size * size; base < end; base += size) {
120 for (i = 0; i < num_phys_regions; i++) {
121 if (phys_regions[i].size &&
122 base <= phys_regions[i].base + (phys_regions[i].size - 1) &&
123 base + (size - 1) >= phys_regions[i].base)
124 break;
125 }
126 if (i == num_phys_regions)
127 return base;
128 }
129 return 0;
130 }
131 unsigned long __init
132 txboard_find_free_phys_region_shrink(unsigned long begin, unsigned long end,
133 unsigned long *size)
134 {
135 unsigned long sz, base;
136 for (sz = *size; sz >= PHYS_REGION_MINSIZE; sz /= 2) {
137 base = txboard_find_free_phys_region(begin, end, sz);
138 if (base) {
139 *size = sz;
140 return base;
141 }
142 }
143 return 0;
144 }
145 unsigned long __init
146 txboard_request_phys_region_range(unsigned long begin, unsigned long end,
147 unsigned long size)
148 {
149 unsigned long base;
150 base = txboard_find_free_phys_region(begin, end, size);
151 if (base)
152 txboard_add_phys_region(base, size);
153 return base;
154 }
155 unsigned long __init
156 txboard_request_phys_region(unsigned long size)
157 {
158 unsigned long base;
159 unsigned long begin = 0, end = 0x20000000; /* search low 512MB */
160 base = txboard_find_free_phys_region(begin, end, size);
161 if (base)
162 txboard_add_phys_region(base, size);
163 return base;
164 }
165 unsigned long __init
166 txboard_request_phys_region_shrink(unsigned long *size)
167 {
168 unsigned long base;
169 unsigned long begin = 0, end = 0x20000000; /* search low 512MB */
170 base = txboard_find_free_phys_region_shrink(begin, end, size);
171 if (base)
172 txboard_add_phys_region(base, *size);
173 return base;
174 }
175
176 #ifdef CONFIG_PCI
177 void __init
178 tx4938_pcic_setup(struct tx4938_pcic_reg *pcicptr,
179 struct pci_controller *channel,
180 unsigned long pci_io_base,
181 int extarb)
182 {
183 int i;
184
185 /* Disable All Initiator Space */
186 pcicptr->pciccfg &= ~(TX4938_PCIC_PCICCFG_G2PMEN(0)|
187 TX4938_PCIC_PCICCFG_G2PMEN(1)|
188 TX4938_PCIC_PCICCFG_G2PMEN(2)|
189 TX4938_PCIC_PCICCFG_G2PIOEN);
190
191 /* GB->PCI mappings */
192 pcicptr->g2piomask = (channel->io_resource->end - channel->io_resource->start) >> 4;
193 pcicptr->g2piogbase = pci_io_base |
194 #ifdef __BIG_ENDIAN
195 TX4938_PCIC_G2PIOGBASE_ECHG
196 #else
197 TX4938_PCIC_G2PIOGBASE_BSDIS
198 #endif
199 ;
200 pcicptr->g2piopbase = 0;
201 for (i = 0; i < 3; i++) {
202 pcicptr->g2pmmask[i] = 0;
203 pcicptr->g2pmgbase[i] = 0;
204 pcicptr->g2pmpbase[i] = 0;
205 }
206 if (channel->mem_resource->end) {
207 pcicptr->g2pmmask[0] = (channel->mem_resource->end - channel->mem_resource->start) >> 4;
208 pcicptr->g2pmgbase[0] = channel->mem_resource->start |
209 #ifdef __BIG_ENDIAN
210 TX4938_PCIC_G2PMnGBASE_ECHG
211 #else
212 TX4938_PCIC_G2PMnGBASE_BSDIS
213 #endif
214 ;
215 pcicptr->g2pmpbase[0] = channel->mem_resource->start;
216 }
217 /* PCI->GB mappings (I/O 256B) */
218 pcicptr->p2giopbase = 0; /* 256B */
219 pcicptr->p2giogbase = 0;
220 /* PCI->GB mappings (MEM 512MB (64MB on R1.x)) */
221 pcicptr->p2gm0plbase = 0;
222 pcicptr->p2gm0pubase = 0;
223 pcicptr->p2gmgbase[0] = 0 |
224 TX4938_PCIC_P2GMnGBASE_TMEMEN |
225 #ifdef __BIG_ENDIAN
226 TX4938_PCIC_P2GMnGBASE_TECHG
227 #else
228 TX4938_PCIC_P2GMnGBASE_TBSDIS
229 #endif
230 ;
231 /* PCI->GB mappings (MEM 16MB) */
232 pcicptr->p2gm1plbase = 0xffffffff;
233 pcicptr->p2gm1pubase = 0xffffffff;
234 pcicptr->p2gmgbase[1] = 0;
235 /* PCI->GB mappings (MEM 1MB) */
236 pcicptr->p2gm2pbase = 0xffffffff; /* 1MB */
237 pcicptr->p2gmgbase[2] = 0;
238
239 pcicptr->pciccfg &= TX4938_PCIC_PCICCFG_GBWC_MASK;
240 /* Enable Initiator Memory Space */
241 if (channel->mem_resource->end)
242 pcicptr->pciccfg |= TX4938_PCIC_PCICCFG_G2PMEN(0);
243 /* Enable Initiator I/O Space */
244 if (channel->io_resource->end)
245 pcicptr->pciccfg |= TX4938_PCIC_PCICCFG_G2PIOEN;
246 /* Enable Initiator Config */
247 pcicptr->pciccfg |=
248 TX4938_PCIC_PCICCFG_ICAEN |
249 TX4938_PCIC_PCICCFG_TCAR;
250
251 /* Do not use MEMMUL, MEMINF: YMFPCI card causes M_ABORT. */
252 pcicptr->pcicfg1 = 0;
253
254 pcicptr->g2ptocnt &= ~0xffff;
255
256 if (tx4938_pcic_trdyto >= 0) {
257 pcicptr->g2ptocnt &= ~0xff;
258 pcicptr->g2ptocnt |= (tx4938_pcic_trdyto & 0xff);
259 }
260
261 if (tx4938_pcic_retryto >= 0) {
262 pcicptr->g2ptocnt &= ~0xff00;
263 pcicptr->g2ptocnt |= ((tx4938_pcic_retryto<<8) & 0xff00);
264 }
265
266 /* Clear All Local Bus Status */
267 pcicptr->pcicstatus = TX4938_PCIC_PCICSTATUS_ALL;
268 /* Enable All Local Bus Interrupts */
269 pcicptr->pcicmask = TX4938_PCIC_PCICSTATUS_ALL;
270 /* Clear All Initiator Status */
271 pcicptr->g2pstatus = TX4938_PCIC_G2PSTATUS_ALL;
272 /* Enable All Initiator Interrupts */
273 pcicptr->g2pmask = TX4938_PCIC_G2PSTATUS_ALL;
274 /* Clear All PCI Status Error */
275 pcicptr->pcistatus =
276 (pcicptr->pcistatus & 0x0000ffff) |
277 (TX4938_PCIC_PCISTATUS_ALL << 16);
278 /* Enable All PCI Status Error Interrupts */
279 pcicptr->pcimask = TX4938_PCIC_PCISTATUS_ALL;
280
281 if (!extarb) {
282 /* Reset Bus Arbiter */
283 pcicptr->pbacfg = TX4938_PCIC_PBACFG_RPBA;
284 pcicptr->pbabm = 0;
285 /* Enable Bus Arbiter */
286 pcicptr->pbacfg = TX4938_PCIC_PBACFG_PBAEN;
287 }
288
289 /* PCIC Int => IRC IRQ16 */
290 pcicptr->pcicfg2 =
291 (pcicptr->pcicfg2 & 0xffffff00) | TX4938_IR_PCIC;
292
293 pcicptr->pcistatus = PCI_COMMAND_MASTER |
294 PCI_COMMAND_MEMORY |
295 PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
296 }
297
298 int __init
299 tx4938_report_pciclk(void)
300 {
301 unsigned long pcode = TX4938_REV_PCODE();
302 int pciclk = 0;
303 printk("TX%lx PCIC --%s PCICLK:",
304 pcode,
305 (tx4938_ccfgptr->ccfg & TX4938_CCFG_PCI66) ? " PCI66" : "");
306 if (tx4938_ccfgptr->pcfg & TX4938_PCFG_PCICLKEN_ALL) {
307
308 switch ((unsigned long)tx4938_ccfgptr->ccfg & TX4938_CCFG_PCIDIVMODE_MASK) {
309 case TX4938_CCFG_PCIDIVMODE_4:
310 pciclk = txx9_cpu_clock / 4; break;
311 case TX4938_CCFG_PCIDIVMODE_4_5:
312 pciclk = txx9_cpu_clock * 2 / 9; break;
313 case TX4938_CCFG_PCIDIVMODE_5:
314 pciclk = txx9_cpu_clock / 5; break;
315 case TX4938_CCFG_PCIDIVMODE_5_5:
316 pciclk = txx9_cpu_clock * 2 / 11; break;
317 case TX4938_CCFG_PCIDIVMODE_8:
318 pciclk = txx9_cpu_clock / 8; break;
319 case TX4938_CCFG_PCIDIVMODE_9:
320 pciclk = txx9_cpu_clock / 9; break;
321 case TX4938_CCFG_PCIDIVMODE_10:
322 pciclk = txx9_cpu_clock / 10; break;
323 case TX4938_CCFG_PCIDIVMODE_11:
324 pciclk = txx9_cpu_clock / 11; break;
325 }
326 printk("Internal(%dMHz)", pciclk / 1000000);
327 } else {
328 printk("External");
329 pciclk = -1;
330 }
331 printk("\n");
332 return pciclk;
333 }
334
335 void __init set_tx4938_pcicptr(int ch, struct tx4938_pcic_reg *pcicptr)
336 {
337 pcicptrs[ch] = pcicptr;
338 }
339
340 struct tx4938_pcic_reg *get_tx4938_pcicptr(int ch)
341 {
342 return pcicptrs[ch];
343 }
344
345 static struct pci_dev *fake_pci_dev(struct pci_controller *hose,
346 int top_bus, int busnr, int devfn)
347 {
348 static struct pci_dev dev;
349 static struct pci_bus bus;
350
351 dev.sysdata = bus.sysdata = hose;
352 dev.devfn = devfn;
353 bus.number = busnr;
354 bus.ops = hose->pci_ops;
355 bus.parent = NULL;
356 dev.bus = &bus;
357
358 return &dev;
359 }
360
361 #define EARLY_PCI_OP(rw, size, type) \
362 static int early_##rw##_config_##size(struct pci_controller *hose, \
363 int top_bus, int bus, int devfn, int offset, type value) \
364 { \
365 return pci_##rw##_config_##size( \
366 fake_pci_dev(hose, top_bus, bus, devfn), \
367 offset, value); \
368 }
369
370 EARLY_PCI_OP(read, word, u16 *)
371
372 int txboard_pci66_check(struct pci_controller *hose, int top_bus, int current_bus)
373 {
374 u32 pci_devfn;
375 unsigned short vid;
376 int devfn_start = 0;
377 int devfn_stop = 0xff;
378 int cap66 = -1;
379 u16 stat;
380
381 printk("PCI: Checking 66MHz capabilities...\n");
382
383 for (pci_devfn=devfn_start; pci_devfn<devfn_stop; pci_devfn++) {
384 if (early_read_config_word(hose, top_bus, current_bus,
385 pci_devfn, PCI_VENDOR_ID,
386 &vid) != PCIBIOS_SUCCESSFUL)
387 continue;
388
389 if (vid == 0xffff) continue;
390
391 /* check 66MHz capability */
392 if (cap66 < 0)
393 cap66 = 1;
394 if (cap66) {
395 early_read_config_word(hose, top_bus, current_bus, pci_devfn,
396 PCI_STATUS, &stat);
397 if (!(stat & PCI_STATUS_66MHZ)) {
398 printk(KERN_DEBUG "PCI: %02x:%02x not 66MHz capable.\n",
399 current_bus, pci_devfn);
400 cap66 = 0;
401 break;
402 }
403 }
404 }
405 return cap66 > 0;
406 }
407
408 int __init
409 tx4938_pciclk66_setup(void)
410 {
411 int pciclk;
412
413 /* Assert M66EN */
414 tx4938_ccfgptr->ccfg |= TX4938_CCFG_PCI66;
415 /* Double PCICLK (if possible) */
416 if (tx4938_ccfgptr->pcfg & TX4938_PCFG_PCICLKEN_ALL) {
417 unsigned int pcidivmode =
418 tx4938_ccfgptr->ccfg & TX4938_CCFG_PCIDIVMODE_MASK;
419 switch (pcidivmode) {
420 case TX4938_CCFG_PCIDIVMODE_8:
421 case TX4938_CCFG_PCIDIVMODE_4:
422 pcidivmode = TX4938_CCFG_PCIDIVMODE_4;
423 pciclk = txx9_cpu_clock / 4;
424 break;
425 case TX4938_CCFG_PCIDIVMODE_9:
426 case TX4938_CCFG_PCIDIVMODE_4_5:
427 pcidivmode = TX4938_CCFG_PCIDIVMODE_4_5;
428 pciclk = txx9_cpu_clock * 2 / 9;
429 break;
430 case TX4938_CCFG_PCIDIVMODE_10:
431 case TX4938_CCFG_PCIDIVMODE_5:
432 pcidivmode = TX4938_CCFG_PCIDIVMODE_5;
433 pciclk = txx9_cpu_clock / 5;
434 break;
435 case TX4938_CCFG_PCIDIVMODE_11:
436 case TX4938_CCFG_PCIDIVMODE_5_5:
437 default:
438 pcidivmode = TX4938_CCFG_PCIDIVMODE_5_5;
439 pciclk = txx9_cpu_clock * 2 / 11;
440 break;
441 }
442 tx4938_ccfgptr->ccfg =
443 (tx4938_ccfgptr->ccfg & ~TX4938_CCFG_PCIDIVMODE_MASK)
444 | pcidivmode;
445 printk(KERN_DEBUG "PCICLK: ccfg:%08lx\n",
446 (unsigned long)tx4938_ccfgptr->ccfg);
447 } else {
448 pciclk = -1;
449 }
450 return pciclk;
451 }
452
453 extern struct pci_controller tx4938_pci_controller[];
454 static int __init tx4938_pcibios_init(void)
455 {
456 unsigned long mem_base[2];
457 unsigned long mem_size[2] = {TX4938_PCIMEM_SIZE_0, TX4938_PCIMEM_SIZE_1}; /* MAX 128M,64K */
458 unsigned long io_base[2];
459 unsigned long io_size[2] = {TX4938_PCIIO_SIZE_0, TX4938_PCIIO_SIZE_1}; /* MAX 16M,64K */
460 /* TX4938 PCIC1: 64K MEM/IO is enough for ETH0,ETH1 */
461 int extarb = !(tx4938_ccfgptr->ccfg & TX4938_CCFG_PCIXARB);
462
463 PCIBIOS_MIN_IO = 0x00001000UL;
464
465 mem_base[0] = txboard_request_phys_region_shrink(&mem_size[0]);
466 io_base[0] = txboard_request_phys_region_shrink(&io_size[0]);
467
468 printk("TX4938 PCIC -- DID:%04x VID:%04x RID:%02x Arbiter:%s\n",
469 (unsigned short)(tx4938_pcicptr->pciid >> 16),
470 (unsigned short)(tx4938_pcicptr->pciid & 0xffff),
471 (unsigned short)(tx4938_pcicptr->pciccrev & 0xff),
472 extarb ? "External" : "Internal");
473
474 /* setup PCI area */
475 tx4938_pci_controller[0].io_resource->start = io_base[0];
476 tx4938_pci_controller[0].io_resource->end = (io_base[0] + io_size[0]) - 1;
477 tx4938_pci_controller[0].mem_resource->start = mem_base[0];
478 tx4938_pci_controller[0].mem_resource->end = mem_base[0] + mem_size[0] - 1;
479
480 set_tx4938_pcicptr(0, tx4938_pcicptr);
481
482 register_pci_controller(&tx4938_pci_controller[0]);
483
484 if (tx4938_ccfgptr->ccfg & TX4938_CCFG_PCI66) {
485 printk("TX4938_CCFG_PCI66 already configured\n");
486 txboard_pci66_mode = -1; /* already configured */
487 }
488
489 /* Reset PCI Bus */
490 *rbtx4938_pcireset_ptr = 0;
491 /* Reset PCIC */
492 tx4938_ccfgptr->clkctr |= TX4938_CLKCTR_PCIRST;
493 if (txboard_pci66_mode > 0)
494 tx4938_pciclk66_setup();
495 mdelay(10);
496 /* clear PCIC reset */
497 tx4938_ccfgptr->clkctr &= ~TX4938_CLKCTR_PCIRST;
498 *rbtx4938_pcireset_ptr = 1;
499 wbflush();
500 tx4938_report_pcic_status1(tx4938_pcicptr);
501
502 tx4938_report_pciclk();
503 tx4938_pcic_setup(tx4938_pcicptr, &tx4938_pci_controller[0], io_base[0], extarb);
504 if (txboard_pci66_mode == 0 &&
505 txboard_pci66_check(&tx4938_pci_controller[0], 0, 0)) {
506 /* Reset PCI Bus */
507 *rbtx4938_pcireset_ptr = 0;
508 /* Reset PCIC */
509 tx4938_ccfgptr->clkctr |= TX4938_CLKCTR_PCIRST;
510 tx4938_pciclk66_setup();
511 mdelay(10);
512 /* clear PCIC reset */
513 tx4938_ccfgptr->clkctr &= ~TX4938_CLKCTR_PCIRST;
514 *rbtx4938_pcireset_ptr = 1;
515 wbflush();
516 /* Reinitialize PCIC */
517 tx4938_report_pciclk();
518 tx4938_pcic_setup(tx4938_pcicptr, &tx4938_pci_controller[0], io_base[0], extarb);
519 }
520
521 mem_base[1] = txboard_request_phys_region_shrink(&mem_size[1]);
522 io_base[1] = txboard_request_phys_region_shrink(&io_size[1]);
523 /* Reset PCIC1 */
524 tx4938_ccfgptr->clkctr |= TX4938_CLKCTR_PCIC1RST;
525 /* PCI1DMD==0 => PCI1CLK==GBUSCLK/2 => PCI66 */
526 if (!(tx4938_ccfgptr->ccfg & TX4938_CCFG_PCI1DMD))
527 tx4938_ccfgptr->ccfg |= TX4938_CCFG_PCI1_66;
528 else
529 tx4938_ccfgptr->ccfg &= ~TX4938_CCFG_PCI1_66;
530 mdelay(10);
531 /* clear PCIC1 reset */
532 tx4938_ccfgptr->clkctr &= ~TX4938_CLKCTR_PCIC1RST;
533 tx4938_report_pcic_status1(tx4938_pcic1ptr);
534
535 printk("TX4938 PCIC1 -- DID:%04x VID:%04x RID:%02x",
536 (unsigned short)(tx4938_pcic1ptr->pciid >> 16),
537 (unsigned short)(tx4938_pcic1ptr->pciid & 0xffff),
538 (unsigned short)(tx4938_pcic1ptr->pciccrev & 0xff));
539 printk("%s PCICLK:%dMHz\n",
540 (tx4938_ccfgptr->ccfg & TX4938_CCFG_PCI1_66) ? " PCI66" : "",
541 txx9_gbus_clock /
542 ((tx4938_ccfgptr->ccfg & TX4938_CCFG_PCI1DMD) ? 4 : 2) /
543 1000000);
544
545 /* assumption: CPHYSADDR(mips_io_port_base) == io_base[0] */
546 tx4938_pci_controller[1].io_resource->start =
547 io_base[1] - io_base[0];
548 tx4938_pci_controller[1].io_resource->end =
549 io_base[1] - io_base[0] + io_size[1] - 1;
550 tx4938_pci_controller[1].mem_resource->start = mem_base[1];
551 tx4938_pci_controller[1].mem_resource->end =
552 mem_base[1] + mem_size[1] - 1;
553 set_tx4938_pcicptr(1, tx4938_pcic1ptr);
554
555 register_pci_controller(&tx4938_pci_controller[1]);
556
557 tx4938_pcic_setup(tx4938_pcic1ptr, &tx4938_pci_controller[1], io_base[1], extarb);
558
559 /* map ioport 0 to PCI I/O space address 0 */
560 set_io_port_base(KSEG1 + io_base[0]);
561
562 return 0;
563 }
564
565 arch_initcall(tx4938_pcibios_init);
566
567 #endif /* CONFIG_PCI */
568
569 /* SPI support */
570
571 /* chip select for SPI devices */
572 #define SEEPROM1_CS 7 /* PIO7 */
573 #define SEEPROM2_CS 0 /* IOC */
574 #define SEEPROM3_CS 1 /* IOC */
575 #define SRTC_CS 2 /* IOC */
576
577 #ifdef CONFIG_PCI
578 static int __init rbtx4938_ethaddr_init(void)
579 {
580 unsigned char dat[17];
581 unsigned char sum;
582 int i;
583
584 /* 0-3: "MAC\0", 4-9:eth0, 10-15:eth1, 16:sum */
585 if (spi_eeprom_read(SEEPROM1_CS, 0, dat, sizeof(dat))) {
586 printk(KERN_ERR "seeprom: read error.\n");
587 return -ENODEV;
588 } else {
589 if (strcmp(dat, "MAC") != 0)
590 printk(KERN_WARNING "seeprom: bad signature.\n");
591 for (i = 0, sum = 0; i < sizeof(dat); i++)
592 sum += dat[i];
593 if (sum)
594 printk(KERN_WARNING "seeprom: bad checksum.\n");
595 }
596 for (i = 0; i < 2; i++) {
597 unsigned int id =
598 TXX9_IRQ_BASE + (i ? TX4938_IR_ETH1 : TX4938_IR_ETH0);
599 struct platform_device *pdev;
600 if (!(tx4938_ccfgptr->pcfg &
601 (i ? TX4938_PCFG_ETH1_SEL : TX4938_PCFG_ETH0_SEL)))
602 continue;
603 pdev = platform_device_alloc("tc35815-mac", id);
604 if (!pdev ||
605 platform_device_add_data(pdev, &dat[4 + 6 * i], 6) ||
606 platform_device_add(pdev))
607 platform_device_put(pdev);
608 }
609 return 0;
610 }
611 device_initcall(rbtx4938_ethaddr_init);
612 #endif /* CONFIG_PCI */
613
614 static void __init rbtx4938_spi_setup(void)
615 {
616 /* set SPI_SEL */
617 tx4938_ccfgptr->pcfg |= TX4938_PCFG_SPI_SEL;
618 /* chip selects for SPI devices */
619 tx4938_pioptr->dout |= (1 << SEEPROM1_CS);
620 tx4938_pioptr->dir |= (1 << SEEPROM1_CS);
621 }
622
623 static struct resource rbtx4938_fpga_resource;
624
625 static char pcode_str[8];
626 static struct resource tx4938_reg_resource = {
627 .start = TX4938_REG_BASE,
628 .end = TX4938_REG_BASE + TX4938_REG_SIZE,
629 .name = pcode_str,
630 .flags = IORESOURCE_MEM
631 };
632
633 void __init tx4938_board_setup(void)
634 {
635 int i;
636 unsigned long divmode;
637 int cpuclk = 0;
638 unsigned long pcode = TX4938_REV_PCODE();
639
640 ioport_resource.start = 0x1000;
641 ioport_resource.end = 0xffffffff;
642 iomem_resource.start = 0x1000;
643 iomem_resource.end = 0xffffffff; /* expand to 4GB */
644
645 sprintf(pcode_str, "TX%lx", pcode);
646 /* SDRAMC,EBUSC are configured by PROM */
647 for (i = 0; i < 8; i++) {
648 if (!(tx4938_ebuscptr->cr[i] & 0x8))
649 continue; /* disabled */
650 rbtx4938_ce_base[i] = (unsigned long)TX4938_EBUSC_BA(i);
651 txboard_add_phys_region(rbtx4938_ce_base[i], TX4938_EBUSC_SIZE(i));
652 }
653
654 /* clocks */
655 if (txx9_master_clock) {
656 /* calculate gbus_clock and cpu_clock_freq from master_clock */
657 divmode = (unsigned long)tx4938_ccfgptr->ccfg & TX4938_CCFG_DIVMODE_MASK;
658 switch (divmode) {
659 case TX4938_CCFG_DIVMODE_8:
660 case TX4938_CCFG_DIVMODE_10:
661 case TX4938_CCFG_DIVMODE_12:
662 case TX4938_CCFG_DIVMODE_16:
663 case TX4938_CCFG_DIVMODE_18:
664 txx9_gbus_clock = txx9_master_clock * 4; break;
665 default:
666 txx9_gbus_clock = txx9_master_clock;
667 }
668 switch (divmode) {
669 case TX4938_CCFG_DIVMODE_2:
670 case TX4938_CCFG_DIVMODE_8:
671 cpuclk = txx9_gbus_clock * 2; break;
672 case TX4938_CCFG_DIVMODE_2_5:
673 case TX4938_CCFG_DIVMODE_10:
674 cpuclk = txx9_gbus_clock * 5 / 2; break;
675 case TX4938_CCFG_DIVMODE_3:
676 case TX4938_CCFG_DIVMODE_12:
677 cpuclk = txx9_gbus_clock * 3; break;
678 case TX4938_CCFG_DIVMODE_4:
679 case TX4938_CCFG_DIVMODE_16:
680 cpuclk = txx9_gbus_clock * 4; break;
681 case TX4938_CCFG_DIVMODE_4_5:
682 case TX4938_CCFG_DIVMODE_18:
683 cpuclk = txx9_gbus_clock * 9 / 2; break;
684 }
685 txx9_cpu_clock = cpuclk;
686 } else {
687 if (txx9_cpu_clock == 0) {
688 txx9_cpu_clock = 300000000; /* 300MHz */
689 }
690 /* calculate gbus_clock and master_clock from cpu_clock_freq */
691 cpuclk = txx9_cpu_clock;
692 divmode = (unsigned long)tx4938_ccfgptr->ccfg & TX4938_CCFG_DIVMODE_MASK;
693 switch (divmode) {
694 case TX4938_CCFG_DIVMODE_2:
695 case TX4938_CCFG_DIVMODE_8:
696 txx9_gbus_clock = cpuclk / 2; break;
697 case TX4938_CCFG_DIVMODE_2_5:
698 case TX4938_CCFG_DIVMODE_10:
699 txx9_gbus_clock = cpuclk * 2 / 5; break;
700 case TX4938_CCFG_DIVMODE_3:
701 case TX4938_CCFG_DIVMODE_12:
702 txx9_gbus_clock = cpuclk / 3; break;
703 case TX4938_CCFG_DIVMODE_4:
704 case TX4938_CCFG_DIVMODE_16:
705 txx9_gbus_clock = cpuclk / 4; break;
706 case TX4938_CCFG_DIVMODE_4_5:
707 case TX4938_CCFG_DIVMODE_18:
708 txx9_gbus_clock = cpuclk * 2 / 9; break;
709 }
710 switch (divmode) {
711 case TX4938_CCFG_DIVMODE_8:
712 case TX4938_CCFG_DIVMODE_10:
713 case TX4938_CCFG_DIVMODE_12:
714 case TX4938_CCFG_DIVMODE_16:
715 case TX4938_CCFG_DIVMODE_18:
716 txx9_master_clock = txx9_gbus_clock / 4; break;
717 default:
718 txx9_master_clock = txx9_gbus_clock;
719 }
720 }
721 /* change default value to udelay/mdelay take reasonable time */
722 loops_per_jiffy = txx9_cpu_clock / HZ / 2;
723
724 /* CCFG */
725 /* clear WatchDogReset,BusErrorOnWrite flag (W1C) */
726 tx4938_ccfgptr->ccfg |= TX4938_CCFG_WDRST | TX4938_CCFG_BEOW;
727 /* do reset on watchdog */
728 tx4938_ccfgptr->ccfg |= TX4938_CCFG_WR;
729 /* clear PCIC1 reset */
730 if (tx4938_ccfgptr->clkctr & TX4938_CLKCTR_PCIC1RST)
731 tx4938_ccfgptr->clkctr &= ~TX4938_CLKCTR_PCIC1RST;
732
733 /* enable Timeout BusError */
734 if (tx4938_ccfg_toeon)
735 tx4938_ccfgptr->ccfg |= TX4938_CCFG_TOE;
736
737 /* DMA selection */
738 tx4938_ccfgptr->pcfg &= ~TX4938_PCFG_DMASEL_ALL;
739
740 /* Use external clock for external arbiter */
741 if (!(tx4938_ccfgptr->ccfg & TX4938_CCFG_PCIXARB))
742 tx4938_ccfgptr->pcfg &= ~TX4938_PCFG_PCICLKEN_ALL;
743
744 printk("%s -- %dMHz(M%dMHz) CRIR:%08lx CCFG:%Lx PCFG:%Lx\n",
745 pcode_str,
746 cpuclk / 1000000, txx9_master_clock / 1000000,
747 (unsigned long)tx4938_ccfgptr->crir,
748 tx4938_ccfgptr->ccfg,
749 tx4938_ccfgptr->pcfg);
750
751 printk("%s SDRAMC --", pcode_str);
752 for (i = 0; i < 4; i++) {
753 unsigned long long cr = tx4938_sdramcptr->cr[i];
754 unsigned long ram_base, ram_size;
755 if (!((unsigned long)cr & 0x00000400))
756 continue; /* disabled */
757 ram_base = (unsigned long)(cr >> 49) << 21;
758 ram_size = ((unsigned long)(cr >> 33) + 1) << 21;
759 if (ram_base >= 0x20000000)
760 continue; /* high memory (ignore) */
761 printk(" CR%d:%016Lx", i, cr);
762 txboard_add_phys_region(ram_base, ram_size);
763 }
764 printk(" TR:%09Lx\n", tx4938_sdramcptr->tr);
765
766 /* SRAM */
767 if (pcode == 0x4938 && tx4938_sramcptr->cr & 1) {
768 unsigned int size = 0x800;
769 unsigned long base =
770 (tx4938_sramcptr->cr >> (39-11)) & ~(size - 1);
771 txboard_add_phys_region(base, size);
772 }
773
774 /* TMR */
775 for (i = 0; i < TX4938_NR_TMR; i++)
776 txx9_tmr_init(TX4938_TMR_REG(i) & 0xfffffffffULL);
777
778 /* enable DMA */
779 TX4938_WR64(0xff1fb150, TX4938_DMA_MCR_MSTEN);
780 TX4938_WR64(0xff1fb950, TX4938_DMA_MCR_MSTEN);
781
782 /* PIO */
783 tx4938_pioptr->maskcpu = 0;
784 tx4938_pioptr->maskext = 0;
785
786 /* TX4938 internal registers */
787 if (request_resource(&iomem_resource, &tx4938_reg_resource))
788 printk("request resource for internal registers failed\n");
789 }
790
791 #ifdef CONFIG_PCI
792 static inline void tx4938_report_pcic_status1(struct tx4938_pcic_reg *pcicptr)
793 {
794 unsigned short pcistatus = (unsigned short)(pcicptr->pcistatus >> 16);
795 unsigned long g2pstatus = pcicptr->g2pstatus;
796 unsigned long pcicstatus = pcicptr->pcicstatus;
797 static struct {
798 unsigned long flag;
799 const char *str;
800 } pcistat_tbl[] = {
801 { PCI_STATUS_DETECTED_PARITY, "DetectedParityError" },
802 { PCI_STATUS_SIG_SYSTEM_ERROR, "SignaledSystemError" },
803 { PCI_STATUS_REC_MASTER_ABORT, "ReceivedMasterAbort" },
804 { PCI_STATUS_REC_TARGET_ABORT, "ReceivedTargetAbort" },
805 { PCI_STATUS_SIG_TARGET_ABORT, "SignaledTargetAbort" },
806 { PCI_STATUS_PARITY, "MasterParityError" },
807 }, g2pstat_tbl[] = {
808 { TX4938_PCIC_G2PSTATUS_TTOE, "TIOE" },
809 { TX4938_PCIC_G2PSTATUS_RTOE, "RTOE" },
810 }, pcicstat_tbl[] = {
811 { TX4938_PCIC_PCICSTATUS_PME, "PME" },
812 { TX4938_PCIC_PCICSTATUS_TLB, "TLB" },
813 { TX4938_PCIC_PCICSTATUS_NIB, "NIB" },
814 { TX4938_PCIC_PCICSTATUS_ZIB, "ZIB" },
815 { TX4938_PCIC_PCICSTATUS_PERR, "PERR" },
816 { TX4938_PCIC_PCICSTATUS_SERR, "SERR" },
817 { TX4938_PCIC_PCICSTATUS_GBE, "GBE" },
818 { TX4938_PCIC_PCICSTATUS_IWB, "IWB" },
819 };
820 int i;
821
822 printk("pcistat:%04x(", pcistatus);
823 for (i = 0; i < ARRAY_SIZE(pcistat_tbl); i++)
824 if (pcistatus & pcistat_tbl[i].flag)
825 printk("%s ", pcistat_tbl[i].str);
826 printk("), g2pstatus:%08lx(", g2pstatus);
827 for (i = 0; i < ARRAY_SIZE(g2pstat_tbl); i++)
828 if (g2pstatus & g2pstat_tbl[i].flag)
829 printk("%s ", g2pstat_tbl[i].str);
830 printk("), pcicstatus:%08lx(", pcicstatus);
831 for (i = 0; i < ARRAY_SIZE(pcicstat_tbl); i++)
832 if (pcicstatus & pcicstat_tbl[i].flag)
833 printk("%s ", pcicstat_tbl[i].str);
834 printk(")\n");
835 }
836
837 void tx4938_report_pcic_status(void)
838 {
839 int i;
840 struct tx4938_pcic_reg *pcicptr;
841 for (i = 0; (pcicptr = get_tx4938_pcicptr(i)) != NULL; i++)
842 tx4938_report_pcic_status1(pcicptr);
843 }
844
845 #endif /* CONFIG_PCI */
846
847 void __init plat_time_init(void)
848 {
849 mips_hpt_frequency = txx9_cpu_clock / 2;
850 if (tx4938_ccfgptr->ccfg & TX4938_CCFG_TINTDIS)
851 txx9_clockevent_init(TX4938_TMR_REG(0) & 0xfffffffffULL,
852 TXX9_IRQ_BASE + TX4938_IR_TMR(0),
853 txx9_gbus_clock / 2);
854 }
855
856 void __init plat_mem_setup(void)
857 {
858 unsigned long long pcfg;
859 char *argptr;
860
861 iomem_resource.end = 0xffffffff; /* 4GB */
862
863 if (txx9_master_clock == 0)
864 txx9_master_clock = 25000000; /* 25MHz */
865 tx4938_board_setup();
866 /* setup serial stuff */
867 TX4938_WR(0xff1ff314, 0x00000000); /* h/w flow control off */
868 TX4938_WR(0xff1ff414, 0x00000000); /* h/w flow control off */
869
870 #ifndef CONFIG_PCI
871 set_io_port_base(RBTX4938_ETHER_BASE);
872 #endif
873
874 #ifdef CONFIG_SERIAL_TXX9
875 {
876 extern int early_serial_txx9_setup(struct uart_port *port);
877 int i;
878 struct uart_port req;
879 for(i = 0; i < 2; i++) {
880 memset(&req, 0, sizeof(req));
881 req.line = i;
882 req.iotype = UPIO_MEM;
883 req.membase = (char *)(0xff1ff300 + i * 0x100);
884 req.mapbase = 0xff1ff300 + i * 0x100;
885 req.irq = RBTX4938_IRQ_IRC_SIO(i);
886 req.flags |= UPF_BUGGY_UART /*HAVE_CTS_LINE*/;
887 req.uartclk = 50000000;
888 early_serial_txx9_setup(&req);
889 }
890 }
891 #ifdef CONFIG_SERIAL_TXX9_CONSOLE
892 argptr = prom_getcmdline();
893 if (strstr(argptr, "console=") == NULL) {
894 strcat(argptr, " console=ttyS0,38400");
895 }
896 #endif
897 #endif
898
899 #ifdef CONFIG_TOSHIBA_RBTX4938_MPLEX_PIO58_61
900 printk("PIOSEL: disabling both ata and nand selection\n");
901 local_irq_disable();
902 tx4938_ccfgptr->pcfg &= ~(TX4938_PCFG_NDF_SEL | TX4938_PCFG_ATA_SEL);
903 #endif
904
905 #ifdef CONFIG_TOSHIBA_RBTX4938_MPLEX_NAND
906 printk("PIOSEL: enabling nand selection\n");
907 tx4938_ccfgptr->pcfg |= TX4938_PCFG_NDF_SEL;
908 tx4938_ccfgptr->pcfg &= ~TX4938_PCFG_ATA_SEL;
909 #endif
910
911 #ifdef CONFIG_TOSHIBA_RBTX4938_MPLEX_ATA
912 printk("PIOSEL: enabling ata selection\n");
913 tx4938_ccfgptr->pcfg |= TX4938_PCFG_ATA_SEL;
914 tx4938_ccfgptr->pcfg &= ~TX4938_PCFG_NDF_SEL;
915 #endif
916
917 #ifdef CONFIG_IP_PNP
918 argptr = prom_getcmdline();
919 if (strstr(argptr, "ip=") == NULL) {
920 strcat(argptr, " ip=any");
921 }
922 #endif
923
924
925 #ifdef CONFIG_FB
926 {
927 conswitchp = &dummy_con;
928 }
929 #endif
930
931 rbtx4938_spi_setup();
932 pcfg = tx4938_ccfgptr->pcfg; /* updated */
933 /* fixup piosel */
934 if ((pcfg & (TX4938_PCFG_ATA_SEL | TX4938_PCFG_NDF_SEL)) ==
935 TX4938_PCFG_ATA_SEL) {
936 *rbtx4938_piosel_ptr = (*rbtx4938_piosel_ptr & 0x03) | 0x04;
937 }
938 else if ((pcfg & (TX4938_PCFG_ATA_SEL | TX4938_PCFG_NDF_SEL)) ==
939 TX4938_PCFG_NDF_SEL) {
940 *rbtx4938_piosel_ptr = (*rbtx4938_piosel_ptr & 0x03) | 0x08;
941 }
942 else {
943 *rbtx4938_piosel_ptr &= ~(0x08 | 0x04);
944 }
945
946 rbtx4938_fpga_resource.name = "FPGA Registers";
947 rbtx4938_fpga_resource.start = CPHYSADDR(RBTX4938_FPGA_REG_ADDR);
948 rbtx4938_fpga_resource.end = CPHYSADDR(RBTX4938_FPGA_REG_ADDR) + 0xffff;
949 rbtx4938_fpga_resource.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
950 if (request_resource(&iomem_resource, &rbtx4938_fpga_resource))
951 printk("request resource for fpga failed\n");
952
953 /* disable all OnBoard I/O interrupts */
954 *rbtx4938_imask_ptr = 0;
955
956 _machine_restart = rbtx4938_machine_restart;
957 _machine_halt = rbtx4938_machine_halt;
958 pm_power_off = rbtx4938_machine_power_off;
959
960 *rbtx4938_led_ptr = 0xff;
961 printk("RBTX4938 --- FPGA(Rev %02x)", *rbtx4938_fpga_rev_ptr);
962 printk(" DIPSW:%02x,%02x\n",
963 *rbtx4938_dipsw_ptr, *rbtx4938_bdipsw_ptr);
964 }
965
966 static int __init rbtx4938_ne_init(void)
967 {
968 struct resource res[] = {
969 {
970 .start = RBTX4938_RTL_8019_BASE,
971 .end = RBTX4938_RTL_8019_BASE + 0x20 - 1,
972 .flags = IORESOURCE_IO,
973 }, {
974 .start = RBTX4938_RTL_8019_IRQ,
975 .flags = IORESOURCE_IRQ,
976 }
977 };
978 struct platform_device *dev =
979 platform_device_register_simple("ne", -1,
980 res, ARRAY_SIZE(res));
981 return IS_ERR(dev) ? PTR_ERR(dev) : 0;
982 }
983 device_initcall(rbtx4938_ne_init);
984
985 /* GPIO support */
986
987 static DEFINE_SPINLOCK(rbtx4938_spi_gpio_lock);
988
989 static void rbtx4938_spi_gpio_set(unsigned gpio, int value)
990 {
991 u8 val;
992 unsigned long flags;
993 gpio -= 16;
994 spin_lock_irqsave(&rbtx4938_spi_gpio_lock, flags);
995 val = *rbtx4938_spics_ptr;
996 if (value)
997 val |= 1 << gpio;
998 else
999 val &= ~(1 << gpio);
1000 *rbtx4938_spics_ptr = val;
1001 mmiowb();
1002 spin_unlock_irqrestore(&rbtx4938_spi_gpio_lock, flags);
1003 }
1004
1005 static int rbtx4938_spi_gpio_dir_out(unsigned gpio, int value)
1006 {
1007 rbtx4938_spi_gpio_set(gpio, value);
1008 return 0;
1009 }
1010
1011 static DEFINE_SPINLOCK(tx4938_gpio_lock);
1012
1013 static int tx4938_gpio_get(unsigned gpio)
1014 {
1015 return tx4938_pioptr->din & (1 << gpio);
1016 }
1017
1018 static void tx4938_gpio_set_raw(unsigned gpio, int value)
1019 {
1020 u32 val;
1021 val = tx4938_pioptr->dout;
1022 if (value)
1023 val |= 1 << gpio;
1024 else
1025 val &= ~(1 << gpio);
1026 tx4938_pioptr->dout = val;
1027 }
1028
1029 static void tx4938_gpio_set(unsigned gpio, int value)
1030 {
1031 unsigned long flags;
1032 spin_lock_irqsave(&tx4938_gpio_lock, flags);
1033 tx4938_gpio_set_raw(gpio, value);
1034 mmiowb();
1035 spin_unlock_irqrestore(&tx4938_gpio_lock, flags);
1036 }
1037
1038 static int tx4938_gpio_dir_in(unsigned gpio)
1039 {
1040 spin_lock_irq(&tx4938_gpio_lock);
1041 tx4938_pioptr->dir &= ~(1 << gpio);
1042 mmiowb();
1043 spin_unlock_irq(&tx4938_gpio_lock);
1044 return 0;
1045 }
1046
1047 static int tx4938_gpio_dir_out(unsigned int gpio, int value)
1048 {
1049 spin_lock_irq(&tx4938_gpio_lock);
1050 tx4938_gpio_set_raw(gpio, value);
1051 tx4938_pioptr->dir |= 1 << gpio;
1052 mmiowb();
1053 spin_unlock_irq(&tx4938_gpio_lock);
1054 return 0;
1055 }
1056
1057 int gpio_direction_input(unsigned gpio)
1058 {
1059 if (gpio < 16)
1060 return tx4938_gpio_dir_in(gpio);
1061 return -EINVAL;
1062 }
1063
1064 int gpio_direction_output(unsigned gpio, int value)
1065 {
1066 if (gpio < 16)
1067 return tx4938_gpio_dir_out(gpio, value);
1068 if (gpio < 16 + 3)
1069 return rbtx4938_spi_gpio_dir_out(gpio, value);
1070 return -EINVAL;
1071 }
1072
1073 int gpio_get_value(unsigned gpio)
1074 {
1075 if (gpio < 16)
1076 return tx4938_gpio_get(gpio);
1077 return 0;
1078 }
1079
1080 void gpio_set_value(unsigned gpio, int value)
1081 {
1082 if (gpio < 16)
1083 tx4938_gpio_set(gpio, value);
1084 else
1085 rbtx4938_spi_gpio_set(gpio, value);
1086 }
1087
1088 /* SPI support */
1089
1090 static void __init txx9_spi_init(unsigned long base, int irq)
1091 {
1092 struct resource res[] = {
1093 {
1094 .start = base,
1095 .end = base + 0x20 - 1,
1096 .flags = IORESOURCE_MEM,
1097 .parent = &tx4938_reg_resource,
1098 }, {
1099 .start = irq,
1100 .flags = IORESOURCE_IRQ,
1101 },
1102 };
1103 platform_device_register_simple("spi_txx9", 0,
1104 res, ARRAY_SIZE(res));
1105 }
1106
1107 static int __init rbtx4938_spi_init(void)
1108 {
1109 struct spi_board_info srtc_info = {
1110 .modalias = "rtc-rs5c348",
1111 .max_speed_hz = 1000000, /* 1.0Mbps @ Vdd 2.0V */
1112 .bus_num = 0,
1113 .chip_select = 16 + SRTC_CS,
1114 /* Mode 1 (High-Active, Shift-Then-Sample), High Avtive CS */
1115 .mode = SPI_MODE_1 | SPI_CS_HIGH,
1116 };
1117 spi_register_board_info(&srtc_info, 1);
1118 spi_eeprom_register(SEEPROM1_CS);
1119 spi_eeprom_register(16 + SEEPROM2_CS);
1120 spi_eeprom_register(16 + SEEPROM3_CS);
1121 txx9_spi_init(TX4938_SPI_REG & 0xfffffffffULL, RBTX4938_IRQ_IRC_SPI);
1122 return 0;
1123 }
1124 arch_initcall(rbtx4938_spi_init);
1125
1126 /* Watchdog support */
1127
1128 static int __init txx9_wdt_init(unsigned long base)
1129 {
1130 struct resource res = {
1131 .start = base,
1132 .end = base + 0x100 - 1,
1133 .flags = IORESOURCE_MEM,
1134 .parent = &tx4938_reg_resource,
1135 };
1136 struct platform_device *dev =
1137 platform_device_register_simple("txx9wdt", -1, &res, 1);
1138 return IS_ERR(dev) ? PTR_ERR(dev) : 0;
1139 }
1140
1141 static int __init rbtx4938_wdt_init(void)
1142 {
1143 return txx9_wdt_init(TX4938_TMR_REG(2) & 0xfffffffffULL);
1144 }
1145 device_initcall(rbtx4938_wdt_init);
1146
1147 /* Minimum CLK support */
1148
1149 struct clk *clk_get(struct device *dev, const char *id)
1150 {
1151 if (!strcmp(id, "spi-baseclk"))
1152 return (struct clk *)(txx9_gbus_clock / 2 / 4);
1153 if (!strcmp(id, "imbus_clk"))
1154 return (struct clk *)(txx9_gbus_clock / 2);
1155 return ERR_PTR(-ENOENT);
1156 }
1157 EXPORT_SYMBOL(clk_get);
1158
1159 int clk_enable(struct clk *clk)
1160 {
1161 return 0;
1162 }
1163 EXPORT_SYMBOL(clk_enable);
1164
1165 void clk_disable(struct clk *clk)
1166 {
1167 }
1168 EXPORT_SYMBOL(clk_disable);
1169
1170 unsigned long clk_get_rate(struct clk *clk)
1171 {
1172 return (unsigned long)clk;
1173 }
1174 EXPORT_SYMBOL(clk_get_rate);
1175
1176 void clk_put(struct clk *clk)
1177 {
1178 }
1179 EXPORT_SYMBOL(clk_put);
linux-next