From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v11 1/4] hw/arm/sysbus-fdt: helpers for platform bus nodes addition Date: Thu, 26 Mar 2015 12:23:23 +0000 Message-ID: <87zj70aqx0.fsf@linaro.org> References: <1425485909-5091-1-git-send-email-eric.auger@linaro.org> <1425485909-5091-2-git-send-email-eric.auger@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from localhost (localhost [127.0.0.1]) by mm01.cs.columbia.edu (Postfix) with ESMTP id B6F3B49BD3 for ; Thu, 26 Mar 2015 08:16:01 -0400 (EDT) Received: from mm01.cs.columbia.edu ([127.0.0.1]) by localhost (mm01.cs.columbia.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id lINosMUJ5gU5 for ; Thu, 26 Mar 2015 08:15:55 -0400 (EDT) Received: from socrates.bennee.com (static.88-198-71-155.clients.your-server.de [88.198.71.155]) by mm01.cs.columbia.edu (Postfix) with ESMTPS id C134D49BA8 for ; Thu, 26 Mar 2015 08:15:54 -0400 (EDT) In-reply-to: <1425485909-5091-2-git-send-email-eric.auger@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: kvmarm-bounces@lists.cs.columbia.edu Sender: kvmarm-bounces@lists.cs.columbia.edu To: Eric Auger Cc: eric.auger@st.com, patches@linaro.org, qemu-devel@nongnu.org, pbonzini@redhat.com, kvmarm@lists.cs.columbia.edu List-Id: kvmarm@lists.cs.columbia.edu CkVyaWMgQXVnZXIgPGVyaWMuYXVnZXJAbGluYXJvLm9yZz4gd3JpdGVzOgoKPiBUaGlzIG5ldyBD IG1vZHVsZSB3aWxsIGJlIHVzZWQgYnkgQVJNIG1hY2hpbmUgZmlsZXMgdG8gZ2VuZXJhdGUKPiBw bGF0Zm9ybSBidXMgbm9kZSBhbmQgdGhlaXIgZHluYW1pYyBzeXNidXMgZGV2aWNlIHRyZWUgbm9k ZXMuCj4KPiBEeW5hbWljIHN5c2J1cyBkZXZpY2Ugbm9kZSBhZGRpdGlvbiBpcyBkb25lIGluIGEg bWFjaGluZSBpbml0Cj4gZG9uZSBub3RpZmllci4gYXJtX3JlZ2lzdGVyX3BsYXRmb3JtX2J1c19m ZHRfY3JlYXRvciBkb2VzIHRoZQo+IHJlZ2lzdHJhdGlvbiBvZiB0aGlzIGxhdHRlciBhbmQgaXMg c3VwcG9zZWQgdG8gYmUgY2FsbGVkIGJ5Cj4gQVJNIG1hY2hpbmUgZmlsZXMgdGhhdCBzdXBwb3J0 IHBsYXRmb3JtIGJ1cyBhbmQgdGhlaXIgZHluYW1pYwo+IHN5c2J1cy4gQWRkaXRpb24gb2YgZHlu YW1pYyBzeXNidXMgbm9kZXMgaXMgZG9uZSBvbmx5IGlmIHRoZQo+IHVzZXIgZGlkIG5vdCBwcm92 aWRlIGFueSBkdGIuCj4KPiBTaWduZWQtb2ZmLWJ5OiBBbGV4YW5kZXIgR3JhZiA8YWdyYWZAc3Vz ZS5kZT4KPiBTaWduZWQtb2ZmLWJ5OiBFcmljIEF1Z2VyIDxlcmljLmF1Z2VyQGxpbmFyby5vcmc+ Cj4gUmV2aWV3ZWQtYnk6IFNoYW5ub24gWmhhbyA8emhhb3NoZW5nbG9uZ0BodWF3ZWkuY29tPgo+ IFJldmlld2VkLWJ5OiBBbGV4YW5kZXIgR3JhZiA8YWdyYWZAc3VzZS5kZT4KClJldmlld2VkLWJ5 OiBBbGV4IEJlbm7DqWUgPGFsZXguYmVubmVlQGxpbmFyby5vcmc+Cgo+Cj4gLS0tCj4gdjkgLT4g djEwOgo+IC0gYWRkIGFzc2VydCBhbmQgZXhpdCBpbiBhZGRfZmR0X25vZGUKPgo+IHY4IC0+IHY5 Ogo+IC0gcy9GZHQvRkRUIGluIHN0cnVjdCB0eXBlIG5hbWVzCj4gLSByZW9yZGVyIGZpZWxkcyBp biBQbGF0Zm9ybUJ1c0ZkdE5vdGlmaWVyUGFyYW1zIGFuZCB1c2UgRE9fVVBDQVNUCj4gICBpbnN0 ZWFkIG9mIGNvbnRhaW5lcl9vZgo+IC0gdXNlIGFzc2VydCgpIHdoZW4gcmVsZXZhbnQgKGJvYXJk IG1vZGVsIGlzc3VlKQo+IC0gZ19mcmVlIHRoZSBBUk1QbGF0Zm9ybUJ1c0ZEVFBhcmFtcyBhbmQg UGxhdGZvcm1CdXNGRFROb3RpZmllclBhcmFtcwo+ICAgcG9pbnRlcnMgaW4gcGxhdGZvcm1fYnVz X2ZkdF9ub3RpZnkKPgo+IHY3IC0+IHY4Ogo+IGFkZCBSZXZpZXdlZC1ieSBmcm9tIEFsZXggYW5k IFNoYW5ub24KPgo+IHY2IC0+IHY3Ogo+IC0gcmV2ZXJ0IGluZGVudGF0aW9uIGluIGFkZF9mZHRf bm9kZV9mdW5jdGlvbnMKPgo+IHY1IC0+IHY2Ogo+IC0gYWRkX2FsbF9wbGF0Zm9ybV9idXNfZmR0 X25vZGVzIGlzIG5vdCBhIG1vZGlmeV9kdGIgZnVuY3Rpb24gYW55bW9yZQo+IC0gaXQgbm93IHRh a2VzIGEgaGFuZGxlIHRvIGFuIEFSTVBsYXRmb3JtQnVzRmR0UGFyYW1zLgo+IC0gZmR0IHBvaW50 ZXIgaXMgY2hlY2tlZCBpbiBjYXNlIHRoaXMgbm90aWZpZXIgaXMgZXhlY3V0ZWQgYWZ0ZXIgdGhl Cj4gICBvbmUgdGhhdCBleGVjdXRlcyB0aGUgbG9hZF9kdGIgKHRoaXMgbGF0dGVyIGRlYWxsb2Nh dGVzIHRoZSBmZHQgcG9pbnRlcikKPiAtIGNoZWNrIG9mIGZkdF9maWxlbmFtZSBtb3ZlZCBpbiBo ZXJlLgo+IC0gdXBncmFkZV9kdGIgaXMgcmVtb3ZlZAo+IC0gY29weXJpZ2h0IGFsaWduZWQgYmV0 d2VlbiAuaCBhbmQgLmMKPgo+IHY0IC0+IHY1Ogo+IC0gY2hhbmdlIGluZGVudGF0aW9uIGluIGFk ZF9mZHRfbm9kZV9mdW5jdGlvbnMuIEFsc28gYmVjb21lcyBhCj4gICBzdGF0aWMgY29uc3QuCj4g LSBBUk1QbGF0Zm9ybUJ1c0ZkdFBhcmFtcy5zeXN0ZW1fcGFyYW1zIGJlY29tZXMgYSBwb2ludGVy IHRvCj4gICBhIGNvbnN0IEFSTVBsYXRmb3JtQnVzU3lzdGVtUGFyYW1zCj4gLSByZW1vdmVzIHBs YXRmb3JtLWJ1cy5oIHNlY29uZCBpbmNsdXNpb24KPgo+IHYzIC0+IHY0Ogo+IC0gZHluX3N5c2J1 c19kZXZ0cmVlLmMgcmVuYW1lZCBpbnRvIHN5c2J1cy1mZHQuYwo+IC0gdXNlIG5ldyBQbGF0Zm9y bUJ1c0RldmljZSBvYmplY3QKPiAtIHRoZSBkdGIgdXBncmFkZSBpcyBkb25lIHRocm91Z2ggbW9k aWZ5X2R0Yi4gQmVmb3JlIHRoZSBmZHQKPiAgIHdhcyByZWNyZWF0ZWQgZnJvbSBzY3JhdGNoLiBX aGVuIHRoZSB1c2VyIHByb3ZpZGVkIGEgZHRiIHRoaXMKPiAgIGxhdHRlciB3YXMgb3ZlcndyaXR0 ZW4gd2hpY2ggd2FzIG5vdCBjb3JyZWN0Lgo+IC0gYW4gYXJyYXkgY29udGFpbnMgdGhlIGFzc29j aWF0aW9uIGJldHdlZW4gZGV2aWNlIHR5cGUgbmFtZXMKPiAgIGFuZCB0aGVpciBub2RlIGNyZWF0 aW9uIGZ1bmN0aW9uCj4gLSBJIG11c3QgYWtub3dsZWRnZSBJIGRpZCBub3QgZmluZCBhbnkgY2xl YW5lciB3YXkgdG8gaW1wbGVtZW50Cj4gICBhIEZEVF9CVUlMREVSIGludGVyZmFjZSwgYXMgc3Vn Z2VzdGVkIGJ5IFBhb2xvLiBUaGUgY2xhc3MgbWV0aG9kCj4gICB3b3VsZCBuZWVkIHRvIGJlIGlu aXRpYWxpemVkIHNvbWV3aGVyZSBhbmQgc2luY2UgaXQgY2Fubm90Cj4gICBoYXBwZW4gaW4gdGhl IGRldmljZSBpdHNlbGYgLSBhY2NvcmRpbmcgdG8gQWxleCAmIFBldGVyIGNvbW1lbnRzIC0sCj4g ICBJIGRvbid0IHNlZSB3aGVuIEkgc2hhbGwgYXNzb2NpYXRlIHRoZSBkZXZpY2UgdHlwZSBhbmQg aXRzCj4gICBpbnRlcmZhY2UgaW1wbGVtZW50YXRpb24uCj4KPiB2MiAtPiB2MzoKPiAtIGFkZCBh cm1fIHByZWZpeAo+IC0gYXJtX3N5c2J1c19kZXZpY2VfY3JlYXRlX2RldnRyZWUgYmVjb21lcyBz dGF0aWMKPgo+IHYxIC0+IHYyOgo+IC0gQ29kZSBtb3ZlZCBpbiBhbiBhcmNoIHNwZWNpZmljIGZp bGUgdG8gYWNjb21vZGF0ZSBhcmNoaXRlY3R1cmUKPiAgIGRlcGVuZGVudCBzcGVjaWZpY2l0aWVz Lgo+IC0gcmVtb3ZlIHBsYXRmb3JtX2J1c19iYXNlIGZyb20gUGxhdGZvcm1EZXZ0cmVlRGF0YQo+ Cj4gdjE6IGNvZGUgb3JpZ2luYWxseSB3cml0dGVuIGJ5IEFsZXggR3JhZiBpbiBlNTAwLmMgYW5k IHJldXNlZCBmb3IKPiBBUk0gW0VyaWMgQXVnZXJdCj4gLS0tCj4gIGh3L2FybS9NYWtlZmlsZS5v YmpzICAgICAgICB8ICAgMSArCj4gIGh3L2FybS9zeXNidXMtZmR0LmMgICAgICAgICB8IDE3NCAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRlL2h3 L2FybS9zeXNidXMtZmR0LmggfCAgNjAgKysrKysrKysrKysrKysrCj4gIDMgZmlsZXMgY2hhbmdl ZCwgMjM1IGluc2VydGlvbnMoKykKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGh3L2FybS9zeXNidXMt ZmR0LmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvaHcvYXJtL3N5c2J1cy1mZHQuaAo+ Cj4gZGlmZiAtLWdpdCBhL2h3L2FybS9NYWtlZmlsZS5vYmpzIGIvaHcvYXJtL01ha2VmaWxlLm9i anMKPiBpbmRleCA2MDg4ZTUzLi4wY2M2M2UxIDEwMDY0NAo+IC0tLSBhL2h3L2FybS9NYWtlZmls ZS5vYmpzCj4gKysrIGIvaHcvYXJtL01ha2VmaWxlLm9ianMKPiBAQCAtMyw2ICszLDcgQEAgb2Jq LSQoQ09ORklHX0RJR0lDKSArPSBkaWdpY19ib2FyZHMubwo+ICBvYmoteSArPSBpbnRlZ3JhdG9y Y3AubyBrem0ubyBtYWluc3RvbmUubyBtdXNpY3BhbC5vIG5zZXJpZXMubwo+ICBvYmoteSArPSBv bWFwX3N4MS5vIHBhbG0ubyByZWFsdmlldy5vIHNwaXR6Lm8gc3RlbGxhcmlzLm8KPiAgb2JqLXkg Kz0gdG9zYS5vIHZlcnNhdGlsZXBiLm8gdmV4cHJlc3MubyB2aXJ0Lm8geGlsaW54X3p5bnEubyB6 Mi5vCj4gK29iai15ICs9IHN5c2J1cy1mZHQubwo+ICAKPiAgb2JqLXkgKz0gYXJtdjdtLm8gZXh5 bm9zNDIxMC5vIHB4YTJ4eC5vIHB4YTJ4eF9ncGlvLm8gcHhhMnh4X3BpYy5vCj4gIG9iai0kKENP TkZJR19ESUdJQykgKz0gZGlnaWMubwo+IGRpZmYgLS1naXQgYS9ody9hcm0vc3lzYnVzLWZkdC5j IGIvaHcvYXJtL3N5c2J1cy1mZHQuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAw MDAwMC4uMzAzOGI5NAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9ody9hcm0vc3lzYnVzLWZkdC5j Cj4gQEAgLTAsMCArMSwxNzQgQEAKPiArLyoKPiArICogQVJNIFBsYXRmb3JtIEJ1cyBkZXZpY2Ug dHJlZSBnZW5lcmF0aW9uIGhlbHBlcnMKPiArICoKPiArICogQ29weXJpZ2h0IChjKSAyMDE0IExp bmFybyBMaW1pdGVkCj4gKyAqCj4gKyAqIEF1dGhvcnM6Cj4gKyAqICBBbGV4IEdyYWYgPGFncmFm QHN1c2UuZGU+Cj4gKyAqICBFcmljIEF1Z2VyIDxlcmljLmF1Z2VyQGxpbmFyby5vcmc+Cj4gKyAq Cj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0Cj4gKyAqIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9u cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCj4gKyAqIHZlcnNpb24gMiBvciBs YXRlciwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCj4gKyAq Cj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJl IHVzZWZ1bCwgYnV0IFdJVEhPVVQKPiArICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCj4gKyAqIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IKPiArICogbW9yZSBkZXRhaWxzLgo+ICsgKgo+ICsgKiBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRo Cj4gKyAqIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGlj ZW5zZXMvPi4KPiArICoKPiArICovCj4gKwo+ICsjaW5jbHVkZSAiaHcvYXJtL3N5c2J1cy1mZHQu aCIKPiArI2luY2x1ZGUgInFlbXUvZXJyb3ItcmVwb3J0LmgiCj4gKyNpbmNsdWRlICJzeXNlbXUv ZGV2aWNlX3RyZWUuaCIKPiArI2luY2x1ZGUgImh3L3BsYXRmb3JtLWJ1cy5oIgo+ICsjaW5jbHVk ZSAic3lzZW11L3N5c2VtdS5oIgo+ICsKPiArLyoKPiArICogaW50ZXJuYWwgc3RydWN0IHRoYXQg Y29udGFpbnMgdGhlIGluZm9ybWF0aW9uIHRvIGNyZWF0ZSBkeW5hbWljCj4gKyAqIHN5c2J1cyBk ZXZpY2Ugbm9kZQo+ICsgKi8KPiArdHlwZWRlZiBzdHJ1Y3QgUGxhdGZvcm1CdXNGRFREYXRhIHsK PiArICAgIHZvaWQgKmZkdDsgLyogZGV2aWNlIHRyZWUgaGFuZGxlICovCj4gKyAgICBpbnQgaXJx X3N0YXJ0OyAvKiBpbmRleCBvZiB0aGUgZmlyc3QgSVJRIHVzYWJsZSBieSBwbGF0Zm9ybSBidXMg ZGV2aWNlcyAqLwo+ICsgICAgY29uc3QgY2hhciAqcGJ1c19ub2RlX25hbWU7IC8qIG5hbWUgb2Yg dGhlIHBsYXRmb3JtIGJ1cyBub2RlICovCj4gKyAgICBQbGF0Zm9ybUJ1c0RldmljZSAqcGJ1czsK PiArfSBQbGF0Zm9ybUJ1c0ZEVERhdGE7Cj4gKwo+ICsvKgo+ICsgKiBzdHJ1Y3QgdXNlZCB3aGVu IGNhbGxpbmcgdGhlIG1hY2hpbmUgaW5pdCBkb25lIG5vdGlmaWVyCj4gKyAqIHRoYXQgY29uc3Ry dWN0cyB0aGUgZmR0IG5vZGVzIG9mIHBsYXRmb3JtIGJ1cyBkZXZpY2VzCj4gKyAqLwo+ICt0eXBl ZGVmIHN0cnVjdCBQbGF0Zm9ybUJ1c0ZEVE5vdGlmaWVyUGFyYW1zIHsKPiArICAgIE5vdGlmaWVy IG5vdGlmaWVyOwo+ICsgICAgQVJNUGxhdGZvcm1CdXNGRFRQYXJhbXMgKmZkdF9wYXJhbXM7Cj4g K30gUGxhdGZvcm1CdXNGRFROb3RpZmllclBhcmFtczsKPiArCj4gKy8qIHN0cnVjdCB0aGF0IGFz c29jaWF0ZXMgYSBkZXZpY2UgdHlwZSBuYW1lIGFuZCBhIG5vZGUgY3JlYXRpb24gZnVuY3Rpb24g Ki8KPiArdHlwZWRlZiBzdHJ1Y3QgTm9kZUNyZWF0aW9uUGFpciB7Cj4gKyAgICBjb25zdCBjaGFy ICp0eXBlbmFtZTsKPiArICAgIGludCAoKmFkZF9mZHRfbm9kZV9mbikoU3lzQnVzRGV2aWNlICpz YmRldiwgdm9pZCAqb3BhcXVlKTsKPiArfSBOb2RlQ3JlYXRpb25QYWlyOwo+ICsKPiArLyogbGlz dCBvZiBzdXBwb3J0ZWQgZHluYW1pYyBzeXNidXMgZGV2aWNlcyAqLwo+ICtzdGF0aWMgY29uc3Qg Tm9kZUNyZWF0aW9uUGFpciBhZGRfZmR0X25vZGVfZnVuY3Rpb25zW10gPSB7Cj4gKyAgICB7IiIs IE5VTEx9LCAvKiBsYXN0IGVsZW1lbnQgKi8KPiArfTsKPiArCj4gKy8qKgo+ICsgKiBhZGRfZmR0 X25vZGUgLSBhZGQgdGhlIGRldmljZSB0cmVlIG5vZGUgb2YgYSBkeW5hbWljIHN5c2J1cyBkZXZp Y2UKPiArICoKPiArICogQHNiZGV2OiBoYW5kbGUgdG8gdGhlIHN5c2J1cyBkZXZpY2UKPiArICog QG9wYXF1ZTogaGFuZGxlIHRvIHRoZSBQbGF0Zm9ybUJ1c0ZEVERhdGEKPiArICoKPiArICogQ2hl Y2tzIHRoZSBzeXNidXMgdHlwZSBiZWxvbmdzIHRvIHRoZSBsaXN0IG9mIGRldmljZSB0eXBlcyB0 aGF0Cj4gKyAqIGFyZSBkeW5hbWljYWxseSBpbnN0YW50aWFibGUgYW5kIGlmIHNvIGNhbGwgdGhl IG5vZGUgY3JlYXRpb24KPiArICogZnVuY3Rpb24uCj4gKyAqLwo+ICtzdGF0aWMgaW50IGFkZF9m ZHRfbm9kZShTeXNCdXNEZXZpY2UgKnNiZGV2LCB2b2lkICpvcGFxdWUpCj4gK3sKPiArICAgIGlu dCBpLCByZXQ7Cj4gKwo+ICsgICAgZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoYWRkX2ZkdF9u b2RlX2Z1bmN0aW9ucyk7IGkrKykgewo+ICsgICAgICAgIGlmICghc3RyY21wKG9iamVjdF9nZXRf dHlwZW5hbWUoT0JKRUNUKHNiZGV2KSksCj4gKyAgICAgICAgICAgICAgICAgICAgYWRkX2ZkdF9u b2RlX2Z1bmN0aW9uc1tpXS50eXBlbmFtZSkpIHsKPiArICAgICAgICAgICAgcmV0ID0gYWRkX2Zk dF9ub2RlX2Z1bmN0aW9uc1tpXS5hZGRfZmR0X25vZGVfZm4oc2JkZXYsIG9wYXF1ZSk7Cj4gKyAg ICAgICAgICAgIGFzc2VydCghcmV0KTsKPiArICAgICAgICAgICAgcmV0dXJuIDA7Cj4gKyAgICAg ICAgfQo+ICsgICAgfQo+ICsgICAgZXJyb3JfcmVwb3J0KCJEZXZpY2UgJXMgY2FuIG5vdCBiZSBk eW5hbWljYWxseSBpbnN0YW50aWF0ZWQiLAo+ICsgICAgICAgICAgICAgICAgICAgICBxZGV2X2Z3 X25hbWUoREVWSUNFKHNiZGV2KSkpOwo+ICsgICAgZXhpdCgxKTsKPiArfQo+ICsKPiArLyoqCj4g KyAqIGFkZF9hbGxfcGxhdGZvcm1fYnVzX2ZkdF9ub2RlcyAtIGNyZWF0ZSBhbGwgdGhlIHBsYXRm b3JtIGJ1cyBub2Rlcwo+ICsgKgo+ICsgKiBidWlsZHMgdGhlIHBhcmVudCBwbGF0Zm9ybSBidXMg bm9kZSBhbmQgYWxsIHRoZSBub2RlcyBvZiBkeW5hbWljCj4gKyAqIHN5c2J1cyBkZXZpY2VzIGF0 dGFjaGVkIHRvIGl0Lgo+ICsgKi8KPiArc3RhdGljIHZvaWQgYWRkX2FsbF9wbGF0Zm9ybV9idXNf ZmR0X25vZGVzKEFSTVBsYXRmb3JtQnVzRkRUUGFyYW1zICpmZHRfcGFyYW1zKQo+ICt7Cj4gKyAg ICBjb25zdCBjaGFyIHBsYXRjb21wW10gPSAicWVtdSxwbGF0Zm9ybVwwc2ltcGxlLWJ1cyI7Cj4g KyAgICBQbGF0Zm9ybUJ1c0RldmljZSAqcGJ1czsKPiArICAgIERldmljZVN0YXRlICpkZXY7Cj4g KyAgICBnY2hhciAqbm9kZTsKPiArICAgIHVpbnQ2NF90IGFkZHIsIHNpemU7Cj4gKyAgICBpbnQg aXJxX3N0YXJ0LCBkdGJfc2l6ZTsKPiArICAgIHN0cnVjdCBhcm1fYm9vdF9pbmZvICppbmZvID0g ZmR0X3BhcmFtcy0+YmluZm87Cj4gKyAgICBjb25zdCBBUk1QbGF0Zm9ybUJ1c1N5c3RlbVBhcmFt cyAqcGFyYW1zID0gZmR0X3BhcmFtcy0+c3lzdGVtX3BhcmFtczsKPiArICAgIGNvbnN0IGNoYXIg KmludGMgPSBmZHRfcGFyYW1zLT5pbnRjOwo+ICsgICAgdm9pZCAqZmR0ID0gaW5mby0+Z2V0X2R0 YihpbmZvLCAmZHRiX3NpemUpOwo+ICsKPiArICAgIC8qCj4gKyAgICAgKiBJZiB0aGUgdXNlciBw cm92aWRlZCBhIGR0Yiwgd2UgYXNzdW1lIHRoZSBkeW5hbWljIHN5c2J1cyBub2Rlcwo+ICsgICAg ICogYWxyZWFkeSBhcmUgaW50ZWdyYXRlZCB0aGVyZS4gVGhpcyBjb3JyZXNwb25kcyB0byBhIHVz ZSBjYXNlIHdoZXJlCj4gKyAgICAgKiB0aGUgZHluYW1pYyBzeXNidXMgbm9kZXMgYXJlIGNvbXBs ZXggYW5kIHRoZWlyIGdlbmVyYXRpb24gaXMgbm90IHlldAo+ICsgICAgICogc3VwcG9ydGVkLiBJ biB0aGF0IGNhc2UgdGhlIHVzZXIgY2FuIHRha2UgY2hhcmdlIG9mIHRoZSBndWVzdCBkdAo+ICsg ICAgICogd2hpbGUgcWVtdSB0YWtlcyBjaGFyZ2Ugb2YgdGhlIHFvbSBzdHVmZi4KPiArICAgICAq Lwo+ICsgICAgaWYgKGluZm8tPmR0Yl9maWxlbmFtZSkgewo+ICsgICAgICAgIHJldHVybjsKPiAr ICAgIH0KPiArCj4gKyAgICBhc3NlcnQoZmR0KTsKPiArCj4gKyAgICBub2RlID0gZ19zdHJkdXBf cHJpbnRmKCIvcGxhdGZvcm1AJSJQUkl4NjQsIHBhcmFtcy0+cGxhdGZvcm1fYnVzX2Jhc2UpOwo+ ICsgICAgYWRkciA9IHBhcmFtcy0+cGxhdGZvcm1fYnVzX2Jhc2U7Cj4gKyAgICBzaXplID0gcGFy YW1zLT5wbGF0Zm9ybV9idXNfc2l6ZTsKPiArICAgIGlycV9zdGFydCA9IHBhcmFtcy0+cGxhdGZv cm1fYnVzX2ZpcnN0X2lycTsKPiArCj4gKyAgICAvKiBDcmVhdGUgYSAvcGxhdGZvcm0gbm9kZSB0 aGF0IHdlIGNhbiBwdXQgYWxsIGRldmljZXMgaW50byAqLwo+ICsgICAgcWVtdV9mZHRfYWRkX3N1 Ym5vZGUoZmR0LCBub2RlKTsKPiArICAgIHFlbXVfZmR0X3NldHByb3AoZmR0LCBub2RlLCAiY29t cGF0aWJsZSIsIHBsYXRjb21wLCBzaXplb2YocGxhdGNvbXApKTsKPiArCj4gKyAgICAvKiBPdXIg cGxhdGZvcm0gYnVzIHJlZ2lvbiBpcyBsZXNzIHRoYW4gMzJiaXRzLCBzbyAxIGNlbGwgaXMgZW5v dWdoIGZvcgo+ICsgICAgICogYWRkcmVzcyBhbmQgc2l6ZQo+ICsgICAgICovCj4gKyAgICBxZW11 X2ZkdF9zZXRwcm9wX2NlbGxzKGZkdCwgbm9kZSwgIiNzaXplLWNlbGxzIiwgMSk7Cj4gKyAgICBx ZW11X2ZkdF9zZXRwcm9wX2NlbGxzKGZkdCwgbm9kZSwgIiNhZGRyZXNzLWNlbGxzIiwgMSk7Cj4g KyAgICBxZW11X2ZkdF9zZXRwcm9wX2NlbGxzKGZkdCwgbm9kZSwgInJhbmdlcyIsIDAsIGFkZHIg Pj4gMzIsIGFkZHIsIHNpemUpOwo+ICsKPiArICAgIHFlbXVfZmR0X3NldHByb3BfcGhhbmRsZShm ZHQsIG5vZGUsICJpbnRlcnJ1cHQtcGFyZW50IiwgaW50Yyk7Cj4gKwo+ICsgICAgZGV2ID0gcWRl dl9maW5kX3JlY3Vyc2l2ZShzeXNidXNfZ2V0X2RlZmF1bHQoKSwgVFlQRV9QTEFURk9STV9CVVNf REVWSUNFKTsKPiArICAgIHBidXMgPSBQTEFURk9STV9CVVNfREVWSUNFKGRldik7Cj4gKwo+ICsg ICAgLyogV2UgY2FuIG9ubHkgY3JlYXRlIGR0IG5vZGVzIGZvciBkeW5hbWljIGRldmljZXMgd2hl biB0aGV5J3JlIHJlYWR5ICovCj4gKyAgICBhc3NlcnQocGJ1cy0+ZG9uZV9nYXRoZXJpbmcpOwo+ ICsKPiArICAgIFBsYXRmb3JtQnVzRkRURGF0YSBkYXRhID0gewo+ICsgICAgICAgIC5mZHQgPSBm ZHQsCj4gKyAgICAgICAgLmlycV9zdGFydCA9IGlycV9zdGFydCwKPiArICAgICAgICAucGJ1c19u b2RlX25hbWUgPSBub2RlLAo+ICsgICAgICAgIC5wYnVzID0gcGJ1cywKPiArICAgIH07Cj4gKwo+ ICsgICAgLyogTG9vcCB0aHJvdWdoIGFsbCBkeW5hbWljIHN5c2J1cyBkZXZpY2VzIGFuZCBjcmVh dGUgdGhlaXIgbm9kZSAqLwo+ICsgICAgZm9yZWFjaF9keW5hbWljX3N5c2J1c19kZXZpY2UoYWRk X2ZkdF9ub2RlLCAmZGF0YSk7Cj4gKwo+ICsgICAgZ19mcmVlKG5vZGUpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgdm9pZCBwbGF0Zm9ybV9idXNfZmR0X25vdGlmeShOb3RpZmllciAqbm90aWZpZXIsIHZv aWQgKmRhdGEpCj4gK3sKPiArICAgIFBsYXRmb3JtQnVzRkRUTm90aWZpZXJQYXJhbXMgKnAgPSBE T19VUENBU1QoUGxhdGZvcm1CdXNGRFROb3RpZmllclBhcmFtcywKPiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbm90aWZpZXIsIG5vdGlmaWVyKTsKPiAr Cj4gKyAgICBhZGRfYWxsX3BsYXRmb3JtX2J1c19mZHRfbm9kZXMocC0+ZmR0X3BhcmFtcyk7Cj4g KyAgICBnX2ZyZWUocC0+ZmR0X3BhcmFtcyk7Cj4gKyAgICBnX2ZyZWUocCk7Cj4gK30KPiArCj4g K3ZvaWQgYXJtX3JlZ2lzdGVyX3BsYXRmb3JtX2J1c19mZHRfY3JlYXRvcihBUk1QbGF0Zm9ybUJ1 c0ZEVFBhcmFtcyAqZmR0X3BhcmFtcykKPiArewo+ICsgICAgUGxhdGZvcm1CdXNGRFROb3RpZmll clBhcmFtcyAqcCA9IGdfbmV3KFBsYXRmb3JtQnVzRkRUTm90aWZpZXJQYXJhbXMsIDEpOwo+ICsK PiArICAgIHAtPmZkdF9wYXJhbXMgPSBmZHRfcGFyYW1zOwo+ICsgICAgcC0+bm90aWZpZXIubm90 aWZ5ID0gcGxhdGZvcm1fYnVzX2ZkdF9ub3RpZnk7Cj4gKyAgICBxZW11X2FkZF9tYWNoaW5lX2lu aXRfZG9uZV9ub3RpZmllcigmcC0+bm90aWZpZXIpOwo+ICt9Cj4gZGlmZiAtLWdpdCBhL2luY2x1 ZGUvaHcvYXJtL3N5c2J1cy1mZHQuaCBiL2luY2x1ZGUvaHcvYXJtL3N5c2J1cy1mZHQuaAo+IG5l dyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uZTE1YmI4MQo+IC0tLSAvZGV2L251 bGwKPiArKysgYi9pbmNsdWRlL2h3L2FybS9zeXNidXMtZmR0LmgKPiBAQCAtMCwwICsxLDYwIEBA Cj4gKy8qCj4gKyAqIER5bmFtaWMgc3lzYnVzIGRldmljZSB0cmVlIG5vZGUgZ2VuZXJhdGlvbiBB UEkKPiArICoKPiArICogQ29weXJpZ2h0IExpbmFybyBMaW1pdGVkLCAyMDE0Cj4gKyAqCj4gKyAq IEF1dGhvcnM6Cj4gKyAqICBBbGV4IEdyYWYgPGFncmFmQHN1c2UuZGU+Cj4gKyAqICBFcmljIEF1 Z2VyIDxlcmljLmF1Z2VyQGxpbmFyby5vcmc+Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0Cj4g KyAqIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UsCj4gKyAqIHZlcnNpb24gMiBvciBsYXRlciwgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKPiAr ICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVS Q0hBTlRBQklMSVRZIG9yCj4gKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKPiArICogbW9yZSBkZXRhaWxz Lgo+ICsgKgo+ICsgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRoCj4gKyAqIHRoaXMgcHJvZ3JhbS4gIElm IG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KPiArICoKPiArICovCj4g Kwo+ICsjaWZuZGVmIEhXX0FSTV9TWVNCVVNfRkRUX0gKPiArI2RlZmluZSBIV19BUk1fU1lTQlVT X0ZEVF9ICj4gKwo+ICsjaW5jbHVkZSAiaHcvYXJtL2FybS5oIgo+ICsjaW5jbHVkZSAicWVtdS1j b21tb24uaCIKPiArI2luY2x1ZGUgImh3L3N5c2J1cy5oIgo+ICsKPiArLyoKPiArICogc3RydWN0 IHRoYXQgY29udGFpbnMgZGltZW5zaW9uaW5nIHBhcmFtZXRlcnMgb2YgdGhlIHBsYXRmb3JtIGJ1 cwo+ICsgKi8KPiArdHlwZWRlZiBzdHJ1Y3Qgewo+ICsgICAgaHdhZGRyIHBsYXRmb3JtX2J1c19i YXNlOyAvKiBzdGFydCBhZGRyZXNzIG9mIHRoZSBidXMgKi8KPiArICAgIGh3YWRkciBwbGF0Zm9y bV9idXNfc2l6ZTsgLyogc2l6ZSBvZiB0aGUgYnVzICovCj4gKyAgICBpbnQgcGxhdGZvcm1fYnVz X2ZpcnN0X2lycTsgLyogZmlyc3QgaHdpcnEgYXNzaWduZWQgdG8gdGhlIGJ1cyAqLwo+ICsgICAg aW50IHBsYXRmb3JtX2J1c19udW1faXJxczsgLyogbnVtYmVyIG9mIGh3aXJxIGFzc2lnbmVkIHRv IHRoZSBidXMgKi8KPiArfSBBUk1QbGF0Zm9ybUJ1c1N5c3RlbVBhcmFtczsKPiArCj4gKy8qCj4g KyAqIHN0cnVjdCB0aGF0IGNvbnRhaW5zIGFsbCByZWxldmFudCBpbmZvIHRvIGJ1aWxkIHRoZSBm ZHQgbm9kZXMgb2YKPiArICogcGxhdGZvcm0gYnVzIGFuZCBhdHRhY2hlZCBkeW5hbWljIHN5c2J1 cyBkZXZpY2VzCj4gKyAqIGluIHRoZSBmdXR1cmUgbWlnaHQgYmUgYXVnbWVudGVkIHdpdGggYWRk aXRpb25hbCBpbmZvCj4gKyAqIHN1Y2ggYXMgUEhZLCBDTEsgaGFuZGxlcyAuLi4KPiArICovCj4g K3R5cGVkZWYgc3RydWN0IHsKPiArICAgIGNvbnN0IEFSTVBsYXRmb3JtQnVzU3lzdGVtUGFyYW1z ICpzeXN0ZW1fcGFyYW1zOwo+ICsgICAgc3RydWN0IGFybV9ib290X2luZm8gKmJpbmZvOwo+ICsg ICAgY29uc3QgY2hhciAqaW50YzsgLyogcGFyZW50IGludGVycnVwdCBjb250cm9sbGVyIG5hbWUg Ki8KPiArfSBBUk1QbGF0Zm9ybUJ1c0ZEVFBhcmFtczsKPiArCj4gKy8qKgo+ICsgKiBhcm1fcmVn aXN0ZXJfcGxhdGZvcm1fYnVzX2ZkdF9jcmVhdG9yIC0gcmVnaXN0ZXIgYSBtYWNoaW5lIGluaXQg ZG9uZQo+ICsgKiBub3RpZmllciB0aGF0IGNyZWF0ZXMgdGhlIGRldmljZSB0cmVlIG5vZGVzIG9m IHRoZSBwbGF0Zm9ybSBidXMgYW5kCj4gKyAqIGFzc29jaWF0ZWQgZHluYW1pYyBzeXNidXMgZGV2 aWNlcwo+ICsgKi8KPiArdm9pZCBhcm1fcmVnaXN0ZXJfcGxhdGZvcm1fYnVzX2ZkdF9jcmVhdG9y KEFSTVBsYXRmb3JtQnVzRkRUUGFyYW1zICpmZHRfcGFyYW1zKTsKPiArCj4gKyNlbmRpZgoKLS0g CkFsZXggQmVubsOpZQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwprdm1hcm0gbWFpbGluZyBsaXN0Cmt2bWFybUBsaXN0cy5jcy5jb2x1bWJpYS5lZHUKaHR0 cHM6Ly9saXN0cy5jcy5jb2x1bWJpYS5lZHUvbWFpbG1hbi9saXN0aW5mby9rdm1hcm0K From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:52422) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Yb6oP-0000R8-OZ for qemu-devel@nongnu.org; Thu, 26 Mar 2015 08:23:03 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Yb6oK-0005CX-Gi for qemu-devel@nongnu.org; Thu, 26 Mar 2015 08:23:00 -0400 Received: from static.88-198-71-155.clients.your-server.de ([88.198.71.155]:59802 helo=socrates.bennee.com) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Yb6oK-0005CQ-7R for qemu-devel@nongnu.org; Thu, 26 Mar 2015 08:22:56 -0400 References: <1425485909-5091-1-git-send-email-eric.auger@linaro.org> <1425485909-5091-2-git-send-email-eric.auger@linaro.org> From: Alex =?utf-8?Q?Benn=C3=A9e?= In-reply-to: <1425485909-5091-2-git-send-email-eric.auger@linaro.org> Date: Thu, 26 Mar 2015 12:23:23 +0000 Message-ID: <87zj70aqx0.fsf@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Subject: Re: [Qemu-devel] [PATCH v11 1/4] hw/arm/sysbus-fdt: helpers for platform bus nodes addition List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Eric Auger Cc: peter.maydell@linaro.org, eric.auger@st.com, patches@linaro.org, qemu-devel@nongnu.org, pbonzini@redhat.com, kvmarm@lists.cs.columbia.edu Eric Auger writes: > This new C module will be used by ARM machine files to generate > platform bus node and their dynamic sysbus device tree nodes. > > Dynamic sysbus device node addition is done in a machine init > done notifier. arm_register_platform_bus_fdt_creator does the > registration of this latter and is supposed to be called by > ARM machine files that support platform bus and their dynamic > sysbus. Addition of dynamic sysbus nodes is done only if the > user did not provide any dtb. > > Signed-off-by: Alexander Graf > Signed-off-by: Eric Auger > Reviewed-by: Shannon Zhao > Reviewed-by: Alexander Graf Reviewed-by: Alex Bennée > > --- > v9 -> v10: > - add assert and exit in add_fdt_node > > v8 -> v9: > - s/Fdt/FDT in struct type names > - reorder fields in PlatformBusFdtNotifierParams and use DO_UPCAST > instead of container_of > - use assert() when relevant (board model issue) > - g_free the ARMPlatformBusFDTParams and PlatformBusFDTNotifierParams > pointers in platform_bus_fdt_notify > > v7 -> v8: > add Reviewed-by from Alex and Shannon > > v6 -> v7: > - revert indentation in add_fdt_node_functions > > v5 -> v6: > - add_all_platform_bus_fdt_nodes is not a modify_dtb function anymore > - it now takes a handle to an ARMPlatformBusFdtParams. > - fdt pointer is checked in case this notifier is executed after the > one that executes the load_dtb (this latter deallocates the fdt pointer) > - check of fdt_filename moved in here. > - upgrade_dtb is removed > - copyright aligned between .h and .c > > v4 -> v5: > - change indentation in add_fdt_node_functions. Also becomes a > static const. > - ARMPlatformBusFdtParams.system_params becomes a pointer to > a const ARMPlatformBusSystemParams > - removes platform-bus.h second inclusion > > v3 -> v4: > - dyn_sysbus_devtree.c renamed into sysbus-fdt.c > - use new PlatformBusDevice object > - the dtb upgrade is done through modify_dtb. Before the fdt > was recreated from scratch. When the user provided a dtb this > latter was overwritten which was not correct. > - an array contains the association between device type names > and their node creation function > - I must aknowledge I did not find any cleaner way to implement > a FDT_BUILDER interface, as suggested by Paolo. The class method > would need to be initialized somewhere and since it cannot > happen in the device itself - according to Alex & Peter comments -, > I don't see when I shall associate the device type and its > interface implementation. > > v2 -> v3: > - add arm_ prefix > - arm_sysbus_device_create_devtree becomes static > > v1 -> v2: > - Code moved in an arch specific file to accomodate architecture > dependent specificities. > - remove platform_bus_base from PlatformDevtreeData > > v1: code originally written by Alex Graf in e500.c and reused for > ARM [Eric Auger] > --- > hw/arm/Makefile.objs | 1 + > hw/arm/sysbus-fdt.c | 174 ++++++++++++++++++++++++++++++++++++++++++++ > include/hw/arm/sysbus-fdt.h | 60 +++++++++++++++ > 3 files changed, 235 insertions(+) > create mode 100644 hw/arm/sysbus-fdt.c > create mode 100644 include/hw/arm/sysbus-fdt.h > > diff --git a/hw/arm/Makefile.objs b/hw/arm/Makefile.objs > index 6088e53..0cc63e1 100644 > --- a/hw/arm/Makefile.objs > +++ b/hw/arm/Makefile.objs > @@ -3,6 +3,7 @@ obj-$(CONFIG_DIGIC) += digic_boards.o > obj-y += integratorcp.o kzm.o mainstone.o musicpal.o nseries.o > obj-y += omap_sx1.o palm.o realview.o spitz.o stellaris.o > obj-y += tosa.o versatilepb.o vexpress.o virt.o xilinx_zynq.o z2.o > +obj-y += sysbus-fdt.o > > obj-y += armv7m.o exynos4210.o pxa2xx.o pxa2xx_gpio.o pxa2xx_pic.o > obj-$(CONFIG_DIGIC) += digic.o > diff --git a/hw/arm/sysbus-fdt.c b/hw/arm/sysbus-fdt.c > new file mode 100644 > index 0000000..3038b94 > --- /dev/null > +++ b/hw/arm/sysbus-fdt.c > @@ -0,0 +1,174 @@ > +/* > + * ARM Platform Bus device tree generation helpers > + * > + * Copyright (c) 2014 Linaro Limited > + * > + * Authors: > + * Alex Graf > + * Eric Auger > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2 or later, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * You should have received a copy of the GNU General Public License along with > + * this program. If not, see . > + * > + */ > + > +#include "hw/arm/sysbus-fdt.h" > +#include "qemu/error-report.h" > +#include "sysemu/device_tree.h" > +#include "hw/platform-bus.h" > +#include "sysemu/sysemu.h" > + > +/* > + * internal struct that contains the information to create dynamic > + * sysbus device node > + */ > +typedef struct PlatformBusFDTData { > + void *fdt; /* device tree handle */ > + int irq_start; /* index of the first IRQ usable by platform bus devices */ > + const char *pbus_node_name; /* name of the platform bus node */ > + PlatformBusDevice *pbus; > +} PlatformBusFDTData; > + > +/* > + * struct used when calling the machine init done notifier > + * that constructs the fdt nodes of platform bus devices > + */ > +typedef struct PlatformBusFDTNotifierParams { > + Notifier notifier; > + ARMPlatformBusFDTParams *fdt_params; > +} PlatformBusFDTNotifierParams; > + > +/* struct that associates a device type name and a node creation function */ > +typedef struct NodeCreationPair { > + const char *typename; > + int (*add_fdt_node_fn)(SysBusDevice *sbdev, void *opaque); > +} NodeCreationPair; > + > +/* list of supported dynamic sysbus devices */ > +static const NodeCreationPair add_fdt_node_functions[] = { > + {"", NULL}, /* last element */ > +}; > + > +/** > + * add_fdt_node - add the device tree node of a dynamic sysbus device > + * > + * @sbdev: handle to the sysbus device > + * @opaque: handle to the PlatformBusFDTData > + * > + * Checks the sysbus type belongs to the list of device types that > + * are dynamically instantiable and if so call the node creation > + * function. > + */ > +static int add_fdt_node(SysBusDevice *sbdev, void *opaque) > +{ > + int i, ret; > + > + for (i = 0; i < ARRAY_SIZE(add_fdt_node_functions); i++) { > + if (!strcmp(object_get_typename(OBJECT(sbdev)), > + add_fdt_node_functions[i].typename)) { > + ret = add_fdt_node_functions[i].add_fdt_node_fn(sbdev, opaque); > + assert(!ret); > + return 0; > + } > + } > + error_report("Device %s can not be dynamically instantiated", > + qdev_fw_name(DEVICE(sbdev))); > + exit(1); > +} > + > +/** > + * add_all_platform_bus_fdt_nodes - create all the platform bus nodes > + * > + * builds the parent platform bus node and all the nodes of dynamic > + * sysbus devices attached to it. > + */ > +static void add_all_platform_bus_fdt_nodes(ARMPlatformBusFDTParams *fdt_params) > +{ > + const char platcomp[] = "qemu,platform\0simple-bus"; > + PlatformBusDevice *pbus; > + DeviceState *dev; > + gchar *node; > + uint64_t addr, size; > + int irq_start, dtb_size; > + struct arm_boot_info *info = fdt_params->binfo; > + const ARMPlatformBusSystemParams *params = fdt_params->system_params; > + const char *intc = fdt_params->intc; > + void *fdt = info->get_dtb(info, &dtb_size); > + > + /* > + * If the user provided a dtb, we assume the dynamic sysbus nodes > + * already are integrated there. This corresponds to a use case where > + * the dynamic sysbus nodes are complex and their generation is not yet > + * supported. In that case the user can take charge of the guest dt > + * while qemu takes charge of the qom stuff. > + */ > + if (info->dtb_filename) { > + return; > + } > + > + assert(fdt); > + > + node = g_strdup_printf("/platform@%"PRIx64, params->platform_bus_base); > + addr = params->platform_bus_base; > + size = params->platform_bus_size; > + irq_start = params->platform_bus_first_irq; > + > + /* Create a /platform node that we can put all devices into */ > + qemu_fdt_add_subnode(fdt, node); > + qemu_fdt_setprop(fdt, node, "compatible", platcomp, sizeof(platcomp)); > + > + /* Our platform bus region is less than 32bits, so 1 cell is enough for > + * address and size > + */ > + qemu_fdt_setprop_cells(fdt, node, "#size-cells", 1); > + qemu_fdt_setprop_cells(fdt, node, "#address-cells", 1); > + qemu_fdt_setprop_cells(fdt, node, "ranges", 0, addr >> 32, addr, size); > + > + qemu_fdt_setprop_phandle(fdt, node, "interrupt-parent", intc); > + > + dev = qdev_find_recursive(sysbus_get_default(), TYPE_PLATFORM_BUS_DEVICE); > + pbus = PLATFORM_BUS_DEVICE(dev); > + > + /* We can only create dt nodes for dynamic devices when they're ready */ > + assert(pbus->done_gathering); > + > + PlatformBusFDTData data = { > + .fdt = fdt, > + .irq_start = irq_start, > + .pbus_node_name = node, > + .pbus = pbus, > + }; > + > + /* Loop through all dynamic sysbus devices and create their node */ > + foreach_dynamic_sysbus_device(add_fdt_node, &data); > + > + g_free(node); > +} > + > +static void platform_bus_fdt_notify(Notifier *notifier, void *data) > +{ > + PlatformBusFDTNotifierParams *p = DO_UPCAST(PlatformBusFDTNotifierParams, > + notifier, notifier); > + > + add_all_platform_bus_fdt_nodes(p->fdt_params); > + g_free(p->fdt_params); > + g_free(p); > +} > + > +void arm_register_platform_bus_fdt_creator(ARMPlatformBusFDTParams *fdt_params) > +{ > + PlatformBusFDTNotifierParams *p = g_new(PlatformBusFDTNotifierParams, 1); > + > + p->fdt_params = fdt_params; > + p->notifier.notify = platform_bus_fdt_notify; > + qemu_add_machine_init_done_notifier(&p->notifier); > +} > diff --git a/include/hw/arm/sysbus-fdt.h b/include/hw/arm/sysbus-fdt.h > new file mode 100644 > index 0000000..e15bb81 > --- /dev/null > +++ b/include/hw/arm/sysbus-fdt.h > @@ -0,0 +1,60 @@ > +/* > + * Dynamic sysbus device tree node generation API > + * > + * Copyright Linaro Limited, 2014 > + * > + * Authors: > + * Alex Graf > + * Eric Auger > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2 or later, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * You should have received a copy of the GNU General Public License along with > + * this program. If not, see . > + * > + */ > + > +#ifndef HW_ARM_SYSBUS_FDT_H > +#define HW_ARM_SYSBUS_FDT_H > + > +#include "hw/arm/arm.h" > +#include "qemu-common.h" > +#include "hw/sysbus.h" > + > +/* > + * struct that contains dimensioning parameters of the platform bus > + */ > +typedef struct { > + hwaddr platform_bus_base; /* start address of the bus */ > + hwaddr platform_bus_size; /* size of the bus */ > + int platform_bus_first_irq; /* first hwirq assigned to the bus */ > + int platform_bus_num_irqs; /* number of hwirq assigned to the bus */ > +} ARMPlatformBusSystemParams; > + > +/* > + * struct that contains all relevant info to build the fdt nodes of > + * platform bus and attached dynamic sysbus devices > + * in the future might be augmented with additional info > + * such as PHY, CLK handles ... > + */ > +typedef struct { > + const ARMPlatformBusSystemParams *system_params; > + struct arm_boot_info *binfo; > + const char *intc; /* parent interrupt controller name */ > +} ARMPlatformBusFDTParams; > + > +/** > + * arm_register_platform_bus_fdt_creator - register a machine init done > + * notifier that creates the device tree nodes of the platform bus and > + * associated dynamic sysbus devices > + */ > +void arm_register_platform_bus_fdt_creator(ARMPlatformBusFDTParams *fdt_params); > + > +#endif -- Alex Bennée