diff for duplicates of <20150801005955.23791.75791@quantum>

diff --git a/a/1.txt b/N1/1.txt
index 6dacf46..fd9da97 100644
--- a/a/1.txt
+++ b/N1/1.txt
@@ -1,155 +1,225 @@
-UXVvdGluZyBMZWUgSm9uZXMgKDIwMTUtMDctMzEgMDI6MDI6MTkpCj4gT24gVGh1LCAzMCBKdWwg
-MjAxNSwgTWljaGFlbCBUdXJxdWV0dGUgd3JvdGU6Cj4gCj4gPiBRdW90aW5nIExlZSBKb25lcyAo
-MjAxNS0wNy0zMCAwNDoxNzo0NykKPiA+ID4gT24gV2VkLCAyOSBKdWwgMjAxNSwgTWljaGFlbCBU
-dXJxdWV0dGUgd3JvdGU6Cj4gPiA+IAo+ID4gPiA+IEhpIExlZSwKPiA+ID4gPiAKPiA+ID4gPiAr
-IGxpbnV4LWNsayBtbAo+ID4gPiA+IAo+ID4gPiA+IFF1b3RpbmcgTGVlIEpvbmVzICgyMDE1LTA3
-LTIyIDA2OjA0OjEzKQo+ID4gPiA+ID4gVGhlc2UgbmV3IEFQSSBjYWxscyB3aWxsIGZpcnN0bHkg
-cHJvdmlkZSBhIG1lY2hhbmlzbXMgdG8gdGFnIGEgY2xvY2sgYXMKPiA+ID4gPiA+IGNyaXRpY2Fs
-IGFuZCBzZWNvbmRseSBhbGxvdyBhbnkga25vd2xlZGdlYWJsZSBkcml2ZXIgdG8gKHVuKWdhdGUg
-Y2xvY2tzLAo+ID4gPiA+ID4gZXZlbiBpZiB0aGV5IGFyZSBtYXJrZWQgYXMgY3JpdGljYWwuCj4g
-PiA+ID4gPiAKPiA+ID4gPiA+IFN1Z2dlc3RlZC1ieTogTWF4aW1lIFJpcGFyZCA8bWF4aW1lLnJp
-cGFyZEBmcmVlLWVsZWN0cm9ucy5jb20+Cj4gPiA+ID4gPiBTaWduZWQtb2ZmLWJ5OiBMZWUgSm9u
-ZXMgPGxlZS5qb25lc0BsaW5hcm8ub3JnPgo+ID4gPiA+ID4gLS0tCj4gPiA+ID4gPiAgZHJpdmVy
-cy9jbGsvY2xrLmMgICAgICAgICAgICB8IDQ1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr
-KysrKysrKysrKysrKysrCj4gPiA+ID4gPiAgaW5jbHVkZS9saW51eC9jbGstcHJvdmlkZXIuaCB8
-ICAyICsrCj4gPiA+ID4gPiAgaW5jbHVkZS9saW51eC9jbGsuaCAgICAgICAgICB8IDMwICsrKysr
-KysrKysrKysrKysrKysrKysrKysrKysrCj4gPiA+ID4gPiAgMyBmaWxlcyBjaGFuZ2VkLCA3NyBp
-bnNlcnRpb25zKCspCj4gPiA+ID4gPiAKPiA+ID4gPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Ns
-ay9jbGsuYyBiL2RyaXZlcnMvY2xrL2Nsay5jCj4gPiA+ID4gPiBpbmRleCA2MWMzZmM1Li40ODZi
-MWRhIDEwMDY0NAo+ID4gPiA+ID4gLS0tIGEvZHJpdmVycy9jbGsvY2xrLmMKPiA+ID4gPiA+ICsr
-KyBiL2RyaXZlcnMvY2xrL2Nsay5jCj4gPiA+ID4gPiBAQCAtNDYsNiArNDYsMjEgQEAgc3RhdGlj
-IHN0cnVjdCBjbGtfY29yZSAqY2xrX2NvcmVfbG9va3VwKGNvbnN0IGNoYXIgKm5hbWUpOwo+ID4g
-PiA+ID4gIAo+ID4gPiA+ID4gIC8qKiogICAgcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZXMgICAgKioq
-Lwo+ID4gPiA+ID4gIAo+ID4gPiA+ID4gKy8qKgo+ID4gPiA+ID4gKyAqIHN0cnVjdCBjcml0aWNh
-bCAtICAgUHJvdmlkZXMgJ3BsYXknIG92ZXIgY3JpdGljYWwgY2xvY2tzLiAgQSBjbG9jayBjYW4g
-YmUKPiA+ID4gPiA+ICsgKiAgICAgICAgICAgICAgICAgICAgIG1hcmtlZCBhcyBjcml0aWNhbCwg
-bWVhbmluZyB0aGF0IGl0IHNob3VsZCBub3QgYmUKPiA+ID4gPiA+ICsgKiAgICAgICAgICAgICAg
-ICAgICAgIGRpc2FibGVkLiAgSG93ZXZlciwgaWYgYSBkcml2ZXIgd2hpY2ggaXMgYXdhcmUgb2Yg
-dGhlCj4gPiA+ID4gPiArICogICAgICAgICAgICAgICAgICAgICBjcml0aWNhbCBiZWhhdmlvdXIg
-d2FudHMgdG8gY29udHJvbCBpdCwgaXQgY2FuIGRvIHNvCj4gPiA+ID4gPiArICogICAgICAgICAg
-ICAgICAgICAgICB1c2luZyBjbGtfZW5hYmxlX2NyaXRpY2FsKCkgYW5kIGNsa19kaXNhYmxlX2Ny
-aXRpY2FsKCkuCj4gPiA+ID4gPiArICoKPiA+ID4gPiA+ICsgKiBAZW5hYmxlZCAgICBJcyBjbG9j
-ayBjcml0aWNhbD8gIE9uY2Ugc2V0LCBkb2Vzbid0IGNoYW5nZQo+ID4gPiA+ID4gKyAqIEBsZWF2
-ZV9vbiAgIFNlbGYgZXhwbGFuYXRvcnkuICBDYW4gYmUgZGlzYWJsZWQgYnkga25vd2xlZGdlYWJs
-ZSBkcml2ZXJzCj4gPiA+ID4gCj4gPiA+ID4gTm90IHNlbGYgZXhwbGFuYXRvcnkuIEkgbmVlZCB0
-aGlzIGV4cGxhaW5lZCB0byBtZS4gV2hhdCBkb2VzIGxlYXZlX29uCj4gPiA+ID4gZG8/IEJldHRl
-ciB5ZXQsIHdoYXQgd291bGQgaGFwcGVuIGlmIGxlYXZlX29uIGRpZCBub3QgZXhpc3Q/Cj4gPiA+
-ID4gCj4gPiA+ID4gPiArICovCj4gPiA+ID4gPiArc3RydWN0IGNyaXRpY2FsIHsKPiA+ID4gPiA+
-ICsgICAgICAgYm9vbCBlbmFibGVkOwo+ID4gPiA+ID4gKyAgICAgICBib29sIGxlYXZlX29uOwo+
-ID4gPiA+ID4gK307Cj4gPiA+ID4gPiArCj4gPiA+ID4gPiAgc3RydWN0IGNsa19jb3JlIHsKPiA+
-ID4gPiA+ICAgICAgICAgY29uc3QgY2hhciAgICAgICAgICAgICAgKm5hbWU7Cj4gPiA+ID4gPiAg
-ICAgICAgIGNvbnN0IHN0cnVjdCBjbGtfb3BzICAgICpvcHM7Cj4gPiA+ID4gPiBAQCAtNzUsNiAr
-OTAsNyBAQCBzdHJ1Y3QgY2xrX2NvcmUgewo+ID4gPiA+ID4gICAgICAgICBzdHJ1Y3QgZGVudHJ5
-ICAgICAgICAgICAqZGVudHJ5Owo+ID4gPiA+ID4gICNlbmRpZgo+ID4gPiA+ID4gICAgICAgICBz
-dHJ1Y3Qga3JlZiAgICAgICAgICAgICByZWY7Cj4gPiA+ID4gPiArICAgICAgIHN0cnVjdCBjcml0
-aWNhbCAgICAgICAgIGNyaXRpY2FsOwo+ID4gPiA+ID4gIH07Cj4gPiA+ID4gPiAgCj4gPiA+ID4g
-PiAgc3RydWN0IGNsayB7Cj4gPiA+ID4gPiBAQCAtOTk1LDYgKzEwMTEsMTAgQEAgc3RhdGljIHZv
-aWQgY2xrX2NvcmVfZGlzYWJsZShzdHJ1Y3QgY2xrX2NvcmUgKmNsaykKPiA+ID4gPiA+ICAgICAg
-ICAgaWYgKFdBUk5fT04oY2xrLT5lbmFibGVfY291bnQgPT0gMCkpCj4gPiA+ID4gPiAgICAgICAg
-ICAgICAgICAgcmV0dXJuOwo+ID4gPiA+ID4gIAo+ID4gPiA+ID4gKyAgICAgICAvKiBSZWZ1c2Ug
-dG8gdHVybiBvZmYgYSBjcml0aWNhbCBjbG9jayAqLwo+ID4gPiA+ID4gKyAgICAgICBpZiAoY2xr
-LT5lbmFibGVfY291bnQgPT0gMSAmJiBjbGstPmNyaXRpY2FsLmxlYXZlX29uKQo+ID4gPiA+ID4g
-KyAgICAgICAgICAgICAgIHJldHVybjsKPiA+ID4gPiAKPiA+ID4gPiBIb3cgZG8gd2UgZ2V0IHRv
-IHRoaXMgcG9pbnQ/IGNsa19lbmFibGVfY3JpdGljYWwgYWN0dWFsbHkgY2FsbHMKPiA+ID4gPiBj
-bGtfZW5hYmxlLCB0aHVzIGluY3JlbWVudGluZyB0aGUgZW5hYmxlX2NvdW50LiBUaGUgb25seSB0
-aW1lIHRoYXQgd2UKPiA+ID4gPiBjb3VsZCBoaXQgdGhlIGFib3ZlIGNhc2UgaXMgaWYsCj4gPiA+
-ID4gCj4gPiA+ID4gYSkgdGhlcmUgaXMgYW4gaW1iYWxhbmNlIGluIGNsa19lbmFibGUgYW5kIGNs
-a19kaXNhYmxlIGNhbGxzLiBJZiB0aGlzIGlzCj4gPiA+ID4gdGhlIGNhc2UgdGhlbiB0aGUgZHJp
-dmVycyBuZWVkIHRvIGJlIGZpeGVkLiBPciBiZXR0ZXIgeWV0IHNvbWUKPiA+ID4gPiBpbmZyYXN0
-cnVjdHVyZSB0byBjYXRjaCB0aGF0LCBub3cgdGhhdCB3ZSBoYXZlIHBlci11c2VyIHN0cnVjdCBj
-bGsKPiA+ID4gPiBjb29raWVzLgo+ID4gPiA+IAo+ID4gPiA+IGIpIGEgZHJpdmVyIGtub3dpbmds
-eSBjYWxscyBjbGtfZW5hYmxlX2NyaXRpY2FsKGZvbykgYW5kIHRoZW4gcmVndWxhciwKPiA+ID4g
-PiBvbGQgY2xrX2Rpc2FibGUoZm9vKS4gQnV0IHdoeSB3b3VsZCBhIGRyaXZlciBkbyB0aGF0Pwo+
-ID4gPiA+IAo+ID4gPiA+IEl0IG1pZ2h0IGJlIHRoYXQgSSBhbSBtaXNzaW5nIHRoZSBwb2ludCBo
-ZXJlLCBzbyBwbGVhc2UgZmVlbCBmcmVlIHRvCj4gPiA+ID4gY2x1ZSBtZSBpbi4KPiA+ID4gCj4g
-PiA+IFRoaXMgY2hlY2sgYmVoYXZlcyBpbiBhIHZlcnkgc2ltaWxhciB0byB0aGUgV0FSTigpIGFi
-b3ZlLiAgSXQncyBtb3JlCj4gPiA+IG9mIGEgZmFpbC1zYWZlLiAgSWYgYWxsIGRyaXZlcnMgYXJl
-IGJlaGF2aW5nIHByb3Blcmx5LCB0aGVuIGl0Cj4gPiA+IHNob3VsZG4ndCBldmVyIGJlIHRydWUu
-ICBJZiB0aGV5J3JlIG5vdCwgaXQgcHJldmVudHMgYW4gaW5jb3JyZWN0bHkKPiA+ID4gd3JpdHRl
-biBkcml2ZXIgZnJvbSBpcnJlY292ZXJhYmx5IGNyaXBwbGluZyB0aGUgc3lzdGVtLgo+ID4gCj4g
-PiBUaGVuIHRoaXMgY2hlY2sgc2hvdWxkIGJlIHJlcGxhY2VkIHdpdGggYSBnZW5lcmljIGFwcHJv
-YWNoIHRoYXQgcmVmdXNlcwo+ID4gdG8gaG9ub3IgaW1iYWxhbmNlcyBhbnl3YXlzLiBCZWxvdyBh
-cmUgdHdvIHBhdGNoZXMgdGhhdCBwcm9iYWJseSByZXNvbHZlCj4gPiB0aGUgaXNzdWUgb2YgYmFk
-bHkgYmVoYXZpbmcgZHJpdmVycyB0aGF0IGNhdXNlIGVuYWJsZSBpbWJhbGFuY2VzLgo+IAo+IFlv
-dXIgcGF0Y2ggc2hvdWxkIG1ha2UgdGhlIHJlcXVpcmVtZW50IGZvciB0aGlzIGNoZWNrIG1vb3Qs
-IHNvIGl0IGNhbgo+IHByb2JhYmx5IGJlIHJlbW92ZWQuCj4gCj4gPiA+IEFzIEkgc2FpZCBpbiB0
-aGUgb3RoZXIgbWFpbC4gIFdlIGNhbiBkbyB3aXRob3V0IHRoZXNlIDMgbmV3IHdyYXBwZXJzLgo+
-ID4gPiBXZSBfY291bGRfIGp1c3Qgd3JpdGUgYSBkcml2ZXIgd2hpY2ggb25seSBjYWxscyBjbGtf
-ZW5hYmxlKCkgX2FmdGVyXwo+ID4gPiBpdCBjYWxscyBjbGtfZGlzYWJsZSgpLCBhIGtpbmQgb2Yg
-aW50ZW50aW9uYWwgdW5iYWxhbmNlIGFuZCBpdCB3b3VsZAo+ID4gPiBkbyB0aGF0IHNhbWUgdGhp
-bmcuCj4gPiAKPiA+IFRoaXMgbmFpdmUgYXBwcm9hY2ggd2lsbCBub3Qgd29yayB3aXRoIHBlci11
-c2VyIGltYmFsYW5jZSB0cmFja2luZy4KPiAKPiBTdGVhZHkgb24uICBJIHNhaWQgd2UgIl9jb3Vs
-ZF8iLCB0aGF0IHRoYXQgSSB0aGluayBpdCdzIGEgZ29vZCBpZGVhLgo+IAo+IEkgdGhpbmsgaXQn
-cyBhIGJhZCBpZGVhLCB3aGljaCBpcyB3aHkgSSB3cm90ZSB0aGlzIHNldC4gOykKPiAKPiA+ID4g
-SG93ZXZlciwgd2hhdCB3ZSdyZSB0cnlpbmcgdG8gZG8gaGVyZSBpcyBwcm92aWRlCj4gPiA+IGEg
-cHJvcGVyIEFQSSwgc28gd2UgY2FuIHNlZSBhdCBmaXJzdCBnbGFuY2Ugd2hhdCB0aGUgJ2tub3ds
-ZWRnZWFibGUnCj4gPiA+IGRyaXZlciBpcyB0cnlpbmcgdG8gZG8gYW5kIG5vdCBoYXZlIHNvbWVv
-bmUgYXR0ZW1wdCB0byBzdWJtaXQgYSAnZml4Jwo+ID4gPiB3aGljaCBjYWxscyBjbGtfZW5hYmxl
-KCkgb3Igc29tZXRoaW5nLgo+ID4gCj4gPiBXZSdsbCBuZWVkIHNvbWUgdHlwZSBvZiBhcGkgZm9y
-IHN1cmUgZm9yIHRoZSBoYW5kb2ZmLgo+IAo+IFRoaXMgc2V0IHdpbGwgbm90IHRyaWdnZXIgeW91
-ciBuZXcgY2hlY2tzLiAgVGhlIGNsb2NrcyB3aWxsIGJlIGluCj4gcGVyZmVjdCBiYWxsYW5jZSBi
-ZWN1YXNlIGEgcmVmZXJlbmNlIHdpbGwgYmUgdGFrZW4gYXQgc3RhcnQtdXAuCj4gCj4gQWdhaW46
-Cj4gCj4gc3RhcnQtdXA6Cj4gICBjbGtfcHJlcGFyZV9lbmFibGUoKQo+IAo+IGtub3dsZWdhYmxl
-X2RyaXZlcl9wcm9iZToKPiAgIGNsa19nZXQoKQo+IAo+IGtub3dsZWdhYmxlX2RyaXZlcl9nYXRl
-X2NsazoKPiAgIGNsa19kaXNhYmxlX2NyaXRpY2FsKCkKClRoZSBjYWxsIHRvIGNsa19kaXNhYmxl
-KCkgbmVzdGVkIGluc2lkZSBjbGtfZGlzYWJsZV9jcml0aWNhbCB3aWxsIGZhaWwKd2l0aCB0aGUg
-bmV3IGNoZWNrcy4gVGhpcyBpcyBiZWNhdXNlIHRoZSBzdHJ1Y3QgY2xrIGluc3RhbmNlIHdpbGwg
-YmUKZGlmZmVyZW50IGZyb20gb25lIHVzZWQgaW4geW91ciAic3RhcnQtdXAiIHNlY3Rpb24gYWJv
-dmUuIGNsa19nZXQoKQpjcmVhdGVzIGEgdW5pcXVlIHN0cnVjdCBjbGsgZXZlcnkgdGltZSB5b3Ug
-Y2FsbCBpdC4KClB1dCBhbm90aGVyIHdheSwgYSB1bmlxdWUgdXNlciBvZiBhIGNsb2NrIGNhbm5v
-dCBjYWxsIGNsa19kaXNhYmxlKCkgd2hlbgp0aGUgcGVyLXVzZXIgZW5hYmxlX2NvdW50IGlzIDAu
-CgpGdXJ0aGVybW9yZSwgdGhlcmUgaXMgbm8gd2F5IHRoYXQgSSB3aWxsIGV2ZXIgYmUgaGFwcHkg
-d2l0aCBhIHRlY2huaXF1ZQp0aGF0IHJlcXVpcmVzIGNhbGxpbmcgZGlzYWJsZSBwcmlvciB0byBh
-biBlbmFibGUgd2l0aGluIGEgZHJpdmVyLiBUaGF0CmdvZXMgYWdhaW5zdCBhIGxvbmctc3RhbmRp
-bmcgYXBpIGRlc2lnbnMgYW5kIGlzIGNvbmZ1c2luZyBhcyBoZWxsIHRvCmRyaXZlciBhdXRob3Jz
-LgoKUmVnYXJkcywKTWlrZQoKPiAKPiBrbm93bGVnYWJsZV9kcml2ZXJfdW5nYXRlX2NsazoKPiAg
-IGNsa19lbmFibGVfY3JpdGljYWwoKQo+IAo+IGtub3dsZWdhYmxlX2RyaXZlcl9yZW1vdmU6Cj4g
-ICBjbGtfcHV0KCkKPiAKPiA+IEZyb20gMzU5OWVkMjA2ZGE5Y2U3NzBiZmFmY2ZkOTVjYmI5YTAz
-YWM0NDQ3MyBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKPiA+IEZyb206IE1pY2hhZWwgVHVycXVl
-dHRlIDxtdHVycXVldHRlQGJheWxpYnJlLmNvbT4KPiA+IERhdGU6IFdlZCwgMjkgSnVsIDIwMTUg
-MTg6MjI6NDUgLTA3MDAKPiA+IFN1YmplY3Q6IFtQQVRDSCAxLzJdIGNsazogcGVyLXVzZXIgY2xr
-IHByZXBhcmUgJiBlbmFibGUgcmVmIGNvdW50cwo+ID4gCj4gPiBUaGlzIHBhdGNoIGFkZHMgcHJl
-cGFyZSBhbmQgZW5hYmxlIHJlZmVyZW5jZSBjb3VudHMgZm9yIHRoZSBwZXItdXNlcgo+ID4gaGFu
-ZGxlcyB0aGF0IGNsb2NrIGNvbnN1bWVycyBoYXZlIGZvciBhIGNsb2NrIG5vZGUuIFRoaXMgcGF0
-Y2ggd2FybnMgaWYKPiA+IGFuIGltYmFsYW5jZSBvY2N1cnMgd2hpbGUgdHJ5aW5nIHRvIGRpc2Fi
-bGUgb3IgdW5wcmVwYXJlIGEgY2xvY2sgYW5kCj4gPiBhYm9ydHMsIGxlYXZpbmcgdGhlIGhhcmR3
-YXJlIHVuYWZmZWN0ZWQuCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IE1pY2hhZWwgVHVycXVldHRl
-IDxtdHVycXVldHRlQGJheWxpYnJlLmNvbT4KPiA+IC0tLQo+ID4gIGRyaXZlcnMvY2xrL2Nsay5j
-IHwgMTAgKysrKysrKysrKwo+ID4gIDEgZmlsZSBjaGFuZ2VkLCAxMCBpbnNlcnRpb25zKCspCj4g
-PiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsay9jbGsuYyBiL2RyaXZlcnMvY2xrL2Nsay5j
-Cj4gPiBpbmRleCA4OTgwNTJlLi43MmZlZWU5IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9jbGsv
-Y2xrLmMKPiA+ICsrKyBiL2RyaXZlcnMvY2xrL2Nsay5jCj4gPiBAQCAtODQsNiArODQsOCBAQCBz
-dHJ1Y3QgY2xrIHsKPiA+ICAgICAgIHVuc2lnbmVkIGxvbmcgbWluX3JhdGU7Cj4gPiAgICAgICB1
-bnNpZ25lZCBsb25nIG1heF9yYXRlOwo+ID4gICAgICAgc3RydWN0IGhsaXN0X25vZGUgY2xrc19u
-b2RlOwo+ID4gKyAgICAgdW5zaWduZWQgaW50IGVuYWJsZV9jb3VudDsKPiA+ICsgICAgIHVuc2ln
-bmVkIGludCBwcmVwYXJlX2NvdW50Owo+ID4gIH07Cj4gPiAgCj4gPiAgLyoqKiAgICAgICAgICAg
-bG9ja2luZyAgICAgICAgICAgICAqKiovCj4gPiBAQCAtNjAwLDYgKzYwMiw5IEBAIHZvaWQgY2xr
-X3VucHJlcGFyZShzdHJ1Y3QgY2xrICpjbGspCj4gPiAgICAgICAgICAgICAgIHJldHVybjsKPiA+
-ICAKPiA+ICAgICAgIGNsa19wcmVwYXJlX2xvY2soKTsKPiA+ICsgICAgIGlmIChXQVJOX09OKGNs
-ay0+cHJlcGFyZV9jb3VudCA9PSAwKSkKPiA+ICsgICAgICAgICAgICAgcmV0dXJuOwo+ID4gKyAg
-ICAgY2xrLT5wcmVwYXJlX2NvdW50LS07Cj4gPiAgICAgICBjbGtfY29yZV91bnByZXBhcmUoY2xr
-LT5jb3JlKTsKPiA+ICAgICAgIGNsa19wcmVwYXJlX3VubG9jaygpOwo+ID4gIH0KPiA+IEBAIC02
-NTcsNiArNjYyLDcgQEAgaW50IGNsa19wcmVwYXJlKHN0cnVjdCBjbGsgKmNsaykKPiA+ICAgICAg
-ICAgICAgICAgcmV0dXJuIDA7Cj4gPiAgCj4gPiAgICAgICBjbGtfcHJlcGFyZV9sb2NrKCk7Cj4g
-PiArICAgICBjbGstPnByZXBhcmVfY291bnQrKzsKPiA+ICAgICAgIHJldCA9IGNsa19jb3JlX3By
-ZXBhcmUoY2xrLT5jb3JlKTsKPiA+ICAgICAgIGNsa19wcmVwYXJlX3VubG9jaygpOwo+ID4gIAo+
-ID4gQEAgLTcwNyw2ICs3MTMsOSBAQCB2b2lkIGNsa19kaXNhYmxlKHN0cnVjdCBjbGsgKmNsaykK
-PiA+ICAgICAgICAgICAgICAgcmV0dXJuOwo+ID4gIAo+ID4gICAgICAgZmxhZ3MgPSBjbGtfZW5h
-YmxlX2xvY2soKTsKPiA+ICsgICAgIGlmIChXQVJOX09OKGNsay0+ZW5hYmxlX2NvdW50ID09IDAp
-KQo+ID4gKyAgICAgICAgICAgICByZXR1cm47Cj4gPiArICAgICBjbGstPmVuYWJsZV9jb3VudC0t
-Owo+ID4gICAgICAgY2xrX2NvcmVfZGlzYWJsZShjbGstPmNvcmUpOwo+ID4gICAgICAgY2xrX2Vu
-YWJsZV91bmxvY2soZmxhZ3MpOwo+ID4gIH0KPiA+IEBAIC03NjksNiArNzc4LDcgQEAgaW50IGNs
-a19lbmFibGUoc3RydWN0IGNsayAqY2xrKQo+ID4gICAgICAgICAgICAgICByZXR1cm4gMDsKPiA+
-ICAKPiA+ICAgICAgIGZsYWdzID0gY2xrX2VuYWJsZV9sb2NrKCk7Cj4gPiArICAgICBjbGstPmVu
-YWJsZV9jb3VudCsrOwo+ID4gICAgICAgcmV0ID0gY2xrX2NvcmVfZW5hYmxlKGNsay0+Y29yZSk7
-Cj4gPiAgICAgICBjbGtfZW5hYmxlX3VubG9jayhmbGFncyk7Cj4gPiAgCj4gCj4gLS0gCj4gTGVl
-IEpvbmVzCj4gTGluYXJvIFNUTWljcm9lbGVjdHJvbmljcyBMYW5kaW5nIFRlYW0gTGVhZAo+IExp
-bmFyby5vcmcg4pSCIE9wZW4gc291cmNlIHNvZnR3YXJlIGZvciBBUk0gU29Dcwo+IEZvbGxvdyBM
-aW5hcm86IEZhY2Vib29rIHwgVHdpdHRlciB8IEJsb2cKPiAtLQo+IFRvIHVuc3Vic2NyaWJlIGZy
-b20gdGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC1jbGsiIGluCj4g
-dGhlIGJvZHkgb2YgYSBtZXNzYWdlIHRvIG1ham9yZG9tb0B2Z2VyLmtlcm5lbC5vcmcKPiBNb3Jl
-IG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZv
-Lmh0bWwKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxp
-bnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFk
-ZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4
-LWFybS1rZXJuZWwK
+Quoting Lee Jones (2015-07-31 02:02:19)
+> On Thu, 30 Jul 2015, Michael Turquette wrote:
+> 
+> > Quoting Lee Jones (2015-07-30 04:17:47)
+> > > On Wed, 29 Jul 2015, Michael Turquette wrote:
+> > > 
+> > > > Hi Lee,
+> > > > 
+> > > > + linux-clk ml
+> > > > 
+> > > > Quoting Lee Jones (2015-07-22 06:04:13)
+> > > > > These new API calls will firstly provide a mechanisms to tag a clock as
+> > > > > critical and secondly allow any knowledgeable driver to (un)gate clocks,
+> > > > > even if they are marked as critical.
+> > > > > 
+> > > > > Suggested-by: Maxime Ripard <maxime.ripard@free-electrons.com>
+> > > > > Signed-off-by: Lee Jones <lee.jones@linaro.org>
+> > > > > ---
+> > > > >  drivers/clk/clk.c            | 45 ++++++++++++++++++++++++++++++++++++++++++++
+> > > > >  include/linux/clk-provider.h |  2 ++
+> > > > >  include/linux/clk.h          | 30 +++++++++++++++++++++++++++++
+> > > > >  3 files changed, 77 insertions(+)
+> > > > > 
+> > > > > diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
+> > > > > index 61c3fc5..486b1da 100644
+> > > > > --- a/drivers/clk/clk.c
+> > > > > +++ b/drivers/clk/clk.c
+> > > > > @@ -46,6 +46,21 @@ static struct clk_core *clk_core_lookup(const char *name);
+> > > > >  
+> > > > >  /***    private data structures    ***/
+> > > > >  
+> > > > > +/**
+> > > > > + * struct critical -   Provides 'play' over critical clocks.  A clock can be
+> > > > > + *                     marked as critical, meaning that it should not be
+> > > > > + *                     disabled.  However, if a driver which is aware of the
+> > > > > + *                     critical behaviour wants to control it, it can do so
+> > > > > + *                     using clk_enable_critical() and clk_disable_critical().
+> > > > > + *
+> > > > > + * @enabled    Is clock critical?  Once set, doesn't change
+> > > > > + * @leave_on   Self explanatory.  Can be disabled by knowledgeable drivers
+> > > > 
+> > > > Not self explanatory. I need this explained to me. What does leave_on
+> > > > do? Better yet, what would happen if leave_on did not exist?
+> > > > 
+> > > > > + */
+> > > > > +struct critical {
+> > > > > +       bool enabled;
+> > > > > +       bool leave_on;
+> > > > > +};
+> > > > > +
+> > > > >  struct clk_core {
+> > > > >         const char              *name;
+> > > > >         const struct clk_ops    *ops;
+> > > > > @@ -75,6 +90,7 @@ struct clk_core {
+> > > > >         struct dentry           *dentry;
+> > > > >  #endif
+> > > > >         struct kref             ref;
+> > > > > +       struct critical         critical;
+> > > > >  };
+> > > > >  
+> > > > >  struct clk {
+> > > > > @@ -995,6 +1011,10 @@ static void clk_core_disable(struct clk_core *clk)
+> > > > >         if (WARN_ON(clk->enable_count == 0))
+> > > > >                 return;
+> > > > >  
+> > > > > +       /* Refuse to turn off a critical clock */
+> > > > > +       if (clk->enable_count == 1 && clk->critical.leave_on)
+> > > > > +               return;
+> > > > 
+> > > > How do we get to this point? clk_enable_critical actually calls
+> > > > clk_enable, thus incrementing the enable_count. The only time that we
+> > > > could hit the above case is if,
+> > > > 
+> > > > a) there is an imbalance in clk_enable and clk_disable calls. If this is
+> > > > the case then the drivers need to be fixed. Or better yet some
+> > > > infrastructure to catch that, now that we have per-user struct clk
+> > > > cookies.
+> > > > 
+> > > > b) a driver knowingly calls clk_enable_critical(foo) and then regular,
+> > > > old clk_disable(foo). But why would a driver do that?
+> > > > 
+> > > > It might be that I am missing the point here, so please feel free to
+> > > > clue me in.
+> > > 
+> > > This check behaves in a very similar to the WARN() above.  It's more
+> > > of a fail-safe.  If all drivers are behaving properly, then it
+> > > shouldn't ever be true.  If they're not, it prevents an incorrectly
+> > > written driver from irrecoverably crippling the system.
+> > 
+> > Then this check should be replaced with a generic approach that refuses
+> > to honor imbalances anyways. Below are two patches that probably resolve
+> > the issue of badly behaving drivers that cause enable imbalances.
+> 
+> Your patch should make the requirement for this check moot, so it can
+> probably be removed.
+> 
+> > > As I said in the other mail.  We can do without these 3 new wrappers.
+> > > We _could_ just write a driver which only calls clk_enable() _after_
+> > > it calls clk_disable(), a kind of intentional unbalance and it would
+> > > do that same thing.
+> > 
+> > This naive approach will not work with per-user imbalance tracking.
+> 
+> Steady on.  I said we "_could_", that that I think it's a good idea.
+> 
+> I think it's a bad idea, which is why I wrote this set. ;)
+> 
+> > > However, what we're trying to do here is provide
+> > > a proper API, so we can see at first glance what the 'knowledgeable'
+> > > driver is trying to do and not have someone attempt to submit a 'fix'
+> > > which calls clk_enable() or something.
+> > 
+> > We'll need some type of api for sure for the handoff.
+> 
+> This set will not trigger your new checks.  The clocks will be in
+> perfect ballance becuase a reference will be taken at start-up.
+> 
+> Again:
+> 
+> start-up:
+>   clk_prepare_enable()
+> 
+> knowlegable_driver_probe:
+>   clk_get()
+> 
+> knowlegable_driver_gate_clk:
+>   clk_disable_critical()
+
+The call to clk_disable() nested inside clk_disable_critical will fail
+with the new checks. This is because the struct clk instance will be
+different from one used in your "start-up" section above. clk_get()
+creates a unique struct clk every time you call it.
+
+Put another way, a unique user of a clock cannot call clk_disable() when
+the per-user enable_count is 0.
+
+Furthermore, there is no way that I will ever be happy with a technique
+that requires calling disable prior to an enable within a driver. That
+goes against a long-standing api designs and is confusing as hell to
+driver authors.
+
+Regards,
+Mike
+
+> 
+> knowlegable_driver_ungate_clk:
+>   clk_enable_critical()
+> 
+> knowlegable_driver_remove:
+>   clk_put()
+> 
+> > From 3599ed206da9ce770bfafcfd95cbb9a03ac44473 Mon Sep 17 00:00:00 2001
+> > From: Michael Turquette <mturquette@baylibre.com>
+> > Date: Wed, 29 Jul 2015 18:22:45 -0700
+> > Subject: [PATCH 1/2] clk: per-user clk prepare & enable ref counts
+> > 
+> > This patch adds prepare and enable reference counts for the per-user
+> > handles that clock consumers have for a clock node. This patch warns if
+> > an imbalance occurs while trying to disable or unprepare a clock and
+> > aborts, leaving the hardware unaffected.
+> > 
+> > Signed-off-by: Michael Turquette <mturquette@baylibre.com>
+> > ---
+> >  drivers/clk/clk.c | 10 ++++++++++
+> >  1 file changed, 10 insertions(+)
+> > 
+> > diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
+> > index 898052e..72feee9 100644
+> > --- a/drivers/clk/clk.c
+> > +++ b/drivers/clk/clk.c
+> > @@ -84,6 +84,8 @@ struct clk {
+> >       unsigned long min_rate;
+> >       unsigned long max_rate;
+> >       struct hlist_node clks_node;
+> > +     unsigned int enable_count;
+> > +     unsigned int prepare_count;
+> >  };
+> >  
+> >  /***           locking             ***/
+> > @@ -600,6 +602,9 @@ void clk_unprepare(struct clk *clk)
+> >               return;
+> >  
+> >       clk_prepare_lock();
+> > +     if (WARN_ON(clk->prepare_count == 0))
+> > +             return;
+> > +     clk->prepare_count--;
+> >       clk_core_unprepare(clk->core);
+> >       clk_prepare_unlock();
+> >  }
+> > @@ -657,6 +662,7 @@ int clk_prepare(struct clk *clk)
+> >               return 0;
+> >  
+> >       clk_prepare_lock();
+> > +     clk->prepare_count++;
+> >       ret = clk_core_prepare(clk->core);
+> >       clk_prepare_unlock();
+> >  
+> > @@ -707,6 +713,9 @@ void clk_disable(struct clk *clk)
+> >               return;
+> >  
+> >       flags = clk_enable_lock();
+> > +     if (WARN_ON(clk->enable_count == 0))
+> > +             return;
+> > +     clk->enable_count--;
+> >       clk_core_disable(clk->core);
+> >       clk_enable_unlock(flags);
+> >  }
+> > @@ -769,6 +778,7 @@ int clk_enable(struct clk *clk)
+> >               return 0;
+> >  
+> >       flags = clk_enable_lock();
+> > +     clk->enable_count++;
+> >       ret = clk_core_enable(clk->core);
+> >       clk_enable_unlock(flags);
+> >  
+> 
+> -- 
+> Lee Jones
+> Linaro STMicroelectronics Landing Team Lead
+> Linaro.org ? Open source software for ARM SoCs
+> Follow Linaro: Facebook | Twitter | Blog
+> --
+> To unsubscribe from this list: send the line "unsubscribe linux-clk" in
+> the body of a message to majordomo at vger.kernel.org
+> More majordomo info at  http://vger.kernel.org/majordomo-info.html
diff --git a/a/content_digest b/N1/content_digest
index 6453b30..2a37a74 100644
--- a/a/content_digest
+++ b/N1/content_digest
@@ -4,176 +4,236 @@
  "ref\020150730111747.GF14642@x1\0"
  "ref\020150730233530.23791.17746@quantum\0"
  "ref\020150731090219.GE3208@x1\0"
- "From\0Michael Turquette <mturquette@baylibre.com>\0"
- "Subject\0Re: [PATCH v7 3/5] clk: Supply the critical clock {init, enable, disable} framework\0"
+ "From\0mturquette@baylibre.com (Michael Turquette)\0"
+ "Subject\0[PATCH v7 3/5] clk: Supply the critical clock {init, enable, disable} framework\0"
  "Date\0Fri, 31 Jul 2015 17:59:55 -0700\0"
- "To\0Lee Jones <lee.jones@linaro.org>"
- "\0"
- "Cc\0devicetree@vger.kernel.org"
-  kernel@stlinux.com
-  s.hauer@pengutronix.de
-  sboyd@codeaurora.org
-  linux-kernel@vger.kernel.org
-  geert@linux-m68k.org
-  maxime.ripard@free-electrons.com
-  linux-clk@vger.kernel.org
- " linux-arm-kernel@lists.infradead.org\0"
+ "To\0linux-arm-kernel@lists.infradead.org\0"
  "\00:1\0"
  "b\0"
- "UXVvdGluZyBMZWUgSm9uZXMgKDIwMTUtMDctMzEgMDI6MDI6MTkpCj4gT24gVGh1LCAzMCBKdWwg\n"
- "MjAxNSwgTWljaGFlbCBUdXJxdWV0dGUgd3JvdGU6Cj4gCj4gPiBRdW90aW5nIExlZSBKb25lcyAo\n"
- "MjAxNS0wNy0zMCAwNDoxNzo0NykKPiA+ID4gT24gV2VkLCAyOSBKdWwgMjAxNSwgTWljaGFlbCBU\n"
- "dXJxdWV0dGUgd3JvdGU6Cj4gPiA+IAo+ID4gPiA+IEhpIExlZSwKPiA+ID4gPiAKPiA+ID4gPiAr\n"
- "IGxpbnV4LWNsayBtbAo+ID4gPiA+IAo+ID4gPiA+IFF1b3RpbmcgTGVlIEpvbmVzICgyMDE1LTA3\n"
- "LTIyIDA2OjA0OjEzKQo+ID4gPiA+ID4gVGhlc2UgbmV3IEFQSSBjYWxscyB3aWxsIGZpcnN0bHkg\n"
- "cHJvdmlkZSBhIG1lY2hhbmlzbXMgdG8gdGFnIGEgY2xvY2sgYXMKPiA+ID4gPiA+IGNyaXRpY2Fs\n"
- "IGFuZCBzZWNvbmRseSBhbGxvdyBhbnkga25vd2xlZGdlYWJsZSBkcml2ZXIgdG8gKHVuKWdhdGUg\n"
- "Y2xvY2tzLAo+ID4gPiA+ID4gZXZlbiBpZiB0aGV5IGFyZSBtYXJrZWQgYXMgY3JpdGljYWwuCj4g\n"
- "PiA+ID4gPiAKPiA+ID4gPiA+IFN1Z2dlc3RlZC1ieTogTWF4aW1lIFJpcGFyZCA8bWF4aW1lLnJp\n"
- "cGFyZEBmcmVlLWVsZWN0cm9ucy5jb20+Cj4gPiA+ID4gPiBTaWduZWQtb2ZmLWJ5OiBMZWUgSm9u\n"
- "ZXMgPGxlZS5qb25lc0BsaW5hcm8ub3JnPgo+ID4gPiA+ID4gLS0tCj4gPiA+ID4gPiAgZHJpdmVy\n"
- "cy9jbGsvY2xrLmMgICAgICAgICAgICB8IDQ1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr\n"
- "KysrKysrKysrKysrKysrCj4gPiA+ID4gPiAgaW5jbHVkZS9saW51eC9jbGstcHJvdmlkZXIuaCB8\n"
- "ICAyICsrCj4gPiA+ID4gPiAgaW5jbHVkZS9saW51eC9jbGsuaCAgICAgICAgICB8IDMwICsrKysr\n"
- "KysrKysrKysrKysrKysrKysrKysrKysrCj4gPiA+ID4gPiAgMyBmaWxlcyBjaGFuZ2VkLCA3NyBp\n"
- "bnNlcnRpb25zKCspCj4gPiA+ID4gPiAKPiA+ID4gPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Ns\n"
- "ay9jbGsuYyBiL2RyaXZlcnMvY2xrL2Nsay5jCj4gPiA+ID4gPiBpbmRleCA2MWMzZmM1Li40ODZi\n"
- "MWRhIDEwMDY0NAo+ID4gPiA+ID4gLS0tIGEvZHJpdmVycy9jbGsvY2xrLmMKPiA+ID4gPiA+ICsr\n"
- "KyBiL2RyaXZlcnMvY2xrL2Nsay5jCj4gPiA+ID4gPiBAQCAtNDYsNiArNDYsMjEgQEAgc3RhdGlj\n"
- "IHN0cnVjdCBjbGtfY29yZSAqY2xrX2NvcmVfbG9va3VwKGNvbnN0IGNoYXIgKm5hbWUpOwo+ID4g\n"
- "PiA+ID4gIAo+ID4gPiA+ID4gIC8qKiogICAgcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZXMgICAgKioq\n"
- "Lwo+ID4gPiA+ID4gIAo+ID4gPiA+ID4gKy8qKgo+ID4gPiA+ID4gKyAqIHN0cnVjdCBjcml0aWNh\n"
- "bCAtICAgUHJvdmlkZXMgJ3BsYXknIG92ZXIgY3JpdGljYWwgY2xvY2tzLiAgQSBjbG9jayBjYW4g\n"
- "YmUKPiA+ID4gPiA+ICsgKiAgICAgICAgICAgICAgICAgICAgIG1hcmtlZCBhcyBjcml0aWNhbCwg\n"
- "bWVhbmluZyB0aGF0IGl0IHNob3VsZCBub3QgYmUKPiA+ID4gPiA+ICsgKiAgICAgICAgICAgICAg\n"
- "ICAgICAgIGRpc2FibGVkLiAgSG93ZXZlciwgaWYgYSBkcml2ZXIgd2hpY2ggaXMgYXdhcmUgb2Yg\n"
- "dGhlCj4gPiA+ID4gPiArICogICAgICAgICAgICAgICAgICAgICBjcml0aWNhbCBiZWhhdmlvdXIg\n"
- "d2FudHMgdG8gY29udHJvbCBpdCwgaXQgY2FuIGRvIHNvCj4gPiA+ID4gPiArICogICAgICAgICAg\n"
- "ICAgICAgICAgICB1c2luZyBjbGtfZW5hYmxlX2NyaXRpY2FsKCkgYW5kIGNsa19kaXNhYmxlX2Ny\n"
- "aXRpY2FsKCkuCj4gPiA+ID4gPiArICoKPiA+ID4gPiA+ICsgKiBAZW5hYmxlZCAgICBJcyBjbG9j\n"
- "ayBjcml0aWNhbD8gIE9uY2Ugc2V0LCBkb2Vzbid0IGNoYW5nZQo+ID4gPiA+ID4gKyAqIEBsZWF2\n"
- "ZV9vbiAgIFNlbGYgZXhwbGFuYXRvcnkuICBDYW4gYmUgZGlzYWJsZWQgYnkga25vd2xlZGdlYWJs\n"
- "ZSBkcml2ZXJzCj4gPiA+ID4gCj4gPiA+ID4gTm90IHNlbGYgZXhwbGFuYXRvcnkuIEkgbmVlZCB0\n"
- "aGlzIGV4cGxhaW5lZCB0byBtZS4gV2hhdCBkb2VzIGxlYXZlX29uCj4gPiA+ID4gZG8/IEJldHRl\n"
- "ciB5ZXQsIHdoYXQgd291bGQgaGFwcGVuIGlmIGxlYXZlX29uIGRpZCBub3QgZXhpc3Q/Cj4gPiA+\n"
- "ID4gCj4gPiA+ID4gPiArICovCj4gPiA+ID4gPiArc3RydWN0IGNyaXRpY2FsIHsKPiA+ID4gPiA+\n"
- "ICsgICAgICAgYm9vbCBlbmFibGVkOwo+ID4gPiA+ID4gKyAgICAgICBib29sIGxlYXZlX29uOwo+\n"
- "ID4gPiA+ID4gK307Cj4gPiA+ID4gPiArCj4gPiA+ID4gPiAgc3RydWN0IGNsa19jb3JlIHsKPiA+\n"
- "ID4gPiA+ICAgICAgICAgY29uc3QgY2hhciAgICAgICAgICAgICAgKm5hbWU7Cj4gPiA+ID4gPiAg\n"
- "ICAgICAgIGNvbnN0IHN0cnVjdCBjbGtfb3BzICAgICpvcHM7Cj4gPiA+ID4gPiBAQCAtNzUsNiAr\n"
- "OTAsNyBAQCBzdHJ1Y3QgY2xrX2NvcmUgewo+ID4gPiA+ID4gICAgICAgICBzdHJ1Y3QgZGVudHJ5\n"
- "ICAgICAgICAgICAqZGVudHJ5Owo+ID4gPiA+ID4gICNlbmRpZgo+ID4gPiA+ID4gICAgICAgICBz\n"
- "dHJ1Y3Qga3JlZiAgICAgICAgICAgICByZWY7Cj4gPiA+ID4gPiArICAgICAgIHN0cnVjdCBjcml0\n"
- "aWNhbCAgICAgICAgIGNyaXRpY2FsOwo+ID4gPiA+ID4gIH07Cj4gPiA+ID4gPiAgCj4gPiA+ID4g\n"
- "PiAgc3RydWN0IGNsayB7Cj4gPiA+ID4gPiBAQCAtOTk1LDYgKzEwMTEsMTAgQEAgc3RhdGljIHZv\n"
- "aWQgY2xrX2NvcmVfZGlzYWJsZShzdHJ1Y3QgY2xrX2NvcmUgKmNsaykKPiA+ID4gPiA+ICAgICAg\n"
- "ICAgaWYgKFdBUk5fT04oY2xrLT5lbmFibGVfY291bnQgPT0gMCkpCj4gPiA+ID4gPiAgICAgICAg\n"
- "ICAgICAgICAgcmV0dXJuOwo+ID4gPiA+ID4gIAo+ID4gPiA+ID4gKyAgICAgICAvKiBSZWZ1c2Ug\n"
- "dG8gdHVybiBvZmYgYSBjcml0aWNhbCBjbG9jayAqLwo+ID4gPiA+ID4gKyAgICAgICBpZiAoY2xr\n"
- "LT5lbmFibGVfY291bnQgPT0gMSAmJiBjbGstPmNyaXRpY2FsLmxlYXZlX29uKQo+ID4gPiA+ID4g\n"
- "KyAgICAgICAgICAgICAgIHJldHVybjsKPiA+ID4gPiAKPiA+ID4gPiBIb3cgZG8gd2UgZ2V0IHRv\n"
- "IHRoaXMgcG9pbnQ/IGNsa19lbmFibGVfY3JpdGljYWwgYWN0dWFsbHkgY2FsbHMKPiA+ID4gPiBj\n"
- "bGtfZW5hYmxlLCB0aHVzIGluY3JlbWVudGluZyB0aGUgZW5hYmxlX2NvdW50LiBUaGUgb25seSB0\n"
- "aW1lIHRoYXQgd2UKPiA+ID4gPiBjb3VsZCBoaXQgdGhlIGFib3ZlIGNhc2UgaXMgaWYsCj4gPiA+\n"
- "ID4gCj4gPiA+ID4gYSkgdGhlcmUgaXMgYW4gaW1iYWxhbmNlIGluIGNsa19lbmFibGUgYW5kIGNs\n"
- "a19kaXNhYmxlIGNhbGxzLiBJZiB0aGlzIGlzCj4gPiA+ID4gdGhlIGNhc2UgdGhlbiB0aGUgZHJp\n"
- "dmVycyBuZWVkIHRvIGJlIGZpeGVkLiBPciBiZXR0ZXIgeWV0IHNvbWUKPiA+ID4gPiBpbmZyYXN0\n"
- "cnVjdHVyZSB0byBjYXRjaCB0aGF0LCBub3cgdGhhdCB3ZSBoYXZlIHBlci11c2VyIHN0cnVjdCBj\n"
- "bGsKPiA+ID4gPiBjb29raWVzLgo+ID4gPiA+IAo+ID4gPiA+IGIpIGEgZHJpdmVyIGtub3dpbmds\n"
- "eSBjYWxscyBjbGtfZW5hYmxlX2NyaXRpY2FsKGZvbykgYW5kIHRoZW4gcmVndWxhciwKPiA+ID4g\n"
- "PiBvbGQgY2xrX2Rpc2FibGUoZm9vKS4gQnV0IHdoeSB3b3VsZCBhIGRyaXZlciBkbyB0aGF0Pwo+\n"
- "ID4gPiA+IAo+ID4gPiA+IEl0IG1pZ2h0IGJlIHRoYXQgSSBhbSBtaXNzaW5nIHRoZSBwb2ludCBo\n"
- "ZXJlLCBzbyBwbGVhc2UgZmVlbCBmcmVlIHRvCj4gPiA+ID4gY2x1ZSBtZSBpbi4KPiA+ID4gCj4g\n"
- "PiA+IFRoaXMgY2hlY2sgYmVoYXZlcyBpbiBhIHZlcnkgc2ltaWxhciB0byB0aGUgV0FSTigpIGFi\n"
- "b3ZlLiAgSXQncyBtb3JlCj4gPiA+IG9mIGEgZmFpbC1zYWZlLiAgSWYgYWxsIGRyaXZlcnMgYXJl\n"
- "IGJlaGF2aW5nIHByb3Blcmx5LCB0aGVuIGl0Cj4gPiA+IHNob3VsZG4ndCBldmVyIGJlIHRydWUu\n"
- "ICBJZiB0aGV5J3JlIG5vdCwgaXQgcHJldmVudHMgYW4gaW5jb3JyZWN0bHkKPiA+ID4gd3JpdHRl\n"
- "biBkcml2ZXIgZnJvbSBpcnJlY292ZXJhYmx5IGNyaXBwbGluZyB0aGUgc3lzdGVtLgo+ID4gCj4g\n"
- "PiBUaGVuIHRoaXMgY2hlY2sgc2hvdWxkIGJlIHJlcGxhY2VkIHdpdGggYSBnZW5lcmljIGFwcHJv\n"
- "YWNoIHRoYXQgcmVmdXNlcwo+ID4gdG8gaG9ub3IgaW1iYWxhbmNlcyBhbnl3YXlzLiBCZWxvdyBh\n"
- "cmUgdHdvIHBhdGNoZXMgdGhhdCBwcm9iYWJseSByZXNvbHZlCj4gPiB0aGUgaXNzdWUgb2YgYmFk\n"
- "bHkgYmVoYXZpbmcgZHJpdmVycyB0aGF0IGNhdXNlIGVuYWJsZSBpbWJhbGFuY2VzLgo+IAo+IFlv\n"
- "dXIgcGF0Y2ggc2hvdWxkIG1ha2UgdGhlIHJlcXVpcmVtZW50IGZvciB0aGlzIGNoZWNrIG1vb3Qs\n"
- "IHNvIGl0IGNhbgo+IHByb2JhYmx5IGJlIHJlbW92ZWQuCj4gCj4gPiA+IEFzIEkgc2FpZCBpbiB0\n"
- "aGUgb3RoZXIgbWFpbC4gIFdlIGNhbiBkbyB3aXRob3V0IHRoZXNlIDMgbmV3IHdyYXBwZXJzLgo+\n"
- "ID4gPiBXZSBfY291bGRfIGp1c3Qgd3JpdGUgYSBkcml2ZXIgd2hpY2ggb25seSBjYWxscyBjbGtf\n"
- "ZW5hYmxlKCkgX2FmdGVyXwo+ID4gPiBpdCBjYWxscyBjbGtfZGlzYWJsZSgpLCBhIGtpbmQgb2Yg\n"
- "aW50ZW50aW9uYWwgdW5iYWxhbmNlIGFuZCBpdCB3b3VsZAo+ID4gPiBkbyB0aGF0IHNhbWUgdGhp\n"
- "bmcuCj4gPiAKPiA+IFRoaXMgbmFpdmUgYXBwcm9hY2ggd2lsbCBub3Qgd29yayB3aXRoIHBlci11\n"
- "c2VyIGltYmFsYW5jZSB0cmFja2luZy4KPiAKPiBTdGVhZHkgb24uICBJIHNhaWQgd2UgIl9jb3Vs\n"
- "ZF8iLCB0aGF0IHRoYXQgSSB0aGluayBpdCdzIGEgZ29vZCBpZGVhLgo+IAo+IEkgdGhpbmsgaXQn\n"
- "cyBhIGJhZCBpZGVhLCB3aGljaCBpcyB3aHkgSSB3cm90ZSB0aGlzIHNldC4gOykKPiAKPiA+ID4g\n"
- "SG93ZXZlciwgd2hhdCB3ZSdyZSB0cnlpbmcgdG8gZG8gaGVyZSBpcyBwcm92aWRlCj4gPiA+IGEg\n"
- "cHJvcGVyIEFQSSwgc28gd2UgY2FuIHNlZSBhdCBmaXJzdCBnbGFuY2Ugd2hhdCB0aGUgJ2tub3ds\n"
- "ZWRnZWFibGUnCj4gPiA+IGRyaXZlciBpcyB0cnlpbmcgdG8gZG8gYW5kIG5vdCBoYXZlIHNvbWVv\n"
- "bmUgYXR0ZW1wdCB0byBzdWJtaXQgYSAnZml4Jwo+ID4gPiB3aGljaCBjYWxscyBjbGtfZW5hYmxl\n"
- "KCkgb3Igc29tZXRoaW5nLgo+ID4gCj4gPiBXZSdsbCBuZWVkIHNvbWUgdHlwZSBvZiBhcGkgZm9y\n"
- "IHN1cmUgZm9yIHRoZSBoYW5kb2ZmLgo+IAo+IFRoaXMgc2V0IHdpbGwgbm90IHRyaWdnZXIgeW91\n"
- "ciBuZXcgY2hlY2tzLiAgVGhlIGNsb2NrcyB3aWxsIGJlIGluCj4gcGVyZmVjdCBiYWxsYW5jZSBi\n"
- "ZWN1YXNlIGEgcmVmZXJlbmNlIHdpbGwgYmUgdGFrZW4gYXQgc3RhcnQtdXAuCj4gCj4gQWdhaW46\n"
- "Cj4gCj4gc3RhcnQtdXA6Cj4gICBjbGtfcHJlcGFyZV9lbmFibGUoKQo+IAo+IGtub3dsZWdhYmxl\n"
- "X2RyaXZlcl9wcm9iZToKPiAgIGNsa19nZXQoKQo+IAo+IGtub3dsZWdhYmxlX2RyaXZlcl9nYXRl\n"
- "X2NsazoKPiAgIGNsa19kaXNhYmxlX2NyaXRpY2FsKCkKClRoZSBjYWxsIHRvIGNsa19kaXNhYmxl\n"
- "KCkgbmVzdGVkIGluc2lkZSBjbGtfZGlzYWJsZV9jcml0aWNhbCB3aWxsIGZhaWwKd2l0aCB0aGUg\n"
- "bmV3IGNoZWNrcy4gVGhpcyBpcyBiZWNhdXNlIHRoZSBzdHJ1Y3QgY2xrIGluc3RhbmNlIHdpbGwg\n"
- "YmUKZGlmZmVyZW50IGZyb20gb25lIHVzZWQgaW4geW91ciAic3RhcnQtdXAiIHNlY3Rpb24gYWJv\n"
- "dmUuIGNsa19nZXQoKQpjcmVhdGVzIGEgdW5pcXVlIHN0cnVjdCBjbGsgZXZlcnkgdGltZSB5b3Ug\n"
- "Y2FsbCBpdC4KClB1dCBhbm90aGVyIHdheSwgYSB1bmlxdWUgdXNlciBvZiBhIGNsb2NrIGNhbm5v\n"
- "dCBjYWxsIGNsa19kaXNhYmxlKCkgd2hlbgp0aGUgcGVyLXVzZXIgZW5hYmxlX2NvdW50IGlzIDAu\n"
- "CgpGdXJ0aGVybW9yZSwgdGhlcmUgaXMgbm8gd2F5IHRoYXQgSSB3aWxsIGV2ZXIgYmUgaGFwcHkg\n"
- "d2l0aCBhIHRlY2huaXF1ZQp0aGF0IHJlcXVpcmVzIGNhbGxpbmcgZGlzYWJsZSBwcmlvciB0byBh\n"
- "biBlbmFibGUgd2l0aGluIGEgZHJpdmVyLiBUaGF0CmdvZXMgYWdhaW5zdCBhIGxvbmctc3RhbmRp\n"
- "bmcgYXBpIGRlc2lnbnMgYW5kIGlzIGNvbmZ1c2luZyBhcyBoZWxsIHRvCmRyaXZlciBhdXRob3Jz\n"
- "LgoKUmVnYXJkcywKTWlrZQoKPiAKPiBrbm93bGVnYWJsZV9kcml2ZXJfdW5nYXRlX2NsazoKPiAg\n"
- "IGNsa19lbmFibGVfY3JpdGljYWwoKQo+IAo+IGtub3dsZWdhYmxlX2RyaXZlcl9yZW1vdmU6Cj4g\n"
- "ICBjbGtfcHV0KCkKPiAKPiA+IEZyb20gMzU5OWVkMjA2ZGE5Y2U3NzBiZmFmY2ZkOTVjYmI5YTAz\n"
- "YWM0NDQ3MyBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKPiA+IEZyb206IE1pY2hhZWwgVHVycXVl\n"
- "dHRlIDxtdHVycXVldHRlQGJheWxpYnJlLmNvbT4KPiA+IERhdGU6IFdlZCwgMjkgSnVsIDIwMTUg\n"
- "MTg6MjI6NDUgLTA3MDAKPiA+IFN1YmplY3Q6IFtQQVRDSCAxLzJdIGNsazogcGVyLXVzZXIgY2xr\n"
- "IHByZXBhcmUgJiBlbmFibGUgcmVmIGNvdW50cwo+ID4gCj4gPiBUaGlzIHBhdGNoIGFkZHMgcHJl\n"
- "cGFyZSBhbmQgZW5hYmxlIHJlZmVyZW5jZSBjb3VudHMgZm9yIHRoZSBwZXItdXNlcgo+ID4gaGFu\n"
- "ZGxlcyB0aGF0IGNsb2NrIGNvbnN1bWVycyBoYXZlIGZvciBhIGNsb2NrIG5vZGUuIFRoaXMgcGF0\n"
- "Y2ggd2FybnMgaWYKPiA+IGFuIGltYmFsYW5jZSBvY2N1cnMgd2hpbGUgdHJ5aW5nIHRvIGRpc2Fi\n"
- "bGUgb3IgdW5wcmVwYXJlIGEgY2xvY2sgYW5kCj4gPiBhYm9ydHMsIGxlYXZpbmcgdGhlIGhhcmR3\n"
- "YXJlIHVuYWZmZWN0ZWQuCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IE1pY2hhZWwgVHVycXVldHRl\n"
- "IDxtdHVycXVldHRlQGJheWxpYnJlLmNvbT4KPiA+IC0tLQo+ID4gIGRyaXZlcnMvY2xrL2Nsay5j\n"
- "IHwgMTAgKysrKysrKysrKwo+ID4gIDEgZmlsZSBjaGFuZ2VkLCAxMCBpbnNlcnRpb25zKCspCj4g\n"
- "PiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsay9jbGsuYyBiL2RyaXZlcnMvY2xrL2Nsay5j\n"
- "Cj4gPiBpbmRleCA4OTgwNTJlLi43MmZlZWU5IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9jbGsv\n"
- "Y2xrLmMKPiA+ICsrKyBiL2RyaXZlcnMvY2xrL2Nsay5jCj4gPiBAQCAtODQsNiArODQsOCBAQCBz\n"
- "dHJ1Y3QgY2xrIHsKPiA+ICAgICAgIHVuc2lnbmVkIGxvbmcgbWluX3JhdGU7Cj4gPiAgICAgICB1\n"
- "bnNpZ25lZCBsb25nIG1heF9yYXRlOwo+ID4gICAgICAgc3RydWN0IGhsaXN0X25vZGUgY2xrc19u\n"
- "b2RlOwo+ID4gKyAgICAgdW5zaWduZWQgaW50IGVuYWJsZV9jb3VudDsKPiA+ICsgICAgIHVuc2ln\n"
- "bmVkIGludCBwcmVwYXJlX2NvdW50Owo+ID4gIH07Cj4gPiAgCj4gPiAgLyoqKiAgICAgICAgICAg\n"
- "bG9ja2luZyAgICAgICAgICAgICAqKiovCj4gPiBAQCAtNjAwLDYgKzYwMiw5IEBAIHZvaWQgY2xr\n"
- "X3VucHJlcGFyZShzdHJ1Y3QgY2xrICpjbGspCj4gPiAgICAgICAgICAgICAgIHJldHVybjsKPiA+\n"
- "ICAKPiA+ICAgICAgIGNsa19wcmVwYXJlX2xvY2soKTsKPiA+ICsgICAgIGlmIChXQVJOX09OKGNs\n"
- "ay0+cHJlcGFyZV9jb3VudCA9PSAwKSkKPiA+ICsgICAgICAgICAgICAgcmV0dXJuOwo+ID4gKyAg\n"
- "ICAgY2xrLT5wcmVwYXJlX2NvdW50LS07Cj4gPiAgICAgICBjbGtfY29yZV91bnByZXBhcmUoY2xr\n"
- "LT5jb3JlKTsKPiA+ICAgICAgIGNsa19wcmVwYXJlX3VubG9jaygpOwo+ID4gIH0KPiA+IEBAIC02\n"
- "NTcsNiArNjYyLDcgQEAgaW50IGNsa19wcmVwYXJlKHN0cnVjdCBjbGsgKmNsaykKPiA+ICAgICAg\n"
- "ICAgICAgICAgcmV0dXJuIDA7Cj4gPiAgCj4gPiAgICAgICBjbGtfcHJlcGFyZV9sb2NrKCk7Cj4g\n"
- "PiArICAgICBjbGstPnByZXBhcmVfY291bnQrKzsKPiA+ICAgICAgIHJldCA9IGNsa19jb3JlX3By\n"
- "ZXBhcmUoY2xrLT5jb3JlKTsKPiA+ICAgICAgIGNsa19wcmVwYXJlX3VubG9jaygpOwo+ID4gIAo+\n"
- "ID4gQEAgLTcwNyw2ICs3MTMsOSBAQCB2b2lkIGNsa19kaXNhYmxlKHN0cnVjdCBjbGsgKmNsaykK\n"
- "PiA+ICAgICAgICAgICAgICAgcmV0dXJuOwo+ID4gIAo+ID4gICAgICAgZmxhZ3MgPSBjbGtfZW5h\n"
- "YmxlX2xvY2soKTsKPiA+ICsgICAgIGlmIChXQVJOX09OKGNsay0+ZW5hYmxlX2NvdW50ID09IDAp\n"
- "KQo+ID4gKyAgICAgICAgICAgICByZXR1cm47Cj4gPiArICAgICBjbGstPmVuYWJsZV9jb3VudC0t\n"
- "Owo+ID4gICAgICAgY2xrX2NvcmVfZGlzYWJsZShjbGstPmNvcmUpOwo+ID4gICAgICAgY2xrX2Vu\n"
- "YWJsZV91bmxvY2soZmxhZ3MpOwo+ID4gIH0KPiA+IEBAIC03NjksNiArNzc4LDcgQEAgaW50IGNs\n"
- "a19lbmFibGUoc3RydWN0IGNsayAqY2xrKQo+ID4gICAgICAgICAgICAgICByZXR1cm4gMDsKPiA+\n"
- "ICAKPiA+ICAgICAgIGZsYWdzID0gY2xrX2VuYWJsZV9sb2NrKCk7Cj4gPiArICAgICBjbGstPmVu\n"
- "YWJsZV9jb3VudCsrOwo+ID4gICAgICAgcmV0ID0gY2xrX2NvcmVfZW5hYmxlKGNsay0+Y29yZSk7\n"
- "Cj4gPiAgICAgICBjbGtfZW5hYmxlX3VubG9jayhmbGFncyk7Cj4gPiAgCj4gCj4gLS0gCj4gTGVl\n"
- "IEpvbmVzCj4gTGluYXJvIFNUTWljcm9lbGVjdHJvbmljcyBMYW5kaW5nIFRlYW0gTGVhZAo+IExp\n"
- "bmFyby5vcmcg4pSCIE9wZW4gc291cmNlIHNvZnR3YXJlIGZvciBBUk0gU29Dcwo+IEZvbGxvdyBM\n"
- "aW5hcm86IEZhY2Vib29rIHwgVHdpdHRlciB8IEJsb2cKPiAtLQo+IFRvIHVuc3Vic2NyaWJlIGZy\n"
- "b20gdGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC1jbGsiIGluCj4g\n"
- "dGhlIGJvZHkgb2YgYSBtZXNzYWdlIHRvIG1ham9yZG9tb0B2Z2VyLmtlcm5lbC5vcmcKPiBNb3Jl\n"
- "IG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZv\n"
- "Lmh0bWwKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxp\n"
- "bnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFk\n"
- "ZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4\n"
- LWFybS1rZXJuZWwK
+ "Quoting Lee Jones (2015-07-31 02:02:19)\n"
+ "> On Thu, 30 Jul 2015, Michael Turquette wrote:\n"
+ "> \n"
+ "> > Quoting Lee Jones (2015-07-30 04:17:47)\n"
+ "> > > On Wed, 29 Jul 2015, Michael Turquette wrote:\n"
+ "> > > \n"
+ "> > > > Hi Lee,\n"
+ "> > > > \n"
+ "> > > > + linux-clk ml\n"
+ "> > > > \n"
+ "> > > > Quoting Lee Jones (2015-07-22 06:04:13)\n"
+ "> > > > > These new API calls will firstly provide a mechanisms to tag a clock as\n"
+ "> > > > > critical and secondly allow any knowledgeable driver to (un)gate clocks,\n"
+ "> > > > > even if they are marked as critical.\n"
+ "> > > > > \n"
+ "> > > > > Suggested-by: Maxime Ripard <maxime.ripard@free-electrons.com>\n"
+ "> > > > > Signed-off-by: Lee Jones <lee.jones@linaro.org>\n"
+ "> > > > > ---\n"
+ "> > > > >  drivers/clk/clk.c            | 45 ++++++++++++++++++++++++++++++++++++++++++++\n"
+ "> > > > >  include/linux/clk-provider.h |  2 ++\n"
+ "> > > > >  include/linux/clk.h          | 30 +++++++++++++++++++++++++++++\n"
+ "> > > > >  3 files changed, 77 insertions(+)\n"
+ "> > > > > \n"
+ "> > > > > diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c\n"
+ "> > > > > index 61c3fc5..486b1da 100644\n"
+ "> > > > > --- a/drivers/clk/clk.c\n"
+ "> > > > > +++ b/drivers/clk/clk.c\n"
+ "> > > > > @@ -46,6 +46,21 @@ static struct clk_core *clk_core_lookup(const char *name);\n"
+ "> > > > >  \n"
+ "> > > > >  /***    private data structures    ***/\n"
+ "> > > > >  \n"
+ "> > > > > +/**\n"
+ "> > > > > + * struct critical -   Provides 'play' over critical clocks.  A clock can be\n"
+ "> > > > > + *                     marked as critical, meaning that it should not be\n"
+ "> > > > > + *                     disabled.  However, if a driver which is aware of the\n"
+ "> > > > > + *                     critical behaviour wants to control it, it can do so\n"
+ "> > > > > + *                     using clk_enable_critical() and clk_disable_critical().\n"
+ "> > > > > + *\n"
+ "> > > > > + * @enabled    Is clock critical?  Once set, doesn't change\n"
+ "> > > > > + * @leave_on   Self explanatory.  Can be disabled by knowledgeable drivers\n"
+ "> > > > \n"
+ "> > > > Not self explanatory. I need this explained to me. What does leave_on\n"
+ "> > > > do? Better yet, what would happen if leave_on did not exist?\n"
+ "> > > > \n"
+ "> > > > > + */\n"
+ "> > > > > +struct critical {\n"
+ "> > > > > +       bool enabled;\n"
+ "> > > > > +       bool leave_on;\n"
+ "> > > > > +};\n"
+ "> > > > > +\n"
+ "> > > > >  struct clk_core {\n"
+ "> > > > >         const char              *name;\n"
+ "> > > > >         const struct clk_ops    *ops;\n"
+ "> > > > > @@ -75,6 +90,7 @@ struct clk_core {\n"
+ "> > > > >         struct dentry           *dentry;\n"
+ "> > > > >  #endif\n"
+ "> > > > >         struct kref             ref;\n"
+ "> > > > > +       struct critical         critical;\n"
+ "> > > > >  };\n"
+ "> > > > >  \n"
+ "> > > > >  struct clk {\n"
+ "> > > > > @@ -995,6 +1011,10 @@ static void clk_core_disable(struct clk_core *clk)\n"
+ "> > > > >         if (WARN_ON(clk->enable_count == 0))\n"
+ "> > > > >                 return;\n"
+ "> > > > >  \n"
+ "> > > > > +       /* Refuse to turn off a critical clock */\n"
+ "> > > > > +       if (clk->enable_count == 1 && clk->critical.leave_on)\n"
+ "> > > > > +               return;\n"
+ "> > > > \n"
+ "> > > > How do we get to this point? clk_enable_critical actually calls\n"
+ "> > > > clk_enable, thus incrementing the enable_count. The only time that we\n"
+ "> > > > could hit the above case is if,\n"
+ "> > > > \n"
+ "> > > > a) there is an imbalance in clk_enable and clk_disable calls. If this is\n"
+ "> > > > the case then the drivers need to be fixed. Or better yet some\n"
+ "> > > > infrastructure to catch that, now that we have per-user struct clk\n"
+ "> > > > cookies.\n"
+ "> > > > \n"
+ "> > > > b) a driver knowingly calls clk_enable_critical(foo) and then regular,\n"
+ "> > > > old clk_disable(foo). But why would a driver do that?\n"
+ "> > > > \n"
+ "> > > > It might be that I am missing the point here, so please feel free to\n"
+ "> > > > clue me in.\n"
+ "> > > \n"
+ "> > > This check behaves in a very similar to the WARN() above.  It's more\n"
+ "> > > of a fail-safe.  If all drivers are behaving properly, then it\n"
+ "> > > shouldn't ever be true.  If they're not, it prevents an incorrectly\n"
+ "> > > written driver from irrecoverably crippling the system.\n"
+ "> > \n"
+ "> > Then this check should be replaced with a generic approach that refuses\n"
+ "> > to honor imbalances anyways. Below are two patches that probably resolve\n"
+ "> > the issue of badly behaving drivers that cause enable imbalances.\n"
+ "> \n"
+ "> Your patch should make the requirement for this check moot, so it can\n"
+ "> probably be removed.\n"
+ "> \n"
+ "> > > As I said in the other mail.  We can do without these 3 new wrappers.\n"
+ "> > > We _could_ just write a driver which only calls clk_enable() _after_\n"
+ "> > > it calls clk_disable(), a kind of intentional unbalance and it would\n"
+ "> > > do that same thing.\n"
+ "> > \n"
+ "> > This naive approach will not work with per-user imbalance tracking.\n"
+ "> \n"
+ "> Steady on.  I said we \"_could_\", that that I think it's a good idea.\n"
+ "> \n"
+ "> I think it's a bad idea, which is why I wrote this set. ;)\n"
+ "> \n"
+ "> > > However, what we're trying to do here is provide\n"
+ "> > > a proper API, so we can see at first glance what the 'knowledgeable'\n"
+ "> > > driver is trying to do and not have someone attempt to submit a 'fix'\n"
+ "> > > which calls clk_enable() or something.\n"
+ "> > \n"
+ "> > We'll need some type of api for sure for the handoff.\n"
+ "> \n"
+ "> This set will not trigger your new checks.  The clocks will be in\n"
+ "> perfect ballance becuase a reference will be taken at start-up.\n"
+ "> \n"
+ "> Again:\n"
+ "> \n"
+ "> start-up:\n"
+ ">   clk_prepare_enable()\n"
+ "> \n"
+ "> knowlegable_driver_probe:\n"
+ ">   clk_get()\n"
+ "> \n"
+ "> knowlegable_driver_gate_clk:\n"
+ ">   clk_disable_critical()\n"
+ "\n"
+ "The call to clk_disable() nested inside clk_disable_critical will fail\n"
+ "with the new checks. This is because the struct clk instance will be\n"
+ "different from one used in your \"start-up\" section above. clk_get()\n"
+ "creates a unique struct clk every time you call it.\n"
+ "\n"
+ "Put another way, a unique user of a clock cannot call clk_disable() when\n"
+ "the per-user enable_count is 0.\n"
+ "\n"
+ "Furthermore, there is no way that I will ever be happy with a technique\n"
+ "that requires calling disable prior to an enable within a driver. That\n"
+ "goes against a long-standing api designs and is confusing as hell to\n"
+ "driver authors.\n"
+ "\n"
+ "Regards,\n"
+ "Mike\n"
+ "\n"
+ "> \n"
+ "> knowlegable_driver_ungate_clk:\n"
+ ">   clk_enable_critical()\n"
+ "> \n"
+ "> knowlegable_driver_remove:\n"
+ ">   clk_put()\n"
+ "> \n"
+ "> > From 3599ed206da9ce770bfafcfd95cbb9a03ac44473 Mon Sep 17 00:00:00 2001\n"
+ "> > From: Michael Turquette <mturquette@baylibre.com>\n"
+ "> > Date: Wed, 29 Jul 2015 18:22:45 -0700\n"
+ "> > Subject: [PATCH 1/2] clk: per-user clk prepare & enable ref counts\n"
+ "> > \n"
+ "> > This patch adds prepare and enable reference counts for the per-user\n"
+ "> > handles that clock consumers have for a clock node. This patch warns if\n"
+ "> > an imbalance occurs while trying to disable or unprepare a clock and\n"
+ "> > aborts, leaving the hardware unaffected.\n"
+ "> > \n"
+ "> > Signed-off-by: Michael Turquette <mturquette@baylibre.com>\n"
+ "> > ---\n"
+ "> >  drivers/clk/clk.c | 10 ++++++++++\n"
+ "> >  1 file changed, 10 insertions(+)\n"
+ "> > \n"
+ "> > diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c\n"
+ "> > index 898052e..72feee9 100644\n"
+ "> > --- a/drivers/clk/clk.c\n"
+ "> > +++ b/drivers/clk/clk.c\n"
+ "> > @@ -84,6 +84,8 @@ struct clk {\n"
+ "> >       unsigned long min_rate;\n"
+ "> >       unsigned long max_rate;\n"
+ "> >       struct hlist_node clks_node;\n"
+ "> > +     unsigned int enable_count;\n"
+ "> > +     unsigned int prepare_count;\n"
+ "> >  };\n"
+ "> >  \n"
+ "> >  /***           locking             ***/\n"
+ "> > @@ -600,6 +602,9 @@ void clk_unprepare(struct clk *clk)\n"
+ "> >               return;\n"
+ "> >  \n"
+ "> >       clk_prepare_lock();\n"
+ "> > +     if (WARN_ON(clk->prepare_count == 0))\n"
+ "> > +             return;\n"
+ "> > +     clk->prepare_count--;\n"
+ "> >       clk_core_unprepare(clk->core);\n"
+ "> >       clk_prepare_unlock();\n"
+ "> >  }\n"
+ "> > @@ -657,6 +662,7 @@ int clk_prepare(struct clk *clk)\n"
+ "> >               return 0;\n"
+ "> >  \n"
+ "> >       clk_prepare_lock();\n"
+ "> > +     clk->prepare_count++;\n"
+ "> >       ret = clk_core_prepare(clk->core);\n"
+ "> >       clk_prepare_unlock();\n"
+ "> >  \n"
+ "> > @@ -707,6 +713,9 @@ void clk_disable(struct clk *clk)\n"
+ "> >               return;\n"
+ "> >  \n"
+ "> >       flags = clk_enable_lock();\n"
+ "> > +     if (WARN_ON(clk->enable_count == 0))\n"
+ "> > +             return;\n"
+ "> > +     clk->enable_count--;\n"
+ "> >       clk_core_disable(clk->core);\n"
+ "> >       clk_enable_unlock(flags);\n"
+ "> >  }\n"
+ "> > @@ -769,6 +778,7 @@ int clk_enable(struct clk *clk)\n"
+ "> >               return 0;\n"
+ "> >  \n"
+ "> >       flags = clk_enable_lock();\n"
+ "> > +     clk->enable_count++;\n"
+ "> >       ret = clk_core_enable(clk->core);\n"
+ "> >       clk_enable_unlock(flags);\n"
+ "> >  \n"
+ "> \n"
+ "> -- \n"
+ "> Lee Jones\n"
+ "> Linaro STMicroelectronics Landing Team Lead\n"
+ "> Linaro.org ? Open source software for ARM SoCs\n"
+ "> Follow Linaro: Facebook | Twitter | Blog\n"
+ "> --\n"
+ "> To unsubscribe from this list: send the line \"unsubscribe linux-clk\" in\n"
+ "> the body of a message to majordomo at vger.kernel.org\n"
+ > More majordomo info at  http://vger.kernel.org/majordomo-info.html
 
-1c5dec83dc704783680a3d67df6e27817296f2a5862cb29496c2065a6e5006a2
+576984da068d4ca959031de8c3bea14f98dab356848e4502d79d088cbcaa308d
