My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

Untitled

By: a guest | Sep 2nd, 2010 | Syntax: None | Size: 19.27 KB | Hits: 35 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. #include <asm/mach-types.h>
  2. #include <asm/io.h>
  3. #include <asm/gpio.h>
  4. #include <linux/module.h>
  5. #include <linux/init.h>
  6. #include <linux/input.h>
  7. #include <linux/i2c.h>
  8. #include <linux/microp-klt.h>
  9. #include <linux/hrtimer.h>
  10. #include <linux/delay.h>
  11. #include <linux/debugfs.h>
  12. #include <linux/earlysuspend.h>
  13. #ifdef CONFIG_ANDROID_POWER
  14. #include <linux/android_power.h>
  15. #endif  
  16.  
  17. #include "proc_comm_wince.h"
  18. #include "gpio_hw.h"
  19. #define MODULE_NAME "rhodium_audio"
  20. #define SPKR_PWR 0x54
  21. #define I2C_READ_RETRY_TIMES 10
  22. #define I2C_WRITE_RETRY_TIMES 10
  23.  
  24. struct data_t {
  25.         struct i2c_client *a1010;
  26.         struct i2c_client *tpa2016;
  27.         struct i2c_client *adc3001;
  28. };
  29. static struct data_t _dat;
  30.  
  31. static int i2c_read(struct i2c_client *client, unsigned char addr,
  32.                 char *data, int len) {
  33.         int retry;
  34.         int ret;
  35.         struct i2c_msg msgs[] = {
  36.         {
  37.                 .addr = client->addr,
  38.                 .flags = 0,
  39.                 .len = 1,
  40.                 .buf = &addr,
  41.         },
  42.         {
  43.                 .addr = client->addr,
  44.                 .flags = I2C_M_RD,
  45.                 .len = len,
  46.                 .buf = data,
  47.         }
  48.         };
  49.  
  50.         mdelay(1);
  51.         for (retry = 0; retry <= I2C_READ_RETRY_TIMES; retry++) {
  52.                 ret = i2c_transfer(client->adapter, msgs, 2);
  53.                 if (ret == 2) {
  54.                         return 0;
  55.                 }
  56.                 msleep(10);
  57.                 printk("read retry\n");
  58.         }
  59.  
  60.         dev_err(&client->dev, "i2c_read_block retry over %d\n",
  61.                         I2C_READ_RETRY_TIMES);
  62.         return -EIO;
  63. }
  64.  
  65. #define MAX_I2C_WRITE 20
  66. static int i2c_write(struct i2c_client *client, unsigned char addr,
  67.                 char *data, int len) {
  68.         int retry;
  69.         uint8_t buf[MAX_I2C_WRITE];
  70.         int ret;
  71.  
  72.         struct i2c_msg msg[] = {
  73.                 {
  74.                         .addr = client->addr,
  75.                         .flags = 0,
  76.                         .len = len + 1,
  77.                         .buf = buf,
  78.                 }
  79.         };
  80.  
  81.         if (len + 1 > MAX_I2C_WRITE) {
  82.                 dev_err(&client->dev, "i2c_write_block length too long\n");
  83.                 return -E2BIG;
  84.         }
  85.  
  86.         buf[0] = addr;
  87.         memcpy((void *)&buf[1], (void *)data, len);
  88.  
  89.         mdelay(1);
  90.         for (retry = 0; retry <= I2C_WRITE_RETRY_TIMES; retry++) {
  91.                 ret = i2c_transfer(client->adapter, msg, 1);
  92.                 if (ret == 1)
  93.                         return 0;
  94.                 msleep(10);
  95.         }
  96.         dev_err(&client->dev, "i2c_write_block retry over %d\n",
  97.                         I2C_WRITE_RETRY_TIMES);
  98.         return -EIO;
  99. }
  100.  
  101. #define AUD_REG 0x66
  102.  
  103. void audience_write(unsigned char a, unsigned char b, unsigned char c) {
  104.         pr_err("A1010 Command Write: 0x%X, 0x%X, 0x%X\n",a,b,c);
  105.         unsigned char buf[4];
  106.         buf[0] = 0x80;
  107.         buf[1] = a;
  108.         buf[2] = b;
  109.         buf[3] = c;
  110.  
  111.         if(i2c_write(_dat.a1010, AUD_REG, &buf, 4))
  112.                 pr_err("Can't write to audience a1010!\n");
  113. }
  114.  
  115. void init_mic();
  116. void audience_enable()
  117. {
  118.  
  119.       audience_write(0x25, 0x00, 0x00);
  120.       audience_write(0x17, 0x00, 0x02);
  121.       audience_write(0x18, 0x00, 0x00);
  122.       audience_write(0x1b, 0x00, 0x09);
  123.       audience_write(0x15, 0x00, 0x08);
  124.       audience_write(0x23, 0xff, 0xf6);
  125.       audience_write(0x17, 0x00, 0x03);
  126.       audience_write(0x18, 0x00, 0x03);
  127.       audience_write(0x17, 0x00, 0x00);
  128.       audience_write(0x18, 0x00, 0x01);
  129.       audience_write(0x0c, 0x03, 0x00);
  130.       audience_write(0x04, 0x00, 0x00);
  131.       audience_write(0x0c, 0x04, 0x00);
  132.       audience_write(0x0d, 0x00, 0x00);
  133.       audience_write(0x17, 0x00, 0x23);
  134.       audience_write(0x18, 0x00, 0x01);
  135.       audience_write(0x17, 0x00, 0x2e);
  136.       audience_write(0x18, 0xff, 0xbf);
  137.       audience_write(0x17, 0x00, 0x12);
  138.       audience_write(0x18, 0xff, 0xf9);
  139.  
  140. //   ?????????   audience_write(0x10 0x00 0x01
  141. //pastebin's command dump
  142. /*
  143.          audience_write(0x25,0x0,0x0);
  144.          audience_write(0x15,0x0,0x5);
  145.          audience_write(0x17,0x0,0x3);
  146.          audience_write(0x18,0x0,0x3);
  147.          audience_write(0x17,0x0,0x23);
  148.          audience_write(0x18,0x0,0x0);
  149.          audience_write(0x25,0x0,0x0);
  150.          audience_write(0x17,0x0,0x2);
  151.          audience_write(0x18,0x0,0x0);
  152.          audience_write(0x1b,0x0,0x9);
  153.          audience_write(0x15,0x0,0x8);
  154.          audience_write(0x23,0xff,0xf6);
  155.          audience_write(0x17,0x0,0x3);
  156.          audience_write(0x18,0x0,0x3);
  157.          audience_write(0x17,0x0,0x0);
  158.          audience_write(0x18,0x0,0x1);
  159.          audience_write(0xc,0x3,0x0);
  160.          audience_write(0xd,0x0,0x0);
  161.          audience_write(0xc,0x4,0x0);
  162.          audience_write(0xd,0x0,0x0);
  163.          audience_write(0x17,0x0,0x23);
  164.          audience_write(0x18,0x0,0x1);
  165.          audience_write(0x17,0x0,0x2e);
  166.          audience_write(0x18,0xff,0xbf);
  167.          audience_write(0x25,0x0,0x0);
  168.          audience_write(0x17,0x0,0x2);
  169.          audience_write(0x18,0x0,0x0);
  170.          audience_write(0x1b,0x0,0x9);
  171.          audience_write(0x15,0x0,0x8);
  172.          //crash
  173.          audience_write(0x23,0xff,0xf6);
  174.          audience_write(0x17,0x0,0x3);
  175.          //crash
  176.          audience_write(0x18,0x0,0x3);
  177.          audience_write(0x17,0x0,0x0);
  178.          audience_write(0x18,0x0,0x1);
  179.          audience_write(0xc,0x3,0x0);
  180.          audience_write(0xd,0x0,0x0);
  181.          audience_write(0xc,0x4,0x0);
  182.          audience_write(0xd,0x0,0x0);
  183.          audience_write(0x17,0x0,0x23);
  184.          audience_write(0x18,0x0,0x1);
  185.          audience_write(0x17,0x0,0x2e);
  186.          audience_write(0x18,0xff,0xbf);
  187.          audience_write(0x10,0x0,0x1);
  188.          audience_write(0x17,0x0,0x2);
  189.          audience_write(0x18,0x0,0x0);
  190.          audience_write(0x1b,0x0,0x9);
  191.          audience_write(0x15,0x0,0x8);
  192.          audience_write(0x23,0xff,0xf6);
  193.          audience_write(0x17,0x0,0x3);
  194.          audience_write(0x18,0x0,0x3);
  195.          audience_write(0x17,0x0,0x0);
  196.          audience_write(0x18,0x0,0x1);
  197.          audience_write(0xc,0x3,0x0);
  198.          audience_write(0xd,0x0,0x0);
  199.          audience_write(0xc,0x4,0x0);
  200.          audience_write(0xd,0x0,0x0);
  201.          audience_write(0x17,0x0,0x23);
  202.          audience_write(0x18,0x0,0x1);
  203.          audience_write(0x17,0x0,0x2e);
  204.          audience_write(0x18,0xff,0xbf);
  205.          audience_write(0x17,0x0,0x2);
  206.          audience_write(0x18,0x0,0x0);
  207.          audience_write(0x1b,0x0,0x0);
  208.          audience_write(0x15,0x0,0x5);
  209.          audience_write(0x23,0xff,0xfc);
  210.          audience_write(0x17,0x0,0x3);
  211.          audience_write(0x18,0x0,0x3);
  212.          audience_write(0x17,0x0,0x0);
  213.          audience_write(0x18,0x0,0x6);
  214.          audience_write(0xc,0x3,0x0);
  215.          audience_write(0xd,0x0,0x2);
  216.          audience_write(0x17,0x0,0x2);
  217.          audience_write(0x18,0x0,0x0);
  218.         //crash
  219.          audience_write(0x1b,0x0,0x9);
  220.          audience_write(0x15,0x0,0x8);
  221.          audience_write(0x23,0xff,0xf6);
  222.          audience_write(0x17,0x0,0x3);
  223.          audience_write(0x18,0x0,0x3);
  224.          audience_write(0x17,0x0,0x0);
  225.          audience_write(0x18,0x0,0x1);
  226.          audience_write(0xc,0x3,0x0);
  227.          audience_write(0xd,0x0,0x0);
  228.          audience_write(0xc,0x4,0x0);
  229.          audience_write(0xd,0x0,0x0);
  230.          audience_write(0x17,0x0,0x23);
  231.          audience_write(0x18,0x0,0x1);
  232.          audience_write(0x17,0x0,0x2e);
  233.          audience_write(0x18,0xff,0xbf);
  234.          audience_write(0x17,0x0,0x2);
  235.          audience_write(0x18,0x0,0x0);
  236.          audience_write(0x1b,0x0,0x0);
  237.          audience_write(0x15,0x0,0x5);
  238.          audience_write(0x23,0xff,0xfc);
  239.          audience_write(0x17,0x0,0x3);
  240.          audience_write(0x18,0x0,0x3);
  241.          audience_write(0x17,0x0,0x0);
  242.          audience_write(0x18,0x0,0x6);
  243.          audience_write(0xc,0x3,0x0);
  244.          audience_write(0xd,0x0,0x2);
  245.          audience_write(0x0,0x0,0x0);
  246.          audience_write(0x0,0x0,0x0);
  247.          audience_write(0x17,0x0,0x12);
  248.          audience_write(0x18,0xff,0xf9);
  249.          audience_write(0x17,0x0,0x12);
  250.          audience_write(0x18,0xff,0xf9);
  251.          audience_write(0x17,0x0,0x12);
  252.          audience_write(0x18,0xff,0xf9);
  253.          audience_write(0x17,0x0,0x12);
  254.          audience_write(0x18,0xff,0xf9);
  255.          audience_write(0x17,0x0,0x12);
  256.          audience_write(0x18,0xff,0xf9);
  257.          audience_write(0x17,0x0,0x12);
  258.          audience_write(0x18,0xff,0xf9);
  259.          audience_write(0x17,0x0,0x12);
  260.          audience_write(0x18,0xff,0xf9);
  261.          audience_write(0x17,0x0,0x12);
  262.          audience_write(0x18,0xff,0xf9);
  263.          audience_write(0x17,0x0,0x12);
  264.          audience_write(0x18,0xff,0xf9);
  265.          audience_write(0x17,0x0,0x12);
  266.          audience_write(0x18,0xff,0xf9);
  267.          audience_write(0x17,0x0,0x12);
  268.          audience_write(0x18,0xff,0xf9);
  269.          audience_write(0x17,0x0,0x12);
  270.          audience_write(0x18,0xff,0xf9);
  271.          audience_write(0x17,0x0,0x12);
  272.          audience_write(0x18,0xff,0xf2);
  273.          audience_write(0x17,0x0,0x12);
  274.          audience_write(0x18,0xff,0xf2);
  275.          audience_write(0x17,0x0,0x12);
  276.          audience_write(0x18,0xff,0xf2);
  277.          audience_write(0x17,0x0,0x12);
  278.          audience_write(0x18,0xff,0xf2);
  279.          audience_write(0x17,0x0,0x12);
  280.          audience_write(0x18,0xff,0xf2);
  281.          audience_write(0x17,0x0,0x12);
  282.          audience_write(0x18,0xff,0xf2); */
  283.  
  284. /* jonpry's command dump
  285.         audience_write(0x25,0x0,0x0);
  286.         audience_write(0x15,0x0,0x5);
  287.         audience_write(0x17,0x0,0x3);
  288.         audience_write(0x18,0x0,0x3);
  289.         audience_write(0x17,0x0,0x23);
  290.         audience_write(0x18,0x0,0x0);
  291.         audience_write(0x0,0x0,0x0);
  292.         audience_write(0x0,0x0,0x0);
  293.         audience_write(0x10,0x0,0x1);
  294.         audience_write(0x17,0x0,0x2);
  295.         audience_write(0x18,0x0,0x2);
  296.         audience_write(0x1b,0x0,0x3);
  297.         audience_write(0x23,0xff,0xf4);
  298.         audience_write(0x17,0x0,0x23);
  299.         //crashes on next write
  300.  
  301.         audience_write(0x18,0x0,0x1);
  302.         audience_write(0x17,0x0,0x0);
  303.         audience_write(0x18,0x0,0x3);
  304.         audience_write(0x17,0x0,0x2e);
  305.         audience_write(0x18,0xff,0xbf);
  306.         audience_write(0xc,0x3,0x0);
  307.         audience_write(0xd,0x0,0x0);
  308.         audience_write(0x15,0x0,0x12);
  309.         audience_write(0x17,0x0,0x2);
  310.         audience_write(0x18,0x0,0x0);
  311.         audience_write(0x1b,0x0,0x0);
  312.         audience_write(0x15,0x0,0x5);
  313.         audience_write(0x23,0xff,0xfc);
  314.         audience_write(0x17,0x0,0x3);
  315.         audience_write(0x18,0x0,0x3);
  316.         audience_write(0x17,0x0,0x0);
  317.         audience_write(0x18,0x0,0x6);
  318.         audience_write(0xc,0x3,0x0);
  319.         audience_write(0xd,0x0,0x2);
  320.         audience_write(0x17,0x0,0x2);
  321.         audience_write(0x18,0x0,0x2);
  322.         audience_write(0x1b,0x0,0x3);
  323.         audience_write(0x23,0xff,0xf4);
  324.         audience_write(0x17,0x0,0x23);
  325.         audience_write(0x18,0x0,0x1);
  326.         audience_write(0x17,0x0,0x0);
  327.         audience_write(0x18,0x0,0x3);
  328.         audience_write(0x17,0x0,0x2e);
  329.         audience_write(0x18,0xff,0xbf);
  330.         audience_write(0xc,0x3,0x0);
  331.         audience_write(0xd,0x0,0x0);
  332.         audience_write(0x15,0x0,0x12);
  333.         audience_write(0x17,0x0,0x2);
  334.         audience_write(0x18,0x0,0x0);
  335.         audience_write(0x1b,0x0,0x0);
  336.         audience_write(0x15,0x0,0x5);
  337.         audience_write(0x23,0xff,0xfc);
  338.         audience_write(0x17,0x0,0x3);
  339.         audience_write(0x18,0x0,0x3);
  340.         audience_write(0x17,0x0,0x0);
  341.         audience_write(0x18,0x0,0x6);
  342.         audience_write(0xc,0x3,0x0);
  343.         audience_write(0xd,0x0,0x2);
  344.         audience_write(0x0,0x0,0x0);
  345.         audience_write(0x0,0x0,0x0);
  346.         audience_write(0x17,0x0,0x12);
  347.         audience_write(0x18,0xff,0xfc);
  348.         audience_write(0x17,0x0,0x12);
  349.         audience_write(0x18,0xff,0xfc);
  350.         audience_write(0x17,0x0,0x12);
  351.         audience_write(0x18,0xff,0xfc);
  352.         audience_write(0x17,0x0,0x12);
  353.         audience_write(0x18,0xff,0xfc);
  354.         audience_write(0x17,0x0,0x12);
  355.         audience_write(0x18,0xff,0xfc);
  356.         audience_write(0x17,0x0,0x12);
  357.         audience_write(0x18,0xff,0xfc);
  358.         audience_write(0x17,0x0,0x12);
  359.         audience_write(0x18,0xff,0xfc);
  360.         audience_write(0x17,0x0,0x12);
  361.         audience_write(0x18,0xff,0xfc);
  362.         audience_write(0x17,0x0,0x12);
  363.         audience_write(0x18,0xff,0xfc);
  364.         audience_write(0x17,0x0,0x12);
  365.         audience_write(0x18,0xff,0xfc);
  366.         audience_write(0x17,0x0,0x12);
  367.         audience_write(0x18,0xff,0xfc);
  368.         audience_write(0x17,0x0,0x12);
  369.         audience_write(0x18,0xff,0xfc);
  370.         audience_write(0x17,0x0,0x12);
  371.         audience_write(0x18,0xff,0xfe);
  372.         audience_write(0x17,0x0,0x12);
  373.         audience_write(0x18,0xff,0xfe);
  374.         audience_write(0x17,0x0,0x12);
  375.         audience_write(0x18,0xff,0xfe);
  376.         audience_write(0x17,0x0,0x12);
  377.         audience_write(0x18,0xff,0xfe);
  378.         audience_write(0x17,0x0,0x12);
  379.         audience_write(0x18,0xff,0xfe);
  380.         audience_write(0x17,0x0,0x12);
  381.         audience_write(0x18,0xff,0xfe);
  382. */
  383. }
  384.  
  385. void adc_write_command(unsigned char reg, unsigned char val)
  386. {
  387.         pr_err("[ADC3001] writing %0.8X, %0.8X\n", reg, val);
  388.         i2c_write(_dat.adc3001, reg, &val, 1);
  389. }
  390.  
  391. void enable_adc3001(void)
  392. {      
  393. //      init_mic();
  394.         adc_write_command(0x0,0x0);
  395.         adc_write_command(0x1,0x1);
  396.         adc_write_command(0x5,0x11);
  397.         adc_write_command(0x4,0x3);
  398.         adc_write_command(0x6,0x5);
  399.         adc_write_command(0x7,0x4);
  400.         adc_write_command(0x8,0xb0);
  401.         adc_write_command(0x12,0xb0);
  402.         adc_write_command(0x13,0x82);
  403.         adc_write_command(0x14,0x80);
  404.         adc_write_command(0x1b,0x4c);
  405.         adc_write_command(0x1c,0x1);
  406.         adc_write_command(0x14,0x2);
  407.         adc_write_command(0x1e,0x81);
  408.         adc_write_command(0x5,0x91);
  409.         adc_write_command(0x35,0x2);
  410.         adc_write_command(0x0,0x1);
  411.         adc_write_command(0x34,0xfc);
  412.         adc_write_command(0x37,0xfc);
  413.         adc_write_command(0x33,0x8);
  414.         adc_write_command(0x0,0x0);
  415.         adc_write_command(0x3d,0x1);
  416.         adc_write_command(0x51,0xc0);
  417.         adc_write_command(0x52,0x0);
  418. }
  419.  
  420.  
  421. #define IC_REG          0x1
  422. #define ATK_REG         0x2
  423. #define REL_REG         0x3
  424. #define HOLD_REG        0x4
  425. #define FIXED_GAIN_REG  0x5
  426. #define AGC_REG1        0x6
  427. #define AGC_REG2        0x7
  428.  
  429. #define SPK_EN_L        1<<6
  430. #define SPK_EN_R        1<<7
  431.  
  432. void tpa_set_power(uint8_t arg) {
  433.         char buf;
  434.         if(i2c_read(_dat.tpa2016, IC_REG, &buf, 1)) {
  435.                 pr_err("Can't get tpa's power i2c reg\n");
  436.                 return;
  437.         }
  438.         buf&=0xc0;//power settings are two last bits
  439.         buf|=arg;
  440.         if(i2c_write(_dat.tpa2016, IC_REG, &buf, 1))
  441.                 pr_err("Can't get tpa's power i2c reg\n");
  442. }
  443.  
  444. void tpa_set_attack_time(uint8_t arg) {
  445.         //Only 6 lower bits
  446.         arg&=0x3f;
  447.         if(i2c_write(_dat.tpa2016, ATK_REG, &arg, 1))
  448.                 pr_err("Can't set tpa's attack time i2c reg\n");
  449. }
  450.  
  451. void tpa_set_release_time(uint8_t arg) {
  452.         //Only 6 lower bits
  453.         arg&=0x3f;
  454.         if(i2c_write(_dat.tpa2016, REL_REG, &arg, 1))
  455.                 pr_err("Can't set tpa's release time i2c reg\n");
  456. }
  457.  
  458. void tpa_set_hold_time(uint8_t arg) {
  459.         //Only 6 lower bits
  460.         arg&=0x3f;
  461.         if(i2c_write(_dat.tpa2016, HOLD_REG, &arg, 1))
  462.                 pr_err("Can't set tpa's hold time i2c reg\n");
  463. }
  464.  
  465. void tpa_set_fixed_gain(uint8_t arg) {
  466.         //Only 6 lower bits
  467.         arg&=0x3f;
  468.         if(i2c_write(_dat.tpa2016, FIXED_GAIN_REG, &arg, 1))
  469.                 pr_err("Can't set tpa's fixed gain i2c reg\n");
  470. }
  471.  
  472. void tpa_set_output_limiter(uint8_t arg) {
  473.         char buf;
  474.         if(i2c_read(_dat.tpa2016, AGC_REG1, &buf, 1)) {
  475.                 pr_err("Can't get tpa's agc reg1 i2c reg\n");
  476.                 return;
  477.         }
  478.         buf&=0xf0;//output limiter is the lowest 4 bits
  479.         //0xff = disable output limiter
  480.         if(arg==0xff)
  481.                 buf&=~(1<<7);
  482.         else {
  483.                 arg&=0xf;
  484.                 buf|=arg;
  485.         }
  486.         if(i2c_write(_dat.tpa2016, AGC_REG1, &buf, 1))
  487.                 pr_err("Can't set tpa's agc reg1 i2c reg\n");
  488. }
  489.  
  490. void tpa_set_noise_gate_threshold(uint8_t arg) {
  491.         char buf;
  492.         if(i2c_read(_dat.tpa2016, AGC_REG1, &buf, 1)) {
  493.                 pr_err("Can't get tpa's agc reg1 i2c reg\n");
  494.                 return;
  495.         }
  496.         buf&=0x9f;//noise gate threshold is the {5,6} bits
  497.         arg&=0x3;
  498.         buf|=arg<<5;
  499.         if(i2c_write(_dat.tpa2016, AGC_REG1, &buf, 1))
  500.                 pr_err("Can't get tpa's agc reg1 i2c reg\n");
  501. }
  502.  
  503. void tpa_set_max_gain(uint8_t arg) {
  504.         char buf;
  505.         if(i2c_read(_dat.tpa2016, AGC_REG2, &buf, 1)) {
  506.                 pr_err("Can't get tpa's agc reg2 i2c reg\n");
  507.                 return;
  508.         }
  509.         buf&=0x0f;//max gain is the highest 4 bits
  510.         arg&=0xf;
  511.         buf|=arg<<4;
  512.         if(i2c_write(_dat.tpa2016, AGC_REG2, &buf, 1))
  513.                 pr_err("Can't set tpa's agc reg2 i2c reg\n");
  514. }
  515.  
  516. void tpa_set_compression_ratio(uint8_t arg) {
  517.         char buf;
  518.         if(i2c_read(_dat.tpa2016, AGC_REG2, &buf, 1)) {
  519.                 pr_err("Can't get tpa's agc reg2 i2c reg\n");
  520.                 return;
  521.         }
  522.         buf&=0xfc;//compression ratio is the lowest 2 bits
  523.         arg&=3;
  524.         buf|=arg;
  525.         if(i2c_write(_dat.tpa2016, AGC_REG2, &buf, 1))
  526.                 pr_err("Can't set tpa's agc reg2 i2c reg\n");
  527. }
  528.  
  529. void tpa_write(uint8_t reg, uint8_t arg) {
  530.         if(i2c_write(_dat.tpa2016, reg, &arg, 1))
  531.                 pr_err("Can't write tpa\n");
  532. }
  533.  
  534. void gpio_fixup()
  535. {
  536.         msm_gpio_set_function(DEX_GPIO_CFG(61,0,GPIO_OUTPUT,GPIO_NO_PULL,GPIO_2MA,1));
  537.         msm_gpio_set_function(DEX_GPIO_CFG(60,0,GPIO_OUTPUT,GPIO_NO_PULL,GPIO_2MA,1));
  538. }
  539.  
  540. void gpio_unfixup()
  541. {
  542.         msm_gpio_set_function(DEX_GPIO_CFG(61,1,GPIO_OUTPUT,GPIO_NO_PULL,GPIO_2MA,0));
  543.         msm_gpio_set_function(DEX_GPIO_CFG(60,1,GPIO_OUTPUT,GPIO_NO_PULL,GPIO_2MA,0));
  544. }
  545.  
  546. void enable_speaker_rhod(void) {
  547.         if(!machine_is_htcrhodium())
  548.                 return;
  549.        
  550.  
  551.         gpio_direction_output(SPKR_PWR, 1);
  552.         mdelay(1);
  553.  
  554.         //Default is use wince's setting
  555.         tpa_write(0x1,0xc2);
  556.         tpa_write(0x2,0x20);
  557.         tpa_write(0x3,0x1);
  558.         tpa_write(0x4,0x0);
  559.         tpa_write(0x5,0x10);
  560.         tpa_write(0x6,0x19);
  561.         tpa_write(0x7,0xc0);
  562. }
  563.  
  564. //#define JONPRY
  565. void init_mic_post_adc();
  566. void init_audio()
  567. {
  568.         writel(0x46,MSM_GPIOCFG1_BASE+0x20);
  569.         writel(0x0,MSM_GPIOCFG1_BASE+0x24);
  570.  
  571.         writel(0x47,MSM_GPIOCFG1_BASE+0x20);
  572.         writel(0x0,MSM_GPIOCFG1_BASE+0x24);
  573.  
  574.         writel(0x54,MSM_GPIOCFG1_BASE+0x20);
  575.         writel(0x0,MSM_GPIOCFG1_BASE+0x24);
  576.  
  577.         writel(0x58,MSM_GPIOCFG1_BASE+0x20);
  578.         writel(0x0,MSM_GPIOCFG1_BASE+0x24);
  579.  
  580.         writel(0x2c,MSM_GPIOCFG1_BASE+0x20);
  581.         writel(0x0,MSM_GPIOCFG1_BASE+0x24);
  582.  
  583.         writel(0x58,MSM_GPIOCFG1_BASE+0x20);
  584.         writel(0x0,MSM_GPIOCFG1_BASE+0x24);
  585.  
  586.         init_mic();
  587. #ifdef JONPRY
  588.         gpio_fixup();
  589. #endif
  590.         enable_adc3001();
  591.         init_mic_post_adc();
  592.         audience_enable();
  593.         enable_speaker_rhod();
  594. #ifdef JONPRY
  595.         gpio_unfixup();
  596. #endif
  597. }
  598.  
  599. void disable_speaker_rhod(void) {
  600.         if(!machine_is_htcrhodium())
  601.                 return;
  602.         gpio_direction_output(SPKR_PWR, 0);
  603. }
  604.  
  605. void speaker_vol_rhod(int arg) {
  606.         //arg ranges from 0 to 5 (0 is supposed to be off I think)
  607.         //Gain ranges from 0 to 30
  608.         int gain=arg*6;
  609.         tpa_set_fixed_gain(gain);
  610. }
  611.  
  612. //TI TPA2016 speaker amplificator
  613. //Datasheet available on TI's site.
  614. static int tpa_probe(struct i2c_client *client, const struct i2c_device_id *id) {
  615.         int res;
  616.         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
  617.                 pr_err("[TPA2016] i2c_check_functionality error!\n");
  618.                 return -ENOTSUPP;
  619.         }
  620.         strlcpy(client->name, "tpa2016", I2C_NAME_SIZE);
  621.         _dat.tpa2016=client;
  622.         res = gpio_request(SPKR_PWR, "SPK AMP");
  623.         if(res<0) {
  624.                 pr_err("[TPA2016] Can't reserve gpio\n");
  625.         }
  626.         return 0;
  627. }
  628.  
  629. static const struct i2c_device_id tpa_ids[] = {
  630.         { "tpa2016", 0 },
  631.         { }
  632. };
  633.  
  634. static struct i2c_driver tpa_driver = {
  635.         .driver = {
  636.                 .name   = "tpa2016",
  637.                 .owner  = THIS_MODULE,
  638.         },
  639.         .id_table = tpa_ids,
  640.         .probe = tpa_probe,
  641. };
  642.  
  643. //Audience A1010 (sound cancelation, etc)
  644. static int aud_probe(struct i2c_client *client, const struct i2c_device_id *id) {
  645.         //Not much to do here uh ?
  646.         _dat.a1010=client;
  647.         //audience_enable();
  648.         return 0;
  649. }
  650.  
  651. static const struct i2c_device_id aud_ids[] = {
  652.         { "a1010", 0 },
  653.         { }
  654. };
  655.  
  656. static struct i2c_driver aud_driver = {
  657.         .driver = {
  658.                 .name   = "a1010",
  659.                 .owner  = THIS_MODULE,
  660.         },
  661.         .id_table = aud_ids,
  662.         .probe = aud_probe,
  663. };
  664.  
  665. //ADC3001 ADC + mic bias
  666. static int adc_probe(struct i2c_client *client, const struct i2c_device_id *id) {
  667.         //Not much to do here uh ?
  668.         _dat.adc3001=client;
  669.         //enable_adc3001();
  670.         return 0;
  671. }
  672.  
  673. static const struct i2c_device_id adc_ids[] = {
  674.         { "adc3001", 0 },
  675.         { }
  676. };
  677.  
  678. static struct i2c_driver adc_driver = {
  679.         .driver = {
  680.                 .name   = "adc3001",
  681.                 .owner  = THIS_MODULE,
  682.         },
  683.         .id_table = adc_ids,
  684.         .probe = adc_probe,
  685. };
  686.  
  687. static int __init rhod_audio_init(void) {
  688.         int rc;
  689.  
  690.         if(!machine_is_htcrhodium())
  691.                 return 0;
  692.  
  693.         printk(KERN_INFO "Rhodium audio registering drivers\n");
  694.         rc=i2c_add_driver(&tpa_driver);
  695.         if(rc)
  696.                 return rc;
  697.  
  698.         rc=i2c_add_driver(&adc_driver);
  699.         if(rc)
  700.                 return rc;
  701.  
  702.         return i2c_add_driver(&aud_driver);
  703. }
  704.  
  705. module_init(rhod_audio_init);
create new paste | create new version of this paste RAW Paste Data