Refactor all avirt_ symbols to have have snd prefix, as per Linux sound

This will aid the eventual migration the the upstream mainline Linux kernel
Fix some checkpatch warnings, and other compiler warnings

Signed-off-by: Mark Farrugia <mark.farrugia@fiberdyne.com.au>

1 files changed, 99 insertions, 98 deletions

diff --git a/core.c b/core.c
index 08381e5..aacc0a1 100644
--- a/core.c
+++ b/core.c
@@ -3,7 +3,7 @@
  * AVIRT - ALSA Virtual Soundcard
  *
  * Copyright (c) 2010-2018 Fiberdyne Systems Pty Ltd
- * 
+ *
  * core.c - AVIRT core internals
  */
 
@@ -27,44 +27,43 @@ MODULE_LICENSE("GPL v2");
 
 #define SND_AVIRTUAL_DRIVER "snd_avirt"
 
-extern struct snd_pcm_ops pcm_ops;
-
-static struct avirt_core core = {
+static struct snd_avirt_core core = {
 	.stream_count = 0,
 	.streams_sealed = false,
 };
 
-struct avirt_coreinfo coreinfo = {
-	.version = {0, 0, 1},
+struct snd_avirt_coreinfo coreinfo = {
+	.version = { 0, 0, 1 },
 };
 
 static LIST_HEAD(audiopath_list);
 
-struct avirt_audiopath_obj {
+struct snd_avirt_audiopath_obj {
 	struct kobject kobj;
 	struct list_head list;
-	struct avirt_audiopath *path;
+	struct snd_avirt_audiopath *path;
 };
 
-static struct kset *avirt_audiopath_kset;
+static struct kset *snd_avirt_audiopath_kset;
 static struct kobject *kobj;
 
-#define to_audiopath_obj(d) container_of(d, struct avirt_audiopath_obj, kobj)
-#define to_audiopath_attr(a)                                                   \
-	container_of(a, struct avirt_audiopath_attribute, attr)
+#define to_audiopath_obj(d) \
+	container_of(d, struct snd_avirt_audiopath_obj, kobj)
+#define to_audiopath_attr(a) \
+	container_of(a, struct snd_avirt_audiopath_attribute, attr)
 
 /**
- * struct avirt_audiopath_attribute - access the attributes of Audio Path
+ * struct snd_avirt_audiopath_attribute - access the attributes of Audio Path
  * @attr: attributes of an Audio Path
  * @show: pointer to the show function
  * @store: pointer to the store function
  */
-struct avirt_audiopath_attribute {
+struct snd_avirt_audiopath_attribute {
 	struct attribute attr;
-	ssize_t (*show)(struct avirt_audiopath_obj *d,
-			struct avirt_audiopath_attribute *attr, char *buf);
-	ssize_t (*store)(struct avirt_audiopath_obj *d,
-			 struct avirt_audiopath_attribute *attr,
+	ssize_t (*show)(struct snd_avirt_audiopath_obj *d,
+			struct snd_avirt_audiopath_attribute *attr, char *buf);
+	ssize_t (*store)(struct snd_avirt_audiopath_obj *d,
+			 struct snd_avirt_audiopath_attribute *attr,
 			 const char *buf, size_t count);
 };
 
@@ -77,8 +76,8 @@ struct avirt_audiopath_attribute {
 static ssize_t audiopath_attr_show(struct kobject *kobj, struct attribute *attr,
 				   char *buf)
 {
-	struct avirt_audiopath_attribute *audiopath_attr;
-	struct avirt_audiopath_obj *audiopath_obj;
+	struct snd_avirt_audiopath_attribute *audiopath_attr;
+	struct snd_avirt_audiopath_obj *audiopath_obj;
 
 	audiopath_attr = to_audiopath_attr(attr);
 	audiopath_obj = to_audiopath_obj(kobj);
@@ -100,8 +99,8 @@ static ssize_t audiopath_attr_store(struct kobject *kobj,
 				    struct attribute *attr, const char *buf,
 				    size_t len)
 {
-	struct avirt_audiopath_attribute *audiopath_attr;
-	struct avirt_audiopath_obj *audiopath_obj;
+	struct snd_avirt_audiopath_attribute *audiopath_attr;
+	struct snd_avirt_audiopath_obj *audiopath_obj;
 
 	audiopath_attr = to_audiopath_attr(attr);
 	audiopath_obj = to_audiopath_obj(kobj);
@@ -111,84 +110,88 @@ static ssize_t audiopath_attr_store(struct kobject *kobj,
 	return audiopath_attr->store(audiopath_obj, audiopath_attr, buf, len);
 }
 
-static const struct sysfs_ops avirt_audiopath_sysfs_ops = {
+static const struct sysfs_ops snd_avirt_audiopath_sysfs_ops = {
 	.show = audiopath_attr_show,
 	.store = audiopath_attr_store,
 };
 
 /**
- * avirt_audiopath_release - Audio Path release function
+ * snd_avirt_audiopath_release - Audio Path release function
  * @kobj: pointer to Audio Paths's kobject
  */
-static void avirt_audiopath_release(struct kobject *kobj)
+static void snd_avirt_audiopath_release(struct kobject *kobj)
 {
-	struct avirt_audiopath_obj *audiopath_obj = to_audiopath_obj(kobj);
+	struct snd_avirt_audiopath_obj *audiopath_obj = to_audiopath_obj(kobj);
 
 	kfree(audiopath_obj);
 }
 
-static ssize_t audiopath_name_show(struct avirt_audiopath_obj *audiopath_obj,
-				   struct avirt_audiopath_attribute *attr,
-				   char *buf)
+static ssize_t
+	audiopath_name_show(struct snd_avirt_audiopath_obj *audiopath_obj,
+			    struct snd_avirt_audiopath_attribute *attr,
+			    char *buf)
 {
 	return sprintf(buf, "%s\n", audiopath_obj->path->name);
 }
 
-static ssize_t audiopath_version_show(struct avirt_audiopath_obj *audiopath_obj,
-				      struct avirt_audiopath_attribute *attr,
-				      char *buf)
+static ssize_t
+	audiopath_version_show(struct snd_avirt_audiopath_obj *audiopath_obj,
+			       struct snd_avirt_audiopath_attribute *attr,
+			       char *buf)
 {
-	struct avirt_audiopath *audiopath = audiopath_obj->path;
+	struct snd_avirt_audiopath *audiopath = audiopath_obj->path;
 
 	return sprintf(buf, "%d.%d.%d\n", audiopath->version[0],
 		       audiopath->version[1], audiopath->version[2]);
 }
 
-static struct avirt_audiopath_attribute avirt_audiopath_attrs[] = {
+static struct snd_avirt_audiopath_attribute snd_avirt_audiopath_attrs[] = {
 	__ATTR_RO(audiopath_name),
 	__ATTR_RO(audiopath_version),
 };
 
-static struct attribute *avirt_audiopath_def_attrs[] = {
-	&avirt_audiopath_attrs[0].attr,
-	&avirt_audiopath_attrs[1].attr,
+static struct attribute *snd_avirt_audiopath_def_attrs[] = {
+	&snd_avirt_audiopath_attrs[0].attr,
+	&snd_avirt_audiopath_attrs[1].attr,
 	NULL,
 };
 
-static struct kobj_type avirt_audiopath_ktype = {
-	.sysfs_ops = &avirt_audiopath_sysfs_ops,
-	.release = avirt_audiopath_release,
-	.default_attrs = avirt_audiopath_def_attrs,
+static struct kobj_type snd_avirt_audiopath_ktype = {
+	.sysfs_ops = &snd_avirt_audiopath_sysfs_ops,
+	.release = snd_avirt_audiopath_release,
+	.default_attrs = snd_avirt_audiopath_def_attrs,
 };
 
 /**
- * create_avirt_audiopath_obj - creates an Audio Path object
+ * create_snd_avirt_audiopath_obj - creates an Audio Path object
  * @uid: Unique ID of the Audio Path
  *
  * This creates an Audio Path object and assigns the kset and registers
  * it with sysfs.
  * @return: Pointer to the Audio Path object or NULL if it failed.
  */
-static struct avirt_audiopath_obj *create_avirt_audiopath_obj(const char *uid)
+static struct snd_avirt_audiopath_obj *
+	create_snd_avirt_audiopath_obj(const char *uid)
 {
-	struct avirt_audiopath_obj *avirt_audiopath;
+	struct snd_avirt_audiopath_obj *snd_avirt_audiopath;
 	int retval;
 
-	avirt_audiopath = kzalloc(sizeof(*avirt_audiopath), GFP_KERNEL);
-	if (!avirt_audiopath)
+	snd_avirt_audiopath = kzalloc(sizeof(*snd_avirt_audiopath), GFP_KERNEL);
+	if (!snd_avirt_audiopath)
 		return NULL;
-	avirt_audiopath->kobj.kset = avirt_audiopath_kset;
-	retval = kobject_init_and_add(&avirt_audiopath->kobj,
-				      &avirt_audiopath_ktype, kobj, "%s", uid);
+	snd_avirt_audiopath->kobj.kset = snd_avirt_audiopath_kset;
+	retval = kobject_init_and_add(&snd_avirt_audiopath->kobj,
+				      &snd_avirt_audiopath_ktype, kobj, "%s",
+				      uid);
 	if (retval) {
-		kobject_put(&avirt_audiopath->kobj);
+		kobject_put(&snd_avirt_audiopath->kobj);
 		return NULL;
 	}
-	kobject_uevent(&avirt_audiopath->kobj, KOBJ_ADD);
-	return avirt_audiopath;
+	kobject_uevent(&snd_avirt_audiopath->kobj, KOBJ_ADD);
+	return snd_avirt_audiopath;
 }
 
-static struct snd_pcm *pcm_create(struct avirt_stream *stream)
+static struct snd_pcm *pcm_create(struct snd_avirt_stream *stream)
 {
 	bool playback = false, capture = false;
 	struct snd_pcm *pcm;
@@ -224,25 +227,24 @@ static struct snd_pcm *pcm_create(struct avirt_stream *stream)
 }
 
 /**
- * destroy_avirt_audiopath_obj - destroys an Audio Path object
+ * destroy_snd_avirt_audiopath_obj - destroys an Audio Path object
  * @name: the Audio Path object
  */
-static void destroy_avirt_audiopath_obj(struct avirt_audiopath_obj *p)
+static void destroy_snd_avirt_audiopath_obj(struct snd_avirt_audiopath_obj *p)
 {
 	kobject_put(&p->kobj);
 }
 
 /**
- * avirt_audiopath_get - retrieves the Audio Path by its UID
+ * snd_avirt_audiopath_get - retrieves the Audio Path by its UID
  * @uid: Unique ID for the Audio Path
  * @return: Corresponding Audio Path
  */
-struct avirt_audiopath *avirt_audiopath_get(const char *uid)
+struct snd_avirt_audiopath *snd_avirt_audiopath_get(const char *uid)
 {
-	struct avirt_audiopath_obj *ap_obj;
+	struct snd_avirt_audiopath_obj *ap_obj;
 
-	list_for_each_entry(ap_obj, &audiopath_list, list)
-	{
+	list_for_each_entry(ap_obj, &audiopath_list, list) {
 		// pr_info("get_ap %s\n", ap_obj->path->uid);
 		if (!strcmp(ap_obj->path->uid, uid))
 			return ap_obj->path;
@@ -252,22 +254,22 @@ struct avirt_audiopath *avirt_audiopath_get(const char *uid)
 }
 
 /**
- * avirt_audiopath_register - register Audio Path with ALSA virtual driver
+ * snd_avirt_audiopath_register - register Audio Path with AVIRT
  * @audiopath: Audio Path to be registered
  * @core: ALSA virtual driver core info
  * @return: 0 on success or error code otherwise
  */
-int avirt_audiopath_register(struct avirt_audiopath *audiopath,
-			     struct avirt_coreinfo **info)
+int snd_avirt_audiopath_register(struct snd_avirt_audiopath *audiopath,
+				 struct snd_avirt_coreinfo **info)
 {
-	struct avirt_audiopath_obj *audiopath_obj;
+	struct snd_avirt_audiopath_obj *audiopath_obj;
 
 	if (!audiopath) {
 		D_ERRORK("Audio Path is NULL!");
 		return -EINVAL;
 	}
 
-	audiopath_obj = create_avirt_audiopath_obj(audiopath->uid);
+	audiopath_obj = create_snd_avirt_audiopath_obj(audiopath->uid);
 	if (!audiopath_obj) {
 		D_INFOK("Failed to alloc driver object");
 		return -ENOMEM;
@@ -288,16 +290,16 @@ int avirt_audiopath_register(struct avirt_audiopath *audiopath,
 
 	return 0;
 }
-EXPORT_SYMBOL_GPL(avirt_audiopath_register);
+EXPORT_SYMBOL_GPL(snd_avirt_audiopath_register);
 
 /**
- * avirt_audiopath_deregister - deregister Audio Path with ALSA virtual driver
+ * snd_avirt_audiopath_deregister - deregister Audio Path with AVIRT
  * @audiopath: Audio Path to be deregistered
  * @return: 0 on success or error code otherwise
  */
-int avirt_audiopath_deregister(struct avirt_audiopath *audiopath)
+int snd_avirt_audiopath_deregister(struct snd_avirt_audiopath *audiopath)
 {
-	struct avirt_audiopath_obj *audiopath_obj;
+	struct snd_avirt_audiopath_obj *audiopath_obj;
 
 	// Check if audio path is registered
 	if (!audiopath) {
@@ -312,32 +314,31 @@ int avirt_audiopath_deregister(struct avirt_audiopath *audiopath)
 	}
 
 	list_del(&audiopath_obj->list);
-	destroy_avirt_audiopath_obj(audiopath_obj);
+	destroy_snd_avirt_audiopath_obj(audiopath_obj);
 	D_INFOK("Deregistered Audio Path %s", audiopath->uid);
 
 	return 0;
 }
-EXPORT_SYMBOL_GPL(avirt_audiopath_deregister);
+EXPORT_SYMBOL_GPL(snd_avirt_audiopath_deregister);
 
 /**
- * avirt_stream_count - get the stream count for the given direction
+ * snd_avirt_stream_count - get the stream count for the given direction
  * @direction: The direction to get the stream count for
  * @return: The stream count
  */
-int avirt_stream_count(unsigned int direction)
+int snd_avirt_stream_count(unsigned int direction)
 {
 	struct list_head *entry;
 	struct config_item *item;
-	struct avirt_stream *stream;
+	struct snd_avirt_stream *stream;
 	unsigned int count = 0;
 
 	if (direction > 1)
 		return -ERANGE;
 
-	list_for_each(entry, &core.stream_group->cg_children)
-	{
+	list_for_each(entry, &core.stream_group->cg_children) {
 		item = container_of(entry, struct config_item, ci_entry);
-		stream = avirt_stream_from_config_item(item);
+		stream = snd_avirt_stream_from_config_item(item);
 		if (!stream)
 			return -EFAULT;
 		if (stream->direction == direction)
@@ -346,18 +347,19 @@ int avirt_stream_count(unsigned int direction)
 
 	return count;
 }
-EXPORT_SYMBOL_GPL(avirt_stream_count);
+EXPORT_SYMBOL_GPL(snd_avirt_stream_count);
 
 /**
- * __avirt_stream_create - Create audio stream, including it's ALSA PCM device
+ * snd_avirt_stream_create - Create audio stream, including it's ALSA PCM device
  * @name: The name designated to the audio stream
  * @direction: The PCM direction (SNDRV_PCM_STREAM_PLAYBACK or
  *             SNDRV_PCM_STREAM_CAPTURE)
  * @return: The newly created audio stream if successful, or an error pointer
  */
-struct avirt_stream *__avirt_stream_create(const char *name, int direction)
+struct snd_avirt_stream *snd_avirt_stream_create(const char *name,
+						 int direction)
 {
-	struct avirt_stream *stream;
+	struct snd_avirt_stream *stream;
 
 	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
 	if (!stream)
@@ -374,11 +376,11 @@ struct avirt_stream *__avirt_stream_create(const char *name, int direction)
 	return stream;
 }
 
-int __avirt_streams_seal(void)
+int snd_avirt_streams_seal(void)
 {
 	int err = 0;
-	struct avirt_audiopath_obj *ap_obj;
-	struct avirt_stream *stream;
+	struct snd_avirt_audiopath_obj *ap_obj;
+	struct snd_avirt_stream *stream;
 	struct config_item *item;
 	struct list_head *entry;
 
@@ -387,9 +389,9 @@ int __avirt_streams_seal(void)
 		return -1;
 	}
 
-	list_for_each (entry, &core.stream_group->cg_children) {
+	list_for_each(entry, &core.stream_group->cg_children) {
 		item = container_of(entry, struct config_item, ci_entry);
-		stream = avirt_stream_from_config_item(item);
+		stream = snd_avirt_stream_from_config_item(item);
 		if (!stream)
 			return -EFAULT;
 		stream->pcm = pcm_create(stream);
@@ -397,7 +399,7 @@ int __avirt_streams_seal(void)
 			return (PTR_ERR(stream->pcm));
 	}
 
-	list_for_each_entry (ap_obj, &audiopath_list, list) {
+	list_for_each_entry(ap_obj, &audiopath_list, list) {
 		D_INFOK("configure() AP uid: %s", ap_obj->path->uid);
 		ap_obj->path->configure(core.card, core.stream_group,
 					core.stream_count);
@@ -414,14 +416,14 @@ int __avirt_streams_seal(void)
 	return err;
 }
 
-bool __avirt_streams_sealed(void)
+bool snd_avirt_streams_sealed(void)
 {
 	return core.streams_sealed;
 }
 
-struct avirt_stream *__avirt_stream_find_by_device(unsigned int device)
+struct snd_avirt_stream *snd_avirt_stream_find_by_device(unsigned int device)
 {
-	struct avirt_stream *stream;
+	struct snd_avirt_stream *stream;
 	struct config_item *item;
 	struct list_head *entry;
 
@@ -430,10 +432,9 @@ struct avirt_stream *__avirt_stream_find_by_device(unsigned int device)
 		return ERR_PTR(-EINVAL);
 	}
 
-	list_for_each(entry, &core.stream_group->cg_children)
-	{
+	list_for_each(entry, &core.stream_group->cg_children) {
 		item = container_of(entry, struct config_item, ci_entry);
-		stream = avirt_stream_from_config_item(item);
+		stream = snd_avirt_stream_from_config_item(item);
 		if (!stream)
 			return ERR_PTR(-EFAULT);
 		if (stream->device == device)
@@ -478,14 +479,14 @@ static int __init core_init(void)
 	strncpy(core.card->longname, "A virtual sound card driver for ALSA",
 		80);
 
-	avirt_audiopath_kset =
+	snd_avirt_audiopath_kset =
 		kset_create_and_add("audiopaths", NULL, &core.dev->kobj);
-	if (!avirt_audiopath_kset) {
+	if (!snd_avirt_audiopath_kset) {
 		err = -ENOMEM;
 		goto exit_snd_card;
 	}
 
-	err = __avirt_configfs_init(&core);
+	err = snd_avirt_configfs_init(&core);
 	if (err < 0)
 		goto exit_snd_card;
 
@@ -506,9 +507,9 @@ exit_class:
  */
 static void __exit core_exit(void)
 {
-	__avirt_configfs_exit(&core);
+	snd_avirt_configfs_exit(&core);
 
-	kset_unregister(avirt_audiopath_kset);
+	kset_unregister(snd_avirt_audiopath_kset);
 	snd_card_free(core.card);
 	device_destroy(core.avirt_class, 0);
 	class_destroy(core.avirt_class);