sys/dev/usb/udsbr.c

   1 /*      $NetBSD: udsbr.c,v 1.16 2009/09/23 19:07:19 plunky Exp $        */
   2
   3 /*
   4  * Copyright (c) 2002 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Lennart Augustsson (lennart@augustsson.net).
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Driver for the D-Link DSB-R100 FM radio.
  34  * I apologize for the magic hex constants, but this is what happens
  35  * when you have to reverse engineer the driver.
  36  * Parts of the code borrowed from Linux and parts from Warner Losh's
  37  * FreeBSD driver.
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __KERNEL_RCSID(0, "$NetBSD: udsbr.c,v 1.16 2009/09/23 19:07:19 plunky Exp $");
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/kernel.h>
  46 #include <sys/device.h>
  47
  48 #include <sys/radioio.h>
  49 #include <dev/radio_if.h>
  50
  51 #include <dev/usb/usb.h>
  52 #include <dev/usb/usbdi.h>
  53 #include <dev/usb/usbdi_util.h>
  54
  55 #include <dev/usb/usbdevs.h>
  56
  57 #ifdef UDSBR_DEBUG
  58 #define DPRINTF(x)      if (udsbrdebug) logprintf x
  59 #define DPRINTFN(n,x)   if (udsbrdebug>(n)) logprintf x
  60 int     udsbrdebug = 0;
  61 #else
  62 #define DPRINTF(x)
  63 #define DPRINTFN(n,x)
  64 #endif
  65
  66 #define UDSBR_CONFIG_NO         1
  67
  68 Static  int     udsbr_get_info(void *, struct radio_info *);
  69 Static  int     udsbr_set_info(void *, struct radio_info *);
  70
  71 const struct radio_hw_if udsbr_hw_if = {
  72         NULL, /* open */
  73         NULL, /* close */
  74         udsbr_get_info,
  75         udsbr_set_info,
  76         NULL
  77 };
  78
  79 struct udsbr_softc {
  80         USBBASEDEVICE           sc_dev;
  81         usbd_device_handle      sc_udev;
  82
  83         char                    sc_mute;
  84         char                    sc_vol;
  85         u_int32_t               sc_freq;
  86
  87         device_t                sc_child;
  88
  89         char                    sc_dying;
  90 };
  91
  92 Static  int     udsbr_req(struct udsbr_softc *sc, int ureq, int value,
  93                           int index);
  94 Static  void    udsbr_start(struct udsbr_softc *sc);
  95 Static  void    udsbr_stop(struct udsbr_softc *sc);
  96 Static  void    udsbr_setfreq(struct udsbr_softc *sc, int freq);
  97 Static  int     udsbr_status(struct udsbr_softc *sc);
  98
  99 int udsbr_match(device_t, cfdata_t, void *);
 100 void udsbr_attach(device_t, device_t, void *);
 101 void udsbr_childdet(device_t, device_t);
 102 int udsbr_detach(device_t, int);
 103 int udsbr_activate(device_t, enum devact);
 104 extern struct cfdriver udsbr_cd;
 105 CFATTACH_DECL2_NEW(udsbr, sizeof(struct udsbr_softc), udsbr_match,
 106     udsbr_attach, udsbr_detach, udsbr_activate, NULL, udsbr_childdet);
 107
 108 USB_MATCH(udsbr)
 109 {
 110         USB_MATCH_START(udsbr, uaa);
 111
 112         DPRINTFN(50,("udsbr_match\n"));
 113
 114         if (uaa->vendor != USB_VENDOR_CYPRESS ||
 115             uaa->product != USB_PRODUCT_CYPRESS_FMRADIO)
 116                 return (UMATCH_NONE);
 117         return (UMATCH_VENDOR_PRODUCT);
 118 }
 119
 120 USB_ATTACH(udsbr)
 121 {
 122         USB_ATTACH_START(udsbr, sc, uaa);
 123         usbd_device_handle      dev = uaa->device;
 124         char                    *devinfop;
 125         usbd_status             err;
 126
 127         DPRINTFN(10,("udsbr_attach: sc=%p\n", sc));
 128
 129         sc->sc_dev = self;
 130
 131         aprint_naive("\n");
 132         aprint_normal("\n");
 133
 134         devinfop = usbd_devinfo_alloc(dev, 0);
 135         aprint_normal_dev(self, "%s\n", devinfop);
 136         usbd_devinfo_free(devinfop);
 137
 138         err = usbd_set_config_no(dev, UDSBR_CONFIG_NO, 1);
 139         if (err) {
 140                 aprint_error_dev(self, "setting config no failed\n");
 141                 USB_ATTACH_ERROR_RETURN;
 142         }
 143
 144         sc->sc_udev = dev;
 145
 146         DPRINTFN(10, ("udsbr_attach: %p\n", sc->sc_udev));
 147
 148         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
 149                            USBDEV(sc->sc_dev));
 150
 151         sc->sc_child = radio_attach_mi(&udsbr_hw_if, sc, USBDEV(sc->sc_dev));
 152
 153         USB_ATTACH_SUCCESS_RETURN;
 154 }
 155
 156 void
 157 udsbr_childdet(device_t self, device_t child)
 158 {
 159 }
 160
 161 USB_DETACH(udsbr)
 162 {
 163         USB_DETACH_START(udsbr, sc);
 164         int rv = 0;
 165
 166         if (sc->sc_child != NULL)
 167                 rv = config_detach(sc->sc_child, flags);
 168
 169         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
 170                            USBDEV(sc->sc_dev));
 171
 172         return (rv);
 173 }
 174
 175 int
 176 udsbr_activate(device_ptr_t self, enum devact act)
 177 {
 178         struct udsbr_softc *sc = device_private(self);
 179
 180         switch (act) {
 181         case DVACT_DEACTIVATE:
 182                 sc->sc_dying = 1;
 183                 return 0;
 184         default:
 185                 return EOPNOTSUPP;
 186         }
 187 }
 188
 189 int
 190 udsbr_req(struct udsbr_softc *sc, int ureq, int value, int index)
 191 {
 192         usb_device_request_t req;
 193         usbd_status err;
 194         u_char data;
 195
 196         DPRINTFN(1,("udsbr_req: ureq=0x%02x value=0x%04x index=0x%04x\n",
 197                     ureq, value, index));
 198         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 199         req.bRequest = ureq;
 200         USETW(req.wValue, value);
 201         USETW(req.wIndex, index);
 202         USETW(req.wLength, 1);
 203         err = usbd_do_request(sc->sc_udev, &req, &data);
 204         if (err) {
 205                 aprint_error_dev(sc->sc_dev, "request failed err=%d\n", err);
 206         }
 207         return !(data & 1);
 208 }
 209
 210 void
 211 udsbr_start(struct udsbr_softc *sc)
 212 {
 213         (void)udsbr_req(sc, 0x00, 0x0000, 0x00c7);
 214         (void)udsbr_req(sc, 0x02, 0x0001, 0x0000);
 215 }
 216
 217 void
 218 udsbr_stop(struct udsbr_softc *sc)
 219 {
 220         (void)udsbr_req(sc, 0x00, 0x0016, 0x001c);
 221         (void)udsbr_req(sc, 0x02, 0x0000, 0x0000);
 222 }
 223
 224 void
 225 udsbr_setfreq(struct udsbr_softc *sc, int freq)
 226 {
 227         DPRINTF(("udsbr_setfreq: setfreq=%d\n", freq));
 228         /*
 229          * Freq now is in Hz.  We need to convert it to the frequency
 230          * that the radio wants.  This frequency is 10.7MHz above
 231          * the actual frequency.  We then need to convert to
 232          * units of 12.5kHz.  We add one to the IFM to make rounding
 233          * easier.
 234          */
 235         freq = (freq * 1000 + 10700001) / 12500;
 236         (void)udsbr_req(sc, 0x01, (freq >> 8) & 0xff, freq & 0xff);
 237         (void)udsbr_req(sc, 0x00, 0x0096, 0x00b7);
 238         usbd_delay_ms(sc->sc_udev, 240); /* wait for signal to settle */
 239 }
 240
 241 int
 242 udsbr_status(struct udsbr_softc *sc)
 243 {
 244         return (udsbr_req(sc, 0x00, 0x0000, 0x0024));
 245 }
 246
 247
 248 int
 249 udsbr_get_info(void *v, struct radio_info *ri)
 250 {
 251         struct udsbr_softc *sc = v;
 252
 253         ri->mute = sc->sc_mute;
 254         ri->volume = sc->sc_vol ? 255 : 0;
 255         ri->caps = RADIO_CAPS_DETECT_STEREO;
 256         ri->rfreq = 0;
 257         ri->lock = 0;
 258         ri->freq = sc->sc_freq;
 259         ri->info = udsbr_status(sc) ? RADIO_INFO_STEREO : 0;
 260
 261         return (0);
 262 }
 263
 264 int
 265 udsbr_set_info(void *v, struct radio_info *ri)
 266 {
 267         struct udsbr_softc *sc = v;
 268
 269         sc->sc_mute = ri->mute != 0;
 270         sc->sc_vol = ri->volume != 0;
 271         sc->sc_freq = ri->freq;
 272         udsbr_setfreq(sc, sc->sc_freq);
 273
 274         if (sc->sc_mute || sc->sc_vol == 0)
 275                 udsbr_stop(sc);
 276         else
 277                 udsbr_start(sc);
 278
 279         return (0);
 280 }