xref: /linux/arch/arm/mach-pxa/devices.c (revision 906fd46a65383cd639e5eec72a047efc33045d86) 
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/module.h>
3 #include <linux/kernel.h>
4 #include <linux/init.h>
5 #include <linux/platform_device.h>
6 #include <linux/clkdev.h>
7 #include <linux/clk-provider.h>
8 #include <linux/dma-mapping.h>
9 #include <linux/dmaengine.h>
10 #include <linux/platform_data/i2c-pxa.h>
11 #include <linux/soc/pxa/cpu.h>
12 
13 #include "udc.h"
14 #include <linux/platform_data/video-pxafb.h>
15 #include <linux/platform_data/mmc-pxamci.h>
16 #include "irqs.h"
17 #include <linux/platform_data/usb-ohci-pxa27x.h>
18 #include <linux/platform_data/mmp_dma.h>
19 
20 #include "regs-ost.h"
21 #include "reset.h"
22 #include "devices.h"
23 #include "generic.h"
24 
25 void __init pxa_register_device(struct platform_device *dev, void *data)
26 {
27 	int ret;
28 
29 	dev->dev.platform_data = data;
30 
31 	ret = platform_device_register(dev);
32 	if (ret)
33 		dev_err(&dev->dev, "unable to register device: %d\n", ret);
34 }
35 
36 static struct resource pxa_resource_pmu = {
37 	.start	= IRQ_PMU,
38 	.end	= IRQ_PMU,
39 	.flags	= IORESOURCE_IRQ,
40 };
41 
42 struct platform_device pxa_device_pmu = {
43 	.name		= "xscale-pmu",
44 	.id		= -1,
45 	.resource	= &pxa_resource_pmu,
46 	.num_resources	= 1,
47 };
48 
49 static struct resource pxamci_resources[] = {
50 	[0] = {
51 		.start	= 0x41100000,
52 		.end	= 0x41100fff,
53 		.flags	= IORESOURCE_MEM,
54 	},
55 	[1] = {
56 		.start	= IRQ_MMC,
57 		.end	= IRQ_MMC,
58 		.flags	= IORESOURCE_IRQ,
59 	},
60 };
61 
62 static u64 pxamci_dmamask = 0xffffffffUL;
63 
64 struct platform_device pxa_device_mci = {
65 	.name		= "pxa2xx-mci",
66 	.id		= 0,
67 	.dev		= {
68 		.dma_mask = &pxamci_dmamask,
69 		.coherent_dma_mask = 0xffffffff,
70 	},
71 	.num_resources	= ARRAY_SIZE(pxamci_resources),
72 	.resource	= pxamci_resources,
73 };
74 
75 void __init pxa_set_mci_info(struct pxamci_platform_data *info)
76 {
77 	pxa_register_device(&pxa_device_mci, info);
78 }
79 
80 static struct pxa2xx_udc_mach_info pxa_udc_info = {
81 	.gpio_pullup = -1,
82 };
83 
84 static struct resource pxa2xx_udc_resources[] = {
85 	[0] = {
86 		.start	= 0x40600000,
87 		.end	= 0x4060ffff,
88 		.flags	= IORESOURCE_MEM,
89 	},
90 	[1] = {
91 		.start	= IRQ_USB,
92 		.end	= IRQ_USB,
93 		.flags	= IORESOURCE_IRQ,
94 	},
95 };
96 
97 static u64 udc_dma_mask = ~(u32)0;
98 
99 struct platform_device pxa25x_device_udc = {
100 	.name		= "pxa25x-udc",
101 	.id		= -1,
102 	.resource	= pxa2xx_udc_resources,
103 	.num_resources	= ARRAY_SIZE(pxa2xx_udc_resources),
104 	.dev		=  {
105 		.platform_data	= &pxa_udc_info,
106 		.dma_mask	= &udc_dma_mask,
107 	}
108 };
109 
110 struct platform_device pxa27x_device_udc = {
111 	.name		= "pxa27x-udc",
112 	.id		= -1,
113 	.resource	= pxa2xx_udc_resources,
114 	.num_resources	= ARRAY_SIZE(pxa2xx_udc_resources),
115 	.dev		=  {
116 		.platform_data	= &pxa_udc_info,
117 		.dma_mask	= &udc_dma_mask,
118 	}
119 };
120 
121 static struct resource pxafb_resources[] = {
122 	[0] = {
123 		.start	= 0x44000000,
124 		.end	= 0x4400ffff,
125 		.flags	= IORESOURCE_MEM,
126 	},
127 	[1] = {
128 		.start	= IRQ_LCD,
129 		.end	= IRQ_LCD,
130 		.flags	= IORESOURCE_IRQ,
131 	},
132 };
133 
134 static u64 fb_dma_mask = ~(u64)0;
135 
136 struct platform_device pxa_device_fb = {
137 	.name		= "pxa2xx-fb",
138 	.id		= -1,
139 	.dev		= {
140 		.dma_mask	= &fb_dma_mask,
141 		.coherent_dma_mask = 0xffffffff,
142 	},
143 	.num_resources	= ARRAY_SIZE(pxafb_resources),
144 	.resource	= pxafb_resources,
145 };
146 
147 void __init pxa_set_fb_info(struct device *parent, struct pxafb_mach_info *info)
148 {
149 	pxa_device_fb.dev.parent = parent;
150 	pxa_register_device(&pxa_device_fb, info);
151 }
152 
153 static struct resource pxa_resource_ffuart[] = {
154 	{
155 		.start	= 0x40100000,
156 		.end	= 0x40100023,
157 		.flags	= IORESOURCE_MEM,
158 	}, {
159 		.start	= IRQ_FFUART,
160 		.end	= IRQ_FFUART,
161 		.flags	= IORESOURCE_IRQ,
162 	}
163 };
164 
165 struct platform_device pxa_device_ffuart = {
166 	.name		= "pxa2xx-uart",
167 	.id		= 0,
168 	.resource	= pxa_resource_ffuart,
169 	.num_resources	= ARRAY_SIZE(pxa_resource_ffuart),
170 };
171 
172 void __init pxa_set_ffuart_info(void *info)
173 {
174 	pxa_register_device(&pxa_device_ffuart, info);
175 }
176 
177 static struct resource pxa_resource_btuart[] = {
178 	{
179 		.start	= 0x40200000,
180 		.end	= 0x40200023,
181 		.flags	= IORESOURCE_MEM,
182 	}, {
183 		.start	= IRQ_BTUART,
184 		.end	= IRQ_BTUART,
185 		.flags	= IORESOURCE_IRQ,
186 	}
187 };
188 
189 struct platform_device pxa_device_btuart = {
190 	.name		= "pxa2xx-uart",
191 	.id		= 1,
192 	.resource	= pxa_resource_btuart,
193 	.num_resources	= ARRAY_SIZE(pxa_resource_btuart),
194 };
195 
196 void __init pxa_set_btuart_info(void *info)
197 {
198 	pxa_register_device(&pxa_device_btuart, info);
199 }
200 
201 static struct resource pxa_resource_stuart[] = {
202 	{
203 		.start	= 0x40700000,
204 		.end	= 0x40700023,
205 		.flags	= IORESOURCE_MEM,
206 	}, {
207 		.start	= IRQ_STUART,
208 		.end	= IRQ_STUART,
209 		.flags	= IORESOURCE_IRQ,
210 	}
211 };
212 
213 struct platform_device pxa_device_stuart = {
214 	.name		= "pxa2xx-uart",
215 	.id		= 2,
216 	.resource	= pxa_resource_stuart,
217 	.num_resources	= ARRAY_SIZE(pxa_resource_stuart),
218 };
219 
220 void __init pxa_set_stuart_info(void *info)
221 {
222 	pxa_register_device(&pxa_device_stuart, info);
223 }
224 
225 static struct resource pxa_resource_hwuart[] = {
226 	{
227 		.start	= 0x41600000,
228 		.end	= 0x4160002F,
229 		.flags	= IORESOURCE_MEM,
230 	}, {
231 		.start	= IRQ_HWUART,
232 		.end	= IRQ_HWUART,
233 		.flags	= IORESOURCE_IRQ,
234 	}
235 };
236 
237 struct platform_device pxa_device_hwuart = {
238 	.name		= "pxa2xx-uart",
239 	.id		= 3,
240 	.resource	= pxa_resource_hwuart,
241 	.num_resources	= ARRAY_SIZE(pxa_resource_hwuart),
242 };
243 
244 void __init pxa_set_hwuart_info(void *info)
245 {
246 	if (cpu_is_pxa255())
247 		pxa_register_device(&pxa_device_hwuart, info);
248 	else
249 		pr_info("UART: Ignoring attempt to register HWUART on non-PXA255 hardware");
250 }
251 
252 static struct resource pxai2c_resources[] = {
253 	{
254 		.start	= 0x40301680,
255 		.end	= 0x403016a3,
256 		.flags	= IORESOURCE_MEM,
257 	}, {
258 		.start	= IRQ_I2C,
259 		.end	= IRQ_I2C,
260 		.flags	= IORESOURCE_IRQ,
261 	},
262 };
263 
264 struct platform_device pxa_device_i2c = {
265 	.name		= "pxa2xx-i2c",
266 	.id		= 0,
267 	.resource	= pxai2c_resources,
268 	.num_resources	= ARRAY_SIZE(pxai2c_resources),
269 };
270 
271 void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
272 {
273 	pxa_register_device(&pxa_device_i2c, info);
274 }
275 
276 #ifdef CONFIG_PXA27x
277 static struct resource pxa27x_resources_i2c_power[] = {
278 	{
279 		.start	= 0x40f00180,
280 		.end	= 0x40f001a3,
281 		.flags	= IORESOURCE_MEM,
282 	}, {
283 		.start	= IRQ_PWRI2C,
284 		.end	= IRQ_PWRI2C,
285 		.flags	= IORESOURCE_IRQ,
286 	},
287 };
288 
289 struct platform_device pxa27x_device_i2c_power = {
290 	.name		= "pxa2xx-i2c",
291 	.id		= 1,
292 	.resource	= pxa27x_resources_i2c_power,
293 	.num_resources	= ARRAY_SIZE(pxa27x_resources_i2c_power),
294 };
295 #endif
296 
297 static struct resource pxai2s_resources[] = {
298 	{
299 		.start	= 0x40400000,
300 		.end	= 0x40400083,
301 		.flags	= IORESOURCE_MEM,
302 	}, {
303 		.start	= IRQ_I2S,
304 		.end	= IRQ_I2S,
305 		.flags	= IORESOURCE_IRQ,
306 	},
307 };
308 
309 struct platform_device pxa_device_i2s = {
310 	.name		= "pxa2xx-i2s",
311 	.id		= -1,
312 	.resource	= pxai2s_resources,
313 	.num_resources	= ARRAY_SIZE(pxai2s_resources),
314 };
315 
316 struct platform_device pxa_device_asoc_ssp1 = {
317 	.name		= "pxa-ssp-dai",
318 	.id		= 0,
319 };
320 
321 struct platform_device pxa_device_asoc_ssp2= {
322 	.name		= "pxa-ssp-dai",
323 	.id		= 1,
324 };
325 
326 struct platform_device pxa_device_asoc_ssp3 = {
327 	.name		= "pxa-ssp-dai",
328 	.id		= 2,
329 };
330 
331 struct platform_device pxa_device_asoc_ssp4 = {
332 	.name		= "pxa-ssp-dai",
333 	.id		= 3,
334 };
335 
336 struct platform_device pxa_device_asoc_platform = {
337 	.name		= "pxa-pcm-audio",
338 	.id		= -1,
339 };
340 
341 static struct resource pxa_rtc_resources[] = {
342 	[0] = {
343 		.start  = 0x40900000,
344 		.end	= 0x40900000 + 0x3b,
345 		.flags  = IORESOURCE_MEM,
346 	},
347 	[1] = {
348 		.start  = IRQ_RTC1Hz,
349 		.end    = IRQ_RTC1Hz,
350 		.name	= "rtc 1Hz",
351 		.flags  = IORESOURCE_IRQ,
352 	},
353 	[2] = {
354 		.start  = IRQ_RTCAlrm,
355 		.end    = IRQ_RTCAlrm,
356 		.name	= "rtc alarm",
357 		.flags  = IORESOURCE_IRQ,
358 	},
359 };
360 
361 struct platform_device pxa_device_rtc = {
362 	.name		= "pxa-rtc",
363 	.id		= -1,
364 	.num_resources  = ARRAY_SIZE(pxa_rtc_resources),
365 	.resource       = pxa_rtc_resources,
366 };
367 
368 struct platform_device sa1100_device_rtc = {
369 	.name		= "sa1100-rtc",
370 	.id		= -1,
371 	.num_resources  = ARRAY_SIZE(pxa_rtc_resources),
372 	.resource       = pxa_rtc_resources,
373 };
374 
375 #ifdef CONFIG_PXA25x
376 
377 static struct resource pxa25x_resource_pwm0[] = {
378 	[0] = {
379 		.start	= 0x40b00000,
380 		.end	= 0x40b0000f,
381 		.flags	= IORESOURCE_MEM,
382 	},
383 };
384 
385 struct platform_device pxa25x_device_pwm0 = {
386 	.name		= "pxa25x-pwm",
387 	.id		= 0,
388 	.resource	= pxa25x_resource_pwm0,
389 	.num_resources	= ARRAY_SIZE(pxa25x_resource_pwm0),
390 };
391 
392 static struct resource pxa25x_resource_pwm1[] = {
393 	[0] = {
394 		.start	= 0x40c00000,
395 		.end	= 0x40c0000f,
396 		.flags	= IORESOURCE_MEM,
397 	},
398 };
399 
400 struct platform_device pxa25x_device_pwm1 = {
401 	.name		= "pxa25x-pwm",
402 	.id		= 1,
403 	.resource	= pxa25x_resource_pwm1,
404 	.num_resources	= ARRAY_SIZE(pxa25x_resource_pwm1),
405 };
406 
407 static u64 pxa25x_ssp_dma_mask = DMA_BIT_MASK(32);
408 
409 static struct resource pxa25x_resource_ssp[] = {
410 	[0] = {
411 		.start	= 0x41000000,
412 		.end	= 0x4100001f,
413 		.flags	= IORESOURCE_MEM,
414 	},
415 	[1] = {
416 		.start	= IRQ_SSP,
417 		.end	= IRQ_SSP,
418 		.flags	= IORESOURCE_IRQ,
419 	},
420 };
421 
422 struct platform_device pxa25x_device_ssp = {
423 	.name		= "pxa25x-ssp",
424 	.id		= 0,
425 	.dev		= {
426 		.dma_mask = &pxa25x_ssp_dma_mask,
427 		.coherent_dma_mask = DMA_BIT_MASK(32),
428 	},
429 	.resource	= pxa25x_resource_ssp,
430 	.num_resources	= ARRAY_SIZE(pxa25x_resource_ssp),
431 };
432 
433 static u64 pxa25x_nssp_dma_mask = DMA_BIT_MASK(32);
434 
435 static struct resource pxa25x_resource_nssp[] = {
436 	[0] = {
437 		.start	= 0x41400000,
438 		.end	= 0x4140002f,
439 		.flags	= IORESOURCE_MEM,
440 	},
441 	[1] = {
442 		.start	= IRQ_NSSP,
443 		.end	= IRQ_NSSP,
444 		.flags	= IORESOURCE_IRQ,
445 	},
446 };
447 
448 struct platform_device pxa25x_device_nssp = {
449 	.name		= "pxa25x-nssp",
450 	.id		= 1,
451 	.dev		= {
452 		.dma_mask = &pxa25x_nssp_dma_mask,
453 		.coherent_dma_mask = DMA_BIT_MASK(32),
454 	},
455 	.resource	= pxa25x_resource_nssp,
456 	.num_resources	= ARRAY_SIZE(pxa25x_resource_nssp),
457 };
458 
459 static u64 pxa25x_assp_dma_mask = DMA_BIT_MASK(32);
460 
461 static struct resource pxa25x_resource_assp[] = {
462 	[0] = {
463 		.start	= 0x41500000,
464 		.end	= 0x4150002f,
465 		.flags	= IORESOURCE_MEM,
466 	},
467 	[1] = {
468 		.start	= IRQ_ASSP,
469 		.end	= IRQ_ASSP,
470 		.flags	= IORESOURCE_IRQ,
471 	},
472 };
473 
474 struct platform_device pxa25x_device_assp = {
475 	/* ASSP is basically equivalent to NSSP */
476 	.name		= "pxa25x-nssp",
477 	.id		= 2,
478 	.dev		= {
479 		.dma_mask = &pxa25x_assp_dma_mask,
480 		.coherent_dma_mask = DMA_BIT_MASK(32),
481 	},
482 	.resource	= pxa25x_resource_assp,
483 	.num_resources	= ARRAY_SIZE(pxa25x_resource_assp),
484 };
485 #endif /* CONFIG_PXA25x */
486 
487 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
488 static u64 pxa27x_ohci_dma_mask = DMA_BIT_MASK(32);
489 
490 static struct resource pxa27x_resource_ohci[] = {
491 	[0] = {
492 		.start  = 0x4C000000,
493 		.end    = 0x4C00ff6f,
494 		.flags  = IORESOURCE_MEM,
495 	},
496 	[1] = {
497 		.start  = IRQ_USBH1,
498 		.end    = IRQ_USBH1,
499 		.flags  = IORESOURCE_IRQ,
500 	},
501 };
502 
503 struct platform_device pxa27x_device_ohci = {
504 	.name		= "pxa27x-ohci",
505 	.id		= -1,
506 	.dev		= {
507 		.dma_mask = &pxa27x_ohci_dma_mask,
508 		.coherent_dma_mask = DMA_BIT_MASK(32),
509 	},
510 	.num_resources  = ARRAY_SIZE(pxa27x_resource_ohci),
511 	.resource       = pxa27x_resource_ohci,
512 };
513 
514 void __init pxa_set_ohci_info(struct pxaohci_platform_data *info)
515 {
516 	pxa_register_device(&pxa27x_device_ohci, info);
517 }
518 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
519 
520 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
521 static u64 pxa27x_ssp1_dma_mask = DMA_BIT_MASK(32);
522 
523 static struct resource pxa27x_resource_ssp1[] = {
524 	[0] = {
525 		.start	= 0x41000000,
526 		.end	= 0x4100003f,
527 		.flags	= IORESOURCE_MEM,
528 	},
529 	[1] = {
530 		.start	= IRQ_SSP,
531 		.end	= IRQ_SSP,
532 		.flags	= IORESOURCE_IRQ,
533 	},
534 };
535 
536 struct platform_device pxa27x_device_ssp1 = {
537 	.name		= "pxa27x-ssp",
538 	.id		= 0,
539 	.dev		= {
540 		.dma_mask = &pxa27x_ssp1_dma_mask,
541 		.coherent_dma_mask = DMA_BIT_MASK(32),
542 	},
543 	.resource	= pxa27x_resource_ssp1,
544 	.num_resources	= ARRAY_SIZE(pxa27x_resource_ssp1),
545 };
546 
547 static u64 pxa27x_ssp2_dma_mask = DMA_BIT_MASK(32);
548 
549 static struct resource pxa27x_resource_ssp2[] = {
550 	[0] = {
551 		.start	= 0x41700000,
552 		.end	= 0x4170003f,
553 		.flags	= IORESOURCE_MEM,
554 	},
555 	[1] = {
556 		.start	= IRQ_SSP2,
557 		.end	= IRQ_SSP2,
558 		.flags	= IORESOURCE_IRQ,
559 	},
560 };
561 
562 struct platform_device pxa27x_device_ssp2 = {
563 	.name		= "pxa27x-ssp",
564 	.id		= 1,
565 	.dev		= {
566 		.dma_mask = &pxa27x_ssp2_dma_mask,
567 		.coherent_dma_mask = DMA_BIT_MASK(32),
568 	},
569 	.resource	= pxa27x_resource_ssp2,
570 	.num_resources	= ARRAY_SIZE(pxa27x_resource_ssp2),
571 };
572 
573 static u64 pxa27x_ssp3_dma_mask = DMA_BIT_MASK(32);
574 
575 static struct resource pxa27x_resource_ssp3[] = {
576 	[0] = {
577 		.start	= 0x41900000,
578 		.end	= 0x4190003f,
579 		.flags	= IORESOURCE_MEM,
580 	},
581 	[1] = {
582 		.start	= IRQ_SSP3,
583 		.end	= IRQ_SSP3,
584 		.flags	= IORESOURCE_IRQ,
585 	},
586 };
587 
588 struct platform_device pxa27x_device_ssp3 = {
589 	.name		= "pxa27x-ssp",
590 	.id		= 2,
591 	.dev		= {
592 		.dma_mask = &pxa27x_ssp3_dma_mask,
593 		.coherent_dma_mask = DMA_BIT_MASK(32),
594 	},
595 	.resource	= pxa27x_resource_ssp3,
596 	.num_resources	= ARRAY_SIZE(pxa27x_resource_ssp3),
597 };
598 
599 static struct resource pxa27x_resource_pwm0[] = {
600 	[0] = {
601 		.start	= 0x40b00000,
602 		.end	= 0x40b0001f,
603 		.flags	= IORESOURCE_MEM,
604 	},
605 };
606 
607 struct platform_device pxa27x_device_pwm0 = {
608 	.name		= "pxa27x-pwm",
609 	.id		= 0,
610 	.resource	= pxa27x_resource_pwm0,
611 	.num_resources	= ARRAY_SIZE(pxa27x_resource_pwm0),
612 };
613 
614 static struct resource pxa27x_resource_pwm1[] = {
615 	[0] = {
616 		.start	= 0x40c00000,
617 		.end	= 0x40c0001f,
618 		.flags	= IORESOURCE_MEM,
619 	},
620 };
621 
622 struct platform_device pxa27x_device_pwm1 = {
623 	.name		= "pxa27x-pwm",
624 	.id		= 1,
625 	.resource	= pxa27x_resource_pwm1,
626 	.num_resources	= ARRAY_SIZE(pxa27x_resource_pwm1),
627 };
628 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
629 
630 struct resource pxa_resource_gpio[] = {
631 	{
632 		.start	= 0x40e00000,
633 		.end	= 0x40e0ffff,
634 		.flags	= IORESOURCE_MEM,
635 	}, {
636 		.start	= IRQ_GPIO0,
637 		.end	= IRQ_GPIO0,
638 		.name	= "gpio0",
639 		.flags	= IORESOURCE_IRQ,
640 	}, {
641 		.start	= IRQ_GPIO1,
642 		.end	= IRQ_GPIO1,
643 		.name	= "gpio1",
644 		.flags	= IORESOURCE_IRQ,
645 	}, {
646 		.start	= IRQ_GPIO_2_x,
647 		.end	= IRQ_GPIO_2_x,
648 		.name	= "gpio_mux",
649 		.flags	= IORESOURCE_IRQ,
650 	},
651 };
652 
653 struct platform_device pxa25x_device_gpio = {
654 	.name		= "pxa25x-gpio",
655 	.id		= -1,
656 	.num_resources	= ARRAY_SIZE(pxa_resource_gpio),
657 	.resource	= pxa_resource_gpio,
658 };
659 
660 struct platform_device pxa27x_device_gpio = {
661 	.name		= "pxa27x-gpio",
662 	.id		= -1,
663 	.num_resources	= ARRAY_SIZE(pxa_resource_gpio),
664 	.resource	= pxa_resource_gpio,
665 };
666 
667 static struct resource pxa_dma_resource[] = {
668 	[0] = {
669 		.start	= 0x40000000,
670 		.end	= 0x4000ffff,
671 		.flags	= IORESOURCE_MEM,
672 	},
673 	[1] = {
674 		.start	= IRQ_DMA,
675 		.end	= IRQ_DMA,
676 		.flags	= IORESOURCE_IRQ,
677 	},
678 };
679 
680 static u64 pxadma_dmamask = 0xffffffffUL;
681 
682 static struct platform_device pxa2xx_pxa_dma = {
683 	.name		= "pxa-dma",
684 	.id		= 0,
685 	.dev		= {
686 		.dma_mask = &pxadma_dmamask,
687 		.coherent_dma_mask = 0xffffffff,
688 	},
689 	.num_resources	= ARRAY_SIZE(pxa_dma_resource),
690 	.resource	= pxa_dma_resource,
691 };
692 
693 void __init pxa2xx_set_dmac_info(struct mmp_dma_platdata *dma_pdata)
694 {
695 	pxa_register_device(&pxa2xx_pxa_dma, dma_pdata);
696 }
697 
698 void __init pxa_register_wdt(unsigned int reset_status)
699 {
700 	struct resource res = DEFINE_RES_MEM(OST_PHYS, OST_LEN);
701 
702 	reset_status &= RESET_STATUS_WATCHDOG;
703 	platform_device_register_resndata(NULL, "sa1100_wdt", -1, &res, 1,
704 					  &reset_status, sizeof(reset_status));
705 }
706