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
  40 #include <asm/atarihw.h>
  41 #include <asm/traps.h>
  42 #include <asm/uaccess.h>        /* For put_user and get_user */
  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 int dsp56k_ioctl(struct inode *inode, struct file *file,
 307                         unsigned int cmd, unsigned long arg)
 308 {
 309         int dev = iminor(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
 335                         r = dsp56k_upload(bin, len);
 336                         if (r < 0) {
 337                                 return r;
 338                         }
 339
 340                         break;
 341                 }
 342                 case DSP56K_SET_TX_WSIZE:
 343                         if (arg > 4 || arg < 1)
 344                                 return -EINVAL;
 345                         dsp56k.tx_wsize = (int) arg;
 346                         break;
 347                 case DSP56K_SET_RX_WSIZE:
 348                         if (arg > 4 || arg < 1)
 349                                 return -EINVAL;
 350                         dsp56k.rx_wsize = (int) arg;
 351                         break;
 352                 case DSP56K_HOST_FLAGS:
 353                 {
 354                         int dir, out, status;
 355                         struct dsp56k_host_flags __user *hf = argp;
 356
 357                         if(get_user(dir, &hf->dir) < 0)
 358                                 return -EFAULT;
 359                         if(get_user(out, &hf->out) < 0)
 360                                 return -EFAULT;
 361
 362                         if ((dir & 0x1) && (out & 0x1))
 363                                 dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
 364                         else if (dir & 0x1)
 365                                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
 366                         if ((dir & 0x2) && (out & 0x2))
 367                                 dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
 368                         else if (dir & 0x2)
 369                                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
 370
 371                         status = 0;
 372                         if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
 373                         if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
 374                         if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
 375                         if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
 376
 377                         return put_user(status, &hf->status);
 378                 }
 379                 case DSP56K_HOST_CMD:
 380                         if (arg > 31 || arg < 0)
 381                                 return -EINVAL;
 382                         dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
 383                                                              DSP56K_CVR_HC);
 384                         break;
 385                 default:
 386                         return -EINVAL;
 387                 }
 388                 return 0;
 389
 390         default:
 391                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 392                 return -ENXIO;
 393         }
 394 }
 395
 396 /* As of 2.1.26 this should be dsp56k_poll,
 397  * but how do I then check device minor number?
 398  * Do I need this function at all???
 399  */
 400 #if 0
 401 static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
 402 {
 403         int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
 404
 405         switch(dev)
 406         {
 407         case DSP56K_DEV_56001:
 408                 /* poll_wait(file, ???, wait); */
 409                 return POLLIN | POLLRDNORM | POLLOUT;
 410
 411         default:
 412                 printk("DSP56k driver: Unknown minor device: %d\n", dev);
 413                 return 0;
 414         }
 415 }
 416 #endif
 417
 418 static int dsp56k_open(struct inode *inode, struct file *file)
 419 {
 420         int dev = iminor(inode) & 0x0f;
 421         int ret = 0;
 422
 423         lock_kernel();
 424         switch(dev)
 425         {
 426         case DSP56K_DEV_56001:
 427
 428                 if (test_and_set_bit(0, &dsp56k.in_use)) {
 429                         ret = -EBUSY;
 430                         goto out;
 431                 }
 432
 433                 dsp56k.timeout = TIMEOUT;
 434                 dsp56k.maxio = MAXIO;
 435                 dsp56k.rx_wsize = dsp56k.tx_wsize = 4;
 436
 437                 DSP56K_TX_INT_OFF;
 438                 DSP56K_RX_INT_OFF;
 439
 440                 /* Zero host flags */
 441                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
 442                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
 443
 444                 break;
 445
 446         default:
 447                 ret = -ENODEV;
 448         }
 449 out:
 450         unlock_kernel();
 451         return ret;
 452 }
 453
 454 static int dsp56k_release(struct inode *inode, struct file *file)
 455 {
 456         int dev = iminor(inode) & 0x0f;
 457
 458         switch(dev)
 459         {
 460         case DSP56K_DEV_56001:
 461                 clear_bit(0, &dsp56k.in_use);
 462                 break;
 463         default:
 464                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 465                 return -ENXIO;
 466         }
 467
 468         return 0;
 469 }
 470
 471 static const struct file_operations dsp56k_fops = {
 472         .owner          = THIS_MODULE,
 473         .read           = dsp56k_read,
 474         .write          = dsp56k_write,
 475         .ioctl          = dsp56k_ioctl,
 476         .open           = dsp56k_open,
 477         .release        = dsp56k_release,
 478 };
 479
 480
 481 /****** Init and module functions ******/
 482
 483 static char banner[] __initdata = KERN_INFO "DSP56k driver installed\n";
 484
 485 static int __init dsp56k_init_driver(void)
 486 {
 487         int err = 0;
 488
 489         if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
 490                 printk("DSP56k driver: Hardware not present\n");
 491                 return -ENODEV;
 492         }
 493
 494         if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
 495                 printk("DSP56k driver: Unable to register driver\n");
 496                 return -ENODEV;
 497         }
 498         dsp56k_class = class_create(THIS_MODULE, "dsp56k");
 499         if (IS_ERR(dsp56k_class)) {
 500                 err = PTR_ERR(dsp56k_class);
 501                 goto out_chrdev;
 502         }
 503         device_create_drvdata(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0),
 504                               NULL, "dsp56k");
 505
 506         printk(banner);
 507         goto out;
 508
 509 out_chrdev:
 510         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 511 out:
 512         return err;
 513 }
 514 module_init(dsp56k_init_driver);
 515
 516 static void __exit dsp56k_cleanup_driver(void)
 517 {
 518         device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
 519         class_destroy(dsp56k_class);
 520         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 521 }
 522 module_exit(dsp56k_cleanup_driver);
 523
 524 MODULE_LICENSE("GPL");
 525 MODULE_FIRMWARE("dsp56k/bootstrap.bin");