528 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2/* dvb-usb.h is part of the DVB USB library.3 *4 * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@posteo.de)5 * see dvb-usb-init.c for copyright information.6 *7 * the headerfile, all dvb-usb-drivers have to include.8 *9 * TODO: clean-up the structures for unused fields and update the comments10 */11#ifndef __DVB_USB_H__12#define __DVB_USB_H__13 14#include <linux/input.h>15#include <linux/usb.h>16#include <linux/firmware.h>17#include <linux/mutex.h>18#include <media/rc-core.h>19 20#include <media/dvb_frontend.h>21#include <media/dvb_demux.h>22#include <media/dvb_net.h>23#include <media/dmxdev.h>24 25#include "dvb-pll.h"26 27#include <media/dvb-usb-ids.h>28 29/* debug */30#ifdef CONFIG_DVB_USB_DEBUG31#define dprintk(var, level, args...) \32 do { if (((var) & (level))) { printk(args); } } while (0)33 34#define debug_dump(b, l, func) {\35 int loop_; \36 for (loop_ = 0; loop_ < (l); loop_++) \37 func("%02x ", b[loop_]); \38 func("\n");\39}40#define DVB_USB_DEBUG_STATUS41#else42#define dprintk(var, level, args...) no_printk(args)43#define debug_dump(b, l, func) do { } while (0)44 45#define DVB_USB_DEBUG_STATUS " (debugging is not enabled)"46 47#endif48 49/* generic log methods - taken from usb.h */50#ifndef DVB_USB_LOG_PREFIX51 #define DVB_USB_LOG_PREFIX "dvb-usb (please define a log prefix)"52#endif53 54#undef err55#define err(format, arg...) printk(KERN_ERR DVB_USB_LOG_PREFIX ": " format "\n" , ## arg)56#undef info57#define info(format, arg...) printk(KERN_INFO DVB_USB_LOG_PREFIX ": " format "\n" , ## arg)58#undef warn59#define warn(format, arg...) printk(KERN_WARNING DVB_USB_LOG_PREFIX ": " format "\n" , ## arg)60 61/**62 * struct dvb_usb_device_description - name and its according USB IDs63 * @name: real name of the box, regardless which DVB USB device class is in use64 * @cold_ids: array of struct usb_device_id which describe the device in65 * pre-firmware state66 * @warm_ids: array of struct usb_device_id which describe the device in67 * post-firmware state68 *69 * Each DVB USB device class can have one or more actual devices, this struct70 * assigns a name to it.71 */72struct dvb_usb_device_description {73 const char *name;74 75#define DVB_USB_ID_MAX_NUM 1576 struct usb_device_id *cold_ids[DVB_USB_ID_MAX_NUM];77 struct usb_device_id *warm_ids[DVB_USB_ID_MAX_NUM];78};79 80static inline u8 rc5_custom(struct rc_map_table *key)81{82 return (key->scancode >> 8) & 0xff;83}84 85static inline u8 rc5_data(struct rc_map_table *key)86{87 return key->scancode & 0xff;88}89 90static inline u16 rc5_scan(struct rc_map_table *key)91{92 return key->scancode & 0xffff;93}94 95struct dvb_usb_device;96struct dvb_usb_adapter;97struct usb_data_stream;98 99/*100 * Properties of USB streaming - TODO this structure should be somewhere else101 * describes the kind of USB transfer used for data-streaming.102 * (BULK or ISOC)103 */104struct usb_data_stream_properties {105#define USB_BULK 1106#define USB_ISOC 2107 int type;108 int count;109 int endpoint;110 111 union {112 struct {113 int buffersize; /* per URB */114 } bulk;115 struct {116 int framesperurb;117 int framesize;118 int interval;119 } isoc;120 } u;121};122 123/**124 * struct dvb_usb_adapter_fe_properties - properties of a dvb-usb-adapter.125 * A DVB-USB-Adapter is basically a dvb_adapter which is present on a USB-device.126 * @caps: capabilities of the DVB USB device.127 * @pid_filter_count: number of PID filter position in the optional hardware128 * PID-filter.129 * @streaming_ctrl: called to start and stop the MPEG2-TS streaming of the130 * device (not URB submitting/killing).131 * This callback will be called without data URBs being active - data URBs132 * will be submitted only after streaming_ctrl(1) returns successfully and133 * they will be killed before streaming_ctrl(0) gets called.134 * @pid_filter_ctrl: called to en/disable the PID filter, if any.135 * @pid_filter: called to set/unset a PID for filtering.136 * @frontend_attach: called to attach the possible frontends (fill fe-field137 * of struct dvb_usb_device).138 * @tuner_attach: called to attach the correct tuner and to fill pll_addr,139 * pll_desc and pll_init_buf of struct dvb_usb_device).140 * @stream: configuration of the USB streaming141 * @size_of_priv: size of the priv memory in struct dvb_usb_adapter142 */143struct dvb_usb_adapter_fe_properties {144#define DVB_USB_ADAP_HAS_PID_FILTER 0x01145#define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02146#define DVB_USB_ADAP_NEED_PID_FILTERING 0x04147#define DVB_USB_ADAP_RECEIVES_204_BYTE_TS 0x08148#define DVB_USB_ADAP_RECEIVES_RAW_PAYLOAD 0x10149 int caps;150 int pid_filter_count;151 152 int (*streaming_ctrl) (struct dvb_usb_adapter *, int);153 int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int);154 int (*pid_filter) (struct dvb_usb_adapter *, int, u16, int);155 156 int (*frontend_attach) (struct dvb_usb_adapter *);157 int (*tuner_attach) (struct dvb_usb_adapter *);158 159 struct usb_data_stream_properties stream;160 161 int size_of_priv;162};163 164#define MAX_NO_OF_FE_PER_ADAP 3165struct dvb_usb_adapter_properties {166 int size_of_priv;167 168 int (*frontend_ctrl) (struct dvb_frontend *, int);169 170 int num_frontends;171 struct dvb_usb_adapter_fe_properties fe[MAX_NO_OF_FE_PER_ADAP];172};173 174/**175 * struct dvb_rc_legacy - old properties of remote controller176 * @rc_map_table: a hard-wired array of struct rc_map_table (NULL to disable177 * remote control handling).178 * @rc_map_size: number of items in @rc_map_table.179 * @rc_query: called to query an event event.180 * @rc_interval: time in ms between two queries.181 */182struct dvb_rc_legacy {183/* remote control properties */184#define REMOTE_NO_KEY_PRESSED 0x00185#define REMOTE_KEY_PRESSED 0x01186#define REMOTE_KEY_REPEAT 0x02187 struct rc_map_table *rc_map_table;188 int rc_map_size;189 int (*rc_query) (struct dvb_usb_device *, u32 *, int *);190 int rc_interval;191};192 193/**194 * struct dvb_rc - properties of remote controller, using rc-core195 * @rc_codes: name of rc codes table196 * @protocol: type of protocol(s) currently used by the driver197 * @allowed_protos: protocol(s) supported by the driver198 * @driver_type: Used to point if a device supports raw mode199 * @change_protocol: callback to change protocol200 * @module_name: module name201 * @rc_query: called to query an event event.202 * @rc_interval: time in ms between two queries.203 * @bulk_mode: device supports bulk mode for RC (disable polling mode)204 * @scancode_mask: scancode mask205 */206struct dvb_rc {207 char *rc_codes;208 u64 protocol;209 u64 allowed_protos;210 enum rc_driver_type driver_type;211 int (*change_protocol)(struct rc_dev *dev, u64 *rc_proto);212 char *module_name;213 int (*rc_query) (struct dvb_usb_device *d);214 int rc_interval;215 bool bulk_mode; /* uses bulk mode */216 u32 scancode_mask;217};218 219/**220 * enum dvb_usb_mode - Specifies if it is using a legacy driver or a new one221 * based on rc-core222 * This is initialized/used only inside dvb-usb-remote.c.223 * It shouldn't be set by the drivers.224 *225 * @DVB_RC_LEGACY: legacy driver226 * @DVB_RC_CORE: rc-core driver227 */228enum dvb_usb_mode {229 DVB_RC_LEGACY,230 DVB_RC_CORE,231};232 233/**234 * struct dvb_usb_device_properties - properties of a dvb-usb-device235 * @caps: capabilities236 * @usb_ctrl: which USB device-side controller is in use. Needed for firmware237 * download.238 * @firmware: name of the firmware file.239 * @download_firmware: called to download the firmware when the usb_ctrl is240 * DEVICE_SPECIFIC.241 * @no_reconnect: device doesn't do a reconnect after downloading the firmware,242 * so do the warm initialization right after it243 *244 * @size_of_priv: how many bytes shall be allocated for the private field245 * of struct dvb_usb_device.246 * @priv_init: optional callback to initialize the variable that private field247 * of struct dvb_usb_device has pointer to just after it had been allocated and248 * zeroed.249 * @priv_destroy: just like priv_init, only called before deallocating250 * the memory pointed by private field of struct dvb_usb_device.251 *252 * @num_adapters: the number of adapters in @adapters253 * @adapter: the adapters254 * @power_ctrl: called to enable/disable power of the device.255 * @read_mac_address: called to read the MAC address of the device.256 * @identify_state: called to determine the state (cold or warm), when it257 * is not distinguishable by the USB IDs.258 *259 * @rc: remote controller properties260 *261 * @i2c_algo: i2c_algorithm if the device has I2CoverUSB.262 *263 * @generic_bulk_ctrl_endpoint: most of the DVB USB devices have a generic264 * endpoint which received control messages with bulk transfers. When this265 * is non-zero, one can use dvb_usb_generic_rw and dvb_usb_generic_write-266 * helper functions.267 *268 * @generic_bulk_ctrl_endpoint_response: some DVB USB devices use a separate269 * endpoint for responses to control messages sent with bulk transfers via270 * the generic_bulk_ctrl_endpoint. When this is non-zero, this will be used271 * instead of the generic_bulk_ctrl_endpoint when reading usb responses in272 * the dvb_usb_generic_rw helper function.273 *274 * @num_device_descs: number of struct dvb_usb_device_description in @devices275 * @devices: array of struct dvb_usb_device_description compatibles with these276 * properties.277 */278struct dvb_usb_device_properties {279#define MAX_NO_OF_ADAPTER_PER_DEVICE 2280#define DVB_USB_IS_AN_I2C_ADAPTER 0x01281 int caps;282 283#define DEVICE_SPECIFIC 0284#define CYPRESS_AN2135 1285#define CYPRESS_AN2235 2286#define CYPRESS_FX2 3287 int usb_ctrl;288 int (*download_firmware) (struct usb_device *, const struct firmware *);289 const char *firmware;290 int no_reconnect;291 292 int size_of_priv;293 int (*priv_init)(struct dvb_usb_device *);294 void (*priv_destroy)(struct dvb_usb_device *);295 296 int num_adapters;297 struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];298 299 int (*power_ctrl) (struct dvb_usb_device *, int);300 int (*read_mac_address) (struct dvb_usb_device *, u8 []);301 int (*identify_state)(struct usb_device *udev,302 const struct dvb_usb_device_properties *props,303 const struct dvb_usb_device_description **desc,304 int *cold);305 306 struct {307 enum dvb_usb_mode mode; /* Drivers shouldn't touch on it */308 struct dvb_rc_legacy legacy;309 struct dvb_rc core;310 } rc;311 312 struct i2c_algorithm *i2c_algo;313 314 int generic_bulk_ctrl_endpoint;315 int generic_bulk_ctrl_endpoint_response;316 317 int num_device_descs;318 struct dvb_usb_device_description devices[12];319};320 321/**322 * struct usb_data_stream - generic object of an USB stream323 * @udev: the USB device324 * @props: data stream properties325 * @state: state of the stream326 * @complete: complete callback327 * @urb_list: list of URBs328 * @buf_num: number of buffer allocated.329 * @buf_size: size of each buffer in buf_list.330 * @buf_list: array containing all allocate buffers for streaming.331 * @dma_addr: list of dma_addr_t for each buffer in buf_list.332 *333 * @urbs_initialized: number of URBs initialized.334 * @urbs_submitted: number of URBs submitted.335 * @user_priv: for private use.336 */337struct usb_data_stream {338#define MAX_NO_URBS_FOR_DATA_STREAM 10339 struct usb_device *udev;340 struct usb_data_stream_properties props;341 342#define USB_STATE_INIT 0x00343#define USB_STATE_URB_BUF 0x01344 int state;345 346 void (*complete) (struct usb_data_stream *, u8 *, size_t);347 348 struct urb *urb_list[MAX_NO_URBS_FOR_DATA_STREAM];349 int buf_num;350 unsigned long buf_size;351 u8 *buf_list[MAX_NO_URBS_FOR_DATA_STREAM];352 dma_addr_t dma_addr[MAX_NO_URBS_FOR_DATA_STREAM];353 354 int urbs_initialized;355 int urbs_submitted;356 357 void *user_priv;358};359 360/**361 * struct dvb_usb_fe_adapter - a DVB adapter on a USB device362 * @fe: frontend363 * @fe_init: rerouted frontend-init (wakeup) function.364 * @fe_sleep: rerouted frontend-sleep function.365 * @stream: the usb data stream.366 * @pid_filtering: is hardware pid_filtering used or not.367 * @max_feed_count: how many feeds can be handled simultaneously by this368 * device369 * @priv: private pointer370 */371struct dvb_usb_fe_adapter {372 struct dvb_frontend *fe;373 374 int (*fe_init) (struct dvb_frontend *);375 int (*fe_sleep) (struct dvb_frontend *);376 377 struct usb_data_stream stream;378 379 int pid_filtering;380 int max_feed_count;381 382 void *priv;383};384 385/**386 * struct dvb_usb_adapter - a DVB adapter on a USB device387 * @dev: DVB USB device pointer388 * @props: properties389 * @state: status390 * @id: index of this adapter (starting with 0).391 *392 * @feedcount: number of requested feeds (used for streaming-activation)393 *394 * @dvb_adap: device's dvb_adapter.395 * @dmxdev: device's dmxdev.396 * @demux: device's software demuxer.397 * @dvb_net: device's dvb_net interfaces.398 *399 * @fe_adap: frontend adapters400 * @active_fe: active frontend401 * @num_frontends_initialized: number of initialized frontends402 * @priv: private pointer403 */404struct dvb_usb_adapter {405 struct dvb_usb_device *dev;406 struct dvb_usb_adapter_properties props;407 408#define DVB_USB_ADAP_STATE_INIT 0x000409#define DVB_USB_ADAP_STATE_DVB 0x001410 int state;411 412 u8 id;413 414 int feedcount;415 416 /* dvb */417 struct dvb_adapter dvb_adap;418 struct dmxdev dmxdev;419 struct dvb_demux demux;420 struct dvb_net dvb_net;421 422 struct dvb_usb_fe_adapter fe_adap[MAX_NO_OF_FE_PER_ADAP];423 int active_fe;424 int num_frontends_initialized;425 426 void *priv;427};428 429/**430 * struct dvb_usb_device - object of a DVB USB device431 * @props: copy of the struct dvb_usb_properties this device belongs to.432 * @desc: pointer to the device's struct dvb_usb_device_description.433 * @state: initialization and runtime state of the device.434 *435 * @powered: indicated whether the device is power or not.436 * Powered is in/decremented for each call to modify the state.437 * @udev: pointer to the device's struct usb_device.438 *439 * @data_mutex: mutex to protect the data structure used to store URB data440 * @usb_mutex: mutex of USB control messages (reading needs two messages).441 * Please notice that this mutex is used internally at the generic442 * URB control functions. So, drivers using dvb_usb_generic_rw() and443 * derivated functions should not lock it internally.444 * @i2c_mutex: mutex for i2c-transfers445 *446 * @i2c_adap: device's i2c_adapter if it uses I2CoverUSB447 *448 * @num_adapters_initialized: number of initialized adapters449 * @adapter: adapters450 *451 * @rc_dev: rc device for the remote control (rc-core mode)452 * @input_dev: input device for the remote control (legacy mode)453 * @rc_phys: rc device path454 * @rc_query_work: struct work_struct frequent rc queries455 * @last_event: last triggered event456 * @last_state: last state (no, pressed, repeat)457 * @owner: owner of the dvb_adapter458 * @priv: private data of the actual driver (allocate by dvb-usb, size defined459 * in size_of_priv of dvb_usb_properties).460 */461struct dvb_usb_device {462 struct dvb_usb_device_properties props;463 const struct dvb_usb_device_description *desc;464 465 struct usb_device *udev;466 467#define DVB_USB_STATE_INIT 0x000468#define DVB_USB_STATE_I2C 0x001469#define DVB_USB_STATE_DVB 0x002470#define DVB_USB_STATE_REMOTE 0x004471 int state;472 473 int powered;474 475 /* locking */476 struct mutex data_mutex;477 struct mutex usb_mutex;478 479 /* i2c */480 struct mutex i2c_mutex;481 struct i2c_adapter i2c_adap;482 483 int num_adapters_initialized;484 struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];485 486 /* remote control */487 struct rc_dev *rc_dev;488 struct input_dev *input_dev;489 char rc_phys[64];490 struct delayed_work rc_query_work;491 u32 last_event;492 int last_state;493 494 struct module *owner;495 496 void *priv;497};498 499extern int dvb_usb_device_init(struct usb_interface *,500 const struct dvb_usb_device_properties *,501 struct module *, struct dvb_usb_device **,502 short *adapter_nums);503extern void dvb_usb_device_exit(struct usb_interface *);504 505/* the generic read/write method for device control */506extern int __must_check507dvb_usb_generic_rw(struct dvb_usb_device *, u8 *, u16, u8 *, u16, int);508extern int __must_check509dvb_usb_generic_write(struct dvb_usb_device *, u8 *, u16);510 511/* commonly used remote control parsing */512int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *d, u8 keybuf[5],513 u32 *event, int *state);514 515/* commonly used firmware download types and function */516struct hexline {517 u8 len;518 u32 addr;519 u8 type;520 u8 data[255];521 u8 chk;522};523extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type);524extern int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos);525 526 527#endif528