]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/arm/common/locomo.c | |
3 | * | |
4 | * Sharp LoCoMo support | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 as | |
8 | * published by the Free Software Foundation. | |
9 | * | |
10 | * This file contains all generic LoCoMo support. | |
11 | * | |
12 | * All initialization functions provided here are intended to be called | |
13 | * from machine specific code with proper arguments when required. | |
14 | * | |
15 | * Based on sa1111.c | |
16 | */ | |
17 | ||
1da177e4 LT |
18 | #include <linux/module.h> |
19 | #include <linux/init.h> | |
20 | #include <linux/kernel.h> | |
21 | #include <linux/delay.h> | |
22 | #include <linux/errno.h> | |
23 | #include <linux/ioport.h> | |
d052d1be | 24 | #include <linux/platform_device.h> |
1da177e4 LT |
25 | #include <linux/slab.h> |
26 | #include <linux/spinlock.h> | |
fced80c7 | 27 | #include <linux/io.h> |
1da177e4 | 28 | |
a09e64fb | 29 | #include <mach/hardware.h> |
1da177e4 LT |
30 | #include <asm/irq.h> |
31 | #include <asm/mach/irq.h> | |
32 | ||
33 | #include <asm/hardware/locomo.h> | |
34 | ||
35 | /* M62332 output channel selection */ | |
36 | #define M62332_EVR_CH 1 /* M62332 volume channel number */ | |
37 | /* 0 : CH.1 , 1 : CH. 2 */ | |
38 | /* DAC send data */ | |
39 | #define M62332_SLAVE_ADDR 0x4e /* Slave address */ | |
40 | #define M62332_W_BIT 0x00 /* W bit (0 only) */ | |
41 | #define M62332_SUB_ADDR 0x00 /* Sub address */ | |
42 | #define M62332_A_BIT 0x00 /* A bit (0 only) */ | |
43 | ||
44 | /* DAC setup and hold times (expressed in us) */ | |
45 | #define DAC_BUS_FREE_TIME 5 /* 4.7 us */ | |
46 | #define DAC_START_SETUP_TIME 5 /* 4.7 us */ | |
47 | #define DAC_STOP_SETUP_TIME 4 /* 4.0 us */ | |
48 | #define DAC_START_HOLD_TIME 5 /* 4.7 us */ | |
49 | #define DAC_SCL_LOW_HOLD_TIME 5 /* 4.7 us */ | |
50 | #define DAC_SCL_HIGH_HOLD_TIME 4 /* 4.0 us */ | |
51 | #define DAC_DATA_SETUP_TIME 1 /* 250 ns */ | |
52 | #define DAC_DATA_HOLD_TIME 1 /* 300 ns */ | |
53 | #define DAC_LOW_SETUP_TIME 1 /* 300 ns */ | |
54 | #define DAC_HIGH_SETUP_TIME 1 /* 1000 ns */ | |
55 | ||
56 | /* the following is the overall data for the locomo chip */ | |
57 | struct locomo { | |
58 | struct device *dev; | |
59 | unsigned long phys; | |
60 | unsigned int irq; | |
61 | spinlock_t lock; | |
54815366 | 62 | void __iomem *base; |
93160c63 RW |
63 | #ifdef CONFIG_PM |
64 | void *saved_state; | |
65 | #endif | |
1da177e4 LT |
66 | }; |
67 | ||
68 | struct locomo_dev_info { | |
69 | unsigned long offset; | |
70 | unsigned long length; | |
71 | unsigned int devid; | |
72 | unsigned int irq[1]; | |
73 | const char * name; | |
74 | }; | |
75 | ||
76 | /* All the locomo devices. If offset is non-zero, the mapbase for the | |
77 | * locomo_dev will be set to the chip base plus offset. If offset is | |
78 | * zero, then the mapbase for the locomo_dev will be set to zero. An | |
79 | * offset of zero means the device only uses GPIOs or other helper | |
80 | * functions inside this file */ | |
81 | static struct locomo_dev_info locomo_devices[] = { | |
82 | { | |
83 | .devid = LOCOMO_DEVID_KEYBOARD, | |
84 | .irq = { | |
85 | IRQ_LOCOMO_KEY, | |
86 | }, | |
87 | .name = "locomo-keyboard", | |
88 | .offset = LOCOMO_KEYBOARD, | |
89 | .length = 16, | |
90 | }, | |
91 | { | |
92 | .devid = LOCOMO_DEVID_FRONTLIGHT, | |
93 | .irq = {}, | |
94 | .name = "locomo-frontlight", | |
95 | .offset = LOCOMO_FRONTLIGHT, | |
96 | .length = 8, | |
97 | ||
98 | }, | |
99 | { | |
100 | .devid = LOCOMO_DEVID_BACKLIGHT, | |
101 | .irq = {}, | |
102 | .name = "locomo-backlight", | |
103 | .offset = LOCOMO_BACKLIGHT, | |
104 | .length = 8, | |
105 | }, | |
106 | { | |
107 | .devid = LOCOMO_DEVID_AUDIO, | |
108 | .irq = {}, | |
109 | .name = "locomo-audio", | |
110 | .offset = LOCOMO_AUDIO, | |
111 | .length = 4, | |
112 | }, | |
113 | { | |
114 | .devid = LOCOMO_DEVID_LED, | |
115 | .irq = {}, | |
116 | .name = "locomo-led", | |
117 | .offset = LOCOMO_LED, | |
118 | .length = 8, | |
119 | }, | |
120 | { | |
121 | .devid = LOCOMO_DEVID_UART, | |
122 | .irq = {}, | |
123 | .name = "locomo-uart", | |
124 | .offset = 0, | |
125 | .length = 0, | |
126 | }, | |
a2025e7f DO |
127 | { |
128 | .devid = LOCOMO_DEVID_SPI, | |
129 | .irq = {}, | |
130 | .name = "locomo-spi", | |
131 | .offset = LOCOMO_SPI, | |
132 | .length = 0x30, | |
133 | }, | |
1da177e4 LT |
134 | }; |
135 | ||
10dd5ce2 | 136 | static void locomo_handler(unsigned int irq, struct irq_desc *desc) |
1da177e4 LT |
137 | { |
138 | int req, i; | |
10dd5ce2 | 139 | void __iomem *mapbase = get_irq_chip_data(irq); |
1da177e4 LT |
140 | |
141 | /* Acknowledge the parent IRQ */ | |
142 | desc->chip->ack(irq); | |
143 | ||
144 | /* check why this interrupt was generated */ | |
145 | req = locomo_readl(mapbase + LOCOMO_ICR) & 0x0f00; | |
146 | ||
147 | if (req) { | |
148 | /* generate the next interrupt(s) */ | |
00dd8027 | 149 | irq = IRQ_LOCOMO_KEY; |
d8aa0251 | 150 | for (i = 0; i <= 3; i++, irq++) { |
1da177e4 | 151 | if (req & (0x0100 << i)) { |
d8aa0251 | 152 | generic_handle_irq(irq); |
1da177e4 LT |
153 | } |
154 | ||
155 | } | |
156 | } | |
157 | } | |
158 | ||
159 | static void locomo_ack_irq(unsigned int irq) | |
160 | { | |
161 | } | |
162 | ||
163 | static void locomo_mask_irq(unsigned int irq) | |
164 | { | |
10dd5ce2 | 165 | void __iomem *mapbase = get_irq_chip_data(irq); |
1da177e4 LT |
166 | unsigned int r; |
167 | r = locomo_readl(mapbase + LOCOMO_ICR); | |
00dd8027 | 168 | r &= ~(0x0010 << (irq - IRQ_LOCOMO_KEY)); |
1da177e4 LT |
169 | locomo_writel(r, mapbase + LOCOMO_ICR); |
170 | } | |
171 | ||
172 | static void locomo_unmask_irq(unsigned int irq) | |
173 | { | |
10dd5ce2 | 174 | void __iomem *mapbase = get_irq_chip_data(irq); |
1da177e4 LT |
175 | unsigned int r; |
176 | r = locomo_readl(mapbase + LOCOMO_ICR); | |
00dd8027 | 177 | r |= (0x0010 << (irq - IRQ_LOCOMO_KEY)); |
1da177e4 LT |
178 | locomo_writel(r, mapbase + LOCOMO_ICR); |
179 | } | |
180 | ||
38c677cb DB |
181 | static struct irq_chip locomo_chip = { |
182 | .name = "LOCOMO", | |
1da177e4 LT |
183 | .ack = locomo_ack_irq, |
184 | .mask = locomo_mask_irq, | |
185 | .unmask = locomo_unmask_irq, | |
186 | }; | |
187 | ||
1da177e4 LT |
188 | static void locomo_setup_irq(struct locomo *lchip) |
189 | { | |
190 | int irq; | |
54815366 | 191 | void __iomem *irqbase = lchip->base; |
1da177e4 LT |
192 | |
193 | /* | |
194 | * Install handler for IRQ_LOCOMO_HW. | |
195 | */ | |
6cab4860 | 196 | set_irq_type(lchip->irq, IRQ_TYPE_EDGE_FALLING); |
10dd5ce2 | 197 | set_irq_chip_data(lchip->irq, irqbase); |
1da177e4 LT |
198 | set_irq_chained_handler(lchip->irq, locomo_handler); |
199 | ||
00dd8027 EM |
200 | /* install handlers for IRQ_LOCOMO_* */ |
201 | for (irq = IRQ_LOCOMO_KEY; irq < IRQ_LOCOMO_KEY + 4; irq++) { | |
202 | set_irq_chip(irq, &locomo_chip); | |
10dd5ce2 RK |
203 | set_irq_chip_data(irq, irqbase); |
204 | set_irq_handler(irq, handle_edge_irq); | |
1da177e4 LT |
205 | set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); |
206 | } | |
207 | } | |
208 | ||
209 | ||
210 | static void locomo_dev_release(struct device *_dev) | |
211 | { | |
212 | struct locomo_dev *dev = LOCOMO_DEV(_dev); | |
213 | ||
214 | kfree(dev); | |
215 | } | |
216 | ||
217 | static int | |
218 | locomo_init_one_child(struct locomo *lchip, struct locomo_dev_info *info) | |
219 | { | |
220 | struct locomo_dev *dev; | |
221 | int ret; | |
222 | ||
d2a02b93 | 223 | dev = kzalloc(sizeof(struct locomo_dev), GFP_KERNEL); |
1da177e4 LT |
224 | if (!dev) { |
225 | ret = -ENOMEM; | |
226 | goto out; | |
227 | } | |
1da177e4 | 228 | |
1da177e4 LT |
229 | /* |
230 | * If the parent device has a DMA mask associated with it, | |
231 | * propagate it down to the children. | |
232 | */ | |
233 | if (lchip->dev->dma_mask) { | |
234 | dev->dma_mask = *lchip->dev->dma_mask; | |
235 | dev->dev.dma_mask = &dev->dma_mask; | |
236 | } | |
237 | ||
3f978704 | 238 | dev_set_name(&dev->dev, "%s", info->name); |
1da177e4 LT |
239 | dev->devid = info->devid; |
240 | dev->dev.parent = lchip->dev; | |
241 | dev->dev.bus = &locomo_bus_type; | |
242 | dev->dev.release = locomo_dev_release; | |
243 | dev->dev.coherent_dma_mask = lchip->dev->coherent_dma_mask; | |
244 | ||
245 | if (info->offset) | |
246 | dev->mapbase = lchip->base + info->offset; | |
247 | else | |
248 | dev->mapbase = 0; | |
249 | dev->length = info->length; | |
250 | ||
251 | memmove(dev->irq, info->irq, sizeof(dev->irq)); | |
252 | ||
253 | ret = device_register(&dev->dev); | |
254 | if (ret) { | |
255 | out: | |
256 | kfree(dev); | |
257 | } | |
258 | return ret; | |
259 | } | |
260 | ||
b38d950d JL |
261 | #ifdef CONFIG_PM |
262 | ||
263 | struct locomo_save_data { | |
264 | u16 LCM_GPO; | |
265 | u16 LCM_SPICT; | |
266 | u16 LCM_GPE; | |
267 | u16 LCM_ASD; | |
268 | u16 LCM_SPIMD; | |
269 | }; | |
270 | ||
3ae5eaec | 271 | static int locomo_suspend(struct platform_device *dev, pm_message_t state) |
b38d950d | 272 | { |
3ae5eaec | 273 | struct locomo *lchip = platform_get_drvdata(dev); |
b38d950d JL |
274 | struct locomo_save_data *save; |
275 | unsigned long flags; | |
276 | ||
b38d950d JL |
277 | save = kmalloc(sizeof(struct locomo_save_data), GFP_KERNEL); |
278 | if (!save) | |
279 | return -ENOMEM; | |
280 | ||
93160c63 | 281 | lchip->saved_state = save; |
b38d950d JL |
282 | |
283 | spin_lock_irqsave(&lchip->lock, flags); | |
284 | ||
285 | save->LCM_GPO = locomo_readl(lchip->base + LOCOMO_GPO); /* GPIO */ | |
286 | locomo_writel(0x00, lchip->base + LOCOMO_GPO); | |
2a52efb2 | 287 | save->LCM_SPICT = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPICT); /* SPI */ |
b38d950d JL |
288 | locomo_writel(0x40, lchip->base + LOCOMO_SPICT); |
289 | save->LCM_GPE = locomo_readl(lchip->base + LOCOMO_GPE); /* GPIO */ | |
290 | locomo_writel(0x00, lchip->base + LOCOMO_GPE); | |
291 | save->LCM_ASD = locomo_readl(lchip->base + LOCOMO_ASD); /* ADSTART */ | |
292 | locomo_writel(0x00, lchip->base + LOCOMO_ASD); | |
2a52efb2 TK |
293 | save->LCM_SPIMD = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPIMD); /* SPI */ |
294 | locomo_writel(0x3C14, lchip->base + LOCOMO_SPI + LOCOMO_SPIMD); | |
b38d950d JL |
295 | |
296 | locomo_writel(0x00, lchip->base + LOCOMO_PAIF); | |
297 | locomo_writel(0x00, lchip->base + LOCOMO_DAC); | |
298 | locomo_writel(0x00, lchip->base + LOCOMO_BACKLIGHT + LOCOMO_TC); | |
299 | ||
2a52efb2 | 300 | if ((locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT0) & 0x88) && (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT1) & 0x88)) |
b38d950d JL |
301 | locomo_writel(0x00, lchip->base + LOCOMO_C32K); /* CLK32 off */ |
302 | else | |
303 | /* 18MHz already enabled, so no wait */ | |
304 | locomo_writel(0xc1, lchip->base + LOCOMO_C32K); /* CLK32 on */ | |
305 | ||
306 | locomo_writel(0x00, lchip->base + LOCOMO_TADC); /* 18MHz clock off*/ | |
307 | locomo_writel(0x00, lchip->base + LOCOMO_AUDIO + LOCOMO_ACC); /* 22MHz/24MHz clock off */ | |
308 | locomo_writel(0x00, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS); /* FL */ | |
309 | ||
310 | spin_unlock_irqrestore(&lchip->lock, flags); | |
311 | ||
312 | return 0; | |
313 | } | |
314 | ||
3ae5eaec | 315 | static int locomo_resume(struct platform_device *dev) |
b38d950d | 316 | { |
3ae5eaec | 317 | struct locomo *lchip = platform_get_drvdata(dev); |
b38d950d JL |
318 | struct locomo_save_data *save; |
319 | unsigned long r; | |
320 | unsigned long flags; | |
93160c63 RW |
321 | |
322 | save = lchip->saved_state; | |
b38d950d JL |
323 | if (!save) |
324 | return 0; | |
325 | ||
326 | spin_lock_irqsave(&lchip->lock, flags); | |
327 | ||
328 | locomo_writel(save->LCM_GPO, lchip->base + LOCOMO_GPO); | |
2a52efb2 | 329 | locomo_writel(save->LCM_SPICT, lchip->base + LOCOMO_SPI + LOCOMO_SPICT); |
b38d950d JL |
330 | locomo_writel(save->LCM_GPE, lchip->base + LOCOMO_GPE); |
331 | locomo_writel(save->LCM_ASD, lchip->base + LOCOMO_ASD); | |
2a52efb2 | 332 | locomo_writel(save->LCM_SPIMD, lchip->base + LOCOMO_SPI + LOCOMO_SPIMD); |
b38d950d JL |
333 | |
334 | locomo_writel(0x00, lchip->base + LOCOMO_C32K); | |
335 | locomo_writel(0x90, lchip->base + LOCOMO_TADC); | |
336 | ||
337 | locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KSC); | |
338 | r = locomo_readl(lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC); | |
339 | r &= 0xFEFF; | |
340 | locomo_writel(r, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC); | |
341 | locomo_writel(0x1, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KCMD); | |
342 | ||
343 | spin_unlock_irqrestore(&lchip->lock, flags); | |
93160c63 RW |
344 | |
345 | lchip->saved_state = NULL; | |
b38d950d JL |
346 | kfree(save); |
347 | ||
348 | return 0; | |
349 | } | |
350 | #endif | |
351 | ||
4ebf2d00 | 352 | |
1da177e4 LT |
353 | /** |
354 | * locomo_probe - probe for a single LoCoMo chip. | |
355 | * @phys_addr: physical address of device. | |
356 | * | |
357 | * Probe for a LoCoMo chip. This must be called | |
358 | * before any other locomo-specific code. | |
359 | * | |
360 | * Returns: | |
361 | * %-ENODEV device not found. | |
362 | * %-EBUSY physical address already marked in-use. | |
363 | * %0 successful. | |
364 | */ | |
365 | static int | |
366 | __locomo_probe(struct device *me, struct resource *mem, int irq) | |
367 | { | |
368 | struct locomo *lchip; | |
369 | unsigned long r; | |
370 | int i, ret = -ENODEV; | |
371 | ||
d2a02b93 | 372 | lchip = kzalloc(sizeof(struct locomo), GFP_KERNEL); |
1da177e4 LT |
373 | if (!lchip) |
374 | return -ENOMEM; | |
375 | ||
1da177e4 LT |
376 | spin_lock_init(&lchip->lock); |
377 | ||
378 | lchip->dev = me; | |
379 | dev_set_drvdata(lchip->dev, lchip); | |
380 | ||
381 | lchip->phys = mem->start; | |
382 | lchip->irq = irq; | |
383 | ||
384 | /* | |
385 | * Map the whole region. This also maps the | |
386 | * registers for our children. | |
387 | */ | |
388 | lchip->base = ioremap(mem->start, PAGE_SIZE); | |
389 | if (!lchip->base) { | |
390 | ret = -ENOMEM; | |
391 | goto out; | |
392 | } | |
393 | ||
394 | /* locomo initialize */ | |
395 | locomo_writel(0, lchip->base + LOCOMO_ICR); | |
396 | /* KEYBOARD */ | |
397 | locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC); | |
398 | ||
399 | /* GPIO */ | |
400 | locomo_writel(0, lchip->base + LOCOMO_GPO); | |
2a52efb2 | 401 | locomo_writel((LOCOMO_GPIO(1) | LOCOMO_GPIO(2) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) |
1da177e4 | 402 | , lchip->base + LOCOMO_GPE); |
2a52efb2 | 403 | locomo_writel((LOCOMO_GPIO(1) | LOCOMO_GPIO(2) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) |
1da177e4 LT |
404 | , lchip->base + LOCOMO_GPD); |
405 | locomo_writel(0, lchip->base + LOCOMO_GIE); | |
406 | ||
e4423781 | 407 | /* Frontlight */ |
1da177e4 LT |
408 | locomo_writel(0, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS); |
409 | locomo_writel(0, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALD); | |
4ebf2d00 | 410 | |
1da177e4 LT |
411 | /* Longtime timer */ |
412 | locomo_writel(0, lchip->base + LOCOMO_LTINT); | |
413 | /* SPI */ | |
414 | locomo_writel(0, lchip->base + LOCOMO_SPIIE); | |
415 | ||
416 | locomo_writel(6 + 8 + 320 + 30 - 10, lchip->base + LOCOMO_ASD); | |
417 | r = locomo_readl(lchip->base + LOCOMO_ASD); | |
418 | r |= 0x8000; | |
419 | locomo_writel(r, lchip->base + LOCOMO_ASD); | |
420 | ||
421 | locomo_writel(6 + 8 + 320 + 30 - 10 - 128 + 4, lchip->base + LOCOMO_HSD); | |
422 | r = locomo_readl(lchip->base + LOCOMO_HSD); | |
423 | r |= 0x8000; | |
424 | locomo_writel(r, lchip->base + LOCOMO_HSD); | |
425 | ||
426 | locomo_writel(128 / 8, lchip->base + LOCOMO_HSC); | |
427 | ||
428 | /* XON */ | |
429 | locomo_writel(0x80, lchip->base + LOCOMO_TADC); | |
430 | udelay(1000); | |
431 | /* CLK9MEN */ | |
432 | r = locomo_readl(lchip->base + LOCOMO_TADC); | |
433 | r |= 0x10; | |
434 | locomo_writel(r, lchip->base + LOCOMO_TADC); | |
435 | udelay(100); | |
436 | ||
437 | /* init DAC */ | |
438 | r = locomo_readl(lchip->base + LOCOMO_DAC); | |
439 | r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB; | |
440 | locomo_writel(r, lchip->base + LOCOMO_DAC); | |
441 | ||
442 | r = locomo_readl(lchip->base + LOCOMO_VER); | |
443 | printk(KERN_INFO "LoCoMo Chip: %lu%lu\n", (r >> 8), (r & 0xff)); | |
444 | ||
445 | /* | |
446 | * The interrupt controller must be initialised before any | |
447 | * other device to ensure that the interrupts are available. | |
448 | */ | |
449 | if (lchip->irq != NO_IRQ) | |
450 | locomo_setup_irq(lchip); | |
451 | ||
452 | for (i = 0; i < ARRAY_SIZE(locomo_devices); i++) | |
453 | locomo_init_one_child(lchip, &locomo_devices[i]); | |
1da177e4 LT |
454 | return 0; |
455 | ||
456 | out: | |
457 | kfree(lchip); | |
458 | return ret; | |
459 | } | |
460 | ||
e24da5d3 | 461 | static int locomo_remove_child(struct device *dev, void *data) |
1da177e4 | 462 | { |
e24da5d3 PM |
463 | device_unregister(dev); |
464 | return 0; | |
465 | } | |
1da177e4 | 466 | |
e24da5d3 PM |
467 | static void __locomo_remove(struct locomo *lchip) |
468 | { | |
469 | device_for_each_child(lchip->dev, NULL, locomo_remove_child); | |
1da177e4 LT |
470 | |
471 | if (lchip->irq != NO_IRQ) { | |
472 | set_irq_chained_handler(lchip->irq, NULL); | |
473 | set_irq_data(lchip->irq, NULL); | |
474 | } | |
475 | ||
476 | iounmap(lchip->base); | |
477 | kfree(lchip); | |
478 | } | |
479 | ||
3ae5eaec | 480 | static int locomo_probe(struct platform_device *dev) |
1da177e4 | 481 | { |
1da177e4 LT |
482 | struct resource *mem; |
483 | int irq; | |
484 | ||
3ae5eaec | 485 | mem = platform_get_resource(dev, IORESOURCE_MEM, 0); |
1da177e4 LT |
486 | if (!mem) |
487 | return -EINVAL; | |
3ae5eaec | 488 | irq = platform_get_irq(dev, 0); |
48944738 DV |
489 | if (irq < 0) |
490 | return -ENXIO; | |
1da177e4 | 491 | |
3ae5eaec | 492 | return __locomo_probe(&dev->dev, mem, irq); |
1da177e4 LT |
493 | } |
494 | ||
3ae5eaec | 495 | static int locomo_remove(struct platform_device *dev) |
1da177e4 | 496 | { |
c35bf4a5 | 497 | struct locomo *lchip = platform_get_drvdata(dev); |
1da177e4 LT |
498 | |
499 | if (lchip) { | |
500 | __locomo_remove(lchip); | |
3ae5eaec | 501 | platform_set_drvdata(dev, NULL); |
1da177e4 LT |
502 | } |
503 | ||
504 | return 0; | |
505 | } | |
506 | ||
507 | /* | |
508 | * Not sure if this should be on the system bus or not yet. | |
509 | * We really want some way to register a system device at | |
510 | * the per-machine level, and then have this driver pick | |
511 | * up the registered devices. | |
512 | */ | |
3ae5eaec | 513 | static struct platform_driver locomo_device_driver = { |
1da177e4 LT |
514 | .probe = locomo_probe, |
515 | .remove = locomo_remove, | |
b38d950d JL |
516 | #ifdef CONFIG_PM |
517 | .suspend = locomo_suspend, | |
518 | .resume = locomo_resume, | |
519 | #endif | |
3ae5eaec RK |
520 | .driver = { |
521 | .name = "locomo", | |
522 | }, | |
1da177e4 LT |
523 | }; |
524 | ||
525 | /* | |
526 | * Get the parent device driver (us) structure | |
527 | * from a child function device | |
528 | */ | |
529 | static inline struct locomo *locomo_chip_driver(struct locomo_dev *ldev) | |
530 | { | |
531 | return (struct locomo *)dev_get_drvdata(ldev->dev.parent); | |
532 | } | |
533 | ||
8d48427e | 534 | void locomo_gpio_set_dir(struct device *dev, unsigned int bits, unsigned int dir) |
1da177e4 | 535 | { |
8d48427e | 536 | struct locomo *lchip = dev_get_drvdata(dev); |
1da177e4 LT |
537 | unsigned long flags; |
538 | unsigned int r; | |
539 | ||
8d48427e RP |
540 | if (!lchip) |
541 | return; | |
542 | ||
1da177e4 LT |
543 | spin_lock_irqsave(&lchip->lock, flags); |
544 | ||
545 | r = locomo_readl(lchip->base + LOCOMO_GPD); | |
2a52efb2 TK |
546 | if (dir) |
547 | r |= bits; | |
548 | else | |
549 | r &= ~bits; | |
1da177e4 LT |
550 | locomo_writel(r, lchip->base + LOCOMO_GPD); |
551 | ||
552 | r = locomo_readl(lchip->base + LOCOMO_GPE); | |
553 | if (dir) | |
554 | r |= bits; | |
555 | else | |
556 | r &= ~bits; | |
557 | locomo_writel(r, lchip->base + LOCOMO_GPE); | |
558 | ||
559 | spin_unlock_irqrestore(&lchip->lock, flags); | |
560 | } | |
9c5e8fec | 561 | EXPORT_SYMBOL(locomo_gpio_set_dir); |
1da177e4 | 562 | |
8d48427e | 563 | int locomo_gpio_read_level(struct device *dev, unsigned int bits) |
1da177e4 | 564 | { |
8d48427e | 565 | struct locomo *lchip = dev_get_drvdata(dev); |
1da177e4 LT |
566 | unsigned long flags; |
567 | unsigned int ret; | |
568 | ||
8d48427e RP |
569 | if (!lchip) |
570 | return -ENODEV; | |
571 | ||
1da177e4 LT |
572 | spin_lock_irqsave(&lchip->lock, flags); |
573 | ret = locomo_readl(lchip->base + LOCOMO_GPL); | |
574 | spin_unlock_irqrestore(&lchip->lock, flags); | |
575 | ||
576 | ret &= bits; | |
577 | return ret; | |
578 | } | |
9c5e8fec | 579 | EXPORT_SYMBOL(locomo_gpio_read_level); |
1da177e4 | 580 | |
8d48427e | 581 | int locomo_gpio_read_output(struct device *dev, unsigned int bits) |
1da177e4 | 582 | { |
8d48427e | 583 | struct locomo *lchip = dev_get_drvdata(dev); |
1da177e4 LT |
584 | unsigned long flags; |
585 | unsigned int ret; | |
586 | ||
8d48427e RP |
587 | if (!lchip) |
588 | return -ENODEV; | |
589 | ||
1da177e4 LT |
590 | spin_lock_irqsave(&lchip->lock, flags); |
591 | ret = locomo_readl(lchip->base + LOCOMO_GPO); | |
592 | spin_unlock_irqrestore(&lchip->lock, flags); | |
593 | ||
594 | ret &= bits; | |
595 | return ret; | |
596 | } | |
9c5e8fec | 597 | EXPORT_SYMBOL(locomo_gpio_read_output); |
1da177e4 | 598 | |
8d48427e | 599 | void locomo_gpio_write(struct device *dev, unsigned int bits, unsigned int set) |
1da177e4 | 600 | { |
8d48427e | 601 | struct locomo *lchip = dev_get_drvdata(dev); |
1da177e4 LT |
602 | unsigned long flags; |
603 | unsigned int r; | |
604 | ||
8d48427e RP |
605 | if (!lchip) |
606 | return; | |
607 | ||
1da177e4 LT |
608 | spin_lock_irqsave(&lchip->lock, flags); |
609 | ||
610 | r = locomo_readl(lchip->base + LOCOMO_GPO); | |
611 | if (set) | |
612 | r |= bits; | |
613 | else | |
614 | r &= ~bits; | |
615 | locomo_writel(r, lchip->base + LOCOMO_GPO); | |
616 | ||
617 | spin_unlock_irqrestore(&lchip->lock, flags); | |
618 | } | |
9c5e8fec | 619 | EXPORT_SYMBOL(locomo_gpio_write); |
1da177e4 LT |
620 | |
621 | static void locomo_m62332_sendbit(void *mapbase, int bit) | |
622 | { | |
623 | unsigned int r; | |
624 | ||
625 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
626 | r &= ~(LOCOMO_DAC_SCLOEB); | |
627 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
628 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
629 | udelay(DAC_DATA_HOLD_TIME); /* 300 nsec */ | |
630 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
631 | r &= ~(LOCOMO_DAC_SCLOEB); | |
632 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
633 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
634 | udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */ | |
635 | ||
636 | if (bit & 1) { | |
637 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
638 | r |= LOCOMO_DAC_SDAOEB; | |
639 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
640 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
641 | } else { | |
642 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
643 | r &= ~(LOCOMO_DAC_SDAOEB); | |
644 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
645 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
646 | } | |
647 | ||
648 | udelay(DAC_DATA_SETUP_TIME); /* 250 nsec */ | |
649 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
650 | r |= LOCOMO_DAC_SCLOEB; | |
651 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
652 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
653 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.0 usec */ | |
654 | } | |
655 | ||
656 | void locomo_m62332_senddata(struct locomo_dev *ldev, unsigned int dac_data, int channel) | |
657 | { | |
658 | struct locomo *lchip = locomo_chip_driver(ldev); | |
659 | int i; | |
660 | unsigned char data; | |
661 | unsigned int r; | |
662 | void *mapbase = lchip->base; | |
663 | unsigned long flags; | |
664 | ||
665 | spin_lock_irqsave(&lchip->lock, flags); | |
666 | ||
667 | /* Start */ | |
668 | udelay(DAC_BUS_FREE_TIME); /* 5.0 usec */ | |
669 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
670 | r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB; | |
671 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
672 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
673 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.0 usec */ | |
674 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
675 | r &= ~(LOCOMO_DAC_SDAOEB); | |
676 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
677 | udelay(DAC_START_HOLD_TIME); /* 5.0 usec */ | |
678 | udelay(DAC_DATA_HOLD_TIME); /* 300 nsec */ | |
679 | ||
680 | /* Send slave address and W bit (LSB is W bit) */ | |
681 | data = (M62332_SLAVE_ADDR << 1) | M62332_W_BIT; | |
682 | for (i = 1; i <= 8; i++) { | |
683 | locomo_m62332_sendbit(mapbase, data >> (8 - i)); | |
684 | } | |
685 | ||
686 | /* Check A bit */ | |
687 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
688 | r &= ~(LOCOMO_DAC_SCLOEB); | |
689 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
690 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
691 | udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */ | |
692 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
693 | r &= ~(LOCOMO_DAC_SDAOEB); | |
694 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
695 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
696 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
697 | r |= LOCOMO_DAC_SCLOEB; | |
698 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
699 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
700 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */ | |
701 | if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */ | |
702 | printk(KERN_WARNING "locomo: m62332_senddata Error 1\n"); | |
703 | return; | |
704 | } | |
705 | ||
706 | /* Send Sub address (LSB is channel select) */ | |
707 | /* channel = 0 : ch1 select */ | |
708 | /* = 1 : ch2 select */ | |
709 | data = M62332_SUB_ADDR + channel; | |
710 | for (i = 1; i <= 8; i++) { | |
711 | locomo_m62332_sendbit(mapbase, data >> (8 - i)); | |
712 | } | |
713 | ||
714 | /* Check A bit */ | |
715 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
716 | r &= ~(LOCOMO_DAC_SCLOEB); | |
717 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
718 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
719 | udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */ | |
720 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
721 | r &= ~(LOCOMO_DAC_SDAOEB); | |
722 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
723 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
724 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
725 | r |= LOCOMO_DAC_SCLOEB; | |
726 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
727 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
728 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */ | |
729 | if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */ | |
730 | printk(KERN_WARNING "locomo: m62332_senddata Error 2\n"); | |
731 | return; | |
732 | } | |
733 | ||
734 | /* Send DAC data */ | |
735 | for (i = 1; i <= 8; i++) { | |
736 | locomo_m62332_sendbit(mapbase, dac_data >> (8 - i)); | |
737 | } | |
738 | ||
739 | /* Check A bit */ | |
740 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
741 | r &= ~(LOCOMO_DAC_SCLOEB); | |
742 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
743 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
744 | udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */ | |
745 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
746 | r &= ~(LOCOMO_DAC_SDAOEB); | |
747 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
748 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
749 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
750 | r |= LOCOMO_DAC_SCLOEB; | |
751 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
752 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
753 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4.7 usec */ | |
754 | if (locomo_readl(mapbase + LOCOMO_DAC) & LOCOMO_DAC_SDAOEB) { /* High is error */ | |
755 | printk(KERN_WARNING "locomo: m62332_senddata Error 3\n"); | |
756 | return; | |
757 | } | |
758 | ||
759 | /* stop */ | |
760 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
761 | r &= ~(LOCOMO_DAC_SCLOEB); | |
762 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
763 | udelay(DAC_LOW_SETUP_TIME); /* 300 nsec */ | |
764 | udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */ | |
765 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
766 | r |= LOCOMO_DAC_SCLOEB; | |
767 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
768 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
769 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4 usec */ | |
770 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
771 | r |= LOCOMO_DAC_SDAOEB; | |
772 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
773 | udelay(DAC_HIGH_SETUP_TIME); /* 1000 nsec */ | |
774 | udelay(DAC_SCL_HIGH_HOLD_TIME); /* 4 usec */ | |
775 | ||
776 | r = locomo_readl(mapbase + LOCOMO_DAC); | |
777 | r |= LOCOMO_DAC_SCLOEB | LOCOMO_DAC_SDAOEB; | |
778 | locomo_writel(r, mapbase + LOCOMO_DAC); | |
779 | udelay(DAC_LOW_SETUP_TIME); /* 1000 nsec */ | |
780 | udelay(DAC_SCL_LOW_HOLD_TIME); /* 4.7 usec */ | |
781 | ||
782 | spin_unlock_irqrestore(&lchip->lock, flags); | |
783 | } | |
9c5e8fec | 784 | EXPORT_SYMBOL(locomo_m62332_senddata); |
1da177e4 | 785 | |
e4423781 RP |
786 | /* |
787 | * Frontlight control | |
788 | */ | |
789 | ||
e4423781 RP |
790 | void locomo_frontlight_set(struct locomo_dev *dev, int duty, int vr, int bpwf) |
791 | { | |
792 | unsigned long flags; | |
793 | struct locomo *lchip = locomo_chip_driver(dev); | |
794 | ||
795 | if (vr) | |
8d48427e | 796 | locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 1); |
e4423781 | 797 | else |
8d48427e | 798 | locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 0); |
e4423781 RP |
799 | |
800 | spin_lock_irqsave(&lchip->lock, flags); | |
801 | locomo_writel(bpwf, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS); | |
802 | udelay(100); | |
803 | locomo_writel(duty, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALD); | |
804 | locomo_writel(bpwf | LOCOMO_ALC_EN, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS); | |
805 | spin_unlock_irqrestore(&lchip->lock, flags); | |
806 | } | |
9179825c | 807 | EXPORT_SYMBOL(locomo_frontlight_set); |
e4423781 | 808 | |
1da177e4 LT |
809 | /* |
810 | * LoCoMo "Register Access Bus." | |
811 | * | |
812 | * We model this as a regular bus type, and hang devices directly | |
813 | * off this. | |
814 | */ | |
815 | static int locomo_match(struct device *_dev, struct device_driver *_drv) | |
816 | { | |
817 | struct locomo_dev *dev = LOCOMO_DEV(_dev); | |
818 | struct locomo_driver *drv = LOCOMO_DRV(_drv); | |
819 | ||
820 | return dev->devid == drv->devid; | |
821 | } | |
822 | ||
823 | static int locomo_bus_suspend(struct device *dev, pm_message_t state) | |
824 | { | |
825 | struct locomo_dev *ldev = LOCOMO_DEV(dev); | |
826 | struct locomo_driver *drv = LOCOMO_DRV(dev->driver); | |
827 | int ret = 0; | |
828 | ||
829 | if (drv && drv->suspend) | |
830 | ret = drv->suspend(ldev, state); | |
831 | return ret; | |
832 | } | |
833 | ||
834 | static int locomo_bus_resume(struct device *dev) | |
835 | { | |
836 | struct locomo_dev *ldev = LOCOMO_DEV(dev); | |
837 | struct locomo_driver *drv = LOCOMO_DRV(dev->driver); | |
838 | int ret = 0; | |
839 | ||
840 | if (drv && drv->resume) | |
841 | ret = drv->resume(ldev); | |
842 | return ret; | |
843 | } | |
844 | ||
845 | static int locomo_bus_probe(struct device *dev) | |
846 | { | |
847 | struct locomo_dev *ldev = LOCOMO_DEV(dev); | |
848 | struct locomo_driver *drv = LOCOMO_DRV(dev->driver); | |
849 | int ret = -ENODEV; | |
850 | ||
851 | if (drv->probe) | |
852 | ret = drv->probe(ldev); | |
853 | return ret; | |
854 | } | |
855 | ||
856 | static int locomo_bus_remove(struct device *dev) | |
857 | { | |
858 | struct locomo_dev *ldev = LOCOMO_DEV(dev); | |
859 | struct locomo_driver *drv = LOCOMO_DRV(dev->driver); | |
860 | int ret = 0; | |
861 | ||
862 | if (drv->remove) | |
863 | ret = drv->remove(ldev); | |
864 | return ret; | |
865 | } | |
866 | ||
867 | struct bus_type locomo_bus_type = { | |
868 | .name = "locomo-bus", | |
869 | .match = locomo_match, | |
306955be RK |
870 | .probe = locomo_bus_probe, |
871 | .remove = locomo_bus_remove, | |
1da177e4 LT |
872 | .suspend = locomo_bus_suspend, |
873 | .resume = locomo_bus_resume, | |
874 | }; | |
875 | ||
876 | int locomo_driver_register(struct locomo_driver *driver) | |
877 | { | |
1da177e4 LT |
878 | driver->drv.bus = &locomo_bus_type; |
879 | return driver_register(&driver->drv); | |
880 | } | |
9c5e8fec | 881 | EXPORT_SYMBOL(locomo_driver_register); |
1da177e4 LT |
882 | |
883 | void locomo_driver_unregister(struct locomo_driver *driver) | |
884 | { | |
885 | driver_unregister(&driver->drv); | |
886 | } | |
9c5e8fec | 887 | EXPORT_SYMBOL(locomo_driver_unregister); |
1da177e4 LT |
888 | |
889 | static int __init locomo_init(void) | |
890 | { | |
891 | int ret = bus_register(&locomo_bus_type); | |
892 | if (ret == 0) | |
3ae5eaec | 893 | platform_driver_register(&locomo_device_driver); |
1da177e4 LT |
894 | return ret; |
895 | } | |
896 | ||
897 | static void __exit locomo_exit(void) | |
898 | { | |
3ae5eaec | 899 | platform_driver_unregister(&locomo_device_driver); |
1da177e4 LT |
900 | bus_unregister(&locomo_bus_type); |
901 | } | |
902 | ||
903 | module_init(locomo_init); | |
904 | module_exit(locomo_exit); | |
905 | ||
906 | MODULE_DESCRIPTION("Sharp LoCoMo core driver"); | |
907 | MODULE_LICENSE("GPL"); | |
908 | MODULE_AUTHOR("John Lenz <lenz@cs.wisc.edu>"); |