Commit dcae5dac authored by Hans Verkuil's avatar Hans Verkuil Committed by Mauro Carvalho Chehab
Browse files

[media] solo6x10: sync to latest code from Bluecherry's git repo 

Synced to commit e9815ac5503ae60cfbf6ff8037035de8f62e2846 from
branch next in git repository https://github.com/bluecherrydvr/solo6x10.git


Only removed some code under #if LINUX_VERSION_CODE < some-kernel-version,
renamed the driver back to solo6x10 from solo6x10-edge, removed the
unnecessary compat.h header and kept the slab.h includes.
Otherwise the code is identical.

Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: default avatarIsmael Luceno <ismael.luceno@corp.bluecherry.net>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent c535cc6c

drivers/staging/media/solo6x10/Makefile

+1 −1
Original line number Diff line number Diff line 
solo6x10-y := core.o i2c.o p2m.o v4l2.o tw28.o gpio.o disp.o enc.o v4l2-enc.o g723.o

solo6x10-y := core.o i2c.o p2m.o v4l2.o tw28.o gpio.o disp.o enc.o v4l2-enc.o g723.o eeprom.o



obj-$(CONFIG_SOLO6X10) += solo6x10.o

drivers/staging/media/solo6x10/TODO

+12 −21
Original line number Diff line number Diff line 
TODO (staging => main):



	* Motion detection flags need to be moved to v4l2

	* Some private CIDs need to be moved to v4l2



TODO (general):



	* encoder on/off controls

	* mpeg cid bitrate mode (vbr/cbr)

	* mpeg cid bitrate/bitrate-peak

	* mpeg encode of user data

	* mpeg decode of user data

	* switch between 4 frames/irq to 1 when using mjpeg (and then back

	  when not)

	* implement a CID control for motion areas/thresholds

	* implement CID controls for mozaic areas

	* allow for higher level of interval (for < 1 fps)

	* sound:

- batch up desc requests for more efficient use of p2m?

- encoder on/off controls

- mpeg cid bitrate mode (vbr/cbr)

- mpeg cid bitrate/bitrate-peak

- mpeg encode of user data

- mpeg decode of user data

- implement CID controls for mozaic areas



- sound

 - implement playback via external sound jack

 - implement loopback of external sound jack with incoming audio?

	  - implement pause/resume

 - implement pause/resume (make use of in bc-server)



Please send patches to the linux media list <linux-media@vger.kernel.org> and

Cc Ismael Luceno <ismael.luceno@corp.bluecherry.net>.

drivers/staging/media/solo6x10/core.c

+489 −87
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 Bluecherry, LLC www.bluecherrydvr.com

 * Copyright (C) 2010 Ben Collins <bcollins@bluecherry.net>

 * Copyright (C) 2010-2013 Bluecherry, LLC <http://www.bluecherrydvr.com>

 *

 * Original author:

 * Ben Collins <bcollins@ubuntu.com>

 *

 * Additional work by:

 * John Brooks <john.brooks@bluecherry.net>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by
@@ -21,29 +26,79 @@ 
#include <linux/module.h>

#include <linux/pci.h>

#include <linux/interrupt.h>

#include <linux/slab.h>

#include <linux/videodev2.h>

#include <linux/delay.h>

#include <linux/sysfs.h>

#include <linux/ktime.h>

#include <linux/slab.h>



#include "solo6x10.h"

#include "tw28.h"



MODULE_DESCRIPTION("Softlogic 6x10 MP4/H.264 Encoder/Decoder V4L2/ALSA Driver");

MODULE_AUTHOR("Ben Collins <bcollins@bluecherry.net>");

MODULE_DESCRIPTION("Softlogic 6x10 MPEG4/H.264/G.723 CODEC V4L2/ALSA Driver");

MODULE_AUTHOR("Bluecherry <maintainers@bluecherrydvr.com>");

MODULE_VERSION(SOLO6X10_VERSION);

MODULE_LICENSE("GPL");



void solo_irq_on(struct solo_dev *solo_dev, u32 mask)

unsigned video_nr = -1;

module_param(video_nr, uint, 0644);

MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect (default)");



static int full_eeprom; /* default is only top 64B */

module_param(full_eeprom, uint, 0644);

MODULE_PARM_DESC(full_eeprom, "Allow access to full 128B EEPROM (dangerous)");





static void solo_set_time(struct solo_dev *solo_dev)

{

	solo_dev->irq_mask |= mask;

	solo_reg_write(solo_dev, SOLO_IRQ_ENABLE, solo_dev->irq_mask);

	struct timespec ts;



	ktime_get_ts(&ts);



	solo_reg_write(solo_dev, SOLO_TIMER_SEC, ts.tv_sec);

	solo_reg_write(solo_dev, SOLO_TIMER_USEC, ts.tv_nsec / NSEC_PER_USEC);

}



void solo_irq_off(struct solo_dev *solo_dev, u32 mask)

static void solo_timer_sync(struct solo_dev *solo_dev)

{

	solo_dev->irq_mask &= ~mask;

	solo_reg_write(solo_dev, SOLO_IRQ_ENABLE, solo_dev->irq_mask);

	u32 sec, usec;

	struct timespec ts;

	long diff;



	if (solo_dev->type != SOLO_DEV_6110)

		return;



	if (++solo_dev->time_sync < 60)

		return;



	solo_dev->time_sync = 0;



	sec = solo_reg_read(solo_dev, SOLO_TIMER_SEC);

	usec = solo_reg_read(solo_dev, SOLO_TIMER_USEC);



	ktime_get_ts(&ts);



	diff = (long)ts.tv_sec - (long)sec;

	diff = (diff * 1000000)

		+ ((long)(ts.tv_nsec / NSEC_PER_USEC) - (long)usec);



	if (diff > 1000 || diff < -1000) {

		solo_set_time(solo_dev);

	} else if (diff) {

		long usec_lsb = solo_dev->usec_lsb;



		usec_lsb -= diff / 4;

		if (usec_lsb < 0)

			usec_lsb = 0;

		else if (usec_lsb > 255)

			usec_lsb = 255;



		solo_dev->usec_lsb = usec_lsb;

		solo_reg_write(solo_dev, SOLO_TIMER_USEC_LSB,

			       solo_dev->usec_lsb);

	}

}



/* XXX We should check the return value of the sub-device ISR's */

static irqreturn_t solo_isr(int irq, void *data)

{

	struct solo_dev *solo_dev = data;
@@ -60,11 +115,8 @@ static irqreturn_t solo_isr(int irq, void *data) 
		status &= solo_dev->irq_mask;

	}



	if (status & SOLO_IRQ_PCI_ERR) {

		u32 err = solo_reg_read(solo_dev, SOLO_PCI_ERR);

		solo_p2m_error_isr(solo_dev, err);

		solo_reg_write(solo_dev, SOLO_IRQ_STAT, SOLO_IRQ_PCI_ERR);

	}

	if (status & SOLO_IRQ_PCI_ERR)

		solo_p2m_error_isr(solo_dev);



	for (i = 0; i < SOLO_NR_P2M; i++)

		if (status & SOLO_IRQ_P2M(i))
@@ -73,12 +125,10 @@ static irqreturn_t solo_isr(int irq, void *data) 
	if (status & SOLO_IRQ_IIC)

		solo_i2c_isr(solo_dev);



	if (status & SOLO_IRQ_VIDEO_IN)

	if (status & SOLO_IRQ_VIDEO_IN) {

		solo_video_in_isr(solo_dev);



	/* Call this first so enc gets detected flag set */

	if (status & SOLO_IRQ_MOTION)

		solo_motion_isr(solo_dev);

		solo_timer_sync(solo_dev);

	}



	if (status & SOLO_IRQ_ENCODER)

		solo_enc_v4l2_isr(solo_dev);
@@ -86,6 +136,9 @@ static irqreturn_t solo_isr(int irq, void *data) 
	if (status & SOLO_IRQ_G723)

		solo_g723_isr(solo_dev);



	/* Clear all interrupts handled */

	solo_reg_write(solo_dev, SOLO_IRQ_STAT, status);



	return IRQ_HANDLED;

}
@@ -96,6 +149,9 @@ static void free_solo_dev(struct solo_dev *solo_dev) 
	if (!solo_dev)

		return;



	if (solo_dev->dev.parent)

		device_unregister(&solo_dev->dev);



	pdev = solo_dev->pdev;



	/* If we never initialized the PCI device, then nothing else
@@ -105,6 +161,7 @@ static void free_solo_dev(struct solo_dev *solo_dev) 
		return;

	}



	if (solo_dev->reg_base) {

		/* Bring down the sub-devices first */

		solo_g723_exit(solo_dev);

		solo_enc_v4l2_exit(solo_dev);
@@ -116,9 +173,9 @@ static void free_solo_dev(struct solo_dev *solo_dev) 
		solo_i2c_exit(solo_dev);



		/* Now cleanup the PCI device */

	if (solo_dev->reg_base) {

		solo_irq_off(solo_dev, ~0);

		pci_iounmap(pdev, solo_dev->reg_base);

		if (pdev->irq)

			free_irq(pdev->irq, solo_dev);

	}
@@ -129,29 +186,346 @@ static void free_solo_dev(struct solo_dev *solo_dev) 
	kfree(solo_dev);

}



static int solo_pci_probe(struct pci_dev *pdev,

				    const struct pci_device_id *id)

static ssize_t eeprom_store(struct device *dev, struct device_attribute *attr,

			    const char *buf, size_t count)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	unsigned short *p = (unsigned short *)buf;

	int i;



	if (count & 0x1)

		dev_warn(dev, "EEPROM Write not aligned (truncating)\n");



	if (!full_eeprom && count > 64) {

		dev_warn(dev, "EEPROM Write truncated to 64 bytes\n");

		count = 64;

	} else if (full_eeprom && count > 128) {

		dev_warn(dev, "EEPROM Write truncated to 128 bytes\n");

		count = 128;

	}



	solo_eeprom_ewen(solo_dev, 1);



	for (i = full_eeprom ? 0 : 32; i < min((int)(full_eeprom ? 64 : 32),

					       (int)(count / 2)); i++)

		solo_eeprom_write(solo_dev, i, cpu_to_be16(p[i]));



	solo_eeprom_ewen(solo_dev, 0);



	return count;

}



static ssize_t eeprom_show(struct device *dev, struct device_attribute *attr,

			   char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	unsigned short *p = (unsigned short *)buf;

	int count = (full_eeprom ? 128 : 64);

	int i;



	for (i = (full_eeprom ? 0 : 32); i < (count / 2); i++)

		p[i] = be16_to_cpu(solo_eeprom_read(solo_dev, i));



	return count;

}



static ssize_t video_type_store(struct device *dev,

				struct device_attribute *attr,

				const char *buf, size_t count)

{

	return -EPERM;

}



static ssize_t video_type_show(struct device *dev,

			       struct device_attribute *attr,

			       char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);



	return sprintf(buf, "%s", solo_dev->video_type ==

		       SOLO_VO_FMT_TYPE_NTSC ? "NTSC" : "PAL");

}



static ssize_t p2m_timeouts_show(struct device *dev,

				 struct device_attribute *attr,

				 char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);



	return sprintf(buf, "%d\n", solo_dev->p2m_timeouts);

}



static ssize_t sdram_size_show(struct device *dev,

			       struct device_attribute *attr,

			       char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);



	return sprintf(buf, "%dMegs\n", solo_dev->sdram_size >> 20);

}



static ssize_t tw28xx_show(struct device *dev,

			   struct device_attribute *attr,

			   char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);



	return sprintf(buf, "tw2815[%d] tw2864[%d] tw2865[%d]\n",

		       hweight32(solo_dev->tw2815),

		       hweight32(solo_dev->tw2864),

		       hweight32(solo_dev->tw2865));

}



static ssize_t input_map_show(struct device *dev,

			      struct device_attribute *attr,

			      char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	unsigned int val;

	char *out = buf;



	val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_0);

	out += sprintf(out, "Channel 0   => Input %d\n", val & 0x1f);

	out += sprintf(out, "Channel 1   => Input %d\n", (val >> 5) & 0x1f);

	out += sprintf(out, "Channel 2   => Input %d\n", (val >> 10) & 0x1f);

	out += sprintf(out, "Channel 3   => Input %d\n", (val >> 15) & 0x1f);

	out += sprintf(out, "Channel 4   => Input %d\n", (val >> 20) & 0x1f);

	out += sprintf(out, "Channel 5   => Input %d\n", (val >> 25) & 0x1f);



	val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_1);

	out += sprintf(out, "Channel 6   => Input %d\n", val & 0x1f);

	out += sprintf(out, "Channel 7   => Input %d\n", (val >> 5) & 0x1f);

	out += sprintf(out, "Channel 8   => Input %d\n", (val >> 10) & 0x1f);

	out += sprintf(out, "Channel 9   => Input %d\n", (val >> 15) & 0x1f);

	out += sprintf(out, "Channel 10  => Input %d\n", (val >> 20) & 0x1f);

	out += sprintf(out, "Channel 11  => Input %d\n", (val >> 25) & 0x1f);



	val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_2);

	out += sprintf(out, "Channel 12  => Input %d\n", val & 0x1f);

	out += sprintf(out, "Channel 13  => Input %d\n", (val >> 5) & 0x1f);

	out += sprintf(out, "Channel 14  => Input %d\n", (val >> 10) & 0x1f);

	out += sprintf(out, "Channel 15  => Input %d\n", (val >> 15) & 0x1f);

	out += sprintf(out, "Spot Output => Input %d\n", (val >> 20) & 0x1f);



	return out - buf;

}



static ssize_t p2m_timeout_store(struct device *dev,

				 struct device_attribute *attr,

				 const char *buf, size_t count)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	unsigned long ms;



	int ret = kstrtoul(buf, 10, &ms);

	if (ret < 0 || ms > 200)

		return -EINVAL;

	solo_dev->p2m_jiffies = msecs_to_jiffies(ms);



	return count;

}



static ssize_t p2m_timeout_show(struct device *dev,

				struct device_attribute *attr,

				char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);



	return sprintf(buf, "%ums\n", jiffies_to_msecs(solo_dev->p2m_jiffies));

}



static ssize_t intervals_show(struct device *dev,

			      struct device_attribute *attr,

			      char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	char *out = buf;

	int fps = solo_dev->fps;

	int i;



	for (i = 0; i < solo_dev->nr_chans; i++) {

		out += sprintf(out, "Channel %d: %d/%d (0x%08x)\n",

			       i, solo_dev->v4l2_enc[i]->interval, fps,

			       solo_reg_read(solo_dev, SOLO_CAP_CH_INTV(i)));

	}



	return out - buf;

}



static ssize_t sdram_offsets_show(struct device *dev,

				  struct device_attribute *attr,

				  char *buf)

{

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	char *out = buf;



	out += sprintf(out, "DISP: 0x%08x @ 0x%08x\n",

		       SOLO_DISP_EXT_ADDR,

		       SOLO_DISP_EXT_SIZE);



	out += sprintf(out, "EOSD: 0x%08x @ 0x%08x (0x%08x * %d)\n",

		       SOLO_EOSD_EXT_ADDR,

		       SOLO_EOSD_EXT_AREA(solo_dev),

		       SOLO_EOSD_EXT_SIZE(solo_dev),

		       SOLO_EOSD_EXT_AREA(solo_dev) /

		       SOLO_EOSD_EXT_SIZE(solo_dev));



	out += sprintf(out, "MOTI: 0x%08x @ 0x%08x\n",

		       SOLO_MOTION_EXT_ADDR(solo_dev),

		       SOLO_MOTION_EXT_SIZE);



	out += sprintf(out, "G723: 0x%08x @ 0x%08x\n",

		       SOLO_G723_EXT_ADDR(solo_dev),

		       SOLO_G723_EXT_SIZE);



	out += sprintf(out, "CAPT: 0x%08x @ 0x%08x (0x%08x * %d)\n",

		       SOLO_CAP_EXT_ADDR(solo_dev),

		       SOLO_CAP_EXT_SIZE(solo_dev),

		       SOLO_CAP_PAGE_SIZE,

		       SOLO_CAP_EXT_SIZE(solo_dev) / SOLO_CAP_PAGE_SIZE);



	out += sprintf(out, "EREF: 0x%08x @ 0x%08x (0x%08x * %d)\n",

		       SOLO_EREF_EXT_ADDR(solo_dev),

		       SOLO_EREF_EXT_AREA(solo_dev),

		       SOLO_EREF_EXT_SIZE,

		       SOLO_EREF_EXT_AREA(solo_dev) / SOLO_EREF_EXT_SIZE);



	out += sprintf(out, "MPEG: 0x%08x @ 0x%08x\n",

		       SOLO_MP4E_EXT_ADDR(solo_dev),

		       SOLO_MP4E_EXT_SIZE(solo_dev));



	out += sprintf(out, "JPEG: 0x%08x @ 0x%08x\n",

		       SOLO_JPEG_EXT_ADDR(solo_dev),

		       SOLO_JPEG_EXT_SIZE(solo_dev));



	return out - buf;

}



static ssize_t sdram_show(struct file *file, struct kobject *kobj,

			  struct bin_attribute *a, char *buf,

			  loff_t off, size_t count)

{

	struct device *dev = container_of(kobj, struct device, kobj);

	struct solo_dev *solo_dev =

		container_of(dev, struct solo_dev, dev);

	const int size = solo_dev->sdram_size;



	if (off >= size)

		return 0;



	if (off + count > size)

		count = size - off;



	if (solo_p2m_dma(solo_dev, 0, buf, off, count, 0, 0))

		return -EIO;



	return count;

}



static const struct device_attribute solo_dev_attrs[] = {

	__ATTR(eeprom, 0640, eeprom_show, eeprom_store),

	__ATTR(video_type, 0644, video_type_show, video_type_store),

	__ATTR(p2m_timeout, 0644, p2m_timeout_show, p2m_timeout_store),

	__ATTR_RO(p2m_timeouts),

	__ATTR_RO(sdram_size),

	__ATTR_RO(tw28xx),

	__ATTR_RO(input_map),

	__ATTR_RO(intervals),

	__ATTR_RO(sdram_offsets),

};



static void solo_device_release(struct device *dev)

{

	/* Do nothing */

}



static int solo_sysfs_init(struct solo_dev *solo_dev)

{

	struct bin_attribute *sdram_attr = &solo_dev->sdram_attr;

	struct device *dev = &solo_dev->dev;

	const char *driver;

	int i;



	if (solo_dev->type == SOLO_DEV_6110)

		driver = "solo6110";

	else

		driver = "solo6010";



	dev->release = solo_device_release;

	dev->parent = &solo_dev->pdev->dev;

	set_dev_node(dev, dev_to_node(&solo_dev->pdev->dev));

	dev_set_name(dev, "%s-%d-%d", driver, solo_dev->vfd->num,

		     solo_dev->nr_chans);



	if (device_register(dev)) {

		dev->parent = NULL;

		return -ENOMEM;

	}



	for (i = 0; i < ARRAY_SIZE(solo_dev_attrs); i++) {

		if (device_create_file(dev, &solo_dev_attrs[i])) {

			device_unregister(dev);

			return -ENOMEM;

		}

	}



	sdram_attr->attr.name = "sdram";

	sdram_attr->attr.mode = 0440;

	sdram_attr->read = sdram_show;

	sdram_attr->size = solo_dev->sdram_size;



	if (device_create_bin_file(dev, sdram_attr)) {

		device_unregister(dev);

		return -ENOMEM;

	}



	return 0;

}



static int solo_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)

{

	struct solo_dev *solo_dev;

	int ret;

	int sdram;

	u8 chip_id;

	u32 reg;



	solo_dev = kzalloc(sizeof(*solo_dev), GFP_KERNEL);

	if (solo_dev == NULL)

		return -ENOMEM;



	if (id->driver_data == SOLO_DEV_6010)

		dev_info(&pdev->dev, "Probing Softlogic 6010\n");

	else

		dev_info(&pdev->dev, "Probing Softlogic 6110\n");



	solo_dev->type = id->driver_data;

	solo_dev->pdev = pdev;

	spin_lock_init(&solo_dev->reg_io_lock);

	pci_set_drvdata(pdev, solo_dev);



	/* Only for during init */

	solo_dev->p2m_jiffies = msecs_to_jiffies(100);



	ret = pci_enable_device(pdev);

	if (ret)

		goto fail_probe;



	pci_set_master(pdev);



	/* RETRY/TRDY Timeout disabled */

	pci_write_config_byte(pdev, 0x40, 0x00);

	pci_write_config_byte(pdev, 0x41, 0x00);



	ret = pci_request_regions(pdev, SOLO6X10_NAME);

	if (ret)

		goto fail_probe;
@@ -174,52 +548,50 @@ static int solo_pci_probe(struct pci_dev *pdev, 
		solo_dev->nr_ext = 2;

		break;

	default:

		dev_warn(&pdev->dev, "Invalid chip_id 0x%02x, "

			 "defaulting to 4 channels\n",

		dev_warn(&pdev->dev, "Invalid chip_id 0x%02x, assuming 4 ch\n",

			 chip_id);

	case 5:

		solo_dev->nr_chans = 4;

		solo_dev->nr_ext = 1;

	}



	solo_dev->flags = id->driver_data;



	/* Disable all interrupts to start */

	solo_irq_off(solo_dev, ~0);



	reg = SOLO_SYS_CFG_SDRAM64BIT;

	/* Initial global settings */

	if (!(solo_dev->flags & FLAGS_6110))

		reg |= SOLO6010_SYS_CFG_INPUTDIV(25) |

			SOLO6010_SYS_CFG_FEEDBACKDIV((SOLO_CLOCK_MHZ * 2) - 2) |

			SOLO6010_SYS_CFG_OUTDIV(3);

	solo_reg_write(solo_dev, SOLO_SYS_CFG, reg);



	if (solo_dev->flags & FLAGS_6110) {

		u32 sys_clock_MHz = SOLO_CLOCK_MHZ;

		u32 pll_DIVQ;

		u32 pll_DIVF;



		if (sys_clock_MHz < 125) {

			pll_DIVQ = 3;

			pll_DIVF = (sys_clock_MHz * 4) / 3;

	if (solo_dev->type == SOLO_DEV_6010) {

		solo_dev->clock_mhz = 108;

		solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT

			| SOLO_SYS_CFG_INPUTDIV(25)

			| SOLO_SYS_CFG_FEEDBACKDIV(solo_dev->clock_mhz * 2 - 2)

			| SOLO_SYS_CFG_OUTDIV(3);

		solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config);

	} else {

		u32 divq, divf;



		solo_dev->clock_mhz = 135;



		if (solo_dev->clock_mhz < 125) {

			divq = 3;

			divf = (solo_dev->clock_mhz * 4) / 3 - 1;

		} else {

			pll_DIVQ = 2;

			pll_DIVF = (sys_clock_MHz * 2) / 3;

			divq = 2;

			divf = (solo_dev->clock_mhz * 2) / 3 - 1;

		}



		solo_reg_write(solo_dev, SOLO6110_PLL_CONFIG,

			       SOLO6110_PLL_RANGE_5_10MHZ |

			       SOLO6110_PLL_DIVR(9) |

			       SOLO6110_PLL_DIVQ_EXP(pll_DIVQ) |

			       SOLO6110_PLL_DIVF(pll_DIVF) | SOLO6110_PLL_FSEN);

		mdelay(1);      /* PLL Locking time (1ms) */

		solo_reg_write(solo_dev, SOLO_PLL_CONFIG,

			       (1 << 20) | /* PLL_RANGE */

			       (8 << 15) | /* PLL_DIVR  */

			       (divq << 12) |

			       (divf <<  4) |

			       (1 <<  1)   /* PLL_FSEN */);



		solo_reg_write(solo_dev, SOLO_DMA_CTRL1, 3 << 8); /* ? */

	} else

		solo_reg_write(solo_dev, SOLO_DMA_CTRL1, 1 << 8); /* ? */

		solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT;

	}



	solo_reg_write(solo_dev, SOLO_TIMER_CLOCK_NUM, SOLO_CLOCK_MHZ - 1);

	solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config);

	solo_reg_write(solo_dev, SOLO_TIMER_CLOCK_NUM,

		       solo_dev->clock_mhz - 1);



	/* PLL locking time of 1ms */

	mdelay(1);
@@ -237,14 +609,27 @@ static int solo_pci_probe(struct pci_dev *pdev, 
		goto fail_probe;



	/* Setup the DMA engine */

	sdram = (solo_dev->nr_chans >= 8) ? 2 : 1;

	solo_reg_write(solo_dev, SOLO_DMA_CTRL,

		       SOLO_DMA_CTRL_REFRESH_CYCLE(1) |

		       SOLO_DMA_CTRL_SDRAM_SIZE(sdram) |

		       SOLO_DMA_CTRL_SDRAM_SIZE(2) |

		       SOLO_DMA_CTRL_SDRAM_CLK_INVERT |

		       SOLO_DMA_CTRL_READ_CLK_SELECT |

		       SOLO_DMA_CTRL_LATENCY(1));



	/* Undocumented crap */

	solo_reg_write(solo_dev, SOLO_DMA_CTRL1,

		       solo_dev->type == SOLO_DEV_6010 ? 0x100 : 0x300);



	if (solo_dev->type != SOLO_DEV_6010) {

		solo_dev->usec_lsb = 0x3f;

		solo_set_time(solo_dev);

	}



	/* Disable watchdog */

	solo_reg_write(solo_dev, SOLO_WATCHDOG, 0);



	/* Initialize sub components */



	ret = solo_p2m_init(solo_dev);

	if (ret)

		goto fail_probe;
@@ -261,7 +646,7 @@ static int solo_pci_probe(struct pci_dev *pdev, 
	if (ret)

		goto fail_probe;



	ret = solo_v4l2_init(solo_dev);

	ret = solo_v4l2_init(solo_dev, video_nr);

	if (ret)

		goto fail_probe;
@@ -269,7 +654,7 @@ static int solo_pci_probe(struct pci_dev *pdev, 
	if (ret)

		goto fail_probe;



	ret = solo_enc_v4l2_init(solo_dev);

	ret = solo_enc_v4l2_init(solo_dev, video_nr);

	if (ret)

		goto fail_probe;
@@ -277,6 +662,13 @@ static int solo_pci_probe(struct pci_dev *pdev, 
	if (ret)

		goto fail_probe;



	ret = solo_sysfs_init(solo_dev);

	if (ret)

		goto fail_probe;



	/* Now that init is over, set this lower */

	solo_dev->p2m_jiffies = msecs_to_jiffies(20);



	return 0;



fail_probe:
@@ -291,21 +683,31 @@ static void solo_pci_remove(struct pci_dev *pdev) 
	free_solo_dev(solo_dev);

}



static struct pci_device_id solo_id_table[] = {

static DEFINE_PCI_DEVICE_TABLE(solo_id_table) = {

	/* 6010 based cards */

	{PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6010)},

	{PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6110),

	 .driver_data = FLAGS_6110},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_4)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_9)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_16)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_4)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_9)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_16)},

	{ PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6010),

	  .driver_data = SOLO_DEV_6010 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_4),

	  .driver_data = SOLO_DEV_6010 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_9),

	  .driver_data = SOLO_DEV_6010 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_16),

	  .driver_data = SOLO_DEV_6010 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_4),

	  .driver_data = SOLO_DEV_6010 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_9),

	  .driver_data = SOLO_DEV_6010 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_16),

	  .driver_data = SOLO_DEV_6010 },

	/* 6110 based cards */

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_4)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_8)},

	{PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_16)},

	{ PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6110),

	  .driver_data = SOLO_DEV_6110 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_4),

	  .driver_data = SOLO_DEV_6110 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_8),

	  .driver_data = SOLO_DEV_6110 },

	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_16),

	  .driver_data = SOLO_DEV_6110 },

	{0,}

};

drivers/staging/media/solo6x10/disp.c

+92 −35

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/media/solo6x10/eeprom.c

0 → 100644
+154 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010-2013 Bluecherry, LLC <http://www.bluecherrydvr.com>

 *

 * Original author:

 * Ben Collins <bcollins@ubuntu.com>

 *

 * Additional work by:

 * John Brooks <john.brooks@bluecherry.net>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 */



#include <linux/kernel.h>

#include <linux/delay.h>



#include "solo6x10.h"



/* Control */

#define EE_SHIFT_CLK	0x04

#define EE_CS		0x08

#define EE_DATA_WRITE	0x02

#define EE_DATA_READ	0x01

#define EE_ENB		(0x80 | EE_CS)



#define eeprom_delay()	udelay(100)

#if 0

#define eeprom_delay()	solo_reg_read(solo_dev, SOLO_EEPROM_CTRL)

#define eeprom_delay()	({				\

	int i, ret;					\

	udelay(100);					\

	for (i = ret = 0; i < 1000 && !ret; i++)	\

		ret = solo_eeprom_reg_read(solo_dev);	\

})

#endif

#define ADDR_LEN	6



/* Commands */

#define EE_EWEN_CMD	4

#define EE_EWDS_CMD	4

#define EE_WRITE_CMD	5

#define EE_READ_CMD	6

#define EE_ERASE_CMD	7



static unsigned int solo_eeprom_reg_read(struct solo_dev *solo_dev)

{

	return solo_reg_read(solo_dev, SOLO_EEPROM_CTRL) & EE_DATA_READ;

}



static void solo_eeprom_reg_write(struct solo_dev *solo_dev, u32 data)

{

	solo_reg_write(solo_dev, SOLO_EEPROM_CTRL, data);

	eeprom_delay();

}



static void solo_eeprom_cmd(struct solo_dev *solo_dev, int cmd)

{

	int i;



	solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ACCESS_EN);

	solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE);



	for (i = 4 + ADDR_LEN; i >= 0; i--) {

		int dataval = (cmd & (1 << i)) ? EE_DATA_WRITE : 0;



		solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE | dataval);

		solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE |

				      EE_SHIFT_CLK | dataval);

	}



	solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE);

}



unsigned int solo_eeprom_ewen(struct solo_dev *solo_dev, int w_en)

{

	int ewen_cmd = (w_en ? 0x3f : 0) | (EE_EWEN_CMD << ADDR_LEN);

	unsigned int retval = 0;

	int i;



	solo_eeprom_cmd(solo_dev, ewen_cmd);



	for (i = 0; i < 16; i++) {

		solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE |

				      EE_SHIFT_CLK);

		retval = (retval << 1) | solo_eeprom_reg_read(solo_dev);

		solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE);

		retval = (retval << 1) | solo_eeprom_reg_read(solo_dev);

	}



	solo_eeprom_reg_write(solo_dev, ~EE_CS);

	retval = (retval << 1) | solo_eeprom_reg_read(solo_dev);



	return retval;

}



unsigned short solo_eeprom_read(struct solo_dev *solo_dev, int loc)

{

	int read_cmd = loc | (EE_READ_CMD << ADDR_LEN);

	unsigned short retval = 0;

	int i;



	solo_eeprom_cmd(solo_dev, read_cmd);



	for (i = 0; i < 16; i++) {

		solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE |

				      EE_SHIFT_CLK);

		retval = (retval << 1) | solo_eeprom_reg_read(solo_dev);

		solo_eeprom_reg_write(solo_dev, SOLO_EEPROM_ENABLE);

	}



	solo_eeprom_reg_write(solo_dev, ~EE_CS);



	return retval;

}



int solo_eeprom_write(struct solo_dev *solo_dev, int loc,

		      unsigned short data)

{

	int write_cmd = loc | (EE_WRITE_CMD << ADDR_LEN);

	unsigned int retval;

	int i;



	solo_eeprom_cmd(solo_dev, write_cmd);



	for (i = 15; i >= 0; i--) {

		unsigned int dataval = (data >> i) & 1;



		solo_eeprom_reg_write(solo_dev, EE_ENB);

		solo_eeprom_reg_write(solo_dev,

				      EE_ENB | (dataval << 1) | EE_SHIFT_CLK);

	}



	solo_eeprom_reg_write(solo_dev, EE_ENB);

	solo_eeprom_reg_write(solo_dev, ~EE_CS);

	solo_eeprom_reg_write(solo_dev, EE_ENB);



	for (i = retval = 0; i < 10000 && !retval; i++)

		retval = solo_eeprom_reg_read(solo_dev);



	solo_eeprom_reg_write(solo_dev, ~EE_CS);



	return !retval;

}