Searched refs:cobalt (Results 1 - 30 of 30) sorted by relevance

/linux-4.4.14/drivers/media/pci/cobalt/
H A DMakefile0 cobalt-objs := cobalt-driver.o cobalt-irq.o cobalt-v4l2.o \
2 cobalt-i2c.o cobalt-omnitek.o cobalt-flash.o cobalt-cpld.o \
3 cobalt-alsa-main.o cobalt-alsa-pcm.o
5 obj-$(CONFIG_VIDEO_COBALT) += cobalt.o
H A Dcobalt-driver.c2 * cobalt driver initialization and card probing
30 #include "cobalt-driver.h"
31 #include "cobalt-irq.h"
32 #include "cobalt-i2c.h"
33 #include "cobalt-v4l2.h"
34 #include "cobalt-flash.h"
35 #include "cobalt-alsa.h"
36 #include "cobalt-omnitek.h"
59 MODULE_DESCRIPTION("cobalt driver");
97 static void cobalt_set_interrupt(struct cobalt *cobalt, bool enable) cobalt_set_interrupt() argument
114 if (cobalt->have_hsma_rx) cobalt_set_interrupt()
119 if (cobalt->have_hsma_tx) cobalt_set_interrupt()
124 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_EDGE, 0xffffffff); cobalt_set_interrupt()
127 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_MASK, irqs); cobalt_set_interrupt()
130 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_MASK, 0); cobalt_set_interrupt()
136 struct cobalt *cobalt = to_cobalt(sd->v4l2_dev); cobalt_get_sd_nr() local
140 if (sd == cobalt->streams[i].sd) cobalt_get_sd_nr()
149 struct cobalt *cobalt = to_cobalt(sd->v4l2_dev); cobalt_notify() local
151 struct cobalt_stream *s = &cobalt->streams[sd_nr]; cobalt_notify()
159 cobalt_s_bit_sysctrl(cobalt, cobalt_notify()
196 void cobalt_pcie_status_show(struct cobalt *cobalt) cobalt_pcie_status_show() argument
198 struct pci_dev *pci_dev = cobalt->pci_dev; cobalt_pcie_status_show()
199 struct pci_dev *pci_bus_dev = cobalt->pci_dev->bus->self; cobalt_pcie_status_show()
247 static unsigned pcie_link_get_lanes(struct cobalt *cobalt) pcie_link_get_lanes() argument
249 struct pci_dev *pci_dev = cobalt->pci_dev; pcie_link_get_lanes()
260 static unsigned pcie_bus_link_get_lanes(struct cobalt *cobalt) pcie_bus_link_get_lanes() argument
262 struct pci_dev *pci_dev = cobalt->pci_dev->bus->self; pcie_bus_link_get_lanes()
273 static void msi_config_show(struct cobalt *cobalt, struct pci_dev *pci_dev) msi_config_show() argument
295 static void cobalt_pci_iounmap(struct cobalt *cobalt, struct pci_dev *pci_dev) cobalt_pci_iounmap() argument
297 if (cobalt->bar0) { cobalt_pci_iounmap()
298 pci_iounmap(pci_dev, cobalt->bar0); cobalt_pci_iounmap()
299 cobalt->bar0 = NULL; cobalt_pci_iounmap()
301 if (cobalt->bar1) { cobalt_pci_iounmap()
302 pci_iounmap(pci_dev, cobalt->bar1); cobalt_pci_iounmap()
303 cobalt->bar1 = NULL; cobalt_pci_iounmap()
307 static void cobalt_free_msi(struct cobalt *cobalt, struct pci_dev *pci_dev) cobalt_free_msi() argument
309 free_irq(pci_dev->irq, (void *)cobalt); cobalt_free_msi()
311 if (cobalt->msi_enabled) cobalt_free_msi()
315 static int cobalt_setup_pci(struct cobalt *cobalt, struct pci_dev *pci_dev, cobalt_setup_pci() argument
329 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cobalt->card_rev); cobalt_setup_pci()
330 pci_read_config_word(pci_dev, PCI_DEVICE_ID, &cobalt->device_id); cobalt_setup_pci()
332 switch (cobalt->device_id) { cobalt_setup_pci()
341 if (pcie_link_get_lanes(cobalt) != 8) { cobalt_setup_pci()
343 pcie_link_get_lanes(cobalt)); cobalt_setup_pci()
344 if (pcie_bus_link_get_lanes(cobalt) < 8) cobalt_setup_pci()
346 pcie_bus_link_get_lanes(cobalt)); cobalt_setup_pci()
347 if (pcie_link_get_lanes(cobalt) != pcie_bus_link_get_lanes(cobalt)) { cobalt_setup_pci()
362 ret = pci_request_regions(pci_dev, "cobalt"); cobalt_setup_pci()
368 cobalt_pcie_status_show(cobalt); cobalt_setup_pci()
370 cobalt->bar0 = pci_iomap(pci_dev, 0, 0); cobalt_setup_pci()
371 cobalt->bar1 = pci_iomap(pci_dev, 1, 0); cobalt_setup_pci()
372 if (cobalt->bar1 == NULL) { cobalt_setup_pci()
373 cobalt->bar1 = pci_iomap(pci_dev, 2, 0); cobalt_setup_pci()
376 if (!cobalt->bar0 || !cobalt->bar1) { cobalt_setup_pci()
382 ctrl = cobalt_read_bar1(cobalt, COBALT_SYS_CTRL_BASE); cobalt_setup_pci()
383 cobalt_write_bar1(cobalt, COBALT_SYS_CTRL_BASE, ctrl & ~0xf00); cobalt_setup_pci()
387 cobalt_set_interrupt(cobalt, false); cobalt_setup_pci()
391 cobalt->msi_enabled = false; cobalt_setup_pci()
395 msi_config_show(cobalt, pci_dev); cobalt_setup_pci()
396 cobalt->msi_enabled = true; cobalt_setup_pci()
400 cobalt->v4l2_dev.name, (void *)cobalt)) { cobalt_setup_pci()
406 omni_sg_dma_init(cobalt); cobalt_setup_pci()
413 cobalt_pci_iounmap(cobalt, pci_dev); cobalt_setup_pci()
417 pci_disable_device(cobalt->pci_dev); cobalt_setup_pci()
421 static int cobalt_hdl_info_get(struct cobalt *cobalt) cobalt_hdl_info_get() argument
426 cobalt->hdl_info[i] = cobalt_hdl_info_get()
427 ioread8(cobalt->bar1 + COBALT_HDL_INFO_BASE + i); cobalt_hdl_info_get()
428 cobalt->hdl_info[COBALT_HDL_INFO_SIZE - 1] = '\0'; cobalt_hdl_info_get()
429 if (strstr(cobalt->hdl_info, COBALT_HDL_SEARCH_STR)) cobalt_hdl_info_get()
435 static void cobalt_stream_struct_init(struct cobalt *cobalt) cobalt_stream_struct_init() argument
440 struct cobalt_stream *s = &cobalt->streams[i]; cobalt_stream_struct_init()
442 s->cobalt = cobalt; cobalt_stream_struct_init()
453 s->dma_channel = i + cobalt->first_fifo_channel; cobalt_stream_struct_init()
488 static int cobalt_subdevs_init(struct cobalt *cobalt) cobalt_subdevs_init() argument
511 struct cobalt_stream *s = cobalt->streams; cobalt_subdevs_init()
529 s[i].i2c_adap = &cobalt->i2c_adap[i]; cobalt_subdevs_init()
532 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_init()
534 s[i].sd = v4l2_i2c_new_subdev_board(&cobalt->v4l2_dev, cobalt_subdevs_init()
554 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_init()
557 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_init()
561 cobalt->streams[i + COBALT_AUDIO_IN_STREAM].is_dummy = false; cobalt_subdevs_init()
566 static int cobalt_subdevs_hsma_init(struct cobalt *cobalt) cobalt_subdevs_hsma_init() argument
620 struct cobalt_stream *s = &cobalt->streams[COBALT_HSMA_IN_NODE]; cobalt_subdevs_hsma_init()
622 s->i2c_adap = &cobalt->i2c_adap[COBALT_NUM_ADAPTERS - 1]; cobalt_subdevs_hsma_init()
625 cobalt_s_bit_sysctrl(cobalt, COBALT_SYS_CTRL_NRESET_TO_HDMI_BIT(4), 1); cobalt_subdevs_hsma_init()
627 s->sd = v4l2_i2c_new_subdev_board(&cobalt->v4l2_dev, cobalt_subdevs_hsma_init()
638 cobalt->have_hsma_rx = true; cobalt_subdevs_hsma_init()
641 cobalt->streams[4 + COBALT_AUDIO_IN_STREAM].is_dummy = false; cobalt_subdevs_hsma_init()
643 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_hsma_init()
646 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_hsma_init()
651 cobalt_s_bit_sysctrl(cobalt, COBALT_SYS_CTRL_NRESET_TO_HDMI_BIT(4), 0); cobalt_subdevs_hsma_init()
652 cobalt_s_bit_sysctrl(cobalt, COBALT_SYS_CTRL_PWRDN0_TO_HSMA_TX_BIT, 0); cobalt_subdevs_hsma_init()
654 s->i2c_adap = &cobalt->i2c_adap[COBALT_NUM_ADAPTERS - 1]; cobalt_subdevs_hsma_init()
655 s->sd = v4l2_i2c_new_subdev_board(&cobalt->v4l2_dev, cobalt_subdevs_hsma_init()
659 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_hsma_init()
661 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_hsma_init()
663 cobalt_s_bit_sysctrl(cobalt, cobalt_subdevs_hsma_init()
665 cobalt->have_hsma_tx = true; cobalt_subdevs_hsma_init()
672 cobalt->streams[COBALT_AUDIO_OUT_STREAM].is_dummy = false; cobalt_subdevs_hsma_init()
681 struct cobalt *cobalt; cobalt_probe() local
688 cobalt = kzalloc(sizeof(struct cobalt), GFP_ATOMIC); cobalt_probe()
689 if (cobalt == NULL) cobalt_probe()
691 cobalt->pci_dev = pci_dev; cobalt_probe()
692 cobalt->instance = i; cobalt_probe()
694 cobalt->alloc_ctx = vb2_dma_sg_init_ctx(&pci_dev->dev); cobalt_probe()
695 if (IS_ERR(cobalt->alloc_ctx)) { cobalt_probe()
696 kfree(cobalt); cobalt_probe()
700 retval = v4l2_device_register(&pci_dev->dev, &cobalt->v4l2_dev); cobalt_probe()
702 pr_err("cobalt: v4l2_device_register of card %d failed\n", cobalt_probe()
703 cobalt->instance); cobalt_probe()
704 vb2_dma_sg_cleanup_ctx(cobalt->alloc_ctx); cobalt_probe()
705 kfree(cobalt); cobalt_probe()
708 snprintf(cobalt->v4l2_dev.name, sizeof(cobalt->v4l2_dev.name), cobalt_probe()
709 "cobalt-%d", cobalt->instance); cobalt_probe()
710 cobalt->v4l2_dev.notify = cobalt_notify; cobalt_probe()
711 cobalt_info("Initializing card %d\n", cobalt->instance); cobalt_probe()
713 cobalt->irq_work_queues = cobalt_probe()
714 create_singlethread_workqueue(cobalt->v4l2_dev.name); cobalt_probe()
715 if (cobalt->irq_work_queues == NULL) { cobalt_probe()
721 INIT_WORK(&cobalt->irq_work_queue, cobalt_irq_work_handler); cobalt_probe()
724 retval = cobalt_setup_pci(cobalt, pci_dev, pci_id); cobalt_probe()
729 if (cobalt_hdl_info_get(cobalt)) cobalt_probe()
732 cobalt_info("%s", cobalt->hdl_info); cobalt_probe()
734 retval = cobalt_i2c_init(cobalt); cobalt_probe()
738 cobalt_stream_struct_init(cobalt); cobalt_probe()
740 retval = cobalt_subdevs_init(cobalt); cobalt_probe()
744 if (!(cobalt_read_bar1(cobalt, COBALT_SYS_STAT_BASE) & cobalt_probe()
746 retval = cobalt_subdevs_hsma_init(cobalt); cobalt_probe()
751 retval = v4l2_device_register_subdev_nodes(&cobalt->v4l2_dev); cobalt_probe()
754 retval = cobalt_nodes_register(cobalt); cobalt_probe()
759 cobalt_set_interrupt(cobalt, true); cobalt_probe()
760 v4l2_device_call_all(&cobalt->v4l2_dev, 0, core, cobalt_probe()
763 cobalt_info("Initialized cobalt card\n"); cobalt_probe()
765 cobalt_flash_probe(cobalt); cobalt_probe()
770 cobalt_i2c_exit(cobalt); cobalt_probe()
771 cobalt_s_bit_sysctrl(cobalt, COBALT_SYS_CTRL_HSMA_TX_ENABLE_BIT, 0); cobalt_probe()
773 cobalt_free_msi(cobalt, pci_dev); cobalt_probe()
774 cobalt_pci_iounmap(cobalt, pci_dev); cobalt_probe()
775 pci_release_regions(cobalt->pci_dev); cobalt_probe()
776 pci_disable_device(cobalt->pci_dev); cobalt_probe()
778 destroy_workqueue(cobalt->irq_work_queues); cobalt_probe()
784 v4l2_device_unregister(&cobalt->v4l2_dev); cobalt_probe()
785 vb2_dma_sg_cleanup_ctx(cobalt->alloc_ctx); cobalt_probe()
786 kfree(cobalt); cobalt_probe()
793 struct cobalt *cobalt = to_cobalt(v4l2_dev); cobalt_remove() local
796 cobalt_flash_remove(cobalt); cobalt_remove()
797 cobalt_set_interrupt(cobalt, false); cobalt_remove()
798 flush_workqueue(cobalt->irq_work_queues); cobalt_remove()
799 cobalt_nodes_unregister(cobalt); cobalt_remove()
801 struct v4l2_subdev *sd = cobalt->streams[i].sd; cobalt_remove()
810 cobalt_i2c_exit(cobalt); cobalt_remove()
811 cobalt_free_msi(cobalt, pci_dev); cobalt_remove()
812 cobalt_s_bit_sysctrl(cobalt, COBALT_SYS_CTRL_HSMA_TX_ENABLE_BIT, 0); cobalt_remove()
813 cobalt_pci_iounmap(cobalt, pci_dev); cobalt_remove()
814 pci_release_regions(cobalt->pci_dev); cobalt_remove()
815 pci_disable_device(cobalt->pci_dev); cobalt_remove()
816 destroy_workqueue(cobalt->irq_work_queues); cobalt_remove()
818 cobalt_info("removed cobalt card\n"); cobalt_remove()
821 vb2_dma_sg_cleanup_ctx(cobalt->alloc_ctx); cobalt_remove()
822 kfree(cobalt); cobalt_remove()
827 .name = "cobalt",
H A Dcobalt-irq.c2 * cobalt interrupt handling
23 #include "cobalt-driver.h"
24 #include "cobalt-irq.h"
25 #include "cobalt-omnitek.h"
29 struct cobalt *cobalt = s->cobalt; cobalt_dma_stream_queue_handler() local
32 COBALT_CVI_FREEWHEEL(s->cobalt, rx); cobalt_dma_stream_queue_handler()
34 COBALT_CVI_VMR(s->cobalt, rx); cobalt_dma_stream_queue_handler()
36 COBALT_CVI(s->cobalt, rx); cobalt_dma_stream_queue_handler()
38 COBALT_CVI_CLK_LOSS(s->cobalt, rx); cobalt_dma_stream_queue_handler()
148 struct cobalt *cobalt = (struct cobalt *)dev_id; cobalt_irq_handler() local
150 cobalt_read_bar0(cobalt, DMA_INTERRUPT_STATUS_REG) & 0xffff; cobalt_irq_handler()
151 u32 mask = cobalt_read_bar1(cobalt, COBALT_SYS_STAT_MASK); cobalt_irq_handler()
152 u32 edge = cobalt_read_bar1(cobalt, COBALT_SYS_STAT_EDGE); cobalt_irq_handler()
156 cobalt_write_bar0(cobalt, DMA_INTERRUPT_STATUS_REG, dma_interrupt); cobalt_irq_handler()
157 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_MASK, mask & ~edge); cobalt_irq_handler()
158 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_EDGE, edge); cobalt_irq_handler()
161 struct cobalt_stream *s = &cobalt->streams[i]; cobalt_irq_handler()
165 cobalt->irq_dma[i]++; cobalt_irq_handler()
171 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_MASK, cobalt_irq_handler()
181 cobalt->irq_full_fifo++; cobalt_irq_handler()
185 queue_work(cobalt->irq_work_queues, &cobalt->irq_work_queue); cobalt_irq_handler()
193 cobalt->irq_adv1++; cobalt_irq_handler()
199 cobalt->irq_adv2++; cobalt_irq_handler()
201 cobalt->irq_advout++; cobalt_irq_handler()
203 cobalt->irq_dma_tot++; cobalt_irq_handler()
205 cobalt->irq_none++; cobalt_irq_handler()
206 dma_interrupt = cobalt_read_bar0(cobalt, DMA_INTERRUPT_STATUS_REG); cobalt_irq_handler()
213 struct cobalt *cobalt = cobalt_irq_work_handler() local
214 container_of(work, struct cobalt, irq_work_queue); cobalt_irq_work_handler()
218 struct cobalt_stream *s = &cobalt->streams[i]; cobalt_irq_work_handler()
223 v4l2_subdev_call(cobalt->streams[i].sd, core, cobalt_irq_work_handler()
225 mask = cobalt_read_bar1(cobalt, COBALT_SYS_STAT_MASK); cobalt_irq_work_handler()
226 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_MASK, cobalt_irq_work_handler()
232 void cobalt_irq_log_status(struct cobalt *cobalt) cobalt_irq_log_status() argument
238 cobalt->irq_adv1, cobalt->irq_adv2, cobalt->irq_advout, cobalt_irq_log_status()
239 cobalt->irq_none, cobalt->irq_full_fifo); cobalt_irq_log_status()
240 cobalt_info("irq: dma_tot=%u (", cobalt->irq_dma_tot); cobalt_irq_log_status()
242 pr_cont("%s%u", i ? "/" : "", cobalt->irq_dma[i]); cobalt_irq_log_status()
244 cobalt->irq_dma_tot = cobalt->irq_adv1 = cobalt->irq_adv2 = 0; cobalt_irq_log_status()
245 cobalt->irq_advout = cobalt->irq_none = cobalt->irq_full_fifo = 0; cobalt_irq_log_status()
246 memset(cobalt->irq_dma, 0, sizeof(cobalt->irq_dma)); cobalt_irq_log_status()
248 mask = cobalt_read_bar1(cobalt, COBALT_SYS_STAT_MASK); cobalt_irq_log_status()
249 cobalt_write_bar1(cobalt, COBALT_SYS_STAT_MASK, cobalt_irq_log_status()
H A Dcobalt-cpld.c23 #include "cobalt-cpld.h"
27 static u16 cpld_read(struct cobalt *cobalt, u32 offset) cpld_read() argument
29 return cobalt_bus_read32(cobalt->bar1, ADRS(offset)); cpld_read()
32 static void cpld_write(struct cobalt *cobalt, u32 offset, u16 val) cpld_write() argument
34 return cobalt_bus_write32(cobalt->bar1, ADRS(offset), val); cpld_write()
37 static void cpld_info_ver3(struct cobalt *cobalt) cpld_info_ver3() argument
44 cpld_read(cobalt, 0)); cpld_info_ver3()
47 cpld_read(cobalt, 0x04)); cpld_info_ver3()
50 cpld_read(cobalt, 0x08)); cpld_info_ver3()
52 cpld_read(cobalt, 0x0c)); cpld_info_ver3()
54 cpld_read(cobalt, 0x10)); cpld_info_ver3()
56 cpld_read(cobalt, 0x14)); cpld_info_ver3()
58 cpld_read(cobalt, 0x18)); cpld_info_ver3()
60 cpld_read(cobalt, 0x1c)); cpld_info_ver3()
62 cpld_read(cobalt, 0x20)); cpld_info_ver3()
64 cpld_read(cobalt, 0x24)); cpld_info_ver3()
67 cpld_read(cobalt, 0x28)); cpld_info_ver3()
70 cpld_read(cobalt, 0x2c)); cpld_info_ver3()
72 cpld_read(cobalt, 0x30)); cpld_info_ver3()
75 cpld_read(cobalt, 0x34) / 4); cpld_info_ver3()
77 cpld_read(cobalt, 0x38) / 4); cpld_info_ver3()
78 rd = cpld_read(cobalt, 0x3c); cpld_info_ver3()
81 rd = cpld_read(cobalt, 0x40); cpld_info_ver3()
84 rd = cpld_read(cobalt, 0x44); cpld_info_ver3()
87 rd = cpld_read(cobalt, 0x48); cpld_info_ver3()
90 rd = cpld_read(cobalt, 0x4c); cpld_info_ver3()
93 rd = cpld_read(cobalt, 0x50); cpld_info_ver3()
96 rd = cpld_read(cobalt, 0x54); cpld_info_ver3()
101 void cobalt_cpld_status(struct cobalt *cobalt) cobalt_cpld_status() argument
103 u32 rev = cpld_read(cobalt, 0x30); cobalt_cpld_status()
109 cpld_info_ver3(cobalt); cobalt_cpld_status()
240 bool cobalt_cpld_set_freq(struct cobalt *cobalt, unsigned f_out) cobalt_cpld_set_freq() argument
275 clock_ctrl = cpld_read(cobalt, SI570_CLOCK_CTRL); cobalt_cpld_set_freq()
298 cpld_write(cobalt, SI570_CLOCK_CTRL, cobalt_cpld_set_freq()
302 cpld_write(cobalt, SI570_REG7, regs[0]); cobalt_cpld_set_freq()
303 cpld_write(cobalt, SI570_REG8, regs[1]); cobalt_cpld_set_freq()
304 cpld_write(cobalt, SI570_REG9, regs[2]); cobalt_cpld_set_freq()
305 cpld_write(cobalt, SI570_REG10, regs[3]); cobalt_cpld_set_freq()
306 cpld_write(cobalt, SI570_REG11, regs[4]); cobalt_cpld_set_freq()
307 cpld_write(cobalt, SI570_REG12, regs[5]); cobalt_cpld_set_freq()
308 cpld_write(cobalt, SI570_CLOCK_CTRL, cobalt_cpld_set_freq()
312 cpld_write(cobalt, SI570_CLOCK_CTRL, cobalt_cpld_set_freq()
316 read_regs[0] = cpld_read(cobalt, SI570_REG7); cobalt_cpld_set_freq()
317 read_regs[1] = cpld_read(cobalt, SI570_REG8); cobalt_cpld_set_freq()
318 read_regs[2] = cpld_read(cobalt, SI570_REG9); cobalt_cpld_set_freq()
319 read_regs[3] = cpld_read(cobalt, SI570_REG10); cobalt_cpld_set_freq()
320 read_regs[4] = cpld_read(cobalt, SI570_REG11); cobalt_cpld_set_freq()
321 read_regs[5] = cpld_read(cobalt, SI570_REG12); cobalt_cpld_set_freq()
322 cpld_write(cobalt, SI570_CLOCK_CTRL, cobalt_cpld_set_freq()
327 cpld_write(cobalt, SI570_CLOCK_CTRL, cobalt_cpld_set_freq()
H A Dcobalt-driver.h2 * cobalt driver internal defines and structures
52 /* Number of cobalt device nodes. */
56 /* Number of cobalt device streams. */
135 #define COBALT_CVI(cobalt, c) \
136 (cobalt->bar1 + COBALT_VID_BASE + (c) * COBALT_VID_SIZE)
137 #define COBALT_CVI_VMR(cobalt, c) \
138 (cobalt->bar1 + COBALT_VID_BASE + (c) * COBALT_VID_SIZE + 0x100)
139 #define COBALT_CVI_EVCNT(cobalt, c) \
140 (cobalt->bar1 + COBALT_VID_BASE + (c) * COBALT_VID_SIZE + 0x200)
141 #define COBALT_CVI_FREEWHEEL(cobalt, c) \
142 (cobalt->bar1 + COBALT_VID_BASE + (c) * COBALT_VID_SIZE + 0x300)
143 #define COBALT_CVI_CLK_LOSS(cobalt, c) \
144 (cobalt->bar1 + COBALT_VID_BASE + (c) * COBALT_VID_SIZE + 0x400)
145 #define COBALT_CVI_PACKER(cobalt, c) \
146 (cobalt->bar1 + COBALT_VID_BASE + (c) * COBALT_VID_SIZE + 0x500)
148 #define COBALT_TX_BASE(cobalt) (cobalt->bar1 + COBALT_VID_BASE + 0x5000)
169 #define cobalt_err(fmt, arg...) v4l2_err(&cobalt->v4l2_dev, fmt, ## arg)
170 #define cobalt_warn(fmt, arg...) v4l2_warn(&cobalt->v4l2_dev, fmt, ## arg)
171 #define cobalt_info(fmt, arg...) v4l2_info(&cobalt->v4l2_dev, fmt, ## arg)
173 v4l2_dbg(level, cobalt_debug, &cobalt->v4l2_dev, fmt, ## arg)
175 struct cobalt;
180 struct cobalt *cobalt; member in struct:cobalt_i2c_data
254 struct cobalt *cobalt; member in struct:cobalt_stream
260 /* Struct to hold info about cobalt cards */
261 struct cobalt { struct
304 static inline struct cobalt *to_cobalt(struct v4l2_device *v4l2_dev) to_cobalt()
306 return container_of(v4l2_dev, struct cobalt, v4l2_dev); to_cobalt()
309 static inline void cobalt_write_bar0(struct cobalt *cobalt, u32 reg, u32 val) cobalt_write_bar0() argument
311 iowrite32(val, cobalt->bar0 + reg); cobalt_write_bar0()
314 static inline u32 cobalt_read_bar0(struct cobalt *cobalt, u32 reg) cobalt_read_bar0() argument
316 return ioread32(cobalt->bar0 + reg); cobalt_read_bar0()
319 static inline void cobalt_write_bar1(struct cobalt *cobalt, u32 reg, u32 val) cobalt_write_bar1() argument
321 iowrite32(val, cobalt->bar1 + reg); cobalt_write_bar1()
324 static inline u32 cobalt_read_bar1(struct cobalt *cobalt, u32 reg) cobalt_read_bar1() argument
326 return ioread32(cobalt->bar1 + reg); cobalt_read_bar1()
329 static inline u32 cobalt_g_sysctrl(struct cobalt *cobalt) cobalt_g_sysctrl() argument
331 return cobalt_read_bar1(cobalt, COBALT_SYS_CTRL_BASE); cobalt_g_sysctrl()
334 static inline void cobalt_s_bit_sysctrl(struct cobalt *cobalt, cobalt_s_bit_sysctrl() argument
337 u32 ctrl = cobalt_read_bar1(cobalt, COBALT_SYS_CTRL_BASE); cobalt_s_bit_sysctrl()
339 cobalt_write_bar1(cobalt, COBALT_SYS_CTRL_BASE, cobalt_s_bit_sysctrl()
343 static inline u32 cobalt_g_sysstat(struct cobalt *cobalt) cobalt_g_sysstat() argument
345 return cobalt_read_bar1(cobalt, COBALT_SYS_STAT_BASE); cobalt_g_sysstat()
380 void cobalt_pcie_status_show(struct cobalt *cobalt);
H A Dcobalt-cpld.h24 #include "cobalt-driver.h"
26 void cobalt_cpld_status(struct cobalt *cobalt);
27 bool cobalt_cpld_set_freq(struct cobalt *cobalt, unsigned freq);
H A Dcobalt-flash.h24 #include "cobalt-driver.h"
26 int cobalt_flash_probe(struct cobalt *cobalt);
27 void cobalt_flash_remove(struct cobalt *cobalt);
H A Dcobalt-i2c.c2 * cobalt I2C functions
23 #include "cobalt-driver.h"
24 #include "cobalt-i2c.h"
94 cobalt_i2c_regs(struct cobalt *cobalt, unsigned idx) cobalt_i2c_regs() argument
100 (cobalt->bar1 + COBALT_I2C_0_BASE); cobalt_i2c_regs()
103 (cobalt->bar1 + COBALT_I2C_1_BASE); cobalt_i2c_regs()
106 (cobalt->bar1 + COBALT_I2C_2_BASE); cobalt_i2c_regs()
109 (cobalt->bar1 + COBALT_I2C_3_BASE); cobalt_i2c_regs()
112 (cobalt->bar1 + COBALT_I2C_HSMA_BASE); cobalt_i2c_regs()
305 .name = "cobalt i2c driver",
317 int cobalt_i2c_init(struct cobalt *cobalt) cobalt_i2c_init() argument
331 cobalt_i2c_regs(cobalt, i); cobalt_i2c_init()
332 struct i2c_adapter *adap = &cobalt->i2c_adap[i]; cobalt_i2c_init()
361 cobalt->i2c_data[i].cobalt = cobalt; cobalt_i2c_init()
362 cobalt->i2c_data[i].regs = regs; cobalt_i2c_init()
365 adap->algo_data = &cobalt->i2c_data[i]; cobalt_i2c_init()
368 " #%d-%d", cobalt->instance, i); cobalt_i2c_init()
369 i2c_set_adapdata(adap, &cobalt->v4l2_dev); cobalt_i2c_init()
370 adap->dev.parent = &cobalt->pci_dev->dev; cobalt_i2c_init()
378 i2c_del_adapter(&cobalt->i2c_adap[i]); cobalt_i2c_init()
386 void cobalt_i2c_exit(struct cobalt *cobalt) cobalt_i2c_exit() argument
393 cobalt_err("unregistered bus %s\n", cobalt->i2c_adap[i].name); cobalt_i2c_exit()
394 i2c_del_adapter(&cobalt->i2c_adap[i]); cobalt_i2c_exit()
H A Dcobalt-flash.c26 #include "cobalt-flash.h"
31 .name = "cobalt-flash",
97 int cobalt_flash_probe(struct cobalt *cobalt) cobalt_flash_probe() argument
103 map->virt = cobalt->bar1; cobalt_flash_probe()
110 cobalt->mtd = mtd; cobalt_flash_probe()
117 mtd->dev.parent = &cobalt->pci_dev->dev; cobalt_flash_probe()
122 void cobalt_flash_remove(struct cobalt *cobalt) cobalt_flash_remove() argument
124 if (cobalt->mtd) { cobalt_flash_remove()
125 mtd_device_unregister(cobalt->mtd); cobalt_flash_remove()
126 map_destroy(cobalt->mtd); cobalt_flash_remove()
H A Dcobalt-omnitek.c26 #include "cobalt-driver.h"
27 #include "cobalt-omnitek.h"
54 #define BASE (cobalt->bar0)
77 static void show_dma_capability(struct cobalt *cobalt) show_dma_capability() argument
110 struct cobalt *cobalt = s->cobalt; omni_sg_dma_start() local
119 struct cobalt *cobalt = s->cobalt; is_dma_done() local
129 struct cobalt *cobalt = s->cobalt; omni_sg_dma_abort_channel() local
135 int omni_sg_dma_init(struct cobalt *cobalt) omni_sg_dma_init() argument
140 cobalt->first_fifo_channel = 0; omni_sg_dma_init()
141 cobalt->dma_channels = capa & 0xf; omni_sg_dma_init()
143 cobalt->pci_32_bit = false; omni_sg_dma_init()
145 cobalt->pci_32_bit = true; omni_sg_dma_init()
147 for (i = 0; i < cobalt->dma_channels; i++) { omni_sg_dma_init()
155 cobalt->first_fifo_channel++; omni_sg_dma_init()
157 show_dma_capability(cobalt); omni_sg_dma_init()
161 int descriptor_list_create(struct cobalt *cobalt, descriptor_list_create() argument
188 if (cobalt->pci_32_bit) { descriptor_list_create()
H A Dcobalt-alsa-main.c2 * ALSA interface to cobalt PCM capture streams
33 #include "cobalt-driver.h"
34 #include "cobalt-alsa.h"
35 #include "cobalt-alsa-pcm.h"
76 struct cobalt *cobalt = s->cobalt; snd_cobalt_card_set_names() local
80 strlcpy(sc->driver, "cobalt", sizeof(sc->driver)); snd_cobalt_card_set_names()
83 snprintf(sc->shortname, sizeof(sc->shortname), "cobalt-%d-%d", snd_cobalt_card_set_names()
84 cobalt->instance, s->video_channel); snd_cobalt_card_set_names()
89 cobalt->instance, s->video_channel); snd_cobalt_card_set_names()
96 struct cobalt *cobalt = s->cobalt; cobalt_alsa_init() local
104 /* This is a no-op for us. We'll use the cobalt->instance */ cobalt_alsa_init()
107 ret = snd_card_new(&cobalt->pci_dev->dev, SNDRV_DEFAULT_IDX1, cobalt_alsa_init()
H A Dcobalt-v4l2.c2 * cobalt V4L2 API
35 #include "cobalt-alsa.h"
36 #include "cobalt-cpld.h"
37 #include "cobalt-driver.h"
38 #include "cobalt-v4l2.h"
39 #include "cobalt-irq.h"
40 #include "cobalt-omnitek.h"
65 alloc_ctxs[0] = s->cobalt->alloc_ctx; cobalt_queue_setup()
72 struct cobalt *cobalt = s->cobalt; cobalt_buf_init() local
91 desc->dev = &cobalt->pci_dev->dev; cobalt_buf_init()
97 ret = descriptor_list_create(cobalt, sg_desc->sgl, cobalt_buf_init()
160 struct cobalt *cobalt = s->cobalt; cobalt_enable_output() local
163 COBALT_TX_BASE(cobalt); cobalt_enable_output()
170 if (!cobalt_cpld_set_freq(cobalt, bt->pixelclock)) { cobalt_enable_output()
215 struct cobalt *cobalt = s->cobalt; cobalt_enable_input() local
234 packer = COBALT_CVI_PACKER(cobalt, ch); cobalt_enable_input()
265 struct cobalt *cobalt = s->cobalt; cobalt_dma_start_streaming() local
268 COBALT_CVI_EVCNT(cobalt, rx); cobalt_dma_start_streaming()
278 COBALT_TX_BASE(cobalt); cobalt_dma_start_streaming()
296 struct cobalt *cobalt = s->cobalt; cobalt_start_streaming() local
301 struct m00389_cvi_regmap __iomem *cvi = COBALT_CVI(cobalt, rx); cobalt_start_streaming()
302 struct m00460_evcnt_regmap __iomem *evcnt = COBALT_CVI_EVCNT(cobalt, rx); cobalt_start_streaming()
317 fw = COBALT_CVI_FREEWHEEL(cobalt, rx); cobalt_start_streaming()
318 vmr = COBALT_CVI_VMR(cobalt, rx); cobalt_start_streaming()
319 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx); cobalt_start_streaming()
362 struct cobalt *cobalt = s->cobalt; cobalt_dma_stop_streaming() local
370 COBALT_CVI_EVCNT(cobalt, rx); cobalt_dma_stop_streaming()
376 COBALT_TX_BASE(cobalt); cobalt_dma_stop_streaming()
398 cobalt_write_bar0(cobalt, DMA_INTERRUPT_STATUS_REG, cobalt_dma_stop_streaming()
405 struct cobalt *cobalt = s->cobalt; cobalt_stop_streaming() local
428 fw = COBALT_CVI_FREEWHEEL(cobalt, rx); cobalt_stop_streaming()
429 vmr = COBALT_CVI_VMR(cobalt, rx); cobalt_stop_streaming()
430 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx); cobalt_stop_streaming()
452 static int cobalt_cobaltc(struct cobalt *cobalt, unsigned int cmd, void *arg) cobalt_cobaltc() argument
455 void __iomem *adrs = cobalt->bar1 + regs->reg; cobalt_cobaltc()
474 struct cobalt *cobalt = s->cobalt; cobalt_g_register() local
476 return cobalt_cobaltc(cobalt, VIDIOC_DBG_G_REGISTER, reg); cobalt_g_register()
483 struct cobalt *cobalt = s->cobalt; cobalt_s_register() local
485 return cobalt_cobaltc(cobalt, VIDIOC_DBG_S_REGISTER, cobalt_s_register()
494 struct cobalt *cobalt = s->cobalt; cobalt_querycap() local
496 strlcpy(vcap->driver, "cobalt", sizeof(vcap->driver)); cobalt_querycap()
497 strlcpy(vcap->card, "cobalt", sizeof(vcap->card)); cobalt_querycap()
499 "PCIe:%s", pci_name(cobalt->pci_dev)); cobalt_querycap()
507 if (cobalt->have_hsma_tx) cobalt_querycap()
520 struct cobalt *cobalt = s->cobalt; cobalt_video_input_status_show() local
524 cvi = COBALT_CVI(cobalt, rx); cobalt_video_input_status_show()
525 vmr = COBALT_CVI_VMR(cobalt, rx); cobalt_video_input_status_show()
526 fw = COBALT_CVI_FREEWHEEL(cobalt, rx); cobalt_video_input_status_show()
527 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx); cobalt_video_input_status_show()
528 packer = COBALT_CVI_PACKER(cobalt, rx); cobalt_video_input_status_show()
593 struct cobalt *cobalt = s->cobalt; cobalt_log_status() local
595 COBALT_TX_BASE(cobalt); cobalt_log_status()
598 cobalt_info("%s", cobalt->hdl_info); cobalt_log_status()
600 cobalt_g_sysctrl(cobalt), cobalt_log_status()
601 cobalt_g_sysstat(cobalt)); cobalt_log_status()
604 cobalt_pcie_status_show(cobalt); cobalt_log_status()
605 cobalt_cpld_status(cobalt); cobalt_log_status()
606 cobalt_irq_log_status(cobalt); cobalt_log_status()
1166 static int cobalt_node_register(struct cobalt *cobalt, int node) cobalt_node_register() argument
1170 struct cobalt_stream *s = cobalt->streams + node; cobalt_node_register()
1179 "%s-%d", cobalt->v4l2_dev.name, node); cobalt_node_register()
1200 vdev->v4l2_dev = &cobalt->v4l2_dev; cobalt_node_register()
1251 int cobalt_nodes_register(struct cobalt *cobalt) cobalt_nodes_register() argument
1257 ret = cobalt_node_register(cobalt, node); cobalt_nodes_register()
1265 void cobalt_nodes_unregister(struct cobalt *cobalt) cobalt_nodes_unregister() argument
1271 struct cobalt_stream *s = cobalt->streams + node; cobalt_nodes_unregister()
H A Dcobalt-omnitek.h25 #include "cobalt-driver.h"
41 int omni_sg_dma_init(struct cobalt *cobalt);
46 int descriptor_list_create(struct cobalt *cobalt,
H A Dcobalt-alsa-pcm.c3 * ALSA interface to cobalt PCM capture streams
32 #include "cobalt-driver.h"
33 #include "cobalt-alsa.h"
34 #include "cobalt-alsa-pcm.h"
43 pr_info("cobalt-alsa-pcm %s: " fmt, __func__, ##arg); \
123 dprintk("cobalt alsa announce ptr=%p data=%p num_bytes=%zd\n", cobsc, cobalt_alsa_announce_pcm_data()
370 dprintk("cobalt alsa pb ptr=%p data=%p samples=%zd\n", cobsc, cobalt_alsa_pb_pcm_data()
542 struct cobalt *cobalt = s->cobalt; snd_cobalt_pcm_create() local
548 cobalt_s_bit_sysctrl(cobalt, snd_cobalt_pcm_create()
552 cobalt_s_bit_sysctrl(cobalt, snd_cobalt_pcm_create()
572 strlcpy(sp->name, "cobalt", sizeof(sp->name)); snd_cobalt_pcm_create()
574 cobalt_s_bit_sysctrl(cobalt, snd_cobalt_pcm_create()
577 cobalt_s_bit_sysctrl(cobalt, snd_cobalt_pcm_create()
596 strlcpy(sp->name, "cobalt", sizeof(sp->name)); snd_cobalt_pcm_create()
H A Dcobalt-alsa.h2 * ALSA interface to cobalt PCM capture streams
/linux-4.4.14/drivers/leds/
H A Dleds-cobalt-qube.c57 .name = "cobalt-qube-leds",
66 MODULE_ALIAS("platform:cobalt-qube-leds");
H A Dleds-rb532.c6 * Based on leds-cobalt-qube.c by Florian Fainelly and
H A Dleds-cobalt-raq.c114 .name = "cobalt-raq-leds",
/linux-4.4.14/arch/mips/cobalt/
H A Dled.c25 #include <cobalt.h>
40 pdev = platform_device_alloc("cobalt-qube-leds", -1); cobalt_led_add()
42 pdev = platform_device_alloc("cobalt-raq-leds", -1); cobalt_led_add()
H A Dreset.c18 #include <cobalt.h>
H A Dlcd.c36 pdev = platform_device_alloc("cobalt-lcd", -1); cobalt_lcd_add()
H A Dserial.c26 #include <cobalt.h>
H A Dsetup.c23 #include <cobalt.h>
/linux-4.4.14/arch/mips/mti-sead3/
H A Dsead3-lcd.c23 pdev = platform_device_alloc("cobalt-lcd", -1); sead3_lcd_add()
/linux-4.4.14/drivers/watchdog/
H A Dalim7101_wdt.c18 * found on very old cobalt hardware.
71 "Use the gpio watchdog (required by old cobalt boards).");
385 pr_info("Detected old alim7101 revision 'a1d'. If this is a cobalt board, set the 'use_gpio' module parameter.\n"); alim7101_wdt_init()
/linux-4.4.14/drivers/input/misc/
H A Dcobalt_btns.c98 input->phys = "cobalt/input0"; cobalt_buttons_probe()
/linux-4.4.14/drivers/video/fbdev/
H A Dcobalt_lcdfb.c171 .id = "cobalt-lcd",
393 .name = "cobalt-lcd",
/linux-4.4.14/arch/mips/pci/
H A Dfixup-cobalt.c19 #include <cobalt.h>
/linux-4.4.14/drivers/tty/serial/
H A Dpmac_zilog.c1466 if (of_device_is_compatible(np, "cobalt")) pmz_init_port()
/linux-4.4.14/arch/powerpc/platforms/powermac/
H A Dfeature.c2751 else if (of_device_is_compatible(np, "cobalt")) initial_serial_shutdown()

Completed in 619 milliseconds