Merge branch 'drm-forlinus' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied...
[linux-2.6] / sound / oss / dmasound / dac3550a.c
1 /*
2  * Driver for the i2c/i2s based DAC3550a sound chip used
3  * on some Apple iBooks. Also known as "DACA".
4  *
5  *  This file is subject to the terms and conditions of the GNU General Public
6  *  License.  See the file COPYING in the main directory of this archive
7  *  for more details.
8  */
9
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/delay.h>
13 #include <linux/proc_fs.h>
14 #include <linux/ioport.h>
15 #include <linux/sysctl.h>
16 #include <linux/types.h>
17 #include <linux/i2c.h>
18 #include <linux/init.h>
19 #include <asm/uaccess.h>
20 #include <asm/errno.h>
21 #include <asm/io.h>
22
23 #include "dmasound.h"
24
25 /* FYI: This code was derived from the tas3001c.c Texas/Tumbler mixer
26  * control code, as well as info derived from the AppleDACAAudio driver
27  * from Darwin CVS (main thing I derived being register numbers and 
28  * values, as well as when to make the calls). */
29
30 #define I2C_DRIVERID_DACA (0xFDCB)
31
32 #define DACA_VERSION    "0.1"
33 #define DACA_DATE "20010930"
34
35 static int cur_left_vol;
36 static int cur_right_vol;
37 static struct i2c_client *daca_client;
38
39 static int daca_attach_adapter(struct i2c_adapter *adapter);
40 static int daca_detect_client(struct i2c_adapter *adapter, int address);
41 static int daca_detach_client(struct i2c_client *client);
42
43 struct i2c_driver daca_driver = {  
44         .driver = {
45                 .name           = "DAC3550A driver  V " DACA_VERSION,
46         },
47         .id                     = I2C_DRIVERID_DACA,
48         .attach_adapter         = daca_attach_adapter,
49         .detach_client          = daca_detach_client,
50 };
51
52 #define VOL_MAX ((1<<20) - 1)
53
54 void daca_get_volume(uint * left_vol, uint  *right_vol)
55 {
56         *left_vol = cur_left_vol >> 5;
57         *right_vol = cur_right_vol >> 5;
58 }
59
60 int daca_set_volume(uint left_vol, uint right_vol)
61 {
62         unsigned short voldata;
63   
64         if (!daca_client)
65                 return -1;
66
67         /* Derived from experience, not from any specific values */
68         left_vol <<= 5;
69         right_vol <<= 5;
70
71         if (left_vol > VOL_MAX)
72                 left_vol = VOL_MAX;
73         if (right_vol > VOL_MAX)
74                 right_vol = VOL_MAX;
75
76         voldata = ((left_vol >> 14)  & 0x3f) << 8;
77         voldata |= (right_vol >> 14)  & 0x3f;
78   
79         if (i2c_smbus_write_word_data(daca_client, 2, voldata) < 0) {
80                 printk("daca: failed to set volume \n");
81                 return -1; 
82         }
83
84         cur_left_vol = left_vol;
85         cur_right_vol = right_vol;
86   
87         return 0;
88 }
89
90 int daca_leave_sleep(void)
91 {
92         if (!daca_client)
93                 return -1;
94   
95         /* Do a short sleep, just to make sure I2C bus is awake and paying
96          * attention to us
97          */
98         msleep(20);
99         /* Write the sample rate reg the value it needs */
100         i2c_smbus_write_byte_data(daca_client, 1, 8);
101         daca_set_volume(cur_left_vol >> 5, cur_right_vol >> 5);
102         /* Another short delay, just to make sure the other I2C bus writes
103          * have taken...
104          */
105         msleep(20);
106         /* Write the global config reg - invert right power amp,
107          * DAC on, use 5-volt mode */
108         i2c_smbus_write_byte_data(daca_client, 3, 0x45);
109
110         return 0;
111 }
112
113 int daca_enter_sleep(void)
114 {
115         if (!daca_client)
116                 return -1;
117
118         i2c_smbus_write_byte_data(daca_client, 1, 8);
119         daca_set_volume(cur_left_vol >> 5, cur_right_vol >> 5);
120
121         /* Write the global config reg - invert right power amp,
122          * DAC on, enter low-power mode, use 5-volt mode
123          */
124         i2c_smbus_write_byte_data(daca_client, 3, 0x65);
125
126         return 0;
127 }
128
129 static int daca_attach_adapter(struct i2c_adapter *adapter)
130 {
131         if (!strncmp(adapter->name, "mac-io", 6))
132                 daca_detect_client(adapter, 0x4d);
133         return 0;
134 }
135
136 static int daca_init_client(struct i2c_client * new_client)
137 {
138         /* 
139          * Probe is not working with the current i2c-keywest
140          * driver. We try to use addr 0x4d on each adapters
141          * instead, by setting the format register.
142          * 
143          * FIXME: I'm sure that can be obtained from the
144          * device-tree. --BenH.
145          */
146   
147         /* Write the global config reg - invert right power amp,
148          * DAC on, use 5-volt mode
149          */
150         if (i2c_smbus_write_byte_data(new_client, 3, 0x45))
151                 return -1;
152
153         i2c_smbus_write_byte_data(new_client, 1, 8);
154         daca_client = new_client;
155         daca_set_volume(15000, 15000);
156
157         return 0;
158 }
159
160 static int daca_detect_client(struct i2c_adapter *adapter, int address)
161 {
162         const char *client_name = "DAC 3550A Digital Equalizer";
163         struct i2c_client *new_client;
164         int rc = -ENODEV;
165
166         new_client = kmalloc(sizeof(*new_client), GFP_KERNEL);
167         if (!new_client)
168                 return -ENOMEM;
169         memset(new_client, 0, sizeof(*new_client));
170
171         new_client->addr = address;
172         new_client->adapter = adapter;
173         new_client->driver = &daca_driver;
174         new_client->flags = 0;
175         strcpy(new_client->name, client_name);
176
177         if (daca_init_client(new_client))
178                 goto bail;
179
180         /* Tell the i2c layer a new client has arrived */
181         if (i2c_attach_client(new_client))
182                 goto bail;
183
184         return 0;
185  bail:
186         kfree(new_client);
187         return rc;
188 }
189
190
191 static int daca_detach_client(struct i2c_client *client)
192 {
193         if (client == daca_client)
194                 daca_client = NULL;
195
196         i2c_detach_client(client);
197         kfree(client);
198         return 0;
199 }
200
201 void daca_cleanup(void)
202 {
203         i2c_del_driver(&daca_driver);
204 }
205
206 int daca_init(void)
207 {
208         printk("dac3550a driver version %s (%s)\n",DACA_VERSION,DACA_DATE);
209         return i2c_add_driver(&daca_driver);
210 }