From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [BUG] mt76x0u: Probing issues on Raspberry Pi 3 B+ From: Stanislaw Gruszka Message-Id: <20190220130009.GA2377@redhat.com> Date: Wed, 20 Feb 2019 14:00:11 +0100 To: Felix Fietkau Cc: Stefan Wahren , Lorenzo Bianconi , Alan Stern , Doug Anderson , Minas Harutyunyan , USB list , linux-wireless List-ID: T24gVHVlLCBGZWIgMTksIDIwMTkgYXQgMDE6MTk6MjZQTSArMDEwMCwgRmVsaXggRmlldGthdSB3 cm90ZToKPiA+PiA+PiBUaGUgd2F5IEkgc2VlIGl0LCB3ZSBoYXZlIHR3byBjaG9pY2VzLgo+ID4+ ID4+IDEuIEZpeCBkd2MyIHRvIGRvIGl0cyBhbGlnbm1lbnQgcXVpcmsgZm9yIHRoZSB1cmItPnNn ICE9IE5VTEwgY2FzZQo+ID4+ID4+IDIuIFJlbHkgb24gdXJiLT50cmFuc2Zlcl9idWZmZXIgYW5k IGtlZXAgdXJiLT5zZyBOVUxMCj4gPj4gPiAKPiA+PiA+IEkgYWdyZWUsIGlmIHRoaXMgaXMgb25s eSBuZWVkZWQgZm9yIGR3YzIuIFRob3VnaCBJIHdvdWxkIGludmVzdGlnYXRlCj4gPj4gPiBpZiB0 aGlzIGlzIG5vdCBhIGJ1ZyBvbiBvdGhlciBwbGF0Zm9ybXMgYXMgd2VsbC4KPiA+PiA+RnJvbSB3 aGF0IEkgY2FuIHNlZSwgdXNpbmcgTG9yZW56bydzIHBhdGNoZXMgc2VlbXMgdG8gYmUgdGhlIGJl dHRlcgo+ID4+IHNvbHV0aW9uLCBzaW5jZSB0aGV5IGF2b2lkIHRoZXNlIGNvcm5lciBjYXNlcyBp biBkd2MyIChhbmQgbWF5YmUgb3RoZXIKPiA+PiBkcml2ZXJzIGFzIHdlbGwpLiBJIHdpbGwgYXBw bHkgdGhlbSBhbmQgdGhlbiB3ZSdsbCBzZWUgaWYgd2UgbmVlZCB0byBkbwo+ID4+IGFueSBmdXJ0 aGVyIGltcHJvdmVtZW50cyBsYXRlciBvbi4KPiA+IAo+ID4gVGhleSB3b3JrIG9uIHJwaSBkd2My LCBidXQgdGhleSBkbyBub3QgYWRkcmVzcyByb290IG9mIHRoZSBwcm9ibGVtLgo+ID4gVGhlcmUg aXMgY2xlYXJseSBzb21ldGhpbmcgd3JvbmcgaG93IG10NzZ1c2IgaGFuZGxlIFNHLCB3aGF0IGlz IG5vdAo+ID4gZml4ZWQuIEFuZCBhZGRpbmcgZGlzYWJsZV91c2Jfc2cgbW9kdWxlIHBhcmFtZXRl ciBmb3IgaGNkJ3Mgc3VwcG9ydGluZwo+ID4gU0cgc2hvdWxkIGJlIHJlZCBmbGFnLgo+IEkgdGhp bmsgd2UncmUgc2ltcGx5IGRlYWxpbmcgd2l0aCBtdWx0aXBsZSBpc3N1ZXMgaGVyZSwgb25seSBz b21lIG9mCj4gd2hpY2ggYXJlIGZpeGVkIGJ5IExvcmVuem8ncyBwYXRjaGVzLgo+IEknbSBwcmV0 dHkgc3VyZSBpdCdzIHN0aWxsIHdyb25nIGZvciBtdDc2IHRvIHRyeSB0byBhbGlnbiBpdHMgYnVm ZmVycywKPiBzaW5jZSB0aGUgTGludXggVVNCIEFQSSBzdXBwb3J0cyBub24tYWxpZ25lZCB0cmFu c2ZlciBidWZmZXJzIGFuZCBpdAo+IHNob3VsZCBiZSB1cCB0byB0aGUgY29udHJvbGxlciBkcml2 ZXIgdG8gZGVhbCB3aXRoIHRoYXQuCgpBZ3JlZS4KCj4gZHdjMiB0cmllcyB0byBkbyB0aGF0LCBi dXQgdGhhdCBoYXMgbGltaXRhdGlvbnMgd2hpY2ggSSBhbHJlYWR5IHBvaW50ZWQKPiBvdXQgYW5k IHdoaWNoIGFyZSBwcm9wZXJseSBkZWFsdCB3aXRoIGJ5IExvcmVuem8ncyBwYXRjaGVzLgoKSSBw bGFuZWQgdG8ganVzdCBhY2NlcHQgY3VycmVudCBzb2x1dGlvbiwgYnV0IEkgc3RhcnRlZCB0byB3 b3JrIG9uIHBhdGNoCnRoYXQgcmVtb3ZlIGxlbiwgc2dsZW4gYXJndW1lbnRzIGZyb20gbXQ3NnVf YnVmX2FsbG9jKCkgYW5kIHVzZQpxLT5idWZfc2l6ZSBhbmQgU0tCX1dJVEhfT1ZFUkhFQUQocS0+ YnVmX3NpemUpIGRpcmVjdGx5IGFuZCByZWFsaXplZCBob3cKcmVsYXRlZCBjb2RlIGlzIG5vdyB0 YW5nbGVkLgoKV291bGQgYmUgb2sgdG8gc2VuZCB0aGlzIHBhdGNoIHdpdGggcHJvcGVyIGNoYW5n ZWxvZyBhcyBmaXggZm9yIFJQSQphZ2FpbnN0IHdpcmVsZXNzLWRyaXZlcnMgYW5kIGNjOnN0YWJs ZSAoYXNzdW1pbmcgaXQgd29ya3MgYW5kIHJlYWxseQpmaXggdGhpbmdzIG9uIFJQSSkgYW5kIHJl dmVydCBMb3JlbnpvJ3MgcGF0Y2hlcyBpbiAtbmV4dCA/CgpTdGFuaXNsYXcKCkZyb20gNGY4ZDdk M2Y0MDMxYjBhOTdiM2JiMTQ3Y2I3ZTUyNTMzODg2ZTdjYyBNb24gU2VwIDE3IDAwOjAwOjAwIDIw MDEKRnJvbTogU3RhbmlzbGF3IEdydXN6a2EgPHNncnVzemthQHJlZGhhdC5jb20+CkRhdGU6IFdl ZCwgMjAgRmViIDIwMTkgMTM6Mjk6NDIgKzAxMDAKU3ViamVjdDogW1BBVENIXSBtdDc2dXNiOiB1 c2UgdXJiIHRyYW5zZmVyX2J1ZmZlciBmb3Igb25lIHNlZ21lbnQKClNpZ25lZC1vZmYtYnk6IFN0 YW5pc2xhdyBHcnVzemthIDxzZ3J1c3prYUByZWRoYXQuY29tPgotLS0KIGRyaXZlcnMvbmV0L3dp cmVsZXNzL21lZGlhdGVrL210NzYvbXQ3Ni5oICAgICB8ICAyICsKIC4uLi93aXJlbGVzcy9tZWRp YXRlay9tdDc2L210NzZ4MDJfdXNiX21jdS5jICB8ICA0ICstCiBkcml2ZXJzL25ldC93aXJlbGVz cy9tZWRpYXRlay9tdDc2L3VzYi5jICAgICAgfCA3NSArKysrKysrKysrKy0tLS0tLS0tCiAzIGZp bGVzIGNoYW5nZWQsIDQ2IGluc2VydGlvbnMoKyksIDM1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL21lZGlhdGVrL210NzYvbXQ3Ni5oIGIvZHJpdmVycy9u ZXQvd2lyZWxlc3MvbWVkaWF0ZWsvbXQ3Ni9tdDc2LmgKaW5kZXggMmU1YmNiM2ZkZmY3Li43ZTA2 ODBkYWVlZTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL21lZGlhdGVrL210NzYv bXQ3Ni5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL21lZGlhdGVrL210NzYvbXQ3Ni5oCkBA IC04Niw2ICs4Niw4IEBAIHN0cnVjdCBtdDc2X3F1ZXVlX2J1ZiB7CiBzdHJ1Y3QgbXQ3NnVfYnVm IHsKIAlzdHJ1Y3QgbXQ3Nl9kZXYgKmRldjsKIAlzdHJ1Y3QgdXJiICp1cmI7CisJc3RydWN0IHNj YXR0ZXJsaXN0ICpzZzsKKwlpbnQgbnVtX3NnczsKIAlzaXplX3QgbGVuOwogCWJvb2wgZG9uZTsK IH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9tZWRpYXRlay9tdDc2L210NzZ4 MDJfdXNiX21jdS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvbWVkaWF0ZWsvbXQ3Ni9tdDc2eDAy X3VzYl9tY3UuYwppbmRleCBkYTI5OWI4YTEzMzQuLjc1NTYxOTEwZDYzMCAxMDA2NDQKLS0tIGEv ZHJpdmVycy9uZXQvd2lyZWxlc3MvbWVkaWF0ZWsvbXQ3Ni9tdDc2eDAyX3VzYl9tY3UuYworKysg Yi9kcml2ZXJzL25ldC93aXJlbGVzcy9tZWRpYXRlay9tdDc2L210NzZ4MDJfdXNiX21jdS5jCkBA IC05MCw3ICs5MCw3IEBAIHN0YXRpYyBpbnQgbXQ3NngwMnVfbWN1X3dhaXRfcmVzcChzdHJ1Y3Qg bXQ3Nl9kZXYgKmRldiwgdTggc2VxKQogCQlpZiAodXJiLT5zdGF0dXMpCiAJCQlyZXR1cm4gLUVJ TzsKIAotCQlkYXRhID0gc2dfdmlydCgmdXJiLT5zZ1swXSk7CisJCWRhdGEgPSBzZ192aXJ0KCZi dWYtPnNnWzBdKTsKIAkJaWYgKHVzYi0+bWN1LnJwKQogCQkJbXQ3NngwMnVfbXVsdGlwbGVfbWN1 X3JlYWRzKGRldiwgZGF0YSArIDQsCiAJCQkJCQkgICAgdXJiLT5hY3R1YWxfbGVuZ3RoIC0gOCk7 CkBAIC0yNjYsNyArMjY2LDcgQEAgc3RhdGljIGludAogX19tdDc2eDAydV9tY3VfZndfc2VuZF9k YXRhKHN0cnVjdCBtdDc2eDAyX2RldiAqZGV2LCBzdHJ1Y3QgbXQ3NnVfYnVmICpidWYsCiAJCQkg ICAgY29uc3Qgdm9pZCAqZndfZGF0YSwgaW50IGxlbiwgdTMyIGRzdF9hZGRyKQogewotCXU4ICpk YXRhID0gc2dfdmlydCgmYnVmLT51cmItPnNnWzBdKTsKKwl1OCAqZGF0YSA9IHNnX3ZpcnQoJmJ1 Zi0+c2dbMF0pOwogCURFQ0xBUkVfQ09NUExFVElPTl9PTlNUQUNLKGNtcGwpOwogCV9fbGUzMiBp bmZvOwogCXUzMiB2YWw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9tZWRpYXRl ay9tdDc2L3VzYi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvbWVkaWF0ZWsvbXQ3Ni91c2IuYwpp bmRleCBhMTgxMWMzOTQxNWUuLjU3YmIxNmVhZmYwNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQv d2lyZWxlc3MvbWVkaWF0ZWsvbXQ3Ni91c2IuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9t ZWRpYXRlay9tdDc2L3VzYi5jCkBAIC0yNzcsNyArMjc3LDYgQEAgbXQ3NnVfZmlsbF9yeF9zZyhz dHJ1Y3QgbXQ3Nl9kZXYgKmRldiwgc3RydWN0IG10NzZ1X2J1ZiAqYnVmLAogCQkgaW50IG5zZ3Ms IGludCBsZW4sIGludCBzZ2xlbikKIHsKIAlzdHJ1Y3QgbXQ3Nl9xdWV1ZSAqcSA9ICZkZXYtPnFf cnhbTVRfUlhRX01BSU5dOwotCXN0cnVjdCB1cmIgKnVyYiA9IGJ1Zi0+dXJiOwogCWludCBpOwog CiAJc3Bpbl9sb2NrX2JoKCZxLT5yeF9wYWdlX2xvY2spOwpAQCAtMjkyLDIxICsyOTEsMjEgQEAg bXQ3NnVfZmlsbF9yeF9zZyhzdHJ1Y3QgbXQ3Nl9kZXYgKmRldiwgc3RydWN0IG10NzZ1X2J1ZiAq YnVmLAogCiAJCXBhZ2UgPSB2aXJ0X3RvX2hlYWRfcGFnZShkYXRhKTsKIAkJb2Zmc2V0ID0gZGF0 YSAtIHBhZ2VfYWRkcmVzcyhwYWdlKTsKLQkJc2dfc2V0X3BhZ2UoJnVyYi0+c2dbaV0sIHBhZ2Us IHNnbGVuLCBvZmZzZXQpOworCQlzZ19zZXRfcGFnZSgmYnVmLT5zZ1tpXSwgcGFnZSwgc2dsZW4s IG9mZnNldCk7CiAJfQogCXNwaW5fdW5sb2NrX2JoKCZxLT5yeF9wYWdlX2xvY2spOwogCiAJaWYg KGkgPCBuc2dzKSB7CiAJCWludCBqOwogCi0JCWZvciAoaiA9IG5zZ3M7IGogPCB1cmItPm51bV9z Z3M7IGorKykKLQkJCXNrYl9mcmVlX2ZyYWcoc2dfdmlydCgmdXJiLT5zZ1tqXSkpOwotCQl1cmIt Pm51bV9zZ3MgPSBpOworCQlmb3IgKGogPSBuc2dzOyBqIDwgYnVmLT5udW1fc2dzOyBqKyspCisJ CQlza2JfZnJlZV9mcmFnKHNnX3ZpcnQoJmJ1Zi0+c2dbal0pKTsKKwkJYnVmLT5udW1fc2dzID0g aTsKIAl9CiAKLQl1cmItPm51bV9zZ3MgPSBtYXhfdChpbnQsIGksIHVyYi0+bnVtX3Nncyk7Ci0J YnVmLT5sZW4gPSB1cmItPm51bV9zZ3MgKiBzZ2xlbiwKLQlzZ19pbml0X21hcmtlcih1cmItPnNn LCB1cmItPm51bV9zZ3MpOworCWJ1Zi0+bnVtX3NncyA9IG1heF90KGludCwgaSwgYnVmLT5udW1f c2dzKTsKKwlidWYtPmxlbiA9IGJ1Zi0+bnVtX3NncyAqIHNnbGVuLAorCXNnX2luaXRfbWFya2Vy KGJ1Zi0+c2csIGJ1Zi0+bnVtX3Nncyk7CiAKIAlyZXR1cm4gaSA/IDogLUVOT01FTTsKIH0KQEAg LTMxOCwxMyArMzE3LDE0IEBAIGludCBtdDc2dV9idWZfYWxsb2Moc3RydWN0IG10NzZfZGV2ICpk ZXYsIHN0cnVjdCBtdDc2dV9idWYgKmJ1ZiwKIAlpZiAoIWJ1Zi0+dXJiKQogCQlyZXR1cm4gLUVO T01FTTsKIAotCWJ1Zi0+dXJiLT5zZyA9IGRldm1fa2NhbGxvYyhkZXYtPmRldiwgbnNncywgc2l6 ZW9mKCpidWYtPnVyYi0+c2cpLAorCWJ1Zi0+c2cgPSBkZXZtX2tjYWxsb2MoZGV2LT5kZXYsIG5z Z3MsIHNpemVvZigqYnVmLT5zZyksCiAJCQkJICAgIGdmcCk7Ci0JaWYgKCFidWYtPnVyYi0+c2cp CisJaWYgKCFidWYtPnNnKQogCQlyZXR1cm4gLUVOT01FTTsKIAotCXNnX2luaXRfdGFibGUoYnVm LT51cmItPnNnLCBuc2dzKTsKKwlzZ19pbml0X3RhYmxlKGJ1Zi0+c2csIG5zZ3MpOwogCWJ1Zi0+ ZGV2ID0gZGV2OworCWJ1Zi0+bnVtX3NncyA9IG5zZ3M7CiAKIAlyZXR1cm4gbXQ3NnVfZmlsbF9y eF9zZyhkZXYsIGJ1ZiwgbnNncywgbGVuLCBzZ2xlbik7CiB9CkBAIC0zMzIsMTIgKzMzMiwxMSBA QCBFWFBPUlRfU1lNQk9MX0dQTChtdDc2dV9idWZfYWxsb2MpOwogCiB2b2lkIG10NzZ1X2J1Zl9m cmVlKHN0cnVjdCBtdDc2dV9idWYgKmJ1ZikKIHsKLQlzdHJ1Y3QgdXJiICp1cmIgPSBidWYtPnVy YjsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOwogCWludCBpOwogCi0JZm9yIChpID0gMDsgaSA8 IHVyYi0+bnVtX3NnczsgaSsrKSB7Ci0JCXNnID0gJnVyYi0+c2dbaV07CisJZm9yIChpID0gMDsg aSA8IGJ1Zi0+bnVtX3NnczsgaSsrKSB7CisJCXNnID0gJmJ1Zi0+c2dbaV07CiAJCWlmICghc2cp CiAJCQljb250aW51ZTsKIApAQCAtMzQ3LDkgKzM0NiwxMCBAQCB2b2lkIG10NzZ1X2J1Zl9mcmVl KHN0cnVjdCBtdDc2dV9idWYgKmJ1ZikKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKG10NzZ1X2J1Zl9m cmVlKTsKIAotaW50IG10NzZ1X3N1Ym1pdF9idWYoc3RydWN0IG10NzZfZGV2ICpkZXYsIGludCBk aXIsIGludCBpbmRleCwKLQkJICAgICBzdHJ1Y3QgbXQ3NnVfYnVmICpidWYsIGdmcF90IGdmcCwK LQkJICAgICB1c2JfY29tcGxldGVfdCBjb21wbGV0ZV9mbiwgdm9pZCAqY29udGV4dCkKK3N0YXRp YyB2b2lkCittdDc2dV9maWxsX2J1bGtfdXJiKHN0cnVjdCBtdDc2X2RldiAqZGV2LCBpbnQgZGly LCBpbnQgaW5kZXgsCisJCSAgICBzdHJ1Y3QgbXQ3NnVfYnVmICpidWYsIHVzYl9jb21wbGV0ZV90 IGNvbXBsZXRlX2ZuLAorCQkgICAgdm9pZCAqY29udGV4dCkKIHsKIAlzdHJ1Y3QgdXNiX2ludGVy ZmFjZSAqaW50ZiA9IHRvX3VzYl9pbnRlcmZhY2UoZGV2LT5kZXYpOwogCXN0cnVjdCB1c2JfZGV2 aWNlICp1ZGV2ID0gaW50ZXJmYWNlX3RvX3VzYmRldihpbnRmKTsKQEAgLTM2MCw5ICszNjAsMjIg QEAgaW50IG10NzZ1X3N1Ym1pdF9idWYoc3RydWN0IG10NzZfZGV2ICpkZXYsIGludCBkaXIsIGlu dCBpbmRleCwKIAllbHNlCiAJCXBpcGUgPSB1c2Jfc25kYnVsa3BpcGUodWRldiwgZGV2LT51c2Iu b3V0X2VwW2luZGV4XSk7CiAKLQl1c2JfZmlsbF9idWxrX3VyYihidWYtPnVyYiwgdWRldiwgcGlw ZSwgTlVMTCwgYnVmLT5sZW4sCi0JCQkgIGNvbXBsZXRlX2ZuLCBjb250ZXh0KTsKKwl1c2JfZmls bF9idWxrX3VyYihidWYtPnVyYiwgdWRldiwgcGlwZSwgTlVMTCwgYnVmLT5sZW4sIGNvbXBsZXRl X2ZuLAorCQkJICBjb250ZXh0KTsKKworCWlmIChidWYtPm51bV9zZ3MgPiAxKSB7CisJCWJ1Zi0+ dXJiLT5udW1fc2dzID0gYnVmLT5udW1fc2dzOworCQlidWYtPnVyYi0+c2cgPSBidWYtPnNnOwor CX0gZWxzZSB7CisJCWJ1Zi0+dXJiLT50cmFuc2Zlcl9idWZmZXIgPSBzZ192aXJ0KGJ1Zi0+c2cp OworCX0KK30KIAoraW50IG10NzZ1X3N1Ym1pdF9idWYoc3RydWN0IG10NzZfZGV2ICpkZXYsIGlu dCBkaXIsIGludCBpbmRleCwKKwkJICAgICBzdHJ1Y3QgbXQ3NnVfYnVmICpidWYsIGdmcF90IGdm cCwKKwkJICAgICB1c2JfY29tcGxldGVfdCBjb21wbGV0ZV9mbiwgdm9pZCAqY29udGV4dCkKK3sK KwltdDc2dV9maWxsX2J1bGtfdXJiKGRldiwgZGlyLCBpbmRleCwgYnVmLCBjb21wbGV0ZV9mbiwg Y29udGV4dCk7CiAJcmV0dXJuIHVzYl9zdWJtaXRfdXJiKGJ1Zi0+dXJiLCBnZnApOwogfQogRVhQ T1JUX1NZTUJPTF9HUEwobXQ3NnVfc3VibWl0X2J1Zik7CkBAIC02NzIsNyArNjg1LDcgQEAgc3Rh dGljIHZvaWQgbXQ3NnVfY29tcGxldGVfdHgoc3RydWN0IHVyYiAqdXJiKQogfQogCiBzdGF0aWMg aW50Ci1tdDc2dV90eF9idWlsZF9zZyhzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgdXJiICp1 cmIpCittdDc2dV90eF9idWlsZF9zZyhzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgbXQ3NnVf YnVmICpidWYpCiB7CiAJaW50IG5zZ3MgPSAxICsgc2tiX3NoaW5mbyhza2IpLT5ucl9mcmFnczsK IAlzdHJ1Y3Qgc2tfYnVmZiAqaXRlcjsKQEAgLTY4MCwxMyArNjkzLDE0IEBAIG10NzZ1X3R4X2J1 aWxkX3NnKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCB1cmIgKnVyYikKIAlza2Jfd2Fsa19m cmFncyhza2IsIGl0ZXIpCiAJCW5zZ3MgKz0gMSArIHNrYl9zaGluZm8oaXRlciktPm5yX2ZyYWdz OwogCi0JbWVtc2V0KHVyYi0+c2csIDAsIHNpemVvZigqdXJiLT5zZykgKiBNVF9TR19NQVhfU0la RSk7CisJbWVtc2V0KGJ1Zi0+c2csIDAsIHNpemVvZigqYnVmLT5zZykgKiBNVF9TR19NQVhfU0la RSk7CiAKIAluc2dzID0gbWluX3QoaW50LCBNVF9TR19NQVhfU0laRSwgbnNncyk7Ci0Jc2dfaW5p dF9tYXJrZXIodXJiLT5zZywgbnNncyk7Ci0JdXJiLT5udW1fc2dzID0gbnNnczsKKwlzZ19pbml0 X21hcmtlcihidWYtPnNnLCBuc2dzKTsKKwlidWYtPm51bV9zZ3MgPSBuc2dzOworCWJ1Zi0+bGVu ID0gc2tiLT5sZW47CiAKLQlyZXR1cm4gc2tiX3RvX3NndmVjX25vbWFyayhza2IsIHVyYi0+c2cs IDAsIHNrYi0+bGVuKTsKKwlyZXR1cm4gc2tiX3RvX3NndmVjX25vbWFyayhza2IsIGJ1Zi0+c2cs IDAsIHNrYi0+bGVuKTsKIH0KIAogc3RhdGljIGludApAQCAtNjk0LDEyICs3MDgsOSBAQCBtdDc2 dV90eF9xdWV1ZV9za2Ioc3RydWN0IG10NzZfZGV2ICpkZXYsIHN0cnVjdCBtdDc2X3F1ZXVlICpx LAogCQkgICBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgbXQ3Nl93Y2lkICp3Y2lkLAogCQkg ICBzdHJ1Y3QgaWVlZTgwMjExX3N0YSAqc3RhKQogewotCXN0cnVjdCB1c2JfaW50ZXJmYWNlICpp bnRmID0gdG9fdXNiX2ludGVyZmFjZShkZXYtPmRldik7Ci0Jc3RydWN0IHVzYl9kZXZpY2UgKnVk ZXYgPSBpbnRlcmZhY2VfdG9fdXNiZGV2KGludGYpOwogCXU4IGVwID0gcTJlcChxLT5od19pZHgp OwogCXN0cnVjdCBtdDc2dV9idWYgKmJ1ZjsKIAl1MTYgaWR4ID0gcS0+dGFpbDsKLQl1bnNpZ25l ZCBpbnQgcGlwZTsKIAlpbnQgZXJyOwogCiAJaWYgKHEtPnF1ZXVlZCA9PSBxLT5uZGVzYykKQEAg LTcxMiwxMyArNzIzLDExIEBAIG10NzZ1X3R4X3F1ZXVlX3NrYihzdHJ1Y3QgbXQ3Nl9kZXYgKmRl diwgc3RydWN0IG10NzZfcXVldWUgKnEsCiAJYnVmID0gJnEtPmVudHJ5W2lkeF0udWJ1ZjsKIAli dWYtPmRvbmUgPSBmYWxzZTsKIAotCWVyciA9IG10NzZ1X3R4X2J1aWxkX3NnKHNrYiwgYnVmLT51 cmIpOworCWVyciA9IG10NzZ1X3R4X2J1aWxkX3NnKHNrYiwgYnVmKTsKIAlpZiAoZXJyIDwgMCkK IAkJcmV0dXJuIGVycjsKIAotCXBpcGUgPSB1c2Jfc25kYnVsa3BpcGUodWRldiwgZGV2LT51c2Iu b3V0X2VwW2VwXSk7Ci0JdXNiX2ZpbGxfYnVsa191cmIoYnVmLT51cmIsIHVkZXYsIHBpcGUsIE5V TEwsIHNrYi0+bGVuLAotCQkJICBtdDc2dV9jb21wbGV0ZV90eCwgYnVmKTsKKwltdDc2dV9maWxs X2J1bGtfdXJiKGRldiwgVVNCX0RJUl9PVVQsIGVwLCBidWYsIG10NzZ1X2NvbXBsZXRlX3R4LCBi dWYpOwogCiAJcS0+dGFpbCA9IChxLT50YWlsICsgMSkgJSBxLT5uZGVzYzsKIAlxLT5lbnRyeVtp ZHhdLnNrYiA9IHNrYjsKQEAgLTc3Niw4ICs3ODUsOCBAQCBzdGF0aWMgaW50IG10NzZ1X2FsbG9j X3R4KHN0cnVjdCBtdDc2X2RldiAqZGV2KQogCQkJaWYgKCFidWYtPnVyYikKIAkJCQlyZXR1cm4g LUVOT01FTTsKIAotCQkJYnVmLT51cmItPnNnID0gZGV2bV9remFsbG9jKGRldi0+ZGV2LCBzaXpl LCBHRlBfS0VSTkVMKTsKLQkJCWlmICghYnVmLT51cmItPnNnKQorCQkJYnVmLT5zZyA9IGRldm1f a3phbGxvYyhkZXYtPmRldiwgc2l6ZSwgR0ZQX0tFUk5FTCk7CisJCQlpZiAoIWJ1Zi0+c2cpCiAJ CQkJcmV0dXJuIC1FTk9NRU07CiAJCX0KIAl9Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_MUTT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id F1EBDC43381 for ; Wed, 20 Feb 2019 13:00:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C1E9C2147A for ; Wed, 20 Feb 2019 13:00:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727954AbfBTNAw (ORCPT ); Wed, 20 Feb 2019 08:00:52 -0500 Received: from mx1.redhat.com ([209.132.183.28]:60384 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726172AbfBTNAv (ORCPT ); Wed, 20 Feb 2019 08:00:51 -0500 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id EC91C74840; Wed, 20 Feb 2019 13:00:50 +0000 (UTC) Received: from localhost (ovpn-204-58.brq.redhat.com [10.40.204.58]) by smtp.corp.redhat.com (Postfix) with ESMTP id E8D5060139; Wed, 20 Feb 2019 13:00:12 +0000 (UTC) Date: Wed, 20 Feb 2019 14:00:11 +0100 From: Stanislaw Gruszka To: Felix Fietkau Cc: Stefan Wahren , Lorenzo Bianconi , Alan Stern , Doug Anderson , Minas Harutyunyan , USB list , linux-wireless Subject: Re: [BUG] mt76x0u: Probing issues on Raspberry Pi 3 B+ Message-ID: <20190220130009.GA2377@redhat.com> References: <20190215071226.GA2372@redhat.com> <1411983628.668277.1550315118443@email.ionos.de> <20190216140739.GA2236@redhat.com> <2009016263.528260.1550344627996@email.ionos.de> <20190218135247.GA9602@redhat.com> <0e29e99a-6ed4-40fe-1f38-30f1b5530a16@nbd.name> <20190218150303.GD9602@redhat.com> <20190219104208.GA22999@redhat.com> <58097bb1-d726-c48e-2a40-2e12098dfb15@nbd.name> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <58097bb1-d726-c48e-2a40-2e12098dfb15@nbd.name> User-Agent: Mutt/1.8.3 (2017-05-23) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.27]); Wed, 20 Feb 2019 13:00:51 +0000 (UTC) Sender: linux-wireless-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org On Tue, Feb 19, 2019 at 01:19:26PM +0100, Felix Fietkau wrote: > >> >> The way I see it, we have two choices. > >> >> 1. Fix dwc2 to do its alignment quirk for the urb->sg != NULL case > >> >> 2. Rely on urb->transfer_buffer and keep urb->sg NULL > >> > > >> > I agree, if this is only needed for dwc2. Though I would investigate > >> > if this is not a bug on other platforms as well. > >> >From what I can see, using Lorenzo's patches seems to be the better > >> solution, since they avoid these corner cases in dwc2 (and maybe other > >> drivers as well). I will apply them and then we'll see if we need to do > >> any further improvements later on. > > > > They work on rpi dwc2, but they do not address root of the problem. > > There is clearly something wrong how mt76usb handle SG, what is not > > fixed. And adding disable_usb_sg module parameter for hcd's supporting > > SG should be red flag. > I think we're simply dealing with multiple issues here, only some of > which are fixed by Lorenzo's patches. > I'm pretty sure it's still wrong for mt76 to try to align its buffers, > since the Linux USB API supports non-aligned transfer buffers and it > should be up to the controller driver to deal with that. Agree. > dwc2 tries to do that, but that has limitations which I already pointed > out and which are properly dealt with by Lorenzo's patches. I planed to just accept current solution, but I started to work on patch that remove len, sglen arguments from mt76u_buf_alloc() and use q->buf_size and SKB_WITH_OVERHEAD(q->buf_size) directly and realized how related code is now tangled. Would be ok to send this patch with proper changelog as fix for RPI against wireless-drivers and cc:stable (assuming it works and really fix things on RPI) and revert Lorenzo's patches in -next ? Stanislaw >From 4f8d7d3f4031b0a97b3bb147cb7e52533886e7cc Mon Sep 17 00:00:00 2001 From: Stanislaw Gruszka Date: Wed, 20 Feb 2019 13:29:42 +0100 Subject: [PATCH] mt76usb: use urb transfer_buffer for one segment Signed-off-by: Stanislaw Gruszka --- drivers/net/wireless/mediatek/mt76/mt76.h | 2 + .../wireless/mediatek/mt76/mt76x02_usb_mcu.c | 4 +- drivers/net/wireless/mediatek/mt76/usb.c | 75 +++++++++++-------- 3 files changed, 46 insertions(+), 35 deletions(-) diff --git a/drivers/net/wireless/mediatek/mt76/mt76.h b/drivers/net/wireless/mediatek/mt76/mt76.h index 2e5bcb3fdff7..7e0680daeee6 100644 --- a/drivers/net/wireless/mediatek/mt76/mt76.h +++ b/drivers/net/wireless/mediatek/mt76/mt76.h @@ -86,6 +86,8 @@ struct mt76_queue_buf { struct mt76u_buf { struct mt76_dev *dev; struct urb *urb; + struct scatterlist *sg; + int num_sgs; size_t len; bool done; }; diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02_usb_mcu.c b/drivers/net/wireless/mediatek/mt76/mt76x02_usb_mcu.c index da299b8a1334..75561910d630 100644 --- a/drivers/net/wireless/mediatek/mt76/mt76x02_usb_mcu.c +++ b/drivers/net/wireless/mediatek/mt76/mt76x02_usb_mcu.c @@ -90,7 +90,7 @@ static int mt76x02u_mcu_wait_resp(struct mt76_dev *dev, u8 seq) if (urb->status) return -EIO; - data = sg_virt(&urb->sg[0]); + data = sg_virt(&buf->sg[0]); if (usb->mcu.rp) mt76x02u_multiple_mcu_reads(dev, data + 4, urb->actual_length - 8); @@ -266,7 +266,7 @@ static int __mt76x02u_mcu_fw_send_data(struct mt76x02_dev *dev, struct mt76u_buf *buf, const void *fw_data, int len, u32 dst_addr) { - u8 *data = sg_virt(&buf->urb->sg[0]); + u8 *data = sg_virt(&buf->sg[0]); DECLARE_COMPLETION_ONSTACK(cmpl); __le32 info; u32 val; diff --git a/drivers/net/wireless/mediatek/mt76/usb.c b/drivers/net/wireless/mediatek/mt76/usb.c index a1811c39415e..57bb16eaff06 100644 --- a/drivers/net/wireless/mediatek/mt76/usb.c +++ b/drivers/net/wireless/mediatek/mt76/usb.c @@ -277,7 +277,6 @@ mt76u_fill_rx_sg(struct mt76_dev *dev, struct mt76u_buf *buf, int nsgs, int len, int sglen) { struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; - struct urb *urb = buf->urb; int i; spin_lock_bh(&q->rx_page_lock); @@ -292,21 +291,21 @@ mt76u_fill_rx_sg(struct mt76_dev *dev, struct mt76u_buf *buf, page = virt_to_head_page(data); offset = data - page_address(page); - sg_set_page(&urb->sg[i], page, sglen, offset); + sg_set_page(&buf->sg[i], page, sglen, offset); } spin_unlock_bh(&q->rx_page_lock); if (i < nsgs) { int j; - for (j = nsgs; j < urb->num_sgs; j++) - skb_free_frag(sg_virt(&urb->sg[j])); - urb->num_sgs = i; + for (j = nsgs; j < buf->num_sgs; j++) + skb_free_frag(sg_virt(&buf->sg[j])); + buf->num_sgs = i; } - urb->num_sgs = max_t(int, i, urb->num_sgs); - buf->len = urb->num_sgs * sglen, - sg_init_marker(urb->sg, urb->num_sgs); + buf->num_sgs = max_t(int, i, buf->num_sgs); + buf->len = buf->num_sgs * sglen, + sg_init_marker(buf->sg, buf->num_sgs); return i ? : -ENOMEM; } @@ -318,13 +317,14 @@ int mt76u_buf_alloc(struct mt76_dev *dev, struct mt76u_buf *buf, if (!buf->urb) return -ENOMEM; - buf->urb->sg = devm_kcalloc(dev->dev, nsgs, sizeof(*buf->urb->sg), + buf->sg = devm_kcalloc(dev->dev, nsgs, sizeof(*buf->sg), gfp); - if (!buf->urb->sg) + if (!buf->sg) return -ENOMEM; - sg_init_table(buf->urb->sg, nsgs); + sg_init_table(buf->sg, nsgs); buf->dev = dev; + buf->num_sgs = nsgs; return mt76u_fill_rx_sg(dev, buf, nsgs, len, sglen); } @@ -332,12 +332,11 @@ EXPORT_SYMBOL_GPL(mt76u_buf_alloc); void mt76u_buf_free(struct mt76u_buf *buf) { - struct urb *urb = buf->urb; struct scatterlist *sg; int i; - for (i = 0; i < urb->num_sgs; i++) { - sg = &urb->sg[i]; + for (i = 0; i < buf->num_sgs; i++) { + sg = &buf->sg[i]; if (!sg) continue; @@ -347,9 +346,10 @@ void mt76u_buf_free(struct mt76u_buf *buf) } EXPORT_SYMBOL_GPL(mt76u_buf_free); -int mt76u_submit_buf(struct mt76_dev *dev, int dir, int index, - struct mt76u_buf *buf, gfp_t gfp, - usb_complete_t complete_fn, void *context) +static void +mt76u_fill_bulk_urb(struct mt76_dev *dev, int dir, int index, + struct mt76u_buf *buf, usb_complete_t complete_fn, + void *context) { struct usb_interface *intf = to_usb_interface(dev->dev); struct usb_device *udev = interface_to_usbdev(intf); @@ -360,9 +360,22 @@ int mt76u_submit_buf(struct mt76_dev *dev, int dir, int index, else pipe = usb_sndbulkpipe(udev, dev->usb.out_ep[index]); - usb_fill_bulk_urb(buf->urb, udev, pipe, NULL, buf->len, - complete_fn, context); + usb_fill_bulk_urb(buf->urb, udev, pipe, NULL, buf->len, complete_fn, + context); + + if (buf->num_sgs > 1) { + buf->urb->num_sgs = buf->num_sgs; + buf->urb->sg = buf->sg; + } else { + buf->urb->transfer_buffer = sg_virt(buf->sg); + } +} +int mt76u_submit_buf(struct mt76_dev *dev, int dir, int index, + struct mt76u_buf *buf, gfp_t gfp, + usb_complete_t complete_fn, void *context) +{ + mt76u_fill_bulk_urb(dev, dir, index, buf, complete_fn, context); return usb_submit_urb(buf->urb, gfp); } EXPORT_SYMBOL_GPL(mt76u_submit_buf); @@ -672,7 +685,7 @@ static void mt76u_complete_tx(struct urb *urb) } static int -mt76u_tx_build_sg(struct sk_buff *skb, struct urb *urb) +mt76u_tx_build_sg(struct sk_buff *skb, struct mt76u_buf *buf) { int nsgs = 1 + skb_shinfo(skb)->nr_frags; struct sk_buff *iter; @@ -680,13 +693,14 @@ mt76u_tx_build_sg(struct sk_buff *skb, struct urb *urb) skb_walk_frags(skb, iter) nsgs += 1 + skb_shinfo(iter)->nr_frags; - memset(urb->sg, 0, sizeof(*urb->sg) * MT_SG_MAX_SIZE); + memset(buf->sg, 0, sizeof(*buf->sg) * MT_SG_MAX_SIZE); nsgs = min_t(int, MT_SG_MAX_SIZE, nsgs); - sg_init_marker(urb->sg, nsgs); - urb->num_sgs = nsgs; + sg_init_marker(buf->sg, nsgs); + buf->num_sgs = nsgs; + buf->len = skb->len; - return skb_to_sgvec_nomark(skb, urb->sg, 0, skb->len); + return skb_to_sgvec_nomark(skb, buf->sg, 0, skb->len); } static int @@ -694,12 +708,9 @@ mt76u_tx_queue_skb(struct mt76_dev *dev, struct mt76_queue *q, struct sk_buff *skb, struct mt76_wcid *wcid, struct ieee80211_sta *sta) { - struct usb_interface *intf = to_usb_interface(dev->dev); - struct usb_device *udev = interface_to_usbdev(intf); u8 ep = q2ep(q->hw_idx); struct mt76u_buf *buf; u16 idx = q->tail; - unsigned int pipe; int err; if (q->queued == q->ndesc) @@ -712,13 +723,11 @@ mt76u_tx_queue_skb(struct mt76_dev *dev, struct mt76_queue *q, buf = &q->entry[idx].ubuf; buf->done = false; - err = mt76u_tx_build_sg(skb, buf->urb); + err = mt76u_tx_build_sg(skb, buf); if (err < 0) return err; - pipe = usb_sndbulkpipe(udev, dev->usb.out_ep[ep]); - usb_fill_bulk_urb(buf->urb, udev, pipe, NULL, skb->len, - mt76u_complete_tx, buf); + mt76u_fill_bulk_urb(dev, USB_DIR_OUT, ep, buf, mt76u_complete_tx, buf); q->tail = (q->tail + 1) % q->ndesc; q->entry[idx].skb = skb; @@ -776,8 +785,8 @@ static int mt76u_alloc_tx(struct mt76_dev *dev) if (!buf->urb) return -ENOMEM; - buf->urb->sg = devm_kzalloc(dev->dev, size, GFP_KERNEL); - if (!buf->urb->sg) + buf->sg = devm_kzalloc(dev->dev, size, GFP_KERNEL); + if (!buf->sg) return -ENOMEM; } } -- 2.20.1