diff for duplicates of <1486428534.18380.148.camel@intel.com> diff --git a/a/1.txt b/N1/1.txt index 795d90a..dd238bf 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,190 +1,100 @@ -On Sat, 2017-02-04 at 12:02 +0000, Jonathan Cameron wrote: -> On 04/02/17 13:47, Song Hongyan wrote: -> > -> > Environmental temperature sensor is a hid defined sensor, -> > it measures temperature. -> > -> > More information can be found in: -> > http://www.usb.org/developers/hidpage/HUTRR39b.pdf -> > -> > According to IIO ABI definition, IIO_TEMP data output unit is -> > milli degrees Celsius. Add the unit convert from degree to milli -> > degree. -> > -> > Signed-off-by: Song Hongyan <hongyan.song@intel.com> -> A few bits and bobs inline. Clearly I'll want Srinivas to comment on -> this -> one as well! - - -[...] - -> -+/* Capture samples in local storage */ -> > +static int temperature_capture_sample(struct hid_sensor_hub_device -> > *hsdev, -> > + unsigned int usage_id, -> > + size_t raw_len, char *raw_data, -> > + void *priv) -> > +{ -> > + struct iio_dev *indio_dev = platform_get_drvdata(priv); -> Why not make priv the indio_dev directly? I would imagine it's the -> pdev -> passed in when registering the callbacks below. - -Actually this priv can be renamed to pdev. The callback will be called -with platform_device * of the mfd device. - -> > -> > + struct temperature_state *temperature_state = -> > iio_priv(indio_dev); -> > + -> > + switch (usage_id) { -> > + case HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_TEMPERATURE: -> > + temperature_state->temperature_data = *(s32 -> > *)raw_data; -> > + return 0; -> > + default: -> > + return -EINVAL; -> > + } -> > +} -> > - -[...] - -> > +/* Function to initialize the processing for usage id */ -> > +static int hid_temperature_probe(struct platform_device *pdev) -> > +{ -> > + static const char *name = "temperature"; -> > + struct iio_dev *indio_dev; -> > + struct temperature_state *temperature_state; -> > + struct hid_sensor_hub_device *hsdev = pdev- -> > >dev.platform_data; -> > + int ret; -> > + -> > + indio_dev = devm_iio_device_alloc(&pdev->dev, -> > + sizeof(struct temperature_state)); -> > + if (!indio_dev) -> > + return -ENOMEM; -> > + -> > + temperature_state = iio_priv(indio_dev); -> > + temperature_state->common_attributes.hsdev = hsdev; -> > + temperature_state->common_attributes.pdev = pdev; -> > + -> > + ret = hid_sensor_parse_common_attributes(hsdev, -> > + HID_USAGE_SENSOR_TEMPERATU -> > RE, -> > + &temperature_state- -> > >common_attributes); -> > + if (ret) -> > + return ret; -> > + -> > + indio_dev->channels = devm_kmemdup(&indio_dev->dev, -> > + temperature_channels, -> > + sizeof(temperature_channel -> > s), -> > + GFP_KERNEL); -> > + if (!indio_dev->channels) -> > + return -ENOMEM; -> > + -> > + ret = temperature_parse_report(pdev, hsdev, -> > + (struct iio_chan_spec *)indio_dev- -> > >channels, -> > + HID_USAGE_SENSOR_TEMPERATURE, -> > + temperature_state); -> > + if (ret) -> > + return ret; -> > + -> > + indio_dev->num_channels = -> > ARRAY_SIZE(temperature_channels); -> > + indio_dev->dev.parent = &pdev->dev; -> > + indio_dev->info = &temperature_info; -> > + indio_dev->name = name; -> > + indio_dev->modes = INDIO_DIRECT_MODE; -> > + -> > + ret = iio_triggered_buffer_setup(indio_dev, -> > &iio_pollfunc_store_time, -> > + NULL, NULL); -> > + if (ret) -> > + return ret; -> If you are going all devm (which is fine) then use -> devm_iio_triggered_buffer_setup. -> -> > -> > + -> > + atomic_set(&temperature_state- -> > >common_attributes.data_ready, 0); -> > + ret = hid_sensor_setup_trigger(indio_dev, name, -> > + &temperature_state- -> > >common_attributes); -> I'd expect to see this unwound somewhere as well.. - -I missed this during my review. There has to be call -to hid_sensor_remove_trigger() to do opposite. - -> > -> > + if (ret) -> > + goto error_unreg_buffer_funcs; -> > + -> > + ret = devm_iio_device_register(indio_dev->dev.parent, -> > indio_dev); -> > + if (ret) -> > + goto error_unreg_buffer_funcs; -> Is there a race here in that userspace interfaces are exposed, but -> the -> hid system has no way to send answers to any queries? -Two scenarios possible: -- If somehow user space calls the raw read before the -sensor_hub_register_callback() is called, then there should not be any -issue as the sensor_hub_input_attr_get_raw_value is called with -"SENSOR_HUB_SYNC" so wait till response arrives or timeout. So doesn't -depend on the callback. - -- If user is activating the buffer mode before the callback us -registered, worst case it will miss event till the callback is -registered. - -But we can call sensor_hub_register_callback() -before devm_iio_device_register(), but the we need to make sure that -the sensor_hub_remove_callback() is called -if devm_iio_device_register() fails. - -> > -> > + -> > + platform_set_drvdata(pdev, indio_dev); -> > + -> > + temperature_state->callbacks.send_event = -> > temperature_proc_event; -> > + temperature_state->callbacks.capture_sample = -> > + temperature_captur -> > e_sample; -> > + temperature_state->callbacks.pdev = pdev; -> > + ret = sensor_hub_register_callback(hsdev, -> > HID_USAGE_SENSOR_TEMPERATURE, -> > + &temperature_state- -> > >callbacks); -> > + return ret; -> > + -> > +error_unreg_buffer_funcs: -> > + iio_triggered_buffer_cleanup(indio_dev); -> > + return ret; -> > +} -> > + -> > +/* Function to deinitialize the processing for usage id */ -> > +static int hid_temperature_remove(struct platform_device *pdev) -> > +{ -> > + struct hid_sensor_hub_device *hsdev = pdev- -> > >dev.platform_data; -> > + -> > + sensor_hub_remove_callback(hsdev, -> > HID_USAGE_SENSOR_TEMPERATURE); - -hid_sensor_remove_trigger() - -> > + -> > + return 0; -> > +} -> > + -> > -Thanks, -Srinivas +T24gU2F0LCAyMDE3LTAyLTA0IGF0IDEyOjAyICswMDAwLCBKb25hdGhhbiBDYW1lcm9uIHdyb3Rl +Og0KPiBPbiAwNC8wMi8xNyAxMzo0NywgU29uZyBIb25neWFuIHdyb3RlOg0KPiA+IA0KPiA+IEVu +dmlyb25tZW50YWwgdGVtcGVyYXR1cmUgc2Vuc29yIGlzIGEgaGlkIGRlZmluZWQgc2Vuc29yLA0K +PiA+IGl0IG1lYXN1cmVzIHRlbXBlcmF0dXJlLg0KPiA+IA0KPiA+IE1vcmUgaW5mb3JtYXRpb24g +Y2FuIGJlIGZvdW5kIGluOg0KPiA+IGh0dHA6Ly93d3cudXNiLm9yZy9kZXZlbG9wZXJzL2hpZHBh +Z2UvSFVUUlIzOWIucGRmDQo+ID4gDQo+ID4gQWNjb3JkaW5nIHRvIElJTyBBQkkgZGVmaW5pdGlv +biwgSUlPX1RFTVAgZGF0YSBvdXRwdXQgdW5pdCBpcw0KPiA+IG1pbGxpIGRlZ3JlZXMgQ2Vsc2l1 +cy4gQWRkIHRoZSB1bml0IGNvbnZlcnQgZnJvbSBkZWdyZWUgdG8gbWlsbGkNCj4gPiBkZWdyZWUu +DQo+ID4gDQo+ID4gU2lnbmVkLW9mZi1ieTogU29uZyBIb25neWFuIDxob25neWFuLnNvbmdAaW50 +ZWwuY29tPg0KPiBBIGZldyBiaXRzIGFuZCBib2JzIGlubGluZS7CoMKgQ2xlYXJseSBJJ2xsIHdh +bnQgU3Jpbml2YXMgdG8gY29tbWVudCBvbg0KPiB0aGlzDQo+IG9uZSBhcyB3ZWxsIQ0KDQoNClsu +Li5dDQoNCj4gDQorLyogQ2FwdHVyZSBzYW1wbGVzIGluIGxvY2FsIHN0b3JhZ2UgKi8NCj4gPiAr +c3RhdGljIGludCB0ZW1wZXJhdHVyZV9jYXB0dXJlX3NhbXBsZShzdHJ1Y3QgaGlkX3NlbnNvcl9o +dWJfZGV2aWNlDQo+ID4gKmhzZGV2LA0KPiA+ICsJCQkJdW5zaWduZWQgaW50IHVzYWdlX2lkLA0K +PiA+ICsJCQkJc2l6ZV90IHJhd19sZW4sIGNoYXIgKnJhd19kYXRhLA0KPiA+ICsJCQkJdm9pZCAq +cHJpdikNCj4gPiArew0KPiA+ICsJc3RydWN0IGlpb19kZXYgKmluZGlvX2RldiA9IHBsYXRmb3Jt +X2dldF9kcnZkYXRhKHByaXYpOw0KPiBXaHkgbm90IG1ha2UgcHJpdiB0aGUgaW5kaW9fZGV2IGRp +cmVjdGx5PyBJIHdvdWxkIGltYWdpbmUgaXQncyB0aGUNCj4gcGRldg0KPiBwYXNzZWQgaW4gd2hl +biByZWdpc3RlcmluZyB0aGUgY2FsbGJhY2tzIGJlbG93Lg0KDQpBY3R1YWxseSB0aGlzIHByaXYg +Y2FuIGJlIHJlbmFtZWQgdG8gcGRldi4gVGhlIGNhbGxiYWNrIHdpbGwgYmUgY2FsbGVkDQp3aXRo +IHBsYXRmb3JtX2RldmljZSAqIG9mIHRoZSBtZmQgZGV2aWNlLg0KDQo+ID4gDQo+ID4gKwlzdHJ1 +Y3QgdGVtcGVyYXR1cmVfc3RhdGUgKnRlbXBlcmF0dXJlX3N0YXRlID0NCj4gPiBpaW9fcHJpdihp +bmRpb19kZXYpOw0KPiA+ICsNCj4gPiArCXN3aXRjaCAodXNhZ2VfaWQpIHsNCj4gPiArCWNhc2Ug +SElEX1VTQUdFX1NFTlNPUl9EQVRBX0VOVklST05NRU5UQUxfVEVNUEVSQVRVUkU6DQo+ID4gKwkJ +dGVtcGVyYXR1cmVfc3RhdGUtPnRlbXBlcmF0dXJlX2RhdGEgPSAqKHMzMg0KPiA+ICopcmF3X2Rh +dGE7DQo+ID4gKwkJcmV0dXJuIDA7DQo+ID4gKwlkZWZhdWx0Og0KPiA+ICsJCXJldHVybiAtRUlO +VkFMOw0KPiA+ICsJfQ0KPiA+ICt9DQo+ID4gDQoNClsuLi5dDQoNCj4gPiArLyogRnVuY3Rpb24g +dG8gaW5pdGlhbGl6ZSB0aGUgcHJvY2Vzc2luZyBmb3IgdXNhZ2UgaWQgKi8NCj4gPiArc3RhdGlj +IGludCBoaWRfdGVtcGVyYXR1cmVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikN +Cj4gPiArew0KPiA+ICsJc3RhdGljIGNvbnN0IGNoYXIgKm5hbWUgPSAidGVtcGVyYXR1cmUiOw0K +PiA+ICsJc3RydWN0IGlpb19kZXYgKmluZGlvX2RldjsNCj4gPiArCXN0cnVjdCB0ZW1wZXJhdHVy +ZV9zdGF0ZSAqdGVtcGVyYXR1cmVfc3RhdGU7DQo+ID4gKwlzdHJ1Y3QgaGlkX3NlbnNvcl9odWJf +ZGV2aWNlICpoc2RldiA9IHBkZXYtDQo+ID4gPmRldi5wbGF0Zm9ybV9kYXRhOw0KPiA+ICsJaW50 +IHJldDsNCj4gPiArDQo+ID4gKwlpbmRpb19kZXYgPSBkZXZtX2lpb19kZXZpY2VfYWxsb2MoJnBk +ZXYtPmRldiwNCj4gPiArCQkJCXNpemVvZihzdHJ1Y3QgdGVtcGVyYXR1cmVfc3RhdGUpKTsNCj4g +PiArCWlmICghaW5kaW9fZGV2KQ0KPiA+ICsJCXJldHVybiAtRU5PTUVNOw0KPiA+ICsNCj4gPiAr +CXRlbXBlcmF0dXJlX3N0YXRlID0gaWlvX3ByaXYoaW5kaW9fZGV2KTsNCj4gPiArCXRlbXBlcmF0 +dXJlX3N0YXRlLT5jb21tb25fYXR0cmlidXRlcy5oc2RldiA9IGhzZGV2Ow0KPiA+ICsJdGVtcGVy +YXR1cmVfc3RhdGUtPmNvbW1vbl9hdHRyaWJ1dGVzLnBkZXYgPSBwZGV2Ow0KPiA+ICsNCj4gPiAr +CXJldCA9IGhpZF9zZW5zb3JfcGFyc2VfY29tbW9uX2F0dHJpYnV0ZXMoaHNkZXYsDQo+ID4gKwkJ +CQkJSElEX1VTQUdFX1NFTlNPUl9URU1QRVJBVFUNCj4gPiBSRSwNCj4gPiArCQkJCQkmdGVtcGVy +YXR1cmVfc3RhdGUtDQo+ID4gPmNvbW1vbl9hdHRyaWJ1dGVzKTsNCj4gPiArCWlmIChyZXQpDQo+ +ID4gKwkJcmV0dXJuIHJldDsNCj4gPiArDQo+ID4gKwlpbmRpb19kZXYtPmNoYW5uZWxzID0gZGV2 +bV9rbWVtZHVwKCZpbmRpb19kZXYtPmRldiwNCj4gPiArCQkJCQl0ZW1wZXJhdHVyZV9jaGFubmVs +cywNCj4gPiArCQkJCQlzaXplb2YodGVtcGVyYXR1cmVfY2hhbm5lbA0KPiA+IHMpLA0KPiA+ICsJ +CQkJCUdGUF9LRVJORUwpOw0KPiA+ICsJaWYgKCFpbmRpb19kZXYtPmNoYW5uZWxzKQ0KPiA+ICsJ +CXJldHVybiAtRU5PTUVNOw0KPiA+ICsNCj4gPiArCXJldCA9IHRlbXBlcmF0dXJlX3BhcnNlX3Jl +cG9ydChwZGV2LCBoc2RldiwNCj4gPiArCQkJCShzdHJ1Y3QgaWlvX2NoYW5fc3BlYyAqKWluZGlv +X2Rldi0NCj4gPiA+Y2hhbm5lbHMsDQo+ID4gKwkJCQlISURfVVNBR0VfU0VOU09SX1RFTVBFUkFU +VVJFLA0KPiA+ICsJCQkJdGVtcGVyYXR1cmVfc3RhdGUpOw0KPiA+ICsJaWYgKHJldCkNCj4gPiAr +CQlyZXR1cm4gcmV0Ow0KPiA+ICsNCj4gPiArCWluZGlvX2Rldi0+bnVtX2NoYW5uZWxzID0NCj4g +PiBBUlJBWV9TSVpFKHRlbXBlcmF0dXJlX2NoYW5uZWxzKTsNCj4gPiArCWluZGlvX2Rldi0+ZGV2 +LnBhcmVudCA9ICZwZGV2LT5kZXY7DQo+ID4gKwlpbmRpb19kZXYtPmluZm8gPSAmdGVtcGVyYXR1 +cmVfaW5mbzsNCj4gPiArCWluZGlvX2Rldi0+bmFtZSA9IG5hbWU7DQo+ID4gKwlpbmRpb19kZXYt +Pm1vZGVzID0gSU5ESU9fRElSRUNUX01PREU7DQo+ID4gKw0KPiA+ICsJcmV0ID0gaWlvX3RyaWdn +ZXJlZF9idWZmZXJfc2V0dXAoaW5kaW9fZGV2LA0KPiA+ICZpaW9fcG9sbGZ1bmNfc3RvcmVfdGlt +ZSwNCj4gPiArCQkJCQlOVUxMLCBOVUxMKTsNCj4gPiArCWlmIChyZXQpDQo+ID4gKwkJcmV0dXJu +IHJldDsNCj4gSWYgeW91IGFyZSBnb2luZyBhbGwgZGV2bSAod2hpY2ggaXMgZmluZSkgdGhlbiB1 +c2UNCj4gZGV2bV9paW9fdHJpZ2dlcmVkX2J1ZmZlcl9zZXR1cC4NCj4gDQo+ID4gDQo+ID4gKw0K +PiA+ICsJYXRvbWljX3NldCgmdGVtcGVyYXR1cmVfc3RhdGUtDQo+ID4gPmNvbW1vbl9hdHRyaWJ1 +dGVzLmRhdGFfcmVhZHksIDApOw0KPiA+ICsJcmV0ID0gaGlkX3NlbnNvcl9zZXR1cF90cmlnZ2Vy +KGluZGlvX2RldiwgbmFtZSwNCj4gPiArCQkJCSZ0ZW1wZXJhdHVyZV9zdGF0ZS0NCj4gPiA+Y29t +bW9uX2F0dHJpYnV0ZXMpOw0KPiBJJ2QgZXhwZWN0IHRvIHNlZSB0aGlzIHVud291bmQgc29tZXdo +ZXJlIGFzIHdlbGwuLg0KDQpJIG1pc3NlZCB0aGlzIGR1cmluZyBteSByZXZpZXcuIFRoZXJlIGhh +cyB0byBiZSBjYWxsDQp0b8KgwqBoaWRfc2Vuc29yX3JlbW92ZV90cmlnZ2VyKCkgdG8gZG8gb3Bw +b3NpdGUuDQoNCj4gPiANCj4gPiArCWlmIChyZXQpDQo+ID4gKwkJZ290byBlcnJvcl91bnJlZ19i +dWZmZXJfZnVuY3M7DQo+ID4gKw0KPiA+ICsJcmV0ID0gZGV2bV9paW9fZGV2aWNlX3JlZ2lzdGVy +KGluZGlvX2Rldi0+ZGV2LnBhcmVudCwNCj4gPiBpbmRpb19kZXYpOw0KPiA+ICsJaWYgKHJldCkN +Cj4gPiArCQlnb3RvIGVycm9yX3VucmVnX2J1ZmZlcl9mdW5jczsNCj4gSXMgdGhlcmUgYSByYWNl +IGhlcmUgaW4gdGhhdCB1c2Vyc3BhY2UgaW50ZXJmYWNlcyBhcmUgZXhwb3NlZCwgYnV0DQo+IHRo +ZQ0KPiBoaWQgc3lzdGVtIGhhcyBubyB3YXkgdG8gc2VuZCBhbnN3ZXJzIHRvIGFueSBxdWVyaWVz +Pw0KVHdvIHNjZW5hcmlvcyBwb3NzaWJsZToNCi0gSWYgc29tZWhvdyB1c2VyIHNwYWNlIGNhbGxz +IHRoZSByYXcgcmVhZCBiZWZvcmUgdGhlwqANCnNlbnNvcl9odWJfcmVnaXN0ZXJfY2FsbGJhY2so +KSBpcyBjYWxsZWQsIHRoZW4gdGhlcmUgc2hvdWxkIG5vdCBiZSBhbnkNCmlzc3VlIGFzIHRoZcKg +c2Vuc29yX2h1Yl9pbnB1dF9hdHRyX2dldF9yYXdfdmFsdWUgaXMgY2FsbGVkIHdpdGgNCiJTRU5T +T1JfSFVCX1NZTkMiIHNvIHdhaXQgdGlsbCByZXNwb25zZSBhcnJpdmVzIG9yIHRpbWVvdXQuIFNv +IGRvZXNuJ3QNCmRlcGVuZCBvbiB0aGUgY2FsbGJhY2suDQoNCi0gSWYgdXNlciBpcyBhY3RpdmF0 +aW5nIHRoZSBidWZmZXIgbW9kZSBiZWZvcmUgdGhlIGNhbGxiYWNrIHVzDQpyZWdpc3RlcmVkLCB3 +b3JzdCBjYXNlIGl0IHdpbGwgbWlzcyBldmVudCB0aWxsIHRoZSBjYWxsYmFjayBpcw0KcmVnaXN0 +ZXJlZC4NCg0KQnV0IHdlIGNhbiBjYWxswqBzZW5zb3JfaHViX3JlZ2lzdGVyX2NhbGxiYWNrKCkN +CmJlZm9yZcKgZGV2bV9paW9fZGV2aWNlX3JlZ2lzdGVyKCksIGJ1dCB0aGUgd2UgbmVlZCB0byBt +YWtlIHN1cmUgdGhhdA0KdGhlwqBzZW5zb3JfaHViX3JlbW92ZV9jYWxsYmFjaygpIGlzIGNhbGxl +ZA0KaWbCoGRldm1faWlvX2RldmljZV9yZWdpc3RlcigpIGZhaWxzLg0KDQo+ID4gDQo+ID4gKw0K +PiA+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaW5kaW9fZGV2KTsNCj4gPiArDQo+ID4g +Kwl0ZW1wZXJhdHVyZV9zdGF0ZS0+Y2FsbGJhY2tzLnNlbmRfZXZlbnQgPQ0KPiA+IHRlbXBlcmF0 +dXJlX3Byb2NfZXZlbnQ7DQo+ID4gKwl0ZW1wZXJhdHVyZV9zdGF0ZS0+Y2FsbGJhY2tzLmNhcHR1 +cmVfc2FtcGxlID0NCj4gPiArCQkJCQkJdGVtcGVyYXR1cmVfY2FwdHVyDQo+ID4gZV9zYW1wbGU7 +DQo+ID4gKwl0ZW1wZXJhdHVyZV9zdGF0ZS0+Y2FsbGJhY2tzLnBkZXYgPSBwZGV2Ow0KPiA+ICsJ +cmV0ID0gc2Vuc29yX2h1Yl9yZWdpc3Rlcl9jYWxsYmFjayhoc2RldiwNCj4gPiBISURfVVNBR0Vf +U0VOU09SX1RFTVBFUkFUVVJFLA0KPiA+ICsJCQkJCSZ0ZW1wZXJhdHVyZV9zdGF0ZS0NCj4gPiA+ +Y2FsbGJhY2tzKTvCoA0KPiA+ICsJcmV0dXJuIHJldDsNCj4gPiArDQo+ID4gK2Vycm9yX3VucmVn +X2J1ZmZlcl9mdW5jczoNCj4gPiArCWlpb190cmlnZ2VyZWRfYnVmZmVyX2NsZWFudXAoaW5kaW9f +ZGV2KTsNCj4gPiArCXJldHVybiByZXQ7DQo+ID4gK30NCj4gPiArDQo+ID4gKy8qIEZ1bmN0aW9u +IHRvIGRlaW5pdGlhbGl6ZSB0aGUgcHJvY2Vzc2luZyBmb3IgdXNhZ2UgaWQgKi8NCj4gPiArc3Rh +dGljIGludCBoaWRfdGVtcGVyYXR1cmVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk +ZXYpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBoaWRfc2Vuc29yX2h1Yl9kZXZpY2UgKmhzZGV2ID0g +cGRldi0NCj4gPiA+ZGV2LnBsYXRmb3JtX2RhdGE7DQo+ID4gKw0KPiA+ICsJc2Vuc29yX2h1Yl9y +ZW1vdmVfY2FsbGJhY2soaHNkZXYsDQo+ID4gSElEX1VTQUdFX1NFTlNPUl9URU1QRVJBVFVSRSk7 +DQoNCmhpZF9zZW5zb3JfcmVtb3ZlX3RyaWdnZXIoKQ0KDQo+ID4gKw0KPiA+ICsJcmV0dXJuIDA7 +DQo+ID4gK30NCj4gPiArDQo+ID7CoA0KVGhhbmtzLA0KU3Jpbml2YXM= diff --git a/a/content_digest b/N1/content_digest index d26df0a..6939af6 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -11,195 +11,105 @@ "Cc\0jikos@kernel.org <jikos@kernel.org>\0" "\00:1\0" "b\0" - "On Sat, 2017-02-04 at 12:02 +0000, Jonathan Cameron wrote:\n" - "> On 04/02/17 13:47, Song Hongyan wrote:\n" - "> > \n" - "> > Environmental temperature sensor is a hid defined sensor,\n" - "> > it measures temperature.\n" - "> > \n" - "> > More information can be found in:\n" - "> > http://www.usb.org/developers/hidpage/HUTRR39b.pdf\n" - "> > \n" - "> > According to IIO ABI definition, IIO_TEMP data output unit is\n" - "> > milli degrees Celsius. Add the unit convert from degree to milli\n" - "> > degree.\n" - "> > \n" - "> > Signed-off-by: Song Hongyan <hongyan.song@intel.com>\n" - "> A few bits and bobs inline.\302\240\302\240Clearly I'll want Srinivas to comment on\n" - "> this\n" - "> one as well!\n" - "\n" - "\n" - "[...]\n" - "\n" - "> \n" - "+/* Capture samples in local storage */\n" - "> > +static int temperature_capture_sample(struct hid_sensor_hub_device\n" - "> > *hsdev,\n" - "> > +\t\t\t\tunsigned int usage_id,\n" - "> > +\t\t\t\tsize_t raw_len, char *raw_data,\n" - "> > +\t\t\t\tvoid *priv)\n" - "> > +{\n" - "> > +\tstruct iio_dev *indio_dev = platform_get_drvdata(priv);\n" - "> Why not make priv the indio_dev directly? I would imagine it's the\n" - "> pdev\n" - "> passed in when registering the callbacks below.\n" - "\n" - "Actually this priv can be renamed to pdev. The callback will be called\n" - "with platform_device * of the mfd device.\n" - "\n" - "> > \n" - "> > +\tstruct temperature_state *temperature_state =\n" - "> > iio_priv(indio_dev);\n" - "> > +\n" - "> > +\tswitch (usage_id) {\n" - "> > +\tcase HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_TEMPERATURE:\n" - "> > +\t\ttemperature_state->temperature_data = *(s32\n" - "> > *)raw_data;\n" - "> > +\t\treturn 0;\n" - "> > +\tdefault:\n" - "> > +\t\treturn -EINVAL;\n" - "> > +\t}\n" - "> > +}\n" - "> > \n" - "\n" - "[...]\n" - "\n" - "> > +/* Function to initialize the processing for usage id */\n" - "> > +static int hid_temperature_probe(struct platform_device *pdev)\n" - "> > +{\n" - "> > +\tstatic const char *name = \"temperature\";\n" - "> > +\tstruct iio_dev *indio_dev;\n" - "> > +\tstruct temperature_state *temperature_state;\n" - "> > +\tstruct hid_sensor_hub_device *hsdev = pdev-\n" - "> > >dev.platform_data;\n" - "> > +\tint ret;\n" - "> > +\n" - "> > +\tindio_dev = devm_iio_device_alloc(&pdev->dev,\n" - "> > +\t\t\t\tsizeof(struct temperature_state));\n" - "> > +\tif (!indio_dev)\n" - "> > +\t\treturn -ENOMEM;\n" - "> > +\n" - "> > +\ttemperature_state = iio_priv(indio_dev);\n" - "> > +\ttemperature_state->common_attributes.hsdev = hsdev;\n" - "> > +\ttemperature_state->common_attributes.pdev = pdev;\n" - "> > +\n" - "> > +\tret = hid_sensor_parse_common_attributes(hsdev,\n" - "> > +\t\t\t\t\tHID_USAGE_SENSOR_TEMPERATU\n" - "> > RE,\n" - "> > +\t\t\t\t\t&temperature_state-\n" - "> > >common_attributes);\n" - "> > +\tif (ret)\n" - "> > +\t\treturn ret;\n" - "> > +\n" - "> > +\tindio_dev->channels = devm_kmemdup(&indio_dev->dev,\n" - "> > +\t\t\t\t\ttemperature_channels,\n" - "> > +\t\t\t\t\tsizeof(temperature_channel\n" - "> > s),\n" - "> > +\t\t\t\t\tGFP_KERNEL);\n" - "> > +\tif (!indio_dev->channels)\n" - "> > +\t\treturn -ENOMEM;\n" - "> > +\n" - "> > +\tret = temperature_parse_report(pdev, hsdev,\n" - "> > +\t\t\t\t(struct iio_chan_spec *)indio_dev-\n" - "> > >channels,\n" - "> > +\t\t\t\tHID_USAGE_SENSOR_TEMPERATURE,\n" - "> > +\t\t\t\ttemperature_state);\n" - "> > +\tif (ret)\n" - "> > +\t\treturn ret;\n" - "> > +\n" - "> > +\tindio_dev->num_channels =\n" - "> > ARRAY_SIZE(temperature_channels);\n" - "> > +\tindio_dev->dev.parent = &pdev->dev;\n" - "> > +\tindio_dev->info = &temperature_info;\n" - "> > +\tindio_dev->name = name;\n" - "> > +\tindio_dev->modes = INDIO_DIRECT_MODE;\n" - "> > +\n" - "> > +\tret = iio_triggered_buffer_setup(indio_dev,\n" - "> > &iio_pollfunc_store_time,\n" - "> > +\t\t\t\t\tNULL, NULL);\n" - "> > +\tif (ret)\n" - "> > +\t\treturn ret;\n" - "> If you are going all devm (which is fine) then use\n" - "> devm_iio_triggered_buffer_setup.\n" - "> \n" - "> > \n" - "> > +\n" - "> > +\tatomic_set(&temperature_state-\n" - "> > >common_attributes.data_ready, 0);\n" - "> > +\tret = hid_sensor_setup_trigger(indio_dev, name,\n" - "> > +\t\t\t\t&temperature_state-\n" - "> > >common_attributes);\n" - "> I'd expect to see this unwound somewhere as well..\n" - "\n" - "I missed this during my review. There has to be call\n" - "to\302\240\302\240hid_sensor_remove_trigger() to do opposite.\n" - "\n" - "> > \n" - "> > +\tif (ret)\n" - "> > +\t\tgoto error_unreg_buffer_funcs;\n" - "> > +\n" - "> > +\tret = devm_iio_device_register(indio_dev->dev.parent,\n" - "> > indio_dev);\n" - "> > +\tif (ret)\n" - "> > +\t\tgoto error_unreg_buffer_funcs;\n" - "> Is there a race here in that userspace interfaces are exposed, but\n" - "> the\n" - "> hid system has no way to send answers to any queries?\n" - "Two scenarios possible:\n" - "- If somehow user space calls the raw read before the\302\240\n" - "sensor_hub_register_callback() is called, then there should not be any\n" - "issue as the\302\240sensor_hub_input_attr_get_raw_value is called with\n" - "\"SENSOR_HUB_SYNC\" so wait till response arrives or timeout. So doesn't\n" - "depend on the callback.\n" - "\n" - "- If user is activating the buffer mode before the callback us\n" - "registered, worst case it will miss event till the callback is\n" - "registered.\n" - "\n" - "But we can call\302\240sensor_hub_register_callback()\n" - "before\302\240devm_iio_device_register(), but the we need to make sure that\n" - "the\302\240sensor_hub_remove_callback() is called\n" - "if\302\240devm_iio_device_register() fails.\n" - "\n" - "> > \n" - "> > +\n" - "> > +\tplatform_set_drvdata(pdev, indio_dev);\n" - "> > +\n" - "> > +\ttemperature_state->callbacks.send_event =\n" - "> > temperature_proc_event;\n" - "> > +\ttemperature_state->callbacks.capture_sample =\n" - "> > +\t\t\t\t\t\ttemperature_captur\n" - "> > e_sample;\n" - "> > +\ttemperature_state->callbacks.pdev = pdev;\n" - "> > +\tret = sensor_hub_register_callback(hsdev,\n" - "> > HID_USAGE_SENSOR_TEMPERATURE,\n" - "> > +\t\t\t\t\t&temperature_state-\n" - "> > >callbacks);\302\240\n" - "> > +\treturn ret;\n" - "> > +\n" - "> > +error_unreg_buffer_funcs:\n" - "> > +\tiio_triggered_buffer_cleanup(indio_dev);\n" - "> > +\treturn ret;\n" - "> > +}\n" - "> > +\n" - "> > +/* Function to deinitialize the processing for usage id */\n" - "> > +static int hid_temperature_remove(struct platform_device *pdev)\n" - "> > +{\n" - "> > +\tstruct hid_sensor_hub_device *hsdev = pdev-\n" - "> > >dev.platform_data;\n" - "> > +\n" - "> > +\tsensor_hub_remove_callback(hsdev,\n" - "> > HID_USAGE_SENSOR_TEMPERATURE);\n" - "\n" - "hid_sensor_remove_trigger()\n" - "\n" - "> > +\n" - "> > +\treturn 0;\n" - "> > +}\n" - "> > +\n" - "> >\302\240\n" - "Thanks,\n" - Srinivas + "T24gU2F0LCAyMDE3LTAyLTA0IGF0IDEyOjAyICswMDAwLCBKb25hdGhhbiBDYW1lcm9uIHdyb3Rl\n" + "Og0KPiBPbiAwNC8wMi8xNyAxMzo0NywgU29uZyBIb25neWFuIHdyb3RlOg0KPiA+IA0KPiA+IEVu\n" + "dmlyb25tZW50YWwgdGVtcGVyYXR1cmUgc2Vuc29yIGlzIGEgaGlkIGRlZmluZWQgc2Vuc29yLA0K\n" + "PiA+IGl0IG1lYXN1cmVzIHRlbXBlcmF0dXJlLg0KPiA+IA0KPiA+IE1vcmUgaW5mb3JtYXRpb24g\n" + "Y2FuIGJlIGZvdW5kIGluOg0KPiA+IGh0dHA6Ly93d3cudXNiLm9yZy9kZXZlbG9wZXJzL2hpZHBh\n" + "Z2UvSFVUUlIzOWIucGRmDQo+ID4gDQo+ID4gQWNjb3JkaW5nIHRvIElJTyBBQkkgZGVmaW5pdGlv\n" + "biwgSUlPX1RFTVAgZGF0YSBvdXRwdXQgdW5pdCBpcw0KPiA+IG1pbGxpIGRlZ3JlZXMgQ2Vsc2l1\n" + "cy4gQWRkIHRoZSB1bml0IGNvbnZlcnQgZnJvbSBkZWdyZWUgdG8gbWlsbGkNCj4gPiBkZWdyZWUu\n" + "DQo+ID4gDQo+ID4gU2lnbmVkLW9mZi1ieTogU29uZyBIb25neWFuIDxob25neWFuLnNvbmdAaW50\n" + "ZWwuY29tPg0KPiBBIGZldyBiaXRzIGFuZCBib2JzIGlubGluZS7CoMKgQ2xlYXJseSBJJ2xsIHdh\n" + "bnQgU3Jpbml2YXMgdG8gY29tbWVudCBvbg0KPiB0aGlzDQo+IG9uZSBhcyB3ZWxsIQ0KDQoNClsu\n" + "Li5dDQoNCj4gDQorLyogQ2FwdHVyZSBzYW1wbGVzIGluIGxvY2FsIHN0b3JhZ2UgKi8NCj4gPiAr\n" + "c3RhdGljIGludCB0ZW1wZXJhdHVyZV9jYXB0dXJlX3NhbXBsZShzdHJ1Y3QgaGlkX3NlbnNvcl9o\n" + "dWJfZGV2aWNlDQo+ID4gKmhzZGV2LA0KPiA+ICsJCQkJdW5zaWduZWQgaW50IHVzYWdlX2lkLA0K\n" + "PiA+ICsJCQkJc2l6ZV90IHJhd19sZW4sIGNoYXIgKnJhd19kYXRhLA0KPiA+ICsJCQkJdm9pZCAq\n" + "cHJpdikNCj4gPiArew0KPiA+ICsJc3RydWN0IGlpb19kZXYgKmluZGlvX2RldiA9IHBsYXRmb3Jt\n" + "X2dldF9kcnZkYXRhKHByaXYpOw0KPiBXaHkgbm90IG1ha2UgcHJpdiB0aGUgaW5kaW9fZGV2IGRp\n" + "cmVjdGx5PyBJIHdvdWxkIGltYWdpbmUgaXQncyB0aGUNCj4gcGRldg0KPiBwYXNzZWQgaW4gd2hl\n" + "biByZWdpc3RlcmluZyB0aGUgY2FsbGJhY2tzIGJlbG93Lg0KDQpBY3R1YWxseSB0aGlzIHByaXYg\n" + "Y2FuIGJlIHJlbmFtZWQgdG8gcGRldi4gVGhlIGNhbGxiYWNrIHdpbGwgYmUgY2FsbGVkDQp3aXRo\n" + "IHBsYXRmb3JtX2RldmljZSAqIG9mIHRoZSBtZmQgZGV2aWNlLg0KDQo+ID4gDQo+ID4gKwlzdHJ1\n" + "Y3QgdGVtcGVyYXR1cmVfc3RhdGUgKnRlbXBlcmF0dXJlX3N0YXRlID0NCj4gPiBpaW9fcHJpdihp\n" + "bmRpb19kZXYpOw0KPiA+ICsNCj4gPiArCXN3aXRjaCAodXNhZ2VfaWQpIHsNCj4gPiArCWNhc2Ug\n" + "SElEX1VTQUdFX1NFTlNPUl9EQVRBX0VOVklST05NRU5UQUxfVEVNUEVSQVRVUkU6DQo+ID4gKwkJ\n" + "dGVtcGVyYXR1cmVfc3RhdGUtPnRlbXBlcmF0dXJlX2RhdGEgPSAqKHMzMg0KPiA+ICopcmF3X2Rh\n" + "dGE7DQo+ID4gKwkJcmV0dXJuIDA7DQo+ID4gKwlkZWZhdWx0Og0KPiA+ICsJCXJldHVybiAtRUlO\n" + "VkFMOw0KPiA+ICsJfQ0KPiA+ICt9DQo+ID4gDQoNClsuLi5dDQoNCj4gPiArLyogRnVuY3Rpb24g\n" + "dG8gaW5pdGlhbGl6ZSB0aGUgcHJvY2Vzc2luZyBmb3IgdXNhZ2UgaWQgKi8NCj4gPiArc3RhdGlj\n" + "IGludCBoaWRfdGVtcGVyYXR1cmVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikN\n" + "Cj4gPiArew0KPiA+ICsJc3RhdGljIGNvbnN0IGNoYXIgKm5hbWUgPSAidGVtcGVyYXR1cmUiOw0K\n" + "PiA+ICsJc3RydWN0IGlpb19kZXYgKmluZGlvX2RldjsNCj4gPiArCXN0cnVjdCB0ZW1wZXJhdHVy\n" + "ZV9zdGF0ZSAqdGVtcGVyYXR1cmVfc3RhdGU7DQo+ID4gKwlzdHJ1Y3QgaGlkX3NlbnNvcl9odWJf\n" + "ZGV2aWNlICpoc2RldiA9IHBkZXYtDQo+ID4gPmRldi5wbGF0Zm9ybV9kYXRhOw0KPiA+ICsJaW50\n" + "IHJldDsNCj4gPiArDQo+ID4gKwlpbmRpb19kZXYgPSBkZXZtX2lpb19kZXZpY2VfYWxsb2MoJnBk\n" + "ZXYtPmRldiwNCj4gPiArCQkJCXNpemVvZihzdHJ1Y3QgdGVtcGVyYXR1cmVfc3RhdGUpKTsNCj4g\n" + "PiArCWlmICghaW5kaW9fZGV2KQ0KPiA+ICsJCXJldHVybiAtRU5PTUVNOw0KPiA+ICsNCj4gPiAr\n" + "CXRlbXBlcmF0dXJlX3N0YXRlID0gaWlvX3ByaXYoaW5kaW9fZGV2KTsNCj4gPiArCXRlbXBlcmF0\n" + "dXJlX3N0YXRlLT5jb21tb25fYXR0cmlidXRlcy5oc2RldiA9IGhzZGV2Ow0KPiA+ICsJdGVtcGVy\n" + "YXR1cmVfc3RhdGUtPmNvbW1vbl9hdHRyaWJ1dGVzLnBkZXYgPSBwZGV2Ow0KPiA+ICsNCj4gPiAr\n" + "CXJldCA9IGhpZF9zZW5zb3JfcGFyc2VfY29tbW9uX2F0dHJpYnV0ZXMoaHNkZXYsDQo+ID4gKwkJ\n" + "CQkJSElEX1VTQUdFX1NFTlNPUl9URU1QRVJBVFUNCj4gPiBSRSwNCj4gPiArCQkJCQkmdGVtcGVy\n" + "YXR1cmVfc3RhdGUtDQo+ID4gPmNvbW1vbl9hdHRyaWJ1dGVzKTsNCj4gPiArCWlmIChyZXQpDQo+\n" + "ID4gKwkJcmV0dXJuIHJldDsNCj4gPiArDQo+ID4gKwlpbmRpb19kZXYtPmNoYW5uZWxzID0gZGV2\n" + "bV9rbWVtZHVwKCZpbmRpb19kZXYtPmRldiwNCj4gPiArCQkJCQl0ZW1wZXJhdHVyZV9jaGFubmVs\n" + "cywNCj4gPiArCQkJCQlzaXplb2YodGVtcGVyYXR1cmVfY2hhbm5lbA0KPiA+IHMpLA0KPiA+ICsJ\n" + "CQkJCUdGUF9LRVJORUwpOw0KPiA+ICsJaWYgKCFpbmRpb19kZXYtPmNoYW5uZWxzKQ0KPiA+ICsJ\n" + "CXJldHVybiAtRU5PTUVNOw0KPiA+ICsNCj4gPiArCXJldCA9IHRlbXBlcmF0dXJlX3BhcnNlX3Jl\n" + "cG9ydChwZGV2LCBoc2RldiwNCj4gPiArCQkJCShzdHJ1Y3QgaWlvX2NoYW5fc3BlYyAqKWluZGlv\n" + "X2Rldi0NCj4gPiA+Y2hhbm5lbHMsDQo+ID4gKwkJCQlISURfVVNBR0VfU0VOU09SX1RFTVBFUkFU\n" + "VVJFLA0KPiA+ICsJCQkJdGVtcGVyYXR1cmVfc3RhdGUpOw0KPiA+ICsJaWYgKHJldCkNCj4gPiAr\n" + "CQlyZXR1cm4gcmV0Ow0KPiA+ICsNCj4gPiArCWluZGlvX2Rldi0+bnVtX2NoYW5uZWxzID0NCj4g\n" + "PiBBUlJBWV9TSVpFKHRlbXBlcmF0dXJlX2NoYW5uZWxzKTsNCj4gPiArCWluZGlvX2Rldi0+ZGV2\n" + "LnBhcmVudCA9ICZwZGV2LT5kZXY7DQo+ID4gKwlpbmRpb19kZXYtPmluZm8gPSAmdGVtcGVyYXR1\n" + "cmVfaW5mbzsNCj4gPiArCWluZGlvX2Rldi0+bmFtZSA9IG5hbWU7DQo+ID4gKwlpbmRpb19kZXYt\n" + "Pm1vZGVzID0gSU5ESU9fRElSRUNUX01PREU7DQo+ID4gKw0KPiA+ICsJcmV0ID0gaWlvX3RyaWdn\n" + "ZXJlZF9idWZmZXJfc2V0dXAoaW5kaW9fZGV2LA0KPiA+ICZpaW9fcG9sbGZ1bmNfc3RvcmVfdGlt\n" + "ZSwNCj4gPiArCQkJCQlOVUxMLCBOVUxMKTsNCj4gPiArCWlmIChyZXQpDQo+ID4gKwkJcmV0dXJu\n" + "IHJldDsNCj4gSWYgeW91IGFyZSBnb2luZyBhbGwgZGV2bSAod2hpY2ggaXMgZmluZSkgdGhlbiB1\n" + "c2UNCj4gZGV2bV9paW9fdHJpZ2dlcmVkX2J1ZmZlcl9zZXR1cC4NCj4gDQo+ID4gDQo+ID4gKw0K\n" + "PiA+ICsJYXRvbWljX3NldCgmdGVtcGVyYXR1cmVfc3RhdGUtDQo+ID4gPmNvbW1vbl9hdHRyaWJ1\n" + "dGVzLmRhdGFfcmVhZHksIDApOw0KPiA+ICsJcmV0ID0gaGlkX3NlbnNvcl9zZXR1cF90cmlnZ2Vy\n" + "KGluZGlvX2RldiwgbmFtZSwNCj4gPiArCQkJCSZ0ZW1wZXJhdHVyZV9zdGF0ZS0NCj4gPiA+Y29t\n" + "bW9uX2F0dHJpYnV0ZXMpOw0KPiBJJ2QgZXhwZWN0IHRvIHNlZSB0aGlzIHVud291bmQgc29tZXdo\n" + "ZXJlIGFzIHdlbGwuLg0KDQpJIG1pc3NlZCB0aGlzIGR1cmluZyBteSByZXZpZXcuIFRoZXJlIGhh\n" + "cyB0byBiZSBjYWxsDQp0b8KgwqBoaWRfc2Vuc29yX3JlbW92ZV90cmlnZ2VyKCkgdG8gZG8gb3Bw\n" + "b3NpdGUuDQoNCj4gPiANCj4gPiArCWlmIChyZXQpDQo+ID4gKwkJZ290byBlcnJvcl91bnJlZ19i\n" + "dWZmZXJfZnVuY3M7DQo+ID4gKw0KPiA+ICsJcmV0ID0gZGV2bV9paW9fZGV2aWNlX3JlZ2lzdGVy\n" + "KGluZGlvX2Rldi0+ZGV2LnBhcmVudCwNCj4gPiBpbmRpb19kZXYpOw0KPiA+ICsJaWYgKHJldCkN\n" + "Cj4gPiArCQlnb3RvIGVycm9yX3VucmVnX2J1ZmZlcl9mdW5jczsNCj4gSXMgdGhlcmUgYSByYWNl\n" + "IGhlcmUgaW4gdGhhdCB1c2Vyc3BhY2UgaW50ZXJmYWNlcyBhcmUgZXhwb3NlZCwgYnV0DQo+IHRo\n" + "ZQ0KPiBoaWQgc3lzdGVtIGhhcyBubyB3YXkgdG8gc2VuZCBhbnN3ZXJzIHRvIGFueSBxdWVyaWVz\n" + "Pw0KVHdvIHNjZW5hcmlvcyBwb3NzaWJsZToNCi0gSWYgc29tZWhvdyB1c2VyIHNwYWNlIGNhbGxz\n" + "IHRoZSByYXcgcmVhZCBiZWZvcmUgdGhlwqANCnNlbnNvcl9odWJfcmVnaXN0ZXJfY2FsbGJhY2so\n" + "KSBpcyBjYWxsZWQsIHRoZW4gdGhlcmUgc2hvdWxkIG5vdCBiZSBhbnkNCmlzc3VlIGFzIHRoZcKg\n" + "c2Vuc29yX2h1Yl9pbnB1dF9hdHRyX2dldF9yYXdfdmFsdWUgaXMgY2FsbGVkIHdpdGgNCiJTRU5T\n" + "T1JfSFVCX1NZTkMiIHNvIHdhaXQgdGlsbCByZXNwb25zZSBhcnJpdmVzIG9yIHRpbWVvdXQuIFNv\n" + "IGRvZXNuJ3QNCmRlcGVuZCBvbiB0aGUgY2FsbGJhY2suDQoNCi0gSWYgdXNlciBpcyBhY3RpdmF0\n" + "aW5nIHRoZSBidWZmZXIgbW9kZSBiZWZvcmUgdGhlIGNhbGxiYWNrIHVzDQpyZWdpc3RlcmVkLCB3\n" + "b3JzdCBjYXNlIGl0IHdpbGwgbWlzcyBldmVudCB0aWxsIHRoZSBjYWxsYmFjayBpcw0KcmVnaXN0\n" + "ZXJlZC4NCg0KQnV0IHdlIGNhbiBjYWxswqBzZW5zb3JfaHViX3JlZ2lzdGVyX2NhbGxiYWNrKCkN\n" + "CmJlZm9yZcKgZGV2bV9paW9fZGV2aWNlX3JlZ2lzdGVyKCksIGJ1dCB0aGUgd2UgbmVlZCB0byBt\n" + "YWtlIHN1cmUgdGhhdA0KdGhlwqBzZW5zb3JfaHViX3JlbW92ZV9jYWxsYmFjaygpIGlzIGNhbGxl\n" + "ZA0KaWbCoGRldm1faWlvX2RldmljZV9yZWdpc3RlcigpIGZhaWxzLg0KDQo+ID4gDQo+ID4gKw0K\n" + "PiA+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaW5kaW9fZGV2KTsNCj4gPiArDQo+ID4g\n" + "Kwl0ZW1wZXJhdHVyZV9zdGF0ZS0+Y2FsbGJhY2tzLnNlbmRfZXZlbnQgPQ0KPiA+IHRlbXBlcmF0\n" + "dXJlX3Byb2NfZXZlbnQ7DQo+ID4gKwl0ZW1wZXJhdHVyZV9zdGF0ZS0+Y2FsbGJhY2tzLmNhcHR1\n" + "cmVfc2FtcGxlID0NCj4gPiArCQkJCQkJdGVtcGVyYXR1cmVfY2FwdHVyDQo+ID4gZV9zYW1wbGU7\n" + "DQo+ID4gKwl0ZW1wZXJhdHVyZV9zdGF0ZS0+Y2FsbGJhY2tzLnBkZXYgPSBwZGV2Ow0KPiA+ICsJ\n" + "cmV0ID0gc2Vuc29yX2h1Yl9yZWdpc3Rlcl9jYWxsYmFjayhoc2RldiwNCj4gPiBISURfVVNBR0Vf\n" + "U0VOU09SX1RFTVBFUkFUVVJFLA0KPiA+ICsJCQkJCSZ0ZW1wZXJhdHVyZV9zdGF0ZS0NCj4gPiA+\n" + "Y2FsbGJhY2tzKTvCoA0KPiA+ICsJcmV0dXJuIHJldDsNCj4gPiArDQo+ID4gK2Vycm9yX3VucmVn\n" + "X2J1ZmZlcl9mdW5jczoNCj4gPiArCWlpb190cmlnZ2VyZWRfYnVmZmVyX2NsZWFudXAoaW5kaW9f\n" + "ZGV2KTsNCj4gPiArCXJldHVybiByZXQ7DQo+ID4gK30NCj4gPiArDQo+ID4gKy8qIEZ1bmN0aW9u\n" + "IHRvIGRlaW5pdGlhbGl6ZSB0aGUgcHJvY2Vzc2luZyBmb3IgdXNhZ2UgaWQgKi8NCj4gPiArc3Rh\n" + "dGljIGludCBoaWRfdGVtcGVyYXR1cmVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk\n" + "ZXYpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBoaWRfc2Vuc29yX2h1Yl9kZXZpY2UgKmhzZGV2ID0g\n" + "cGRldi0NCj4gPiA+ZGV2LnBsYXRmb3JtX2RhdGE7DQo+ID4gKw0KPiA+ICsJc2Vuc29yX2h1Yl9y\n" + "ZW1vdmVfY2FsbGJhY2soaHNkZXYsDQo+ID4gSElEX1VTQUdFX1NFTlNPUl9URU1QRVJBVFVSRSk7\n" + "DQoNCmhpZF9zZW5zb3JfcmVtb3ZlX3RyaWdnZXIoKQ0KDQo+ID4gKw0KPiA+ICsJcmV0dXJuIDA7\n" + DQo+ID4gK30NCj4gPiArDQo+ID7CoA0KVGhhbmtzLA0KU3Jpbml2YXM= -b728fd05e3a75d325934d08ce0392c30716f0de26b997461c5d153433d8321d7 +d1efb78c6e1fc0acb94f5b1e8fae273f909cca16f1a55e301d3559ccf07bd76b
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.