driver core: replace remaining __FUNCTION__ occurrences

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

__FUNCTION__ is gcc-specific, use __func__

Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

authored by

Harvey Harrison and committed by

Greg Kroah-Hartman 18 years ago 2b3a302a 2424b5dd

+36 -36

7 changed files

expand all

drivers

base

bus.c

class.c

core.c

dd.c

firmware_class.c

memory.c

sys.c

+4 -4

drivers/base/bus.c

··· 79 79 { 80 80 struct driver_private *drv_priv = to_driver(kobj); 81 81 82 - pr_debug("driver: '%s': %s\n", kobject_name(kobj), __FUNCTION__); 82 + pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__); 83 83 kfree(drv_priv); 84 84 } 85 85 ··· 677 677 error = driver_create_file(drv, &driver_attr_uevent); 678 678 if (error) { 679 679 printk(KERN_ERR "%s: uevent attr (%s) failed\n", 680 - __FUNCTION__, drv->name); 680 + __func__, drv->name); 681 681 } 682 682 error = driver_add_attrs(bus, drv); 683 683 if (error) { 684 684 /* How the hell do we get out of this pickle? Give up */ 685 685 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n", 686 - __FUNCTION__, drv->name); 686 + __func__, drv->name); 687 687 } 688 688 error = add_bind_files(drv); 689 689 if (error) { 690 690 /* Ditto */ 691 691 printk(KERN_ERR "%s: add_bind_files(%s) failed\n", 692 - __FUNCTION__, drv->name); 692 + __func__, drv->name); 693 693 } 694 694 695 695 kobject_uevent(&priv->kobj, KOBJ_ADD);

+4 -4

drivers/base/class.c

··· 175 175 176 176 static void class_create_release(struct class *cls) 177 177 { 178 - pr_debug("%s called for %s\n", __FUNCTION__, cls->name); 178 + pr_debug("%s called for %s\n", __func__, cls->name); 179 179 kfree(cls); 180 180 } 181 181 182 182 static void class_device_create_release(struct class_device *class_dev) 183 183 { 184 - pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id); 184 + pr_debug("%s called for %s\n", __func__, class_dev->class_id); 185 185 kfree(class_dev); 186 186 } 187 187 ··· 189 189 static int class_device_create_uevent(struct class_device *class_dev, 190 190 struct kobj_uevent_env *env) 191 191 { 192 - pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id); 192 + pr_debug("%s called for %s\n", __func__, class_dev->class_id); 193 193 return 0; 194 194 } 195 195 ··· 415 415 struct device *dev = class_dev->dev; 416 416 int retval = 0; 417 417 418 - pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id); 418 + pr_debug("%s - name = %s\n", __func__, class_dev->class_id); 419 419 420 420 if (MAJOR(class_dev->devt)) { 421 421 add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));

+9 -9

drivers/base/core.c

··· 207 207 retval = dev->bus->uevent(dev, env); 208 208 if (retval) 209 209 pr_debug("device: '%s': %s: bus uevent() returned %d\n", 210 - dev->bus_id, __FUNCTION__, retval); 210 + dev->bus_id, __func__, retval); 211 211 } 212 212 213 213 /* have the class specific function add its stuff */ ··· 216 216 if (retval) 217 217 pr_debug("device: '%s': %s: class uevent() " 218 218 "returned %d\n", dev->bus_id, 219 - __FUNCTION__, retval); 219 + __func__, retval); 220 220 } 221 221 222 222 /* have the device type specific fuction add its stuff */ ··· 225 225 if (retval) 226 226 pr_debug("device: '%s': %s: dev_type uevent() " 227 227 "returned %d\n", dev->bus_id, 228 - __FUNCTION__, retval); 228 + __func__, retval); 229 229 } 230 230 231 231 return retval; ··· 782 782 goto Done; 783 783 } 784 784 785 - pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__); 785 + pr_debug("device: '%s': %s\n", dev->bus_id, __func__); 786 786 787 787 parent = get_device(dev->parent); 788 788 setup_parent(dev, parent); ··· 980 980 */ 981 981 void device_unregister(struct device *dev) 982 982 { 983 - pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__); 983 + pr_debug("device: '%s': %s\n", dev->bus_id, __func__); 984 984 device_del(dev); 985 985 put_device(dev); 986 986 } ··· 1075 1075 1076 1076 static void device_create_release(struct device *dev) 1077 1077 { 1078 - pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__); 1078 + pr_debug("device: '%s': %s\n", dev->bus_id, __func__); 1079 1079 kfree(dev); 1080 1080 } 1081 1081 ··· 1180 1180 return -EINVAL; 1181 1181 1182 1182 pr_debug("device: '%s': %s: renaming to '%s'\n", dev->bus_id, 1183 - __FUNCTION__, new_name); 1183 + __func__, new_name); 1184 1184 1185 1185 #ifdef CONFIG_SYSFS_DEPRECATED 1186 1186 if ((dev->class) && (dev->parent)) ··· 1219 1219 dev->bus_id); 1220 1220 if (error) { 1221 1221 dev_err(dev, "%s: sysfs_create_symlink failed (%d)\n", 1222 - __FUNCTION__, error); 1222 + __func__, error); 1223 1223 } 1224 1224 } 1225 1225 #endif ··· 1295 1295 new_parent_kobj = get_device_parent(dev, new_parent); 1296 1296 1297 1297 pr_debug("device: '%s': %s: moving to '%s'\n", dev->bus_id, 1298 - __FUNCTION__, new_parent ? new_parent->bus_id : "<NULL>"); 1298 + __func__, new_parent ? new_parent->bus_id : "<NULL>"); 1299 1299 error = kobject_move(&dev->kobj, new_parent_kobj); 1300 1300 if (error) { 1301 1301 cleanup_glue_dir(dev, new_parent_kobj);

+7 -7

drivers/base/dd.c

··· 30 30 { 31 31 if (klist_node_attached(&dev->knode_driver)) { 32 32 printk(KERN_WARNING "%s: device %s already bound\n", 33 - __FUNCTION__, kobject_name(&dev->kobj)); 33 + __func__, kobject_name(&dev->kobj)); 34 34 return; 35 35 } 36 36 37 37 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->bus_id, 38 - __FUNCTION__, dev->driver->name); 38 + __func__, dev->driver->name); 39 39 40 40 if (dev->bus) 41 41 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, ··· 104 104 105 105 atomic_inc(&probe_count); 106 106 pr_debug("bus: '%s': %s: probing driver %s with device %s\n", 107 - drv->bus->name, __FUNCTION__, drv->name, dev->bus_id); 107 + drv->bus->name, __func__, drv->name, dev->bus_id); 108 108 WARN_ON(!list_empty(&dev->devres_head)); 109 109 110 110 dev->driver = drv; 111 111 if (driver_sysfs_add(dev)) { 112 112 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", 113 - __FUNCTION__, dev->bus_id); 113 + __func__, dev->bus_id); 114 114 goto probe_failed; 115 115 } 116 116 ··· 127 127 driver_bound(dev); 128 128 ret = 1; 129 129 pr_debug("bus: '%s': %s: bound device %s to driver %s\n", 130 - drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); 130 + drv->bus->name, __func__, dev->bus_id, drv->name); 131 131 goto done; 132 132 133 133 probe_failed: ··· 160 160 */ 161 161 int driver_probe_done(void) 162 162 { 163 - pr_debug("%s: probe_count = %d\n", __FUNCTION__, 163 + pr_debug("%s: probe_count = %d\n", __func__, 164 164 atomic_read(&probe_count)); 165 165 if (atomic_read(&probe_count)) 166 166 return -EBUSY; ··· 194 194 goto done; 195 195 196 196 pr_debug("bus: '%s': %s: matched device %s with driver %s\n", 197 - drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); 197 + drv->bus->name, __func__, dev->bus_id, drv->name); 198 198 199 199 ret = really_probe(dev, drv); 200 200

+9 -9

drivers/base/firmware_class.c

··· 156 156 } 157 157 /* fallthrough */ 158 158 default: 159 - printk(KERN_ERR "%s: unexpected value (%d)\n", __FUNCTION__, 159 + printk(KERN_ERR "%s: unexpected value (%d)\n", __func__, 160 160 loading); 161 161 /* fallthrough */ 162 162 case -1: ··· 209 209 new_size = ALIGN(min_size, PAGE_SIZE); 210 210 new_data = vmalloc(new_size); 211 211 if (!new_data) { 212 - printk(KERN_ERR "%s: unable to alloc buffer\n", __FUNCTION__); 212 + printk(KERN_ERR "%s: unable to alloc buffer\n", __func__); 213 213 /* Make sure that we don't keep incomplete data */ 214 214 fw_load_abort(fw_priv); 215 215 return -ENOMEM; ··· 307 307 *dev_p = NULL; 308 308 309 309 if (!fw_priv || !f_dev) { 310 - printk(KERN_ERR "%s: kmalloc failed\n", __FUNCTION__); 310 + printk(KERN_ERR "%s: kmalloc failed\n", __func__); 311 311 retval = -ENOMEM; 312 312 goto error_kfree; 313 313 } ··· 328 328 retval = device_register(f_dev); 329 329 if (retval) { 330 330 printk(KERN_ERR "%s: device_register failed\n", 331 - __FUNCTION__); 331 + __func__); 332 332 goto error_kfree; 333 333 } 334 334 *dev_p = f_dev; ··· 362 362 retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data); 363 363 if (retval) { 364 364 printk(KERN_ERR "%s: sysfs_create_bin_file failed\n", 365 - __FUNCTION__); 365 + __func__); 366 366 goto error_unreg; 367 367 } 368 368 369 369 retval = device_create_file(f_dev, &dev_attr_loading); 370 370 if (retval) { 371 371 printk(KERN_ERR "%s: device_create_file failed\n", 372 - __FUNCTION__); 372 + __func__); 373 373 goto error_unreg; 374 374 } 375 375 ··· 399 399 *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL); 400 400 if (!firmware) { 401 401 printk(KERN_ERR "%s: kmalloc(struct firmware) failed\n", 402 - __FUNCTION__); 402 + __func__); 403 403 retval = -ENOMEM; 404 404 goto out; 405 405 } ··· 570 570 int error; 571 571 error = class_register(&firmware_class); 572 572 if (error) { 573 - printk(KERN_ERR "%s: class_register failed\n", __FUNCTION__); 573 + printk(KERN_ERR "%s: class_register failed\n", __func__); 574 574 return error; 575 575 } 576 576 error = class_create_file(&firmware_class, &class_attr_timeout); 577 577 if (error) { 578 578 printk(KERN_ERR "%s: class_create_file failed\n", 579 - __FUNCTION__); 579 + __func__); 580 580 class_unregister(&firmware_class); 581 581 } 582 582 return error;

+2 -2

drivers/base/memory.c

··· 186 186 break; 187 187 default: 188 188 printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n", 189 - __FUNCTION__, mem, action, action); 189 + __func__, mem, action, action); 190 190 WARN_ON(1); 191 191 ret = -EINVAL; 192 192 } ··· 444 444 ret = err; 445 445 out: 446 446 if (ret) 447 - printk(KERN_ERR "%s() failed: %d\n", __FUNCTION__, ret); 447 + printk(KERN_ERR "%s() failed: %d\n", __func__, ret); 448 448 return ret; 449 449 }

+1 -1

drivers/base/sys.c

··· 195 195 } 196 196 } else { 197 197 err = -EINVAL; 198 - printk(KERN_ERR "%s: invalid device class\n", __FUNCTION__); 198 + printk(KERN_ERR "%s: invalid device class\n", __func__); 199 199 WARN_ON(1); 200 200 } 201 201 mutex_unlock(&sysdev_drivers_lock);