sound/pci/emu10k1/io.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   3  *                   Creative Labs, Inc.
   4  *  Routines for control of EMU10K1 chips
   5  *
   6  *  BUGS:
   7  *    --
   8  *
   9  *  TODO:
  10  *    --
  11  *
  12  *   This program is free software; you can redistribute it and/or modify
  13  *   it under the terms of the GNU General Public License as published by
  14  *   the Free Software Foundation; either version 2 of the License, or
  15  *   (at your option) any later version.
  16  *
  17  *   This program is distributed in the hope that it will be useful,
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *   GNU General Public License for more details.
  21  *
  22  *   You should have received a copy of the GNU General Public License
  23  *   along with this program; if not, write to the Free Software
  24  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  25  *
  26  */
  27
  28 #include <linux/time.h>
  29 #include <sound/core.h>
  30 #include <sound/emu10k1.h>
  31 #include <linux/delay.h>
  32 #include <linux/export.h>
  33 #include "p17v.h"
  34
  35 unsigned int snd_emu10k1_ptr_read(struct snd_emu10k1 * emu, unsigned int reg, unsigned int chn)
  36 {
  37         unsigned long flags;
  38         unsigned int regptr, val;
  39         unsigned int mask;
  40
  41         mask = emu->audigy ? A_PTR_ADDRESS_MASK : PTR_ADDRESS_MASK;
  42         regptr = ((reg << 16) & mask) | (chn & PTR_CHANNELNUM_MASK);
  43
  44         if (reg & 0xff000000) {
  45                 unsigned char size, offset;
  46
  47                 size = (reg >> 24) & 0x3f;
  48                 offset = (reg >> 16) & 0x1f;
  49                 mask = ((1 << size) - 1) << offset;
  50
  51                 spin_lock_irqsave(&emu->emu_lock, flags);
  52                 outl(regptr, emu->port + PTR);
  53                 val = inl(emu->port + DATA);
  54                 spin_unlock_irqrestore(&emu->emu_lock, flags);
  55
  56                 return (val & mask) >> offset;
  57         } else {
  58                 spin_lock_irqsave(&emu->emu_lock, flags);
  59                 outl(regptr, emu->port + PTR);
  60                 val = inl(emu->port + DATA);
  61                 spin_unlock_irqrestore(&emu->emu_lock, flags);
  62                 return val;
  63         }
  64 }
  65
  66 EXPORT_SYMBOL(snd_emu10k1_ptr_read);
  67
  68 void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned int chn, unsigned int data)
  69 {
  70         unsigned int regptr;
  71         unsigned long flags;
  72         unsigned int mask;
  73
  74         if (snd_BUG_ON(!emu))
  75                 return;
  76         mask = emu->audigy ? A_PTR_ADDRESS_MASK : PTR_ADDRESS_MASK;
  77         regptr = ((reg << 16) & mask) | (chn & PTR_CHANNELNUM_MASK);
  78
  79         if (reg & 0xff000000) {
  80                 unsigned char size, offset;
  81
  82                 size = (reg >> 24) & 0x3f;
  83                 offset = (reg >> 16) & 0x1f;
  84                 mask = ((1 << size) - 1) << offset;
  85                 data = (data << offset) & mask;
  86
  87                 spin_lock_irqsave(&emu->emu_lock, flags);
  88                 outl(regptr, emu->port + PTR);
  89                 data |= inl(emu->port + DATA) & ~mask;
  90                 outl(data, emu->port + DATA);
  91                 spin_unlock_irqrestore(&emu->emu_lock, flags);
  92         } else {
  93                 spin_lock_irqsave(&emu->emu_lock, flags);
  94                 outl(regptr, emu->port + PTR);
  95                 outl(data, emu->port + DATA);
  96                 spin_unlock_irqrestore(&emu->emu_lock, flags);
  97         }
  98 }
  99
 100 EXPORT_SYMBOL(snd_emu10k1_ptr_write);
 101
 102 unsigned int snd_emu10k1_ptr20_read(struct snd_emu10k1 * emu,
 103                                           unsigned int reg,
 104                                           unsigned int chn)
 105 {
 106         unsigned long flags;
 107         unsigned int regptr, val;
 108
 109         regptr = (reg << 16) | chn;
 110
 111         spin_lock_irqsave(&emu->emu_lock, flags);
 112         outl(regptr, emu->port + 0x20 + PTR);
 113         val = inl(emu->port + 0x20 + DATA);
 114         spin_unlock_irqrestore(&emu->emu_lock, flags);
 115         return val;
 116 }
 117
 118 void snd_emu10k1_ptr20_write(struct snd_emu10k1 *emu,
 119                                    unsigned int reg,
 120                                    unsigned int chn,
 121                                    unsigned int data)
 122 {
 123         unsigned int regptr;
 124         unsigned long flags;
 125
 126         regptr = (reg << 16) | chn;
 127
 128         spin_lock_irqsave(&emu->emu_lock, flags);
 129         outl(regptr, emu->port + 0x20 + PTR);
 130         outl(data, emu->port + 0x20 + DATA);
 131         spin_unlock_irqrestore(&emu->emu_lock, flags);
 132 }
 133
 134 int snd_emu10k1_spi_write(struct snd_emu10k1 * emu,
 135                                    unsigned int data)
 136 {
 137         unsigned int reset, set;
 138         unsigned int reg, tmp;
 139         int n, result;
 140         int err = 0;
 141
 142         /* This function is not re-entrant, so protect against it. */
 143         spin_lock(&emu->spi_lock);
 144         if (emu->card_capabilities->ca0108_chip)
 145                 reg = 0x3c; /* PTR20, reg 0x3c */
 146         else {
 147                 /* For other chip types the SPI register
 148                  * is currently unknown. */
 149                 err = 1;
 150                 goto spi_write_exit;
 151         }
 152         if (data > 0xffff) {
 153                 /* Only 16bit values allowed */
 154                 err = 1;
 155                 goto spi_write_exit;
 156         }
 157
 158         tmp = snd_emu10k1_ptr20_read(emu, reg, 0);
 159         reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */
 160         set = reset | 0x10000; /* Set xxx1xxxx */
 161         snd_emu10k1_ptr20_write(emu, reg, 0, reset | data);
 162         tmp = snd_emu10k1_ptr20_read(emu, reg, 0); /* write post */
 163         snd_emu10k1_ptr20_write(emu, reg, 0, set | data);
 164         result = 1;
 165         /* Wait for status bit to return to 0 */
 166         for (n = 0; n < 100; n++) {
 167                 udelay(10);
 168                 tmp = snd_emu10k1_ptr20_read(emu, reg, 0);
 169                 if (!(tmp & 0x10000)) {
 170                         result = 0;
 171                         break;
 172                 }
 173         }
 174         if (result) {
 175                 /* Timed out */
 176                 err = 1;
 177                 goto spi_write_exit;
 178         }
 179         snd_emu10k1_ptr20_write(emu, reg, 0, reset | data);
 180         tmp = snd_emu10k1_ptr20_read(emu, reg, 0); /* Write post */
 181         err = 0;
 182 spi_write_exit:
 183         spin_unlock(&emu->spi_lock);
 184         return err;
 185 }
 186
 187 /* The ADC does not support i2c read, so only write is implemented */
 188 int snd_emu10k1_i2c_write(struct snd_emu10k1 *emu,
 189                                 u32 reg,
 190                                 u32 value)
 191 {
 192         u32 tmp;
 193         int timeout = 0;
 194         int status;
 195         int retry;
 196         int err = 0;
 197
 198         if ((reg > 0x7f) || (value > 0x1ff)) {
 199                 dev_err(emu->card->dev, "i2c_write: invalid values.\n");
 200                 return -EINVAL;
 201         }
 202
 203         /* This function is not re-entrant, so protect against it. */
 204         spin_lock(&emu->i2c_lock);
 205
 206         tmp = reg << 25 | value << 16;
 207
 208         /* This controls the I2C connected to the WM8775 ADC Codec */
 209         snd_emu10k1_ptr20_write(emu, P17V_I2C_1, 0, tmp);
 210         tmp = snd_emu10k1_ptr20_read(emu, P17V_I2C_1, 0); /* write post */
 211
 212         for (retry = 0; retry < 10; retry++) {
 213                 /* Send the data to i2c */
 214                 tmp = 0;
 215                 tmp = tmp | (I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD);
 216                 snd_emu10k1_ptr20_write(emu, P17V_I2C_ADDR, 0, tmp);
 217
 218                 /* Wait till the transaction ends */
 219                 while (1) {
 220                         mdelay(1);
 221                         status = snd_emu10k1_ptr20_read(emu, P17V_I2C_ADDR, 0);
 222                         timeout++;
 223                         if ((status & I2C_A_ADC_START) == 0)
 224                                 break;
 225
 226                         if (timeout > 1000) {
 227                                 dev_warn(emu->card->dev,
 228                                            "emu10k1:I2C:timeout status=0x%x\n",
 229                                            status);
 230                                 break;
 231                         }
 232                 }
 233                 //Read back and see if the transaction is successful
 234                 if ((status & I2C_A_ADC_ABORT) == 0)
 235                         break;
 236         }
 237
 238         if (retry == 10) {
 239                 dev_err(emu->card->dev, "Writing to ADC failed!\n");
 240                 dev_err(emu->card->dev, "status=0x%x, reg=%d, value=%d\n",
 241                         status, reg, value);
 242                 /* dump_stack(); */
 243                 err = -EINVAL;
 244         }
 245
 246         spin_unlock(&emu->i2c_lock);
 247         return err;
 248 }
 249
 250 int snd_emu1010_fpga_write(struct snd_emu10k1 * emu, u32 reg, u32 value)
 251 {
 252         unsigned long flags;
 253
 254         if (reg > 0x3f)
 255                 return 1;
 256         reg += 0x40; /* 0x40 upwards are registers. */
 257         if (value > 0x3f) /* 0 to 0x3f are values */
 258                 return 1;
 259         spin_lock_irqsave(&emu->emu_lock, flags);
 260         outl(reg, emu->port + A_IOCFG);
 261         udelay(10);
 262         outl(reg | 0x80, emu->port + A_IOCFG);  /* High bit clocks the value into the fpga. */
 263         udelay(10);
 264         outl(value, emu->port + A_IOCFG);
 265         udelay(10);
 266         outl(value | 0x80 , emu->port + A_IOCFG);  /* High bit clocks the value into the fpga. */
 267         spin_unlock_irqrestore(&emu->emu_lock, flags);
 268
 269         return 0;
 270 }
 271
 272 int snd_emu1010_fpga_read(struct snd_emu10k1 * emu, u32 reg, u32 *value)
 273 {
 274         unsigned long flags;
 275         if (reg > 0x3f)
 276                 return 1;
 277         reg += 0x40; /* 0x40 upwards are registers. */
 278         spin_lock_irqsave(&emu->emu_lock, flags);
 279         outl(reg, emu->port + A_IOCFG);
 280         udelay(10);
 281         outl(reg | 0x80, emu->port + A_IOCFG);  /* High bit clocks the value into the fpga. */
 282         udelay(10);
 283         *value = ((inl(emu->port + A_IOCFG) >> 8) & 0x7f);
 284         spin_unlock_irqrestore(&emu->emu_lock, flags);
 285
 286         return 0;
 287 }
 288
 289 /* Each Destination has one and only one Source,
 290  * but one Source can feed any number of Destinations simultaneously.
 291  */
 292 int snd_emu1010_fpga_link_dst_src_write(struct snd_emu10k1 * emu, u32 dst, u32 src)
 293 {
 294         snd_emu1010_fpga_write(emu, 0x00, ((dst >> 8) & 0x3f) );
 295         snd_emu1010_fpga_write(emu, 0x01, (dst & 0x3f) );
 296         snd_emu1010_fpga_write(emu, 0x02, ((src >> 8) & 0x3f) );
 297         snd_emu1010_fpga_write(emu, 0x03, (src & 0x3f) );
 298
 299         return 0;
 300 }
 301
 302 void snd_emu10k1_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb)
 303 {
 304         unsigned long flags;
 305         unsigned int enable;
 306
 307         spin_lock_irqsave(&emu->emu_lock, flags);
 308         enable = inl(emu->port + INTE) | intrenb;
 309         outl(enable, emu->port + INTE);
 310         spin_unlock_irqrestore(&emu->emu_lock, flags);
 311 }
 312
 313 void snd_emu10k1_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb)
 314 {
 315         unsigned long flags;
 316         unsigned int enable;
 317
 318         spin_lock_irqsave(&emu->emu_lock, flags);
 319         enable = inl(emu->port + INTE) & ~intrenb;
 320         outl(enable, emu->port + INTE);
 321         spin_unlock_irqrestore(&emu->emu_lock, flags);
 322 }
 323
 324 void snd_emu10k1_voice_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum)
 325 {
 326         unsigned long flags;
 327         unsigned int val;
 328
 329         spin_lock_irqsave(&emu->emu_lock, flags);
 330         /* voice interrupt */
 331         if (voicenum >= 32) {
 332                 outl(CLIEH << 16, emu->port + PTR);
 333                 val = inl(emu->port + DATA);
 334                 val |= 1 << (voicenum - 32);
 335         } else {
 336                 outl(CLIEL << 16, emu->port + PTR);
 337                 val = inl(emu->port + DATA);
 338                 val |= 1 << voicenum;
 339         }
 340         outl(val, emu->port + DATA);
 341         spin_unlock_irqrestore(&emu->emu_lock, flags);
 342 }
 343
 344 void snd_emu10k1_voice_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum)
 345 {
 346         unsigned long flags;
 347         unsigned int val;
 348
 349         spin_lock_irqsave(&emu->emu_lock, flags);
 350         /* voice interrupt */
 351         if (voicenum >= 32) {
 352                 outl(CLIEH << 16, emu->port + PTR);
 353                 val = inl(emu->port + DATA);
 354                 val &= ~(1 << (voicenum - 32));
 355         } else {
 356                 outl(CLIEL << 16, emu->port + PTR);
 357                 val = inl(emu->port + DATA);
 358                 val &= ~(1 << voicenum);
 359         }
 360         outl(val, emu->port + DATA);
 361         spin_unlock_irqrestore(&emu->emu_lock, flags);
 362 }
 363
 364 void snd_emu10k1_voice_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum)
 365 {
 366         unsigned long flags;
 367
 368         spin_lock_irqsave(&emu->emu_lock, flags);
 369         /* voice interrupt */
 370         if (voicenum >= 32) {
 371                 outl(CLIPH << 16, emu->port + PTR);
 372                 voicenum = 1 << (voicenum - 32);
 373         } else {
 374                 outl(CLIPL << 16, emu->port + PTR);
 375                 voicenum = 1 << voicenum;
 376         }
 377         outl(voicenum, emu->port + DATA);
 378         spin_unlock_irqrestore(&emu->emu_lock, flags);
 379 }
 380
 381 void snd_emu10k1_voice_half_loop_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum)
 382 {
 383         unsigned long flags;
 384         unsigned int val;
 385
 386         spin_lock_irqsave(&emu->emu_lock, flags);
 387         /* voice interrupt */
 388         if (voicenum >= 32) {
 389                 outl(HLIEH << 16, emu->port + PTR);
 390                 val = inl(emu->port + DATA);
 391                 val |= 1 << (voicenum - 32);
 392         } else {
 393                 outl(HLIEL << 16, emu->port + PTR);
 394                 val = inl(emu->port + DATA);
 395                 val |= 1 << voicenum;
 396         }
 397         outl(val, emu->port + DATA);
 398         spin_unlock_irqrestore(&emu->emu_lock, flags);
 399 }
 400
 401 void snd_emu10k1_voice_half_loop_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum)
 402 {
 403         unsigned long flags;
 404         unsigned int val;
 405
 406         spin_lock_irqsave(&emu->emu_lock, flags);
 407         /* voice interrupt */
 408         if (voicenum >= 32) {
 409                 outl(HLIEH << 16, emu->port + PTR);
 410                 val = inl(emu->port + DATA);
 411                 val &= ~(1 << (voicenum - 32));
 412         } else {
 413                 outl(HLIEL << 16, emu->port + PTR);
 414                 val = inl(emu->port + DATA);
 415                 val &= ~(1 << voicenum);
 416         }
 417         outl(val, emu->port + DATA);
 418         spin_unlock_irqrestore(&emu->emu_lock, flags);
 419 }
 420
 421 void snd_emu10k1_voice_half_loop_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum)
 422 {
 423         unsigned long flags;
 424
 425         spin_lock_irqsave(&emu->emu_lock, flags);
 426         /* voice interrupt */
 427         if (voicenum >= 32) {
 428                 outl(HLIPH << 16, emu->port + PTR);
 429                 voicenum = 1 << (voicenum - 32);
 430         } else {
 431                 outl(HLIPL << 16, emu->port + PTR);
 432                 voicenum = 1 << voicenum;
 433         }
 434         outl(voicenum, emu->port + DATA);
 435         spin_unlock_irqrestore(&emu->emu_lock, flags);
 436 }
 437
 438 void snd_emu10k1_voice_set_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum)
 439 {
 440         unsigned long flags;
 441         unsigned int sol;
 442
 443         spin_lock_irqsave(&emu->emu_lock, flags);
 444         /* voice interrupt */
 445         if (voicenum >= 32) {
 446                 outl(SOLEH << 16, emu->port + PTR);
 447                 sol = inl(emu->port + DATA);
 448                 sol |= 1 << (voicenum - 32);
 449         } else {
 450                 outl(SOLEL << 16, emu->port + PTR);
 451                 sol = inl(emu->port + DATA);
 452                 sol |= 1 << voicenum;
 453         }
 454         outl(sol, emu->port + DATA);
 455         spin_unlock_irqrestore(&emu->emu_lock, flags);
 456 }
 457
 458 void snd_emu10k1_voice_clear_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum)
 459 {
 460         unsigned long flags;
 461         unsigned int sol;
 462
 463         spin_lock_irqsave(&emu->emu_lock, flags);
 464         /* voice interrupt */
 465         if (voicenum >= 32) {
 466                 outl(SOLEH << 16, emu->port + PTR);
 467                 sol = inl(emu->port + DATA);
 468                 sol &= ~(1 << (voicenum - 32));
 469         } else {
 470                 outl(SOLEL << 16, emu->port + PTR);
 471                 sol = inl(emu->port + DATA);
 472                 sol &= ~(1 << voicenum);
 473         }
 474         outl(sol, emu->port + DATA);
 475         spin_unlock_irqrestore(&emu->emu_lock, flags);
 476 }
 477
 478 void snd_emu10k1_wait(struct snd_emu10k1 *emu, unsigned int wait)
 479 {
 480         volatile unsigned count;
 481         unsigned int newtime = 0, curtime;
 482
 483         curtime = inl(emu->port + WC) >> 6;
 484         while (wait-- > 0) {
 485                 count = 0;
 486                 while (count++ < 16384) {
 487                         newtime = inl(emu->port + WC) >> 6;
 488                         if (newtime != curtime)
 489                                 break;
 490                 }
 491                 if (count > 16384)
 492                         break;
 493                 curtime = newtime;
 494         }
 495 }
 496
 497 unsigned short snd_emu10k1_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
 498 {
 499         struct snd_emu10k1 *emu = ac97->private_data;
 500         unsigned long flags;
 501         unsigned short val;
 502
 503         spin_lock_irqsave(&emu->emu_lock, flags);
 504         outb(reg, emu->port + AC97ADDRESS);
 505         val = inw(emu->port + AC97DATA);
 506         spin_unlock_irqrestore(&emu->emu_lock, flags);
 507         return val;
 508 }
 509
 510 void snd_emu10k1_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short data)
 511 {
 512         struct snd_emu10k1 *emu = ac97->private_data;
 513         unsigned long flags;
 514
 515         spin_lock_irqsave(&emu->emu_lock, flags);
 516         outb(reg, emu->port + AC97ADDRESS);
 517         outw(data, emu->port + AC97DATA);
 518         spin_unlock_irqrestore(&emu->emu_lock, flags);
 519 }
 520
 521 /*
 522  *  convert rate to pitch
 523  */
 524
 525 unsigned int snd_emu10k1_rate_to_pitch(unsigned int rate)
 526 {
 527         static u32 logMagTable[128] = {
 528                 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
 529                 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
 530                 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
 531                 0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
 532                 0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
 533                 0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
 534                 0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
 535                 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
 536                 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
 537                 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
 538                 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
 539                 0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
 540                 0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
 541                 0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
 542                 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
 543                 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
 544         };
 545         static char logSlopeTable[128] = {
 546                 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
 547                 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
 548                 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
 549                 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
 550                 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
 551                 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
 552                 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
 553                 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
 554                 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
 555                 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
 556                 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
 557                 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
 558                 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
 559                 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
 560                 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
 561                 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
 562         };
 563         int i;
 564
 565         if (rate == 0)
 566                 return 0;       /* Bail out if no leading "1" */
 567         rate *= 11185;          /* Scale 48000 to 0x20002380 */
 568         for (i = 31; i > 0; i--) {
 569                 if (rate & 0x80000000) {        /* Detect leading "1" */
 570                         return (((unsigned int) (i - 15) << 20) +
 571                                logMagTable[0x7f & (rate >> 24)] +
 572                                         (0x7f & (rate >> 17)) *
 573                                         logSlopeTable[0x7f & (rate >> 24)]);
 574                 }
 575                 rate <<= 1;
 576         }
 577
 578         return 0;               /* Should never reach this point */
 579 }
 580