m68k/amiga: Use PTR_RET rather than if(IS_ERR(...)) + PTR_ERR
[linux-3.10.git] / arch / m68k / amiga / platform.c
1 /*
2  *  Copyright (C) 2007-2009 Geert Uytterhoeven
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file COPYING in the main directory of this archive
6  * for more details.
7  */
8
9 #include <linux/err.h>
10 #include <linux/init.h>
11 #include <linux/platform_device.h>
12 #include <linux/zorro.h>
13
14 #include <asm/amigahw.h>
15 #include <asm/amigayle.h>
16
17
18 #ifdef CONFIG_ZORRO
19
20 static const struct resource zorro_resources[] __initconst = {
21         /* Zorro II regions (on Zorro II/III) */
22         {
23                 .name   = "Zorro II exp",
24                 .start  = 0x00e80000,
25                 .end    = 0x00efffff,
26                 .flags  = IORESOURCE_MEM,
27         }, {
28                 .name   = "Zorro II mem",
29                 .start  = 0x00200000,
30                 .end    = 0x009fffff,
31                 .flags  = IORESOURCE_MEM,
32         },
33         /* Zorro III regions (on Zorro III only) */
34         {
35                 .name   = "Zorro III exp",
36                 .start  = 0xff000000,
37                 .end    = 0xffffffff,
38                 .flags  = IORESOURCE_MEM,
39         }, {
40                 .name   = "Zorro III cfg",
41                 .start  = 0x40000000,
42                 .end    = 0x7fffffff,
43                 .flags  = IORESOURCE_MEM,
44         }
45 };
46
47
48 static int __init amiga_init_bus(void)
49 {
50         struct platform_device *pdev;
51         unsigned int n;
52
53         if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
54                 return -ENODEV;
55
56         n = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2;
57         pdev = platform_device_register_simple("amiga-zorro", -1,
58                                                zorro_resources, n);
59         return PTR_RET(pdev);
60 }
61
62 subsys_initcall(amiga_init_bus);
63
64
65 static int __init z_dev_present(zorro_id id)
66 {
67         unsigned int i;
68
69         for (i = 0; i < zorro_num_autocon; i++)
70                 if (zorro_autocon[i].rom.er_Manufacturer == ZORRO_MANUF(id) &&
71                     zorro_autocon[i].rom.er_Product == ZORRO_PROD(id))
72                         return 1;
73
74         return 0;
75 }
76
77 #else /* !CONFIG_ZORRO */
78
79 static inline int z_dev_present(zorro_id id) { return 0; }
80
81 #endif /* !CONFIG_ZORRO */
82
83
84 static const struct resource a3000_scsi_resource __initconst = {
85         .start  = 0xdd0000,
86         .end    = 0xdd00ff,
87         .flags  = IORESOURCE_MEM,
88 };
89
90
91 static const struct resource a4000t_scsi_resource __initconst = {
92         .start  = 0xdd0000,
93         .end    = 0xdd0fff,
94         .flags  = IORESOURCE_MEM,
95 };
96
97
98 static const struct resource a1200_ide_resource __initconst = {
99         .start  = 0xda0000,
100         .end    = 0xda1fff,
101         .flags  = IORESOURCE_MEM,
102 };
103
104 static const struct gayle_ide_platform_data a1200_ide_pdata __initconst = {
105         .base           = 0xda0000,
106         .irqport        = 0xda9000,
107         .explicit_ack   = 1,
108 };
109
110
111 static const struct resource a4000_ide_resource __initconst = {
112         .start  = 0xdd2000,
113         .end    = 0xdd3fff,
114         .flags  = IORESOURCE_MEM,
115 };
116
117 static const struct gayle_ide_platform_data a4000_ide_pdata __initconst = {
118         .base           = 0xdd2020,
119         .irqport        = 0xdd3020,
120         .explicit_ack   = 0,
121 };
122
123
124 static const struct resource amiga_rtc_resource __initconst = {
125         .start  = 0x00dc0000,
126         .end    = 0x00dcffff,
127         .flags  = IORESOURCE_MEM,
128 };
129
130
131 static int __init amiga_init_devices(void)
132 {
133         struct platform_device *pdev;
134         int error;
135
136         if (!MACH_IS_AMIGA)
137                 return -ENODEV;
138
139         /* video hardware */
140         if (AMIGAHW_PRESENT(AMI_VIDEO)) {
141                 pdev = platform_device_register_simple("amiga-video", -1, NULL,
142                                                        0);
143                 if (IS_ERR(pdev))
144                         return PTR_ERR(pdev);
145         }
146
147
148         /* sound hardware */
149         if (AMIGAHW_PRESENT(AMI_AUDIO)) {
150                 pdev = platform_device_register_simple("amiga-audio", -1, NULL,
151                                                        0);
152                 if (IS_ERR(pdev))
153                         return PTR_ERR(pdev);
154         }
155
156
157         /* storage interfaces */
158         if (AMIGAHW_PRESENT(AMI_FLOPPY)) {
159                 pdev = platform_device_register_simple("amiga-floppy", -1,
160                                                        NULL, 0);
161                 if (IS_ERR(pdev))
162                         return PTR_ERR(pdev);
163         }
164
165         if (AMIGAHW_PRESENT(A3000_SCSI)) {
166                 pdev = platform_device_register_simple("amiga-a3000-scsi", -1,
167                                                        &a3000_scsi_resource, 1);
168                 if (IS_ERR(pdev))
169                         return PTR_ERR(pdev);
170         }
171
172         if (AMIGAHW_PRESENT(A4000_SCSI)) {
173                 pdev = platform_device_register_simple("amiga-a4000t-scsi", -1,
174                                                        &a4000t_scsi_resource,
175                                                        1);
176                 if (IS_ERR(pdev))
177                         return PTR_ERR(pdev);
178         }
179
180         if (AMIGAHW_PRESENT(A1200_IDE) ||
181             z_dev_present(ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530_SCSI_IDE)) {
182                 pdev = platform_device_register_simple("amiga-gayle-ide", -1,
183                                                        &a1200_ide_resource, 1);
184                 if (IS_ERR(pdev))
185                         return PTR_ERR(pdev);
186                 error = platform_device_add_data(pdev, &a1200_ide_pdata,
187                                                  sizeof(a1200_ide_pdata));
188                 if (error)
189                         return error;
190         }
191
192         if (AMIGAHW_PRESENT(A4000_IDE)) {
193                 pdev = platform_device_register_simple("amiga-gayle-ide", -1,
194                                                        &a4000_ide_resource, 1);
195                 if (IS_ERR(pdev))
196                         return PTR_ERR(pdev);
197                 error = platform_device_add_data(pdev, &a4000_ide_pdata,
198                                                  sizeof(a4000_ide_pdata));
199                 if (error)
200                         return error;
201         }
202
203
204         /* other I/O hardware */
205         if (AMIGAHW_PRESENT(AMI_KEYBOARD)) {
206                 pdev = platform_device_register_simple("amiga-keyboard", -1,
207                                                        NULL, 0);
208                 if (IS_ERR(pdev))
209                         return PTR_ERR(pdev);
210         }
211
212         if (AMIGAHW_PRESENT(AMI_MOUSE)) {
213                 pdev = platform_device_register_simple("amiga-mouse", -1, NULL,
214                                                        0);
215                 if (IS_ERR(pdev))
216                         return PTR_ERR(pdev);
217         }
218
219         if (AMIGAHW_PRESENT(AMI_SERIAL)) {
220                 pdev = platform_device_register_simple("amiga-serial", -1,
221                                                        NULL, 0);
222                 if (IS_ERR(pdev))
223                         return PTR_ERR(pdev);
224         }
225
226         if (AMIGAHW_PRESENT(AMI_PARALLEL)) {
227                 pdev = platform_device_register_simple("amiga-parallel", -1,
228                                                        NULL, 0);
229                 if (IS_ERR(pdev))
230                         return PTR_ERR(pdev);
231         }
232
233
234         /* real time clocks */
235         if (AMIGAHW_PRESENT(A2000_CLK)) {
236                 pdev = platform_device_register_simple("rtc-msm6242", -1,
237                                                        &amiga_rtc_resource, 1);
238                 if (IS_ERR(pdev))
239                         return PTR_ERR(pdev);
240         }
241
242         if (AMIGAHW_PRESENT(A3000_CLK)) {
243                 pdev = platform_device_register_simple("rtc-rp5c01", -1,
244                                                        &amiga_rtc_resource, 1);
245                 if (IS_ERR(pdev))
246                         return PTR_ERR(pdev);
247         }
248
249         return 0;
250 }
251
252 arch_initcall(amiga_init_devices);