mac_newworld: add gpios to macio devices with PMU enabled - bwlp/qemu.git - Experimental fork of QEMU with video encoding patches

diff options

author	Mark Cave-Ayland	2018-06-12 18:43:58 +0200
committer	David Gibson	2018-06-16 08:32:33 +0200
commit	7c4166a971b54a65900d9624ccd9669ba99d75ad (patch)
tree	a3217491665ad013d2359e57ee0ac9a90e75aebd /hw/misc/macio/trace-events
parent	mac_newworld: add via machine option to control mac99 VIA/ADB configuration (diff)
download	qemu-7c4166a971b54a65900d9624ccd9669ba99d75ad.tar.gz qemu-7c4166a971b54a65900d9624ccd9669ba99d75ad.tar.xz qemu-7c4166a971b54a65900d9624ccd9669ba99d75ad.zip

mac_newworld: add gpios to macio devices with PMU enabled

PMU-enabled New World Macs expose their GPIOs via a separate memory region within the macio device. Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> Signed-off-by: David Gibson <david@gibson.dropbear.id.au>

Diffstat (limited to 'hw/misc/macio/trace-events')

-rw-r--r--

hw/misc/macio/trace-events

1 files changed, 7 insertions, 0 deletions

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267

/* * QEMU Error Objects * * Copyright IBM, Corp. 2011 * Copyright (C) 2011-2015 Red Hat, Inc. * * Authors: * Anthony Liguori <aliguori@us.ibm.com> * Markus Armbruster <armbru@redhat.com> * * This work is licensed under the terms of the GNU LGPL, version 2. See * the COPYING.LIB file in the top-level directory. */ /* * Error reporting system loosely patterned after Glib's GError. * * = Rules = * * - Functions that use Error to report errors have an Error **errp * parameter. It should be the last parameter, except for functions * taking variable arguments. * * - You may pass NULL to not receive the error, &error_abort to abort * on error, &error_fatal to exit(1) on error, or a pointer to a * variable containing NULL to receive the error. * * - Separation of concerns: the function is responsible for detecting * errors and failing cleanly; handling the error is its caller's * job. Since the value of @errp is about handling the error, the * function should not examine it. * * - The function may pass @errp to functions it calls to pass on * their errors to its caller. If it dereferences @errp to check * for errors, it must use ERRP_GUARD(). * * - On success, the function should not touch *errp. On failure, it * should set a new error, e.g. with error_setg(errp, ...), or * propagate an existing one, e.g. with error_propagate(errp, ...). * * - Whenever practical, also return a value that indicates success / * failure. This can make the error checking more concise, and can * avoid useless error object creation and destruction. Note that * we still have many functions returning void. We recommend * • bool-valued functions return true on success / false on failure, * • pointer-valued functions return non-null / null pointer, and * • integer-valued functions return non-negative / negative. * * = Creating errors = * * Create an error: * error_setg(errp, "situation normal, all fouled up"); * where @errp points to the location to receive the error. * * Create an error and add additional explanation: * error_setg(errp, "invalid quark"); * error_append_hint(errp, "Valid quarks are up, down, strange, " * "charm, top, bottom.\n"); * This may require use of ERRP_GUARD(); more on that below. * * Do *not* contract this to * error_setg(errp, "invalid quark\n" // WRONG! * "Valid quarks are up, down, strange, charm, top, bottom."); * * = Reporting and destroying errors = * * Report an error to the current monitor if we have one, else stderr: * error_report_err(err); * This frees the error object. * * Likewise, but with additional text prepended: * error_reportf_err(err, "Could not frobnicate '%s': ", name); * * Report an error somewhere else: * const char *msg = error_get_pretty(err); * do with msg what needs to be done... * error_free(err); * Note that this loses hints added with error_append_hint(). * * Call a function ignoring errors: * foo(arg, NULL); * This is more concise than * Error *err = NULL; * foo(arg, &err); * error_free(err); // don't do this * * Call a function aborting on errors: * foo(arg, &error_abort); * This is more concise and fails more nicely than * Error *err = NULL; * foo(arg, &err); * assert(!err); // don't do this * * Call a function treating errors as fatal: * foo(arg, &error_fatal); * This is more concise than * Error *err = NULL; * foo(arg, &err); * if (err) { // don't do this * error_report_err(err); * exit(1); * } * * Handle an error without reporting it (just for completeness): * error_free(err); * * Assert that an expected error occurred, but clean it up without * reporting it (primarily useful in testsuites): * error_free_or_abort(&err); * * = Passing errors around = * * Errors get passed to the caller through the conventional @errp * parameter. * * Create a new error and pass it to the caller: * error_setg(errp, "situation normal, all fouled up"); * * Call a function, receive an error from it, and pass it to the caller * - when the function returns a value that indicates failure, say * false: * if (!foo(arg, errp)) { * handle the error... * } * - when it does not, say because it is a void function: * ERRP_GUARD(); * foo(arg, errp); * if (*errp) { * handle the error... * } * More on ERRP_GUARD() below. * * Code predating ERRP_GUARD() still exists, and looks like this: * Error *err = NULL; * foo(arg, &err); * if (err) { * handle the error... * error_propagate(errp, err); // deprecated * } * Avoid in new code. Do *not* "optimize" it to * foo(arg, errp); * if (*errp) { // WRONG! * handle the error... * } * because errp may be NULL without the ERRP_GUARD() guard. * * But when all you do with the error is pass it on, please use * foo(arg, errp); * for readability. * * Receive an error, and handle it locally * - when the function returns a value that indicates failure, say * false: * Error *err = NULL; * if (!foo(arg, &err)) { * handle the error... * } * - when it does not, say because it is a void function: * Error *err = NULL; * foo(arg, &err); * if (err) { * handle the error... * } * * Pass an existing error to the caller: * error_propagate(errp, err); * This is rarely needed. When @err is a local variable, use of * ERRP_GUARD() commonly results in more readable code. * * Pass an existing error to the caller with the message modified: * error_propagate_prepend(errp, err,


context:
space:
mode: