From mboxrd@z Thu Jan 1 00:00:00 1970 From: Wolfram Sang Subject: [PATCH] mpc52xx-psc-spi: refactor probe and remove to make use of of_register_spi_devices() Date: Fri, 30 Oct 2009 20:44:12 +0100 Message-ID: <1256931852-13255-1-git-send-email-w.sang@pengutronix.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: =?utf-8?q?K=C3=A1ri=20Dav=C3=AD=C3=B0sson?= , linuxppc-dev@ozlabs.org To: spi-devel-general@lists.sourceforge.net Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linuxppc-dev-bounces+glppd-linuxppc64-dev=m.gmane.org@lists.ozlabs.org Errors-To: linuxppc-dev-bounces+glppd-linuxppc64-dev=m.gmane.org@lists.ozlabs.org List-Id: linux-spi.vger.kernel.org VGhpcyBkcml2ZXIgaGFzIGEgZ2VuZXJpYyBwYXJ0IGZvciB0aGUgcHJvYmUvcmVtb3ZlIHJvdXRp bmVzIHdoaWNoIHByb2JhYmx5CnVzZWQgdG8gYmUgY2FsbGVkIGZyb20gYSBwbGF0Zm9ybSBkcml2 ZXIgYW5kIGFuIG9mX3BsYXRmb3JtIGRyaXZlci4gTWVhbndoaWxlLAp0aGUgZHJpdmVyIGlzIG9m X3BsYXRmb3JtIG9ubHksIHNvIHRoZXJlIGlzIG5vIG5lZWQgZm9yIHRoZSBnZW5lcmljIHBhcnQK YW55bW9yZS4gVW5pZnlpbmcgcHJvYmUvcmVtb3ZlIGZpbmFsbHkgZW5hYmxlcyB1cyB0byBjYWxs Cm9mX3JlZ2lzdGVyX3NwaV9kZXZpY2VzKCksIHNvIHNwaS1kZXZpY2Ugbm9kZXMgZnJvbSB0aGUg ZGV2aWNlIHRyZWUgd2lsbCBiZQpwYXJzZWQuIFRoaXMgd2FzIGFsc28gbWVudGlvbmVkIGJ5Ogpo dHRwOi8vbGlzdHMub3psYWJzLm9yZy9waXBlcm1haWwvbGludXhwcGMtZGV2LzIwMDktSnVuZS8w NzMyNzMuaHRtbAoKT24gdGhlIHdheSwgc29tZSBwYXR0ZXJucyBoYXZlIGJlZW4gY2hhbmdlZCB0 byBjdXJyZW50IGJlc3QgcHJhY3RpY2VzIChsaWtlCnVzaW5nICchcHRyJyBhbmQgJ3N0cnVjdCBy ZXNvdXJjZScpLiBBbHNvLCBhbiBvbGRlciwgeWV0IHVuY29tbWVudGVkLCBwYXRjaApmcm9tIG1l IGhhcyBiZWVuIGluY29ycG9yYXRlZCB0byBpbXByb3ZlIHRoZSBjaGVja3MgaWYgdGhlIHNlbGVj dGVkIFBTQyBpcwp2YWxpZDoKCmh0dHA6Ly9wYXRjaHdvcmsub3psYWJzLm9yZy9wYXRjaC8zNjc4 MC8KClNpZ25lZC1vZmYtYnk6IFdvbGZyYW0gU2FuZyA8dy5zYW5nQHBlbmd1dHJvbml4LmRlPgpD YzogS8OhcmkgRGF2w63DsHNzb24gPGthcmkuZGF2aWRzc29uQG1hcmVsLmNvbT4KQ2M6IEdyYW50 IExpa2VseSA8Z3JhbnQubGlrZWx5QHNlY3JldGxhYi5jYT4KLS0tCiBkcml2ZXJzL3NwaS9tcGM1 Mnh4X3BzY19zcGkuYyB8ICAxMTAgKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQogMSBmaWxlcyBjaGFuZ2VkLCA1MiBpbnNlcnRpb25zKCspLCA1OCBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9tcGM1Mnh4X3BzY19zcGkuYyBiL2RyaXZlcnMvc3Bp L21wYzUyeHhfcHNjX3NwaS5jCmluZGV4IDFiNzRkNWMuLjNmYThjNzggMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvc3BpL21wYzUyeHhfcHNjX3NwaS5jCisrKyBiL2RyaXZlcnMvc3BpL21wYzUyeHhfcHNj X3NwaS5jCkBAIC0xNyw2ICsxNyw3IEBACiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KICNpbmNs dWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9vZl9wbGF0Zm9ybS5oPgor I2luY2x1ZGUgPGxpbnV4L29mX3NwaS5oPgogI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgog I2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgpAQCAt MjcsNiArMjgsNyBAQAogI2luY2x1ZGUgPGFzbS9tcGM1Mnh4Lmg+CiAjaW5jbHVkZSA8YXNtL21w YzUyeHhfcHNjLmg+CiAKKyNkZWZpbmUgRFJJVkVSX05BTUUgIm1wYzUyeHgtcHNjLXNwaSIKICNk ZWZpbmUgTUNMSyAyMDAwMDAwMCAvKiBQU0MgcG9ydCBNQ2xrIGluIGh6ICovCiAKIHN0cnVjdCBt cGM1Mnh4X3BzY19zcGkgewpAQCAtMzU4LDMyICszNjAsNTQgQEAgc3RhdGljIGlycXJldHVybl90 IG1wYzUyeHhfcHNjX3NwaV9pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKQogCXJldHVybiBJUlFf Tk9ORTsKIH0KIAotLyogYnVzX251bSBpcyB1c2VkIG9ubHkgZm9yIHRoZSBjYXNlIGRldi0+cGxh dGZvcm1fZGF0YSA9PSBOVUxMICovCi1zdGF0aWMgaW50IF9faW5pdCBtcGM1Mnh4X3BzY19zcGlf ZG9fcHJvYmUoc3RydWN0IGRldmljZSAqZGV2LCB1MzIgcmVnYWRkciwKLQkJCQl1MzIgc2l6ZSwg dW5zaWduZWQgaW50IGlycSwgczE2IGJ1c19udW0pCitzdGF0aWMgaW50IF9faW5pdCBtcGM1Mnh4 X3BzY19zcGlfb2ZfcHJvYmUoc3RydWN0IG9mX2RldmljZSAqb3AsCisJY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCAqbWF0Y2gpCiB7Ci0Jc3RydWN0IGZzbF9zcGlfcGxhdGZvcm1fZGF0YSAqcGRh dGEgPSBkZXYtPnBsYXRmb3JtX2RhdGE7CisJc3RydWN0IGZzbF9zcGlfcGxhdGZvcm1fZGF0YSAq cGRhdGEgPSBvcC0+ZGV2LnBsYXRmb3JtX2RhdGE7CiAJc3RydWN0IG1wYzUyeHhfcHNjX3NwaSAq bXBzOwogCXN0cnVjdCBzcGlfbWFzdGVyICptYXN0ZXI7CisJc3RydWN0IHJlc291cmNlIG1lbTsK KwlzMTYgaWQgPSAtMTsKIAlpbnQgcmV0OwogCi0JbWFzdGVyID0gc3BpX2FsbG9jX21hc3Rlcihk ZXYsIHNpemVvZiAqbXBzKTsKLQlpZiAobWFzdGVyID09IE5VTEwpCisJLyogZ2V0IFBTQyBpZCAo b25seSAxLDIsMyw2IGNhbiBkbyBTUEkpICovCisJaWYgKCFwZGF0YSkgeworCQljb25zdCB1MzIg KnBzY19udW1wOworCisJCXBzY19udW1wID0gb2ZfZ2V0X3Byb3BlcnR5KG9wLT5ub2RlLCAiY2Vs bC1pbmRleCIsIE5VTEwpOworCQlpZiAoIXBzY19udW1wIHx8ICgqcHNjX251bXAgPiAyICYmICpw c2NfbnVtcCAhPSA1KSkgeworCQkJZGV2X2Vycigmb3AtPmRldiwgIlBTQyBjYW4ndCBkbyBTUElc biIpOworCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KKwkJaWQgPSAqcHNjX251bXAgKyAxOworCX0K KworCXJldCA9IG9mX2FkZHJlc3NfdG9fcmVzb3VyY2Uob3AtPm5vZGUsIDAsICZtZW0pOworCWlm IChyZXQpCisJCXJldHVybiByZXQ7CisKKwltYXN0ZXIgPSBzcGlfYWxsb2NfbWFzdGVyKCZvcC0+ ZGV2LCBzaXplb2YgKm1wcyk7CisJaWYgKCFtYXN0ZXIpCiAJCXJldHVybiAtRU5PTUVNOwogCi0J ZGV2X3NldF9kcnZkYXRhKGRldiwgbWFzdGVyKTsKKwlpZiAoIXJlcXVlc3RfbWVtX3JlZ2lvbiht ZW0uc3RhcnQsIHJlc291cmNlX3NpemUoJm1lbSksIERSSVZFUl9OQU1FKSkgeworCQlyZXQgPSAt RU5PTUVNOworCQlnb3RvIGZyZWVfbWFzdGVyOworCX0KKworCWRldl9zZXRfZHJ2ZGF0YSgmb3At PmRldiwgbWFzdGVyKTsKIAltcHMgPSBzcGlfbWFzdGVyX2dldF9kZXZkYXRhKG1hc3Rlcik7CiAK IAkvKiB0aGUgc3BpLT5tb2RlIGJpdHMgdW5kZXJzdG9vZCBieSB0aGlzIGRyaXZlcjogKi8KIAlt YXN0ZXItPm1vZGVfYml0cyA9IFNQSV9DUE9MIHwgU1BJX0NQSEEgfCBTUElfQ1NfSElHSCB8IFNQ SV9MU0JfRklSU1Q7CiAKLQltcHMtPmlycSA9IGlycTsKLQlpZiAocGRhdGEgPT0gTlVMTCkgewot CQlkZXZfd2FybihkZXYsICJwcm9iZSBjYWxsZWQgd2l0aG91dCBwbGF0Zm9ybSBkYXRhLCBubyAi CisJbXBzLT5pcnEgPSBpcnFfb2ZfcGFyc2VfYW5kX21hcChvcC0+bm9kZSwgMCk7CisJaWYgKCFw ZGF0YSkgeworCQlkZXZfaW5mbygmb3AtPmRldiwgInByb2JlIGNhbGxlZCB3aXRob3V0IHBsYXRm b3JtIGRhdGEsIG5vICIKIAkJCQkiY3NfY29udHJvbCBmdW5jdGlvbiB3aWxsIGJlIGNhbGxlZFxu Iik7CiAJCW1wcy0+Y3NfY29udHJvbCA9IE5VTEw7CiAJCW1wcy0+c3lzY2xrID0gMDsKLQkJbWFz dGVyLT5idXNfbnVtID0gYnVzX251bTsKKwkJbWFzdGVyLT5idXNfbnVtID0gaWQ7CiAJCW1hc3Rl ci0+bnVtX2NoaXBzZWxlY3QgPSAyNTU7CiAJfSBlbHNlIHsKIAkJbXBzLT5jc19jb250cm9sID0g cGRhdGEtPmNzX2NvbnRyb2w7CkBAIC0zOTUsMTkgKzQxOSwxOCBAQCBzdGF0aWMgaW50IF9faW5p dCBtcGM1Mnh4X3BzY19zcGlfZG9fcHJvYmUoc3RydWN0IGRldmljZSAqZGV2LCB1MzIgcmVnYWRk ciwKIAltYXN0ZXItPnRyYW5zZmVyID0gbXBjNTJ4eF9wc2Nfc3BpX3RyYW5zZmVyOwogCW1hc3Rl ci0+Y2xlYW51cCA9IG1wYzUyeHhfcHNjX3NwaV9jbGVhbnVwOwogCi0JbXBzLT5wc2MgPSBpb3Jl bWFwKHJlZ2FkZHIsIHNpemUpOworCW1wcy0+cHNjID0gaW9yZW1hcChtZW0uc3RhcnQsIHJlc291 cmNlX3NpemUoJm1lbSkpOwogCWlmICghbXBzLT5wc2MpIHsKLQkJZGV2X2VycihkZXYsICJjb3Vs ZCBub3QgaW9yZW1hcCBJL08gcG9ydCByYW5nZVxuIik7CisJCWRldl9lcnIoJm9wLT5kZXYsICJj b3VsZCBub3QgaW9yZW1hcCBJL08gcG9ydCByYW5nZVxuIik7CiAJCXJldCA9IC1FRkFVTFQ7Ci0J CWdvdG8gZnJlZV9tYXN0ZXI7CisJCWdvdG8gZnJlZV91bm1hcDsKIAl9CiAJLyogT24gdGhlIDUy MDAsIGZpZm8gcmVncyBhcmUgaW1tZWRpYXRlbHkgYWphY2VudCB0byB0aGUgcHNjIHJlZ3MgKi8K IAltcHMtPmZpZm8gPSAoKHZvaWQgX19pb21lbSAqKW1wcy0+cHNjKSArIHNpemVvZihzdHJ1Y3Qg bXBjNTJ4eF9wc2MpOwogCi0JcmV0ID0gcmVxdWVzdF9pcnEobXBzLT5pcnEsIG1wYzUyeHhfcHNj X3NwaV9pc3IsIDAsICJtcGM1Mnh4LXBzYy1zcGkiLAotCQkJCW1wcyk7CisJcmV0ID0gcmVxdWVz dF9pcnEobXBzLT5pcnEsIG1wYzUyeHhfcHNjX3NwaV9pc3IsIDAsIERSSVZFUl9OQU1FLCBtcHMp OwogCWlmIChyZXQpCi0JCWdvdG8gZnJlZV9tYXN0ZXI7CisJCWdvdG8gZnJlZV91bm1hcDsKIAog CXJldCA9IG1wYzUyeHhfcHNjX3NwaV9wb3J0X2NvbmZpZyhtYXN0ZXItPmJ1c19udW0sIG1wcyk7 CiAJaWYgKHJldCA8IDApCkBAIC00MjksMjQgKzQ1MiwyOSBAQCBzdGF0aWMgaW50IF9faW5pdCBt cGM1Mnh4X3BzY19zcGlfZG9fcHJvYmUoc3RydWN0IGRldmljZSAqZGV2LCB1MzIgcmVnYWRkciwK IAlpZiAocmV0IDwgMCkKIAkJZ290byB1bnJlZ19tYXN0ZXI7CiAKKwlvZl9yZWdpc3Rlcl9zcGlf ZGV2aWNlcyhtYXN0ZXIsIG9wLT5ub2RlKTsKKwogCXJldHVybiByZXQ7CiAKIHVucmVnX21hc3Rl cjoKIAlkZXN0cm95X3dvcmtxdWV1ZShtcHMtPndvcmtxdWV1ZSk7CiBmcmVlX2lycToKIAlmcmVl X2lycShtcHMtPmlycSwgbXBzKTsKLWZyZWVfbWFzdGVyOgorZnJlZV91bm1hcDoKIAlpZiAobXBz LT5wc2MpCiAJCWlvdW5tYXAobXBzLT5wc2MpOworCXJlbGVhc2VfbWVtX3JlZ2lvbihtZW0uc3Rh cnQsIHJlc291cmNlX3NpemUoJm1lbSkpOworZnJlZV9tYXN0ZXI6CiAJc3BpX21hc3Rlcl9wdXQo bWFzdGVyKTsKIAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBpbnQgX19leGl0IG1wYzUyeHhf cHNjX3NwaV9kb19yZW1vdmUoc3RydWN0IGRldmljZSAqZGV2KQorc3RhdGljIGludCBfX2V4aXQg bXBjNTJ4eF9wc2Nfc3BpX29mX3JlbW92ZShzdHJ1Y3Qgb2ZfZGV2aWNlICpvcCkKIHsKLQlzdHJ1 Y3Qgc3BpX21hc3RlciAqbWFzdGVyID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisJc3RydWN0IHNw aV9tYXN0ZXIgKm1hc3RlciA9IGRldl9nZXRfZHJ2ZGF0YSgmb3AtPmRldik7CiAJc3RydWN0IG1w YzUyeHhfcHNjX3NwaSAqbXBzID0gc3BpX21hc3Rlcl9nZXRfZGV2ZGF0YShtYXN0ZXIpOworCXN0 cnVjdCByZXNvdXJjZSBtZW07CiAKIAlmbHVzaF93b3JrcXVldWUobXBzLT53b3JrcXVldWUpOwog CWRlc3Ryb3lfd29ya3F1ZXVlKG1wcy0+d29ya3F1ZXVlKTsKQEAgLTQ1NCw0NiArNDgyLDEyIEBA IHN0YXRpYyBpbnQgX19leGl0IG1wYzUyeHhfcHNjX3NwaV9kb19yZW1vdmUoc3RydWN0IGRldmlj ZSAqZGV2KQogCWZyZWVfaXJxKG1wcy0+aXJxLCBtcHMpOwogCWlmIChtcHMtPnBzYykKIAkJaW91 bm1hcChtcHMtPnBzYyk7CisJaWYgKG9mX2FkZHJlc3NfdG9fcmVzb3VyY2Uob3AtPm5vZGUsIDAs ICZtZW0pID09IDApCisJCXJlbGVhc2VfbWVtX3JlZ2lvbihtZW0uc3RhcnQsIHJlc291cmNlX3Np emUoJm1lbSkpOwogCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgX19pbml0IG1wYzUyeHhf cHNjX3NwaV9vZl9wcm9iZShzdHJ1Y3Qgb2ZfZGV2aWNlICpvcCwKLQljb25zdCBzdHJ1Y3Qgb2Zf ZGV2aWNlX2lkICptYXRjaCkKLXsKLQljb25zdCB1MzIgKnJlZ2FkZHJfcDsKLQl1NjQgcmVnYWRk cjY0LCBzaXplNjQ7Ci0JczE2IGlkID0gLTE7Ci0KLQlyZWdhZGRyX3AgPSBvZl9nZXRfYWRkcmVz cyhvcC0+bm9kZSwgMCwgJnNpemU2NCwgTlVMTCk7Ci0JaWYgKCFyZWdhZGRyX3ApIHsKLQkJcHJp bnRrKEtFUk5fRVJSICJJbnZhbGlkIFBTQyBhZGRyZXNzXG4iKTsKLQkJcmV0dXJuIC1FSU5WQUw7 Ci0JfQotCXJlZ2FkZHI2NCA9IG9mX3RyYW5zbGF0ZV9hZGRyZXNzKG9wLT5ub2RlLCByZWdhZGRy X3ApOwotCi0JLyogZ2V0IFBTQyBpZCAoMS4uNiwgdXNlZCBieSBwb3J0X2NvbmZpZykgKi8KLQlp ZiAob3AtPmRldi5wbGF0Zm9ybV9kYXRhID09IE5VTEwpIHsKLQkJY29uc3QgdTMyICpwc2NfbnVt cDsKLQotCQlwc2NfbnVtcCA9IG9mX2dldF9wcm9wZXJ0eShvcC0+bm9kZSwgImNlbGwtaW5kZXgi LCBOVUxMKTsKLQkJaWYgKCFwc2NfbnVtcCB8fCAqcHNjX251bXAgPiA1KSB7Ci0JCQlwcmludGso S0VSTl9FUlIgIm1wYzUyeHhfcHNjX3NwaTogRGV2aWNlIG5vZGUgJXMgaGFzIGludmFsaWQgIgot CQkJCQkiY2VsbC1pbmRleCBwcm9wZXJ0eVxuIiwgb3AtPm5vZGUtPmZ1bGxfbmFtZSk7Ci0JCQly ZXR1cm4gLUVJTlZBTDsKLQkJfQotCQlpZCA9ICpwc2NfbnVtcCArIDE7Ci0JfQotCi0JcmV0dXJu IG1wYzUyeHhfcHNjX3NwaV9kb19wcm9iZSgmb3AtPmRldiwgKHUzMilyZWdhZGRyNjQsICh1MzIp c2l6ZTY0LAotCQkJCQlpcnFfb2ZfcGFyc2VfYW5kX21hcChvcC0+bm9kZSwgMCksIGlkKTsKLX0K LQotc3RhdGljIGludCBfX2V4aXQgbXBjNTJ4eF9wc2Nfc3BpX29mX3JlbW92ZShzdHJ1Y3Qgb2Zf ZGV2aWNlICpvcCkKLXsKLQlyZXR1cm4gbXBjNTJ4eF9wc2Nfc3BpX2RvX3JlbW92ZSgmb3AtPmRl dik7Ci19Ci0KIHN0YXRpYyBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIG1wYzUyeHhfcHNjX3NwaV9vZl9t YXRjaFtdID0gewogCXsgLmNvbXBhdGlibGUgPSAiZnNsLG1wYzUyMDAtcHNjLXNwaSIsIH0sCiAJ eyAuY29tcGF0aWJsZSA9ICJtcGM1MjAwLXBzYy1zcGkiLCB9LCAvKiBvbGQgKi8KQEAgLTUwNCwx MiArNDk4LDEyIEBAIE1PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIG1wYzUyeHhfcHNjX3NwaV9vZl9t YXRjaCk7CiAKIHN0YXRpYyBzdHJ1Y3Qgb2ZfcGxhdGZvcm1fZHJpdmVyIG1wYzUyeHhfcHNjX3Nw aV9vZl9kcml2ZXIgPSB7CiAJLm93bmVyID0gVEhJU19NT0RVTEUsCi0JLm5hbWUgPSAibXBjNTJ4 eC1wc2Mtc3BpIiwKKwkubmFtZSA9IERSSVZFUl9OQU1FLAogCS5tYXRjaF90YWJsZSA9IG1wYzUy eHhfcHNjX3NwaV9vZl9tYXRjaCwKIAkucHJvYmUgPSBtcGM1Mnh4X3BzY19zcGlfb2ZfcHJvYmUs CiAJLnJlbW92ZSA9IF9fZXhpdF9wKG1wYzUyeHhfcHNjX3NwaV9vZl9yZW1vdmUpLAogCS5kcml2 ZXIgPSB7Ci0JCS5uYW1lID0gIm1wYzUyeHgtcHNjLXNwaSIsCisJCS5uYW1lID0gRFJJVkVSX05B TUUsCiAJCS5vd25lciA9IFRISVNfTU9EVUxFLAogCX0sCiB9OwotLSAKMS42LjMuMwoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXhwcGMtZGV2IG1h aWxpbmcgbGlzdApMaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwpodHRwczovL2xpc3RzLm96 bGFicy5vcmcvbGlzdGluZm8vbGludXhwcGMtZGV2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from metis.ext.pengutronix.de (metis.ext.pengutronix.de [92.198.50.35]) by ozlabs.org (Postfix) with ESMTP id 4634DB7BF2 for ; Sat, 31 Oct 2009 06:44:43 +1100 (EST) From: Wolfram Sang To: spi-devel-general@lists.sourceforge.net Date: Fri, 30 Oct 2009 20:44:12 +0100 Message-Id: <1256931852-13255-1-git-send-email-w.sang@pengutronix.de> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Subject: [PATCH] mpc52xx-psc-spi: refactor probe and remove to make use of of_register_spi_devices() Cc: =?utf-8?q?K=C3=A1ri=20Dav=C3=AD=C3=B0sson?= , linuxppc-dev@ozlabs.org List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , This driver has a generic part for the probe/remove routines which probably used to be called from a platform driver and an of_platform driver. Meanwhile, the driver is of_platform only, so there is no need for the generic part anymore. Unifying probe/remove finally enables us to call of_register_spi_devices(), so spi-device nodes from the device tree will be parsed. This was also mentioned by: http://lists.ozlabs.org/pipermail/linuxppc-dev/2009-June/073273.html On the way, some patterns have been changed to current best practices (like using '!ptr' and 'struct resource'). Also, an older, yet uncommented, patch from me has been incorporated to improve the checks if the selected PSC is valid: http://patchwork.ozlabs.org/patch/36780/ Signed-off-by: Wolfram Sang Cc: Kári Davíðsson Cc: Grant Likely --- drivers/spi/mpc52xx_psc_spi.c | 110 +++++++++++++++++++--------------------- 1 files changed, 52 insertions(+), 58 deletions(-) diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c index 1b74d5c..3fa8c78 100644 --- a/drivers/spi/mpc52xx_psc_spi.c +++ b/drivers/spi/mpc52xx_psc_spi.c @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -27,6 +28,7 @@ #include #include +#define DRIVER_NAME "mpc52xx-psc-spi" #define MCLK 20000000 /* PSC port MClk in hz */ struct mpc52xx_psc_spi { @@ -358,32 +360,54 @@ static irqreturn_t mpc52xx_psc_spi_isr(int irq, void *dev_id) return IRQ_NONE; } -/* bus_num is used only for the case dev->platform_data == NULL */ -static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr, - u32 size, unsigned int irq, s16 bus_num) +static int __init mpc52xx_psc_spi_of_probe(struct of_device *op, + const struct of_device_id *match) { - struct fsl_spi_platform_data *pdata = dev->platform_data; + struct fsl_spi_platform_data *pdata = op->dev.platform_data; struct mpc52xx_psc_spi *mps; struct spi_master *master; + struct resource mem; + s16 id = -1; int ret; - master = spi_alloc_master(dev, sizeof *mps); - if (master == NULL) + /* get PSC id (only 1,2,3,6 can do SPI) */ + if (!pdata) { + const u32 *psc_nump; + + psc_nump = of_get_property(op->node, "cell-index", NULL); + if (!psc_nump || (*psc_nump > 2 && *psc_nump != 5)) { + dev_err(&op->dev, "PSC can't do SPI\n"); + return -EINVAL; + } + id = *psc_nump + 1; + } + + ret = of_address_to_resource(op->node, 0, &mem); + if (ret) + return ret; + + master = spi_alloc_master(&op->dev, sizeof *mps); + if (!master) return -ENOMEM; - dev_set_drvdata(dev, master); + if (!request_mem_region(mem.start, resource_size(&mem), DRIVER_NAME)) { + ret = -ENOMEM; + goto free_master; + } + + dev_set_drvdata(&op->dev, master); mps = spi_master_get_devdata(master); /* the spi->mode bits understood by this driver: */ master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST; - mps->irq = irq; - if (pdata == NULL) { - dev_warn(dev, "probe called without platform data, no " + mps->irq = irq_of_parse_and_map(op->node, 0); + if (!pdata) { + dev_info(&op->dev, "probe called without platform data, no " "cs_control function will be called\n"); mps->cs_control = NULL; mps->sysclk = 0; - master->bus_num = bus_num; + master->bus_num = id; master->num_chipselect = 255; } else { mps->cs_control = pdata->cs_control; @@ -395,19 +419,18 @@ static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr, master->transfer = mpc52xx_psc_spi_transfer; master->cleanup = mpc52xx_psc_spi_cleanup; - mps->psc = ioremap(regaddr, size); + mps->psc = ioremap(mem.start, resource_size(&mem)); if (!mps->psc) { - dev_err(dev, "could not ioremap I/O port range\n"); + dev_err(&op->dev, "could not ioremap I/O port range\n"); ret = -EFAULT; - goto free_master; + goto free_unmap; } /* On the 5200, fifo regs are immediately ajacent to the psc regs */ mps->fifo = ((void __iomem *)mps->psc) + sizeof(struct mpc52xx_psc); - ret = request_irq(mps->irq, mpc52xx_psc_spi_isr, 0, "mpc52xx-psc-spi", - mps); + ret = request_irq(mps->irq, mpc52xx_psc_spi_isr, 0, DRIVER_NAME, mps); if (ret) - goto free_master; + goto free_unmap; ret = mpc52xx_psc_spi_port_config(master->bus_num, mps); if (ret < 0) @@ -429,24 +452,29 @@ static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr, if (ret < 0) goto unreg_master; + of_register_spi_devices(master, op->node); + return ret; unreg_master: destroy_workqueue(mps->workqueue); free_irq: free_irq(mps->irq, mps); -free_master: +free_unmap: if (mps->psc) iounmap(mps->psc); + release_mem_region(mem.start, resource_size(&mem)); +free_master: spi_master_put(master); return ret; } -static int __exit mpc52xx_psc_spi_do_remove(struct device *dev) +static int __exit mpc52xx_psc_spi_of_remove(struct of_device *op) { - struct spi_master *master = dev_get_drvdata(dev); + struct spi_master *master = dev_get_drvdata(&op->dev); struct mpc52xx_psc_spi *mps = spi_master_get_devdata(master); + struct resource mem; flush_workqueue(mps->workqueue); destroy_workqueue(mps->workqueue); @@ -454,46 +482,12 @@ static int __exit mpc52xx_psc_spi_do_remove(struct device *dev) free_irq(mps->irq, mps); if (mps->psc) iounmap(mps->psc); + if (of_address_to_resource(op->node, 0, &mem) == 0) + release_mem_region(mem.start, resource_size(&mem)); return 0; } -static int __init mpc52xx_psc_spi_of_probe(struct of_device *op, - const struct of_device_id *match) -{ - const u32 *regaddr_p; - u64 regaddr64, size64; - s16 id = -1; - - regaddr_p = of_get_address(op->node, 0, &size64, NULL); - if (!regaddr_p) { - printk(KERN_ERR "Invalid PSC address\n"); - return -EINVAL; - } - regaddr64 = of_translate_address(op->node, regaddr_p); - - /* get PSC id (1..6, used by port_config) */ - if (op->dev.platform_data == NULL) { - const u32 *psc_nump; - - psc_nump = of_get_property(op->node, "cell-index", NULL); - if (!psc_nump || *psc_nump > 5) { - printk(KERN_ERR "mpc52xx_psc_spi: Device node %s has invalid " - "cell-index property\n", op->node->full_name); - return -EINVAL; - } - id = *psc_nump + 1; - } - - return mpc52xx_psc_spi_do_probe(&op->dev, (u32)regaddr64, (u32)size64, - irq_of_parse_and_map(op->node, 0), id); -} - -static int __exit mpc52xx_psc_spi_of_remove(struct of_device *op) -{ - return mpc52xx_psc_spi_do_remove(&op->dev); -} - static struct of_device_id mpc52xx_psc_spi_of_match[] = { { .compatible = "fsl,mpc5200-psc-spi", }, { .compatible = "mpc5200-psc-spi", }, /* old */ @@ -504,12 +498,12 @@ MODULE_DEVICE_TABLE(of, mpc52xx_psc_spi_of_match); static struct of_platform_driver mpc52xx_psc_spi_of_driver = { .owner = THIS_MODULE, - .name = "mpc52xx-psc-spi", + .name = DRIVER_NAME, .match_table = mpc52xx_psc_spi_of_match, .probe = mpc52xx_psc_spi_of_probe, .remove = __exit_p(mpc52xx_psc_spi_of_remove), .driver = { - .name = "mpc52xx-psc-spi", + .name = DRIVER_NAME, .owner = THIS_MODULE, }, }; -- 1.6.3.3