get_unaligned_be16 - Linux

Symbol: get_unaligned_be16

block/partitions/ldm.c

rec = get_unaligned_be16(data + 0x0C);

block/partitions/ldm.c

num = get_unaligned_be16(data + 0x0E);

block/partitions/ldm.c

recs = get_unaligned_be16(data + 0x0E); /* Number of records */

block/partitions/ldm.c

vm->ver_major = get_unaligned_be16(data + 0x12);

block/partitions/ldm.c

vm->ver_minor = get_unaligned_be16(data + 0x14);

block/partitions/ldm.c

if (get_unaligned_be16(data + 0x10) != 0x01) {

block/partitions/ldm.c

ph->ver_major = get_unaligned_be16(data + 0x000C);

block/partitions/ldm.c

ph->ver_minor = get_unaligned_be16(data + 0x000E);

drivers/ata/libata-scsi.c

*plen = get_unaligned_be16(&cdb[7]);

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[2]) + 4;

drivers/ata/libata-scsi.c

return get_unaligned_be16(&rbuf[0]) + 2;

drivers/ata/libata-scsi.c

len = get_unaligned_be16(&cdb[7]);

drivers/ata/libata-scsi.c

bd_len = get_unaligned_be16(&p[6]);

drivers/ata/libata-scsi.c

pg_len = get_unaligned_be16(&p[2]);

drivers/ata/libata-scsi.c

u16 spsp = get_unaligned_be16(&cdb[2]);

drivers/ata/libata-scsi.c

const u16 sa = get_unaligned_be16(&cdb[8]);

drivers/base/regmap/regmap.c

return get_unaligned_be16(buf);

drivers/base/regmap/regmap.c

u16 v = get_unaligned_be16(buf);

drivers/block/aoe/aoecmd.c

get_unaligned_be16(&h->major),

drivers/block/aoe/aoecmd.c

aoemajor = get_unaligned_be16(&h->major);

drivers/block/aoe/aoenet.c

get_unaligned_be16(&h->major),

drivers/bluetooth/hci_bcsp.c

return get_unaligned_be16(&bcsp->rx_skb->data[bcsp->rx_skb->len - 2]);

drivers/bluetooth/hci_qca.c

(get_unaligned_be16(skb->data + 2) == QCA_SSR_DUMP_HANDLE))

drivers/char/tpm/tpm2-sessions.c

u16 hash_alg = get_unaligned_be16(name);

drivers/firmware/dmi_scan.c

smbios_ver = get_unaligned_be16(buf + 6);

drivers/fsi/fsi-occ.c

u16 checksum_resp = get_unaligned_be16(&resp->data[data_length]);

drivers/fsi/fsi-occ.c

get_unaligned_be16(&resp->data_length);

drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c

mbox_size = get_unaligned_be16(header + 2);

drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-hdcp.c

mbox_size = get_unaligned_be16(header + 2);

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

int id = get_unaligned_be16(&d[0]);

drivers/hid/hid-logitech-hidpp.c

*voltage = get_unaligned_be16(data);

drivers/hid/hid-logitech-hidpp.c

*voltage = get_unaligned_be16(data);

drivers/hid/hid-logitech-hidpp.c

raw_info->x_size = get_unaligned_be16(&params[0]);

drivers/hid/hid-logitech-hidpp.c

raw_info->y_size = get_unaligned_be16(&params[2]);

drivers/hid/hid-logitech-hidpp.c

raw_info->res = get_unaligned_be16(&params[13]) * 2 / 51;

drivers/hid/hid-logitech-hidpp.c

900 : get_unaligned_be16(&response.fap.params[0]);

drivers/hid/hid-logitech-hidpp.c

0xffff : get_unaligned_be16(&response.fap.params[0]);

drivers/hid/wacom_wac.c

int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;

drivers/hid/wacom_wac.c

int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;

drivers/hid/wacom_wac.c

input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));

drivers/hid/wacom_wac.c

input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));

drivers/hid/wacom_wac.c

pid = get_unaligned_be16(&data[6]);

drivers/hwmon/aquacomputer_d5next.c

priv->serial_number[0] = get_unaligned_be16(data + priv->serial_number_start_offset);

drivers/hwmon/aquacomputer_d5next.c

priv->serial_number[1] = get_unaligned_be16(data + priv->serial_number_start_offset +

drivers/hwmon/aquacomputer_d5next.c

priv->firmware_version = get_unaligned_be16(data + priv->firmware_version_offset);

drivers/hwmon/aquacomputer_d5next.c

sensor_value = get_unaligned_be16(data +

drivers/hwmon/aquacomputer_d5next.c

sensor_value = get_unaligned_be16(data +

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + priv->fan_sensor_offsets[i] +

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + priv->fan_sensor_offsets[i] +

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + priv->fan_sensor_offsets[i] +

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + priv->fan_sensor_offsets[i] +

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[i] = get_unaligned_be16(data + priv->flow_sensors_start_offset +

drivers/hwmon/aquacomputer_d5next.c

sensor_value = get_unaligned_be16(data +

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[2] = get_unaligned_be16(data + AQUASTREAMULT_PRESSURE_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[3] = get_unaligned_be16(data + AQUASTREAMULT_FLOW_SENSOR_OFFSET);

drivers/hwmon/aquacomputer_d5next.c

priv->power_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_POWER) * 10000;

drivers/hwmon/aquacomputer_d5next.c

priv->voltage_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_VOLTAGE) * 10;

drivers/hwmon/aquacomputer_d5next.c

priv->current_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_CURRENT);

drivers/hwmon/aquacomputer_d5next.c

priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10;

drivers/hwmon/aquacomputer_d5next.c

priv->voltage_input[3] = get_unaligned_be16(data + D5NEXT_12V_VOLTAGE) * 10;

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + HIGHFLOWNEXT_POWER) * 1000000;

drivers/hwmon/aquacomputer_d5next.c

priv->voltage_input[0] = get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE) * 10;

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE_USB) * 10;

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[1] = get_unaligned_be16(data + HIGHFLOWNEXT_WATER_QUALITY);

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[2] = get_unaligned_be16(data + HIGHFLOWNEXT_CONDUCTIVITY);

drivers/hwmon/aquacomputer_d5next.c

((s16)get_unaligned_be16(data + LEAKSHIELD_PRESSURE_ADJUSTED)) * 100;

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input_min[0] = get_unaligned_be16(data + LEAKSHIELD_PRESSURE_MIN) * 100;

drivers/hwmon/aquacomputer_d5next.c

get_unaligned_be16(data + LEAKSHIELD_PRESSURE_TARGET) * 100;

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input_max[0] = get_unaligned_be16(data + LEAKSHIELD_PRESSURE_MAX) * 100;

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[1] = get_unaligned_be16(data + LEAKSHIELD_PUMP_RPM_IN);

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[2] = get_unaligned_be16(data + LEAKSHIELD_FLOW_IN);

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[3] = get_unaligned_be16(data + LEAKSHIELD_RESERVOIR_VOLUME);

drivers/hwmon/aquacomputer_d5next.c

priv->speed_input[4] = get_unaligned_be16(data + LEAKSHIELD_RESERVOIR_FILLED);

drivers/hwmon/aquacomputer_d5next.c

priv->temp_input[1] = get_unaligned_be16(data + LEAKSHIELD_TEMPERATURE_2) * 10;

drivers/hwmon/aquacomputer_d5next.c

*val = (s16)get_unaligned_be16(priv->buffer + offset);

drivers/hwmon/asus-ec-sensors.c

return (s16)get_unaligned_be16(data);

drivers/hwmon/asus-ec-sensors.c

return get_unaligned_be16(data);

drivers/hwmon/nzxt-kraken2.c

priv->fan_input[0] = get_unaligned_be16(data + 3);

drivers/hwmon/nzxt-kraken2.c

priv->fan_input[1] = get_unaligned_be16(data + 5);

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&temp->sensor_id);

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&temp->value) * 1000;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&freq->sensor_id);

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&freq->value);

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&freq->value);

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->sensor_id);

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->value) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->value) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->system.value) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->proc.value) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->cap) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->system_power) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->max) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->min) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->user) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->cap) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->system_power) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->max) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->user) * 1000000ULL;

drivers/hwmon/occ/common.c

val = get_unaligned_be16(&caps->soft_min) * 1000000ULL;

drivers/hwmon/occ/p8_i2c.c

data_length = get_unaligned_be16(&or->data_length);

drivers/iio/accel/adxl355_core.c

*val = get_unaligned_be16(data->transf_buf);

drivers/iio/accel/adxl380.c

part_id = get_unaligned_be16(st->transf_buf);

drivers/iio/accel/adxl380.c

return get_unaligned_be16(st->transf_buf);

drivers/iio/accel/sca3300.c

*val = sign_extend32(get_unaligned_be16(&sca_data->rxbuf[1]), 15);

drivers/iio/adc/ad4030.c

gain = get_unaligned_be16(st->rx_data.raw);

drivers/iio/adc/ad4030.c

*val = sign_extend32(get_unaligned_be16(st->rx_data.raw), 15);

drivers/iio/adc/ad4130.c

*val = get_unaligned_be16(st->reg_read_rx_buf);

drivers/iio/adc/ad4170-4.c

*val = get_unaligned_be16(st->rx_buf);

drivers/iio/adc/ad_sigma_delta.c

*val = get_unaligned_be16(sigma_delta->rx_buf);

drivers/iio/adc/ade9000.c

*val = get_unaligned_be16(rx_buf);

drivers/iio/adc/axp20x_adc.c

*val = FIELD_GET(AXP717_ADC_DATA_MASK, get_unaligned_be16(bulk_reg));

drivers/iio/adc/max11100.c

*val = get_unaligned_be16(&state->buffer[1]);

drivers/iio/adc/max1363.c

data = get_unaligned_be16(rxbuf) &

drivers/iio/adc/mcp3422.c

temp = get_unaligned_be16(&buf[0]);

drivers/iio/adc/mt6360-adc.c

*val = get_unaligned_be16(&rpt[1]);

drivers/iio/adc/pac1921.c

*val = FIELD_GET(PAC1921_RES_MASK, get_unaligned_be16(val));

drivers/iio/adc/pac1934.c

tmp_value = get_unaligned_be16(offset_reg_data_p);

drivers/iio/adc/pac1934.c

tmp_value = get_unaligned_be16(offset_reg_data_p);

drivers/iio/adc/pac1934.c

tmp_value = get_unaligned_be16(offset_reg_data_p);

drivers/iio/adc/pac1934.c

tmp_value = get_unaligned_be16(offset_reg_data_p);

drivers/iio/adc/ti-adc161s626.c

*val = get_unaligned_be16(data->buf);

drivers/iio/adc/ti-ads131m02.c

status = get_unaligned_be16(&priv->rx_buffer[0]);

drivers/iio/adc/ti-ads131m02.c

response = get_unaligned_be16(&priv->rx_buffer[0]);

drivers/iio/adc/ti-ads131m02.c

*val = get_unaligned_be16(&priv->rx_buffer[0]);

drivers/iio/adc/ti-ads131m02.c

received_crc = get_unaligned_be16(&priv->rx_buffer[data_len]);

drivers/iio/adc/ti-ads131m02.c

status = get_unaligned_be16(&priv->rx_buffer[0]);

drivers/iio/adc/ti-ads131m02.c

response = get_unaligned_be16(&priv->rx_buffer[0]);

drivers/iio/adc/ti-tsc2046.c

return FIELD_GET(TI_TSC2046_DATA_12BIT, get_unaligned_be16(&buf->data));

drivers/iio/addac/ad74115.c

*val = get_unaligned_be16(&st->reg_rx_buf[1]);

drivers/iio/addac/ad74413r.c

*val = get_unaligned_be16(&st->reg_rx_buf[1]);

drivers/iio/chemical/bme680_core.c

adc_humid = get_unaligned_be16(&data->buf[8]);

drivers/iio/chemical/bme680_core.c

gas_regs_val = get_unaligned_be16(&data->buf[13]);

drivers/iio/chemical/mhz19b.c

return get_unaligned_be16(&st->buf[2]);

drivers/iio/chemical/pms7003.c

return clamp_val(get_unaligned_be16(data),

drivers/iio/chemical/pms7003.c

u16 checksum = get_unaligned_be16(frame->data + offset);

drivers/iio/chemical/pms7003.c

magic = get_unaligned_be16(buf);

drivers/iio/chemical/pms7003.c

num = get_unaligned_be16(buf + 2);

drivers/iio/dac/ad3552r.c

*val = get_unaligned_be16(buf);

drivers/iio/dac/ad5593r.c

*value = get_unaligned_be16(buf);

drivers/iio/dac/ad7293.c

*val = get_unaligned_be16(&st->data[1]);

drivers/iio/humidity/hdc3020.c

return get_unaligned_be16(buf);

drivers/iio/humidity/hdc3020.c

*val = get_unaligned_be16(buf);

drivers/iio/humidity/hdc3020.c

*val = get_unaligned_be16(&buf[3]);

drivers/iio/imu/adis.c

*val = get_unaligned_be16(adis->rx + 2);

drivers/iio/magnetometer/mmc5633.c

*val = get_unaligned_be16(buf + 2 * index) << 4;

drivers/iio/magnetometer/yamaha-yas530.c

val = get_unaligned_be16(&data[0]);

drivers/iio/magnetometer/yamaha-yas530.c

val = get_unaligned_be16(&data[0]);

drivers/iio/magnetometer/yamaha-yas530.c

val = get_unaligned_be16(&data[0]);

drivers/iio/magnetometer/yamaha-yas530.c

val = get_unaligned_be16(&data[0]);

drivers/iio/magnetometer/yamaha-yas530.c

*t = get_unaligned_be16(&data[0]);

drivers/iio/magnetometer/yamaha-yas530.c

xy1y2[0] = FIELD_GET(GENMASK(13, 0), get_unaligned_be16(&data[2]));

drivers/iio/magnetometer/yamaha-yas530.c

xy1y2[1] = get_unaligned_be16(&data[4]);

drivers/iio/magnetometer/yamaha-yas530.c

xy1y2[2] = get_unaligned_be16(&data[6]);

drivers/iio/pressure/adp810.c

*val = get_unaligned_be16(&buf.dp);

drivers/iio/pressure/adp810.c

*val = get_unaligned_be16(&buf.tmp);

drivers/iio/pressure/adp810.c

*val = get_unaligned_be16(&buf.sf);

drivers/iio/pressure/bmp280-core.c

adc_humidity = get_unaligned_be16(&data->buf[6]);

drivers/iio/pressure/bmp280-core.c

tmp_1 = get_unaligned_be16(&data->bme280_humid_cal_buf[H4]);

drivers/iio/pressure/sdp500.c

*val = get_unaligned_be16(rxbuf);

drivers/iio/proximity/vl53l0x-i2c.c

*val = get_unaligned_be16(&buffer[10]);

drivers/iio/proximity/vl53l0x-i2c.c

scan.chan = get_unaligned_be16(&buffer[10]);

drivers/iio/temperature/max31856.c

*val = get_unaligned_be16(&reg_val[1]) >> 2;

drivers/iio/temperature/max31865.c

*val = get_unaligned_be16(&data->buf) >> 1;

drivers/input/joystick/adc-joystick.c

val = get_unaligned_be16(data_u16);

drivers/input/joystick/spaceball.c

(__s16)get_unaligned_be16(&data[i * 2]));

drivers/input/mouse/cyapa_gen5.c

get_unaligned_be16(&app_integrity->row_number) != 0x01ff) {

drivers/input/mouse/cyapa_gen5.c

flash_row_id = get_unaligned_be16(&flash_record->row_number);

drivers/input/mouse/cyapa_gen5.c

record_len = get_unaligned_be16(&flash_record->record_len);

drivers/input/mouse/cyapa_gen5.c

value = get_unaligned_be16(buf);

drivers/input/mouse/elan_i2c_core.c

pos_x = get_unaligned_be16(&finger_data[0]);

drivers/input/mouse/elan_i2c_core.c

pos_y = get_unaligned_be16(&finger_data[2]);

drivers/input/touchscreen/ads7846.c

status = get_unaligned_be16(&req->sample[1]);

drivers/input/touchscreen/cy8ctma140.c

x = get_unaligned_be16(buf);

drivers/input/touchscreen/cy8ctma140.c

y = get_unaligned_be16(buf + 2);

drivers/input/touchscreen/edt-ft5x06.c

x = get_unaligned_be16(buf) & 0x0fff;

drivers/input/touchscreen/edt-ft5x06.c

y = get_unaligned_be16(buf + 2) & 0x0fff;

drivers/input/touchscreen/eeti_ts.c

x = get_unaligned_be16(&buf[1]);

drivers/input/touchscreen/eeti_ts.c

y = get_unaligned_be16(&buf[3]);

drivers/input/touchscreen/elants_i2c.c

rek_count = get_unaligned_be16(&resp[2]);

drivers/input/touchscreen/elants_i2c.c

phy_x = get_unaligned_be16(&resp[2]);

drivers/input/touchscreen/elants_i2c.c

phy_y = get_unaligned_be16(&resp[2]);

drivers/input/touchscreen/elants_i2c.c

ts_remark_id = get_unaligned_be16(&resp[3]);

drivers/input/touchscreen/goodix.c

check_sum += get_unaligned_be16(&cfg[i]);

drivers/input/touchscreen/goodix.c

if (check_sum != get_unaligned_be16(&cfg[raw_cfg_len])) {

drivers/input/touchscreen/goodix.c

check_sum += get_unaligned_be16(&ts->config[i]);

drivers/input/touchscreen/hycon-hy46xx.c

x = get_unaligned_be16(buf) & 0x0fff;

drivers/input/touchscreen/hycon-hy46xx.c

y = get_unaligned_be16(buf + 2) & 0x0fff;

drivers/input/touchscreen/hynitron-cst816x.c

tch->abs_x = get_unaligned_be16(&tch->abs_x) & GENMASK(11, 0);

drivers/input/touchscreen/hynitron-cst816x.c

tch->abs_y = get_unaligned_be16(&tch->abs_y) & GENMASK(11, 0);

drivers/input/touchscreen/ili210x.c

*x = get_unaligned_be16(touchdata + 1 + (finger * 4) + 0);

drivers/input/touchscreen/ili210x.c

*y = get_unaligned_be16(touchdata + 1 + (finger * 4) + 2);

drivers/input/touchscreen/ili210x.c

val = get_unaligned_be16(touchdata + 3 + (finger * 5) + 0);

drivers/input/touchscreen/ili210x.c

*y = get_unaligned_be16(touchdata + 3 + (finger * 5) + 2);

drivers/input/touchscreen/ili210x.c

val = get_unaligned_be16(touchdata + 1 + (finger * 5) + 0);

drivers/input/touchscreen/ili210x.c

*y = get_unaligned_be16(touchdata + 1 + (finger * 5) + 2);

drivers/input/touchscreen/ilitek_ts_i2c.c

ts->ptl.ver = get_unaligned_be16(outbuf);

drivers/input/touchscreen/iqs5xx.c

get_unaligned_be16(mbuf) != IQS5XX_BL_ID) {

drivers/input/touchscreen/iqs5xx.c

get_unaligned_be16(mbuf));

drivers/input/touchscreen/iqs5xx.c

rec_addr = get_unaligned_be16(rec_hdr + sizeof(rec_len));

drivers/input/touchscreen/novatek-nvt-ts.c

width = get_unaligned_be16(&data->buf[NVT_TS_PARAMS_WIDTH]);

drivers/input/touchscreen/novatek-nvt-ts.c

height = get_unaligned_be16(&data->buf[NVT_TS_PARAMS_HEIGHT]);

drivers/input/touchscreen/s6sy761.c

sdata->devid = get_unaligned_be16(buffer + 1);

drivers/input/touchscreen/s6sy761.c

*max_x = get_unaligned_be16(buffer);

drivers/input/touchscreen/s6sy761.c

*max_y = get_unaligned_be16(buffer + 2);

drivers/input/touchscreen/zet6223.c

finger_bits = get_unaligned_be16(buf + 1);

drivers/macintosh/adb-iop.c

autopoll_devs = get_unaligned_be16(amsg->data);

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

first_list = get_unaligned_be16(first_list_addr);

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

list_count = get_unaligned_be16(list_count_addr);

drivers/md/dm-vdo/indexer/hash-utils.h

u64 bytes = (u64) get_unaligned_be16(chapter_bits) << 32;

drivers/md/dm-vdo/indexer/hash-utils.h

return get_unaligned_be16(&name->name[SAMPLE_BYTES_OFFSET]);

drivers/media/i2c/ccs/ccs-reg-access.c

*val = get_unaligned_be16(data);

drivers/media/i2c/ir-kbd-i2c.c

vendor = get_unaligned_be16(buf + 1);

drivers/media/i2c/ir-kbd-i2c.c

if (get_unaligned_be16(&array[i]) == val) {

drivers/media/i2c/ir-kbd-i2c.c

u16 d = get_unaligned_be16(&code_block->space[i]);

drivers/media/i2c/ir-kbd-i2c.c

if (get_unaligned_be16(&code_block->space[s]) > d)

drivers/media/pci/bt8xx/bttv-cards.c

type = get_unaligned_be16((__be16 *)(ee+4));

drivers/media/platform/renesas/rcar_jpu.c

*word = get_unaligned_be16(buf->curr);

drivers/media/radio/radio-raremono.c

(get_unaligned_be16(&radio->buffer[1]) & 0xfff) == 0x0242) {

drivers/media/radio/si470x/radio-si470x-usb.c

radio->registers[regnr] = get_unaligned_be16(&radio->usb_buf[1]);

drivers/media/radio/si470x/radio-si470x-usb.c

radio->registers[regnr] = get_unaligned_be16(

drivers/media/radio/si470x/radio-si470x-usb.c

get_unaligned_be16(&radio->int_in_buffer[1]);

drivers/media/radio/si470x/radio-si470x-usb.c

get_unaligned_be16(&radio->int_in_buffer[

drivers/media/radio/si470x/radio-si470x-usb.c

(get_unaligned_be16(&radio->usb_buf[1]) & 0xfff) != 0x0242) {

drivers/media/rc/ir_toy.c

u16 emitted = get_unaligned_be16(irtoy->in + 1);

drivers/media/rc/redrat3.c

val = get_unaligned_be16(&rr3->irdata.lens[offset]);

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

*val = get_unaligned_be16(buf);

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

word = get_unaligned_be16(stream->curr);

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

len = get_unaligned_be16(stream->curr);

drivers/mfd/si476x-cmd.c

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

report->readantcap = get_unaligned_be16(resp + 13);

drivers/mfd/si476x-cmd.c

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

report->readantcap = get_unaligned_be16(resp + 13);

drivers/mfd/si476x-cmd.c

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

report->readantcap = get_unaligned_be16(resp + 13);

drivers/mfd/si476x-cmd.c

report->rdspi = get_unaligned_be16(resp + 21);

drivers/mfd/si476x-cmd.c

return get_unaligned_be16(resp + 2);

drivers/mfd/si476x-cmd.c

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

report->pi = get_unaligned_be16(resp + 4);

drivers/mfd/si476x-cmd.c

report->expected = get_unaligned_be16(resp + 2);

drivers/mfd/si476x-cmd.c

report->received = get_unaligned_be16(resp + 4);

drivers/mfd/si476x-cmd.c

report->uncorrectable = get_unaligned_be16(resp + 6);

drivers/misc/altera-stapl/altera.c

local_expected = (u16)get_unaligned_be16(&p[crc_section]);

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

crc_received = get_unaligned_be16(buf_rx->data + data_len);

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

get_unaligned_be16(buf_rx->data + val_len));

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

get_unaligned_be16(buf_rx->data + val_len));

drivers/net/can/usb/f81604.c

cf->can_id = get_unaligned_be16(&frame->sff.id) >>

drivers/net/can/usb/mcba_usb.c

sid = get_unaligned_be16(&msg->sid);

drivers/net/can/usb/mcba_usb.c

cf->can_id |= get_unaligned_be16(&msg->eid);

drivers/net/can/usb/mcba_usb.c

const u32 bitrate = get_unaligned_be16(&msg->can_bitrate);

drivers/net/ethernet/adi/adin1110.c

val = port_rules | get_unaligned_be16(&addr[0]);

drivers/net/ethernet/adi/adin1110.c

val = get_unaligned_be16(&mask[0]);

drivers/net/ethernet/airoha/airoha_ppe.c

br->dest_mac_lo = get_unaligned_be16(eh->h_dest + 4);

drivers/net/ethernet/airoha/airoha_ppe.c

br->src_mac_hi = get_unaligned_be16(eh->h_source);

drivers/net/ethernet/airoha/airoha_ppe.c

l2->dest_mac_lo = get_unaligned_be16(data->eth.h_dest + 4);

drivers/net/ethernet/airoha/airoha_ppe.c

get_unaligned_be16(data->eth.h_source + 4);

drivers/net/ethernet/broadcom/asp2/bcmasp_intf.c

umac_wl(intf, get_unaligned_be16(&intf->sopass[0]),

drivers/net/ethernet/broadcom/bcmsysport.c

umac_writel(priv, get_unaligned_be16(&priv->sopass[0]),

drivers/net/ethernet/broadcom/genet/bcmgenet.c

bcmgenet_umac_writel(priv, get_unaligned_be16(&addr[4]), UMAC_MAC1);

drivers/net/ethernet/broadcom/genet/bcmgenet_wol.c

bcmgenet_umac_writel(priv, get_unaligned_be16(&priv->sopass[0]),

drivers/net/ethernet/mediatek/mtk_ppe.c

l2->dest_mac_lo = get_unaligned_be16(dest_mac + 4);

drivers/net/ethernet/mediatek/mtk_ppe.c

l2->src_mac_lo = get_unaligned_be16(src_mac + 4);

drivers/net/ethernet/mediatek/mtk_ppe.c

if (get_unaligned_be16(tag) != ETH_P_8021Q)

drivers/net/ethernet/mediatek/mtk_ppe.c

key.vlan = get_unaligned_be16(tag + 2) & VLAN_VID_MASK;

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

get_unaligned_be16(addr + 4));

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

nn_writew(nn, NFP_NET_CFG_MACADDR + 6, get_unaligned_be16(addr + 4));

drivers/net/ethernet/netronome/nfp/nfp_net_sriov.c

writew(get_unaligned_be16(mac + 4),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

hi = get_unaligned_be16(data + offset + OFF_PTP_SOURCE_UUID + 0);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

id = get_unaligned_be16(data + offset + OFF_PTP_SEQUENCE_ID);

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 1));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 2));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 1));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 2));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 1));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 2));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 1));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

tmp = cpu_to_le16(get_unaligned_be16(p + 2));

drivers/net/ethernet/wiznet/w5100.c

rx_len = get_unaligned_be16(header) - 2;

drivers/net/phy/aquantia/aquantia_firmware.c

*value = get_unaligned_be16(data + offset);

drivers/net/phy/mscc/mscc_ptp.c

get_unaligned_be16(&ptp_multicast[4]);

drivers/net/ppp/ppp_async.c

proto = get_unaligned_be16(data);

drivers/net/ppp/ppp_async.c

dlen = get_unaligned_be16(data + 2);

drivers/net/ppp/ppp_async.c

val = get_unaligned_be16(data + 2);

drivers/net/ppp/ppp_deflate.c

seq = get_unaligned_be16(ibuf + PPP_HDRLEN);

drivers/net/ppp/ppp_generic.c

#define PPP_PROTO(skb) get_unaligned_be16((skb)->data)

drivers/net/ppp/ppp_generic.c

return get_unaligned_be16(skb->data) != PPP_LCP ||

drivers/net/ppp/ppp_synctty.c

proto = get_unaligned_be16(data);

drivers/net/usb/sierra_net.c

p->word = get_unaligned_be16(datap);

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

return get_unaligned_be16(eep->macAddr);

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

return get_unaligned_be16(eep->macAddr + 2);

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

return get_unaligned_be16(eep->macAddr + 4);

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

return get_unaligned_be16(pBase->macAddr);

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

return get_unaligned_be16(pBase->macAddr + 2);

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

return get_unaligned_be16(pBase->macAddr + 4);

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

return get_unaligned_be16(pBase->macAddr);

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

return get_unaligned_be16(pBase->macAddr + 2);

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

return get_unaligned_be16(pBase->macAddr + 4);

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

return get_unaligned_be16(pBase->macAddr);

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

return get_unaligned_be16(pBase->macAddr + 2);

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

return get_unaligned_be16(pBase->macAddr + 4);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.h

subtype = get_unaligned_be16(&event_packet->hdr.subtype);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.h

usr_stype = get_unaligned_be16(&event_packet->hdr.usr_subtype);

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

put_unaligned_le16(get_unaligned_be16(&data[i]),

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

if (get_unaligned_be16(skb->data + pad_start) == ETH_P_8021Q)

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

ethertype = get_unaligned_be16(&skb->data[12]);

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

if (get_unaligned_be16(skb->data + pad_start) == ETH_P_8021Q)

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

if (get_unaligned_be16(skb->data + pad_start) == ETH_P_8021Q)

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

ethertype = get_unaligned_be16(&skb->data[12]);

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

if (get_unaligned_be16(skb->data + pad_start) == ETH_P_8021Q)

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

ethertype = get_unaligned_be16(&skb->data[12]);

drivers/nfc/nxp-nci/firmware.c

fw_info->frame_size = get_unaligned_be16(fw_info->data) &

drivers/nfc/nxp-nci/firmware.c

frame_crc = get_unaligned_be16(skb->data + len);

drivers/nfc/pn544/i2c.c

phy->fw_blob_size = get_unaligned_be16(&framep->be_datalen)

drivers/platform/x86/msi-wmi-platform.c

value = get_unaligned_be16(&output[channel * 2 + 1]);

drivers/power/supply/axp288_fuel_gauge.c

ret = get_unaligned_be16(buf);

drivers/power/supply/rk817_charger.c

vcalib0 = get_unaligned_be16(bulk_reg);

drivers/power/supply/rk817_charger.c

vcalib1 = get_unaligned_be16(bulk_reg);

drivers/power/supply/rk817_charger.c

tmp = get_unaligned_be16(bulk_reg);

drivers/power/supply/rk817_charger.c

tmp = (short int)get_unaligned_be16(bulk_reg);

drivers/power/supply/rk817_charger.c

reg = get_unaligned_be16(bulk_reg);

drivers/power/supply/rk817_charger.c

tmp = get_unaligned_be16(bulk_reg);

drivers/power/supply/rk817_charger.c

tmp = get_unaligned_be16(bulk_reg);

drivers/rtc/rtc-max31335.c

temp = get_unaligned_be16(reg);

drivers/scsi/device_handler/scsi_dh_alua.c

u16 group_id = get_unaligned_be16(&desc[2]);

drivers/scsi/hpsa.c

block_cnt = get_unaligned_be16(&cdb[7]);

drivers/scsi/libiscsi.c

senselen = get_unaligned_be16(data);

drivers/scsi/mpi3mr/mpi3mr_os.c

trunc_param_len = param_len = get_unaligned_be16(scmd->cmnd + 7);

drivers/scsi/mpi3mr/mpi3mr_os.c

desc_len = get_unaligned_be16(&buf[2]);

drivers/scsi/myrb.c

block_cnt = get_unaligned_be16(&scmd->cmnd[7]);

drivers/scsi/qla2xxx/qla_target.c

cmd->a_guard = get_unaligned_be16(ap + 0);

drivers/scsi/qla2xxx/qla_target.c

cmd->a_app_tag = get_unaligned_be16(ap + 2);

drivers/scsi/qla2xxx/qla_target.c

cmd->e_guard = get_unaligned_be16(ep + 0);

drivers/scsi/qla2xxx/qla_target.c

cmd->e_app_tag = get_unaligned_be16(ep + 2);

drivers/scsi/scsi.c

result = get_unaligned_be16(&buffer[2]);

drivers/scsi/scsi_debug.c

alloc_len = get_unaligned_be16(cmd + 3);

drivers/scsi/scsi_debug.c

len = min_t(u32, get_unaligned_be16(arr + 2) + 4, alloc_len);

drivers/scsi/scsi_debug.c

req_sa = get_unaligned_be16(cmd + 4);

drivers/scsi/scsi_debug.c

p0_size = get_unaligned_be16(new + 8);

drivers/scsi/scsi_debug.c

p1_size = get_unaligned_be16(new + 10);

drivers/scsi/scsi_debug.c

alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

param_len = mselect6 ? cmd[4] : get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

md_len = mselect6 ? (arr[0] + 1) : (get_unaligned_be16(arr + 0) + 2);

drivers/scsi/scsi_debug.c

bd_len = mselect6 ? arr[3] : get_unaligned_be16(arr + 6);

drivers/scsi/scsi_debug.c

blksize = get_unaligned_be16(arr + off + 6);

drivers/scsi/scsi_debug.c

pg_len = spf ? (get_unaligned_be16(arr + off + 2) + 4) :

drivers/scsi/scsi_debug.c

alloc_len = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

len = min_t(u32, get_unaligned_be16(arr + 2) + 4, alloc_len);

drivers/scsi/scsi_debug.c

all_length = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

num = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

num = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

num = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

num = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

lbdof = get_unaligned_be16(cmd + 12);

drivers/scsi/scsi_debug.c

num_lrd = get_unaligned_be16(cmd + 16);

drivers/scsi/scsi_debug.c

lbdof = get_unaligned_be16(cmd + 4);

drivers/scsi/scsi_debug.c

num_lrd = get_unaligned_be16(cmd + 8);

drivers/scsi/scsi_debug.c

num = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

payload_len = get_unaligned_be16(scp->cmnd + 7);

drivers/scsi/scsi_debug.c

BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);

drivers/scsi/scsi_debug.c

BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);

drivers/scsi/scsi_debug.c

starting_stream_id = get_unaligned_be16(cmd + 4);

drivers/scsi/scsi_debug.c

num_blocks = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

nblks = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

vnum = get_unaligned_be16(cmd + 7);

drivers/scsi/scsi_debug.c

boundary = get_unaligned_be16(cmd + 10);

drivers/scsi/scsi_debug.c

len = get_unaligned_be16(cmd + 12);

drivers/scsi/scsi_debug.c

sa = get_unaligned_be16(cmd + 8);

drivers/scsi/scsi_lib.c

data->length = get_unaligned_be16(&buffer[0]) + 2;

drivers/scsi/scsi_lib.c

data->block_descriptor_length = get_unaligned_be16(&buffer[6]);

drivers/scsi/scsi_lib.c

rel_port = get_unaligned_be16(&d[6]);

drivers/scsi/scsi_lib.c

group_id = get_unaligned_be16(&d[6]);

drivers/scsi/scsi_proto_test.c

KUNIT_EXPECT_EQ(test, get_unaligned_be16(&ss.s.stream_identifier),

drivers/scsi/scsi_proto_test.c

KUNIT_EXPECT_EQ(test, get_unaligned_be16(&sh.h.number_of_open_streams),

drivers/scsi/scsi_trace.c

#define SERVICE_ACTION32(cdb) (get_unaligned_be16(&cdb[8]))

drivers/scsi/scsi_trace.c

unsigned int regions = get_unaligned_be16(&cdb[7]);

drivers/scsi/scsi_trace.c

boundary_size = get_unaligned_be16(&cdb[10]);

drivers/scsi/scsi_trace.c

nr_blocks = get_unaligned_be16(&cdb[12]);

drivers/scsi/scsi_trace.c

txlen = get_unaligned_be16(&cdb[7]);

drivers/scsi/sd.c

sdkp->min_xfer_blocks = get_unaligned_be16(&vpd->data[6]);

drivers/scsi/sd.c

rot = get_unaligned_be16(&vpd->data[4]);

drivers/scsi/sd.c

vpd_len = get_unaligned_be16(&buffer[2]) + 4;

drivers/scsi/smartpqi/smartpqi_init.c

rmd->block_cnt = (u32)get_unaligned_be16(&scmd->cmnd[7]);

drivers/scsi/sr.c

cd->cdi.speed = get_unaligned_be16(&buffer[n + 8]) / 176;

drivers/scsi/sr.c

get_unaligned_be16(&buffer[n + 14]) / 176,

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

u16 attr_id = get_unaligned_be16(attr_ptr);

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

u16 attr_data_len = get_unaligned_be16(attr_ptr + 2);

drivers/staging/rtl8723bs/core/rtw_recv.c

eth_type = get_unaligned_be16(&sub_skb->data[6]);

drivers/staging/rtl8723bs/core/rtw_recv.c

nSubframe_Length = get_unaligned_be16(pdata + 12);

drivers/target/target_core_alua.c

tg_pt_id = get_unaligned_be16(ptr + 2);

drivers/target/target_core_alua.c

rtpi = get_unaligned_be16(ptr + 2);

drivers/target/target_core_device.c

size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_device.c

size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_device.c

size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_device.c

switch (get_unaligned_be16(&cdb[8])) {

drivers/target/target_core_fabric_lib.c

*out_tid_len = get_unaligned_be16(&buf[2]);

drivers/target/target_core_pr.c

rtpi = get_unaligned_be16(&buf[18]);

drivers/target/target_core_pscsi.c

page_len = get_unaligned_be16(&buf[2]);

drivers/target/target_core_pscsi.c

bdl = get_unaligned_be16(&buf[6]);

drivers/target/target_core_sbc.c

size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_sbc.c

dl = get_unaligned_be16(&buf[0]);

drivers/target/target_core_sbc.c

bd_dl = get_unaligned_be16(&buf[2]);

drivers/target/target_core_sbc.c

num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);

drivers/target/target_core_sbc.c

return get_unaligned_be16(&cdb[7]);

drivers/target/target_core_sbc.c

boundary = get_unaligned_be16(&cdb[10]);

drivers/target/target_core_sbc.c

transfer_len = get_unaligned_be16(&cdb[12]);

drivers/target/target_core_sbc.c

u16 service_action = get_unaligned_be16(&cdb[8]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[7]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[3]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[3]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[8]);

drivers/target/target_core_spc.c

*size = get_unaligned_be16(&cdb[8]);

drivers/target/target_core_spc.c

len = get_unaligned_be16(&buf[2]) + 4;

drivers/target/target_core_xcopy.c

ript = get_unaligned_be16(&desc[2]);

drivers/target/target_core_xcopy.c

desc_len = get_unaligned_be16(&desc[2]);

drivers/target/target_core_xcopy.c

xop->stdi = get_unaligned_be16(&desc[4]);

drivers/target/target_core_xcopy.c

xop->dtdi = get_unaligned_be16(&desc[6]);

drivers/target/target_core_xcopy.c

xop->nolb = get_unaligned_be16(&desc[10]);

drivers/target/target_core_xcopy.c

tdll = get_unaligned_be16(&p[2]);

drivers/ufs/core/ufs-sysfs.c

get_unaligned_be16(desc_buf));

drivers/ufs/core/ufshcd.c

data = get_unaligned_be16(&buff[2 * i]);

drivers/ufs/core/ufshcd.c

dev_info->ext_wb_sup = get_unaligned_be16(desc_buf +

drivers/ufs/core/ufshcd.c

u16 periodic_rtc_update = get_unaligned_be16(&desc_buf[DEVICE_DESC_PARAM_FRQ_RTC]);

drivers/ufs/core/ufshcd.c

device_version = get_unaligned_be16(&desc_buf[DEVICE_DESC_PARAM_DEV_VER]);

drivers/ufs/core/ufshcd.c

manufacture_date = get_unaligned_be16(&desc_buf[DEVICE_DESC_PARAM_MANF_DATE]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

get_unaligned_be16(&common->cmnd[7]);

drivers/usb/gadget/function/f_mass_storage.c

verification_length = get_unaligned_be16(&common->cmnd[7]);

drivers/usb/serial/mxuport.c

u16 rcv_msr_event = get_unaligned_be16(buf);

drivers/usb/serial/mxuport.c

rcv_port = get_unaligned_be16(data);

drivers/usb/serial/mxuport.c

rcv_len = get_unaligned_be16(data + 2);

drivers/usb/serial/mxuport.c

rcv_port = get_unaligned_be16(data);

drivers/usb/serial/mxuport.c

rcv_event = get_unaligned_be16(data + 2);

drivers/usb/typec/ucsi/ucsi_ccg.c

row = get_unaligned_be16(wr_buf);

drivers/usb/typec/ucsi/ucsi_ccg.c

len = get_unaligned_be16(&wr_buf[2]);

fs/ecryptfs/crypto.c

num_header_extents_at_front = get_unaligned_be16(virt);

fs/isofs/isofs.h

return get_unaligned_be16(p);

fs/xfs/libxfs/xfs_da_format.h

return get_unaligned_be16(sfep->offset);

fs/xfs/xfs_mount.c

(get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |

fs/xfs/xfs_mount.c

get_unaligned_be16(&sbp->sb_uuid.b[4]);

include/linux/ieee80211.h

if (get_unaligned_be16(tdls_data) == ETH_P_TDLS &&

include/net/mac802154.h

put_unaligned_le16(get_unaligned_be16(be16_src), le16_dst);

lib/decompress_unlzo.c

version = get_unaligned_be16(parse);

net/bluetooth/bnep/core.c

n = get_unaligned_be16(data);

net/bluetooth/bnep/core.c

f[i].start = get_unaligned_be16(data++);

net/bluetooth/bnep/core.c

f[i].end = get_unaligned_be16(data++);

net/bluetooth/bnep/core.c

n = get_unaligned_be16(data);

net/bridge/br_stp_bpdu.c

unsigned long ticks = get_unaligned_be16(src);

net/core/filter.c

return get_unaligned_be16(data + offset);

net/ipv4/cipso_ipv4.c

cat_high = get_unaligned_be16(&rngcat[iter]);

net/ipv4/cipso_ipv4.c

cat_low = get_unaligned_be16(&rngcat[iter + 2]);

net/ipv4/cipso_ipv4.c

cat_high = get_unaligned_be16(&net_cat[net_iter]);

net/ipv4/cipso_ipv4.c

cat_low = get_unaligned_be16(&net_cat[net_iter + 2]);

net/ipv4/cipso_ipv4.c

cat = get_unaligned_be16(&enumcat[iter]);

net/ipv4/cipso_ipv4.c

get_unaligned_be16(&net_cat[iter]),

net/ipv4/tcp_input.c

u16 in_mss = get_unaligned_be16(ptr);

net/ipv4/tcp_input.c

u16 in_mss = get_unaligned_be16(ptr);

net/ipv4/tcp_input.c

get_unaligned_be16(ptr) ==

net/mptcp/options.c

mp_opt->data_len = get_unaligned_be16(ptr);

net/mptcp/options.c

mp_opt->data_len = get_unaligned_be16(ptr);

net/mptcp/options.c

mp_opt->addr.port = htons(get_unaligned_be16(ptr));

net/mptcp/options.c

mp_opt->addr.port = htons(get_unaligned_be16(ptr));

net/netfilter/nf_synproxy_core.c

opts->mss_option = get_unaligned_be16(ptr);

net/phonet/af_phonet.c

len = get_unaligned_be16(&ph->pn_length);

net/sched/em_cmp.c

val = get_unaligned_be16(ptr);

scripts/elf-parse.h

return get_unaligned_be16(x);

security/apparmor/match.c

dfa->flags = get_unaligned_be16(data + 12);

security/apparmor/match.c

th.td_id = get_unaligned_be16(blob) - 1;

security/apparmor/match.c

th.td_flags = get_unaligned_be16(blob + 2);

security/apparmor/match.c

u16, __be16, get_unaligned_be16);

security/keys/trusted-keys/trusted_tpm2.c

priv_len = get_unaligned_be16(src) + 2;

security/keys/trusted-keys/trusted_tpm2.c

pub_len = get_unaligned_be16(src) + 2;

security/keys/trusted-keys/trusted_tpm2.c

private_len = get_unaligned_be16(blob);

security/keys/trusted-keys/trusted_tpm2.c

public_len = get_unaligned_be16(blob + 2 + private_len);

sound/soc/codecs/pcm6240.c

get_unaligned_be16(&config_data[config_offset]);

sound/soc/codecs/pcm6240.c

unsigned short len = get_unaligned_be16(&data[2]);

sound/soc/codecs/pcm6240.c

unsigned short len = get_unaligned_be16(&data[2]);

sound/soc/codecs/pcm6240.c

delay_time = get_unaligned_be16(&data[2]) * 1000;

sound/soc/codecs/peb2466.c

val16 = get_unaligned_be16(buf);

sound/soc/codecs/peb2466.c

val16 = get_unaligned_be16(buf);

sound/soc/codecs/peb2466.c

tag = get_unaligned_be16(buf);

sound/soc/codecs/tas2781-fmwlib.c

img_data->nr_blk = get_unaligned_be16(&data[offset]);

sound/soc/codecs/tas2781-fmwlib.c

tas_fmw->nr_programs = get_unaligned_be16(&buf[offset]);

sound/soc/codecs/tas2781-fmwlib.c

tas_fmw->nr_configurations = get_unaligned_be16(&data[offset]);

sound/soc/codecs/tas2781-fmwlib.c

tas_fmw->nr_calibrations = get_unaligned_be16(&data[offset]);

sound/soc/codecs/tas2781-fmwlib.c

get_unaligned_be16(&config_data[config_offset]);

sound/soc/codecs/tas2781-fmwlib.c

fw_hdr->device_family = get_unaligned_be16(&buf[offset]);

sound/soc/codecs/tas2781-fmwlib.c

fw_hdr->device = get_unaligned_be16(&buf[offset]);

sound/soc/codecs/tas2781-fmwlib.c

unsigned short len = get_unaligned_be16(&data[2]);

sound/soc/codecs/tas2781-fmwlib.c

unsigned short len = get_unaligned_be16(&data[2]);

sound/soc/codecs/tas2781-fmwlib.c

sleep_time = get_unaligned_be16(&data[2]) * 1000;

sound/soc/codecs/tlv320aic31xx.c

val16 = get_unaligned_be16(data);

sound/soc/codecs/tlv320aic31xx.c

val16 = get_unaligned_be16(data);

sound/soc/codecs/wm5102.c

uint16_t dac_comp_coeff = get_unaligned_be16(ucontrol->value.bytes.data);

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c

ctx->attrs.mss = get_unaligned_be16(mss);