Commit | Line | Data |
---|---|---|
f045f77b JC |
1 | /* |
2 | * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved. | |
3 | * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved. | |
4 | * Copyright 2009 Jonathan Corbet <corbet@lwn.net> | |
5 | */ | |
6 | ||
7 | /* | |
8 | * Core code for the Via multifunction framebuffer device. | |
9 | */ | |
ec66841e JC |
10 | #include <linux/via-core.h> |
11 | #include <linux/via_i2c.h> | |
12 | #include <linux/via-gpio.h> | |
24b4d82e JC |
13 | #include "global.h" |
14 | ||
f045f77b | 15 | #include <linux/module.h> |
3d28eb42 | 16 | #include <linux/interrupt.h> |
f045f77b | 17 | #include <linux/platform_device.h> |
751305d9 DD |
18 | #include <linux/list.h> |
19 | #include <linux/pm.h> | |
b884a94e | 20 | #include <asm/olpc.h> |
f045f77b JC |
21 | |
22 | /* | |
23 | * The default port config. | |
24 | */ | |
25 | static struct via_port_cfg adap_configs[] = { | |
ee40b7d1 | 26 | [VIA_PORT_26] = { VIA_PORT_I2C, VIA_MODE_I2C, VIASR, 0x26 }, |
f045f77b JC |
27 | [VIA_PORT_31] = { VIA_PORT_I2C, VIA_MODE_I2C, VIASR, 0x31 }, |
28 | [VIA_PORT_25] = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x25 }, | |
29 | [VIA_PORT_2C] = { VIA_PORT_GPIO, VIA_MODE_I2C, VIASR, 0x2c }, | |
30 | [VIA_PORT_3D] = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x3d }, | |
31 | { 0, 0, 0, 0 } | |
32 | }; | |
33 | ||
b884a94e DD |
34 | /* |
35 | * The OLPC XO-1.5 puts the camera power and reset lines onto | |
36 | * GPIO 2C. | |
37 | */ | |
38 | static const struct via_port_cfg olpc_adap_configs[] = { | |
39 | [VIA_PORT_26] = { VIA_PORT_I2C, VIA_MODE_I2C, VIASR, 0x26 }, | |
40 | [VIA_PORT_31] = { VIA_PORT_I2C, VIA_MODE_I2C, VIASR, 0x31 }, | |
41 | [VIA_PORT_25] = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x25 }, | |
42 | [VIA_PORT_2C] = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x2c }, | |
43 | [VIA_PORT_3D] = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x3d }, | |
44 | { 0, 0, 0, 0 } | |
45 | }; | |
46 | ||
24b4d82e JC |
47 | /* |
48 | * We currently only support one viafb device (will there ever be | |
49 | * more than one?), so just declare it globally here. | |
50 | */ | |
51 | static struct viafb_dev global_dev; | |
52 | ||
53 | ||
94dd1a85 JC |
54 | /* |
55 | * Basic register access; spinlock required. | |
56 | */ | |
57 | static inline void viafb_mmio_write(int reg, u32 v) | |
58 | { | |
59 | iowrite32(v, global_dev.engine_mmio + reg); | |
60 | } | |
61 | ||
62 | static inline int viafb_mmio_read(int reg) | |
63 | { | |
64 | return ioread32(global_dev.engine_mmio + reg); | |
65 | } | |
66 | ||
67 | /* ---------------------------------------------------------------------- */ | |
68 | /* | |
69 | * Interrupt management. We have a single IRQ line for a lot of | |
70 | * different functions, so we need to share it. The design here | |
71 | * is that we don't want to reimplement the shared IRQ code here; | |
72 | * we also want to avoid having contention for a single handler thread. | |
73 | * So each subdev driver which needs interrupts just requests | |
74 | * them directly from the kernel. We just have what's needed for | |
75 | * overall access to the interrupt control register. | |
76 | */ | |
77 | ||
78 | /* | |
79 | * Which interrupts are enabled now? | |
80 | */ | |
81 | static u32 viafb_enabled_ints; | |
82 | ||
eca9c47b | 83 | static void __devinit viafb_int_init(void) |
94dd1a85 JC |
84 | { |
85 | viafb_enabled_ints = 0; | |
86 | ||
87 | viafb_mmio_write(VDE_INTERRUPT, 0); | |
88 | } | |
89 | ||
90 | /* | |
91 | * Allow subdevs to ask for specific interrupts to be enabled. These | |
92 | * functions must be called with reg_lock held | |
93 | */ | |
94 | void viafb_irq_enable(u32 mask) | |
95 | { | |
96 | viafb_enabled_ints |= mask; | |
97 | viafb_mmio_write(VDE_INTERRUPT, viafb_enabled_ints | VDE_I_ENABLE); | |
98 | } | |
99 | EXPORT_SYMBOL_GPL(viafb_irq_enable); | |
100 | ||
101 | void viafb_irq_disable(u32 mask) | |
102 | { | |
103 | viafb_enabled_ints &= ~mask; | |
104 | if (viafb_enabled_ints == 0) | |
105 | viafb_mmio_write(VDE_INTERRUPT, 0); /* Disable entirely */ | |
106 | else | |
107 | viafb_mmio_write(VDE_INTERRUPT, | |
108 | viafb_enabled_ints | VDE_I_ENABLE); | |
109 | } | |
110 | EXPORT_SYMBOL_GPL(viafb_irq_disable); | |
111 | ||
3d28eb42 | 112 | /* ---------------------------------------------------------------------- */ |
024fafba JC |
113 | /* |
114 | * Currently, the camera driver is the only user of the DMA code, so we | |
115 | * only compile it in if the camera driver is being built. Chances are, | |
116 | * most viafb systems will not need to have this extra code for a while. | |
117 | * As soon as another user comes long, the ifdef can be removed. | |
118 | */ | |
119 | #if defined(CONFIG_VIDEO_VIA_CAMERA) || defined(CONFIG_VIDEO_VIA_CAMERA_MODULE) | |
3d28eb42 JC |
120 | /* |
121 | * Access to the DMA engine. This currently provides what the camera | |
122 | * driver needs (i.e. outgoing only) but is easily expandable if need | |
123 | * be. | |
124 | */ | |
125 | ||
126 | /* | |
127 | * There are four DMA channels in the vx855. For now, we only | |
128 | * use one of them, though. Most of the time, the DMA channel | |
129 | * will be idle, so we keep the IRQ handler unregistered except | |
130 | * when some subsystem has indicated an interest. | |
131 | */ | |
132 | static int viafb_dma_users; | |
133 | static DECLARE_COMPLETION(viafb_dma_completion); | |
134 | /* | |
135 | * This mutex protects viafb_dma_users and our global interrupt | |
136 | * registration state; it also serializes access to the DMA | |
137 | * engine. | |
138 | */ | |
139 | static DEFINE_MUTEX(viafb_dma_lock); | |
140 | ||
141 | /* | |
142 | * The VX855 DMA descriptor (used for s/g transfers) looks | |
143 | * like this. | |
144 | */ | |
145 | struct viafb_vx855_dma_descr { | |
146 | u32 addr_low; /* Low part of phys addr */ | |
147 | u32 addr_high; /* High 12 bits of addr */ | |
148 | u32 fb_offset; /* Offset into FB memory */ | |
149 | u32 seg_size; /* Size, 16-byte units */ | |
150 | u32 tile_mode; /* "tile mode" setting */ | |
151 | u32 next_desc_low; /* Next descriptor addr */ | |
152 | u32 next_desc_high; | |
153 | u32 pad; /* Fill out to 64 bytes */ | |
154 | }; | |
94dd1a85 | 155 | |
3d28eb42 JC |
156 | /* |
157 | * Flags added to the "next descriptor low" pointers | |
158 | */ | |
159 | #define VIAFB_DMA_MAGIC 0x01 /* ??? Just has to be there */ | |
160 | #define VIAFB_DMA_FINAL_SEGMENT 0x02 /* Final segment */ | |
161 | ||
162 | /* | |
163 | * The completion IRQ handler. | |
164 | */ | |
165 | static irqreturn_t viafb_dma_irq(int irq, void *data) | |
166 | { | |
167 | int csr; | |
168 | irqreturn_t ret = IRQ_NONE; | |
169 | ||
170 | spin_lock(&global_dev.reg_lock); | |
171 | csr = viafb_mmio_read(VDMA_CSR0); | |
172 | if (csr & VDMA_C_DONE) { | |
173 | viafb_mmio_write(VDMA_CSR0, VDMA_C_DONE); | |
174 | complete(&viafb_dma_completion); | |
175 | ret = IRQ_HANDLED; | |
176 | } | |
177 | spin_unlock(&global_dev.reg_lock); | |
178 | return ret; | |
179 | } | |
180 | ||
181 | /* | |
182 | * Indicate a need for DMA functionality. | |
183 | */ | |
184 | int viafb_request_dma(void) | |
185 | { | |
186 | int ret = 0; | |
187 | ||
188 | /* | |
189 | * Only VX855 is supported currently. | |
190 | */ | |
191 | if (global_dev.chip_type != UNICHROME_VX855) | |
192 | return -ENODEV; | |
193 | /* | |
194 | * Note the new user and set up our interrupt handler | |
195 | * if need be. | |
196 | */ | |
197 | mutex_lock(&viafb_dma_lock); | |
198 | viafb_dma_users++; | |
199 | if (viafb_dma_users == 1) { | |
200 | ret = request_irq(global_dev.pdev->irq, viafb_dma_irq, | |
201 | IRQF_SHARED, "via-dma", &viafb_dma_users); | |
202 | if (ret) | |
203 | viafb_dma_users--; | |
204 | else | |
205 | viafb_irq_enable(VDE_I_DMA0TDEN); | |
206 | } | |
207 | mutex_unlock(&viafb_dma_lock); | |
208 | return ret; | |
209 | } | |
210 | EXPORT_SYMBOL_GPL(viafb_request_dma); | |
211 | ||
212 | void viafb_release_dma(void) | |
213 | { | |
214 | mutex_lock(&viafb_dma_lock); | |
215 | viafb_dma_users--; | |
216 | if (viafb_dma_users == 0) { | |
217 | viafb_irq_disable(VDE_I_DMA0TDEN); | |
218 | free_irq(global_dev.pdev->irq, &viafb_dma_users); | |
219 | } | |
220 | mutex_unlock(&viafb_dma_lock); | |
221 | } | |
222 | EXPORT_SYMBOL_GPL(viafb_release_dma); | |
223 | ||
224 | ||
225 | #if 0 | |
226 | /* | |
227 | * Copy a single buffer from FB memory, synchronously. This code works | |
228 | * but is not currently used. | |
229 | */ | |
230 | void viafb_dma_copy_out(unsigned int offset, dma_addr_t paddr, int len) | |
231 | { | |
232 | unsigned long flags; | |
233 | int csr; | |
234 | ||
235 | mutex_lock(&viafb_dma_lock); | |
236 | init_completion(&viafb_dma_completion); | |
237 | /* | |
238 | * Program the controller. | |
239 | */ | |
240 | spin_lock_irqsave(&global_dev.reg_lock, flags); | |
241 | viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_DONE); | |
242 | /* Enable ints; must happen after CSR0 write! */ | |
243 | viafb_mmio_write(VDMA_MR0, VDMA_MR_TDIE); | |
244 | viafb_mmio_write(VDMA_MARL0, (int) (paddr & 0xfffffff0)); | |
245 | viafb_mmio_write(VDMA_MARH0, (int) ((paddr >> 28) & 0xfff)); | |
246 | /* Data sheet suggests DAR0 should be <<4, but it lies */ | |
247 | viafb_mmio_write(VDMA_DAR0, offset); | |
248 | viafb_mmio_write(VDMA_DQWCR0, len >> 4); | |
249 | viafb_mmio_write(VDMA_TMR0, 0); | |
250 | viafb_mmio_write(VDMA_DPRL0, 0); | |
251 | viafb_mmio_write(VDMA_DPRH0, 0); | |
252 | viafb_mmio_write(VDMA_PMR0, 0); | |
253 | csr = viafb_mmio_read(VDMA_CSR0); | |
254 | viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_START); | |
255 | spin_unlock_irqrestore(&global_dev.reg_lock, flags); | |
256 | /* | |
257 | * Now we just wait until the interrupt handler says | |
258 | * we're done. | |
259 | */ | |
260 | wait_for_completion_interruptible(&viafb_dma_completion); | |
261 | viafb_mmio_write(VDMA_MR0, 0); /* Reset int enable */ | |
262 | mutex_unlock(&viafb_dma_lock); | |
263 | } | |
264 | EXPORT_SYMBOL_GPL(viafb_dma_copy_out); | |
265 | #endif | |
266 | ||
267 | /* | |
268 | * Do a scatter/gather DMA copy from FB memory. You must have done | |
269 | * a successful call to viafb_request_dma() first. | |
270 | */ | |
271 | int viafb_dma_copy_out_sg(unsigned int offset, struct scatterlist *sg, int nsg) | |
272 | { | |
273 | struct viafb_vx855_dma_descr *descr; | |
274 | void *descrpages; | |
275 | dma_addr_t descr_handle; | |
276 | unsigned long flags; | |
277 | int i; | |
278 | struct scatterlist *sgentry; | |
279 | dma_addr_t nextdesc; | |
280 | ||
281 | /* | |
282 | * Get a place to put the descriptors. | |
283 | */ | |
284 | descrpages = dma_alloc_coherent(&global_dev.pdev->dev, | |
285 | nsg*sizeof(struct viafb_vx855_dma_descr), | |
286 | &descr_handle, GFP_KERNEL); | |
287 | if (descrpages == NULL) { | |
288 | dev_err(&global_dev.pdev->dev, "Unable to get descr page.\n"); | |
289 | return -ENOMEM; | |
290 | } | |
291 | mutex_lock(&viafb_dma_lock); | |
292 | /* | |
293 | * Fill them in. | |
294 | */ | |
295 | descr = descrpages; | |
296 | nextdesc = descr_handle + sizeof(struct viafb_vx855_dma_descr); | |
297 | for_each_sg(sg, sgentry, nsg, i) { | |
298 | dma_addr_t paddr = sg_dma_address(sgentry); | |
299 | descr->addr_low = paddr & 0xfffffff0; | |
300 | descr->addr_high = ((u64) paddr >> 32) & 0x0fff; | |
301 | descr->fb_offset = offset; | |
302 | descr->seg_size = sg_dma_len(sgentry) >> 4; | |
303 | descr->tile_mode = 0; | |
304 | descr->next_desc_low = (nextdesc&0xfffffff0) | VIAFB_DMA_MAGIC; | |
305 | descr->next_desc_high = ((u64) nextdesc >> 32) & 0x0fff; | |
306 | descr->pad = 0xffffffff; /* VIA driver does this */ | |
307 | offset += sg_dma_len(sgentry); | |
308 | nextdesc += sizeof(struct viafb_vx855_dma_descr); | |
309 | descr++; | |
310 | } | |
311 | descr[-1].next_desc_low = VIAFB_DMA_FINAL_SEGMENT|VIAFB_DMA_MAGIC; | |
312 | /* | |
313 | * Program the engine. | |
314 | */ | |
315 | spin_lock_irqsave(&global_dev.reg_lock, flags); | |
316 | init_completion(&viafb_dma_completion); | |
317 | viafb_mmio_write(VDMA_DQWCR0, 0); | |
318 | viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_DONE); | |
319 | viafb_mmio_write(VDMA_MR0, VDMA_MR_TDIE | VDMA_MR_CHAIN); | |
320 | viafb_mmio_write(VDMA_DPRL0, descr_handle | VIAFB_DMA_MAGIC); | |
321 | viafb_mmio_write(VDMA_DPRH0, | |
322 | (((u64)descr_handle >> 32) & 0x0fff) | 0xf0000); | |
323 | (void) viafb_mmio_read(VDMA_CSR0); | |
324 | viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_START); | |
325 | spin_unlock_irqrestore(&global_dev.reg_lock, flags); | |
326 | /* | |
327 | * Now we just wait until the interrupt handler says | |
328 | * we're done. Except that, actually, we need to wait a little | |
329 | * longer: the interrupts seem to jump the gun a little and we | |
330 | * get corrupted frames sometimes. | |
331 | */ | |
332 | wait_for_completion_timeout(&viafb_dma_completion, 1); | |
333 | msleep(1); | |
334 | if ((viafb_mmio_read(VDMA_CSR0)&VDMA_C_DONE) == 0) | |
335 | printk(KERN_ERR "VIA DMA timeout!\n"); | |
336 | /* | |
337 | * Clean up and we're done. | |
338 | */ | |
339 | viafb_mmio_write(VDMA_CSR0, VDMA_C_DONE); | |
340 | viafb_mmio_write(VDMA_MR0, 0); /* Reset int enable */ | |
341 | mutex_unlock(&viafb_dma_lock); | |
342 | dma_free_coherent(&global_dev.pdev->dev, | |
343 | nsg*sizeof(struct viafb_vx855_dma_descr), descrpages, | |
344 | descr_handle); | |
345 | return 0; | |
346 | } | |
347 | EXPORT_SYMBOL_GPL(viafb_dma_copy_out_sg); | |
024fafba | 348 | #endif /* CONFIG_VIDEO_VIA_CAMERA */ |
3d28eb42 JC |
349 | |
350 | /* ---------------------------------------------------------------------- */ | |
24b4d82e JC |
351 | /* |
352 | * Figure out how big our framebuffer memory is. Kind of ugly, | |
353 | * but evidently we can't trust the information found in the | |
354 | * fbdev configuration area. | |
355 | */ | |
356 | static u16 via_function3[] = { | |
357 | CLE266_FUNCTION3, KM400_FUNCTION3, CN400_FUNCTION3, CN700_FUNCTION3, | |
358 | CX700_FUNCTION3, KM800_FUNCTION3, KM890_FUNCTION3, P4M890_FUNCTION3, | |
51f4332b | 359 | P4M900_FUNCTION3, VX800_FUNCTION3, VX855_FUNCTION3, VX900_FUNCTION3, |
24b4d82e JC |
360 | }; |
361 | ||
362 | /* Get the BIOS-configured framebuffer size from PCI configuration space | |
363 | * of function 3 in the respective chipset */ | |
364 | static int viafb_get_fb_size_from_pci(int chip_type) | |
365 | { | |
366 | int i; | |
367 | u8 offset = 0; | |
368 | u32 FBSize; | |
369 | u32 VideoMemSize; | |
370 | ||
371 | /* search for the "FUNCTION3" device in this chipset */ | |
372 | for (i = 0; i < ARRAY_SIZE(via_function3); i++) { | |
373 | struct pci_dev *pdev; | |
374 | ||
375 | pdev = pci_get_device(PCI_VENDOR_ID_VIA, via_function3[i], | |
376 | NULL); | |
377 | if (!pdev) | |
378 | continue; | |
379 | ||
380 | DEBUG_MSG(KERN_INFO "Device ID = %x\n", pdev->device); | |
381 | ||
382 | switch (pdev->device) { | |
383 | case CLE266_FUNCTION3: | |
384 | case KM400_FUNCTION3: | |
385 | offset = 0xE0; | |
386 | break; | |
387 | case CN400_FUNCTION3: | |
388 | case CN700_FUNCTION3: | |
389 | case CX700_FUNCTION3: | |
390 | case KM800_FUNCTION3: | |
391 | case KM890_FUNCTION3: | |
392 | case P4M890_FUNCTION3: | |
393 | case P4M900_FUNCTION3: | |
394 | case VX800_FUNCTION3: | |
395 | case VX855_FUNCTION3: | |
51f4332b | 396 | case VX900_FUNCTION3: |
24b4d82e JC |
397 | /*case CN750_FUNCTION3: */ |
398 | offset = 0xA0; | |
399 | break; | |
400 | } | |
401 | ||
402 | if (!offset) | |
403 | break; | |
404 | ||
405 | pci_read_config_dword(pdev, offset, &FBSize); | |
406 | pci_dev_put(pdev); | |
407 | } | |
408 | ||
409 | if (!offset) { | |
410 | printk(KERN_ERR "cannot determine framebuffer size\n"); | |
411 | return -EIO; | |
412 | } | |
413 | ||
414 | FBSize = FBSize & 0x00007000; | |
415 | DEBUG_MSG(KERN_INFO "FB Size = %x\n", FBSize); | |
416 | ||
417 | if (chip_type < UNICHROME_CX700) { | |
418 | switch (FBSize) { | |
419 | case 0x00004000: | |
420 | VideoMemSize = (16 << 20); /*16M */ | |
421 | break; | |
422 | ||
423 | case 0x00005000: | |
424 | VideoMemSize = (32 << 20); /*32M */ | |
425 | break; | |
426 | ||
427 | case 0x00006000: | |
428 | VideoMemSize = (64 << 20); /*64M */ | |
429 | break; | |
430 | ||
431 | default: | |
432 | VideoMemSize = (32 << 20); /*32M */ | |
433 | break; | |
434 | } | |
435 | } else { | |
436 | switch (FBSize) { | |
437 | case 0x00001000: | |
438 | VideoMemSize = (8 << 20); /*8M */ | |
439 | break; | |
440 | ||
441 | case 0x00002000: | |
442 | VideoMemSize = (16 << 20); /*16M */ | |
443 | break; | |
444 | ||
445 | case 0x00003000: | |
446 | VideoMemSize = (32 << 20); /*32M */ | |
447 | break; | |
448 | ||
449 | case 0x00004000: | |
450 | VideoMemSize = (64 << 20); /*64M */ | |
451 | break; | |
452 | ||
453 | case 0x00005000: | |
454 | VideoMemSize = (128 << 20); /*128M */ | |
455 | break; | |
456 | ||
457 | case 0x00006000: | |
458 | VideoMemSize = (256 << 20); /*256M */ | |
459 | break; | |
460 | ||
461 | case 0x00007000: /* Only on VX855/875 */ | |
462 | VideoMemSize = (512 << 20); /*512M */ | |
463 | break; | |
464 | ||
465 | default: | |
466 | VideoMemSize = (32 << 20); /*32M */ | |
467 | break; | |
468 | } | |
469 | } | |
470 | ||
471 | return VideoMemSize; | |
472 | } | |
473 | ||
474 | ||
475 | /* | |
476 | * Figure out and map our MMIO regions. | |
477 | */ | |
478 | static int __devinit via_pci_setup_mmio(struct viafb_dev *vdev) | |
479 | { | |
8bbf50fe | 480 | int ret; |
24b4d82e | 481 | /* |
8bbf50fe JC |
482 | * Hook up to the device registers. Note that we soldier |
483 | * on if it fails; the framebuffer can operate (without | |
484 | * acceleration) without this region. | |
24b4d82e JC |
485 | */ |
486 | vdev->engine_start = pci_resource_start(vdev->pdev, 1); | |
487 | vdev->engine_len = pci_resource_len(vdev->pdev, 1); | |
24b4d82e JC |
488 | vdev->engine_mmio = ioremap_nocache(vdev->engine_start, |
489 | vdev->engine_len); | |
8bbf50fe JC |
490 | if (vdev->engine_mmio == NULL) |
491 | dev_err(&vdev->pdev->dev, | |
492 | "Unable to map engine MMIO; operation will be " | |
493 | "slow and crippled.\n"); | |
24b4d82e | 494 | /* |
8bbf50fe JC |
495 | * Map in framebuffer memory. For now, failure here is |
496 | * fatal. Unfortunately, in the absence of significant | |
497 | * vmalloc space, failure here is also entirely plausible. | |
498 | * Eventually we want to move away from mapping this | |
499 | * entire region. | |
24b4d82e | 500 | */ |
51f4332b FTS |
501 | if (vdev->chip_type == UNICHROME_VX900) |
502 | vdev->fbmem_start = pci_resource_start(vdev->pdev, 2); | |
503 | else | |
504 | vdev->fbmem_start = pci_resource_start(vdev->pdev, 0); | |
8bbf50fe JC |
505 | ret = vdev->fbmem_len = viafb_get_fb_size_from_pci(vdev->chip_type); |
506 | if (ret < 0) | |
507 | goto out_unmap; | |
24b4d82e | 508 | vdev->fbmem = ioremap_nocache(vdev->fbmem_start, vdev->fbmem_len); |
8bbf50fe JC |
509 | if (vdev->fbmem == NULL) { |
510 | ret = -ENOMEM; | |
511 | goto out_unmap; | |
512 | } | |
24b4d82e | 513 | return 0; |
8bbf50fe JC |
514 | out_unmap: |
515 | iounmap(vdev->engine_mmio); | |
516 | return ret; | |
24b4d82e JC |
517 | } |
518 | ||
eca9c47b | 519 | static void via_pci_teardown_mmio(struct viafb_dev *vdev) |
24b4d82e JC |
520 | { |
521 | iounmap(vdev->fbmem); | |
522 | iounmap(vdev->engine_mmio); | |
523 | } | |
524 | ||
7582eb9b JC |
525 | /* |
526 | * Create our subsidiary devices. | |
527 | */ | |
528 | static struct viafb_subdev_info { | |
529 | char *name; | |
530 | struct platform_device *platdev; | |
531 | } viafb_subdevs[] = { | |
532 | { | |
533 | .name = "viafb-gpio", | |
534 | }, | |
535 | { | |
536 | .name = "viafb-i2c", | |
024fafba JC |
537 | }, |
538 | #if defined(CONFIG_VIDEO_VIA_CAMERA) || defined(CONFIG_VIDEO_VIA_CAMERA_MODULE) | |
539 | { | |
540 | .name = "viafb-camera", | |
541 | }, | |
542 | #endif | |
7582eb9b JC |
543 | }; |
544 | #define N_SUBDEVS ARRAY_SIZE(viafb_subdevs) | |
545 | ||
546 | static int __devinit via_create_subdev(struct viafb_dev *vdev, | |
547 | struct viafb_subdev_info *info) | |
548 | { | |
549 | int ret; | |
550 | ||
551 | info->platdev = platform_device_alloc(info->name, -1); | |
552 | if (!info->platdev) { | |
553 | dev_err(&vdev->pdev->dev, "Unable to allocate pdev %s\n", | |
554 | info->name); | |
555 | return -ENOMEM; | |
556 | } | |
557 | info->platdev->dev.parent = &vdev->pdev->dev; | |
558 | info->platdev->dev.platform_data = vdev; | |
559 | ret = platform_device_add(info->platdev); | |
560 | if (ret) { | |
561 | dev_err(&vdev->pdev->dev, "Unable to add pdev %s\n", | |
562 | info->name); | |
563 | platform_device_put(info->platdev); | |
564 | info->platdev = NULL; | |
565 | } | |
566 | return ret; | |
567 | } | |
568 | ||
569 | static int __devinit via_setup_subdevs(struct viafb_dev *vdev) | |
570 | { | |
571 | int i; | |
572 | ||
573 | /* | |
574 | * Ignore return values. Even if some of the devices | |
575 | * fail to be created, we'll still be able to use some | |
576 | * of the rest. | |
577 | */ | |
578 | for (i = 0; i < N_SUBDEVS; i++) | |
579 | via_create_subdev(vdev, viafb_subdevs + i); | |
580 | return 0; | |
581 | } | |
582 | ||
eca9c47b | 583 | static void via_teardown_subdevs(void) |
7582eb9b JC |
584 | { |
585 | int i; | |
586 | ||
587 | for (i = 0; i < N_SUBDEVS; i++) | |
588 | if (viafb_subdevs[i].platdev) { | |
589 | viafb_subdevs[i].platdev->dev.platform_data = NULL; | |
590 | platform_device_unregister(viafb_subdevs[i].platdev); | |
591 | } | |
592 | } | |
593 | ||
751305d9 DD |
594 | /* |
595 | * Power management functions | |
596 | */ | |
597 | #ifdef CONFIG_PM | |
598 | static LIST_HEAD(viafb_pm_hooks); | |
599 | static DEFINE_MUTEX(viafb_pm_hooks_lock); | |
600 | ||
601 | void viafb_pm_register(struct viafb_pm_hooks *hooks) | |
602 | { | |
603 | INIT_LIST_HEAD(&hooks->list); | |
604 | ||
605 | mutex_lock(&viafb_pm_hooks_lock); | |
606 | list_add_tail(&hooks->list, &viafb_pm_hooks); | |
607 | mutex_unlock(&viafb_pm_hooks_lock); | |
608 | } | |
609 | EXPORT_SYMBOL_GPL(viafb_pm_register); | |
610 | ||
611 | void viafb_pm_unregister(struct viafb_pm_hooks *hooks) | |
612 | { | |
613 | mutex_lock(&viafb_pm_hooks_lock); | |
614 | list_del(&hooks->list); | |
615 | mutex_unlock(&viafb_pm_hooks_lock); | |
616 | } | |
617 | EXPORT_SYMBOL_GPL(viafb_pm_unregister); | |
618 | ||
619 | static int via_suspend(struct pci_dev *pdev, pm_message_t state) | |
620 | { | |
621 | struct viafb_pm_hooks *hooks; | |
622 | ||
623 | if (state.event != PM_EVENT_SUSPEND) | |
624 | return 0; | |
625 | /* | |
626 | * "I've occasionally hit a few drivers that caused suspend | |
627 | * failures, and each and every time it was a driver bug, and | |
628 | * the right thing to do was to just ignore the error and suspend | |
629 | * anyway - returning an error code and trying to undo the suspend | |
630 | * is not what anybody ever really wants, even if our model | |
631 | *_allows_ for it." | |
632 | * -- Linus Torvalds, Dec. 7, 2009 | |
633 | */ | |
634 | mutex_lock(&viafb_pm_hooks_lock); | |
635 | list_for_each_entry_reverse(hooks, &viafb_pm_hooks, list) | |
636 | hooks->suspend(hooks->private); | |
637 | mutex_unlock(&viafb_pm_hooks_lock); | |
638 | ||
639 | pci_save_state(pdev); | |
640 | pci_disable_device(pdev); | |
641 | pci_set_power_state(pdev, pci_choose_state(pdev, state)); | |
642 | return 0; | |
643 | } | |
644 | ||
645 | static int via_resume(struct pci_dev *pdev) | |
646 | { | |
647 | struct viafb_pm_hooks *hooks; | |
648 | ||
649 | /* Get the bus side powered up */ | |
650 | pci_set_power_state(pdev, PCI_D0); | |
651 | pci_restore_state(pdev); | |
652 | if (pci_enable_device(pdev)) | |
653 | return 0; | |
654 | ||
655 | pci_set_master(pdev); | |
656 | ||
657 | /* Now bring back any subdevs */ | |
658 | mutex_lock(&viafb_pm_hooks_lock); | |
659 | list_for_each_entry(hooks, &viafb_pm_hooks, list) | |
660 | hooks->resume(hooks->private); | |
661 | mutex_unlock(&viafb_pm_hooks_lock); | |
662 | ||
663 | return 0; | |
664 | } | |
665 | #endif /* CONFIG_PM */ | |
f045f77b JC |
666 | |
667 | static int __devinit via_pci_probe(struct pci_dev *pdev, | |
668 | const struct pci_device_id *ent) | |
669 | { | |
670 | int ret; | |
671 | ||
672 | ret = pci_enable_device(pdev); | |
673 | if (ret) | |
674 | return ret; | |
751305d9 | 675 | |
24b4d82e JC |
676 | /* |
677 | * Global device initialization. | |
678 | */ | |
679 | memset(&global_dev, 0, sizeof(global_dev)); | |
680 | global_dev.pdev = pdev; | |
681 | global_dev.chip_type = ent->driver_data; | |
7582eb9b | 682 | global_dev.port_cfg = adap_configs; |
b884a94e DD |
683 | if (machine_is_olpc()) |
684 | global_dev.port_cfg = olpc_adap_configs; | |
685 | ||
24b4d82e JC |
686 | spin_lock_init(&global_dev.reg_lock); |
687 | ret = via_pci_setup_mmio(&global_dev); | |
688 | if (ret) | |
689 | goto out_disable; | |
f045f77b | 690 | /* |
94dd1a85 JC |
691 | * Set up interrupts and create our subdevices. Continue even if |
692 | * some things fail. | |
f045f77b | 693 | */ |
94dd1a85 | 694 | viafb_int_init(); |
7582eb9b | 695 | via_setup_subdevs(&global_dev); |
f045f77b | 696 | /* |
8bbf50fe | 697 | * Set up the framebuffer device |
f045f77b | 698 | */ |
24b4d82e | 699 | ret = via_fb_pci_probe(&global_dev); |
f045f77b | 700 | if (ret) |
7582eb9b | 701 | goto out_subdevs; |
f045f77b JC |
702 | return 0; |
703 | ||
7582eb9b JC |
704 | out_subdevs: |
705 | via_teardown_subdevs(); | |
24b4d82e | 706 | via_pci_teardown_mmio(&global_dev); |
f045f77b JC |
707 | out_disable: |
708 | pci_disable_device(pdev); | |
709 | return ret; | |
710 | } | |
711 | ||
712 | static void __devexit via_pci_remove(struct pci_dev *pdev) | |
713 | { | |
7582eb9b | 714 | via_teardown_subdevs(); |
f045f77b | 715 | via_fb_pci_remove(pdev); |
24b4d82e | 716 | via_pci_teardown_mmio(&global_dev); |
f045f77b JC |
717 | pci_disable_device(pdev); |
718 | } | |
719 | ||
720 | ||
721 | static struct pci_device_id via_pci_table[] __devinitdata = { | |
722 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CLE266_DID), | |
723 | .driver_data = UNICHROME_CLE266 }, | |
f045f77b JC |
724 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_K400_DID), |
725 | .driver_data = UNICHROME_K400 }, | |
726 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_K800_DID), | |
727 | .driver_data = UNICHROME_K800 }, | |
ad0676cf FTS |
728 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_PM800_DID), |
729 | .driver_data = UNICHROME_PM800 }, | |
730 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CN700_DID), | |
f045f77b | 731 | .driver_data = UNICHROME_CN700 }, |
f045f77b JC |
732 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CX700_DID), |
733 | .driver_data = UNICHROME_CX700 }, | |
f045f77b JC |
734 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CN750_DID), |
735 | .driver_data = UNICHROME_CN750 }, | |
ad0676cf FTS |
736 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_K8M890_DID), |
737 | .driver_data = UNICHROME_K8M890 }, | |
738 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_P4M890_DID), | |
739 | .driver_data = UNICHROME_P4M890 }, | |
740 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_P4M900_DID), | |
741 | .driver_data = UNICHROME_P4M900 }, | |
f045f77b JC |
742 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_VX800_DID), |
743 | .driver_data = UNICHROME_VX800 }, | |
744 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_VX855_DID), | |
745 | .driver_data = UNICHROME_VX855 }, | |
51f4332b FTS |
746 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_VX900_DID), |
747 | .driver_data = UNICHROME_VX900 }, | |
f045f77b JC |
748 | { } |
749 | }; | |
750 | MODULE_DEVICE_TABLE(pci, via_pci_table); | |
751 | ||
752 | static struct pci_driver via_driver = { | |
753 | .name = "viafb", | |
754 | .id_table = via_pci_table, | |
755 | .probe = via_pci_probe, | |
756 | .remove = __devexit_p(via_pci_remove), | |
3fd9b6cc | 757 | #ifdef CONFIG_PM |
751305d9 DD |
758 | .suspend = via_suspend, |
759 | .resume = via_resume, | |
3fd9b6cc | 760 | #endif |
f045f77b JC |
761 | }; |
762 | ||
763 | static int __init via_core_init(void) | |
764 | { | |
765 | int ret; | |
766 | ||
767 | ret = viafb_init(); | |
768 | if (ret) | |
769 | return ret; | |
7582eb9b JC |
770 | viafb_i2c_init(); |
771 | viafb_gpio_init(); | |
f045f77b JC |
772 | return pci_register_driver(&via_driver); |
773 | } | |
774 | ||
775 | static void __exit via_core_exit(void) | |
776 | { | |
777 | pci_unregister_driver(&via_driver); | |
7582eb9b JC |
778 | viafb_gpio_exit(); |
779 | viafb_i2c_exit(); | |
f045f77b JC |
780 | viafb_exit(); |
781 | } | |
782 | ||
783 | module_init(via_core_init); | |
784 | module_exit(via_core_exit); |