tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

media: dw2102: fix coding style issues

Use checkpatch --strict --in-place to cleanup most style issues.
Then, do some manual work to fix most of the remaining issues.

Signed-off-by: Mauro Carvalho Chehab <mchehab@kernel.org>

Mauro Carvalho Chehab 4a7d7351 efc3e49d

+132 -141
+132 -141
drivers/media/usb/dvb-usb/dw2102.c
··· 36 36 /* Max transfer size done by I2C transfer functions */ 37 37 #define MAX_XFER_SIZE 64 38 38 39 - 40 39 #define DW210X_READ_MSG 0 41 40 #define DW210X_WRITE_MSG 1 42 41 ··· 98 99 if (!u8buf) 99 100 return -ENOMEM; 100 101 101 - 102 102 if (flags == DW210X_WRITE_MSG) 103 103 memcpy(u8buf, data, len); 104 104 ret = usb_control_msg(dev, pipe, request, request_type | USB_TYPE_VENDOR, 105 - value, index, u8buf, len, 2000); 105 + value, index, u8buf, len, 2000); 106 106 107 107 if (flags == DW210X_READ_MSG) 108 108 memcpy(data, u8buf, len); ··· 112 114 113 115 /* I2C */ 114 116 static int dw2102_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 115 - int num) 117 + int num) 116 118 { 117 119 struct dvb_usb_device *d = i2c_get_adapdata(adap); 118 120 int i = 0; ··· 134 136 value = msg[0].buf[0];/* register */ 135 137 for (i = 0; i < msg[1].len; i++) { 136 138 dw210x_op_rw(d->udev, 0xb5, value + i, 0, 137 - buf6, 2, DW210X_READ_MSG); 139 + buf6, 2, DW210X_READ_MSG); 138 140 msg[1].buf[i] = buf6[0]; 139 141 } 140 142 break; ··· 150 152 buf6[1] = msg[0].buf[0]; 151 153 buf6[2] = msg[0].buf[1]; 152 154 dw210x_op_rw(d->udev, 0xb2, 0, 0, 153 - buf6, 3, DW210X_WRITE_MSG); 155 + buf6, 3, DW210X_WRITE_MSG); 154 156 break; 155 157 case 0x60: 156 158 if (msg[0].flags == 0) { ··· 167 169 buf6[5] = msg[0].buf[2]; 168 170 buf6[6] = msg[0].buf[3]; 169 171 dw210x_op_rw(d->udev, 0xb2, 0, 0, 170 - buf6, 7, DW210X_WRITE_MSG); 172 + buf6, 7, DW210X_WRITE_MSG); 171 173 } else { 172 174 if (msg[0].len < 1) { 173 175 num = -EOPNOTSUPP; ··· 175 177 } 176 178 /* read from tuner */ 177 179 dw210x_op_rw(d->udev, 0xb5, 0, 0, 178 - buf6, 1, DW210X_READ_MSG); 180 + buf6, 1, DW210X_READ_MSG); 179 181 msg[0].buf[0] = buf6[0]; 180 182 } 181 183 break; ··· 185 187 break; 186 188 } 187 189 dw210x_op_rw(d->udev, 0xb8, 0, 0, 188 - buf6, 2, DW210X_READ_MSG); 190 + buf6, 2, DW210X_READ_MSG); 189 191 msg[0].buf[0] = buf6[0]; 190 192 msg[0].buf[1] = buf6[1]; 191 193 break; ··· 197 199 buf6[0] = 0x30; 198 200 buf6[1] = msg[0].buf[0]; 199 201 dw210x_op_rw(d->udev, 0xb2, 0, 0, 200 - buf6, 2, DW210X_WRITE_MSG); 202 + buf6, 2, DW210X_WRITE_MSG); 201 203 break; 202 204 } 203 205 ··· 209 211 } 210 212 211 213 static int dw2102_serit_i2c_transfer(struct i2c_adapter *adap, 212 - struct i2c_msg msg[], int num) 214 + struct i2c_msg msg[], int num) 213 215 { 214 216 struct dvb_usb_device *d = i2c_get_adapdata(adap); 215 217 u8 buf6[] = {0, 0, 0, 0, 0, 0, 0}; ··· 240 242 buf6[1] = msg[0].len; 241 243 buf6[2] = msg[0].buf[0]; 242 244 dw210x_op_rw(d->udev, 0xc2, 0, 0, 243 - buf6, msg[0].len + 2, DW210X_WRITE_MSG); 245 + buf6, msg[0].len + 2, DW210X_WRITE_MSG); 244 246 /* read si2109 register */ 245 247 dw210x_op_rw(d->udev, 0xc3, 0xd0, 0, 246 - buf6, msg[1].len + 2, DW210X_READ_MSG); 248 + buf6, msg[1].len + 2, DW210X_READ_MSG); 247 249 memcpy(msg[1].buf, buf6 + 2, msg[1].len); 248 250 249 251 break; ··· 262 264 buf6[1] = msg[0].len; 263 265 memcpy(buf6 + 2, msg[0].buf, msg[0].len); 264 266 dw210x_op_rw(d->udev, 0xc2, 0, 0, buf6, 265 - msg[0].len + 2, DW210X_WRITE_MSG); 267 + msg[0].len + 2, DW210X_WRITE_MSG); 266 268 break; 267 269 case(DW2102_RC_QUERY): 268 270 dw210x_op_rw(d->udev, 0xb8, 0, 0, 269 - buf6, 2, DW210X_READ_MSG); 271 + buf6, 2, DW210X_READ_MSG); 270 272 msg[0].buf[0] = buf6[0]; 271 273 msg[0].buf[1] = buf6[1]; 272 274 break; ··· 274 276 buf6[0] = 0x30; 275 277 buf6[1] = msg[0].buf[0]; 276 278 dw210x_op_rw(d->udev, 0xb2, 0, 0, 277 - buf6, 2, DW210X_WRITE_MSG); 279 + buf6, 2, DW210X_WRITE_MSG); 278 280 break; 279 281 } 280 282 break; ··· 318 320 obuf[1] = msg[0].len; 319 321 obuf[2] = msg[0].buf[0]; 320 322 dw210x_op_rw(d->udev, 0xc2, 0, 0, 321 - obuf, msg[0].len + 2, DW210X_WRITE_MSG); 323 + obuf, msg[0].len + 2, DW210X_WRITE_MSG); 322 324 /* second read registers */ 323 325 dw210x_op_rw(d->udev, 0xc3, 0xd1, 0, 324 - ibuf, msg[1].len + 2, DW210X_READ_MSG); 326 + ibuf, msg[1].len + 2, DW210X_READ_MSG); 325 327 memcpy(msg[1].buf, ibuf + 2, msg[1].len); 326 328 327 329 break; ··· 343 345 obuf[1] = msg[0].len; 344 346 memcpy(obuf + 2, msg[0].buf, msg[0].len); 345 347 dw210x_op_rw(d->udev, 0xc2, 0, 0, 346 - obuf, msg[0].len + 2, DW210X_WRITE_MSG); 348 + obuf, msg[0].len + 2, DW210X_WRITE_MSG); 347 349 break; 348 350 } 349 351 case 0x61: { ··· 361 363 obuf[1] = msg[0].len; 362 364 memcpy(obuf + 2, msg[0].buf, msg[0].len); 363 365 dw210x_op_rw(d->udev, 0xc2, 0, 0, 364 - obuf, msg[0].len + 2, DW210X_WRITE_MSG); 366 + obuf, msg[0].len + 2, DW210X_WRITE_MSG); 365 367 break; 366 368 } 367 369 case(DW2102_RC_QUERY): { 368 370 u8 ibuf[2]; 369 371 370 372 dw210x_op_rw(d->udev, 0xb8, 0, 0, 371 - ibuf, 2, DW210X_READ_MSG); 373 + ibuf, 2, DW210X_READ_MSG); 372 374 memcpy(msg[0].buf, ibuf, 2); 373 375 break; 374 376 } ··· 378 380 obuf[0] = 0x30; 379 381 obuf[1] = msg[0].buf[0]; 380 382 dw210x_op_rw(d->udev, 0xb2, 0, 0, 381 - obuf, 2, DW210X_WRITE_MSG); 383 + obuf, 2, DW210X_WRITE_MSG); 382 384 break; 383 385 } 384 386 } ··· 408 410 u8 ibuf[2]; 409 411 410 412 dw210x_op_rw(d->udev, 0xb8, 0, 0, 411 - ibuf, 2, DW210X_READ_MSG); 413 + ibuf, 2, DW210X_READ_MSG); 412 414 memcpy(msg[j].buf, ibuf, 2); 413 415 break; 414 416 } ··· 418 420 obuf[0] = 0x30; 419 421 obuf[1] = msg[j].buf[0]; 420 422 dw210x_op_rw(d->udev, 0xb2, 0, 0, 421 - obuf, 2, DW210X_WRITE_MSG); 423 + obuf, 2, DW210X_WRITE_MSG); 422 424 break; 423 425 } 424 426 /* case 0x55: cx24116 ··· 439 441 } 440 442 441 443 dw210x_op_rw(d->udev, 0xc3, 442 - (msg[j].addr << 1) + 1, 0, 443 - ibuf, msg[j].len + 2, 444 - DW210X_READ_MSG); 444 + (msg[j].addr << 1) + 1, 0, 445 + ibuf, msg[j].len + 2, 446 + DW210X_READ_MSG); 445 447 memcpy(msg[j].buf, ibuf + 2, msg[j].len); 446 448 mdelay(10); 447 - } else if (((msg[j].buf[0] == 0xb0) && 448 - (msg[j].addr == 0x68)) || 449 - ((msg[j].buf[0] == 0xf7) && 450 - (msg[j].addr == 0x55))) { 449 + } else if (((msg[j].buf[0] == 0xb0) && (msg[j].addr == 0x68)) || 450 + ((msg[j].buf[0] == 0xf7) && (msg[j].addr == 0x55))) { 451 451 /* write firmware */ 452 452 u8 obuf[19]; 453 453 ··· 456 460 i = 1; 457 461 do { 458 462 memcpy(obuf + 3, msg[j].buf + i, 459 - (len > 16 ? 16 : len)); 463 + (len > 16 ? 16 : len)); 460 464 dw210x_op_rw(d->udev, 0xc2, 0, 0, 461 - obuf, (len > 16 ? 16 : len) + 3, 462 - DW210X_WRITE_MSG); 465 + obuf, (len > 16 ? 16 : len) + 3, 466 + DW210X_WRITE_MSG); 463 467 i += 16; 464 468 len -= 16; 465 469 } while (len > 0); ··· 478 482 obuf[1] = msg[j].len; 479 483 memcpy(obuf + 2, msg[j].buf, msg[j].len); 480 484 dw210x_op_rw(d->udev, 0xc2, 0, 0, 481 - obuf, msg[j].len + 2, 482 - DW210X_WRITE_MSG); 485 + obuf, msg[j].len + 2, 486 + DW210X_WRITE_MSG); 483 487 } 484 488 break; 485 489 } 486 490 } 487 - 488 491 } 489 492 ret = num; 490 493 ··· 493 498 } 494 499 495 500 static int dw3101_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 496 - int num) 501 + int num) 497 502 { 498 503 struct dvb_usb_device *d = i2c_get_adapdata(adap); 499 504 int ret; ··· 526 531 obuf[1] = msg[0].len; 527 532 obuf[2] = msg[0].buf[0]; 528 533 dw210x_op_rw(d->udev, 0xc2, 0, 0, 529 - obuf, msg[0].len + 2, DW210X_WRITE_MSG); 534 + obuf, msg[0].len + 2, DW210X_WRITE_MSG); 530 535 /* second read registers */ 531 536 dw210x_op_rw(d->udev, 0xc3, 0x19, 0, 532 - ibuf, msg[1].len + 2, DW210X_READ_MSG); 537 + ibuf, msg[1].len + 2, DW210X_READ_MSG); 533 538 memcpy(msg[1].buf, ibuf + 2, msg[1].len); 534 539 535 540 break; ··· 551 556 obuf[1] = msg[0].len; 552 557 memcpy(obuf + 2, msg[0].buf, msg[0].len); 553 558 dw210x_op_rw(d->udev, 0xc2, 0, 0, 554 - obuf, msg[0].len + 2, DW210X_WRITE_MSG); 559 + obuf, msg[0].len + 2, DW210X_WRITE_MSG); 555 560 break; 556 561 } 557 562 case(DW2102_RC_QUERY): { 558 563 u8 ibuf[2]; 559 564 560 565 dw210x_op_rw(d->udev, 0xb8, 0, 0, 561 - ibuf, 2, DW210X_READ_MSG); 566 + ibuf, 2, DW210X_READ_MSG); 562 567 memcpy(msg[0].buf, ibuf, 2); 563 568 break; 564 569 } ··· 569 574 570 575 for (i = 0; i < num; i++) { 571 576 deb_xfer("%02x:%02x: %s ", i, msg[i].addr, 572 - msg[i].flags == 0 ? ">>>" : "<<<"); 577 + msg[i].flags == 0 ? ">>>" : "<<<"); 573 578 debug_dump(msg[i].buf, msg[i].len, deb_xfer); 574 579 } 575 580 ret = num; ··· 580 585 } 581 586 582 587 static int s6x0_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 583 - int num) 588 + int num) 584 589 { 585 590 struct dvb_usb_device *d = i2c_get_adapdata(adap); 586 591 struct usb_device *udev; ··· 598 603 u8 ibuf[5]; 599 604 600 605 dw210x_op_rw(d->udev, 0xb8, 0, 0, 601 - ibuf, 5, DW210X_READ_MSG); 606 + ibuf, 5, DW210X_READ_MSG); 602 607 memcpy(msg[j].buf, ibuf + 3, 2); 603 608 break; 604 609 } ··· 608 613 obuf[0] = 1; 609 614 obuf[1] = msg[j].buf[1];/* off-on */ 610 615 dw210x_op_rw(d->udev, 0x8a, 0, 0, 611 - obuf, 2, DW210X_WRITE_MSG); 616 + obuf, 2, DW210X_WRITE_MSG); 612 617 obuf[0] = 3; 613 618 obuf[1] = msg[j].buf[0];/* 13v-18v */ 614 619 dw210x_op_rw(d->udev, 0x8a, 0, 0, 615 - obuf, 2, DW210X_WRITE_MSG); 620 + obuf, 2, DW210X_WRITE_MSG); 616 621 break; 617 622 } 618 623 case (DW2102_LED_CTRL): { ··· 621 626 obuf[0] = 5; 622 627 obuf[1] = msg[j].buf[0]; 623 628 dw210x_op_rw(d->udev, 0x8a, 0, 0, 624 - obuf, 2, DW210X_WRITE_MSG); 629 + obuf, 2, DW210X_WRITE_MSG); 625 630 break; 626 631 } 627 632 /* case 0x55: cx24116 ··· 643 648 } 644 649 645 650 dw210x_op_rw(d->udev, 0x91, 0, 0, 646 - ibuf, msg[j].len, 651 + ibuf, msg[j].len, 647 652 DW210X_READ_MSG); 648 653 memcpy(msg[j].buf, ibuf, msg[j].len); 649 654 break; 650 - } else if ((msg[j].buf[0] == 0xb0) && 651 - (msg[j].addr == 0x68)) { 655 + } else if ((msg[j].buf[0] == 0xb0) && (msg[j].addr == 0x68)) { 652 656 /* write firmware */ 653 657 u8 obuf[19]; 654 658 ··· 659 665 i = 1; 660 666 do { 661 667 memcpy(obuf + 3, msg[j].buf + i, 662 - (len > 16 ? 16 : len)); 668 + (len > 16 ? 16 : len)); 663 669 dw210x_op_rw(d->udev, 0x80, 0, 0, 664 - obuf, (len > 16 ? 16 : len) + 3, 665 - DW210X_WRITE_MSG); 670 + obuf, (len > 16 ? 16 : len) + 3, 671 + DW210X_WRITE_MSG); 666 672 i += 16; 667 673 len -= 16; 668 674 } while (len > 0); ··· 681 687 obuf[1] = (msg[j].addr << 1); 682 688 memcpy(obuf + 2, msg[j].buf, msg[j].len); 683 689 dw210x_op_rw(d->udev, 684 - le16_to_cpu(udev->descriptor.idProduct) == 685 - 0x7500 ? 0x92 : 0x90, 0, 0, 686 - obuf, msg[j].len + 2, 687 - DW210X_WRITE_MSG); 690 + le16_to_cpu(udev->descriptor.idProduct) == 0x7500 ? 0x92 : 0x90, 691 + 0, 0, obuf, msg[j].len + 2, 692 + DW210X_WRITE_MSG); 688 693 break; 689 694 } else { 690 695 /* write registers */ ··· 699 706 obuf[1] = (msg[j].addr << 1); 700 707 memcpy(obuf + 2, msg[j].buf, msg[j].len); 701 708 dw210x_op_rw(d->udev, 0x80, 0, 0, 702 - obuf, msg[j].len + 2, 703 - DW210X_WRITE_MSG); 709 + obuf, msg[j].len + 2, 710 + DW210X_WRITE_MSG); 704 711 break; 705 712 } 706 713 break; ··· 715 722 } 716 723 717 724 static int su3000_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 718 - int num) 725 + int num) 719 726 { 720 727 struct dvb_usb_device *d = i2c_get_adapdata(adap); 721 728 struct dw2102_state *state; ··· 741 748 state->data[1] = 3; 742 749 state->data[2] = 0; 743 750 if (dvb_usb_generic_rw(d, state->data, 3, 744 - state->data, 0, 0) < 0) 751 + state->data, 0, 0) < 0) 745 752 err("i2c transfer failed."); 746 753 break; 747 754 case DW2102_RC_QUERY: 748 755 state->data[0] = 0x10; 749 756 if (dvb_usb_generic_rw(d, state->data, 1, 750 - state->data, 2, 0) < 0) 757 + state->data, 2, 0) < 0) 751 758 err("i2c transfer failed."); 752 759 msg[j].buf[1] = state->data[0]; 753 760 msg[j].buf[0] = state->data[1]; ··· 756 763 /* if the current write msg is followed by a another 757 764 * read msg to/from the same address 758 765 */ 759 - if ((j+1 < num) && (msg[j+1].flags & I2C_M_RD) && 760 - (msg[j].addr == msg[j+1].addr)) { 766 + if ((j + 1 < num) && (msg[j + 1].flags & I2C_M_RD) && 767 + (msg[j].addr == msg[j + 1].addr)) { 761 768 /* join both i2c msgs to one usb read command */ 762 769 if (4 + msg[j].len > sizeof(state->data)) { 763 770 warn("i2c combined wr/rd: write len=%d is too big!\n", 764 - msg[j].len); 771 + msg[j].len); 765 772 num = -EOPNOTSUPP; 766 773 break; 767 774 } 768 - if (1 + msg[j+1].len > sizeof(state->data)) { 775 + if (1 + msg[j + 1].len > sizeof(state->data)) { 769 776 warn("i2c combined wr/rd: read len=%d is too big!\n", 770 - msg[j+1].len); 777 + msg[j + 1].len); 771 778 num = -EOPNOTSUPP; 772 779 break; 773 780 } 774 781 775 782 state->data[0] = 0x09; 776 783 state->data[1] = msg[j].len; 777 - state->data[2] = msg[j+1].len; 784 + state->data[2] = msg[j + 1].len; 778 785 state->data[3] = msg[j].addr; 779 786 memcpy(&state->data[4], msg[j].buf, msg[j].len); 780 787 781 788 if (dvb_usb_generic_rw(d, state->data, msg[j].len + 4, 782 - state->data, msg[j+1].len + 1, 0) < 0) 789 + state->data, msg[j + 1].len + 1, 0) < 0) 783 790 err("i2c transfer failed."); 784 791 785 - memcpy(msg[j+1].buf, &state->data[1], msg[j+1].len); 792 + memcpy(msg[j + 1].buf, &state->data[1], msg[j + 1].len); 786 793 j++; 787 794 break; 788 795 } ··· 802 809 memcpy(&state->data[4], msg[j].buf, msg[j].len); 803 810 804 811 if (dvb_usb_generic_rw(d, state->data, 4, 805 - state->data, msg[j].len + 1, 0) < 0) 812 + state->data, msg[j].len + 1, 0) < 0) 806 813 err("i2c transfer failed."); 807 814 808 815 memcpy(msg[j].buf, &state->data[1], msg[j].len); ··· 823 830 memcpy(&state->data[3], msg[j].buf, msg[j].len); 824 831 825 832 if (dvb_usb_generic_rw(d, state->data, msg[j].len + 3, 826 - state->data, 1, 0) < 0) 833 + state->data, 1, 0) < 0) 827 834 err("i2c transfer failed."); 828 835 } // switch 829 836 j++; ··· 881 888 u8 eeprom[256], eepromline[16]; 882 889 883 890 for (i = 0; i < 256; i++) { 884 - if (dw210x_op_rw(d->udev, 0xb6, 0xa0 , i, ibuf, 2, DW210X_READ_MSG) < 0) { 891 + if (dw210x_op_rw(d->udev, 0xb6, 0xa0, i, ibuf, 2, DW210X_READ_MSG) < 0) { 885 892 err("read eeprom failed."); 886 893 return -EIO; 887 894 } else { 888 - eepromline[i%16] = ibuf[0]; 895 + eepromline[i % 16] = ibuf[0]; 889 896 eeprom[i] = ibuf[0]; 890 897 } 891 898 if ((i % 16) == 15) { ··· 992 999 .flags = I2C_M_RD, 993 1000 .buf = ibuf, 994 1001 .len = 1, 995 - 996 1002 } 997 1003 }; 998 1004 ··· 1029 1037 }; 1030 1038 1031 1039 struct dvb_usb_adapter *udev_adap = fe->dvb->priv; 1040 + 1032 1041 if (voltage == SEC_VOLTAGE_18) 1033 1042 msg.buf = command_18v; 1034 1043 else if (voltage == SEC_VOLTAGE_13) ··· 1233 1240 1234 1241 if (demod_probe & 4) { 1235 1242 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &dw2104a_stv0900_config, 1236 - &d->dev->i2c_adap, 0); 1237 - if (d->fe_adap[0].fe != NULL) { 1243 + &d->dev->i2c_adap, 0); 1244 + if (d->fe_adap[0].fe) { 1238 1245 if (dvb_attach(stb6100_attach, d->fe_adap[0].fe, 1239 - &dw2104a_stb6100_config, 1240 - &d->dev->i2c_adap)) { 1246 + &dw2104a_stb6100_config, 1247 + &d->dev->i2c_adap)) { 1241 1248 tuner_ops = &d->fe_adap[0].fe->ops.tuner_ops; 1242 1249 tuner_ops->set_frequency = stb6100_set_freq; 1243 1250 tuner_ops->get_frequency = stb6100_get_freq; ··· 1252 1259 1253 1260 if (demod_probe & 2) { 1254 1261 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &dw2104_stv0900_config, 1255 - &d->dev->i2c_adap, 0); 1256 - if (d->fe_adap[0].fe != NULL) { 1262 + &d->dev->i2c_adap, 0); 1263 + if (d->fe_adap[0].fe) { 1257 1264 if (dvb_attach(stv6110_attach, d->fe_adap[0].fe, 1258 - &dw2104_stv6110_config, 1259 - &d->dev->i2c_adap)) { 1265 + &dw2104_stv6110_config, 1266 + &d->dev->i2c_adap)) { 1260 1267 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1261 1268 info("Attached STV0900+STV6110A!"); 1262 1269 return 0; ··· 1266 1273 1267 1274 if (demod_probe & 1) { 1268 1275 d->fe_adap[0].fe = dvb_attach(cx24116_attach, &dw2104_config, 1269 - &d->dev->i2c_adap); 1270 - if (d->fe_adap[0].fe != NULL) { 1276 + &d->dev->i2c_adap); 1277 + if (d->fe_adap[0].fe) { 1271 1278 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1272 1279 info("Attached cx24116!"); 1273 1280 return 0; ··· 1275 1282 } 1276 1283 1277 1284 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config, 1278 - &d->dev->i2c_adap); 1279 - if (d->fe_adap[0].fe != NULL) { 1285 + &d->dev->i2c_adap); 1286 + if (d->fe_adap[0].fe) { 1280 1287 dvb_attach(ts2020_attach, d->fe_adap[0].fe, 1281 - &dw2104_ts2020_config, &d->dev->i2c_adap); 1288 + &dw2104_ts2020_config, &d->dev->i2c_adap); 1282 1289 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1283 1290 info("Attached DS3000!"); 1284 1291 return 0; ··· 1296 1303 if (dw2102_properties.i2c_algo == &dw2102_serit_i2c_algo) { 1297 1304 /*dw2102_properties.adapter->tuner_attach = NULL;*/ 1298 1305 d->fe_adap[0].fe = dvb_attach(si21xx_attach, &serit_sp1511lhb_config, 1299 - &d->dev->i2c_adap); 1300 - if (d->fe_adap[0].fe != NULL) { 1306 + &d->dev->i2c_adap); 1307 + if (d->fe_adap[0].fe) { 1301 1308 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1302 1309 info("Attached si21xx!"); 1303 1310 return 0; ··· 1306 1313 1307 1314 if (dw2102_properties.i2c_algo == &dw2102_earda_i2c_algo) { 1308 1315 d->fe_adap[0].fe = dvb_attach(stv0288_attach, &earda_config, 1309 - &d->dev->i2c_adap); 1310 - if (d->fe_adap[0].fe != NULL) { 1316 + &d->dev->i2c_adap); 1317 + if (d->fe_adap[0].fe) { 1311 1318 if (dvb_attach(stb6000_attach, d->fe_adap[0].fe, 0x61, 1312 - &d->dev->i2c_adap)) { 1319 + &d->dev->i2c_adap)) { 1313 1320 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1314 1321 info("Attached stv0288!"); 1315 1322 return 0; ··· 1320 1327 if (dw2102_properties.i2c_algo == &dw2102_i2c_algo) { 1321 1328 /*dw2102_properties.adapter->tuner_attach = dw2102_tuner_attach;*/ 1322 1329 d->fe_adap[0].fe = dvb_attach(stv0299_attach, &sharp_z0194a_config, 1323 - &d->dev->i2c_adap); 1324 - if (d->fe_adap[0].fe != NULL) { 1330 + &d->dev->i2c_adap); 1331 + if (d->fe_adap[0].fe) { 1325 1332 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1326 1333 info("Attached stv0299!"); 1327 1334 return 0; ··· 1333 1340 static int dw3101_frontend_attach(struct dvb_usb_adapter *d) 1334 1341 { 1335 1342 d->fe_adap[0].fe = dvb_attach(tda10023_attach, &dw3101_tda10023_config, 1336 - &d->dev->i2c_adap, 0x48); 1337 - if (d->fe_adap[0].fe != NULL) { 1343 + &d->dev->i2c_adap, 0x48); 1344 + if (d->fe_adap[0].fe) { 1338 1345 info("Attached tda10023!"); 1339 1346 return 0; 1340 1347 } ··· 1344 1351 static int zl100313_frontend_attach(struct dvb_usb_adapter *d) 1345 1352 { 1346 1353 d->fe_adap[0].fe = dvb_attach(mt312_attach, &zl313_config, 1347 - &d->dev->i2c_adap); 1348 - if (d->fe_adap[0].fe != NULL) { 1354 + &d->dev->i2c_adap); 1355 + if (d->fe_adap[0].fe) { 1349 1356 if (dvb_attach(zl10039_attach, d->fe_adap[0].fe, 0x60, 1350 - &d->dev->i2c_adap)) { 1357 + &d->dev->i2c_adap)) { 1351 1358 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1352 1359 info("Attached zl100313+zl10039!"); 1353 1360 return 0; ··· 1362 1369 u8 obuf[] = {7, 1}; 1363 1370 1364 1371 d->fe_adap[0].fe = dvb_attach(stv0288_attach, &earda_config, 1365 - &d->dev->i2c_adap); 1372 + &d->dev->i2c_adap); 1366 1373 1367 - if (d->fe_adap[0].fe == NULL) 1374 + if (!d->fe_adap[0].fe) 1368 1375 return -EIO; 1369 1376 1370 1377 if (dvb_attach(stb6000_attach, d->fe_adap[0].fe, 0x61, &d->dev->i2c_adap) == NULL) ··· 1377 1384 info("Attached stv0288+stb6000!"); 1378 1385 1379 1386 return 0; 1380 - 1381 1387 } 1382 1388 1383 1389 static int ds3000_frontend_attach(struct dvb_usb_adapter *d) ··· 1385 1393 u8 obuf[] = {7, 1}; 1386 1394 1387 1395 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &s660_ds3000_config, 1388 - &d->dev->i2c_adap); 1396 + &d->dev->i2c_adap); 1389 1397 1390 - if (d->fe_adap[0].fe == NULL) 1398 + if (!d->fe_adap[0].fe) 1391 1399 return -EIO; 1392 1400 1393 1401 dvb_attach(ts2020_attach, d->fe_adap[0].fe, &s660_ts2020_config, 1394 - &d->dev->i2c_adap); 1402 + &d->dev->i2c_adap); 1395 1403 1396 1404 st->old_set_voltage = d->fe_adap[0].fe->ops.set_voltage; 1397 1405 d->fe_adap[0].fe->ops.set_voltage = s660_set_voltage; ··· 1408 1416 u8 obuf[] = {7, 1}; 1409 1417 1410 1418 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &prof_7500_stv0900_config, 1411 - &d->dev->i2c_adap, 0); 1412 - if (d->fe_adap[0].fe == NULL) 1419 + &d->dev->i2c_adap, 0); 1420 + if (!d->fe_adap[0].fe) 1413 1421 return -EIO; 1414 1422 1415 1423 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; ··· 1465 1473 mutex_unlock(&d->data_mutex); 1466 1474 1467 1475 adap->fe_adap[0].fe = dvb_attach(ds3000_attach, &su3000_ds3000_config, 1468 - &d->i2c_adap); 1469 - if (adap->fe_adap[0].fe == NULL) 1476 + &d->i2c_adap); 1477 + if (!adap->fe_adap[0].fe) 1470 1478 return -EIO; 1471 1479 1472 1480 if (dvb_attach(ts2020_attach, adap->fe_adap[0].fe, 1473 - &dw2104_ts2020_config, 1481 + &dw2104_ts2020_config, 1474 1482 &d->i2c_adap)) { 1475 1483 info("Attached DS3000/TS2020!"); 1476 1484 return 0; ··· 1525 1533 mutex_unlock(&d->data_mutex); 1526 1534 1527 1535 adap->fe_adap[0].fe = dvb_attach(cxd2820r_attach, &cxd2820r_config, 1528 - &d->i2c_adap, NULL); 1529 - if (adap->fe_adap[0].fe != NULL) { 1536 + &d->i2c_adap, NULL); 1537 + if (adap->fe_adap[0].fe) { 1530 1538 if (dvb_attach(tda18271_attach, adap->fe_adap[0].fe, 0x60, 1531 - &d->i2c_adap, &tda18271_config)) { 1539 + &d->i2c_adap, &tda18271_config)) { 1532 1540 info("Attached TDA18271HD/CXD2820R!"); 1533 1541 return 0; 1534 1542 } ··· 1553 1561 mutex_unlock(&d->data_mutex); 1554 1562 1555 1563 adap->fe_adap[0].fe = dvb_attach(m88rs2000_attach, 1556 - &s421_m88rs2000_config, 1557 - &d->i2c_adap); 1564 + &s421_m88rs2000_config, 1565 + &d->i2c_adap); 1558 1566 1559 - if (adap->fe_adap[0].fe == NULL) 1567 + if (!adap->fe_adap[0].fe) 1560 1568 return -EIO; 1561 1569 1562 1570 if (dvb_attach(ts2020_attach, adap->fe_adap[0].fe, 1563 - &dw2104_ts2020_config, 1571 + &dw2104_ts2020_config, 1564 1572 &d->i2c_adap)) { 1565 1573 info("Attached RS2000/TS2020!"); 1566 1574 return 0; ··· 1727 1735 static int dw2102_tuner_attach(struct dvb_usb_adapter *adap) 1728 1736 { 1729 1737 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, 1730 - &adap->dev->i2c_adap, DVB_PLL_OPERA1); 1738 + &adap->dev->i2c_adap, DVB_PLL_OPERA1); 1731 1739 return 0; 1732 1740 } 1733 1741 1734 1742 static int dw3101_tuner_attach(struct dvb_usb_adapter *adap) 1735 1743 { 1736 1744 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, 1737 - &adap->dev->i2c_adap, DVB_PLL_TUA6034); 1745 + &adap->dev->i2c_adap, DVB_PLL_TUA6034); 1738 1746 1739 1747 return 0; 1740 1748 } ··· 1752 1760 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) { 1753 1761 if (msg.buf[0] != 0xff) { 1754 1762 deb_rc("%s: rc code: %x, %x\n", 1755 - __func__, key[0], key[1]); 1763 + __func__, key[0], key[1]); 1756 1764 rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN, key[0], 0); 1757 1765 } 1758 1766 } ··· 1773 1781 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) { 1774 1782 if (msg.buf[0] != 0xff) { 1775 1783 deb_rc("%s: rc code: %x, %x\n", 1776 - __func__, key[0], key[1]); 1784 + __func__, key[0], key[1]); 1777 1785 rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN, key[0] ^ 0xff, 1778 1786 0); 1779 1787 } ··· 1795 1803 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) { 1796 1804 if (msg.buf[0] != 0xff) { 1797 1805 deb_rc("%s: rc code: %x, %x\n", 1798 - __func__, key[0], key[1]); 1806 + __func__, key[0], key[1]); 1799 1807 rc_keydown(d->rc_dev, RC_PROTO_RC5, 1800 1808 RC_SCANCODE_RC5(key[1], key[0]), 0); 1801 1809 } ··· 1872 1880 MODULE_DEVICE_TABLE(usb, dw2102_table); 1873 1881 1874 1882 static int dw2102_load_firmware(struct usb_device *dev, 1875 - const struct firmware *frmwr) 1883 + const struct firmware *frmwr) 1876 1884 { 1877 1885 u8 *b, *p; 1878 1886 int ret = 0, i; ··· 1899 1907 dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1, DW210X_WRITE_MSG); 1900 1908 dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1, DW210X_WRITE_MSG); 1901 1909 1902 - if (p != NULL) { 1910 + if (p) { 1903 1911 memcpy(p, fw->data, fw->size); 1904 1912 for (i = 0; i < fw->size; i += 0x40) { 1905 - b = (u8 *) p + i; 1913 + b = (u8 *)p + i; 1906 1914 if (dw210x_op_rw(dev, 0xa0, i, 0, b, 0x40, 1907 - DW210X_WRITE_MSG) != 0x40) { 1915 + DW210X_WRITE_MSG) != 0x40) { 1908 1916 err("error while transferring firmware"); 1909 1917 ret = -EINVAL; 1910 1918 break; ··· 1930 1938 case USB_PID_CYPRESS_DW2104: 1931 1939 reset = 1; 1932 1940 dw210x_op_rw(dev, 0xc4, 0x0000, 0, &reset, 1, 1933 - DW210X_WRITE_MSG); 1941 + DW210X_WRITE_MSG); 1934 1942 fallthrough; 1935 1943 case USB_PID_CYPRESS_DW3101: 1936 1944 reset = 0; 1937 1945 dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0, 1938 - DW210X_WRITE_MSG); 1946 + DW210X_WRITE_MSG); 1939 1947 break; 1940 1948 case USB_PID_TERRATEC_CINERGY_S: 1941 1949 case USB_PID_CYPRESS_DW2102: 1942 1950 dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0, 1943 - DW210X_WRITE_MSG); 1951 + DW210X_WRITE_MSG); 1944 1952 dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2, 1945 - DW210X_READ_MSG); 1953 + DW210X_READ_MSG); 1946 1954 /* check STV0299 frontend */ 1947 1955 dw210x_op_rw(dev, 0xb5, 0, 0, &reset16[0], 2, 1948 - DW210X_READ_MSG); 1956 + DW210X_READ_MSG); 1949 1957 if ((reset16[0] == 0xa1) || (reset16[0] == 0x80)) { 1950 1958 dw2102_properties.i2c_algo = &dw2102_i2c_algo; 1951 1959 dw2102_properties.adapter->fe[0].tuner_attach = &dw2102_tuner_attach; ··· 1956 1964 reset16[1] = 1; 1957 1965 reset16[2] = 0; 1958 1966 dw210x_op_rw(dev, 0xc2, 0, 0, &reset16[0], 3, 1959 - DW210X_WRITE_MSG); 1967 + DW210X_WRITE_MSG); 1960 1968 dw210x_op_rw(dev, 0xc3, 0xd1, 0, &reset16[0], 3, 1961 - DW210X_READ_MSG); 1969 + DW210X_READ_MSG); 1962 1970 if (reset16[2] == 0x11) { 1963 1971 dw2102_properties.i2c_algo = &dw2102_earda_i2c_algo; 1964 1972 break; ··· 1966 1974 fallthrough; 1967 1975 case 0x2101: 1968 1976 dw210x_op_rw(dev, 0xbc, 0x0030, 0, &reset16[0], 2, 1969 - DW210X_READ_MSG); 1977 + DW210X_READ_MSG); 1970 1978 dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7, 1971 - DW210X_READ_MSG); 1979 + DW210X_READ_MSG); 1972 1980 dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7, 1973 - DW210X_READ_MSG); 1981 + DW210X_READ_MSG); 1974 1982 dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2, 1975 - DW210X_READ_MSG); 1983 + DW210X_READ_MSG); 1976 1984 break; 1977 1985 } 1978 1986 ··· 2585 2593 }; 2586 2594 2587 2595 static int dw2102_probe(struct usb_interface *intf, 2588 - const struct usb_device_id *id) 2596 + const struct usb_device_id *id) 2589 2597 { 2590 2598 if (!(dvb_usb_device_init(intf, &dw2102_properties, 2591 2599 THIS_MODULE, NULL, adapter_nr) && ··· 2609 2617 THIS_MODULE, NULL, adapter_nr) && 2610 2618 dvb_usb_device_init(intf, &tt_s2_4600_properties, 2611 2619 THIS_MODULE, NULL, adapter_nr))) { 2612 - 2613 2620 return 0; 2614 2621 } 2615 2622