aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media
diff options
context:
space:
mode:
authorAntti Palosaari <crope@iki.fi>2014-12-15 12:30:02 -0500
committerMauro Carvalho Chehab <mchehab@osg.samsung.com>2015-02-03 13:13:17 -0500
commit725b7f30463ab54b453a7113e7fb7148cfe636a2 (patch)
treee3ba4b255f8f340ee99a902fcd4b8ad0de933f98 /drivers/media
parent0aa32ef9b38f9683b4ddaab9ac9bee8f75d872d2 (diff)
[media] rtl2832_sdr: rename state variable from 's' to 'dev'
'dev' sounds better than 's' for such variable. Signed-off-by: Antti Palosaari <crope@iki.fi> Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
Diffstat (limited to 'drivers/media')
-rw-r--r--drivers/media/dvb-frontends/rtl2832_sdr.c858
1 files changed, 429 insertions, 429 deletions
diff --git a/drivers/media/dvb-frontends/rtl2832_sdr.c b/drivers/media/dvb-frontends/rtl2832_sdr.c
index 2896b47c29d8..3af869c5497d 100644
--- a/drivers/media/dvb-frontends/rtl2832_sdr.c
+++ b/drivers/media/dvb-frontends/rtl2832_sdr.c
@@ -107,7 +107,7 @@ struct rtl2832_sdr_frame_buf {
107 struct list_head list; 107 struct list_head list;
108}; 108};
109 109
110struct rtl2832_sdr_state { 110struct rtl2832_sdr_dev {
111#define POWER_ON (1 << 1) 111#define POWER_ON (1 << 1)
112#define URB_BUF (1 << 2) 112#define URB_BUF (1 << 2)
113 unsigned long flags; 113 unsigned long flags;
@@ -161,7 +161,7 @@ struct rtl2832_sdr_state {
161}; 161};
162 162
163/* write multiple hardware registers */ 163/* write multiple hardware registers */
164static int rtl2832_sdr_wr(struct rtl2832_sdr_state *s, u8 reg, const u8 *val, 164static int rtl2832_sdr_wr(struct rtl2832_sdr_dev *dev, u8 reg, const u8 *val,
165 int len) 165 int len)
166{ 166{
167 int ret; 167 int ret;
@@ -170,7 +170,7 @@ static int rtl2832_sdr_wr(struct rtl2832_sdr_state *s, u8 reg, const u8 *val,
170 u8 buf[MAX_WR_XFER_LEN]; 170 u8 buf[MAX_WR_XFER_LEN];
171 struct i2c_msg msg[1] = { 171 struct i2c_msg msg[1] = {
172 { 172 {
173 .addr = s->cfg->i2c_addr, 173 .addr = dev->cfg->i2c_addr,
174 .flags = 0, 174 .flags = 0,
175 .len = 1 + len, 175 .len = 1 + len,
176 .buf = buf, 176 .buf = buf,
@@ -183,11 +183,11 @@ static int rtl2832_sdr_wr(struct rtl2832_sdr_state *s, u8 reg, const u8 *val,
183 buf[0] = reg; 183 buf[0] = reg;
184 memcpy(&buf[1], val, len); 184 memcpy(&buf[1], val, len);
185 185
186 ret = i2c_transfer(s->i2c, msg, 1); 186 ret = i2c_transfer(dev->i2c, msg, 1);
187 if (ret == 1) { 187 if (ret == 1) {
188 ret = 0; 188 ret = 0;
189 } else { 189 } else {
190 dev_err(&s->i2c->dev, 190 dev_err(&dev->i2c->dev,
191 "%s: I2C wr failed=%d reg=%02x len=%d\n", 191 "%s: I2C wr failed=%d reg=%02x len=%d\n",
192 KBUILD_MODNAME, ret, reg, len); 192 KBUILD_MODNAME, ret, reg, len);
193 ret = -EREMOTEIO; 193 ret = -EREMOTEIO;
@@ -196,28 +196,28 @@ static int rtl2832_sdr_wr(struct rtl2832_sdr_state *s, u8 reg, const u8 *val,
196} 196}
197 197
198/* read multiple hardware registers */ 198/* read multiple hardware registers */
199static int rtl2832_sdr_rd(struct rtl2832_sdr_state *s, u8 reg, u8 *val, int len) 199static int rtl2832_sdr_rd(struct rtl2832_sdr_dev *dev, u8 reg, u8 *val, int len)
200{ 200{
201 int ret; 201 int ret;
202 struct i2c_msg msg[2] = { 202 struct i2c_msg msg[2] = {
203 { 203 {
204 .addr = s->cfg->i2c_addr, 204 .addr = dev->cfg->i2c_addr,
205 .flags = 0, 205 .flags = 0,
206 .len = 1, 206 .len = 1,
207 .buf = &reg, 207 .buf = &reg,
208 }, { 208 }, {
209 .addr = s->cfg->i2c_addr, 209 .addr = dev->cfg->i2c_addr,
210 .flags = I2C_M_RD, 210 .flags = I2C_M_RD,
211 .len = len, 211 .len = len,
212 .buf = val, 212 .buf = val,
213 } 213 }
214 }; 214 };
215 215
216 ret = i2c_transfer(s->i2c, msg, 2); 216 ret = i2c_transfer(dev->i2c, msg, 2);
217 if (ret == 2) { 217 if (ret == 2) {
218 ret = 0; 218 ret = 0;
219 } else { 219 } else {
220 dev_err(&s->i2c->dev, 220 dev_err(&dev->i2c->dev,
221 "%s: I2C rd failed=%d reg=%02x len=%d\n", 221 "%s: I2C rd failed=%d reg=%02x len=%d\n",
222 KBUILD_MODNAME, ret, reg, len); 222 KBUILD_MODNAME, ret, reg, len);
223 ret = -EREMOTEIO; 223 ret = -EREMOTEIO;
@@ -226,7 +226,7 @@ static int rtl2832_sdr_rd(struct rtl2832_sdr_state *s, u8 reg, u8 *val, int len)
226} 226}
227 227
228/* write multiple registers */ 228/* write multiple registers */
229static int rtl2832_sdr_wr_regs(struct rtl2832_sdr_state *s, u16 reg, 229static int rtl2832_sdr_wr_regs(struct rtl2832_sdr_dev *dev, u16 reg,
230 const u8 *val, int len) 230 const u8 *val, int len)
231{ 231{
232 int ret; 232 int ret;
@@ -234,19 +234,19 @@ static int rtl2832_sdr_wr_regs(struct rtl2832_sdr_state *s, u16 reg,
234 u8 bank = (reg >> 8) & 0xff; 234 u8 bank = (reg >> 8) & 0xff;
235 235
236 /* switch bank if needed */ 236 /* switch bank if needed */
237 if (bank != s->bank) { 237 if (bank != dev->bank) {
238 ret = rtl2832_sdr_wr(s, 0x00, &bank, 1); 238 ret = rtl2832_sdr_wr(dev, 0x00, &bank, 1);
239 if (ret) 239 if (ret)
240 return ret; 240 return ret;
241 241
242 s->bank = bank; 242 dev->bank = bank;
243 } 243 }
244 244
245 return rtl2832_sdr_wr(s, reg2, val, len); 245 return rtl2832_sdr_wr(dev, reg2, val, len);
246} 246}
247 247
248/* read multiple registers */ 248/* read multiple registers */
249static int rtl2832_sdr_rd_regs(struct rtl2832_sdr_state *s, u16 reg, u8 *val, 249static int rtl2832_sdr_rd_regs(struct rtl2832_sdr_dev *dev, u16 reg, u8 *val,
250 int len) 250 int len)
251{ 251{
252 int ret; 252 int ret;
@@ -254,33 +254,33 @@ static int rtl2832_sdr_rd_regs(struct rtl2832_sdr_state *s, u16 reg, u8 *val,
254 u8 bank = (reg >> 8) & 0xff; 254 u8 bank = (reg >> 8) & 0xff;
255 255
256 /* switch bank if needed */ 256 /* switch bank if needed */
257 if (bank != s->bank) { 257 if (bank != dev->bank) {
258 ret = rtl2832_sdr_wr(s, 0x00, &bank, 1); 258 ret = rtl2832_sdr_wr(dev, 0x00, &bank, 1);
259 if (ret) 259 if (ret)
260 return ret; 260 return ret;
261 261
262 s->bank = bank; 262 dev->bank = bank;
263 } 263 }
264 264
265 return rtl2832_sdr_rd(s, reg2, val, len); 265 return rtl2832_sdr_rd(dev, reg2, val, len);
266} 266}
267 267
268/* write single register */ 268/* write single register */
269static int rtl2832_sdr_wr_reg(struct rtl2832_sdr_state *s, u16 reg, u8 val) 269static int rtl2832_sdr_wr_reg(struct rtl2832_sdr_dev *dev, u16 reg, u8 val)
270{ 270{
271 return rtl2832_sdr_wr_regs(s, reg, &val, 1); 271 return rtl2832_sdr_wr_regs(dev, reg, &val, 1);
272} 272}
273 273
274#if 0 274#if 0
275/* read single register */ 275/* read single register */
276static int rtl2832_sdr_rd_reg(struct rtl2832_sdr_state *s, u16 reg, u8 *val) 276static int rtl2832_sdr_rd_reg(struct rtl2832_sdr_dev *dev, u16 reg, u8 *val)
277{ 277{
278 return rtl2832_sdr_rd_regs(s, reg, val, 1); 278 return rtl2832_sdr_rd_regs(dev, reg, val, 1);
279} 279}
280#endif 280#endif
281 281
282/* write single register with mask */ 282/* write single register with mask */
283static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_state *s, u16 reg, 283static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_dev *dev, u16 reg,
284 u8 val, u8 mask) 284 u8 val, u8 mask)
285{ 285{
286 int ret; 286 int ret;
@@ -288,7 +288,7 @@ static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_state *s, u16 reg,
288 288
289 /* no need for read if whole reg is written */ 289 /* no need for read if whole reg is written */
290 if (mask != 0xff) { 290 if (mask != 0xff) {
291 ret = rtl2832_sdr_rd_regs(s, reg, &tmp, 1); 291 ret = rtl2832_sdr_rd_regs(dev, reg, &tmp, 1);
292 if (ret) 292 if (ret)
293 return ret; 293 return ret;
294 294
@@ -297,18 +297,18 @@ static int rtl2832_sdr_wr_reg_mask(struct rtl2832_sdr_state *s, u16 reg,
297 val |= tmp; 297 val |= tmp;
298 } 298 }
299 299
300 return rtl2832_sdr_wr_regs(s, reg, &val, 1); 300 return rtl2832_sdr_wr_regs(dev, reg, &val, 1);
301} 301}
302 302
303#if 0 303#if 0
304/* read single register with mask */ 304/* read single register with mask */
305static int rtl2832_sdr_rd_reg_mask(struct rtl2832_sdr_state *s, u16 reg, 305static int rtl2832_sdr_rd_reg_mask(struct rtl2832_sdr_dev *dev, u16 reg,
306 u8 *val, u8 mask) 306 u8 *val, u8 mask)
307{ 307{
308 int ret, i; 308 int ret, i;
309 u8 tmp; 309 u8 tmp;
310 310
311 ret = rtl2832_sdr_rd_regs(s, reg, &tmp, 1); 311 ret = rtl2832_sdr_rd_regs(dev, reg, &tmp, 1);
312 if (ret) 312 if (ret)
313 return ret; 313 return ret;
314 314
@@ -327,33 +327,33 @@ static int rtl2832_sdr_rd_reg_mask(struct rtl2832_sdr_state *s, u16 reg,
327 327
328/* Private functions */ 328/* Private functions */
329static struct rtl2832_sdr_frame_buf *rtl2832_sdr_get_next_fill_buf( 329static struct rtl2832_sdr_frame_buf *rtl2832_sdr_get_next_fill_buf(
330 struct rtl2832_sdr_state *s) 330 struct rtl2832_sdr_dev *dev)
331{ 331{
332 unsigned long flags; 332 unsigned long flags;
333 struct rtl2832_sdr_frame_buf *buf = NULL; 333 struct rtl2832_sdr_frame_buf *buf = NULL;
334 334
335 spin_lock_irqsave(&s->queued_bufs_lock, flags); 335 spin_lock_irqsave(&dev->queued_bufs_lock, flags);
336 if (list_empty(&s->queued_bufs)) 336 if (list_empty(&dev->queued_bufs))
337 goto leave; 337 goto leave;
338 338
339 buf = list_entry(s->queued_bufs.next, 339 buf = list_entry(dev->queued_bufs.next,
340 struct rtl2832_sdr_frame_buf, list); 340 struct rtl2832_sdr_frame_buf, list);
341 list_del(&buf->list); 341 list_del(&buf->list);
342leave: 342leave:
343 spin_unlock_irqrestore(&s->queued_bufs_lock, flags); 343 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
344 return buf; 344 return buf;
345} 345}
346 346
347static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_state *s, 347static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_dev *dev,
348 void *dst, const u8 *src, unsigned int src_len) 348 void *dst, const u8 *src, unsigned int src_len)
349{ 349{
350 unsigned int dst_len; 350 unsigned int dst_len;
351 351
352 if (s->pixelformat == V4L2_SDR_FMT_CU8) { 352 if (dev->pixelformat == V4L2_SDR_FMT_CU8) {
353 /* native stream, no need to convert */ 353 /* native stream, no need to convert */
354 memcpy(dst, src, src_len); 354 memcpy(dst, src, src_len);
355 dst_len = src_len; 355 dst_len = src_len;
356 } else if (s->pixelformat == V4L2_SDR_FMT_CU16LE) { 356 } else if (dev->pixelformat == V4L2_SDR_FMT_CU16LE) {
357 /* convert u8 to u16 */ 357 /* convert u8 to u16 */
358 unsigned int i; 358 unsigned int i;
359 u16 *u16dst = dst; 359 u16 *u16dst = dst;
@@ -366,22 +366,22 @@ static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_state *s,
366 } 366 }
367 367
368 /* calculate sample rate and output it in 10 seconds intervals */ 368 /* calculate sample rate and output it in 10 seconds intervals */
369 if (unlikely(time_is_before_jiffies(s->jiffies_next))) { 369 if (unlikely(time_is_before_jiffies(dev->jiffies_next))) {
370 #define MSECS 10000UL 370 #define MSECS 10000UL
371 unsigned int msecs = jiffies_to_msecs(jiffies - 371 unsigned int msecs = jiffies_to_msecs(jiffies -
372 s->jiffies_next + msecs_to_jiffies(MSECS)); 372 dev->jiffies_next + msecs_to_jiffies(MSECS));
373 unsigned int samples = s->sample - s->sample_measured; 373 unsigned int samples = dev->sample - dev->sample_measured;
374 374
375 s->jiffies_next = jiffies + msecs_to_jiffies(MSECS); 375 dev->jiffies_next = jiffies + msecs_to_jiffies(MSECS);
376 s->sample_measured = s->sample; 376 dev->sample_measured = dev->sample;
377 dev_dbg(&s->udev->dev, 377 dev_dbg(&dev->udev->dev,
378 "slen=%u samples=%u msecs=%u sample rate=%lu\n", 378 "slen=%u samples=%u msecs=%u sample rate=%lu\n",
379 src_len, samples, msecs, 379 src_len, samples, msecs,
380 samples * 1000UL / msecs); 380 samples * 1000UL / msecs);
381 } 381 }
382 382
383 /* total number of I+Q pairs */ 383 /* total number of I+Q pairs */
384 s->sample += src_len / 2; 384 dev->sample += src_len / 2;
385 385
386 return dst_len; 386 return dst_len;
387} 387}
@@ -392,10 +392,10 @@ static unsigned int rtl2832_sdr_convert_stream(struct rtl2832_sdr_state *s,
392 */ 392 */
393static void rtl2832_sdr_urb_complete(struct urb *urb) 393static void rtl2832_sdr_urb_complete(struct urb *urb)
394{ 394{
395 struct rtl2832_sdr_state *s = urb->context; 395 struct rtl2832_sdr_dev *dev = urb->context;
396 struct rtl2832_sdr_frame_buf *fbuf; 396 struct rtl2832_sdr_frame_buf *fbuf;
397 397
398 dev_dbg_ratelimited(&s->udev->dev, 398 dev_dbg_ratelimited(&dev->udev->dev,
399 "status=%d length=%d/%d errors=%d\n", 399 "status=%d length=%d/%d errors=%d\n",
400 urb->status, urb->actual_length, 400 urb->status, urb->actual_length,
401 urb->transfer_buffer_length, urb->error_count); 401 urb->transfer_buffer_length, urb->error_count);
@@ -409,7 +409,7 @@ static void rtl2832_sdr_urb_complete(struct urb *urb)
409 case -ESHUTDOWN: 409 case -ESHUTDOWN:
410 return; 410 return;
411 default: /* error */ 411 default: /* error */
412 dev_err_ratelimited(&s->udev->dev, "urb failed=%d\n", 412 dev_err_ratelimited(&dev->udev->dev, "urb failed=%d\n",
413 urb->status); 413 urb->status);
414 break; 414 break;
415 } 415 }
@@ -418,190 +418,190 @@ static void rtl2832_sdr_urb_complete(struct urb *urb)
418 void *ptr; 418 void *ptr;
419 unsigned int len; 419 unsigned int len;
420 /* get free framebuffer */ 420 /* get free framebuffer */
421 fbuf = rtl2832_sdr_get_next_fill_buf(s); 421 fbuf = rtl2832_sdr_get_next_fill_buf(dev);
422 if (unlikely(fbuf == NULL)) { 422 if (unlikely(fbuf == NULL)) {
423 s->vb_full++; 423 dev->vb_full++;
424 dev_notice_ratelimited(&s->udev->dev, 424 dev_notice_ratelimited(&dev->udev->dev,
425 "videobuf is full, %d packets dropped\n", 425 "videobuf is full, %d packets dropped\n",
426 s->vb_full); 426 dev->vb_full);
427 goto skip; 427 goto skip;
428 } 428 }
429 429
430 /* fill framebuffer */ 430 /* fill framebuffer */
431 ptr = vb2_plane_vaddr(&fbuf->vb, 0); 431 ptr = vb2_plane_vaddr(&fbuf->vb, 0);
432 len = rtl2832_sdr_convert_stream(s, ptr, urb->transfer_buffer, 432 len = rtl2832_sdr_convert_stream(dev, ptr, urb->transfer_buffer,
433 urb->actual_length); 433 urb->actual_length);
434 vb2_set_plane_payload(&fbuf->vb, 0, len); 434 vb2_set_plane_payload(&fbuf->vb, 0, len);
435 v4l2_get_timestamp(&fbuf->vb.v4l2_buf.timestamp); 435 v4l2_get_timestamp(&fbuf->vb.v4l2_buf.timestamp);
436 fbuf->vb.v4l2_buf.sequence = s->sequence++; 436 fbuf->vb.v4l2_buf.sequence = dev->sequence++;
437 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE); 437 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
438 } 438 }
439skip: 439skip:
440 usb_submit_urb(urb, GFP_ATOMIC); 440 usb_submit_urb(urb, GFP_ATOMIC);
441} 441}
442 442
443static int rtl2832_sdr_kill_urbs(struct rtl2832_sdr_state *s) 443static int rtl2832_sdr_kill_urbs(struct rtl2832_sdr_dev *dev)
444{ 444{
445 int i; 445 int i;
446 446
447 for (i = s->urbs_submitted - 1; i >= 0; i--) { 447 for (i = dev->urbs_submitted - 1; i >= 0; i--) {
448 dev_dbg(&s->udev->dev, "kill urb=%d\n", i); 448 dev_dbg(&dev->udev->dev, "kill urb=%d\n", i);
449 /* stop the URB */ 449 /* stop the URB */
450 usb_kill_urb(s->urb_list[i]); 450 usb_kill_urb(dev->urb_list[i]);
451 } 451 }
452 s->urbs_submitted = 0; 452 dev->urbs_submitted = 0;
453 453
454 return 0; 454 return 0;
455} 455}
456 456
457static int rtl2832_sdr_submit_urbs(struct rtl2832_sdr_state *s) 457static int rtl2832_sdr_submit_urbs(struct rtl2832_sdr_dev *dev)
458{ 458{
459 int i, ret; 459 int i, ret;
460 460
461 for (i = 0; i < s->urbs_initialized; i++) { 461 for (i = 0; i < dev->urbs_initialized; i++) {
462 dev_dbg(&s->udev->dev, "submit urb=%d\n", i); 462 dev_dbg(&dev->udev->dev, "submit urb=%d\n", i);
463 ret = usb_submit_urb(s->urb_list[i], GFP_ATOMIC); 463 ret = usb_submit_urb(dev->urb_list[i], GFP_ATOMIC);
464 if (ret) { 464 if (ret) {
465 dev_err(&s->udev->dev, 465 dev_err(&dev->udev->dev,
466 "Could not submit urb no. %d - get them all back\n", 466 "Could not submit urb no. %d - get them all back\n",
467 i); 467 i);
468 rtl2832_sdr_kill_urbs(s); 468 rtl2832_sdr_kill_urbs(dev);
469 return ret; 469 return ret;
470 } 470 }
471 s->urbs_submitted++; 471 dev->urbs_submitted++;
472 } 472 }
473 473
474 return 0; 474 return 0;
475} 475}
476 476
477static int rtl2832_sdr_free_stream_bufs(struct rtl2832_sdr_state *s) 477static int rtl2832_sdr_free_stream_bufs(struct rtl2832_sdr_dev *dev)
478{ 478{
479 if (s->flags & USB_STATE_URB_BUF) { 479 if (dev->flags & USB_STATE_URB_BUF) {
480 while (s->buf_num) { 480 while (dev->buf_num) {
481 s->buf_num--; 481 dev->buf_num--;
482 dev_dbg(&s->udev->dev, "free buf=%d\n", s->buf_num); 482 dev_dbg(&dev->udev->dev, "free buf=%d\n", dev->buf_num);
483 usb_free_coherent(s->udev, s->buf_size, 483 usb_free_coherent(dev->udev, dev->buf_size,
484 s->buf_list[s->buf_num], 484 dev->buf_list[dev->buf_num],
485 s->dma_addr[s->buf_num]); 485 dev->dma_addr[dev->buf_num]);
486 } 486 }
487 } 487 }
488 s->flags &= ~USB_STATE_URB_BUF; 488 dev->flags &= ~USB_STATE_URB_BUF;
489 489
490 return 0; 490 return 0;
491} 491}
492 492
493static int rtl2832_sdr_alloc_stream_bufs(struct rtl2832_sdr_state *s) 493static int rtl2832_sdr_alloc_stream_bufs(struct rtl2832_sdr_dev *dev)
494{ 494{
495 s->buf_num = 0; 495 dev->buf_num = 0;
496 s->buf_size = BULK_BUFFER_SIZE; 496 dev->buf_size = BULK_BUFFER_SIZE;
497 497
498 dev_dbg(&s->udev->dev, "all in all I will use %u bytes for streaming\n", 498 dev_dbg(&dev->udev->dev, "all in all I will use %u bytes for streaming\n",
499 MAX_BULK_BUFS * BULK_BUFFER_SIZE); 499 MAX_BULK_BUFS * BULK_BUFFER_SIZE);
500 500
501 for (s->buf_num = 0; s->buf_num < MAX_BULK_BUFS; s->buf_num++) { 501 for (dev->buf_num = 0; dev->buf_num < MAX_BULK_BUFS; dev->buf_num++) {
502 s->buf_list[s->buf_num] = usb_alloc_coherent(s->udev, 502 dev->buf_list[dev->buf_num] = usb_alloc_coherent(dev->udev,
503 BULK_BUFFER_SIZE, GFP_ATOMIC, 503 BULK_BUFFER_SIZE, GFP_ATOMIC,
504 &s->dma_addr[s->buf_num]); 504 &dev->dma_addr[dev->buf_num]);
505 if (!s->buf_list[s->buf_num]) { 505 if (!dev->buf_list[dev->buf_num]) {
506 dev_dbg(&s->udev->dev, "alloc buf=%d failed\n", 506 dev_dbg(&dev->udev->dev, "alloc buf=%d failed\n",
507 s->buf_num); 507 dev->buf_num);
508 rtl2832_sdr_free_stream_bufs(s); 508 rtl2832_sdr_free_stream_bufs(dev);
509 return -ENOMEM; 509 return -ENOMEM;
510 } 510 }
511 511
512 dev_dbg(&s->udev->dev, "alloc buf=%d %p (dma %llu)\n", 512 dev_dbg(&dev->udev->dev, "alloc buf=%d %p (dma %llu)\n",
513 s->buf_num, s->buf_list[s->buf_num], 513 dev->buf_num, dev->buf_list[dev->buf_num],
514 (long long)s->dma_addr[s->buf_num]); 514 (long long)dev->dma_addr[dev->buf_num]);
515 s->flags |= USB_STATE_URB_BUF; 515 dev->flags |= USB_STATE_URB_BUF;
516 } 516 }
517 517
518 return 0; 518 return 0;
519} 519}
520 520
521static int rtl2832_sdr_free_urbs(struct rtl2832_sdr_state *s) 521static int rtl2832_sdr_free_urbs(struct rtl2832_sdr_dev *dev)
522{ 522{
523 int i; 523 int i;
524 524
525 rtl2832_sdr_kill_urbs(s); 525 rtl2832_sdr_kill_urbs(dev);
526 526
527 for (i = s->urbs_initialized - 1; i >= 0; i--) { 527 for (i = dev->urbs_initialized - 1; i >= 0; i--) {
528 if (s->urb_list[i]) { 528 if (dev->urb_list[i]) {
529 dev_dbg(&s->udev->dev, "free urb=%d\n", i); 529 dev_dbg(&dev->udev->dev, "free urb=%d\n", i);
530 /* free the URBs */ 530 /* free the URBs */
531 usb_free_urb(s->urb_list[i]); 531 usb_free_urb(dev->urb_list[i]);
532 } 532 }
533 } 533 }
534 s->urbs_initialized = 0; 534 dev->urbs_initialized = 0;
535 535
536 return 0; 536 return 0;
537} 537}
538 538
539static int rtl2832_sdr_alloc_urbs(struct rtl2832_sdr_state *s) 539static int rtl2832_sdr_alloc_urbs(struct rtl2832_sdr_dev *dev)
540{ 540{
541 int i, j; 541 int i, j;
542 542
543 /* allocate the URBs */ 543 /* allocate the URBs */
544 for (i = 0; i < MAX_BULK_BUFS; i++) { 544 for (i = 0; i < MAX_BULK_BUFS; i++) {
545 dev_dbg(&s->udev->dev, "alloc urb=%d\n", i); 545 dev_dbg(&dev->udev->dev, "alloc urb=%d\n", i);
546 s->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC); 546 dev->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
547 if (!s->urb_list[i]) { 547 if (!dev->urb_list[i]) {
548 dev_dbg(&s->udev->dev, "failed\n"); 548 dev_dbg(&dev->udev->dev, "failed\n");
549 for (j = 0; j < i; j++) 549 for (j = 0; j < i; j++)
550 usb_free_urb(s->urb_list[j]); 550 usb_free_urb(dev->urb_list[j]);
551 return -ENOMEM; 551 return -ENOMEM;
552 } 552 }
553 usb_fill_bulk_urb(s->urb_list[i], 553 usb_fill_bulk_urb(dev->urb_list[i],
554 s->udev, 554 dev->udev,
555 usb_rcvbulkpipe(s->udev, 0x81), 555 usb_rcvbulkpipe(dev->udev, 0x81),
556 s->buf_list[i], 556 dev->buf_list[i],
557 BULK_BUFFER_SIZE, 557 BULK_BUFFER_SIZE,
558 rtl2832_sdr_urb_complete, s); 558 rtl2832_sdr_urb_complete, dev);
559 559
560 s->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 560 dev->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
561 s->urb_list[i]->transfer_dma = s->dma_addr[i]; 561 dev->urb_list[i]->transfer_dma = dev->dma_addr[i];
562 s->urbs_initialized++; 562 dev->urbs_initialized++;
563 } 563 }
564 564
565 return 0; 565 return 0;
566} 566}
567 567
568/* Must be called with vb_queue_lock hold */ 568/* Must be called with vb_queue_lock hold */
569static void rtl2832_sdr_cleanup_queued_bufs(struct rtl2832_sdr_state *s) 569static void rtl2832_sdr_cleanup_queued_bufs(struct rtl2832_sdr_dev *dev)
570{ 570{
571 unsigned long flags; 571 unsigned long flags;
572 572
573 dev_dbg(&s->udev->dev, "\n"); 573 dev_dbg(&dev->udev->dev, "\n");
574 574
575 spin_lock_irqsave(&s->queued_bufs_lock, flags); 575 spin_lock_irqsave(&dev->queued_bufs_lock, flags);
576 while (!list_empty(&s->queued_bufs)) { 576 while (!list_empty(&dev->queued_bufs)) {
577 struct rtl2832_sdr_frame_buf *buf; 577 struct rtl2832_sdr_frame_buf *buf;
578 578
579 buf = list_entry(s->queued_bufs.next, 579 buf = list_entry(dev->queued_bufs.next,
580 struct rtl2832_sdr_frame_buf, list); 580 struct rtl2832_sdr_frame_buf, list);
581 list_del(&buf->list); 581 list_del(&buf->list);
582 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 582 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
583 } 583 }
584 spin_unlock_irqrestore(&s->queued_bufs_lock, flags); 584 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
585} 585}
586 586
587/* The user yanked out the cable... */ 587/* The user yanked out the cable... */
588static void rtl2832_sdr_release_sec(struct dvb_frontend *fe) 588static void rtl2832_sdr_release_sec(struct dvb_frontend *fe)
589{ 589{
590 struct rtl2832_sdr_state *s = fe->sec_priv; 590 struct rtl2832_sdr_dev *dev = fe->sec_priv;
591 591
592 dev_dbg(&s->udev->dev, "\n"); 592 dev_dbg(&dev->udev->dev, "\n");
593 593
594 mutex_lock(&s->vb_queue_lock); 594 mutex_lock(&dev->vb_queue_lock);
595 mutex_lock(&s->v4l2_lock); 595 mutex_lock(&dev->v4l2_lock);
596 /* No need to keep the urbs around after disconnection */ 596 /* No need to keep the urbs around after disconnection */
597 s->udev = NULL; 597 dev->udev = NULL;
598 598
599 v4l2_device_disconnect(&s->v4l2_dev); 599 v4l2_device_disconnect(&dev->v4l2_dev);
600 video_unregister_device(&s->vdev); 600 video_unregister_device(&dev->vdev);
601 mutex_unlock(&s->v4l2_lock); 601 mutex_unlock(&dev->v4l2_lock);
602 mutex_unlock(&s->vb_queue_lock); 602 mutex_unlock(&dev->vb_queue_lock);
603 603
604 v4l2_device_put(&s->v4l2_dev); 604 v4l2_device_put(&dev->v4l2_dev);
605 605
606 fe->sec_priv = NULL; 606 fe->sec_priv = NULL;
607} 607}
@@ -609,13 +609,13 @@ static void rtl2832_sdr_release_sec(struct dvb_frontend *fe)
609static int rtl2832_sdr_querycap(struct file *file, void *fh, 609static int rtl2832_sdr_querycap(struct file *file, void *fh,
610 struct v4l2_capability *cap) 610 struct v4l2_capability *cap)
611{ 611{
612 struct rtl2832_sdr_state *s = video_drvdata(file); 612 struct rtl2832_sdr_dev *dev = video_drvdata(file);
613 613
614 dev_dbg(&s->udev->dev, "\n"); 614 dev_dbg(&dev->udev->dev, "\n");
615 615
616 strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver)); 616 strlcpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
617 strlcpy(cap->card, s->vdev.name, sizeof(cap->card)); 617 strlcpy(cap->card, dev->vdev.name, sizeof(cap->card));
618 usb_make_path(s->udev, cap->bus_info, sizeof(cap->bus_info)); 618 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
619 cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING | 619 cap->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_STREAMING |
620 V4L2_CAP_READWRITE | V4L2_CAP_TUNER; 620 V4L2_CAP_READWRITE | V4L2_CAP_TUNER;
621 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 621 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
@@ -627,26 +627,26 @@ static int rtl2832_sdr_queue_setup(struct vb2_queue *vq,
627 const struct v4l2_format *fmt, unsigned int *nbuffers, 627 const struct v4l2_format *fmt, unsigned int *nbuffers,
628 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[]) 628 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
629{ 629{
630 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vq); 630 struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vq);
631 631
632 dev_dbg(&s->udev->dev, "nbuffers=%d\n", *nbuffers); 632 dev_dbg(&dev->udev->dev, "nbuffers=%d\n", *nbuffers);
633 633
634 /* Need at least 8 buffers */ 634 /* Need at least 8 buffers */
635 if (vq->num_buffers + *nbuffers < 8) 635 if (vq->num_buffers + *nbuffers < 8)
636 *nbuffers = 8 - vq->num_buffers; 636 *nbuffers = 8 - vq->num_buffers;
637 *nplanes = 1; 637 *nplanes = 1;
638 sizes[0] = PAGE_ALIGN(s->buffersize); 638 sizes[0] = PAGE_ALIGN(dev->buffersize);
639 dev_dbg(&s->udev->dev, "nbuffers=%d sizes[0]=%d\n", 639 dev_dbg(&dev->udev->dev, "nbuffers=%d sizes[0]=%d\n",
640 *nbuffers, sizes[0]); 640 *nbuffers, sizes[0]);
641 return 0; 641 return 0;
642} 642}
643 643
644static int rtl2832_sdr_buf_prepare(struct vb2_buffer *vb) 644static int rtl2832_sdr_buf_prepare(struct vb2_buffer *vb)
645{ 645{
646 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vb->vb2_queue); 646 struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
647 647
648 /* Don't allow queing new buffers after device disconnection */ 648 /* Don't allow queing new buffers after device disconnection */
649 if (!s->udev) 649 if (!dev->udev)
650 return -ENODEV; 650 return -ENODEV;
651 651
652 return 0; 652 return 0;
@@ -654,46 +654,46 @@ static int rtl2832_sdr_buf_prepare(struct vb2_buffer *vb)
654 654
655static void rtl2832_sdr_buf_queue(struct vb2_buffer *vb) 655static void rtl2832_sdr_buf_queue(struct vb2_buffer *vb)
656{ 656{
657 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vb->vb2_queue); 657 struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
658 struct rtl2832_sdr_frame_buf *buf = 658 struct rtl2832_sdr_frame_buf *buf =
659 container_of(vb, struct rtl2832_sdr_frame_buf, vb); 659 container_of(vb, struct rtl2832_sdr_frame_buf, vb);
660 unsigned long flags; 660 unsigned long flags;
661 661
662 /* Check the device has not disconnected between prep and queuing */ 662 /* Check the device has not disconnected between prep and queuing */
663 if (!s->udev) { 663 if (!dev->udev) {
664 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 664 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
665 return; 665 return;
666 } 666 }
667 667
668 spin_lock_irqsave(&s->queued_bufs_lock, flags); 668 spin_lock_irqsave(&dev->queued_bufs_lock, flags);
669 list_add_tail(&buf->list, &s->queued_bufs); 669 list_add_tail(&buf->list, &dev->queued_bufs);
670 spin_unlock_irqrestore(&s->queued_bufs_lock, flags); 670 spin_unlock_irqrestore(&dev->queued_bufs_lock, flags);
671} 671}
672 672
673static int rtl2832_sdr_set_adc(struct rtl2832_sdr_state *s) 673static int rtl2832_sdr_set_adc(struct rtl2832_sdr_dev *dev)
674{ 674{
675 struct dvb_frontend *fe = s->fe; 675 struct dvb_frontend *fe = dev->fe;
676 int ret; 676 int ret;
677 unsigned int f_sr, f_if; 677 unsigned int f_sr, f_if;
678 u8 buf[4], u8tmp1, u8tmp2; 678 u8 buf[4], u8tmp1, u8tmp2;
679 u64 u64tmp; 679 u64 u64tmp;
680 u32 u32tmp; 680 u32 u32tmp;
681 681
682 dev_dbg(&s->udev->dev, "f_adc=%u\n", s->f_adc); 682 dev_dbg(&dev->udev->dev, "f_adc=%u\n", dev->f_adc);
683 683
684 if (!test_bit(POWER_ON, &s->flags)) 684 if (!test_bit(POWER_ON, &dev->flags))
685 return 0; 685 return 0;
686 686
687 if (s->f_adc == 0) 687 if (dev->f_adc == 0)
688 return 0; 688 return 0;
689 689
690 f_sr = s->f_adc; 690 f_sr = dev->f_adc;
691 691
692 ret = rtl2832_sdr_wr_regs(s, 0x13e, "\x00\x00", 2); 692 ret = rtl2832_sdr_wr_regs(dev, 0x13e, "\x00\x00", 2);
693 if (ret) 693 if (ret)
694 goto err; 694 goto err;
695 695
696 ret = rtl2832_sdr_wr_regs(s, 0x115, "\x00\x00\x00\x00", 4); 696 ret = rtl2832_sdr_wr_regs(dev, 0x115, "\x00\x00\x00\x00", 4);
697 if (ret) 697 if (ret)
698 goto err; 698 goto err;
699 699
@@ -707,19 +707,19 @@ static int rtl2832_sdr_set_adc(struct rtl2832_sdr_state *s)
707 goto err; 707 goto err;
708 708
709 /* program IF */ 709 /* program IF */
710 u64tmp = f_if % s->cfg->xtal; 710 u64tmp = f_if % dev->cfg->xtal;
711 u64tmp *= 0x400000; 711 u64tmp *= 0x400000;
712 u64tmp = div_u64(u64tmp, s->cfg->xtal); 712 u64tmp = div_u64(u64tmp, dev->cfg->xtal);
713 u64tmp = -u64tmp; 713 u64tmp = -u64tmp;
714 u32tmp = u64tmp & 0x3fffff; 714 u32tmp = u64tmp & 0x3fffff;
715 715
716 dev_dbg(&s->udev->dev, "f_if=%u if_ctl=%08x\n", f_if, u32tmp); 716 dev_dbg(&dev->udev->dev, "f_if=%u if_ctl=%08x\n", f_if, u32tmp);
717 717
718 buf[0] = (u32tmp >> 16) & 0xff; 718 buf[0] = (u32tmp >> 16) & 0xff;
719 buf[1] = (u32tmp >> 8) & 0xff; 719 buf[1] = (u32tmp >> 8) & 0xff;
720 buf[2] = (u32tmp >> 0) & 0xff; 720 buf[2] = (u32tmp >> 0) & 0xff;
721 721
722 ret = rtl2832_sdr_wr_regs(s, 0x119, buf, 3); 722 ret = rtl2832_sdr_wr_regs(dev, 0x119, buf, 3);
723 if (ret) 723 if (ret)
724 goto err; 724 goto err;
725 725
@@ -733,208 +733,208 @@ static int rtl2832_sdr_set_adc(struct rtl2832_sdr_state *s)
733 u8tmp2 = 0xcd; /* enable ADC I, ADC Q */ 733 u8tmp2 = 0xcd; /* enable ADC I, ADC Q */
734 } 734 }
735 735
736 ret = rtl2832_sdr_wr_reg(s, 0x1b1, u8tmp1); 736 ret = rtl2832_sdr_wr_reg(dev, 0x1b1, u8tmp1);
737 if (ret) 737 if (ret)
738 goto err; 738 goto err;
739 739
740 ret = rtl2832_sdr_wr_reg(s, 0x008, u8tmp2); 740 ret = rtl2832_sdr_wr_reg(dev, 0x008, u8tmp2);
741 if (ret) 741 if (ret)
742 goto err; 742 goto err;
743 743
744 ret = rtl2832_sdr_wr_reg(s, 0x006, 0x80); 744 ret = rtl2832_sdr_wr_reg(dev, 0x006, 0x80);
745 if (ret) 745 if (ret)
746 goto err; 746 goto err;
747 747
748 /* program sampling rate (resampling down) */ 748 /* program sampling rate (resampling down) */
749 u32tmp = div_u64(s->cfg->xtal * 0x400000ULL, f_sr * 4U); 749 u32tmp = div_u64(dev->cfg->xtal * 0x400000ULL, f_sr * 4U);
750 u32tmp <<= 2; 750 u32tmp <<= 2;
751 buf[0] = (u32tmp >> 24) & 0xff; 751 buf[0] = (u32tmp >> 24) & 0xff;
752 buf[1] = (u32tmp >> 16) & 0xff; 752 buf[1] = (u32tmp >> 16) & 0xff;
753 buf[2] = (u32tmp >> 8) & 0xff; 753 buf[2] = (u32tmp >> 8) & 0xff;
754 buf[3] = (u32tmp >> 0) & 0xff; 754 buf[3] = (u32tmp >> 0) & 0xff;
755 ret = rtl2832_sdr_wr_regs(s, 0x19f, buf, 4); 755 ret = rtl2832_sdr_wr_regs(dev, 0x19f, buf, 4);
756 if (ret) 756 if (ret)
757 goto err; 757 goto err;
758 758
759 /* low-pass filter */ 759 /* low-pass filter */
760 ret = rtl2832_sdr_wr_regs(s, 0x11c, 760 ret = rtl2832_sdr_wr_regs(dev, 0x11c,
761 "\xca\xdc\xd7\xd8\xe0\xf2\x0e\x35\x06\x50\x9c\x0d\x71\x11\x14\x71\x74\x19\x41\xa5", 761 "\xca\xdc\xd7\xd8\xe0\xf2\x0e\x35\x06\x50\x9c\x0d\x71\x11\x14\x71\x74\x19\x41\xa5",
762 20); 762 20);
763 if (ret) 763 if (ret)
764 goto err; 764 goto err;
765 765
766 ret = rtl2832_sdr_wr_regs(s, 0x017, "\x11\x10", 2); 766 ret = rtl2832_sdr_wr_regs(dev, 0x017, "\x11\x10", 2);
767 if (ret) 767 if (ret)
768 goto err; 768 goto err;
769 769
770 /* mode */ 770 /* mode */
771 ret = rtl2832_sdr_wr_regs(s, 0x019, "\x05", 1); 771 ret = rtl2832_sdr_wr_regs(dev, 0x019, "\x05", 1);
772 if (ret) 772 if (ret)
773 goto err; 773 goto err;
774 774
775 ret = rtl2832_sdr_wr_regs(s, 0x01a, "\x1b\x16\x0d\x06\x01\xff", 6); 775 ret = rtl2832_sdr_wr_regs(dev, 0x01a, "\x1b\x16\x0d\x06\x01\xff", 6);
776 if (ret) 776 if (ret)
777 goto err; 777 goto err;
778 778
779 /* FSM */ 779 /* FSM */
780 ret = rtl2832_sdr_wr_regs(s, 0x192, "\x00\xf0\x0f", 3); 780 ret = rtl2832_sdr_wr_regs(dev, 0x192, "\x00\xf0\x0f", 3);
781 if (ret) 781 if (ret)
782 goto err; 782 goto err;
783 783
784 /* PID filter */ 784 /* PID filter */
785 ret = rtl2832_sdr_wr_regs(s, 0x061, "\x60", 1); 785 ret = rtl2832_sdr_wr_regs(dev, 0x061, "\x60", 1);
786 if (ret) 786 if (ret)
787 goto err; 787 goto err;
788 788
789 /* used RF tuner based settings */ 789 /* used RF tuner based settings */
790 switch (s->cfg->tuner) { 790 switch (dev->cfg->tuner) {
791 case RTL2832_TUNER_E4000: 791 case RTL2832_TUNER_E4000:
792 ret = rtl2832_sdr_wr_regs(s, 0x112, "\x5a", 1); 792 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x5a", 1);
793 ret = rtl2832_sdr_wr_regs(s, 0x102, "\x40", 1); 793 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
794 ret = rtl2832_sdr_wr_regs(s, 0x103, "\x5a", 1); 794 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x5a", 1);
795 ret = rtl2832_sdr_wr_regs(s, 0x1c7, "\x30", 1); 795 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x30", 1);
796 ret = rtl2832_sdr_wr_regs(s, 0x104, "\xd0", 1); 796 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xd0", 1);
797 ret = rtl2832_sdr_wr_regs(s, 0x105, "\xbe", 1); 797 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
798 ret = rtl2832_sdr_wr_regs(s, 0x1c8, "\x18", 1); 798 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x18", 1);
799 ret = rtl2832_sdr_wr_regs(s, 0x106, "\x35", 1); 799 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
800 ret = rtl2832_sdr_wr_regs(s, 0x1c9, "\x21", 1); 800 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
801 ret = rtl2832_sdr_wr_regs(s, 0x1ca, "\x21", 1); 801 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
802 ret = rtl2832_sdr_wr_regs(s, 0x1cb, "\x00", 1); 802 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
803 ret = rtl2832_sdr_wr_regs(s, 0x107, "\x40", 1); 803 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
804 ret = rtl2832_sdr_wr_regs(s, 0x1cd, "\x10", 1); 804 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
805 ret = rtl2832_sdr_wr_regs(s, 0x1ce, "\x10", 1); 805 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
806 ret = rtl2832_sdr_wr_regs(s, 0x108, "\x80", 1); 806 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
807 ret = rtl2832_sdr_wr_regs(s, 0x109, "\x7f", 1); 807 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
808 ret = rtl2832_sdr_wr_regs(s, 0x10a, "\x80", 1); 808 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x80", 1);
809 ret = rtl2832_sdr_wr_regs(s, 0x10b, "\x7f", 1); 809 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
810 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1); 810 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
811 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1); 811 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
812 ret = rtl2832_sdr_wr_regs(s, 0x011, "\xd4", 1); 812 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xd4", 1);
813 ret = rtl2832_sdr_wr_regs(s, 0x1e5, "\xf0", 1); 813 ret = rtl2832_sdr_wr_regs(dev, 0x1e5, "\xf0", 1);
814 ret = rtl2832_sdr_wr_regs(s, 0x1d9, "\x00", 1); 814 ret = rtl2832_sdr_wr_regs(dev, 0x1d9, "\x00", 1);
815 ret = rtl2832_sdr_wr_regs(s, 0x1db, "\x00", 1); 815 ret = rtl2832_sdr_wr_regs(dev, 0x1db, "\x00", 1);
816 ret = rtl2832_sdr_wr_regs(s, 0x1dd, "\x14", 1); 816 ret = rtl2832_sdr_wr_regs(dev, 0x1dd, "\x14", 1);
817 ret = rtl2832_sdr_wr_regs(s, 0x1de, "\xec", 1); 817 ret = rtl2832_sdr_wr_regs(dev, 0x1de, "\xec", 1);
818 ret = rtl2832_sdr_wr_regs(s, 0x1d8, "\x0c", 1); 818 ret = rtl2832_sdr_wr_regs(dev, 0x1d8, "\x0c", 1);
819 ret = rtl2832_sdr_wr_regs(s, 0x1e6, "\x02", 1); 819 ret = rtl2832_sdr_wr_regs(dev, 0x1e6, "\x02", 1);
820 ret = rtl2832_sdr_wr_regs(s, 0x1d7, "\x09", 1); 820 ret = rtl2832_sdr_wr_regs(dev, 0x1d7, "\x09", 1);
821 ret = rtl2832_sdr_wr_regs(s, 0x00d, "\x83", 1); 821 ret = rtl2832_sdr_wr_regs(dev, 0x00d, "\x83", 1);
822 ret = rtl2832_sdr_wr_regs(s, 0x010, "\x49", 1); 822 ret = rtl2832_sdr_wr_regs(dev, 0x010, "\x49", 1);
823 ret = rtl2832_sdr_wr_regs(s, 0x00d, "\x87", 1); 823 ret = rtl2832_sdr_wr_regs(dev, 0x00d, "\x87", 1);
824 ret = rtl2832_sdr_wr_regs(s, 0x00d, "\x85", 1); 824 ret = rtl2832_sdr_wr_regs(dev, 0x00d, "\x85", 1);
825 ret = rtl2832_sdr_wr_regs(s, 0x013, "\x02", 1); 825 ret = rtl2832_sdr_wr_regs(dev, 0x013, "\x02", 1);
826 break; 826 break;
827 case RTL2832_TUNER_FC0012: 827 case RTL2832_TUNER_FC0012:
828 case RTL2832_TUNER_FC0013: 828 case RTL2832_TUNER_FC0013:
829 ret = rtl2832_sdr_wr_regs(s, 0x112, "\x5a", 1); 829 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x5a", 1);
830 ret = rtl2832_sdr_wr_regs(s, 0x102, "\x40", 1); 830 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
831 ret = rtl2832_sdr_wr_regs(s, 0x103, "\x5a", 1); 831 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x5a", 1);
832 ret = rtl2832_sdr_wr_regs(s, 0x1c7, "\x2c", 1); 832 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x2c", 1);
833 ret = rtl2832_sdr_wr_regs(s, 0x104, "\xcc", 1); 833 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xcc", 1);
834 ret = rtl2832_sdr_wr_regs(s, 0x105, "\xbe", 1); 834 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
835 ret = rtl2832_sdr_wr_regs(s, 0x1c8, "\x16", 1); 835 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x16", 1);
836 ret = rtl2832_sdr_wr_regs(s, 0x106, "\x35", 1); 836 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
837 ret = rtl2832_sdr_wr_regs(s, 0x1c9, "\x21", 1); 837 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
838 ret = rtl2832_sdr_wr_regs(s, 0x1ca, "\x21", 1); 838 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
839 ret = rtl2832_sdr_wr_regs(s, 0x1cb, "\x00", 1); 839 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
840 ret = rtl2832_sdr_wr_regs(s, 0x107, "\x40", 1); 840 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
841 ret = rtl2832_sdr_wr_regs(s, 0x1cd, "\x10", 1); 841 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
842 ret = rtl2832_sdr_wr_regs(s, 0x1ce, "\x10", 1); 842 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
843 ret = rtl2832_sdr_wr_regs(s, 0x108, "\x80", 1); 843 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
844 ret = rtl2832_sdr_wr_regs(s, 0x109, "\x7f", 1); 844 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
845 ret = rtl2832_sdr_wr_regs(s, 0x10a, "\x80", 1); 845 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x80", 1);
846 ret = rtl2832_sdr_wr_regs(s, 0x10b, "\x7f", 1); 846 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
847 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1); 847 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
848 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1); 848 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
849 ret = rtl2832_sdr_wr_regs(s, 0x011, "\xe9\xbf", 2); 849 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xe9\xbf", 2);
850 ret = rtl2832_sdr_wr_regs(s, 0x1e5, "\xf0", 1); 850 ret = rtl2832_sdr_wr_regs(dev, 0x1e5, "\xf0", 1);
851 ret = rtl2832_sdr_wr_regs(s, 0x1d9, "\x00", 1); 851 ret = rtl2832_sdr_wr_regs(dev, 0x1d9, "\x00", 1);
852 ret = rtl2832_sdr_wr_regs(s, 0x1db, "\x00", 1); 852 ret = rtl2832_sdr_wr_regs(dev, 0x1db, "\x00", 1);
853 ret = rtl2832_sdr_wr_regs(s, 0x1dd, "\x11", 1); 853 ret = rtl2832_sdr_wr_regs(dev, 0x1dd, "\x11", 1);
854 ret = rtl2832_sdr_wr_regs(s, 0x1de, "\xef", 1); 854 ret = rtl2832_sdr_wr_regs(dev, 0x1de, "\xef", 1);
855 ret = rtl2832_sdr_wr_regs(s, 0x1d8, "\x0c", 1); 855 ret = rtl2832_sdr_wr_regs(dev, 0x1d8, "\x0c", 1);
856 ret = rtl2832_sdr_wr_regs(s, 0x1e6, "\x02", 1); 856 ret = rtl2832_sdr_wr_regs(dev, 0x1e6, "\x02", 1);
857 ret = rtl2832_sdr_wr_regs(s, 0x1d7, "\x09", 1); 857 ret = rtl2832_sdr_wr_regs(dev, 0x1d7, "\x09", 1);
858 break; 858 break;
859 case RTL2832_TUNER_R820T: 859 case RTL2832_TUNER_R820T:
860 ret = rtl2832_sdr_wr_regs(s, 0x112, "\x5a", 1); 860 ret = rtl2832_sdr_wr_regs(dev, 0x112, "\x5a", 1);
861 ret = rtl2832_sdr_wr_regs(s, 0x102, "\x40", 1); 861 ret = rtl2832_sdr_wr_regs(dev, 0x102, "\x40", 1);
862 ret = rtl2832_sdr_wr_regs(s, 0x115, "\x01", 1); 862 ret = rtl2832_sdr_wr_regs(dev, 0x115, "\x01", 1);
863 ret = rtl2832_sdr_wr_regs(s, 0x103, "\x80", 1); 863 ret = rtl2832_sdr_wr_regs(dev, 0x103, "\x80", 1);
864 ret = rtl2832_sdr_wr_regs(s, 0x1c7, "\x24", 1); 864 ret = rtl2832_sdr_wr_regs(dev, 0x1c7, "\x24", 1);
865 ret = rtl2832_sdr_wr_regs(s, 0x104, "\xcc", 1); 865 ret = rtl2832_sdr_wr_regs(dev, 0x104, "\xcc", 1);
866 ret = rtl2832_sdr_wr_regs(s, 0x105, "\xbe", 1); 866 ret = rtl2832_sdr_wr_regs(dev, 0x105, "\xbe", 1);
867 ret = rtl2832_sdr_wr_regs(s, 0x1c8, "\x14", 1); 867 ret = rtl2832_sdr_wr_regs(dev, 0x1c8, "\x14", 1);
868 ret = rtl2832_sdr_wr_regs(s, 0x106, "\x35", 1); 868 ret = rtl2832_sdr_wr_regs(dev, 0x106, "\x35", 1);
869 ret = rtl2832_sdr_wr_regs(s, 0x1c9, "\x21", 1); 869 ret = rtl2832_sdr_wr_regs(dev, 0x1c9, "\x21", 1);
870 ret = rtl2832_sdr_wr_regs(s, 0x1ca, "\x21", 1); 870 ret = rtl2832_sdr_wr_regs(dev, 0x1ca, "\x21", 1);
871 ret = rtl2832_sdr_wr_regs(s, 0x1cb, "\x00", 1); 871 ret = rtl2832_sdr_wr_regs(dev, 0x1cb, "\x00", 1);
872 ret = rtl2832_sdr_wr_regs(s, 0x107, "\x40", 1); 872 ret = rtl2832_sdr_wr_regs(dev, 0x107, "\x40", 1);
873 ret = rtl2832_sdr_wr_regs(s, 0x1cd, "\x10", 1); 873 ret = rtl2832_sdr_wr_regs(dev, 0x1cd, "\x10", 1);
874 ret = rtl2832_sdr_wr_regs(s, 0x1ce, "\x10", 1); 874 ret = rtl2832_sdr_wr_regs(dev, 0x1ce, "\x10", 1);
875 ret = rtl2832_sdr_wr_regs(s, 0x108, "\x80", 1); 875 ret = rtl2832_sdr_wr_regs(dev, 0x108, "\x80", 1);
876 ret = rtl2832_sdr_wr_regs(s, 0x109, "\x7f", 1); 876 ret = rtl2832_sdr_wr_regs(dev, 0x109, "\x7f", 1);
877 ret = rtl2832_sdr_wr_regs(s, 0x10a, "\x80", 1); 877 ret = rtl2832_sdr_wr_regs(dev, 0x10a, "\x80", 1);
878 ret = rtl2832_sdr_wr_regs(s, 0x10b, "\x7f", 1); 878 ret = rtl2832_sdr_wr_regs(dev, 0x10b, "\x7f", 1);
879 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1); 879 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
880 ret = rtl2832_sdr_wr_regs(s, 0x00e, "\xfc", 1); 880 ret = rtl2832_sdr_wr_regs(dev, 0x00e, "\xfc", 1);
881 ret = rtl2832_sdr_wr_regs(s, 0x011, "\xf4", 1); 881 ret = rtl2832_sdr_wr_regs(dev, 0x011, "\xf4", 1);
882 break; 882 break;
883 default: 883 default:
884 dev_notice(&s->udev->dev, "Unsupported tuner\n"); 884 dev_notice(&dev->udev->dev, "Unsupported tuner\n");
885 } 885 }
886 886
887 /* software reset */ 887 /* software reset */
888 ret = rtl2832_sdr_wr_reg_mask(s, 0x101, 0x04, 0x04); 888 ret = rtl2832_sdr_wr_reg_mask(dev, 0x101, 0x04, 0x04);
889 if (ret) 889 if (ret)
890 goto err; 890 goto err;
891 891
892 ret = rtl2832_sdr_wr_reg_mask(s, 0x101, 0x00, 0x04); 892 ret = rtl2832_sdr_wr_reg_mask(dev, 0x101, 0x00, 0x04);
893 if (ret) 893 if (ret)
894 goto err; 894 goto err;
895err: 895err:
896 return ret; 896 return ret;
897}; 897};
898 898
899static void rtl2832_sdr_unset_adc(struct rtl2832_sdr_state *s) 899static void rtl2832_sdr_unset_adc(struct rtl2832_sdr_dev *dev)
900{ 900{
901 int ret; 901 int ret;
902 902
903 dev_dbg(&s->udev->dev, "\n"); 903 dev_dbg(&dev->udev->dev, "\n");
904 904
905 /* PID filter */ 905 /* PID filter */
906 ret = rtl2832_sdr_wr_regs(s, 0x061, "\xe0", 1); 906 ret = rtl2832_sdr_wr_regs(dev, 0x061, "\xe0", 1);
907 if (ret) 907 if (ret)
908 goto err; 908 goto err;
909 909
910 /* mode */ 910 /* mode */
911 ret = rtl2832_sdr_wr_regs(s, 0x019, "\x20", 1); 911 ret = rtl2832_sdr_wr_regs(dev, 0x019, "\x20", 1);
912 if (ret) 912 if (ret)
913 goto err; 913 goto err;
914 914
915 ret = rtl2832_sdr_wr_regs(s, 0x017, "\x11\x10", 2); 915 ret = rtl2832_sdr_wr_regs(dev, 0x017, "\x11\x10", 2);
916 if (ret) 916 if (ret)
917 goto err; 917 goto err;
918 918
919 /* FSM */ 919 /* FSM */
920 ret = rtl2832_sdr_wr_regs(s, 0x192, "\x00\x0f\xff", 3); 920 ret = rtl2832_sdr_wr_regs(dev, 0x192, "\x00\x0f\xff", 3);
921 if (ret) 921 if (ret)
922 goto err; 922 goto err;
923 923
924 ret = rtl2832_sdr_wr_regs(s, 0x13e, "\x40\x00", 2); 924 ret = rtl2832_sdr_wr_regs(dev, 0x13e, "\x40\x00", 2);
925 if (ret) 925 if (ret)
926 goto err; 926 goto err;
927 927
928 ret = rtl2832_sdr_wr_regs(s, 0x115, "\x06\x3f\xce\xcc", 4); 928 ret = rtl2832_sdr_wr_regs(dev, 0x115, "\x06\x3f\xce\xcc", 4);
929 if (ret) 929 if (ret)
930 goto err; 930 goto err;
931err: 931err:
932 return; 932 return;
933}; 933};
934 934
935static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_state *s) 935static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_dev *dev)
936{ 936{
937 struct dvb_frontend *fe = s->fe; 937 struct dvb_frontend *fe = dev->fe;
938 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 938 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
939 struct v4l2_ctrl *bandwidth_auto; 939 struct v4l2_ctrl *bandwidth_auto;
940 struct v4l2_ctrl *bandwidth; 940 struct v4l2_ctrl *bandwidth;
@@ -942,29 +942,29 @@ static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_state *s)
942 /* 942 /*
943 * tuner RF (Hz) 943 * tuner RF (Hz)
944 */ 944 */
945 if (s->f_tuner == 0) 945 if (dev->f_tuner == 0)
946 return 0; 946 return 0;
947 947
948 /* 948 /*
949 * bandwidth (Hz) 949 * bandwidth (Hz)
950 */ 950 */
951 bandwidth_auto = v4l2_ctrl_find(&s->hdl, 951 bandwidth_auto = v4l2_ctrl_find(&dev->hdl,
952 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO); 952 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO);
953 bandwidth = v4l2_ctrl_find(&s->hdl, V4L2_CID_RF_TUNER_BANDWIDTH); 953 bandwidth = v4l2_ctrl_find(&dev->hdl, V4L2_CID_RF_TUNER_BANDWIDTH);
954 if (v4l2_ctrl_g_ctrl(bandwidth_auto)) { 954 if (v4l2_ctrl_g_ctrl(bandwidth_auto)) {
955 c->bandwidth_hz = s->f_adc; 955 c->bandwidth_hz = dev->f_adc;
956 v4l2_ctrl_s_ctrl(bandwidth, s->f_adc); 956 v4l2_ctrl_s_ctrl(bandwidth, dev->f_adc);
957 } else { 957 } else {
958 c->bandwidth_hz = v4l2_ctrl_g_ctrl(bandwidth); 958 c->bandwidth_hz = v4l2_ctrl_g_ctrl(bandwidth);
959 } 959 }
960 960
961 c->frequency = s->f_tuner; 961 c->frequency = dev->f_tuner;
962 c->delivery_system = SYS_DVBT; 962 c->delivery_system = SYS_DVBT;
963 963
964 dev_dbg(&s->udev->dev, "frequency=%u bandwidth=%d\n", 964 dev_dbg(&dev->udev->dev, "frequency=%u bandwidth=%d\n",
965 c->frequency, c->bandwidth_hz); 965 c->frequency, c->bandwidth_hz);
966 966
967 if (!test_bit(POWER_ON, &s->flags)) 967 if (!test_bit(POWER_ON, &dev->flags))
968 return 0; 968 return 0;
969 969
970 if (fe->ops.tuner_ops.set_params) 970 if (fe->ops.tuner_ops.set_params)
@@ -973,11 +973,11 @@ static int rtl2832_sdr_set_tuner_freq(struct rtl2832_sdr_state *s)
973 return 0; 973 return 0;
974}; 974};
975 975
976static int rtl2832_sdr_set_tuner(struct rtl2832_sdr_state *s) 976static int rtl2832_sdr_set_tuner(struct rtl2832_sdr_dev *dev)
977{ 977{
978 struct dvb_frontend *fe = s->fe; 978 struct dvb_frontend *fe = dev->fe;
979 979
980 dev_dbg(&s->udev->dev, "\n"); 980 dev_dbg(&dev->udev->dev, "\n");
981 981
982 if (fe->ops.tuner_ops.init) 982 if (fe->ops.tuner_ops.init)
983 fe->ops.tuner_ops.init(fe); 983 fe->ops.tuner_ops.init(fe);
@@ -985,11 +985,11 @@ static int rtl2832_sdr_set_tuner(struct rtl2832_sdr_state *s)
985 return 0; 985 return 0;
986}; 986};
987 987
988static void rtl2832_sdr_unset_tuner(struct rtl2832_sdr_state *s) 988static void rtl2832_sdr_unset_tuner(struct rtl2832_sdr_dev *dev)
989{ 989{
990 struct dvb_frontend *fe = s->fe; 990 struct dvb_frontend *fe = dev->fe;
991 991
992 dev_dbg(&s->udev->dev, "\n"); 992 dev_dbg(&dev->udev->dev, "\n");
993 993
994 if (fe->ops.tuner_ops.sleep) 994 if (fe->ops.tuner_ops.sleep)
995 fe->ops.tuner_ops.sleep(fe); 995 fe->ops.tuner_ops.sleep(fe);
@@ -999,83 +999,83 @@ static void rtl2832_sdr_unset_tuner(struct rtl2832_sdr_state *s)
999 999
1000static int rtl2832_sdr_start_streaming(struct vb2_queue *vq, unsigned int count) 1000static int rtl2832_sdr_start_streaming(struct vb2_queue *vq, unsigned int count)
1001{ 1001{
1002 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vq); 1002 struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vq);
1003 int ret; 1003 int ret;
1004 1004
1005 dev_dbg(&s->udev->dev, "\n"); 1005 dev_dbg(&dev->udev->dev, "\n");
1006 1006
1007 if (!s->udev) 1007 if (!dev->udev)
1008 return -ENODEV; 1008 return -ENODEV;
1009 1009
1010 if (mutex_lock_interruptible(&s->v4l2_lock)) 1010 if (mutex_lock_interruptible(&dev->v4l2_lock))
1011 return -ERESTARTSYS; 1011 return -ERESTARTSYS;
1012 1012
1013 if (s->d->props->power_ctrl) 1013 if (dev->d->props->power_ctrl)
1014 s->d->props->power_ctrl(s->d, 1); 1014 dev->d->props->power_ctrl(dev->d, 1);
1015 1015
1016 /* enable ADC */ 1016 /* enable ADC */
1017 if (s->d->props->frontend_ctrl) 1017 if (dev->d->props->frontend_ctrl)
1018 s->d->props->frontend_ctrl(s->fe, 1); 1018 dev->d->props->frontend_ctrl(dev->fe, 1);
1019 1019
1020 set_bit(POWER_ON, &s->flags); 1020 set_bit(POWER_ON, &dev->flags);
1021 1021
1022 ret = rtl2832_sdr_set_tuner(s); 1022 ret = rtl2832_sdr_set_tuner(dev);
1023 if (ret) 1023 if (ret)
1024 goto err; 1024 goto err;
1025 1025
1026 ret = rtl2832_sdr_set_tuner_freq(s); 1026 ret = rtl2832_sdr_set_tuner_freq(dev);
1027 if (ret) 1027 if (ret)
1028 goto err; 1028 goto err;
1029 1029
1030 ret = rtl2832_sdr_set_adc(s); 1030 ret = rtl2832_sdr_set_adc(dev);
1031 if (ret) 1031 if (ret)
1032 goto err; 1032 goto err;
1033 1033
1034 ret = rtl2832_sdr_alloc_stream_bufs(s); 1034 ret = rtl2832_sdr_alloc_stream_bufs(dev);
1035 if (ret) 1035 if (ret)
1036 goto err; 1036 goto err;
1037 1037
1038 ret = rtl2832_sdr_alloc_urbs(s); 1038 ret = rtl2832_sdr_alloc_urbs(dev);
1039 if (ret) 1039 if (ret)
1040 goto err; 1040 goto err;
1041 1041
1042 s->sequence = 0; 1042 dev->sequence = 0;
1043 1043
1044 ret = rtl2832_sdr_submit_urbs(s); 1044 ret = rtl2832_sdr_submit_urbs(dev);
1045 if (ret) 1045 if (ret)
1046 goto err; 1046 goto err;
1047 1047
1048err: 1048err:
1049 mutex_unlock(&s->v4l2_lock); 1049 mutex_unlock(&dev->v4l2_lock);
1050 1050
1051 return ret; 1051 return ret;
1052} 1052}
1053 1053
1054static void rtl2832_sdr_stop_streaming(struct vb2_queue *vq) 1054static void rtl2832_sdr_stop_streaming(struct vb2_queue *vq)
1055{ 1055{
1056 struct rtl2832_sdr_state *s = vb2_get_drv_priv(vq); 1056 struct rtl2832_sdr_dev *dev = vb2_get_drv_priv(vq);
1057 1057
1058 dev_dbg(&s->udev->dev, "\n"); 1058 dev_dbg(&dev->udev->dev, "\n");
1059 1059
1060 mutex_lock(&s->v4l2_lock); 1060 mutex_lock(&dev->v4l2_lock);
1061 1061
1062 rtl2832_sdr_kill_urbs(s); 1062 rtl2832_sdr_kill_urbs(dev);
1063 rtl2832_sdr_free_urbs(s); 1063 rtl2832_sdr_free_urbs(dev);
1064 rtl2832_sdr_free_stream_bufs(s); 1064 rtl2832_sdr_free_stream_bufs(dev);
1065 rtl2832_sdr_cleanup_queued_bufs(s); 1065 rtl2832_sdr_cleanup_queued_bufs(dev);
1066 rtl2832_sdr_unset_adc(s); 1066 rtl2832_sdr_unset_adc(dev);
1067 rtl2832_sdr_unset_tuner(s); 1067 rtl2832_sdr_unset_tuner(dev);
1068 1068
1069 clear_bit(POWER_ON, &s->flags); 1069 clear_bit(POWER_ON, &dev->flags);
1070 1070
1071 /* disable ADC */ 1071 /* disable ADC */
1072 if (s->d->props->frontend_ctrl) 1072 if (dev->d->props->frontend_ctrl)
1073 s->d->props->frontend_ctrl(s->fe, 0); 1073 dev->d->props->frontend_ctrl(dev->fe, 0);
1074 1074
1075 if (s->d->props->power_ctrl) 1075 if (dev->d->props->power_ctrl)
1076 s->d->props->power_ctrl(s->d, 0); 1076 dev->d->props->power_ctrl(dev->d, 0);
1077 1077
1078 mutex_unlock(&s->v4l2_lock); 1078 mutex_unlock(&dev->v4l2_lock);
1079} 1079}
1080 1080
1081static struct vb2_ops rtl2832_sdr_vb2_ops = { 1081static struct vb2_ops rtl2832_sdr_vb2_ops = {
@@ -1091,9 +1091,9 @@ static struct vb2_ops rtl2832_sdr_vb2_ops = {
1091static int rtl2832_sdr_g_tuner(struct file *file, void *priv, 1091static int rtl2832_sdr_g_tuner(struct file *file, void *priv,
1092 struct v4l2_tuner *v) 1092 struct v4l2_tuner *v)
1093{ 1093{
1094 struct rtl2832_sdr_state *s = video_drvdata(file); 1094 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1095 1095
1096 dev_dbg(&s->udev->dev, "index=%d type=%d\n", v->index, v->type); 1096 dev_dbg(&dev->udev->dev, "index=%d type=%d\n", v->index, v->type);
1097 1097
1098 if (v->index == 0) { 1098 if (v->index == 0) {
1099 strlcpy(v->name, "ADC: Realtek RTL2832", sizeof(v->name)); 1099 strlcpy(v->name, "ADC: Realtek RTL2832", sizeof(v->name));
@@ -1117,9 +1117,9 @@ static int rtl2832_sdr_g_tuner(struct file *file, void *priv,
1117static int rtl2832_sdr_s_tuner(struct file *file, void *priv, 1117static int rtl2832_sdr_s_tuner(struct file *file, void *priv,
1118 const struct v4l2_tuner *v) 1118 const struct v4l2_tuner *v)
1119{ 1119{
1120 struct rtl2832_sdr_state *s = video_drvdata(file); 1120 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1121 1121
1122 dev_dbg(&s->udev->dev, "\n"); 1122 dev_dbg(&dev->udev->dev, "\n");
1123 1123
1124 if (v->index > 1) 1124 if (v->index > 1)
1125 return -EINVAL; 1125 return -EINVAL;
@@ -1129,9 +1129,9 @@ static int rtl2832_sdr_s_tuner(struct file *file, void *priv,
1129static int rtl2832_sdr_enum_freq_bands(struct file *file, void *priv, 1129static int rtl2832_sdr_enum_freq_bands(struct file *file, void *priv,
1130 struct v4l2_frequency_band *band) 1130 struct v4l2_frequency_band *band)
1131{ 1131{
1132 struct rtl2832_sdr_state *s = video_drvdata(file); 1132 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1133 1133
1134 dev_dbg(&s->udev->dev, "tuner=%d type=%d index=%d\n", 1134 dev_dbg(&dev->udev->dev, "tuner=%d type=%d index=%d\n",
1135 band->tuner, band->type, band->index); 1135 band->tuner, band->type, band->index);
1136 1136
1137 if (band->tuner == 0) { 1137 if (band->tuner == 0) {
@@ -1154,17 +1154,17 @@ static int rtl2832_sdr_enum_freq_bands(struct file *file, void *priv,
1154static int rtl2832_sdr_g_frequency(struct file *file, void *priv, 1154static int rtl2832_sdr_g_frequency(struct file *file, void *priv,
1155 struct v4l2_frequency *f) 1155 struct v4l2_frequency *f)
1156{ 1156{
1157 struct rtl2832_sdr_state *s = video_drvdata(file); 1157 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1158 int ret = 0; 1158 int ret = 0;
1159 1159
1160 dev_dbg(&s->udev->dev, "tuner=%d type=%d\n", 1160 dev_dbg(&dev->udev->dev, "tuner=%d type=%d\n",
1161 f->tuner, f->type); 1161 f->tuner, f->type);
1162 1162
1163 if (f->tuner == 0) { 1163 if (f->tuner == 0) {
1164 f->frequency = s->f_adc; 1164 f->frequency = dev->f_adc;
1165 f->type = V4L2_TUNER_ADC; 1165 f->type = V4L2_TUNER_ADC;
1166 } else if (f->tuner == 1) { 1166 } else if (f->tuner == 1) {
1167 f->frequency = s->f_tuner; 1167 f->frequency = dev->f_tuner;
1168 f->type = V4L2_TUNER_RF; 1168 f->type = V4L2_TUNER_RF;
1169 } else { 1169 } else {
1170 return -EINVAL; 1170 return -EINVAL;
@@ -1176,10 +1176,10 @@ static int rtl2832_sdr_g_frequency(struct file *file, void *priv,
1176static int rtl2832_sdr_s_frequency(struct file *file, void *priv, 1176static int rtl2832_sdr_s_frequency(struct file *file, void *priv,
1177 const struct v4l2_frequency *f) 1177 const struct v4l2_frequency *f)
1178{ 1178{
1179 struct rtl2832_sdr_state *s = video_drvdata(file); 1179 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1180 int ret, band; 1180 int ret, band;
1181 1181
1182 dev_dbg(&s->udev->dev, "tuner=%d type=%d frequency=%u\n", 1182 dev_dbg(&dev->udev->dev, "tuner=%d type=%d frequency=%u\n",
1183 f->tuner, f->type, f->frequency); 1183 f->tuner, f->type, f->frequency);
1184 1184
1185 /* ADC band midpoints */ 1185 /* ADC band midpoints */
@@ -1194,19 +1194,19 @@ static int rtl2832_sdr_s_frequency(struct file *file, void *priv,
1194 else 1194 else
1195 band = 2; 1195 band = 2;
1196 1196
1197 s->f_adc = clamp_t(unsigned int, f->frequency, 1197 dev->f_adc = clamp_t(unsigned int, f->frequency,
1198 bands_adc[band].rangelow, 1198 bands_adc[band].rangelow,
1199 bands_adc[band].rangehigh); 1199 bands_adc[band].rangehigh);
1200 1200
1201 dev_dbg(&s->udev->dev, "ADC frequency=%u Hz\n", s->f_adc); 1201 dev_dbg(&dev->udev->dev, "ADC frequency=%u Hz\n", dev->f_adc);
1202 ret = rtl2832_sdr_set_adc(s); 1202 ret = rtl2832_sdr_set_adc(dev);
1203 } else if (f->tuner == 1) { 1203 } else if (f->tuner == 1) {
1204 s->f_tuner = clamp_t(unsigned int, f->frequency, 1204 dev->f_tuner = clamp_t(unsigned int, f->frequency,
1205 bands_fm[0].rangelow, 1205 bands_fm[0].rangelow,
1206 bands_fm[0].rangehigh); 1206 bands_fm[0].rangehigh);
1207 dev_dbg(&s->udev->dev, "RF frequency=%u Hz\n", f->frequency); 1207 dev_dbg(&dev->udev->dev, "RF frequency=%u Hz\n", f->frequency);
1208 1208
1209 ret = rtl2832_sdr_set_tuner_freq(s); 1209 ret = rtl2832_sdr_set_tuner_freq(dev);
1210 } else { 1210 } else {
1211 ret = -EINVAL; 1211 ret = -EINVAL;
1212 } 1212 }
@@ -1217,11 +1217,11 @@ static int rtl2832_sdr_s_frequency(struct file *file, void *priv,
1217static int rtl2832_sdr_enum_fmt_sdr_cap(struct file *file, void *priv, 1217static int rtl2832_sdr_enum_fmt_sdr_cap(struct file *file, void *priv,
1218 struct v4l2_fmtdesc *f) 1218 struct v4l2_fmtdesc *f)
1219{ 1219{
1220 struct rtl2832_sdr_state *s = video_drvdata(file); 1220 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1221 1221
1222 dev_dbg(&s->udev->dev, "\n"); 1222 dev_dbg(&dev->udev->dev, "\n");
1223 1223
1224 if (f->index >= s->num_formats) 1224 if (f->index >= dev->num_formats)
1225 return -EINVAL; 1225 return -EINVAL;
1226 1226
1227 strlcpy(f->description, formats[f->index].name, sizeof(f->description)); 1227 strlcpy(f->description, formats[f->index].name, sizeof(f->description));
@@ -1233,12 +1233,12 @@ static int rtl2832_sdr_enum_fmt_sdr_cap(struct file *file, void *priv,
1233static int rtl2832_sdr_g_fmt_sdr_cap(struct file *file, void *priv, 1233static int rtl2832_sdr_g_fmt_sdr_cap(struct file *file, void *priv,
1234 struct v4l2_format *f) 1234 struct v4l2_format *f)
1235{ 1235{
1236 struct rtl2832_sdr_state *s = video_drvdata(file); 1236 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1237 1237
1238 dev_dbg(&s->udev->dev, "\n"); 1238 dev_dbg(&dev->udev->dev, "\n");
1239 1239
1240 f->fmt.sdr.pixelformat = s->pixelformat; 1240 f->fmt.sdr.pixelformat = dev->pixelformat;
1241 f->fmt.sdr.buffersize = s->buffersize; 1241 f->fmt.sdr.buffersize = dev->buffersize;
1242 1242
1243 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved)); 1243 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1244 1244
@@ -1248,28 +1248,28 @@ static int rtl2832_sdr_g_fmt_sdr_cap(struct file *file, void *priv,
1248static int rtl2832_sdr_s_fmt_sdr_cap(struct file *file, void *priv, 1248static int rtl2832_sdr_s_fmt_sdr_cap(struct file *file, void *priv,
1249 struct v4l2_format *f) 1249 struct v4l2_format *f)
1250{ 1250{
1251 struct rtl2832_sdr_state *s = video_drvdata(file); 1251 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1252 struct vb2_queue *q = &s->vb_queue; 1252 struct vb2_queue *q = &dev->vb_queue;
1253 int i; 1253 int i;
1254 1254
1255 dev_dbg(&s->udev->dev, "pixelformat fourcc %4.4s\n", 1255 dev_dbg(&dev->udev->dev, "pixelformat fourcc %4.4s\n",
1256 (char *)&f->fmt.sdr.pixelformat); 1256 (char *)&f->fmt.sdr.pixelformat);
1257 1257
1258 if (vb2_is_busy(q)) 1258 if (vb2_is_busy(q))
1259 return -EBUSY; 1259 return -EBUSY;
1260 1260
1261 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved)); 1261 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1262 for (i = 0; i < s->num_formats; i++) { 1262 for (i = 0; i < dev->num_formats; i++) {
1263 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) { 1263 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
1264 s->pixelformat = formats[i].pixelformat; 1264 dev->pixelformat = formats[i].pixelformat;
1265 s->buffersize = formats[i].buffersize; 1265 dev->buffersize = formats[i].buffersize;
1266 f->fmt.sdr.buffersize = formats[i].buffersize; 1266 f->fmt.sdr.buffersize = formats[i].buffersize;
1267 return 0; 1267 return 0;
1268 } 1268 }
1269 } 1269 }
1270 1270
1271 s->pixelformat = formats[0].pixelformat; 1271 dev->pixelformat = formats[0].pixelformat;
1272 s->buffersize = formats[0].buffersize; 1272 dev->buffersize = formats[0].buffersize;
1273 f->fmt.sdr.pixelformat = formats[0].pixelformat; 1273 f->fmt.sdr.pixelformat = formats[0].pixelformat;
1274 f->fmt.sdr.buffersize = formats[0].buffersize; 1274 f->fmt.sdr.buffersize = formats[0].buffersize;
1275 1275
@@ -1279,14 +1279,14 @@ static int rtl2832_sdr_s_fmt_sdr_cap(struct file *file, void *priv,
1279static int rtl2832_sdr_try_fmt_sdr_cap(struct file *file, void *priv, 1279static int rtl2832_sdr_try_fmt_sdr_cap(struct file *file, void *priv,
1280 struct v4l2_format *f) 1280 struct v4l2_format *f)
1281{ 1281{
1282 struct rtl2832_sdr_state *s = video_drvdata(file); 1282 struct rtl2832_sdr_dev *dev = video_drvdata(file);
1283 int i; 1283 int i;
1284 1284
1285 dev_dbg(&s->udev->dev, "pixelformat fourcc %4.4s\n", 1285 dev_dbg(&dev->udev->dev, "pixelformat fourcc %4.4s\n",
1286 (char *)&f->fmt.sdr.pixelformat); 1286 (char *)&f->fmt.sdr.pixelformat);
1287 1287
1288 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved)); 1288 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
1289 for (i = 0; i < s->num_formats; i++) { 1289 for (i = 0; i < dev->num_formats; i++) {
1290 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) { 1290 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
1291 f->fmt.sdr.buffersize = formats[i].buffersize; 1291 f->fmt.sdr.buffersize = formats[i].buffersize;
1292 return 0; 1292 return 0;
@@ -1348,14 +1348,14 @@ static struct video_device rtl2832_sdr_template = {
1348 1348
1349static int rtl2832_sdr_s_ctrl(struct v4l2_ctrl *ctrl) 1349static int rtl2832_sdr_s_ctrl(struct v4l2_ctrl *ctrl)
1350{ 1350{
1351 struct rtl2832_sdr_state *s = 1351 struct rtl2832_sdr_dev *dev =
1352 container_of(ctrl->handler, struct rtl2832_sdr_state, 1352 container_of(ctrl->handler, struct rtl2832_sdr_dev,
1353 hdl); 1353 hdl);
1354 struct dvb_frontend *fe = s->fe; 1354 struct dvb_frontend *fe = dev->fe;
1355 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1355 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1356 int ret; 1356 int ret;
1357 1357
1358 dev_dbg(&s->udev->dev, 1358 dev_dbg(&dev->udev->dev,
1359 "id=%d name=%s val=%d min=%lld max=%lld step=%lld\n", 1359 "id=%d name=%s val=%d min=%lld max=%lld step=%lld\n",
1360 ctrl->id, ctrl->name, ctrl->val, 1360 ctrl->id, ctrl->name, ctrl->val,
1361 ctrl->minimum, ctrl->maximum, ctrl->step); 1361 ctrl->minimum, ctrl->maximum, ctrl->step);
@@ -1364,21 +1364,21 @@ static int rtl2832_sdr_s_ctrl(struct v4l2_ctrl *ctrl)
1364 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO: 1364 case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1365 case V4L2_CID_RF_TUNER_BANDWIDTH: 1365 case V4L2_CID_RF_TUNER_BANDWIDTH:
1366 /* TODO: these controls should be moved to tuner drivers */ 1366 /* TODO: these controls should be moved to tuner drivers */
1367 if (s->bandwidth_auto->val) { 1367 if (dev->bandwidth_auto->val) {
1368 /* Round towards the closest legal value */ 1368 /* Round towards the closest legal value */
1369 s32 val = s->f_adc + div_u64(s->bandwidth->step, 2); 1369 s32 val = dev->f_adc + div_u64(dev->bandwidth->step, 2);
1370 u32 offset; 1370 u32 offset;
1371 1371
1372 val = clamp_t(s32, val, s->bandwidth->minimum, 1372 val = clamp_t(s32, val, dev->bandwidth->minimum,
1373 s->bandwidth->maximum); 1373 dev->bandwidth->maximum);
1374 offset = val - s->bandwidth->minimum; 1374 offset = val - dev->bandwidth->minimum;
1375 offset = s->bandwidth->step * 1375 offset = dev->bandwidth->step *
1376 div_u64(offset, s->bandwidth->step); 1376 div_u64(offset, dev->bandwidth->step);
1377 s->bandwidth->val = s->bandwidth->minimum + offset; 1377 dev->bandwidth->val = dev->bandwidth->minimum + offset;
1378 } 1378 }
1379 c->bandwidth_hz = s->bandwidth->val; 1379 c->bandwidth_hz = dev->bandwidth->val;
1380 1380
1381 if (!test_bit(POWER_ON, &s->flags)) 1381 if (!test_bit(POWER_ON, &dev->flags))
1382 return 0; 1382 return 0;
1383 1383
1384 if (fe->ops.tuner_ops.set_params) 1384 if (fe->ops.tuner_ops.set_params)
@@ -1399,12 +1399,12 @@ static const struct v4l2_ctrl_ops rtl2832_sdr_ctrl_ops = {
1399 1399
1400static void rtl2832_sdr_video_release(struct v4l2_device *v) 1400static void rtl2832_sdr_video_release(struct v4l2_device *v)
1401{ 1401{
1402 struct rtl2832_sdr_state *s = 1402 struct rtl2832_sdr_dev *dev =
1403 container_of(v, struct rtl2832_sdr_state, v4l2_dev); 1403 container_of(v, struct rtl2832_sdr_dev, v4l2_dev);
1404 1404
1405 v4l2_ctrl_handler_free(&s->hdl); 1405 v4l2_ctrl_handler_free(&dev->hdl);
1406 v4l2_device_unregister(&s->v4l2_dev); 1406 v4l2_device_unregister(&dev->v4l2_dev);
1407 kfree(s); 1407 kfree(dev);
1408} 1408}
1409 1409
1410struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe, 1410struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
@@ -1412,138 +1412,138 @@ struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
1412 struct v4l2_subdev *sd) 1412 struct v4l2_subdev *sd)
1413{ 1413{
1414 int ret; 1414 int ret;
1415 struct rtl2832_sdr_state *s; 1415 struct rtl2832_sdr_dev *dev;
1416 const struct v4l2_ctrl_ops *ops = &rtl2832_sdr_ctrl_ops; 1416 const struct v4l2_ctrl_ops *ops = &rtl2832_sdr_ctrl_ops;
1417 struct dvb_usb_device *d = i2c_get_adapdata(i2c); 1417 struct dvb_usb_device *d = i2c_get_adapdata(i2c);
1418 1418
1419 s = kzalloc(sizeof(struct rtl2832_sdr_state), GFP_KERNEL); 1419 dev = kzalloc(sizeof(struct rtl2832_sdr_dev), GFP_KERNEL);
1420 if (s == NULL) { 1420 if (dev == NULL) {
1421 dev_err(&d->udev->dev, 1421 dev_err(&d->udev->dev,
1422 "Could not allocate memory for rtl2832_sdr_state\n"); 1422 "Could not allocate memory for rtl2832_sdr_dev\n");
1423 return NULL; 1423 return NULL;
1424 } 1424 }
1425 1425
1426 /* setup the state */ 1426 /* setup the state */
1427 s->fe = fe; 1427 dev->fe = fe;
1428 s->d = d; 1428 dev->d = d;
1429 s->udev = d->udev; 1429 dev->udev = d->udev;
1430 s->i2c = i2c; 1430 dev->i2c = i2c;
1431 s->cfg = cfg; 1431 dev->cfg = cfg;
1432 s->f_adc = bands_adc[0].rangelow; 1432 dev->f_adc = bands_adc[0].rangelow;
1433 s->f_tuner = bands_fm[0].rangelow; 1433 dev->f_tuner = bands_fm[0].rangelow;
1434 s->pixelformat = formats[0].pixelformat; 1434 dev->pixelformat = formats[0].pixelformat;
1435 s->buffersize = formats[0].buffersize; 1435 dev->buffersize = formats[0].buffersize;
1436 s->num_formats = NUM_FORMATS; 1436 dev->num_formats = NUM_FORMATS;
1437 if (!rtl2832_sdr_emulated_fmt) 1437 if (!rtl2832_sdr_emulated_fmt)
1438 s->num_formats -= 1; 1438 dev->num_formats -= 1;
1439 1439
1440 mutex_init(&s->v4l2_lock); 1440 mutex_init(&dev->v4l2_lock);
1441 mutex_init(&s->vb_queue_lock); 1441 mutex_init(&dev->vb_queue_lock);
1442 spin_lock_init(&s->queued_bufs_lock); 1442 spin_lock_init(&dev->queued_bufs_lock);
1443 INIT_LIST_HEAD(&s->queued_bufs); 1443 INIT_LIST_HEAD(&dev->queued_bufs);
1444 1444
1445 /* Init videobuf2 queue structure */ 1445 /* Init videobuf2 queue structure */
1446 s->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE; 1446 dev->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1447 s->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 1447 dev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1448 s->vb_queue.drv_priv = s; 1448 dev->vb_queue.drv_priv = dev;
1449 s->vb_queue.buf_struct_size = sizeof(struct rtl2832_sdr_frame_buf); 1449 dev->vb_queue.buf_struct_size = sizeof(struct rtl2832_sdr_frame_buf);
1450 s->vb_queue.ops = &rtl2832_sdr_vb2_ops; 1450 dev->vb_queue.ops = &rtl2832_sdr_vb2_ops;
1451 s->vb_queue.mem_ops = &vb2_vmalloc_memops; 1451 dev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1452 s->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1452 dev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1453 ret = vb2_queue_init(&s->vb_queue); 1453 ret = vb2_queue_init(&dev->vb_queue);
1454 if (ret) { 1454 if (ret) {
1455 dev_err(&s->udev->dev, "Could not initialize vb2 queue\n"); 1455 dev_err(&dev->udev->dev, "Could not initialize vb2 queue\n");
1456 goto err_free_mem; 1456 goto err_free_mem;
1457 } 1457 }
1458 1458
1459 /* Register controls */ 1459 /* Register controls */
1460 switch (s->cfg->tuner) { 1460 switch (dev->cfg->tuner) {
1461 case RTL2832_TUNER_E4000: 1461 case RTL2832_TUNER_E4000:
1462 v4l2_ctrl_handler_init(&s->hdl, 9); 1462 v4l2_ctrl_handler_init(&dev->hdl, 9);
1463 if (sd) 1463 if (sd)
1464 v4l2_ctrl_add_handler(&s->hdl, sd->ctrl_handler, NULL); 1464 v4l2_ctrl_add_handler(&dev->hdl, sd->ctrl_handler, NULL);
1465 break; 1465 break;
1466 case RTL2832_TUNER_R820T: 1466 case RTL2832_TUNER_R820T:
1467 v4l2_ctrl_handler_init(&s->hdl, 2); 1467 v4l2_ctrl_handler_init(&dev->hdl, 2);
1468 s->bandwidth_auto = v4l2_ctrl_new_std(&s->hdl, ops, 1468 dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, ops,
1469 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO, 1469 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1470 0, 1, 1, 1); 1470 0, 1, 1, 1);
1471 s->bandwidth = v4l2_ctrl_new_std(&s->hdl, ops, 1471 dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, ops,
1472 V4L2_CID_RF_TUNER_BANDWIDTH, 1472 V4L2_CID_RF_TUNER_BANDWIDTH,
1473 0, 8000000, 100000, 0); 1473 0, 8000000, 100000, 0);
1474 v4l2_ctrl_auto_cluster(2, &s->bandwidth_auto, 0, false); 1474 v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
1475 break; 1475 break;
1476 case RTL2832_TUNER_FC0012: 1476 case RTL2832_TUNER_FC0012:
1477 case RTL2832_TUNER_FC0013: 1477 case RTL2832_TUNER_FC0013:
1478 v4l2_ctrl_handler_init(&s->hdl, 2); 1478 v4l2_ctrl_handler_init(&dev->hdl, 2);
1479 s->bandwidth_auto = v4l2_ctrl_new_std(&s->hdl, ops, 1479 dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, ops,
1480 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO, 1480 V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
1481 0, 1, 1, 1); 1481 0, 1, 1, 1);
1482 s->bandwidth = v4l2_ctrl_new_std(&s->hdl, ops, 1482 dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, ops,
1483 V4L2_CID_RF_TUNER_BANDWIDTH, 1483 V4L2_CID_RF_TUNER_BANDWIDTH,
1484 6000000, 8000000, 1000000, 1484 6000000, 8000000, 1000000,
1485 6000000); 1485 6000000);
1486 v4l2_ctrl_auto_cluster(2, &s->bandwidth_auto, 0, false); 1486 v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
1487 break; 1487 break;
1488 default: 1488 default:
1489 v4l2_ctrl_handler_init(&s->hdl, 0); 1489 v4l2_ctrl_handler_init(&dev->hdl, 0);
1490 dev_notice(&s->udev->dev, "%s: Unsupported tuner\n", 1490 dev_notice(&dev->udev->dev, "%s: Unsupported tuner\n",
1491 KBUILD_MODNAME); 1491 KBUILD_MODNAME);
1492 goto err_free_controls; 1492 goto err_free_controls;
1493 } 1493 }
1494 1494
1495 if (s->hdl.error) { 1495 if (dev->hdl.error) {
1496 ret = s->hdl.error; 1496 ret = dev->hdl.error;
1497 dev_err(&s->udev->dev, "Could not initialize controls\n"); 1497 dev_err(&dev->udev->dev, "Could not initialize controls\n");
1498 goto err_free_controls; 1498 goto err_free_controls;
1499 } 1499 }
1500 1500
1501 /* Init video_device structure */ 1501 /* Init video_device structure */
1502 s->vdev = rtl2832_sdr_template; 1502 dev->vdev = rtl2832_sdr_template;
1503 s->vdev.queue = &s->vb_queue; 1503 dev->vdev.queue = &dev->vb_queue;
1504 s->vdev.queue->lock = &s->vb_queue_lock; 1504 dev->vdev.queue->lock = &dev->vb_queue_lock;
1505 video_set_drvdata(&s->vdev, s); 1505 video_set_drvdata(&dev->vdev, dev);
1506 1506
1507 /* Register the v4l2_device structure */ 1507 /* Register the v4l2_device structure */
1508 s->v4l2_dev.release = rtl2832_sdr_video_release; 1508 dev->v4l2_dev.release = rtl2832_sdr_video_release;
1509 ret = v4l2_device_register(&s->udev->dev, &s->v4l2_dev); 1509 ret = v4l2_device_register(&dev->udev->dev, &dev->v4l2_dev);
1510 if (ret) { 1510 if (ret) {
1511 dev_err(&s->udev->dev, 1511 dev_err(&dev->udev->dev,
1512 "Failed to register v4l2-device (%d)\n", ret); 1512 "Failed to register v4l2-device (%d)\n", ret);
1513 goto err_free_controls; 1513 goto err_free_controls;
1514 } 1514 }
1515 1515
1516 s->v4l2_dev.ctrl_handler = &s->hdl; 1516 dev->v4l2_dev.ctrl_handler = &dev->hdl;
1517 s->vdev.v4l2_dev = &s->v4l2_dev; 1517 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1518 s->vdev.lock = &s->v4l2_lock; 1518 dev->vdev.lock = &dev->v4l2_lock;
1519 s->vdev.vfl_dir = VFL_DIR_RX; 1519 dev->vdev.vfl_dir = VFL_DIR_RX;
1520 1520
1521 ret = video_register_device(&s->vdev, VFL_TYPE_SDR, -1); 1521 ret = video_register_device(&dev->vdev, VFL_TYPE_SDR, -1);
1522 if (ret) { 1522 if (ret) {
1523 dev_err(&s->udev->dev, 1523 dev_err(&dev->udev->dev,
1524 "Failed to register as video device (%d)\n", 1524 "Failed to register as video device (%d)\n",
1525 ret); 1525 ret);
1526 goto err_unregister_v4l2_dev; 1526 goto err_unregister_v4l2_dev;
1527 } 1527 }
1528 dev_info(&s->udev->dev, "Registered as %s\n", 1528 dev_info(&dev->udev->dev, "Registered as %s\n",
1529 video_device_node_name(&s->vdev)); 1529 video_device_node_name(&dev->vdev));
1530 1530
1531 fe->sec_priv = s; 1531 fe->sec_priv = dev;
1532 fe->ops.release_sec = rtl2832_sdr_release_sec; 1532 fe->ops.release_sec = rtl2832_sdr_release_sec;
1533 1533
1534 dev_info(&s->i2c->dev, "%s: Realtek RTL2832 SDR attached\n", 1534 dev_info(&dev->i2c->dev, "%s: Realtek RTL2832 SDR attached\n",
1535 KBUILD_MODNAME); 1535 KBUILD_MODNAME);
1536 dev_notice(&s->udev->dev, 1536 dev_notice(&dev->udev->dev,
1537 "%s: SDR API is still slightly experimental and functionality changes may follow\n", 1537 "%s: SDR API is still slightly experimental and functionality changes may follow\n",
1538 KBUILD_MODNAME); 1538 KBUILD_MODNAME);
1539 return fe; 1539 return fe;
1540 1540
1541err_unregister_v4l2_dev: 1541err_unregister_v4l2_dev:
1542 v4l2_device_unregister(&s->v4l2_dev); 1542 v4l2_device_unregister(&dev->v4l2_dev);
1543err_free_controls: 1543err_free_controls:
1544 v4l2_ctrl_handler_free(&s->hdl); 1544 v4l2_ctrl_handler_free(&dev->hdl);
1545err_free_mem: 1545err_free_mem:
1546 kfree(s); 1546 kfree(dev);
1547 return NULL; 1547 return NULL;
1548} 1548}
1549EXPORT_SYMBOL(rtl2832_sdr_attach); 1549EXPORT_SYMBOL(rtl2832_sdr_attach);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-25 05:44:43 -0500