1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/kernel.h>
#include <sys/queue.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <sys/bus.h>
#include <machine/bus.h>
#include <sys/rman.h>
#include <machine/resource.h>
#include <dev/spibus/spibusvar.h>
#include <dev/spibus/spi.h>
#include "spibus_if.h"
static int
spibus_probe(device_t dev)
{
device_set_desc(dev, "spibus bus");
return (BUS_PROBE_GENERIC);
}
static int
spibus_attach(device_t dev)
{
struct spibus_softc *sc = SPIBUS_SOFTC(dev);
sc->dev = dev;
bus_enumerate_hinted_children(dev);
return (bus_generic_attach(dev));
}
/*
* Since this is not a self-enumerating bus, and since we always add
* children in attach, we have to always delete children here.
*/
static int
spibus_detach(device_t dev)
{
int err, ndevs, i;
device_t *devlist;
if ((err = bus_generic_detach(dev)) != 0)
return (err);
if ((err = device_get_children(dev, &devlist, &ndevs)) != 0)
return (err);
for (i = 0; i < ndevs; i++)
device_delete_child(dev, devlist[i]);
free(devlist, M_TEMP);
return (0);
}
static int
spibus_suspend(device_t dev)
{
return (bus_generic_suspend(dev));
}
static
int
spibus_resume(device_t dev)
{
return (bus_generic_resume(dev));
}
static int
spibus_print_child(device_t dev, device_t child)
{
struct spibus_ivar *devi = SPIBUS_IVAR(child);
int retval = 0;
retval += bus_print_child_header(dev, child);
retval += printf(" at cs %d", devi->cs);
retval += bus_print_child_footer(dev, child);
return (retval);
}
static void
spibus_probe_nomatch(device_t bus, device_t child)
{
struct spibus_ivar *devi = SPIBUS_IVAR(child);
device_printf(bus, "<unknown card>");
printf(" at cs %d\n", devi->cs);
return;
}
static int
spibus_child_location_str(device_t bus, device_t child, char *buf,
size_t buflen)
{
struct spibus_ivar *devi = SPIBUS_IVAR(child);
snprintf(buf, buflen, "cs=%d", devi->cs);
return (0);
}
static int
spibus_child_pnpinfo_str(device_t bus, device_t child, char *buf,
size_t buflen)
{
*buf = '\0';
return (0);
}
static int
spibus_read_ivar(device_t bus, device_t child, int which, u_int *result)
{
struct spibus_ivar *devi = SPIBUS_IVAR(child);
switch (which) {
default:
return (EINVAL);
case SPIBUS_IVAR_CS:
*(uint32_t *)result = devi->cs;
break;
}
return (0);
}
static device_t
spibus_add_child(device_t dev, u_int order, const char *name, int unit)
{
device_t child;
struct spibus_ivar *devi;
child = device_add_child_ordered(dev, order, name, unit);
if (child == NULL)
return (child);
devi = malloc(sizeof(struct spibus_ivar), M_DEVBUF, M_NOWAIT | M_ZERO);
if (devi == NULL) {
device_delete_child(dev, child);
return (0);
}
device_set_ivars(child, devi);
return (child);
}
static void
spibus_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
struct spibus_ivar *devi;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
devi = SPIBUS_IVAR(child);
resource_int_value(dname, dunit, "cs", &devi->cs);
}
static int
spibus_transfer_impl(device_t dev, device_t child, struct spi_command *cmd)
{
return (SPIBUS_TRANSFER(device_get_parent(dev), child, cmd));
}
static device_method_t spibus_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, spibus_probe),
DEVMETHOD(device_attach, spibus_attach),
DEVMETHOD(device_detach, spibus_detach),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(device_suspend, spibus_suspend),
DEVMETHOD(device_resume, spibus_resume),
/* Bus interface */
DEVMETHOD(bus_add_child, spibus_add_child),
DEVMETHOD(bus_print_child, spibus_print_child),
DEVMETHOD(bus_probe_nomatch, spibus_probe_nomatch),
DEVMETHOD(bus_read_ivar, spibus_read_ivar),
DEVMETHOD(bus_child_pnpinfo_str, spibus_child_pnpinfo_str),
DEVMETHOD(bus_child_location_str, spibus_child_location_str),
DEVMETHOD(bus_hinted_child, spibus_hinted_child),
/* spibus interface */
DEVMETHOD(spibus_transfer, spibus_transfer_impl),
DEVMETHOD_END
};
driver_t spibus_driver = {
"spibus",
spibus_methods,
sizeof(struct spibus_softc)
};
devclass_t spibus_devclass;
DRIVER_MODULE(spibus, spi, spibus_driver, spibus_devclass, 0, 0);
MODULE_VERSION(spibus, 1);
|
