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