Changeset 445 for GPL/trunk/lib32/misc.c

Timestamp:

Jun 8, 2009, 11:51:32 AM (16 years ago)

Author:

Paul Smedley

Message:

More code tidyups, remove some unnecessary #ifndef TARGET_OS2 by adding some more stub functions

File:

• GPL/trunk/lib32/misc.c (modified) (2 diffs)

GPL/trunk/lib32/misc.c

@@ -36 +36 @@
 #include <linux\utsname.h>
 #include <linux\module.h>
+#include <linux/workqueue.h>
+#include <linux/firmware.h>
 #include <dbgos2.h>
 #include <printfos2.h>
@@ -219 +221 @@
 //******************************************************************************
 //******************************************************************************
+static void __x_queue_work(struct workqueue_struct *wq, struct work_struct *work)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wq->lock, flags);
+        work->wq_data = wq;
+        list_add_tail(&work->entry, &wq->worklist);
+        wake_up(&wq->more_work);
+        spin_unlock_irqrestore(&wq->lock, flags);
+}
+//******************************************************************************
+//******************************************************************************
+int queue_work(struct workqueue_struct *wq, struct work_struct *work)
+{
+        if (!test_and_set_bit(0, &work->pending)) {
+                __x_queue_work(wq, work);
+                return 1;
+        }
+        return 0;
+}
+//******************************************************************************
+//******************************************************************************
+void flush_workqueue(struct workqueue_struct *wq)
+{
+        if (wq->task == current) {
+                run_workqueue(wq);
+        } else {
+                wait_queue_t wait;
+
+                init_waitqueue_entry(&wait, current);
+                set_current_state(TASK_UNINTERRUPTIBLE);
+                spin_lock_irq(&wq->lock);
+                add_wait_queue(&wq->work_done, &wait);
+                while (!list_empty(&wq->worklist)) {
+                        spin_unlock_irq(&wq->lock);
+                        schedule();
+                        spin_lock_irq(&wq->lock);
+                }
+                set_current_state(TASK_RUNNING);
+                remove_wait_queue(&wq->work_done, &wait);
+                spin_unlock_irq(&wq->lock);
+        }
+}
+//******************************************************************************
+//******************************************************************************
+static void run_workqueue(struct workqueue_struct *wq)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wq->lock, flags);
+        while (!list_empty(&wq->worklist)) {
+                struct work_struct *work = list_entry(wq->worklist.next,
+                                                      struct work_struct, entry);
+                void (*f) (void *) = work->func;
+                void *data = work->data;
+
+                list_del_init(wq->worklist.next);
+                spin_unlock_irqrestore(&wq->lock, flags);
+                clear_bit(0, &work->pending);
+                f(data);
+                spin_lock_irqsave(&wq->lock, flags);
+                wake_up(&wq->work_done);
+        }
+        spin_unlock_irqrestore(&wq->lock, flags);
+}
+//******************************************************************************
+//******************************************************************************
+struct workqueue_struct *create_workqueue(const char *name)
+{
+        struct workqueue_struct *wq;
+        
+        BUG_ON(strlen(name) > 10);
+        
+        wq = kmalloc(sizeof(*wq), GFP_KERNEL);
+        if (!wq)
+                return NULL;
+        memset(wq, 0, sizeof(*wq));
+        
+        spin_lock_init(&wq->lock);
+        INIT_LIST_HEAD(&wq->worklist);
+        init_waitqueue_head(&wq->more_work);
+        init_waitqueue_head(&wq->work_done);
+#ifndef TARGET_OS2
+        init_completion(&wq->thread_exited);
+        wq->name = name;
+        wq->task_pid = kernel_thread(xworker_thread, wq, 0);
+        if (wq->task_pid < 0) {
+                printk(KERN_ERR "snd: failed to start thread %s\n", name);
+                snd_compat_destroy_workqueue(wq);
+                wq = NULL;
+        }
+        wq->task = find_task_by_pid(wq->task_pid);
+#endif
+        return wq;
+}
+//******************************************************************************
+//******************************************************************************
+void destroy_workqueue(struct workqueue_struct *wq)
+{
+#ifndef TARGET_OS2
+        snd_compat_flush_workqueue(wq);
+        kill_proc(wq->task_pid, SIGKILL, 1);
+        if (wq->task_pid >= 0)
+                wait_for_completion(&wq->thread_exited);
+#endif
+        kfree(wq);
+}
+
+//******************************************************************************
+//******************************************************************************
+char *kstrdup(const char *s, unsigned int __nocast gfp_flags)
+{
+        int len;
+        char *buf;
+
+        if (!s) return NULL;
+
+        len = strlen(s) + 1;
+        buf = kmalloc(len, gfp_flags);
+        if (buf)
+                memcpy(buf, s, len);
+        return buf;
+}
+//******************************************************************************
+//******************************************************************************
+int mod_firmware_load(const char *fn, char **fp)
+{
+    return 0;
+}
+//******************************************************************************
+//******************************************************************************
+static int snd_try_load_firmware(const char *path, const char *name,
+                                 struct firmware *firmware)
+{
+        char filename[30 + FIRMWARE_NAME_MAX];
+
+        sprintf(filename, "%s/%s", path, name);
+        firmware->size = mod_firmware_load(filename, (char **)&firmware->data);
+        if (firmware->size)
+                printk(KERN_INFO "Loaded '%s'.", filename);
+        return firmware->size;
+}
+//******************************************************************************
+//******************************************************************************
+int request_firmware(const struct firmware **fw, const char *name,
+                     struct device *device)
+{
+        struct firmware *firmware;
+
+        *fw = NULL;
+        firmware = kmalloc(sizeof *firmware, GFP_KERNEL);
+        if (!firmware)
+                return -ENOMEM;
+        if (!snd_try_load_firmware("/lib/firmware", name, firmware) &&
+            !snd_try_load_firmware("/lib/hotplug/firmware", name, firmware) &&
+            !snd_try_load_firmware("/usr/lib/hotplug/firmware", name, firmware)) {
+                kfree(firmware);
+                return -EIO;
+        }
+        *fw = firmware;
+        return 0;
+}
+//******************************************************************************
+//******************************************************************************
+void release_firmware(const struct firmware *fw)
+{
+        if (fw) {
+                vfree(fw->data);
+                kfree(fw);
+        }
+}
+//******************************************************************************
+//******************************************************************************
+void *memdup_user(void __user *src, size_t len)
+{
+        void *p = kmalloc(len, GFP_KERNEL);
+        if (!p)
+                return ERR_PTR(-ENOMEM);
+        if (copy_from_user(p, src, len)) {
+                kfree(p);
+                return ERR_PTR(-EFAULT);
+        }
+        return p;
+}
+//******************************************************************************
+//******************************************************************************