5#include <sys/param.h>
6#include <sys/systm.h>
7#include <sys/kernel.h>
8#include <sys/module.h>
9#include <sys/conf.h>
10#include <sys/fcntl.h>
11#include <sys/bio.h>
12#include <sys/cdio.h>
13#include <sys/bus.h>
14
15#include <sys/mutex.h>
16
17#include <machine/bus_pio.h>
18#include <machine/bus.h>
19#include <machine/resource.h>
20#include <sys/rman.h>
21
22#include <isa/isavar.h>
23
24#include <dev/scd/scdreg.h>
25#include <dev/scd/scdvar.h>
26
27static int scd_isa_probe (device_t);
28static int scd_isa_attach (device_t);
29static int scd_isa_detach (device_t);
30
31static int scd_alloc_resources (device_t);
32static void scd_release_resources (device_t);
33
34static int
35scd_isa_probe (device_t dev)
36{
37 struct scd_softc * sc;
38 int error;
39
40 /* No pnp support */
41 if (isa_get_vendorid(dev))
42 return (ENXIO);
43
44 /* IO port must be configured. */
45 if (bus_get_resource_start(dev, SYS_RES_IOPORT, 0) == 0)
46 return (ENXIO);
47
48 sc = device_get_softc(dev);
49 sc->dev = dev;
50 sc->port_rid = 0;
51 sc->port_type = SYS_RES_IOPORT;
52 error = scd_alloc_resources(dev);
53 if (error)
54 goto fail;
55
56 error = scd_probe(sc);
57 if (error) {
58 device_printf(dev, "Probe failed.\n");
59 goto fail;
60 }
61
62 device_set_desc(dev, sc->data.name);
63
64fail:
65 scd_release_resources(dev);
66 return (error);
67}
68
69static int
70scd_isa_attach (device_t dev)
71{
72 struct scd_softc * sc;
73 int error;
74
75 sc = device_get_softc(dev);
76 error = 0;
77
78 sc->dev = dev;
79 sc->port_rid = 0;
80 sc->port_type = SYS_RES_IOPORT;
81 error = scd_alloc_resources(dev);
82 if (error)
83 goto fail;
84
85 error = scd_probe(sc);
86 if (error) {
87 device_printf(dev, "Re-Probe failed.\n");
88 goto fail;
89 }
90
91 error = scd_attach(sc);
92 if (error) {
93 device_printf(dev, "Attach failed.\n");
94 goto fail;
95 }
96
97 return (0);
98fail:
99 scd_release_resources(dev);
100 return (error);
101}
102
103static int
104scd_isa_detach (device_t dev)
105{
106 struct scd_softc * sc;
107 int error;
108
109 sc = device_get_softc(dev);
110 error = 0;
111
112 destroy_dev(sc->scd_dev_t);
113
114 scd_release_resources(dev);
115
116 return (error);
117}
118
119static int
120scd_alloc_resources (device_t dev)
121{
122 struct scd_softc * sc;
123 int error;
124
125 sc = device_get_softc(dev);
126 error = 0;
127
128 if (sc->port_type) {
129 sc->port = bus_alloc_resource(dev, sc->port_type, &sc->port_rid,
130 0, ~0, 1, RF_ACTIVE);
131 if (sc->port == NULL) {
132 device_printf(dev, "Unable to allocate PORT resource.\n");
133 error = ENOMEM;
134 goto bad;
135 }
136 sc->port_bst = rman_get_bustag(sc->port);
137 sc->port_bsh = rman_get_bushandle(sc->port);
138 }
139
140 mtx_init(&sc->mtx, device_get_nameunit(dev),
141 "Interrupt lock", MTX_DEF | MTX_RECURSE);
142
143bad:
144 return (error);
145}
146
147void
148scd_release_resources (device_t dev)
149{
150 struct scd_softc * sc;
151
152 sc = device_get_softc(dev);
153
154 if (sc->port) {
155 bus_release_resource(dev, sc->port_type, sc->port_rid, sc->port);
156 sc->port_bst = 0;
157 sc->port_bsh = 0;
158 }
159
160 if (mtx_initialized(&sc->mtx) != 0)
161 mtx_destroy(&sc->mtx);
162
163 return;
164}
165
166static device_method_t scd_isa_methods[] = {
167 DEVMETHOD(device_probe, scd_isa_probe),
168 DEVMETHOD(device_attach, scd_isa_attach),
169 DEVMETHOD(device_detach, scd_isa_detach),
170
171 { 0, 0 }
172};
173
174static driver_t scd_isa_driver = {
175 "scd",
176 scd_isa_methods,
177 sizeof(struct scd_softc)
178};
179
180static devclass_t scd_devclass;
181
182DRIVER_MODULE(scd, isa, scd_isa_driver, scd_devclass, NULL, 0);
| 7#include <sys/param.h>
8#include <sys/systm.h>
9#include <sys/kernel.h>
10#include <sys/module.h>
11#include <sys/conf.h>
12#include <sys/fcntl.h>
13#include <sys/bio.h>
14#include <sys/cdio.h>
15#include <sys/bus.h>
16
17#include <sys/mutex.h>
18
19#include <machine/bus_pio.h>
20#include <machine/bus.h>
21#include <machine/resource.h>
22#include <sys/rman.h>
23
24#include <isa/isavar.h>
25
26#include <dev/scd/scdreg.h>
27#include <dev/scd/scdvar.h>
28
29static int scd_isa_probe (device_t);
30static int scd_isa_attach (device_t);
31static int scd_isa_detach (device_t);
32
33static int scd_alloc_resources (device_t);
34static void scd_release_resources (device_t);
35
36static int
37scd_isa_probe (device_t dev)
38{
39 struct scd_softc * sc;
40 int error;
41
42 /* No pnp support */
43 if (isa_get_vendorid(dev))
44 return (ENXIO);
45
46 /* IO port must be configured. */
47 if (bus_get_resource_start(dev, SYS_RES_IOPORT, 0) == 0)
48 return (ENXIO);
49
50 sc = device_get_softc(dev);
51 sc->dev = dev;
52 sc->port_rid = 0;
53 sc->port_type = SYS_RES_IOPORT;
54 error = scd_alloc_resources(dev);
55 if (error)
56 goto fail;
57
58 error = scd_probe(sc);
59 if (error) {
60 device_printf(dev, "Probe failed.\n");
61 goto fail;
62 }
63
64 device_set_desc(dev, sc->data.name);
65
66fail:
67 scd_release_resources(dev);
68 return (error);
69}
70
71static int
72scd_isa_attach (device_t dev)
73{
74 struct scd_softc * sc;
75 int error;
76
77 sc = device_get_softc(dev);
78 error = 0;
79
80 sc->dev = dev;
81 sc->port_rid = 0;
82 sc->port_type = SYS_RES_IOPORT;
83 error = scd_alloc_resources(dev);
84 if (error)
85 goto fail;
86
87 error = scd_probe(sc);
88 if (error) {
89 device_printf(dev, "Re-Probe failed.\n");
90 goto fail;
91 }
92
93 error = scd_attach(sc);
94 if (error) {
95 device_printf(dev, "Attach failed.\n");
96 goto fail;
97 }
98
99 return (0);
100fail:
101 scd_release_resources(dev);
102 return (error);
103}
104
105static int
106scd_isa_detach (device_t dev)
107{
108 struct scd_softc * sc;
109 int error;
110
111 sc = device_get_softc(dev);
112 error = 0;
113
114 destroy_dev(sc->scd_dev_t);
115
116 scd_release_resources(dev);
117
118 return (error);
119}
120
121static int
122scd_alloc_resources (device_t dev)
123{
124 struct scd_softc * sc;
125 int error;
126
127 sc = device_get_softc(dev);
128 error = 0;
129
130 if (sc->port_type) {
131 sc->port = bus_alloc_resource(dev, sc->port_type, &sc->port_rid,
132 0, ~0, 1, RF_ACTIVE);
133 if (sc->port == NULL) {
134 device_printf(dev, "Unable to allocate PORT resource.\n");
135 error = ENOMEM;
136 goto bad;
137 }
138 sc->port_bst = rman_get_bustag(sc->port);
139 sc->port_bsh = rman_get_bushandle(sc->port);
140 }
141
142 mtx_init(&sc->mtx, device_get_nameunit(dev),
143 "Interrupt lock", MTX_DEF | MTX_RECURSE);
144
145bad:
146 return (error);
147}
148
149void
150scd_release_resources (device_t dev)
151{
152 struct scd_softc * sc;
153
154 sc = device_get_softc(dev);
155
156 if (sc->port) {
157 bus_release_resource(dev, sc->port_type, sc->port_rid, sc->port);
158 sc->port_bst = 0;
159 sc->port_bsh = 0;
160 }
161
162 if (mtx_initialized(&sc->mtx) != 0)
163 mtx_destroy(&sc->mtx);
164
165 return;
166}
167
168static device_method_t scd_isa_methods[] = {
169 DEVMETHOD(device_probe, scd_isa_probe),
170 DEVMETHOD(device_attach, scd_isa_attach),
171 DEVMETHOD(device_detach, scd_isa_detach),
172
173 { 0, 0 }
174};
175
176static driver_t scd_isa_driver = {
177 "scd",
178 scd_isa_methods,
179 sizeof(struct scd_softc)
180};
181
182static devclass_t scd_devclass;
183
184DRIVER_MODULE(scd, isa, scd_isa_driver, scd_devclass, NULL, 0);
|