diff for duplicates of <1489716812.10281.4.camel@intel.com> diff --git a/a/1.txt b/N1/1.txt index 1f992f7..ef7b505 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,182 +1,108 @@ -On Thu, 2017-03-16 at 18:20 +0800, Song Hongyan wrote: -> As accelerometer sensor becomes more and more popular, there are more -> user scenarios have been developed, "Hinge" is a very important -> usecase -> which needs two accelerometer sensors to calculate the included angle -> of keyboard and screen. -> In this case, two accelerometer sensors will be exposed. Currently, -> IIO interface hasn't other way to distinguish two sensors with same -> sensor type, except sensor name. So a new sensor name "accel_2nd_3d" -> is added for secondary accelerometer sensor. - -This type of interface will not satisfy all cases. We have some hubs -with many accelerometers attached. Same case is also true even for -discrete sensors. So there should be some framework way to expose -location of sensors. - -ACPI has special method called _PLD (Physical Device Location), which -can be used to specify location of any device. So we need to be able -to export such information to user space. We can add for each sensor -the location information. - -I can propose some ABI for exporting location information. - -Thought? - -Thanks, -Srinivas - - -> -> In HID level, connection type is a good common property to -> differentiate two sensors with same sensor type. -> -> Signed-off-by: Song Hongyan <hongyan.song@intel.com> -> --- -> drivers/iio/accel/hid-sensor-accel-3d.c | 35 -> ++++++++++++++++++++-- -> .../iio/common/hid-sensors/hid-sensor-attributes.c | 5 ++++ -> include/linux/hid-sensor-hub.h | 1 + -> include/linux/hid-sensor-ids.h | 1 + -> 4 files changed, 40 insertions(+), 2 deletions(-) -> -> diff --git a/drivers/iio/accel/hid-sensor-accel-3d.c -> b/drivers/iio/accel/hid-sensor-accel-3d.c -> index ca5759c..cc4366e 100644 -> --- a/drivers/iio/accel/hid-sensor-accel-3d.c -> +++ b/drivers/iio/accel/hid-sensor-accel-3d.c -> @@ -31,6 +31,13 @@ -> #include <linux/iio/triggered_buffer.h> -> #include "../common/hid-sensors/hid-sensor-trigger.h" -> -> +enum connection_type { -> + CONN_PC_INTEGRATED_SEL, -> + CONN_PC_ATTACHED_SEL, -> + CONN_PC_EXTERNAL_SEL, -> + CONN_TYPE_MAX, -> +}; -> + -> enum accel_3d_channel { -> CHANNEL_SCAN_INDEX_X, -> CHANNEL_SCAN_INDEX_Y, -> @@ -343,6 +350,19 @@ static int accel_3d_parse_report(struct -> platform_device *pdev, -> return ret; -> } -> -> +int connection_type_check(struct hid_sensor_common *st, int -> *conn_tp) -> +{ -> + int ret; -> + -> + ret = sensor_hub_get_feature(st->hsdev, st- -> >conn_type.report_id, -> + st->conn_type.index, sizeof(*conn_tp), conn_tp); -> + -> + if (ret < 0 || conn_tp < 0) -> + return -EINVAL; -> + -> + return ret; -> +} -> + -> /* Function to initialize the processing for usage id */ -> static int hid_accel_3d_probe(struct platform_device *pdev) -> { -> @@ -352,6 +372,7 @@ static int hid_accel_3d_probe(struct -> platform_device *pdev) -> struct accel_3d_state *accel_state; -> const struct iio_chan_spec *channel_spec; -> int channel_size; -> + s32 conn_type; -> -> struct hid_sensor_hub_device *hsdev = pdev- -> >dev.platform_data; -> -> @@ -367,11 +388,9 @@ static int hid_accel_3d_probe(struct -> platform_device *pdev) -> accel_state->common_attributes.pdev = pdev; -> -> if (hsdev->usage == HID_USAGE_SENSOR_ACCEL_3D) { -> - name = "accel_3d"; -> channel_spec = accel_3d_channels; -> channel_size = sizeof(accel_3d_channels); -> } else { -> - name = "gravity"; -> channel_spec = gravity_channels; -> channel_size = sizeof(gravity_channels); -> } -> @@ -387,6 +406,18 @@ static int hid_accel_3d_probe(struct -> platform_device *pdev) -> dev_err(&pdev->dev, "failed to duplicate -> channels\n"); -> return -ENOMEM; -> } -> + -> + ret = connection_type_check(&accel_state->common_attributes, -> + &conn_type); -> + -> + if (hsdev->usage == HID_USAGE_SENSOR_ACCEL_3D) { -> + if (conn_type == CONN_PC_EXTERNAL_SEL) -> + name = "accel_2nd_3d"; -> + else -> + name = "accel_3d"; -> + } else -> + name = "gravity"; -> + -> ret = accel_3d_parse_report(pdev, hsdev, -> (struct iio_chan_spec *)indio_dev- -> >channels, -> hsdev->usage, accel_state); -> diff --git a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c -> b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c -> index 4f280ae..cc2ce2a 100644 -> --- a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c -> +++ b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c -> @@ -400,6 +400,11 @@ int hid_sensor_parse_common_attributes(struct -> hid_sensor_hub_device *hsdev, -> &st->sensitivity); -> -> sensor_hub_input_get_attribute_info(hsdev, -> + HID_FEATURE_REPORT, -> usage_id, -> + HID_USAGE_SENSOR_PROP_CONN_T -> YPE, -> + &st->conn_type); -> + -> + sensor_hub_input_get_attribute_info(hsdev, -> HID_INPUT_REPORT, -> usage_id, -> HID_USAGE_SENSOR_TIME_TI -> MESTAMP, -> ×tamp); -> diff --git a/include/linux/hid-sensor-hub.h b/include/linux/hid- -> sensor-hub.h -> index 7ef111d..08756a9 100644 -> --- a/include/linux/hid-sensor-hub.h -> +++ b/include/linux/hid-sensor-hub.h -> @@ -237,6 +237,7 @@ struct hid_sensor_common { -> struct hid_sensor_hub_attribute_info report_state; -> struct hid_sensor_hub_attribute_info power_state; -> struct hid_sensor_hub_attribute_info sensitivity; -> + struct hid_sensor_hub_attribute_info conn_type; -> struct work_struct work; -> }; -> -> diff --git a/include/linux/hid-sensor-ids.h b/include/linux/hid- -> sensor-ids.h -> index 719c928..2d349f7 100644 -> --- a/include/linux/hid-sensor-ids.h -> +++ b/include/linux/hid-sensor-ids.h -> @@ -135,6 +135,7 @@ -> #define HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND 0x1 -> 5 -> -> /* Common selectors */ -> +#define HID_USAGE_SENSOR_PROP_CONN_TYPE -> 0x200309 -> #define HID_USAGE_SENSOR_PROP_REPORT_INTERVAL -> 0x20030E -> #define HID_USAGE_SENSOR_PROP_SENSITIVITY_ABS -> 0x20030F -> #define HID_USAGE_SENSOR_PROP_SENSITIVITY_RANGE_PCT 0 -> x200310 +T24gVGh1LCAyMDE3LTAzLTE2IGF0IDE4OjIwICswODAwLCBTb25nIEhvbmd5YW4gd3JvdGU6DQo+ +IEFzIGFjY2VsZXJvbWV0ZXIgc2Vuc29yIGJlY29tZXMgbW9yZSBhbmQgbW9yZSBwb3B1bGFyLCB0 +aGVyZSBhcmUgbW9yZQ0KPiB1c2VyIHNjZW5hcmlvcyBoYXZlIGJlZW4gZGV2ZWxvcGVkLCAiSGlu +Z2UiIGlzIGEgdmVyeSBpbXBvcnRhbnQNCj4gdXNlY2FzZQ0KPiB3aGljaCBuZWVkcyB0d28gYWNj +ZWxlcm9tZXRlciBzZW5zb3JzIHRvIGNhbGN1bGF0ZSB0aGUgaW5jbHVkZWQgYW5nbGUNCj4gb2Yg +a2V5Ym9hcmQgYW5kIHNjcmVlbi4NCj4gSW4gdGhpcyBjYXNlLCB0d28gYWNjZWxlcm9tZXRlciBz +ZW5zb3JzIHdpbGwgYmUgZXhwb3NlZC4gQ3VycmVudGx5LA0KPiBJSU8gaW50ZXJmYWNlIGhhc24n +dCBvdGhlciB3YXkgdG8gZGlzdGluZ3Vpc2ggdHdvIHNlbnNvcnMgd2l0aCBzYW1lDQo+IHNlbnNv +ciB0eXBlLCBleGNlcHQgc2Vuc29yIG5hbWUuIFNvIGEgbmV3IHNlbnNvciBuYW1lICJhY2NlbF8y +bmRfM2QiDQo+IGlzIGFkZGVkIGZvciBzZWNvbmRhcnkgYWNjZWxlcm9tZXRlciBzZW5zb3IuDQoN +ClRoaXMgdHlwZSBvZiBpbnRlcmZhY2Ugd2lsbCBub3Qgc2F0aXNmeSBhbGwgY2FzZXMuIFdlIGhh +dmUgc29tZSBodWJzDQp3aXRoICBtYW55IGFjY2VsZXJvbWV0ZXJzIGF0dGFjaGVkLiBTYW1lIGNh +c2UgaXMgYWxzbyB0cnVlIGV2ZW4gZm9yDQpkaXNjcmV0ZSBzZW5zb3JzLiBTbyB0aGVyZSBzaG91 +bGQgYmUgc29tZSBmcmFtZXdvcmsgd2F5IHRvIGV4cG9zZQ0KbG9jYXRpb24gb2Ygc2Vuc29ycy4N +Cg0KQUNQSSBoYXMgc3BlY2lhbCBtZXRob2QgY2FsbGVkIF9QTEQgKFBoeXNpY2FsIERldmljZSBM +b2NhdGlvbiksIHdoaWNoDQpjYW4gIGJlIHVzZWQgdG8gc3BlY2lmeSBsb2NhdGlvbiBvZiBhbnkg +ZGV2aWNlLiBTbyB3ZSBuZWVkIHRvIGJlIGFibGUNCnRvIGV4cG9ydCBzdWNoIGluZm9ybWF0aW9u +IHRvIHVzZXIgc3BhY2UuIFdlIGNhbiBhZGQgZm9yIGVhY2ggc2Vuc29yDQp0aGUgbG9jYXRpb24g +aW5mb3JtYXRpb24uDQoNCkkgY2FuIHByb3Bvc2Ugc29tZSBBQkkgZm9yIGV4cG9ydGluZyBsb2Nh +dGlvbiBpbmZvcm1hdGlvbi4NCg0KVGhvdWdodD8NCg0KVGhhbmtzLA0KU3Jpbml2YXMNCg0KDQo+ +IA0KPiBJbiBISUQgbGV2ZWwsIGNvbm5lY3Rpb24gdHlwZSBpcyBhIGdvb2QgY29tbW9uIHByb3Bl +cnR5IHRvDQo+IGRpZmZlcmVudGlhdGUgdHdvIHNlbnNvcnMgd2l0aCBzYW1lIHNlbnNvciB0eXBl +Lg0KPiANCj4gU2lnbmVkLW9mZi1ieTogU29uZyBIb25neWFuIDxob25neWFuLnNvbmdAaW50ZWwu +Y29tPg0KPiAtLS0NCj4gwqBkcml2ZXJzL2lpby9hY2NlbC9oaWQtc2Vuc29yLWFjY2VsLTNkLmPC +oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8IDM1DQo+ICsrKysrKysrKysrKysrKysrKysrLS0NCj4g +wqAuLi4vaWlvL2NvbW1vbi9oaWQtc2Vuc29ycy9oaWQtc2Vuc29yLWF0dHJpYnV0ZXMuYyB8wqDC +oDUgKysrKw0KPiDCoGluY2x1ZGUvbGludXgvaGlkLXNlbnNvci1odWIuaMKgwqDCoMKgwqDCoMKg +wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMSArDQo+IMKgaW5jbHVkZS9saW51eC9o +aWQtc2Vuc29yLWlkcy5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg +fMKgwqAxICsNCj4gwqA0IGZpbGVzIGNoYW5nZWQsIDQwIGluc2VydGlvbnMoKyksIDIgZGVsZXRp +b25zKC0pDQo+IA0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9paW8vYWNjZWwvaGlkLXNlbnNvci1h +Y2NlbC0zZC5jDQo+IGIvZHJpdmVycy9paW8vYWNjZWwvaGlkLXNlbnNvci1hY2NlbC0zZC5jDQo+ +IGluZGV4IGNhNTc1OWMuLmNjNDM2NmUgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvaWlvL2FjY2Vs +L2hpZC1zZW5zb3ItYWNjZWwtM2QuYw0KPiArKysgYi9kcml2ZXJzL2lpby9hY2NlbC9oaWQtc2Vu +c29yLWFjY2VsLTNkLmMNCj4gQEAgLTMxLDYgKzMxLDEzIEBADQo+IMKgI2luY2x1ZGUgPGxpbnV4 +L2lpby90cmlnZ2VyZWRfYnVmZmVyLmg+DQo+IMKgI2luY2x1ZGUgIi4uL2NvbW1vbi9oaWQtc2Vu +c29ycy9oaWQtc2Vuc29yLXRyaWdnZXIuaCINCj4gwqANCj4gK2VudW0gY29ubmVjdGlvbl90eXBl +IHsNCj4gKwlDT05OX1BDX0lOVEVHUkFURURfU0VMLA0KPiArCUNPTk5fUENfQVRUQUNIRURfU0VM +LA0KPiArCUNPTk5fUENfRVhURVJOQUxfU0VMLA0KPiArCUNPTk5fVFlQRV9NQVgsDQo+ICt9Ow0K +PiArDQo+IMKgZW51bSBhY2NlbF8zZF9jaGFubmVsIHsNCj4gwqAJQ0hBTk5FTF9TQ0FOX0lOREVY +X1gsDQo+IMKgCUNIQU5ORUxfU0NBTl9JTkRFWF9ZLA0KPiBAQCAtMzQzLDYgKzM1MCwxOSBAQCBz +dGF0aWMgaW50IGFjY2VsXzNkX3BhcnNlX3JlcG9ydChzdHJ1Y3QNCj4gcGxhdGZvcm1fZGV2aWNl +ICpwZGV2LA0KPiDCoAlyZXR1cm4gcmV0Ow0KPiDCoH0NCj4gwqANCj4gK2ludCBjb25uZWN0aW9u +X3R5cGVfY2hlY2soc3RydWN0IGhpZF9zZW5zb3JfY29tbW9uICpzdCwgaW50DQo+ICpjb25uX3Rw +KQ0KPiArew0KPiArCWludCByZXQ7DQo+ICsNCj4gKwlyZXQgPSBzZW5zb3JfaHViX2dldF9mZWF0 +dXJlKHN0LT5oc2Rldiwgc3QtDQo+ID5jb25uX3R5cGUucmVwb3J0X2lkLA0KPiArCQlzdC0+Y29u +bl90eXBlLmluZGV4LCBzaXplb2YoKmNvbm5fdHApLCBjb25uX3RwKTsNCj4gKw0KPiArCWlmIChy +ZXQgPCAwIHx8IGNvbm5fdHAgPCAwKQ0KPiArCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0KPiArCXJl +dHVybiByZXQ7DQo+ICt9DQo+ICsNCj4gwqAvKiBGdW5jdGlvbiB0byBpbml0aWFsaXplIHRoZSBw +cm9jZXNzaW5nIGZvciB1c2FnZSBpZCAqLw0KPiDCoHN0YXRpYyBpbnQgaGlkX2FjY2VsXzNkX3By +b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+IMKgew0KPiBAQCAtMzUyLDYgKzM3 +Miw3IEBAIHN0YXRpYyBpbnQgaGlkX2FjY2VsXzNkX3Byb2JlKHN0cnVjdA0KPiBwbGF0Zm9ybV9k +ZXZpY2UgKnBkZXYpDQo+IMKgCXN0cnVjdCBhY2NlbF8zZF9zdGF0ZSAqYWNjZWxfc3RhdGU7DQo+ +IMKgCWNvbnN0IHN0cnVjdCBpaW9fY2hhbl9zcGVjICpjaGFubmVsX3NwZWM7DQo+IMKgCWludCBj +aGFubmVsX3NpemU7DQo+ICsJczMyIGNvbm5fdHlwZTsNCj4gwqANCj4gwqAJc3RydWN0IGhpZF9z +ZW5zb3JfaHViX2RldmljZSAqaHNkZXYgPSBwZGV2LQ0KPiA+ZGV2LnBsYXRmb3JtX2RhdGE7DQo+ +IMKgDQo+IEBAIC0zNjcsMTEgKzM4OCw5IEBAIHN0YXRpYyBpbnQgaGlkX2FjY2VsXzNkX3Byb2Jl +KHN0cnVjdA0KPiBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+IMKgCWFjY2VsX3N0YXRlLT5jb21t +b25fYXR0cmlidXRlcy5wZGV2ID0gcGRldjsNCj4gwqANCj4gwqAJaWYgKGhzZGV2LT51c2FnZSA9 +PSBISURfVVNBR0VfU0VOU09SX0FDQ0VMXzNEKSB7DQo+IC0JCW5hbWUgPSAiYWNjZWxfM2QiOw0K +PiDCoAkJY2hhbm5lbF9zcGVjID0gYWNjZWxfM2RfY2hhbm5lbHM7DQo+IMKgCQljaGFubmVsX3Np +emUgPSBzaXplb2YoYWNjZWxfM2RfY2hhbm5lbHMpOw0KPiDCoAl9IGVsc2Ugew0KPiAtCQluYW1l +ID0gImdyYXZpdHkiOw0KPiDCoAkJY2hhbm5lbF9zcGVjID0gZ3Jhdml0eV9jaGFubmVsczsNCj4g +wqAJCWNoYW5uZWxfc2l6ZSA9IHNpemVvZihncmF2aXR5X2NoYW5uZWxzKTsNCj4gwqAJfQ0KPiBA +QCAtMzg3LDYgKzQwNiwxOCBAQCBzdGF0aWMgaW50IGhpZF9hY2NlbF8zZF9wcm9iZShzdHJ1Y3QN +Cj4gcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiDCoAkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFp +bGVkIHRvIGR1cGxpY2F0ZQ0KPiBjaGFubmVsc1xuIik7DQo+IMKgCQlyZXR1cm4gLUVOT01FTTsN +Cj4gwqAJfQ0KPiArDQo+ICsJcmV0ID0gY29ubmVjdGlvbl90eXBlX2NoZWNrKCZhY2NlbF9zdGF0 +ZS0+Y29tbW9uX2F0dHJpYnV0ZXMsDQo+ICsJCQkJJmNvbm5fdHlwZSk7DQo+ICsNCj4gKwlpZiAo +aHNkZXYtPnVzYWdlID09IEhJRF9VU0FHRV9TRU5TT1JfQUNDRUxfM0QpIHsNCj4gKwkJaWYgKGNv +bm5fdHlwZSA9PSBDT05OX1BDX0VYVEVSTkFMX1NFTCkNCj4gKwkJCW5hbWUgPSAiYWNjZWxfMm5k +XzNkIjsNCj4gKwkJZWxzZQ0KPiArCQkJbmFtZSA9ICJhY2NlbF8zZCI7DQo+ICsJfSBlbHNlDQo+ +ICsJCW5hbWUgPSAiZ3Jhdml0eSI7DQo+ICsNCj4gwqAJcmV0ID0gYWNjZWxfM2RfcGFyc2VfcmVw +b3J0KHBkZXYsIGhzZGV2LA0KPiDCoAkJCQkoc3RydWN0IGlpb19jaGFuX3NwZWMgKilpbmRpb19k +ZXYtDQo+ID5jaGFubmVscywNCj4gwqAJCQkJaHNkZXYtPnVzYWdlLCBhY2NlbF9zdGF0ZSk7DQo+ +IGRpZmYgLS1naXQgYS9kcml2ZXJzL2lpby9jb21tb24vaGlkLXNlbnNvcnMvaGlkLXNlbnNvci1h +dHRyaWJ1dGVzLmMNCj4gYi9kcml2ZXJzL2lpby9jb21tb24vaGlkLXNlbnNvcnMvaGlkLXNlbnNv +ci1hdHRyaWJ1dGVzLmMNCj4gaW5kZXggNGYyODBhZS4uY2MyY2UyYSAxMDA2NDQNCj4gLS0tIGEv +ZHJpdmVycy9paW8vY29tbW9uL2hpZC1zZW5zb3JzL2hpZC1zZW5zb3ItYXR0cmlidXRlcy5jDQo+ +ICsrKyBiL2RyaXZlcnMvaWlvL2NvbW1vbi9oaWQtc2Vuc29ycy9oaWQtc2Vuc29yLWF0dHJpYnV0 +ZXMuYw0KPiBAQCAtNDAwLDYgKzQwMCwxMSBAQCBpbnQgaGlkX3NlbnNvcl9wYXJzZV9jb21tb25f +YXR0cmlidXRlcyhzdHJ1Y3QNCj4gaGlkX3NlbnNvcl9odWJfZGV2aWNlICpoc2RldiwNCj4gwqAJ +CQnCoCZzdC0+c2Vuc2l0aXZpdHkpOw0KPiDCoA0KPiDCoAlzZW5zb3JfaHViX2lucHV0X2dldF9h +dHRyaWJ1dGVfaW5mbyhoc2RldiwNCj4gKwkJCQkJSElEX0ZFQVRVUkVfUkVQT1JULA0KPiB1c2Fn +ZV9pZCwNCj4gKwkJCQkJSElEX1VTQUdFX1NFTlNPUl9QUk9QX0NPTk5fVA0KPiBZUEUsDQo+ICsJ +CQkJCSZzdC0+Y29ubl90eXBlKTsNCj4gKw0KPiArCXNlbnNvcl9odWJfaW5wdXRfZ2V0X2F0dHJp +YnV0ZV9pbmZvKGhzZGV2LA0KPiDCoAkJCQkJwqDCoMKgwqBISURfSU5QVVRfUkVQT1JULA0KPiB1 +c2FnZV9pZCwNCj4gwqAJCQkJCcKgwqDCoMKgSElEX1VTQUdFX1NFTlNPUl9USU1FX1RJDQo+IE1F +U1RBTVAsDQo+IMKgCQkJCQnCoMKgwqDCoCZ0aW1lc3RhbXApOw0KPiBkaWZmIC0tZ2l0IGEvaW5j +bHVkZS9saW51eC9oaWQtc2Vuc29yLWh1Yi5oIGIvaW5jbHVkZS9saW51eC9oaWQtDQo+IHNlbnNv +ci1odWIuaA0KPiBpbmRleCA3ZWYxMTFkLi4wODc1NmE5IDEwMDY0NA0KPiAtLS0gYS9pbmNsdWRl +L2xpbnV4L2hpZC1zZW5zb3ItaHViLmgNCj4gKysrIGIvaW5jbHVkZS9saW51eC9oaWQtc2Vuc29y +LWh1Yi5oDQo+IEBAIC0yMzcsNiArMjM3LDcgQEAgc3RydWN0IGhpZF9zZW5zb3JfY29tbW9uIHsN +Cj4gwqAJc3RydWN0IGhpZF9zZW5zb3JfaHViX2F0dHJpYnV0ZV9pbmZvIHJlcG9ydF9zdGF0ZTsN +Cj4gwqAJc3RydWN0IGhpZF9zZW5zb3JfaHViX2F0dHJpYnV0ZV9pbmZvIHBvd2VyX3N0YXRlOw0K +PiDCoAlzdHJ1Y3QgaGlkX3NlbnNvcl9odWJfYXR0cmlidXRlX2luZm8gc2Vuc2l0aXZpdHk7DQo+ +ICsJc3RydWN0IGhpZF9zZW5zb3JfaHViX2F0dHJpYnV0ZV9pbmZvIGNvbm5fdHlwZTsNCj4gwqAJ +c3RydWN0IHdvcmtfc3RydWN0IHdvcms7DQo+IMKgfTsNCj4gwqANCj4gZGlmZiAtLWdpdCBhL2lu +Y2x1ZGUvbGludXgvaGlkLXNlbnNvci1pZHMuaCBiL2luY2x1ZGUvbGludXgvaGlkLQ0KPiBzZW5z +b3ItaWRzLmgNCj4gaW5kZXggNzE5YzkyOC4uMmQzNDlmNyAxMDA2NDQNCj4gLS0tIGEvaW5jbHVk +ZS9saW51eC9oaWQtc2Vuc29yLWlkcy5oDQo+ICsrKyBiL2luY2x1ZGUvbGludXgvaGlkLXNlbnNv +ci1pZHMuaA0KPiBAQCAtMTM1LDYgKzEzNSw3IEBADQo+IMKgI2RlZmluZSBISURfVVNBR0VfU0VO +U09SX1VOSVRTX0RFR1JFRVNfUEVSX1NFQ09ORAkJMHgxDQo+IDUNCj4gwqANCj4gwqAvKiBDb21t +b24gc2VsZWN0b3JzICovDQo+ICsjZGVmaW5lIEhJRF9VU0FHRV9TRU5TT1JfUFJPUF9DT05OX1RZ +UEUJCQkJDQo+IDB4MjAwMzA5DQo+IMKgI2RlZmluZSBISURfVVNBR0VfU0VOU09SX1BST1BfUkVQ +T1JUX0lOVEVSVkFMCQkJDQo+IDB4MjAwMzBFDQo+IMKgI2RlZmluZSBISURfVVNBR0VfU0VOU09S +X1BST1BfU0VOU0lUSVZJVFlfQUJTCQkJDQo+IDB4MjAwMzBGDQo+IMKgI2RlZmluZSBISURfVVNB +R0VfU0VOU09SX1BST1BfU0VOU0lUSVZJVFlfUkFOR0VfUENUCQkwDQo+IHgyMDAzMTA= diff --git a/a/content_digest b/N1/content_digest index e987860..0b9178c 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -1,197 +1,122 @@ "ref\01489659652-35608-1-git-send-email-hongyan.song@intel.com\0" - "ref\01489659652-35608-1-git-send-email-hongyan.song-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org\0" - "From\0Pandruvada, Srinivas <srinivas.pandruvada-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>\0" + "From\0Pandruvada, Srinivas <srinivas.pandruvada@intel.com>\0" "Subject\0Re: [PATCH] iio: hid: hid-sensor-accel-3d: Add second ACC sensor support\0" "Date\0Fri, 17 Mar 2017 02:13:35 +0000\0" - "To\0linux-input-u79uwXL29TY76Z2rM5mHXA@public.gmane.org <linux-input-u79uwXL29TY76Z2rM5mHXA@public.gmane.org>" + "To\0linux-input@vger.kernel.org <linux-input@vger.kernel.org>" Song - Hongyan <hongyan.song-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org> - " linux-iio-u79uwXL29TY76Z2rM5mHXA@public.gmane.org <linux-iio-u79uwXL29TY76Z2rM5mHXA@public.gmane.org>\0" - "Cc\0jikos-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org <jikos-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>" - " jic23-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org <jic23-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>\0" + Hongyan <hongyan.song@intel.com> + " linux-iio@vger.kernel.org <linux-iio@vger.kernel.org>\0" + "Cc\0jikos@kernel.org <jikos@kernel.org>" + " jic23@kernel.org <jic23@kernel.org>\0" "\00:1\0" "b\0" - "On Thu, 2017-03-16 at 18:20 +0800, Song Hongyan wrote:\n" - "> As accelerometer sensor becomes more and more popular, there are more\n" - "> user scenarios have been developed, \"Hinge\" is a very important\n" - "> usecase\n" - "> which needs two accelerometer sensors to calculate the included angle\n" - "> of keyboard and screen.\n" - "> In this case, two accelerometer sensors will be exposed. Currently,\n" - "> IIO interface hasn't other way to distinguish two sensors with same\n" - "> sensor type, except sensor name. So a new sensor name \"accel_2nd_3d\"\n" - "> is added for secondary accelerometer sensor.\n" - "\n" - "This type of interface will not satisfy all cases. We have some hubs\n" - "with many accelerometers attached. Same case is also true even for\n" - "discrete sensors. So there should be some framework way to expose\n" - "location of sensors.\n" - "\n" - "ACPI has special method called _PLD (Physical Device Location), which\n" - "can be used to specify location of any device. So we need to be able\n" - "to export such information to user space. We can add for each sensor\n" - "the location information.\n" - "\n" - "I can propose some ABI for exporting location information.\n" - "\n" - "Thought?\n" - "\n" - "Thanks,\n" - "Srinivas\n" - "\n" - "\n" - "> \n" - "> In HID level, connection type is a good common property to\n" - "> differentiate two sensors with same sensor type.\n" - "> \n" - "> Signed-off-by: Song Hongyan <hongyan.song@intel.com>\n" - "> ---\n" - "> \302\240drivers/iio/accel/hid-sensor-accel-3d.c\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240| 35\n" - "> ++++++++++++++++++++--\n" - "> \302\240.../iio/common/hid-sensors/hid-sensor-attributes.c |\302\240\302\2405 ++++\n" - "> \302\240include/linux/hid-sensor-hub.h\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240|\302\240\302\2401 +\n" - "> \302\240include/linux/hid-sensor-ids.h\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240\302\240|\302\240\302\2401 +\n" - "> \302\2404 files changed, 40 insertions(+), 2 deletions(-)\n" - "> \n" - "> diff --git a/drivers/iio/accel/hid-sensor-accel-3d.c\n" - "> b/drivers/iio/accel/hid-sensor-accel-3d.c\n" - "> index ca5759c..cc4366e 100644\n" - "> --- a/drivers/iio/accel/hid-sensor-accel-3d.c\n" - "> +++ b/drivers/iio/accel/hid-sensor-accel-3d.c\n" - "> @@ -31,6 +31,13 @@\n" - "> \302\240#include <linux/iio/triggered_buffer.h>\n" - "> \302\240#include \"../common/hid-sensors/hid-sensor-trigger.h\"\n" - "> \302\240\n" - "> +enum connection_type {\n" - "> +\tCONN_PC_INTEGRATED_SEL,\n" - "> +\tCONN_PC_ATTACHED_SEL,\n" - "> +\tCONN_PC_EXTERNAL_SEL,\n" - "> +\tCONN_TYPE_MAX,\n" - "> +};\n" - "> +\n" - "> \302\240enum accel_3d_channel {\n" - "> \302\240\tCHANNEL_SCAN_INDEX_X,\n" - "> \302\240\tCHANNEL_SCAN_INDEX_Y,\n" - "> @@ -343,6 +350,19 @@ static int accel_3d_parse_report(struct\n" - "> platform_device *pdev,\n" - "> \302\240\treturn ret;\n" - "> \302\240}\n" - "> \302\240\n" - "> +int connection_type_check(struct hid_sensor_common *st, int\n" - "> *conn_tp)\n" - "> +{\n" - "> +\tint ret;\n" - "> +\n" - "> +\tret = sensor_hub_get_feature(st->hsdev, st-\n" - "> >conn_type.report_id,\n" - "> +\t\tst->conn_type.index, sizeof(*conn_tp), conn_tp);\n" - "> +\n" - "> +\tif (ret < 0 || conn_tp < 0)\n" - "> +\t\treturn -EINVAL;\n" - "> +\n" - "> +\treturn ret;\n" - "> +}\n" - "> +\n" - "> \302\240/* Function to initialize the processing for usage id */\n" - "> \302\240static int hid_accel_3d_probe(struct platform_device *pdev)\n" - "> \302\240{\n" - "> @@ -352,6 +372,7 @@ static int hid_accel_3d_probe(struct\n" - "> platform_device *pdev)\n" - "> \302\240\tstruct accel_3d_state *accel_state;\n" - "> \302\240\tconst struct iio_chan_spec *channel_spec;\n" - "> \302\240\tint channel_size;\n" - "> +\ts32 conn_type;\n" - "> \302\240\n" - "> \302\240\tstruct hid_sensor_hub_device *hsdev = pdev-\n" - "> >dev.platform_data;\n" - "> \302\240\n" - "> @@ -367,11 +388,9 @@ static int hid_accel_3d_probe(struct\n" - "> platform_device *pdev)\n" - "> \302\240\taccel_state->common_attributes.pdev = pdev;\n" - "> \302\240\n" - "> \302\240\tif (hsdev->usage == HID_USAGE_SENSOR_ACCEL_3D) {\n" - "> -\t\tname = \"accel_3d\";\n" - "> \302\240\t\tchannel_spec = accel_3d_channels;\n" - "> \302\240\t\tchannel_size = sizeof(accel_3d_channels);\n" - "> \302\240\t} else {\n" - "> -\t\tname = \"gravity\";\n" - "> \302\240\t\tchannel_spec = gravity_channels;\n" - "> \302\240\t\tchannel_size = sizeof(gravity_channels);\n" - "> \302\240\t}\n" - "> @@ -387,6 +406,18 @@ static int hid_accel_3d_probe(struct\n" - "> platform_device *pdev)\n" - "> \302\240\t\tdev_err(&pdev->dev, \"failed to duplicate\n" - "> channels\\n\");\n" - "> \302\240\t\treturn -ENOMEM;\n" - "> \302\240\t}\n" - "> +\n" - "> +\tret = connection_type_check(&accel_state->common_attributes,\n" - "> +\t\t\t\t&conn_type);\n" - "> +\n" - "> +\tif (hsdev->usage == HID_USAGE_SENSOR_ACCEL_3D) {\n" - "> +\t\tif (conn_type == CONN_PC_EXTERNAL_SEL)\n" - "> +\t\t\tname = \"accel_2nd_3d\";\n" - "> +\t\telse\n" - "> +\t\t\tname = \"accel_3d\";\n" - "> +\t} else\n" - "> +\t\tname = \"gravity\";\n" - "> +\n" - "> \302\240\tret = accel_3d_parse_report(pdev, hsdev,\n" - "> \302\240\t\t\t\t(struct iio_chan_spec *)indio_dev-\n" - "> >channels,\n" - "> \302\240\t\t\t\thsdev->usage, accel_state);\n" - "> diff --git a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c\n" - "> b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c\n" - "> index 4f280ae..cc2ce2a 100644\n" - "> --- a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c\n" - "> +++ b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c\n" - "> @@ -400,6 +400,11 @@ int hid_sensor_parse_common_attributes(struct\n" - "> hid_sensor_hub_device *hsdev,\n" - "> \302\240\t\t\t\302\240&st->sensitivity);\n" - "> \302\240\n" - "> \302\240\tsensor_hub_input_get_attribute_info(hsdev,\n" - "> +\t\t\t\t\tHID_FEATURE_REPORT,\n" - "> usage_id,\n" - "> +\t\t\t\t\tHID_USAGE_SENSOR_PROP_CONN_T\n" - "> YPE,\n" - "> +\t\t\t\t\t&st->conn_type);\n" - "> +\n" - "> +\tsensor_hub_input_get_attribute_info(hsdev,\n" - "> \302\240\t\t\t\t\t\302\240\302\240\302\240\302\240HID_INPUT_REPORT,\n" - "> usage_id,\n" - "> \302\240\t\t\t\t\t\302\240\302\240\302\240\302\240HID_USAGE_SENSOR_TIME_TI\n" - "> MESTAMP,\n" - "> \302\240\t\t\t\t\t\302\240\302\240\302\240\302\240×tamp);\n" - "> diff --git a/include/linux/hid-sensor-hub.h b/include/linux/hid-\n" - "> sensor-hub.h\n" - "> index 7ef111d..08756a9 100644\n" - "> --- a/include/linux/hid-sensor-hub.h\n" - "> +++ b/include/linux/hid-sensor-hub.h\n" - "> @@ -237,6 +237,7 @@ struct hid_sensor_common {\n" - "> \302\240\tstruct hid_sensor_hub_attribute_info report_state;\n" - "> \302\240\tstruct hid_sensor_hub_attribute_info power_state;\n" - "> \302\240\tstruct hid_sensor_hub_attribute_info sensitivity;\n" - "> +\tstruct hid_sensor_hub_attribute_info conn_type;\n" - "> \302\240\tstruct work_struct work;\n" - "> \302\240};\n" - "> \302\240\n" - "> diff --git a/include/linux/hid-sensor-ids.h b/include/linux/hid-\n" - "> sensor-ids.h\n" - "> index 719c928..2d349f7 100644\n" - "> --- a/include/linux/hid-sensor-ids.h\n" - "> +++ b/include/linux/hid-sensor-ids.h\n" - "> @@ -135,6 +135,7 @@\n" - "> \302\240#define HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND\t\t0x1\n" - "> 5\n" - "> \302\240\n" - "> \302\240/* Common selectors */\n" - "> +#define HID_USAGE_SENSOR_PROP_CONN_TYPE\t\t\t\t\n" - "> 0x200309\n" - "> \302\240#define HID_USAGE_SENSOR_PROP_REPORT_INTERVAL\t\t\t\n" - "> 0x20030E\n" - "> \302\240#define HID_USAGE_SENSOR_PROP_SENSITIVITY_ABS\t\t\t\n" - "> 0x20030F\n" - "> \302\240#define HID_USAGE_SENSOR_PROP_SENSITIVITY_RANGE_PCT\t\t0\n" - > x200310 + "T24gVGh1LCAyMDE3LTAzLTE2IGF0IDE4OjIwICswODAwLCBTb25nIEhvbmd5YW4gd3JvdGU6DQo+\n" + "IEFzIGFjY2VsZXJvbWV0ZXIgc2Vuc29yIGJlY29tZXMgbW9yZSBhbmQgbW9yZSBwb3B1bGFyLCB0\n" + "aGVyZSBhcmUgbW9yZQ0KPiB1c2VyIHNjZW5hcmlvcyBoYXZlIGJlZW4gZGV2ZWxvcGVkLCAiSGlu\n" + "Z2UiIGlzIGEgdmVyeSBpbXBvcnRhbnQNCj4gdXNlY2FzZQ0KPiB3aGljaCBuZWVkcyB0d28gYWNj\n" + "ZWxlcm9tZXRlciBzZW5zb3JzIHRvIGNhbGN1bGF0ZSB0aGUgaW5jbHVkZWQgYW5nbGUNCj4gb2Yg\n" + "a2V5Ym9hcmQgYW5kIHNjcmVlbi4NCj4gSW4gdGhpcyBjYXNlLCB0d28gYWNjZWxlcm9tZXRlciBz\n" + "ZW5zb3JzIHdpbGwgYmUgZXhwb3NlZC4gQ3VycmVudGx5LA0KPiBJSU8gaW50ZXJmYWNlIGhhc24n\n" + "dCBvdGhlciB3YXkgdG8gZGlzdGluZ3Vpc2ggdHdvIHNlbnNvcnMgd2l0aCBzYW1lDQo+IHNlbnNv\n" + "ciB0eXBlLCBleGNlcHQgc2Vuc29yIG5hbWUuIFNvIGEgbmV3IHNlbnNvciBuYW1lICJhY2NlbF8y\n" + "bmRfM2QiDQo+IGlzIGFkZGVkIGZvciBzZWNvbmRhcnkgYWNjZWxlcm9tZXRlciBzZW5zb3IuDQoN\n" + "ClRoaXMgdHlwZSBvZiBpbnRlcmZhY2Ugd2lsbCBub3Qgc2F0aXNmeSBhbGwgY2FzZXMuIFdlIGhh\n" + "dmUgc29tZSBodWJzDQp3aXRoICBtYW55IGFjY2VsZXJvbWV0ZXJzIGF0dGFjaGVkLiBTYW1lIGNh\n" + "c2UgaXMgYWxzbyB0cnVlIGV2ZW4gZm9yDQpkaXNjcmV0ZSBzZW5zb3JzLiBTbyB0aGVyZSBzaG91\n" + "bGQgYmUgc29tZSBmcmFtZXdvcmsgd2F5IHRvIGV4cG9zZQ0KbG9jYXRpb24gb2Ygc2Vuc29ycy4N\n" + "Cg0KQUNQSSBoYXMgc3BlY2lhbCBtZXRob2QgY2FsbGVkIF9QTEQgKFBoeXNpY2FsIERldmljZSBM\n" + "b2NhdGlvbiksIHdoaWNoDQpjYW4gIGJlIHVzZWQgdG8gc3BlY2lmeSBsb2NhdGlvbiBvZiBhbnkg\n" + "ZGV2aWNlLiBTbyB3ZSBuZWVkIHRvIGJlIGFibGUNCnRvIGV4cG9ydCBzdWNoIGluZm9ybWF0aW9u\n" + "IHRvIHVzZXIgc3BhY2UuIFdlIGNhbiBhZGQgZm9yIGVhY2ggc2Vuc29yDQp0aGUgbG9jYXRpb24g\n" + "aW5mb3JtYXRpb24uDQoNCkkgY2FuIHByb3Bvc2Ugc29tZSBBQkkgZm9yIGV4cG9ydGluZyBsb2Nh\n" + "dGlvbiBpbmZvcm1hdGlvbi4NCg0KVGhvdWdodD8NCg0KVGhhbmtzLA0KU3Jpbml2YXMNCg0KDQo+\n" + "IA0KPiBJbiBISUQgbGV2ZWwsIGNvbm5lY3Rpb24gdHlwZSBpcyBhIGdvb2QgY29tbW9uIHByb3Bl\n" + "cnR5IHRvDQo+IGRpZmZlcmVudGlhdGUgdHdvIHNlbnNvcnMgd2l0aCBzYW1lIHNlbnNvciB0eXBl\n" + "Lg0KPiANCj4gU2lnbmVkLW9mZi1ieTogU29uZyBIb25neWFuIDxob25neWFuLnNvbmdAaW50ZWwu\n" + "Y29tPg0KPiAtLS0NCj4gwqBkcml2ZXJzL2lpby9hY2NlbC9oaWQtc2Vuc29yLWFjY2VsLTNkLmPC\n" + "oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8IDM1DQo+ICsrKysrKysrKysrKysrKysrKysrLS0NCj4g\n" + "wqAuLi4vaWlvL2NvbW1vbi9oaWQtc2Vuc29ycy9oaWQtc2Vuc29yLWF0dHJpYnV0ZXMuYyB8wqDC\n" + "oDUgKysrKw0KPiDCoGluY2x1ZGUvbGludXgvaGlkLXNlbnNvci1odWIuaMKgwqDCoMKgwqDCoMKg\n" + "wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMSArDQo+IMKgaW5jbHVkZS9saW51eC9o\n" + "aWQtc2Vuc29yLWlkcy5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg\n" + "fMKgwqAxICsNCj4gwqA0IGZpbGVzIGNoYW5nZWQsIDQwIGluc2VydGlvbnMoKyksIDIgZGVsZXRp\n" + "b25zKC0pDQo+IA0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9paW8vYWNjZWwvaGlkLXNlbnNvci1h\n" + "Y2NlbC0zZC5jDQo+IGIvZHJpdmVycy9paW8vYWNjZWwvaGlkLXNlbnNvci1hY2NlbC0zZC5jDQo+\n" + "IGluZGV4IGNhNTc1OWMuLmNjNDM2NmUgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvaWlvL2FjY2Vs\n" + "L2hpZC1zZW5zb3ItYWNjZWwtM2QuYw0KPiArKysgYi9kcml2ZXJzL2lpby9hY2NlbC9oaWQtc2Vu\n" + "c29yLWFjY2VsLTNkLmMNCj4gQEAgLTMxLDYgKzMxLDEzIEBADQo+IMKgI2luY2x1ZGUgPGxpbnV4\n" + "L2lpby90cmlnZ2VyZWRfYnVmZmVyLmg+DQo+IMKgI2luY2x1ZGUgIi4uL2NvbW1vbi9oaWQtc2Vu\n" + "c29ycy9oaWQtc2Vuc29yLXRyaWdnZXIuaCINCj4gwqANCj4gK2VudW0gY29ubmVjdGlvbl90eXBl\n" + "IHsNCj4gKwlDT05OX1BDX0lOVEVHUkFURURfU0VMLA0KPiArCUNPTk5fUENfQVRUQUNIRURfU0VM\n" + "LA0KPiArCUNPTk5fUENfRVhURVJOQUxfU0VMLA0KPiArCUNPTk5fVFlQRV9NQVgsDQo+ICt9Ow0K\n" + "PiArDQo+IMKgZW51bSBhY2NlbF8zZF9jaGFubmVsIHsNCj4gwqAJQ0hBTk5FTF9TQ0FOX0lOREVY\n" + "X1gsDQo+IMKgCUNIQU5ORUxfU0NBTl9JTkRFWF9ZLA0KPiBAQCAtMzQzLDYgKzM1MCwxOSBAQCBz\n" + "dGF0aWMgaW50IGFjY2VsXzNkX3BhcnNlX3JlcG9ydChzdHJ1Y3QNCj4gcGxhdGZvcm1fZGV2aWNl\n" + "ICpwZGV2LA0KPiDCoAlyZXR1cm4gcmV0Ow0KPiDCoH0NCj4gwqANCj4gK2ludCBjb25uZWN0aW9u\n" + "X3R5cGVfY2hlY2soc3RydWN0IGhpZF9zZW5zb3JfY29tbW9uICpzdCwgaW50DQo+ICpjb25uX3Rw\n" + "KQ0KPiArew0KPiArCWludCByZXQ7DQo+ICsNCj4gKwlyZXQgPSBzZW5zb3JfaHViX2dldF9mZWF0\n" + "dXJlKHN0LT5oc2Rldiwgc3QtDQo+ID5jb25uX3R5cGUucmVwb3J0X2lkLA0KPiArCQlzdC0+Y29u\n" + "bl90eXBlLmluZGV4LCBzaXplb2YoKmNvbm5fdHApLCBjb25uX3RwKTsNCj4gKw0KPiArCWlmIChy\n" + "ZXQgPCAwIHx8IGNvbm5fdHAgPCAwKQ0KPiArCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0KPiArCXJl\n" + "dHVybiByZXQ7DQo+ICt9DQo+ICsNCj4gwqAvKiBGdW5jdGlvbiB0byBpbml0aWFsaXplIHRoZSBw\n" + "cm9jZXNzaW5nIGZvciB1c2FnZSBpZCAqLw0KPiDCoHN0YXRpYyBpbnQgaGlkX2FjY2VsXzNkX3By\n" + "b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+IMKgew0KPiBAQCAtMzUyLDYgKzM3\n" + "Miw3IEBAIHN0YXRpYyBpbnQgaGlkX2FjY2VsXzNkX3Byb2JlKHN0cnVjdA0KPiBwbGF0Zm9ybV9k\n" + "ZXZpY2UgKnBkZXYpDQo+IMKgCXN0cnVjdCBhY2NlbF8zZF9zdGF0ZSAqYWNjZWxfc3RhdGU7DQo+\n" + "IMKgCWNvbnN0IHN0cnVjdCBpaW9fY2hhbl9zcGVjICpjaGFubmVsX3NwZWM7DQo+IMKgCWludCBj\n" + "aGFubmVsX3NpemU7DQo+ICsJczMyIGNvbm5fdHlwZTsNCj4gwqANCj4gwqAJc3RydWN0IGhpZF9z\n" + "ZW5zb3JfaHViX2RldmljZSAqaHNkZXYgPSBwZGV2LQ0KPiA+ZGV2LnBsYXRmb3JtX2RhdGE7DQo+\n" + "IMKgDQo+IEBAIC0zNjcsMTEgKzM4OCw5IEBAIHN0YXRpYyBpbnQgaGlkX2FjY2VsXzNkX3Byb2Jl\n" + "KHN0cnVjdA0KPiBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+IMKgCWFjY2VsX3N0YXRlLT5jb21t\n" + "b25fYXR0cmlidXRlcy5wZGV2ID0gcGRldjsNCj4gwqANCj4gwqAJaWYgKGhzZGV2LT51c2FnZSA9\n" + "PSBISURfVVNBR0VfU0VOU09SX0FDQ0VMXzNEKSB7DQo+IC0JCW5hbWUgPSAiYWNjZWxfM2QiOw0K\n" + "PiDCoAkJY2hhbm5lbF9zcGVjID0gYWNjZWxfM2RfY2hhbm5lbHM7DQo+IMKgCQljaGFubmVsX3Np\n" + "emUgPSBzaXplb2YoYWNjZWxfM2RfY2hhbm5lbHMpOw0KPiDCoAl9IGVsc2Ugew0KPiAtCQluYW1l\n" + "ID0gImdyYXZpdHkiOw0KPiDCoAkJY2hhbm5lbF9zcGVjID0gZ3Jhdml0eV9jaGFubmVsczsNCj4g\n" + "wqAJCWNoYW5uZWxfc2l6ZSA9IHNpemVvZihncmF2aXR5X2NoYW5uZWxzKTsNCj4gwqAJfQ0KPiBA\n" + "QCAtMzg3LDYgKzQwNiwxOCBAQCBzdGF0aWMgaW50IGhpZF9hY2NlbF8zZF9wcm9iZShzdHJ1Y3QN\n" + "Cj4gcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiDCoAkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFp\n" + "bGVkIHRvIGR1cGxpY2F0ZQ0KPiBjaGFubmVsc1xuIik7DQo+IMKgCQlyZXR1cm4gLUVOT01FTTsN\n" + "Cj4gwqAJfQ0KPiArDQo+ICsJcmV0ID0gY29ubmVjdGlvbl90eXBlX2NoZWNrKCZhY2NlbF9zdGF0\n" + "ZS0+Y29tbW9uX2F0dHJpYnV0ZXMsDQo+ICsJCQkJJmNvbm5fdHlwZSk7DQo+ICsNCj4gKwlpZiAo\n" + "aHNkZXYtPnVzYWdlID09IEhJRF9VU0FHRV9TRU5TT1JfQUNDRUxfM0QpIHsNCj4gKwkJaWYgKGNv\n" + "bm5fdHlwZSA9PSBDT05OX1BDX0VYVEVSTkFMX1NFTCkNCj4gKwkJCW5hbWUgPSAiYWNjZWxfMm5k\n" + "XzNkIjsNCj4gKwkJZWxzZQ0KPiArCQkJbmFtZSA9ICJhY2NlbF8zZCI7DQo+ICsJfSBlbHNlDQo+\n" + "ICsJCW5hbWUgPSAiZ3Jhdml0eSI7DQo+ICsNCj4gwqAJcmV0ID0gYWNjZWxfM2RfcGFyc2VfcmVw\n" + "b3J0KHBkZXYsIGhzZGV2LA0KPiDCoAkJCQkoc3RydWN0IGlpb19jaGFuX3NwZWMgKilpbmRpb19k\n" + "ZXYtDQo+ID5jaGFubmVscywNCj4gwqAJCQkJaHNkZXYtPnVzYWdlLCBhY2NlbF9zdGF0ZSk7DQo+\n" + "IGRpZmYgLS1naXQgYS9kcml2ZXJzL2lpby9jb21tb24vaGlkLXNlbnNvcnMvaGlkLXNlbnNvci1h\n" + "dHRyaWJ1dGVzLmMNCj4gYi9kcml2ZXJzL2lpby9jb21tb24vaGlkLXNlbnNvcnMvaGlkLXNlbnNv\n" + "ci1hdHRyaWJ1dGVzLmMNCj4gaW5kZXggNGYyODBhZS4uY2MyY2UyYSAxMDA2NDQNCj4gLS0tIGEv\n" + "ZHJpdmVycy9paW8vY29tbW9uL2hpZC1zZW5zb3JzL2hpZC1zZW5zb3ItYXR0cmlidXRlcy5jDQo+\n" + "ICsrKyBiL2RyaXZlcnMvaWlvL2NvbW1vbi9oaWQtc2Vuc29ycy9oaWQtc2Vuc29yLWF0dHJpYnV0\n" + "ZXMuYw0KPiBAQCAtNDAwLDYgKzQwMCwxMSBAQCBpbnQgaGlkX3NlbnNvcl9wYXJzZV9jb21tb25f\n" + "YXR0cmlidXRlcyhzdHJ1Y3QNCj4gaGlkX3NlbnNvcl9odWJfZGV2aWNlICpoc2RldiwNCj4gwqAJ\n" + "CQnCoCZzdC0+c2Vuc2l0aXZpdHkpOw0KPiDCoA0KPiDCoAlzZW5zb3JfaHViX2lucHV0X2dldF9h\n" + "dHRyaWJ1dGVfaW5mbyhoc2RldiwNCj4gKwkJCQkJSElEX0ZFQVRVUkVfUkVQT1JULA0KPiB1c2Fn\n" + "ZV9pZCwNCj4gKwkJCQkJSElEX1VTQUdFX1NFTlNPUl9QUk9QX0NPTk5fVA0KPiBZUEUsDQo+ICsJ\n" + "CQkJCSZzdC0+Y29ubl90eXBlKTsNCj4gKw0KPiArCXNlbnNvcl9odWJfaW5wdXRfZ2V0X2F0dHJp\n" + "YnV0ZV9pbmZvKGhzZGV2LA0KPiDCoAkJCQkJwqDCoMKgwqBISURfSU5QVVRfUkVQT1JULA0KPiB1\n" + "c2FnZV9pZCwNCj4gwqAJCQkJCcKgwqDCoMKgSElEX1VTQUdFX1NFTlNPUl9USU1FX1RJDQo+IE1F\n" + "U1RBTVAsDQo+IMKgCQkJCQnCoMKgwqDCoCZ0aW1lc3RhbXApOw0KPiBkaWZmIC0tZ2l0IGEvaW5j\n" + "bHVkZS9saW51eC9oaWQtc2Vuc29yLWh1Yi5oIGIvaW5jbHVkZS9saW51eC9oaWQtDQo+IHNlbnNv\n" + "ci1odWIuaA0KPiBpbmRleCA3ZWYxMTFkLi4wODc1NmE5IDEwMDY0NA0KPiAtLS0gYS9pbmNsdWRl\n" + "L2xpbnV4L2hpZC1zZW5zb3ItaHViLmgNCj4gKysrIGIvaW5jbHVkZS9saW51eC9oaWQtc2Vuc29y\n" + "LWh1Yi5oDQo+IEBAIC0yMzcsNiArMjM3LDcgQEAgc3RydWN0IGhpZF9zZW5zb3JfY29tbW9uIHsN\n" + "Cj4gwqAJc3RydWN0IGhpZF9zZW5zb3JfaHViX2F0dHJpYnV0ZV9pbmZvIHJlcG9ydF9zdGF0ZTsN\n" + "Cj4gwqAJc3RydWN0IGhpZF9zZW5zb3JfaHViX2F0dHJpYnV0ZV9pbmZvIHBvd2VyX3N0YXRlOw0K\n" + "PiDCoAlzdHJ1Y3QgaGlkX3NlbnNvcl9odWJfYXR0cmlidXRlX2luZm8gc2Vuc2l0aXZpdHk7DQo+\n" + "ICsJc3RydWN0IGhpZF9zZW5zb3JfaHViX2F0dHJpYnV0ZV9pbmZvIGNvbm5fdHlwZTsNCj4gwqAJ\n" + "c3RydWN0IHdvcmtfc3RydWN0IHdvcms7DQo+IMKgfTsNCj4gwqANCj4gZGlmZiAtLWdpdCBhL2lu\n" + "Y2x1ZGUvbGludXgvaGlkLXNlbnNvci1pZHMuaCBiL2luY2x1ZGUvbGludXgvaGlkLQ0KPiBzZW5z\n" + "b3ItaWRzLmgNCj4gaW5kZXggNzE5YzkyOC4uMmQzNDlmNyAxMDA2NDQNCj4gLS0tIGEvaW5jbHVk\n" + "ZS9saW51eC9oaWQtc2Vuc29yLWlkcy5oDQo+ICsrKyBiL2luY2x1ZGUvbGludXgvaGlkLXNlbnNv\n" + "ci1pZHMuaA0KPiBAQCAtMTM1LDYgKzEzNSw3IEBADQo+IMKgI2RlZmluZSBISURfVVNBR0VfU0VO\n" + "U09SX1VOSVRTX0RFR1JFRVNfUEVSX1NFQ09ORAkJMHgxDQo+IDUNCj4gwqANCj4gwqAvKiBDb21t\n" + "b24gc2VsZWN0b3JzICovDQo+ICsjZGVmaW5lIEhJRF9VU0FHRV9TRU5TT1JfUFJPUF9DT05OX1RZ\n" + "UEUJCQkJDQo+IDB4MjAwMzA5DQo+IMKgI2RlZmluZSBISURfVVNBR0VfU0VOU09SX1BST1BfUkVQ\n" + "T1JUX0lOVEVSVkFMCQkJDQo+IDB4MjAwMzBFDQo+IMKgI2RlZmluZSBISURfVVNBR0VfU0VOU09S\n" + "X1BST1BfU0VOU0lUSVZJVFlfQUJTCQkJDQo+IDB4MjAwMzBGDQo+IMKgI2RlZmluZSBISURfVVNB\n" + R0VfU0VOU09SX1BST1BfU0VOU0lUSVZJVFlfUkFOR0VfUENUCQkwDQo+IHgyMDAzMTA= -ab0ad7d66782da7e4013c658666fed44b4e37e37f8b3acae5a50f3bf8732c1cb +fb1f267a2dc4d1767301c5a795c1f8a3510b8ab5ce42df528f37716c0631e47d
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.