From mboxrd@z Thu Jan 1 00:00:00 1970 From: khali@linux-fr.org (Jean Delvare) Date: Thu, 19 May 2005 06:24:29 +0000 Subject: [PATCH 2.4] i2c cleanups (3/4) Message-Id: <20031213203116.5149d233.khali@linux-fr.org> List-Id: References: <20031213191258.2d78a9f7.khali@linux-fr.org> In-Reply-To: <20031213191258.2d78a9f7.khali@linux-fr.org> MIME-Version: 1.0 Content-Type: text/plain; charset="macroman" Content-Transfer-Encoding: base64 To: Marcelo Tosatti Cc: LKML , LM Sensors VGhpcyBwYXRjaCBmaXhlcyBtYW55ICgxMjIpIHByaW50ayBjYWxscyBtaXNzaW5nIHRoZWlyIEtF Uk5fKiBjb25zdGFudC4KVGhlcmUgYWxzbyBhcmUgc29tZSBvdGhlciB0cml2aWFsIGZpeGVzIHRo YXQgd2VyZSBwYXNzaW5nIGJ5CihpbmRlbnRhdGlvbiBjaGFuZ2VzIGFuZCBzdHJpbmcgY2hhbmdl cykuCgpQbGVhc2UgYXBwbHkuCgpkaWZmIC1ydU4gbGludXgtMi40LjI0LXByZTEvZHJpdmVycy9p MmMvaTJjLWFsZ28tYml0LmMgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtYWxn by1iaXQuYwotLS0gbGludXgtMi40LjI0LXByZTEvZHJpdmVycy9pMmMvaTJjLWFsZ28tYml0LmMJ TW9uIEF1ZyAyNSAxMzo0NDo0MSAyMDAzCisrKyBsaW51eC0yLjQuMjQtcHJlMS1rL2RyaXZlcnMv aTJjL2kyYy1hbGdvLWJpdC5jCVNhdCBEZWMgMTMgMTU6NDE6NTcgMjAwMwpAQCAtMTIzLDcgKzEy Myw3IEBACiAJCWlmIChjdXJyZW50LT5uZWVkX3Jlc2NoZWQpCiAJCQlzY2hlZHVsZSgpOwogCX0K LQlERUJTVEFUKHByaW50aygibmVlZGVkICVsZCBqaWZmaWVzXG4iLCBqaWZmaWVzLXN0YXJ0KSk7 CisJREVCU1RBVChwcmludGsoS0VSTl9ERUJVRyAibmVlZGVkICVsZCBqaWZmaWVzXG4iLCBqaWZm aWVzLXN0YXJ0KSk7CiAjaWZkZWYgU0xPX0lPCiAJU0xPX0lPCiAjZW5kaWYKQEAgLTE3OSwxMiAr MTc5LDEyIEBACiAJc3RydWN0IGkyY19hbGdvX2JpdF9kYXRhICphZGFwID0gaTJjX2FkYXAtPmFs Z29fZGF0YTsKIAogCS8qIGFzc2VydDogc2NsIGlzIGxvdyAqLwotCURFQjIocHJpbnRrKCIgaTJj X291dGI6JTIuMlhcbiIsYyYweGZmKSk7CisJREVCMihwcmludGsoS0VSTl9ERUJVRyAiIGkyY19v dXRiOiUyLjJYXG4iLGMmMHhmZikpOwogCWZvciAoIGk9NyA7IGk+PTAgOyBpLS0gKSB7CiAJCXNi ID0gYyAmICggMSA8PCBpICk7CiAJCXNldHNkYShhZGFwLHNiKTsKIAkJdWRlbGF5KGFkYXAtPnVk ZWxheSk7Ci0JCURFQlBST1RPKHByaW50aygiJWQiLHNiIT0wKSk7CisJCURFQlBST1RPKHByaW50 ayhLRVJOX0RFQlVHICIlZCIsc2IhPTApKTsKIAkJaWYgKHNjbGhpKGFkYXApPDApIHsgLyogdGlt ZWQgb3V0ICovCiAJCQlzZGFoaShhZGFwKTsgLyogd2UgZG9uJ3Qgd2FudCB0byBibG9jayB0aGUg bmV0ICovCiAJCQlyZXR1cm4gLUVUSU1FRE9VVDsKQEAgLTIwMSwxMCArMjAxLDEwIEBACiAJfTsK IAkvKiByZWFkIGFjazogU0RBIHNob3VsZCBiZSBwdWxsZWQgZG93biBieSBzbGF2ZSAqLwogCWFj az1nZXRzZGEoYWRhcCk7CS8qIGFjazogc2RhIGlzIHB1bGxlZCBsb3cgLT5zdWNjZXNzLgkgKi8K LQlERUIyKHByaW50aygiIGkyY19vdXRiOiBnZXRzZGEoKSA9ICAweCUyLjJ4XG4iLCB+YWNrICkp OworCURFQjIocHJpbnRrKEtFUk5fREVCVUcgIiBpMmNfb3V0YjogZ2V0c2RhKCkgPSAgMHglMi4y eFxuIiwgfmFjayApKTsKIAotCURFQlBST1RPKCBwcmludGsoIlslMi4yeF0iLGMmMHhmZikgKTsK LQlERUJQUk9UTyhpZiAoMD1hY2speyBwcmludGsoIiBBICIpO30gZWxzZSBwcmludGsoIiBOQSAi KSApOworCURFQlBST1RPKCBwcmludGsoS0VSTl9ERUJVRyAiWyUyLjJ4XSIsYyYweGZmKSApOwor CURFQlBST1RPKGlmICgwPWFjayl7IHByaW50ayhLRVJOX0RFQlVHICIgQSAiKTt9IGVsc2UgcHJp bnRrKEtFUk5fREVCVUcgIiBOQSAiKSApOwogCXNjbGxvKGFkYXApOwogCXJldHVybiAwPWFjazsJ CS8qIHJldHVybiAxIGlmIGRldmljZSBhY2tlZAkgKi8KIAkvKiBhc3NlcnQ6IHNjbCBpcyBsb3cg KHNkYSB1bmRlZikgKi8KQEAgLTIyMCw3ICsyMjAsNyBAQAogCXN0cnVjdCBpMmNfYWxnb19iaXRf ZGF0YSAqYWRhcCA9IGkyY19hZGFwLT5hbGdvX2RhdGE7CiAKIAkvKiBhc3NlcnQ6IHNjbCBpcyBs b3cgKi8KLQlERUIyKHByaW50aygiaTJjX2luYi5cbiIpKTsKKwlERUIyKHByaW50ayhLRVJOX0RF QlVHICJpMmNfaW5iLlxuIikpOwogCiAJc2RhaGkoYWRhcCk7CiAJZm9yIChpPTA7aTw4O2krKykg ewpAQCAtMjMzLDcgKzIzMyw3IEBACiAJCXNjbGxvKGFkYXApOwogCX0KIAkvKiBhc3NlcnQ6IHNj bCBpcyBsb3cgKi8KLQlERUJQUk9UTyhwcmludGsoIiAlMi4yeCIsIGluZGF0YSAmIDB4ZmYpKTsK KwlERUJQUk9UTyhwcmludGsoS0VSTl9ERUJVRyAiIDB4JTAyeCIsIGluZGF0YSAmIDB4ZmYpKTsK IAlyZXR1cm4gKGludCkgKGluZGF0YSAmIDB4ZmYpOwogfQogCkBAIC0zNDEsNyArMzQxLDcgQEAK IAkJaTJjX3N0YXJ0KGFkYXApOwogCQl1ZGVsYXkoYWRhcC0+dWRlbGF5KTsKIAl9Ci0JREVCMihp ZiAoaSkgcHJpbnRrKCJpMmMtYWxnby1iaXQubzogbmVlZGVkICVkIHJldHJpZXMgZm9yICVkXG4i LAorCURFQjIoaWYgKGkpIHByaW50ayhLRVJOX0RFQlVHICJpMmMtYWxnby1iaXQubzogbmVlZGVk ICVkIHJldHJpZXMgZm9yICVkXG4iLAogCSAgICAgICAgICAgICAgICAgICBpLGFkZHIpKTsKIAly ZXR1cm4gcmV0OwogfQpAQCAtMzU2LDcgKzM1Niw3IEBACiAKIAl3aGlsZSAoY291bnQgPiAwKSB7 CiAJCWMgPSAqdGVtcDsKLQkJREVCMihwcmludGsoImkyYy1hbGdvLWJpdC5vOiAlcyBpMmNfd3Jp dGU6IHdyaXRpbmcgJTIuMlhcbiIsCisJCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImkyYy1hbGdv LWJpdC5vOiAlcyBzZW5kYnl0ZXM6IHdyaXRpbmcgJTIuMlhcbiIsCiAJCQkgICAgaTJjX2FkYXAt Pm5hbWUsIGMmMHhmZikpOwogCQlyZXR2YWwgPSBpMmNfb3V0YihpMmNfYWRhcCxjKTsKIAkJaWYg KHJldHZhbD4wKSB7CkBAIC0zNjQsNyArMzY0LDcgQEAKIAkJCXRlbXArKzsKIAkJCXdyY291bnQr KzsKIAkJfSBlbHNlIHsgLyogYXJiaXRyYXRpb24gb3Igbm8gYWNrbm93bGVkZ2UgKi8KLQkJCXBy aW50aygiaTJjLWFsZ28tYml0Lm86ICVzIGkyY193cml0ZTogZXJyb3IgLSBiYWlsb3V0LlxuIiwK KwkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28tYml0Lm86ICVzIHNlbmRieXRlczogZXJyb3Ig LSBiYWlsb3V0LlxuIiwKIAkJCSAgICAgICBpMmNfYWRhcC0+bmFtZSk7CiAJCQlpMmNfc3RvcChh ZGFwKTsKIAkJCXJldHVybiAocmV0dmFsPDApPyByZXR2YWwgOiAtRUZBVUxUOwpAQCAtMzkyLDcg KzM5Miw3IEBACiAJCQkqdGVtcCA9IGludmFsOwogCQkJcmRjb3VudCsrOwogCQl9IGVsc2UgeyAg IC8qIHJlYWQgdGltZWQgb3V0ICovCi0JCQlwcmludGsoImkyYy1hbGdvLWJpdC5vOiBpMmNfcmVh ZDogaTJjX2luYiB0aW1lZCBvdXQuXG4iKTsKKwkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28t Yml0Lm86IHJlYWRieXRlczogaTJjX2luYiB0aW1lZCBvdXQuXG4iKTsKIAkJCWJyZWFrOwogCQl9 CiAKQEAgLTQwNSw3ICs0MDUsNyBAQAogCQl9CiAJCWlmIChzY2xoaShhZGFwKTwwKSB7CS8qIHRp bWVvdXQgKi8KIAkJCXNkYWhpKGFkYXApOwotCQkJcHJpbnRrKCJpMmMtYWxnby1iaXQubzogaTJj X3JlYWQ6IFRpbWVvdXQgYXQgYWNrXG4iKTsKKwkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28t Yml0Lm86IHJlYWRieXRlczogVGltZW91dCBhdCBhY2tcbiIpOwogCQkJcmV0dXJuIC1FVElNRURP VVQ7CiAJCX07CiAJCXNjbGxvKGFkYXApOwpAQCAtNDM1LDE4ICs0MzUsMTggQEAKIAlpZiAoIChm bGFncyAmIEkyQ19NX1RFTikgICkgeyAKIAkJLyogYSB0ZW4gYml0IGFkZHJlc3MgKi8KIAkJYWRk ciA9IDB4ZjAgfCAoKCBtc2ctPmFkZHIgPj4gNykgJiAweDAzKTsKLQkJREVCMihwcmludGsoImFk ZHIwOiAlZFxuIixhZGRyKSk7CisJCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImFkZHIwOiAlZFxu IixhZGRyKSk7CiAJCS8qIHRyeSBleHRlbmRlZCBhZGRyZXNzIGNvZGUuLi4qLwogCQlyZXQgPSB0 cnlfYWRkcmVzcyhpMmNfYWRhcCwgYWRkciwgcmV0cmllcyk7CiAJCWlmIChyZXQhPTEpIHsKLQkJ CXByaW50aygiZGllZCBhdCBleHRlbmRlZCBhZGRyZXNzIGNvZGUuXG4iKTsKKwkJCXByaW50ayhL RVJOX0VSUiAiZGllZCBhdCBleHRlbmRlZCBhZGRyZXNzIGNvZGUuXG4iKTsKIAkJCXJldHVybiAt RVJFTU9URUlPOwogCQl9CiAJCS8qIHRoZSByZW1haW5pbmcgOCBiaXQgYWRkcmVzcyAqLwogCQly ZXQgPSBpMmNfb3V0YihpMmNfYWRhcCxtc2ctPmFkZHIgJiAweDdmKTsKIAkJaWYgKHJldCAhPSAx KSB7CiAJCQkvKiB0aGUgY2hpcCBkaWQgbm90IGFjayAvIHhtaXNzaW9uIGVycm9yIG9jY3VycmVk ICovCi0JCQlwcmludGsoImRpZWQgYXQgMm5kIGFkZHJlc3MgY29kZS5cbiIpOworCQkJcHJpbnRr KEtFUk5fRVJSICJkaWVkIGF0IDJuZCBhZGRyZXNzIGNvZGUuXG4iKTsKIAkJCXJldHVybiAtRVJF TU9URUlPOwogCQl9CiAJCWlmICggZmxhZ3MgJiBJMkNfTV9SRCApIHsKQEAgLTQ1NSw3ICs0NTUs NyBAQAogCQkJYWRkciB8PSAweDAxOwogCQkJcmV0ID0gdHJ5X2FkZHJlc3MoaTJjX2FkYXAsIGFk ZHIsIHJldHJpZXMpOwogCQkJaWYgKHJldCE9MSkgewotCQkJCXByaW50aygiZGllZCBhdCBleHRl bmRlZCBhZGRyZXNzIGNvZGUuXG4iKTsKKwkJCQlwcmludGsoS0VSTl9FUlIgImRpZWQgYXQgZXh0 ZW5kZWQgYWRkcmVzcyBjb2RlLlxuIik7CiAJCQkJcmV0dXJuIC1FUkVNT1RFSU87CiAJCQl9CiAJ CX0KQEAgLTQ5MCwyMiArNDkwLDIyIEBACiAJCQl9CiAJCQlyZXQgPSBiaXRfZG9BZGRyZXNzKGky Y19hZGFwLHBtc2csaTJjX2FkYXAtPnJldHJpZXMpOwogCQkJaWYgKHJldCAhPSAwKSB7Ci0JCQkJ REVCMihwcmludGsoImkyYy1hbGdvLWJpdC5vOiBOQUsgZnJvbSBkZXZpY2UgYWRyICUjMnggbXNn ICMlZFxuIgotCQkJCSAgICAgICAsbXNnc1tpXS5hZGRyLGkpKTsKKwkJCQlERUIyKHByaW50ayhL RVJOX0RFQlVHICJpMmMtYWxnby1iaXQubzogTkFLIGZyb20gZGV2aWNlIGFkZHIgJTIuMnggbXNn ICMlZFxuIiwKKwkJCQkJbXNnc1tpXS5hZGRyLGkpKTsKIAkJCQlyZXR1cm4gKHJldDwwKSA/IHJl dCA6IC1FUkVNT1RFSU87CiAJCQl9CiAJCX0KIAkJaWYgKHBtc2ctPmZsYWdzICYgSTJDX01fUkQg KSB7CiAJCQkvKiByZWFkIGJ5dGVzIGludG8gYnVmZmVyKi8KIAkJCXJldCA9IHJlYWRieXRlcyhp MmNfYWRhcCxwbXNnLT5idWYscG1zZy0+bGVuKTsKLQkJCURFQjIocHJpbnRrKCJpMmMtYWxnby1i aXQubzogcmVhZCAlZCBieXRlcy5cbiIscmV0KSk7CisJCQlERUIyKHByaW50ayhLRVJOX0RFQlVH ICJpMmMtYWxnby1iaXQubzogcmVhZCAlZCBieXRlcy5cbiIscmV0KSk7CiAJCQlpZiAocmV0IDwg cG1zZy0+bGVuICkgewogCQkJCXJldHVybiAocmV0PDApPyByZXQgOiAtRVJFTU9URUlPOwogCQkJ fQogCQl9IGVsc2UgewogCQkJLyogd3JpdGUgYnl0ZXMgZnJvbSBidWZmZXIgKi8KIAkJCXJldCA9 IHNlbmRieXRlcyhpMmNfYWRhcCxwbXNnLT5idWYscG1zZy0+bGVuKTsKLQkJCURFQjIocHJpbnRr KCJpMmMtYWxnby1iaXQubzogd3JvdGUgJWQgYnl0ZXMuXG4iLHJldCkpOworCQkJREVCMihwcmlu dGsoS0VSTl9ERUJVRyAiaTJjLWFsZ28tYml0Lm86IHdyb3RlICVkIGJ5dGVzLlxuIixyZXQpKTsK IAkJCWlmIChyZXQgPCBwbXNnLT5sZW4gKSB7CiAJCQkJcmV0dXJuIChyZXQ8MCkgPyByZXQgOiAt RVJFTU9URUlPOwogCQkJfQpAQCAtNTU1LDcgKzU1NSw3IEBACiAJCQlyZXR1cm4gLUVOT0RFVjsK IAl9CiAKLQlERUIyKHByaW50aygiaTJjLWFsZ28tYml0Lm86IGh3IHJvdXRpbmVzIGZvciAlcyBy ZWdpc3RlcmVkLlxuIiwKKwlERUIyKHByaW50ayhLRVJOX0RFQlVHICJpMmMtYWxnby1iaXQubzog aHcgcm91dGluZXMgZm9yICVzIHJlZ2lzdGVyZWQuXG4iLAogCSAgICAgICAgICAgIGFkYXAtPm5h bWUpKTsKIAogCS8qIHJlZ2lzdGVyIG5ldyBhZGFwdGVyIHRvIGkyYyBtb2R1bGUuLi4gKi8KZGlm ZiAtcnVOIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy1hbGdvLXBjZi5jIGxpbnV4 LTIuNC4yNC1wcmUxLWsvZHJpdmVycy9pMmMvaTJjLWFsZ28tcGNmLmMKLS0tIGxpbnV4LTIuNC4y NC1wcmUxL2RyaXZlcnMvaTJjL2kyYy1hbGdvLXBjZi5jCVRodSBPY3QgMTEgMTc6MDU6NDcgMjAw MQorKysgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtYWxnby1wY2YuYwlUaHUg RGVjIDExIDIyOjI1OjQyIDIwMDMKQEAgLTk5LDcgKzk5LDcgQEAKIAl9CiAjZW5kaWYKIAlpZiAo dGltZW91dCA8PSAwKSB7Ci0JCXByaW50aygiVGltZW91dCB3YWl0aW5nIGZvciBCdXMgQnVzeVxu Iik7CisJCXByaW50ayhLRVJOX0VSUiAiVGltZW91dCB3YWl0aW5nIGZvciBCdXMgQnVzeVxuIik7 CiAJfQogCQogCXJldHVybiAodGltZW91dDw9MCk7CkBAIC0xNDQsNyArMTQ0LDcgQEAKIHsKIAl1 bnNpZ25lZCBjaGFyIHRlbXA7CiAKLQlERUIzKHByaW50aygiaTJjLWFsZ28tcGNmLm86IFBDRiBz dGF0ZSAweCUwMnhcbiIsIGdldF9wY2YoYWRhcCwgMSkpKTsKKwlERUIzKHByaW50ayhLRVJOX0RF QlVHICJpMmMtYWxnby1wY2YubzogUENGIHN0YXRlIDB4JTAyeFxuIiwgZ2V0X3BjZihhZGFwLCAx KSkpOwogCiAJLyogUzE9MHg4MDogUzAgc2VsZWN0ZWQsIHNlcmlhbCBpbnRlcmZhY2Ugb2ZmICov CiAJc2V0X3BjZihhZGFwLCAxLCBJMkNfUENGX1BJTik7CkBAIC0xNTIsNyArMTUyLDcgQEAKIAkg ICBQQ0Y4NTg0IGRvZXMgdGhhdCB3aGVuIEVTTyBpcyB6ZXJvICovCiAJLyogUENGIGFsc28gcmVz ZXRzIFBJTiBiaXQgKi8KIAlpZiAoKHRlbXAgPSBnZXRfcGNmKGFkYXAsIDEpKSAhPSAoMCkpIHsK LQkJREVCMihwcmludGsoImkyYy1hbGdvLXBjZi5vOiBQQ0YgZGV0ZWN0aW9uIGZhaWxlZCAtLSBj YW4ndCBzZWxlY3QgUzAgKDB4JTAyeCkuXG4iLCB0ZW1wKSk7CisJCURFQjIocHJpbnRrKEtFUk5f RVJSICJpMmMtYWxnby1wY2YubzogUENGIGRldGVjdGlvbiBmYWlsZWQgLS0gY2FuJ3Qgc2VsZWN0 IFMwICgweCUwMngpLlxuIiwgdGVtcCkpOwogCQlyZXR1cm4gLUVOWElPOyAvKiBkZWZpbmV0bHkg bm90IFBDRjg1ODQgKi8KIAl9CiAKQEAgLTE2MCw3ICsxNjAsNyBAQAogCWkyY19vdXRiKGFkYXAs IGdldF9vd24oYWRhcCkpOwogCS8qIGNoZWNrIGl0J3MgcmVhbHkgd3JpdGVuICovCiAJaWYgKCh0 ZW1wID0gaTJjX2luYihhZGFwKSkgIT0gZ2V0X293bihhZGFwKSkgewotCQlERUIyKHByaW50aygi aTJjLWFsZ28tcGNmLm86IFBDRiBkZXRlY3Rpb24gZmFpbGVkIC0tIGNhbid0IHNldCBTMCAoMHgl MDJ4KS5cbiIsIHRlbXApKTsKKwkJREVCMihwcmludGsoS0VSTl9FUlIgImkyYy1hbGdvLXBjZi5v OiBQQ0YgZGV0ZWN0aW9uIGZhaWxlZCAtLSBjYW4ndCBzZXQgUzAgKDB4JTAyeCkuXG4iLCB0ZW1w KSk7CiAJCXJldHVybiAtRU5YSU87CiAJfQogCkBAIC0xNjgsNyArMTY4LDcgQEAKIAlzZXRfcGNm KGFkYXAsIDEsIEkyQ19QQ0ZfUElOIHwgSTJDX1BDRl9FUzEpOwogCS8qIGNoZWNrIHRvIHNlZSBT MiBub3cgc2VsZWN0ZWQgKi8KIAlpZiAoKHRlbXAgPSBnZXRfcGNmKGFkYXAsIDEpKSAhPSBJMkNf UENGX0VTMSkgewotCQlERUIyKHByaW50aygiaTJjLWFsZ28tcGNmLm86IFBDRiBkZXRlY3Rpb24g ZmFpbGVkIC0tIGNhbid0IHNlbGVjdCBTMiAoMHglMDJ4KS5cbiIsIHRlbXApKTsKKwkJREVCMihw cmludGsoS0VSTl9FUlIgImkyYy1hbGdvLXBjZi5vOiBQQ0YgZGV0ZWN0aW9uIGZhaWxlZCAtLSBj YW4ndCBzZWxlY3QgUzIgKDB4JTAyeCkuXG4iLCB0ZW1wKSk7CiAJCXJldHVybiAtRU5YSU87CiAJ fQogCkBAIC0xNzYsNyArMTc2LDcgQEAKIAlpMmNfb3V0YihhZGFwLCBnZXRfY2xvY2soYWRhcCkp OwogCS8qIGNoZWNrIGl0J3MgcmVhbHkgd3JpdGVuLCB0aGUgb25seSA1IGxvd2VzdCBiaXRzIGRv ZXMgbWF0dGVyICovCiAJaWYgKCgodGVtcCA9IGkyY19pbmIoYWRhcCkpICYgMHgxZikgIT0gZ2V0 X2Nsb2NrKGFkYXApKSB7Ci0JCURFQjIocHJpbnRrKCJpMmMtYWxnby1wY2YubzogUENGIGRldGVj dGlvbiBmYWlsZWQgLS0gY2FuJ3Qgc2V0IFMyICgweCUwMngpLlxuIiwgdGVtcCkpOworCQlERUIy KHByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28tcGNmLm86IFBDRiBkZXRlY3Rpb24gZmFpbGVkIC0t IGNhbid0IHNldCBTMiAoMHglMDJ4KS5cbiIsIHRlbXApKTsKIAkJcmV0dXJuIC1FTlhJTzsKIAl9 CiAKQEAgLTE4NSwxMSArMTg1LDExIEBACiAKIAkvKiBjaGVjayB0byBzZWUgUENGIGlzIHJlYWx5 IGlkbGVkIGFuZCB3ZSBjYW4gYWNjZXNzIHN0YXR1cyByZWdpc3RlciAqLwogCWlmICgodGVtcCA9 IGdldF9wY2YoYWRhcCwgMSkpICE9IChJMkNfUENGX1BJTiB8IEkyQ19QQ0ZfQkIpKSB7Ci0JCURF QjIocHJpbnRrKCJpMmMtYWxnby1wY2YubzogUENGIGRldGVjdGlvbiBmYWlsZWQgLS0gY2FuJ3Qg c2VsZWN0IFMxYCAoMHglMDJ4KS5cbiIsIHRlbXApKTsKKwkJREVCMihwcmludGsoS0VSTl9FUlIg ImkyYy1hbGdvLXBjZi5vOiBQQ0YgZGV0ZWN0aW9uIGZhaWxlZCAtLSBjYW4ndCBzZWxlY3QgUzFg ICgweCUwMngpLlxuIiwgdGVtcCkpOwogCQlyZXR1cm4gLUVOWElPOwogCX0KIAkKLQlwcmludGso ImkyYy1hbGdvLXBjZi5vOiBkZXRldGVkIGFuZCBpbml0aWFsaXplZCBQQ0Y4NTg0LlxuIik7CisJ cHJpbnRrKEtFUk5fREVCVUcgImkyYy1hbGdvLXBjZi5vOiBkZXRldGVkIGFuZCBpbml0aWFsaXpl ZCBQQ0Y4NTg0LlxuIik7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTIxNSw3ICsyMTUsNyBAQAogCQlp MmNfc3RvcChhZGFwKTsKIAkJdWRlbGF5KGFkYXAtPnVkZWxheSk7CiAJfQotCURFQjIoaWYgKGkp IHByaW50aygiaTJjLWFsZ28tcGNmLm86IG5lZWRlZCAlZCByZXRyaWVzIGZvciAlZFxuIixpLAor CURFQjIoaWYgKGkpIHByaW50ayhLRVJOX0RFQlVHICJpMmMtYWxnby1wY2YubzogbmVlZGVkICVk IHJldHJpZXMgZm9yICVkXG4iLGksCiAJICAgICAgICAgICAgICAgICAgIGFkZHIpKTsKIAlyZXR1 cm4gcmV0OwogfQpAQCAtMjI4LDIwICsyMjgsMjAgQEAKIAlpbnQgd3Jjb3VudCwgc3RhdHVzLCB0 aW1lb3V0OwogICAgIAogCWZvciAod3Jjb3VudD0wOyB3cmNvdW50PGNvdW50OyArK3dyY291bnQp IHsKLQkJREVCMihwcmludGsoImkyYy1hbGdvLXBjZi5vOiAlcyBpMmNfd3JpdGU6IHdyaXRpbmcg JTIuMlhcbiIsCisJCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImkyYy1hbGdvLXBjZi5vOiAlcyBp MmNfd3JpdGU6IHdyaXRpbmcgJTIuMlhcbiIsCiAJCSAgICAgIGkyY19hZGFwLT5uYW1lLCBidWZb d3Jjb3VudF0mMHhmZikpOwogCQlpMmNfb3V0YihhZGFwLCBidWZbd3Jjb3VudF0pOwogCQl0aW1l b3V0ID0gd2FpdF9mb3JfcGluKGFkYXAsICZzdGF0dXMpOwogCQlpZiAodGltZW91dCkgewogCQkJ aTJjX3N0b3AoYWRhcCk7Ci0JCQlwcmludGsoImkyYy1hbGdvLXBjZi5vOiAlcyBpMmNfd3JpdGU6 ICIKKwkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28tcGNmLm86ICVzIGkyY193cml0ZTogIgog CQkJICAgICAgICJlcnJvciAtIHRpbWVvdXQuXG4iLCBpMmNfYWRhcC0+bmFtZSk7CiAJCQlyZXR1 cm4gLUVSRU1PVEVJTzsgLyogZ290IGEgYmV0dGVyIG9uZSA/PyAqLwogCQl9CiAjaWZuZGVmIFNU VUJfSTJDCiAJCWlmIChzdGF0dXMgJiBJMkNfUENGX0xSQikgewogCQkJaTJjX3N0b3AoYWRhcCk7 Ci0JCQlwcmludGsoImkyYy1hbGdvLXBjZi5vOiAlcyBpMmNfd3JpdGU6ICIKKwkJCXByaW50ayhL RVJOX0VSUiAiaTJjLWFsZ28tcGNmLm86ICVzIGkyY193cml0ZTogIgogCQkJICAgICAgICJlcnJv ciAtIG5vIGFjay5cbiIsIGkyY19hZGFwLT5uYW1lKTsKIAkJCXJldHVybiAtRVJFTU9URUlPOyAv KiBnb3QgYSBiZXR0ZXIgb25lID8/ICovCiAJCX0KQEAgLTI2OSwxNCArMjY5LDE0IEBACiAKIAkJ aWYgKHdhaXRfZm9yX3BpbihhZGFwLCAmc3RhdHVzKSkgewogCQkJaTJjX3N0b3AoYWRhcCk7Ci0J CQlwcmludGsoImkyYy1hbGdvLXBjZi5vOiBwY2ZfcmVhZGJ5dGVzIHRpbWVkIG91dC5cbiIpOwor CQkJcHJpbnRrKEtFUk5fRVJSICJpMmMtYWxnby1wY2YubzogcGNmX3JlYWRieXRlcyB0aW1lZCBv dXQuXG4iKTsKIAkJCXJldHVybiAoLTEpOwogCQl9CiAKICNpZm5kZWYgU1RVQl9JMkMKIAkJaWYg KChzdGF0dXMgJiBJMkNfUENGX0xSQikgJiYgKGkgIT0gY291bnQpKSB7CiAJCQlpMmNfc3RvcChh ZGFwKTsKLQkJCXByaW50aygiaTJjLWFsZ28tcGNmLm86IGkyY19yZWFkOiBpMmNfaW5iLCBObyBh Y2suXG4iKTsKKwkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28tcGNmLm86IGkyY19yZWFkOiBp MmNfaW5iLCBObyBhY2suXG4iKTsKIAkJCXJldHVybiAoLTEpOwogCQl9CiAjZW5kaWYKQEAgLTMx MiwxOCArMzEyLDE4IEBACiAJaWYgKCAoZmxhZ3MgJiBJMkNfTV9URU4pICApIHsgCiAJCS8qIGEg dGVuIGJpdCBhZGRyZXNzICovCiAJCWFkZHIgPSAweGYwIHwgKCggbXNnLT5hZGRyID4+IDcpICYg MHgwMyk7Ci0JCURFQjIocHJpbnRrKCJhZGRyMDogJWRcbiIsYWRkcikpOworCQlERUIyKHByaW50 ayhLRVJOX0RFQlVHICJhZGRyMDogJWRcbiIsYWRkcikpOwogCQkvKiB0cnkgZXh0ZW5kZWQgYWRk cmVzcyBjb2RlLi4uKi8KIAkJcmV0ID0gdHJ5X2FkZHJlc3MoYWRhcCwgYWRkciwgcmV0cmllcyk7 CiAJCWlmIChyZXQhPTEpIHsKLQkJCXByaW50aygiZGllZCBhdCBleHRlbmRlZCBhZGRyZXNzIGNv ZGUuXG4iKTsKKwkJCXByaW50ayhLRVJOX0VSUiAiZGllZCBhdCBleHRlbmRlZCBhZGRyZXNzIGNv ZGUuXG4iKTsKIAkJCXJldHVybiAtRVJFTU9URUlPOwogCQl9CiAJCS8qIHRoZSByZW1haW5pbmcg OCBiaXQgYWRkcmVzcyAqLwogCQlpMmNfb3V0YihhZGFwLG1zZy0+YWRkciAmIDB4N2YpOwogLyog U3RhdHVzIGNoZWNrIGNvbWVzIGhlcmUgKi8KIAkJaWYgKHJldCAhPSAxKSB7Ci0JCQlwcmludGso ImRpZWQgYXQgMm5kIGFkZHJlc3MgY29kZS5cbiIpOworCQkJcHJpbnRrKEtFUk5fRVJSICJkaWVk IGF0IDJuZCBhZGRyZXNzIGNvZGUuXG4iKTsKIAkJCXJldHVybiAtRVJFTU9URUlPOwogCQl9CiAJ CWlmICggZmxhZ3MgJiBJMkNfTV9SRCApIHsKQEAgLTMzMiw3ICszMzIsNyBAQAogCQkJYWRkciB8 PSAweDAxOwogCQkJcmV0ID0gdHJ5X2FkZHJlc3MoYWRhcCwgYWRkciwgcmV0cmllcyk7CiAJCQlp ZiAocmV0IT0xKSB7Ci0JCQkJcHJpbnRrKCJkaWVkIGF0IGV4dGVuZGVkIGFkZHJlc3MgY29kZS5c biIpOworCQkJCXByaW50ayhLRVJOX0VSUiAiZGllZCBhdCBleHRlbmRlZCBhZGRyZXNzIGNvZGUu XG4iKTsKIAkJCQlyZXR1cm4gLUVSRU1PVEVJTzsKIAkJCX0KIAkJfQpAQCAtMzYwLDcgKzM2MCw3 IEBACiAJLyogQ2hlY2sgZm9yIGJ1cyBidXN5ICovCiAJdGltZW91dCA9IHdhaXRfZm9yX2JiKGFk YXApOwogCWlmICh0aW1lb3V0KSB7Ci0JCURFQjIocHJpbnRrKCJpMmMtYWxnby1wY2YubzogIgor CQlERUIyKHByaW50ayhLRVJOX0VSUiAiaTJjLWFsZ28tcGNmLm86ICIKIAkJICAgICAgICAgICAg IlRpbWVvdXQgd2FpdGluZyBmb3IgQkIgaW4gcGNmX3hmZXJcbiIpOykKIAkJcmV0dXJuIC1FSU87 CiAJfQpAQCAtMzY4LDcgKzM2OCw3IEBACiAJZm9yIChpID0gMDtyZXQgPj0gMCAmJiBpIDwgbnVt OyBpKyspIHsKIAkJcG1zZyA9ICZtc2dzW2ldOwogCi0JCURFQjIocHJpbnRrKCJpMmMtYWxnby1w Y2YubzogRG9pbmcgJXMgJWQgYnl0ZXMgdG8gMHglMDJ4IC0gJWQgb2YgJWQgbWVzc2FnZXNcbiIs CisJCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImkyYy1hbGdvLXBjZi5vOiBEb2luZyAlcyAlZCBi eXRlcyB0byAweCUwMnggLSAlZCBvZiAlZCBtZXNzYWdlc1xuIiwKIAkJICAgICBwbXNnLT5mbGFn cyAmIEkyQ19NX1JEID8gInJlYWQiIDogIndyaXRlIiwKICAgICAgICAgICAgICAgICAgICAgIHBt c2ctPmxlbiwgcG1zZy0+YWRkciwgaSArIDEsIG51bSk7KQogICAgIApAQCAtMzgzLDcgKzM4Myw3 IEBACiAJCXRpbWVvdXQgPSB3YWl0X2Zvcl9waW4oYWRhcCwgJnN0YXR1cyk7CiAJCWlmICh0aW1l b3V0KSB7CiAJCQlpMmNfc3RvcChhZGFwKTsKLQkJCURFQjIocHJpbnRrKCJpMmMtYWxnby1wY2Yu bzogVGltZW91dCB3YWl0aW5nICIKKwkJCURFQjIocHJpbnRrKEtFUk5fRVJSICJpMmMtYWxnby1w Y2YubzogVGltZW91dCB3YWl0aW5nICIKIAkJCQkgICAgImZvciBQSU4oMSkgaW4gcGNmX3hmZXJc biIpOykKIAkJCXJldHVybiAoLUVSRU1PVEVJTyk7CiAJCX0KQEAgLTM5MiwxMiArMzkyLDEyIEBA CiAJCS8qIENoZWNrIExSQiAobGFzdCByY3ZkIGJpdCAtIHNsYXZlIGFjaykgKi8KIAkJaWYgKHN0 YXR1cyAmIEkyQ19QQ0ZfTFJCKSB7CiAJCQlpMmNfc3RvcChhZGFwKTsKLQkJCURFQjIocHJpbnRr KCJpMmMtYWxnby1wY2YubzogTm8gTFJCKDEpIGluIHBjZl94ZmVyXG4iKTspCisJCQlERUIyKHBy aW50ayhLRVJOX0VSUiAiaTJjLWFsZ28tcGNmLm86IE5vIExSQigxKSBpbiBwY2ZfeGZlclxuIik7 KQogCQkJcmV0dXJuICgtRVJFTU9URUlPKTsKIAkJfQogI2VuZGlmCiAgICAgCi0JCURFQjMocHJp bnRrKCJpMmMtYWxnby1wY2YubzogTXNnICVkLCBhZGRyPTB4JXgsIGZsYWdzPTB4JXgsIGxlbj0l ZFxuIiwKKwkJREVCMyhwcmludGsoS0VSTl9ERUJVRyAiaTJjLWFsZ28tcGNmLm86IE1zZyAlZCwg YWRkcj0weCV4LCBmbGFncz0weCV4LCBsZW49JWRcbiIsCiAJCQkgICAgaSwgbXNnc1tpXS5hZGRy LCBtc2dzW2ldLmZsYWdzLCBtc2dzW2ldLmxlbik7KQogICAgIAogCQkvKiBSZWFkICovCkBAIC00 MDcsMjAgKzQwNywyMCBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAoaSArIDEgPSBudW0pKTsKICAgICAgICAgCiAJCQlpZiAocmV0ICE9IHBtc2ctPmxlbikg ewotCQkJCURFQjIocHJpbnRrKCJpMmMtYWxnby1wY2YubzogZmFpbDogIgorCQkJCURFQjIocHJp bnRrKEtFUk5fREVCVUcgImkyYy1hbGdvLXBjZi5vOiBmYWlsOiAiCiAJCQkJCSAgICAib25seSBy ZWFkICVkIGJ5dGVzLlxuIixyZXQpKTsKIAkJCX0gZWxzZSB7Ci0JCQkJREVCMihwcmludGsoImky Yy1hbGdvLXBjZi5vOiByZWFkICVkIGJ5dGVzLlxuIixyZXQpKTsKKwkJCQlERUIyKHByaW50ayhL RVJOX0RFQlVHICJpMmMtYWxnby1wY2YubzogcmVhZCAlZCBieXRlcy5cbiIscmV0KSk7CiAJCQl9 CiAJCX0gZWxzZSB7IC8qIFdyaXRlICovCiAJCQlyZXQgPSBwY2Zfc2VuZGJ5dGVzKGkyY19hZGFw LCBwbXNnLT5idWYsIHBtc2ctPmxlbiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgKGkgKyAxID0gbnVtKSk7CiAgICAgICAgIAogCQkJaWYgKHJldCAhPSBwbXNn LT5sZW4pIHsKLQkJCQlERUIyKHByaW50aygiaTJjLWFsZ28tcGNmLm86IGZhaWw6ICIKKwkJCQlE RUIyKHByaW50ayhLRVJOX0RFQlVHICJpMmMtYWxnby1wY2YubzogZmFpbDogIgogCQkJCQkgICAg Im9ubHkgd3JvdGUgJWQgYnl0ZXMuXG4iLHJldCkpOwogCQkJfSBlbHNlIHsKLQkJCQlERUIyKHBy aW50aygiaTJjLWFsZ28tcGNmLm86IHdyb3RlICVkIGJ5dGVzLlxuIixyZXQpKTsKKwkJCQlERUIy KHByaW50ayhLRVJOX0RFQlVHICJpMmMtYWxnby1wY2Yubzogd3JvdGUgJWQgYnl0ZXMuXG4iLHJl dCkpOwogCQkJfQogCQl9CiAJfQpAQCAtNDYxLDcgKzQ2MSw3IEBACiAJaW50IGksIHN0YXR1czsK IAlzdHJ1Y3QgaTJjX2FsZ29fcGNmX2RhdGEgKnBjZl9hZGFwID0gYWRhcC0+YWxnb19kYXRhOwog Ci0JREVCMihwcmludGsoImkyYy1hbGdvLXBjZi5vOiBodyByb3V0aW5lcyBmb3IgJXMgcmVnaXN0 ZXJlZC5cbiIsCisJREVCMihwcmludGsoS0VSTl9ERUJVRyAiaTJjLWFsZ28tcGNmLm86IGh3IHJv dXRpbmVzIGZvciAlcyByZWdpc3RlcmVkLlxuIiwKIAkgICAgICAgICAgICBhZGFwLT5uYW1lKSk7 CiAKIAkvKiByZWdpc3RlciBuZXcgYWRhcHRlciB0byBpMmMgbW9kdWxlLi4uICovCmRpZmYgLXJ1 TiBsaW51eC0yLjQuMjQtcHJlMS9kcml2ZXJzL2kyYy9pMmMtY29yZS5jIGxpbnV4LTIuNC4yNC1w cmUxLWsvZHJpdmVycy9pMmMvaTJjLWNvcmUuYwotLS0gbGludXgtMi40LjI0LXByZTEvZHJpdmVy cy9pMmMvaTJjLWNvcmUuYwlNb24gQXVnIDI1IDEzOjQ0OjQxIDIwMDMKKysrIGxpbnV4LTIuNC4y NC1wcmUxLWsvZHJpdmVycy9pMmMvaTJjLWNvcmUuYwlTYXQgRGVjIDEzIDE0OjU0OjI1IDIwMDMK QEAgLTE4OCw3ICsxODgsNyBAQAogCQkJZHJpdmVyc1tqXS0+YXR0YWNoX2FkYXB0ZXIoYWRhcCk7 CiAJRFJWX1VOTE9DSygpOwogCQotCURFQihwcmludGsoImkyYy1jb3JlLm86IGFkYXB0ZXIgJXMg cmVnaXN0ZXJlZCBhcyBhZGFwdGVyICVkLlxuIiwKKwlERUIocHJpbnRrKEtFUk5fREVCVUcgImky Yy1jb3JlLm86IGFkYXB0ZXIgJXMgcmVnaXN0ZXJlZCBhcyBhZGFwdGVyICVkLlxuIiwKIAkgICAg ICAgICAgIGFkYXAtPm5hbWUsaSkpOwogCiAJcmV0dXJuIDA7CQpAQCAtMjE0LDcgKzIxNCw3IEBA CiAJCWlmIChhZGFwID0gYWRhcHRlcnNbaV0pCiAJCQlicmVhazsKIAlpZiAoSTJDX0FEQVBfTUFY ID0gaSkgewotCQlwcmludGsoICJpMmMtY29yZS5vOiB1bnJlZ2lzdGVyX2FkYXB0ZXIgYWRhcCBb JXNdIG5vdCBmb3VuZC5cbiIsCisJCXByaW50ayhLRVJOX1dBUk5JTkcgImkyYy1jb3JlLm86IHVu cmVnaXN0ZXJfYWRhcHRlciBhZGFwIFslc10gbm90IGZvdW5kLlxuIiwKIAkJCWFkYXAtPm5hbWUp OwogCQlyZXMgPSAtRU5PREVWOwogCQlnb3RvIEVSUk9SMDsKQEAgLTIyOSw3ICsyMjksNyBAQAog CWZvciAoaiA9IDA7IGogPCBJMkNfRFJJVkVSX01BWDsgaisrKSAKIAkJaWYgKGRyaXZlcnNbal0g JiYgKGRyaXZlcnNbal0tPmZsYWdzICYgSTJDX0RGX0RVTU1ZKSkKIAkJCWlmICgocmVzID0gZHJp dmVyc1tqXS0+YXR0YWNoX2FkYXB0ZXIoYWRhcCkpKSB7Ci0JCQkJcHJpbnRrKCJpMmMtY29yZS5v OiBjYW4ndCBkZXRhY2ggYWRhcHRlciAlcyAiCisJCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiaTJj LWNvcmUubzogY2FuJ3QgZGV0YWNoIGFkYXB0ZXIgJXMgIgogCQkJCSAgICAgICAid2hpbGUgZGV0 YWNoaW5nIGRyaXZlciAlczogZHJpdmVyIG5vdCAiCiAJCQkJICAgICAgICJkZXRhY2hlZCEiLGFk YXAtPm5hbWUsZHJpdmVyc1tqXS0+bmFtZSk7CiAJCQkJZ290byBFUlJPUjE7CQpAQCAtMjQ3LDcg KzI0Nyw3IEBACiAJCSAgICAgKiBtdXN0IGJlIGRlbGV0ZWQsIGFzIHRoaXMgd291bGQgY2F1c2Ug aW52YWxpZCBzdGF0ZXMuCiAJCSAgICAgKi8KIAkJCWlmICgocmVzPWNsaWVudC0+ZHJpdmVyLT5k ZXRhY2hfY2xpZW50KGNsaWVudCkpKSB7Ci0JCQkJcHJpbnRrKCJpMmMtY29yZS5vOiBhZGFwdGVy ICVzIG5vdCAiCisJCQkJcHJpbnRrKEtFUk5fRVJSICJpMmMtY29yZS5vOiBhZGFwdGVyICVzIG5v dCAiCiAJCQkJCSJ1bnJlZ2lzdGVyZWQsIGJlY2F1c2UgY2xpZW50IGF0ICIKIAkJCQkJImFkZHJl c3MgJTAyeCBjYW4ndCBiZSBkZXRhY2hlZC4gIiwKIAkJCQkJYWRhcC0+bmFtZSwgY2xpZW50LT5h ZGRyKTsKQEAgLTI2Niw3ICsyNjYsNyBAQAogCWFkYXBfY291bnQtLTsKIAkKIAlBREFQX1VOTE9D SygpOwkKLQlERUIocHJpbnRrKCJpMmMtY29yZS5vOiBhZGFwdGVyIHVucmVnaXN0ZXJlZDogJXNc biIsYWRhcC0+bmFtZSkpOworCURFQihwcmludGsoS0VSTl9ERUJVRyAiaTJjLWNvcmUubzogYWRh cHRlciB1bnJlZ2lzdGVyZWQ6ICVzXG4iLGFkYXAtPm5hbWUpKTsKIAlyZXR1cm4gMDsKIAogRVJS T1IwOgpAQCAtMzA1LDcgKzMwNSw3IEBACiAJCiAJRFJWX1VOTE9DSygpOwkvKiBkcml2ZXIgd2Fz IHN1Y2Nlc3NmdWxseSBhZGRlZCAqLwogCQotCURFQihwcmludGsoImkyYy1jb3JlLm86IGRyaXZl ciAlcyByZWdpc3RlcmVkLlxuIixkcml2ZXItPm5hbWUpKTsKKwlERUIocHJpbnRrKEtFUk5fREVC VUcgImkyYy1jb3JlLm86IGRyaXZlciAlcyByZWdpc3RlcmVkLlxuIixkcml2ZXItPm5hbWUpKTsK IAkKIAlBREFQX0xPQ0soKTsKIApAQCAtMzQwLDcgKzM0MCw3IEBACiAJICogYXR0YWNoZWQuIElm IHNvLCBkZXRhY2ggdGhlbSB0byBiZSBhYmxlIHRvIGtpbGwgdGhlIGRyaXZlciAKIAkgKiBhZnRl cndhcmRzLgogCSAqLwotCURFQjIocHJpbnRrKCJpMmMtY29yZS5vOiB1bnJlZ2lzdGVyX2RyaXZl ciAtIGxvb2tpbmcgZm9yIGNsaWVudHMuXG4iKSk7CisJREVCMihwcmludGsoS0VSTl9ERUJVRyAi aTJjLWNvcmUubzogdW5yZWdpc3Rlcl9kcml2ZXIgLSBsb29raW5nIGZvciBjbGllbnRzLlxuIikp OwogCS8qIHJlbW92aW5nIGNsaWVudHMgZG9lcyBub3QgZGVwZW5kIG9uIHRoZSBub3RpZnkgZmxh ZywgZWxzZSAKIAkgKiBpbnZhbGlkIG9wZXJhdGlvbiBtaWdodCAod2lsbCEpIHJlc3VsdCwgd2hl biB1c2luZyBzdGFsZSBjbGllbnQKIAkgKiBwb2ludGVycy4KQEAgLTM1MCw3ICszNTAsNyBAQAog CQlzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXAgPSBhZGFwdGVyc1trXTsKIAkJaWYgKGFkYXAgPSBO VUxMKSAvKiBza2lwIGVtcHR5IGVudHJpZXMuICovCiAJCQljb250aW51ZTsKLQkJREVCMihwcmlu dGsoImkyYy1jb3JlLm86IGV4YW1pbmluZyBhZGFwdGVyICVzOlxuIiwKKwkJREVCMihwcmludGso S0VSTl9ERUJVRyAiaTJjLWNvcmUubzogZXhhbWluaW5nIGFkYXB0ZXIgJXM6XG4iLAogCQkJICAg IGFkYXAtPm5hbWUpKTsKIAkJaWYgKGRyaXZlci0+ZmxhZ3MgJiBJMkNfREZfRFVNTVkpIHsKIAkJ LyogRFVNTVkgZHJpdmVycyBkbyBub3QgcmVnaXN0ZXIgdGhlaXIgY2xpZW50cywgc28gd2UgaGF2 ZSB0bwpAQCAtMzU5LDcgKzM1OSw3IEBACiAJCSAqIHRoaXMgb3IgaGVsbCB3aWxsIGJyZWFrIGxv b3NlLi4uICAKIAkJICovCiAJCQlpZiAoKHJlcyA9IGRyaXZlci0+YXR0YWNoX2FkYXB0ZXIoYWRh cCkpKSB7Ci0JCQkJcHJpbnRrKCJpMmMtY29yZS5vOiB3aGlsZSB1bnJlZ2lzdGVyaW5nICIKKwkJ CQlwcmludGsoS0VSTl9XQVJOSU5HICJpMmMtY29yZS5vOiB3aGlsZSB1bnJlZ2lzdGVyaW5nICIK IAkJCQkgICAgICAgImR1bW15IGRyaXZlciAlcywgYWRhcHRlciAlcyBjb3VsZCAiCiAJCQkJICAg ICAgICJub3QgYmUgZGV0YWNoZWQgcHJvcGVybHk7IGRyaXZlciAiCiAJCQkJICAgICAgICJub3Qg dW5sb2FkZWQhIixkcml2ZXItPm5hbWUsCkBAIC0zNzIsMTMgKzM3MiwxMyBAQAogCQkJCXN0cnVj dCBpMmNfY2xpZW50ICpjbGllbnQgPSBhZGFwLT5jbGllbnRzW2pdOwogCQkJCWlmIChjbGllbnQg IT0gTlVMTCAmJiAKIAkJCQkgICAgY2xpZW50LT5kcml2ZXIgPSBkcml2ZXIpIHsKLQkJCQkJREVC MihwcmludGsoImkyYy1jb3JlLm86ICIKKwkJCQkJREVCMihwcmludGsoS0VSTl9ERUJVRyAiaTJj LWNvcmUubzogIgogCQkJCQkJICAgICJkZXRhY2hpbmcgY2xpZW50ICVzOlxuIiwKIAkJCQkJICAg ICAgICAgICAgY2xpZW50LT5uYW1lKSk7CiAJCQkJCWlmICgocmVzID0gZHJpdmVyLT4KIAkJCQkJ CQlkZXRhY2hfY2xpZW50KGNsaWVudCkpKQogCQkJCQl7Ci0JCQkJCQlwcmludGsoImkyYy1jb3Jl Lm86IHdoaWxlICIKKwkJCQkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWNvcmUubzogd2hpbGUgIgog CQkJCQkJICAgICAgICJ1bnJlZ2lzdGVyaW5nIGRyaXZlciAiCiAJCQkJCQkgICAgICAgImAlcycs IHRoZSBjbGllbnQgYXQgIgogCQkJCQkJICAgICAgICJhZGRyZXNzICUwMnggb2YgIgpAQCAtNDAw LDcgKzQwMCw3IEBACiAJZHJpdmVyX2NvdW50LS07CiAJRFJWX1VOTE9DSygpOwogCQotCURFQihw cmludGsoImkyYy1jb3JlLm86IGRyaXZlciB1bnJlZ2lzdGVyZWQ6ICVzXG4iLGRyaXZlci0+bmFt ZSkpOworCURFQihwcmludGsoS0VSTl9ERUJVRyAiaTJjLWNvcmUubzogZHJpdmVyIHVucmVnaXN0 ZXJlZDogJXNcbiIsZHJpdmVyLT5uYW1lKSk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTQzNiwxMCAr NDM2LDEwIEBACiAJCiAJaWYgKGFkYXB0ZXItPmNsaWVudF9yZWdpc3RlcikgCiAJCWlmIChhZGFw dGVyLT5jbGllbnRfcmVnaXN0ZXIoY2xpZW50KSkgCi0JCQlwcmludGsoImkyYy1jb3JlLm86IHdh cm5pbmc6IGNsaWVudF9yZWdpc3RlciBzZWVtcyAiCisJCQlwcmludGsoS0VSTl9ERUJVRyAiaTJj LWNvcmUubzogd2FybmluZzogY2xpZW50X3JlZ2lzdGVyIHNlZW1zICIKIAkJCSAgICAgICAidG8g aGF2ZSBmYWlsZWQgZm9yIGNsaWVudCAlMDJ4IGF0IGFkYXB0ZXIgJXNcbiIsCiAJCQkgICAgICAg Y2xpZW50LT5hZGRyLGFkYXB0ZXItPm5hbWUpOwotCURFQihwcmludGsoImkyYy1jb3JlLm86IGNs aWVudCBbJXNdIHJlZ2lzdGVyZWQgdG8gYWRhcHRlciBbJXNdKHBvcy4gJWQpLlxuIiwKKwlERUIo cHJpbnRrKEtFUk5fREVCVUcgImkyYy1jb3JlLm86IGNsaWVudCBbJXNdIHJlZ2lzdGVyZWQgdG8g YWRhcHRlciBbJXNdKHBvcy4gJWQpLlxuIiwKIAkJY2xpZW50LT5uYW1lLCBhZGFwdGVyLT5uYW1l LGkpKTsKIAogCWlmKGNsaWVudC0+ZmxhZ3MgJiBJMkNfQ0xJRU5UX0FMTE9XX1VTRSkKQEAgLTQ3 MCw3ICs0NzAsNyBAQAogCQogCWlmIChhZGFwdGVyLT5jbGllbnRfdW5yZWdpc3RlciAhPSBOVUxM KSAKIAkJaWYgKChyZXMgPSBhZGFwdGVyLT5jbGllbnRfdW5yZWdpc3RlcihjbGllbnQpKSkgewot CQkJcHJpbnRrKCJpMmMtY29yZS5vOiBjbGllbnRfdW5yZWdpc3RlciBbJXNdIGZhaWxlZCwgIgor CQkJcHJpbnRrKEtFUk5fRVJSICJpMmMtY29yZS5vOiBjbGllbnRfdW5yZWdpc3RlciBbJXNdIGZh aWxlZCwgIgogCQkJICAgICAgICJjbGllbnQgbm90IGRldGFjaGVkIixjbGllbnQtPm5hbWUpOwog CQkJcmV0dXJuIHJlczsKIAkJfQpAQCAtNDc4LDcgKzQ3OCw3IEBACiAJYWRhcHRlci0+Y2xpZW50 c1tpXSA9IE5VTEw7CiAJYWRhcHRlci0+Y2xpZW50X2NvdW50LS07CiAKLQlERUIocHJpbnRrKCJp MmMtY29yZS5vOiBjbGllbnQgWyVzXSB1bnJlZ2lzdGVyZWQuXG4iLGNsaWVudC0+bmFtZSkpOwor CURFQihwcmludGsoS0VSTl9ERUJVRyAiaTJjLWNvcmUubzogY2xpZW50IFslc10gdW5yZWdpc3Rl cmVkLlxuIixjbGllbnQtPm5hbWUpKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNzI3LDcgKzcyNyw3 IEBACiAgCX0gCiAJcHJvY19idXNfaTJjID0gY3JlYXRlX3Byb2NfZW50cnkoImkyYyIsMCxwcm9j X2J1cyk7CiAJaWYgKCFwcm9jX2J1c19pMmMpIHsKLQkJcHJpbnRrKCJpMmMtY29yZS5vOiBDb3Vs ZCBub3QgY3JlYXRlIC9wcm9jL2J1cy9pMmMiKTsKKwkJcHJpbnRrKEtFUk5fRVJSICJpMmMtY29y ZS5vOiBDb3VsZCBub3QgY3JlYXRlIC9wcm9jL2J1cy9pMmMiKTsKIAkJaTJjcHJvY19jbGVhbnVw KCk7CiAJCXJldHVybiAtRU5PRU5UOwogIAl9CkBAIC03NjQsNyArNzY0LDcgQEAKIAlpbnQgcmV0 OwogCiAJaWYgKGFkYXAtPmFsZ28tPm1hc3Rlcl94ZmVyKSB7Ci0gCSAJREVCMihwcmludGsoImky Yy1jb3JlLm86IG1hc3Rlcl94ZmVyOiAlcyB3aXRoICVkIG1zZ3MuXG4iLAorIAkgCURFQjIocHJp bnRrKEtFUk5fREVCVUcgImkyYy1jb3JlLm86IG1hc3Rlcl94ZmVyOiAlcyB3aXRoICVkIG1zZ3Mu XG4iLAogCQkgICAgICAgICAgICBhZGFwLT5uYW1lLG51bSkpOwogCiAJCUkyQ19MT0NLKGFkYXAp OwpAQCAtNzczLDcgKzc3Myw3IEBACiAKIAkJcmV0dXJuIHJldDsKIAl9IGVsc2UgewotCQlwcmlu dGsoImkyYy1jb3JlLm86IEkyQyBhZGFwdGVyICUwNHg6IEkyQyBsZXZlbCB0cmFuc2ZlcnMgbm90 IHN1cHBvcnRlZFxuIiwKKwkJcHJpbnRrKEtFUk5fRVJSICJpMmMtY29yZS5vOiBJMkMgYWRhcHRl ciAlMDR4OiBJMkMgbGV2ZWwgdHJhbnNmZXJzIG5vdCBzdXBwb3J0ZWRcbiIsCiAJCSAgICAgICBh ZGFwLT5pZCk7CiAJCXJldHVybiAtRU5PU1lTOwogCX0KQEAgLTc5MSw3ICs3OTEsNyBAQAogCQlt c2cubGVuID0gY291bnQ7CiAJCShjb25zdCBjaGFyICopbXNnLmJ1ZiA9IGJ1ZjsKIAkKLQkJREVC MihwcmludGsoImkyYy1jb3JlLm86IG1hc3Rlcl9zZW5kOiB3cml0aW5nICVkIGJ5dGVzIG9uICVz LlxuIiwKKwkJREVCMihwcmludGsoS0VSTl9ERUJVRyAiaTJjLWNvcmUubzogbWFzdGVyX3NlbmQ6 IHdyaXRpbmcgJWQgYnl0ZXMgb24gJXMuXG4iLAogCQkJY291bnQsY2xpZW50LT5hZGFwdGVyLT5u YW1lKSk7CiAJCiAJCUkyQ19MT0NLKGFkYXApOwpAQCAtODAzLDcgKzgwMyw3IEBACiAJCSAqLwog CQlyZXR1cm4gKHJldCA9IDEgKT8gY291bnQgOiByZXQ7CiAJfSBlbHNlIHsKLQkJcHJpbnRrKCJp MmMtY29yZS5vOiBJMkMgYWRhcHRlciAlMDR4OiBJMkMgbGV2ZWwgdHJhbnNmZXJzIG5vdCBzdXBw b3J0ZWRcbiIsCisJCXByaW50ayhLRVJOX0VSUiAiaTJjLWNvcmUubzogSTJDIGFkYXB0ZXIgJTA0 eDogSTJDIGxldmVsIHRyYW5zZmVycyBub3Qgc3VwcG9ydGVkXG4iLAogCQkgICAgICAgY2xpZW50 LT5hZGFwdGVyLT5pZCk7CiAJCXJldHVybiAtRU5PU1lTOwogCX0KQEAgLTgyMSwxNCArODIxLDE0 IEBACiAJCW1zZy5sZW4gPSBjb3VudDsKIAkJbXNnLmJ1ZiA9IGJ1ZjsKIAotCQlERUIyKHByaW50 aygiaTJjLWNvcmUubzogbWFzdGVyX3JlY3Y6IHJlYWRpbmcgJWQgYnl0ZXMgb24gJXMuXG4iLAor CQlERUIyKHByaW50ayhLRVJOX0RFQlVHICJpMmMtY29yZS5vOiBtYXN0ZXJfcmVjdjogcmVhZGlu ZyAlZCBieXRlcyBvbiAlcy5cbiIsCiAJCQljb3VudCxjbGllbnQtPmFkYXB0ZXItPm5hbWUpKTsK IAkKIAkJSTJDX0xPQ0soYWRhcCk7CiAJCXJldCA9IGFkYXAtPmFsZ28tPm1hc3Rlcl94ZmVyKGFk YXAsJm1zZywxKTsKIAkJSTJDX1VOTE9DSyhhZGFwKTsKIAkKLQkJREVCMihwcmludGsoImkyYy1j b3JlLm86IG1hc3Rlcl9yZWN2OiByZXR1cm46JWQgKGNvdW50OiVkLCBhZGRyOjB4JTAyeClcbiIs CisJCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImkyYy1jb3JlLm86IG1hc3Rlcl9yZWN2OiByZXR1 cm46JWQgKGNvdW50OiVkLCBhZGRyOjB4JTAyeClcbiIsCiAJCQlyZXQsIGNvdW50LCBjbGllbnQt PmFkZHIpKTsKIAkKIAkJLyogaWYgZXZlcnl0aGluZyB3ZW50IG9rIChpLmUuIDEgbXNnIHRyYW5z bWl0dGVkKSwgcmV0dXJuICNieXRlcwpAQCAtODM2LDcgKzgzNiw3IEBACiAJIAkqLwogCQlyZXR1 cm4gKHJldCA9IDEgKT8gY291bnQgOiByZXQ7CiAJfSBlbHNlIHsKLQkJcHJpbnRrKCJpMmMtY29y ZS5vOiBJMkMgYWRhcHRlciAlMDR4OiBJMkMgbGV2ZWwgdHJhbnNmZXJzIG5vdCBzdXBwb3J0ZWRc biIsCisJCXByaW50ayhLRVJOX0VSUiAiaTJjLWNvcmUubzogSTJDIGFkYXB0ZXIgJTA0eDogSTJD IGxldmVsIHRyYW5zZmVycyBub3Qgc3VwcG9ydGVkXG4iLAogCQkgICAgICAgY2xpZW50LT5hZGFw dGVyLT5pZCk7CiAJCXJldHVybiAtRU5PU1lTOwogCX0KQEAgLTg0OSw3ICs4NDksNyBAQAogCWlu dCByZXQgPSAwOwogCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcCA9IGNsaWVudC0+YWRhcHRlcjsK IAotCURFQjIocHJpbnRrKCJpMmMtY29yZS5vOiBpMmMgaW9jdGwsIGNtZDogMHgleCwgYXJnOiAl I2x4XG4iLCBjbWQsIGFyZykpOworCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImkyYy1jb3JlLm86 IGkyYyBpb2N0bCwgY21kOiAweCV4LCBhcmc6ICUjbHhcbiIsIGNtZCwgYXJnKSk7CiAJc3dpdGNo ICggY21kICkgewogCQljYXNlIEkyQ19SRVRSSUVTOgogCQkJYWRhcC0+cmV0cmllcyA9IGFyZzsK QEAgLTg5NCw3ICs4OTQsNyBAQAogCQkJaWYgKCgoYWRhcF9pZCA9IGFkZHJlc3NfZGF0YS0+Zm9y Y2VbaV0pIHx8IAogCQkJICAgICAoYWRkcmVzc19kYXRhLT5mb3JjZVtpXSA9IEFOWV9JMkNfQlVT KSkgJiYKIAkJCSAgICAgKGFkZHIgPSBhZGRyZXNzX2RhdGEtPmZvcmNlW2krMV0pKSB7Ci0JCQkJ REVCMihwcmludGsoImkyYy1jb3JlLm86IGZvdW5kIGZvcmNlIHBhcmFtZXRlciBmb3IgYWRhcHRl ciAlZCwgYWRkciAlMDR4XG4iLAorCQkJCURFQjIocHJpbnRrKEtFUk5fREVCVUcgImkyYy1jb3Jl Lm86IGZvdW5kIGZvcmNlIHBhcmFtZXRlciBmb3IgYWRhcHRlciAlZCwgYWRkciAlMDR4XG4iLAog CQkJCSAgICAgICAgICAgIGFkYXBfaWQsYWRkcikpOwogCQkJCWlmICgoZXJyID0gZm91bmRfcHJv YyhhZGFwdGVyLGFkZHIsMCwwKSkpCiAJCQkJCXJldHVybiBlcnI7CkBAIC05MTIsNyArOTEyLDcg QEAKIAkJCWlmICgoKGFkYXBfaWQgPSBhZGRyZXNzX2RhdGEtPmlnbm9yZVtpXSkgfHwgCiAJCQkg ICAgKChhZGRyZXNzX2RhdGEtPmlnbm9yZVtpXSA9IEFOWV9JMkNfQlVTKSkpICYmCiAJCQkgICAg KGFkZHIgPSBhZGRyZXNzX2RhdGEtPmlnbm9yZVtpKzFdKSkgewotCQkJCURFQjIocHJpbnRrKCJp MmMtY29yZS5vOiBmb3VuZCBpZ25vcmUgcGFyYW1ldGVyIGZvciBhZGFwdGVyICVkLCAiCisJCQkJ REVCMihwcmludGsoS0VSTl9ERUJVRyAiaTJjLWNvcmUubzogZm91bmQgaWdub3JlIHBhcmFtZXRl ciBmb3IgYWRhcHRlciAlZCwgIgogCQkJCSAgICAgImFkZHIgJTA0eFxuIiwgYWRhcF9pZCAsYWRk cikpOwogCQkJCWZvdW5kID0gMTsKIAkJCX0KQEAgLTkyNCw3ICs5MjQsNyBAQAogCQkJICAgICgo YWRkcmVzc19kYXRhLT5pZ25vcmVfcmFuZ2VbaV09QU5ZX0kyQ19CVVMpKSkgJiYKIAkJCSAgICAo YWRkciA+PSBhZGRyZXNzX2RhdGEtPmlnbm9yZV9yYW5nZVtpKzFdKSAmJgogCQkJICAgIChhZGRy IDw9IGFkZHJlc3NfZGF0YS0+aWdub3JlX3JhbmdlW2krMl0pKSB7Ci0JCQkJREVCMihwcmludGso ImkyYy1jb3JlLm86IGZvdW5kIGlnbm9yZV9yYW5nZSBwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIgJWQs ICIKKwkJCQlERUIyKHByaW50ayhLRVJOX0RFQlVHICJpMmMtY29yZS5vOiBmb3VuZCBpZ25vcmVf cmFuZ2UgcGFyYW1ldGVyIGZvciBhZGFwdGVyICVkLCAiCiAJCQkJICAgICAgICAgICAgImFkZHIg JTA0eFxuIiwgYWRhcF9pZCxhZGRyKSk7CiAJCQkJZm91bmQgPSAxOwogCQkJfQpAQCAtOTM5LDcg KzkzOSw3IEBACiAJCSAgICAgaSArPSAxKSB7CiAJCQlpZiAoYWRkciA9IGFkZHJlc3NfZGF0YS0+ bm9ybWFsX2kyY1tpXSkgewogCQkJCWZvdW5kID0gMTsKLQkJCQlERUIyKHByaW50aygiaTJjLWNv cmUubzogZm91bmQgbm9ybWFsIGkyYyBlbnRyeSBmb3IgYWRhcHRlciAlZCwgIgorCQkJCURFQjIo cHJpbnRrKEtFUk5fREVCVUcgImkyYy1jb3JlLm86IGZvdW5kIG5vcm1hbCBpMmMgZW50cnkgZm9y IGFkYXB0ZXIgJWQsICIKIAkJCQkgICAgICAgICAgICAiYWRkciAlMDJ4IiwgYWRhcF9pZCxhZGRy KSk7CiAJCQl9CiAJCX0KQEAgLTk1MCw3ICs5NTAsNyBAQAogCQkJaWYgKChhZGRyID49IGFkZHJl c3NfZGF0YS0+bm9ybWFsX2kyY19yYW5nZVtpXSkgJiYKIAkJCSAgICAoYWRkciA8PSBhZGRyZXNz X2RhdGEtPm5vcm1hbF9pMmNfcmFuZ2VbaSsxXSkpIHsKIAkJCQlmb3VuZCA9IDE7Ci0JCQkJREVC MihwcmludGsoImkyYy1jb3JlLm86IGZvdW5kIG5vcm1hbCBpMmNfcmFuZ2UgZW50cnkgZm9yIGFk YXB0ZXIgJWQsICIKKwkJCQlERUIyKHByaW50ayhLRVJOX0RFQlVHICJpMmMtY29yZS5vOiBmb3Vu ZCBub3JtYWwgaTJjX3JhbmdlIGVudHJ5IGZvciBhZGFwdGVyICVkLCAiCiAJCQkJICAgICAgICAg ICAgImFkZHIgJTA0eFxuIiwgYWRhcF9pZCxhZGRyKSk7CiAJCQl9CiAJCX0KQEAgLTk2Miw3ICs5 NjIsNyBAQAogCQkJICAgICgoYWRkcmVzc19kYXRhLT5wcm9iZVtpXSA9IEFOWV9JMkNfQlVTKSkp ICYmCiAJCQkgICAgKGFkZHIgPSBhZGRyZXNzX2RhdGEtPnByb2JlW2krMV0pKSB7CiAJCQkJZm91 bmQgPSAxOwotCQkJCURFQjIocHJpbnRrKCJpMmMtY29yZS5vOiBmb3VuZCBwcm9iZSBwYXJhbWV0 ZXIgZm9yIGFkYXB0ZXIgJWQsICIKKwkJCQlERUIyKHByaW50ayhLRVJOX0RFQlVHICJpMmMtY29y ZS5vOiBmb3VuZCBwcm9iZSBwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIgJWQsICIKIAkJCQkgICAgICAg ICAgICAiYWRkciAlMDR4XG4iLCBhZGFwX2lkLGFkZHIpKTsKIAkJCX0KIAkJfQpAQCAtOTc0LDcg Kzk3NCw3IEBACiAJCQkgICAoYWRkciA+PSBhZGRyZXNzX2RhdGEtPnByb2JlX3JhbmdlW2krMV0p ICYmCiAJCQkgICAoYWRkciA8PSBhZGRyZXNzX2RhdGEtPnByb2JlX3JhbmdlW2krMl0pKSB7CiAJ CQkJZm91bmQgPSAxOwotCQkJCURFQjIocHJpbnRrKCJpMmMtY29yZS5vOiBmb3VuZCBwcm9iZV9y YW5nZSBwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIgJWQsICIKKwkJCQlERUIyKHByaW50ayhLRVJOX0RF QlVHICJpMmMtY29yZS5vOiBmb3VuZCBwcm9iZV9yYW5nZSBwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIg JWQsICIKIAkJCQkgICAgICAgICAgICAiYWRkciAlMDR4XG4iLCBhZGFwX2lkLGFkZHIpKTsKIAkJ CX0KIAkJfQpAQCAtMTE4NiwxMyArMTE4NiwxMyBAQAogCQlicmVhazsKIAljYXNlIEkyQ19TTUJV U19CTE9DS19EQVRBOgogCQlpZiAocmVhZF93cml0ZSA9IEkyQ19TTUJVU19SRUFEKSB7Ci0JCQlw cmludGsoImkyYy1jb3JlLm86IEJsb2NrIHJlYWQgbm90IHN1cHBvcnRlZCB1bmRlciAiCi0JCQkg ICAgICAgIkkyQyBlbXVsYXRpb24hXG4iKTsKLQkJcmV0dXJuIC0xOworCQkJcHJpbnRrKEtFUk5f RVJSICJpMmMtY29yZS5vOiBCbG9jayByZWFkIG5vdCBzdXBwb3J0ZWQgIgorCQkJICAgICAgICJ1 bmRlciBJMkMgZW11bGF0aW9uIVxuIik7CisJCQlyZXR1cm4gLTE7CiAJCX0gZWxzZSB7CiAJCQlt c2dbMF0ubGVuID0gZGF0YS0+YmxvY2tbMF0gKyAyOwogCQkJaWYgKG1zZ1swXS5sZW4gPiAzNCkg ewotCQkJCXByaW50aygiaTJjLWNvcmUubzogc21idXNfYWNjZXNzIGNhbGxlZCB3aXRoICIKKwkJ CQlwcmludGsoS0VSTl9FUlIgImkyYy1jb3JlLm86IHNtYnVzX2FjY2VzcyBjYWxsZWQgd2l0aCAi CiAJCQkJICAgICAgICJpbnZhbGlkIGJsb2NrIHdyaXRlIHNpemUgKCVkKVxuIiwKIAkJCQkgICAg ICAgbXNnWzBdLmxlbik7CiAJCQkJcmV0dXJuIC0xOwpAQCAtMTIwMiw3ICsxMjAyLDcgQEAKIAkJ fQogCQlicmVhazsKIAlkZWZhdWx0OgotCQlwcmludGsoImkyYy1jb3JlLm86IHNtYnVzX2FjY2Vz cyBjYWxsZWQgd2l0aCBpbnZhbGlkIHNpemUgKCVkKVxuIiwKKwkJcHJpbnRrKEtFUk5fRVJSICJp MmMtY29yZS5vOiBzbWJ1c19hY2Nlc3MgY2FsbGVkIHdpdGggaW52YWxpZCBzaXplICglZClcbiIs CiAJCSAgICAgICBzaXplKTsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTEyNjQsNyArMTI2NCw3IEBA CiAKIHN0YXRpYyBpbnQgX19pbml0IGkyY19pbml0KHZvaWQpCiB7Ci0JcHJpbnRrKEtFUk5fSU5G TyAiaTJjLWNvcmUubzogaTJjIGNvcmUgbW9kdWxlXG4iKTsKKwlwcmludGsoS0VSTl9JTkZPICJp MmMtY29yZS5vOiBpMmMgY29yZSBtb2R1bGUgdmVyc2lvbiAlcyAoJXMpXG4iLCBJMkNfVkVSU0lP TiwgSTJDX0RBVEUpOwogCW1lbXNldChhZGFwdGVycywwLHNpemVvZihhZGFwdGVycykpOwogCW1l bXNldChkcml2ZXJzLDAsc2l6ZW9mKGRyaXZlcnMpKTsKIAlhZGFwX2NvdW50PTA7CmRpZmYgLXJ1 TiBsaW51eC0yLjQuMjQtcHJlMS9kcml2ZXJzL2kyYy9pMmMtZGV2LmMgbGludXgtMi40LjI0LXBy ZTEtay9kcml2ZXJzL2kyYy9pMmMtZGV2LmMKLS0tIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMv aTJjL2kyYy1kZXYuYwlNb24gQXVnIDI1IDEzOjQ0OjQxIDIwMDMKKysrIGxpbnV4LTIuNC4yNC1w cmUxLWsvZHJpdmVycy9pMmMvaTJjLWRldi5jCVNhdCBEZWMgMTMgMTQ6NTY6NDggMjAwMwpAQCAt MTY4LDcgKzE2OCw3IEBACiAJCXJldHVybiAtRU5PTUVNOwogCiAjaWZkZWYgREVCVUcKLQlwcmlu dGsoImkyYy1kZXYubzogaTJjLSVkIHJlYWRpbmcgJWQgYnl0ZXMuXG4iLE1JTk9SKGlub2RlLT5p X3JkZXYpLAorCXByaW50ayhLRVJOX0RFQlVHICJpMmMtZGV2Lm86IGkyYy0lZCByZWFkaW5nICVk IGJ5dGVzLlxuIixNSU5PUihpbm9kZS0+aV9yZGV2KSwKIAkgICAgICAgY291bnQpOwogI2VuZGlm CiAKQEAgLTIwMyw3ICsyMDMsNyBAQAogCX0KIAogI2lmZGVmIERFQlVHCi0JcHJpbnRrKCJpMmMt ZGV2Lm86IGkyYy0lZCB3cml0aW5nICVkIGJ5dGVzLlxuIixNSU5PUihpbm9kZS0+aV9yZGV2KSwK KwlwcmludGsoS0VSTl9ERUJVRyAiaTJjLWRldi5vOiBpMmMtJWQgd3JpdGluZyAlZCBieXRlcy5c biIsTUlOT1IoaW5vZGUtPmlfcmRldiksCiAJICAgICAgIGNvdW50KTsKICNlbmRpZgogCXJldCA9 IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsdG1wLGNvdW50KTsKQEAgLTIyNCw3ICsyMjQsNyBAQAog CXVuc2lnbmVkIGxvbmcgZnVuY3M7CiAKICNpZmRlZiBERUJVRwotCXByaW50aygiaTJjLWRldi5v OiBpMmMtJWQgaW9jdGwsIGNtZDogMHgleCwgYXJnOiAlbHguXG4iLCAKKwlwcmludGsoS0VSTl9E RUJVRyAiaTJjLWRldi5vOiBpMmMtJWQgaW9jdGwsIGNtZDogMHgleCwgYXJnOiAlbHguXG4iLCAK IAkgICAgICAgTUlOT1IoaW5vZGUtPmlfcmRldiksY21kLCBhcmcpOwogI2VuZGlmIC8qIERFQlVH ICovCiAKQEAgLTM0Niw3ICszNDYsNyBAQAogCQkgICAgKGRhdGFfYXJnLnNpemUgIT0gSTJDX1NN QlVTX0JMT0NLX0RBVEEpICYmCiAJCSAgICAoZGF0YV9hcmcuc2l6ZSAhPSBJMkNfU01CVVNfSTJD X0JMT0NLX0RBVEEpKSB7CiAjaWZkZWYgREVCVUcKLQkJCXByaW50aygiaTJjLWRldi5vOiBzaXpl IG91dCBvZiByYW5nZSAoJXgpIGluIGlvY3RsIEkyQ19TTUJVUy5cbiIsCisJCQlwcmludGsoS0VS Tl9ERUJVRyAiaTJjLWRldi5vOiBzaXplIG91dCBvZiByYW5nZSAoJXgpIGluIGlvY3RsIEkyQ19T TUJVUy5cbiIsCiAJCQkgICAgICAgZGF0YV9hcmcuc2l6ZSk7CiAjZW5kaWYKIAkJCXJldHVybiAt RUlOVkFMOwpAQCAtMzU2LDcgKzM1Niw3IEBACiAJCWlmICgoZGF0YV9hcmcucmVhZF93cml0ZSAh PSBJMkNfU01CVVNfUkVBRCkgJiYgCiAJCSAgICAoZGF0YV9hcmcucmVhZF93cml0ZSAhPSBJMkNf U01CVVNfV1JJVEUpKSB7CiAjaWZkZWYgREVCVUcKLQkJCXByaW50aygiaTJjLWRldi5vOiByZWFk X3dyaXRlIG91dCBvZiByYW5nZSAoJXgpIGluIGlvY3RsIEkyQ19TTUJVUy5cbiIsCisJCQlwcmlu dGsoS0VSTl9ERUJVRyAiaTJjLWRldi5vOiByZWFkX3dyaXRlIG91dCBvZiByYW5nZSAoJXgpIGlu IGlvY3RsIEkyQ19TTUJVUy5cbiIsCiAJCQkgICAgICAgZGF0YV9hcmcucmVhZF93cml0ZSk7CiAj ZW5kaWYKIAkJCXJldHVybiAtRUlOVkFMOwpAQCAtMzc2LDcgKzM3Niw3IEBACiAKIAkJaWYgKGRh dGFfYXJnLmRhdGEgPSBOVUxMKSB7CiAjaWZkZWYgREVCVUcKLQkJCXByaW50aygiaTJjLWRldi5v OiBkYXRhIGlzIE5VTEwgcG9pbnRlciBpbiBpb2N0bCBJMkNfU01CVVMuXG4iKTsKKwkJCXByaW50 ayhLRVJOX0RFQlVHICJpMmMtZGV2Lm86IGRhdGEgaXMgTlVMTCBwb2ludGVyIGluIGlvY3RsIEky Q19TTUJVUy5cbiIpOwogI2VuZGlmCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQpAQCAtNDE4LDcg KzQxOCw3IEBACiAKIAlpZiAoKG1pbm9yID49IEkyQ0RFVl9BREFQU19NQVgpIHx8ICEgKGkyY2Rl dl9hZGFwc1ttaW5vcl0pKSB7CiAjaWZkZWYgREVCVUcKLQkJcHJpbnRrKCJpMmMtZGV2Lm86IFRy eWluZyB0byBvcGVuIHVuYXR0YWNoZWQgYWRhcHRlciBpMmMtJWRcbiIsCisJCXByaW50ayhLRVJO X0RFQlVHICJpMmMtZGV2Lm86IFRyeWluZyB0byBvcGVuIHVuYXR0YWNoZWQgYWRhcHRlciBpMmMt JWRcbiIsCiAJCSAgICAgICBtaW5vcik7CiAjZW5kaWYKIAkJcmV0dXJuIC1FTk9ERVY7CkBAIC00 MzksNyArNDM5LDcgQEAKICNlbmRpZiAvKiBMSU5VWF9LRVJORUxfVkVSU0lPTiA8IEtFUk5FTF9W RVJTSU9OKDIsNCwwKSAqLwogCiAjaWZkZWYgREVCVUcKLQlwcmludGsoImkyYy1kZXYubzogb3Bl bmVkIGkyYy0lZFxuIixtaW5vcik7CisJcHJpbnRrKEtFUk5fREVCVUcgImkyYy1kZXYubzogb3Bl bmVkIGkyYy0lZFxuIixtaW5vcik7CiAjZW5kaWYKIAlyZXR1cm4gMDsKIH0KQEAgLTQ1MCw3ICs0 NTAsNyBAQAogCWtmcmVlKGZpbGUtPnByaXZhdGVfZGF0YSk7CiAJZmlsZS0+cHJpdmF0ZV9kYXRh PU5VTEw7CiAjaWZkZWYgREVCVUcKLQlwcmludGsoImkyYy1kZXYubzogQ2xvc2VkOiBpMmMtJWRc biIsIG1pbm9yKTsKKwlwcmludGsoS0VSTl9ERUJVRyAiaTJjLWRldi5vOiBDbG9zZWQ6IGkyYy0l ZFxuIiwgbWlub3IpOwogI2VuZGlmCiAjaWYgTElOVVhfS0VSTkVMX1ZFUlNJT04gPCBLRVJORUxf VkVSU0lPTigyLDQsMCkKIAlNT0RfREVDX1VTRV9DT1VOVDsKQEAgLTQ3MSwxMSArNDcxLDExIEBA CiAJY2hhciBuYW1lWzhdOwogCiAJaWYgKChpID0gaTJjX2FkYXB0ZXJfaWQoYWRhcCkpIDwgMCkg ewotCQlwcmludGsoImkyYy1kZXYubzogVW5rbm93biBhZGFwdGVyID8hP1xuIik7CisJCXByaW50 ayhLRVJOX0RFQlVHICJpMmMtZGV2Lm86IFVua25vd24gYWRhcHRlciA/IT9cbiIpOwogCQlyZXR1 cm4gLUVOT0RFVjsKIAl9CiAJaWYgKGkgPj0gSTJDREVWX0FEQVBTX01BWCkgewotCQlwcmludGso ImkyYy1kZXYubzogQWRhcHRlciBudW1iZXIgdG9vIGxhcmdlPyE/ICglZClcbiIsaSk7CisJCXBy aW50ayhLRVJOX0RFQlVHICJpMmMtZGV2Lm86IEFkYXB0ZXIgbnVtYmVyIHRvbyBsYXJnZT8hPyAo JWQpXG4iLGkpOwogCQlyZXR1cm4gLUVOT0RFVjsKIAl9CiAKQEAgLTQ4OCw3ICs0ODgsNyBAQAog CQkJU19JRkNIUiB8IFNfSVJVU1IgfCBTX0lXVVNSLAogCQkJJmkyY2Rldl9mb3BzLCBOVUxMKTsK ICNlbmRpZgotCQlwcmludGsoImkyYy1kZXYubzogUmVnaXN0ZXJlZCAnJXMnIGFzIG1pbm9yICVk XG4iLGFkYXAtPm5hbWUsaSk7CisJCXByaW50ayhLRVJOX0RFQlVHICJpMmMtZGV2Lm86IFJlZ2lz dGVyZWQgJyVzJyBhcyBtaW5vciAlZFxuIixhZGFwLT5uYW1lLGkpOwogCX0gZWxzZSB7CiAJCS8q IFRoaXMgaXMgYWN0dWFsbHkgYSBkZXRhY2hfYWRhcHRlciBjYWxsISAqLwogI2lmZGVmIENPTkZJ R19ERVZGU19GUwpAQCAtNDk2LDcgKzQ5Niw3IEBACiAjZW5kaWYKIAkJaTJjZGV2X2FkYXBzW2ld ID0gTlVMTDsKICNpZmRlZiBERUJVRwotCQlwcmludGsoImkyYy1kZXYubzogQWRhcHRlciB1bnJl Z2lzdGVyZWQ6ICVzXG4iLGFkYXAtPm5hbWUpOworCQlwcmludGsoS0VSTl9ERUJVRyAiaTJjLWRl di5vOiBBZGFwdGVyIHVucmVnaXN0ZXJlZDogJXNcbiIsYWRhcC0+bmFtZSk7CiAjZW5kaWYKIAl9 CiAKQEAgLTUxOCw3ICs1MTgsNyBAQAogewogCWludCByZXM7CiAKLQlwcmludGsoImkyYy1kZXYu bzogaTJjIC9kZXYgZW50cmllcyBkcml2ZXIgbW9kdWxlXG4iKTsKKwlwcmludGsoS0VSTl9JTkZP ICJpMmMtZGV2Lm86IGkyYyAvZGV2IGVudHJpZXMgZHJpdmVyIG1vZHVsZSB2ZXJzaW9uICVzICgl cylcbiIsIEkyQ19WRVJTSU9OLCBJMkNfREFURSk7CiAKIAlpMmNkZXZfaW5pdGlhbGl6ZWQgPSAw OwogI2lmZGVmIENPTkZJR19ERVZGU19GUwpAQCAtNTI2LDcgKzUyNiw3IEBACiAjZWxzZQogCWlm IChyZWdpc3Rlcl9jaHJkZXYoSTJDX01BSk9SLCJpMmMiLCZpMmNkZXZfZm9wcykpIHsKICNlbmRp ZgotCQlwcmludGsoImkyYy1kZXYubzogdW5hYmxlIHRvIGdldCBtYWpvciAlZCBmb3IgaTJjIGJ1 c1xuIiwKKwkJcHJpbnRrKEtFUk5fRVJSICJpMmMtZGV2Lm86IHVuYWJsZSB0byBnZXQgbWFqb3Ig JWQgZm9yIGkyYyBidXNcbiIsCiAJCSAgICAgICBJMkNfTUFKT1IpOwogCQlyZXR1cm4gLUVJTzsK IAl9CkBAIC01MzYsNyArNTM2LDcgQEAKIAlpMmNkZXZfaW5pdGlhbGl6ZWQgKys7CiAKIAlpZiAo KHJlcyA9IGkyY19hZGRfZHJpdmVyKCZpMmNkZXZfZHJpdmVyKSkpIHsKLQkJcHJpbnRrKCJpMmMt ZGV2Lm86IERyaXZlciByZWdpc3RyYXRpb24gZmFpbGVkLCBtb2R1bGUgbm90IGluc2VydGVkLlxu Iik7CisJCXByaW50ayhLRVJOX0VSUiAiaTJjLWRldi5vOiBEcml2ZXIgcmVnaXN0cmF0aW9uIGZh aWxlZCwgbW9kdWxlIG5vdCBpbnNlcnRlZC5cbiIpOwogCQlpMmNkZXZfY2xlYW51cCgpOwogCQly ZXR1cm4gcmVzOwogCX0KZGlmZiAtcnVOIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2ky Yy1lbGVrdG9yLmMgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtZWxla3Rvci5j Ci0tLSBsaW51eC0yLjQuMjQtcHJlMS9kcml2ZXJzL2kyYy9pMmMtZWxla3Rvci5jCVRodSBPY3Qg MTEgMTc6MDU6NDcgMjAwMQorKysgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMt ZWxla3Rvci5jCVNhdCBEZWMgMTMgMTQ6NTk6MDAgMjAwMwpAQCAtNzgsNyArNzgsNyBAQAogCQl2 YWwgfD0gSTJDX1BDRl9FTkk7CiAJfQogCi0JREVCMyhwcmludGsoImkyYy1lbGVrdG9yLm86IFdy aXRlIDB4JVggMHglMDJYXG4iLCBhZGRyZXNzLCB2YWwgJiAyNTUpKTsKKwlERUIzKHByaW50ayhL RVJOX0RFQlVHICJpMmMtZWxla3Rvci5vOiBXcml0ZSAweCVYIDB4JTAyWFxuIiwgYWRkcmVzcywg dmFsICYgMjU1KSk7CiAKIAlzd2l0Y2ggKG1tYXBwZWQpIHsKIAljYXNlIDA6IC8qIHJlZ3VsYXIg SS9PICovCkBAIC05OSw3ICs5OSw3IEBACiAJaW50IGFkZHJlc3MgPSBjdGwgPyAoYmFzZSArIDEp IDogYmFzZTsKIAlpbnQgdmFsID0gbW1hcHBlZCA/IHJlYWRiKGFkZHJlc3MpIDogaW5iKGFkZHJl c3MpOwogCi0JREVCMyhwcmludGsoImkyYy1lbGVrdG9yLm86IFJlYWQgMHglWCAweCUwMlhcbiIs IGFkZHJlc3MsIHZhbCkpOworCURFQjMocHJpbnRrKEtFUk5fREVCVUcgImkyYy1lbGVrdG9yLm86 IFJlYWQgMHglWCAweCUwMlhcbiIsIGFkZHJlc3MsIHZhbCkpOwogCiAJcmV0dXJuICh2YWwpOwog fQpAQCAtMTQyLDcgKzE0Miw5IEBACiB7CiAJaWYgKCFtbWFwcGVkKSB7CiAJCWlmIChjaGVja19y ZWdpb24oYmFzZSwgMikgPCAwICkgewotCQkJcHJpbnRrKCJpMmMtZWxla3Rvci5vOiByZXF1ZXN0 ZWQgSS9PIHJlZ2lvbiAoMHglWDoyKSBpcyBpbiB1c2UuXG4iLCBiYXNlKTsKKwkJCXByaW50ayhL RVJOX0VSUgorCQkJICAgICAgICJpMmMtZWxla3Rvci5vOiByZXF1ZXN0ZWQgSS9PIHJlZ2lvbiAo MHglWDoyKSAiCisJCQkgICAgICAgImlzIGluIHVzZS5cbiIsIGJhc2UpOwogCQkJcmV0dXJuIC1F Tk9ERVY7CiAJCX0gZWxzZSB7CiAJCQlyZXF1ZXN0X3JlZ2lvbihiYXNlLCAyLCAiaTJjIChpc2Eg YnVzIGFkYXB0ZXIpIik7CkBAIC0xNTAsNyArMTUyLDcgQEAKIAl9CiAJaWYgKGlycSA+IDApIHsK IAkJaWYgKHJlcXVlc3RfaXJxKGlycSwgcGNmX2lzYV9oYW5kbGVyLCAwLCAiUENGODU4NCIsIDAp IDwgMCkgewotCQkJcHJpbnRrKCJpMmMtZWxla3Rvci5vOiBSZXF1ZXN0IGlycSVkIGZhaWxlZFxu IiwgaXJxKTsKKwkJCXByaW50ayhLRVJOX0VSUiAiaTJjLWVsZWt0b3IubzogUmVxdWVzdCBpcnEl ZCBmYWlsZWRcbiIsIGlycSk7CiAJCQlpcnEgPSAwOwogCQl9IGVsc2UKIAkJCWVuYWJsZV9pcnEo aXJxKTsKQEAgLTIzOCw3ICsyNDAsNyBAQAogCQkJLyogeWVhcCwgd2UndmUgZm91bmQgY3lwcmVz cywgbGV0J3MgY2hlY2sgY29uZmlnICovCiAJCQlpZiAoIXBjaV9yZWFkX2NvbmZpZ19ieXRlKGN5 NjkzX2RldiwgMHg0NywgJmNvbmZpZykpIHsKIAkJCQkKLQkJCQlERUIzKHByaW50aygiaTJjLWVs ZWt0b3IubzogZm91bmQgY3k4MmM2OTMsIGNvbmZpZyByZWdpc3RlciAweDQ3ID0gMHglMDJ4Llxu IiwgY29uZmlnKSk7CisJCQkJREVCMyhwcmludGsoS0VSTl9ERUJVRyAiaTJjLWVsZWt0b3Iubzog Zm91bmQgY3k4MmM2OTMsIGNvbmZpZyByZWdpc3RlciAweDQ3ID0gMHglMDJ4LlxuIiwgY29uZmln KSk7CiAKIAkJCQkvKiBVUDIwMDAgYm9hcmQgaGFzIHRoaXMgcmVnaXN0ZXIgc2V0IHRvIDB4ZTEs CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJ1dCB0aGUgbW9zdCBzaWduaWZp Y2FudCBiaXQgYXMgc2VlbXMgY2FuIGJlIApAQCAtMjYwLDcgKzI2Miw3IEBACiAJCQkJCSAgIDgu MjUgTUh6IChQQ0kvNCkgY2xvY2sKIAkJCQkJICAgKHRoaXMgY2FuIGJlIHJlYWQgZnJvbSBjeXBy ZXNzKSAqLwogCQkJCQljbG9jayA9IEkyQ19QQ0ZfQ0xLIHwgSTJDX1BDRl9UUk5TOTA7Ci0JCQkJ CXByaW50aygiaTJjLWVsZWt0b3IubzogZm91bmQgQVBJIFVQMjAwMCBsaWtlIGJvYXJkLCB3aWxs IHByb2JlIFBDRjg1ODQgbGF0ZXIuXG4iKTsKKwkJCQkJcHJpbnRrKEtFUk5fSU5GTyAiaTJjLWVs ZWt0b3IubzogZm91bmQgQVBJIFVQMjAwMCBsaWtlIGJvYXJkLCB3aWxsIHByb2JlIFBDRjg1ODQg bGF0ZXIuXG4iKTsKIAkJCQl9CiAJCQl9CiAJCX0KQEAgLTI2OSwxMSArMjcxLDExIEBACiAKIAkv KiBzYW5pdHkgY2hlY2tzIGZvciBtbWFwcGVkIEkvTyAqLwogCWlmIChtbWFwcGVkICYmIGJhc2Ug PCAweGM4MDAwKSB7Ci0JCXByaW50aygiaTJjLWVsZWt0b3IubzogaW5jb3JyZWN0IGJhc2UgYWRk cmVzcyAoMHglMFgpIHNwZWNpZmllZCBmb3IgbW1hcHBlZCBJL08uXG4iLCBiYXNlKTsKKwkJcHJp bnRrKEtFUk5fRVJSICJpMmMtZWxla3Rvci5vOiBpbmNvcnJlY3QgYmFzZSBhZGRyZXNzICgweCUw WCkgc3BlY2lmaWVkIGZvciBtbWFwcGVkIEkvTy5cbiIsIGJhc2UpOwogCQlyZXR1cm4gLUVOT0RF VjsKIAl9CiAKLQlwcmludGsoImkyYy1lbGVrdG9yLm86IGkyYyBwY2Y4NTg0LWlzYSBhZGFwdGVy IG1vZHVsZVxuIik7CisJcHJpbnRrKEtFUk5fSU5GTyAiaTJjLWVsZWt0b3IubzogaTJjIHBjZjg1 ODQtaXNhIGFkYXB0ZXIgbW9kdWxlIHZlcnNpb24gJXMgKCVzKVxuIiwgSTJDX1ZFUlNJT04sIEky Q19EQVRFKTsKIAogCWlmIChiYXNlID0gMCkgewogCQliYXNlID0gREVGQVVMVF9CQVNFOwpAQCAt Mjg5LDcgKzI5MSw3IEBACiAJCXJldHVybiAtRU5PREVWOwogCX0KIAkKLQlwcmludGsoImkyYy1l bGVrdG9yLm86IGZvdW5kIGRldmljZSBhdCAlI3guXG4iLCBiYXNlKTsKKwlwcmludGsoS0VSTl9E RUJVRyAiaTJjLWVsZWt0b3IubzogZm91bmQgZGV2aWNlIGF0ICUjeC5cbiIsIGJhc2UpOwogCiAJ cmV0dXJuIDA7CiB9CmRpZmYgLXJ1TiBsaW51eC0yLjQuMjQtcHJlMS9kcml2ZXJzL2kyYy9pMmMt ZWx2LmMgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtZWx2LmMKLS0tIGxpbnV4 LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy1lbHYuYwlUaHUgT2N0IDExIDE3OjA1OjQ3IDIw MDEKKysrIGxpbnV4LTIuNC4yNC1wcmUxLWsvZHJpdmVycy9pMmMvaTJjLWVsdi5jCVNhdCBEZWMg MTMgMTU6MDQ6MTggMjAwMwpAQCAtOTUsMTQgKzk1LDE0IEBACiAJfSBlbHNlIHsKIAkJCQkJCS8q IHRlc3QgZm9yIEVMViBhZGFwLiAJKi8KIAkJaWYgKGluYihiYXNlKzEpICYgMHg4MCkgewkvKiBC VVNZIHNob3VsZCBiZSBoaWdoCSovCi0JCQlERUJJTklUKHByaW50aygiaTJjLWVsdi5vOiBCdXN5 IHdhcyBsb3cuXG4iKSk7CisJCQlERUJJTklUKHByaW50ayhLRVJOX0RFQlVHICJpMmMtZWx2Lm86 IEJ1c3kgd2FzIGxvdy5cbiIpKTsKIAkJCXJldHVybiAtRU5PREVWOwogCQl9IGVsc2UgewogCQkJ b3V0YigweDBjLGJhc2UrMik7CS8qIFNMQ1QgYXVmIGxvdwkJKi8KIAkJCXVkZWxheSg0MDApOwog CQkJaWYgKCAhKGluYihiYXNlKzEpICYmIDB4MTApICkgewogCQkJCW91dGIoMHgwNCxiYXNlKzIp OwotCQkJCURFQklOSVQocHJpbnRrKCJpMmMtZWx2Lm86IFNlbGVjdCB3YXMgaGlnaC5cbiIpKTsK KwkJCQlERUJJTklUKHByaW50ayhLRVJOX0RFQlVHICJpMmMtZWx2Lm86IFNlbGVjdCB3YXMgaGln aC5cbiIpKTsKIAkJCQlyZXR1cm4gLUVOT0RFVjsKIAkJCX0KIAkJfQpAQCAtMTcwLDcgKzE3MCw3 IEBACiAKIGludCBfX2luaXQgaTJjX2JpdGVsdl9pbml0KHZvaWQpCiB7Ci0JcHJpbnRrKCJpMmMt ZWx2Lm86IGkyYyBFTFYgcGFyYWxsZWwgcG9ydCBhZGFwdGVyIG1vZHVsZVxuIik7CisJcHJpbnRr KEtFUk5fSU5GTyAiaTJjLWVsdi5vOiBpMmMgRUxWIHBhcmFsbGVsIHBvcnQgYWRhcHRlciBtb2R1 bGUgdmVyc2lvbiAlcyAoJXMpXG4iLCBJMkNfVkVSU0lPTiwgSTJDX0RBVEUpOwogCWlmIChiYXNl PTApIHsKIAkJLyogcHJvYmUgc29tZSB2YWx1ZXMgKi8KIAkJYmFzZd5GQVVMVF9CQVNFOwpAQCAt MTkwLDcgKzE5MCw3IEBACiAJCQlyZXR1cm4gLUVOT0RFVjsKIAkJfQogCX0KLQlwcmludGsoImky Yy1lbHYubzogZm91bmQgZGV2aWNlIGF0ICUjeC5cbiIsYmFzZSk7CisJcHJpbnRrKEtFUk5fREVC VUcgImkyYy1lbHYubzogZm91bmQgZGV2aWNlIGF0ICUjeC5cbiIsYmFzZSk7CiAJcmV0dXJuIDA7 CiB9CiAKZGlmZiAtcnVOIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy1waGlsaXBz LXBhci5jIGxpbnV4LTIuNC4yNC1wcmUxLWsvZHJpdmVycy9pMmMvaTJjLXBoaWxpcHMtcGFyLmMK LS0tIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy1waGlsaXBzLXBhci5jCVN1biBT ZXAgMzAgMjE6MjY6MDUgMjAwMQorKysgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9p MmMtcGhpbGlwcy1wYXIuYwlTYXQgRGVjIDEzIDE1OjA3OjUzIDIwMDMKQEAgLTE5MCwxOCArMTkw LDE4IEBACiAJc3RydWN0IGkyY19wYXIgKmFkYXB0ZXIgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qg aTJjX3BhciksCiAJCQkJCSAgR0ZQX0tFUk5FTCk7CiAJaWYgKCFhZGFwdGVyKSB7Ci0JCXByaW50 aygiaTJjLXBoaWxpcHMtcGFyOiBVbmFibGUgdG8gbWFsbG9jLlxuIik7CisJCXByaW50ayhLRVJO X0VSUiAiaTJjLXBoaWxpcHMtcGFyOiBVbmFibGUgdG8gbWFsbG9jLlxuIik7CiAJCXJldHVybjsK IAl9CiAKLQlwcmludGsoImkyYy1waGlsaXBzLXBhci5vOiBhdHRhY2hpbmcgdG8gJXNcbiIsIHBv cnQtPm5hbWUpOworCXByaW50ayhLRVJOX0RFQlVHICJpMmMtcGhpbGlwcy1wYXIubzogYXR0YWNo aW5nIHRvICVzXG4iLCBwb3J0LT5uYW1lKTsKIAogCWFkYXB0ZXItPnBkZXYgPSBwYXJwb3J0X3Jl Z2lzdGVyX2RldmljZShwb3J0LCAiaTJjLXBoaWxpcHMtcGFyIiwKIAkJCQkJCU5VTEwsIE5VTEws IE5VTEwsIAogCQkJCQkJUEFSUE9SVF9GTEFHX0VYQ0wsCiAJCQkJCQlOVUxMKTsKIAlpZiAoIWFk YXB0ZXItPnBkZXYpIHsKLQkJcHJpbnRrKCJpMmMtcGhpbGlwcy1wYXI6IFVuYWJsZSB0byByZWdp c3RlciB3aXRoIHBhcnBvcnQuXG4iKTsKKwkJcHJpbnRrKEtFUk5fRVJSICJpMmMtcGhpbGlwcy1w YXI6IFVuYWJsZSB0byByZWdpc3RlciB3aXRoIHBhcnBvcnQuXG4iKTsKIAkJcmV0dXJuOwogCX0K IApAQCAtMjE4LDcgKzIxOCw3IEBACiAKIAlpZiAoaTJjX2JpdF9hZGRfYnVzKCZhZGFwdGVyLT5h ZGFwdGVyKSA8IDApCiAJewotCQlwcmludGsoImkyYy1waGlsaXBzLXBhcjogVW5hYmxlIHRvIHJl Z2lzdGVyIHdpdGggSTJDLlxuIik7CisJCXByaW50ayhLRVJOX0VSUiAiaTJjLXBoaWxpcHMtcGFy OiBVbmFibGUgdG8gcmVnaXN0ZXIgd2l0aCBJMkMuXG4iKTsKIAkJcGFycG9ydF91bnJlZ2lzdGVy X2RldmljZShhZGFwdGVyLT5wZGV2KTsKIAkJa2ZyZWUoYWRhcHRlcik7CiAJCXJldHVybjsJCS8q IE5vIGdvb2QgKi8KQEAgLTI2NCw3ICsyNjQsNyBAQAogI2lmIExJTlVYX1ZFUlNJT05fQ09ERSA8 IEtFUk5FTF9WRVJTSU9OKDIsMyw0KQogCXN0cnVjdCBwYXJwb3J0ICpwb3J0OwogI2VuZGlmCi0J cHJpbnRrKCJpMmMtcGhpbGlwcy1wYXIubzogaTJjIFBoaWxpcHMgcGFyYWxsZWwgcG9ydCBhZGFw dGVyIG1vZHVsZVxuIik7CisJcHJpbnRrKEtFUk5fSU5GTyAiaTJjLXBoaWxpcHMtcGFyLm86IGky YyBQaGlsaXBzIHBhcmFsbGVsIHBvcnQgYWRhcHRlciBtb2R1bGUgdmVyc2lvbiAlcyAoJXMpXG4i LCBJMkNfVkVSU0lPTiwgSTJDX0RBVEUpOwogCiAjaWYgTElOVVhfVkVSU0lPTl9DT0RFID49IEtF Uk5FTF9WRVJTSU9OKDIsMyw0KQogCXBhcnBvcnRfcmVnaXN0ZXJfZHJpdmVyKCZpMmNfZHJpdmVy KTsKZGlmZiAtcnVOIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy1wcm9jLmMgbGlu dXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtcHJvYy5jCi0tLSBsaW51eC0yLjQuMjQt cHJlMS9kcml2ZXJzL2kyYy9pMmMtcHJvYy5jCUZyaSBKdW4gMTMgMTY6NTE6MzMgMjAwMworKysg bGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtcHJvYy5jCVNhdCBEZWMgMTMgMTU6 MTM6MTMgMjAwMwpAQCAtMzgsMTAgKzM4LDYgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4K IAotLyogRklYTUUgbmVlZCBpMmMgdmVyc2lvbmluZyAqLwotI2RlZmluZSBMTV9EQVRFICIyMDAx MDgyNSIKLSNkZWZpbmUgTE1fVkVSU0lPTiAiMi42LjEiCi0KICNpZm5kZWYgVEhJU19NT0RVTEUK ICNkZWZpbmUgVEhJU19NT0RVTEUgTlVMTAogI2VuZGlmCkBAIC02ODQsNyArNjgwLDcgQEAKIAkJ CQkgICAgJiYgKGFkZHIgPSB0aGlzX2ZvcmNlLT5mb3JjZVtqICsgMV0pKSB7CiAjaWZkZWYgREVC VUcKIAkJCQkJcHJpbnRrCi0JCQkJCSAgICAoImkyYy1wcm9jLm86IGZvdW5kIGZvcmNlIHBhcmFt ZXRlciBmb3IgYWRhcHRlciAlZCwgYWRkciAlMDR4XG4iLAorCQkJCQkgICAgKEtFUk5fREVCVUcg ImkyYy1wcm9jLm86IGZvdW5kIGZvcmNlIHBhcmFtZXRlciBmb3IgYWRhcHRlciAlZCwgYWRkciAl MDR4XG4iLAogCQkJCQkgICAgIGFkYXB0ZXJfaWQsIGFkZHIpOwogI2VuZGlmCiAJCQkJCWlmICgK QEAgLTcxNCw3ICs3MTAsNyBAQAogCQkJICAgICYmIChhZGRyID0gYWRkcmVzc19kYXRhLT5pZ25v cmVbaSArIDFdKSkgewogI2lmZGVmIERFQlVHCiAJCQkJcHJpbnRrCi0JCQkJICAgICgiaTJjLXBy b2MubzogZm91bmQgaWdub3JlIHBhcmFtZXRlciBmb3IgYWRhcHRlciAlZCwgIgorCQkJCSAgICAo S0VSTl9ERUJVRyAiaTJjLXByb2MubzogZm91bmQgaWdub3JlIHBhcmFtZXRlciBmb3IgYWRhcHRl ciAlZCwgIgogCQkJCSAgICAgImFkZHIgJTA0eFxuIiwgYWRhcHRlcl9pZCwgYWRkcik7CiAjZW5k aWYKIAkJCQlmb3VuZCA9IDE7CkBAIC03MzQsNyArNzMwLDcgQEAKIAkJCSAgICAmJiAoYWRkciA8 PSBhZGRyZXNzX2RhdGEtPmlnbm9yZV9yYW5nZVtpICsgMl0pKSB7CiAjaWZkZWYgREVCVUcKIAkJ CQlwcmludGsKLQkJCQkgICAgKCJpMmMtcHJvYy5vOiBmb3VuZCBpZ25vcmVfcmFuZ2UgcGFyYW1l dGVyIGZvciBhZGFwdGVyICVkLCAiCisJCQkJICAgIChLRVJOX0RFQlVHICJpMmMtcHJvYy5vOiBm b3VuZCBpZ25vcmVfcmFuZ2UgcGFyYW1ldGVyIGZvciBhZGFwdGVyICVkLCAiCiAJCQkJICAgICAi YWRkciAlMDR4XG4iLCBhZGFwdGVyX2lkLCBhZGRyKTsKICNlbmRpZgogCQkJCWZvdW5kID0gMTsK QEAgLTc1Myw3ICs3NDksNyBAQAogCQkJCWlmIChhZGRyID0gYWRkcmVzc19kYXRhLT5ub3JtYWxf aXNhW2ldKSB7CiAjaWZkZWYgREVCVUcKIAkJCQkJcHJpbnRrCi0JCQkJCSAgICAoImkyYy1wcm9j Lm86IGZvdW5kIG5vcm1hbCBpc2EgZW50cnkgZm9yIGFkYXB0ZXIgJWQsICIKKwkJCQkJICAgIChL RVJOX0RFQlVHICJpMmMtcHJvYy5vOiBmb3VuZCBub3JtYWwgaXNhIGVudHJ5IGZvciBhZGFwdGVy ICVkLCAiCiAJCQkJCSAgICAgImFkZHIgJTA0eFxuIiwgYWRhcHRlcl9pZCwKIAkJCQkJICAgICBh ZGRyKTsKICNlbmRpZgpAQCAtNzc1LDcgKzc3MSw3IEBACiAJCQkJICAgICAwKSkgewogI2lmZGVm IERFQlVHCiAJCQkJCXByaW50awotCQkJCQkgICAgKCJpMmMtcHJvYy5vOiBmb3VuZCBub3JtYWwg aXNhX3JhbmdlIGVudHJ5IGZvciBhZGFwdGVyICVkLCAiCisJCQkJCSAgICAoS0VSTl9ERUJVRyAi aTJjLXByb2MubzogZm91bmQgbm9ybWFsIGlzYV9yYW5nZSBlbnRyeSBmb3IgYWRhcHRlciAlZCwg IgogCQkJCQkgICAgICJhZGRyICUwNHgiLCBhZGFwdGVyX2lkLCBhZGRyKTsKICNlbmRpZgogCQkJ CQlmb3VuZCA9IDE7CkBAIC03ODksNyArNzg1LDcgQEAKIAkJCQkJZm91bmQgPSAxOwogI2lmZGVm IERFQlVHCiAJCQkJCXByaW50awotCQkJCQkgICAgKCJpMmMtcHJvYy5vOiBmb3VuZCBub3JtYWwg aTJjIGVudHJ5IGZvciBhZGFwdGVyICVkLCAiCisJCQkJCSAgICAoS0VSTl9ERUJVRyAiaTJjLXBy b2MubzogZm91bmQgbm9ybWFsIGkyYyBlbnRyeSBmb3IgYWRhcHRlciAlZCwgIgogCQkJCQkgICAg ICJhZGRyICUwMngiLCBhZGFwdGVyX2lkLCBhZGRyKTsKICNlbmRpZgogCQkJCX0KQEAgLTgwNSw3 ICs4MDEsNyBAQAogCQkJCXsKICNpZmRlZiBERUJVRwogCQkJCQlwcmludGsKLQkJCQkJICAgICgi aTJjLXByb2MubzogZm91bmQgbm9ybWFsIGkyY19yYW5nZSBlbnRyeSBmb3IgYWRhcHRlciAlZCwg IgorCQkJCQkgICAgKEtFUk5fREVCVUcgImkyYy1wcm9jLm86IGZvdW5kIG5vcm1hbCBpMmNfcmFu Z2UgZW50cnkgZm9yIGFkYXB0ZXIgJWQsICIKIAkJCQkJICAgICAiYWRkciAlMDR4XG4iLCBhZGFw dGVyX2lkLCBhZGRyKTsKICNlbmRpZgogCQkJCQlmb3VuZCA9IDE7CkBAIC04MjIsNyArODE4LDcg QEAKIAkJCSAgICAmJiAoYWRkciA9IGFkZHJlc3NfZGF0YS0+cHJvYmVbaSArIDFdKSkgewogI2lm ZGVmIERFQlVHCiAJCQkJcHJpbnRrCi0JCQkJICAgICgiaTJjLXByb2MubzogZm91bmQgcHJvYmUg cGFyYW1ldGVyIGZvciBhZGFwdGVyICVkLCAiCisJCQkJICAgIChLRVJOX0RFQlVHICJpMmMtcHJv Yy5vOiBmb3VuZCBwcm9iZSBwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIgJWQsICIKIAkJCQkgICAgICJh ZGRyICUwNHhcbiIsIGFkYXB0ZXJfaWQsIGFkZHIpOwogI2VuZGlmCiAJCQkJZm91bmQgPSAxOwpA QCAtODQxLDcgKzgzNyw3IEBACiAJCQkJZm91bmQgPSAxOwogI2lmZGVmIERFQlVHCiAJCQkJcHJp bnRrCi0JCQkJICAgICgiaTJjLXByb2MubzogZm91bmQgcHJvYmVfcmFuZ2UgcGFyYW1ldGVyIGZv ciBhZGFwdGVyICVkLCAiCisJCQkJICAgIChLRVJOX0RFQlVHICJpMmMtcHJvYy5vOiBmb3VuZCBw cm9iZV9yYW5nZSBwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIgJWQsICIKIAkJCQkgICAgICJhZGRyICUw NHhcbiIsIGFkYXB0ZXJfaWQsIGFkZHIpOwogI2VuZGlmCiAJCQl9CkBAIC04NjIsNyArODU4LDcg QEAKIAogaW50IF9faW5pdCBzZW5zb3JzX2luaXQodm9pZCkKIHsKLQlwcmludGsoImkyYy1wcm9j Lm8gdmVyc2lvbiAlcyAoJXMpXG4iLCBMTV9WRVJTSU9OLCBMTV9EQVRFKTsKKwlwcmludGsoS0VS Tl9JTkZPICJpMmMtcHJvYy5vIHZlcnNpb24gJXMgKCVzKVxuIiwgSTJDX1ZFUlNJT04sIEkyQ19E QVRFKTsKIAlpMmNfaW5pdGlhbGl6ZWQgPSAwOwogCWlmICghCiAJICAgIChpMmNfcHJvY19oZWFk ZXIgZGlmZiAtcnVOIGxpbnV4LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy12ZWxsZW1hbi5j IGxpbnV4LTIuNC4yNC1wcmUxLWsvZHJpdmVycy9pMmMvaTJjLXZlbGxlbWFuLmMKLS0tIGxpbnV4 LTIuNC4yNC1wcmUxL2RyaXZlcnMvaTJjL2kyYy12ZWxsZW1hbi5jCVRodSBPY3QgMTEgMTc6MDU6 NDcgMjAwMQorKysgbGludXgtMi40LjI0LXByZTEtay9kcml2ZXJzL2kyYy9pMmMtdmVsbGVtYW4u YwlTYXQgRGVjIDEzIDE1OjE1OjU5IDIwMDMKQEAgLTE2MCw3ICsxNjAsNyBAQAogCiBpbnQgX19p bml0ICBpMmNfYml0dmVsbGVfaW5pdCh2b2lkKQogewotCXByaW50aygiaTJjLXZlbGxlbWFuLm86 IGkyYyBWZWxsZW1hbiBLODAwMCBhZGFwdGVyIG1vZHVsZVxuIik7CisJcHJpbnRrKEtFUk5fSU5G TyAiaTJjLXZlbGxlbWFuLm86IGkyYyBWZWxsZW1hbiBLODAwMCBhZGFwdGVyIG1vZHVsZSB2ZXJz aW9uICVzICglcylcbiIsIEkyQ19WRVJTSU9OLCBJMkNfREFURSk7CiAJaWYgKGJhc2U9MCkgewog CQkvKiBwcm9iZSBzb21lIHZhbHVlcyAqLwogCQliYXNl3kZBVUxUX0JBU0U7CkBAIC0xODAsNyAr MTgwLDcgQEAKIAkJCXJldHVybiAtRU5PREVWOwogCQl9CiAJfQotCXByaW50aygiaTJjLXZlbGxl bWFuLm86IGZvdW5kIGRldmljZSBhdCAlI3guXG4iLGJhc2UpOworCXByaW50ayhLRVJOX0RFQlVH ICJpMmMtdmVsbGVtYW4ubzogZm91bmQgZGV2aWNlIGF0ICUjeC5cbiIsYmFzZSk7CiAJcmV0dXJu IDA7CiB9CiAKCgotLSAKSmVhbiBEZWx2YXJlCmh0dHA6Ly93d3cuZW5zaWNhZW4uaXNtcmEuZnIv fmRlbHZhcmUvCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S265291AbTLMTbf (ORCPT ); Sat, 13 Dec 2003 14:31:35 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S265289AbTLMTbf (ORCPT ); Sat, 13 Dec 2003 14:31:35 -0500 Received: from smtp-106-saturday.nerim.net ([62.4.16.106]:9229 "EHLO kraid.nerim.net") by vger.kernel.org with ESMTP id S265300AbTLMTav (ORCPT ); Sat, 13 Dec 2003 14:30:51 -0500 Date: Sat, 13 Dec 2003 20:31:16 +0100 From: Jean Delvare To: Marcelo Tosatti Cc: LKML , LM Sensors Subject: [PATCH 2.4] i2c cleanups (3/4) Message-Id: <20031213203116.5149d233.khali@linux-fr.org> In-Reply-To: <20031213191258.2d78a9f7.khali@linux-fr.org> References: <20031213191258.2d78a9f7.khali@linux-fr.org> Reply-To: LKML , LM Sensors X-Mailer: Sylpheed version 0.9.8 (GTK+ 1.2.10; i686-pc-linux-gnu) Mime-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org X-Mailing-List: linux-kernel@vger.kernel.org This patch fixes many (122) printk calls missing their KERN_* constant. There also are some other trivial fixes that were passing by (indentation changes and string changes). Please apply. diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-algo-bit.c linux-2.4.24-pre1-k/drivers/i2c/i2c-algo-bit.c --- linux-2.4.24-pre1/drivers/i2c/i2c-algo-bit.c Mon Aug 25 13:44:41 2003 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-algo-bit.c Sat Dec 13 15:41:57 2003 @@ -123,7 +123,7 @@ if (current->need_resched) schedule(); } - DEBSTAT(printk("needed %ld jiffies\n", jiffies-start)); + DEBSTAT(printk(KERN_DEBUG "needed %ld jiffies\n", jiffies-start)); #ifdef SLO_IO SLO_IO #endif @@ -179,12 +179,12 @@ struct i2c_algo_bit_data *adap = i2c_adap->algo_data; /* assert: scl is low */ - DEB2(printk(" i2c_outb:%2.2X\n",c&0xff)); + DEB2(printk(KERN_DEBUG " i2c_outb:%2.2X\n",c&0xff)); for ( i=7 ; i>=0 ; i-- ) { sb = c & ( 1 << i ); setsda(adap,sb); udelay(adap->udelay); - DEBPROTO(printk("%d",sb!=0)); + DEBPROTO(printk(KERN_DEBUG "%d",sb!=0)); if (sclhi(adap)<0) { /* timed out */ sdahi(adap); /* we don't want to block the net */ return -ETIMEDOUT; @@ -201,10 +201,10 @@ }; /* read ack: SDA should be pulled down by slave */ ack=getsda(adap); /* ack: sda is pulled low ->success. */ - DEB2(printk(" i2c_outb: getsda() = 0x%2.2x\n", ~ack )); + DEB2(printk(KERN_DEBUG " i2c_outb: getsda() = 0x%2.2x\n", ~ack )); - DEBPROTO( printk("[%2.2x]",c&0xff) ); - DEBPROTO(if (0==ack){ printk(" A ");} else printk(" NA ") ); + DEBPROTO( printk(KERN_DEBUG "[%2.2x]",c&0xff) ); + DEBPROTO(if (0==ack){ printk(KERN_DEBUG " A ");} else printk(KERN_DEBUG " NA ") ); scllo(adap); return 0==ack; /* return 1 if device acked */ /* assert: scl is low (sda undef) */ @@ -220,7 +220,7 @@ struct i2c_algo_bit_data *adap = i2c_adap->algo_data; /* assert: scl is low */ - DEB2(printk("i2c_inb.\n")); + DEB2(printk(KERN_DEBUG "i2c_inb.\n")); sdahi(adap); for (i=0;i<8;i++) { @@ -233,7 +233,7 @@ scllo(adap); } /* assert: scl is low */ - DEBPROTO(printk(" %2.2x", indata & 0xff)); + DEBPROTO(printk(KERN_DEBUG " 0x%02x", indata & 0xff)); return (int) (indata & 0xff); } @@ -341,7 +341,7 @@ i2c_start(adap); udelay(adap->udelay); } - DEB2(if (i) printk("i2c-algo-bit.o: needed %d retries for %d\n", + DEB2(if (i) printk(KERN_DEBUG "i2c-algo-bit.o: needed %d retries for %d\n", i,addr)); return ret; } @@ -356,7 +356,7 @@ while (count > 0) { c = *temp; - DEB2(printk("i2c-algo-bit.o: %s i2c_write: writing %2.2X\n", + DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: %s sendbytes: writing %2.2X\n", i2c_adap->name, c&0xff)); retval = i2c_outb(i2c_adap,c); if (retval>0) { @@ -364,7 +364,7 @@ temp++; wrcount++; } else { /* arbitration or no acknowledge */ - printk("i2c-algo-bit.o: %s i2c_write: error - bailout.\n", + printk(KERN_ERR "i2c-algo-bit.o: %s sendbytes: error - bailout.\n", i2c_adap->name); i2c_stop(adap); return (retval<0)? retval : -EFAULT; @@ -392,7 +392,7 @@ *temp = inval; rdcount++; } else { /* read timed out */ - printk("i2c-algo-bit.o: i2c_read: i2c_inb timed out.\n"); + printk(KERN_ERR "i2c-algo-bit.o: readbytes: i2c_inb timed out.\n"); break; } @@ -405,7 +405,7 @@ } if (sclhi(adap)<0) { /* timeout */ sdahi(adap); - printk("i2c-algo-bit.o: i2c_read: Timeout at ack\n"); + printk(KERN_ERR "i2c-algo-bit.o: readbytes: Timeout at ack\n"); return -ETIMEDOUT; }; scllo(adap); @@ -435,18 +435,18 @@ if ( (flags & I2C_M_TEN) ) { /* a ten bit address */ addr = 0xf0 | (( msg->addr >> 7) & 0x03); - DEB2(printk("addr0: %d\n",addr)); + DEB2(printk(KERN_DEBUG "addr0: %d\n",addr)); /* try extended address code...*/ ret = try_address(i2c_adap, addr, retries); if (ret!=1) { - printk("died at extended address code.\n"); + printk(KERN_ERR "died at extended address code.\n"); return -EREMOTEIO; } /* the remaining 8 bit address */ ret = i2c_outb(i2c_adap,msg->addr & 0x7f); if (ret != 1) { /* the chip did not ack / xmission error occurred */ - printk("died at 2nd address code.\n"); + printk(KERN_ERR "died at 2nd address code.\n"); return -EREMOTEIO; } if ( flags & I2C_M_RD ) { @@ -455,7 +455,7 @@ addr |= 0x01; ret = try_address(i2c_adap, addr, retries); if (ret!=1) { - printk("died at extended address code.\n"); + printk(KERN_ERR "died at extended address code.\n"); return -EREMOTEIO; } } @@ -490,22 +490,22 @@ } ret = bit_doAddress(i2c_adap,pmsg,i2c_adap->retries); if (ret != 0) { - DEB2(printk("i2c-algo-bit.o: NAK from device adr %#2x msg #%d\n" - ,msgs[i].addr,i)); + DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: NAK from device addr %2.2x msg #%d\n", + msgs[i].addr,i)); return (ret<0) ? ret : -EREMOTEIO; } } if (pmsg->flags & I2C_M_RD ) { /* read bytes into buffer*/ ret = readbytes(i2c_adap,pmsg->buf,pmsg->len); - DEB2(printk("i2c-algo-bit.o: read %d bytes.\n",ret)); + DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: read %d bytes.\n",ret)); if (ret < pmsg->len ) { return (ret<0)? ret : -EREMOTEIO; } } else { /* write bytes from buffer */ ret = sendbytes(i2c_adap,pmsg->buf,pmsg->len); - DEB2(printk("i2c-algo-bit.o: wrote %d bytes.\n",ret)); + DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: wrote %d bytes.\n",ret)); if (ret < pmsg->len ) { return (ret<0) ? ret : -EREMOTEIO; } @@ -555,7 +555,7 @@ return -ENODEV; } - DEB2(printk("i2c-algo-bit.o: hw routines for %s registered.\n", + DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: hw routines for %s registered.\n", adap->name)); /* register new adapter to i2c module... */ diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-algo-pcf.c linux-2.4.24-pre1-k/drivers/i2c/i2c-algo-pcf.c --- linux-2.4.24-pre1/drivers/i2c/i2c-algo-pcf.c Thu Oct 11 17:05:47 2001 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-algo-pcf.c Thu Dec 11 22:25:42 2003 @@ -99,7 +99,7 @@ } #endif if (timeout <= 0) { - printk("Timeout waiting for Bus Busy\n"); + printk(KERN_ERR "Timeout waiting for Bus Busy\n"); } return (timeout<=0); @@ -144,7 +144,7 @@ { unsigned char temp; - DEB3(printk("i2c-algo-pcf.o: PCF state 0x%02x\n", get_pcf(adap, 1))); + DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n", get_pcf(adap, 1))); /* S1=0x80: S0 selected, serial interface off */ set_pcf(adap, 1, I2C_PCF_PIN); @@ -152,7 +152,7 @@ PCF8584 does that when ESO is zero */ /* PCF also resets PIN bit */ if ((temp = get_pcf(adap, 1)) != (0)) { - DEB2(printk("i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp)); + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp)); return -ENXIO; /* definetly not PCF8584 */ } @@ -160,7 +160,7 @@ i2c_outb(adap, get_own(adap)); /* check it's realy writen */ if ((temp = i2c_inb(adap)) != get_own(adap)) { - DEB2(printk("i2c-algo-pcf.o: PCF detection failed -- can't set S0 (0x%02x).\n", temp)); + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S0 (0x%02x).\n", temp)); return -ENXIO; } @@ -168,7 +168,7 @@ set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1); /* check to see S2 now selected */ if ((temp = get_pcf(adap, 1)) != I2C_PCF_ES1) { - DEB2(printk("i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp)); + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp)); return -ENXIO; } @@ -176,7 +176,7 @@ i2c_outb(adap, get_clock(adap)); /* check it's realy writen, the only 5 lowest bits does matter */ if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) { - DEB2(printk("i2c-algo-pcf.o: PCF detection failed -- can't set S2 (0x%02x).\n", temp)); + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S2 (0x%02x).\n", temp)); return -ENXIO; } @@ -185,11 +185,11 @@ /* check to see PCF is realy idled and we can access status register */ if ((temp = get_pcf(adap, 1)) != (I2C_PCF_PIN | I2C_PCF_BB)) { - DEB2(printk("i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp)); + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp)); return -ENXIO; } - printk("i2c-algo-pcf.o: deteted and initialized PCF8584.\n"); + printk(KERN_DEBUG "i2c-algo-pcf.o: deteted and initialized PCF8584.\n"); return 0; } @@ -215,7 +215,7 @@ i2c_stop(adap); udelay(adap->udelay); } - DEB2(if (i) printk("i2c-algo-pcf.o: needed %d retries for %d\n",i, + DEB2(if (i) printk(KERN_DEBUG "i2c-algo-pcf.o: needed %d retries for %d\n",i, addr)); return ret; } @@ -228,20 +228,20 @@ int wrcount, status, timeout; for (wrcount=0; wrcountname, buf[wrcount]&0xff)); i2c_outb(adap, buf[wrcount]); timeout = wait_for_pin(adap, &status); if (timeout) { i2c_stop(adap); - printk("i2c-algo-pcf.o: %s i2c_write: " + printk(KERN_ERR "i2c-algo-pcf.o: %s i2c_write: " "error - timeout.\n", i2c_adap->name); return -EREMOTEIO; /* got a better one ?? */ } #ifndef STUB_I2C if (status & I2C_PCF_LRB) { i2c_stop(adap); - printk("i2c-algo-pcf.o: %s i2c_write: " + printk(KERN_ERR "i2c-algo-pcf.o: %s i2c_write: " "error - no ack.\n", i2c_adap->name); return -EREMOTEIO; /* got a better one ?? */ } @@ -269,14 +269,14 @@ if (wait_for_pin(adap, &status)) { i2c_stop(adap); - printk("i2c-algo-pcf.o: pcf_readbytes timed out.\n"); + printk(KERN_ERR "i2c-algo-pcf.o: pcf_readbytes timed out.\n"); return (-1); } #ifndef STUB_I2C if ((status & I2C_PCF_LRB) && (i != count)) { i2c_stop(adap); - printk("i2c-algo-pcf.o: i2c_read: i2c_inb, No ack.\n"); + printk(KERN_ERR "i2c-algo-pcf.o: i2c_read: i2c_inb, No ack.\n"); return (-1); } #endif @@ -312,18 +312,18 @@ if ( (flags & I2C_M_TEN) ) { /* a ten bit address */ addr = 0xf0 | (( msg->addr >> 7) & 0x03); - DEB2(printk("addr0: %d\n",addr)); + DEB2(printk(KERN_DEBUG "addr0: %d\n",addr)); /* try extended address code...*/ ret = try_address(adap, addr, retries); if (ret!=1) { - printk("died at extended address code.\n"); + printk(KERN_ERR "died at extended address code.\n"); return -EREMOTEIO; } /* the remaining 8 bit address */ i2c_outb(adap,msg->addr & 0x7f); /* Status check comes here */ if (ret != 1) { - printk("died at 2nd address code.\n"); + printk(KERN_ERR "died at 2nd address code.\n"); return -EREMOTEIO; } if ( flags & I2C_M_RD ) { @@ -332,7 +332,7 @@ addr |= 0x01; ret = try_address(adap, addr, retries); if (ret!=1) { - printk("died at extended address code.\n"); + printk(KERN_ERR "died at extended address code.\n"); return -EREMOTEIO; } } @@ -360,7 +360,7 @@ /* Check for bus busy */ timeout = wait_for_bb(adap); if (timeout) { - DEB2(printk("i2c-algo-pcf.o: " + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: " "Timeout waiting for BB in pcf_xfer\n");) return -EIO; } @@ -368,7 +368,7 @@ for (i = 0;ret >= 0 && i < num; i++) { pmsg = &msgs[i]; - DEB2(printk("i2c-algo-pcf.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n", + DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n", pmsg->flags & I2C_M_RD ? "read" : "write", pmsg->len, pmsg->addr, i + 1, num);) @@ -383,7 +383,7 @@ timeout = wait_for_pin(adap, &status); if (timeout) { i2c_stop(adap); - DEB2(printk("i2c-algo-pcf.o: Timeout waiting " + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: Timeout waiting " "for PIN(1) in pcf_xfer\n");) return (-EREMOTEIO); } @@ -392,12 +392,12 @@ /* Check LRB (last rcvd bit - slave ack) */ if (status & I2C_PCF_LRB) { i2c_stop(adap); - DEB2(printk("i2c-algo-pcf.o: No LRB(1) in pcf_xfer\n");) + DEB2(printk(KERN_ERR "i2c-algo-pcf.o: No LRB(1) in pcf_xfer\n");) return (-EREMOTEIO); } #endif - DEB3(printk("i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", + DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", i, msgs[i].addr, msgs[i].flags, msgs[i].len);) /* Read */ @@ -407,20 +407,20 @@ (i + 1 == num)); if (ret != pmsg->len) { - DEB2(printk("i2c-algo-pcf.o: fail: " + DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " "only read %d bytes.\n",ret)); } else { - DEB2(printk("i2c-algo-pcf.o: read %d bytes.\n",ret)); + DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: read %d bytes.\n",ret)); } } else { /* Write */ ret = pcf_sendbytes(i2c_adap, pmsg->buf, pmsg->len, (i + 1 == num)); if (ret != pmsg->len) { - DEB2(printk("i2c-algo-pcf.o: fail: " + DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " "only wrote %d bytes.\n",ret)); } else { - DEB2(printk("i2c-algo-pcf.o: wrote %d bytes.\n",ret)); + DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: wrote %d bytes.\n",ret)); } } } @@ -461,7 +461,7 @@ int i, status; struct i2c_algo_pcf_data *pcf_adap = adap->algo_data; - DEB2(printk("i2c-algo-pcf.o: hw routines for %s registered.\n", + DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: hw routines for %s registered.\n", adap->name)); /* register new adapter to i2c module... */ diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-core.c linux-2.4.24-pre1-k/drivers/i2c/i2c-core.c --- linux-2.4.24-pre1/drivers/i2c/i2c-core.c Mon Aug 25 13:44:41 2003 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-core.c Sat Dec 13 14:54:25 2003 @@ -188,7 +188,7 @@ drivers[j]->attach_adapter(adap); DRV_UNLOCK(); - DEB(printk("i2c-core.o: adapter %s registered as adapter %d.\n", + DEB(printk(KERN_DEBUG "i2c-core.o: adapter %s registered as adapter %d.\n", adap->name,i)); return 0; @@ -214,7 +214,7 @@ if (adap == adapters[i]) break; if (I2C_ADAP_MAX == i) { - printk( "i2c-core.o: unregister_adapter adap [%s] not found.\n", + printk(KERN_WARNING "i2c-core.o: unregister_adapter adap [%s] not found.\n", adap->name); res = -ENODEV; goto ERROR0; @@ -229,7 +229,7 @@ for (j = 0; j < I2C_DRIVER_MAX; j++) if (drivers[j] && (drivers[j]->flags & I2C_DF_DUMMY)) if ((res = drivers[j]->attach_adapter(adap))) { - printk("i2c-core.o: can't detach adapter %s " + printk(KERN_WARNING "i2c-core.o: can't detach adapter %s " "while detaching driver %s: driver not " "detached!",adap->name,drivers[j]->name); goto ERROR1; @@ -247,7 +247,7 @@ * must be deleted, as this would cause invalid states. */ if ((res=client->driver->detach_client(client))) { - printk("i2c-core.o: adapter %s not " + printk(KERN_ERR "i2c-core.o: adapter %s not " "unregistered, because client at " "address %02x can't be detached. ", adap->name, client->addr); @@ -266,7 +266,7 @@ adap_count--; ADAP_UNLOCK(); - DEB(printk("i2c-core.o: adapter unregistered: %s\n",adap->name)); + DEB(printk(KERN_DEBUG "i2c-core.o: adapter unregistered: %s\n",adap->name)); return 0; ERROR0: @@ -305,7 +305,7 @@ DRV_UNLOCK(); /* driver was successfully added */ - DEB(printk("i2c-core.o: driver %s registered.\n",driver->name)); + DEB(printk(KERN_DEBUG "i2c-core.o: driver %s registered.\n",driver->name)); ADAP_LOCK(); @@ -340,7 +340,7 @@ * attached. If so, detach them to be able to kill the driver * afterwards. */ - DEB2(printk("i2c-core.o: unregister_driver - looking for clients.\n")); + DEB2(printk(KERN_DEBUG "i2c-core.o: unregister_driver - looking for clients.\n")); /* removing clients does not depend on the notify flag, else * invalid operation might (will!) result, when using stale client * pointers. @@ -350,7 +350,7 @@ struct i2c_adapter *adap = adapters[k]; if (adap == NULL) /* skip empty entries. */ continue; - DEB2(printk("i2c-core.o: examining adapter %s:\n", + DEB2(printk(KERN_DEBUG "i2c-core.o: examining adapter %s:\n", adap->name)); if (driver->flags & I2C_DF_DUMMY) { /* DUMMY drivers do not register their clients, so we have to @@ -359,7 +359,7 @@ * this or hell will break loose... */ if ((res = driver->attach_adapter(adap))) { - printk("i2c-core.o: while unregistering " + printk(KERN_WARNING "i2c-core.o: while unregistering " "dummy driver %s, adapter %s could " "not be detached properly; driver " "not unloaded!",driver->name, @@ -372,13 +372,13 @@ struct i2c_client *client = adap->clients[j]; if (client != NULL && client->driver == driver) { - DEB2(printk("i2c-core.o: " + DEB2(printk(KERN_DEBUG "i2c-core.o: " "detaching client %s:\n", client->name)); if ((res = driver-> detach_client(client))) { - printk("i2c-core.o: while " + printk(KERN_ERR "i2c-core.o: while " "unregistering driver " "`%s', the client at " "address %02x of " @@ -400,7 +400,7 @@ driver_count--; DRV_UNLOCK(); - DEB(printk("i2c-core.o: driver unregistered: %s\n",driver->name)); + DEB(printk(KERN_DEBUG "i2c-core.o: driver unregistered: %s\n",driver->name)); return 0; } @@ -436,10 +436,10 @@ if (adapter->client_register) if (adapter->client_register(client)) - printk("i2c-core.o: warning: client_register seems " + printk(KERN_DEBUG "i2c-core.o: warning: client_register seems " "to have failed for client %02x at adapter %s\n", client->addr,adapter->name); - DEB(printk("i2c-core.o: client [%s] registered to adapter [%s](pos. %d).\n", + DEB(printk(KERN_DEBUG "i2c-core.o: client [%s] registered to adapter [%s](pos. %d).\n", client->name, adapter->name,i)); if(client->flags & I2C_CLIENT_ALLOW_USE) @@ -470,7 +470,7 @@ if (adapter->client_unregister != NULL) if ((res = adapter->client_unregister(client))) { - printk("i2c-core.o: client_unregister [%s] failed, " + printk(KERN_ERR "i2c-core.o: client_unregister [%s] failed, " "client not detached",client->name); return res; } @@ -478,7 +478,7 @@ adapter->clients[i] = NULL; adapter->client_count--; - DEB(printk("i2c-core.o: client [%s] unregistered.\n",client->name)); + DEB(printk(KERN_DEBUG "i2c-core.o: client [%s] unregistered.\n",client->name)); return 0; } @@ -727,7 +727,7 @@ } proc_bus_i2c = create_proc_entry("i2c",0,proc_bus); if (!proc_bus_i2c) { - printk("i2c-core.o: Could not create /proc/bus/i2c"); + printk(KERN_ERR "i2c-core.o: Could not create /proc/bus/i2c"); i2cproc_cleanup(); return -ENOENT; } @@ -764,7 +764,7 @@ int ret; if (adap->algo->master_xfer) { - DEB2(printk("i2c-core.o: master_xfer: %s with %d msgs.\n", + DEB2(printk(KERN_DEBUG "i2c-core.o: master_xfer: %s with %d msgs.\n", adap->name,num)); I2C_LOCK(adap); @@ -773,7 +773,7 @@ return ret; } else { - printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", + printk(KERN_ERR "i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", adap->id); return -ENOSYS; } @@ -791,7 +791,7 @@ msg.len = count; (const char *)msg.buf = buf; - DEB2(printk("i2c-core.o: master_send: writing %d bytes on %s.\n", + DEB2(printk(KERN_DEBUG "i2c-core.o: master_send: writing %d bytes on %s.\n", count,client->adapter->name)); I2C_LOCK(adap); @@ -803,7 +803,7 @@ */ return (ret == 1 )? count : ret; } else { - printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", + printk(KERN_ERR "i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", client->adapter->id); return -ENOSYS; } @@ -821,14 +821,14 @@ msg.len = count; msg.buf = buf; - DEB2(printk("i2c-core.o: master_recv: reading %d bytes on %s.\n", + DEB2(printk(KERN_DEBUG "i2c-core.o: master_recv: reading %d bytes on %s.\n", count,client->adapter->name)); I2C_LOCK(adap); ret = adap->algo->master_xfer(adap,&msg,1); I2C_UNLOCK(adap); - DEB2(printk("i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)\n", + DEB2(printk(KERN_DEBUG "i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)\n", ret, count, client->addr)); /* if everything went ok (i.e. 1 msg transmitted), return #bytes @@ -836,7 +836,7 @@ */ return (ret == 1 )? count : ret; } else { - printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", + printk(KERN_ERR "i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", client->adapter->id); return -ENOSYS; } @@ -849,7 +849,7 @@ int ret = 0; struct i2c_adapter *adap = client->adapter; - DEB2(printk("i2c-core.o: i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg)); + DEB2(printk(KERN_DEBUG "i2c-core.o: i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg)); switch ( cmd ) { case I2C_RETRIES: adap->retries = arg; @@ -894,7 +894,7 @@ if (((adap_id == address_data->force[i]) || (address_data->force[i] == ANY_I2C_BUS)) && (addr == address_data->force[i+1])) { - DEB2(printk("i2c-core.o: found force parameter for adapter %d, addr %04x\n", + DEB2(printk(KERN_DEBUG "i2c-core.o: found force parameter for adapter %d, addr %04x\n", adap_id,addr)); if ((err = found_proc(adapter,addr,0,0))) return err; @@ -912,7 +912,7 @@ if (((adap_id == address_data->ignore[i]) || ((address_data->ignore[i] == ANY_I2C_BUS))) && (addr == address_data->ignore[i+1])) { - DEB2(printk("i2c-core.o: found ignore parameter for adapter %d, " + DEB2(printk(KERN_DEBUG "i2c-core.o: found ignore parameter for adapter %d, " "addr %04x\n", adap_id ,addr)); found = 1; } @@ -924,7 +924,7 @@ ((address_data->ignore_range[i]==ANY_I2C_BUS))) && (addr >= address_data->ignore_range[i+1]) && (addr <= address_data->ignore_range[i+2])) { - DEB2(printk("i2c-core.o: found ignore_range parameter for adapter %d, " + DEB2(printk(KERN_DEBUG "i2c-core.o: found ignore_range parameter for adapter %d, " "addr %04x\n", adap_id,addr)); found = 1; } @@ -939,7 +939,7 @@ i += 1) { if (addr == address_data->normal_i2c[i]) { found = 1; - DEB2(printk("i2c-core.o: found normal i2c entry for adapter %d, " + DEB2(printk(KERN_DEBUG "i2c-core.o: found normal i2c entry for adapter %d, " "addr %02x", adap_id,addr)); } } @@ -950,7 +950,7 @@ if ((addr >= address_data->normal_i2c_range[i]) && (addr <= address_data->normal_i2c_range[i+1])) { found = 1; - DEB2(printk("i2c-core.o: found normal i2c_range entry for adapter %d, " + DEB2(printk(KERN_DEBUG "i2c-core.o: found normal i2c_range entry for adapter %d, " "addr %04x\n", adap_id,addr)); } } @@ -962,7 +962,7 @@ ((address_data->probe[i] == ANY_I2C_BUS))) && (addr == address_data->probe[i+1])) { found = 1; - DEB2(printk("i2c-core.o: found probe parameter for adapter %d, " + DEB2(printk(KERN_DEBUG "i2c-core.o: found probe parameter for adapter %d, " "addr %04x\n", adap_id,addr)); } } @@ -974,7 +974,7 @@ (addr >= address_data->probe_range[i+1]) && (addr <= address_data->probe_range[i+2])) { found = 1; - DEB2(printk("i2c-core.o: found probe_range parameter for adapter %d, " + DEB2(printk(KERN_DEBUG "i2c-core.o: found probe_range parameter for adapter %d, " "addr %04x\n", adap_id,addr)); } } @@ -1186,13 +1186,13 @@ break; case I2C_SMBUS_BLOCK_DATA: if (read_write == I2C_SMBUS_READ) { - printk("i2c-core.o: Block read not supported under " - "I2C emulation!\n"); - return -1; + printk(KERN_ERR "i2c-core.o: Block read not supported " + "under I2C emulation!\n"); + return -1; } else { msg[0].len = data->block[0] + 2; if (msg[0].len > 34) { - printk("i2c-core.o: smbus_access called with " + printk(KERN_ERR "i2c-core.o: smbus_access called with " "invalid block write size (%d)\n", msg[0].len); return -1; @@ -1202,7 +1202,7 @@ } break; default: - printk("i2c-core.o: smbus_access called with invalid size (%d)\n", + printk(KERN_ERR "i2c-core.o: smbus_access called with invalid size (%d)\n", size); return -1; } @@ -1264,7 +1264,7 @@ static int __init i2c_init(void) { - printk(KERN_INFO "i2c-core.o: i2c core module\n"); + printk(KERN_INFO "i2c-core.o: i2c core module version %s (%s)\n", I2C_VERSION, I2C_DATE); memset(adapters,0,sizeof(adapters)); memset(drivers,0,sizeof(drivers)); adap_count=0; diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-dev.c linux-2.4.24-pre1-k/drivers/i2c/i2c-dev.c --- linux-2.4.24-pre1/drivers/i2c/i2c-dev.c Mon Aug 25 13:44:41 2003 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-dev.c Sat Dec 13 14:56:48 2003 @@ -168,7 +168,7 @@ return -ENOMEM; #ifdef DEBUG - printk("i2c-dev.o: i2c-%d reading %d bytes.\n",MINOR(inode->i_rdev), + printk(KERN_DEBUG "i2c-dev.o: i2c-%d reading %d bytes.\n",MINOR(inode->i_rdev), count); #endif @@ -203,7 +203,7 @@ } #ifdef DEBUG - printk("i2c-dev.o: i2c-%d writing %d bytes.\n",MINOR(inode->i_rdev), + printk(KERN_DEBUG "i2c-dev.o: i2c-%d writing %d bytes.\n",MINOR(inode->i_rdev), count); #endif ret = i2c_master_send(client,tmp,count); @@ -224,7 +224,7 @@ unsigned long funcs; #ifdef DEBUG - printk("i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n", + printk(KERN_DEBUG "i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n", MINOR(inode->i_rdev),cmd, arg); #endif /* DEBUG */ @@ -346,7 +346,7 @@ (data_arg.size != I2C_SMBUS_BLOCK_DATA) && (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA)) { #ifdef DEBUG - printk("i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.\n", + printk(KERN_DEBUG "i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.\n", data_arg.size); #endif return -EINVAL; @@ -356,7 +356,7 @@ if ((data_arg.read_write != I2C_SMBUS_READ) && (data_arg.read_write != I2C_SMBUS_WRITE)) { #ifdef DEBUG - printk("i2c-dev.o: read_write out of range (%x) in ioctl I2C_SMBUS.\n", + printk(KERN_DEBUG "i2c-dev.o: read_write out of range (%x) in ioctl I2C_SMBUS.\n", data_arg.read_write); #endif return -EINVAL; @@ -376,7 +376,7 @@ if (data_arg.data == NULL) { #ifdef DEBUG - printk("i2c-dev.o: data is NULL pointer in ioctl I2C_SMBUS.\n"); + printk(KERN_DEBUG "i2c-dev.o: data is NULL pointer in ioctl I2C_SMBUS.\n"); #endif return -EINVAL; } @@ -418,7 +418,7 @@ if ((minor >= I2CDEV_ADAPS_MAX) || ! (i2cdev_adaps[minor])) { #ifdef DEBUG - printk("i2c-dev.o: Trying to open unattached adapter i2c-%d\n", + printk(KERN_DEBUG "i2c-dev.o: Trying to open unattached adapter i2c-%d\n", minor); #endif return -ENODEV; @@ -439,7 +439,7 @@ #endif /* LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,0) */ #ifdef DEBUG - printk("i2c-dev.o: opened i2c-%d\n",minor); + printk(KERN_DEBUG "i2c-dev.o: opened i2c-%d\n",minor); #endif return 0; } @@ -450,7 +450,7 @@ kfree(file->private_data); file->private_data=NULL; #ifdef DEBUG - printk("i2c-dev.o: Closed: i2c-%d\n", minor); + printk(KERN_DEBUG "i2c-dev.o: Closed: i2c-%d\n", minor); #endif #if LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,0) MOD_DEC_USE_COUNT; @@ -471,11 +471,11 @@ char name[8]; if ((i = i2c_adapter_id(adap)) < 0) { - printk("i2c-dev.o: Unknown adapter ?!?\n"); + printk(KERN_DEBUG "i2c-dev.o: Unknown adapter ?!?\n"); return -ENODEV; } if (i >= I2CDEV_ADAPS_MAX) { - printk("i2c-dev.o: Adapter number too large?!? (%d)\n",i); + printk(KERN_DEBUG "i2c-dev.o: Adapter number too large?!? (%d)\n",i); return -ENODEV; } @@ -488,7 +488,7 @@ S_IFCHR | S_IRUSR | S_IWUSR, &i2cdev_fops, NULL); #endif - printk("i2c-dev.o: Registered '%s' as minor %d\n",adap->name,i); + printk(KERN_DEBUG "i2c-dev.o: Registered '%s' as minor %d\n",adap->name,i); } else { /* This is actually a detach_adapter call! */ #ifdef CONFIG_DEVFS_FS @@ -496,7 +496,7 @@ #endif i2cdev_adaps[i] = NULL; #ifdef DEBUG - printk("i2c-dev.o: Adapter unregistered: %s\n",adap->name); + printk(KERN_DEBUG "i2c-dev.o: Adapter unregistered: %s\n",adap->name); #endif } @@ -518,7 +518,7 @@ { int res; - printk("i2c-dev.o: i2c /dev entries driver module\n"); + printk(KERN_INFO "i2c-dev.o: i2c /dev entries driver module version %s (%s)\n", I2C_VERSION, I2C_DATE); i2cdev_initialized = 0; #ifdef CONFIG_DEVFS_FS @@ -526,7 +526,7 @@ #else if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) { #endif - printk("i2c-dev.o: unable to get major %d for i2c bus\n", + printk(KERN_ERR "i2c-dev.o: unable to get major %d for i2c bus\n", I2C_MAJOR); return -EIO; } @@ -536,7 +536,7 @@ i2cdev_initialized ++; if ((res = i2c_add_driver(&i2cdev_driver))) { - printk("i2c-dev.o: Driver registration failed, module not inserted.\n"); + printk(KERN_ERR "i2c-dev.o: Driver registration failed, module not inserted.\n"); i2cdev_cleanup(); return res; } diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-elektor.c linux-2.4.24-pre1-k/drivers/i2c/i2c-elektor.c --- linux-2.4.24-pre1/drivers/i2c/i2c-elektor.c Thu Oct 11 17:05:47 2001 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-elektor.c Sat Dec 13 14:59:00 2003 @@ -78,7 +78,7 @@ val |= I2C_PCF_ENI; } - DEB3(printk("i2c-elektor.o: Write 0x%X 0x%02X\n", address, val & 255)); + DEB3(printk(KERN_DEBUG "i2c-elektor.o: Write 0x%X 0x%02X\n", address, val & 255)); switch (mmapped) { case 0: /* regular I/O */ @@ -99,7 +99,7 @@ int address = ctl ? (base + 1) : base; int val = mmapped ? readb(address) : inb(address); - DEB3(printk("i2c-elektor.o: Read 0x%X 0x%02X\n", address, val)); + DEB3(printk(KERN_DEBUG "i2c-elektor.o: Read 0x%X 0x%02X\n", address, val)); return (val); } @@ -142,7 +142,9 @@ { if (!mmapped) { if (check_region(base, 2) < 0 ) { - printk("i2c-elektor.o: requested I/O region (0x%X:2) is in use.\n", base); + printk(KERN_ERR + "i2c-elektor.o: requested I/O region (0x%X:2) " + "is in use.\n", base); return -ENODEV; } else { request_region(base, 2, "i2c (isa bus adapter)"); @@ -150,7 +152,7 @@ } if (irq > 0) { if (request_irq(irq, pcf_isa_handler, 0, "PCF8584", 0) < 0) { - printk("i2c-elektor.o: Request irq%d failed\n", irq); + printk(KERN_ERR "i2c-elektor.o: Request irq%d failed\n", irq); irq = 0; } else enable_irq(irq); @@ -238,7 +240,7 @@ /* yeap, we've found cypress, let's check config */ if (!pci_read_config_byte(cy693_dev, 0x47, &config)) { - DEB3(printk("i2c-elektor.o: found cy82c693, config register 0x47 = 0x%02x.\n", config)); + DEB3(printk(KERN_DEBUG "i2c-elektor.o: found cy82c693, config register 0x47 = 0x%02x.\n", config)); /* UP2000 board has this register set to 0xe1, but the most significant bit as seems can be @@ -260,7 +262,7 @@ 8.25 MHz (PCI/4) clock (this can be read from cypress) */ clock = I2C_PCF_CLK | I2C_PCF_TRNS90; - printk("i2c-elektor.o: found API UP2000 like board, will probe PCF8584 later.\n"); + printk(KERN_INFO "i2c-elektor.o: found API UP2000 like board, will probe PCF8584 later.\n"); } } } @@ -269,11 +271,11 @@ /* sanity checks for mmapped I/O */ if (mmapped && base < 0xc8000) { - printk("i2c-elektor.o: incorrect base address (0x%0X) specified for mmapped I/O.\n", base); + printk(KERN_ERR "i2c-elektor.o: incorrect base address (0x%0X) specified for mmapped I/O.\n", base); return -ENODEV; } - printk("i2c-elektor.o: i2c pcf8584-isa adapter module\n"); + printk(KERN_INFO "i2c-elektor.o: i2c pcf8584-isa adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE); if (base == 0) { base = DEFAULT_BASE; @@ -289,7 +291,7 @@ return -ENODEV; } - printk("i2c-elektor.o: found device at %#x.\n", base); + printk(KERN_DEBUG "i2c-elektor.o: found device at %#x.\n", base); return 0; } diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-elv.c linux-2.4.24-pre1-k/drivers/i2c/i2c-elv.c --- linux-2.4.24-pre1/drivers/i2c/i2c-elv.c Thu Oct 11 17:05:47 2001 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-elv.c Sat Dec 13 15:04:18 2003 @@ -95,14 +95,14 @@ } else { /* test for ELV adap. */ if (inb(base+1) & 0x80) { /* BUSY should be high */ - DEBINIT(printk("i2c-elv.o: Busy was low.\n")); + DEBINIT(printk(KERN_DEBUG "i2c-elv.o: Busy was low.\n")); return -ENODEV; } else { outb(0x0c,base+2); /* SLCT auf low */ udelay(400); if ( !(inb(base+1) && 0x10) ) { outb(0x04,base+2); - DEBINIT(printk("i2c-elv.o: Select was high.\n")); + DEBINIT(printk(KERN_DEBUG "i2c-elv.o: Select was high.\n")); return -ENODEV; } } @@ -170,7 +170,7 @@ int __init i2c_bitelv_init(void) { - printk("i2c-elv.o: i2c ELV parallel port adapter module\n"); + printk(KERN_INFO "i2c-elv.o: i2c ELV parallel port adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE); if (base==0) { /* probe some values */ base=DEFAULT_BASE; @@ -190,7 +190,7 @@ return -ENODEV; } } - printk("i2c-elv.o: found device at %#x.\n",base); + printk(KERN_DEBUG "i2c-elv.o: found device at %#x.\n",base); return 0; } diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-philips-par.c linux-2.4.24-pre1-k/drivers/i2c/i2c-philips-par.c --- linux-2.4.24-pre1/drivers/i2c/i2c-philips-par.c Sun Sep 30 21:26:05 2001 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-philips-par.c Sat Dec 13 15:07:53 2003 @@ -190,18 +190,18 @@ struct i2c_par *adapter = kmalloc(sizeof(struct i2c_par), GFP_KERNEL); if (!adapter) { - printk("i2c-philips-par: Unable to malloc.\n"); + printk(KERN_ERR "i2c-philips-par: Unable to malloc.\n"); return; } - printk("i2c-philips-par.o: attaching to %s\n", port->name); + printk(KERN_DEBUG "i2c-philips-par.o: attaching to %s\n", port->name); adapter->pdev = parport_register_device(port, "i2c-philips-par", NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL); if (!adapter->pdev) { - printk("i2c-philips-par: Unable to register with parport.\n"); + printk(KERN_ERR "i2c-philips-par: Unable to register with parport.\n"); return; } @@ -218,7 +218,7 @@ if (i2c_bit_add_bus(&adapter->adapter) < 0) { - printk("i2c-philips-par: Unable to register with I2C.\n"); + printk(KERN_ERR "i2c-philips-par: Unable to register with I2C.\n"); parport_unregister_device(adapter->pdev); kfree(adapter); return; /* No good */ @@ -264,7 +264,7 @@ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,4) struct parport *port; #endif - printk("i2c-philips-par.o: i2c Philips parallel port adapter module\n"); + printk(KERN_INFO "i2c-philips-par.o: i2c Philips parallel port adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,4) parport_register_driver(&i2c_driver); diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-proc.c linux-2.4.24-pre1-k/drivers/i2c/i2c-proc.c --- linux-2.4.24-pre1/drivers/i2c/i2c-proc.c Fri Jun 13 16:51:33 2003 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-proc.c Sat Dec 13 15:13:13 2003 @@ -38,10 +38,6 @@ #include -/* FIXME need i2c versioning */ -#define LM_DATE "20010825" -#define LM_VERSION "2.6.1" - #ifndef THIS_MODULE #define THIS_MODULE NULL #endif @@ -684,7 +680,7 @@ && (addr == this_force->force[j + 1])) { #ifdef DEBUG printk - ("i2c-proc.o: found force parameter for adapter %d, addr %04x\n", + (KERN_DEBUG "i2c-proc.o: found force parameter for adapter %d, addr %04x\n", adapter_id, addr); #endif if ( @@ -714,7 +710,7 @@ && (addr == address_data->ignore[i + 1])) { #ifdef DEBUG printk - ("i2c-proc.o: found ignore parameter for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found ignore parameter for adapter %d, " "addr %04x\n", adapter_id, addr); #endif found = 1; @@ -734,7 +730,7 @@ && (addr <= address_data->ignore_range[i + 2])) { #ifdef DEBUG printk - ("i2c-proc.o: found ignore_range parameter for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found ignore_range parameter for adapter %d, " "addr %04x\n", adapter_id, addr); #endif found = 1; @@ -753,7 +749,7 @@ if (addr == address_data->normal_isa[i]) { #ifdef DEBUG printk - ("i2c-proc.o: found normal isa entry for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found normal isa entry for adapter %d, " "addr %04x\n", adapter_id, addr); #endif @@ -775,7 +771,7 @@ 0)) { #ifdef DEBUG printk - ("i2c-proc.o: found normal isa_range entry for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found normal isa_range entry for adapter %d, " "addr %04x", adapter_id, addr); #endif found = 1; @@ -789,7 +785,7 @@ found = 1; #ifdef DEBUG printk - ("i2c-proc.o: found normal i2c entry for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found normal i2c entry for adapter %d, " "addr %02x", adapter_id, addr); #endif } @@ -805,7 +801,7 @@ { #ifdef DEBUG printk - ("i2c-proc.o: found normal i2c_range entry for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found normal i2c_range entry for adapter %d, " "addr %04x\n", adapter_id, addr); #endif found = 1; @@ -822,7 +818,7 @@ && (addr == address_data->probe[i + 1])) { #ifdef DEBUG printk - ("i2c-proc.o: found probe parameter for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found probe parameter for adapter %d, " "addr %04x\n", adapter_id, addr); #endif found = 1; @@ -841,7 +837,7 @@ found = 1; #ifdef DEBUG printk - ("i2c-proc.o: found probe_range parameter for adapter %d, " + (KERN_DEBUG "i2c-proc.o: found probe_range parameter for adapter %d, " "addr %04x\n", adapter_id, addr); #endif } @@ -862,7 +858,7 @@ int __init sensors_init(void) { - printk("i2c-proc.o version %s (%s)\n", LM_VERSION, LM_DATE); + printk(KERN_INFO "i2c-proc.o version %s (%s)\n", I2C_VERSION, I2C_DATE); i2c_initialized = 0; if (! (i2c_proc_header = diff -ruN linux-2.4.24-pre1/drivers/i2c/i2c-velleman.c linux-2.4.24-pre1-k/drivers/i2c/i2c-velleman.c --- linux-2.4.24-pre1/drivers/i2c/i2c-velleman.c Thu Oct 11 17:05:47 2001 +++ linux-2.4.24-pre1-k/drivers/i2c/i2c-velleman.c Sat Dec 13 15:15:59 2003 @@ -160,7 +160,7 @@ int __init i2c_bitvelle_init(void) { - printk("i2c-velleman.o: i2c Velleman K8000 adapter module\n"); + printk(KERN_INFO "i2c-velleman.o: i2c Velleman K8000 adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE); if (base==0) { /* probe some values */ base=DEFAULT_BASE; @@ -180,7 +180,7 @@ return -ENODEV; } } - printk("i2c-velleman.o: found device at %#x.\n",base); + printk(KERN_DEBUG "i2c-velleman.o: found device at %#x.\n",base); return 0; } -- Jean Delvare http://www.ensicaen.ismra.fr/~delvare/