Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'staging-4.1-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging
Pull staging / IIO driver fixes from Greg KH:
"Here's some staging and iio driver fixes to resolve a number of
reported issues.
All of these have been in linux-next for a while"
* tag 'staging-4.1-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (31 commits)
iio: light: hid-sensor-prox: Fix memory leak in probe()
iio: adc: cc10001: Add delay before setting START bit
iio: adc: cc10001: Fix regulator_get_voltage() return value check
iio: adc: cc10001: Fix incorrect use of power-up/power-down register
staging: gdm724x: Correction of variable usage after applying ALIGN()
iio: adc: cc10001: Fix the channel number mapping
staging: vt6655: lock MACvWriteBSSIDAddress.
staging: vt6655: CARDbUpdateTSF bss timestamp correct tsf counter value.
staging: vt6655: vnt_tx_packet Correct TX order of OWNED_BY_NIC
staging: vt6655: Fix 80211 control and management status reporting.
staging: vt6655: implement IEEE80211_TX_STAT_NOACK_TRANSMITTED
staging: vt6655: device_free_tx_buf use only ieee80211_tx_status_irqsafe
staging: vt6656: use ieee80211_tx_info to select packet type.
staging: rtl8712: freeing an ERR_PTR
staging: sm750: remove incorrect __exit annotation
iio: kfifo: Set update_needed to false only if a buffer was allocated
iio: mcp320x: Fix occasional incorrect readings
iio: accel: mma9553: check input value for activity period
iio: accel: mma9553: add enable channel for activity
iio: accel: mma9551_core: prevent buffer overrun
...
+152
-110
+18
-3
drivers/iio/accel/mma9551_core.c
+18
-3
drivers/iio/accel/mma9551_core.c
···
389
389
{
390
390
int ret, i;
391
391
int len_words = len / sizeof(u16);
392
-
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS];
392
+
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
393
+
394
+
if (len_words > ARRAY_SIZE(be_buf)) {
395
+
dev_err(&client->dev, "Invalid buffer size %d\n", len);
396
+
return -EINVAL;
397
+
}
393
398
394
399
ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
395
400
reg, NULL, 0, (u8 *) be_buf, len);
···
429
424
{
430
425
int ret, i;
431
426
int len_words = len / sizeof(u16);
432
-
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS];
427
+
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
428
+
429
+
if (len_words > ARRAY_SIZE(be_buf)) {
430
+
dev_err(&client->dev, "Invalid buffer size %d\n", len);
431
+
return -EINVAL;
432
+
}
433
433
434
434
ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
435
435
reg, NULL, 0, (u8 *) be_buf, len);
···
469
459
{
470
460
int i;
471
461
int len_words = len / sizeof(u16);
472
-
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS];
462
+
__be16 be_buf[(MMA9551_MAX_MAILBOX_DATA_REGS - 1) / 2];
463
+
464
+
if (len_words > ARRAY_SIZE(be_buf)) {
465
+
dev_err(&client->dev, "Invalid buffer size %d\n", len);
466
+
return -EINVAL;
467
+
}
473
468
474
469
for (i = 0; i < len_words; i++)
475
470
be_buf[i] = cpu_to_be16(buf[i]);
+10
-8
drivers/iio/accel/mma9553.c
+10
-8
drivers/iio/accel/mma9553.c
···
54
54
#define MMA9553_MASK_CONF_STEPCOALESCE GENMASK(7, 0)
55
55
56
56
#define MMA9553_REG_CONF_ACTTHD 0x0E
57
+
#define MMA9553_MAX_ACTTHD GENMASK(15, 0)
57
58
58
59
/* Pedometer status registers (R-only) */
59
60
#define MMA9553_REG_STATUS 0x00
···
317
316
static int mma9553_read_activity_stepcnt(struct mma9553_data *data,
318
317
u8 *activity, u16 *stepcnt)
319
318
{
320
-
u32 status_stepcnt;
321
-
u16 status;
319
+
u16 buf[2];
322
320
int ret;
323
321
324
322
ret = mma9551_read_status_words(data->client, MMA9551_APPID_PEDOMETER,
325
-
MMA9553_REG_STATUS, sizeof(u32),
326
-
(u16 *) &status_stepcnt);
323
+
MMA9553_REG_STATUS, sizeof(u32), buf);
327
324
if (ret < 0) {
328
325
dev_err(&data->client->dev,
329
326
"error reading status and stepcnt\n");
330
327
return ret;
331
328
}
332
329
333
-
status = status_stepcnt & MMA9553_MASK_CONF_WORD;
334
-
*activity = mma9553_get_bits(status, MMA9553_MASK_STATUS_ACTIVITY);
335
-
*stepcnt = status_stepcnt >> 16;
330
+
*activity = mma9553_get_bits(buf[0], MMA9553_MASK_STATUS_ACTIVITY);
331
+
*stepcnt = buf[1];
336
332
337
333
return 0;
338
334
}
···
870
872
case IIO_EV_INFO_PERIOD:
871
873
switch (chan->type) {
872
874
case IIO_ACTIVITY:
875
+
if (val < 0 || val > MMA9553_ACTIVITY_THD_TO_SEC(
876
+
MMA9553_MAX_ACTTHD))
877
+
return -EINVAL;
873
878
mutex_lock(&data->mutex);
874
879
ret = mma9553_set_config(data, MMA9553_REG_CONF_ACTTHD,
875
880
&data->conf.actthd,
···
972
971
.modified = 1, \
973
972
.channel2 = _chan2, \
974
973
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
975
-
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_CALIBHEIGHT), \
974
+
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_CALIBHEIGHT) | \
975
+
BIT(IIO_CHAN_INFO_ENABLE), \
976
976
.event_spec = mma9553_activity_events, \
977
977
.num_event_specs = ARRAY_SIZE(mma9553_activity_events), \
978
978
.ext_info = mma9553_ext_info, \
+1
drivers/iio/accel/st_accel_core.c
+1
drivers/iio/accel/st_accel_core.c
+6
-6
drivers/iio/adc/axp288_adc.c
+6
-6
drivers/iio/adc/axp288_adc.c
···
53
53
.channel = 0,
54
54
.address = AXP288_TS_ADC_H,
55
55
.datasheet_name = "TS_PIN",
56
+
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
56
57
}, {
57
58
.indexed = 1,
58
59
.type = IIO_TEMP,
59
60
.channel = 1,
60
61
.address = AXP288_PMIC_ADC_H,
61
62
.datasheet_name = "PMIC_TEMP",
63
+
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
62
64
}, {
63
65
.indexed = 1,
64
66
.type = IIO_TEMP,
65
67
.channel = 2,
66
68
.address = AXP288_GP_ADC_H,
67
69
.datasheet_name = "GPADC",
70
+
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
68
71
}, {
69
72
.indexed = 1,
70
73
.type = IIO_CURRENT,
71
74
.channel = 3,
72
75
.address = AXP20X_BATT_CHRG_I_H,
73
76
.datasheet_name = "BATT_CHG_I",
74
-
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
77
+
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
75
78
}, {
76
79
.indexed = 1,
77
80
.type = IIO_CURRENT,
78
81
.channel = 4,
79
82
.address = AXP20X_BATT_DISCHRG_I_H,
80
83
.datasheet_name = "BATT_DISCHRG_I",
81
-
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
84
+
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
82
85
}, {
83
86
.indexed = 1,
84
87
.type = IIO_VOLTAGE,
85
88
.channel = 5,
86
89
.address = AXP20X_BATT_V_H,
87
90
.datasheet_name = "BATT_V",
88
-
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
91
+
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
89
92
},
90
93
};
91
94
···
153
150
if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_ON,
154
151
chan->address))
155
152
dev_err(&indio_dev->dev, "TS pin restore\n");
156
-
break;
157
-
case IIO_CHAN_INFO_PROCESSED:
158
-
ret = axp288_adc_read_channel(val, chan->address, info->regmap);
159
153
break;
160
154
default:
161
155
ret = -EINVAL;
+34
-26
drivers/iio/adc/cc10001_adc.c
+34
-26
drivers/iio/adc/cc10001_adc.c
···
35
35
#define CC10001_ADC_EOC_SET BIT(0)
36
36
37
37
#define CC10001_ADC_CHSEL_SAMPLED 0x0c
38
-
#define CC10001_ADC_POWER_UP 0x10
39
-
#define CC10001_ADC_POWER_UP_SET BIT(0)
38
+
#define CC10001_ADC_POWER_DOWN 0x10
39
+
#define CC10001_ADC_POWER_DOWN_SET BIT(0)
40
+
40
41
#define CC10001_ADC_DEBUG 0x14
41
42
#define CC10001_ADC_DATA_COUNT 0x20
42
43
···
63
62
u16 *buf;
64
63
65
64
struct mutex lock;
66
-
unsigned long channel_map;
67
65
unsigned int start_delay_ns;
68
66
unsigned int eoc_delay_ns;
69
67
};
···
79
79
return readl(adc_dev->reg_base + reg);
80
80
}
81
81
82
+
static void cc10001_adc_power_up(struct cc10001_adc_device *adc_dev)
83
+
{
84
+
cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_DOWN, 0);
85
+
ndelay(adc_dev->start_delay_ns);
86
+
}
87
+
88
+
static void cc10001_adc_power_down(struct cc10001_adc_device *adc_dev)
89
+
{
90
+
cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_DOWN,
91
+
CC10001_ADC_POWER_DOWN_SET);
92
+
}
93
+
82
94
static void cc10001_adc_start(struct cc10001_adc_device *adc_dev,
83
95
unsigned int channel)
84
96
{
···
100
88
val = (channel & CC10001_ADC_CH_MASK) | CC10001_ADC_MODE_SINGLE_CONV;
101
89
cc10001_adc_write_reg(adc_dev, CC10001_ADC_CONFIG, val);
102
90
91
+
udelay(1);
103
92
val = cc10001_adc_read_reg(adc_dev, CC10001_ADC_CONFIG);
104
93
val = val | CC10001_ADC_START_CONV;
105
94
cc10001_adc_write_reg(adc_dev, CC10001_ADC_CONFIG, val);
···
142
129
struct iio_dev *indio_dev;
143
130
unsigned int delay_ns;
144
131
unsigned int channel;
132
+
unsigned int scan_idx;
145
133
bool sample_invalid;
146
134
u16 *data;
147
135
int i;
···
153
139
154
140
mutex_lock(&adc_dev->lock);
155
141
156
-
cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_UP,
157
-
CC10001_ADC_POWER_UP_SET);
158
-
159
-
/* Wait for 8 (6+2) clock cycles before activating START */
160
-
ndelay(adc_dev->start_delay_ns);
142
+
cc10001_adc_power_up(adc_dev);
161
143
162
144
/* Calculate delay step for eoc and sampled data */
163
145
delay_ns = adc_dev->eoc_delay_ns / CC10001_MAX_POLL_COUNT;
164
146
165
147
i = 0;
166
148
sample_invalid = false;
167
-
for_each_set_bit(channel, indio_dev->active_scan_mask,
149
+
for_each_set_bit(scan_idx, indio_dev->active_scan_mask,
168
150
indio_dev->masklength) {
169
151
152
+
channel = indio_dev->channels[scan_idx].channel;
170
153
cc10001_adc_start(adc_dev, channel);
171
154
172
155
data[i] = cc10001_adc_poll_done(indio_dev, channel, delay_ns);
···
177
166
}
178
167
179
168
done:
180
-
cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_UP, 0);
169
+
cc10001_adc_power_down(adc_dev);
181
170
182
171
mutex_unlock(&adc_dev->lock);
183
172
···
196
185
unsigned int delay_ns;
197
186
u16 val;
198
187
199
-
cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_UP,
200
-
CC10001_ADC_POWER_UP_SET);
201
-
202
-
/* Wait for 8 (6+2) clock cycles before activating START */
203
-
ndelay(adc_dev->start_delay_ns);
188
+
cc10001_adc_power_up(adc_dev);
204
189
205
190
/* Calculate delay step for eoc and sampled data */
206
191
delay_ns = adc_dev->eoc_delay_ns / CC10001_MAX_POLL_COUNT;
···
205
198
206
199
val = cc10001_adc_poll_done(indio_dev, chan->channel, delay_ns);
207
200
208
-
cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_UP, 0);
201
+
cc10001_adc_power_down(adc_dev);
209
202
210
203
return val;
211
204
}
···
231
224
232
225
case IIO_CHAN_INFO_SCALE:
233
226
ret = regulator_get_voltage(adc_dev->reg);
234
-
if (ret)
227
+
if (ret < 0)
235
228
return ret;
236
229
237
230
*val = ret / 1000;
···
262
255
.update_scan_mode = &cc10001_update_scan_mode,
263
256
};
264
257
265
-
static int cc10001_adc_channel_init(struct iio_dev *indio_dev)
258
+
static int cc10001_adc_channel_init(struct iio_dev *indio_dev,
259
+
unsigned long channel_map)
266
260
{
267
-
struct cc10001_adc_device *adc_dev = iio_priv(indio_dev);
268
261
struct iio_chan_spec *chan_array, *timestamp;
269
262
unsigned int bit, idx = 0;
270
263
271
-
indio_dev->num_channels = bitmap_weight(&adc_dev->channel_map,
272
-
CC10001_ADC_NUM_CHANNELS);
264
+
indio_dev->num_channels = bitmap_weight(&channel_map,
265
+
CC10001_ADC_NUM_CHANNELS) + 1;
273
266
274
-
chan_array = devm_kcalloc(&indio_dev->dev, indio_dev->num_channels + 1,
267
+
chan_array = devm_kcalloc(&indio_dev->dev, indio_dev->num_channels,
275
268
sizeof(struct iio_chan_spec),
276
269
GFP_KERNEL);
277
270
if (!chan_array)
278
271
return -ENOMEM;
279
272
280
-
for_each_set_bit(bit, &adc_dev->channel_map, CC10001_ADC_NUM_CHANNELS) {
273
+
for_each_set_bit(bit, &channel_map, CC10001_ADC_NUM_CHANNELS) {
281
274
struct iio_chan_spec *chan = &chan_array[idx];
282
275
283
276
chan->type = IIO_VOLTAGE;
···
312
305
unsigned long adc_clk_rate;
313
306
struct resource *res;
314
307
struct iio_dev *indio_dev;
308
+
unsigned long channel_map;
315
309
int ret;
316
310
317
311
indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc_dev));
···
321
313
322
314
adc_dev = iio_priv(indio_dev);
323
315
324
-
adc_dev->channel_map = GENMASK(CC10001_ADC_NUM_CHANNELS - 1, 0);
316
+
channel_map = GENMASK(CC10001_ADC_NUM_CHANNELS - 1, 0);
325
317
if (!of_property_read_u32(node, "adc-reserved-channels", &ret))
326
-
adc_dev->channel_map &= ~ret;
318
+
channel_map &= ~ret;
327
319
328
320
adc_dev->reg = devm_regulator_get(&pdev->dev, "vref");
329
321
if (IS_ERR(adc_dev->reg))
···
369
361
adc_dev->start_delay_ns = adc_dev->eoc_delay_ns * CC10001_WAIT_CYCLES;
370
362
371
363
/* Setup the ADC channels available on the device */
372
-
ret = cc10001_adc_channel_init(indio_dev);
364
+
ret = cc10001_adc_channel_init(indio_dev, channel_map);
373
365
if (ret < 0)
374
366
goto err_disable_clk;
375
367
+3
-3
drivers/iio/adc/mcp320x.c
+3
-3
drivers/iio/adc/mcp320x.c
···
60
60
struct spi_message msg;
61
61
struct spi_transfer transfer[2];
62
62
63
-
u8 tx_buf;
64
-
u8 rx_buf[2];
65
-
66
63
struct regulator *reg;
67
64
struct mutex lock;
68
65
const struct mcp320x_chip_info *chip_info;
66
+
67
+
u8 tx_buf ____cacheline_aligned;
68
+
u8 rx_buf[2];
69
69
};
70
70
71
71
static int mcp320x_channel_to_tx_data(int device_index,
+4
-3
drivers/iio/adc/qcom-spmi-vadc.c
+4
-3
drivers/iio/adc/qcom-spmi-vadc.c
···
18
18
#include <linux/iio/iio.h>
19
19
#include <linux/interrupt.h>
20
20
#include <linux/kernel.h>
21
+
#include <linux/math64.h>
21
22
#include <linux/module.h>
22
23
#include <linux/of.h>
23
24
#include <linux/platform_device.h>
···
472
471
const struct vadc_channel_prop *prop, u16 adc_code)
473
472
{
474
473
const struct vadc_prescale_ratio *prescale;
475
-
s32 voltage;
474
+
s64 voltage;
476
475
477
476
voltage = adc_code - vadc->graph[prop->calibration].gnd;
478
477
voltage *= vadc->graph[prop->calibration].dx;
479
-
voltage = voltage / vadc->graph[prop->calibration].dy;
478
+
voltage = div64_s64(voltage, vadc->graph[prop->calibration].dy);
480
479
481
480
if (prop->calibration == VADC_CALIB_ABSOLUTE)
482
481
voltage += vadc->graph[prop->calibration].dx;
···
488
487
489
488
voltage = voltage * prescale->den;
490
489
491
-
return voltage / prescale->num;
490
+
return div64_s64(voltage, prescale->num);
492
491
}
493
492
494
493
static int vadc_decimation_from_dt(u32 value)
+3
-2
drivers/iio/adc/xilinx-xadc-core.c
+3
-2
drivers/iio/adc/xilinx-xadc-core.c
···
856
856
switch (chan->address) {
857
857
case XADC_REG_VCCINT:
858
858
case XADC_REG_VCCAUX:
859
+
case XADC_REG_VREFP:
859
860
case XADC_REG_VCCBRAM:
860
861
case XADC_REG_VCCPINT:
861
862
case XADC_REG_VCCPAUX:
···
997
996
.num_event_specs = (_alarm) ? ARRAY_SIZE(xadc_voltage_events) : 0, \
998
997
.scan_index = (_scan_index), \
999
998
.scan_type = { \
1000
-
.sign = 'u', \
999
+
.sign = ((_addr) == XADC_REG_VREFN) ? 's' : 'u', \
1001
1000
.realbits = 12, \
1002
1001
.storagebits = 16, \
1003
1002
.shift = 4, \
···
1009
1008
static const struct iio_chan_spec xadc_channels[] = {
1010
1009
XADC_CHAN_TEMP(0, 8, XADC_REG_TEMP),
1011
1010
XADC_CHAN_VOLTAGE(0, 9, XADC_REG_VCCINT, "vccint", true),
1012
-
XADC_CHAN_VOLTAGE(1, 10, XADC_REG_VCCINT, "vccaux", true),
1011
+
XADC_CHAN_VOLTAGE(1, 10, XADC_REG_VCCAUX, "vccaux", true),
1013
1012
XADC_CHAN_VOLTAGE(2, 14, XADC_REG_VCCBRAM, "vccbram", true),
1014
1013
XADC_CHAN_VOLTAGE(3, 5, XADC_REG_VCCPINT, "vccpint", true),
1015
1014
XADC_CHAN_VOLTAGE(4, 6, XADC_REG_VCCPAUX, "vccpaux", true),
+3
-3
drivers/iio/adc/xilinx-xadc.h
+3
-3
drivers/iio/adc/xilinx-xadc.h
···
145
145
#define XADC_REG_MAX_VCCPINT 0x28
146
146
#define XADC_REG_MAX_VCCPAUX 0x29
147
147
#define XADC_REG_MAX_VCCO_DDR 0x2a
148
-
#define XADC_REG_MIN_VCCPINT 0x2b
149
-
#define XADC_REG_MIN_VCCPAUX 0x2c
150
-
#define XADC_REG_MIN_VCCO_DDR 0x2d
148
+
#define XADC_REG_MIN_VCCPINT 0x2c
149
+
#define XADC_REG_MIN_VCCPAUX 0x2d
150
+
#define XADC_REG_MIN_VCCO_DDR 0x2e
151
151
152
152
#define XADC_REG_CONF0 0x40
153
153
#define XADC_REG_CONF1 0x41
-2
drivers/iio/common/st_sensors/st_sensors_core.c
-2
drivers/iio/common/st_sensors/st_sensors_core.c
+1
drivers/iio/gyro/st_gyro_core.c
+1
drivers/iio/gyro/st_gyro_core.c
+2
-1
drivers/iio/kfifo_buf.c
+2
-1
drivers/iio/kfifo_buf.c
+5
-7
drivers/iio/light/hid-sensor-prox.c
+5
-7
drivers/iio/light/hid-sensor-prox.c
···
43
43
static const struct iio_chan_spec prox_channels[] = {
44
44
{
45
45
.type = IIO_PROXIMITY,
46
-
.modified = 1,
47
-
.channel2 = IIO_NO_MOD,
48
46
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
49
47
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
50
48
BIT(IIO_CHAN_INFO_SCALE) |
···
251
253
struct iio_dev *indio_dev;
252
254
struct prox_state *prox_state;
253
255
struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
254
-
struct iio_chan_spec *channels;
255
256
256
257
indio_dev = devm_iio_device_alloc(&pdev->dev,
257
258
sizeof(struct prox_state));
···
269
272
return ret;
270
273
}
271
274
272
-
channels = kmemdup(prox_channels, sizeof(prox_channels), GFP_KERNEL);
273
-
if (!channels) {
275
+
indio_dev->channels = kmemdup(prox_channels, sizeof(prox_channels),
276
+
GFP_KERNEL);
277
+
if (!indio_dev->channels) {
274
278
dev_err(&pdev->dev, "failed to duplicate channels\n");
275
279
return -ENOMEM;
276
280
}
277
281
278
-
ret = prox_parse_report(pdev, hsdev, channels,
282
+
ret = prox_parse_report(pdev, hsdev,
283
+
(struct iio_chan_spec *)indio_dev->channels,
279
284
HID_USAGE_SENSOR_PROX, prox_state);
280
285
if (ret) {
281
286
dev_err(&pdev->dev, "failed to setup attributes\n");
282
287
goto error_free_dev_mem;
283
288
}
284
289
285
-
indio_dev->channels = channels;
286
290
indio_dev->num_channels =
287
291
ARRAY_SIZE(prox_channels);
288
292
indio_dev->dev.parent = &pdev->dev;
+1
drivers/iio/magnetometer/st_magn_core.c
+1
drivers/iio/magnetometer/st_magn_core.c
+1
drivers/iio/pressure/bmp280.c
+1
drivers/iio/pressure/bmp280.c
-2
drivers/iio/pressure/hid-sensor-press.c
-2
drivers/iio/pressure/hid-sensor-press.c
+1
drivers/iio/pressure/st_pressure_core.c
+1
drivers/iio/pressure/st_pressure_core.c
+7
-9
drivers/staging/gdm724x/gdm_mux.c
+7
-9
drivers/staging/gdm724x/gdm_mux.c
···
158
158
unsigned int start_flag;
159
159
unsigned int payload_size;
160
160
unsigned short packet_type;
161
-
int dummy_cnt;
161
+
int total_len;
162
162
u32 packet_size_sum = r->offset;
163
163
int index;
164
164
int ret = TO_HOST_INVALID_PACKET;
···
176
176
break;
177
177
}
178
178
179
-
dummy_cnt = ALIGN(MUX_HEADER_SIZE + payload_size, 4);
179
+
total_len = ALIGN(MUX_HEADER_SIZE + payload_size, 4);
180
180
181
181
if (len - packet_size_sum <
182
-
MUX_HEADER_SIZE + payload_size + dummy_cnt) {
182
+
total_len) {
183
183
pr_err("invalid payload : %d %d %04x\n",
184
184
payload_size, len, packet_type);
185
185
break;
···
202
202
break;
203
203
}
204
204
205
-
packet_size_sum += MUX_HEADER_SIZE + payload_size + dummy_cnt;
205
+
packet_size_sum += total_len;
206
206
if (len - packet_size_sum <= MUX_HEADER_SIZE + 2) {
207
207
ret = r->callback(NULL,
208
208
0,
···
361
361
struct mux_pkt_header *mux_header;
362
362
struct mux_tx *t = NULL;
363
363
static u32 seq_num = 1;
364
-
int dummy_cnt;
365
364
int total_len;
366
365
int ret;
367
366
unsigned long flags;
···
373
374
374
375
spin_lock_irqsave(&mux_dev->write_lock, flags);
375
376
376
-
dummy_cnt = ALIGN(MUX_HEADER_SIZE + len, 4);
377
-
378
-
total_len = len + MUX_HEADER_SIZE + dummy_cnt;
377
+
total_len = ALIGN(MUX_HEADER_SIZE + len, 4);
379
378
380
379
t = alloc_mux_tx(total_len);
381
380
if (!t) {
···
389
392
mux_header->packet_type = __cpu_to_le16(packet_type[tty_index]);
390
393
391
394
memcpy(t->buf+MUX_HEADER_SIZE, data, len);
392
-
memset(t->buf+MUX_HEADER_SIZE+len, 0, dummy_cnt);
395
+
memset(t->buf+MUX_HEADER_SIZE+len, 0, total_len - MUX_HEADER_SIZE -
396
+
len);
393
397
394
398
t->len = total_len;
395
399
t->callback = cb;
+7
-10
drivers/staging/rtl8712/rtl871x_ioctl_linux.c
+7
-10
drivers/staging/rtl8712/rtl871x_ioctl_linux.c
···
1900
1900
struct mp_ioctl_handler *phandler;
1901
1901
struct mp_ioctl_param *poidparam;
1902
1902
unsigned long BytesRead, BytesWritten, BytesNeeded;
1903
-
u8 *pparmbuf = NULL, bset;
1903
+
u8 *pparmbuf, bset;
1904
1904
u16 len;
1905
1905
uint status;
1906
1906
int ret = 0;
1907
1907
1908
-
if ((!p->length) || (!p->pointer)) {
1909
-
ret = -EINVAL;
1910
-
goto _r871x_mp_ioctl_hdl_exit;
1911
-
}
1908
+
if ((!p->length) || (!p->pointer))
1909
+
return -EINVAL;
1910
+
1912
1911
bset = (u8)(p->flags & 0xFFFF);
1913
1912
len = p->length;
1914
-
pparmbuf = NULL;
1915
1913
pparmbuf = memdup_user(p->pointer, len);
1916
-
if (IS_ERR(pparmbuf)) {
1917
-
ret = PTR_ERR(pparmbuf);
1918
-
goto _r871x_mp_ioctl_hdl_exit;
1919
-
}
1914
+
if (IS_ERR(pparmbuf))
1915
+
return PTR_ERR(pparmbuf);
1916
+
1920
1917
poidparam = (struct mp_ioctl_param *)pparmbuf;
1921
1918
if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) {
1922
1919
ret = -EINVAL;
+1
-1
drivers/staging/sm750fb/sm750.c
+1
-1
drivers/staging/sm750fb/sm750.c
+7
-3
drivers/staging/vt6655/card.c
+7
-3
drivers/staging/vt6655/card.c
···
362
362
* Return Value: none
363
363
*/
364
364
bool CARDbUpdateTSF(struct vnt_private *pDevice, unsigned char byRxRate,
365
-
u64 qwBSSTimestamp, u64 qwLocalTSF)
365
+
u64 qwBSSTimestamp)
366
366
{
367
+
u64 local_tsf;
367
368
u64 qwTSFOffset = 0;
368
369
369
-
if (qwBSSTimestamp != qwLocalTSF) {
370
-
qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
370
+
CARDbGetCurrentTSF(pDevice, &local_tsf);
371
+
372
+
if (qwBSSTimestamp != local_tsf) {
373
+
qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp,
374
+
local_tsf);
371
375
/* adjust TSF, HW's TSF add TSF Offset reg */
372
376
VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST, (u32)qwTSFOffset);
373
377
VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST + 4, (u32)(qwTSFOffset >> 32));
+1
-1
drivers/staging/vt6655/card.h
+1
-1
drivers/staging/vt6655/card.h
···
83
83
bool CARDbRadioPowerOn(struct vnt_private *);
84
84
bool CARDbSetPhyParameter(struct vnt_private *, u8);
85
85
bool CARDbUpdateTSF(struct vnt_private *, unsigned char byRxRate,
86
-
u64 qwBSSTimestamp, u64 qwLocalTSF);
86
+
u64 qwBSSTimestamp);
87
87
bool CARDbSetBeaconPeriod(struct vnt_private *, unsigned short wBeaconInterval);
88
88
89
89
#endif /* __CARD_H__ */
+25
-17
drivers/staging/vt6655/device_main.c
+25
-17
drivers/staging/vt6655/device_main.c
···
912
912
913
913
if (!(tsr1 & TSR1_TERR)) {
914
914
info->status.rates[0].idx = idx;
915
-
info->flags |= IEEE80211_TX_STAT_ACK;
915
+
916
+
if (info->flags & IEEE80211_TX_CTL_NO_ACK)
917
+
info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED;
918
+
else
919
+
info->flags |= IEEE80211_TX_STAT_ACK;
916
920
}
917
921
918
922
return 0;
···
941
937
/* Only the status of first TD in the chain is correct */
942
938
if (pTD->m_td1TD1.byTCR & TCR_STP) {
943
939
if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
944
-
945
-
vnt_int_report_rate(pDevice, pTD->pTDInfo, byTsr0, byTsr1);
946
-
947
940
if (!(byTsr1 & TSR1_TERR)) {
948
941
if (byTsr0 != 0) {
949
942
pr_debug(" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X]\n",
···
959
958
(int)uIdx, byTsr1, byTsr0);
960
959
}
961
960
}
961
+
962
+
vnt_int_report_rate(pDevice, pTD->pTDInfo, byTsr0, byTsr1);
963
+
962
964
device_free_tx_buf(pDevice, pTD);
963
965
pDevice->iTDUsed[uIdx]--;
964
966
}
···
993
989
skb->len, DMA_TO_DEVICE);
994
990
}
995
991
996
-
if (pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)
992
+
if (skb)
997
993
ieee80211_tx_status_irqsafe(pDevice->hw, skb);
998
-
else
999
-
dev_kfree_skb_irq(skb);
1000
994
1001
995
pTDInfo->skb_dma = 0;
1002
996
pTDInfo->skb = NULL;
···
1206
1204
if (dma_idx == TYPE_AC0DMA)
1207
1205
head_td->pTDInfo->byFlags = TD_FLAGS_NETIF_SKB;
1208
1206
1209
-
priv->iTDUsed[dma_idx]++;
1210
-
1211
-
/* Take ownership */
1212
-
wmb();
1213
-
head_td->m_td0TD0.f1Owner = OWNED_BY_NIC;
1214
-
1215
-
/* get Next */
1216
-
wmb();
1217
1207
priv->apCurrTD[dma_idx] = head_td->next;
1218
1208
1219
1209
spin_unlock_irqrestore(&priv->lock, flags);
···
1226
1232
1227
1233
head_td->buff_addr = cpu_to_le32(head_td->pTDInfo->skb_dma);
1228
1234
1235
+
/* Poll Transmit the adapter */
1236
+
wmb();
1237
+
head_td->m_td0TD0.f1Owner = OWNED_BY_NIC;
1238
+
wmb(); /* second memory barrier */
1239
+
1229
1240
if (head_td->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)
1230
1241
MACvTransmitAC0(priv->PortOffset);
1231
1242
else
1232
1243
MACvTransmit0(priv->PortOffset);
1244
+
1245
+
priv->iTDUsed[dma_idx]++;
1233
1246
1234
1247
spin_unlock_irqrestore(&priv->lock, flags);
1235
1248
···
1417
1416
1418
1417
priv->current_aid = conf->aid;
1419
1418
1420
-
if (changed & BSS_CHANGED_BSSID)
1419
+
if (changed & BSS_CHANGED_BSSID) {
1420
+
unsigned long flags;
1421
+
1422
+
spin_lock_irqsave(&priv->lock, flags);
1423
+
1421
1424
MACvWriteBSSIDAddress(priv->PortOffset, (u8 *)conf->bssid);
1425
+
1426
+
spin_unlock_irqrestore(&priv->lock, flags);
1427
+
}
1422
1428
1423
1429
if (changed & BSS_CHANGED_BASIC_RATES) {
1424
1430
priv->basic_rates = conf->basic_rates;
···
1485
1477
if (changed & BSS_CHANGED_ASSOC && priv->op_mode != NL80211_IFTYPE_AP) {
1486
1478
if (conf->assoc) {
1487
1479
CARDbUpdateTSF(priv, conf->beacon_rate->hw_value,
1488
-
conf->sync_device_ts, conf->sync_tsf);
1480
+
conf->sync_tsf);
1489
1481
1490
1482
CARDbSetBeaconPeriod(priv, conf->beacon_int);
1491
1483
+11
-3
drivers/staging/vt6656/rxtx.c
+11
-3
drivers/staging/vt6656/rxtx.c
···
805
805
vnt_schedule_command(priv, WLAN_CMD_SETPOWER);
806
806
}
807
807
808
-
if (current_rate > RATE_11M)
809
-
pkt_type = priv->packet_type;
810
-
else
808
+
if (current_rate > RATE_11M) {
809
+
if (info->band == IEEE80211_BAND_5GHZ) {
810
+
pkt_type = PK_TYPE_11A;
811
+
} else {
812
+
if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
813
+
pkt_type = PK_TYPE_11GB;
814
+
else
815
+
pkt_type = PK_TYPE_11GA;
816
+
}
817
+
} else {
811
818
pkt_type = PK_TYPE_11B;
819
+
}
812
820
813
821
spin_lock_irqsave(&priv->lock, flags);
814
822