1 /*
2     saa7146.o - driver for generic saa7146-based hardware
3 
4     Copyright (C) 1998-2003 Michael Hunold <michael@mihu.de>
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 as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10 
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15 
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20 
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 
23 #include <media/drv-intf/saa7146.h>
24 #include <linux/module.h>
25 
26 static int saa7146_num;
27 
28 unsigned int saa7146_debug;
29 
30 module_param(saa7146_debug, uint, 0644);
31 MODULE_PARM_DESC(saa7146_debug, "debug level (default: 0)");
32 
33 #if 0
34 static void dump_registers(struct saa7146_dev* dev)
35 {
36 	int i = 0;
37 
38 	pr_info(" @ %li jiffies:\n", jiffies);
39 	for (i = 0; i <= 0x148; i += 4)
40 		pr_info("0x%03x: 0x%08x\n", i, saa7146_read(dev, i));
41 }
42 #endif
43 
44 /****************************************************************************
45  * gpio and debi helper functions
46  ****************************************************************************/
47 
saa7146_setgpio(struct saa7146_dev * dev,int port,u32 data)48 void saa7146_setgpio(struct saa7146_dev *dev, int port, u32 data)
49 {
50 	u32 value = 0;
51 
52 	BUG_ON(port > 3);
53 
54 	value = saa7146_read(dev, GPIO_CTRL);
55 	value &= ~(0xff << (8*port));
56 	value |= (data << (8*port));
57 	saa7146_write(dev, GPIO_CTRL, value);
58 }
59 
60 /* This DEBI code is based on the saa7146 Stradis driver by Nathan Laredo */
saa7146_wait_for_debi_done_sleep(struct saa7146_dev * dev,unsigned long us1,unsigned long us2)61 static inline int saa7146_wait_for_debi_done_sleep(struct saa7146_dev *dev,
62 				unsigned long us1, unsigned long us2)
63 {
64 	unsigned long timeout;
65 	int err;
66 
67 	/* wait for registers to be programmed */
68 	timeout = jiffies + usecs_to_jiffies(us1);
69 	while (1) {
70 		err = time_after(jiffies, timeout);
71 		if (saa7146_read(dev, MC2) & 2)
72 			break;
73 		if (err) {
74 			pr_debug("%s: %s timed out while waiting for registers getting programmed\n",
75 			       dev->name, __func__);
76 			return -ETIMEDOUT;
77 		}
78 		msleep(1);
79 	}
80 
81 	/* wait for transfer to complete */
82 	timeout = jiffies + usecs_to_jiffies(us2);
83 	while (1) {
84 		err = time_after(jiffies, timeout);
85 		if (!(saa7146_read(dev, PSR) & SPCI_DEBI_S))
86 			break;
87 		saa7146_read(dev, MC2);
88 		if (err) {
89 			DEB_S("%s: %s timed out while waiting for transfer completion\n",
90 			      dev->name, __func__);
91 			return -ETIMEDOUT;
92 		}
93 		msleep(1);
94 	}
95 
96 	return 0;
97 }
98 
saa7146_wait_for_debi_done_busyloop(struct saa7146_dev * dev,unsigned long us1,unsigned long us2)99 static inline int saa7146_wait_for_debi_done_busyloop(struct saa7146_dev *dev,
100 				unsigned long us1, unsigned long us2)
101 {
102 	unsigned long loops;
103 
104 	/* wait for registers to be programmed */
105 	loops = us1;
106 	while (1) {
107 		if (saa7146_read(dev, MC2) & 2)
108 			break;
109 		if (!loops--) {
110 			pr_err("%s: %s timed out while waiting for registers getting programmed\n",
111 			       dev->name, __func__);
112 			return -ETIMEDOUT;
113 		}
114 		udelay(1);
115 	}
116 
117 	/* wait for transfer to complete */
118 	loops = us2 / 5;
119 	while (1) {
120 		if (!(saa7146_read(dev, PSR) & SPCI_DEBI_S))
121 			break;
122 		saa7146_read(dev, MC2);
123 		if (!loops--) {
124 			DEB_S("%s: %s timed out while waiting for transfer completion\n",
125 			      dev->name, __func__);
126 			return -ETIMEDOUT;
127 		}
128 		udelay(5);
129 	}
130 
131 	return 0;
132 }
133 
saa7146_wait_for_debi_done(struct saa7146_dev * dev,int nobusyloop)134 int saa7146_wait_for_debi_done(struct saa7146_dev *dev, int nobusyloop)
135 {
136 	if (nobusyloop)
137 		return saa7146_wait_for_debi_done_sleep(dev, 50000, 250000);
138 	else
139 		return saa7146_wait_for_debi_done_busyloop(dev, 50000, 250000);
140 }
141 
142 /****************************************************************************
143  * general helper functions
144  ****************************************************************************/
145 
146 /* this is videobuf_vmalloc_to_sg() from videobuf-dma-sg.c
147    make sure virt has been allocated with vmalloc_32(), otherwise the BUG()
148    may be triggered on highmem machines */
vmalloc_to_sg(unsigned char * virt,int nr_pages)149 static struct scatterlist* vmalloc_to_sg(unsigned char *virt, int nr_pages)
150 {
151 	struct scatterlist *sglist;
152 	struct page *pg;
153 	int i;
154 
155 	sglist = kcalloc(nr_pages, sizeof(struct scatterlist), GFP_KERNEL);
156 	if (NULL == sglist)
157 		return NULL;
158 	sg_init_table(sglist, nr_pages);
159 	for (i = 0; i < nr_pages; i++, virt += PAGE_SIZE) {
160 		pg = vmalloc_to_page(virt);
161 		if (NULL == pg)
162 			goto err;
163 		BUG_ON(PageHighMem(pg));
164 		sg_set_page(&sglist[i], pg, PAGE_SIZE, 0);
165 	}
166 	return sglist;
167 
168  err:
169 	kfree(sglist);
170 	return NULL;
171 }
172 
173 /********************************************************************************/
174 /* common page table functions */
175 
saa7146_vmalloc_build_pgtable(struct pci_dev * pci,long length,struct saa7146_pgtable * pt)176 void *saa7146_vmalloc_build_pgtable(struct pci_dev *pci, long length, struct saa7146_pgtable *pt)
177 {
178 	int pages = (length+PAGE_SIZE-1)/PAGE_SIZE;
179 	void *mem = vmalloc_32(length);
180 	int slen = 0;
181 
182 	if (NULL == mem)
183 		goto err_null;
184 
185 	if (!(pt->slist = vmalloc_to_sg(mem, pages)))
186 		goto err_free_mem;
187 
188 	if (saa7146_pgtable_alloc(pci, pt))
189 		goto err_free_slist;
190 
191 	pt->nents = pages;
192 	slen = pci_map_sg(pci,pt->slist,pt->nents,PCI_DMA_FROMDEVICE);
193 	if (0 == slen)
194 		goto err_free_pgtable;
195 
196 	if (0 != saa7146_pgtable_build_single(pci, pt, pt->slist, slen))
197 		goto err_unmap_sg;
198 
199 	return mem;
200 
201 err_unmap_sg:
202 	pci_unmap_sg(pci, pt->slist, pt->nents, PCI_DMA_FROMDEVICE);
203 err_free_pgtable:
204 	saa7146_pgtable_free(pci, pt);
205 err_free_slist:
206 	kfree(pt->slist);
207 	pt->slist = NULL;
208 err_free_mem:
209 	vfree(mem);
210 err_null:
211 	return NULL;
212 }
213 
saa7146_vfree_destroy_pgtable(struct pci_dev * pci,void * mem,struct saa7146_pgtable * pt)214 void saa7146_vfree_destroy_pgtable(struct pci_dev *pci, void *mem, struct saa7146_pgtable *pt)
215 {
216 	pci_unmap_sg(pci, pt->slist, pt->nents, PCI_DMA_FROMDEVICE);
217 	saa7146_pgtable_free(pci, pt);
218 	kfree(pt->slist);
219 	pt->slist = NULL;
220 	vfree(mem);
221 }
222 
saa7146_pgtable_free(struct pci_dev * pci,struct saa7146_pgtable * pt)223 void saa7146_pgtable_free(struct pci_dev *pci, struct saa7146_pgtable *pt)
224 {
225 	if (NULL == pt->cpu)
226 		return;
227 	pci_free_consistent(pci, pt->size, pt->cpu, pt->dma);
228 	pt->cpu = NULL;
229 }
230 
saa7146_pgtable_alloc(struct pci_dev * pci,struct saa7146_pgtable * pt)231 int saa7146_pgtable_alloc(struct pci_dev *pci, struct saa7146_pgtable *pt)
232 {
233 	__le32       *cpu;
234 	dma_addr_t   dma_addr = 0;
235 
236 	cpu = pci_alloc_consistent(pci, PAGE_SIZE, &dma_addr);
237 	if (NULL == cpu) {
238 		return -ENOMEM;
239 	}
240 	pt->size = PAGE_SIZE;
241 	pt->cpu  = cpu;
242 	pt->dma  = dma_addr;
243 
244 	return 0;
245 }
246 
saa7146_pgtable_build_single(struct pci_dev * pci,struct saa7146_pgtable * pt,struct scatterlist * list,int sglen)247 int saa7146_pgtable_build_single(struct pci_dev *pci, struct saa7146_pgtable *pt,
248 	struct scatterlist *list, int sglen  )
249 {
250 	__le32 *ptr, fill;
251 	int nr_pages = 0;
252 	int i,p;
253 
254 	BUG_ON(0 == sglen);
255 	BUG_ON(list->offset > PAGE_SIZE);
256 
257 	/* if we have a user buffer, the first page may not be
258 	   aligned to a page boundary. */
259 	pt->offset = list->offset;
260 
261 	ptr = pt->cpu;
262 	for (i = 0; i < sglen; i++, list++) {
263 /*
264 		pr_debug("i:%d, adr:0x%08x, len:%d, offset:%d\n",
265 			 i, sg_dma_address(list), sg_dma_len(list),
266 			 list->offset);
267 */
268 		for (p = 0; p * 4096 < list->length; p++, ptr++) {
269 			*ptr = cpu_to_le32(sg_dma_address(list) + p * 4096);
270 			nr_pages++;
271 		}
272 	}
273 
274 
275 	/* safety; fill the page table up with the last valid page */
276 	fill = *(ptr-1);
277 	for(i=nr_pages;i<1024;i++) {
278 		*ptr++ = fill;
279 	}
280 
281 /*
282 	ptr = pt->cpu;
283 	pr_debug("offset: %d\n", pt->offset);
284 	for(i=0;i<5;i++) {
285 		pr_debug("ptr1 %d: 0x%08x\n", i, ptr[i]);
286 	}
287 */
288 	return 0;
289 }
290 
291 /********************************************************************************/
292 /* interrupt handler */
interrupt_hw(int irq,void * dev_id)293 static irqreturn_t interrupt_hw(int irq, void *dev_id)
294 {
295 	struct saa7146_dev *dev = dev_id;
296 	u32 isr;
297 	u32 ack_isr;
298 
299 	/* read out the interrupt status register */
300 	ack_isr = isr = saa7146_read(dev, ISR);
301 
302 	/* is this our interrupt? */
303 	if ( 0 == isr ) {
304 		/* nope, some other device */
305 		return IRQ_NONE;
306 	}
307 
308 	if (dev->ext) {
309 		if (dev->ext->irq_mask & isr) {
310 			if (dev->ext->irq_func)
311 				dev->ext->irq_func(dev, &isr);
312 			isr &= ~dev->ext->irq_mask;
313 		}
314 	}
315 	if (0 != (isr & (MASK_27))) {
316 		DEB_INT("irq: RPS0 (0x%08x)\n", isr);
317 		if (dev->vv_data && dev->vv_callback)
318 			dev->vv_callback(dev,isr);
319 		isr &= ~MASK_27;
320 	}
321 	if (0 != (isr & (MASK_28))) {
322 		if (dev->vv_data && dev->vv_callback)
323 			dev->vv_callback(dev,isr);
324 		isr &= ~MASK_28;
325 	}
326 	if (0 != (isr & (MASK_16|MASK_17))) {
327 		SAA7146_IER_DISABLE(dev, MASK_16|MASK_17);
328 		/* only wake up if we expect something */
329 		if (0 != dev->i2c_op) {
330 			dev->i2c_op = 0;
331 			wake_up(&dev->i2c_wq);
332 		} else {
333 			u32 psr = saa7146_read(dev, PSR);
334 			u32 ssr = saa7146_read(dev, SSR);
335 			pr_warn("%s: unexpected i2c irq: isr %08x psr %08x ssr %08x\n",
336 				dev->name, isr, psr, ssr);
337 		}
338 		isr &= ~(MASK_16|MASK_17);
339 	}
340 	if( 0 != isr ) {
341 		ERR("warning: interrupt enabled, but not handled properly.(0x%08x)\n",
342 		    isr);
343 		ERR("disabling interrupt source(s)!\n");
344 		SAA7146_IER_DISABLE(dev,isr);
345 	}
346 	saa7146_write(dev, ISR, ack_isr);
347 	return IRQ_HANDLED;
348 }
349 
350 /*********************************************************************************/
351 /* configuration-functions                                                       */
352 
saa7146_init_one(struct pci_dev * pci,const struct pci_device_id * ent)353 static int saa7146_init_one(struct pci_dev *pci, const struct pci_device_id *ent)
354 {
355 	struct saa7146_pci_extension_data *pci_ext = (struct saa7146_pci_extension_data *)ent->driver_data;
356 	struct saa7146_extension *ext = pci_ext->ext;
357 	struct saa7146_dev *dev;
358 	int err = -ENOMEM;
359 
360 	/* clear out mem for sure */
361 	dev = kzalloc(sizeof(struct saa7146_dev), GFP_KERNEL);
362 	if (!dev) {
363 		ERR("out of memory\n");
364 		goto out;
365 	}
366 
367 	/* create a nice device name */
368 	sprintf(dev->name, "saa7146 (%d)", saa7146_num);
369 
370 	DEB_EE("pci:%p\n", pci);
371 
372 	err = pci_enable_device(pci);
373 	if (err < 0) {
374 		ERR("pci_enable_device() failed\n");
375 		goto err_free;
376 	}
377 
378 	/* enable bus-mastering */
379 	pci_set_master(pci);
380 
381 	dev->pci = pci;
382 
383 	/* get chip-revision; this is needed to enable bug-fixes */
384 	dev->revision = pci->revision;
385 
386 	/* remap the memory from virtual to physical address */
387 
388 	err = pci_request_region(pci, 0, "saa7146");
389 	if (err < 0)
390 		goto err_disable;
391 
392 	dev->mem = ioremap(pci_resource_start(pci, 0),
393 			   pci_resource_len(pci, 0));
394 	if (!dev->mem) {
395 		ERR("ioremap() failed\n");
396 		err = -ENODEV;
397 		goto err_release;
398 	}
399 
400 	/* we don't do a master reset here anymore, it screws up
401 	   some boards that don't have an i2c-eeprom for configuration
402 	   values */
403 /*
404 	saa7146_write(dev, MC1, MASK_31);
405 */
406 
407 	/* disable all irqs */
408 	saa7146_write(dev, IER, 0);
409 
410 	/* shut down all dma transfers and rps tasks */
411 	saa7146_write(dev, MC1, 0x30ff0000);
412 
413 	/* clear out any rps-signals pending */
414 	saa7146_write(dev, MC2, 0xf8000000);
415 
416 	/* request an interrupt for the saa7146 */
417 	err = request_irq(pci->irq, interrupt_hw, IRQF_SHARED,
418 			  dev->name, dev);
419 	if (err < 0) {
420 		ERR("request_irq() failed\n");
421 		goto err_unmap;
422 	}
423 
424 	err = -ENOMEM;
425 
426 	/* get memory for various stuff */
427 	dev->d_rps0.cpu_addr = pci_zalloc_consistent(pci, SAA7146_RPS_MEM,
428 						     &dev->d_rps0.dma_handle);
429 	if (!dev->d_rps0.cpu_addr)
430 		goto err_free_irq;
431 
432 	dev->d_rps1.cpu_addr = pci_zalloc_consistent(pci, SAA7146_RPS_MEM,
433 						     &dev->d_rps1.dma_handle);
434 	if (!dev->d_rps1.cpu_addr)
435 		goto err_free_rps0;
436 
437 	dev->d_i2c.cpu_addr = pci_zalloc_consistent(pci, SAA7146_RPS_MEM,
438 						    &dev->d_i2c.dma_handle);
439 	if (!dev->d_i2c.cpu_addr)
440 		goto err_free_rps1;
441 
442 	/* the rest + print status message */
443 
444 	pr_info("found saa7146 @ mem %p (revision %d, irq %d) (0x%04x,0x%04x)\n",
445 		dev->mem, dev->revision, pci->irq,
446 		pci->subsystem_vendor, pci->subsystem_device);
447 	dev->ext = ext;
448 
449 	mutex_init(&dev->v4l2_lock);
450 	spin_lock_init(&dev->int_slock);
451 	spin_lock_init(&dev->slock);
452 
453 	mutex_init(&dev->i2c_lock);
454 
455 	dev->module = THIS_MODULE;
456 	init_waitqueue_head(&dev->i2c_wq);
457 
458 	/* set some sane pci arbitrition values */
459 	saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
460 
461 	/* TODO: use the status code of the callback */
462 
463 	err = -ENODEV;
464 
465 	if (ext->probe && ext->probe(dev)) {
466 		DEB_D("ext->probe() failed for %p. skipping device.\n", dev);
467 		goto err_free_i2c;
468 	}
469 
470 	if (ext->attach(dev, pci_ext)) {
471 		DEB_D("ext->attach() failed for %p. skipping device.\n", dev);
472 		goto err_free_i2c;
473 	}
474 	/* V4L extensions will set the pci drvdata to the v4l2_device in the
475 	   attach() above. So for those cards that do not use V4L we have to
476 	   set it explicitly. */
477 	pci_set_drvdata(pci, &dev->v4l2_dev);
478 
479 	saa7146_num++;
480 
481 	err = 0;
482 out:
483 	return err;
484 
485 err_free_i2c:
486 	pci_free_consistent(pci, SAA7146_RPS_MEM, dev->d_i2c.cpu_addr,
487 			    dev->d_i2c.dma_handle);
488 err_free_rps1:
489 	pci_free_consistent(pci, SAA7146_RPS_MEM, dev->d_rps1.cpu_addr,
490 			    dev->d_rps1.dma_handle);
491 err_free_rps0:
492 	pci_free_consistent(pci, SAA7146_RPS_MEM, dev->d_rps0.cpu_addr,
493 			    dev->d_rps0.dma_handle);
494 err_free_irq:
495 	free_irq(pci->irq, (void *)dev);
496 err_unmap:
497 	iounmap(dev->mem);
498 err_release:
499 	pci_release_region(pci, 0);
500 err_disable:
501 	pci_disable_device(pci);
502 err_free:
503 	kfree(dev);
504 	goto out;
505 }
506 
saa7146_remove_one(struct pci_dev * pdev)507 static void saa7146_remove_one(struct pci_dev *pdev)
508 {
509 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev);
510 	struct saa7146_dev *dev = to_saa7146_dev(v4l2_dev);
511 	struct {
512 		void *addr;
513 		dma_addr_t dma;
514 	} dev_map[] = {
515 		{ dev->d_i2c.cpu_addr, dev->d_i2c.dma_handle },
516 		{ dev->d_rps1.cpu_addr, dev->d_rps1.dma_handle },
517 		{ dev->d_rps0.cpu_addr, dev->d_rps0.dma_handle },
518 		{ NULL, 0 }
519 	}, *p;
520 
521 	DEB_EE("dev:%p\n", dev);
522 
523 	dev->ext->detach(dev);
524 
525 	/* shut down all video dma transfers */
526 	saa7146_write(dev, MC1, 0x00ff0000);
527 
528 	/* disable all irqs, release irq-routine */
529 	saa7146_write(dev, IER, 0);
530 
531 	free_irq(pdev->irq, dev);
532 
533 	for (p = dev_map; p->addr; p++)
534 		pci_free_consistent(pdev, SAA7146_RPS_MEM, p->addr, p->dma);
535 
536 	iounmap(dev->mem);
537 	pci_release_region(pdev, 0);
538 	pci_disable_device(pdev);
539 	kfree(dev);
540 
541 	saa7146_num--;
542 }
543 
544 /*********************************************************************************/
545 /* extension handling functions                                                  */
546 
saa7146_register_extension(struct saa7146_extension * ext)547 int saa7146_register_extension(struct saa7146_extension* ext)
548 {
549 	DEB_EE("ext:%p\n", ext);
550 
551 	ext->driver.name = ext->name;
552 	ext->driver.id_table = ext->pci_tbl;
553 	ext->driver.probe = saa7146_init_one;
554 	ext->driver.remove = saa7146_remove_one;
555 
556 	pr_info("register extension '%s'\n", ext->name);
557 	return pci_register_driver(&ext->driver);
558 }
559 
saa7146_unregister_extension(struct saa7146_extension * ext)560 int saa7146_unregister_extension(struct saa7146_extension* ext)
561 {
562 	DEB_EE("ext:%p\n", ext);
563 	pr_info("unregister extension '%s'\n", ext->name);
564 	pci_unregister_driver(&ext->driver);
565 	return 0;
566 }
567 
568 EXPORT_SYMBOL_GPL(saa7146_register_extension);
569 EXPORT_SYMBOL_GPL(saa7146_unregister_extension);
570 
571 /* misc functions used by extension modules */
572 EXPORT_SYMBOL_GPL(saa7146_pgtable_alloc);
573 EXPORT_SYMBOL_GPL(saa7146_pgtable_free);
574 EXPORT_SYMBOL_GPL(saa7146_pgtable_build_single);
575 EXPORT_SYMBOL_GPL(saa7146_vmalloc_build_pgtable);
576 EXPORT_SYMBOL_GPL(saa7146_vfree_destroy_pgtable);
577 EXPORT_SYMBOL_GPL(saa7146_wait_for_debi_done);
578 
579 EXPORT_SYMBOL_GPL(saa7146_setgpio);
580 
581 EXPORT_SYMBOL_GPL(saa7146_i2c_adapter_prepare);
582 
583 EXPORT_SYMBOL_GPL(saa7146_debug);
584 
585 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
586 MODULE_DESCRIPTION("driver for generic saa7146-based hardware");
587 MODULE_LICENSE("GPL");
588