1 /* 2 * Abilis Systems Single DVB-T Receiver 3 * Copyright (C) 2008 Pierrick Hascoet <pierrick.hascoet@abilis.com> 4 * Copyright (C) 2010 Devin Heitmueller <dheitmueller@kernellabs.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2, or (at your option) 9 * any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 */ 16 #include <linux/kernel.h> 17 #include <linux/errno.h> 18 #include <linux/slab.h> 19 #include <linux/mm.h> 20 #include <linux/usb.h> 21 22 #include "as102_drv.h" 23 #include "as102_usb_drv.h" 24 #include "as102_fw.h" 25 26 static void as102_usb_disconnect(struct usb_interface *interface); 27 static int as102_usb_probe(struct usb_interface *interface, 28 const struct usb_device_id *id); 29 30 static int as102_usb_start_stream(struct as102_dev_t *dev); 31 static void as102_usb_stop_stream(struct as102_dev_t *dev); 32 33 static int as102_open(struct inode *inode, struct file *file); 34 static int as102_release(struct inode *inode, struct file *file); 35 36 static struct usb_device_id as102_usb_id_table[] = { 37 { USB_DEVICE(AS102_USB_DEVICE_VENDOR_ID, AS102_USB_DEVICE_PID_0001) }, 38 { USB_DEVICE(PCTV_74E_USB_VID, PCTV_74E_USB_PID) }, 39 { USB_DEVICE(ELGATO_EYETV_DTT_USB_VID, ELGATO_EYETV_DTT_USB_PID) }, 40 { USB_DEVICE(NBOX_DVBT_DONGLE_USB_VID, NBOX_DVBT_DONGLE_USB_PID) }, 41 { USB_DEVICE(SKY_IT_DIGITAL_KEY_USB_VID, SKY_IT_DIGITAL_KEY_USB_PID) }, 42 { } /* Terminating entry */ 43 }; 44 45 /* Note that this table must always have the same number of entries as the 46 as102_usb_id_table struct */ 47 static const char * const as102_device_names[] = { 48 AS102_REFERENCE_DESIGN, 49 AS102_PCTV_74E, 50 AS102_ELGATO_EYETV_DTT_NAME, 51 AS102_NBOX_DVBT_DONGLE_NAME, 52 AS102_SKY_IT_DIGITAL_KEY_NAME, 53 NULL /* Terminating entry */ 54 }; 55 56 /* eLNA configuration: devices built on the reference design work best 57 with 0xA0, while custom designs seem to require 0xC0 */ 58 static uint8_t const as102_elna_cfg[] = { 59 0xA0, 60 0xC0, 61 0xC0, 62 0xA0, 63 0xA0, 64 0x00 /* Terminating entry */ 65 }; 66 67 struct usb_driver as102_usb_driver = { 68 .name = DRIVER_FULL_NAME, 69 .probe = as102_usb_probe, 70 .disconnect = as102_usb_disconnect, 71 .id_table = as102_usb_id_table 72 }; 73 74 static const struct file_operations as102_dev_fops = { 75 .owner = THIS_MODULE, 76 .open = as102_open, 77 .release = as102_release, 78 }; 79 80 static struct usb_class_driver as102_usb_class_driver = { 81 .name = "aton2-%d", 82 .fops = &as102_dev_fops, 83 .minor_base = AS102_DEVICE_MAJOR, 84 }; 85 86 static int as102_usb_xfer_cmd(struct as10x_bus_adapter_t *bus_adap, 87 unsigned char *send_buf, int send_buf_len, 88 unsigned char *recv_buf, int recv_buf_len) 89 { 90 int ret = 0; 91 92 if (send_buf != NULL) { 93 ret = usb_control_msg(bus_adap->usb_dev, 94 usb_sndctrlpipe(bus_adap->usb_dev, 0), 95 AS102_USB_DEVICE_TX_CTRL_CMD, 96 USB_DIR_OUT | USB_TYPE_VENDOR | 97 USB_RECIP_DEVICE, 98 bus_adap->cmd_xid, /* value */ 99 0, /* index */ 100 send_buf, send_buf_len, 101 USB_CTRL_SET_TIMEOUT /* 200 */); 102 if (ret < 0) { 103 dev_dbg(&bus_adap->usb_dev->dev, 104 "usb_control_msg(send) failed, err %i\n", ret); 105 return ret; 106 } 107 108 if (ret != send_buf_len) { 109 dev_dbg(&bus_adap->usb_dev->dev, 110 "only wrote %d of %d bytes\n", ret, send_buf_len); 111 return -1; 112 } 113 } 114 115 if (recv_buf != NULL) { 116 #ifdef TRACE 117 dev_dbg(bus_adap->usb_dev->dev, 118 "want to read: %d bytes\n", recv_buf_len); 119 #endif 120 ret = usb_control_msg(bus_adap->usb_dev, 121 usb_rcvctrlpipe(bus_adap->usb_dev, 0), 122 AS102_USB_DEVICE_RX_CTRL_CMD, 123 USB_DIR_IN | USB_TYPE_VENDOR | 124 USB_RECIP_DEVICE, 125 bus_adap->cmd_xid, /* value */ 126 0, /* index */ 127 recv_buf, recv_buf_len, 128 USB_CTRL_GET_TIMEOUT /* 200 */); 129 if (ret < 0) { 130 dev_dbg(&bus_adap->usb_dev->dev, 131 "usb_control_msg(recv) failed, err %i\n", ret); 132 return ret; 133 } 134 #ifdef TRACE 135 dev_dbg(bus_adap->usb_dev->dev, 136 "read %d bytes\n", recv_buf_len); 137 #endif 138 } 139 140 return ret; 141 } 142 143 static int as102_send_ep1(struct as10x_bus_adapter_t *bus_adap, 144 unsigned char *send_buf, 145 int send_buf_len, 146 int swap32) 147 { 148 int ret, actual_len; 149 150 ret = usb_bulk_msg(bus_adap->usb_dev, 151 usb_sndbulkpipe(bus_adap->usb_dev, 1), 152 send_buf, send_buf_len, &actual_len, 200); 153 if (ret) { 154 dev_dbg(&bus_adap->usb_dev->dev, 155 "usb_bulk_msg(send) failed, err %i\n", ret); 156 return ret; 157 } 158 159 if (actual_len != send_buf_len) { 160 dev_dbg(&bus_adap->usb_dev->dev, "only wrote %d of %d bytes\n", 161 actual_len, send_buf_len); 162 return -1; 163 } 164 return actual_len; 165 } 166 167 static int as102_read_ep2(struct as10x_bus_adapter_t *bus_adap, 168 unsigned char *recv_buf, int recv_buf_len) 169 { 170 int ret, actual_len; 171 172 if (recv_buf == NULL) 173 return -EINVAL; 174 175 ret = usb_bulk_msg(bus_adap->usb_dev, 176 usb_rcvbulkpipe(bus_adap->usb_dev, 2), 177 recv_buf, recv_buf_len, &actual_len, 200); 178 if (ret) { 179 dev_dbg(&bus_adap->usb_dev->dev, 180 "usb_bulk_msg(recv) failed, err %i\n", ret); 181 return ret; 182 } 183 184 if (actual_len != recv_buf_len) { 185 dev_dbg(&bus_adap->usb_dev->dev, "only read %d of %d bytes\n", 186 actual_len, recv_buf_len); 187 return -1; 188 } 189 return actual_len; 190 } 191 192 static struct as102_priv_ops_t as102_priv_ops = { 193 .upload_fw_pkt = as102_send_ep1, 194 .xfer_cmd = as102_usb_xfer_cmd, 195 .as102_read_ep2 = as102_read_ep2, 196 .start_stream = as102_usb_start_stream, 197 .stop_stream = as102_usb_stop_stream, 198 }; 199 200 static int as102_submit_urb_stream(struct as102_dev_t *dev, struct urb *urb) 201 { 202 int err; 203 204 usb_fill_bulk_urb(urb, 205 dev->bus_adap.usb_dev, 206 usb_rcvbulkpipe(dev->bus_adap.usb_dev, 0x2), 207 urb->transfer_buffer, 208 AS102_USB_BUF_SIZE, 209 as102_urb_stream_irq, 210 dev); 211 212 err = usb_submit_urb(urb, GFP_ATOMIC); 213 if (err) 214 dev_dbg(&urb->dev->dev, 215 "%s: usb_submit_urb failed\n", __func__); 216 217 return err; 218 } 219 220 void as102_urb_stream_irq(struct urb *urb) 221 { 222 struct as102_dev_t *as102_dev = urb->context; 223 224 if (urb->actual_length > 0) { 225 dvb_dmx_swfilter(&as102_dev->dvb_dmx, 226 urb->transfer_buffer, 227 urb->actual_length); 228 } else { 229 if (urb->actual_length == 0) 230 memset(urb->transfer_buffer, 0, AS102_USB_BUF_SIZE); 231 } 232 233 /* is not stopped, re-submit urb */ 234 if (as102_dev->streaming) 235 as102_submit_urb_stream(as102_dev, urb); 236 } 237 238 static void as102_free_usb_stream_buffer(struct as102_dev_t *dev) 239 { 240 int i; 241 242 for (i = 0; i < MAX_STREAM_URB; i++) 243 usb_free_urb(dev->stream_urb[i]); 244 245 usb_free_coherent(dev->bus_adap.usb_dev, 246 MAX_STREAM_URB * AS102_USB_BUF_SIZE, 247 dev->stream, 248 dev->dma_addr); 249 } 250 251 static int as102_alloc_usb_stream_buffer(struct as102_dev_t *dev) 252 { 253 int i; 254 255 dev->stream = usb_alloc_coherent(dev->bus_adap.usb_dev, 256 MAX_STREAM_URB * AS102_USB_BUF_SIZE, 257 GFP_KERNEL, 258 &dev->dma_addr); 259 if (!dev->stream) { 260 dev_dbg(&dev->bus_adap.usb_dev->dev, 261 "%s: usb_buffer_alloc failed\n", __func__); 262 return -ENOMEM; 263 } 264 265 memset(dev->stream, 0, MAX_STREAM_URB * AS102_USB_BUF_SIZE); 266 267 /* init urb buffers */ 268 for (i = 0; i < MAX_STREAM_URB; i++) { 269 struct urb *urb; 270 271 urb = usb_alloc_urb(0, GFP_ATOMIC); 272 if (urb == NULL) { 273 dev_dbg(&dev->bus_adap.usb_dev->dev, 274 "%s: usb_alloc_urb failed\n", __func__); 275 as102_free_usb_stream_buffer(dev); 276 return -ENOMEM; 277 } 278 279 urb->transfer_buffer = dev->stream + (i * AS102_USB_BUF_SIZE); 280 urb->transfer_dma = dev->dma_addr + (i * AS102_USB_BUF_SIZE); 281 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 282 urb->transfer_buffer_length = AS102_USB_BUF_SIZE; 283 284 dev->stream_urb[i] = urb; 285 } 286 return 0; 287 } 288 289 static void as102_usb_stop_stream(struct as102_dev_t *dev) 290 { 291 int i; 292 293 for (i = 0; i < MAX_STREAM_URB; i++) 294 usb_kill_urb(dev->stream_urb[i]); 295 } 296 297 static int as102_usb_start_stream(struct as102_dev_t *dev) 298 { 299 int i, ret = 0; 300 301 for (i = 0; i < MAX_STREAM_URB; i++) { 302 ret = as102_submit_urb_stream(dev, dev->stream_urb[i]); 303 if (ret) { 304 as102_usb_stop_stream(dev); 305 return ret; 306 } 307 } 308 309 return 0; 310 } 311 312 static void as102_usb_release(struct kref *kref) 313 { 314 struct as102_dev_t *as102_dev; 315 316 as102_dev = container_of(kref, struct as102_dev_t, kref); 317 if (as102_dev != NULL) { 318 usb_put_dev(as102_dev->bus_adap.usb_dev); 319 kfree(as102_dev); 320 } 321 } 322 323 static void as102_usb_disconnect(struct usb_interface *intf) 324 { 325 struct as102_dev_t *as102_dev; 326 327 /* extract as102_dev_t from usb_device private data */ 328 as102_dev = usb_get_intfdata(intf); 329 330 /* unregister dvb layer */ 331 as102_dvb_unregister(as102_dev); 332 333 /* free usb buffers */ 334 as102_free_usb_stream_buffer(as102_dev); 335 336 usb_set_intfdata(intf, NULL); 337 338 /* usb unregister device */ 339 usb_deregister_dev(intf, &as102_usb_class_driver); 340 341 /* decrement usage counter */ 342 kref_put(&as102_dev->kref, as102_usb_release); 343 344 pr_info("%s: device has been disconnected\n", DRIVER_NAME); 345 } 346 347 static int as102_usb_probe(struct usb_interface *intf, 348 const struct usb_device_id *id) 349 { 350 int ret; 351 struct as102_dev_t *as102_dev; 352 int i; 353 354 /* This should never actually happen */ 355 if (ARRAY_SIZE(as102_usb_id_table) != 356 (sizeof(as102_device_names) / sizeof(const char *))) { 357 pr_err("Device names table invalid size"); 358 return -EINVAL; 359 } 360 361 as102_dev = kzalloc(sizeof(struct as102_dev_t), GFP_KERNEL); 362 if (as102_dev == NULL) 363 return -ENOMEM; 364 365 /* Assign the user-friendly device name */ 366 for (i = 0; i < ARRAY_SIZE(as102_usb_id_table); i++) { 367 if (id == &as102_usb_id_table[i]) { 368 as102_dev->name = as102_device_names[i]; 369 as102_dev->elna_cfg = as102_elna_cfg[i]; 370 } 371 } 372 373 if (as102_dev->name == NULL) 374 as102_dev->name = "Unknown AS102 device"; 375 376 /* set private callback functions */ 377 as102_dev->bus_adap.ops = &as102_priv_ops; 378 379 /* init cmd token for usb bus */ 380 as102_dev->bus_adap.cmd = &as102_dev->bus_adap.token.usb.c; 381 as102_dev->bus_adap.rsp = &as102_dev->bus_adap.token.usb.r; 382 383 /* init kernel device reference */ 384 kref_init(&as102_dev->kref); 385 386 /* store as102 device to usb_device private data */ 387 usb_set_intfdata(intf, (void *) as102_dev); 388 389 /* store in as102 device the usb_device pointer */ 390 as102_dev->bus_adap.usb_dev = usb_get_dev(interface_to_usbdev(intf)); 391 392 /* we can register the device now, as it is ready */ 393 ret = usb_register_dev(intf, &as102_usb_class_driver); 394 if (ret < 0) { 395 /* something prevented us from registering this driver */ 396 dev_err(&intf->dev, 397 "%s: usb_register_dev() failed (errno = %d)\n", 398 __func__, ret); 399 goto failed; 400 } 401 402 pr_info("%s: device has been detected\n", DRIVER_NAME); 403 404 /* request buffer allocation for streaming */ 405 ret = as102_alloc_usb_stream_buffer(as102_dev); 406 if (ret != 0) 407 goto failed_stream; 408 409 /* register dvb layer */ 410 ret = as102_dvb_register(as102_dev); 411 if (ret != 0) 412 goto failed_dvb; 413 414 return ret; 415 416 failed_dvb: 417 as102_free_usb_stream_buffer(as102_dev); 418 failed_stream: 419 usb_deregister_dev(intf, &as102_usb_class_driver); 420 failed: 421 usb_put_dev(as102_dev->bus_adap.usb_dev); 422 usb_set_intfdata(intf, NULL); 423 kfree(as102_dev); 424 return ret; 425 } 426 427 static int as102_open(struct inode *inode, struct file *file) 428 { 429 int ret = 0, minor = 0; 430 struct usb_interface *intf = NULL; 431 struct as102_dev_t *dev = NULL; 432 433 /* read minor from inode */ 434 minor = iminor(inode); 435 436 /* fetch device from usb interface */ 437 intf = usb_find_interface(&as102_usb_driver, minor); 438 if (intf == NULL) { 439 pr_err("%s: can't find device for minor %d\n", 440 __func__, minor); 441 ret = -ENODEV; 442 goto exit; 443 } 444 445 /* get our device */ 446 dev = usb_get_intfdata(intf); 447 if (dev == NULL) { 448 ret = -EFAULT; 449 goto exit; 450 } 451 452 /* save our device object in the file's private structure */ 453 file->private_data = dev; 454 455 /* increment our usage count for the device */ 456 kref_get(&dev->kref); 457 458 exit: 459 return ret; 460 } 461 462 static int as102_release(struct inode *inode, struct file *file) 463 { 464 struct as102_dev_t *dev = NULL; 465 466 dev = file->private_data; 467 if (dev != NULL) { 468 /* decrement the count on our device */ 469 kref_put(&dev->kref, as102_usb_release); 470 } 471 472 return 0; 473 } 474 475 MODULE_DEVICE_TABLE(usb, as102_usb_id_table); 476