git.oblomov.eu Git - linux-2.6/blob - drivers/char/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  */
  25
  26 #include <linux/module.h>
  27 #include <linux/slab.h> /* for kmalloc() and kfree() */
  28 #include <linux/major.h>
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/delay.h>        /* guess what */
  32 #include <linux/fs.h>
  33 #include <linux/mm.h>
  34 #include <linux/init.h>
  35 #include <linux/device.h>
  36 #include <linux/smp_lock.h>
  37 #include <linux/firmware.h>
  38 #include <linux/platform_device.h>
  39 #include <linux/uaccess.h>      /* For put_user and get_user */
  40
  41 #include <asm/atarihw.h>
  42 #include <asm/traps.h>
  43
  44 #include <asm/dsp56k.h>
  45
  46 /* minor devices */
  47 #define DSP56K_DEV_56001        0    /* The only device so far */
  48
  49 #define TIMEOUT    10   /* Host port timeout in number of tries */
  50 #define MAXIO    2048   /* Maximum number of words before sleep */
  51 #define DSP56K_MAX_BINARY_LENGTH (3*64*1024)
  52
  53 #define DSP56K_TX_INT_ON        dsp56k_host_interface.icr |=  DSP56K_ICR_TREQ
  54 #define DSP56K_RX_INT_ON        dsp56k_host_interface.icr |=  DSP56K_ICR_RREQ
  55 #define DSP56K_TX_INT_OFF       dsp56k_host_interface.icr &= ~DSP56K_ICR_TREQ
  56 #define DSP56K_RX_INT_OFF       dsp56k_host_interface.icr &= ~DSP56K_ICR_RREQ
  57
  58 #define DSP56K_TRANSMIT         (dsp56k_host_interface.isr & DSP56K_ISR_TXDE)
  59 #define DSP56K_RECEIVE          (dsp56k_host_interface.isr & DSP56K_ISR_RXDF)
  60
  61 #define handshake(count, maxio, timeout, ENABLE, f) \
  62 { \
  63         long i, t, m; \
  64         while (count > 0) { \
  65                 m = min_t(unsigned long, count, maxio); \
  66                 for (i = 0; i < m; i++) { \
  67                         for (t = 0; t < timeout && !ENABLE; t++) \
  68                                 msleep(20); \
  69                         if(!ENABLE) \
  70                                 return -EIO; \
  71                         f; \
  72                 } \
  73                 count -= m; \
  74                 if (m == maxio) msleep(20); \
  75         } \
  76 }
  77
  78 #define tx_wait(n) \
  79 { \
  80         int t; \
  81         for(t = 0; t < n && !DSP56K_TRANSMIT; t++) \
  82                 msleep(10); \
  83         if(!DSP56K_TRANSMIT) { \
  84                 return -EIO; \
  85         } \
  86 }
  87
  88 #define rx_wait(n) \
  89 { \
  90         int t; \
  91         for(t = 0; t < n && !DSP56K_RECEIVE; t++) \
  92                 msleep(10); \
  93         if(!DSP56K_RECEIVE) { \
  94                 return -EIO; \
  95         } \
  96 }
  97
  98 static struct dsp56k_device {
  99         unsigned long in_use;
 100         long maxio, timeout;
 101         int tx_wsize, rx_wsize;
 102 } dsp56k;
 103
 104 static struct class *dsp56k_class;
 105
 106 static int dsp56k_reset(void)
 107 {
 108         u_char status;
 109
 110         /* Power down the DSP */
 111         sound_ym.rd_data_reg_sel = 14;
 112         status = sound_ym.rd_data_reg_sel & 0xef;
 113         sound_ym.wd_data = status;
 114         sound_ym.wd_data = status | 0x10;
 115
 116         udelay(10);
 117
 118         /* Power up the DSP */
 119         sound_ym.rd_data_reg_sel = 14;
 120         sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;
 121
 122         return 0;
 123 }
 124
 125 static int dsp56k_upload(u_char __user *bin, int len)
 126 {
 127         struct platform_device *pdev;
 128         const struct firmware *fw;
 129         const char fw_name[] = "dsp56k/bootstrap.bin";
 130         int err;
 131         int i;
 132
 133         dsp56k_reset();
 134
 135         pdev = platform_device_register_simple("dsp56k", 0, NULL, 0);
 136         if (IS_ERR(pdev)) {
 137                 printk(KERN_ERR "Failed to register device for \"%s\"\n",
 138                        fw_name);
 139                 return -EINVAL;
 140         }
 141         err = request_firmware(&fw, fw_name, &pdev->dev);
 142         platform_device_unregister(pdev);
 143         if (err) {
 144                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
 145                        fw_name, err);
 146                 return err;
 147         }
 148         if (fw->size % 3) {
 149                 printk(KERN_ERR "Bogus length %d in image \"%s\"\n",
 150                        fw->size, fw_name);
 151                 release_firmware(fw);
 152                 return -EINVAL;
 153         }
 154         for (i = 0; i < fw->size; i = i + 3) {
 155                 /* tx_wait(10); */
 156                 dsp56k_host_interface.data.b[1] = fw->data[i];
 157                 dsp56k_host_interface.data.b[2] = fw->data[i + 1];
 158                 dsp56k_host_interface.data.b[3] = fw->data[i + 2];
 159         }
 160         release_firmware(fw);
 161         for (; i < 512; i++) {
 162                 /* tx_wait(10); */
 163                 dsp56k_host_interface.data.b[1] = 0;
 164                 dsp56k_host_interface.data.b[2] = 0;
 165                 dsp56k_host_interface.data.b[3] = 0;
 166         }
 167
 168         for (i = 0; i < len; i++) {
 169                 tx_wait(10);
 170                 get_user(dsp56k_host_interface.data.b[1], bin++);
 171                 get_user(dsp56k_host_interface.data.b[2], bin++);
 172                 get_user(dsp56k_host_interface.data.b[3], bin++);
 173         }
 174
 175         tx_wait(10);
 176         dsp56k_host_interface.data.l = 3;    /* Magic execute */
 177
 178         return 0;
 179 }
 180
 181 static ssize_t dsp56k_read(struct file *file, char __user *buf, size_t count,
 182                            loff_t *ppos)
 183 {
 184         struct inode *inode = file->f_path.dentry->d_inode;
 185         int dev = iminor(inode) & 0x0f;
 186
 187         switch(dev)
 188         {
 189         case DSP56K_DEV_56001:
 190         {
 191
 192                 long n;
 193
 194                 /* Don't do anything if nothing is to be done */
 195                 if (!count) return 0;
 196
 197                 n = 0;
 198                 switch (dsp56k.rx_wsize) {
 199                 case 1:  /* 8 bit */
 200                 {
 201                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 202                                   put_user(dsp56k_host_interface.data.b[3], buf+n++));
 203                         return n;
 204                 }
 205                 case 2:  /* 16 bit */
 206                 {
 207                         short __user *data;
 208
 209                         count /= 2;
 210                         data = (short __user *) buf;
 211                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 212                                   put_user(dsp56k_host_interface.data.w[1], data+n++));
 213                         return 2*n;
 214                 }
 215                 case 3:  /* 24 bit */
 216                 {
 217                         count /= 3;
 218                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 219                                   put_user(dsp56k_host_interface.data.b[1], buf+n++);
 220                                   put_user(dsp56k_host_interface.data.b[2], buf+n++);
 221                                   put_user(dsp56k_host_interface.data.b[3], buf+n++));
 222                         return 3*n;
 223                 }
 224                 case 4:  /* 32 bit */
 225                 {
 226                         long __user *data;
 227
 228                         count /= 4;
 229                         data = (long __user *) buf;
 230                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 231                                   put_user(dsp56k_host_interface.data.l, data+n++));
 232                         return 4*n;
 233                 }
 234                 }
 235                 return -EFAULT;
 236         }
 237
 238         default:
 239                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 240                 return -ENXIO;
 241         }
 242 }
 243
 244 static ssize_t dsp56k_write(struct file *file, const char __user *buf, size_t count,
 245                             loff_t *ppos)
 246 {
 247         struct inode *inode = file->f_path.dentry->d_inode;
 248         int dev = iminor(inode) & 0x0f;
 249
 250         switch(dev)
 251         {
 252         case DSP56K_DEV_56001:
 253         {
 254                 long n;
 255
 256                 /* Don't do anything if nothing is to be done */
 257                 if (!count) return 0;
 258
 259                 n = 0;
 260                 switch (dsp56k.tx_wsize) {
 261                 case 1:  /* 8 bit */
 262                 {
 263                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 264                                   get_user(dsp56k_host_interface.data.b[3], buf+n++));
 265                         return n;
 266                 }
 267                 case 2:  /* 16 bit */
 268                 {
 269                         const short __user *data;
 270
 271                         count /= 2;
 272                         data = (const short __user *)buf;
 273                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 274                                   get_user(dsp56k_host_interface.data.w[1], data+n++));
 275                         return 2*n;
 276                 }
 277                 case 3:  /* 24 bit */
 278                 {
 279                         count /= 3;
 280                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 281                                   get_user(dsp56k_host_interface.data.b[1], buf+n++);
 282                                   get_user(dsp56k_host_interface.data.b[2], buf+n++);
 283                                   get_user(dsp56k_host_interface.data.b[3], buf+n++));
 284                         return 3*n;
 285                 }
 286                 case 4:  /* 32 bit */
 287                 {
 288                         const long __user *data;
 289
 290                         count /= 4;
 291                         data = (const long __user *)buf;
 292                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 293                                   get_user(dsp56k_host_interface.data.l, data+n++));
 294                         return 4*n;
 295                 }
 296                 }
 297
 298                 return -EFAULT;
 299         }
 300         default:
 301                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 302                 return -ENXIO;
 303         }
 304 }
 305
 306 static long dsp56k_ioctl(struct file *file, unsigned int cmd,
 307                          unsigned long arg)
 308 {
 309         int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
 310         void __user *argp = (void __user *)arg;
 311
 312         switch(dev)
 313         {
 314         case DSP56K_DEV_56001:
 315
 316                 switch(cmd) {
 317                 case DSP56K_UPLOAD:
 318                 {
 319                         char __user *bin;
 320                         int r, len;
 321                         struct dsp56k_upload __user *binary = argp;
 322
 323                         if(get_user(len, &binary->len) < 0)
 324                                 return -EFAULT;
 325                         if(get_user(bin, &binary->bin) < 0)
 326                                 return -EFAULT;
 327
 328                         if (len == 0) {
 329                                 return -EINVAL;      /* nothing to upload?!? */
 330                         }
 331                         if (len > DSP56K_MAX_BINARY_LENGTH) {
 332                                 return -EINVAL;
 333                         }
 334                         lock_kernel();
 335                         r = dsp56k_upload(bin, len);
 336                         unlock_kernel();
 337                         if (r < 0) {
 338                                 return r;
 339                         }
 340
 341                         break;
 342                 }
 343                 case DSP56K_SET_TX_WSIZE:
 344                         if (arg > 4 || arg < 1)
 345                                 return -EINVAL;
 346                         lock_kernel();
 347                         dsp56k.tx_wsize = (int) arg;
 348                         unlock_kernel();
 349                         break;
 350                 case DSP56K_SET_RX_WSIZE:
 351                         if (arg > 4 || arg < 1)
 352                                 return -EINVAL;
 353                         lock_kernel();
 354                         dsp56k.rx_wsize = (int) arg;
 355                         unlock_kernel();
 356                         break;
 357                 case DSP56K_HOST_FLAGS:
 358                 {
 359                         int dir, out, status;
 360                         struct dsp56k_host_flags __user *hf = argp;
 361
 362                         if(get_user(dir, &hf->dir) < 0)
 363                                 return -EFAULT;
 364                         if(get_user(out, &hf->out) < 0)
 365                                 return -EFAULT;
 366
 367                         lock_kernel();
 368                         if ((dir & 0x1) && (out & 0x1))
 369                                 dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
 370                         else if (dir & 0x1)
 371                                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
 372                         if ((dir & 0x2) && (out & 0x2))
 373                                 dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
 374                         else if (dir & 0x2)
 375                                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
 376
 377                         status = 0;
 378                         if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
 379                         if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
 380                         if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
 381                         if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
 382                         unlock_kernel();
 383                         return put_user(status, &hf->status);
 384                 }
 385                 case DSP56K_HOST_CMD:
 386                         if (arg > 31 || arg < 0)
 387                                 return -EINVAL;
 388                         lock_kernel();
 389                         dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
 390                                                              DSP56K_CVR_HC);
 391                         unlock_kernel();
 392                         break;
 393                 default:
 394                         return -EINVAL;
 395                 }
 396                 return 0;
 397
 398         default:
 399                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 400                 return -ENXIO;
 401         }
 402 }
 403
 404 /* As of 2.1.26 this should be dsp56k_poll,
 405  * but how do I then check device minor number?
 406  * Do I need this function at all???
 407  */
 408 #if 0
 409 static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
 410 {
 411         int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
 412
 413         switch(dev)
 414         {
 415         case DSP56K_DEV_56001:
 416                 /* poll_wait(file, ???, wait); */
 417                 return POLLIN | POLLRDNORM | POLLOUT;
 418
 419         default:
 420                 printk("DSP56k driver: Unknown minor device: %d\n", dev);
 421                 return 0;
 422         }
 423 }
 424 #endif
 425
 426 static int dsp56k_open(struct inode *inode, struct file *file)
 427 {
 428         int dev = iminor(inode) & 0x0f;
 429         int ret = 0;
 430
 431         lock_kernel();
 432         switch(dev)
 433         {
 434         case DSP56K_DEV_56001:
 435
 436                 if (test_and_set_bit(0, &dsp56k.in_use)) {
 437                         ret = -EBUSY;
 438                         goto out;
 439                 }
 440
 441                 dsp56k.timeout = TIMEOUT;
 442                 dsp56k.maxio = MAXIO;
 443                 dsp56k.rx_wsize = dsp56k.tx_wsize = 4;
 444
 445                 DSP56K_TX_INT_OFF;
 446                 DSP56K_RX_INT_OFF;
 447
 448                 /* Zero host flags */
 449                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
 450                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
 451
 452                 break;
 453
 454         default:
 455                 ret = -ENODEV;
 456         }
 457 out:
 458         unlock_kernel();
 459         return ret;
 460 }
 461
 462 static int dsp56k_release(struct inode *inode, struct file *file)
 463 {
 464         int dev = iminor(inode) & 0x0f;
 465
 466         switch(dev)
 467         {
 468         case DSP56K_DEV_56001:
 469                 clear_bit(0, &dsp56k.in_use);
 470                 break;
 471         default:
 472                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 473                 return -ENXIO;
 474         }
 475
 476         return 0;
 477 }
 478
 479 static const struct file_operations dsp56k_fops = {
 480         .owner          = THIS_MODULE,
 481         .read           = dsp56k_read,
 482         .write          = dsp56k_write,
 483         .unlocked_ioctl = dsp56k_ioctl,
 484         .open           = dsp56k_open,
 485         .release        = dsp56k_release,
 486 };
 487
 488
 489 /****** Init and module functions ******/
 490
 491 static char banner[] __initdata = KERN_INFO "DSP56k driver installed\n";
 492
 493 static int __init dsp56k_init_driver(void)
 494 {
 495         int err = 0;
 496
 497         if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
 498                 printk("DSP56k driver: Hardware not present\n");
 499                 return -ENODEV;
 500         }
 501
 502         if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
 503                 printk("DSP56k driver: Unable to register driver\n");
 504                 return -ENODEV;
 505         }
 506         dsp56k_class = class_create(THIS_MODULE, "dsp56k");
 507         if (IS_ERR(dsp56k_class)) {
 508                 err = PTR_ERR(dsp56k_class);
 509                 goto out_chrdev;
 510         }
 511         device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL,
 512                       "dsp56k");
 513
 514         printk(banner);
 515         goto out;
 516
 517 out_chrdev:
 518         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 519 out:
 520         return err;
 521 }
 522 module_init(dsp56k_init_driver);
 523
 524 static void __exit dsp56k_cleanup_driver(void)
 525 {
 526         device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
 527         class_destroy(dsp56k_class);
 528         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 529 }
 530 module_exit(dsp56k_cleanup_driver);
 531
 532 MODULE_LICENSE("GPL");
 533 MODULE_FIRMWARE("dsp56k/bootstrap.bin");