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