[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

New media framework user space usage



Hello Laurent,

my mt9p031 camera project for the omap3530 isp has come to the point
where the ISP registered video[0-6], media0 and v4l-subdev[0-7].

As far as I can see from the names...

cat /sys/class/video4linux/video*/names
OMAP3 ISP CCP2 input
OMAP3 ISP CSI2a output
OMAP3 ISP CCDC output
OMAP3 ISP preview input
OMAP3 ISP preview output
OMAP3 ISP resizer input
OMAP3 ISP resizer output

cat /sys/class/video4linux/v4l-subdev*/names
OMAP3 ISP CCP2
OMAP3 ISP CSI2a
OMAP3 ISP CCDC
OMAP3 ISP preview
OMAP3 ISP resizer
OMAP3 ISP AEWB
OMAP3 ISP AF
OMAP3 ISP histogram

... I want to read /dev/video2 (CCDC).

When I try out a little test program from the V4L2 doc, this line fails:
      ioctl (fd, VIDIOC_G_STD, &std_id)


So far I adopted your mt9t001 driver, merged it with Guennadis
mt9p031. It contains lot of stubs that I want to fill out when I
succeed to make them called inside the kernel.
I looked at your presentation for the media controller and wonder if I
have to set up a pipeline by myself before I can read /dev/video2
(http://linuxtv.org/downloads/presentations/summit_jun_2010/20100614-v4l2_summit-media.pdf).
I failed at the point where I wanted to try out the little snippet on
page 17 as I don't have definitions of the MEDIA_IOC_ENUM_ENTITIES.
Are there somewhere userspace headers available?

int fd;
fd = open(“/dev/media0”, O_RDWR);
while (1) {
 struct media_user_entity entity;
 struct media_user_links links;
 ret = ioctl(fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
 if (ret < 0)
 break;
 while (1) {
 ret = ioctl(fd, MEDIA_IOC_ENUM_LINKS, &links);
 if (ret < 0)
 break;
}

Thanks for help,

 Bastian


APPENDIX A: dmesg

[  103.356018] Linux media interface: v0.10
[  103.356048] device class 'media': registering
[  103.442230] Linux video capture interface: v2.00
[  103.442260] device class 'video4linux': registering
[  103.814239] bus: 'i2c': add driver mt9p031
[  103.894622] bus: 'platform': add driver omap3isp
[  103.933959] address of isp_platform_data in boardconfig: bf065074
[  103.940155] Registering platform device 'omap3isp'. Parent at platform
[  103.940185] device: 'omap3isp': device_add
[  103.940246] bus: 'platform': add device omap3isp
[  103.940490] bus: 'platform': driver_probe_device: matched device
omap3isp with driver omap3isp
[  103.940490] bus: 'platform': really_probe: probing driver omap3isp
with device omap3isp
[  103.940551] address of isp_platform_data bf065074
[  103.954467] omap3isp omap3isp: Revision 2.0 found
[  103.962738] omap-iommu omap-iommu.0: isp: version 1.1
[  103.969879] omap3isp omap3isp: hist: DMA channel = 0
[  103.970001] omap3isp omap3isp: isp_set_xclk(): cam_xclka set to 5760000 Hz
[  103.972229] omap3isp omap3isp: -------------ISP Register dump--------------
[  103.972259] omap3isp omap3isp: ###ISP SYSCONFIG=0x00000001
[  103.972259] omap3isp omap3isp: ###ISP SYSSTATUS=0x00000001
[  103.972290] omap3isp omap3isp: ###ISP IRQ0ENABLE=0x00000000
[  103.972290] omap3isp omap3isp: ###ISP IRQ0STATUS=0x00000000
[  103.972320] omap3isp omap3isp: ###ISP TCTRL_GRESET_LENGTH=0x00000000
[  103.972320] omap3isp omap3isp: ###ISP TCTRL_PSTRB_REPLAY=0x00000000
[  103.972351] omap3isp omap3isp: ###ISP CTRL=0x00200200
[  103.972351] omap3isp omap3isp: ###ISP TCTRL_CTRL=0x0000001e
[  103.972381] omap3isp omap3isp: ###ISP TCTRL_FRAME=0x00000000
[  103.972381] omap3isp omap3isp: ###ISP TCTRL_PSTRB_DELAY=0x00000000
[  103.972412] omap3isp omap3isp: ###ISP TCTRL_STRB_DELAY=0x00000000
[  103.972442] omap3isp omap3isp: ###ISP TCTRL_SHUT_DELAY=0x00000000
[  103.972442] omap3isp omap3isp: ###ISP TCTRL_PSTRB_LENGTH=0x00000000
[  103.972473] omap3isp omap3isp: ###ISP TCTRL_STRB_LENGTH=0x00000000
[  103.972473] omap3isp omap3isp: ###ISP TCTRL_SHUT_LENGTH=0x00000000
[  103.972503] omap3isp omap3isp: ###SBL PCR=0x00000000
[  103.972503] omap3isp omap3isp: ###SBL SDR_REQ_EXP=0x00000000
[  103.972534] omap3isp omap3isp: --------------------------------------------
[  103.974700] device: 'media0': device_add
[  103.975128] device: 'v4l-subdev0': device_add
[  103.975524] device: 'video0': device_add
[  103.975799] device: 'v4l-subdev1': device_add
[  103.976104] device: 'video1': device_add
[  103.976409] device: 'v4l-subdev2': device_add
[  103.976684] device: 'video2': device_add
[  103.976959] device: 'v4l-subdev3': device_add
[  103.977294] device: 'video3': device_add
[  103.977600] device: 'video4': device_add
[  103.977905] device: 'v4l-subdev4': device_add
[  103.978210] device: 'video5': device_add
[  103.978485] device: 'video6': device_add
[  103.978759] device: 'v4l-subdev5': device_add
[  103.979156] device: 'v4l-subdev6': device_add
[  103.979461] device: 'v4l-subdev7': device_add
[  104.752685] device: '2-005d': device_add
[  104.752777] bus: 'i2c': add device 2-005d
[  104.753051] bus: 'i2c': driver_probe_device: matched device 2-005d
with driver mt9p031
[  104.753082] bus: 'i2c': really_probe: probing driver mt9p031 with
device 2-005d
[  104.769897] mt9p031 2-005d: Detected a MT9P031 chip ID 1801
[  104.771881] mt9p031 2-005d: reset succesful
[  104.771911] driver: '2-005d': driver_bound: bound to device 'mt9p031'
[  104.771942] bus: 'i2c': really_probe: bound device 2-005d to driver mt9p031
[  104.772003] driver: 'omap3isp': driver_bound: bound to device 'omap3isp'
[  104.772033] bus: 'platform': really_probe: bound device omap3isp to
driver omap3isp


APPENDIX B: mt9p031.c

#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/log2.h>
#include <linux/pm.h>
#include <linux/slab.h>
#include <linux/videodev2.h>

//#include <media/soc_camera.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-subdev.h>

/*
 * mt9p031 i2c address 0x5d (0xBA read, 0xBB write) same as mt9t031
 * The platform has to define i2c_board_info and link to it from
 * struct soc_camera_link
 */

/* mt9p031 selected register addresses */
#define MT9P031_CHIP_VERSION		0x00
#define MT9P031_ROW_START		0x01
#define MT9P031_COLUMN_START		0x02
#define MT9P031_WINDOW_HEIGHT		0x03
#define MT9P031_WINDOW_WIDTH		0x04
#define MT9P031_HORIZONTAL_BLANKING	0x05
#define MT9P031_VERTICAL_BLANKING	0x06
#define MT9P031_OUTPUT_CONTROL		0x07
#define MT9P031_SHUTTER_WIDTH_UPPER	0x08
#define MT9P031_SHUTTER_WIDTH		0x09
#define MT9P031_PIXEL_CLOCK_CONTROL	0x0a
#define MT9P031_FRAME_RESTART		0x0b
#define MT9P031_SHUTTER_DELAY		0x0c
#define MT9P031_RESET			0x0d
#define MT9P031_READ_MODE_1		0x1e
#define MT9P031_READ_MODE_2		0x20
//#define MT9T031_READ_MODE_3		0x21 // NA readmode_2 is 2 bytes
#define MT9P031_ROW_ADDRESS_MODE	0x22
#define MT9P031_COLUMN_ADDRESS_MODE	0x23
#define MT9P031_GLOBAL_GAIN		0x35
//#define MT9T031_CHIP_ENABLE		0xF8 // PDN is pin signal. no i2c register

#define MT9P031_MAX_HEIGHT		1944 // adapted
#define MT9P031_MAX_WIDTH		2592 // adapted
#define MT9P031_MIN_HEIGHT		2  // could be 0
#define MT9P031_MIN_WIDTH		18 // could be 0
#define MT9P031_HORIZONTAL_BLANK	0  // adapted R0x05
#define MT9P031_VERTICAL_BLANK		25 // adapted R0x06
#define MT9P031_COLUMN_SKIP		16 // adapted
#define MT9P031_ROW_SKIP		54 // adapted

#define MT9P031_CHIP_VERSION_VALUE	0x1801

/*
#define MT9T031_BUS_PARAM	(SOCAM_PCLK_SAMPLE_RISING |	\
	SOCAM_PCLK_SAMPLE_FALLING | SOCAM_HSYNC_ACTIVE_HIGH |	\
	SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_DATA_ACTIVE_HIGH |	\
	SOCAM_MASTER | SOCAM_DATAWIDTH_10)
*/
struct mt9p031 {
	struct v4l2_subdev subdev;
        struct media_entity_pad pad;

	struct v4l2_rect rect;	/* Sensor window */
	int model;	/* V4L2_IDENT_MT9P031* codes from v4l2-chip-ident.h */
	u16 xskip;
	u16 yskip;
	unsigned int gain;
	unsigned short y_skip_top;	/* Lines to skip at the top */
	unsigned int exposure;
	unsigned char autoexposure;
};

static struct mt9p031 *to_mt9p031(const struct i2c_client *client)
{
	return container_of(i2c_get_clientdata(client), struct mt9p031, subdev);
}

static int reg_read(struct i2c_client *client, const u8 reg)
{
	s32 data = i2c_smbus_read_word_data(client, reg);
	return data < 0 ? data : swab16(data);
}

static int reg_write(struct i2c_client *client, const u8 reg,
		     const u16 data)
{
	return i2c_smbus_write_word_data(client, reg, swab16(data));
}

static int reg_set(struct i2c_client *client, const u8 reg,
		   const u16 data)
{
	int ret;

	ret = reg_read(client, reg);
	if (ret < 0)
		return ret;
	return reg_write(client, reg, ret | data);
}

static int reg_clear(struct i2c_client *client, const u8 reg,
		     const u16 data)
{
	int ret;

	ret = reg_read(client, reg);
	if (ret < 0)
		return ret;
	return reg_write(client, reg, ret & ~data);
}

static int set_shutter(struct i2c_client *client, const u32 data)
{
	int ret;

	ret = reg_write(client, MT9P031_SHUTTER_WIDTH_UPPER, data >> 16);

	if (ret >= 0)
		ret = reg_write(client, MT9P031_SHUTTER_WIDTH, data & 0xffff);

	return ret;
}

static int get_shutter(struct i2c_client *client, u32 *data)
{
	int ret;

	ret = reg_read(client, MT9P031_SHUTTER_WIDTH_UPPER);
	*data = ret << 16;

	if (ret >= 0)
		ret = reg_read(client, MT9P031_SHUTTER_WIDTH);
	*data |= ret & 0xffff;

	return ret < 0 ? ret : 0;
}

static int mt9p031_idle(struct i2c_client *client)
{
        int ret;

        /* Disable chip output, synchronous option update */
        ret = reg_write(client, MT9P031_RESET, 1);
        if (ret >= 0)
                ret = reg_write(client, MT9P031_RESET, 0);
        if (ret >= 0)
                ret = reg_clear(client, MT9P031_OUTPUT_CONTROL, 2);

        return ret >= 0 ? 0 : -EIO;
}

/////////////////////////////////////////////////////////////////////////////////
STUB
static int mt9t001_enum_mbus_code(struct v4l2_subdev *subdev,
                                  struct v4l2_subdev_fh *fh,
                                  struct v4l2_subdev_pad_mbus_code_enum *code)
{
	printk(KERN_ALERT "pad_op 0\n");
        return 0;
}

static int mt9t001_enum_frame_size(struct v4l2_subdev *subdev,
                                   struct v4l2_subdev_fh *fh,
                                   struct v4l2_subdev_frame_size_enum *fse)
{
	printk(KERN_ALERT "pad_op 1\n");
       	return 0;
}

static int mt9t001_get_format(struct v4l2_subdev *subdev,
                              struct v4l2_subdev_fh *fh, unsigned int pad,
                              struct v4l2_mbus_framefmt *format,
                              enum v4l2_subdev_format which)
{	
	printk(KERN_ALERT "pad_op 4\n");
        return 0;
}

static int mt9t001_set_format(struct v4l2_subdev *subdev,
                              struct v4l2_subdev_fh *fh, unsigned int pad,
                              struct v4l2_mbus_framefmt *format,
                              enum v4l2_subdev_format which)
{	
	printk(KERN_ALERT "pad_op 5\n");
        return 0;
}
static int mt9t001_get_crop(struct v4l2_subdev *subdev,
                            struct v4l2_subdev_fh *fh,
                            struct v4l2_subdev_pad_crop *crop)
{	
	printk(KERN_ALERT "pad_op 6\n");
        return 0;
}

static int mt9t001_set_crop(struct v4l2_subdev *subdev,
                            struct v4l2_subdev_fh *fh,
                            struct v4l2_subdev_pad_crop *crop)
{	
	printk(KERN_ALERT "pad_op 7\n");
        return 0;
}


/////////////////////////////////////////////////////////////////////////////////
END STUB


static int mt9p031_s_stream(struct v4l2_subdev *sd, int enable)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int ret;

	if (enable)
		/* Switch to master "normal" mode */
		ret = reg_set(client, MT9P031_OUTPUT_CONTROL, 2);
	else
		/* Stop sensor readout */
		ret = reg_clear(client, MT9P031_OUTPUT_CONTROL, 2);

	if (ret < 0)
		return -EIO;

	return 0;
}

enum {
        MT9P031_CTRL_VFLIP,
        MT9P031_CTRL_HFLIP,
        MT9P031_CTRL_GAIN,
        MT9P031_CTRL_EXPOSURE,
        MT9P031_CTRL_EXPOSURE_AUTO,
};

static const struct v4l2_queryctrl mt9p031_controls[] = {
	[MT9P031_CTRL_VFLIP] = {
		.id		= V4L2_CID_VFLIP,
		.type		= V4L2_CTRL_TYPE_BOOLEAN,
		.name		= "Flip Vertically",
		.minimum	= 0,
		.maximum	= 1,
		.step		= 1,
		.default_value	= 0,
	},
	[MT9P031_CTRL_HFLIP] = {
		.id		= V4L2_CID_HFLIP,
		.type		= V4L2_CTRL_TYPE_BOOLEAN,
		.name		= "Flip Horizontally",
		.minimum	= 0,
		.maximum	= 1,
		.step		= 1,
		.default_value	= 0,
	},
	[MT9P031_CTRL_GAIN] = {
		.id		= V4L2_CID_GAIN,
		.type		= V4L2_CTRL_TYPE_INTEGER,
		.name		= "Gain",
		.minimum	= 0,
		.maximum	= 127,
		.step		= 1,
		.default_value	= 64,
		.flags		= V4L2_CTRL_FLAG_SLIDER,
	},
	[MT9P031_CTRL_EXPOSURE] = {
		.id		= V4L2_CID_EXPOSURE,
		.type		= V4L2_CTRL_TYPE_INTEGER,
		.name		= "Exposure",
		.minimum	= 1,
		.maximum	= 255,
		.step		= 1,
		.default_value	= 255,
		.flags		= V4L2_CTRL_FLAG_SLIDER,
	},
	[MT9P031_CTRL_EXPOSURE_AUTO] = {
		.id		= V4L2_CID_EXPOSURE_AUTO,
		.type		= V4L2_CTRL_TYPE_BOOLEAN,
		.name		= "Automatic Exposure",
		.minimum	= 0,
		.maximum	= 1,
		.step		= 1,
		.default_value	= 1,
	}
};



static int mt9p031_g_chip_ident(struct v4l2_subdev *sd,
				struct v4l2_dbg_chip_ident *id)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	struct mt9p031 *mt9p031 = to_mt9p031(client);

	if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
		return -EINVAL;

	if (id->match.addr != client->addr)
		return -ENODEV;

	id->ident	= mt9p031->model;
	id->revision	= 0;

	return 0;
}

static int mt9p031_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	struct mt9p031 *mt9p031 = to_mt9p031(client);
	int data;

	switch (ctrl->id) {
	case V4L2_CID_VFLIP:
		data = reg_read(client, MT9P031_READ_MODE_2);
		if (data < 0)
			return -EIO;
		ctrl->value = !!(data & 0x8000);
		break;
	case V4L2_CID_HFLIP:
		data = reg_read(client, MT9P031_READ_MODE_2);
		if (data < 0)
			return -EIO;
		ctrl->value = !!(data & 0x4000);
		break;
	case V4L2_CID_EXPOSURE_AUTO:
		ctrl->value = mt9p031->autoexposure;
		break;
	case V4L2_CID_GAIN:
		ctrl->value = mt9p031->gain;
		break;
	case V4L2_CID_EXPOSURE:
		ctrl->value = mt9p031->exposure;
		break;
	}
	return 0;
}

static int mt9p031_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	printk(KERN_ALERT "s_ctrl\n");
	return 0;
}


static struct dev_pm_ops mt9p031_dev_pm_ops = {
/*
	.runtime_suspend	= mt9t031_runtime_suspend,
	.runtime_resume		= mt9t031_runtime_resume,
*/
};

static struct device_type mt9p031_dev_type = {
	.name	= "MT9P031",
	.pm	= &mt9p031_dev_pm_ops,
};

/*
 * Interface active, can use i2c. If it fails, it can indeed mean, that
 * this wasn't our capture interface, so, we wait for the right one
 */
static int mt9p031_video_probe(struct i2c_client *client)
{
	struct mt9p031 *mt9p031 = to_mt9p031(client);
	s32 data;
	int ret;

	/* Enable the chip */
	//data = reg_write(client, MT9P031_CHIP_ENABLE, 1);
	//dev_dbg(&client->dev, "write: %d\n", data);

	/* Read out the chip version register */
	data = reg_read(client, MT9P031_CHIP_VERSION);

	switch (data) {
	case MT9P031_CHIP_VERSION_VALUE:
		mt9p031->model = V4L2_IDENT_MT9P031;
		break;
	default:
		dev_err(&client->dev,
			"No MT9P031 chip detected, register read %x\n", data);
		return -ENODEV;
	}

	dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);

	ret = mt9p031_idle(client);
	if (ret < 0)
		dev_err(&client->dev, "Failed to initialise the camera\n");
	else
		dev_info(&client->dev, "reset succesful\n");//vdev->dev.type =
&mt9p031_dev_type;

	/* mt9t031_idle() has reset the chip to default. */
	mt9p031->exposure = 255;
	mt9p031->gain = 64;

	return ret;
}

static int mt9p031_open(struct v4l2_subdev *subdev, u32 i)
{
        printk(KERN_ALERT "mt9p031 open\n");
        return 0;
}
static int mt9p031_query_ctrl(struct v4l2_subdev *subdev,
                              struct v4l2_queryctrl *qc)
{
        return 0;
}



static struct v4l2_subdev_core_ops mt9p031_subdev_core_ops = {
	.g_ctrl		= mt9p031_g_ctrl,
	.s_ctrl		= mt9p031_s_ctrl,
	.g_chip_ident	= mt9p031_g_chip_ident,
	.init           = mt9p031_open,
        .queryctrl      = mt9p031_query_ctrl,

};

static struct v4l2_subdev_video_ops mt9p031_subdev_video_ops = {
	.s_stream	= mt9p031_s_stream,
};


static struct v4l2_subdev_pad_ops mt9p031_subdev_pad_ops = {
        .enum_mbus_code = mt9t001_enum_mbus_code,
        .enum_frame_size = mt9t001_enum_frame_size,
        .get_fmt = mt9t001_get_format,
        .set_fmt = mt9t001_set_format,
        .get_crop = mt9t001_get_crop,
        .set_crop = mt9t001_set_crop,
};


static struct v4l2_subdev_ops mt9p031_subdev_ops = {
	.core	= &mt9p031_subdev_core_ops,
	.video	= &mt9p031_subdev_video_ops,
	.pad	= &mt9p031_subdev_pad_ops,
};

static int mt9p031_probe(struct i2c_client *client,
			 const struct i2c_device_id *did)
{
	struct mt9p031 *mt9p031;
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	int ret;



	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
		dev_warn(&adapter->dev,
			 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
		return -EIO;
	}

	mt9p031 = kzalloc(sizeof(struct mt9p031), GFP_KERNEL);
	if (!mt9p031)
		return -ENOMEM;

	v4l2_i2c_subdev_init(&mt9p031->subdev, client, &mt9p031_subdev_ops);

//       struct isp_device *isp = v4l2_dev_to_isp_device(subdev->v4l2_dev);
//       isp_set_xclk(isp, 16*1000*1000, ISP_XCLK_A);

	mt9p031->y_skip_top	= 0;
	mt9p031->rect.left	= MT9P031_COLUMN_SKIP;
	mt9p031->rect.top	= MT9P031_ROW_SKIP;
	mt9p031->rect.width	= MT9P031_MAX_WIDTH;
	mt9p031->rect.height	= MT9P031_MAX_HEIGHT;

	/*
	 * Simulated autoexposure. If enabled, we calculate shutter width
	 * ourselves in the driver based on vertical blanking and frame width
	 */
	mt9p031->autoexposure = 1;

	mt9p031->xskip = 1;
	mt9p031->yskip = 1;

	mt9p031_idle(client);

	ret = mt9p031_video_probe(client);

	//mt9p031_disable(client);

	if (ret) {
		kfree(mt9p031);
		return ret;
	}

        mt9p031->pad.type = MEDIA_PAD_TYPE_OUTPUT;
        ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
        if (ret) {
                kfree(mt9p031);
                return ret;
        }



	return ret;
}

static int mt9p031_remove(struct i2c_client *client)
{
	struct mt9p031 *mt9p031 = to_mt9p031(client);

	client->driver = NULL;
	kfree(mt9p031);

	return 0;
}

static const struct i2c_device_id mt9p031_id[] = {
	{ "mt9p031", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, mt9p031_id);

static struct i2c_driver mt9p031_i2c_driver = {
	.driver = {
		.name = "mt9p031",
	},
	.probe		= mt9p031_probe,
	.remove		= mt9p031_remove,
	.id_table	= mt9p031_id,
};

static int __init mt9p031_mod_init(void)
{
	return i2c_add_driver(&mt9p031_i2c_driver);
}

static void __exit mt9p031_mod_exit(void)
{
	i2c_del_driver(&mt9p031_i2c_driver);
}

module_init(mt9p031_mod_init);
module_exit(mt9p031_mod_exit);

MODULE_DESCRIPTION("Micron MT9T031 Camera driver");
MODULE_AUTHOR("Guennadi Liakhovetski <lg@xxxxxxx>");
MODULE_LICENSE("GPL v2");
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Linux Input]     [Video for Linux]     [Mplayer Users]     [Linux USB Devel]     [Linux Audio Users]     [Photos]     [Yosemite Photos]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Devices]     [Yosemite Backpacking]     [Linux Input]

Add to Google Powered by Linux