开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
dsp56k.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：13k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

dsp56k.c：源码内容
  1. /*
  2.  * The DSP56001 Device Driver, saviour of the Free World(tm)
  3.  *
  4.  * Authors: Fredrik Noring   <noring@nocrew.org>
  5.  *          lars brinkhoff   <lars@nocrew.org>
  6.  *          Tomas Berndtsson <tomas@nocrew.org>
  7.  *
  8.  * First version May 1996
  9.  *
  10.  * History:
  11.  *  97-01-29   Tomas Berndtsson,
  12.  *               Integrated with Linux 2.1.21 kernel sources.
  13.  *  97-02-15   Tomas Berndtsson,
  14.  *               Fixed for kernel 2.1.26
  15.  *
  16.  * BUGS:
  17.  *  Hmm... there must be something here :)
  18.  *
  19.  * Copyright (C) 1996,1997 Fredrik Noring, lars brinkhoff & Tomas Berndtsson
  20.  *
  21.  * This file is subject to the terms and conditions of the GNU General Public
  22.  * License.  See the file COPYING in the main directory of this archive
  23.  * for more details.
  24.  */
  26. #include <linux/module.h>
  27. #include <linux/version.h>
  28. #include <linux/slab.h> /* for kmalloc() and kfree() */
  29. #include <linux/sched.h> /* for struct wait_queue etc */
  30. #include <linux/major.h>
  31. #include <linux/types.h>
  32. #include <linux/errno.h>
  33. #include <linux/delay.h> /* guess what */
  34. #include <linux/fs.h>
  35. #include <linux/mm.h>
  36. #include <linux/init.h>
  37. #include <linux/devfs_fs_kernel.h>
  38. #include <linux/smp_lock.h>
  40. #include <asm/segment.h>
  41. #include <asm/atarihw.h>
  42. #include <asm/traps.h>
  43. #include <asm/uaccess.h> /* For put_user and get_user */
  45. #include <asm/dsp56k.h>
  47. /* minor devices */
  48. #define DSP56K_DEV_56001        0    /* The only device so far */
  50. #define TIMEOUT    10   /* Host port timeout in number of tries */
  51. #define MAXIO    2048   /* Maximum number of words before sleep */
  52. #define DSP56K_MAX_BINARY_LENGTH (3*64*1024)
  54. #define DSP56K_TX_INT_ON dsp56k_host_interface.icr |=  DSP56K_ICR_TREQ
  55. #define DSP56K_RX_INT_ON dsp56k_host_interface.icr |=  DSP56K_ICR_RREQ
  56. #define DSP56K_TX_INT_OFF dsp56k_host_interface.icr &= ~DSP56K_ICR_TREQ
  57. #define DSP56K_RX_INT_OFF dsp56k_host_interface.icr &= ~DSP56K_ICR_RREQ
  59. #define DSP56K_TRANSMIT (dsp56k_host_interface.isr & DSP56K_ISR_TXDE)
  60. #define DSP56K_RECEIVE (dsp56k_host_interface.isr & DSP56K_ISR_RXDF)
  62. #define wait_some(n) 
  63. { 
  64. set_current_state(TASK_INTERRUPTIBLE); 
  65. schedule_timeout(n); 
  66. }
  68. #define handshake(count, maxio, timeout, ENABLE, f) 
  69. { 
  70. long i, t, m; 
  71. while (count > 0) { 
  72. m = min_t(unsigned long, count, maxio); 
  73. for (i = 0; i < m; i++) { 
  74. for (t = 0; t < timeout && !ENABLE; t++) 
  75. wait_some(HZ/50); 
  76. if(!ENABLE) 
  77. return -EIO; 
  78. f; 
  79. } 
  80. count -= m; 
  81. if (m == maxio) wait_some(HZ/50); 
  82. } 
  83. }
  85. #define tx_wait(n) 
  86. { 
  87. int t; 
  88. for(t = 0; t < n && !DSP56K_TRANSMIT; t++) 
  89. wait_some(HZ/100); 
  90. if(!DSP56K_TRANSMIT) { 
  91. return -EIO; 
  92. } 
  93. }
  95. #define rx_wait(n) 
  96. { 
  97. int t; 
  98. for(t = 0; t < n && !DSP56K_RECEIVE; t++) 
  99. wait_some(HZ/100); 
  100. if(!DSP56K_RECEIVE) { 
  101. return -EIO; 
  102. } 
  103. }
  105. /* DSP56001 bootstrap code */
  106. static char bootstrap[] = {
  107. 0x0c, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  108. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  109. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  110. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  111. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  112. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  113. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  114. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  115. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  116. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  117. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  118. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  119. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  120. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  121. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  122. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  123. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  124. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  125. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  126. 0x00, 0x00, 0x60, 0xf4, 0x00, 0x00, 0x00, 0x4f, 0x61, 0xf4,
  127. 0x00, 0x00, 0x7e, 0xa9, 0x06, 0x2e, 0x80, 0x00, 0x00, 0x47,
  128. 0x07, 0xd8, 0x84, 0x07, 0x59, 0x84, 0x08, 0xf4, 0xa8, 0x00,
  129. 0x00, 0x04, 0x08, 0xf4, 0xbf, 0x00, 0x0c, 0x00, 0x00, 0xfe,
  130. 0xb8, 0x0a, 0xf0, 0x80, 0x00, 0x7e, 0xa9, 0x08, 0xf4, 0xa0,
  131. 0x00, 0x00, 0x01, 0x08, 0xf4, 0xbe, 0x00, 0x00, 0x00, 0x0a,
  132. 0xa9, 0x80, 0x00, 0x7e, 0xad, 0x08, 0x4e, 0x2b, 0x44, 0xf4,
  133. 0x00, 0x00, 0x00, 0x03, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x01,
  134. 0x0e, 0xa0, 0x00, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb5, 0x08,
  135. 0x50, 0x2b, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb8, 0x08, 0x46,
  136. 0x2b, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x02, 0x0a, 0xf0, 0xaa,
  137. 0x00, 0x7e, 0xc9, 0x20, 0x00, 0x45, 0x0a, 0xf0, 0xaa, 0x00,
  138. 0x7e, 0xd0, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xc6, 0x0a, 0xa9,
  139. 0x80, 0x00, 0x7e, 0xc4, 0x08, 0x58, 0x6b, 0x0a, 0xf0, 0x80,
  140. 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xcd, 0x0a,
  141. 0xa9, 0x80, 0x00, 0x7e, 0xcb, 0x08, 0x58, 0xab, 0x0a, 0xf0,
  142. 0x80, 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xd4,
  143. 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xd2, 0x08, 0x58, 0xeb, 0x0a,
  144. 0xf0, 0x80, 0x00, 0x7e, 0xad};
  145. static int sizeof_bootstrap = 375;
  148. static struct dsp56k_device {
  149. long in_use;
  150. long maxio, timeout;
  151. int tx_wsize, rx_wsize;
  152. } dsp56k;
  154. static int dsp56k_reset(void)
  155. {
  156. u_char status;
  158. /* Power down the DSP */
  159. sound_ym.rd_data_reg_sel = 14;
  160. status = sound_ym.rd_data_reg_sel & 0xef;
  161. sound_ym.wd_data = status;
  162. sound_ym.wd_data = status | 0x10;
  163.   
  164. udelay(10);
  165.   
  166. /* Power up the DSP */
  167. sound_ym.rd_data_reg_sel = 14;
  168. sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;
  170. return 0;
  171. }
  173. static int dsp56k_upload(u_char *bin, int len)
  174. {
  175. int i;
  176. u_char *p;
  178. dsp56k_reset();
  179.   
  180. p = bootstrap;
  181. for (i = 0; i < sizeof_bootstrap/3; i++) {
  182. /* tx_wait(10); */
  183. dsp56k_host_interface.data.b[1] = *p++;
  184. dsp56k_host_interface.data.b[2] = *p++;
  185. dsp56k_host_interface.data.b[3] = *p++;
  186. }
  187. for (; i < 512; i++) {
  188. /* tx_wait(10); */
  189. dsp56k_host_interface.data.b[1] = 0;
  190. dsp56k_host_interface.data.b[2] = 0;
  191. dsp56k_host_interface.data.b[3] = 0;
  192. }
  193.   
  194. for (i = 0; i < len; i++) {
  195. tx_wait(10);
  196. get_user(dsp56k_host_interface.data.b[1], bin++);
  197. get_user(dsp56k_host_interface.data.b[2], bin++);
  198. get_user(dsp56k_host_interface.data.b[3], bin++);
  199. }
  201. tx_wait(10);
  202. dsp56k_host_interface.data.l = 3;    /* Magic execute */
  204. return 0;
  205. }
  207. static ssize_t dsp56k_read(struct file *file, char *buf, size_t count,
  208.    loff_t *ppos)
  209. {
  210. struct inode *inode = file->f_dentry->d_inode;
  211. int dev = MINOR(inode->i_rdev) & 0x0f;
  213. switch(dev)
  214. {
  215. case DSP56K_DEV_56001:
  216. {
  218. long n;
  220. /* Don't do anything if nothing is to be done */
  221. if (!count) return 0;
  223. n = 0;
  224. switch (dsp56k.rx_wsize) {
  225. case 1:  /* 8 bit */
  226. {
  227. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
  228.   put_user(dsp56k_host_interface.data.b[3], buf+n++));
  229. return n;
  230. }
  231. case 2:  /* 16 bit */
  232. {
  233. short *data;
  235. count /= 2;
  236. data = (short*) buf;
  237. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
  238.   put_user(dsp56k_host_interface.data.w[1], data+n++));
  239. return 2*n;
  240. }
  241. case 3:  /* 24 bit */
  242. {
  243. count /= 3;
  244. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
  245.   put_user(dsp56k_host_interface.data.b[1], buf+n++);
  246.   put_user(dsp56k_host_interface.data.b[2], buf+n++);
  247.   put_user(dsp56k_host_interface.data.b[3], buf+n++));
  248. return 3*n;
  249. }
  250. case 4:  /* 32 bit */
  251. {
  252. long *data;
  254. count /= 4;
  255. data = (long*) buf;
  256. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
  257.   put_user(dsp56k_host_interface.data.l, data+n++));
  258. return 4*n;
  259. }
  260. }
  261. return -EFAULT;
  262. }
  264. default:
  265. printk(KERN_ERR "DSP56k driver: Unknown minor device: %dn", dev);
  266. return -ENXIO;
  267. }
  268. }
  270. static ssize_t dsp56k_write(struct file *file, const char *buf, size_t count,
  271.     loff_t *ppos)
  272. {
  273. struct inode *inode = file->f_dentry->d_inode;
  274. int dev = MINOR(inode->i_rdev) & 0x0f;
  276. switch(dev)
  277. {
  278. case DSP56K_DEV_56001:
  279. {
  280. long n;
  282. /* Don't do anything if nothing is to be done */
  283. if (!count) return 0;
  285. n = 0;
  286. switch (dsp56k.tx_wsize) {
  287. case 1:  /* 8 bit */
  288. {
  289. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
  290.   get_user(dsp56k_host_interface.data.b[3], buf+n++));
  291. return n;
  292. }
  293. case 2:  /* 16 bit */
  294. {
  295. short *data;
  297. count /= 2;
  298. data = (short*) buf;
  299. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
  300.   get_user(dsp56k_host_interface.data.w[1], data+n++));
  301. return 2*n;
  302. }
  303. case 3:  /* 24 bit */
  304. {
  305. count /= 3;
  306. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
  307.   get_user(dsp56k_host_interface.data.b[1], buf+n++);
  308.   get_user(dsp56k_host_interface.data.b[2], buf+n++);
  309.   get_user(dsp56k_host_interface.data.b[3], buf+n++));
  310. return 3*n;
  311. }
  312. case 4:  /* 32 bit */
  313. {
  314. long *data;
  316. count /= 4;
  317. data = (long*) buf;
  318. handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
  319.   get_user(dsp56k_host_interface.data.l, data+n++));
  320. return 4*n;
  321. }
  322. }
  324. return -EFAULT;
  325. }
  326. default:
  327. printk(KERN_ERR "DSP56k driver: Unknown minor device: %dn", dev);
  328. return -ENXIO;
  329. }
  330. }
  332. static int dsp56k_ioctl(struct inode *inode, struct file *file,
  333. unsigned int cmd, unsigned long arg)
  334. {
  335. int dev = MINOR(inode->i_rdev) & 0x0f;
  337. switch(dev)
  338. {
  339. case DSP56K_DEV_56001:
  341. switch(cmd) {
  342. case DSP56K_UPLOAD:
  343. {
  344. char *bin;
  345. int r, len;
  346. struct dsp56k_upload *binary = (struct dsp56k_upload *) arg;
  347.     
  348. if(get_user(len, &binary->len) < 0)
  349. return -EFAULT;
  350. if(get_user(bin, &binary->bin) < 0)
  351. return -EFAULT;
  353. if (len == 0) {
  354. return -EINVAL;      /* nothing to upload?!? */
  355. }
  356. if (len > DSP56K_MAX_BINARY_LENGTH) {
  357. return -EINVAL;
  358. }
  359.     
  360. r = dsp56k_upload(bin, len);
  361. if (r < 0) {
  362. return r;
  363. }
  364.     
  365. break;
  366. }
  367. case DSP56K_SET_TX_WSIZE:
  368. if (arg > 4 || arg < 1)
  369. return -EINVAL;
  370. dsp56k.tx_wsize = (int) arg;
  371. break;
  372. case DSP56K_SET_RX_WSIZE:
  373. if (arg > 4 || arg < 1)
  374. return -EINVAL;
  375. dsp56k.rx_wsize = (int) arg;
  376. break;
  377. case DSP56K_HOST_FLAGS:
  378. {
  379. int dir, out, status;
  380. struct dsp56k_host_flags *hf = (struct dsp56k_host_flags*) arg;
  381.     
  382. if(get_user(dir, &hf->dir) < 0)
  383. return -EFAULT;
  384. if(get_user(out, &hf->out) < 0)
  385. return -EFAULT;
  387. if ((dir & 0x1) && (out & 0x1))
  388. dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
  389. else if (dir & 0x1)
  390. dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
  391. if ((dir & 0x2) && (out & 0x2))
  392. dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
  393. else if (dir & 0x2)
  394. dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
  396. status = 0;
  397. if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
  398. if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
  399. if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
  400. if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
  402. return put_user(status, &hf->status);
  403. }
  404. case DSP56K_HOST_CMD:
  405. if (arg > 31 || arg < 0)
  406. return -EINVAL;
  407. dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
  408.      DSP56K_CVR_HC);
  409. break;
  410. default:
  411. return -EINVAL;
  412. }
  413. return 0;
  415. default:
  416. printk(KERN_ERR "DSP56k driver: Unknown minor device: %dn", dev);
  417. return -ENXIO;
  418. }
  419. }
  421. /* As of 2.1.26 this should be dsp56k_poll,
  422.  * but how do I then check device minor number?
  423.  * Do I need this function at all???
  424.  */
  425. #if 0
  426. static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
  427. {
  428. int dev = MINOR(file->f_dentry->d_inode->i_rdev) & 0x0f;
  430. switch(dev)
  431. {
  432. case DSP56K_DEV_56001:
  433. /* poll_wait(file, ???, wait); */
  434. return POLLIN | POLLRDNORM | POLLOUT;
  436. default:
  437. printk("DSP56k driver: Unknown minor device: %dn", dev);
  438. return 0;
  439. }
  440. }
  441. #endif
  443. static int dsp56k_open(struct inode *inode, struct file *file)
  444. {
  445. int dev = MINOR(inode->i_rdev) & 0x0f;
  447. switch(dev)
  448. {
  449. case DSP56K_DEV_56001:
  451. if (test_and_set_bit(0, &dsp56k.in_use))
  452. return -EBUSY;
  454. dsp56k.timeout = TIMEOUT;
  455. dsp56k.maxio = MAXIO;
  456. dsp56k.rx_wsize = dsp56k.tx_wsize = 4; 
  458. DSP56K_TX_INT_OFF;
  459. DSP56K_RX_INT_OFF;
  461. /* Zero host flags */
  462. dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
  463. dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
  465. break;
  467. default:
  468. return -ENODEV;
  469. }
  471. return 0;
  472. }
  474. static int dsp56k_release(struct inode *inode, struct file *file)
  475. {
  476. int dev = MINOR(inode->i_rdev) & 0x0f;
  478. switch(dev)
  479. {
  480. case DSP56K_DEV_56001:
  481. clear_bit(0, &dsp56k.in_use);
  482. break;
  483. default:
  484. printk(KERN_ERR "DSP56k driver: Unknown minor device: %dn", dev);
  485. return -ENXIO;
  486. }
  488. return 0;
  489. }
  491. static struct file_operations dsp56k_fops = {
  492. owner: THIS_MODULE,
  493. read: dsp56k_read,
  494. write: dsp56k_write,
  495. ioctl: dsp56k_ioctl,
  496. open: dsp56k_open,
  497. release: dsp56k_release,
  498. };
  501. /****** Init and module functions ******/
  503. static devfs_handle_t devfs_handle;
  505. static char banner[] __initdata = KERN_INFO "DSP56k driver installedn";
  507. static int __init dsp56k_init_driver(void)
  508. {
  509. if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
  510. printk("DSP56k driver: Hardware not presentn");
  511. return -ENODEV;
  512. }
  514. if(devfs_register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
  515. printk("DSP56k driver: Unable to register drivern");
  516. return -ENODEV;
  517. }
  518. devfs_handle = devfs_register(NULL, "dsp56k", DEVFS_FL_DEFAULT,
  519.       DSP56K_MAJOR, 0,
  520.       S_IFCHR | S_IRUSR | S_IWUSR,
  521.       &dsp56k_fops, NULL);
  523. printk(banner);
  524. return 0;
  525. }
  526. module_init(dsp56k_init_driver);
  528. static void __exit dsp56k_cleanup_driver(void)
  529. {
  530. devfs_unregister_chrdev(DSP56K_MAJOR, "dsp56k");
  531. devfs_unregister(devfs_handle);
  532. }
  533. module_exit(dsp56k_cleanup_driver);
  535. MODULE_LICENSE("GPL");