← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/intel_sst/intelmid.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/intel_sst/intelmid.c
32
32
#include <linux/platform_device.h>
33
33
#include <linux/interrupt.h>
34
34
#include <linux/sched.h>
 
35
#include <linux/firmware.h>
 
36
#include <linux/input.h>
35
37
#include <sound/control.h>
36
38
#include <asm/mrst.h>
37
39
#include <sound/pcm.h>
38
 
#include "jack.h"
 
40
#include <sound/jack.h>
39
41
#include <sound/pcm_params.h>
40
42
#include <sound/initval.h>
 
43
#include <linux/gpio.h>
41
44
#include "intel_sst.h"
42
45
#include "intel_sst_ioctl.h"
 
46
#include "intel_sst_fw_ipc.h"
 
47
#include "intel_sst_common.h"
43
48
#include "intelmid_snd_control.h"
 
49
#include "intelmid_adc_control.h"
44
50
#include "intelmid.h"
45
51
 
46
52
MODULE_AUTHOR("Vinod Koul <vinod.koul@intel.com>");
62
68
 
63
69
int     sst_card_vendor_id;
64
70
int intelmid_audio_interrupt_enable;/*checkpatch fix*/
 
71
struct snd_intelmad *intelmad_drv;
65
72
 
 
73
#define INFO(_cpu_id, _irq_cache, _size) \
 
74
        ((kernel_ulong_t)&(struct snd_intelmad_probe_info) {    \
 
75
                .cpu_id = (_cpu_id),                    \
 
76
                .irq_cache = (_irq_cache),                      \
 
77
                .size = (_size),                                \
 
78
        })
66
79
/* Data path functionalities */
67
80
static struct snd_pcm_hardware snd_intelmad_stream = {
68
81
        .info = (SNDRV_PCM_INFO_INTERLEAVED |
184
197
                return ret_val;
185
198
        }
186
199
 
187
 
         ret_val = snd_intelmad_alloc_stream(substream);
 
200
        ret_val = snd_intelmad_alloc_stream(substream);
188
201
        if (ret_val < 0)
189
202
                return ret_val;
190
203
        stream->dbg_cum_bytes = 0;
323
336
        runtime = substream->runtime;
324
337
        /* set the runtime hw parameter with local snd_pcm_hardware struct */
325
338
        runtime->hw = snd_intelmad_stream;
 
339
        if (intelmaddata->cpu_id == CPU_CHIP_LINCROFT) {
 
340
                /*
 
341
                 * MRST firmware currently denies stereo recording requests.
 
342
                 */
 
343
                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
 
344
                        runtime->hw.formats = (SNDRV_PCM_FMTBIT_S16 |
 
345
                                               SNDRV_PCM_FMTBIT_U16);
 
346
                        runtime->hw.channels_max = 1;
 
347
                }
 
348
        }
326
349
        if (intelmaddata->cpu_id == CPU_CHIP_PENWELL) {
327
350
                runtime->hw = snd_intelmad_stream;
328
351
                runtime->hw.rates = SNDRV_PCM_RATE_48000;
423
446
        .pointer = snd_intelmad_pcm_pointer,
424
447
};
425
448
 
426
 
 
 
449
int intelmad_get_mic_bias(void)
 
450
{
 
451
        struct snd_pmic_ops *pmic_ops;
 
452
 
 
453
        if (!intelmad_drv || !intelmad_drv->sstdrv_ops)
 
454
                return -ENODEV;
 
455
        pmic_ops = intelmad_drv->sstdrv_ops->scard_ops;
 
456
        if (pmic_ops && pmic_ops->pmic_get_mic_bias)
 
457
                return pmic_ops->pmic_get_mic_bias(intelmad_drv);
 
458
        else
 
459
                return -ENODEV;
 
460
}
 
461
EXPORT_SYMBOL_GPL(intelmad_get_mic_bias);
 
462
 
 
463
int intelmad_set_headset_state(int state)
 
464
{
 
465
        struct snd_pmic_ops *pmic_ops;
 
466
 
 
467
        if (!intelmad_drv || !intelmad_drv->sstdrv_ops)
 
468
                return -ENODEV;
 
469
        pmic_ops = intelmad_drv->sstdrv_ops->scard_ops;
 
470
        if (pmic_ops && pmic_ops->pmic_set_headset_state)
 
471
                return pmic_ops->pmic_set_headset_state(state);
 
472
        else
 
473
                return -ENODEV;
 
474
}
 
475
EXPORT_SYMBOL_GPL(intelmad_set_headset_state);
 
476
 
 
477
void sst_process_mad_jack_detection(struct work_struct *work)
 
478
{
 
479
        u8 interrupt_status;
 
480
        struct mad_jack_msg_wq *mad_jack_detect =
 
481
                        container_of(work, struct mad_jack_msg_wq, wq);
 
482
 
 
483
        struct snd_intelmad *intelmaddata =
 
484
                        mad_jack_detect->intelmaddata;
 
485
 
 
486
        if (!intelmaddata)
 
487
                return;
 
488
 
 
489
        interrupt_status = mad_jack_detect->intsts;
 
490
        if (intelmaddata->sstdrv_ops && intelmaddata->sstdrv_ops->scard_ops
 
491
                        && intelmaddata->sstdrv_ops->scard_ops->pmic_irq_cb) {
 
492
                intelmaddata->sstdrv_ops->scard_ops->pmic_irq_cb(
 
493
                        (void *)intelmaddata, interrupt_status);
 
494
                intelmaddata->sstdrv_ops->scard_ops->pmic_jack_enable();
 
495
        }
 
496
        kfree(mad_jack_detect);
 
497
}
427
498
/**
428
499
 * snd_intelmad_intr_handler- interrupt handler
429
500
 *
436
507
{
437
508
        struct snd_intelmad *intelmaddata =
438
509
                        (struct snd_intelmad *)dev;
439
 
        u8 intsts;
440
 
 
441
 
        memcpy_fromio(&intsts,
 
510
        u8 interrupt_status;
 
511
        struct mad_jack_msg_wq  *mad_jack_msg;
 
512
        memcpy_fromio(&interrupt_status,
442
513
                        ((void *)(intelmaddata->int_base)),
443
514
                        sizeof(u8));
444
 
        intelmaddata->mad_jack_msg.intsts = intsts;
445
 
        intelmaddata->mad_jack_msg.intelmaddata = intelmaddata;
446
515
 
447
 
        queue_work(intelmaddata->mad_jack_wq, &intelmaddata->mad_jack_msg.wq);
 
516
        mad_jack_msg = kzalloc(sizeof(*mad_jack_msg), GFP_ATOMIC);
 
517
        mad_jack_msg->intsts = interrupt_status;
 
518
        mad_jack_msg->intelmaddata = intelmaddata;
 
519
        INIT_WORK(&mad_jack_msg->wq, sst_process_mad_jack_detection);
 
520
        queue_work(intelmaddata->mad_jack_wq, &mad_jack_msg->wq);
448
521
 
449
522
        return IRQ_HANDLED;
450
523
}
457
530
                pr_debug("MAD error jack empty\n");
458
531
 
459
532
        } else {
460
 
                pr_debug("MAD send jack report for = %d!!!\n", status);
461
 
                pr_debug("MAD send jack report %d\n", jack->type);
462
533
                snd_jack_report(jack, status);
463
 
 
464
 
                /*button pressed and released */
 
534
                /* button pressed and released */
465
535
                if (buttonpressevent)
466
536
                        snd_jack_report(jack, 0);
467
537
                pr_debug("MAD sending jack report Done !!!\n");
468
538
        }
469
 
 
470
 
 
471
 
 
472
 
}
473
 
 
474
 
void sst_mad_jackdetection_fs(u8 intsts , struct snd_intelmad *intelmaddata)
475
 
{
476
 
        struct snd_jack *jack = NULL;
477
 
        unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
478
 
        struct sc_reg_access sc_access[] = {
479
 
                                {0x187, 0x00, MASK7},
480
 
                                {0x188, 0x10, MASK4},
481
 
                                {0x18b, 0x10, MASK4},
482
 
        };
483
 
 
484
 
        struct sc_reg_access sc_access_write[] = {
485
 
                                {0x198, 0x00, 0x0},
486
 
        };
487
 
 
488
 
        if (intsts & 0x4) {
489
 
 
490
 
                if (!(intelmid_audio_interrupt_enable)) {
491
 
                        pr_debug("Audio interrupt enable\n");
492
 
                        sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
493
 
 
494
 
                        sst_sc_reg_access(sc_access_write, PMIC_WRITE, 1);
495
 
                        intelmid_audio_interrupt_enable = 1;
496
 
                        intelmaddata->jack[0].jack_status = 0;
497
 
                        intelmaddata->jack[1].jack_status = 0;
498
 
 
499
 
                }
500
 
                /* send headphone detect */
501
 
                pr_debug("MAD headphone %d\n", intsts & 0x4);
502
 
                jack = &intelmaddata->jack[0].jack;
503
 
                present = !(intelmaddata->jack[0].jack_status);
504
 
                intelmaddata->jack[0].jack_status = present;
505
 
                jack_event_flag = 1;
506
 
 
507
 
        }
508
 
 
509
 
        if (intsts & 0x2) {
510
 
                /* send short push */
511
 
                pr_debug("MAD short push %d\n", intsts & 0x2);
512
 
                jack = &intelmaddata->jack[2].jack;
513
 
                present = 1;
514
 
                jack_event_flag = 1;
515
 
                buttonpressflag = 1;
516
 
        }
517
 
        if (intsts & 0x1) {
518
 
                /* send long push */
519
 
                pr_debug("MAD long push %d\n", intsts & 0x1);
520
 
                jack = &intelmaddata->jack[3].jack;
521
 
                present = 1;
522
 
                jack_event_flag = 1;
523
 
                buttonpressflag = 1;
524
 
        }
525
 
        if (intsts & 0x8) {
526
 
                if (!(intelmid_audio_interrupt_enable)) {
527
 
                        pr_debug("Audio interrupt enable\n");
528
 
                        sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
529
 
 
530
 
                        sst_sc_reg_access(sc_access_write, PMIC_WRITE, 1);
531
 
                        intelmid_audio_interrupt_enable = 1;
532
 
                        intelmaddata->jack[0].jack_status = 0;
533
 
                        intelmaddata->jack[1].jack_status = 0;
534
 
                }
535
 
                /* send headset detect */
536
 
                pr_debug("MAD headset = %d\n", intsts & 0x8);
537
 
                jack = &intelmaddata->jack[1].jack;
538
 
                present = !(intelmaddata->jack[1].jack_status);
539
 
                intelmaddata->jack[1].jack_status = present;
540
 
                jack_event_flag = 1;
541
 
        }
542
 
 
543
 
        if (jack_event_flag)
544
 
                sst_mad_send_jack_report(jack, buttonpressflag, present);
545
 
}
546
 
 
547
 
 
548
 
void sst_mad_jackdetection_mx(u8 intsts, struct snd_intelmad *intelmaddata)
549
 
{
550
 
        u8 value = 0, jack_prev_state = 0;
551
 
        struct snd_jack *jack = NULL;
552
 
        unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
553
 
        time_t  timediff;
554
 
        struct sc_reg_access sc_access_read = {0,};
555
 
        struct snd_pmic_ops *scard_ops;
556
 
 
557
 
        scard_ops = intelmaddata->sstdrv_ops->scard_ops;
558
 
 
559
 
        pr_debug("previous value: %x\n", intelmaddata->jack_prev_state);
560
 
 
561
 
        if (!(intelmid_audio_interrupt_enable)) {
562
 
                pr_debug("Audio interrupt enable\n");
563
 
                intelmaddata->jack_prev_state = 0xC0;
564
 
                intelmid_audio_interrupt_enable = 1;
565
 
        }
566
 
 
567
 
        if (intsts & 0x2) {
568
 
                jack_prev_state = intelmaddata->jack_prev_state;
569
 
                if (intelmaddata->pmic_status == PMIC_INIT) {
570
 
                        sc_access_read.reg_addr = 0x201;
571
 
                        sst_sc_reg_access(&sc_access_read, PMIC_READ, 1);
572
 
                        value = (sc_access_read.value);
573
 
                        pr_debug("value returned = 0x%x\n", value);
574
 
                }
575
 
 
576
 
                if (jack_prev_state == 0xc0 && value == 0x40) {
577
 
                        /*headset detected. */
578
 
                        pr_debug("MAD headset inserted\n");
579
 
                        jack = &intelmaddata->jack[1].jack;
580
 
                        present = 1;
581
 
                        jack_event_flag = 1;
582
 
                        intelmaddata->jack[1].jack_status = 1;
583
 
 
584
 
                }
585
 
 
586
 
                if (jack_prev_state == 0xc0 && value == 0x00) {
587
 
                        /* headphone  detected. */
588
 
                        pr_debug("MAD headphone inserted\n");
589
 
                        jack = &intelmaddata->jack[0].jack;
590
 
                        present = 1;
591
 
                        jack_event_flag = 1;
592
 
 
593
 
                }
594
 
 
595
 
                if (jack_prev_state == 0x40 && value == 0xc0) {
596
 
                        /*headset  removed*/
597
 
                        pr_debug("Jack headset status %d\n",
598
 
                                intelmaddata->jack[1].jack_status);
599
 
                        pr_debug("MAD headset removed\n");
600
 
                        jack = &intelmaddata->jack[1].jack;
601
 
                        present = 0;
602
 
                        jack_event_flag = 1;
603
 
                        intelmaddata->jack[1].jack_status = 0;
604
 
                }
605
 
 
606
 
                if (jack_prev_state == 0x00 && value == 0xc0) {
607
 
                        /* headphone  detected. */
608
 
                        pr_debug("Jack headphone status %d\n",
609
 
                                        intelmaddata->jack[0].jack_status);
610
 
                        pr_debug("headphone removed\n");
611
 
                        jack = &intelmaddata->jack[0].jack;
612
 
                        present = 0;
613
 
                        jack_event_flag = 1;
614
 
                }
615
 
 
616
 
                if (jack_prev_state == 0x40 && value == 0x00) {
617
 
                        /*button pressed*/
618
 
                        do_gettimeofday(&intelmaddata->jack[1].buttonpressed);
619
 
                        pr_debug("MAD button press detected\n");
620
 
                }
621
 
 
622
 
 
623
 
                if (jack_prev_state == 0x00 && value == 0x40) {
624
 
                        if (intelmaddata->jack[1].jack_status) {
625
 
                                /*button pressed*/
626
 
                                do_gettimeofday(
627
 
                                        &intelmaddata->jack[1].buttonreleased);
628
 
                                /*button pressed */
629
 
                                pr_debug("Button Released detected\n");
630
 
                                timediff = intelmaddata->jack[1].
631
 
                                        buttonreleased.tv_sec - intelmaddata->
632
 
                                        jack[1].buttonpressed.tv_sec;
633
 
                                buttonpressflag = 1;
634
 
                                if (timediff > 1) {
635
 
                                        pr_debug("long press detected\n");
636
 
                                        /* send headphone detect/undetect */
637
 
                                        jack = &intelmaddata->jack[3].jack;
638
 
                                        present = 1;
639
 
                                        jack_event_flag = 1;
640
 
                                } else {
641
 
                                        pr_debug("short press detected\n");
642
 
                                        /* send headphone detect/undetect */
643
 
                                        jack = &intelmaddata->jack[2].jack;
644
 
                                        present = 1;
645
 
                                        jack_event_flag = 1;
646
 
                                }
647
 
                        }
648
 
 
649
 
                }
650
 
                intelmaddata->jack_prev_state = value;
651
 
        }
652
 
        if (jack_event_flag)
653
 
                sst_mad_send_jack_report(jack, buttonpressflag, present);
654
 
}
655
 
 
656
 
 
657
 
void sst_mad_jackdetection_nec(u8 intsts, struct snd_intelmad *intelmaddata)
658
 
{
659
 
        u8 value = 0;
660
 
        struct snd_jack *jack = NULL;
661
 
        unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
662
 
        struct sc_reg_access sc_access_read = {0,};
663
 
 
664
 
        if (intelmaddata->pmic_status == PMIC_INIT) {
665
 
                sc_access_read.reg_addr = 0x132;
666
 
                sst_sc_reg_access(&sc_access_read, PMIC_READ, 1);
667
 
                value = (sc_access_read.value);
668
 
                pr_debug("value returned = 0x%x\n", value);
669
 
        }
670
 
        if (intsts & 0x1) {
671
 
                pr_debug("headset detected\n");
672
 
                /* send headset detect/undetect */
673
 
                jack = &intelmaddata->jack[1].jack;
674
 
                present = (value == 0x1) ? 1 : 0;
675
 
                jack_event_flag = 1;
676
 
        }
677
 
        if (intsts & 0x2) {
678
 
                pr_debug("headphone detected\n");
679
 
                /* send headphone detect/undetect */
680
 
                jack = &intelmaddata->jack[0].jack;
681
 
                present = (value == 0x2) ? 1 : 0;
682
 
                jack_event_flag = 1;
683
 
        }
684
 
        if (intsts & 0x4) {
685
 
                pr_debug("short push detected\n");
686
 
                /* send short push */
687
 
                jack = &intelmaddata->jack[2].jack;
688
 
                present = 1;
689
 
                jack_event_flag = 1;
690
 
                buttonpressflag = 1;
691
 
        }
692
 
        if (intsts & 0x8) {
693
 
                pr_debug("long push detected\n");
694
 
                /* send long push */
695
 
                jack = &intelmaddata->jack[3].jack;
696
 
                present = 1;
697
 
                jack_event_flag = 1;
698
 
                buttonpressflag = 1;
699
 
        }
700
 
 
701
 
        if (jack_event_flag)
702
 
                sst_mad_send_jack_report(jack, buttonpressflag, present);
703
 
 
704
 
 
705
 
}
706
 
 
707
 
void sst_process_mad_jack_detection(struct work_struct *work)
708
 
{
709
 
        u8 intsts;
710
 
        struct mad_jack_msg_wq *mad_jack_detect =
711
 
                        container_of(work, struct mad_jack_msg_wq, wq);
712
 
 
713
 
        struct snd_intelmad *intelmaddata =
714
 
                        mad_jack_detect->intelmaddata;
715
 
 
716
 
        intsts = mad_jack_detect->intsts;
717
 
 
718
 
        switch (intelmaddata->sstdrv_ops->vendor_id) {
719
 
        case SND_FS:
720
 
                sst_mad_jackdetection_fs(intsts , intelmaddata);
721
 
                break;
722
 
        case SND_MX:
723
 
                sst_mad_jackdetection_mx(intsts , intelmaddata);
724
 
                break;
725
 
        case SND_NC:
726
 
                sst_mad_jackdetection_nec(intsts , intelmaddata);
727
 
                break;
728
 
        }
729
 
}
730
 
 
 
539
}
731
540
 
732
541
static int __devinit snd_intelmad_register_irq(
733
 
                                        struct snd_intelmad *intelmaddata)
 
542
                struct snd_intelmad *intelmaddata, unsigned int regbase,
 
543
                unsigned int regsize)
734
544
{
735
545
        int ret_val;
736
 
        u32 regbase = AUDINT_BASE, regsize = 8;
737
546
        char *drv_name;
738
547
 
739
 
        pr_debug("irq reg done, regbase 0x%x, regsize 0x%x\n",
 
548
        pr_debug("irq reg regbase 0x%x, regsize 0x%x\n",
740
549
                                        regbase, regsize);
741
550
        intelmaddata->int_base = ioremap_nocache(regbase, regsize);
742
551
        if (!intelmaddata->int_base)
773
582
                if (ret_val)
774
583
                        return ret_val;
775
584
                sst_card_vendor_id = (vendor_addr.value & (MASK2|MASK1|MASK0));
776
 
                pr_debug("orginal n extrated vendor id = 0x%x %d\n",
 
585
                pr_debug("original n extrated vendor id = 0x%x %d\n",
777
586
                                vendor_addr.value, sst_card_vendor_id);
778
587
                if (sst_card_vendor_id < 0 || sst_card_vendor_id > 2) {
779
588
                        pr_err("vendor card not supported!!\n");
794
603
                intelmaddata->sstdrv_ops->scard_ops->input_dev_id = DMIC;
795
604
                intelmaddata->sstdrv_ops->scard_ops->output_dev_id =
796
605
                                                        STEREO_HEADPHONE;
 
606
                intelmaddata->sstdrv_ops->scard_ops->lineout_dev_id = NONE;
797
607
        }
798
608
 
799
609
        /* registering with SST driver to get access to SST APIs to use */
802
612
                pr_err("sst card registration failed\n");
803
613
                return ret_val;
804
614
        }
805
 
 
806
615
        sst_card_vendor_id = intelmaddata->sstdrv_ops->vendor_id;
807
616
        intelmaddata->pmic_status = PMIC_UNINIT;
808
617
        return ret_val;
809
618
}
810
619
 
 
620
static void snd_intelmad_page_free(struct snd_pcm *pcm)
 
621
{
 
622
        snd_pcm_lib_preallocate_free_for_all(pcm);
 
623
}
811
624
/* Driver Init/exit functionalities */
812
625
/**
813
626
 * snd_intelmad_pcm_new - to setup pcm for the card
859
672
                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, cap_ops);
860
673
        /* setup private data which can be retrieved when required */
861
674
        pcm->private_data = intelmaddata;
 
675
        pcm->private_free = snd_intelmad_page_free;
862
676
        pcm->info_flags = 0;
863
677
        strncpy(pcm->name, card->shortname, strlen(card->shortname));
864
678
        /* allocate dma pages for ALSA stream operations */
903
717
 
904
718
        pr_debug("snd_intelmad_jack called\n");
905
719
        jack = &intelmaddata->jack[0].jack;
906
 
        retval = snd_jack_new(intelmaddata->card, "Headphone",
907
 
                                SND_JACK_HEADPHONE, &jack);
 
720
        snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PHONE);
 
721
        retval = snd_jack_new(intelmaddata->card, "Intel(R) MID Audio Jack",
 
722
                SND_JACK_HEADPHONE | SND_JACK_HEADSET |
 
723
                SW_JACK_PHYSICAL_INSERT | SND_JACK_BTN_0
 
724
                | SND_JACK_BTN_1, &jack);
 
725
        pr_debug("snd_intelmad_jack called\n");
908
726
        if (retval < 0)
909
727
                return retval;
910
728
        snd_jack_report(jack, 0);
912
730
        jack->private_data = jack;
913
731
        intelmaddata->jack[0].jack = *jack;
914
732
 
915
 
 
916
 
        jack = &intelmaddata->jack[1].jack;
917
 
        retval = snd_jack_new(intelmaddata->card, "Headset",
918
 
                                SND_JACK_HEADSET, &jack);
919
 
        if (retval < 0)
920
 
                return retval;
921
 
 
922
 
 
923
 
 
924
 
        jack->private_data = jack;
925
 
        intelmaddata->jack[1].jack = *jack;
926
 
 
927
 
 
928
 
        jack = &intelmaddata->jack[2].jack;
929
 
        retval = snd_jack_new(intelmaddata->card, "Short Press",
930
 
                                SND_JACK_HS_SHORT_PRESS, &jack);
931
 
        if (retval < 0)
932
 
                return retval;
933
 
 
934
 
 
935
 
        jack->private_data = jack;
936
 
        intelmaddata->jack[2].jack = *jack;
937
 
 
938
 
 
939
 
        jack = &intelmaddata->jack[3].jack;
940
 
        retval = snd_jack_new(intelmaddata->card, "Long Press",
941
 
                                SND_JACK_HS_LONG_PRESS, &jack);
942
 
        if (retval < 0)
943
 
                return retval;
944
 
 
945
 
 
946
 
        jack->private_data = jack;
947
 
        intelmaddata->jack[3].jack = *jack;
948
 
 
949
733
        return retval;
950
734
}
951
735
 
998
782
        intelmaddata = device->device_data;
999
783
 
1000
784
        pr_debug("snd_intelmad_dev_free called\n");
1001
 
        snd_card_free(intelmaddata->card);
1002
 
        /*genl_unregister_family(&audio_event_genl_family);*/
1003
785
        unregister_sst_card(intelmaddata->sstdrv_ops);
1004
786
 
1005
787
        /* free allocated memory for internal context */
1006
788
        destroy_workqueue(intelmaddata->mad_jack_wq);
 
789
        device->device_data = NULL;
1007
790
        kfree(intelmaddata->sstdrv_ops);
1008
791
        kfree(intelmaddata);
 
792
 
1009
793
        return 0;
1010
794
}
1011
795
 
1036
820
        int ret_val;
1037
821
        struct snd_intelmad *intelmaddata;
1038
822
        const struct platform_device_id *id = platform_get_device_id(pdev);
1039
 
        unsigned int cpu_id = (unsigned int)id->driver_data;
 
823
        struct snd_intelmad_probe_info *info = (void *)id->driver_data;
1040
824
 
1041
 
        pr_debug("probe for %s cpu_id %d\n", pdev->name, cpu_id);
 
825
        pr_debug("probe for %s cpu_id %d\n", pdev->name, info->cpu_id);
 
826
        pr_debug("rq_chache %x of size %x\n", info->irq_cache, info->size);
1042
827
        if (!strcmp(pdev->name, DRIVER_NAME_MRST))
1043
828
                pr_debug("detected MRST\n");
1044
829
        else if (!strcmp(pdev->name, DRIVER_NAME_MFLD))
1047
832
                pr_err("detected unknown device abort!!\n");
1048
833
                return -EIO;
1049
834
        }
1050
 
        if ((cpu_id < CPU_CHIP_LINCROFT) || (cpu_id > CPU_CHIP_PENWELL)) {
 
835
        if ((info->cpu_id < CPU_CHIP_LINCROFT) ||
 
836
                                (info->cpu_id > CPU_CHIP_PENWELL)) {
1051
837
                pr_err("detected unknown cpu_id abort!!\n");
1052
838
                return -EIO;
1053
839
        }
1057
843
                pr_debug("mem alloctn fail\n");
1058
844
                return -ENOMEM;
1059
845
        }
 
846
        intelmad_drv = intelmaddata;
1060
847
 
1061
848
        /* allocate memory for LPE API set */
1062
849
        intelmaddata->sstdrv_ops = kzalloc(sizeof(struct intel_sst_card_ops),
1067
854
                return -ENOMEM;
1068
855
        }
1069
856
 
1070
 
        intelmaddata->cpu_id = cpu_id;
 
857
        intelmaddata->cpu_id = info->cpu_id;
1071
858
        /* create a card instance with ALSA framework */
1072
859
        ret_val = snd_card_create(card_index, card_id, THIS_MODULE, 0, &card);
1073
860
        if (ret_val) {
1091
878
        ret_val = snd_intelmad_sst_register(intelmaddata);
1092
879
        if (ret_val) {
1093
880
                pr_err("snd_intelmad_sst_register failed\n");
1094
 
                goto free_allocs;
 
881
                goto set_null_data;
1095
882
        }
1096
883
 
1097
884
        intelmaddata->pmic_status = PMIC_INIT;
1099
886
        ret_val = snd_intelmad_pcm(card, intelmaddata);
1100
887
        if (ret_val) {
1101
888
                pr_err("snd_intelmad_pcm failed\n");
1102
 
                goto free_allocs;
 
889
                goto free_sst;
1103
890
        }
1104
891
 
1105
892
        ret_val = snd_intelmad_mixer(intelmaddata);
1106
893
        if (ret_val) {
1107
894
                pr_err("snd_intelmad_mixer failed\n");
1108
 
                goto free_allocs;
 
895
                goto free_card;
1109
896
        }
1110
897
 
1111
898
        ret_val = snd_intelmad_jack(intelmaddata);
1112
899
        if (ret_val) {
1113
900
                pr_err("snd_intelmad_jack failed\n");
1114
 
                goto free_allocs;
 
901
                goto free_card;
1115
902
        }
 
903
        intelmaddata->adc_address = mid_initialize_adc();
1116
904
 
1117
905
        /*create work queue for jack interrupt*/
1118
906
        INIT_WORK(&intelmaddata->mad_jack_msg.wq,
1120
908
 
1121
909
        intelmaddata->mad_jack_wq = create_workqueue("sst_mad_jack_wq");
1122
910
        if (!intelmaddata->mad_jack_wq)
 
911
                goto free_card;
 
912
 
 
913
        ret_val = snd_intelmad_register_irq(intelmaddata,
 
914
                                        info->irq_cache, info->size);
 
915
        if (ret_val) {
 
916
                pr_err("snd_intelmad_register_irq fail\n");
1123
917
                goto free_mad_jack_wq;
1124
 
 
1125
 
        ret_val = snd_intelmad_register_irq(intelmaddata);
1126
 
        if (ret_val) {
1127
 
                pr_err("snd_intelmad_register_irq fail\n");
1128
 
                goto free_allocs;
1129
918
        }
1130
919
 
1131
920
        /* internal function call to register device with ALSA */
1132
921
        ret_val = snd_intelmad_create(intelmaddata, card);
1133
922
        if (ret_val) {
1134
923
                pr_err("snd_intelmad_create failed\n");
1135
 
                goto free_allocs;
 
924
                goto set_pvt_data;
1136
925
        }
1137
926
        card->private_data = &intelmaddata;
1138
927
        snd_card_set_dev(card, &pdev->dev);
1139
928
        ret_val = snd_card_register(card);
1140
929
        if (ret_val) {
1141
930
                pr_err("snd_card_register failed\n");
1142
 
                goto free_allocs;
 
931
                goto set_pvt_data;
 
932
        }
 
933
        if (pdev->dev.platform_data) {
 
934
                int gpio_amp = *(int *)pdev->dev.platform_data;
 
935
                if (gpio_request_one(gpio_amp, GPIOF_OUT_INIT_LOW, "amp power"))
 
936
                        gpio_amp = 0;
 
937
                intelmaddata->sstdrv_ops->scard_ops->gpio_amp = gpio_amp;
1143
938
        }
1144
939
 
1145
940
        pr_debug("snd_intelmad_probe complete\n");
1146
941
        return ret_val;
1147
942
 
 
943
set_pvt_data:
 
944
        card->private_data = NULL;
1148
945
free_mad_jack_wq:
1149
946
        destroy_workqueue(intelmaddata->mad_jack_wq);
 
947
free_card:
 
948
        snd_card_free(intelmaddata->card);
 
949
free_sst:
 
950
        unregister_sst_card(intelmaddata->sstdrv_ops);
 
951
set_null_data:
 
952
        platform_set_drvdata(pdev, NULL);
1150
953
free_allocs:
1151
954
        pr_err("probe failed\n");
1152
955
        snd_card_free(card);
1161
964
        struct snd_intelmad *intelmaddata = platform_get_drvdata(pdev);
1162
965
 
1163
966
        if (intelmaddata) {
 
967
                if (intelmaddata->sstdrv_ops->scard_ops->gpio_amp)
 
968
                        gpio_free(intelmaddata->sstdrv_ops->scard_ops->gpio_amp);
 
969
                free_irq(intelmaddata->irq, intelmaddata);
1164
970
                snd_card_free(intelmaddata->card);
1165
 
                unregister_sst_card(intelmaddata->sstdrv_ops);
1166
 
                /* free allocated memory for internal context */
1167
 
                destroy_workqueue(intelmaddata->mad_jack_wq);
1168
 
                kfree(intelmaddata->sstdrv_ops);
1169
 
                kfree(intelmaddata);
1170
971
        }
 
972
        intelmad_drv = NULL;
 
973
        platform_set_drvdata(pdev, NULL);
1171
974
        return 0;
1172
975
}
1173
976
 
1175
978
 *              Driver initialization and exit
1176
979
 *********************************************************************/
1177
980
static const struct platform_device_id snd_intelmad_ids[] = {
1178
 
        {DRIVER_NAME_MRST, CPU_CHIP_LINCROFT},
1179
 
        {DRIVER_NAME_MFLD, CPU_CHIP_PENWELL},
 
981
        {DRIVER_NAME_MRST, INFO(CPU_CHIP_LINCROFT, AUDINT_BASE, 1)},
 
982
        {DRIVER_NAME_MFLD, INFO(CPU_CHIP_PENWELL, 0xFFFF7FCD, 1)},
1180
983
        {"", 0},
1181
984
 
1182
985
};