← Back to branch summary

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

« back to all changes in this revision

Viewing changes to sound/soc/blackfin/bf5xx-sport.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:
sound/soc/blackfin/bf5xx-sport.c
42
42
/* delay between frame sync pulse and first data bit in multichannel mode */
43
43
#define FRAME_DELAY (1<<12)
44
44
 
45
 
struct sport_device *sport_handle;
46
 
EXPORT_SYMBOL(sport_handle);
47
45
/* note: multichannel is in units of 8 channels,
48
46
 * tdm_count is # channels NOT / 8 ! */
49
47
int sport_set_multichannel(struct sport_device *sport,
798
796
}
799
797
EXPORT_SYMBOL(sport_set_err_callback);
800
798
 
801
 
struct sport_device *sport_init(struct sport_param *param, unsigned wdsize,
802
 
                unsigned dummy_count, void *private_data)
803
 
{
804
 
        int ret;
 
799
static int sport_config_pdev(struct platform_device *pdev, struct sport_param *param)
 
800
{
 
801
        /* Extract settings from platform data */
 
802
        struct device *dev = &pdev->dev;
 
803
        struct bfin_snd_platform_data *pdata = dev->platform_data;
 
804
        struct resource *res;
 
805
 
 
806
        param->num = pdev->id;
 
807
 
 
808
        if (!pdata) {
 
809
                dev_err(dev, "no platform_data\n");
 
810
                return -ENODEV;
 
811
        }
 
812
        param->pin_req = pdata->pin_req;
 
813
 
 
814
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
815
        if (!res) {
 
816
                dev_err(dev, "no MEM resource\n");
 
817
                return -ENODEV;
 
818
        }
 
819
        param->regs = (struct sport_register *)res->start;
 
820
 
 
821
        /* first RX, then TX */
 
822
        res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 
823
        if (!res) {
 
824
                dev_err(dev, "no rx DMA resource\n");
 
825
                return -ENODEV;
 
826
        }
 
827
        param->dma_rx_chan = res->start;
 
828
 
 
829
        res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
 
830
        if (!res) {
 
831
                dev_err(dev, "no tx DMA resource\n");
 
832
                return -ENODEV;
 
833
        }
 
834
        param->dma_tx_chan = res->start;
 
835
 
 
836
        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 
837
        if (!res) {
 
838
                dev_err(dev, "no irq resource\n");
 
839
                return -ENODEV;
 
840
        }
 
841
        param->err_irq = res->start;
 
842
 
 
843
        return 0;
 
844
}
 
845
 
 
846
struct sport_device *sport_init(struct platform_device *pdev,
 
847
        unsigned int wdsize, unsigned int dummy_count, size_t priv_size)
 
848
{
 
849
        struct device *dev = &pdev->dev;
 
850
        struct sport_param param;
805
851
        struct sport_device *sport;
806
 
        pr_debug("%s enter\n", __func__);
807
 
        BUG_ON(param == NULL);
808
 
        BUG_ON(wdsize == 0 || dummy_count == 0);
809
 
        sport = kmalloc(sizeof(struct sport_device), GFP_KERNEL);
 
852
        int ret;
 
853
 
 
854
        dev_dbg(dev, "%s enter\n", __func__);
 
855
 
 
856
        param.wdsize = wdsize;
 
857
        param.dummy_count = dummy_count;
 
858
        BUG_ON(param.wdsize == 0 || param.dummy_count == 0);
 
859
 
 
860
        ret = sport_config_pdev(pdev, &param);
 
861
        if (ret)
 
862
                return NULL;
 
863
 
 
864
        if (peripheral_request_list(param.pin_req, "soc-audio")) {
 
865
                dev_err(dev, "requesting Peripherals failed\n");
 
866
                return NULL;
 
867
        }
 
868
 
 
869
        sport = kzalloc(sizeof(*sport), GFP_KERNEL);
810
870
        if (!sport) {
811
 
                pr_err("Failed to allocate for sport device\n");
812
 
                return NULL;
 
871
                dev_err(dev, "failed to allocate for sport device\n");
 
872
                goto __init_err0;
813
873
        }
814
874
 
815
 
        memset(sport, 0, sizeof(struct sport_device));
816
 
        sport->dma_rx_chan = param->dma_rx_chan;
817
 
        sport->dma_tx_chan = param->dma_tx_chan;
818
 
        sport->err_irq = param->err_irq;
819
 
        sport->regs = param->regs;
820
 
        sport->private_data = private_data;
 
875
        sport->num = param.num;
 
876
        sport->dma_rx_chan = param.dma_rx_chan;
 
877
        sport->dma_tx_chan = param.dma_tx_chan;
 
878
        sport->err_irq = param.err_irq;
 
879
        sport->regs = param.regs;
 
880
        sport->pin_req = param.pin_req;
821
881
 
822
882
        if (request_dma(sport->dma_rx_chan, "SPORT RX Data") == -EBUSY) {
823
 
                pr_err("Failed to request RX dma %d\n", \
824
 
                                sport->dma_rx_chan);
 
883
                dev_err(dev, "failed to request RX dma %d\n", sport->dma_rx_chan);
825
884
                goto __init_err1;
826
885
        }
827
886
        if (set_dma_callback(sport->dma_rx_chan, rx_handler, sport) != 0) {
828
 
                pr_err("Failed to request RX irq %d\n", \
829
 
                                sport->dma_rx_chan);
 
887
                dev_err(dev, "failed to request RX irq %d\n", sport->dma_rx_chan);
830
888
                goto __init_err2;
831
889
        }
832
890
 
833
891
        if (request_dma(sport->dma_tx_chan, "SPORT TX Data") == -EBUSY) {
834
 
                pr_err("Failed to request TX dma %d\n", \
835
 
                                sport->dma_tx_chan);
 
892
                dev_err(dev, "failed to request TX dma %d\n", sport->dma_tx_chan);
836
893
                goto __init_err2;
837
894
        }
838
895
 
839
896
        if (set_dma_callback(sport->dma_tx_chan, tx_handler, sport) != 0) {
840
 
                pr_err("Failed to request TX irq %d\n", \
841
 
                                sport->dma_tx_chan);
 
897
                dev_err(dev, "failed to request TX irq %d\n", sport->dma_tx_chan);
842
898
                goto __init_err3;
843
899
        }
844
900
 
845
901
        if (request_irq(sport->err_irq, err_handler, IRQF_SHARED, "SPORT err",
846
902
                        sport) < 0) {
847
 
                pr_err("Failed to request err irq:%d\n", \
848
 
                                sport->err_irq);
 
903
                dev_err(dev, "failed to request err irq %d\n", sport->err_irq);
849
904
                goto __init_err3;
850
905
        }
851
906
 
852
 
        pr_err("dma rx:%d tx:%d, err irq:%d, regs:%p\n",
 
907
        dev_info(dev, "dma rx:%d tx:%d, err irq:%d, regs:%p\n",
853
908
                        sport->dma_rx_chan, sport->dma_tx_chan,
854
909
                        sport->err_irq, sport->regs);
855
910
 
856
 
        sport->wdsize = wdsize;
857
 
        sport->dummy_count = dummy_count;
 
911
        sport->wdsize = param.wdsize;
 
912
        sport->dummy_count = param.dummy_count;
 
913
 
 
914
        sport->private_data = kzalloc(priv_size, GFP_KERNEL);
 
915
        if (!sport->private_data) {
 
916
                dev_err(dev, "could not alloc priv data %zu bytes\n", priv_size);
 
917
                goto __init_err4;
 
918
        }
858
919
 
859
920
        if (L1_DATA_A_LENGTH)
860
 
                sport->dummy_buf = l1_data_sram_zalloc(dummy_count * 2);
 
921
                sport->dummy_buf = l1_data_sram_zalloc(param.dummy_count * 2);
861
922
        else
862
 
                sport->dummy_buf = kzalloc(dummy_count * 2, GFP_KERNEL);
 
923
                sport->dummy_buf = kzalloc(param.dummy_count * 2, GFP_KERNEL);
863
924
        if (sport->dummy_buf == NULL) {
864
 
                pr_err("Failed to allocate dummy buffer\n");
865
 
                goto __error;
 
925
                dev_err(dev, "failed to allocate dummy buffer\n");
 
926
                goto __error1;
866
927
        }
867
928
 
868
929
        ret = sport_config_rx_dummy(sport);
869
930
        if (ret) {
870
 
                pr_err("Failed to config rx dummy ring\n");
871
 
                goto __error;
 
931
                dev_err(dev, "failed to config rx dummy ring\n");
 
932
                goto __error2;
872
933
        }
873
934
        ret = sport_config_tx_dummy(sport);
874
935
        if (ret) {
875
 
                pr_err("Failed to config tx dummy ring\n");
876
 
                goto __error;
 
936
                dev_err(dev, "failed to config tx dummy ring\n");
 
937
                goto __error3;
877
938
        }
878
939
 
 
940
        platform_set_drvdata(pdev, sport);
 
941
 
879
942
        return sport;
880
 
__error:
 
943
__error3:
 
944
        if (L1_DATA_A_LENGTH)
 
945
                l1_data_sram_free(sport->dummy_rx_desc);
 
946
        else
 
947
                dma_free_coherent(NULL, 2*sizeof(struct dmasg),
 
948
                                sport->dummy_rx_desc, 0);
 
949
__error2:
 
950
        if (L1_DATA_A_LENGTH)
 
951
                l1_data_sram_free(sport->dummy_buf);
 
952
        else
 
953
                kfree(sport->dummy_buf);
 
954
__error1:
 
955
        kfree(sport->private_data);
 
956
__init_err4:
881
957
        free_irq(sport->err_irq, sport);
882
958
__init_err3:
883
959
        free_dma(sport->dma_tx_chan);
885
961
        free_dma(sport->dma_rx_chan);
886
962
__init_err1:
887
963
        kfree(sport);
 
964
__init_err0:
 
965
        peripheral_free_list(param.pin_req);
888
966
        return NULL;
889
967
}
890
968
EXPORT_SYMBOL(sport_init);
917
995
        free_dma(sport->dma_tx_chan);
918
996
        free_irq(sport->err_irq, sport);
919
997
 
 
998
        kfree(sport->private_data);
 
999
        peripheral_free_list(sport->pin_req);
920
1000
        kfree(sport);
921
 
                sport = NULL;
922
1001
}
923
1002
EXPORT_SYMBOL(sport_done);
924
1003