14faba767SHans de Goede /*
24faba767SHans de Goede * Linux V4L2 radio driver for the Griffin radioSHARK2 USB radio receiver
34faba767SHans de Goede *
44faba767SHans de Goede * Note the radioSHARK2 offers the audio through a regular USB audio device,
54faba767SHans de Goede * this driver only handles the tuning.
64faba767SHans de Goede *
74faba767SHans de Goede * The info necessary to drive the shark2 was taken from the small userspace
84faba767SHans de Goede * shark2.c program by Hisaaki Shibata, which he kindly placed in the Public
94faba767SHans de Goede * Domain.
104faba767SHans de Goede *
114faba767SHans de Goede * Copyright (c) 2012 Hans de Goede <hdegoede@redhat.com>
124faba767SHans de Goede *
134faba767SHans de Goede * This program is free software; you can redistribute it and/or modify
144faba767SHans de Goede * it under the terms of the GNU General Public License as published by
154faba767SHans de Goede * the Free Software Foundation; either version 2 of the License, or
164faba767SHans de Goede * (at your option) any later version.
174faba767SHans de Goede *
184faba767SHans de Goede * This program is distributed in the hope that it will be useful,
194faba767SHans de Goede * but WITHOUT ANY WARRANTY; without even the implied warranty of
204faba767SHans de Goede * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
214faba767SHans de Goede * GNU General Public License for more details.
224faba767SHans de Goede */
234faba767SHans de Goede
244faba767SHans de Goede #include <linux/init.h>
254faba767SHans de Goede #include <linux/kernel.h>
264faba767SHans de Goede #include <linux/leds.h>
274faba767SHans de Goede #include <linux/module.h>
284faba767SHans de Goede #include <linux/slab.h>
294faba767SHans de Goede #include <linux/usb.h>
304faba767SHans de Goede #include <linux/workqueue.h>
314faba767SHans de Goede #include <media/v4l2-device.h>
324faba767SHans de Goede #include "radio-tea5777.h"
334faba767SHans de Goede
34be0c44fbSHans de Goede #if defined(CONFIG_LEDS_CLASS) || \
35be0c44fbSHans de Goede (defined(CONFIG_LEDS_CLASS_MODULE) && defined(CONFIG_RADIO_SHARK2_MODULE))
36be0c44fbSHans de Goede #define SHARK_USE_LEDS 1
37be0c44fbSHans de Goede #endif
38be0c44fbSHans de Goede
394faba767SHans de Goede MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
404faba767SHans de Goede MODULE_DESCRIPTION("Griffin radioSHARK2, USB radio receiver driver");
414faba767SHans de Goede MODULE_LICENSE("GPL");
424faba767SHans de Goede
434faba767SHans de Goede static int debug;
444faba767SHans de Goede module_param(debug, int, 0);
454faba767SHans de Goede MODULE_PARM_DESC(debug, "Debug level (0-1)");
464faba767SHans de Goede
474faba767SHans de Goede #define SHARK_IN_EP 0x83
484faba767SHans de Goede #define SHARK_OUT_EP 0x05
494faba767SHans de Goede
504faba767SHans de Goede #define TB_LEN 7
514faba767SHans de Goede #define DRV_NAME "radioshark2"
524faba767SHans de Goede
534faba767SHans de Goede #define v4l2_dev_to_shark(d) container_of(d, struct shark_device, v4l2_dev)
544faba767SHans de Goede
554faba767SHans de Goede enum { BLUE_LED, RED_LED, NO_LEDS };
564faba767SHans de Goede
574faba767SHans de Goede struct shark_device {
584faba767SHans de Goede struct usb_device *usbdev;
594faba767SHans de Goede struct v4l2_device v4l2_dev;
604faba767SHans de Goede struct radio_tea5777 tea;
614faba767SHans de Goede
62be0c44fbSHans de Goede #ifdef SHARK_USE_LEDS
634faba767SHans de Goede struct work_struct led_work;
644faba767SHans de Goede struct led_classdev leds[NO_LEDS];
650f070f0cSRicardo Ribalda char led_names[NO_LEDS][64];
664faba767SHans de Goede atomic_t brightness[NO_LEDS];
674faba767SHans de Goede unsigned long brightness_new;
68be0c44fbSHans de Goede #endif
694faba767SHans de Goede
704faba767SHans de Goede u8 *transfer_buffer;
714faba767SHans de Goede };
724faba767SHans de Goede
734faba767SHans de Goede static atomic_t shark_instance = ATOMIC_INIT(0);
744faba767SHans de Goede
shark_write_reg(struct radio_tea5777 * tea,u64 reg)754faba767SHans de Goede static int shark_write_reg(struct radio_tea5777 *tea, u64 reg)
764faba767SHans de Goede {
774faba767SHans de Goede struct shark_device *shark = tea->private_data;
784faba767SHans de Goede int i, res, actual_len;
794faba767SHans de Goede
804faba767SHans de Goede memset(shark->transfer_buffer, 0, TB_LEN);
814faba767SHans de Goede shark->transfer_buffer[0] = 0x81; /* Write register command */
824faba767SHans de Goede for (i = 0; i < 6; i++)
834faba767SHans de Goede shark->transfer_buffer[i + 1] = (reg >> (40 - i * 8)) & 0xff;
844faba767SHans de Goede
859697b54fSAndy Shevchenko v4l2_dbg(1, debug, tea->v4l2_dev, "shark2-write: %*ph\n",
869697b54fSAndy Shevchenko 7, shark->transfer_buffer);
874faba767SHans de Goede
884faba767SHans de Goede res = usb_interrupt_msg(shark->usbdev,
894faba767SHans de Goede usb_sndintpipe(shark->usbdev, SHARK_OUT_EP),
904faba767SHans de Goede shark->transfer_buffer, TB_LEN,
914faba767SHans de Goede &actual_len, 1000);
924faba767SHans de Goede if (res < 0) {
934faba767SHans de Goede v4l2_err(tea->v4l2_dev, "write error: %d\n", res);
944faba767SHans de Goede return res;
954faba767SHans de Goede }
964faba767SHans de Goede
974faba767SHans de Goede return 0;
984faba767SHans de Goede }
994faba767SHans de Goede
shark_read_reg(struct radio_tea5777 * tea,u32 * reg_ret)1004faba767SHans de Goede static int shark_read_reg(struct radio_tea5777 *tea, u32 *reg_ret)
1014faba767SHans de Goede {
1024faba767SHans de Goede struct shark_device *shark = tea->private_data;
1034faba767SHans de Goede int i, res, actual_len;
1044faba767SHans de Goede u32 reg = 0;
1054faba767SHans de Goede
1064faba767SHans de Goede memset(shark->transfer_buffer, 0, TB_LEN);
1074faba767SHans de Goede shark->transfer_buffer[0] = 0x82;
1084faba767SHans de Goede res = usb_interrupt_msg(shark->usbdev,
1094faba767SHans de Goede usb_sndintpipe(shark->usbdev, SHARK_OUT_EP),
1104faba767SHans de Goede shark->transfer_buffer, TB_LEN,
1114faba767SHans de Goede &actual_len, 1000);
1124faba767SHans de Goede if (res < 0) {
1134faba767SHans de Goede v4l2_err(tea->v4l2_dev, "request-read error: %d\n", res);
1144faba767SHans de Goede return res;
1154faba767SHans de Goede }
1164faba767SHans de Goede
1174faba767SHans de Goede res = usb_interrupt_msg(shark->usbdev,
1184faba767SHans de Goede usb_rcvintpipe(shark->usbdev, SHARK_IN_EP),
1194faba767SHans de Goede shark->transfer_buffer, TB_LEN,
1204faba767SHans de Goede &actual_len, 1000);
1214faba767SHans de Goede if (res < 0) {
1224faba767SHans de Goede v4l2_err(tea->v4l2_dev, "read error: %d\n", res);
1234faba767SHans de Goede return res;
1244faba767SHans de Goede }
1254faba767SHans de Goede
1264faba767SHans de Goede for (i = 0; i < 3; i++)
1274faba767SHans de Goede reg |= shark->transfer_buffer[i] << (16 - i * 8);
1284faba767SHans de Goede
1299697b54fSAndy Shevchenko v4l2_dbg(1, debug, tea->v4l2_dev, "shark2-read: %*ph\n",
1309697b54fSAndy Shevchenko 3, shark->transfer_buffer);
1314faba767SHans de Goede
1324faba767SHans de Goede *reg_ret = reg;
1334faba767SHans de Goede return 0;
1344faba767SHans de Goede }
1354faba767SHans de Goede
13618a8560cSJulia Lawall static const struct radio_tea5777_ops shark_tea_ops = {
1374faba767SHans de Goede .write_reg = shark_write_reg,
1384faba767SHans de Goede .read_reg = shark_read_reg,
1394faba767SHans de Goede };
1404faba767SHans de Goede
141be0c44fbSHans de Goede #ifdef SHARK_USE_LEDS
shark_led_work(struct work_struct * work)1424faba767SHans de Goede static void shark_led_work(struct work_struct *work)
1434faba767SHans de Goede {
1444faba767SHans de Goede struct shark_device *shark =
1454faba767SHans de Goede container_of(work, struct shark_device, led_work);
1464faba767SHans de Goede int i, res, brightness, actual_len;
1474faba767SHans de Goede
1484faba767SHans de Goede for (i = 0; i < 2; i++) {
1494faba767SHans de Goede if (!test_and_clear_bit(i, &shark->brightness_new))
1504faba767SHans de Goede continue;
1514faba767SHans de Goede
1524faba767SHans de Goede brightness = atomic_read(&shark->brightness[i]);
1534faba767SHans de Goede memset(shark->transfer_buffer, 0, TB_LEN);
1544faba767SHans de Goede shark->transfer_buffer[0] = 0x83 + i;
1554faba767SHans de Goede shark->transfer_buffer[1] = brightness;
1564faba767SHans de Goede res = usb_interrupt_msg(shark->usbdev,
1574faba767SHans de Goede usb_sndintpipe(shark->usbdev,
1584faba767SHans de Goede SHARK_OUT_EP),
1594faba767SHans de Goede shark->transfer_buffer, TB_LEN,
1604faba767SHans de Goede &actual_len, 1000);
1614faba767SHans de Goede if (res < 0)
1624faba767SHans de Goede v4l2_err(&shark->v4l2_dev, "set LED %s error: %d\n",
1634faba767SHans de Goede shark->led_names[i], res);
1644faba767SHans de Goede }
1654faba767SHans de Goede }
1664faba767SHans de Goede
shark_led_set_blue(struct led_classdev * led_cdev,enum led_brightness value)1674faba767SHans de Goede static void shark_led_set_blue(struct led_classdev *led_cdev,
1684faba767SHans de Goede enum led_brightness value)
1694faba767SHans de Goede {
1704faba767SHans de Goede struct shark_device *shark =
1714faba767SHans de Goede container_of(led_cdev, struct shark_device, leds[BLUE_LED]);
1724faba767SHans de Goede
1734faba767SHans de Goede atomic_set(&shark->brightness[BLUE_LED], value);
1744faba767SHans de Goede set_bit(BLUE_LED, &shark->brightness_new);
1754faba767SHans de Goede schedule_work(&shark->led_work);
1764faba767SHans de Goede }
1774faba767SHans de Goede
shark_led_set_red(struct led_classdev * led_cdev,enum led_brightness value)1784faba767SHans de Goede static void shark_led_set_red(struct led_classdev *led_cdev,
1794faba767SHans de Goede enum led_brightness value)
1804faba767SHans de Goede {
1814faba767SHans de Goede struct shark_device *shark =
1824faba767SHans de Goede container_of(led_cdev, struct shark_device, leds[RED_LED]);
1834faba767SHans de Goede
1844faba767SHans de Goede atomic_set(&shark->brightness[RED_LED], value);
1854faba767SHans de Goede set_bit(RED_LED, &shark->brightness_new);
1864faba767SHans de Goede schedule_work(&shark->led_work);
1874faba767SHans de Goede }
1884faba767SHans de Goede
189be0c44fbSHans de Goede static const struct led_classdev shark_led_templates[NO_LEDS] = {
190be0c44fbSHans de Goede [BLUE_LED] = {
191be0c44fbSHans de Goede .name = "%s:blue:",
192be0c44fbSHans de Goede .brightness = LED_OFF,
193be0c44fbSHans de Goede .max_brightness = 127,
194be0c44fbSHans de Goede .brightness_set = shark_led_set_blue,
195be0c44fbSHans de Goede },
196be0c44fbSHans de Goede [RED_LED] = {
197be0c44fbSHans de Goede .name = "%s:red:",
198be0c44fbSHans de Goede .brightness = LED_OFF,
199be0c44fbSHans de Goede .max_brightness = 1,
200be0c44fbSHans de Goede .brightness_set = shark_led_set_red,
201be0c44fbSHans de Goede },
202be0c44fbSHans de Goede };
203be0c44fbSHans de Goede
shark_register_leds(struct shark_device * shark,struct device * dev)204be0c44fbSHans de Goede static int shark_register_leds(struct shark_device *shark, struct device *dev)
205be0c44fbSHans de Goede {
206be0c44fbSHans de Goede int i, retval;
207be0c44fbSHans de Goede
208d1f280d6SHans de Goede atomic_set(&shark->brightness[BLUE_LED], 127);
209be0c44fbSHans de Goede INIT_WORK(&shark->led_work, shark_led_work);
210be0c44fbSHans de Goede for (i = 0; i < NO_LEDS; i++) {
211be0c44fbSHans de Goede shark->leds[i] = shark_led_templates[i];
212be0c44fbSHans de Goede snprintf(shark->led_names[i], sizeof(shark->led_names[0]),
213be0c44fbSHans de Goede shark->leds[i].name, shark->v4l2_dev.name);
214be0c44fbSHans de Goede shark->leds[i].name = shark->led_names[i];
215be0c44fbSHans de Goede retval = led_classdev_register(dev, &shark->leds[i]);
216be0c44fbSHans de Goede if (retval) {
217be0c44fbSHans de Goede v4l2_err(&shark->v4l2_dev,
218be0c44fbSHans de Goede "couldn't register led: %s\n",
219be0c44fbSHans de Goede shark->led_names[i]);
220be0c44fbSHans de Goede return retval;
221be0c44fbSHans de Goede }
222be0c44fbSHans de Goede }
223be0c44fbSHans de Goede return 0;
224be0c44fbSHans de Goede }
225be0c44fbSHans de Goede
shark_unregister_leds(struct shark_device * shark)226be0c44fbSHans de Goede static void shark_unregister_leds(struct shark_device *shark)
227be0c44fbSHans de Goede {
228be0c44fbSHans de Goede int i;
229be0c44fbSHans de Goede
230be0c44fbSHans de Goede for (i = 0; i < NO_LEDS; i++)
231be0c44fbSHans de Goede led_classdev_unregister(&shark->leds[i]);
232be0c44fbSHans de Goede
233be0c44fbSHans de Goede cancel_work_sync(&shark->led_work);
234be0c44fbSHans de Goede }
235d1f280d6SHans de Goede
shark_resume_leds(struct shark_device * shark)236c7223f8fSHans de Goede static inline void shark_resume_leds(struct shark_device *shark)
237d1f280d6SHans de Goede {
238d1f280d6SHans de Goede int i;
239d1f280d6SHans de Goede
240d1f280d6SHans de Goede for (i = 0; i < NO_LEDS; i++)
241d1f280d6SHans de Goede set_bit(i, &shark->brightness_new);
242d1f280d6SHans de Goede
243d1f280d6SHans de Goede schedule_work(&shark->led_work);
244d1f280d6SHans de Goede }
245be0c44fbSHans de Goede #else
shark_register_leds(struct shark_device * shark,struct device * dev)246be0c44fbSHans de Goede static int shark_register_leds(struct shark_device *shark, struct device *dev)
247be0c44fbSHans de Goede {
248be0c44fbSHans de Goede v4l2_warn(&shark->v4l2_dev,
2490bb9121cSPaul Bolle "CONFIG_LEDS_CLASS not enabled, LED support disabled\n");
250be0c44fbSHans de Goede return 0;
251be0c44fbSHans de Goede }
shark_unregister_leds(struct shark_device * shark)252be0c44fbSHans de Goede static inline void shark_unregister_leds(struct shark_device *shark) { }
shark_resume_leds(struct shark_device * shark)253d1f280d6SHans de Goede static inline void shark_resume_leds(struct shark_device *shark) { }
254be0c44fbSHans de Goede #endif
255be0c44fbSHans de Goede
usb_shark_disconnect(struct usb_interface * intf)2564faba767SHans de Goede static void usb_shark_disconnect(struct usb_interface *intf)
2574faba767SHans de Goede {
2584faba767SHans de Goede struct v4l2_device *v4l2_dev = usb_get_intfdata(intf);
2594faba767SHans de Goede struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
2604faba767SHans de Goede
2614faba767SHans de Goede mutex_lock(&shark->tea.mutex);
2624faba767SHans de Goede v4l2_device_disconnect(&shark->v4l2_dev);
2634faba767SHans de Goede radio_tea5777_exit(&shark->tea);
2644faba767SHans de Goede mutex_unlock(&shark->tea.mutex);
2654faba767SHans de Goede
266be0c44fbSHans de Goede shark_unregister_leds(shark);
2674faba767SHans de Goede
2684faba767SHans de Goede v4l2_device_put(&shark->v4l2_dev);
2694faba767SHans de Goede }
2704faba767SHans de Goede
usb_shark_release(struct v4l2_device * v4l2_dev)2714faba767SHans de Goede static void usb_shark_release(struct v4l2_device *v4l2_dev)
2724faba767SHans de Goede {
2734faba767SHans de Goede struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
2744faba767SHans de Goede
2754faba767SHans de Goede v4l2_device_unregister(&shark->v4l2_dev);
2764faba767SHans de Goede kfree(shark->transfer_buffer);
2774faba767SHans de Goede kfree(shark);
2784faba767SHans de Goede }
2794faba767SHans de Goede
usb_shark_probe(struct usb_interface * intf,const struct usb_device_id * id)2804faba767SHans de Goede static int usb_shark_probe(struct usb_interface *intf,
2814faba767SHans de Goede const struct usb_device_id *id)
2824faba767SHans de Goede {
2834faba767SHans de Goede struct shark_device *shark;
284be0c44fbSHans de Goede int retval = -ENOMEM;
28576e31045SAlan Stern static const u8 ep_addresses[] = {
28676e31045SAlan Stern SHARK_IN_EP | USB_DIR_IN,
28776e31045SAlan Stern SHARK_OUT_EP | USB_DIR_OUT,
28876e31045SAlan Stern 0};
28976e31045SAlan Stern
29076e31045SAlan Stern /* Are the expected endpoints present? */
29176e31045SAlan Stern if (!usb_check_int_endpoints(intf, ep_addresses)) {
29276e31045SAlan Stern dev_err(&intf->dev, "Invalid radioSHARK2 device\n");
29376e31045SAlan Stern return -EINVAL;
29476e31045SAlan Stern }
2954faba767SHans de Goede
2964faba767SHans de Goede shark = kzalloc(sizeof(struct shark_device), GFP_KERNEL);
2974faba767SHans de Goede if (!shark)
2984faba767SHans de Goede return retval;
2994faba767SHans de Goede
3004faba767SHans de Goede shark->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);
3014faba767SHans de Goede if (!shark->transfer_buffer)
3024faba767SHans de Goede goto err_alloc_buffer;
3034faba767SHans de Goede
3044faba767SHans de Goede v4l2_device_set_name(&shark->v4l2_dev, DRV_NAME, &shark_instance);
305be0c44fbSHans de Goede
306be0c44fbSHans de Goede retval = shark_register_leds(shark, &intf->dev);
307be0c44fbSHans de Goede if (retval)
308be0c44fbSHans de Goede goto err_reg_leds;
3094faba767SHans de Goede
3104faba767SHans de Goede shark->v4l2_dev.release = usb_shark_release;
3114faba767SHans de Goede retval = v4l2_device_register(&intf->dev, &shark->v4l2_dev);
3124faba767SHans de Goede if (retval) {
3134faba767SHans de Goede v4l2_err(&shark->v4l2_dev, "couldn't register v4l2_device\n");
3144faba767SHans de Goede goto err_reg_dev;
3154faba767SHans de Goede }
3164faba767SHans de Goede
3174faba767SHans de Goede shark->usbdev = interface_to_usbdev(intf);
3184faba767SHans de Goede shark->tea.v4l2_dev = &shark->v4l2_dev;
3194faba767SHans de Goede shark->tea.private_data = shark;
3204faba767SHans de Goede shark->tea.ops = &shark_tea_ops;
3214faba767SHans de Goede shark->tea.has_am = true;
3224faba767SHans de Goede shark->tea.write_before_read = true;
323c0decac1SMauro Carvalho Chehab strscpy(shark->tea.card, "Griffin radioSHARK2",
3244faba767SHans de Goede sizeof(shark->tea.card));
3254faba767SHans de Goede usb_make_path(shark->usbdev, shark->tea.bus_info,
3264faba767SHans de Goede sizeof(shark->tea.bus_info));
3274faba767SHans de Goede
3284faba767SHans de Goede retval = radio_tea5777_init(&shark->tea, THIS_MODULE);
3294faba767SHans de Goede if (retval) {
3304faba767SHans de Goede v4l2_err(&shark->v4l2_dev, "couldn't init tea5777\n");
3314faba767SHans de Goede goto err_init_tea;
3324faba767SHans de Goede }
3334faba767SHans de Goede
3344faba767SHans de Goede return 0;
3354faba767SHans de Goede
3364faba767SHans de Goede err_init_tea:
3374faba767SHans de Goede v4l2_device_unregister(&shark->v4l2_dev);
3384faba767SHans de Goede err_reg_dev:
339be0c44fbSHans de Goede shark_unregister_leds(shark);
340be0c44fbSHans de Goede err_reg_leds:
3414faba767SHans de Goede kfree(shark->transfer_buffer);
3424faba767SHans de Goede err_alloc_buffer:
3434faba767SHans de Goede kfree(shark);
3444faba767SHans de Goede
3454faba767SHans de Goede return retval;
3464faba767SHans de Goede }
3474faba767SHans de Goede
348d1f280d6SHans de Goede #ifdef CONFIG_PM
usb_shark_suspend(struct usb_interface * intf,pm_message_t message)3491f71927eSMauro Carvalho Chehab static int usb_shark_suspend(struct usb_interface *intf, pm_message_t message)
350d1f280d6SHans de Goede {
351d1f280d6SHans de Goede return 0;
352d1f280d6SHans de Goede }
353d1f280d6SHans de Goede
usb_shark_resume(struct usb_interface * intf)3541f71927eSMauro Carvalho Chehab static int usb_shark_resume(struct usb_interface *intf)
355d1f280d6SHans de Goede {
356d1f280d6SHans de Goede struct v4l2_device *v4l2_dev = usb_get_intfdata(intf);
357d1f280d6SHans de Goede struct shark_device *shark = v4l2_dev_to_shark(v4l2_dev);
358d1f280d6SHans de Goede int ret;
359d1f280d6SHans de Goede
360d1f280d6SHans de Goede mutex_lock(&shark->tea.mutex);
361d1f280d6SHans de Goede ret = radio_tea5777_set_freq(&shark->tea);
362d1f280d6SHans de Goede mutex_unlock(&shark->tea.mutex);
363d1f280d6SHans de Goede
364d1f280d6SHans de Goede shark_resume_leds(shark);
365d1f280d6SHans de Goede
366d1f280d6SHans de Goede return ret;
367d1f280d6SHans de Goede }
368d1f280d6SHans de Goede #endif
369d1f280d6SHans de Goede
3704faba767SHans de Goede /* Specify the bcdDevice value, as the radioSHARK and radioSHARK2 share ids */
3711ab2234eSArvind Yadav static const struct usb_device_id usb_shark_device_table[] = {
3724faba767SHans de Goede { .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
3734faba767SHans de Goede USB_DEVICE_ID_MATCH_INT_CLASS,
3744faba767SHans de Goede .idVendor = 0x077d,
3754faba767SHans de Goede .idProduct = 0x627a,
3764faba767SHans de Goede .bcdDevice_lo = 0x0010,
3774faba767SHans de Goede .bcdDevice_hi = 0x0010,
3784faba767SHans de Goede .bInterfaceClass = 3,
3794faba767SHans de Goede },
3804faba767SHans de Goede { }
3814faba767SHans de Goede };
3824faba767SHans de Goede MODULE_DEVICE_TABLE(usb, usb_shark_device_table);
3834faba767SHans de Goede
3844faba767SHans de Goede static struct usb_driver usb_shark_driver = {
3854faba767SHans de Goede .name = DRV_NAME,
3864faba767SHans de Goede .probe = usb_shark_probe,
3874faba767SHans de Goede .disconnect = usb_shark_disconnect,
3884faba767SHans de Goede .id_table = usb_shark_device_table,
389d1f280d6SHans de Goede #ifdef CONFIG_PM
390d1f280d6SHans de Goede .suspend = usb_shark_suspend,
391d1f280d6SHans de Goede .resume = usb_shark_resume,
392d1f280d6SHans de Goede .reset_resume = usb_shark_resume,
393d1f280d6SHans de Goede #endif
3944faba767SHans de Goede };
3954faba767SHans de Goede module_usb_driver(usb_shark_driver);
396