1 /* 2 * Device's clock input and output 3 * 4 * Copyright GreenSocs 2016-2020 5 * 6 * Authors: 7 * Frederic Konrad 8 * Damien Hedde 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include "qemu/osdep.h" 15 #include "hw/qdev-clock.h" 16 #include "hw/qdev-core.h" 17 #include "qapi/error.h" 18 19 /* 20 * qdev_init_clocklist: 21 * Add a new clock in a device 22 */ 23 static NamedClockList *qdev_init_clocklist(DeviceState *dev, const char *name, 24 bool output, Clock *clk) 25 { 26 NamedClockList *ncl; 27 28 /* 29 * Clock must be added before realize() so that we can compute the 30 * clock's canonical path during device_realize(). 31 */ 32 assert(!dev->realized); 33 34 /* 35 * The ncl structure is freed by qdev_finalize_clocklist() which will 36 * be called during @dev's device_finalize(). 37 */ 38 ncl = g_new0(NamedClockList, 1); 39 ncl->name = g_strdup(name); 40 ncl->output = output; 41 ncl->alias = (clk != NULL); 42 43 /* 44 * Trying to create a clock whose name clashes with some other 45 * clock or property is a bug in the caller and we will abort(). 46 */ 47 if (clk == NULL) { 48 clk = CLOCK(object_new(TYPE_CLOCK)); 49 object_property_add_child(OBJECT(dev), name, OBJECT(clk), &error_abort); 50 if (output) { 51 /* 52 * Remove object_new()'s initial reference. 53 * Note that for inputs, the reference created by object_new() 54 * will be deleted in qdev_finalize_clocklist(). 55 */ 56 object_unref(OBJECT(clk)); 57 } 58 } else { 59 object_property_add_link(OBJECT(dev), name, 60 object_get_typename(OBJECT(clk)), 61 (Object **) &ncl->clock, 62 NULL, OBJ_PROP_LINK_STRONG, &error_abort); 63 } 64 65 ncl->clock = clk; 66 67 QLIST_INSERT_HEAD(&dev->clocks, ncl, node); 68 return ncl; 69 } 70 71 void qdev_finalize_clocklist(DeviceState *dev) 72 { 73 /* called by @dev's device_finalize() */ 74 NamedClockList *ncl, *ncl_next; 75 76 QLIST_FOREACH_SAFE(ncl, &dev->clocks, node, ncl_next) { 77 QLIST_REMOVE(ncl, node); 78 if (!ncl->output && !ncl->alias) { 79 /* 80 * We kept a reference on the input clock to ensure it lives up to 81 * this point so we can safely remove the callback. 82 * It avoids having a callback to a deleted object if ncl->clock 83 * is still referenced somewhere else (eg: by a clock output). 84 */ 85 clock_clear_callback(ncl->clock); 86 object_unref(OBJECT(ncl->clock)); 87 } 88 g_free(ncl->name); 89 g_free(ncl); 90 } 91 } 92 93 Clock *qdev_init_clock_out(DeviceState *dev, const char *name) 94 { 95 NamedClockList *ncl; 96 97 assert(name); 98 99 ncl = qdev_init_clocklist(dev, name, true, NULL); 100 101 return ncl->clock; 102 } 103 104 Clock *qdev_init_clock_in(DeviceState *dev, const char *name, 105 ClockCallback *callback, void *opaque) 106 { 107 NamedClockList *ncl; 108 109 assert(name); 110 111 ncl = qdev_init_clocklist(dev, name, false, NULL); 112 113 if (callback) { 114 clock_set_callback(ncl->clock, callback, opaque); 115 } 116 return ncl->clock; 117 } 118 119 static NamedClockList *qdev_get_clocklist(DeviceState *dev, const char *name) 120 { 121 NamedClockList *ncl; 122 123 QLIST_FOREACH(ncl, &dev->clocks, node) { 124 if (strcmp(name, ncl->name) == 0) { 125 return ncl; 126 } 127 } 128 129 return NULL; 130 } 131 132 Clock *qdev_get_clock_in(DeviceState *dev, const char *name) 133 { 134 NamedClockList *ncl; 135 136 assert(name); 137 138 ncl = qdev_get_clocklist(dev, name); 139 assert(!ncl->output); 140 141 return ncl->clock; 142 } 143 144 Clock *qdev_get_clock_out(DeviceState *dev, const char *name) 145 { 146 NamedClockList *ncl; 147 148 assert(name); 149 150 ncl = qdev_get_clocklist(dev, name); 151 assert(ncl->output); 152 153 return ncl->clock; 154 } 155 156 Clock *qdev_alias_clock(DeviceState *dev, const char *name, 157 DeviceState *alias_dev, const char *alias_name) 158 { 159 NamedClockList *ncl; 160 161 assert(name && alias_name); 162 163 ncl = qdev_get_clocklist(dev, name); 164 165 qdev_init_clocklist(alias_dev, alias_name, ncl->output, ncl->clock); 166 167 return ncl->clock; 168 } 169