1 /*-
2 * Copyright (c) 2015 Brian Fundakowski Feldman. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 */
24
25 #include <sys/cdefs.h>
26 #include "opt_platform.h"
27 #include "opt_spi.h"
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/bus.h>
32 #include <sys/conf.h>
33 #include <sys/kernel.h>
34 #include <sys/lock.h>
35 #include <sys/malloc.h>
36 #include <sys/mman.h>
37 #include <sys/mutex.h>
38 #include <sys/module.h>
39 #include <sys/proc.h>
40 #include <sys/rwlock.h>
41 #include <sys/spigenio.h>
42 #include <sys/types.h>
43
44 #include <vm/vm.h>
45 #include <vm/vm_extern.h>
46 #include <vm/vm_object.h>
47 #include <vm/vm_page.h>
48 #include <vm/vm_pager.h>
49
50 #include <dev/spibus/spi.h>
51 #include <dev/spibus/spibusvar.h>
52
53 #ifdef FDT
54 #include <dev/ofw/ofw_bus_subr.h>
55
56 static struct ofw_compat_data compat_data[] = {
57 {"freebsd,spigen", true},
58 {NULL, false}
59 };
60
61 #endif
62
63 #include "spibus_if.h"
64
65 struct spigen_softc {
66 device_t sc_dev;
67 struct cdev *sc_cdev;
68 #ifdef SPIGEN_LEGACY_CDEVNAME
69 struct cdev *sc_adev; /* alias device */
70 #endif
71 struct mtx sc_mtx;
72 };
73
74 struct spigen_mmap {
75 vm_object_t bufobj;
76 vm_offset_t kvaddr;
77 size_t bufsize;
78 };
79
80 static int
spigen_probe(device_t dev)81 spigen_probe(device_t dev)
82 {
83 int rv;
84
85 /*
86 * By default we only bid to attach if specifically added by our parent
87 * (usually via hint.spigen.#.at=busname). On FDT systems we bid as the
88 * default driver based on being configured in the FDT data.
89 */
90 rv = BUS_PROBE_NOWILDCARD;
91
92 #ifdef FDT
93 if (ofw_bus_status_okay(dev) &&
94 ofw_bus_search_compatible(dev, compat_data)->ocd_data)
95 rv = BUS_PROBE_DEFAULT;
96 #endif
97
98 device_set_desc(dev, "SPI Generic IO");
99
100 return (rv);
101 }
102
103 static int spigen_open(struct cdev *, int, int, struct thread *);
104 static int spigen_ioctl(struct cdev *, u_long, caddr_t, int, struct thread *);
105 static int spigen_close(struct cdev *, int, int, struct thread *);
106 static d_mmap_single_t spigen_mmap_single;
107
108 static struct cdevsw spigen_cdevsw = {
109 .d_version = D_VERSION,
110 .d_name = "spigen",
111 .d_open = spigen_open,
112 .d_ioctl = spigen_ioctl,
113 .d_mmap_single = spigen_mmap_single,
114 .d_close = spigen_close
115 };
116
117 static int
spigen_attach(device_t dev)118 spigen_attach(device_t dev)
119 {
120 struct spigen_softc *sc;
121 const int unit = device_get_unit(dev);
122 int cs, res;
123 struct make_dev_args mda;
124
125 spibus_get_cs(dev, &cs);
126 cs &= ~SPIBUS_CS_HIGH; /* trim 'cs high' bit */
127
128 sc = device_get_softc(dev);
129 sc->sc_dev = dev;
130
131 mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
132
133 make_dev_args_init(&mda);
134 mda.mda_flags = MAKEDEV_WAITOK;
135 mda.mda_devsw = &spigen_cdevsw;
136 mda.mda_cr = NULL;
137 mda.mda_uid = UID_ROOT;
138 mda.mda_gid = GID_OPERATOR;
139 mda.mda_mode = 0660;
140 mda.mda_unit = unit;
141 mda.mda_si_drv1 = dev;
142
143 res = make_dev_s(&mda, &(sc->sc_cdev), "spigen%d.%d",
144 device_get_unit(device_get_parent(dev)), cs);
145 if (res) {
146 return res;
147 }
148
149 #ifdef SPIGEN_LEGACY_CDEVNAME
150 res = make_dev_alias_p(0, &sc->sc_adev, sc->sc_cdev, "spigen%d", unit);
151 if (res) {
152 if (sc->sc_cdev) {
153 destroy_dev(sc->sc_cdev);
154 sc->sc_cdev = NULL;
155 }
156 return res;
157 }
158 #endif
159
160 return (0);
161 }
162
163 static int
spigen_open(struct cdev * cdev,int oflags,int devtype,struct thread * td)164 spigen_open(struct cdev *cdev, int oflags, int devtype, struct thread *td)
165 {
166 device_t dev;
167 struct spigen_softc *sc;
168
169 dev = cdev->si_drv1;
170 sc = device_get_softc(dev);
171
172 mtx_lock(&sc->sc_mtx);
173 device_busy(sc->sc_dev);
174 mtx_unlock(&sc->sc_mtx);
175
176 return (0);
177 }
178
179 static int
spigen_transfer(struct cdev * cdev,struct spigen_transfer * st)180 spigen_transfer(struct cdev *cdev, struct spigen_transfer *st)
181 {
182 struct spi_command transfer = SPI_COMMAND_INITIALIZER;
183 device_t dev = cdev->si_drv1;
184 int error = 0;
185
186 #if 0
187 device_printf(dev, "cmd %p %u data %p %u\n", st->st_command.iov_base,
188 st->st_command.iov_len, st->st_data.iov_base, st->st_data.iov_len);
189 #endif
190
191 if (st->st_command.iov_len == 0)
192 return (EINVAL);
193
194 transfer.tx_cmd = transfer.rx_cmd = malloc(st->st_command.iov_len,
195 M_DEVBUF, M_WAITOK);
196 if (st->st_data.iov_len > 0) {
197 transfer.tx_data = transfer.rx_data = malloc(st->st_data.iov_len,
198 M_DEVBUF, M_WAITOK);
199 }
200 else
201 transfer.tx_data = transfer.rx_data = NULL;
202
203 error = copyin(st->st_command.iov_base, transfer.tx_cmd,
204 transfer.tx_cmd_sz = transfer.rx_cmd_sz = st->st_command.iov_len);
205 if ((error == 0) && (st->st_data.iov_len > 0))
206 error = copyin(st->st_data.iov_base, transfer.tx_data,
207 transfer.tx_data_sz = transfer.rx_data_sz =
208 st->st_data.iov_len);
209 if (error == 0)
210 error = SPIBUS_TRANSFER(device_get_parent(dev), dev, &transfer);
211 if (error == 0) {
212 error = copyout(transfer.rx_cmd, st->st_command.iov_base,
213 transfer.rx_cmd_sz);
214 if ((error == 0) && (st->st_data.iov_len > 0))
215 error = copyout(transfer.rx_data, st->st_data.iov_base,
216 transfer.rx_data_sz);
217 }
218
219 free(transfer.tx_cmd, M_DEVBUF);
220 free(transfer.tx_data, M_DEVBUF);
221 return (error);
222 }
223
224 static int
spigen_transfer_mmapped(struct cdev * cdev,struct spigen_transfer_mmapped * stm)225 spigen_transfer_mmapped(struct cdev *cdev, struct spigen_transfer_mmapped *stm)
226 {
227 struct spi_command transfer = SPI_COMMAND_INITIALIZER;
228 device_t dev = cdev->si_drv1;
229 struct spigen_mmap *mmap;
230 int error;
231
232 if ((error = devfs_get_cdevpriv((void **)&mmap)) != 0)
233 return (error);
234
235 if (mmap->bufsize < stm->stm_command_length + stm->stm_data_length)
236 return (E2BIG);
237
238 transfer.tx_cmd = transfer.rx_cmd = (void *)((uintptr_t)mmap->kvaddr);
239 transfer.tx_cmd_sz = transfer.rx_cmd_sz = stm->stm_command_length;
240 transfer.tx_data = transfer.rx_data =
241 (void *)((uintptr_t)mmap->kvaddr + stm->stm_command_length);
242 transfer.tx_data_sz = transfer.rx_data_sz = stm->stm_data_length;
243 error = SPIBUS_TRANSFER(device_get_parent(dev), dev, &transfer);
244
245 return (error);
246 }
247
248 static int
spigen_ioctl(struct cdev * cdev,u_long cmd,caddr_t data,int fflag,struct thread * td)249 spigen_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag,
250 struct thread *td)
251 {
252 device_t dev = cdev->si_drv1;
253 int error;
254
255 switch (cmd) {
256 case SPIGENIOC_TRANSFER:
257 error = spigen_transfer(cdev, (struct spigen_transfer *)data);
258 break;
259 case SPIGENIOC_TRANSFER_MMAPPED:
260 error = spigen_transfer_mmapped(cdev, (struct spigen_transfer_mmapped *)data);
261 break;
262 case SPIGENIOC_GET_CLOCK_SPEED:
263 error = spibus_get_clock(dev, (uint32_t *)data);
264 break;
265 case SPIGENIOC_SET_CLOCK_SPEED:
266 error = spibus_set_clock(dev, *(uint32_t *)data);
267 break;
268 case SPIGENIOC_GET_SPI_MODE:
269 error = spibus_get_mode(dev, (uint32_t *)data);
270 break;
271 case SPIGENIOC_SET_SPI_MODE:
272 error = spibus_set_mode(dev, *(uint32_t *)data);
273 break;
274 default:
275 error = ENOTTY;
276 break;
277 }
278 return (error);
279 }
280
281 static void
spigen_mmap_cleanup(void * arg)282 spigen_mmap_cleanup(void *arg)
283 {
284 struct spigen_mmap *mmap = arg;
285
286 if (mmap->kvaddr != 0)
287 pmap_qremove(mmap->kvaddr, mmap->bufsize / PAGE_SIZE);
288 if (mmap->bufobj != NULL)
289 vm_object_deallocate(mmap->bufobj);
290 free(mmap, M_DEVBUF);
291 }
292
293 static int
spigen_mmap_single(struct cdev * cdev,vm_ooffset_t * offset,vm_size_t size,struct vm_object ** object,int nprot)294 spigen_mmap_single(struct cdev *cdev, vm_ooffset_t *offset,
295 vm_size_t size, struct vm_object **object, int nprot)
296 {
297 struct spigen_mmap *mmap;
298 vm_page_t *m;
299 size_t n, pages;
300 int error;
301
302 if (size == 0 ||
303 (nprot & (PROT_EXEC | PROT_READ | PROT_WRITE))
304 != (PROT_READ | PROT_WRITE))
305 return (EINVAL);
306 size = roundup2(size, PAGE_SIZE);
307 pages = size / PAGE_SIZE;
308
309 if (devfs_get_cdevpriv((void **)&mmap) == 0)
310 return (EBUSY);
311
312 mmap = malloc(sizeof(*mmap), M_DEVBUF, M_ZERO | M_WAITOK);
313 if ((mmap->kvaddr = kva_alloc(size)) == 0) {
314 spigen_mmap_cleanup(mmap);
315 return (ENOMEM);
316 }
317 mmap->bufsize = size;
318 mmap->bufobj = vm_pager_allocate(OBJT_PHYS, 0, size, nprot, 0,
319 curthread->td_ucred);
320
321 m = malloc(sizeof(*m) * pages, M_TEMP, M_WAITOK);
322 VM_OBJECT_WLOCK(mmap->bufobj);
323 vm_object_reference_locked(mmap->bufobj); // kernel and userland both
324 for (n = 0; n < pages; n++) {
325 m[n] = vm_page_grab(mmap->bufobj, n,
326 VM_ALLOC_ZERO | VM_ALLOC_WIRED);
327 vm_page_valid(m[n]);
328 vm_page_xunbusy(m[n]);
329 }
330 VM_OBJECT_WUNLOCK(mmap->bufobj);
331 pmap_qenter(mmap->kvaddr, m, pages);
332 free(m, M_TEMP);
333
334 if ((error = devfs_set_cdevpriv(mmap, spigen_mmap_cleanup)) != 0) {
335 /* Two threads were racing through this code; we lost. */
336 spigen_mmap_cleanup(mmap);
337 return (error);
338 }
339 *offset = 0;
340 *object = mmap->bufobj;
341
342 return (0);
343 }
344
345 static int
spigen_close(struct cdev * cdev,int fflag,int devtype,struct thread * td)346 spigen_close(struct cdev *cdev, int fflag, int devtype, struct thread *td)
347 {
348 device_t dev = cdev->si_drv1;
349 struct spigen_softc *sc = device_get_softc(dev);
350
351 mtx_lock(&sc->sc_mtx);
352 device_unbusy(sc->sc_dev);
353 mtx_unlock(&sc->sc_mtx);
354 return (0);
355 }
356
357 static int
spigen_detach(device_t dev)358 spigen_detach(device_t dev)
359 {
360 struct spigen_softc *sc;
361
362 sc = device_get_softc(dev);
363
364 #ifdef SPIGEN_LEGACY_CDEVNAME
365 if (sc->sc_adev)
366 destroy_dev(sc->sc_adev);
367 #endif
368
369 if (sc->sc_cdev)
370 destroy_dev(sc->sc_cdev);
371
372 mtx_destroy(&sc->sc_mtx);
373
374 return (0);
375 }
376
377 static device_method_t spigen_methods[] = {
378 /* Device interface */
379 DEVMETHOD(device_probe, spigen_probe),
380 DEVMETHOD(device_attach, spigen_attach),
381 DEVMETHOD(device_detach, spigen_detach),
382 { 0, 0 }
383 };
384
385 static driver_t spigen_driver = {
386 "spigen",
387 spigen_methods,
388 sizeof(struct spigen_softc),
389 };
390
391 DRIVER_MODULE(spigen, spibus, spigen_driver, 0, 0);
392 MODULE_DEPEND(spigen, spibus, 1, 1, 1);
393 #ifdef FDT
394 SIMPLEBUS_PNP_INFO(compat_data);
395 #endif
396