root/dev/usb/udsbr.c

DEFINITIONS

1. udsbr_match
2. udsbr_attach
3. udsbr_detach
4. udsbr_activate
5. udsbr_req
6. udsbr_start
7. udsbr_stop
8. udsbr_setfreq
9. udsbr_status
10. udsbr_get_info
11. udsbr_set_info

    1 /*      $OpenBSD: udsbr.c,v 1.18 2007/06/14 10:11:15 mbalmer Exp $      */
    2 /*      $NetBSD: udsbr.c,v 1.7 2002/07/11 21:14:27 augustss Exp $       */
    4 /*
    5  * Copyright (c) 2002 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Lennart Augustsson (lennart@augustsson.net).
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Driver for the D-Link DSB-R100 FM radio.
   42  * I apologize for the magic hex constants, but this is what happens
   43  * when you have to reverse engineer the driver.
   44  * Parts of the code borrowed from Linux and parts from Warner Losh's
   45  * FreeBSD driver.
   46  */
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/kernel.h>
   51 #include <sys/device.h>
   53 #include <sys/radioio.h>
   54 #include <dev/radio_if.h>
   56 #include <dev/usb/usb.h>
   57 #include <dev/usb/usbdi.h>
   58 #include <dev/usb/usbdi_util.h>
   60 #include <dev/usb/usbdevs.h>
   62 #ifdef UDSBR_DEBUG
   63 #define DPRINTF(x)      do { if (udsbrdebug) printf x; } while (0)
   64 #define DPRINTFN(n,x)   do { if (udsbrdebug>(n)) printf x; } while (0)
   65 int     udsbrdebug = 0;
   66 #else
   67 #define DPRINTF(x)
   68 #define DPRINTFN(n,x)
   69 #endif
   71 #define UDSBR_CONFIG_NO         1
   73 int     udsbr_get_info(void *, struct radio_info *);
   74 int     udsbr_set_info(void *, struct radio_info *);
   76 struct radio_hw_if udsbr_hw_if = {
NULL, /* open */
NULL, /* close */
udsbr_get_info,
udsbr_set_info,
NULL
   82 };
   84 struct udsbr_softc {
   85         struct device            sc_dev;
usbd_device_handle       sc_udev;
   88         char                     sc_mute;
   89         char                     sc_vol;
u_int32_t                sc_freq;
   92         struct device           *sc_child;
   94         char                     sc_dying;
   95 };
   97 int     udsbr_req(struct udsbr_softc *sc, int ureq, int value, int index);
   98 void    udsbr_start(struct udsbr_softc *sc);
   99 void    udsbr_stop(struct udsbr_softc *sc);
  100 void    udsbr_setfreq(struct udsbr_softc *sc, int freq);
  101 int     udsbr_status(struct udsbr_softc *sc);
  103 int udsbr_match(struct device *, void *, void *); 
  104 void udsbr_attach(struct device *, struct device *, void *); 
  105 int udsbr_detach(struct device *, int); 
  106 int udsbr_activate(struct device *, enum devact); 
  108 struct cfdriver udsbr_cd = { 
NULL, "udsbr", DV_DULL 
  110 }; 
  112 const struct cfattach udsbr_ca = { 
  113         sizeof(struct udsbr_softc), 
udsbr_match, 
udsbr_attach, 
udsbr_detach, 
udsbr_activate, 
  118 };
  120 int
udsbr_match(struct device *parent, void *match, void *aux)
  122 {
  123         struct usb_attach_arg   *uaa = aux;
DPRINTFN(50,("udsbr_match\n"));
  127         if (uaa->iface != NULL)
  128                 return (UMATCH_NONE);
  130         if (uaa->vendor != USB_VENDOR_CYPRESS ||
uaa->product != USB_PRODUCT_CYPRESS_FMRADIO)
  132                 return (UMATCH_NONE);
  133         return (UMATCH_VENDOR_PRODUCT);
  134 }
  136 void
udsbr_attach(struct device *parent, struct device *self, void *aux)
  138 {
  139         struct udsbr_softc      *sc = (struct udsbr_softc *)self;
  140         struct usb_attach_arg   *uaa = aux;
usbd_device_handle      dev = uaa->device;
  142         char                    *devinfop;
usbd_status             err;
DPRINTFN(10,("udsbr_attach: sc=%p\n", sc));
devinfop = usbd_devinfo_alloc(dev, 0);
printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, UDSBR_CONFIG_NO, 1);
  152         if (err) {
printf("%s: setting config no failed\n",
sc->sc_dev.dv_xname);
  155                 return;
  156         }
sc->sc_udev = dev;
DPRINTFN(10, ("udsbr_attach: %p\n", sc->sc_udev));
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  163                            &sc->sc_dev);
sc->sc_child = radio_attach_mi(&udsbr_hw_if, sc, &sc->sc_dev);
  166 }
  168 int
udsbr_detach(struct device *self, int flags)
  170 {
  171         struct udsbr_softc *sc = (struct udsbr_softc *)self;
  172         int rv = 0;
  174         if (sc->sc_child != NULL)
rv = config_detach(sc->sc_child, flags);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
  178                            &sc->sc_dev);
  180         return (rv);
  181 }
  183 int
udsbr_activate(struct device *self, enum devact act)
  185 {
  186         struct udsbr_softc *sc = (struct udsbr_softc *)self;
  187         int rv = 0;
  189         switch (act) {
  190         case DVACT_ACTIVATE:
  191                 break;
  193         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  195                 if (sc->sc_child != NULL)
rv = config_deactivate(sc->sc_child);
  197                 break;
  198         }
  199         return (rv);
  200 }
  202 int
udsbr_req(struct udsbr_softc *sc, int ureq, int value, int index)
  204 {
usb_device_request_t req;
usbd_status err;
u_char data;
DPRINTFN(1,("udsbr_req: ureq=0x%02x value=0x%04x index=0x%04x\n",
ureq, value, index));
req.bmRequestType = UT_READ_VENDOR_DEVICE;
req.bRequest = ureq;
USETW(req.wValue, value);
USETW(req.wIndex, index);
USETW(req.wLength, 1);
err = usbd_do_request(sc->sc_udev, &req, &data);
  217         if (err) {
printf("%s: request failed err=%d\n", sc->sc_dev.dv_xname,
err);
  220         }
  221         return !(data & 1);
  222 }
  224 void
udsbr_start(struct udsbr_softc *sc)
  226 {
  227         (void)udsbr_req(sc, 0x00, 0x0000, 0x00c7);
  228         (void)udsbr_req(sc, 0x02, 0x0001, 0x0000);
  229 }
  231 void
udsbr_stop(struct udsbr_softc *sc)
  233 {
  234         (void)udsbr_req(sc, 0x00, 0x0016, 0x001c);
  235         (void)udsbr_req(sc, 0x02, 0x0000, 0x0000);
  236 }
  238 void
udsbr_setfreq(struct udsbr_softc *sc, int freq)
  240 {
DPRINTF(("udsbr_setfreq: setfreq=%d\n", freq));
  242         /*
  243          * Freq now is in Hz.  We need to convert it to the frequency
  244          * that the radio wants.  This frequency is 10.7MHz above
  245          * the actual frequency.  We then need to convert to
  246          * units of 12.5kHz.  We add one to the IFM to make rounding
  247          * easier.
  248          */
freq = (freq * 1000 + 10700001) / 12500;
  250         (void)udsbr_req(sc, 0x01, (freq >> 8) & 0xff, freq & 0xff);
  251         (void)udsbr_req(sc, 0x00, 0x0096, 0x00b7);
usbd_delay_ms(sc->sc_udev, 240); /* wait for signal to settle */
  253 }
  255 int
udsbr_status(struct udsbr_softc *sc)
  257 {
  258         return (udsbr_req(sc, 0x00, 0x0000, 0x0024));
  259 }
  262 int
udsbr_get_info(void *v, struct radio_info *ri)
  264 {
  265         struct udsbr_softc *sc = v;
ri->mute = sc->sc_mute;
ri->volume = sc->sc_vol ? 255 : 0;
ri->caps = RADIO_CAPS_DETECT_STEREO;
ri->rfreq = 0;
ri->lock = 0;
ri->freq = sc->sc_freq;
ri->info = udsbr_status(sc) ? RADIO_INFO_STEREO : 0;
  275         return (0);
  276 }
  278 int
udsbr_set_info(void *v, struct radio_info *ri)
  280 {
  281         struct udsbr_softc *sc = v;
sc->sc_mute = ri->mute != 0;
sc->sc_vol = ri->volume != 0;
sc->sc_freq = ri->freq;
udsbr_setfreq(sc, sc->sc_freq);
  288         if (sc->sc_mute || sc->sc_vol == 0)
udsbr_stop(sc);
  290         else
udsbr_start(sc);
  293         return (0);
  294 }