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/sched.h>        /* for struct wait_queue etc */
  29 #include <linux/major.h>
  30 #include <linux/types.h>
  31 #include <linux/errno.h>
  32 #include <linux/delay.h>        /* guess what */
  33 #include <linux/fs.h>
  34 #include <linux/mm.h>
  35 #include <linux/init.h>
  36 #include <linux/devfs_fs_kernel.h>
  37 #include <linux/smp_lock.h>
  38 #include <linux/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 /* DSP56001 bootstrap code */
  99 static char bootstrap[] = {
 100         0x0c, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 101         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 102         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 103         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 104         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 105         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 106         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 107         0x00, 0x00, 0x00, 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, 0x60, 0xf4, 0x00, 0x00, 0x00, 0x4f, 0x61, 0xf4,
 120         0x00, 0x00, 0x7e, 0xa9, 0x06, 0x2e, 0x80, 0x00, 0x00, 0x47,
 121         0x07, 0xd8, 0x84, 0x07, 0x59, 0x84, 0x08, 0xf4, 0xa8, 0x00,
 122         0x00, 0x04, 0x08, 0xf4, 0xbf, 0x00, 0x0c, 0x00, 0x00, 0xfe,
 123         0xb8, 0x0a, 0xf0, 0x80, 0x00, 0x7e, 0xa9, 0x08, 0xf4, 0xa0,
 124         0x00, 0x00, 0x01, 0x08, 0xf4, 0xbe, 0x00, 0x00, 0x00, 0x0a,
 125         0xa9, 0x80, 0x00, 0x7e, 0xad, 0x08, 0x4e, 0x2b, 0x44, 0xf4,
 126         0x00, 0x00, 0x00, 0x03, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x01,
 127         0x0e, 0xa0, 0x00, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb5, 0x08,
 128         0x50, 0x2b, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb8, 0x08, 0x46,
 129         0x2b, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x02, 0x0a, 0xf0, 0xaa,
 130         0x00, 0x7e, 0xc9, 0x20, 0x00, 0x45, 0x0a, 0xf0, 0xaa, 0x00,
 131         0x7e, 0xd0, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xc6, 0x0a, 0xa9,
 132         0x80, 0x00, 0x7e, 0xc4, 0x08, 0x58, 0x6b, 0x0a, 0xf0, 0x80,
 133         0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xcd, 0x0a,
 134         0xa9, 0x80, 0x00, 0x7e, 0xcb, 0x08, 0x58, 0xab, 0x0a, 0xf0,
 135         0x80, 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xd4,
 136         0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xd2, 0x08, 0x58, 0xeb, 0x0a,
 137         0xf0, 0x80, 0x00, 0x7e, 0xad};
 138 static int sizeof_bootstrap = 375;
 139
 140
 141 static struct dsp56k_device {
 142         long in_use;
 143         long maxio, timeout;
 144         int tx_wsize, rx_wsize;
 145 } dsp56k;
 146
 147 static struct class_simple *dsp56k_class;
 148
 149 static int dsp56k_reset(void)
 150 {
 151         u_char status;
 152
 153         /* Power down the DSP */
 154         sound_ym.rd_data_reg_sel = 14;
 155         status = sound_ym.rd_data_reg_sel & 0xef;
 156         sound_ym.wd_data = status;
 157         sound_ym.wd_data = status | 0x10;
 158
 159         udelay(10);
 160
 161         /* Power up the DSP */
 162         sound_ym.rd_data_reg_sel = 14;
 163         sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;
 164
 165         return 0;
 166 }
 167
 168 static int dsp56k_upload(u_char *bin, int len)
 169 {
 170         int i;
 171         u_char *p;
 172
 173         dsp56k_reset();
 174
 175         p = bootstrap;
 176         for (i = 0; i < sizeof_bootstrap/3; i++) {
 177                 /* tx_wait(10); */
 178                 dsp56k_host_interface.data.b[1] = *p++;
 179                 dsp56k_host_interface.data.b[2] = *p++;
 180                 dsp56k_host_interface.data.b[3] = *p++;
 181         }
 182         for (; i < 512; i++) {
 183                 /* tx_wait(10); */
 184                 dsp56k_host_interface.data.b[1] = 0;
 185                 dsp56k_host_interface.data.b[2] = 0;
 186                 dsp56k_host_interface.data.b[3] = 0;
 187         }
 188
 189         for (i = 0; i < len; i++) {
 190                 tx_wait(10);
 191                 get_user(dsp56k_host_interface.data.b[1], bin++);
 192                 get_user(dsp56k_host_interface.data.b[2], bin++);
 193                 get_user(dsp56k_host_interface.data.b[3], bin++);
 194         }
 195
 196         tx_wait(10);
 197         dsp56k_host_interface.data.l = 3;    /* Magic execute */
 198
 199         return 0;
 200 }
 201
 202 static ssize_t dsp56k_read(struct file *file, char *buf, size_t count,
 203                            loff_t *ppos)
 204 {
 205         struct inode *inode = file->f_dentry->d_inode;
 206         int dev = iminor(inode) & 0x0f;
 207
 208         switch(dev)
 209         {
 210         case DSP56K_DEV_56001:
 211         {
 212
 213                 long n;
 214
 215                 /* Don't do anything if nothing is to be done */
 216                 if (!count) return 0;
 217
 218                 n = 0;
 219                 switch (dsp56k.rx_wsize) {
 220                 case 1:  /* 8 bit */
 221                 {
 222                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 223                                   put_user(dsp56k_host_interface.data.b[3], buf+n++));
 224                         return n;
 225                 }
 226                 case 2:  /* 16 bit */
 227                 {
 228                         short *data;
 229
 230                         count /= 2;
 231                         data = (short*) buf;
 232                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 233                                   put_user(dsp56k_host_interface.data.w[1], data+n++));
 234                         return 2*n;
 235                 }
 236                 case 3:  /* 24 bit */
 237                 {
 238                         count /= 3;
 239                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 240                                   put_user(dsp56k_host_interface.data.b[1], buf+n++);
 241                                   put_user(dsp56k_host_interface.data.b[2], buf+n++);
 242                                   put_user(dsp56k_host_interface.data.b[3], buf+n++));
 243                         return 3*n;
 244                 }
 245                 case 4:  /* 32 bit */
 246                 {
 247                         long *data;
 248
 249                         count /= 4;
 250                         data = (long*) buf;
 251                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
 252                                   put_user(dsp56k_host_interface.data.l, data+n++));
 253                         return 4*n;
 254                 }
 255                 }
 256                 return -EFAULT;
 257         }
 258
 259         default:
 260                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 261                 return -ENXIO;
 262         }
 263 }
 264
 265 static ssize_t dsp56k_write(struct file *file, const char *buf, size_t count,
 266                             loff_t *ppos)
 267 {
 268         struct inode *inode = file->f_dentry->d_inode;
 269         int dev = iminor(inode) & 0x0f;
 270
 271         switch(dev)
 272         {
 273         case DSP56K_DEV_56001:
 274         {
 275                 long n;
 276
 277                 /* Don't do anything if nothing is to be done */
 278                 if (!count) return 0;
 279
 280                 n = 0;
 281                 switch (dsp56k.tx_wsize) {
 282                 case 1:  /* 8 bit */
 283                 {
 284                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 285                                   get_user(dsp56k_host_interface.data.b[3], buf+n++));
 286                         return n;
 287                 }
 288                 case 2:  /* 16 bit */
 289                 {
 290                         const short *data;
 291
 292                         count /= 2;
 293                         data = (const short *)buf;
 294                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 295                                   get_user(dsp56k_host_interface.data.w[1], data+n++));
 296                         return 2*n;
 297                 }
 298                 case 3:  /* 24 bit */
 299                 {
 300                         count /= 3;
 301                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 302                                   get_user(dsp56k_host_interface.data.b[1], buf+n++);
 303                                   get_user(dsp56k_host_interface.data.b[2], buf+n++);
 304                                   get_user(dsp56k_host_interface.data.b[3], buf+n++));
 305                         return 3*n;
 306                 }
 307                 case 4:  /* 32 bit */
 308                 {
 309                         const long *data;
 310
 311                         count /= 4;
 312                         data = (const long *)buf;
 313                         handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
 314                                   get_user(dsp56k_host_interface.data.l, data+n++));
 315                         return 4*n;
 316                 }
 317                 }
 318
 319                 return -EFAULT;
 320         }
 321         default:
 322                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 323                 return -ENXIO;
 324         }
 325 }
 326
 327 static int dsp56k_ioctl(struct inode *inode, struct file *file,
 328                         unsigned int cmd, unsigned long arg)
 329 {
 330         int dev = iminor(inode) & 0x0f;
 331
 332         switch(dev)
 333         {
 334         case DSP56K_DEV_56001:
 335
 336                 switch(cmd) {
 337                 case DSP56K_UPLOAD:
 338                 {
 339                         char *bin;
 340                         int r, len;
 341                         struct dsp56k_upload *binary = (struct dsp56k_upload *) arg;
 342
 343                         if(get_user(len, &binary->len) < 0)
 344                                 return -EFAULT;
 345                         if(get_user(bin, &binary->bin) < 0)
 346                                 return -EFAULT;
 347
 348                         if (len == 0) {
 349                                 return -EINVAL;      /* nothing to upload?!? */
 350                         }
 351                         if (len > DSP56K_MAX_BINARY_LENGTH) {
 352                                 return -EINVAL;
 353                         }
 354
 355                         r = dsp56k_upload(bin, len);
 356                         if (r < 0) {
 357                                 return r;
 358                         }
 359
 360                         break;
 361                 }
 362                 case DSP56K_SET_TX_WSIZE:
 363                         if (arg > 4 || arg < 1)
 364                                 return -EINVAL;
 365                         dsp56k.tx_wsize = (int) arg;
 366                         break;
 367                 case DSP56K_SET_RX_WSIZE:
 368                         if (arg > 4 || arg < 1)
 369                                 return -EINVAL;
 370                         dsp56k.rx_wsize = (int) arg;
 371                         break;
 372                 case DSP56K_HOST_FLAGS:
 373                 {
 374                         int dir, out, status;
 375                         struct dsp56k_host_flags *hf = (struct dsp56k_host_flags*) arg;
 376
 377                         if(get_user(dir, &hf->dir) < 0)
 378                                 return -EFAULT;
 379                         if(get_user(out, &hf->out) < 0)
 380                                 return -EFAULT;
 381
 382                         if ((dir & 0x1) && (out & 0x1))
 383                                 dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
 384                         else if (dir & 0x1)
 385                                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
 386                         if ((dir & 0x2) && (out & 0x2))
 387                                 dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
 388                         else if (dir & 0x2)
 389                                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
 390
 391                         status = 0;
 392                         if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
 393                         if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
 394                         if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
 395                         if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
 396
 397                         return put_user(status, &hf->status);
 398                 }
 399                 case DSP56K_HOST_CMD:
 400                         if (arg > 31 || arg < 0)
 401                                 return -EINVAL;
 402                         dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
 403                                                              DSP56K_CVR_HC);
 404                         break;
 405                 default:
 406                         return -EINVAL;
 407                 }
 408                 return 0;
 409
 410         default:
 411                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 412                 return -ENXIO;
 413         }
 414 }
 415
 416 /* As of 2.1.26 this should be dsp56k_poll,
 417  * but how do I then check device minor number?
 418  * Do I need this function at all???
 419  */
 420 #if 0
 421 static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
 422 {
 423         int dev = iminor(file->f_dentry->d_inode) & 0x0f;
 424
 425         switch(dev)
 426         {
 427         case DSP56K_DEV_56001:
 428                 /* poll_wait(file, ???, wait); */
 429                 return POLLIN | POLLRDNORM | POLLOUT;
 430
 431         default:
 432                 printk("DSP56k driver: Unknown minor device: %d\n", dev);
 433                 return 0;
 434         }
 435 }
 436 #endif
 437
 438 static int dsp56k_open(struct inode *inode, struct file *file)
 439 {
 440         int dev = iminor(inode) & 0x0f;
 441
 442         switch(dev)
 443         {
 444         case DSP56K_DEV_56001:
 445
 446                 if (test_and_set_bit(0, &dsp56k.in_use))
 447                         return -EBUSY;
 448
 449                 dsp56k.timeout = TIMEOUT;
 450                 dsp56k.maxio = MAXIO;
 451                 dsp56k.rx_wsize = dsp56k.tx_wsize = 4;
 452
 453                 DSP56K_TX_INT_OFF;
 454                 DSP56K_RX_INT_OFF;
 455
 456                 /* Zero host flags */
 457                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
 458                 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
 459
 460                 break;
 461
 462         default:
 463                 return -ENODEV;
 464         }
 465
 466         return 0;
 467 }
 468
 469 static int dsp56k_release(struct inode *inode, struct file *file)
 470 {
 471         int dev = iminor(inode) & 0x0f;
 472
 473         switch(dev)
 474         {
 475         case DSP56K_DEV_56001:
 476                 clear_bit(0, &dsp56k.in_use);
 477                 break;
 478         default:
 479                 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
 480                 return -ENXIO;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static struct file_operations dsp56k_fops = {
 487         .owner          = THIS_MODULE,
 488         .read           = dsp56k_read,
 489         .write          = dsp56k_write,
 490         .ioctl          = dsp56k_ioctl,
 491         .open           = dsp56k_open,
 492         .release        = dsp56k_release,
 493 };
 494
 495
 496 /****** Init and module functions ******/
 497
 498 static char banner[] __initdata = KERN_INFO "DSP56k driver installed\n";
 499
 500 static int __init dsp56k_init_driver(void)
 501 {
 502         int err = 0;
 503
 504         if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
 505                 printk("DSP56k driver: Hardware not present\n");
 506                 return -ENODEV;
 507         }
 508
 509         if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
 510                 printk("DSP56k driver: Unable to register driver\n");
 511                 return -ENODEV;
 512         }
 513         dsp56k_class = class_simple_create(THIS_MODULE, "dsp56k");
 514         if (IS_ERR(dsp56k_class)) {
 515                 err = PTR_ERR(dsp56k_class);
 516                 goto out_chrdev;
 517         }
 518         class_simple_device_add(dsp56k_class, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
 519
 520         err = devfs_mk_cdev(MKDEV(DSP56K_MAJOR, 0),
 521                       S_IFCHR | S_IRUSR | S_IWUSR, "dsp56k");
 522         if(err)
 523                 goto out_class;
 524
 525         printk(banner);
 526         goto out;
 527
 528 out_class:
 529         class_simple_device_remove(MKDEV(DSP56K_MAJOR, 0));
 530         class_simple_destroy(dsp56k_class);
 531 out_chrdev:
 532         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 533 out:
 534         return err;
 535 }
 536 module_init(dsp56k_init_driver);
 537
 538 static void __exit dsp56k_cleanup_driver(void)
 539 {
 540         class_simple_device_remove(MKDEV(DSP56K_MAJOR, 0));
 541         class_simple_destroy(dsp56k_class);
 542         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 543         devfs_remove("dsp56k");
 544 }
 545 module_exit(dsp56k_cleanup_driver);
 546
 547 MODULE_LICENSE("GPL");