typo fixes: specfic -> specific
[linux-2.6.git] / sound / aoa / soundbus / i2sbus / i2sbus-control.c
1 /*
2  * i2sbus driver -- bus control routines
3  *
4  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * GPL v2, can be found in COPYING.
7  */
8
9 #include <asm/io.h>
10 #include <linux/delay.h>
11 #include <asm/prom.h>
12 #include <asm/macio.h>
13 #include <asm/pmac_feature.h>
14 #include <asm/pmac_pfunc.h>
15 #include "i2sbus.h"
16
17 int i2sbus_control_init(struct macio_dev* dev, struct i2sbus_control **c)
18 {
19         *c = kzalloc(sizeof(struct i2sbus_control), GFP_KERNEL);
20         if (!*c)
21                 return -ENOMEM;
22
23         INIT_LIST_HEAD(&(*c)->list);
24
25         if (of_address_to_resource(dev->ofdev.node, 0, &(*c)->rsrc))
26                 goto err;
27         /* we really should be using feature calls instead of mapping
28          * these registers. It's safe for now since no one else is
29          * touching them... */
30         (*c)->controlregs = ioremap((*c)->rsrc.start,
31                                     sizeof(struct i2s_control_regs));
32         if (!(*c)->controlregs)
33                 goto err;
34
35         return 0;
36  err:
37         kfree(*c);
38         *c = NULL;
39         return -ENODEV;
40 }
41
42 void i2sbus_control_destroy(struct i2sbus_control *c)
43 {
44         iounmap(c->controlregs);
45         kfree(c);
46 }
47
48 /* this is serialised externally */
49 int i2sbus_control_add_dev(struct i2sbus_control *c,
50                            struct i2sbus_dev *i2sdev)
51 {
52         struct device_node *np;
53
54         np = i2sdev->sound.ofdev.node;
55         i2sdev->enable = pmf_find_function(np, "enable");
56         i2sdev->cell_enable = pmf_find_function(np, "cell-enable");
57         i2sdev->clock_enable = pmf_find_function(np, "clock-enable");
58         i2sdev->cell_disable = pmf_find_function(np, "cell-disable");
59         i2sdev->clock_disable = pmf_find_function(np, "clock-disable");
60
61         /* if the bus number is not 0 or 1 we absolutely need to use
62          * the platform functions -- there's nothing in Darwin that
63          * would allow seeing a system behind what the FCRs are then,
64          * and I don't want to go parsing a bunch of platform functions
65          * by hand to try finding a system... */
66         if (i2sdev->bus_number != 0 && i2sdev->bus_number != 1 &&
67             (!i2sdev->enable ||
68              !i2sdev->cell_enable || !i2sdev->clock_enable ||
69              !i2sdev->cell_disable || !i2sdev->clock_disable)) {
70                 pmf_put_function(i2sdev->enable);
71                 pmf_put_function(i2sdev->cell_enable);
72                 pmf_put_function(i2sdev->clock_enable);
73                 pmf_put_function(i2sdev->cell_disable);
74                 pmf_put_function(i2sdev->clock_disable);
75                 return -ENODEV;
76         }
77
78         list_add(&i2sdev->item, &c->list);
79
80         return 0;
81 }
82
83 void i2sbus_control_remove_dev(struct i2sbus_control *c,
84                                struct i2sbus_dev *i2sdev)
85 {
86         /* this is serialised externally */
87         list_del(&i2sdev->item);
88         if (list_empty(&c->list))
89                 i2sbus_control_destroy(c);
90 }
91
92 int i2sbus_control_enable(struct i2sbus_control *c,
93                           struct i2sbus_dev *i2sdev)
94 {
95         struct pmf_args args = { .count = 0 };
96         int cc;
97
98         if (i2sdev->enable)
99                 return pmf_call_one(i2sdev->enable, &args);
100
101         switch (i2sdev->bus_number) {
102         case 0:
103                 cc = in_le32(&c->controlregs->cell_control);
104                 out_le32(&c->controlregs->cell_control, cc | CTRL_CLOCK_INTF_0_ENABLE);
105                 break;
106         case 1:
107                 cc = in_le32(&c->controlregs->cell_control);
108                 out_le32(&c->controlregs->cell_control, cc | CTRL_CLOCK_INTF_1_ENABLE);
109                 break;
110         default:
111                 return -ENODEV;
112         }
113         return 0;
114 }
115
116 int i2sbus_control_cell(struct i2sbus_control *c,
117                         struct i2sbus_dev *i2sdev,
118                         int enable)
119 {
120         struct pmf_args args = { .count = 0 };
121         int cc;
122
123         switch (enable) {
124         case 0:
125                 if (i2sdev->cell_disable)
126                         return pmf_call_one(i2sdev->cell_disable, &args);
127                 break;
128         case 1:
129                 if (i2sdev->cell_enable)
130                         return pmf_call_one(i2sdev->cell_enable, &args);
131                 break;
132         default:
133                 printk(KERN_ERR "i2sbus: INVALID CELL ENABLE VALUE\n");
134                 return -ENODEV;
135         }
136         switch (i2sdev->bus_number) {
137         case 0:
138                 cc = in_le32(&c->controlregs->cell_control);
139                 cc &= ~CTRL_CLOCK_CELL_0_ENABLE;
140                 cc |= enable * CTRL_CLOCK_CELL_0_ENABLE;
141                 out_le32(&c->controlregs->cell_control, cc);
142                 break;
143         case 1:
144                 cc = in_le32(&c->controlregs->cell_control);
145                 cc &= ~CTRL_CLOCK_CELL_1_ENABLE;
146                 cc |= enable * CTRL_CLOCK_CELL_1_ENABLE;
147                 out_le32(&c->controlregs->cell_control, cc);
148                 break;
149         default:
150                 return -ENODEV;
151         }
152         return 0;
153 }
154
155 int i2sbus_control_clock(struct i2sbus_control *c,
156                          struct i2sbus_dev *i2sdev,
157                          int enable)
158 {
159         struct pmf_args args = { .count = 0 };
160         int cc;
161
162         switch (enable) {
163         case 0:
164                 if (i2sdev->clock_disable)
165                         return pmf_call_one(i2sdev->clock_disable, &args);
166                 break;
167         case 1:
168                 if (i2sdev->clock_enable)
169                         return pmf_call_one(i2sdev->clock_enable, &args);
170                 break;
171         default:
172                 printk(KERN_ERR "i2sbus: INVALID CLOCK ENABLE VALUE\n");
173                 return -ENODEV;
174         }
175         switch (i2sdev->bus_number) {
176         case 0:
177                 cc = in_le32(&c->controlregs->cell_control);
178                 cc &= ~CTRL_CLOCK_CLOCK_0_ENABLE;
179                 cc |= enable * CTRL_CLOCK_CLOCK_0_ENABLE;
180                 out_le32(&c->controlregs->cell_control, cc);
181                 break;
182         case 1:
183                 cc = in_le32(&c->controlregs->cell_control);
184                 cc &= ~CTRL_CLOCK_CLOCK_1_ENABLE;
185                 cc |= enable * CTRL_CLOCK_CLOCK_1_ENABLE;
186                 out_le32(&c->controlregs->cell_control, cc);
187                 break;
188         default:
189                 return -ENODEV;
190         }
191         return 0;
192 }