| /* SPDX-License-Identifier: GPL-2.0-or-later */ | |
| /* | |
| * DVB USB framework | |
| * | |
| * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@posteo.de> | |
| * Copyright (C) 2012 Antti Palosaari <crope@iki.fi> | |
| */ | |
| #ifndef DVB_USB_H | |
| #define DVB_USB_H | |
| #include <linux/usb/input.h> | |
| #include <linux/firmware.h> | |
| #include <media/rc-core.h> | |
| #include <media/media-device.h> | |
| #include <media/dvb_frontend.h> | |
| #include <media/dvb_demux.h> | |
| #include <media/dvb_net.h> | |
| #include <media/dmxdev.h> | |
| #include <media/dvb-usb-ids.h> | |
| /* | |
| * device file: /dev/dvb/adapter[0-1]/frontend[0-2] | |
| * | |
| * |-- device | |
| * | |-- adapter0 | |
| * | | |-- frontend0 | |
| * | | |-- frontend1 | |
| * | | `-- frontend2 | |
| * | `-- adapter1 | |
| * | |-- frontend0 | |
| * | |-- frontend1 | |
| * | `-- frontend2 | |
| * | |
| * | |
| * Commonly used variable names: | |
| * d = pointer to device (struct dvb_usb_device *) | |
| * adap = pointer to adapter (struct dvb_usb_adapter *) | |
| * fe = pointer to frontend (struct dvb_frontend *) | |
| * | |
| * Use macros defined in that file to resolve needed pointers. | |
| */ | |
| /* helper macros for every DVB USB driver use */ | |
| #define adap_to_d(adap) (container_of(adap, struct dvb_usb_device, \ | |
| adapter[adap->id])) | |
| #define adap_to_priv(adap) (adap_to_d(adap)->priv) | |
| #define fe_to_adap(fe) ((struct dvb_usb_adapter *) ((fe)->dvb->priv)) | |
| #define fe_to_d(fe) (adap_to_d(fe_to_adap(fe))) | |
| #define fe_to_priv(fe) (fe_to_d(fe)->priv) | |
| #define d_to_priv(d) (d->priv) | |
| #define dvb_usb_dbg_usb_control_msg(udev, r, t, v, i, b, l) { \ | |
| char *direction; \ | |
| if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \ | |
| direction = ">>>"; \ | |
| else \ | |
| direction = "<<<"; \ | |
| dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \ | |
| "%s %*ph\n", __func__, t, r, v & 0xff, v >> 8, \ | |
| i & 0xff, i >> 8, l & 0xff, l >> 8, direction, l, b); \ | |
| } | |
| #define DVB_USB_STREAM_BULK(endpoint_, count_, size_) { \ | |
| .type = USB_BULK, \ | |
| .count = count_, \ | |
| .endpoint = endpoint_, \ | |
| .u = { \ | |
| .bulk = { \ | |
| .buffersize = size_, \ | |
| } \ | |
| } \ | |
| } | |
| #define DVB_USB_STREAM_ISOC(endpoint_, count_, frames_, size_, interval_) { \ | |
| .type = USB_ISOC, \ | |
| .count = count_, \ | |
| .endpoint = endpoint_, \ | |
| .u = { \ | |
| .isoc = { \ | |
| .framesperurb = frames_, \ | |
| .framesize = size_,\ | |
| .interval = interval_, \ | |
| } \ | |
| } \ | |
| } | |
| #define DVB_USB_DEVICE(vend, prod, props_, name_, rc) \ | |
| .match_flags = USB_DEVICE_ID_MATCH_DEVICE, \ | |
| .idVendor = (vend), \ | |
| .idProduct = (prod), \ | |
| .driver_info = (kernel_ulong_t) &((const struct dvb_usb_driver_info) { \ | |
| .props = (props_), \ | |
| .name = (name_), \ | |
| .rc_map = (rc), \ | |
| }) | |
| struct dvb_usb_device; | |
| struct dvb_usb_adapter; | |
| /** | |
| * struct dvb_usb_driver_info - structure for carrying all needed data from the | |
| * device driver to the general | |
| * dvb usb routines | |
| * @name: device name | |
| * @rc_map: name of rc codes table | |
| * @props: structure containing all device properties | |
| */ | |
| struct dvb_usb_driver_info { | |
| const char *name; | |
| const char *rc_map; | |
| const struct dvb_usb_device_properties *props; | |
| }; | |
| /** | |
| * struct dvb_usb_rc - structure for remote controller configuration | |
| * @map_name: name of rc codes table | |
| * @allowed_protos: protocol(s) supported by the driver | |
| * @change_protocol: callback to change protocol | |
| * @query: called to query an event from the device | |
| * @interval: time in ms between two queries | |
| * @driver_type: used to point if a device supports raw mode | |
| * @bulk_mode: device supports bulk mode for rc (disable polling mode) | |
| * @timeout: set to length of last space before raw IR goes idle | |
| */ | |
| struct dvb_usb_rc { | |
| const char *map_name; | |
| u64 allowed_protos; | |
| int (*change_protocol)(struct rc_dev *dev, u64 *rc_proto); | |
| int (*query) (struct dvb_usb_device *d); | |
| unsigned int interval; | |
| enum rc_driver_type driver_type; | |
| bool bulk_mode; | |
| int timeout; | |
| }; | |
| /** | |
| * struct usb_data_stream_properties - usb streaming configuration for adapter | |
| * @type: urb type | |
| * @count: count of used urbs | |
| * @endpoint: stream usb endpoint number | |
| * @u: union for @bulk and @isoc | |
| */ | |
| struct usb_data_stream_properties { | |
| #define USB_BULK 1 | |
| #define USB_ISOC 2 | |
| u8 type; | |
| u8 count; | |
| u8 endpoint; | |
| union { | |
| struct { | |
| unsigned int buffersize; /* per URB */ | |
| } bulk; | |
| struct { | |
| int framesperurb; | |
| int framesize; | |
| int interval; | |
| } isoc; | |
| } u; | |
| }; | |
| /** | |
| * struct dvb_usb_adapter_properties - properties of dvb usb device adapter | |
| * @caps: adapter capabilities | |
| * @pid_filter_count: pid count of adapter pid-filter | |
| * @pid_filter_ctrl: called to enable/disable pid-filter | |
| * @pid_filter: called to set/unset pid for filtering | |
| * @stream: adapter usb stream configuration | |
| */ | |
| struct dvb_usb_adapter_properties { | |
| #define MAX_NO_OF_FE_PER_ADAP 3 | |
| #define DVB_USB_ADAP_HAS_PID_FILTER 0x01 | |
| #define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02 | |
| #define DVB_USB_ADAP_NEED_PID_FILTERING 0x04 | |
| u8 caps; | |
| u8 pid_filter_count; | |
| int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int); | |
| int (*pid_filter) (struct dvb_usb_adapter *, int, u16, int); | |
| struct usb_data_stream_properties stream; | |
| }; | |
| /** | |
| * struct dvb_usb_device_properties - properties of a dvb-usb-device | |
| * @driver_name: name of the owning driver module | |
| * @owner: owner of the dvb_adapter | |
| * @adapter_nr: values from the DVB_DEFINE_MOD_OPT_ADAPTER_NR() macro | |
| * @bInterfaceNumber: usb interface number driver binds | |
| * @size_of_priv: bytes allocated for the driver private data | |
| * @generic_bulk_ctrl_endpoint: bulk control endpoint number for sent | |
| * @generic_bulk_ctrl_endpoint_response: bulk control endpoint number for | |
| * receive | |
| * @generic_bulk_ctrl_delay: delay between bulk control sent and receive message | |
| * @probe: like probe on driver model | |
| * @disconnect: like disconnect on driver model | |
| * @identify_state: called to determine the firmware state (cold or warm) and | |
| * return possible firmware file name to be loaded | |
| * @firmware: name of the firmware file to be loaded | |
| * @download_firmware: called to download the firmware | |
| * @i2c_algo: i2c_algorithm if the device has i2c-adapter | |
| * @num_adapters: dvb usb device adapter count | |
| * @get_adapter_count: called to resolve adapter count | |
| * @adapter: array of all adapter properties of device | |
| * @power_ctrl: called to enable/disable power of the device | |
| * @read_config: called to resolve device configuration | |
| * @read_mac_address: called to resolve adapter mac-address | |
| * @frontend_attach: called to attach the possible frontends | |
| * @frontend_detach: called to detach the possible frontends | |
| * @tuner_attach: called to attach the possible tuners | |
| * @tuner_detach: called to detach the possible tuners | |
| * @frontend_ctrl: called to power on/off active frontend | |
| * @streaming_ctrl: called to start/stop the usb streaming of adapter | |
| * @init: called after adapters are created in order to finalize device | |
| * configuration | |
| * @exit: called when driver is unloaded | |
| * @get_rc_config: called to resolve used remote controller configuration | |
| * @get_stream_config: called to resolve input and output stream configuration | |
| * of the adapter just before streaming is started. input stream is transport | |
| * stream from the demodulator and output stream is usb stream to host. | |
| */ | |
| struct dvb_usb_device_properties { | |
| #define MAX_NO_OF_ADAPTER_PER_DEVICE 2 | |
| const char *driver_name; | |
| struct module *owner; | |
| short *adapter_nr; | |
| u8 bInterfaceNumber; | |
| unsigned int size_of_priv; | |
| u8 generic_bulk_ctrl_endpoint; | |
| u8 generic_bulk_ctrl_endpoint_response; | |
| unsigned int generic_bulk_ctrl_delay; | |
| int (*probe)(struct dvb_usb_device *); | |
| void (*disconnect)(struct dvb_usb_device *); | |
| #define WARM 0 | |
| #define COLD 1 | |
| int (*identify_state) (struct dvb_usb_device *, const char **); | |
| const char *firmware; | |
| #define RECONNECTS_USB 1 | |
| int (*download_firmware) (struct dvb_usb_device *, | |
| const struct firmware *); | |
| const struct i2c_algorithm *i2c_algo; | |
| unsigned int num_adapters; | |
| int (*get_adapter_count) (struct dvb_usb_device *); | |
| struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE]; | |
| int (*power_ctrl) (struct dvb_usb_device *, int); | |
| int (*read_config) (struct dvb_usb_device *d); | |
| int (*read_mac_address) (struct dvb_usb_adapter *, u8 []); | |
| int (*frontend_attach) (struct dvb_usb_adapter *); | |
| int (*frontend_detach)(struct dvb_usb_adapter *); | |
| int (*tuner_attach) (struct dvb_usb_adapter *); | |
| int (*tuner_detach)(struct dvb_usb_adapter *); | |
| int (*frontend_ctrl) (struct dvb_frontend *, int); | |
| int (*streaming_ctrl) (struct dvb_frontend *, int); | |
| int (*init) (struct dvb_usb_device *); | |
| void (*exit) (struct dvb_usb_device *); | |
| int (*get_rc_config) (struct dvb_usb_device *, struct dvb_usb_rc *); | |
| #define DVB_USB_FE_TS_TYPE_188 0 | |
| #define DVB_USB_FE_TS_TYPE_204 1 | |
| #define DVB_USB_FE_TS_TYPE_RAW 2 | |
| int (*get_stream_config) (struct dvb_frontend *, u8 *, | |
| struct usb_data_stream_properties *); | |
| }; | |
| /** | |
| * struct usb_data_stream - generic object of an usb stream | |
| * @udev: USB device | |
| * @props: properties | |
| * @state: state of the data stream | |
| * @complete: complete callback | |
| * @urb_list: list of URBs | |
| * @buf_num: number of buffer allocated | |
| * @buf_size: size of each buffer in buf_list | |
| * @buf_list: array containing all allocate buffers for streaming | |
| * @dma_addr: list of dma_addr_t for each buffer in buf_list | |
| * | |
| * @urbs_initialized: number of URBs initialized | |
| * @urbs_submitted: number of URBs submitted | |
| * @user_priv: private pointer | |
| */ | |
| struct usb_data_stream { | |
| #define MAX_NO_URBS_FOR_DATA_STREAM 10 | |
| struct usb_device *udev; | |
| struct usb_data_stream_properties props; | |
| #define USB_STATE_INIT 0x00 | |
| #define USB_STATE_URB_BUF 0x01 | |
| u8 state; | |
| void (*complete) (struct usb_data_stream *, u8 *, size_t); | |
| struct urb *urb_list[MAX_NO_URBS_FOR_DATA_STREAM]; | |
| int buf_num; | |
| unsigned long buf_size; | |
| u8 *buf_list[MAX_NO_URBS_FOR_DATA_STREAM]; | |
| dma_addr_t dma_addr[MAX_NO_URBS_FOR_DATA_STREAM]; | |
| int urbs_initialized; | |
| int urbs_submitted; | |
| void *user_priv; | |
| }; | |
| /** | |
| * struct dvb_usb_adapter - dvb adapter object on dvb usb device | |
| * @props: pointer to adapter properties | |
| * @stream: adapter the usb data stream | |
| * @id: index of this adapter (starting with 0) | |
| * @ts_type: transport stream, input stream, type | |
| * @suspend_resume_active: set when there is ongoing suspend / resume | |
| * @pid_filtering: is hardware pid_filtering used or not | |
| * @feed_count: current feed count | |
| * @max_feed_count: maimum feed count device can handle | |
| * @active_fe: active frontend | |
| * @state_bits: status bits | |
| * @dvb_adap: adapter dvb_adapter | |
| * @dmxdev: adapter dmxdev | |
| * @demux: adapter software demuxer | |
| * @dvb_net: adapter dvb_net interfaces | |
| * @fe: adapter frontends | |
| * @fe_init: rerouted frontend-init function | |
| * @fe_sleep: rerouted frontend-sleep function | |
| */ | |
| struct dvb_usb_adapter { | |
| const struct dvb_usb_adapter_properties *props; | |
| struct usb_data_stream stream; | |
| u8 id; | |
| u8 ts_type; | |
| bool suspend_resume_active; | |
| bool pid_filtering; | |
| u8 feed_count; | |
| u8 max_feed_count; | |
| s8 active_fe; | |
| #define ADAP_INIT 0 | |
| #define ADAP_SLEEP 1 | |
| #define ADAP_STREAMING 2 | |
| unsigned long state_bits; | |
| /* dvb */ | |
| struct dvb_adapter dvb_adap; | |
| struct dmxdev dmxdev; | |
| struct dvb_demux demux; | |
| struct dvb_net dvb_net; | |
| struct dvb_frontend *fe[MAX_NO_OF_FE_PER_ADAP]; | |
| int (*fe_init[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *); | |
| int (*fe_sleep[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *); | |
| }; | |
| /** | |
| * struct dvb_usb_device - dvb usb device object | |
| * @props: device properties | |
| * @name: device name | |
| * @rc_map: name of rc codes table | |
| * @rc_polling_active: set when RC polling is active | |
| * @intf: pointer to the device's struct usb_interface | |
| * @udev: pointer to the device's struct usb_device | |
| * @rc: remote controller configuration | |
| * @powered: indicated whether the device is power or not | |
| * @usb_mutex: mutex for usb control messages | |
| * @i2c_mutex: mutex for i2c-transfers | |
| * @i2c_adap: device's i2c-adapter | |
| * @adapter: adapters | |
| * @rc_dev: rc device for the remote control | |
| * @rc_phys: rc path | |
| * @rc_query_work: work for polling remote | |
| * @priv: private data of the actual driver (allocate by dvb usb, size defined | |
| * in size_of_priv of dvb_usb_properties). | |
| */ | |
| struct dvb_usb_device { | |
| const struct dvb_usb_device_properties *props; | |
| const char *name; | |
| const char *rc_map; | |
| bool rc_polling_active; | |
| struct usb_interface *intf; | |
| struct usb_device *udev; | |
| struct dvb_usb_rc rc; | |
| int powered; | |
| /* locking */ | |
| struct mutex usb_mutex; | |
| /* i2c */ | |
| struct mutex i2c_mutex; | |
| struct i2c_adapter i2c_adap; | |
| struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE]; | |
| /* remote control */ | |
| struct rc_dev *rc_dev; | |
| char rc_phys[64]; | |
| struct delayed_work rc_query_work; | |
| void *priv; | |
| }; | |
| extern int dvb_usbv2_probe(struct usb_interface *, | |
| const struct usb_device_id *); | |
| extern void dvb_usbv2_disconnect(struct usb_interface *); | |
| extern int dvb_usbv2_suspend(struct usb_interface *, pm_message_t); | |
| extern int dvb_usbv2_resume(struct usb_interface *); | |
| extern int dvb_usbv2_reset_resume(struct usb_interface *); | |
| /* the generic read/write method for device control */ | |
| extern int dvb_usbv2_generic_rw(struct dvb_usb_device *, u8 *, u16, u8 *, u16); | |
| extern int dvb_usbv2_generic_write(struct dvb_usb_device *, u8 *, u16); | |
| /* caller must hold lock when locked versions are called */ | |
| extern int dvb_usbv2_generic_rw_locked(struct dvb_usb_device *, | |
| u8 *, u16, u8 *, u16); | |
| extern int dvb_usbv2_generic_write_locked(struct dvb_usb_device *, u8 *, u16); | |
| #endif |