ufm.c revision 196490 
1/*-
2 * Copyright (c) 2001 M. Warner Losh
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions, and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
18 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * This code is based on ugen.c and ulpt.c developed by Lennart Augustsson.
27 * This code includes software developed by the NetBSD Foundation, Inc. and
28 * its contributors.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: head/sys/dev/usb/misc/ufm.c 196490 2009-08-24 04:59:09Z alfred $");
33
34
35#include <sys/stdint.h>
36#include <sys/stddef.h>
37#include <sys/param.h>
38#include <sys/queue.h>
39#include <sys/types.h>
40#include <sys/systm.h>
41#include <sys/kernel.h>
42#include <sys/bus.h>
43#include <sys/linker_set.h>
44#include <sys/module.h>
45#include <sys/lock.h>
46#include <sys/mutex.h>
47#include <sys/condvar.h>
48#include <sys/sysctl.h>
49#include <sys/sx.h>
50#include <sys/unistd.h>
51#include <sys/callout.h>
52#include <sys/malloc.h>
53#include <sys/priv.h>
54#include <sys/conf.h>
55#include <sys/fcntl.h>
56
57#include <dev/usb/usb.h>
58#include <dev/usb/usbdi.h>
59#include "usbdevs.h"
60
61#define	USB_DEBUG_VAR usb_debug
62#include <dev/usb/usb_debug.h>
63
64#include <dev/usb/ufm_ioctl.h>
65
66#define	UFM_CMD0		0x00
67#define	UFM_CMD_SET_FREQ	0x01
68#define	UFM_CMD2		0x02
69
70struct ufm_softc {
71	struct usb_fifo_sc sc_fifo;
72	struct mtx sc_mtx;
73
74	struct usb_device *sc_udev;
75
76	uint32_t sc_unit;
77	uint32_t sc_freq;
78
79	uint8_t	sc_name[16];
80};
81
82/* prototypes */
83
84static device_probe_t ufm_probe;
85static device_attach_t ufm_attach;
86static device_detach_t ufm_detach;
87
88static usb_fifo_ioctl_t ufm_ioctl;
89
90static struct usb_fifo_methods ufm_fifo_methods = {
91	.f_ioctl = &ufm_ioctl,
92	.basename[0] = "ufm",
93};
94
95static int	ufm_do_req(struct ufm_softc *, uint8_t, uint16_t, uint16_t,
96		    uint8_t *);
97static int	ufm_set_freq(struct ufm_softc *, void *);
98static int	ufm_get_freq(struct ufm_softc *, void *);
99static int	ufm_start(struct ufm_softc *, void *);
100static int	ufm_stop(struct ufm_softc *, void *);
101static int	ufm_get_stat(struct ufm_softc *, void *);
102
103static devclass_t ufm_devclass;
104
105static device_method_t ufm_methods[] = {
106	DEVMETHOD(device_probe, ufm_probe),
107	DEVMETHOD(device_attach, ufm_attach),
108	DEVMETHOD(device_detach, ufm_detach),
109	{0, 0}
110};
111
112static driver_t ufm_driver = {
113	.name = "ufm",
114	.methods = ufm_methods,
115	.size = sizeof(struct ufm_softc),
116};
117
118DRIVER_MODULE(ufm, uhub, ufm_driver, ufm_devclass, NULL, 0);
119MODULE_DEPEND(ufm, usb, 1, 1, 1);
120
121static int
122ufm_probe(device_t dev)
123{
124	struct usb_attach_arg *uaa = device_get_ivars(dev);
125
126	if (uaa->usb_mode != USB_MODE_HOST) {
127		return (ENXIO);
128	}
129	if ((uaa->info.idVendor == USB_VENDOR_CYPRESS) &&
130	    (uaa->info.idProduct == USB_PRODUCT_CYPRESS_FMRADIO)) {
131		return (0);
132	}
133	return (ENXIO);
134}
135
136static int
137ufm_attach(device_t dev)
138{
139	struct usb_attach_arg *uaa = device_get_ivars(dev);
140	struct ufm_softc *sc = device_get_softc(dev);
141	int error;
142
143	sc->sc_udev = uaa->device;
144	sc->sc_unit = device_get_unit(dev);
145
146	snprintf(sc->sc_name, sizeof(sc->sc_name), "%s",
147	    device_get_nameunit(dev));
148
149	mtx_init(&sc->sc_mtx, "ufm lock", NULL, MTX_DEF | MTX_RECURSE);
150
151	device_set_usb_desc(dev);
152
153	error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
154	    &ufm_fifo_methods, &sc->sc_fifo,
155	    device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex,
156	    UID_ROOT, GID_OPERATOR, 0644);
157	if (error) {
158		goto detach;
159	}
160	return (0);			/* success */
161
162detach:
163	ufm_detach(dev);
164	return (ENXIO);
165}
166
167static int
168ufm_detach(device_t dev)
169{
170	struct ufm_softc *sc = device_get_softc(dev);
171
172	usb_fifo_detach(&sc->sc_fifo);
173
174	mtx_destroy(&sc->sc_mtx);
175
176	return (0);
177}
178
179static int
180ufm_do_req(struct ufm_softc *sc, uint8_t request,
181    uint16_t value, uint16_t index, uint8_t *retbuf)
182{
183	int error;
184
185	struct usb_device_request req;
186	uint8_t buf[1];
187
188	req.bmRequestType = UT_READ_VENDOR_DEVICE;
189	req.bRequest = request;
190	USETW(req.wValue, value);
191	USETW(req.wIndex, index);
192	USETW(req.wLength, 1);
193
194	error = usbd_do_request(sc->sc_udev, NULL, &req, buf);
195
196	if (retbuf) {
197		*retbuf = buf[0];
198	}
199	if (error) {
200		return (ENXIO);
201	}
202	return (0);
203}
204
205static int
206ufm_set_freq(struct ufm_softc *sc, void *addr)
207{
208	int freq = *(int *)addr;
209
210	/*
211	 * Freq now is in Hz.  We need to convert it to the frequency
212	 * that the radio wants.  This frequency is 10.7MHz above
213	 * the actual frequency.  We then need to convert to
214	 * units of 12.5kHz.  We add one to the IFM to make rounding
215	 * easier.
216	 */
217	mtx_lock(&sc->sc_mtx);
218	sc->sc_freq = freq;
219	mtx_unlock(&sc->sc_mtx);
220
221	freq = (freq + 10700001) / 12500;
222
223	/* This appears to set the frequency */
224	if (ufm_do_req(sc, UFM_CMD_SET_FREQ,
225	    freq >> 8, freq, NULL) != 0) {
226		return (EIO);
227	}
228	/* Not sure what this does */
229	if (ufm_do_req(sc, UFM_CMD0,
230	    0x96, 0xb7, NULL) != 0) {
231		return (EIO);
232	}
233	return (0);
234}
235
236static int
237ufm_get_freq(struct ufm_softc *sc, void *addr)
238{
239	int *valp = (int *)addr;
240
241	mtx_lock(&sc->sc_mtx);
242	*valp = sc->sc_freq;
243	mtx_unlock(&sc->sc_mtx);
244	return (0);
245}
246
247static int
248ufm_start(struct ufm_softc *sc, void *addr)
249{
250	uint8_t ret;
251
252	if (ufm_do_req(sc, UFM_CMD0,
253	    0x00, 0xc7, &ret)) {
254		return (EIO);
255	}
256	if (ufm_do_req(sc, UFM_CMD2,
257	    0x01, 0x00, &ret)) {
258		return (EIO);
259	}
260	if (ret & 0x1) {
261		return (EIO);
262	}
263	return (0);
264}
265
266static int
267ufm_stop(struct ufm_softc *sc, void *addr)
268{
269	if (ufm_do_req(sc, UFM_CMD0,
270	    0x16, 0x1C, NULL)) {
271		return (EIO);
272	}
273	if (ufm_do_req(sc, UFM_CMD2,
274	    0x00, 0x00, NULL)) {
275		return (EIO);
276	}
277	return (0);
278}
279
280static int
281ufm_get_stat(struct ufm_softc *sc, void *addr)
282{
283	uint8_t ret;
284
285	/*
286	 * Note, there's a 240ms settle time before the status
287	 * will be valid, so sleep that amount.
288	 */
289	usb_pause_mtx(NULL, hz / 4);
290
291	if (ufm_do_req(sc, UFM_CMD0,
292	    0x00, 0x24, &ret)) {
293		return (EIO);
294	}
295	*(int *)addr = ret;
296
297	return (0);
298}
299
300static int
301ufm_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr,
302    int fflags)
303{
304	struct ufm_softc *sc = usb_fifo_softc(fifo);
305	int error = 0;
306
307	if ((fflags & (FWRITE | FREAD)) != (FWRITE | FREAD)) {
308		return (EACCES);
309	}
310
311	switch (cmd) {
312	case FM_SET_FREQ:
313		error = ufm_set_freq(sc, addr);
314		break;
315	case FM_GET_FREQ:
316		error = ufm_get_freq(sc, addr);
317		break;
318	case FM_START:
319		error = ufm_start(sc, addr);
320		break;
321	case FM_STOP:
322		error = ufm_stop(sc, addr);
323		break;
324	case FM_GET_STAT:
325		error = ufm_get_stat(sc, addr);
326		break;
327	default:
328		error = ENOTTY;
329		break;
330	}
331	return (error);
332}
333