From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gavin Shan Subject: [PATCH v7 23/50] powerpc/powernv: Use PE instead of number during setup and release Date: Thu, 5 Nov 2015 00:12:23 +1100 Message-ID: <1446642770-4681-24-git-send-email-gwshan@linux.vnet.ibm.com> References: <1446642770-4681-1-git-send-email-gwshan@linux.vnet.ibm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1446642770-4681-1-git-send-email-gwshan@linux.vnet.ibm.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" To: linuxppc-dev@lists.ozlabs.org Cc: devicetree@vger.kernel.org, aik@ozlabs.ru, linux-pci@vger.kernel.org, panto@antoniou-consulting.com, Gavin Shan , grant.likely@linaro.org, robherring2@gmail.com, bhelgaas@google.com, frowand.list@gmail.com List-Id: devicetree@vger.kernel.org SW4gY3VycmVudCBpbXBsZW1lbnRhdGlvbiwgdGhlIFBFcyB0aGF0IGFyZSBhbGxvY2F0ZWQgb3Ig cGlja2VkCmZyb20gdGhlIHJlc2VydmVkIGxpc3QgYXJlIGlkZW50aWZpZWQgYnkgUEUgbnVtYmVy LiBUaGUgUEUgaW5zdGFuY2UKaGFzIHRvIGJlIHBpY2tlZCBhY2NvcmRpbmcgdG8gdGhlIFBFIG51 bWJlciBldmVudHVhbGx5LiBXZSBoYXZlCnNhbWUgaXNzdWUgd2hlbiBQRSBpcyByZWxlYXNlZC4K CkZvciBwbnZfaW9kYV9waWNrX202NF9wZSgpIGFuZCBwbnZfaW9kYV9hbGxvY19wZSgpLCB0aGlz IHJldHVybnMKUEUgaW5zdGFuY2Ugc28gdGhhdCBwbnZfaW9kYV9zZXR1cF9idXNfUEUoKSBjYW4g dXNlIHRoZSBhbGxvY2F0ZWQKb3IgcmVzZXJ2ZWQgUEUgaW5zdGFuY2UgZGlyZWN0bHkuIEFsc28s IHBudl9pb2RhX3NldHVwX2J1c19QRSgpCnJldHVybnMgdGhlIHJlc2VydmVkL2FsbG9jYXRlZCBQ RSBpbnN0YW5jZSB0byBiZSB1c2VkIGluIHN1YnNlcXVlbnQKcGF0Y2hlcy4gT24gdGhlIG90aGVy IGhhbmQsIHBudl9pb2RhX2ZyZWVfcGUoKSB1c2VzIFBFIGluc3RhbmNlCihub3QgbnVtYmVyKSBh cyBpdHMgYXJndW1lbnQuIE5vIGxvZ2ljYWwgY2hhbmdlcyBpbnRyb2R1Y2VkLgoKU2lnbmVkLW9m Zi1ieTogR2F2aW4gU2hhbiA8Z3dzaGFuQGxpbnV4LnZuZXQuaWJtLmNvbT4KLS0tCiBhcmNoL3Bv d2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvcGNpLWlvZGEuYyB8IDgxICsrKysrKysrKysrKysrKysr LS0tLS0tLS0tLS0tLS0KIGFyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9wY2kuaCAgICAg IHwgIDIgKy0KIDIgZmlsZXMgY2hhbmdlZCwgNDYgaW5zZXJ0aW9ucygrKSwgMzcgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L3BjaS1pb2Rh LmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvcGNpLWlvZGEuYwppbmRleCA0ODhl MGY4Li5hZTgyZGYxIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYv cGNpLWlvZGEuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvcGNpLWlvZGEu YwpAQCAtMTUyLDcgKzE1Miw3IEBAIHN0YXRpYyB2b2lkIHBudl9pb2RhX3Jlc2VydmVfcGUoc3Ry dWN0IHBudl9waGIgKnBoYiwgaW50IHBlX25vKQogCXBudl9pb2RhX2luaXRfcGUocGhiLCBwZV9u byk7CiB9CiAKLXN0YXRpYyBpbnQgcG52X2lvZGFfYWxsb2NfcGUoc3RydWN0IHBudl9waGIgKnBo YikKK3N0YXRpYyBzdHJ1Y3QgcG52X2lvZGFfcGUgKnBudl9pb2RhX2FsbG9jX3BlKHN0cnVjdCBw bnZfcGhiICpwaGIpCiB7CiAJdW5zaWduZWQgbG9uZyBwZTsKIApAQCAtMTYwLDE5ICsxNjAsMjAg QEAgc3RhdGljIGludCBwbnZfaW9kYV9hbGxvY19wZShzdHJ1Y3QgcG52X3BoYiAqcGhiKQogCQlw ZSA9IGZpbmRfbmV4dF96ZXJvX2JpdChwaGItPmlvZGEucGVfYWxsb2MsCiAJCQkJCXBoYi0+aW9k YS50b3RhbF9wZV9udW0sIDApOwogCQlpZiAocGUgPj0gcGhiLT5pb2RhLnRvdGFsX3BlX251bSkK LQkJCXJldHVybiBJT0RBX0lOVkFMSURfUEU7CisJCQlyZXR1cm4gTlVMTDsKIAl9IHdoaWxlKHRl c3RfYW5kX3NldF9iaXQocGUsIHBoYi0+aW9kYS5wZV9hbGxvYykpOwogCi0JcG52X2lvZGFfaW5p dF9wZShwaGIsIHBlKTsKLQlyZXR1cm4gcGU7CisJcmV0dXJuIHBudl9pb2RhX2luaXRfcGUocGhi LCBwZSk7CiB9CiAKLXN0YXRpYyB2b2lkIHBudl9pb2RhX2ZyZWVfcGUoc3RydWN0IHBudl9waGIg KnBoYiwgaW50IHBlKQorc3RhdGljIHZvaWQgcG52X2lvZGFfZnJlZV9wZShzdHJ1Y3QgcG52X2lv ZGFfcGUgKnBlKQogewotCVdBUk5fT04ocGhiLT5pb2RhLnBlX2FycmF5W3BlXS5wZGV2KTsKKwlz dHJ1Y3QgcG52X3BoYiAqcGhiID0gcGUtPnBoYjsKKworCVdBUk5fT04ocGUtPnBkZXYpOwogCi0J bWVtc2V0KCZwaGItPmlvZGEucGVfYXJyYXlbcGVdLCAwLCBzaXplb2Yoc3RydWN0IHBudl9pb2Rh X3BlKSk7Ci0JY2xlYXJfYml0KHBlLCBwaGItPmlvZGEucGVfYWxsb2MpOworCW1lbXNldChwZSwg MCwgc2l6ZW9mKHN0cnVjdCBwbnZfaW9kYV9wZSkpOworCWNsZWFyX2JpdChwZS0+cGVfbnVtYmVy LCBwaGItPmlvZGEucGVfYWxsb2MpOwogfQogCiAvKiBUaGUgZGVmYXVsdCBNNjQgQkFSIGlzIHNo YXJlZCBieSBhbGwgUEVzICovCkBAIC0zMzIsNyArMzMzLDcgQEAgc3RhdGljIHZvaWQgcG52X2lv ZGFfcmVzZXJ2ZV9tNjRfcGUoc3RydWN0IHBjaV9idXMgKmJ1cywKIAl9CiB9CiAKLXN0YXRpYyBp bnQgcG52X2lvZGFfcGlja19tNjRfcGUoc3RydWN0IHBjaV9idXMgKmJ1cywgYm9vbCBhbGwpCitz dGF0aWMgc3RydWN0IHBudl9pb2RhX3BlICpwbnZfaW9kYV9waWNrX202NF9wZShzdHJ1Y3QgcGNp X2J1cyAqYnVzLCBib29sIGFsbCkKIHsKIAlzdHJ1Y3QgcGNpX2NvbnRyb2xsZXIgKmhvc2UgPSBw Y2lfYnVzX3RvX2hvc3QoYnVzKTsKIAlzdHJ1Y3QgcG52X3BoYiAqcGhiID0gaG9zZS0+cHJpdmF0 ZV9kYXRhOwpAQCAtMzQyLDcgKzM0Myw3IEBAIHN0YXRpYyBpbnQgcG52X2lvZGFfcGlja19tNjRf cGUoc3RydWN0IHBjaV9idXMgKmJ1cywgYm9vbCBhbGwpCiAKIAkvKiBSb290IGJ1cyBzaG91bGRu J3QgdXNlIE02NCAqLwogCWlmIChwY2lfaXNfcm9vdF9idXMoYnVzKSkKLQkJcmV0dXJuIElPREFf SU5WQUxJRF9QRTsKKwkJcmV0dXJuIE5VTEw7CiAKIAkvKiBBbGxvY2F0ZSBiaXRtYXAgKi8KIAlz aXplID0gX0FMSUdOX1VQKHBoYi0+aW9kYS50b3RhbF9wZV9udW0gLyA4LCBzaXplb2YodW5zaWdu ZWQgbG9uZykpOwpAQCAtMzUwLDcgKzM1MSw3IEBAIHN0YXRpYyBpbnQgcG52X2lvZGFfcGlja19t NjRfcGUoc3RydWN0IHBjaV9idXMgKmJ1cywgYm9vbCBhbGwpCiAJaWYgKCFwZV9hbGxvYykgewog CQlwcl93YXJuKCIlczogT3V0IG9mIG1lbW9yeSAhXG4iLAogCQkJX19mdW5jX18pOwotCQlyZXR1 cm4gSU9EQV9JTlZBTElEX1BFOworCQlyZXR1cm4gTlVMTDsKIAl9CiAKIAkvKiBGaWd1cmUgb3V0 IHJlc2VydmVkIFBFIG51bWJlcnMgYnkgdGhlIFBFICovCkBAIC0zNjMsNyArMzY0LDcgQEAgc3Rh dGljIGludCBwbnZfaW9kYV9waWNrX202NF9wZShzdHJ1Y3QgcGNpX2J1cyAqYnVzLCBib29sIGFs bCkKIAkgKi8KIAlpZiAoYml0bWFwX2VtcHR5KHBlX2FsbG9jLCBwaGItPmlvZGEudG90YWxfcGVf bnVtKSkgewogCQlrZnJlZShwZV9hbGxvYyk7Ci0JCXJldHVybiBJT0RBX0lOVkFMSURfUEU7CisJ CXJldHVybiBOVUxMOwogCX0KIAogCS8qCkBAIC00MDksNyArNDEwLDcgQEAgc3RhdGljIGludCBw bnZfaW9kYV9waWNrX202NF9wZShzdHJ1Y3QgcGNpX2J1cyAqYnVzLCBib29sIGFsbCkKIAl9CiAK IAlrZnJlZShwZV9hbGxvYyk7Ci0JcmV0dXJuIG1hc3Rlcl9wZS0+cGVfbnVtYmVyOworCXJldHVy biBtYXN0ZXJfcGU7CiB9CiAKIHN0YXRpYyB2b2lkIF9faW5pdCBwbnZfaW9kYV9wYXJzZV9tNjRf d2luZG93KHN0cnVjdCBwbnZfcGhiICpwaGIpCkBAIC05ODgsMjggKzk4OSwyNiBAQCBzdGF0aWMg dm9pZCBwbnZfaW9kYV9zZXR1cF9zYW1lX1BFKHN0cnVjdCBwY2lfYnVzICpidXMsIHN0cnVjdCBw bnZfaW9kYV9wZSAqcGUpCiAgKiBzdWJvcmRpbmF0ZSBQQ0kgZGV2aWNlcyBhbmQgYnVzZXMuIFRo ZSBzZWNvbmQgdHlwZSBvZiBQRSBpcyBub3JtYWxseQogICogb3JnaXJpYXRlZCBieSBQQ0llLXRv LVBDSSBicmlkZ2Ugb3IgUExYIHN3aXRjaCBkb3duc3RyZWFtIHBvcnRzLgogICovCi1zdGF0aWMg dm9pZCBwbnZfaW9kYV9zZXR1cF9idXNfUEUoc3RydWN0IHBjaV9idXMgKmJ1cywgYm9vbCBhbGwp CitzdGF0aWMgc3RydWN0IHBudl9pb2RhX3BlICpwbnZfaW9kYV9zZXR1cF9idXNfUEUoc3RydWN0 IHBjaV9idXMgKmJ1cywgYm9vbCBhbGwpCiB7CiAJc3RydWN0IHBjaV9jb250cm9sbGVyICpob3Nl ID0gcGNpX2J1c190b19ob3N0KGJ1cyk7CiAJc3RydWN0IHBudl9waGIgKnBoYiA9IGhvc2UtPnBy aXZhdGVfZGF0YTsKLQlzdHJ1Y3QgcG52X2lvZGFfcGUgKnBlOwotCWludCBwZV9udW0gPSBJT0RB X0lOVkFMSURfUEU7CisJc3RydWN0IHBudl9pb2RhX3BlICpwZSA9IE5VTEw7CiAKIAkvKiBDaGVj ayBpZiBQRSBpcyBkZXRlcm1pbmVkIGJ5IE02NCAqLwogCWlmIChwaGItPnBpY2tfbTY0X3BlKQot CQlwZV9udW0gPSBwaGItPnBpY2tfbTY0X3BlKGJ1cywgYWxsKTsKKwkJcGUgPSBwaGItPnBpY2tf bTY0X3BlKGJ1cywgYWxsKTsKIAogCS8qIFRoZSBQRSBudW1iZXIgaXNuJ3QgcGlubmVkIGJ5IE02 NCAqLwotCWlmIChwZV9udW0gPT0gSU9EQV9JTlZBTElEX1BFKQotCQlwZV9udW0gPSBwbnZfaW9k YV9hbGxvY19wZShwaGIpOworCWlmICghcGUpCisJCXBlID0gcG52X2lvZGFfYWxsb2NfcGUocGhi KTsKIAotCWlmIChwZV9udW0gPT0gSU9EQV9JTlZBTElEX1BFKSB7CisJaWYgKCFwZSkgewogCQlw cl93YXJuaW5nKCIlczogTm90IGVub3VnaCBQRSMgYXZhaWxhYmxlIGZvciBQQ0kgYnVzICUwNHg6 JTAyeFxuIiwKIAkJCV9fZnVuY19fLCBwY2lfZG9tYWluX25yKGJ1cyksIGJ1cy0+bnVtYmVyKTsK LQkJcmV0dXJuOworCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlwZSA9ICZwaGItPmlvZGEucGVfYXJy YXlbcGVfbnVtXTsKIAlwZS0+ZmxhZ3MgfD0gKGFsbCA/IFBOVl9JT0RBX1BFX0JVU19BTEwgOiBQ TlZfSU9EQV9QRV9CVVMpOwogCXBlLT5wYnVzID0gYnVzOwogCXBlLT5wZGV2ID0gTlVMTDsKQEAg LTEwMTgsMTcgKzEwMTcsMTYgQEAgc3RhdGljIHZvaWQgcG52X2lvZGFfc2V0dXBfYnVzX1BFKHN0 cnVjdCBwY2lfYnVzICpidXMsIGJvb2wgYWxsKQogCiAJaWYgKGFsbCkKIAkJcGVfaW5mbyhwZSwg IlNlY29uZGFyeSBidXMgJWQuLiVkIGFzc29jaWF0ZWQgd2l0aCBQRSMlZFxuIiwKLQkJCWJ1cy0+ YnVzbl9yZXMuc3RhcnQsIGJ1cy0+YnVzbl9yZXMuZW5kLCBwZV9udW0pOworCQkJYnVzLT5idXNu X3Jlcy5zdGFydCwgYnVzLT5idXNuX3Jlcy5lbmQsIHBlLT5wZV9udW1iZXIpOwogCWVsc2UKIAkJ cGVfaW5mbyhwZSwgIlNlY29uZGFyeSBidXMgJWQgYXNzb2NpYXRlZCB3aXRoIFBFIyVkXG4iLAot CQkJYnVzLT5idXNuX3Jlcy5zdGFydCwgcGVfbnVtKTsKKwkJCWJ1cy0+YnVzbl9yZXMuc3RhcnQs IHBlLT5wZV9udW1iZXIpOwogCiAJaWYgKHBudl9pb2RhX2NvbmZpZ3VyZV9wZShwaGIsIHBlKSkg ewogCQkvKiBYWFggV2hhdCBkbyB3ZSBkbyBoZXJlID8gKi8KLQkJaWYgKHBlX251bSkKLQkJCXBu dl9pb2RhX2ZyZWVfcGUocGhiLCBwZV9udW0pOworCQlwbnZfaW9kYV9mcmVlX3BlKHBlKTsKIAkJ cGUtPnBidXMgPSBOVUxMOwotCQlyZXR1cm47CisJCXJldHVybiBOVUxMOwogCX0KIAogCS8qIEFz c29jaWF0ZSBpdCB3aXRoIGFsbCBjaGlsZCBkZXZpY2VzICovCkBAIC0xMDM2LDYgKzEwMzQsOCBA QCBzdGF0aWMgdm9pZCBwbnZfaW9kYV9zZXR1cF9idXNfUEUoc3RydWN0IHBjaV9idXMgKmJ1cywg Ym9vbCBhbGwpCiAKIAkvKiBQdXQgUEUgdG8gdGhlIGxpc3QgKi8KIAlsaXN0X2FkZF90YWlsKCZw ZS0+bGlzdCwgJnBoYi0+aW9kYS5wZV9saXN0KTsKKworCXJldHVybiBwZTsKIH0KIAogc3RhdGlj IHZvaWQgcG52X2lvZGFfc2V0dXBfUEVzKHN0cnVjdCBwY2lfYnVzICpidXMpCkBAIC0xMjY3LDcg KzEyNjcsNyBAQCBzdGF0aWMgdm9pZCBwbnZfaW9kYV9yZWxlYXNlX3ZmX1BFKHN0cnVjdCBwY2lf ZGV2ICpwZGV2KQogCiAJCXBudl9pb2RhX2RlY29uZmlndXJlX3BlKHBoYiwgcGUpOwogCi0JCXBu dl9pb2RhX2ZyZWVfcGUocGhiLCBwZS0+cGVfbnVtYmVyKTsKKwkJcG52X2lvZGFfZnJlZV9wZShw ZSk7CiAJfQogfQogCkBAIC0xMjc2LDYgKzEyNzYsNyBAQCB2b2lkIHBudl9wY2lfc3Jpb3ZfZGlz YWJsZShzdHJ1Y3QgcGNpX2RldiAqcGRldikKIAlzdHJ1Y3QgcGNpX2J1cyAgICAgICAgKmJ1czsK IAlzdHJ1Y3QgcGNpX2NvbnRyb2xsZXIgKmhvc2U7CiAJc3RydWN0IHBudl9waGIgICAgICAgICpw aGI7CisJc3RydWN0IHBudl9pb2RhX3BlICAgICpwZTsKIAlzdHJ1Y3QgcGNpX2RuICAgICAgICAg KnBkbjsKIAlzdHJ1Y3QgcGNpX3NyaW92ICAgICAgKmlvdjsKIAl1MTYgICAgICAgICAgICAgICAg ICAgIG51bV92ZnMsIGk7CkBAIC0xMzAwLDggKzEzMDEsMTEgQEAgdm9pZCBwbnZfcGNpX3NyaW92 X2Rpc2FibGUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiAJCS8qIFJlbGVhc2UgUEUgbnVtYmVycyAq LwogCQlpZiAocGRuLT5tNjRfc2luZ2xlX21vZGUpIHsKIAkJCWZvciAoaSA9IDA7IGkgPCBudW1f dmZzOyBpKyspIHsKLQkJCQlpZiAocGRuLT5wZV9udW1fbWFwW2ldICE9IElPREFfSU5WQUxJRF9Q RSkKLQkJCQkJcG52X2lvZGFfZnJlZV9wZShwaGIsIHBkbi0+cGVfbnVtX21hcFtpXSk7CisJCQkJ aWYgKHBkbi0+cGVfbnVtX21hcFtpXSA9PSBJT0RBX0lOVkFMSURfUEUpCisJCQkJCWNvbnRpbnVl OworCisJCQkJcGUgPSAmcGhiLT5pb2RhLnBlX2FycmF5W3Bkbi0+cGVfbnVtX21hcFtpXV07CisJ CQkJcG52X2lvZGFfZnJlZV9wZShwZSk7CiAJCQl9CiAJCX0gZWxzZQogCQkJYml0bWFwX2NsZWFy KHBoYi0+aW9kYS5wZV9hbGxvYywgKnBkbi0+cGVfbnVtX21hcCwgbnVtX3Zmcyk7CkBAIC0xMzU0 LDkgKzEzNTgsOCBAQCBzdGF0aWMgdm9pZCBwbnZfaW9kYV9zZXR1cF92Zl9QRShzdHJ1Y3QgcGNp X2RldiAqcGRldiwgdTE2IG51bV92ZnMpCiAKIAkJaWYgKHBudl9pb2RhX2NvbmZpZ3VyZV9wZShw aGIsIHBlKSkgewogCQkJLyogWFhYIFdoYXQgZG8gd2UgZG8gaGVyZSA/ICovCi0JCQlpZiAocGVf bnVtKQotCQkJCXBudl9pb2RhX2ZyZWVfcGUocGhiLCBwZV9udW0pOwogCQkJcGUtPnBkZXYgPSBO VUxMOworCQkJcG52X2lvZGFfZnJlZV9wZShwZSk7CiAJCQljb250aW51ZTsKIAkJfQogCkBAIC0x Mzc0LDYgKzEzNzcsNyBAQCBpbnQgcG52X3BjaV9zcmlvdl9lbmFibGUoc3RydWN0IHBjaV9kZXYg KnBkZXYsIHUxNiBudW1fdmZzKQogCXN0cnVjdCBwY2lfYnVzICAgICAgICAqYnVzOwogCXN0cnVj dCBwY2lfY29udHJvbGxlciAqaG9zZTsKIAlzdHJ1Y3QgcG52X3BoYiAgICAgICAgKnBoYjsKKwlz dHJ1Y3QgcG52X2lvZGFfcGUgICAgKnBlOwogCXN0cnVjdCBwY2lfZG4gICAgICAgICAqcGRuOwog CWludCAgICAgICAgICAgICAgICAgICAgcmV0OwogCXUxNiAgICAgICAgICAgICAgICAgICAgaTsK QEAgLTE0MTYsMTEgKzE0MjAsMTMgQEAgaW50IHBudl9wY2lfc3Jpb3ZfZW5hYmxlKHN0cnVjdCBw Y2lfZGV2ICpwZGV2LCB1MTYgbnVtX3ZmcykKIAkJLyogQ2FsY3VsYXRlIGF2YWlsYWJsZSBQRSBm b3IgcmVxdWlyZWQgVkZzICovCiAJCWlmIChwZG4tPm02NF9zaW5nbGVfbW9kZSkgewogCQkJZm9y IChpID0gMDsgaSA8IG51bV92ZnM7IGkrKykgewotCQkJCXBkbi0+cGVfbnVtX21hcFtpXSA9IHBu dl9pb2RhX2FsbG9jX3BlKHBoYik7Ci0JCQkJaWYgKHBkbi0+cGVfbnVtX21hcFtpXSA9PSBJT0RB X0lOVkFMSURfUEUpIHsKKwkJCQlwZSA9IHBudl9pb2RhX2FsbG9jX3BlKHBoYik7CisJCQkJaWYg KCFwZSkgewogCQkJCQlyZXQgPSAtRUJVU1k7CiAJCQkJCWdvdG8gbTY0X2ZhaWxlZDsKIAkJCQl9 CisKKwkJCQlwZG4tPnBlX251bV9tYXBbaV0gPSBwZS0+cGVfbnVtYmVyOwogCQkJfQogCQl9IGVs c2UgewogCQkJbXV0ZXhfbG9jaygmcGhiLT5pb2RhLnBlX2FsbG9jX211dGV4KTsKQEAgLTE0NjUs OCArMTQ3MSwxMSBAQCBpbnQgcG52X3BjaV9zcmlvdl9lbmFibGUoc3RydWN0IHBjaV9kZXYgKnBk ZXYsIHUxNiBudW1fdmZzKQogbTY0X2ZhaWxlZDoKIAlpZiAocGRuLT5tNjRfc2luZ2xlX21vZGUp IHsKIAkJZm9yIChpID0gMDsgaSA8IG51bV92ZnM7IGkrKykgewotCQkJaWYgKHBkbi0+cGVfbnVt X21hcFtpXSAhPSBJT0RBX0lOVkFMSURfUEUpCi0JCQkJcG52X2lvZGFfZnJlZV9wZShwaGIsIHBk bi0+cGVfbnVtX21hcFtpXSk7CisJCQlpZiAocGRuLT5wZV9udW1fbWFwW2ldID09IElPREFfSU5W QUxJRF9QRSkKKwkJCQljb250aW51ZTsKKworCQkJcGUgPSAmcGhiLT5pb2RhLnBlX2FycmF5W3Bk bi0+cGVfbnVtX21hcFtpXV07CisJCQlwbnZfaW9kYV9mcmVlX3BlKHBlKTsKIAkJfQogCX0gZWxz ZQogCQliaXRtYXBfY2xlYXIocGhiLT5pb2RhLnBlX2FsbG9jLCAqcGRuLT5wZV9udW1fbWFwLCBu dW1fdmZzKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9wY2ku aCBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9wY2kuaAppbmRleCA1ZGY5NDVmLi5l NTVhYjBlIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvcGNpLmgK KysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L3BjaS5oCkBAIC0xMDUsNyArMTA1 LDcgQEAgc3RydWN0IHBudl9waGIgewogCWludCAoKmluaXRfbTY0KShzdHJ1Y3QgcG52X3BoYiAq cGhiKTsKIAl2b2lkICgqcmVzZXJ2ZV9tNjRfcGUpKHN0cnVjdCBwY2lfYnVzICpidXMsCiAJCQkg ICAgICAgdW5zaWduZWQgbG9uZyAqcGVfYml0bWFwLCBib29sIGFsbCk7Ci0JaW50ICgqcGlja19t NjRfcGUpKHN0cnVjdCBwY2lfYnVzICpidXMsIGJvb2wgYWxsKTsKKwlzdHJ1Y3QgcG52X2lvZGFf cGUgKigqcGlja19tNjRfcGUpKHN0cnVjdCBwY2lfYnVzICpidXMsIGJvb2wgYWxsKTsKIAlpbnQg KCpnZXRfcGVfc3RhdGUpKHN0cnVjdCBwbnZfcGhiICpwaGIsIGludCBwZV9ubyk7CiAJdm9pZCAo KmZyZWV6ZV9wZSkoc3RydWN0IHBudl9waGIgKnBoYiwgaW50IHBlX25vKTsKIAlpbnQgKCp1bmZy ZWV6ZV9wZSkoc3RydWN0IHBudl9waGIgKnBoYiwgaW50IHBlX25vLCBpbnQgb3B0KTsKLS0gCjIu MS4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51 eHBwYy1kZXYgbWFpbGluZyBsaXN0CkxpbnV4cHBjLWRldkBsaXN0cy5vemxhYnMub3JnCmh0dHBz Oi8vbGlzdHMub3psYWJzLm9yZy9saXN0aW5mby9saW51eHBwYy1kZXY= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from e28smtp09.in.ibm.com ([122.248.162.9]:40787 "EHLO e28smtp09.in.ibm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S965471AbbKDPPj (ORCPT ); Wed, 4 Nov 2015 10:15:39 -0500 Received: from /spool/local by e28smtp09.in.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Wed, 4 Nov 2015 20:45:36 +0530 From: Gavin Shan To: linuxppc-dev@lists.ozlabs.org Cc: linux-pci@vger.kernel.org, devicetree@vger.kernel.org, benh@kernel.crashing.org, mpe@ellerman.id.au, aik@ozlabs.ru, bhelgaas@google.com, grant.likely@linaro.org, robherring2@gmail.com, panto@antoniou-consulting.com, frowand.list@gmail.com, Gavin Shan Subject: [PATCH v7 23/50] powerpc/powernv: Use PE instead of number during setup and release Date: Thu, 5 Nov 2015 00:12:23 +1100 Message-Id: <1446642770-4681-24-git-send-email-gwshan@linux.vnet.ibm.com> In-Reply-To: <1446642770-4681-1-git-send-email-gwshan@linux.vnet.ibm.com> References: <1446642770-4681-1-git-send-email-gwshan@linux.vnet.ibm.com> Sender: linux-pci-owner@vger.kernel.org List-ID: In current implementation, the PEs that are allocated or picked from the reserved list are identified by PE number. The PE instance has to be picked according to the PE number eventually. We have same issue when PE is released. For pnv_ioda_pick_m64_pe() and pnv_ioda_alloc_pe(), this returns PE instance so that pnv_ioda_setup_bus_PE() can use the allocated or reserved PE instance directly. Also, pnv_ioda_setup_bus_PE() returns the reserved/allocated PE instance to be used in subsequent patches. On the other hand, pnv_ioda_free_pe() uses PE instance (not number) as its argument. No logical changes introduced. Signed-off-by: Gavin Shan --- arch/powerpc/platforms/powernv/pci-ioda.c | 81 +++++++++++++++++-------------- arch/powerpc/platforms/powernv/pci.h | 2 +- 2 files changed, 46 insertions(+), 37 deletions(-) diff --git a/arch/powerpc/platforms/powernv/pci-ioda.c b/arch/powerpc/platforms/powernv/pci-ioda.c index 488e0f8..ae82df1 100644 --- a/arch/powerpc/platforms/powernv/pci-ioda.c +++ b/arch/powerpc/platforms/powernv/pci-ioda.c @@ -152,7 +152,7 @@ static void pnv_ioda_reserve_pe(struct pnv_phb *phb, int pe_no) pnv_ioda_init_pe(phb, pe_no); } -static int pnv_ioda_alloc_pe(struct pnv_phb *phb) +static struct pnv_ioda_pe *pnv_ioda_alloc_pe(struct pnv_phb *phb) { unsigned long pe; @@ -160,19 +160,20 @@ static int pnv_ioda_alloc_pe(struct pnv_phb *phb) pe = find_next_zero_bit(phb->ioda.pe_alloc, phb->ioda.total_pe_num, 0); if (pe >= phb->ioda.total_pe_num) - return IODA_INVALID_PE; + return NULL; } while(test_and_set_bit(pe, phb->ioda.pe_alloc)); - pnv_ioda_init_pe(phb, pe); - return pe; + return pnv_ioda_init_pe(phb, pe); } -static void pnv_ioda_free_pe(struct pnv_phb *phb, int pe) +static void pnv_ioda_free_pe(struct pnv_ioda_pe *pe) { - WARN_ON(phb->ioda.pe_array[pe].pdev); + struct pnv_phb *phb = pe->phb; + + WARN_ON(pe->pdev); - memset(&phb->ioda.pe_array[pe], 0, sizeof(struct pnv_ioda_pe)); - clear_bit(pe, phb->ioda.pe_alloc); + memset(pe, 0, sizeof(struct pnv_ioda_pe)); + clear_bit(pe->pe_number, phb->ioda.pe_alloc); } /* The default M64 BAR is shared by all PEs */ @@ -332,7 +333,7 @@ static void pnv_ioda_reserve_m64_pe(struct pci_bus *bus, } } -static int pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) +static struct pnv_ioda_pe *pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) { struct pci_controller *hose = pci_bus_to_host(bus); struct pnv_phb *phb = hose->private_data; @@ -342,7 +343,7 @@ static int pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) /* Root bus shouldn't use M64 */ if (pci_is_root_bus(bus)) - return IODA_INVALID_PE; + return NULL; /* Allocate bitmap */ size = _ALIGN_UP(phb->ioda.total_pe_num / 8, sizeof(unsigned long)); @@ -350,7 +351,7 @@ static int pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) if (!pe_alloc) { pr_warn("%s: Out of memory !\n", __func__); - return IODA_INVALID_PE; + return NULL; } /* Figure out reserved PE numbers by the PE */ @@ -363,7 +364,7 @@ static int pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) */ if (bitmap_empty(pe_alloc, phb->ioda.total_pe_num)) { kfree(pe_alloc); - return IODA_INVALID_PE; + return NULL; } /* @@ -409,7 +410,7 @@ static int pnv_ioda_pick_m64_pe(struct pci_bus *bus, bool all) } kfree(pe_alloc); - return master_pe->pe_number; + return master_pe; } static void __init pnv_ioda_parse_m64_window(struct pnv_phb *phb) @@ -988,28 +989,26 @@ static void pnv_ioda_setup_same_PE(struct pci_bus *bus, struct pnv_ioda_pe *pe) * subordinate PCI devices and buses. The second type of PE is normally * orgiriated by PCIe-to-PCI bridge or PLX switch downstream ports. */ -static void pnv_ioda_setup_bus_PE(struct pci_bus *bus, bool all) +static struct pnv_ioda_pe *pnv_ioda_setup_bus_PE(struct pci_bus *bus, bool all) { struct pci_controller *hose = pci_bus_to_host(bus); struct pnv_phb *phb = hose->private_data; - struct pnv_ioda_pe *pe; - int pe_num = IODA_INVALID_PE; + struct pnv_ioda_pe *pe = NULL; /* Check if PE is determined by M64 */ if (phb->pick_m64_pe) - pe_num = phb->pick_m64_pe(bus, all); + pe = phb->pick_m64_pe(bus, all); /* The PE number isn't pinned by M64 */ - if (pe_num == IODA_INVALID_PE) - pe_num = pnv_ioda_alloc_pe(phb); + if (!pe) + pe = pnv_ioda_alloc_pe(phb); - if (pe_num == IODA_INVALID_PE) { + if (!pe) { pr_warning("%s: Not enough PE# available for PCI bus %04x:%02x\n", __func__, pci_domain_nr(bus), bus->number); - return; + return NULL; } - pe = &phb->ioda.pe_array[pe_num]; pe->flags |= (all ? PNV_IODA_PE_BUS_ALL : PNV_IODA_PE_BUS); pe->pbus = bus; pe->pdev = NULL; @@ -1018,17 +1017,16 @@ static void pnv_ioda_setup_bus_PE(struct pci_bus *bus, bool all) if (all) pe_info(pe, "Secondary bus %d..%d associated with PE#%d\n", - bus->busn_res.start, bus->busn_res.end, pe_num); + bus->busn_res.start, bus->busn_res.end, pe->pe_number); else pe_info(pe, "Secondary bus %d associated with PE#%d\n", - bus->busn_res.start, pe_num); + bus->busn_res.start, pe->pe_number); if (pnv_ioda_configure_pe(phb, pe)) { /* XXX What do we do here ? */ - if (pe_num) - pnv_ioda_free_pe(phb, pe_num); + pnv_ioda_free_pe(pe); pe->pbus = NULL; - return; + return NULL; } /* Associate it with all child devices */ @@ -1036,6 +1034,8 @@ static void pnv_ioda_setup_bus_PE(struct pci_bus *bus, bool all) /* Put PE to the list */ list_add_tail(&pe->list, &phb->ioda.pe_list); + + return pe; } static void pnv_ioda_setup_PEs(struct pci_bus *bus) @@ -1267,7 +1267,7 @@ static void pnv_ioda_release_vf_PE(struct pci_dev *pdev) pnv_ioda_deconfigure_pe(phb, pe); - pnv_ioda_free_pe(phb, pe->pe_number); + pnv_ioda_free_pe(pe); } } @@ -1276,6 +1276,7 @@ void pnv_pci_sriov_disable(struct pci_dev *pdev) struct pci_bus *bus; struct pci_controller *hose; struct pnv_phb *phb; + struct pnv_ioda_pe *pe; struct pci_dn *pdn; struct pci_sriov *iov; u16 num_vfs, i; @@ -1300,8 +1301,11 @@ void pnv_pci_sriov_disable(struct pci_dev *pdev) /* Release PE numbers */ if (pdn->m64_single_mode) { for (i = 0; i < num_vfs; i++) { - if (pdn->pe_num_map[i] != IODA_INVALID_PE) - pnv_ioda_free_pe(phb, pdn->pe_num_map[i]); + if (pdn->pe_num_map[i] == IODA_INVALID_PE) + continue; + + pe = &phb->ioda.pe_array[pdn->pe_num_map[i]]; + pnv_ioda_free_pe(pe); } } else bitmap_clear(phb->ioda.pe_alloc, *pdn->pe_num_map, num_vfs); @@ -1354,9 +1358,8 @@ static void pnv_ioda_setup_vf_PE(struct pci_dev *pdev, u16 num_vfs) if (pnv_ioda_configure_pe(phb, pe)) { /* XXX What do we do here ? */ - if (pe_num) - pnv_ioda_free_pe(phb, pe_num); pe->pdev = NULL; + pnv_ioda_free_pe(pe); continue; } @@ -1374,6 +1377,7 @@ int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs) struct pci_bus *bus; struct pci_controller *hose; struct pnv_phb *phb; + struct pnv_ioda_pe *pe; struct pci_dn *pdn; int ret; u16 i; @@ -1416,11 +1420,13 @@ int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs) /* Calculate available PE for required VFs */ if (pdn->m64_single_mode) { for (i = 0; i < num_vfs; i++) { - pdn->pe_num_map[i] = pnv_ioda_alloc_pe(phb); - if (pdn->pe_num_map[i] == IODA_INVALID_PE) { + pe = pnv_ioda_alloc_pe(phb); + if (!pe) { ret = -EBUSY; goto m64_failed; } + + pdn->pe_num_map[i] = pe->pe_number; } } else { mutex_lock(&phb->ioda.pe_alloc_mutex); @@ -1465,8 +1471,11 @@ int pnv_pci_sriov_enable(struct pci_dev *pdev, u16 num_vfs) m64_failed: if (pdn->m64_single_mode) { for (i = 0; i < num_vfs; i++) { - if (pdn->pe_num_map[i] != IODA_INVALID_PE) - pnv_ioda_free_pe(phb, pdn->pe_num_map[i]); + if (pdn->pe_num_map[i] == IODA_INVALID_PE) + continue; + + pe = &phb->ioda.pe_array[pdn->pe_num_map[i]]; + pnv_ioda_free_pe(pe); } } else bitmap_clear(phb->ioda.pe_alloc, *pdn->pe_num_map, num_vfs); diff --git a/arch/powerpc/platforms/powernv/pci.h b/arch/powerpc/platforms/powernv/pci.h index 5df945f..e55ab0e 100644 --- a/arch/powerpc/platforms/powernv/pci.h +++ b/arch/powerpc/platforms/powernv/pci.h @@ -105,7 +105,7 @@ struct pnv_phb { int (*init_m64)(struct pnv_phb *phb); void (*reserve_m64_pe)(struct pci_bus *bus, unsigned long *pe_bitmap, bool all); - int (*pick_m64_pe)(struct pci_bus *bus, bool all); + struct pnv_ioda_pe *(*pick_m64_pe)(struct pci_bus *bus, bool all); int (*get_pe_state)(struct pnv_phb *phb, int pe_no); void (*freeze_pe)(struct pnv_phb *phb, int pe_no); int (*unfreeze_pe)(struct pnv_phb *phb, int pe_no, int opt); -- 2.1.0