Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-or-later */
0002 /*
0003  * DVB USB framework
0004  *
0005  * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@posteo.de>
0006  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
0007  */
0008 
0009 #ifndef DVB_USB_H
0010 #define DVB_USB_H
0011 
0012 #include <linux/usb/input.h>
0013 #include <linux/firmware.h>
0014 #include <media/rc-core.h>
0015 #include <media/media-device.h>
0016 
0017 #include <media/dvb_frontend.h>
0018 #include <media/dvb_demux.h>
0019 #include <media/dvb_net.h>
0020 #include <media/dmxdev.h>
0021 #include <media/dvb-usb-ids.h>
0022 
0023 /*
0024  * device file: /dev/dvb/adapter[0-1]/frontend[0-2]
0025  *
0026  * |-- device
0027  * |   |-- adapter0
0028  * |   |   |-- frontend0
0029  * |   |   |-- frontend1
0030  * |   |   `-- frontend2
0031  * |   `-- adapter1
0032  * |       |-- frontend0
0033  * |       |-- frontend1
0034  * |       `-- frontend2
0035  *
0036  *
0037  * Commonly used variable names:
0038  * d = pointer to device (struct dvb_usb_device *)
0039  * adap = pointer to adapter (struct dvb_usb_adapter *)
0040  * fe = pointer to frontend (struct dvb_frontend *)
0041  *
0042  * Use macros defined in that file to resolve needed pointers.
0043  */
0044 
0045 /* helper macros for every DVB USB driver use */
0046 #define adap_to_d(adap) (container_of(adap, struct dvb_usb_device, \
0047         adapter[adap->id]))
0048 #define adap_to_priv(adap) (adap_to_d(adap)->priv)
0049 #define fe_to_adap(fe) ((struct dvb_usb_adapter *) ((fe)->dvb->priv))
0050 #define fe_to_d(fe) (adap_to_d(fe_to_adap(fe)))
0051 #define fe_to_priv(fe) (fe_to_d(fe)->priv)
0052 #define d_to_priv(d) (d->priv)
0053 
0054 #define dvb_usb_dbg_usb_control_msg(udev, r, t, v, i, b, l) { \
0055     char *direction; \
0056     if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
0057         direction = ">>>"; \
0058     else \
0059         direction = "<<<"; \
0060     dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
0061             "%s %*ph\n",  __func__, t, r, v & 0xff, v >> 8, \
0062             i & 0xff, i >> 8, l & 0xff, l >> 8, direction, l, b); \
0063 }
0064 
0065 #define DVB_USB_STREAM_BULK(endpoint_, count_, size_) { \
0066     .type = USB_BULK, \
0067     .count = count_, \
0068     .endpoint = endpoint_, \
0069     .u = { \
0070         .bulk = { \
0071             .buffersize = size_, \
0072         } \
0073     } \
0074 }
0075 
0076 #define DVB_USB_STREAM_ISOC(endpoint_, count_, frames_, size_, interval_) { \
0077     .type = USB_ISOC, \
0078     .count = count_, \
0079     .endpoint = endpoint_, \
0080     .u = { \
0081         .isoc = { \
0082             .framesperurb = frames_, \
0083             .framesize = size_,\
0084             .interval = interval_, \
0085         } \
0086     } \
0087 }
0088 
0089 #define DVB_USB_DEVICE(vend, prod, props_, name_, rc) \
0090     .match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
0091     .idVendor = (vend), \
0092     .idProduct = (prod), \
0093     .driver_info = (kernel_ulong_t) &((const struct dvb_usb_driver_info) { \
0094         .props = (props_), \
0095         .name = (name_), \
0096         .rc_map = (rc), \
0097     })
0098 
0099 struct dvb_usb_device;
0100 struct dvb_usb_adapter;
0101 
0102 /**
0103  * struct dvb_usb_driver_info - structure for carrying all needed data from the
0104  *  device driver to the general
0105  * dvb usb routines
0106  * @name: device name
0107  * @rc_map: name of rc codes table
0108  * @props: structure containing all device properties
0109  */
0110 struct dvb_usb_driver_info {
0111     const char *name;
0112     const char *rc_map;
0113     const struct dvb_usb_device_properties *props;
0114 };
0115 
0116 /**
0117  * struct dvb_usb_rc - structure for remote controller configuration
0118  * @map_name: name of rc codes table
0119  * @allowed_protos: protocol(s) supported by the driver
0120  * @change_protocol: callback to change protocol
0121  * @query: called to query an event from the device
0122  * @interval: time in ms between two queries
0123  * @driver_type: used to point if a device supports raw mode
0124  * @bulk_mode: device supports bulk mode for rc (disable polling mode)
0125  * @timeout: set to length of last space before raw IR goes idle
0126  */
0127 struct dvb_usb_rc {
0128     const char *map_name;
0129     u64 allowed_protos;
0130     int (*change_protocol)(struct rc_dev *dev, u64 *rc_proto);
0131     int (*query) (struct dvb_usb_device *d);
0132     unsigned int interval;
0133     enum rc_driver_type driver_type;
0134     bool bulk_mode;
0135     int timeout;
0136 };
0137 
0138 /**
0139  * struct usb_data_stream_properties - usb streaming configuration for adapter
0140  * @type: urb type
0141  * @count: count of used urbs
0142  * @endpoint: stream usb endpoint number
0143  * @u: union for @bulk and @isoc
0144  */
0145 struct usb_data_stream_properties {
0146 #define USB_BULK  1
0147 #define USB_ISOC  2
0148     u8 type;
0149     u8 count;
0150     u8 endpoint;
0151 
0152     union {
0153         struct {
0154             unsigned int buffersize; /* per URB */
0155         } bulk;
0156         struct {
0157             int framesperurb;
0158             int framesize;
0159             int interval;
0160         } isoc;
0161     } u;
0162 };
0163 
0164 /**
0165  * struct dvb_usb_adapter_properties - properties of dvb usb device adapter
0166  * @caps: adapter capabilities
0167  * @pid_filter_count: pid count of adapter pid-filter
0168  * @pid_filter_ctrl: called to enable/disable pid-filter
0169  * @pid_filter: called to set/unset pid for filtering
0170  * @stream: adapter usb stream configuration
0171  */
0172 struct dvb_usb_adapter_properties {
0173 #define MAX_NO_OF_FE_PER_ADAP 3
0174 #define DVB_USB_ADAP_HAS_PID_FILTER               0x01
0175 #define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02
0176 #define DVB_USB_ADAP_NEED_PID_FILTERING           0x04
0177     u8 caps;
0178 
0179     u8 pid_filter_count;
0180     int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int);
0181     int (*pid_filter) (struct dvb_usb_adapter *, int, u16, int);
0182 
0183     struct usb_data_stream_properties stream;
0184 };
0185 
0186 /**
0187  * struct dvb_usb_device_properties - properties of a dvb-usb-device
0188  * @driver_name: name of the owning driver module
0189  * @owner: owner of the dvb_adapter
0190  * @adapter_nr: values from the DVB_DEFINE_MOD_OPT_ADAPTER_NR() macro
0191  * @bInterfaceNumber: usb interface number driver binds
0192  * @size_of_priv: bytes allocated for the driver private data
0193  * @generic_bulk_ctrl_endpoint: bulk control endpoint number for sent
0194  * @generic_bulk_ctrl_endpoint_response: bulk control endpoint number for
0195  *  receive
0196  * @generic_bulk_ctrl_delay: delay between bulk control sent and receive message
0197  * @probe: like probe on driver model
0198  * @disconnect: like disconnect on driver model
0199  * @identify_state: called to determine the firmware state (cold or warm) and
0200  *  return possible firmware file name to be loaded
0201  * @firmware: name of the firmware file to be loaded
0202  * @download_firmware: called to download the firmware
0203  * @i2c_algo: i2c_algorithm if the device has i2c-adapter
0204  * @num_adapters: dvb usb device adapter count
0205  * @get_adapter_count: called to resolve adapter count
0206  * @adapter: array of all adapter properties of device
0207  * @power_ctrl: called to enable/disable power of the device
0208  * @read_config: called to resolve device configuration
0209  * @read_mac_address: called to resolve adapter mac-address
0210  * @frontend_attach: called to attach the possible frontends
0211  * @frontend_detach: called to detach the possible frontends
0212  * @tuner_attach: called to attach the possible tuners
0213  * @tuner_detach: called to detach the possible tuners
0214  * @frontend_ctrl: called to power on/off active frontend
0215  * @streaming_ctrl: called to start/stop the usb streaming of adapter
0216  * @init: called after adapters are created in order to finalize device
0217  *  configuration
0218  * @exit: called when driver is unloaded
0219  * @get_rc_config: called to resolve used remote controller configuration
0220  * @get_stream_config: called to resolve input and output stream configuration
0221  *  of the adapter just before streaming is started. input stream is transport
0222  *  stream from the demodulator and output stream is usb stream to host.
0223  */
0224 struct dvb_usb_device_properties {
0225 #define MAX_NO_OF_ADAPTER_PER_DEVICE 2
0226     const char *driver_name;
0227     struct module *owner;
0228     short *adapter_nr;
0229 
0230     u8 bInterfaceNumber;
0231     unsigned int size_of_priv;
0232     u8 generic_bulk_ctrl_endpoint;
0233     u8 generic_bulk_ctrl_endpoint_response;
0234     unsigned int generic_bulk_ctrl_delay;
0235 
0236     int (*probe)(struct dvb_usb_device *);
0237     void (*disconnect)(struct dvb_usb_device *);
0238 #define WARM                  0
0239 #define COLD                  1
0240     int (*identify_state) (struct dvb_usb_device *, const char **);
0241     const char *firmware;
0242 #define RECONNECTS_USB        1
0243     int (*download_firmware) (struct dvb_usb_device *,
0244             const struct firmware *);
0245 
0246     struct i2c_algorithm *i2c_algo;
0247 
0248     unsigned int num_adapters;
0249     int (*get_adapter_count) (struct dvb_usb_device *);
0250     struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
0251     int (*power_ctrl) (struct dvb_usb_device *, int);
0252     int (*read_config) (struct dvb_usb_device *d);
0253     int (*read_mac_address) (struct dvb_usb_adapter *, u8 []);
0254     int (*frontend_attach) (struct dvb_usb_adapter *);
0255     int (*frontend_detach)(struct dvb_usb_adapter *);
0256     int (*tuner_attach) (struct dvb_usb_adapter *);
0257     int (*tuner_detach)(struct dvb_usb_adapter *);
0258     int (*frontend_ctrl) (struct dvb_frontend *, int);
0259     int (*streaming_ctrl) (struct dvb_frontend *, int);
0260     int (*init) (struct dvb_usb_device *);
0261     void (*exit) (struct dvb_usb_device *);
0262     int (*get_rc_config) (struct dvb_usb_device *, struct dvb_usb_rc *);
0263 #define DVB_USB_FE_TS_TYPE_188        0
0264 #define DVB_USB_FE_TS_TYPE_204        1
0265 #define DVB_USB_FE_TS_TYPE_RAW        2
0266     int (*get_stream_config) (struct dvb_frontend *,  u8 *,
0267             struct usb_data_stream_properties *);
0268 };
0269 
0270 /**
0271  * struct usb_data_stream - generic object of an usb stream
0272  * @udev: USB device
0273  * @props: properties
0274  * @state: state of the data stream
0275  * @complete: complete callback
0276  * @urb_list: list of URBs
0277  * @buf_num: number of buffer allocated
0278  * @buf_size: size of each buffer in buf_list
0279  * @buf_list: array containing all allocate buffers for streaming
0280  * @dma_addr: list of dma_addr_t for each buffer in buf_list
0281  *
0282  * @urbs_initialized: number of URBs initialized
0283  * @urbs_submitted: number of URBs submitted
0284  * @user_priv: private pointer
0285  */
0286 struct usb_data_stream {
0287 #define MAX_NO_URBS_FOR_DATA_STREAM 10
0288     struct usb_device *udev;
0289     struct usb_data_stream_properties props;
0290 
0291 #define USB_STATE_INIT    0x00
0292 #define USB_STATE_URB_BUF 0x01
0293     u8 state;
0294 
0295     void (*complete) (struct usb_data_stream *, u8 *, size_t);
0296 
0297     struct urb    *urb_list[MAX_NO_URBS_FOR_DATA_STREAM];
0298     int            buf_num;
0299     unsigned long  buf_size;
0300     u8            *buf_list[MAX_NO_URBS_FOR_DATA_STREAM];
0301     dma_addr_t     dma_addr[MAX_NO_URBS_FOR_DATA_STREAM];
0302 
0303     int urbs_initialized;
0304     int urbs_submitted;
0305 
0306     void *user_priv;
0307 };
0308 
0309 /**
0310  * struct dvb_usb_adapter - dvb adapter object on dvb usb device
0311  * @props: pointer to adapter properties
0312  * @stream: adapter the usb data stream
0313  * @id: index of this adapter (starting with 0)
0314  * @ts_type: transport stream, input stream, type
0315  * @suspend_resume_active: set when there is ongoing suspend / resume
0316  * @pid_filtering: is hardware pid_filtering used or not
0317  * @feed_count: current feed count
0318  * @max_feed_count: maimum feed count device can handle
0319  * @active_fe: active frontend
0320  * @state_bits: status bits
0321  * @dvb_adap: adapter dvb_adapter
0322  * @dmxdev: adapter dmxdev
0323  * @demux: adapter software demuxer
0324  * @dvb_net: adapter dvb_net interfaces
0325  * @fe: adapter frontends
0326  * @fe_init: rerouted frontend-init function
0327  * @fe_sleep: rerouted frontend-sleep function
0328  */
0329 struct dvb_usb_adapter {
0330     const struct dvb_usb_adapter_properties *props;
0331     struct usb_data_stream stream;
0332     u8 id;
0333     u8 ts_type;
0334     bool suspend_resume_active;
0335     bool pid_filtering;
0336     u8 feed_count;
0337     u8 max_feed_count;
0338     s8 active_fe;
0339 #define ADAP_INIT                0
0340 #define ADAP_SLEEP               1
0341 #define ADAP_STREAMING           2
0342     unsigned long state_bits;
0343 
0344     /* dvb */
0345     struct dvb_adapter   dvb_adap;
0346     struct dmxdev        dmxdev;
0347     struct dvb_demux     demux;
0348     struct dvb_net       dvb_net;
0349 
0350     struct dvb_frontend *fe[MAX_NO_OF_FE_PER_ADAP];
0351     int (*fe_init[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *);
0352     int (*fe_sleep[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *);
0353 };
0354 
0355 /**
0356  * struct dvb_usb_device - dvb usb device object
0357  * @props: device properties
0358  * @name: device name
0359  * @rc_map: name of rc codes table
0360  * @rc_polling_active: set when RC polling is active
0361  * @intf: pointer to the device's struct usb_interface
0362  * @udev: pointer to the device's struct usb_device
0363  * @rc: remote controller configuration
0364  * @powered: indicated whether the device is power or not
0365  * @usb_mutex: mutex for usb control messages
0366  * @i2c_mutex: mutex for i2c-transfers
0367  * @i2c_adap: device's i2c-adapter
0368  * @adapter: adapters
0369  * @rc_dev: rc device for the remote control
0370  * @rc_phys: rc path
0371  * @rc_query_work: work for polling remote
0372  * @priv: private data of the actual driver (allocate by dvb usb, size defined
0373  *  in size_of_priv of dvb_usb_properties).
0374  */
0375 struct dvb_usb_device {
0376     const struct dvb_usb_device_properties *props;
0377     const char *name;
0378     const char *rc_map;
0379     bool rc_polling_active;
0380     struct usb_interface *intf;
0381     struct usb_device *udev;
0382     struct dvb_usb_rc rc;
0383     int powered;
0384 
0385     /* locking */
0386     struct mutex usb_mutex;
0387 
0388     /* i2c */
0389     struct mutex i2c_mutex;
0390     struct i2c_adapter i2c_adap;
0391 
0392     struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
0393 
0394     /* remote control */
0395     struct rc_dev *rc_dev;
0396     char rc_phys[64];
0397     struct delayed_work rc_query_work;
0398 
0399     void *priv;
0400 };
0401 
0402 extern int dvb_usbv2_probe(struct usb_interface *,
0403         const struct usb_device_id *);
0404 extern void dvb_usbv2_disconnect(struct usb_interface *);
0405 extern int dvb_usbv2_suspend(struct usb_interface *, pm_message_t);
0406 extern int dvb_usbv2_resume(struct usb_interface *);
0407 extern int dvb_usbv2_reset_resume(struct usb_interface *);
0408 
0409 /* the generic read/write method for device control */
0410 extern int dvb_usbv2_generic_rw(struct dvb_usb_device *, u8 *, u16, u8 *, u16);
0411 extern int dvb_usbv2_generic_write(struct dvb_usb_device *, u8 *, u16);
0412 /* caller must hold lock when locked versions are called */
0413 extern int dvb_usbv2_generic_rw_locked(struct dvb_usb_device *,
0414         u8 *, u16, u8 *, u16);
0415 extern int dvb_usbv2_generic_write_locked(struct dvb_usb_device *, u8 *, u16);
0416 
0417 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!