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.

Merge tag 'staging-4.1-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Pull staging / IIO fixes from Greg KH:
"Here are some IIO driver fixes to resolve reported issues, some ozwpan
fixes for some reported CVE problems, and a rtl8712 driver fix for a
reported regression.

All have been in linux-next successfully"

* tag 'staging-4.1-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging:
staging: rtl8712: fix stack dump
ozwpan: unchecked signed subtraction leads to DoS
ozwpan: divide-by-zero leading to panic
ozwpan: Use unsigned ints to prevent heap overflow
ozwpan: Use proper check to prevent heap overflow
iio: adc: twl6030-gpadc: Fix modalias
iio: adis16400: Fix burst transfer for adis16448
iio: adis16400: Fix burst mode
iio: adis16400: Compute the scan mask from channel indices
iio: adis16400: Use != channel indices for the two voltage channels
iio: adis16400: Report pressure channel scale

Linus Torvalds eadc21f5 b334b773

+148 -110
+1 -1
drivers/iio/adc/twl6030-gpadc.c
··· 1001 1001 1002 1002 module_platform_driver(twl6030_gpadc_driver); 1003 1003 1004 - MODULE_ALIAS("platform: " DRIVER_NAME); 1004 + MODULE_ALIAS("platform:" DRIVER_NAME); 1005 1005 MODULE_AUTHOR("Balaji T K <balajitk@ti.com>"); 1006 1006 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>"); 1007 1007 MODULE_AUTHOR("Oleksandr Kozaruk <oleksandr.kozaruk@ti.com");
+2
drivers/iio/imu/adis16400.h
··· 139 139 #define ADIS16400_NO_BURST BIT(1) 140 140 #define ADIS16400_HAS_SLOW_MODE BIT(2) 141 141 #define ADIS16400_HAS_SERIAL_NUMBER BIT(3) 142 + #define ADIS16400_BURST_DIAG_STAT BIT(4) 142 143 143 144 struct adis16400_state; 144 145 ··· 166 165 int filt_int; 167 166 168 167 struct adis adis; 168 + unsigned long avail_scan_mask[2]; 169 169 }; 170 170 171 171 /* At the moment triggers are only used for ring buffer
+18 -8
drivers/iio/imu/adis16400_buffer.c
··· 18 18 { 19 19 struct adis16400_state *st = iio_priv(indio_dev); 20 20 struct adis *adis = &st->adis; 21 - uint16_t *tx; 21 + unsigned int burst_length; 22 + u8 *tx; 22 23 23 24 if (st->variant->flags & ADIS16400_NO_BURST) 24 25 return adis_update_scan_mode(indio_dev, scan_mask); ··· 27 26 kfree(adis->xfer); 28 27 kfree(adis->buffer); 29 28 29 + /* All but the timestamp channel */ 30 + burst_length = (indio_dev->num_channels - 1) * sizeof(u16); 31 + if (st->variant->flags & ADIS16400_BURST_DIAG_STAT) 32 + burst_length += sizeof(u16); 33 + 30 34 adis->xfer = kcalloc(2, sizeof(*adis->xfer), GFP_KERNEL); 31 35 if (!adis->xfer) 32 36 return -ENOMEM; 33 37 34 - adis->buffer = kzalloc(indio_dev->scan_bytes + sizeof(u16), 35 - GFP_KERNEL); 38 + adis->buffer = kzalloc(burst_length + sizeof(u16), GFP_KERNEL); 36 39 if (!adis->buffer) 37 40 return -ENOMEM; 38 41 39 - tx = adis->buffer + indio_dev->scan_bytes; 40 - 42 + tx = adis->buffer + burst_length; 41 43 tx[0] = ADIS_READ_REG(ADIS16400_GLOB_CMD); 42 44 tx[1] = 0; 43 45 44 46 adis->xfer[0].tx_buf = tx; 45 47 adis->xfer[0].bits_per_word = 8; 46 48 adis->xfer[0].len = 2; 47 - adis->xfer[1].tx_buf = tx; 49 + adis->xfer[1].rx_buf = adis->buffer; 48 50 adis->xfer[1].bits_per_word = 8; 49 - adis->xfer[1].len = indio_dev->scan_bytes; 51 + adis->xfer[1].len = burst_length; 50 52 51 53 spi_message_init(&adis->msg); 52 54 spi_message_add_tail(&adis->xfer[0], &adis->msg); ··· 65 61 struct adis16400_state *st = iio_priv(indio_dev); 66 62 struct adis *adis = &st->adis; 67 63 u32 old_speed_hz = st->adis.spi->max_speed_hz; 64 + void *buffer; 68 65 int ret; 69 66 70 67 if (!adis->buffer) ··· 86 81 spi_setup(st->adis.spi); 87 82 } 88 83 89 - iio_push_to_buffers_with_timestamp(indio_dev, adis->buffer, 84 + if (st->variant->flags & ADIS16400_BURST_DIAG_STAT) 85 + buffer = adis->buffer + sizeof(u16); 86 + else 87 + buffer = adis->buffer; 88 + 89 + iio_push_to_buffers_with_timestamp(indio_dev, buffer, 90 90 pf->timestamp); 91 91 92 92 iio_trigger_notify_done(indio_dev->trig);
+29 -12
drivers/iio/imu/adis16400_core.c
··· 405 405 *val = st->variant->temp_scale_nano / 1000000; 406 406 *val2 = (st->variant->temp_scale_nano % 1000000); 407 407 return IIO_VAL_INT_PLUS_MICRO; 408 + case IIO_PRESSURE: 409 + /* 20 uBar = 0.002kPascal */ 410 + *val = 0; 411 + *val2 = 2000; 412 + return IIO_VAL_INT_PLUS_MICRO; 408 413 default: 409 414 return -EINVAL; 410 415 } ··· 459 454 } 460 455 } 461 456 462 - #define ADIS16400_VOLTAGE_CHAN(addr, bits, name, si) { \ 457 + #define ADIS16400_VOLTAGE_CHAN(addr, bits, name, si, chn) { \ 463 458 .type = IIO_VOLTAGE, \ 464 459 .indexed = 1, \ 465 - .channel = 0, \ 460 + .channel = chn, \ 466 461 .extend_name = name, \ 467 462 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 468 463 BIT(IIO_CHAN_INFO_SCALE), \ ··· 479 474 } 480 475 481 476 #define ADIS16400_SUPPLY_CHAN(addr, bits) \ 482 - ADIS16400_VOLTAGE_CHAN(addr, bits, "supply", ADIS16400_SCAN_SUPPLY) 477 + ADIS16400_VOLTAGE_CHAN(addr, bits, "supply", ADIS16400_SCAN_SUPPLY, 0) 483 478 484 479 #define ADIS16400_AUX_ADC_CHAN(addr, bits) \ 485 - ADIS16400_VOLTAGE_CHAN(addr, bits, NULL, ADIS16400_SCAN_ADC) 480 + ADIS16400_VOLTAGE_CHAN(addr, bits, NULL, ADIS16400_SCAN_ADC, 1) 486 481 487 482 #define ADIS16400_GYRO_CHAN(mod, addr, bits) { \ 488 483 .type = IIO_ANGL_VEL, \ ··· 778 773 .channels = adis16448_channels, 779 774 .num_channels = ARRAY_SIZE(adis16448_channels), 780 775 .flags = ADIS16400_HAS_PROD_ID | 781 - ADIS16400_HAS_SERIAL_NUMBER, 776 + ADIS16400_HAS_SERIAL_NUMBER | 777 + ADIS16400_BURST_DIAG_STAT, 782 778 .gyro_scale_micro = IIO_DEGREE_TO_RAD(10000), /* 0.01 deg/s */ 783 779 .accel_scale_micro = IIO_G_TO_M_S_2(833), /* 1/1200 g */ 784 780 .temp_scale_nano = 73860000, /* 0.07386 C */ ··· 795 789 .write_raw = &adis16400_write_raw, 796 790 .update_scan_mode = adis16400_update_scan_mode, 797 791 .debugfs_reg_access = adis_debugfs_reg_access, 798 - }; 799 - 800 - static const unsigned long adis16400_burst_scan_mask[] = { 801 - ~0UL, 802 - 0, 803 792 }; 804 793 805 794 static const char * const adis16400_status_error_msgs[] = { ··· 844 843 BIT(ADIS16400_DIAG_STAT_POWER_LOW), 845 844 }; 846 845 846 + static void adis16400_setup_chan_mask(struct adis16400_state *st) 847 + { 848 + const struct adis16400_chip_info *chip_info = st->variant; 849 + unsigned i; 850 + 851 + for (i = 0; i < chip_info->num_channels; i++) { 852 + const struct iio_chan_spec *ch = &chip_info->channels[i]; 853 + 854 + if (ch->scan_index >= 0 && 855 + ch->scan_index != ADIS16400_SCAN_TIMESTAMP) 856 + st->avail_scan_mask[0] |= BIT(ch->scan_index); 857 + } 858 + } 859 + 847 860 static int adis16400_probe(struct spi_device *spi) 848 861 { 849 862 struct adis16400_state *st; ··· 881 866 indio_dev->info = &adis16400_info; 882 867 indio_dev->modes = INDIO_DIRECT_MODE; 883 868 884 - if (!(st->variant->flags & ADIS16400_NO_BURST)) 885 - indio_dev->available_scan_masks = adis16400_burst_scan_mask; 869 + if (!(st->variant->flags & ADIS16400_NO_BURST)) { 870 + adis16400_setup_chan_mask(st); 871 + indio_dev->available_scan_masks = st->avail_scan_mask; 872 + } 886 873 887 874 ret = adis_init(&st->adis, indio_dev, spi, &adis16400_data); 888 875 if (ret)
+4 -4
drivers/staging/ozwpan/ozhcd.c
··· 746 746 /* 747 747 * Context: softirq 748 748 */ 749 - void oz_hcd_get_desc_cnf(void *hport, u8 req_id, int status, const u8 *desc, 750 - int length, int offset, int total_size) 749 + void oz_hcd_get_desc_cnf(void *hport, u8 req_id, u8 status, const u8 *desc, 750 + u8 length, u16 offset, u16 total_size) 751 751 { 752 752 struct oz_port *port = hport; 753 753 struct urb *urb; ··· 759 759 if (!urb) 760 760 return; 761 761 if (status == 0) { 762 - int copy_len; 763 - int required_size = urb->transfer_buffer_length; 762 + unsigned int copy_len; 763 + unsigned int required_size = urb->transfer_buffer_length; 764 764 765 765 if (required_size > total_size) 766 766 required_size = total_size;
+2 -2
drivers/staging/ozwpan/ozusbif.h
··· 29 29 30 30 /* Confirmation functions. 31 31 */ 32 - void oz_hcd_get_desc_cnf(void *hport, u8 req_id, int status, 33 - const u8 *desc, int length, int offset, int total_size); 32 + void oz_hcd_get_desc_cnf(void *hport, u8 req_id, u8 status, 33 + const u8 *desc, u8 length, u16 offset, u16 total_size); 34 34 void oz_hcd_control_cnf(void *hport, u8 req_id, u8 rcode, 35 35 const u8 *data, int data_len); 36 36
+14 -5
drivers/staging/ozwpan/ozusbsvc1.c
··· 326 326 struct oz_multiple_fixed *body = 327 327 (struct oz_multiple_fixed *)data_hdr; 328 328 u8 *data = body->data; 329 - int n = (len - sizeof(struct oz_multiple_fixed)+1) 329 + unsigned int n; 330 + if (!body->unit_size || 331 + len < sizeof(struct oz_multiple_fixed) - 1) 332 + break; 333 + n = (len - (sizeof(struct oz_multiple_fixed) - 1)) 330 334 / body->unit_size; 331 335 while (n--) { 332 336 oz_hcd_data_ind(usb_ctx->hport, body->endpoint, ··· 394 390 case OZ_GET_DESC_RSP: { 395 391 struct oz_get_desc_rsp *body = 396 392 (struct oz_get_desc_rsp *)usb_hdr; 397 - int data_len = elt->length - 398 - sizeof(struct oz_get_desc_rsp) + 1; 399 - u16 offs = le16_to_cpu(get_unaligned(&body->offset)); 400 - u16 total_size = 393 + u16 offs, total_size; 394 + u8 data_len; 395 + 396 + if (elt->length < sizeof(struct oz_get_desc_rsp) - 1) 397 + break; 398 + data_len = elt->length - 399 + (sizeof(struct oz_get_desc_rsp) - 1); 400 + offs = le16_to_cpu(get_unaligned(&body->offset)); 401 + total_size = 401 402 le16_to_cpu(get_unaligned(&body->total_size)); 402 403 oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - cnf\n"); 403 404 oz_hcd_get_desc_cnf(usb_ctx->hport, body->req_id,
+72 -72
drivers/staging/rtl8712/rtl8712_led.c
··· 898 898 IS_LED_WPS_BLINKING(pLed)) 899 899 return; 900 900 if (pLed->bLedLinkBlinkInProgress == true) { 901 - del_timer_sync(&pLed->BlinkTimer); 901 + del_timer(&pLed->BlinkTimer); 902 902 pLed->bLedLinkBlinkInProgress = false; 903 903 } 904 904 if (pLed->bLedBlinkInProgress == true) { 905 - del_timer_sync(&pLed->BlinkTimer); 905 + del_timer(&pLed->BlinkTimer); 906 906 pLed->bLedBlinkInProgress = false; 907 907 } 908 908 pLed->bLedNoLinkBlinkInProgress = true; ··· 921 921 IS_LED_WPS_BLINKING(pLed)) 922 922 return; 923 923 if (pLed->bLedNoLinkBlinkInProgress == true) { 924 - del_timer_sync(&pLed->BlinkTimer); 924 + del_timer(&pLed->BlinkTimer); 925 925 pLed->bLedNoLinkBlinkInProgress = false; 926 926 } 927 927 if (pLed->bLedBlinkInProgress == true) { 928 - del_timer_sync(&pLed->BlinkTimer); 928 + del_timer(&pLed->BlinkTimer); 929 929 pLed->bLedBlinkInProgress = false; 930 930 } 931 931 pLed->bLedLinkBlinkInProgress = true; ··· 946 946 if (IS_LED_WPS_BLINKING(pLed)) 947 947 return; 948 948 if (pLed->bLedNoLinkBlinkInProgress == true) { 949 - del_timer_sync(&pLed->BlinkTimer); 949 + del_timer(&pLed->BlinkTimer); 950 950 pLed->bLedNoLinkBlinkInProgress = false; 951 951 } 952 952 if (pLed->bLedLinkBlinkInProgress == true) { 953 - del_timer_sync(&pLed->BlinkTimer); 953 + del_timer(&pLed->BlinkTimer); 954 954 pLed->bLedLinkBlinkInProgress = false; 955 955 } 956 956 if (pLed->bLedBlinkInProgress == true) { 957 - del_timer_sync(&pLed->BlinkTimer); 957 + del_timer(&pLed->BlinkTimer); 958 958 pLed->bLedBlinkInProgress = false; 959 959 } 960 960 pLed->bLedScanBlinkInProgress = true; ··· 975 975 IS_LED_WPS_BLINKING(pLed)) 976 976 return; 977 977 if (pLed->bLedNoLinkBlinkInProgress == true) { 978 - del_timer_sync(&pLed->BlinkTimer); 978 + del_timer(&pLed->BlinkTimer); 979 979 pLed->bLedNoLinkBlinkInProgress = false; 980 980 } 981 981 if (pLed->bLedLinkBlinkInProgress == true) { 982 - del_timer_sync(&pLed->BlinkTimer); 982 + del_timer(&pLed->BlinkTimer); 983 983 pLed->bLedLinkBlinkInProgress = false; 984 984 } 985 985 pLed->bLedBlinkInProgress = true; ··· 998 998 case LED_CTL_START_WPS_BOTTON: 999 999 if (pLed->bLedWPSBlinkInProgress == false) { 1000 1000 if (pLed->bLedNoLinkBlinkInProgress == true) { 1001 - del_timer_sync(&pLed->BlinkTimer); 1001 + del_timer(&pLed->BlinkTimer); 1002 1002 pLed->bLedNoLinkBlinkInProgress = false; 1003 1003 } 1004 1004 if (pLed->bLedLinkBlinkInProgress == true) { 1005 - del_timer_sync(&pLed->BlinkTimer); 1005 + del_timer(&pLed->BlinkTimer); 1006 1006 pLed->bLedLinkBlinkInProgress = false; 1007 1007 } 1008 1008 if (pLed->bLedBlinkInProgress == true) { 1009 - del_timer_sync(&pLed->BlinkTimer); 1009 + del_timer(&pLed->BlinkTimer); 1010 1010 pLed->bLedBlinkInProgress = false; 1011 1011 } 1012 1012 if (pLed->bLedScanBlinkInProgress == true) { 1013 - del_timer_sync(&pLed->BlinkTimer); 1013 + del_timer(&pLed->BlinkTimer); 1014 1014 pLed->bLedScanBlinkInProgress = false; 1015 1015 } 1016 1016 pLed->bLedWPSBlinkInProgress = true; ··· 1025 1025 break; 1026 1026 case LED_CTL_STOP_WPS: 1027 1027 if (pLed->bLedNoLinkBlinkInProgress == true) { 1028 - del_timer_sync(&pLed->BlinkTimer); 1028 + del_timer(&pLed->BlinkTimer); 1029 1029 pLed->bLedNoLinkBlinkInProgress = false; 1030 1030 } 1031 1031 if (pLed->bLedLinkBlinkInProgress == true) { 1032 - del_timer_sync(&pLed->BlinkTimer); 1032 + del_timer(&pLed->BlinkTimer); 1033 1033 pLed->bLedLinkBlinkInProgress = false; 1034 1034 } 1035 1035 if (pLed->bLedBlinkInProgress == true) { 1036 - del_timer_sync(&pLed->BlinkTimer); 1036 + del_timer(&pLed->BlinkTimer); 1037 1037 pLed->bLedBlinkInProgress = false; 1038 1038 } 1039 1039 if (pLed->bLedScanBlinkInProgress == true) { 1040 - del_timer_sync(&pLed->BlinkTimer); 1040 + del_timer(&pLed->BlinkTimer); 1041 1041 pLed->bLedScanBlinkInProgress = false; 1042 1042 } 1043 1043 if (pLed->bLedWPSBlinkInProgress) 1044 - del_timer_sync(&pLed->BlinkTimer); 1044 + del_timer(&pLed->BlinkTimer); 1045 1045 else 1046 1046 pLed->bLedWPSBlinkInProgress = true; 1047 1047 pLed->CurrLedState = LED_BLINK_WPS_STOP; ··· 1057 1057 break; 1058 1058 case LED_CTL_STOP_WPS_FAIL: 1059 1059 if (pLed->bLedWPSBlinkInProgress) { 1060 - del_timer_sync(&pLed->BlinkTimer); 1060 + del_timer(&pLed->BlinkTimer); 1061 1061 pLed->bLedWPSBlinkInProgress = false; 1062 1062 } 1063 1063 pLed->bLedNoLinkBlinkInProgress = true; ··· 1073 1073 pLed->CurrLedState = LED_OFF; 1074 1074 pLed->BlinkingLedState = LED_OFF; 1075 1075 if (pLed->bLedNoLinkBlinkInProgress) { 1076 - del_timer_sync(&pLed->BlinkTimer); 1076 + del_timer(&pLed->BlinkTimer); 1077 1077 pLed->bLedNoLinkBlinkInProgress = false; 1078 1078 } 1079 1079 if (pLed->bLedLinkBlinkInProgress) { 1080 - del_timer_sync(&pLed->BlinkTimer); 1080 + del_timer(&pLed->BlinkTimer); 1081 1081 pLed->bLedLinkBlinkInProgress = false; 1082 1082 } 1083 1083 if (pLed->bLedBlinkInProgress) { 1084 - del_timer_sync(&pLed->BlinkTimer); 1084 + del_timer(&pLed->BlinkTimer); 1085 1085 pLed->bLedBlinkInProgress = false; 1086 1086 } 1087 1087 if (pLed->bLedWPSBlinkInProgress) { 1088 - del_timer_sync(&pLed->BlinkTimer); 1088 + del_timer(&pLed->BlinkTimer); 1089 1089 pLed->bLedWPSBlinkInProgress = false; 1090 1090 } 1091 1091 if (pLed->bLedScanBlinkInProgress) { 1092 - del_timer_sync(&pLed->BlinkTimer); 1092 + del_timer(&pLed->BlinkTimer); 1093 1093 pLed->bLedScanBlinkInProgress = false; 1094 1094 } 1095 1095 mod_timer(&pLed->BlinkTimer, ··· 1116 1116 return; 1117 1117 1118 1118 if (pLed->bLedBlinkInProgress == true) { 1119 - del_timer_sync(&pLed->BlinkTimer); 1119 + del_timer(&pLed->BlinkTimer); 1120 1120 pLed->bLedBlinkInProgress = false; 1121 1121 } 1122 1122 pLed->bLedScanBlinkInProgress = true; ··· 1154 1154 pLed->CurrLedState = LED_ON; 1155 1155 pLed->BlinkingLedState = LED_ON; 1156 1156 if (pLed->bLedBlinkInProgress) { 1157 - del_timer_sync(&pLed->BlinkTimer); 1157 + del_timer(&pLed->BlinkTimer); 1158 1158 pLed->bLedBlinkInProgress = false; 1159 1159 } 1160 1160 if (pLed->bLedScanBlinkInProgress) { 1161 - del_timer_sync(&pLed->BlinkTimer); 1161 + del_timer(&pLed->BlinkTimer); 1162 1162 pLed->bLedScanBlinkInProgress = false; 1163 1163 } 1164 1164 ··· 1170 1170 case LED_CTL_START_WPS_BOTTON: 1171 1171 if (pLed->bLedWPSBlinkInProgress == false) { 1172 1172 if (pLed->bLedBlinkInProgress == true) { 1173 - del_timer_sync(&pLed->BlinkTimer); 1173 + del_timer(&pLed->BlinkTimer); 1174 1174 pLed->bLedBlinkInProgress = false; 1175 1175 } 1176 1176 if (pLed->bLedScanBlinkInProgress == true) { 1177 - del_timer_sync(&pLed->BlinkTimer); 1177 + del_timer(&pLed->BlinkTimer); 1178 1178 pLed->bLedScanBlinkInProgress = false; 1179 1179 } 1180 1180 pLed->bLedWPSBlinkInProgress = true; ··· 1214 1214 pLed->CurrLedState = LED_OFF; 1215 1215 pLed->BlinkingLedState = LED_OFF; 1216 1216 if (pLed->bLedBlinkInProgress) { 1217 - del_timer_sync(&pLed->BlinkTimer); 1217 + del_timer(&pLed->BlinkTimer); 1218 1218 pLed->bLedBlinkInProgress = false; 1219 1219 } 1220 1220 if (pLed->bLedScanBlinkInProgress) { 1221 - del_timer_sync(&pLed->BlinkTimer); 1221 + del_timer(&pLed->BlinkTimer); 1222 1222 pLed->bLedScanBlinkInProgress = false; 1223 1223 } 1224 1224 if (pLed->bLedWPSBlinkInProgress) { 1225 - del_timer_sync(&pLed->BlinkTimer); 1225 + del_timer(&pLed->BlinkTimer); 1226 1226 pLed->bLedWPSBlinkInProgress = false; 1227 1227 } 1228 1228 mod_timer(&pLed->BlinkTimer, ··· 1248 1248 if (IS_LED_WPS_BLINKING(pLed)) 1249 1249 return; 1250 1250 if (pLed->bLedBlinkInProgress == true) { 1251 - del_timer_sync(&pLed->BlinkTimer); 1251 + del_timer(&pLed->BlinkTimer); 1252 1252 pLed->bLedBlinkInProgress = false; 1253 1253 } 1254 1254 pLed->bLedScanBlinkInProgress = true; ··· 1286 1286 pLed->CurrLedState = LED_ON; 1287 1287 pLed->BlinkingLedState = LED_ON; 1288 1288 if (pLed->bLedBlinkInProgress) { 1289 - del_timer_sync(&pLed->BlinkTimer); 1289 + del_timer(&pLed->BlinkTimer); 1290 1290 pLed->bLedBlinkInProgress = false; 1291 1291 } 1292 1292 if (pLed->bLedScanBlinkInProgress) { 1293 - del_timer_sync(&pLed->BlinkTimer); 1293 + del_timer(&pLed->BlinkTimer); 1294 1294 pLed->bLedScanBlinkInProgress = false; 1295 1295 } 1296 1296 mod_timer(&pLed->BlinkTimer, ··· 1300 1300 case LED_CTL_START_WPS_BOTTON: 1301 1301 if (pLed->bLedWPSBlinkInProgress == false) { 1302 1302 if (pLed->bLedBlinkInProgress == true) { 1303 - del_timer_sync(&pLed->BlinkTimer); 1303 + del_timer(&pLed->BlinkTimer); 1304 1304 pLed->bLedBlinkInProgress = false; 1305 1305 } 1306 1306 if (pLed->bLedScanBlinkInProgress == true) { 1307 - del_timer_sync(&pLed->BlinkTimer); 1307 + del_timer(&pLed->BlinkTimer); 1308 1308 pLed->bLedScanBlinkInProgress = false; 1309 1309 } 1310 1310 pLed->bLedWPSBlinkInProgress = true; ··· 1319 1319 break; 1320 1320 case LED_CTL_STOP_WPS: 1321 1321 if (pLed->bLedWPSBlinkInProgress) { 1322 - del_timer_sync(&(pLed->BlinkTimer)); 1322 + del_timer(&pLed->BlinkTimer); 1323 1323 pLed->bLedWPSBlinkInProgress = false; 1324 1324 } else 1325 1325 pLed->bLedWPSBlinkInProgress = true; ··· 1336 1336 break; 1337 1337 case LED_CTL_STOP_WPS_FAIL: 1338 1338 if (pLed->bLedWPSBlinkInProgress) { 1339 - del_timer_sync(&pLed->BlinkTimer); 1339 + del_timer(&pLed->BlinkTimer); 1340 1340 pLed->bLedWPSBlinkInProgress = false; 1341 1341 } 1342 1342 pLed->CurrLedState = LED_OFF; ··· 1357 1357 pLed->CurrLedState = LED_OFF; 1358 1358 pLed->BlinkingLedState = LED_OFF; 1359 1359 if (pLed->bLedBlinkInProgress) { 1360 - del_timer_sync(&pLed->BlinkTimer); 1360 + del_timer(&pLed->BlinkTimer); 1361 1361 pLed->bLedBlinkInProgress = false; 1362 1362 } 1363 1363 if (pLed->bLedScanBlinkInProgress) { 1364 - del_timer_sync(&pLed->BlinkTimer); 1364 + del_timer(&pLed->BlinkTimer); 1365 1365 pLed->bLedScanBlinkInProgress = false; 1366 1366 } 1367 1367 if (pLed->bLedWPSBlinkInProgress) { 1368 - del_timer_sync(&pLed->BlinkTimer); 1368 + del_timer(&pLed->BlinkTimer); 1369 1369 pLed->bLedWPSBlinkInProgress = false; 1370 1370 } 1371 1371 mod_timer(&pLed->BlinkTimer, ··· 1388 1388 case LED_CTL_START_TO_LINK: 1389 1389 if (pLed1->bLedWPSBlinkInProgress) { 1390 1390 pLed1->bLedWPSBlinkInProgress = false; 1391 - del_timer_sync(&pLed1->BlinkTimer); 1391 + del_timer(&pLed1->BlinkTimer); 1392 1392 pLed1->BlinkingLedState = LED_OFF; 1393 1393 pLed1->CurrLedState = LED_OFF; 1394 1394 if (pLed1->bLedOn) ··· 1400 1400 IS_LED_WPS_BLINKING(pLed)) 1401 1401 return; 1402 1402 if (pLed->bLedBlinkInProgress == true) { 1403 - del_timer_sync(&pLed->BlinkTimer); 1403 + del_timer(&pLed->BlinkTimer); 1404 1404 pLed->bLedBlinkInProgress = false; 1405 1405 } 1406 1406 if (pLed->bLedNoLinkBlinkInProgress == true) { 1407 - del_timer_sync(&pLed->BlinkTimer); 1407 + del_timer(&pLed->BlinkTimer); 1408 1408 pLed->bLedNoLinkBlinkInProgress = false; 1409 1409 } 1410 1410 pLed->bLedStartToLinkBlinkInProgress = true; ··· 1426 1426 if (LedAction == LED_CTL_LINK) { 1427 1427 if (pLed1->bLedWPSBlinkInProgress) { 1428 1428 pLed1->bLedWPSBlinkInProgress = false; 1429 - del_timer_sync(&pLed1->BlinkTimer); 1429 + del_timer(&pLed1->BlinkTimer); 1430 1430 pLed1->BlinkingLedState = LED_OFF; 1431 1431 pLed1->CurrLedState = LED_OFF; 1432 1432 if (pLed1->bLedOn) ··· 1439 1439 IS_LED_WPS_BLINKING(pLed)) 1440 1440 return; 1441 1441 if (pLed->bLedBlinkInProgress == true) { 1442 - del_timer_sync(&pLed->BlinkTimer); 1442 + del_timer(&pLed->BlinkTimer); 1443 1443 pLed->bLedBlinkInProgress = false; 1444 1444 } 1445 1445 pLed->bLedNoLinkBlinkInProgress = true; ··· 1460 1460 if (IS_LED_WPS_BLINKING(pLed)) 1461 1461 return; 1462 1462 if (pLed->bLedNoLinkBlinkInProgress == true) { 1463 - del_timer_sync(&pLed->BlinkTimer); 1463 + del_timer(&pLed->BlinkTimer); 1464 1464 pLed->bLedNoLinkBlinkInProgress = false; 1465 1465 } 1466 1466 if (pLed->bLedBlinkInProgress == true) { 1467 - del_timer_sync(&pLed->BlinkTimer); 1467 + del_timer(&pLed->BlinkTimer); 1468 1468 pLed->bLedBlinkInProgress = false; 1469 1469 } 1470 1470 pLed->bLedScanBlinkInProgress = true; ··· 1485 1485 IS_LED_WPS_BLINKING(pLed)) 1486 1486 return; 1487 1487 if (pLed->bLedNoLinkBlinkInProgress == true) { 1488 - del_timer_sync(&pLed->BlinkTimer); 1488 + del_timer(&pLed->BlinkTimer); 1489 1489 pLed->bLedNoLinkBlinkInProgress = false; 1490 1490 } 1491 1491 pLed->bLedBlinkInProgress = true; ··· 1503 1503 case LED_CTL_START_WPS_BOTTON: 1504 1504 if (pLed1->bLedWPSBlinkInProgress) { 1505 1505 pLed1->bLedWPSBlinkInProgress = false; 1506 - del_timer_sync(&(pLed1->BlinkTimer)); 1506 + del_timer(&pLed1->BlinkTimer); 1507 1507 pLed1->BlinkingLedState = LED_OFF; 1508 1508 pLed1->CurrLedState = LED_OFF; 1509 1509 if (pLed1->bLedOn) ··· 1512 1512 } 1513 1513 if (pLed->bLedWPSBlinkInProgress == false) { 1514 1514 if (pLed->bLedNoLinkBlinkInProgress == true) { 1515 - del_timer_sync(&pLed->BlinkTimer); 1515 + del_timer(&pLed->BlinkTimer); 1516 1516 pLed->bLedNoLinkBlinkInProgress = false; 1517 1517 } 1518 1518 if (pLed->bLedBlinkInProgress == true) { 1519 - del_timer_sync(&pLed->BlinkTimer); 1519 + del_timer(&pLed->BlinkTimer); 1520 1520 pLed->bLedBlinkInProgress = false; 1521 1521 } 1522 1522 if (pLed->bLedScanBlinkInProgress == true) { 1523 - del_timer_sync(&pLed->BlinkTimer); 1523 + del_timer(&pLed->BlinkTimer); 1524 1524 pLed->bLedScanBlinkInProgress = false; 1525 1525 } 1526 1526 pLed->bLedWPSBlinkInProgress = true; ··· 1538 1538 break; 1539 1539 case LED_CTL_STOP_WPS: /*WPS connect success*/ 1540 1540 if (pLed->bLedWPSBlinkInProgress) { 1541 - del_timer_sync(&pLed->BlinkTimer); 1541 + del_timer(&pLed->BlinkTimer); 1542 1542 pLed->bLedWPSBlinkInProgress = false; 1543 1543 } 1544 1544 pLed->bLedNoLinkBlinkInProgress = true; ··· 1552 1552 break; 1553 1553 case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/ 1554 1554 if (pLed->bLedWPSBlinkInProgress) { 1555 - del_timer_sync(&pLed->BlinkTimer); 1555 + del_timer(&pLed->BlinkTimer); 1556 1556 pLed->bLedWPSBlinkInProgress = false; 1557 1557 } 1558 1558 pLed->bLedNoLinkBlinkInProgress = true; ··· 1565 1565 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 1566 1566 /*LED1 settings*/ 1567 1567 if (pLed1->bLedWPSBlinkInProgress) 1568 - del_timer_sync(&pLed1->BlinkTimer); 1568 + del_timer(&pLed1->BlinkTimer); 1569 1569 else 1570 1570 pLed1->bLedWPSBlinkInProgress = true; 1571 1571 pLed1->CurrLedState = LED_BLINK_WPS_STOP; ··· 1578 1578 break; 1579 1579 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/ 1580 1580 if (pLed->bLedWPSBlinkInProgress) { 1581 - del_timer_sync(&pLed->BlinkTimer); 1581 + del_timer(&pLed->BlinkTimer); 1582 1582 pLed->bLedWPSBlinkInProgress = false; 1583 1583 } 1584 1584 pLed->bLedNoLinkBlinkInProgress = true; ··· 1591 1591 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 1592 1592 /*LED1 settings*/ 1593 1593 if (pLed1->bLedWPSBlinkInProgress) 1594 - del_timer_sync(&pLed1->BlinkTimer); 1594 + del_timer(&pLed1->BlinkTimer); 1595 1595 else 1596 1596 pLed1->bLedWPSBlinkInProgress = true; 1597 1597 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP; ··· 1607 1607 pLed->CurrLedState = LED_OFF; 1608 1608 pLed->BlinkingLedState = LED_OFF; 1609 1609 if (pLed->bLedNoLinkBlinkInProgress) { 1610 - del_timer_sync(&pLed->BlinkTimer); 1610 + del_timer(&pLed->BlinkTimer); 1611 1611 pLed->bLedNoLinkBlinkInProgress = false; 1612 1612 } 1613 1613 if (pLed->bLedLinkBlinkInProgress) { 1614 - del_timer_sync(&pLed->BlinkTimer); 1614 + del_timer(&pLed->BlinkTimer); 1615 1615 pLed->bLedLinkBlinkInProgress = false; 1616 1616 } 1617 1617 if (pLed->bLedBlinkInProgress) { 1618 - del_timer_sync(&pLed->BlinkTimer); 1618 + del_timer(&pLed->BlinkTimer); 1619 1619 pLed->bLedBlinkInProgress = false; 1620 1620 } 1621 1621 if (pLed->bLedWPSBlinkInProgress) { 1622 - del_timer_sync(&pLed->BlinkTimer); 1622 + del_timer(&pLed->BlinkTimer); 1623 1623 pLed->bLedWPSBlinkInProgress = false; 1624 1624 } 1625 1625 if (pLed->bLedScanBlinkInProgress) { 1626 - del_timer_sync(&pLed->BlinkTimer); 1626 + del_timer(&pLed->BlinkTimer); 1627 1627 pLed->bLedScanBlinkInProgress = false; 1628 1628 } 1629 1629 if (pLed->bLedStartToLinkBlinkInProgress) { 1630 - del_timer_sync(&pLed->BlinkTimer); 1630 + del_timer(&pLed->BlinkTimer); 1631 1631 pLed->bLedStartToLinkBlinkInProgress = false; 1632 1632 } 1633 1633 if (pLed1->bLedWPSBlinkInProgress) { 1634 - del_timer_sync(&pLed1->BlinkTimer); 1634 + del_timer(&pLed1->BlinkTimer); 1635 1635 pLed1->bLedWPSBlinkInProgress = false; 1636 1636 } 1637 1637 pLed1->BlinkingLedState = LED_UNKNOWN; ··· 1671 1671 ; /* dummy branch */ 1672 1672 else if (pLed->bLedScanBlinkInProgress == false) { 1673 1673 if (pLed->bLedBlinkInProgress == true) { 1674 - del_timer_sync(&pLed->BlinkTimer); 1674 + del_timer(&pLed->BlinkTimer); 1675 1675 pLed->bLedBlinkInProgress = false; 1676 1676 } 1677 1677 pLed->bLedScanBlinkInProgress = true; ··· 1705 1705 pLed->CurrLedState = LED_OFF; 1706 1706 pLed->BlinkingLedState = LED_OFF; 1707 1707 if (pLed->bLedBlinkInProgress) { 1708 - del_timer_sync(&pLed->BlinkTimer); 1708 + del_timer(&pLed->BlinkTimer); 1709 1709 pLed->bLedBlinkInProgress = false; 1710 1710 } 1711 1711 SwLedOff(padapter, pLed); ··· 1756 1756 case LED_CTL_START_WPS_BOTTON: 1757 1757 if (pLed->bLedWPSBlinkInProgress == false) { 1758 1758 if (pLed->bLedBlinkInProgress == true) { 1759 - del_timer_sync(&pLed->BlinkTimer); 1759 + del_timer(&pLed->BlinkTimer); 1760 1760 pLed->bLedBlinkInProgress = false; 1761 1761 } 1762 1762 pLed->bLedWPSBlinkInProgress = true; ··· 1772 1772 case LED_CTL_STOP_WPS_FAIL: 1773 1773 case LED_CTL_STOP_WPS: 1774 1774 if (pLed->bLedWPSBlinkInProgress) { 1775 - del_timer_sync(&pLed->BlinkTimer); 1775 + del_timer(&pLed->BlinkTimer); 1776 1776 pLed->bLedWPSBlinkInProgress = false; 1777 1777 } 1778 1778 pLed->CurrLedState = LED_ON; ··· 1784 1784 pLed->CurrLedState = LED_OFF; 1785 1785 pLed->BlinkingLedState = LED_OFF; 1786 1786 if (pLed->bLedBlinkInProgress) { 1787 - del_timer_sync(&pLed->BlinkTimer); 1787 + del_timer(&pLed->BlinkTimer); 1788 1788 pLed->bLedBlinkInProgress = false; 1789 1789 } 1790 1790 if (pLed->bLedWPSBlinkInProgress) { 1791 - del_timer_sync(&pLed->BlinkTimer); 1791 + del_timer(&pLed->BlinkTimer); 1792 1792 pLed->bLedWPSBlinkInProgress = false; 1793 1793 } 1794 1794 SwLedOff(padapter, pLed);
+1 -1
drivers/staging/rtl8712/rtl871x_cmd.c
··· 910 910 if (pcmd->res != H2C_SUCCESS) 911 911 mod_timer(&pmlmepriv->assoc_timer, 912 912 jiffies + msecs_to_jiffies(1)); 913 - del_timer_sync(&pmlmepriv->assoc_timer); 913 + del_timer(&pmlmepriv->assoc_timer); 914 914 #ifdef __BIG_ENDIAN 915 915 /* endian_convert */ 916 916 pnetwork->Length = le32_to_cpu(pnetwork->Length);
+3 -3
drivers/staging/rtl8712/rtl871x_mlme.c
··· 582 582 spin_lock_irqsave(&pmlmepriv->lock, irqL); 583 583 584 584 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) { 585 - del_timer_sync(&pmlmepriv->scan_to_timer); 585 + del_timer(&pmlmepriv->scan_to_timer); 586 586 587 587 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 588 588 } ··· 696 696 } 697 697 if (padapter->pwrctrlpriv.pwr_mode != 698 698 padapter->registrypriv.power_mgnt) { 699 - del_timer_sync(&pmlmepriv->dhcp_timer); 699 + del_timer(&pmlmepriv->dhcp_timer); 700 700 r8712_set_ps_mode(padapter, padapter->registrypriv.power_mgnt, 701 701 padapter->registrypriv.smart_ps); 702 702 } ··· 910 910 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) 911 911 == true) 912 912 r8712_indicate_connect(adapter); 913 - del_timer_sync(&pmlmepriv->assoc_timer); 913 + del_timer(&pmlmepriv->assoc_timer); 914 914 } else 915 915 goto ignore_joinbss_callback; 916 916 } else {
+1 -1
drivers/staging/rtl8712/rtl871x_pwrctrl.c
··· 103 103 104 104 if (pwrpriv->cpwm_tog == ((preportpwrstate->state) & 0x80)) 105 105 return; 106 - del_timer_sync(&padapter->pwrctrlpriv.rpwm_check_timer); 106 + del_timer(&padapter->pwrctrlpriv.rpwm_check_timer); 107 107 _enter_pwrlock(&pwrpriv->lock); 108 108 pwrpriv->cpwm = (preportpwrstate->state) & 0xf; 109 109 if (pwrpriv->cpwm >= PS_STATE_S2) {
+1 -1
drivers/staging/rtl8712/rtl871x_sta_mgt.c
··· 198 198 * cancel reordering_ctrl_timer */ 199 199 for (i = 0; i < 16; i++) { 200 200 preorder_ctrl = &psta->recvreorder_ctrl[i]; 201 - del_timer_sync(&preorder_ctrl->reordering_ctrl_timer); 201 + del_timer(&preorder_ctrl->reordering_ctrl_timer); 202 202 } 203 203 spin_lock(&(pfree_sta_queue->lock)); 204 204 /* insert into free_sta_queue; 20061114 */