1 2 3/* 4 * sm_sbc.c -- soundcard radio modem driver soundblaster hardware driver 5 * 6 * Copyright (C) 1996 Thomas Sailer (sailer@ife.ee.ethz.ch) 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 * 22 * Please note that the GPL allows you to use the driver, NOT the radio. 23 * In order to use the radio, you need a license from the communications 24 * authority of your country. 25 * 26 */ 27 28#include <linux/ptrace.h> 29#include <linux/sched.h> 30#include <linux/interrupt.h> 31#include <asm/io.h> 32#include <asm/dma.h> 33#include <linux/ioport.h> 34#include <linux/soundmodem.h> 35#include <linux/delay.h> 36#include "sm.h" 37#include "smdma.h" 38 39/* --------------------------------------------------------------------- */ 40 41/* 42 * currently this module is supposed to support both module styles, i.e. 43 * the old one present up to about 2.1.9, and the new one functioning 44 * starting with 2.1.21. The reason is I have a kit allowing to compile 45 * this module also under 2.0.x which was requested by several people. 46 * This will go in 2.2 47 */ 48#include <linux/version.h> 49 50#include <asm/uaccess.h> 51 52/* --------------------------------------------------------------------- */ 53 54struct sc_state_sbc { 55 unsigned char revhi, revlo; 56 unsigned char fmt[2]; 57 unsigned int sr[2]; 58}; 59 60#define SCSTATE ((struct sc_state_sbc *)(&sm->hw)) 61 62/* --------------------------------------------------------------------- */ 63/* 64 * the sbc converter's registers 65 */ 66#define DSP_RESET(iobase) (iobase+0x6) 67#define DSP_READ_DATA(iobase) (iobase+0xa) 68#define DSP_WRITE_DATA(iobase) (iobase+0xc) 69#define DSP_WRITE_STATUS(iobase) (iobase+0xc) 70#define DSP_DATA_AVAIL(iobase) (iobase+0xe) 71#define DSP_MIXER_ADDR(iobase) (iobase+0x4) 72#define DSP_MIXER_DATA(iobase) (iobase+0x5) 73#define DSP_INTACK_16BIT(iobase) (iobase+0xf) 74#define SBC_EXTENT 16 75 76/* --------------------------------------------------------------------- */ 77/* 78 * SBC commands 79 */ 80#define SBC_OUTPUT 0x14 81#define SBC_INPUT 0x24 82#define SBC_BLOCKSIZE 0x48 83#define SBC_HI_OUTPUT 0x91 84#define SBC_HI_INPUT 0x99 85#define SBC_LO_OUTPUT_AUTOINIT 0x1c 86#define SBC_LO_INPUT_AUTOINIT 0x2c 87#define SBC_HI_OUTPUT_AUTOINIT 0x90 88#define SBC_HI_INPUT_AUTOINIT 0x98 89#define SBC_IMMED_INT 0xf2 90#define SBC_GET_REVISION 0xe1 91#define ESS_GET_REVISION 0xe7 92#define SBC_SPEAKER_ON 0xd1 93#define SBC_SPEAKER_OFF 0xd3 94#define SBC_DMA_ON 0xd0 95#define SBC_DMA_OFF 0xd4 96#define SBC_SAMPLE_RATE 0x40 97#define SBC_SAMPLE_RATE_OUT 0x41 98#define SBC_SAMPLE_RATE_IN 0x42 99#define SBC_MONO_8BIT 0xa0 100#define SBC_MONO_16BIT 0xa4 101#define SBC_STEREO_8BIT 0xa8 102#define SBC_STEREO_16BIT 0xac 103 104#define SBC4_OUT8_AI 0xc6 105#define SBC4_IN8_AI 0xce 106#define SBC4_MODE_UNS_MONO 0x00 107#define SBC4_MODE_SIGN_MONO 0x10 108 109#define SBC4_OUT16_AI 0xb6 110#define SBC4_IN16_AI 0xbe 111 112/* --------------------------------------------------------------------- */ 113 114static int inline reset_dsp(struct net_device *dev) 115{ 116 int i; 117 118 outb(1, DSP_RESET(dev->base_addr)); 119 udelay(300); 120 outb(0, DSP_RESET(dev->base_addr)); 121 for (i = 0; i < 0xffff; i++) 122 if (inb(DSP_DATA_AVAIL(dev->base_addr)) & 0x80) 123 if (inb(DSP_READ_DATA(dev->base_addr)) == 0xaa) 124 return 1; 125 return 0; 126} 127 128/* --------------------------------------------------------------------- */ 129 130static void inline write_dsp(struct net_device *dev, unsigned char data) 131{ 132 int i; 133 134 for (i = 0; i < 0xffff; i++) 135 if (!(inb(DSP_WRITE_STATUS(dev->base_addr)) & 0x80)) { 136 outb(data, DSP_WRITE_DATA(dev->base_addr)); 137 return; 138 } 139} 140 141/* --------------------------------------------------------------------- */ 142 143static int inline read_dsp(struct net_device *dev, unsigned char *data) 144{ 145 int i; 146 147 if (!data) 148 return 0; 149 for (i = 0; i < 0xffff; i++) 150 if (inb(DSP_DATA_AVAIL(dev->base_addr)) & 0x80) { 151 *data = inb(DSP_READ_DATA(dev->base_addr)); 152 return 1; 153 } 154 return 0; 155} 156 157/* --------------------------------------------------------------------- */ 158 159static int config_resources(struct net_device *dev, struct sm_state *sm, int fdx) 160{ 161 unsigned char irqreg = 0, dmareg = 0, realirq, realdma; 162 unsigned long flags; 163 164 switch (dev->irq) { 165 case 2: 166 case 9: 167 irqreg |= 0x01; 168 break; 169 170 case 5: 171 irqreg |= 0x02; 172 break; 173 174 case 7: 175 irqreg |= 0x04; 176 break; 177 178 case 10: 179 irqreg |= 0x08; 180 break; 181 182 default: 183 return -ENODEV; 184 } 185 186 switch (dev->dma) { 187 case 0: 188 dmareg |= 0x01; 189 break; 190 191 case 1: 192 dmareg |= 0x02; 193 break; 194 195 case 3: 196 dmareg |= 0x08; 197 break; 198 199 default: 200 return -ENODEV; 201 } 202 203 if (fdx) { 204 switch (sm->hdrv.ptt_out.dma2) { 205 case 5: 206 dmareg |= 0x20; 207 break; 208 209 case 6: 210 dmareg |= 0x40; 211 break; 212 213 case 7: 214 dmareg |= 0x80; 215 break; 216 217 default: 218 return -ENODEV; 219 } 220 } 221 save_flags(flags); 222 cli(); 223 outb(0x80, DSP_MIXER_ADDR(dev->base_addr)); 224 outb(irqreg, DSP_MIXER_DATA(dev->base_addr)); 225 realirq = inb(DSP_MIXER_DATA(dev->base_addr)); 226 outb(0x81, DSP_MIXER_ADDR(dev->base_addr)); 227 outb(dmareg, DSP_MIXER_DATA(dev->base_addr)); 228 realdma = inb(DSP_MIXER_DATA(dev->base_addr)); 229 restore_flags(flags); 230 if ((~realirq) & irqreg || (~realdma) & dmareg) { 231 printk(KERN_ERR "%s: sbc resource registers cannot be set; PnP device " 232 "and IRQ/DMA specified wrongly?\n", sm_drvname); 233 return -EINVAL; 234 } 235 return 0; 236} 237 238/* --------------------------------------------------------------------- */ 239 240static void inline sbc_int_ack_8bit(struct net_device *dev) 241{ 242 inb(DSP_DATA_AVAIL(dev->base_addr)); 243} 244 245/* --------------------------------------------------------------------- */ 246 247static void inline sbc_int_ack_16bit(struct net_device *dev) 248{ 249 inb(DSP_INTACK_16BIT(dev->base_addr)); 250} 251 252/* --------------------------------------------------------------------- */ 253 254static void setup_dma_dsp(struct net_device *dev, struct sm_state *sm, int send) 255{ 256 unsigned long flags; 257 static const unsigned char sbcmode[2][2] = { 258 { SBC_LO_INPUT_AUTOINIT, SBC_LO_OUTPUT_AUTOINIT }, 259 { SBC_HI_INPUT_AUTOINIT, SBC_HI_OUTPUT_AUTOINIT } 260 }; 261 static const unsigned char sbc4mode[2] = { SBC4_IN8_AI, SBC4_OUT8_AI }; 262 static const unsigned char sbcskr[2] = { SBC_SPEAKER_OFF, SBC_SPEAKER_ON }; 263 unsigned int nsamps; 264 265 send = !!send; 266 if (!reset_dsp(dev)) { 267 printk(KERN_ERR "%s: sbc: cannot reset sb dsp\n", sm_drvname); 268 return; 269 } 270 save_flags(flags); 271 cli(); 272 sbc_int_ack_8bit(dev); 273 write_dsp(dev, SBC_SAMPLE_RATE); /* set sampling rate */ 274 write_dsp(dev, SCSTATE->fmt[send]); 275 write_dsp(dev, sbcskr[send]); 276 nsamps = dma_setup(sm, send, dev->dma) - 1; 277 sbc_int_ack_8bit(dev); 278 if (SCSTATE->revhi >= 4) { 279 write_dsp(dev, sbc4mode[send]); 280 write_dsp(dev, SBC4_MODE_UNS_MONO); 281 write_dsp(dev, nsamps & 0xff); 282 write_dsp(dev, nsamps >> 8); 283 } else { 284 write_dsp(dev, SBC_BLOCKSIZE); 285 write_dsp(dev, nsamps & 0xff); 286 write_dsp(dev, nsamps >> 8); 287 write_dsp(dev, sbcmode[SCSTATE->fmt[send] >= 180][send]); 288 /* hispeed mode if sample rate > 13kHz */ 289 } 290 restore_flags(flags); 291} 292 293/* --------------------------------------------------------------------- */ 294 295static void sbc_interrupt(int irq, void *dev_id, struct pt_regs *regs) 296{ 297 struct net_device *dev = (struct net_device *)dev_id; 298 struct sm_state *sm = (struct sm_state *)dev->priv; 299 unsigned int curfrag; 300 301 if (!dev || !sm || sm->hdrv.magic != HDLCDRV_MAGIC) 302 return; 303 cli(); 304 sbc_int_ack_8bit(dev); 305 disable_dma(dev->dma); 306 clear_dma_ff(dev->dma); 307 dma_ptr(sm, sm->dma.ptt_cnt > 0, dev->dma, &curfrag); 308 enable_dma(dev->dma); 309 sm_int_freq(sm); 310 sti(); 311 if (sm->dma.ptt_cnt <= 0) { 312 dma_receive(sm, curfrag); 313 hdlcdrv_arbitrate(dev, &sm->hdrv); 314 if (hdlcdrv_ptt(&sm->hdrv)) { 315 /* starting to transmit */ 316 disable_dma(dev->dma); 317 hdlcdrv_transmitter(dev, &sm->hdrv); /* prefill HDLC buffer */ 318 dma_start_transmit(sm); 319 setup_dma_dsp(dev, sm, 1); 320 dma_transmit(sm); 321 } 322 } else if (dma_end_transmit(sm, curfrag)) { 323 /* stopping transmission */ 324 disable_dma(dev->dma); 325 sti(); 326 dma_init_receive(sm); 327 setup_dma_dsp(dev, sm, 0); 328 } else 329 dma_transmit(sm); 330 sm_output_status(sm); 331 hdlcdrv_transmitter(dev, &sm->hdrv); 332 hdlcdrv_receiver(dev, &sm->hdrv); 333 334} 335 336/* --------------------------------------------------------------------- */ 337 338static int sbc_open(struct net_device *dev, struct sm_state *sm) 339{ 340 int err; 341 unsigned int dmasz, u; 342 343 if (sizeof(sm->m) < sizeof(struct sc_state_sbc)) { 344 printk(KERN_ERR "sm sbc: sbc state too big: %d > %d\n", 345 sizeof(struct sc_state_sbc), sizeof(sm->m)); 346 return -ENODEV; 347 } 348 if (!dev || !sm) 349 return -ENXIO; 350 if (dev->base_addr <= 0 || dev->base_addr > 0x1000-SBC_EXTENT || 351 dev->irq < 2 || dev->irq > 15 || dev->dma > 3) 352 return -ENXIO; 353 if (check_region(dev->base_addr, SBC_EXTENT)) 354 return -EACCES; 355 /* 356 * check if a card is available 357 */ 358 if (!reset_dsp(dev)) { 359 printk(KERN_ERR "%s: sbc: no card at io address 0x%lx\n", 360 sm_drvname, dev->base_addr); 361 return -ENODEV; 362 } 363 write_dsp(dev, SBC_GET_REVISION); 364 if (!read_dsp(dev, &SCSTATE->revhi) || 365 !read_dsp(dev, &SCSTATE->revlo)) 366 return -ENODEV; 367 printk(KERN_INFO "%s: SoundBlaster DSP revision %d.%d\n", sm_drvname, 368 SCSTATE->revhi, SCSTATE->revlo); 369 if (SCSTATE->revhi < 2) { 370 printk(KERN_ERR "%s: your card is an antiquity, at least DSP " 371 "rev 2.00 required\n", sm_drvname); 372 return -ENODEV; 373 } 374 if (SCSTATE->revhi < 3 && 375 (SCSTATE->fmt[0] >= 180 || SCSTATE->fmt[1] >= 180)) { 376 printk(KERN_ERR "%s: sbc io 0x%lx: DSP rev %d.%02d too " 377 "old, at least 3.00 required\n", sm_drvname, 378 dev->base_addr, SCSTATE->revhi, SCSTATE->revlo); 379 return -ENODEV; 380 } 381 if (SCSTATE->revhi >= 4 && 382 (err = config_resources(dev, sm, 0))) { 383 printk(KERN_ERR "%s: invalid IRQ and/or DMA specified\n", sm_drvname); 384 return err; 385 } 386 /* 387 * initialize some variables 388 */ 389 dma_init_receive(sm); 390 dmasz = (NUM_FRAGMENTS + 1) * sm->dma.ifragsz; 391 u = NUM_FRAGMENTS * sm->dma.ofragsz; 392 if (u > dmasz) 393 dmasz = u; 394 if (!(sm->dma.ibuf = sm->dma.obuf = kmalloc(dmasz, GFP_KERNEL | GFP_DMA))) 395 return -ENOMEM; 396 dma_init_transmit(sm); 397 dma_init_receive(sm); 398 399 memset(&sm->m, 0, sizeof(sm->m)); 400 memset(&sm->d, 0, sizeof(sm->d)); 401 if (sm->mode_tx->init) 402 sm->mode_tx->init(sm); 403 if (sm->mode_rx->init) 404 sm->mode_rx->init(sm); 405 406 if (request_dma(dev->dma, sm->hwdrv->hw_name)) { 407 kfree(sm->dma.obuf); 408 return -EBUSY; 409 } 410 if (request_irq(dev->irq, sbc_interrupt, SA_INTERRUPT, 411 sm->hwdrv->hw_name, dev)) { 412 free_dma(dev->dma); 413 kfree(sm->dma.obuf); 414 return -EBUSY; 415 } 416 request_region(dev->base_addr, SBC_EXTENT, sm->hwdrv->hw_name); 417 setup_dma_dsp(dev, sm, 0); 418 return 0; 419} 420 421/* --------------------------------------------------------------------- */ 422 423static int sbc_close(struct net_device *dev, struct sm_state *sm) 424{ 425 if (!dev || !sm) 426 return -EINVAL; 427 /* 428 * disable interrupts 429 */ 430 disable_dma(dev->dma); 431 reset_dsp(dev); 432 free_irq(dev->irq, dev); 433 free_dma(dev->dma); 434 release_region(dev->base_addr, SBC_EXTENT); 435 kfree(sm->dma.obuf); 436 return 0; 437} 438 439/* --------------------------------------------------------------------- */ 440 441static int sbc_sethw(struct net_device *dev, struct sm_state *sm, char *mode) 442{ 443 char *cp = strchr(mode, '.'); 444 const struct modem_tx_info **mtp = sm_modem_tx_table; 445 const struct modem_rx_info **mrp; 446 447 if (!strcmp(mode, "off")) { 448 sm->mode_tx = NULL; 449 sm->mode_rx = NULL; 450 return 0; 451 } 452 if (cp) 453 *cp++ = '\0'; 454 else 455 cp = mode; 456 for (; *mtp; mtp++) { 457 if ((*mtp)->loc_storage > sizeof(sm->m)) { 458 printk(KERN_ERR "%s: insufficient storage for modulator %s (%d)\n", 459 sm_drvname, (*mtp)->name, (*mtp)->loc_storage); 460 continue; 461 } 462 if (!(*mtp)->name || strcmp((*mtp)->name, mode)) 463 continue; 464 if ((*mtp)->srate < 5000 || (*mtp)->srate > 44100) 465 continue; 466 if (!(*mtp)->modulator_u8) 467 continue; 468 for (mrp = sm_modem_rx_table; *mrp; mrp++) { 469 if ((*mrp)->loc_storage > sizeof(sm->d)) { 470 printk(KERN_ERR "%s: insufficient storage for demodulator %s (%d)\n", 471 sm_drvname, (*mrp)->name, (*mrp)->loc_storage); 472 continue; 473 } 474 if (!(*mrp)->demodulator_u8) 475 continue; 476 if ((*mrp)->name && !strcmp((*mrp)->name, cp) && 477 (*mrp)->srate >= 5000 && (*mrp)->srate <= 44100) { 478 sm->mode_tx = *mtp; 479 sm->mode_rx = *mrp; 480 SCSTATE->fmt[0] = 256-((1000000L+sm->mode_rx->srate/2)/ 481 sm->mode_rx->srate); 482 SCSTATE->fmt[1] = 256-((1000000L+sm->mode_tx->srate/2)/ 483 sm->mode_tx->srate); 484 sm->dma.ifragsz = (sm->mode_rx->srate + 50)/100; 485 sm->dma.ofragsz = (sm->mode_tx->srate + 50)/100; 486 if (sm->dma.ifragsz < sm->mode_rx->overlap) 487 sm->dma.ifragsz = sm->mode_rx->overlap; 488 sm->dma.i16bit = sm->dma.o16bit = 0; 489 return 0; 490 } 491 } 492 } 493 return -EINVAL; 494} 495 496/* --------------------------------------------------------------------- */ 497 498static int sbc_ioctl(struct net_device *dev, struct sm_state *sm, struct ifreq *ifr, 499 struct hdlcdrv_ioctl *hi, int cmd) 500{ 501 struct sm_ioctl bi; 502 unsigned long flags; 503 int i; 504 505 if (cmd != SIOCDEVPRIVATE) 506 return -ENOIOCTLCMD; 507 508 if (hi->cmd == HDLCDRVCTL_MODEMPARMASK) 509 return HDLCDRV_PARMASK_IOBASE | HDLCDRV_PARMASK_IRQ | 510 HDLCDRV_PARMASK_DMA | HDLCDRV_PARMASK_SERIOBASE | 511 HDLCDRV_PARMASK_PARIOBASE | HDLCDRV_PARMASK_MIDIIOBASE; 512 513 if (copy_from_user(&bi, ifr->ifr_data, sizeof(bi))) 514 return -EFAULT; 515 516 switch (bi.cmd) { 517 default: 518 return -ENOIOCTLCMD; 519 520 case SMCTL_GETMIXER: 521 i = 0; 522 bi.data.mix.sample_rate = sm->mode_rx->srate; 523 bi.data.mix.bit_rate = sm->hdrv.par.bitrate; 524 bi.data.mix.mixer_type = SM_MIXER_INVALID; 525 switch (SCSTATE->revhi) { 526 case 2: 527 bi.data.mix.mixer_type = SM_MIXER_CT1335; 528 break; 529 case 3: 530 bi.data.mix.mixer_type = SM_MIXER_CT1345; 531 break; 532 case 4: 533 bi.data.mix.mixer_type = SM_MIXER_CT1745; 534 break; 535 } 536 if (bi.data.mix.mixer_type != SM_MIXER_INVALID && 537 bi.data.mix.reg < 0x80) { 538 save_flags(flags); 539 cli(); 540 outb(bi.data.mix.reg, DSP_MIXER_ADDR(dev->base_addr)); 541 bi.data.mix.data = inb(DSP_MIXER_DATA(dev->base_addr)); 542 restore_flags(flags); 543 i = 1; 544 } 545 if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi))) 546 return -EFAULT; 547 return i; 548 549 case SMCTL_SETMIXER: 550 if (!capable(CAP_SYS_RAWIO)) 551 return -EACCES; 552 switch (SCSTATE->revhi) { 553 case 2: 554 if (bi.data.mix.mixer_type != SM_MIXER_CT1335) 555 return -EINVAL; 556 break; 557 case 3: 558 if (bi.data.mix.mixer_type != SM_MIXER_CT1345) 559 return -EINVAL; 560 break; 561 case 4: 562 if (bi.data.mix.mixer_type != SM_MIXER_CT1745) 563 return -EINVAL; 564 break; 565 default: 566 return -ENODEV; 567 } 568 if (bi.data.mix.reg >= 0x80) 569 return -EACCES; 570 save_flags(flags); 571 cli(); 572 outb(bi.data.mix.reg, DSP_MIXER_ADDR(dev->base_addr)); 573 outb(bi.data.mix.data, DSP_MIXER_DATA(dev->base_addr)); 574 restore_flags(flags); 575 return 0; 576 577 } 578 if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi))) 579 return -EFAULT; 580 return 0; 581 582} 583 584/* --------------------------------------------------------------------- */ 585 586const struct hardware_info sm_hw_sbc = { 587 "sbc", sizeof(struct sc_state_sbc), 588 sbc_open, sbc_close, sbc_ioctl, sbc_sethw 589}; 590 591/* --------------------------------------------------------------------- */ 592 593static void setup_dma_fdx_dsp(struct net_device *dev, struct sm_state *sm) 594{ 595 unsigned long flags; 596 unsigned int isamps, osamps; 597 598 if (!reset_dsp(dev)) { 599 printk(KERN_ERR "%s: sbc: cannot reset sb dsp\n", sm_drvname); 600 return; 601 } 602 save_flags(flags); 603 cli(); 604 sbc_int_ack_8bit(dev); 605 sbc_int_ack_16bit(dev); 606 /* should eventually change to set rates individually by SBC_SAMPLE_RATE_{IN/OUT} */ 607 write_dsp(dev, SBC_SAMPLE_RATE_IN); 608 write_dsp(dev, SCSTATE->sr[0] >> 8); 609 write_dsp(dev, SCSTATE->sr[0] & 0xff); 610 write_dsp(dev, SBC_SAMPLE_RATE_OUT); 611 write_dsp(dev, SCSTATE->sr[1] >> 8); 612 write_dsp(dev, SCSTATE->sr[1] & 0xff); 613 write_dsp(dev, SBC_SPEAKER_ON); 614 if (sm->dma.o16bit) { 615 /* 616 * DMA channel 1 (8bit) does input (capture), 617 * DMA channel 2 (16bit) does output (playback) 618 */ 619 isamps = dma_setup(sm, 0, dev->dma) - 1; 620 osamps = dma_setup(sm, 1, sm->hdrv.ptt_out.dma2) - 1; 621 sbc_int_ack_8bit(dev); 622 sbc_int_ack_16bit(dev); 623 write_dsp(dev, SBC4_IN8_AI); 624 write_dsp(dev, SBC4_MODE_UNS_MONO); 625 write_dsp(dev, isamps & 0xff); 626 write_dsp(dev, isamps >> 8); 627 write_dsp(dev, SBC4_OUT16_AI); 628 write_dsp(dev, SBC4_MODE_SIGN_MONO); 629 write_dsp(dev, osamps & 0xff); 630 write_dsp(dev, osamps >> 8); 631 } else { 632 /* 633 * DMA channel 1 (8bit) does output (playback), 634 * DMA channel 2 (16bit) does input (capture) 635 */ 636 isamps = dma_setup(sm, 0, sm->hdrv.ptt_out.dma2) - 1; 637 osamps = dma_setup(sm, 1, dev->dma) - 1; 638 sbc_int_ack_8bit(dev); 639 sbc_int_ack_16bit(dev); 640 write_dsp(dev, SBC4_OUT8_AI); 641 write_dsp(dev, SBC4_MODE_UNS_MONO); 642 write_dsp(dev, osamps & 0xff); 643 write_dsp(dev, osamps >> 8); 644 write_dsp(dev, SBC4_IN16_AI); 645 write_dsp(dev, SBC4_MODE_SIGN_MONO); 646 write_dsp(dev, isamps & 0xff); 647 write_dsp(dev, isamps >> 8); 648 } 649 dma_init_receive(sm); 650 dma_init_transmit(sm); 651 restore_flags(flags); 652} 653 654/* --------------------------------------------------------------------- */ 655 656static void sbcfdx_interrupt(int irq, void *dev_id, struct pt_regs *regs) 657{ 658 struct net_device *dev = (struct net_device *)dev_id; 659 struct sm_state *sm = (struct sm_state *)dev->priv; 660 unsigned char intsrc, pbint = 0, captint = 0; 661 unsigned int ocfrag, icfrag; 662 unsigned long flags; 663 664 if (!dev || !sm || sm->hdrv.magic != HDLCDRV_MAGIC) 665 return; 666 save_flags(flags); 667 cli(); 668 outb(0x82, DSP_MIXER_ADDR(dev->base_addr)); 669 intsrc = inb(DSP_MIXER_DATA(dev->base_addr)); 670 if (intsrc & 0x01) { 671 sbc_int_ack_8bit(dev); 672 if (sm->dma.o16bit) { 673 captint = 1; 674 disable_dma(dev->dma); 675 clear_dma_ff(dev->dma); 676 dma_ptr(sm, 0, dev->dma, &icfrag); 677 enable_dma(dev->dma); 678 } else { 679 pbint = 1; 680 disable_dma(dev->dma); 681 clear_dma_ff(dev->dma); 682 dma_ptr(sm, 1, dev->dma, &ocfrag); 683 enable_dma(dev->dma); 684 } 685 } 686 if (intsrc & 0x02) { 687 sbc_int_ack_16bit(dev); 688 if (sm->dma.o16bit) { 689 pbint = 1; 690 disable_dma(sm->hdrv.ptt_out.dma2); 691 clear_dma_ff(sm->hdrv.ptt_out.dma2); 692 dma_ptr(sm, 1, sm->hdrv.ptt_out.dma2, &ocfrag); 693 enable_dma(sm->hdrv.ptt_out.dma2); 694 } else { 695 captint = 1; 696 disable_dma(sm->hdrv.ptt_out.dma2); 697 clear_dma_ff(sm->hdrv.ptt_out.dma2); 698 dma_ptr(sm, 0, sm->hdrv.ptt_out.dma2, &icfrag); 699 enable_dma(sm->hdrv.ptt_out.dma2); 700 } 701 } 702 restore_flags(flags); 703 sm_int_freq(sm); 704 sti(); 705 if (pbint) { 706 if (dma_end_transmit(sm, ocfrag)) 707 dma_clear_transmit(sm); 708 dma_transmit(sm); 709 } 710 if (captint) { 711 dma_receive(sm, icfrag); 712 hdlcdrv_arbitrate(dev, &sm->hdrv); 713 } 714 sm_output_status(sm); 715 hdlcdrv_transmitter(dev, &sm->hdrv); 716 hdlcdrv_receiver(dev, &sm->hdrv); 717} 718 719/* --------------------------------------------------------------------- */ 720 721static int sbcfdx_open(struct net_device *dev, struct sm_state *sm) 722{ 723 int err; 724 725 if (sizeof(sm->m) < sizeof(struct sc_state_sbc)) { 726 printk(KERN_ERR "sm sbc: sbc state too big: %d > %d\n", 727 sizeof(struct sc_state_sbc), sizeof(sm->m)); 728 return -ENODEV; 729 } 730 if (!dev || !sm) 731 return -ENXIO; 732 if (dev->base_addr <= 0 || dev->base_addr > 0x1000-SBC_EXTENT || 733 dev->irq < 2 || dev->irq > 15 || dev->dma > 3) 734 return -ENXIO; 735 if (check_region(dev->base_addr, SBC_EXTENT)) 736 return -EACCES; 737 /* 738 * check if a card is available 739 */ 740 if (!reset_dsp(dev)) { 741 printk(KERN_ERR "%s: sbc: no card at io address 0x%lx\n", 742 sm_drvname, dev->base_addr); 743 return -ENODEV; 744 } 745 write_dsp(dev, SBC_GET_REVISION); 746 if (!read_dsp(dev, &SCSTATE->revhi) || 747 !read_dsp(dev, &SCSTATE->revlo)) 748 return -ENODEV; 749 printk(KERN_INFO "%s: SoundBlaster DSP revision %d.%d\n", sm_drvname, 750 SCSTATE->revhi, SCSTATE->revlo); 751 if (SCSTATE->revhi < 4) { 752 printk(KERN_ERR "%s: at least DSP rev 4.00 required\n", sm_drvname); 753 return -ENODEV; 754 } 755 if ((err = config_resources(dev, sm, 1))) { 756 printk(KERN_ERR "%s: invalid IRQ and/or DMA specified\n", sm_drvname); 757 return err; 758 } 759 /* 760 * initialize some variables 761 */ 762 if (!(sm->dma.ibuf = kmalloc(sm->dma.ifragsz * (NUM_FRAGMENTS+1), GFP_KERNEL | GFP_DMA))) 763 return -ENOMEM; 764 if (!(sm->dma.obuf = kmalloc(sm->dma.ofragsz * NUM_FRAGMENTS, GFP_KERNEL | GFP_DMA))) { 765 kfree(sm->dma.ibuf); 766 return -ENOMEM; 767 } 768 dma_init_transmit(sm); 769 dma_init_receive(sm); 770 771 memset(&sm->m, 0, sizeof(sm->m)); 772 memset(&sm->d, 0, sizeof(sm->d)); 773 if (sm->mode_tx->init) 774 sm->mode_tx->init(sm); 775 if (sm->mode_rx->init) 776 sm->mode_rx->init(sm); 777 778 if (request_dma(dev->dma, sm->hwdrv->hw_name)) { 779 kfree(sm->dma.ibuf); 780 kfree(sm->dma.obuf); 781 return -EBUSY; 782 } 783 if (request_dma(sm->hdrv.ptt_out.dma2, sm->hwdrv->hw_name)) { 784 kfree(sm->dma.ibuf); 785 kfree(sm->dma.obuf); 786 free_dma(dev->dma); 787 return -EBUSY; 788 } 789 if (request_irq(dev->irq, sbcfdx_interrupt, SA_INTERRUPT, 790 sm->hwdrv->hw_name, dev)) { 791 kfree(sm->dma.ibuf); 792 kfree(sm->dma.obuf); 793 free_dma(dev->dma); 794 free_dma(sm->hdrv.ptt_out.dma2); 795 return -EBUSY; 796 } 797 request_region(dev->base_addr, SBC_EXTENT, sm->hwdrv->hw_name); 798 setup_dma_fdx_dsp(dev, sm); 799 return 0; 800} 801 802/* --------------------------------------------------------------------- */ 803 804static int sbcfdx_close(struct net_device *dev, struct sm_state *sm) 805{ 806 if (!dev || !sm) 807 return -EINVAL; 808 /* 809 * disable interrupts 810 */ 811 disable_dma(dev->dma); 812 disable_dma(sm->hdrv.ptt_out.dma2); 813 reset_dsp(dev); 814 free_irq(dev->irq, dev); 815 free_dma(dev->dma); 816 free_dma(sm->hdrv.ptt_out.dma2); 817 release_region(dev->base_addr, SBC_EXTENT); 818 kfree(sm->dma.ibuf); 819 kfree(sm->dma.obuf); 820 return 0; 821} 822 823/* --------------------------------------------------------------------- */ 824 825static int sbcfdx_sethw(struct net_device *dev, struct sm_state *sm, char *mode) 826{ 827 char *cp = strchr(mode, '.'); 828 const struct modem_tx_info **mtp = sm_modem_tx_table; 829 const struct modem_rx_info **mrp; 830 831 if (!strcmp(mode, "off")) { 832 sm->mode_tx = NULL; 833 sm->mode_rx = NULL; 834 return 0; 835 } 836 if (cp) 837 *cp++ = '\0'; 838 else 839 cp = mode; 840 for (; *mtp; mtp++) { 841 if ((*mtp)->loc_storage > sizeof(sm->m)) { 842 printk(KERN_ERR "%s: insufficient storage for modulator %s (%d)\n", 843 sm_drvname, (*mtp)->name, (*mtp)->loc_storage); 844 continue; 845 } 846 if (!(*mtp)->name || strcmp((*mtp)->name, mode)) 847 continue; 848 if ((*mtp)->srate < 5000 || (*mtp)->srate > 44100) 849 continue; 850 for (mrp = sm_modem_rx_table; *mrp; mrp++) { 851 if ((*mrp)->loc_storage > sizeof(sm->d)) { 852 printk(KERN_ERR "%s: insufficient storage for demodulator %s (%d)\n", 853 sm_drvname, (*mrp)->name, (*mrp)->loc_storage); 854 continue; 855 } 856 if ((*mrp)->name && !strcmp((*mrp)->name, cp) && 857 (*mtp)->srate >= 5000 && (*mtp)->srate <= 44100 && 858 (*mrp)->srate == (*mtp)->srate) { 859 sm->mode_tx = *mtp; 860 sm->mode_rx = *mrp; 861 SCSTATE->sr[0] = sm->mode_rx->srate; 862 SCSTATE->sr[1] = sm->mode_tx->srate; 863 sm->dma.ifragsz = (sm->mode_rx->srate + 50)/100; 864 sm->dma.ofragsz = (sm->mode_tx->srate + 50)/100; 865 if (sm->dma.ifragsz < sm->mode_rx->overlap) 866 sm->dma.ifragsz = sm->mode_rx->overlap; 867 if (sm->mode_rx->demodulator_s16 && sm->mode_tx->modulator_u8) { 868 sm->dma.i16bit = 1; 869 sm->dma.o16bit = 0; 870 sm->dma.ifragsz <<= 1; 871 } else if (sm->mode_rx->demodulator_u8 && sm->mode_tx->modulator_s16) { 872 sm->dma.i16bit = 0; 873 sm->dma.o16bit = 1; 874 sm->dma.ofragsz <<= 1; 875 } else { 876 printk(KERN_INFO "%s: mode %s or %s unusable\n", sm_drvname, 877 sm->mode_rx->name, sm->mode_tx->name); 878 sm->mode_tx = NULL; 879 sm->mode_rx = NULL; 880 return -EINVAL; 881 } 882 return 0; 883 } 884 } 885 } 886 return -EINVAL; 887} 888 889/* --------------------------------------------------------------------- */ 890 891static int sbcfdx_ioctl(struct net_device *dev, struct sm_state *sm, struct ifreq *ifr, 892 struct hdlcdrv_ioctl *hi, int cmd) 893{ 894 if (cmd != SIOCDEVPRIVATE) 895 return -ENOIOCTLCMD; 896 897 if (hi->cmd == HDLCDRVCTL_MODEMPARMASK) 898 return HDLCDRV_PARMASK_IOBASE | HDLCDRV_PARMASK_IRQ | 899 HDLCDRV_PARMASK_DMA | HDLCDRV_PARMASK_DMA2 | HDLCDRV_PARMASK_SERIOBASE | 900 HDLCDRV_PARMASK_PARIOBASE | HDLCDRV_PARMASK_MIDIIOBASE; 901 902 return sbc_ioctl(dev, sm, ifr, hi, cmd); 903} 904 905/* --------------------------------------------------------------------- */ 906 907const struct hardware_info sm_hw_sbcfdx = { 908 "sbcfdx", sizeof(struct sc_state_sbc), 909 sbcfdx_open, sbcfdx_close, sbcfdx_ioctl, sbcfdx_sethw 910}; 911 912/* --------------------------------------------------------------------- */ 913