LXR linux/drivers/media/usb/dvb-usb-v2/dvb

   1/*
   2 * DVB USB framework
   3 *
   4 * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@desy.de>
   5 * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
   6 *
   7 *    This program is free software; you can redistribute it and/or modify
   8 *    it under the terms of the GNU General Public License as published by
   9 *    the Free Software Foundation; either version 2 of the License, or
  10 *    (at your option) any later version.
  11 *
  12 *    This program is distributed in the hope that it will be useful,
  13 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 *    GNU General Public License for more details.
  16 *
  17 *    You should have received a copy of the GNU General Public License along
  18 *    with this program; if not, write to the Free Software Foundation, Inc.,
  19 *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 */
  21
  22#ifndef DVB_USB_H
  23#define DVB_USB_H
  24
  25#include <linux/usb/input.h>
  26#include <linux/firmware.h>
  27#include <media/rc-core.h>
  28
  29#include "dvb_frontend.h"
  30#include "dvb_demux.h"
  31#include "dvb_net.h"
  32#include "dmxdev.h"
  33#include "dvb-usb-ids.h"
  34
  35/*
  36 * device file: /dev/dvb/adapter[0-1]/frontend[0-2]
  37 *
  38 * |-- device
  39 * |   |-- adapter0
  40 * |   |   |-- frontend0
  41 * |   |   |-- frontend1
  42 * |   |   `-- frontend2
  43 * |   `-- adapter1
  44 * |       |-- frontend0
  45 * |       |-- frontend1
  46 * |       `-- frontend2
  47 *
  48 *
  49 * Commonly used variable names:
  50 * d = pointer to device (struct dvb_usb_device *)
  51 * adap = pointer to adapter (struct dvb_usb_adapter *)
  52 * fe = pointer to frontend (struct dvb_frontend *)
  53 *
  54 * Use macros defined in that file to resolve needed pointers.
  55 */
  56
  57/* helper macros for every DVB USB driver use */
  58#define adap_to_d(adap) (container_of(adap, struct dvb_usb_device, \
  59                adapter[adap->id]))
  60#define adap_to_priv(adap) (adap_to_d(adap)->priv)
  61#define fe_to_adap(fe) ((struct dvb_usb_adapter *) ((fe)->dvb->priv))
  62#define fe_to_d(fe) (adap_to_d(fe_to_adap(fe)))
  63#define fe_to_priv(fe) (fe_to_d(fe)->priv)
  64#define d_to_priv(d) (d->priv)
  65
  66#define dvb_usb_dbg_usb_control_msg(udev, r, t, v, i, b, l) { \
  67        char *direction; \
  68        if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
  69                direction = ">>>"; \
  70        else \
  71                direction = "<<<"; \
  72        dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
  73                        "%s %*ph\n",  __func__, t, r, v & 0xff, v >> 8, \
  74                        i & 0xff, i >> 8, l & 0xff, l >> 8, direction, l, b); \
  75}
  76
  77#define DVB_USB_STREAM_BULK(endpoint_, count_, size_) { \
  78        .type = USB_BULK, \
  79        .count = count_, \
  80        .endpoint = endpoint_, \
  81        .u = { \
  82                .bulk = { \
  83                        .buffersize = size_, \
  84                } \
  85        } \
  86}
  87
  88#define DVB_USB_STREAM_ISOC(endpoint_, count_, frames_, size_, interval_) { \
  89        .type = USB_ISOC, \
  90        .count = count_, \
  91        .endpoint = endpoint_, \
  92        .u = { \
  93                .isoc = { \
  94                        .framesperurb = frames_, \
  95                        .framesize = size_,\
  96                        .interval = interval_, \
  97                } \
  98        } \
  99}
 100
 101#define DVB_USB_DEVICE(vend, prod, props_, name_, rc) \
 102        .match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
 103        .idVendor = (vend), \
 104        .idProduct = (prod), \
 105        .driver_info = (kernel_ulong_t) &((const struct dvb_usb_driver_info) { \
 106                .props = (props_), \
 107                .name = (name_), \
 108                .rc_map = (rc), \
 109        })
 110
 111struct dvb_usb_device;
 112struct dvb_usb_adapter;
 113
 114/**
 115 * structure for carrying all needed data from the device driver to the general
 116 * dvb usb routines
 117 * @name: device name
 118 * @rc_map: name of rc codes table
 119 * @props: structure containing all device properties
 120 */
 121struct dvb_usb_driver_info {
 122        const char *name;
 123        const char *rc_map;
 124        const struct dvb_usb_device_properties *props;
 125};
 126
 127/**
 128 * structure for remote controller configuration
 129 * @map_name: name of rc codes table
 130 * @allowed_protos: protocol(s) supported by the driver
 131 * @change_protocol: callback to change protocol
 132 * @query: called to query an event from the device
 133 * @interval: time in ms between two queries
 134 * @driver_type: used to point if a device supports raw mode
 135 * @bulk_mode: device supports bulk mode for rc (disable polling mode)
 136 */
 137struct dvb_usb_rc {
 138        const char *map_name;
 139        u64 allowed_protos;
 140        int (*change_protocol)(struct rc_dev *dev, u64 *rc_type);
 141        int (*query) (struct dvb_usb_device *d);
 142        unsigned int interval;
 143        enum rc_driver_type driver_type;
 144        bool bulk_mode;
 145};
 146
 147/**
 148 * usb streaming configration for adapter
 149 * @type: urb type
 150 * @count: count of used urbs
 151 * @endpoint: stream usb endpoint number
 152 */
 153struct usb_data_stream_properties {
 154#define USB_BULK  1
 155#define USB_ISOC  2
 156        u8 type;
 157        u8 count;
 158        u8 endpoint;
 159
 160        union {
 161                struct {
 162                        unsigned int buffersize; /* per URB */
 163                } bulk;
 164                struct {
 165                        int framesperurb;
 166                        int framesize;
 167                        int interval;
 168                } isoc;
 169        } u;
 170};
 171
 172/**
 173 * properties of dvb usb device adapter
 174 * @caps: adapter capabilities
 175 * @pid_filter_count: pid count of adapter pid-filter
 176 * @pid_filter_ctrl: called to enable/disable pid-filter
 177 * @pid_filter: called to set/unset pid for filtering
 178 * @stream: adapter usb stream configuration
 179 */
 180#define MAX_NO_OF_FE_PER_ADAP 3
 181struct dvb_usb_adapter_properties {
 182#define DVB_USB_ADAP_HAS_PID_FILTER               0x01
 183#define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02
 184#define DVB_USB_ADAP_NEED_PID_FILTERING           0x04
 185        u8 caps;
 186
 187        u8 pid_filter_count;
 188        int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int);
 189        int (*pid_filter) (struct dvb_usb_adapter *, int, u16, int);
 190
 191        struct usb_data_stream_properties stream;
 192};
 193
 194/**
 195 * struct dvb_usb_device_properties - properties of a dvb-usb-device
 196 * @driver_name: name of the owning driver module
 197 * @owner: owner of the dvb_adapter
 198 * @adapter_nr: values from the DVB_DEFINE_MOD_OPT_ADAPTER_NR() macro
 199 * @bInterfaceNumber: usb interface number driver binds
 200 * @size_of_priv: bytes allocated for the driver private data
 201 * @generic_bulk_ctrl_endpoint: bulk control endpoint number for sent
 202 * @generic_bulk_ctrl_endpoint_response: bulk control endpoint number for
 203 *  receive
 204 * @generic_bulk_ctrl_delay: delay between bulk control sent and receive message
 205 * @identify_state: called to determine the firmware state (cold or warm) and
 206 *  return possible firmware file name to be loaded
 207 * @firmware: name of the firmware file to be loaded
 208 * @download_firmware: called to download the firmware
 209 * @i2c_algo: i2c_algorithm if the device has i2c-adapter
 210 * @num_adapters: dvb usb device adapter count
 211 * @get_adapter_count: called to resolve adapter count
 212 * @adapter: array of all adapter properties of device
 213 * @power_ctrl: called to enable/disable power of the device
 214 * @read_config: called to resolve device configuration
 215 * @read_mac_address: called to resolve adapter mac-address
 216 * @frontend_attach: called to attach the possible frontends
 217 * @tuner_attach: called to attach the possible tuners
 218 * @frontend_ctrl: called to power on/off active frontend
 219 * @streaming_ctrl: called to start/stop the usb streaming of adapter
 220 * @init: called after adapters are created in order to finalize device
 221 *  configuration
 222 * @exit: called when driver is unloaded
 223 * @get_rc_config: called to resolve used remote controller configuration
 224 * @get_stream_config: called to resolve input and output stream configuration
 225 *  of the adapter just before streaming is started. input stream is transport
 226 *  stream from the demodulator and output stream is usb stream to host.
 227 */
 228#define MAX_NO_OF_ADAPTER_PER_DEVICE 2
 229struct dvb_usb_device_properties {
 230        const char *driver_name;
 231        struct module *owner;
 232        short *adapter_nr;
 233
 234        u8 bInterfaceNumber;
 235        unsigned int size_of_priv;
 236        u8 generic_bulk_ctrl_endpoint;
 237        u8 generic_bulk_ctrl_endpoint_response;
 238        unsigned int generic_bulk_ctrl_delay;
 239
 240#define WARM                  0
 241#define COLD                  1
 242        int (*identify_state) (struct dvb_usb_device *, const char **);
 243        const char *firmware;
 244#define RECONNECTS_USB        1
 245        int (*download_firmware) (struct dvb_usb_device *,
 246                        const struct firmware *);
 247
 248        struct i2c_algorithm *i2c_algo;
 249
 250        unsigned int num_adapters;
 251        int (*get_adapter_count) (struct dvb_usb_device *);
 252        struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
 253        int (*power_ctrl) (struct dvb_usb_device *, int);
 254        int (*read_config) (struct dvb_usb_device *d);
 255        int (*read_mac_address) (struct dvb_usb_adapter *, u8 []);
 256        int (*frontend_attach) (struct dvb_usb_adapter *);
 257        int (*tuner_attach) (struct dvb_usb_adapter *);
 258        int (*frontend_ctrl) (struct dvb_frontend *, int);
 259        int (*streaming_ctrl) (struct dvb_frontend *, int);
 260        int (*init) (struct dvb_usb_device *);
 261        void (*exit) (struct dvb_usb_device *);
 262        int (*get_rc_config) (struct dvb_usb_device *, struct dvb_usb_rc *);
 263#define DVB_USB_FE_TS_TYPE_188        0
 264#define DVB_USB_FE_TS_TYPE_204        1
 265#define DVB_USB_FE_TS_TYPE_RAW        2
 266        int (*get_stream_config) (struct dvb_frontend *,  u8 *,
 267                        struct usb_data_stream_properties *);
 268};
 269
 270/**
 271 * generic object of an usb stream
 272 * @buf_num: number of buffer allocated
 273 * @buf_size: size of each buffer in buf_list
 274 * @buf_list: array containing all allocate buffers for streaming
 275 * @dma_addr: list of dma_addr_t for each buffer in buf_list
 276 *
 277 * @urbs_initialized: number of URBs initialized
 278 * @urbs_submitted: number of URBs submitted
 279 */
 280#define MAX_NO_URBS_FOR_DATA_STREAM 10
 281struct usb_data_stream {
 282        struct usb_device *udev;
 283        struct usb_data_stream_properties props;
 284
 285#define USB_STATE_INIT    0x00
 286#define USB_STATE_URB_BUF 0x01
 287        u8 state;
 288
 289        void (*complete) (struct usb_data_stream *, u8 *, size_t);
 290
 291        struct urb    *urb_list[MAX_NO_URBS_FOR_DATA_STREAM];
 292        int            buf_num;
 293        unsigned long  buf_size;
 294        u8            *buf_list[MAX_NO_URBS_FOR_DATA_STREAM];
 295        dma_addr_t     dma_addr[MAX_NO_URBS_FOR_DATA_STREAM];
 296
 297        int urbs_initialized;
 298        int urbs_submitted;
 299
 300        void *user_priv;
 301};
 302
 303/**
 304 * dvb adapter object on dvb usb device
 305 * @props: pointer to adapter properties
 306 * @stream: adapter the usb data stream
 307 * @id: index of this adapter (starting with 0)
 308 * @ts_type: transport stream, input stream, type
 309 * @suspend_resume_active: set when there is ongoing suspend / resume
 310 * @pid_filtering: is hardware pid_filtering used or not
 311 * @feed_count: current feed count
 312 * @max_feed_count: maimum feed count device can handle
 313 * @dvb_adap: adapter dvb_adapter
 314 * @dmxdev: adapter dmxdev
 315 * @demux: adapter software demuxer
 316 * @dvb_net: adapter dvb_net interfaces
 317 * @sync_mutex: mutex used to sync control and streaming of the adapter
 318 * @fe: adapter frontends
 319 * @fe_init: rerouted frontend-init function
 320 * @fe_sleep: rerouted frontend-sleep function
 321 */
 322struct dvb_usb_adapter {
 323        const struct dvb_usb_adapter_properties *props;
 324        struct usb_data_stream stream;
 325        u8 id;
 326        u8 ts_type;
 327        bool suspend_resume_active;
 328        bool pid_filtering;
 329        u8 feed_count;
 330        u8 max_feed_count;
 331        s8 active_fe;
 332#define ADAP_INIT                0
 333#define ADAP_SLEEP               1
 334#define ADAP_STREAMING           2
 335        unsigned long state_bits;
 336
 337        /* dvb */
 338        struct dvb_adapter   dvb_adap;
 339        struct dmxdev        dmxdev;
 340        struct dvb_demux     demux;
 341        struct dvb_net       dvb_net;
 342
 343        struct dvb_frontend *fe[MAX_NO_OF_FE_PER_ADAP];
 344        int (*fe_init[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *);
 345        int (*fe_sleep[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *);
 346};
 347
 348/**
 349 * dvb usb device object
 350 * @props: device properties
 351 * @name: device name
 352 * @rc_map: name of rc codes table
 353 * @rc_polling_active: set when RC polling is active
 354 * @udev: pointer to the device's struct usb_device
 355 * @intf: pointer to the device's usb interface
 356 * @rc: remote controller configuration
 357 * @probe_work: work to defer .probe()
 358 * @powered: indicated whether the device is power or not
 359 * @usb_mutex: mutex for usb control messages
 360 * @i2c_mutex: mutex for i2c-transfers
 361 * @i2c_adap: device's i2c-adapter
 362 * @rc_dev: rc device for the remote control
 363 * @rc_query_work: work for polling remote
 364 * @priv: private data of the actual driver (allocate by dvb usb, size defined
 365 *  in size_of_priv of dvb_usb_properties).
 366 */
 367struct dvb_usb_device {
 368        const struct dvb_usb_device_properties *props;
 369        const char *name;
 370        const char *rc_map;
 371        bool rc_polling_active;
 372        struct usb_device *udev;
 373        struct usb_interface *intf;
 374        struct dvb_usb_rc rc;
 375        struct work_struct probe_work;
 376        pid_t work_pid;
 377        int powered;
 378
 379        /* locking */
 380        struct mutex usb_mutex;
 381
 382        /* i2c */
 383        struct mutex i2c_mutex;
 384        struct i2c_adapter i2c_adap;
 385
 386        struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
 387
 388        /* remote control */
 389        struct rc_dev *rc_dev;
 390        char rc_phys[64];
 391        struct delayed_work rc_query_work;
 392
 393        void *priv;
 394};
 395
 396extern int dvb_usbv2_probe(struct usb_interface *,
 397                const struct usb_device_id *);
 398extern void dvb_usbv2_disconnect(struct usb_interface *);
 399extern int dvb_usbv2_suspend(struct usb_interface *, pm_message_t);
 400extern int dvb_usbv2_resume(struct usb_interface *);
 401extern int dvb_usbv2_reset_resume(struct usb_interface *);
 402
 403/* the generic read/write method for device control */
 404extern int dvb_usbv2_generic_rw(struct dvb_usb_device *, u8 *, u16, u8 *, u16);
 405extern int dvb_usbv2_generic_write(struct dvb_usb_device *, u8 *, u16);
 406/* caller must hold lock when locked versions are called */
 407extern int dvb_usbv2_generic_rw_locked(struct dvb_usb_device *,
 408                u8 *, u16, u8 *, u16);
 409extern int dvb_usbv2_generic_write_locked(struct dvb_usb_device *, u8 *, u16);
 410
 411#endif
 412