Loading...
1#include <linux/err.h>
2#include <linux/kernel.h>
3#include <linux/init.h>
4#include <linux/io.h>
5#include <linux/platform_device.h>
6#include <linux/ata_platform.h>
7
8#include <asm/sibyte/board.h>
9#include <asm/sibyte/sb1250_genbus.h>
10#include <asm/sibyte/sb1250_regs.h>
11
12#if defined(CONFIG_SIBYTE_SWARM) || defined(CONFIG_SIBYTE_LITTLESUR)
13
14#define DRV_NAME "pata-swarm"
15
16#define SWARM_IDE_SHIFT 5
17#define SWARM_IDE_BASE 0x1f0
18#define SWARM_IDE_CTRL 0x3f6
19
20static struct resource swarm_pata_resource[] = {
21 {
22 .name = "Swarm GenBus IDE",
23 .flags = IORESOURCE_MEM,
24 }, {
25 .name = "Swarm GenBus IDE",
26 .flags = IORESOURCE_MEM,
27 }, {
28 .name = "Swarm GenBus IDE",
29 .flags = IORESOURCE_IRQ,
30 .start = K_INT_GB_IDE,
31 .end = K_INT_GB_IDE,
32 },
33};
34
35static struct pata_platform_info pata_platform_data = {
36 .ioport_shift = SWARM_IDE_SHIFT,
37};
38
39static struct platform_device swarm_pata_device = {
40 .name = "pata_platform",
41 .id = -1,
42 .resource = swarm_pata_resource,
43 .num_resources = ARRAY_SIZE(swarm_pata_resource),
44 .dev = {
45 .platform_data = &pata_platform_data,
46 .coherent_dma_mask = ~0, /* grumble */
47 },
48};
49
50static int __init swarm_pata_init(void)
51{
52 u8 __iomem *base;
53 phys_t offset, size;
54 struct resource *r;
55
56 if (!SIBYTE_HAVE_IDE)
57 return -ENODEV;
58
59 base = ioremap(A_IO_EXT_BASE, 0x800);
60 offset = __raw_readq(base + R_IO_EXT_REG(R_IO_EXT_START_ADDR, IDE_CS));
61 size = __raw_readq(base + R_IO_EXT_REG(R_IO_EXT_MULT_SIZE, IDE_CS));
62 iounmap(base);
63
64 offset = G_IO_START_ADDR(offset) << S_IO_ADDRBASE;
65 size = (G_IO_MULT_SIZE(size) + 1) << S_IO_REGSIZE;
66 if (offset < A_PHYS_GENBUS || offset >= A_PHYS_GENBUS_END) {
67 pr_info(DRV_NAME ": PATA interface at GenBus disabled\n");
68
69 return -EBUSY;
70 }
71
72 pr_info(DRV_NAME ": PATA interface at GenBus slot %i\n", IDE_CS);
73
74 r = swarm_pata_resource;
75 r[0].start = offset + (SWARM_IDE_BASE << SWARM_IDE_SHIFT);
76 r[0].end = offset + ((SWARM_IDE_BASE + 8) << SWARM_IDE_SHIFT) - 1;
77 r[1].start = offset + (SWARM_IDE_CTRL << SWARM_IDE_SHIFT);
78 r[1].end = offset + ((SWARM_IDE_CTRL + 1) << SWARM_IDE_SHIFT) - 1;
79
80 return platform_device_register(&swarm_pata_device);
81}
82
83device_initcall(swarm_pata_init);
84
85#endif /* defined(CONFIG_SIBYTE_SWARM) || defined(CONFIG_SIBYTE_LITTLESUR) */
86
87#define sb1250_dev_struct(num) \
88 static struct resource sb1250_res##num = { \
89 .name = "SB1250 MAC " __stringify(num), \
90 .flags = IORESOURCE_MEM, \
91 .start = A_MAC_CHANNEL_BASE(num), \
92 .end = A_MAC_CHANNEL_BASE(num + 1) -1, \
93 };\
94 static struct platform_device sb1250_dev##num = { \
95 .name = "sb1250-mac", \
96 .id = num, \
97 .resource = &sb1250_res##num, \
98 .num_resources = 1, \
99 }
100
101sb1250_dev_struct(0);
102sb1250_dev_struct(1);
103sb1250_dev_struct(2);
104sb1250_dev_struct(3);
105
106static struct platform_device *sb1250_devs[] __initdata = {
107 &sb1250_dev0,
108 &sb1250_dev1,
109 &sb1250_dev2,
110 &sb1250_dev3,
111};
112
113static int __init sb1250_device_init(void)
114{
115 int ret;
116
117 /* Set the number of available units based on the SOC type. */
118 switch (soc_type) {
119 case K_SYS_SOC_TYPE_BCM1250:
120 case K_SYS_SOC_TYPE_BCM1250_ALT:
121 ret = platform_add_devices(sb1250_devs, 3);
122 break;
123 case K_SYS_SOC_TYPE_BCM1120:
124 case K_SYS_SOC_TYPE_BCM1125:
125 case K_SYS_SOC_TYPE_BCM1125H:
126 case K_SYS_SOC_TYPE_BCM1250_ALT2: /* Hybrid */
127 ret = platform_add_devices(sb1250_devs, 2);
128 break;
129 case K_SYS_SOC_TYPE_BCM1x55:
130 case K_SYS_SOC_TYPE_BCM1x80:
131 ret = platform_add_devices(sb1250_devs, 4);
132 break;
133 default:
134 ret = -ENODEV;
135 break;
136 }
137 return ret;
138}
139device_initcall(sb1250_device_init);
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/err.h>
3#include <linux/kernel.h>
4#include <linux/init.h>
5#include <linux/io.h>
6#include <linux/platform_device.h>
7#include <linux/ata_platform.h>
8
9#include <asm/sibyte/board.h>
10#include <asm/sibyte/sb1250_genbus.h>
11#include <asm/sibyte/sb1250_regs.h>
12
13#if defined(CONFIG_SIBYTE_SWARM) || defined(CONFIG_SIBYTE_LITTLESUR)
14
15#define DRV_NAME "pata-swarm"
16
17#define SWARM_IDE_SHIFT 5
18#define SWARM_IDE_BASE 0x1f0
19#define SWARM_IDE_CTRL 0x3f6
20
21static struct resource swarm_pata_resource[] = {
22 {
23 .name = "Swarm GenBus IDE",
24 .flags = IORESOURCE_MEM,
25 }, {
26 .name = "Swarm GenBus IDE",
27 .flags = IORESOURCE_MEM,
28 }, {
29 .name = "Swarm GenBus IDE",
30 .flags = IORESOURCE_IRQ,
31 .start = K_INT_GB_IDE,
32 .end = K_INT_GB_IDE,
33 },
34};
35
36static struct pata_platform_info pata_platform_data = {
37 .ioport_shift = SWARM_IDE_SHIFT,
38};
39
40static struct platform_device swarm_pata_device = {
41 .name = "pata_platform",
42 .id = -1,
43 .resource = swarm_pata_resource,
44 .num_resources = ARRAY_SIZE(swarm_pata_resource),
45 .dev = {
46 .platform_data = &pata_platform_data,
47 .coherent_dma_mask = ~0, /* grumble */
48 },
49};
50
51static int __init swarm_pata_init(void)
52{
53 u8 __iomem *base;
54 phys_addr_t offset, size;
55 struct resource *r;
56
57 if (!SIBYTE_HAVE_IDE)
58 return -ENODEV;
59
60 base = ioremap(A_IO_EXT_BASE, 0x800);
61 offset = __raw_readq(base + R_IO_EXT_REG(R_IO_EXT_START_ADDR, IDE_CS));
62 size = __raw_readq(base + R_IO_EXT_REG(R_IO_EXT_MULT_SIZE, IDE_CS));
63 iounmap(base);
64
65 offset = G_IO_START_ADDR(offset) << S_IO_ADDRBASE;
66 size = (G_IO_MULT_SIZE(size) + 1) << S_IO_REGSIZE;
67 if (offset < A_PHYS_GENBUS || offset >= A_PHYS_GENBUS_END) {
68 pr_info(DRV_NAME ": PATA interface at GenBus disabled\n");
69
70 return -EBUSY;
71 }
72
73 pr_info(DRV_NAME ": PATA interface at GenBus slot %i\n", IDE_CS);
74
75 r = swarm_pata_resource;
76 r[0].start = offset + (SWARM_IDE_BASE << SWARM_IDE_SHIFT);
77 r[0].end = offset + ((SWARM_IDE_BASE + 8) << SWARM_IDE_SHIFT) - 1;
78 r[1].start = offset + (SWARM_IDE_CTRL << SWARM_IDE_SHIFT);
79 r[1].end = offset + ((SWARM_IDE_CTRL + 1) << SWARM_IDE_SHIFT) - 1;
80
81 return platform_device_register(&swarm_pata_device);
82}
83
84device_initcall(swarm_pata_init);
85
86#endif /* defined(CONFIG_SIBYTE_SWARM) || defined(CONFIG_SIBYTE_LITTLESUR) */
87
88#define sb1250_dev_struct(num) \
89 static struct resource sb1250_res##num = { \
90 .name = "SB1250 MAC " __stringify(num), \
91 .flags = IORESOURCE_MEM, \
92 .start = A_MAC_CHANNEL_BASE(num), \
93 .end = A_MAC_CHANNEL_BASE(num + 1) -1, \
94 };\
95 static struct platform_device sb1250_dev##num = { \
96 .name = "sb1250-mac", \
97 .id = num, \
98 .resource = &sb1250_res##num, \
99 .num_resources = 1, \
100 }
101
102sb1250_dev_struct(0);
103sb1250_dev_struct(1);
104sb1250_dev_struct(2);
105sb1250_dev_struct(3);
106
107static struct platform_device *sb1250_devs[] __initdata = {
108 &sb1250_dev0,
109 &sb1250_dev1,
110 &sb1250_dev2,
111 &sb1250_dev3,
112};
113
114static int __init sb1250_device_init(void)
115{
116 int ret;
117
118 /* Set the number of available units based on the SOC type. */
119 switch (soc_type) {
120 case K_SYS_SOC_TYPE_BCM1250:
121 case K_SYS_SOC_TYPE_BCM1250_ALT:
122 ret = platform_add_devices(sb1250_devs, 3);
123 break;
124 case K_SYS_SOC_TYPE_BCM1120:
125 case K_SYS_SOC_TYPE_BCM1125:
126 case K_SYS_SOC_TYPE_BCM1125H:
127 case K_SYS_SOC_TYPE_BCM1250_ALT2: /* Hybrid */
128 ret = platform_add_devices(sb1250_devs, 2);
129 break;
130 case K_SYS_SOC_TYPE_BCM1x55:
131 case K_SYS_SOC_TYPE_BCM1x80:
132 ret = platform_add_devices(sb1250_devs, 4);
133 break;
134 default:
135 ret = -ENODEV;
136 break;
137 }
138 return ret;
139}
140device_initcall(sb1250_device_init);