Pileus Git - ~andy/linux/blob - 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         if (IS_ERR(pdev))
  60                 return PTR_ERR(pdev);
  61
  62         return 0;
  63 }
  64
  65 subsys_initcall(amiga_init_bus);
  66
  67
  68 static int __init z_dev_present(zorro_id id)
  69 {
  70         unsigned int i;
  71
  72         for (i = 0; i < zorro_num_autocon; i++)
  73                 if (zorro_autocon[i].rom.er_Manufacturer == ZORRO_MANUF(id) &&
  74                     zorro_autocon[i].rom.er_Product == ZORRO_PROD(id))
  75                         return 1;
  76
  77         return 0;
  78 }
  79
  80 #else /* !CONFIG_ZORRO */
  81
  82 static inline int z_dev_present(zorro_id id) { return 0; }
  83
  84 #endif /* !CONFIG_ZORRO */
  85
  86
  87 static const struct resource a3000_scsi_resource __initconst = {
  88         .start  = 0xdd0000,
  89         .end    = 0xdd00ff,
  90         .flags  = IORESOURCE_MEM,
  91 };
  92
  93
  94 static const struct resource a4000t_scsi_resource __initconst = {
  95         .start  = 0xdd0000,
  96         .end    = 0xdd0fff,
  97         .flags  = IORESOURCE_MEM,
  98 };
  99
 100
 101 static const struct resource a1200_ide_resource __initconst = {
 102         .start  = 0xda0000,
 103         .end    = 0xda1fff,
 104         .flags  = IORESOURCE_MEM,
 105 };
 106
 107 static const struct gayle_ide_platform_data a1200_ide_pdata __initconst = {
 108         .base           = 0xda0000,
 109         .irqport        = 0xda9000,
 110         .explicit_ack   = 1,
 111 };
 112
 113
 114 static const struct resource a4000_ide_resource __initconst = {
 115         .start  = 0xdd2000,
 116         .end    = 0xdd3fff,
 117         .flags  = IORESOURCE_MEM,
 118 };
 119
 120 static const struct gayle_ide_platform_data a4000_ide_pdata __initconst = {
 121         .base           = 0xdd2020,
 122         .irqport        = 0xdd3020,
 123         .explicit_ack   = 0,
 124 };
 125
 126
 127 static const struct resource amiga_rtc_resource __initconst = {
 128         .start  = 0x00dc0000,
 129         .end    = 0x00dcffff,
 130         .flags  = IORESOURCE_MEM,
 131 };
 132
 133
 134 static 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
 255 arch_initcall(amiga_init_devices);