source: GPL/trunk/lib32/misc.c@ 521

Last change on this file since 521 was 521, checked in by David Azarewicz, 15 years ago

Debug statement cleanup
File size: 14.1 KB
Line 
1/* $Id: misc.c,v 1.1.1.1 2003/07/02 13:57:02 eleph Exp $ */
2/*
3 * OS/2 implementation of misc. Linux kernel services
4 *
5 * (C) 2000-2002 InnoTek Systemberatung GmbH
6 * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 * hweight32 based on Linux code (bitops.h)
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the Free
22 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
23 * USA.
24 *
25 */
26#include <limits.h>
27#include "linux.h"
28#include <linux/init.h>
29#include <linux/fs.h>
30#include <linux/poll.h>
31#define CONFIG_PROC_FS
32#include <linux/proc_fs.h>
33#include <asm/uaccess.h>
34#include <asm/hardirq.h>
35#include <linux\ioport.h>
36#include <linux\utsname.h>
37#include <linux\module.h>
38#include <linux/workqueue.h>
39#include <linux/firmware.h>
40#include <dbgos2.h>
41
42void StringOut(char *DbgStr);
43
44struct new_utsname system_utsname = {0};
45struct resource ioport_resource = {NULL, 0, 0, IORESOURCE_IO, NULL, NULL, NULL};
46struct resource iomem_resource = {NULL, 0, 0, IORESOURCE_MEM, NULL, NULL, NULL};
47mem_map_t *mem_map = 0;
48int this_module[64] = {0};
49
50#include <stdarg.h>
51
52char szLastALSAError1[128] = {0};
53char szOverrunTest1 = 0xCC;
54char szLastALSAError2[128] = {0};
55char szOverrunTest2 = 0xCC;
56int iLastError = 0;
57
58//******************************************************************************
59//Save error message in szLastALSAError; if card init failed, then we will
60//print it in drv32\init.cpp
61//******************************************************************************
62int printk(const char * fmt, ...)
63{
64 va_list argptr; /* -> variable argument list */
65
66 char *pszLastALSAError;
67
68 pszLastALSAError= iLastError ? szLastALSAError2 : szLastALSAError1;
69
70 va_start(argptr, fmt); /* get pointer to argument list */
71 vsprintf(pszLastALSAError, fmt, argptr);
72// strcat(pszLastALSAError, "\r");
73 va_end(argptr); /* done with variable arguments */
74
75 if(szOverrunTest1 != 0xCC || szOverrunTest2 != 0xCC) {
76 DebugInt3();
77 }
78
79 StringOut(pszLastALSAError);
80// rprintf( (pszLastALSAError) );
81 if(++iLastError > 1) {
82 iLastError = 0;
83 }
84 return 0;
85}
86//******************************************************************************
87//******************************************************************************
88void schedule(void)
89{
90
91}
92//******************************************************************************
93//******************************************************************************
94void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
95{
96
97}
98//******************************************************************************
99//******************************************************************************
100int __check_region(struct resource *a, unsigned long b, unsigned long c)
101{
102 DebugInt3();
103 return 0;
104}
105
106/* --------------------------------------------------------------------- */
107/*
108 * hweightN: returns the hamming weight (i.e. the number
109 * of bits set) of a N-bit word
110 */
111
112#ifdef hweight32
113#undef hweight32
114#endif
115
116unsigned int hweight32(unsigned int w)
117{
118 unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
119 res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
120 res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
121 res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
122 return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
123}
124//******************************************************************************
125//******************************************************************************
126#if 0
127mem_map_t *virt_to_page(int x)
128{
129 static mem_map_t map = {0};
130 return &map;
131}
132#endif
133//******************************************************************************
134//******************************************************************************
135struct proc_dir_entry proc_root = {0};
136//******************************************************************************
137//******************************************************************************
138struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
139 struct proc_dir_entry *parent)
140{
141 struct proc_dir_entry *proc;
142 proc = (struct proc_dir_entry *)kmalloc(sizeof(struct proc_dir_entry), 0);
143 memset(proc, 0, sizeof(struct proc_dir_entry));
144
145 proc->name = name;
146 proc->mode = mode;
147 proc->parent = parent;
148
149 return proc;
150}
151//******************************************************************************
152//******************************************************************************
153void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
154{
155 return; //memory leak
156}
157//******************************************************************************
158//******************************************************************************
159int proc_register(struct proc_dir_entry *parent, struct proc_dir_entry *proc)
160{
161 return 0;
162}
163//******************************************************************************
164//******************************************************************************
165int proc_unregister(struct proc_dir_entry *proc, int bla)
166{
167 return 0;
168}
169//******************************************************************************
170//******************************************************************************
171int fasync_helper(int a, struct file *b, int c, struct fasync_struct **d)
172{
173 return 0;
174}
175//******************************************************************************
176//******************************************************************************
177void kill_fasync(struct fasync_struct *a, int b, int c)
178{
179}
180//******************************************************************************
181//******************************************************************************
182int request_dma(unsigned int dmanr, const char * device_id) /* reserve a DMA channel */
183{
184 DebugInt3();
185 return 0;
186}
187//******************************************************************************
188//******************************************************************************
189void free_dma(unsigned int dmanr)
190{
191 DebugInt3();
192}
193//******************************************************************************
194/* enable/disable a specific DMA channel */
195//******************************************************************************
196void enable_dma(unsigned int dmanr)
197{
198 DebugInt3();
199}
200//******************************************************************************
201//******************************************************************************
202void disable_dma(unsigned int dmanr)
203{
204 DebugInt3();
205}
206//******************************************************************************
207static struct notifier_block *reboot_notify_list = NULL;
208// No need to implement this right now. The ESS Maestro 3 driver uses it
209// to call pci_unregister_driver, which is always called from the shutdown
210// notification sent by OS2.
211// Same goes for es1968 & Yamaha's DS1/DS1E.
212//******************************************************************************
213int register_reboot_notifier(struct notifier_block *pnblock)
214{
215 return 0;
216}
217//******************************************************************************
218//******************************************************************************
219int unregister_reboot_notifier(struct notifier_block *pnblock)
220{
221 return 0;
222}
223//******************************************************************************
224//******************************************************************************
225static void __x_queue_work(struct workqueue_struct *wq, struct work_struct *work)
226{
227 unsigned long flags;
228
229 spin_lock_irqsave(&wq->lock, flags);
230 work->wq_data = wq;
231 list_add_tail(&work->entry, &wq->worklist);
232 wake_up(&wq->more_work);
233 spin_unlock_irqrestore(&wq->lock, flags);
234}
235//******************************************************************************
236//******************************************************************************
237int queue_work(struct workqueue_struct *wq, struct work_struct *work)
238{
239 if (!test_and_set_bit(0, &work->pending)) {
240 __x_queue_work(wq, work);
241 return 1;
242 }
243 return 0;
244}
245//******************************************************************************
246//******************************************************************************
247static void run_workqueue(struct workqueue_struct *wq)
248{
249 unsigned long flags;
250
251 spin_lock_irqsave(&wq->lock, flags);
252 while (!list_empty(&wq->worklist)) {
253 struct work_struct *work = list_entry(wq->worklist.next,
254 struct work_struct, entry);
255 void (*f) (void *) = work->func;
256 void *data = work->data;
257
258 list_del_init(wq->worklist.next);
259 spin_unlock_irqrestore(&wq->lock, flags);
260 clear_bit(0, &work->pending);
261 f(data);
262 spin_lock_irqsave(&wq->lock, flags);
263 wake_up(&wq->work_done);
264 }
265 spin_unlock_irqrestore(&wq->lock, flags);
266}
267//******************************************************************************
268//******************************************************************************
269void flush_workqueue(struct workqueue_struct *wq)
270{
271 if (wq->task == current) {
272 run_workqueue(wq);
273 } else {
274 wait_queue_t wait;
275
276 init_waitqueue_entry(&wait, current);
277 set_current_state(TASK_UNINTERRUPTIBLE);
278 spin_lock_irq(&wq->lock);
279 add_wait_queue(&wq->work_done, &wait);
280 while (!list_empty(&wq->worklist)) {
281 spin_unlock_irq(&wq->lock);
282 schedule();
283 spin_lock_irq(&wq->lock);
284 }
285 set_current_state(TASK_RUNNING);
286 remove_wait_queue(&wq->work_done, &wait);
287 spin_unlock_irq(&wq->lock);
288 }
289}
290//******************************************************************************
291//******************************************************************************
292struct workqueue_struct *create_workqueue(const char *name)
293{
294 struct workqueue_struct *wq;
295
296 BUG_ON(strlen(name) > 10);
297
298 wq = kmalloc(sizeof(*wq), GFP_KERNEL);
299 if (!wq)
300 return NULL;
301 memset(wq, 0, sizeof(*wq));
302
303 spin_lock_init(&wq->lock);
304 INIT_LIST_HEAD(&wq->worklist);
305 init_waitqueue_head(&wq->more_work);
306 init_waitqueue_head(&wq->work_done);
307#ifndef TARGET_OS2
308 init_completion(&wq->thread_exited);
309 wq->name = name;
310 wq->task_pid = kernel_thread(xworker_thread, wq, 0);
311 if (wq->task_pid < 0) {
312 printk(KERN_ERR "snd: failed to start thread %s\n", name);
313 snd_compat_destroy_workqueue(wq);
314 wq = NULL;
315 }
316 wq->task = find_task_by_pid(wq->task_pid);
317#endif
318 return wq;
319}
320//******************************************************************************
321//******************************************************************************
322void destroy_workqueue(struct workqueue_struct *wq)
323{
324#ifndef TARGET_OS2
325 snd_compat_flush_workqueue(wq);
326 kill_proc(wq->task_pid, SIGKILL, 1);
327 if (wq->task_pid >= 0)
328 wait_for_completion(&wq->thread_exited);
329#endif
330 kfree(wq);
331}
332
333//******************************************************************************
334//******************************************************************************
335char *kstrdup(const char *s, unsigned int __nocast gfp_flags)
336{
337 int len;
338 char *buf;
339
340 if (!s) return NULL;
341
342 len = strlen(s) + 1;
343 buf = kmalloc(len, gfp_flags);
344 if (buf)
345 memcpy(buf, s, len);
346 return buf;
347}
348//******************************************************************************
349//******************************************************************************
350int mod_firmware_load(const char *fn, char **fp)
351{
352 return 0;
353}
354//******************************************************************************
355//******************************************************************************
356static int snd_try_load_firmware(const char *path, const char *name,
357 struct firmware *firmware)
358{
359 char filename[30 + FIRMWARE_NAME_MAX];
360
361 sprintf(filename, "%s/%s", path, name);
362 firmware->size = mod_firmware_load(filename, (char **)&firmware->data);
363 if (firmware->size)
364 printk(KERN_INFO "Loaded '%s'.", filename);
365 return firmware->size;
366}
367//******************************************************************************
368//******************************************************************************
369int request_firmware(const struct firmware **fw, const char *name,
370 struct device *device)
371{
372 struct firmware *firmware;
373
374 *fw = NULL;
375 firmware = kmalloc(sizeof *firmware, GFP_KERNEL);
376 if (!firmware)
377 return -ENOMEM;
378 if (!snd_try_load_firmware("/lib/firmware", name, firmware) &&
379 !snd_try_load_firmware("/lib/hotplug/firmware", name, firmware) &&
380 !snd_try_load_firmware("/usr/lib/hotplug/firmware", name, firmware)) {
381 kfree(firmware);
382 return -EIO;
383 }
384 *fw = firmware;
385 return 0;
386}
387//******************************************************************************
388//******************************************************************************
389void release_firmware(const struct firmware *fw)
390{
391 if (fw) {
392 vfree(fw->data);
393 kfree(fw);
394 }
395}
396//******************************************************************************
397//******************************************************************************
398void *memdup_user(void __user *src, size_t len)
399{
400 void *p = kmalloc(len, GFP_KERNEL);
401 if (!p)
402 return ERR_PTR(-ENOMEM);
403 if (copy_from_user(p, src, len)) {
404 kfree(p);
405 return ERR_PTR(-EFAULT);
406 }
407 return p;
408}
409//******************************************************************************
410//******************************************************************************
411
Note: See TracBrowser for help on using the repository browser.