开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
module.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：15k
源码类别：

DVD

开发平台：

Unix_Linux

module.c：源码内容
  1. /*
  2.   **********************************************************************
  3.   *
  4.   *     Copyright 1999, 2000 Creative Labs, Inc.
  5.   *
  6.   **********************************************************************
  7.   *
  8.   *     Date                 Author               Summary of changes
  9.   *     ----                 ------               ------------------
  10.   *     October 20, 1999     Andrew de Quincey    Rewrote and extended
  11.   *                          Lucien Murray-Pitts  original incomplete 
  12.   *                                               driver.
  13.   *
  14.   *     April 18, 1999       Andrew Veliath       Original Driver
  15.   *                                               implementation
  16.   *
  17.   **********************************************************************
  18.   *
  19.   *     This program is free software; you can redistribute it and/or
  20.   *     modify it under the terms of the GNU General Public License as
  21.   *     published by the Free Software Foundation; either version 2 of
  22.   *     the License, or (at your option) any later version.
  23.   *
  24.   *     This program is distributed in the hope that it will be useful,
  25.   *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  26.   *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27.   *     GNU General Public License for more details.
  28.   *
  29.   *     You should have received a copy of the GNU General Public
  30.   *     License along with this program; if not, write to the Free
  31.   *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  32.   *     USA.
  33.   *
  34.   **********************************************************************
  35.   */
  37. /**
  38.  *
  39.  * Overall driver for the dxr2 card
  40.  *
  41.  */
  43. #define EXPORT_SYMTAB
  45. #include <linux/config.h>
  46. #undef MODVERSION
  47. #undef CONFIG_MODVERSIONS
  48. #include <linux/version.h>
  49. #include <linux/module.h>
  50. #include <linux/kernel.h>
  51. #include <linux/sched.h>
  52. #include <linux/string.h>
  53. #include <linux/ptrace.h>
  54. #include <linux/errno.h>
  55. #include <linux/ioport.h>
  56. #include <linux/malloc.h>
  57. #include <linux/interrupt.h>
  58. #include <linux/pci.h>
  59. #include <linux/delay.h>
  60. #include <linux/init.h>
  61. #include <linux/pci.h>
  62. #include <linux/cdrom.h>
  63. #include <linux/videodev.h>
  64. #include <linux/types.h>
  65. #include <asm/byteorder.h>
  66. #include <asm/bitops.h>
  67. #include <asm/io.h>
  68. #include <asm/irq.h>
  69. #include <asm/uaccess.h>
  70. #include <asm/spinlock.h>
  72. #include <pcm1723.h>
  73. #include <bt865.h>
  74. #include <tc6807af.h>
  75. #include <anp82.h>
  76. #include <zivaDS.h>
  77. #include <vxp524.h>
  78. #include <dxr2.h>
  82. /**
  83.  *
  84.  * IRQ handler function
  85.  *
  86.  * @param irq IRQ number
  87.  * @param vInstance DXR2 instance pointer
  88.  * @param regs Processor regs
  89.  *
  90.  */
  92. extern void dxr2_irq_handler(int irq, void* vInstance, struct pt_regs* regs);
  94. extern ssize_t dxr2_io_write(struct file* filp, const char* buf, size_t count, loff_t* offset);
  95. extern int dxr2_io_ioctl(struct inode* inode, struct file* filp, unsigned int cmd, unsigned long arg);
  96. extern int dxr2_io_open(struct inode* inode, struct file* filp);
  97. extern int dxr2_io_release(struct inode* inode, struct file* filp);
  100. extern vxp524_ops_t vxp524_ops_table;
  101. extern anp82_ops_t anp82_ops_table;
  102. extern bt865_ops_t bt865_ops_table;
  103. extern pcm1723_ops_t pcm1723_ops_table;
  104. extern tc6807af_ops_t tc6807af_ops_table;
  105. extern zivaDS_ops_t zivaDS_ops_table;
  107. static struct file_operations dxr2_fops = {
  109.   NULL,
  110.   NULL,
  111.   dxr2_io_write,
  112.   NULL,
  113.   NULL,
  114.   dxr2_io_ioctl,
  115.   NULL,
  116.   dxr2_io_open,
  117.   NULL,
  118.   dxr2_io_release,
  119.   NULL,
  120.   NULL,
  121.   NULL,
  122.   NULL,
  123.   NULL };
  128. /**
  129.  *
  130.  * Create new DXR2 device
  131.  *
  132.  */
  134. extern dxr2_t* dxr2_new()
  135. {
  136.   dxr2_t* instance;
  139.   // create new structure
  140.   instance = (dxr2_t*) vmalloc (sizeof (dxr2_t));
  141.   if (!instance)
  142.     return;
  144.   // OK, initialise the VxP524
  145.   if (!(instance->vxp524Instance = vxp524_new(&vxp524_ops_table, instance)))
  146.     goto err_vxp524;
  148.   // work out base addresses for all the hardware
  149.   instance->vxp524Base = instance->vxp524Instance->base;
  150.   instance->asicBase = instance->vxp524Base + 0x80040;
  151.   instance->zivaDSBase = instance->vxp524Base + 0x80000;
  152.   instance->tc6807afBase = instance->vxp524Base + 0x80080;
  154.   // initialise the ASIC
  155.   dxr2_asic_init(instance);
  157.   // this works out the type of ziva chip (initially... can be changed
  158.   // during ziva initialisation)
  159.   dxr2_zivaDS_get_hardware_type(instance);
  161.   // pre-initialise the ZiVA
  162.   if (!(instance->zivaDSInstance = zivaDS_new (&zivaDS_ops_table, instance)))
  163.     goto err_ziva;
  164.   
  165.   // we've not *actually* initialised the ziva yet... cannot do that until
  166.   // firmware is loaded
  167.   instance->zivaDSInitialised = 0;
  169.   // OK, now we can initialise the rest of the hardware
  170.   // initialise the AnP82
  171.   if (!(instance->anp82Instance = anp82_new (&anp82_ops_table, instance)))
  172.     goto err_anp82;
  174.   // initialise the pcm1723e
  175.   if (!(instance->pcm1723Instance = pcm1723_new (&pcm1723_ops_table, instance)))
  176.     goto err_pcm1723;
  177.   
  178.   // initialise the Bt865
  179.   if (!(instance->bt865Instance = bt865_new (&bt865_ops_table, instance)))
  180.     goto err_bt865;
  182.   // OK, check if the ziva is ZIVADS_TYPE_1
  183.   if (zivaDS_check_type_1(instance->zivaDSInstance)) {
  184.     
  185.     instance->zivaDSInstance->zivaDSType = ZIVADS_TYPE_1;
  186.     if (!(instance->tc6807afInstance = tc6807af_new(&tc6807af_ops_table, instance)))
  187.       goto err_tc6807af;
  188.   }
  189.   else {
  191.     instance->tc6807afInstance = NULL;
  192.   }
  194.   // nothing in the deferred queue
  195.   instance->deferredCount = 0;
  197.   // semaphore = *1*... i.e. nothing in the critial section
  198.   atomic_set(&(instance->semaphore), 1);
  200.   // initialise other structure members
  201.   instance->waitQueue = NULL;
  202.   instance->userBuffer = 0;
  203.   instance->userBytesTransferred = 0;
  204.   instance->userBufferSize = 0;
  205.   instance->hliFlag = DXR2_SUBPICTURE_OFF;
  206.   instance->currentOutputTvFormat = DXR2_TVFORMAT_NTSC;
  207.   instance->currentZivaAudioDACMode = 0;
  208.   instance->currentSourceVideoFrequency = DXR2_SRC_VIDEO_FREQ_30;
  209.   instance->currentSourceVideoXRes = 720;
  210.   instance->currentSourceVideoYRes = 480;
  211.   instance->currentPlayMode = 0;
  212.   instance->currentAudioVolume = 19;
  213.   instance->currentOutputAspectRatio = DXR2_ASPECTRATIO_4_3;
  214.   instance->currentSlowRate = 0;
  215.   instance->currentAspectRatioMode = 0;
  216.   instance->currentScanOp = 0;
  217.   instance->currentScanParam = 0;
  218.   instance->currentBitstreamType = DXR2_BITSTREAM_TYPE_MPEG_VOB;
  219.   instance->currentVideoStream = 0;
  220.   instance->currentSubPictureStream = 0;
  221.   instance->currentAudioStream = 0;
  222.   instance->currentAudioStreamType = DXR2_STREAM_AUDIO_AC3;
  223.   instance->currentAudioMuteStatus = 0;
  225.   // bus mastering stuff
  226.   instance->bmBuffer = 1;
  227.   instance->writeBuffer = 0;
  228.   instance->bufferCount[0] = 0;
  229.   instance->bufferCount[1] = 0;
  231.   // get BM buffers
  232.   if (!(instance->buffer[0] = __get_free_pages(GFP_KERNEL, DXR2_PAGE_ORDER))) {
  233.     
  234.     goto err_mem1;
  235.   }
  236.   if (!(instance->buffer[1] = __get_free_pages(GFP_KERNEL, DXR2_PAGE_ORDER))) {
  237.     
  238.     goto err_mem2;
  239.   }
  240.   instance->bufferSize[0] = (2*2*2) * PAGE_SIZE;
  241.   instance->bufferSize[1] = (2*2*2) * PAGE_SIZE;
  243.   // hook the IRQ
  244.   if (request_irq(instance->vxp524Instance->pci_dev->irq,
  245.   dxr2_irq_handler,
  246.   SA_INTERRUPT | SA_SHIRQ,
  247.   DXR2_LOGNAME,
  248.   instance) != 0) {
  249.     
  250.     goto err_irq;
  251.   }
  253.   // another module use
  254.   MOD_INC_USE_COUNT;
  255.   
  256.   // OK!
  257.   return(instance);
  258.   
  259.   // error handling!
  260.  err_irq:
  261.   free_pages(instance->buffer[1], DXR2_PAGE_ORDER);
  262.  err_mem2:
  263.   free_pages(instance->buffer[0], DXR2_PAGE_ORDER);
  264.  err_mem1:
  265.   if (instance->tc6807afInstance != NULL) tc6807af_free(instance->tc6807afInstance);
  266.  err_tc6807af:
  267.   bt865_free (instance->bt865Instance);
  268.  err_bt865:
  269.   pcm1723_free (instance->pcm1723Instance);
  270.  err_pcm1723:
  271.   anp82_free (instance->anp82Instance);
  272.  err_anp82:
  273.   zivaDS_free (instance->zivaDSInstance);
  274.  err_ziva:
  275.   vxp524_free (instance->vxp524Instance);
  276.  err_vxp524:
  277.   vfree (instance);
  278.   return(NULL);
  279. }
  283. /**
  284.  *
  285.  * Destroy a dxr2 device (BURNY BURNY!!!!)
  286.  *
  287.  * @param instance DXR2 instance to use
  288.  *
  289.  */
  291. void dxr2_free (dxr2_t* instance)
  292. {
  293.   // ok, shut everything down...
  294.   zivaDS_reset(instance->zivaDSInstance);
  295.   vxp524_bm_reset(instance->vxp524Instance);
  296.   if (instance->zivaDSInitialised) {
  298.     zivaDS_set_audio_attenuation(instance->zivaDSInstance, 0x60);
  299.     zivaDS_clear_video(instance->zivaDSInstance);
  300.   }
  301.   pcm1723_set_mute_mode(instance->pcm1723Instance, DXR2_AUDIO_MUTE_ON);
  303.   // unhook IRQ
  304.   free_irq(instance->vxp524Instance->pci_dev->irq, instance);
  306.   // free BM buffers
  307.   free_pages(instance->buffer[0], DXR2_PAGE_ORDER);
  308.   free_pages(instance->buffer[1], DXR2_PAGE_ORDER);
  310.   // free all the other drivers
  311.   if (instance->tc6807afInstance != NULL) {
  313.     tc6807af_free (instance->tc6807afInstance);
  314.   }
  315.   pcm1723_free (instance->pcm1723Instance);
  316.   zivaDS_free (instance->zivaDSInstance);
  317.   bt865_free (instance->bt865Instance);
  318.   anp82_free (instance->anp82Instance);
  319.   vxp524_free (instance->vxp524Instance);
  321.   // OK, free ourselves!
  322.   vfree(instance);
  324.   // one less module usage
  325.   MOD_DEC_USE_COUNT;
  326. }
  329. /**
  330.  *
  331.  * IOCTL handler. This is temporary, so kI can get the driver out so people
  332.  * can test it etc...
  333.  *
  334.  */
  336. extern int dxr2_io_ioctl(struct inode* inode, struct file* filp, unsigned int cmd, unsigned long arg)
  337. {
  338.   char* buffer = (char*) arg;
  339.   dxr2_t* instance = (dxr2_t*) filp->private_data;
  340.   int status;
  342.   // OK, do it!
  343.   switch(cmd) {
  344.   case DXR2_IOC_GET_REGION_CODE:
  345.       
  346.     status = dxr2_ioc_get_region_code(instance, buffer);
  347.     break;
  349.   case DXR2_IOC_SET_OUTPUT_TV_FORMAT:
  350.     
  351.     status = dxr2_ioc_set_output_tv_format(instance, buffer);
  352.     break;
  354.   case DXR2_IOC_SET_SOURCE_VIDEO_FORMAT:
  356.     status = dxr2_ioc_set_source_video_format(instance, buffer);
  357.     break;
  359.   case DXR2_IOC_GET_CAPABILITIES:
  360.     
  361.     status = dxr2_ioc_get_capabilities(instance, buffer);
  362.     break;
  363.     
  364.   case DXR2_IOC_CLEAR_VIDEO:
  365.     
  366.     status = dxr2_ioc_clear_video(instance);
  367.     break;
  369.   case DXR2_IOC_PAUSE:
  370.     
  371.     status = dxr2_ioc_pause(instance);
  372.     break;
  373.     
  374.   case DXR2_IOC_SET_AUDIO_VOLUME:
  375.     
  376.     status = dxr2_ioc_set_audio_volume(instance, buffer);
  377.     break;
  378.     
  379.   case DXR2_IOC_SET_OUTPUT_ASPECT_RATIO:
  380.     
  381.     status = dxr2_ioc_set_output_aspect_ratio(instance, buffer);
  382.     break;
  383.     
  384.   case DXR2_IOC_ABORT:
  385.     
  386.     status = dxr2_ioc_abort(instance);
  387.     break;
  388.     
  389.   case DXR2_IOC_STOP:
  390.     
  391.     status = dxr2_ioc_stop(instance);
  392.     break;
  393.     
  394.   case DXR2_IOC_ENABLE_SUBPICTURE:
  395.     
  396.     status = dxr2_ioc_enable_subpicture(instance, buffer);
  397.     break;
  398.     
  399.   case DXR2_IOC_SLOW_FORWARDS:
  400.     
  401.     status = dxr2_ioc_slow_forwards(instance, buffer);
  402.     break;
  404.   case DXR2_IOC_SLOW_BACKWARDS:
  405.     
  406.     status = dxr2_ioc_slow_backwards(instance, buffer);
  407.     break;
  409.   case DXR2_IOC_SET_SOURCE_ASPECT_RATIO:
  410.     
  411.     status = dxr2_ioc_set_source_aspect_ratio(instance, buffer);
  412.     break;
  414.   case DXR2_IOC_SET_ASPECT_RATIO_MODE:
  415.     
  416.     status = dxr2_ioc_set_aspect_ratio_mode(instance, buffer);
  417.     break;
  419.   case DXR2_IOC_SINGLE_STEP:
  420.     
  421.     status = dxr2_ioc_single_step(instance);
  422.     break;
  424.   case DXR2_IOC_REVERSE_PLAY:
  425.     
  426.     status = dxr2_ioc_reverse_play(instance);
  427.     break;
  428.     
  429.   case DXR2_IOC_SET_SUBPICTURE_PALETTE:
  430.     
  431.     status = dxr2_ioc_set_subpicture_palettes(instance, buffer);
  432.     break;
  434.   case DXR2_IOC_GET_CHALLENGE_KEY:
  435.     
  436.     status = dxr2_ioc_get_challenge_key(instance, buffer);
  437.     break;
  439.   case DXR2_IOC_SEND_CHALLENGE_KEY:
  440.     
  441.     status = dxr2_ioc_send_challenge_key(instance, buffer);
  442.     break;
  444.   case DXR2_IOC_GET_RESPONSE_KEY:
  445.     
  446.     status = dxr2_ioc_get_response_key(instance, buffer);
  447.     break;
  449.   case DXR2_IOC_SEND_RESPONSE_KEY:
  450.     
  451.     status = dxr2_ioc_send_response_key(instance, buffer);
  452.     break;
  454.   case DXR2_IOC_SEND_DISC_KEY:
  455.     
  456.     status = dxr2_ioc_send_disc_key(instance, buffer);
  457.     break;
  459.   case DXR2_IOC_SEND_TITLE_KEY:
  460.     
  461.     status = dxr2_ioc_send_title_key(instance, buffer);
  462.     break;
  464.   case DXR2_IOC_SET_DECRYPTION_MODE:
  465.     
  466.     status = dxr2_ioc_set_decryption_mode(instance, buffer);
  467.     break;
  469.   case DXR2_IOC_INIT_ZIVADS:
  470.     
  471.     status = dxr2_ioc_init_zivaDS(instance, buffer);
  472.     break;
  474.   case DXR2_IOC_SCAN_MODE:
  475.     
  476.     status = dxr2_ioc_scan_mode(instance, buffer);
  477.     break;
  479.   case DXR2_IOC_SET_MACROVISION_MODE:
  480.     
  481.     status = dxr2_ioc_set_macrovision_mode(instance, buffer);
  482.     break;
  484.   case DXR2_IOC_RESET:
  485.     
  486.     status = dxr2_ioc_reset(instance);
  487.     break;
  488.     
  489.   case DXR2_IOC_SET_BITSTREAM_TYPE:
  490.     
  491.     status = dxr2_ioc_set_bitstream_type(instance, buffer);
  492.     break;
  493.     
  494.   case DXR2_IOC_PLAY:
  495.     
  496.     status = dxr2_ioc_play(instance);
  497.     break;
  498.     
  499.   case DXR2_IOC_GET_STC:
  500.     
  501.     status = dxr2_ioc_get_stc(instance, buffer);
  502.     break;
  504.   case DXR2_IOC_SET_AUDIO_SAMPLE_FREQUENCY:
  505.     
  506.     status = dxr2_ioc_set_audio_sample_freqency(instance, buffer);
  507.     break;
  509.   case DXR2_IOC_SET_AUDIO_DATA_WIDTH:
  510.     
  511.     status = dxr2_ioc_set_audio_data_width(instance, buffer);
  512.     break;
  513.     
  514.   case DXR2_IOC_IEC958_OUTPUT_MODE:
  515.     
  516.     status = dxr2_ioc_iec958_output_mode(instance, buffer);
  517.     break;
  518.     
  519.   case DXR2_IOC_SET_AC3_MODE:
  520.     
  521.     status = dxr2_ioc_set_AC3_mode(instance, buffer);
  522.     break;
  523.     
  524.   case DXR2_IOC_SELECT_AC3_VOICE:
  525.     
  526.     status = dxr2_ioc_select_AC3_voice(instance, buffer);
  527.     break;
  528.     
  529.   case DXR2_IOC_AUDIO_MUTE:
  530.     
  531.     status = dxr2_ioc_audio_mute(instance, buffer);
  532.     break;
  534.   case DXR2_IOC_SET_STEREO_MODE:
  535.     
  536.     status = dxr2_ioc_set_stereo_mode(instance, buffer);
  537.     break;
  539.   case DXR2_IOC_SELECT_STREAM:
  540.     
  541.     status = dxr2_ioc_select_stream(instance, buffer);
  542.     break;
  543.     
  544.   case DXR2_IOC_HIGHLIGHT:
  545.     
  546.     status = dxr2_ioc_highlight(instance, buffer);
  547.     break;
  548.     
  549.   default:
  550.     
  551.     status = -EINVAL;
  552.   }
  553.   
  554.   return(status);
  555. }
  556.     
  557.     
  558. extern int dxr2_io_open(struct inode* inode, struct file* filp) 
  559. {
  560.   dxr2_t* instance;
  562.   // create new DXR2 instance & check (increments module usage automatically)
  563.   if ((instance = dxr2_new()) == NULL) {
  564.     
  565.     return(-EIO);
  566.   }
  568.   // OK, remember instance pointer
  569.   filp->private_data = instance;
  571.   // OK!
  572.   return(0);
  573. }
  575. extern int dxr2_io_release(struct inode* inode, struct file* filp) 
  576. {
  577.   dxr2_t* instance = (dxr2_t*) filp->private_data;
  578.   
  579.   // free the DXR2 instance (decrements module usage automatically)
  580.   dxr2_free(instance);
  582.   // OK
  583.   return(0);
  584. }
  585.     
  586.     
  587.     
  589. #ifdef MODULE
  590. int init_module (void)
  591. {
  592.   return(register_chrdev(DXR2_MAJOR, DXR2_LOGNAME, &dxr2_fops));
  593. }
  595. void cleanup_module (void)
  596. {
  597.   unregister_chrdev(DXR2_MAJOR, DXR2_LOGNAME);
  598. }
  599. #endif