drivers/ata/libata-core.c

2196

version = get_unaligned_le16(&dev->gp_log_dir[0]);

drivers/ata/libata-core.c

2205

version = get_unaligned_le16(&dev->gp_log_dir[0]);

drivers/ata/libata-core.c

2222

return get_unaligned_le16(&dev->gp_log_dir[log * 2]);

drivers/ata/libata-sata.c

1567

extended_sense = get_unaligned_le16(&buf[14]);

drivers/ata/libata-scsi.c

3739

same = get_unaligned_le16(&hdr[4]);

drivers/base/regmap/regmap.c

332

return get_unaligned_le16(buf);

drivers/base/regmap/regmap.c

344

u16 v = get_unaligned_le16(buf);

drivers/block/aoe/aoecmd.c

936

n = get_unaligned_le16(&id[83 << 1]);

drivers/block/aoe/aoecmd.c

939

n |= get_unaligned_le16(&id[86 << 1]);

drivers/block/aoe/aoecmd.c

959

d->geo.cylinders = get_unaligned_le16(&id[54 << 1]);

drivers/block/aoe/aoecmd.c

960

d->geo.heads = get_unaligned_le16(&id[55 << 1]);

drivers/block/aoe/aoecmd.c

961

d->geo.sectors = get_unaligned_le16(&id[56 << 1]);

drivers/bluetooth/btbcm.c

637

vid = get_unaligned_le16(skb->data + 1);

drivers/bluetooth/btbcm.c

638

pid = get_unaligned_le16(skb->data + 3);

drivers/bluetooth/btbcm.c

746

skb->data[1], get_unaligned_le16(skb->data + 5));

drivers/bluetooth/btbcm.c

754

get_unaligned_le16(skb->data + 1),

drivers/bluetooth/btbcm.c

755

get_unaligned_le16(skb->data + 3));

drivers/bluetooth/btintel.c

612

version->dev_rev_id = get_unaligned_le16(tlv->val);

drivers/bluetooth/btintel.c

624

version->timestamp = get_unaligned_le16(tlv->val);

drivers/bluetooth/btmtksdio.c

527

dlen = get_unaligned_le16(skb->data +

drivers/bluetooth/btrsi.c

84

int pkt_len = get_unaligned_le16(pkt) & 0x0fff;

drivers/bluetooth/btrtl.c

1093

lmp_subver = get_unaligned_le16(reg_val);

drivers/bluetooth/btrtl.c

1099

hci_rev = get_unaligned_le16(reg_val);

drivers/bluetooth/btrtl.c

782

u16 chip_id = get_unaligned_le16(chip_id_base +

drivers/bluetooth/btrtl.c

785

patch_length = get_unaligned_le16(patch_length_base +

drivers/bluetooth/btusb.c

1210

u16 handle = get_unaligned_le16(skb->data);

drivers/bluetooth/hci_h4.c

239

dlen = get_unaligned_le16(skb->data +

drivers/bluetooth/hci_nokia.c

351

u16 pkt_size = get_unaligned_le16(fw_ptr);

drivers/bluetooth/hci_qca.c

1006

if (get_unaligned_le16(skb->data) == QCA_DEBUG_HANDLE)

drivers/clk/clk-si5341.c

1013

model = get_unaligned_le16(reg);

drivers/counter/i8254.c

79

*val = get_unaligned_le16(value);

drivers/crypto/intel/qat/qat_common/qat_comp_zstd_utils.c

109

offset = get_unaligned_le16(ip);

drivers/cxl/core/edac.c

1361

if (!get_unaligned_le16(rec->media_hdr.validity_flags))

drivers/cxl/core/edac.c

1372

validity_flags = get_unaligned_le16(rec->media_hdr.validity_flags);

drivers/cxl/core/edac.c

950

validity_flags = get_unaligned_le16(rec->media_hdr.validity_flags);

drivers/cxl/core/edac.c

973

get_unaligned_le16(rec->column) == attrbs->column &&

drivers/cxl/core/trace.h

506

__entry->validity_flags = get_unaligned_le16(&rec->media_hdr.validity_flags);

drivers/cxl/core/trace.h

649

__entry->validity_flags = get_unaligned_le16(rec->media_hdr.validity_flags);

drivers/cxl/core/trace.h

656

__entry->column = get_unaligned_le16(rec->column);

drivers/cxl/core/trace.h

863

__entry->device_temp = get_unaligned_le16(rec->info.device_temp);

drivers/cxl/core/trace.h

865

__entry->validity_flags = get_unaligned_le16(rec->validity_flags);

drivers/firmware/dmi_scan.c

625

dmi_num = get_unaligned_le16(buf + 12);

drivers/firmware/dmi_scan.c

626

dmi_len = get_unaligned_le16(buf + 6);

drivers/fpga/microchip-spi.c

181

components_num = get_unaligned_le16(buf + MPF_DATA_SIZE_OFFSET);

drivers/gpu/drm/bridge/sil-sii8620.c

674

count = get_unaligned_le16(buf);

drivers/gpu/drm/bridge/sil-sii8620.c

754

ctx->burst.r_size = get_unaligned_le16(&d[2]);

drivers/gpu/drm/i915/display/intel_dsi_vbt.c

560

i2c_address = get_unaligned_le16(data + 1);

drivers/gpu/drm/nouveau/nouveau_bios.h

34

#define ROM16(x) get_unaligned_le16(&(x))

drivers/gpu/drm/nouveau/nvkm/subdev/bios/base.c

69

return get_unaligned_le16(&bios->data[addr]);

drivers/gpu/drm/nouveau/nvkm/subdev/mxm/mxms.c

26

#define ROM16(x) get_unaligned_le16(&(x))

drivers/gpu/drm/udl/udl_main.c

44

key = get_unaligned_le16(pos);

drivers/hid/hid-alps.c

376

x = get_unaligned_le16(contact + 3);

drivers/hid/hid-alps.c

377

y = get_unaligned_le16(contact + 5);

drivers/hid/hid-alps.c

410

sp_x = get_unaligned_le16(data+2);

drivers/hid/hid-alps.c

411

sp_y = get_unaligned_le16(data+4);

drivers/hid/hid-core.c

826

item->data.u16 = get_unaligned_le16(start);

drivers/hid/hid-letsketch.c

185

get_unaligned_le16(raw_data + 2));

drivers/hid/hid-letsketch.c

187

get_unaligned_le16(raw_data + 4));

drivers/hid/hid-letsketch.c

189

get_unaligned_le16(raw_data + 6));

drivers/hid/hid-logitech-hidpp.c

3022

.x = get_unaligned_le16(&data[3]),

drivers/hid/hid-logitech-hidpp.c

3023

.y = get_unaligned_le16(&data[5]),

drivers/hid/hid-logitech-hidpp.c

3030

.x = get_unaligned_le16(&data[9]),

drivers/hid/hid-logitech-hidpp.c

3031

.y = get_unaligned_le16(&data[11]),

drivers/hid/hid-nintendo.c

1274

ctlr->accel_cal.offset[i] = get_unaligned_le16(raw_cal + j);

drivers/hid/hid-nintendo.c

1275

ctlr->accel_cal.scale[i] = get_unaligned_le16(raw_cal + j + 6);

drivers/hid/hid-nintendo.c

1276

ctlr->gyro_cal.offset[i] = get_unaligned_le16(raw_cal + j + 12);

drivers/hid/hid-nintendo.c

1277

ctlr->gyro_cal.scale[i] = get_unaligned_le16(raw_cal + j + 18);

drivers/hid/hid-nintendo.c

1370

data->accel_x = get_unaligned_le16(raw + 0);

drivers/hid/hid-nintendo.c

1371

data->accel_y = get_unaligned_le16(raw + 2);

drivers/hid/hid-nintendo.c

1372

data->accel_z = get_unaligned_le16(raw + 4);

drivers/hid/hid-nintendo.c

1373

data->gyro_x = get_unaligned_le16(raw + 6);

drivers/hid/hid-nintendo.c

1374

data->gyro_y = get_unaligned_le16(raw + 8);

drivers/hid/hid-nintendo.c

1375

data->gyro_z = get_unaligned_le16(raw + 10);

drivers/hid/hid-playstation.c

1050

gyro_pitch_bias = get_unaligned_le16(&buf[1]);

drivers/hid/hid-playstation.c

1051

gyro_yaw_bias = get_unaligned_le16(&buf[3]);

drivers/hid/hid-playstation.c

1052

gyro_roll_bias = get_unaligned_le16(&buf[5]);

drivers/hid/hid-playstation.c

1053

gyro_pitch_plus = get_unaligned_le16(&buf[7]);

drivers/hid/hid-playstation.c

1054

gyro_pitch_minus = get_unaligned_le16(&buf[9]);

drivers/hid/hid-playstation.c

1055

gyro_yaw_plus = get_unaligned_le16(&buf[11]);

drivers/hid/hid-playstation.c

1056

gyro_yaw_minus = get_unaligned_le16(&buf[13]);

drivers/hid/hid-playstation.c

1057

gyro_roll_plus = get_unaligned_le16(&buf[15]);

drivers/hid/hid-playstation.c

1058

gyro_roll_minus = get_unaligned_le16(&buf[17]);

drivers/hid/hid-playstation.c

1059

gyro_speed_plus = get_unaligned_le16(&buf[19]);

drivers/hid/hid-playstation.c

1060

gyro_speed_minus = get_unaligned_le16(&buf[21]);

drivers/hid/hid-playstation.c

1061

acc_x_plus = get_unaligned_le16(&buf[23]);

drivers/hid/hid-playstation.c

1062

acc_x_minus = get_unaligned_le16(&buf[25]);

drivers/hid/hid-playstation.c

1063

acc_y_plus = get_unaligned_le16(&buf[27]);

drivers/hid/hid-playstation.c

1064

acc_y_minus = get_unaligned_le16(&buf[29]);

drivers/hid/hid-playstation.c

1065

acc_z_plus = get_unaligned_le16(&buf[31]);

drivers/hid/hid-playstation.c

1066

acc_z_minus = get_unaligned_le16(&buf[33]);

drivers/hid/hid-playstation.c

1176

ds->update_version = get_unaligned_le16(&buf[44]);

drivers/hid/hid-playstation.c

2007

gyro_pitch_bias = get_unaligned_le16(&buf[1]);

drivers/hid/hid-playstation.c

2008

gyro_yaw_bias = get_unaligned_le16(&buf[3]);

drivers/hid/hid-playstation.c

2009

gyro_roll_bias = get_unaligned_le16(&buf[5]);

drivers/hid/hid-playstation.c

2011

gyro_pitch_plus = get_unaligned_le16(&buf[7]);

drivers/hid/hid-playstation.c

2012

gyro_pitch_minus = get_unaligned_le16(&buf[9]);

drivers/hid/hid-playstation.c

2013

gyro_yaw_plus = get_unaligned_le16(&buf[11]);

drivers/hid/hid-playstation.c

2014

gyro_yaw_minus = get_unaligned_le16(&buf[13]);

drivers/hid/hid-playstation.c

2015

gyro_roll_plus = get_unaligned_le16(&buf[15]);

drivers/hid/hid-playstation.c

2016

gyro_roll_minus = get_unaligned_le16(&buf[17]);

drivers/hid/hid-playstation.c

2019

gyro_pitch_plus = get_unaligned_le16(&buf[7]);

drivers/hid/hid-playstation.c

2020

gyro_yaw_plus = get_unaligned_le16(&buf[9]);

drivers/hid/hid-playstation.c

2021

gyro_roll_plus = get_unaligned_le16(&buf[11]);

drivers/hid/hid-playstation.c

2022

gyro_pitch_minus = get_unaligned_le16(&buf[13]);

drivers/hid/hid-playstation.c

2023

gyro_yaw_minus = get_unaligned_le16(&buf[15]);

drivers/hid/hid-playstation.c

2024

gyro_roll_minus = get_unaligned_le16(&buf[17]);

drivers/hid/hid-playstation.c

2026

gyro_speed_plus = get_unaligned_le16(&buf[19]);

drivers/hid/hid-playstation.c

2027

gyro_speed_minus = get_unaligned_le16(&buf[21]);

drivers/hid/hid-playstation.c

2028

acc_x_plus = get_unaligned_le16(&buf[23]);

drivers/hid/hid-playstation.c

2029

acc_x_minus = get_unaligned_le16(&buf[25]);

drivers/hid/hid-playstation.c

2030

acc_y_plus = get_unaligned_le16(&buf[27]);

drivers/hid/hid-playstation.c

2031

acc_y_minus = get_unaligned_le16(&buf[29]);

drivers/hid/hid-playstation.c

2032

acc_z_plus = get_unaligned_le16(&buf[31]);

drivers/hid/hid-playstation.c

2033

acc_z_minus = get_unaligned_le16(&buf[33]);

drivers/hid/hid-playstation.c

2140

ds4->base.hw_version = get_unaligned_le16(&buf[35]);

drivers/hid/hid-playstation.c

2141

ds4->base.fw_version = get_unaligned_le16(&buf[41]);

drivers/hid/hid-uclogic-params.c

1125

pen_x_lm = get_unaligned_le16(str_desc + 2);

drivers/hid/hid-uclogic-params.c

1129

pen_y_lm = get_unaligned_le16(str_desc + 4);

drivers/hid/hid-uclogic-params.c

1132

pen_pressure_lm = get_unaligned_le16(str_desc + 8);

drivers/hid/hid-uclogic-params.c

1134

resolution = get_unaligned_le16(str_desc + 10);

drivers/hid/hid-uclogic-params.c

278

get_unaligned_le16(buf + 2);

drivers/hid/hid-uclogic-params.c

280

get_unaligned_le16(buf + 4);

drivers/hid/hid-uclogic-params.c

282

get_unaligned_le16(buf + 8);

drivers/hid/hid-uclogic-params.c

283

resolution = get_unaligned_le16(buf + 10);

drivers/hid/hid-uclogic-params.c

444

get_unaligned_le16(buf + 8);

drivers/hid/hid-uclogic-params.c

445

resolution = get_unaligned_le16(buf + 10);

drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-protocol.c

255

if (get_unaligned_le16(qcdev->input_buf)) {

drivers/hid/surface-hid/surface_hid_core.c

138

size_t len = get_unaligned_le16(&shid->hid_desc.report_desc_len);

drivers/hid/surface-hid/surface_hid_core.c

207

shid->hid->vendor = get_unaligned_le16(&shid->attrs.vendor);

drivers/hid/surface-hid/surface_hid_core.c

208

shid->hid->product = get_unaligned_le16(&shid->attrs.product);

drivers/hid/surface-hid/surface_hid_core.c

209

shid->hid->version = get_unaligned_le16(&shid->hid_desc.hid_version);

drivers/hid/wacom_wac.c

1287

wacom->id[0] = get_unaligned_le16(&data[107]);

drivers/hid/wacom_wac.c

1292

wacom->id[0] = get_unaligned_le16(&data[41]);

drivers/hid/wacom_wac.c

1353

input_report_abs(pen_input, ABS_X, get_unaligned_le16(&frame[1]));

drivers/hid/wacom_wac.c

1354

input_report_abs(pen_input, ABS_Y, get_unaligned_le16(&frame[3]));

drivers/hid/wacom_wac.c

1360

(int16_t)get_unaligned_le16(&frame[9]);

drivers/hid/wacom_wac.c

1372

get_unaligned_le16(&frame[11]));

drivers/hid/wacom_wac.c

1377

input_report_abs(pen_input, ABS_PRESSURE, get_unaligned_le16(&frame[5]));

drivers/hid/wacom_wac.c

138

input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));

drivers/hid/wacom_wac.c

139

input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));

drivers/hid/wacom_wac.c

1437

int x = get_unaligned_le16(&touch[2]);

drivers/hid/wacom_wac.c

1438

int y = get_unaligned_le16(&touch[4]);

drivers/hid/wacom_wac.c

154

input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));

drivers/hid/wacom_wac.c

155

input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));

drivers/hid/wacom_wac.c

1605

int t_x = get_unaligned_le16(&data[offset + 2]);

drivers/hid/wacom_wac.c

1606

int t_y = get_unaligned_le16(&data[offset + 4 + y_offset]);

drivers/hid/wacom_wac.c

1612

int c_x = get_unaligned_le16(&data[offset + 4]);

drivers/hid/wacom_wac.c

1613

int c_y = get_unaligned_le16(&data[offset + 8]);

drivers/hid/wacom_wac.c

1614

int w = get_unaligned_le16(&data[offset + 10]);

drivers/hid/wacom_wac.c

1615

int h = get_unaligned_le16(&data[offset + 12]);

drivers/hid/wacom_wac.c

1661

int id = get_unaligned_le16(&data[offset + 1]);

drivers/hid/wacom_wac.c

1670

int x = get_unaligned_le16(&data[offset + x_offset + 7]);

drivers/hid/wacom_wac.c

1671

int y = get_unaligned_le16(&data[offset + x_offset + 9]);

drivers/hid/wacom_wac.c

1726

x = get_unaligned_le16(&data[1]);

drivers/hid/wacom_wac.c

1727

y = get_unaligned_le16(&data[3]);

drivers/hid/wacom_wac.c

1730

x = get_unaligned_le16(&data[3]);

drivers/hid/wacom_wac.c

1731

y = get_unaligned_le16(&data[5]);

drivers/hwmon/aquacomputer_d5next.c

946

sensor_value = get_unaligned_le16(priv->buffer + priv->temp_sensor_start_offset +

drivers/hwmon/aquacomputer_d5next.c

958

priv->serial_number[0] = get_unaligned_le16(priv->buffer +

drivers/hwmon/aquacomputer_d5next.c

961

get_unaligned_le16(priv->buffer + priv->firmware_version_offset);

drivers/hwmon/aquacomputer_d5next.c

964

sensor_value = get_unaligned_le16(priv->buffer + priv->fan_sensor_offsets[0]);

drivers/hwmon/aquacomputer_d5next.c

968

sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_FAN_STATUS_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

973

get_unaligned_le16(priv->buffer + priv->fan_sensor_offsets[1]);

drivers/hwmon/aquacomputer_d5next.c

978

sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_PUMP_CURR_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

981

sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_PUMP_VOLTAGE_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

984

sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_FAN_VOLTAGE_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

989

priv->serial_number[0] = get_unaligned_le16(priv->buffer +

drivers/hwmon/aquacomputer_d5next.c

992

get_unaligned_le16(priv->buffer + priv->firmware_version_offset);

drivers/hwmon/aquacomputer_d5next.c

995

priv->speed_input[0] = get_unaligned_le16(priv->buffer +

drivers/hwmon/arctic_fan_controller.c

76

priv->fan_rpm[i] = get_unaligned_le16(&buf[rpm_off + i * 2]);

drivers/hwmon/asus_rog_ryujin.c

399

priv->speed_input[0] = get_unaligned_le16(data + RYUJIN_PUMP_SPEED);

drivers/hwmon/asus_rog_ryujin.c

400

priv->speed_input[1] = get_unaligned_le16(data + RYUJIN_INTERNAL_FAN_SPEED);

drivers/hwmon/asus_rog_ryujin.c

406

priv->speed_input[2] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_1);

drivers/hwmon/asus_rog_ryujin.c

407

priv->speed_input[3] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_2);

drivers/hwmon/asus_rog_ryujin.c

408

priv->speed_input[4] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_3);

drivers/hwmon/asus_rog_ryujin.c

409

priv->speed_input[5] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_4);

drivers/hwmon/gigabyte_waterforce.c

274

priv->speed_input[0] = get_unaligned_le16(data + WATERFORCE_FAN_SPEED);

drivers/hwmon/gigabyte_waterforce.c

275

priv->speed_input[1] = get_unaligned_le16(data + WATERFORCE_PUMP_SPEED);

drivers/hwmon/nzxt-kraken3.c

777

priv->fan_input[0] = get_unaligned_le16(data + PUMP_SPEED_OFFSET);

drivers/hwmon/nzxt-kraken3.c

786

priv->fan_input[1] = get_unaligned_le16(data + Z53_FAN_SPEED_OFFSET);

drivers/hwmon/nzxt-smart2.c

284

get_unaligned_le16(&report->fan_speed.fan_rpm[i]);

drivers/hwmon/nzxt-smart2.c

296

get_unaligned_le16(&report->fan_voltage.fan_in[i]);

drivers/hwmon/nzxt-smart2.c

298

get_unaligned_le16(&report->fan_voltage.fan_current[i]);

drivers/iio/accel/adxl367.c

756

*fifo_entries = get_unaligned_le16(&st->status_buf[1]);

drivers/iio/accel/dmard09.c

73

accel = get_unaligned_le16(&buf[chan->address]);

drivers/iio/adc/qcom-spmi-adc5-gen3.c

104

*data = get_unaligned_le16(rslt);

drivers/iio/adc/ti-ads7138.c

246

*val = get_unaligned_le16(values);

drivers/iio/adc/ti-ads7138.c

255

*val = get_unaligned_le16(values);

drivers/iio/adc/ti-ads7138.c

264

*val = get_unaligned_le16(values);

drivers/iio/chemical/bme680_core.c

246

calib->par_t2 = get_unaligned_le16(&data->bme680_cal_buf_1[T2_LSB]);

drivers/iio/chemical/bme680_core.c

248

calib->par_p1 = get_unaligned_le16(&data->bme680_cal_buf_1[P1_LSB]);

drivers/iio/chemical/bme680_core.c

249

calib->par_p2 = get_unaligned_le16(&data->bme680_cal_buf_1[P2_LSB]);

drivers/iio/chemical/bme680_core.c

251

calib->par_p4 = get_unaligned_le16(&data->bme680_cal_buf_1[P4_LSB]);

drivers/iio/chemical/bme680_core.c

252

calib->par_p5 = get_unaligned_le16(&data->bme680_cal_buf_1[P5_LSB]);

drivers/iio/chemical/bme680_core.c

255

calib->par_p8 = get_unaligned_le16(&data->bme680_cal_buf_1[P8_LSB]);

drivers/iio/chemical/bme680_core.c

256

calib->par_p9 = get_unaligned_le16(&data->bme680_cal_buf_1[P9_LSB]);

drivers/iio/chemical/bme680_core.c

282

calib->par_t1 = get_unaligned_le16(&data->bme680_cal_buf_2[T1_LSB]);

drivers/iio/chemical/bme680_core.c

283

calib->par_gh2 = get_unaligned_le16(&data->bme680_cal_buf_2[GH2_LSB]);

drivers/iio/chemical/scd30_serial.c

159

crc = get_unaligned_le16(rxbuf + rxsize);

drivers/iio/common/st_sensors/st_sensors_core.c

518

tmp = get_unaligned_le16(outdata);

drivers/iio/dac/ad5770r.c

327

buf16 = get_unaligned_le16(st->transf_buf);

drivers/iio/frequency/adf4377.c

533

get_unaligned_le16(&st->buf));

drivers/iio/light/gp2ap020a00f.c

957

out_val = get_unaligned_le16(&priv->buffer[d_size]);

drivers/iio/light/tsl2591.c

394

als_ch0 = get_unaligned_le16(&als_data[0]);

drivers/iio/light/tsl2591.c

395

als_ch1 = get_unaligned_le16(&als_data[2]);

drivers/iio/pressure/bmp280-core.c

1628

calib->T1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T1]);

drivers/iio/pressure/bmp280-core.c

1629

calib->T2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_T2]);

drivers/iio/pressure/bmp280-core.c

1631

calib->P1 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P1]);

drivers/iio/pressure/bmp280-core.c

1632

calib->P2 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P2]);

drivers/iio/pressure/bmp280-core.c

1635

calib->P5 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P5]);

drivers/iio/pressure/bmp280-core.c

1636

calib->P6 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P6]);

drivers/iio/pressure/bmp280-core.c

1639

calib->P9 = get_unaligned_le16(&data->bmp380_cal_buf[BMP380_P9]);

drivers/iio/pressure/bmp280-core.c

387

calib->H2 = get_unaligned_le16(&data->bme280_humid_cal_buf[H2]);

drivers/iio/pressure/bmp280-core.c

394

tmp_3 = get_unaligned_le16(&data->bme280_humid_cal_buf[H5]);

drivers/iio/proximity/aw96103.c

504

reg_addr = get_unaligned_le16(aw_bin_data_s->data + start_addr);

drivers/iio/proximity/hx9023s.c

1042

bin->reg_count = get_unaligned_le16(bin->data + FW_REG_CNT_OFFSET);

drivers/iio/proximity/hx9023s.c

528

value = get_unaligned_le16(&buf[i * 3 + 1]);

drivers/iio/proximity/hx9023s.c

548

value = get_unaligned_le16(&buf[i * 3 + 1]);

drivers/iio/proximity/hx9023s.c

568

value = get_unaligned_le16(&buf[i * 2]);

drivers/input/joystick/adc-joystick.c

84

val = get_unaligned_le16(data_u16);

drivers/input/joystick/iforce/iforce-main.c

278

input_dev->id.vendor = get_unaligned_le16(buf + 1);

drivers/input/joystick/iforce/iforce-main.c

283

input_dev->id.product = get_unaligned_le16(buf + 1);

drivers/input/joystick/iforce/iforce-main.c

288

iforce->device_memory.end = get_unaligned_le16(buf + 1);

drivers/input/joystick/iforce/iforce-packets.c

159

(__s16) get_unaligned_le16(data));

drivers/input/joystick/iforce/iforce-packets.c

161

(__s16) get_unaligned_le16(data + 2));

drivers/input/joystick/iforce/iforce-packets.c

174

(__s16) get_unaligned_le16(data));

drivers/input/joystick/iforce/iforce-packets.c

204

mark_core_as_ready(iforce, get_unaligned_le16(data + j));

drivers/input/misc/ims-pcu.c

1047

get_unaligned_le16(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);

drivers/input/misc/ims-pcu.c

1329

result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);

drivers/input/misc/ims-pcu.c

1355

result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);

drivers/input/misc/iqs7222.c

1663

if (get_unaligned_le16(msg[1].buf) == IQS7222_COMMS_ERROR) {

drivers/input/mouse/cyapa_gen5.c

1280

if (app_integrity_crc != get_unaligned_le16(&metadata->metadata_crc)) {

drivers/input/mouse/cyapa_gen5.c

1286

fw_app_len = get_unaligned_le16(&metadata->app_len);

drivers/input/mouse/cyapa_gen5.c

1288

fw_upgrade_len = get_unaligned_le16(&metadata->upgrade_len);

drivers/input/mouse/cyapa_gen5.c

1306

if (app_crc != get_unaligned_le16(&metadata->app_crc)) {

drivers/input/mouse/cyapa_gen5.c

1540

*interval_time = get_unaligned_le16(&resp_data[7]) & mask;

drivers/input/mouse/cyapa_gen5.c

1882

value = get_unaligned_le16(buf);

drivers/input/mouse/cyapa_gen5.c

2033

read_len = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen5.c

2263

read_elements = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen5.c

2493

product_family = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen5.c

2512

cyapa->physical_size_x = get_unaligned_le16(&resp_data[54]) / 100;

drivers/input/mouse/cyapa_gen5.c

2513

cyapa->physical_size_y = get_unaligned_le16(&resp_data[56]) / 100;

drivers/input/mouse/cyapa_gen5.c

2515

cyapa->max_abs_x = get_unaligned_le16(&resp_data[58]);

drivers/input/mouse/cyapa_gen5.c

2516

cyapa->max_abs_y = get_unaligned_le16(&resp_data[60]);

drivers/input/mouse/cyapa_gen5.c

2518

cyapa->max_z = get_unaligned_le16(&resp_data[62]);

drivers/input/mouse/cyapa_gen5.c

2623

length = get_unaligned_le16(pip->irq_cmd_buf);

drivers/input/mouse/cyapa_gen5.c

2785

report_len = get_unaligned_le16(

drivers/input/mouse/cyapa_gen5.c

2816

report_len = get_unaligned_le16(

drivers/input/mouse/cyapa_gen5.c

484

length = get_unaligned_le16(pip->empty_buf);

drivers/input/mouse/cyapa_gen5.c

511

length = get_unaligned_le16(pip->empty_buf);

drivers/input/mouse/cyapa_gen5.c

696

resp_len = get_unaligned_le16(&data[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen5.c

738

resp_len = get_unaligned_le16(&buf[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen5.c

739

max_output_len = get_unaligned_le16(&buf[16]);

drivers/input/mouse/cyapa_gen5.c

788

length = get_unaligned_le16(&resp_data[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen5.c

808

length = get_unaligned_le16(

drivers/input/mouse/cyapa_gen5.c

810

max_output_len = get_unaligned_le16(&resp_data[16]);

drivers/input/mouse/cyapa_gen5.c

852

length = get_unaligned_le16(&resp_data[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen5.c

853

max_output_len = get_unaligned_le16(&resp_data[16]);

drivers/input/mouse/cyapa_gen5.c

896

length = get_unaligned_le16(&reg_data[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen5.c

934

length = get_unaligned_le16(&reg_data[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen5.c

987

length = get_unaligned_le16(&reg_data[PIP_RESP_LENGTH_OFFSET]);

drivers/input/mouse/cyapa_gen6.c

123

product_family = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen6.c

211

product_family = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen6.c

224

cyapa->physical_size_x = get_unaligned_le16(&resp_data[35]) / 100;

drivers/input/mouse/cyapa_gen6.c

225

cyapa->physical_size_y = get_unaligned_le16(&resp_data[37]) / 100;

drivers/input/mouse/cyapa_gen6.c

227

cyapa->max_abs_x = get_unaligned_le16(&resp_data[39]);

drivers/input/mouse/cyapa_gen6.c

228

cyapa->max_abs_y = get_unaligned_le16(&resp_data[41]);

drivers/input/mouse/cyapa_gen6.c

230

cyapa->max_z = get_unaligned_le16(&resp_data[43]);

drivers/input/mouse/cyapa_gen6.c

381

interval_setting->active_interval = get_unaligned_le16(&resp_data[5]);

drivers/input/mouse/cyapa_gen6.c

382

interval_setting->lp1_interval = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen6.c

383

interval_setting->lp2_interval = get_unaligned_le16(&resp_data[9]);

drivers/input/mouse/cyapa_gen6.c

405

interval_setting->active_interval = get_unaligned_le16(&resp_data[5]);

drivers/input/mouse/cyapa_gen6.c

406

interval_setting->lp1_interval = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/cyapa_gen6.c

407

interval_setting->lp2_interval = get_unaligned_le16(&resp_data[9]);

drivers/input/mouse/cyapa_gen6.c

594

read_len = get_unaligned_le16(&resp_data[7]);

drivers/input/mouse/elan_i2c_core.c

517

iap_start_addr = get_unaligned_le16(&fw->data[ETP_IAP_START_ADDR * 2]);

drivers/input/rmi4/rmi_driver.c

579

item->reg_size = get_unaligned_le16(&buf[offset]);

drivers/input/rmi4/rmi_driver.c

652

rdesc->struct_size = get_unaligned_le16(&buf[1]);

drivers/input/rmi4/rmi_f12.c

133

sensor->max_x = get_unaligned_le16(&buf[offset]);

drivers/input/rmi4/rmi_f12.c

134

sensor->max_y = get_unaligned_le16(&buf[offset + 2]);

drivers/input/rmi4/rmi_f12.c

142

pitch_x = get_unaligned_le16(&buf[offset]);

drivers/input/rmi4/rmi_f12.c

143

pitch_y = get_unaligned_le16(&buf[offset + 2]);

drivers/input/rmi4/rmi_f12.c

226

obj->x = get_unaligned_le16(&data1[1]);

drivers/input/rmi4/rmi_f12.c

227

obj->y = get_unaligned_le16(&data1[3]);

drivers/input/rmi4/rmi_f34.c

541

f34->v5.block_size = get_unaligned_le16(&f34_queries[3]);

drivers/input/rmi4/rmi_f34.c

542

f34->v5.fw_blocks = get_unaligned_le16(&f34_queries[5]);

drivers/input/rmi4/rmi_f34.c

543

f34->v5.config_blocks = get_unaligned_le16(&f34_queries[7]);

drivers/input/tablet/aiptek.c

478

x = get_unaligned_le16(data + 1);

drivers/input/tablet/aiptek.c

479

y = get_unaligned_le16(data + 3);

drivers/input/tablet/aiptek.c

480

z = get_unaligned_le16(data + 6);

drivers/input/tablet/aiptek.c

563

x = get_unaligned_le16(data + 1);

drivers/input/tablet/aiptek.c

564

y = get_unaligned_le16(data + 3);

drivers/input/tablet/aiptek.c

631

z = get_unaligned_le16(data + 4);

drivers/input/tablet/aiptek.c

711

macro = get_unaligned_le16(data + 1);

drivers/input/tablet/aiptek.c

913

ret = get_unaligned_le16(buf + 1);

drivers/input/tablet/kbtab.c

61

input_report_abs(dev, ABS_X, get_unaligned_le16(&data[1]));

drivers/input/tablet/kbtab.c

62

input_report_abs(dev, ABS_Y, get_unaligned_le16(&data[3]));

drivers/input/touchscreen/apple_z2.c

149

pkt_len = (get_unaligned_le16(z2->rx_buf + 1) + 8) & 0xfffffffc;

drivers/input/touchscreen/atmel_mxt_ts.c

1957

data->max_x = get_unaligned_le16(&range.x);

drivers/input/touchscreen/atmel_mxt_ts.c

1958

data->max_y = get_unaligned_le16(&range.y);

drivers/input/touchscreen/atmel_mxt_ts.c

1993

data->max_x = get_unaligned_le16(&range_x);

drivers/input/touchscreen/atmel_mxt_ts.c

2001

data->max_y = get_unaligned_le16(&range_y);

drivers/input/touchscreen/atmel_mxt_ts.c

2382

return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);

drivers/input/touchscreen/atmel_mxt_ts.c

941

x = get_unaligned_le16(&message[2]);

drivers/input/touchscreen/atmel_mxt_ts.c

942

y = get_unaligned_le16(&message[4]);

drivers/input/touchscreen/chipone_icn8505.c

255

if (get_unaligned_le16(buf) != fw->size) {

drivers/input/touchscreen/chipone_icn8505.c

351

get_unaligned_le16(touch->x),

drivers/input/touchscreen/chipone_icn8505.c

352

get_unaligned_le16(touch->y),

drivers/input/touchscreen/cyttsp5.c

229

size = get_unaligned_le16(temp);

drivers/input/touchscreen/cyttsp5.c

463

size = get_unaligned_le16(&ts->response_buf[0]);

drivers/input/touchscreen/cyttsp5.c

482

if (get_unaligned_le16(&ts->response_buf[size - 3]) != crc) {

drivers/input/touchscreen/cyttsp5.c

531

scd->res_x = get_unaligned_le16(&scd_dev->res_x);

drivers/input/touchscreen/cyttsp5.c

532

scd->res_y = get_unaligned_le16(&scd_dev->res_y);

drivers/input/touchscreen/cyttsp5.c

533

scd->max_z = get_unaligned_le16(&scd_dev->max_z);

drivers/input/touchscreen/cyttsp5.c

534

scd->len_x = get_unaligned_le16(&scd_dev->len_x);

drivers/input/touchscreen/cyttsp5.c

535

scd->len_y = get_unaligned_le16(&scd_dev->len_y);

drivers/input/touchscreen/cyttsp5.c

706

size = get_unaligned_le16(&ts->input_buf[0]);

drivers/input/touchscreen/cyttsp5.c

745

size = get_unaligned_le16(&buf[0]);

drivers/input/touchscreen/elants_i2c.c

738

fw_remark_id = get_unaligned_le16(&fw->data[fw->size - 4]);

drivers/input/touchscreen/exc3000.c

100

get_unaligned_le16(buf + 4),

drivers/input/touchscreen/exc3000.c

143

if (get_unaligned_le16(buf) != EXC3000_LEN_FRAME)

drivers/input/touchscreen/exc3000.c

99

get_unaligned_le16(buf + 2),

drivers/input/touchscreen/goodix.c

1063

x_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC]);

drivers/input/touchscreen/goodix.c

1064

y_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC + 2]);

drivers/input/touchscreen/goodix.c

1092

ts->version = get_unaligned_le16(&buf[4]);

drivers/input/touchscreen/goodix.c

364

input_x = get_unaligned_le16(&data[4]);

drivers/input/touchscreen/goodix.c

365

input_y = get_unaligned_le16(&data[6]);

drivers/input/touchscreen/goodix.c

366

input_w = get_unaligned_le16(&data[8]);

drivers/input/touchscreen/goodix.c

368

input_x = get_unaligned_le16(&data[2]);

drivers/input/touchscreen/goodix.c

369

input_y = get_unaligned_le16(&data[4]);

drivers/input/touchscreen/goodix.c

370

input_w = get_unaligned_le16(&data[6]);

drivers/input/touchscreen/goodix.c

407

int input_x = get_unaligned_le16(&coor_data[1]);

drivers/input/touchscreen/goodix.c

408

int input_y = get_unaligned_le16(&coor_data[3]);

drivers/input/touchscreen/goodix.c

409

int input_w = get_unaligned_le16(&coor_data[5]);

drivers/input/touchscreen/goodix.c

422

int input_x = get_unaligned_le16(&coor_data[3]);

drivers/input/touchscreen/goodix.c

423

int input_y = get_unaligned_le16(&coor_data[5]);

drivers/input/touchscreen/goodix.c

424

int input_w = get_unaligned_le16(&coor_data[7]);

drivers/input/touchscreen/goodix_berlin_core.c

195

r_checksum = get_unaligned_le16(&data[i]);

drivers/input/touchscreen/himax_hx852x.c

277

finger_pressed = get_unaligned_le16(&info->finger_pressed);

drivers/input/touchscreen/ilitek_ts_i2c.c

197

x = get_unaligned_le16(buf + i * packet_len + 2);

drivers/input/touchscreen/ilitek_ts_i2c.c

198

y = get_unaligned_le16(buf + i * packet_len + 4);

drivers/input/touchscreen/ilitek_ts_i2c.c

263

ts->mcu_ver = get_unaligned_le16(outbuf);

drivers/input/touchscreen/ilitek_ts_i2c.c

297

ts->screen_min_x = get_unaligned_le16(outbuf);

drivers/input/touchscreen/ilitek_ts_i2c.c

298

ts->screen_min_y = get_unaligned_le16(outbuf + 2);

drivers/input/touchscreen/ilitek_ts_i2c.c

299

ts->screen_max_x = get_unaligned_le16(outbuf + 4);

drivers/input/touchscreen/ilitek_ts_i2c.c

300

ts->screen_max_y = get_unaligned_le16(outbuf + 6);

drivers/input/touchscreen/iqs7211.c

1327

if (get_unaligned_le16(msg[1].buf) == IQS7211_COMMS_ERROR) {

drivers/input/touchscreen/melfas_mip4.c

1174

tail_size = get_unaligned_le16(&fw_info->tail_size);

drivers/input/touchscreen/melfas_mip4.c

216

v->boot = get_unaligned_le16(buf + 0);

drivers/input/touchscreen/melfas_mip4.c

217

v->core = get_unaligned_le16(buf + 2);

drivers/input/touchscreen/melfas_mip4.c

218

v->app = get_unaligned_le16(buf + 4);

drivers/input/touchscreen/melfas_mip4.c

219

v->param = get_unaligned_le16(buf + 6);

drivers/input/touchscreen/melfas_mip4.c

282

ts->product_id = get_unaligned_le16(&buf[0]);

drivers/input/touchscreen/melfas_mip4.c

322

ts->max_x = get_unaligned_le16(&buf[0]);

drivers/input/touchscreen/melfas_mip4.c

323

ts->max_y = get_unaligned_le16(&buf[2]);

drivers/input/touchscreen/melfas_mip4.c

353

ts->event_format = get_unaligned_le16(&buf[4]);

drivers/input/touchscreen/melfas_mip4.c

873

*buf_addr = get_unaligned_le16(result);

drivers/input/touchscreen/pixcir_i2c_ts.c

136

get_unaligned_le16(bufptr),

drivers/input/touchscreen/pixcir_i2c_ts.c

137

get_unaligned_le16(bufptr + 2));

drivers/input/touchscreen/raydium_i2c_ts.c

875

get_unaligned_le16(&contact[RM_CONTACT_X_POS]));

drivers/input/touchscreen/raydium_i2c_ts.c

877

get_unaligned_le16(&contact[RM_CONTACT_Y_POS]));

drivers/input/touchscreen/raydium_i2c_ts.c

907

fw_crc = get_unaligned_le16(&ts->report_data[ts->report_size]);

drivers/input/touchscreen/silead.c

222

get_unaligned_le16(&coord[SILEAD_POINT_X_OFF]) & 0xfff,

drivers/input/touchscreen/silead.c

223

get_unaligned_le16(&coord[SILEAD_POINT_Y_OFF]) & 0xfff);

drivers/input/touchscreen/silead.c

292

get_unaligned_le16(&bufp[SILEAD_POINT_X_OFF]) & 0xfff,

drivers/input/touchscreen/silead.c

293

get_unaligned_le16(&bufp[SILEAD_POINT_Y_OFF]) & 0xfff);

drivers/input/touchscreen/sis_i2c.c

118

len = get_unaligned_le16(&buf[SIS_PKT_LEN_OFFSET]);

drivers/input/touchscreen/sis_i2c.c

141

pkg_crc = get_unaligned_le16(&buf[len - 2]);

drivers/input/touchscreen/sis_i2c.c

208

x = get_unaligned_le16(&data[SIS_CONTACT_X_OFFSET]);

drivers/input/touchscreen/sis_i2c.c

209

y = get_unaligned_le16(&data[SIS_CONTACT_Y_OFFSET]);

drivers/input/touchscreen/surface3_spi.c

148

get_unaligned_le16(&pen->x));

drivers/input/touchscreen/surface3_spi.c

151

get_unaligned_le16(&pen->y));

drivers/input/touchscreen/surface3_spi.c

154

get_unaligned_le16(&pen->pressure));

drivers/input/touchscreen/surface3_spi.c

73

get_unaligned_le16(&finger->tracking_id));

drivers/input/touchscreen/surface3_spi.c

82

get_unaligned_le16(&finger->x));

drivers/input/touchscreen/surface3_spi.c

85

get_unaligned_le16(&finger->y));

drivers/input/touchscreen/surface3_spi.c

88

get_unaligned_le16(&finger->width));

drivers/input/touchscreen/surface3_spi.c

91

get_unaligned_le16(&finger->height));

drivers/input/touchscreen/wacom_i2c.c

93

features->x_max = get_unaligned_le16(&data[3]);

drivers/input/touchscreen/wacom_i2c.c

94

features->y_max = get_unaligned_le16(&data[5]);

drivers/input/touchscreen/wacom_i2c.c

95

features->pressure_max = get_unaligned_le16(&data[11]);

drivers/input/touchscreen/wacom_i2c.c

96

features->fw_version = get_unaligned_le16(&data[13]);

drivers/input/touchscreen/wdt87xx_i2c.c

309

rx_len = min_t(size_t, buf_size, get_unaligned_le16(rx_buf));

drivers/input/touchscreen/wdt87xx_i2c.c

446

param->vendor_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_VID);

drivers/input/touchscreen/wdt87xx_i2c.c

447

param->product_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_PID);

drivers/input/touchscreen/wdt87xx_i2c.c

455

param->xmls_id1 = get_unaligned_le16(buf + CTL_PARAM_OFFSET_XMLS_ID1);

drivers/input/touchscreen/wdt87xx_i2c.c

456

param->xmls_id2 = get_unaligned_le16(buf + CTL_PARAM_OFFSET_XMLS_ID2);

drivers/input/touchscreen/wdt87xx_i2c.c

457

param->phy_ch_x = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_CH_X);

drivers/input/touchscreen/wdt87xx_i2c.c

458

param->phy_ch_y = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_CH_Y);

drivers/input/touchscreen/wdt87xx_i2c.c

459

param->phy_w = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_W) / 10;

drivers/input/touchscreen/wdt87xx_i2c.c

460

param->phy_h = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_H) / 10;

drivers/input/touchscreen/wdt87xx_i2c.c

464

get_unaligned_le16(buf + CTL_PARAM_OFFSET_FACTOR);

drivers/input/touchscreen/wdt87xx_i2c.c

491

param->fw_id = get_unaligned_le16(&buf[1]);

drivers/input/touchscreen/wdt87xx_i2c.c

682

*checksum = get_unaligned_le16(&pkt_buf[CMD_DATA_OFFSET]);

drivers/input/touchscreen/wdt87xx_i2c.c

968

x = get_unaligned_le16(buf + FINGER_EV_V1_OFFSET_X);

drivers/input/touchscreen/wdt87xx_i2c.c

970

y = get_unaligned_le16(buf + FINGER_EV_V1_OFFSET_Y);

drivers/input/touchscreen/zet6223.c

162

ts->max_x = get_unaligned_le16(&buf[8]);

drivers/input/touchscreen/zet6223.c

163

ts->max_y = get_unaligned_le16(&buf[10]);

drivers/input/touchscreen/zforce_ts.c

323

point.coord_x = get_unaligned_le16(&p[0]);

drivers/input/touchscreen/zforce_ts.c

324

point.coord_y = get_unaligned_le16(&p[2]);

drivers/input/touchscreen/zforce_ts.c

514

get_unaligned_le16(&payload[RESPONSE_DATA]);

drivers/input/touchscreen/zforce_ts.c

516

get_unaligned_le16(&payload[RESPONSE_DATA + 2]);

drivers/input/touchscreen/zforce_ts.c

518

get_unaligned_le16(&payload[RESPONSE_DATA + 4]);

drivers/input/touchscreen/zforce_ts.c

520

get_unaligned_le16(&payload[RESPONSE_DATA + 6]);

drivers/md/dm-vdo/indexer/delta-index.c

1003

.byte_count = get_unaligned_le16(&buffer[2]),

drivers/md/dm-vdo/indexer/delta-index.c

1418

*name++ = get_unaligned_le16(addr++) >> shift;

drivers/md/dm-vdo/indexer/delta-index.c

1431

data = (get_unaligned_le16(addr) & mask) | (*name++ << shift);

drivers/md/dm-vdo/indexer/delta-index.c

508

first_list = get_unaligned_le16(first_list_addr);

drivers/md/dm-vdo/indexer/delta-index.c

509

list_count = get_unaligned_le16(list_count_addr);

drivers/md/dm-vdo/indexer/delta-index.c

931

delta_list_size = get_unaligned_le16(size_data);

drivers/md/dm-vdo/numeric.h

68

*decoded = get_unaligned_le16(buffer + *offset);

drivers/media/tuners/xc2028.c

325

priv->firm_version = get_unaligned_le16(p);

drivers/media/tuners/xc2028.c

328

n_array = get_unaligned_le16(p);

drivers/media/tuners/xc2028.c

366

int_freq = get_unaligned_le16(p);

drivers/media/tuners/xc4000.c

756

priv->firm_version = get_unaligned_le16(p);

drivers/media/tuners/xc4000.c

759

n_array = get_unaligned_le16(p);

drivers/media/tuners/xc4000.c

797

int_freq = get_unaligned_le16(p);

drivers/media/usb/dvb-usb/m920x.c

425

value = get_unaligned_le16(fw->data + i);

drivers/media/usb/dvb-usb/m920x.c

428

index = get_unaligned_le16(fw->data + i);

drivers/media/usb/dvb-usb/m920x.c

431

size = get_unaligned_le16(fw->data + i);

drivers/media/usb/uvc/uvc_driver.c

1027

type = get_unaligned_le16(&buffer[4]);

drivers/media/usb/uvc/uvc_driver.c

1066

get_unaligned_le16(&buffer[8]);

drivers/media/usb/uvc/uvc_driver.c

1068

get_unaligned_le16(&buffer[10]);

drivers/media/usb/uvc/uvc_driver.c

1070

get_unaligned_le16(&buffer[12]);

drivers/media/usb/uvc/uvc_driver.c

1107

type = get_unaligned_le16(&buffer[4]);

drivers/media/usb/uvc/uvc_driver.c

1187

get_unaligned_le16(&buffer[5]);

drivers/media/usb/uvc/uvc_driver.c

254

frame->wWidth = get_unaligned_le16(&buffer[5]) * width_multiplier;

drivers/media/usb/uvc/uvc_driver.c

255

frame->wHeight = get_unaligned_le16(&buffer[7]);

drivers/media/usb/uvc/uvc_driver.c

991

dev->uvc_version = get_unaligned_le16(&buffer[3]);

drivers/media/usb/uvc/uvc_video.c

602

sample.dev_sof = get_unaligned_le16(&data[header_size - 2]) & 2047;

drivers/media/usb/uvc/uvc_video.c

985

scr_sof = get_unaligned_le16(&data[header_size - 2]);

drivers/media/v4l2-core/v4l2-cci.c

55

*val = get_unaligned_le16(buf);

drivers/mfd/iqs62x.c

484

event_data.ui_data = get_unaligned_le16(&event_map[i]);

drivers/net/can/usb/etas_es58x/es581_4.c

180

u16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es581_4.c

204

u16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es581_4.c

223

get_unaligned_le16(&tx_ack_msg->tx_free_entries),

drivers/net/can/usb/etas_es58x/es581_4.c

231

u16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es581_4.c

36

return get_unaligned_le16(&urb_cmd->es581_4_urb_cmd.msg_len);

drivers/net/can/usb/etas_es58x/es581_4.c

52

msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len) -

drivers/net/can/usb/etas_es58x/es58x_core.c

105

crc = get_unaligned_le16(crc_addr);

drivers/net/can/usb/etas_es58x/es58x_core.c

1181

sof = get_unaligned_le16(&urb_cmd->sof);

drivers/net/can/usb/etas_es58x/es58x_core.c

1266

sof = get_unaligned_le16(&urb_cmd->sof);

drivers/net/can/usb/etas_es58x/es58x_fd.c

103

u16 rx_can_msg_buf_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es58x_fd.c

172

u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es58x_fd.c

191

u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es58x_fd.c

208

u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es58x_fd.c

217

get_unaligned_le16(&tx_ack_msg->tx_free_entries),

drivers/net/can/usb/etas_es58x/es58x_fd.c

269

u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);

drivers/net/can/usb/etas_es58x/es58x_fd.c

58

return get_unaligned_le16(&urb_cmd->es58x_fd_urb_cmd.msg_len);

drivers/net/can/usb/etas_es58x/es58x_fd.c

68

u16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);

drivers/net/can/usb/peak_usb/pcan_usb.c

429

mc->ts16 = get_unaligned_le16(mc->ptr);

drivers/net/can/usb/peak_usb/pcan_usb.c

449

mc->ts16 = get_unaligned_le16(mc->ptr);

drivers/net/can/usb/peak_usb/pcan_usb.c

673

can_id_flags = get_unaligned_le16(mc->ptr);

drivers/net/dsa/microchip/ksz_spi.c

84

u16 v = get_unaligned_le16(val);

drivers/net/dsa/mxl862xx/mxl862xx-host.c

354

if (!get_unaligned_le16(&data[i]))

drivers/net/dsa/mxl862xx/mxl862xx-host.c

400

val = get_unaligned_le16(&data[i]);

drivers/net/ethernet/cadence/macb_main.c

257

top = get_unaligned_le16(bp->dev->dev_addr + 4);

drivers/net/ethernet/davicom/dm9051.c

527

wid = get_unaligned_le16(buff + 2);

drivers/net/ethernet/dec/tulip/tulip.h

366

#define get_u16(ptr) get_unaligned_le16((ptr))

drivers/net/ethernet/dec/tulip/tulip_core.c

328

u32 addr_high = get_unaligned_le16(dev->dev_addr + 4);

drivers/net/ethernet/dlink/dl2k.c

586

dw16(StationAddr0 + 2 * i, get_unaligned_le16(&dev->dev_addr[2 * i]));

drivers/net/ethernet/freescale/enetc/enetc4_pf.c

53

u16 lower = get_unaligned_le16(addr + 4);

drivers/net/ethernet/freescale/enetc/enetc_pf.c

28

u16 lower = get_unaligned_le16(addr + 4);

drivers/net/ethernet/intel/ice/ice_fw_update.c

805

value = get_unaligned_le16(desc->data);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

1031

buf_field_cnt = get_unaligned_le16(buf);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

1035

buf_off = get_unaligned_le16(buf + id2off[id] + flash * 2);

drivers/net/ethernet/realtek/r8169_main.c

2511

rtl_eri_write(tp, 0xe4, ERIAR_MASK_1111, get_unaligned_le16(addr + 4));

drivers/net/ethernet/realtek/r8169_main.c

2512

rtl_eri_write(tp, 0xf0, ERIAR_MASK_1111, get_unaligned_le16(addr) << 16);

drivers/net/ethernet/realtek/r8169_main.c

2568

RTL_W32(tp, MAC4, get_unaligned_le16(addr + 4));

drivers/net/ethernet/renesas/ravb_main.c

795

skb->csum = csum_unfold((__force __sum16)get_unaligned_le16(hw_csum));

drivers/net/ethernet/renesas/sh_eth.c

1576

skb->csum = csum_unfold((__force __sum16)get_unaligned_le16(hw_csum));

drivers/net/ethernet/smsc/smsc9420.c

765

u16 hw_csum = get_unaligned_le16(skb_tail_pointer(skb) +

drivers/net/ieee802154/ca8210.c

1796

hdr.source.pan_id = cpu_to_le16(get_unaligned_le16(&data_ind[1]));

drivers/net/ieee802154/ca8210.c

1801

hdr.dest.pan_id = cpu_to_le16(get_unaligned_le16(&data_ind[12]));

drivers/net/phy/air_en8811h.c

295

val = get_unaligned_le16(&fw->data[offset + 2]);

drivers/net/phy/air_en8811h.c

300

val = get_unaligned_le16(&fw->data[offset]);

drivers/net/phy/aquantia/aquantia_firmware.c

74

*value = get_unaligned_le16(data + offset);

drivers/net/phy/sfp.c

864

smbus_data.word = get_unaligned_le16(data);

drivers/net/usb/asix_common.c

169

rx->header = get_unaligned_le16(

drivers/net/usb/asix_common.c

177

rx->header |= (get_unaligned_le16(

drivers/net/usb/cdc_eem.c

181

header = get_unaligned_le16(skb->data);

drivers/net/usb/kalmia.c

289

ether_packet_length = get_unaligned_le16(&header_start[2]);

drivers/net/usb/lan78xx.c

3928

rx_cmd_c = get_unaligned_le16(skb->data);

drivers/net/wireless/ath/ath12k/mac.c

3314

ppet->ru_bit_mask = u16_get_bits(get_unaligned_le16(ppe_thres),

drivers/net/wireless/ath/ath5k/pcu.c

383

high_id = get_unaligned_le16(mac + 4);

drivers/net/wireless/ath/ath5k/pcu.c

417

get_unaligned_le16(common->curbssid + 4) |

drivers/net/wireless/ath/ath5k/pcu.c

932

high_id = get_unaligned_le16(common->macaddr + 4);

drivers/net/wireless/ath/ath6kl/cfg80211.c

2748

cnt = get_unaligned_le16(rsn_ie);

drivers/net/wireless/ath/ath6kl/cfg80211.c

2755

cnt = get_unaligned_le16(rsn_ie);

drivers/net/wireless/ath/ath6kl/wmi.c

1163

get_unaligned_le16(((__le16 *)buf) + 5),

drivers/net/wireless/ath/ath6kl/wmi.c

1164

get_unaligned_le16(((__le16 *)buf) + 4),

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3364

mchecksum = get_unaligned_le16(&word[COMP_HDR_LEN + osize]);

drivers/net/wireless/ath/ath9k/hif_usb.c

599

pkt_len = get_unaligned_le16(ptr + index);

drivers/net/wireless/ath/ath9k/hif_usb.c

600

pkt_tag = get_unaligned_le16(ptr + index + 2);

drivers/net/wireless/ath/ath9k/hw.c

3004

REG_WRITE(ah, AR_BSS_ID1, get_unaligned_le16(common->curbssid + 4) |

drivers/net/wireless/ath/carl9170/mac.c

268

carl9170_regwrite(reg + 4, get_unaligned_le16(mac + 4));

drivers/net/wireless/ath/hw.c

125

id1 |= get_unaligned_le16(common->macaddr + 4);

drivers/net/wireless/ath/hw.c

129

REG_WRITE(ah, AR_BSSMSKU, get_unaligned_le16(common->bssidmask + 4));

drivers/net/wireless/ath/key.c

111

macHi = get_unaligned_le16(mac + 4);

drivers/net/wireless/ath/key.c

185

key1 = get_unaligned_le16(k->kv_val + 4);

drivers/net/wireless/ath/key.c

187

key3 = get_unaligned_le16(k->kv_val + 10);

drivers/net/wireless/ath/key.c

239

mic1 = get_unaligned_le16(k->kv_txmic + 2) & 0xffff;

drivers/net/wireless/ath/key.c

240

mic3 = get_unaligned_le16(k->kv_txmic + 0) & 0xffff;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

1381

len = get_unaligned_le16(header);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

1382

checksum = get_unaligned_le16(header + sizeof(u16));

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

1545

sublen = get_unaligned_le16(dptr);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

1691

sublen = get_unaligned_le16(dptr);

drivers/net/wireless/marvell/libertas/cfg.c

555

bsssize = get_unaligned_le16(&scanresp->bssdescriptsize);

drivers/net/wireless/marvell/libertas/cfg.c

600

i = get_unaligned_le16(tsfdesc);

drivers/net/wireless/marvell/libertas/cfg.c

611

i = get_unaligned_le16(tsfdesc);

drivers/net/wireless/marvell/libertas/cfg.c

632

int len = get_unaligned_le16(pos);

drivers/net/wireless/marvell/libertas/cfg.c

643

intvl = get_unaligned_le16(pos);

drivers/net/wireless/marvell/libertas/cfg.c

646

capa = get_unaligned_le16(pos);

drivers/net/wireless/marvell/mwifiex/cmdevt.c

230

get_unaligned_le16((u8 *)host_cmd + S_DS_GEN),

drivers/net/wireless/marvell/mwifiex/cmdevt.c

274

get_unaligned_le16((u8 *)host_cmd + S_DS_GEN);

drivers/net/wireless/marvell/mwifiex/pcie.c

1571

rx_len = get_unaligned_le16(skb_data->data);

drivers/net/wireless/marvell/mwifiex/pcie.c

1824

rx_len = get_unaligned_le16(skb->data);

drivers/net/wireless/marvell/mwifiex/scan.c

1751

beacon_size = get_unaligned_le16((*bss_info));

drivers/net/wireless/marvell/mwifiex/sdio.c

1421

nb = get_unaligned_le16((buffer));

drivers/net/wireless/marvell/mwifiex/sdio.c

1429

*type = get_unaligned_le16((buffer + 2));

drivers/net/wireless/marvell/mwifiex/sdio.c

1617

pkt_len = get_unaligned_le16((data +

drivers/net/wireless/marvell/mwifiex/sdio.c

1654

pkt_len = get_unaligned_le16(skb->data);

drivers/net/wireless/marvell/mwifiex/sdio.c

1872

pkt_len = get_unaligned_le16(&curr_ptr[0]);

drivers/net/wireless/marvell/mwifiex/sdio.c

1873

pkt_type = get_unaligned_le16(&curr_ptr[2]);

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

129

get_unaligned_le16(snmp_mib->value));

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1540

hostcmd->len = get_unaligned_le16(&hostcmd->cmd[2]);

drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c

169

ul_temp = get_unaligned_le16(smib->value);

drivers/net/wireless/marvell/mwifiex/sta_event.c

727

get_unaligned_le16(adapter->event_body);

drivers/net/wireless/marvell/mwifiex/sta_event.c

742

get_unaligned_le16(adapter->event_body);

drivers/net/wireless/marvell/mwifiex/sta_event.c

752

get_unaligned_le16(adapter->event_body);

drivers/net/wireless/marvell/mwifiex/sta_event.c

987

ctrl = get_unaligned_le16(adapter->event_body);

drivers/net/wireless/marvell/mwifiex/tdls.c

1045

get_unaligned_le16((pos + 2));

drivers/net/wireless/marvell/mwifiex/tdls.c

918

cap = get_unaligned_le16(pos);

drivers/net/wireless/marvell/mwifiex/tdls.c

928

cap = get_unaligned_le16(pos);

drivers/net/wireless/marvell/mwifiex/uap_event.c

220

ctrl = get_unaligned_le16(adapter->event_body);

drivers/net/wireless/marvell/mwifiex/util.h

86

put_unaligned_le16(get_unaligned_le16(var) + val, var);

drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c

139

u16 val = get_unaligned_le16(dev->eeprom.data);

drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c

72

if (get_unaligned_le16(efuse + MT_EE_TX_POWER_0_START_2G) == 0)

drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c

75

if (get_unaligned_le16(efuse + MT_EE_TX_POWER_1_START_2G) == 0)

drivers/net/wireless/mediatek/mt76/mt7603/mac.c

134

get_unaligned_le16(_mac + 4));

drivers/net/wireless/mediatek/mt76/mt7603/mac.c

374

(get_unaligned_le16(addr + 4) |

drivers/net/wireless/mediatek/mt76/mt7603/main.c

298

(get_unaligned_le16(info->bssid + 4) |

drivers/net/wireless/mediatek/mt76/mt7603/main.c

56

(get_unaligned_le16(vif->addr + 4) |

drivers/net/wireless/mediatek/mt76/mt7603/main.c

63

(get_unaligned_le16(vif->addr + 4) |

drivers/net/wireless/mediatek/mt76/mt7615/debugfs.c

516

get_unaligned_le16(addr + 4) |

drivers/net/wireless/mediatek/mt76/mt7615/eeprom.c

89

u16 val = get_unaligned_le16(dev->eeprom.data);

drivers/net/wireless/mediatek/mt76/mt76x0/eeprom.c

277

val = get_unaligned_le16(dev->mt76.eeprom.data);

drivers/net/wireless/mediatek/mt76/mt76x0/eeprom.c

279

val = get_unaligned_le16(dev->mt76.eeprom.data +

drivers/net/wireless/mediatek/mt76/mt76x02_eeprom.h

169

return get_unaligned_le16(dev->mt76.eeprom.data + field);

drivers/net/wireless/mediatek/mt76/mt76x02_mac.c

1237

get_unaligned_le16(addr + 4));

drivers/net/wireless/mediatek/mt76/mt76x02_mac.c

743

get_unaligned_le16(dev->mphy.macaddr + 4) |

drivers/net/wireless/mediatek/mt76/mt76x02_mac.c

749

get_unaligned_le16(dev->mphy.macaddr + 4) |

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

110

val = get_unaligned_le16(efuse + MT_EE_BT_RCAL_RESULT);

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

114

val = get_unaligned_le16(efuse + MT_EE_BT_VCDL_CALIBRATION);

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

118

val = get_unaligned_le16(efuse + MT_EE_BT_PMUCFG);

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

125

u16 val = get_unaligned_le16(dev->mt76.eeprom.data);

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

128

val = get_unaligned_le16(dev->mt76.eeprom.data + MT_EE_PCI_ID);

drivers/net/wireless/mediatek/mt76/mt7915/eeprom.c

50

u16 val = get_unaligned_le16(eeprom);

drivers/net/wireless/mediatek/mt76/mt7996/eeprom.c

13

u16 val = get_unaligned_le16(eeprom);

drivers/net/wireless/mediatek/mt76/usb.c

460

dma_len = get_unaligned_le16(data);

drivers/net/wireless/mediatek/mt7601u/dma.c

121

u16 dma_len = get_unaligned_le16(data);

drivers/net/wireless/mediatek/mt7601u/eeprom.c

100

u16 nic_conf1 = get_unaligned_le16(eeprom + MT_EE_NIC_CONF_1);

drivers/net/wireless/mediatek/mt7601u/eeprom.c

108

u16 nic_conf0 = get_unaligned_le16(eeprom + MT_EE_NIC_CONF_0);

drivers/net/wireless/mediatek/mt7601u/eeprom.c

109

u16 nic_conf1 = get_unaligned_le16(eeprom + MT_EE_NIC_CONF_1);

drivers/net/wireless/mediatek/mt7601u/mac.c

23

mt76_wr(dev, MT_MAC_ADDR_DW1, get_unaligned_le16(dev->macaddr + 4) |

drivers/net/wireless/microchip/wilc1000/hif.c

1602

msg->body.net_info.frame_len = get_unaligned_le16(&buffer[6]) - 1;

drivers/net/wireless/microchip/wilc1000/wlan_cfg.c

146

wid = get_unaligned_le16(info);

drivers/net/wireless/microchip/wilc1000/wlan_cfg.c

171

cfg->hw[i].val = get_unaligned_le16(&info[4]);

drivers/net/wireless/microchip/wilc1000/wlan_cfg.c

189

len = 2 + get_unaligned_le16(&info[2]);

drivers/net/wireless/microchip/wilc1000/wlan_cfg.c

216

wid = get_unaligned_le16(info);

drivers/net/wireless/microchip/wilc1000/wlan_cfg.c

320

u16 size = get_unaligned_le16(cfg->s[i].str);

drivers/net/wireless/quantenna/qtnfmac/commands.c

481

rate_dst->legacy = get_unaligned_le16(&rate_src->rate) * 10;

drivers/net/wireless/realtek/rtw89/fw.c

3959

ppe_thres_hdr = get_unaligned_le16(link_sta->eht_cap.eht_ppe_thres);

drivers/net/wireless/realtek/rtw89/fw.c

3976

ppe = get_unaligned_le16(link_sta->eht_cap.eht_ppe_thres + idx);

drivers/net/wireless/rsi/rsi_91x_ps.c

125

u16 cfm_type = get_unaligned_le16(msg + PS_CONFIRM_INDEX);

drivers/net/wireless/silabs/wfx/main.c

196

chunk_type = get_unaligned_le16(buf + 0);

drivers/net/wireless/silabs/wfx/main.c

197

chunk_len = get_unaligned_le16(buf + 2);

drivers/net/wireless/zydas/zd1211rw/zd_usb.c

628

if (get_unaligned_le16(&length_info->tag) == RX_LENGTH_INFO_TAG)

drivers/net/wireless/zydas/zd1211rw/zd_usb.c

632

k = get_unaligned_le16(&length_info->length[i]);

drivers/nfc/nfcmrvl/fw_dnld.c

273

len = get_unaligned_le16(skb->data);

drivers/nfc/nfcmrvl/fw_dnld.c

275

comp_len = get_unaligned_le16(skb->data);

drivers/nvme/host/hwmon.c

98

temp = get_unaligned_le16(log->temperature);

drivers/nvme/host/pr.c

254

keys_info->num_keys = get_unaligned_le16(&rse->regctl);

drivers/nvme/host/pr.c

291

num_regs = get_unaligned_le16(&tmp_rse.regctl);

drivers/nvme/host/pr.c

306

if (num_regs != get_unaligned_le16(&rse->regctl)) {

drivers/nvme/host/trace.c

109

u16 rl = get_unaligned_le16(cdw10 + 12);

drivers/nvme/host/trace.c

13

u16 sqid = get_unaligned_le16(cdw10);

drivers/nvme/host/trace.c

143

u16 length = get_unaligned_le16(cdw10 + 8);

drivers/nvme/host/trace.c

144

u16 control = get_unaligned_le16(cdw10 + 10);

drivers/nvme/host/trace.c

24

u16 sqid = get_unaligned_le16(cdw10);

drivers/nvme/host/trace.c

25

u16 qsize = get_unaligned_le16(cdw10 + 2);

drivers/nvme/host/trace.c

26

u16 sq_flags = get_unaligned_le16(cdw10 + 4);

drivers/nvme/host/trace.c

27

u16 cqid = get_unaligned_le16(cdw10 + 6);

drivers/nvme/host/trace.c

40

u16 cqid = get_unaligned_le16(cdw10);

drivers/nvme/host/trace.c

410

u16 recfmt = get_unaligned_le16(spc);

drivers/nvme/host/trace.c

411

u16 qid = get_unaligned_le16(spc + 2);

drivers/nvme/host/trace.c

412

u16 sqsize = get_unaligned_le16(spc + 4);

drivers/nvme/host/trace.c

51

u16 cqid = get_unaligned_le16(cdw10);

drivers/nvme/host/trace.c

52

u16 qsize = get_unaligned_le16(cdw10 + 2);

drivers/nvme/host/trace.c

53

u16 cq_flags = get_unaligned_le16(cdw10 + 4);

drivers/nvme/host/trace.c

54

u16 irq_vector = get_unaligned_le16(cdw10 + 6);

drivers/nvme/host/trace.c

67

u16 ctrlid = get_unaligned_le16(cdw10 + 2);

drivers/nvme/target/trace.c

14

u16 ctrlid = get_unaligned_le16(cdw10 + 2);

drivers/nvme/target/trace.c

329

u16 recfmt = get_unaligned_le16(spc);

drivers/nvme/target/trace.c

330

u16 qid = get_unaligned_le16(spc + 2);

drivers/nvme/target/trace.c

331

u16 sqsize = get_unaligned_le16(spc + 4);

drivers/nvme/target/trace.c

42

u16 rl = get_unaligned_le16(cdw10 + 12);

drivers/nvme/target/trace.c

70

u16 length = get_unaligned_le16(cdw10 + 8);

drivers/nvme/target/trace.c

71

u16 control = get_unaligned_le16(cdw10 + 10);

drivers/pci/vpd.c

23

return get_unaligned_le16(lrdt + 1);

drivers/pcmcia/cistpl.c

1162

entry->mem.win[0].len = get_unaligned_le16(p) << 8;

drivers/pcmcia/cistpl.c

1171

entry->mem.win[0].len = get_unaligned_le16(p) << 8;

drivers/pcmcia/cistpl.c

1172

entry->mem.win[0].card_addr = get_unaligned_le16(p + 2) << 8;

drivers/pcmcia/cistpl.c

1238

v2->dindex = get_unaligned_le16(p + 2);

drivers/pcmcia/cistpl.c

726

csum->addr = tuple->CISOffset + get_unaligned_le16(p) - 2;

drivers/pcmcia/cistpl.c

727

csum->len = get_unaligned_le16(p + 2);

drivers/pcmcia/cistpl.c

846

m->manf = get_unaligned_le16(tuple->TupleData);

drivers/pcmcia/cistpl.c

847

m->card = get_unaligned_le16(tuple->TupleData + 2);

drivers/peci/request.c

404

return get_unaligned_le16(&req->rx.buf[1]);

drivers/peci/request.c

428

return get_unaligned_le16(&req->rx.buf[0]);

drivers/platform/arm64/acer-aspire1-ec.c

254

val->intval = get_unaligned_le16(&ddat.voltage_now) * MILLI_TO_MICRO;

drivers/platform/arm64/acer-aspire1-ec.c

262

val->intval = get_unaligned_le16(&ddat.capacity_now) * MILLI_TO_MICRO;

drivers/platform/arm64/acer-aspire1-ec.c

270

val->intval = get_unaligned_le16(&ddat.capacity_now) * 100;

drivers/platform/arm64/acer-aspire1-ec.c

275

val->intval = (s16)get_unaligned_le16(&ddat.current_now) * MILLI_TO_MICRO;

drivers/platform/surface/aggregator/controller.c

995

item->rqid = get_unaligned_le16(&cmd->rqid);

drivers/platform/surface/aggregator/ssh_packet_layer.c

459

payload_len = get_unaligned_le16(&frame->ptr[SSH_MSGOFFSET_FRAME(len)]);

drivers/platform/surface/aggregator/ssh_parser.c

151

sp.len = get_unaligned_le16(&((struct ssh_frame *)sf.ptr)->len);

drivers/platform/surface/aggregator/ssh_parser.c

32

u16 expected = get_unaligned_le16(crc);

drivers/platform/surface/aggregator/ssh_parser.c

43

return src->len >= 2 && get_unaligned_le16(src->ptr) == SSH_MSG_SYN;

drivers/platform/surface/aggregator/ssh_parser.c

74

if (likely(get_unaligned_le16(src->ptr + i) == SSH_MSG_SYN)) {

drivers/platform/surface/aggregator/ssh_request_layer.c

473

u16 rqid = get_unaligned_le16(&command->rqid);

drivers/platform/surface/aggregator/ssh_request_layer.c

88

return get_unaligned_le16(rqst->packet.data.ptr

drivers/platform/surface/aggregator/ssh_request_layer.c

904

get_unaligned_le16(&cmd->rqid));

drivers/platform/surface/aggregator/ssh_request_layer.c

934

if (ssh_rqid_is_event(get_unaligned_le16(&command->rqid)))

drivers/platform/surface/aggregator/trace.h

151

return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(rqid)]);

drivers/platform/surface/aggregator/trace.h

167

return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tid)]);

drivers/platform/surface/aggregator/trace.h

183

return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(sid)]);

drivers/platform/surface/aggregator/trace.h

199

return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tc)]);

drivers/platform/surface/aggregator/trace.h

335

__entry->len = get_unaligned_le16(&frame->len);

drivers/platform/surface/aggregator/trace.h

367

__entry->rqid = get_unaligned_le16(&cmd->rqid);

drivers/platform/wmi/marshalling.c

208

length = get_unaligned_le16(&string->length);

drivers/platform/wmi/marshalling.c

222

value = get_unaligned_le16(&string->chars[i]);

drivers/platform/x86/bitland-mifs-wmi.c

369

*val = get_unaligned_le16(&res.data[0]);

drivers/platform/x86/bitland-mifs-wmi.c

372

*val = get_unaligned_le16(&res.data[2]);

drivers/platform/x86/bitland-mifs-wmi.c

375

*val = get_unaligned_le16(&res.data[6]);

drivers/platform/x86/dell/dell-wmi-ddv.c

329

*val = get_unaligned_le16(&entry[channel].rpm);

drivers/platform/x86/quickstart.c

128

data->id = get_unaligned_le16(obj->buffer.pointer);

drivers/power/supply/bq27xxx_battery_i2c.c

66

ret = get_unaligned_le16(data);

drivers/ptp/ptp_clockmatrix.c

2166

n = get_unaligned_le16(nbuf);

drivers/ptp/ptp_fc3.c

926

*device_id = get_unaligned_le16(buf);

drivers/scsi/qla2xxx/qla_isr.c

3060

a_guard = get_unaligned_le16(ap + 2);

drivers/scsi/qla2xxx/qla_isr.c

3061

a_app_tag = get_unaligned_le16(ap + 0);

drivers/scsi/qla2xxx/qla_isr.c

3063

e_guard = get_unaligned_le16(ep + 2);

drivers/scsi/qla2xxx/qla_isr.c

3064

e_app_tag = get_unaligned_le16(ep + 0);

drivers/scsi/smartpqi/smartpqi_init.c

1441

if (get_unaligned_le16(&raid_map->layout_map_count) != 2) {

drivers/scsi/smartpqi/smartpqi_init.c

1446

if (get_unaligned_le16(&raid_map->layout_map_count) != 3) {

drivers/scsi/smartpqi/smartpqi_init.c

1452

get_unaligned_le16(&raid_map->layout_map_count) > 1) {

drivers/scsi/smartpqi/smartpqi_init.c

1455

get_unaligned_le16(&raid_map->strip_size) *

drivers/scsi/smartpqi/smartpqi_init.c

1456

get_unaligned_le16(&raid_map->data_disks_per_row);

drivers/scsi/smartpqi/smartpqi_init.c

1596

if (get_unaligned_le16(&device->raid_map->flags) &

drivers/scsi/smartpqi/smartpqi_init.c

1676

get_unaligned_le16(&id_phys->current_queue_depth_limit);

drivers/scsi/smartpqi/smartpqi_init.c

1698

device->erase_in_progress = !!(get_unaligned_le16(&id_phys->extra_physical_drive_flags) & PQI_DEVICE_ERASE_IN_PROGRESS);

drivers/scsi/smartpqi/smartpqi_init.c

2665

get_unaligned_le16(&raid_map->data_encryption_key_index);

drivers/scsi/smartpqi/smartpqi_init.c

2774

get_unaligned_le16(&raid_map->data_disks_per_row);

drivers/scsi/smartpqi/smartpqi_init.c

2775

rmd->strip_size = get_unaligned_le16(&raid_map->strip_size);

drivers/scsi/smartpqi/smartpqi_init.c

2776

rmd->layout_map_count = get_unaligned_le16(&raid_map->layout_map_count);

drivers/scsi/smartpqi/smartpqi_init.c

2815

get_unaligned_le16(&raid_map->metadata_disks_per_row);

drivers/scsi/smartpqi/smartpqi_init.c

2818

get_unaligned_le16(&raid_map->row_cnt);

drivers/scsi/smartpqi/smartpqi_init.c

2910

get_unaligned_le16(&raid_map->row_cnt);

drivers/scsi/smartpqi/smartpqi_init.c

2913

(get_unaligned_le16(&raid_map->row_cnt) *

drivers/scsi/smartpqi/smartpqi_init.c

2931

index -= get_unaligned_le16(&raid_map->metadata_disks_per_row);

drivers/scsi/smartpqi/smartpqi_init.c

3062

if (get_unaligned_le16(&raid_map->flags) & RAID_MAP_ENCRYPTION_ENABLED) {

drivers/scsi/smartpqi/smartpqi_init.c

3237

sense_data_length = get_unaligned_le16(&error_info->sense_data_length);

drivers/scsi/smartpqi/smartpqi_init.c

3240

get_unaligned_le16(&error_info->response_data_length);

drivers/scsi/smartpqi/smartpqi_init.c

3365

get_unaligned_le16(&error_info->data_length);

drivers/scsi/smartpqi/smartpqi_init.c

3458

request_id = get_unaligned_le16(&response->request_id);

drivers/scsi/smartpqi/smartpqi_init.c

3486

get_unaligned_le16(

drivers/scsi/smartpqi/smartpqi_init.c

3500

(get_unaligned_le16(&response->error_index) *

drivers/scsi/smartpqi/smartpqi_init.c

3891

get_unaligned_le16(&response->data.ofa_cancelled.reason);

drivers/scsi/smartpqi/smartpqi_init.c

3932

event->event_id = get_unaligned_le16(&response->event_id);

drivers/scsi/smartpqi/smartpqi_init.c

4530

iu_length = get_unaligned_le16(&request->iu_length) +

drivers/scsi/smartpqi/smartpqi_init.c

4678

iu_length = get_unaligned_le16(&request->iu_length) +

drivers/scsi/smartpqi/smartpqi_init.c

4714

if (get_unaligned_le16(&response->header.iu_length) !=

drivers/scsi/smartpqi/smartpqi_init.c

4788

get_unaligned_le16(&capability->max_inbound_queues);

drivers/scsi/smartpqi/smartpqi_init.c

4790

get_unaligned_le16(&capability->max_elements_per_iq);

drivers/scsi/smartpqi/smartpqi_init.c

4792

get_unaligned_le16(&capability->max_iq_element_length)

drivers/scsi/smartpqi/smartpqi_init.c

4795

get_unaligned_le16(&capability->max_outbound_queues);

drivers/scsi/smartpqi/smartpqi_init.c

4797

get_unaligned_le16(&capability->max_elements_per_oq);

drivers/scsi/smartpqi/smartpqi_init.c

4799

get_unaligned_le16(&capability->max_oq_element_length)

drivers/scsi/smartpqi/smartpqi_init.c

4806

get_unaligned_le16(

drivers/scsi/smartpqi/smartpqi_init.c

6767

get_unaligned_le16(&pqi_error_info->sense_data_length);

drivers/scsi/smartpqi/smartpqi_init.c

6770

get_unaligned_le16(&pqi_error_info->response_data_length);

drivers/scsi/smartpqi/smartpqi_init.c

7794

get_unaligned_le16(&identify->firmware_build_number));

drivers/scsi/smartpqi/smartpqi_init.c

8240

switch (get_unaligned_le16(&section->section_id)) {

drivers/scsi/smartpqi/smartpqi_init.c

8265

section_offset = get_unaligned_le16(&section->next_section_offset);

drivers/scsi/smartpqi/smartpqi_init.c

857

bytes = get_unaligned_le16(limit);

drivers/scsi/smartpqi/smartpqi_init.c

9092

num_memory_descriptors = get_unaligned_le16(&host_memory->num_memory_descriptors);

drivers/scsi/smartpqi/smartpqi_init.c

9125

buffer_length = offsetof(struct pqi_host_memory, sg_descriptor) + get_unaligned_le16(&host_memory->num_memory_descriptors) * sizeof(struct pqi_sg_descriptor);

drivers/scsi/smartpqi/smartpqi_init.c

913

get_unaligned_le16(&buffer->header.buffer_length) <

drivers/scsi/smartpqi/smartpqi_init.c

919

get_unaligned_le16(&buffer->aio_subpage.header.page_length) <

drivers/spi/spi-uniphier.c

263

val = get_unaligned_le16(priv->tx_buf);

drivers/staging/rtl8723bs/core/rtw_ap.c

795

pbss_network->configuration.beacon_period = get_unaligned_le16(p);

drivers/staging/rtl8723bs/core/rtw_ap.c

798

cap = get_unaligned_le16(ie);

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

481

count = get_unaligned_le16(pos);

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

541

count = get_unaligned_le16(pos);

drivers/staging/rtl8723bs/core/rtw_mlme_ext.c

1633

status = get_unaligned_le16(&frame_body[3]);

drivers/staging/rtl8723bs/core/rtw_mlme_ext.c

957

capab_info = get_unaligned_le16(pframe + WLAN_HDR_A3_LEN);

drivers/tty/n_gsm.c

1579

n1 = FIELD_GET(PN_N_FIELD_N1, get_unaligned_le16(&params->n_bits));

drivers/usb/atm/ueagle-atm.c

1696

get_unaligned_le16(&cmvs_v1[i].offset),

drivers/usb/atm/ueagle-atm.c

634

u16 add = get_unaligned_le16(pfw + 1);

drivers/usb/atm/ueagle-atm.c

754

blocksize = get_unaligned_le16(dsp + pp);

drivers/usb/atm/ueagle-atm.c

940

blockaddr = get_unaligned_le16(p);

drivers/usb/atm/ueagle-atm.c

943

blocksize = get_unaligned_le16(p);

drivers/usb/class/cdc-acm.c

311

newctrl = get_unaligned_le16(data);

drivers/usb/gadget/function/f_eem.c

406

header = get_unaligned_le16(skb->data);

drivers/usb/gadget/function/f_fs.c

3133

t->language = get_unaligned_le16(data);

drivers/usb/gadget/function/f_ncm.c

1209

if (get_unaligned_le16(tmp++) != opts->nth_size) {

drivers/usb/gadget/function/f_ncm.c

1254

ndp_len = get_unaligned_le16(tmp++);

drivers/usb/gadget/function/f_ncm.c

505

tmp = get_unaligned_le16(*p);

drivers/usb/gadget/udc/goku_udc.c

125

max = get_unaligned_le16(&desc->wMaxPacketSize);

drivers/usb/host/xhci-pci-renesas.c

143

if (get_unaligned_le16(fw_data) != 0x55aa) {

drivers/usb/host/xhci-pci-renesas.c

149

fw_version_pointer = get_unaligned_le16(fw_data + 4);

drivers/usb/serial/ch341.c

695

reg_contents = get_unaligned_le16(break_reg);

drivers/usb/serial/kl5kusb105.c

355

len = get_unaligned_le16(data);

drivers/video/fbdev/matrox/matroxfb_misc.c

541

if (get_unaligned_le16(bd->pins + 24)) {

drivers/video/fbdev/matrox/matroxfb_misc.c

542

maxdac = get_unaligned_le16(bd->pins + 24) * 10;

drivers/video/fbdev/matrox/matroxfb_misc.c

545

minfo->values.pll.system = get_unaligned_le16(bd->pins + 28) ?

drivers/video/fbdev/matrox/matroxfb_misc.c

546

get_unaligned_le16(bd->pins + 28) * 10 : 50000;

fs/exfat/nls.c

676

unsigned short uni = get_unaligned_le16(bh->b_data + i);

fs/fat/inode.c

1371

if (get_unaligned_le16(&b->sector_size))

fs/fat/inode.c

1379

if (get_unaligned_le16(&b->dir_entries))

fs/fat/inode.c

1381

if (get_unaligned_le16(&b->sectors))

fs/fat/inode.c

1401

bpb->fat_sector_size = get_unaligned_le16(&b->sector_size);

fs/fat/inode.c

1405

bpb->fat_dir_entries = get_unaligned_le16(&b->dir_entries);

fs/fat/inode.c

1406

bpb->fat_sectors = get_unaligned_le16(&b->sectors);

fs/isofs/isofs.h

85

return get_unaligned_le16(p);

fs/isofs/isofs.h

94

return get_unaligned_le16(p);

fs/ntfs3/lib/decompress_common.h

159

v = get_unaligned_le16(is->next);

fs/ntfs3/lib/decompress_common.h

92

is->bitbuf |= (u32)get_unaligned_le16(is->next)

fs/smb/client/cifs_unicode.c

182

ftmp[0] = get_unaligned_le16(&from[i]);

fs/smb/client/cifs_unicode.c

186

ftmp[1] = get_unaligned_le16(&from[i + 1]);

fs/smb/client/cifs_unicode.c

190

ftmp[2] = get_unaligned_le16(&from[i + 2]);

fs/smb/client/cifs_unicode.c

300

ftmp[0] = get_unaligned_le16(&from[i]);

fs/smb/client/cifs_unicode.c

304

ftmp[1] = get_unaligned_le16(&from[i + 1]);

fs/smb/client/cifs_unicode.c

308

ftmp[2] = get_unaligned_le16(&from[i + 2]);

fs/smb/client/cifssmb.c

344

if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||

fs/smb/client/cifssmb.c

345

get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)

fs/smb/client/cifssmb.c

348

total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);

fs/smb/client/cifssmb.c

355

total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);

fs/smb/client/smb1proto.h

336

return get_unaligned_le16(bc_ptr);

fs/smb/client/smb1transport.c

299

total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);

fs/smb/client/smb1transport.c

300

data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);

fs/smb/client/smb1transport.c

333

src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);

fs/smb/client/smb1transport.c

334

tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);

fs/smb/client/smb1transport.c

340

total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);

fs/smb/client/smb1transport.c

356

total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);

fs/smb/client/smb1transport.c

362

get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);

fs/smb/client/smb1transport.c

366

get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);

fs/smb/common/compress/lz77.c

379

w = get_unaligned_le16(*src);

fs/smb/common/compress/lz77.c

436

token = get_unaligned_le16(sp);

fs/smb/server/unicode.c

116

ftmp[0] = get_unaligned_le16(&from[i]);

fs/smb/server/unicode.c

121

ftmp[j] = get_unaligned_le16(&from[i + j]);

fs/smb/server/unicode.c

179

ftmp[0] = get_unaligned_le16(&from[i]);

fs/smb/server/unicode.c

184

ftmp[j] = get_unaligned_le16(&from[i + j]);

include/linux/ceph/decode.h

33

u16 v = get_unaligned_le16(*p);

include/linux/ieee80211-eht.h

368

ppe_thres_hdr = get_unaligned_le16(data + needed);

include/linux/ieee80211-eht.h

419

return get_unaligned_le16(info->optional);

include/linux/ieee80211-eht.h

692

return get_unaligned_le16(common);

include/linux/ieee80211-eht.h

723

return get_unaligned_le16(common);

include/linux/ieee80211-eht.h

759

return get_unaligned_le16(common);

include/linux/ieee80211-eht.h

809

return get_unaligned_le16(common);

include/linux/ieee80211-mesh.h

357

return get_unaligned_le16(&dst->variable[

include/net/ieee80211_radiotap.h

614

return get_unaligned_le16(&hdr->it_len);

include/net/mac802154.h

383

put_unaligned_be16(get_unaligned_le16(le16_src), be16_dst);

lib/crc/loongarch/crc32.h

50

u16 value = get_unaligned_le16(p);

lib/crc/loongarch/crc32.h

86

u16 value = get_unaligned_le16(p);

lib/crc/mips/crc32.h

134

u16 value = get_unaligned_le16(p);

lib/crc/mips/crc32.h

91

u16 value = get_unaligned_le16(p);

lib/crypto/mldsa.c

339

(get_unaligned_le16(&sig[8]) << 4);

lib/lz4/lz4defs.h

134

return get_unaligned_le16(memPtr);

lib/lzo/lzo1x_decompress_safe.c

163

next = get_unaligned_le16(ip);

lib/lzo/lzo1x_decompress_safe.c

169

next = get_unaligned_le16(ip);

lib/lzo/lzo1x_decompress_safe.c

202

next = get_unaligned_le16(ip);

lib/pldmfw/pldmfw.c

150

data->total_header_size = get_unaligned_le16(&header->size);

lib/pldmfw/pldmfw.c

158

get_unaligned_le16(&header->component_bitmap_len);

lib/pldmfw/pldmfw.c

276

type = get_unaligned_le16(&__desc->type);

lib/pldmfw/pldmfw.c

279

size = get_unaligned_le16(&__desc->size);

lib/pldmfw/pldmfw.c

343

record_len = get_unaligned_le16(&__record->record_len);

lib/pldmfw/pldmfw.c

344

record->package_data_len = get_unaligned_le16(&__record->package_data_len);

lib/pldmfw/pldmfw.c

423

get_unaligned_le16(&component_area->component_image_count);

lib/pldmfw/pldmfw.c

473

component->classification = get_unaligned_le16(&__component->classification);

lib/pldmfw/pldmfw.c

474

component->identifier = get_unaligned_le16(&__component->identifier);

lib/pldmfw/pldmfw.c

476

component->options = get_unaligned_le16(&__component->options);

lib/pldmfw/pldmfw.c

477

component->activation_method = get_unaligned_le16(&__component->activation_method);

lib/pldmfw/pldmfw.c

669

value = get_unaligned_le16(desc->data);

lib/pldmfw/pldmfw_private.h

153

get_unaligned_le16(&(desc)->size)))

lib/pldmfw/pldmfw_private.h

188

((const u8 *)(record) + get_unaligned_le16(&(record)->record_len)))

lib/siphash.c

103

case 2: b |= get_unaligned_le16(end); break;

lib/siphash.c

303

case 2: b |= get_unaligned_le16(end); break;

lib/siphash.c

446

case 2: b |= get_unaligned_le16(end); break;

lib/zstd/common/mem.h

151

return get_unaligned_le16(memPtr);

net/bluetooth/eir.c

375

u16 value = get_unaligned_le16(eir);

net/bluetooth/eir.c

81

uuid16 = get_unaligned_le16(&uuid->uuid[12]);

net/bluetooth/hci_event.c

226

conn->link_policy = get_unaligned_le16(sent + 2);

net/bluetooth/hci_event.c

263

hdev->link_policy = get_unaligned_le16(sent);

net/bluetooth/hci_event.c

594

setting = get_unaligned_le16(sent);

net/bluetooth/hci_event.c

841

conn->auth_payload_timeout = get_unaligned_le16(sent + 2);

net/bluetooth/hci_sock.c

1879

u16 opcode = get_unaligned_le16(skb->data);

net/bluetooth/l2cap_core.c

1107

__unpack_enhanced_control(get_unaligned_le16(skb->data),

net/bluetooth/l2cap_core.c

3105

*val = get_unaligned_le16(opt->val);

net/bluetooth/l2cap_core.c

5824

rcv_fcs = get_unaligned_le16(skb->data + skb->len);

net/bluetooth/l2cap_core.c

5906

chan->sdu_len = get_unaligned_le16(skb->data);

net/bluetooth/l2cap_core.c

6886

sdu_len = get_unaligned_le16(skb->data);

net/bluetooth/l2cap_core.c

7741

len = get_unaligned_le16(rx_skb->data);

net/bluetooth/l2cap_core.c

7841

len = get_unaligned_le16(skb->data) + L2CAP_HDR_SIZE;

net/mac80211/ap.c

178

eml_params.link_bitmap = get_unaligned_le16(ptr);

net/mac80211/eht.c

47

eht_ppe_hdr = get_unaligned_le16(eht_cap_ie_elem->optional + mcs_nss_size);

net/mac80211/key.c

637

get_unaligned_le16(seq);

net/mac80211/mesh_plink.c

1165

plid = get_unaligned_le16(PLINK_GET_LLID(elems->peering));

net/mac80211/mesh_plink.c

1168

llid = get_unaligned_le16(PLINK_GET_PLID(elems->peering));

net/mac80211/mesh_plink.c

1209

sta->mesh->aid = get_unaligned_le16(PLINK_CNF_AID(mgmt));

net/mac80211/mesh_ps.c

597

(!elems->awake_window || !get_unaligned_le16(elems->awake_window)))

net/mac80211/mlme.c

11665

control = get_unaligned_le16(pos);

net/mac80211/mlme.c

11716

status_code = get_unaligned_le16(pos + 1);

net/mac80211/mlme.c

4226

params[ac].txop = get_unaligned_le16(pos + 2);

net/mac80211/mlme.c

5470

encap_len = get_unaligned_le16(mgmt->u.auth.variable);

net/mac80211/mlme.c

5918

capab_info = get_unaligned_le16(ptr);

net/mac80211/mlme.c

5919

assoc_data->link[link_id].status = get_unaligned_le16(ptr + 2);

net/mac80211/mlme.c

6837

return get_unaligned_le16(data);

net/mac80211/mlme.c

6867

ttlm_info->switch_time = get_unaligned_le16(pos);

net/mac80211/mlme.c

7682

link_removal_timeout[link_id] = get_unaligned_le16(pos);

net/mac80211/spectmgmt.c

349

get_unaligned_le16(bwi->info.optional);

net/mac80211/tkip.c

100

p1k[4] += tkipS(p1k[3] ^ get_unaligned_le16(tk + 0 + j)) + i;

net/mac80211/tkip.c

120

ppk[0] += tkipS(ppk[5] ^ get_unaligned_le16(tk + 0));

net/mac80211/tkip.c

121

ppk[1] += tkipS(ppk[0] ^ get_unaligned_le16(tk + 2));

net/mac80211/tkip.c

122

ppk[2] += tkipS(ppk[1] ^ get_unaligned_le16(tk + 4));

net/mac80211/tkip.c

123

ppk[3] += tkipS(ppk[2] ^ get_unaligned_le16(tk + 6));

net/mac80211/tkip.c

124

ppk[4] += tkipS(ppk[3] ^ get_unaligned_le16(tk + 8));

net/mac80211/tkip.c

125

ppk[5] += tkipS(ppk[4] ^ get_unaligned_le16(tk + 10));

net/mac80211/tkip.c

126

ppk[0] += ror16(ppk[5] ^ get_unaligned_le16(tk + 12), 1);

net/mac80211/tkip.c

127

ppk[1] += ror16(ppk[0] ^ get_unaligned_le16(tk + 14), 1);

net/mac80211/tkip.c

134

*rc4key++ = ((ppk[5] ^ get_unaligned_le16(tk)) >> 1) & 0xFF;

net/mac80211/tkip.c

90

p1k[2] = get_unaligned_le16(ta + 0);

net/mac80211/tkip.c

91

p1k[3] = get_unaligned_le16(ta + 2);

net/mac80211/tkip.c

92

p1k[4] = get_unaligned_le16(ta + 4);

net/mac80211/tkip.c

96

p1k[0] += tkipS(p1k[4] ^ get_unaligned_le16(tk + 0 + j));

net/mac80211/tkip.c

97

p1k[1] += tkipS(p1k[0] ^ get_unaligned_le16(tk + 4 + j));

net/mac80211/tkip.c

98

p1k[2] += tkipS(p1k[1] ^ get_unaligned_le16(tk + 8 + j));

net/mac80211/tkip.c

99

p1k[3] += tkipS(p1k[2] ^ get_unaligned_le16(tk + 12 + j));

net/mac80211/tx.c

2166

txflags = get_unaligned_le16(iterator.this_arg);

net/mac80211/tx.c

2227

vht_known = get_unaligned_le16(iterator.this_arg);

net/mac802154/scan.c

343

desc.superframe_spec = get_unaligned_le16(skb->data);

net/wireless/michael-mic.c

50

michael_block(mctx, get_unaligned_le16(&da[4]) |

net/wireless/michael-mic.c

51

(get_unaligned_le16(sa) << 16));

net/wireless/nl80211.c

2188

ppe_thres_hdr = get_unaligned_le16(&eht_cap->eht_ppe_thres[0]);

net/wireless/nl80211.c

358

attr_len = get_unaligned_le16(&data[1]);

net/wireless/nl80211.c

397

attr_len = get_unaligned_le16(&data[pos]);

net/wireless/radiotap.c

103

if (max_length < get_unaligned_le16(&radiotap_header->it_len))

net/wireless/radiotap.c

107

iterator->_max_length = get_unaligned_le16(&radiotap_header->it_len);

net/wireless/radiotap.c

284

vnslen = get_unaligned_le16(iterator->_arg + 4);

net/wireless/scan.c

2595

data.capability = get_unaligned_le16(profile + 2);

net/wireless/scan.c

3057

get_unaligned_le16(mle->sta_prof[i]->variable + 6);

net/wireless/scan.c

3070

data.capability = get_unaligned_le16(profile);

net/wireless/util.c

2004

attr_len = get_unaligned_le16(iedata + 1);

scripts/elf-parse.h

272

return get_unaligned_le16(x);

sound/core/pcm_drm_eld.c

356

e->manufacture_id = get_unaligned_le16(buf + 16);

sound/core/pcm_drm_eld.c

357

e->product_id = get_unaligned_le16(buf + 18);

tools/perf/util/arm-spe-decoder/arm-spe-pkt-decoder.c

63

case 2: packet->payload = get_unaligned_le16(buf); break;

tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c

123

packet->payload = get_unaligned_le16(buf + 2);

tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c

459

packet->payload = get_unaligned_le16(buf + 1);