[media] radio-mr800: add hardware seek support (4bd9ff19) · Commits · 戴 / test

drivers/media/radio/radio-mr800.c

+141 −114

Original line number	Diff line number	Diff line
		@@ -103,13 +103,17 @@ devices, that would be 76 and 91. */
		* List isn't full and will be updated with implementation of new functions
		*/
		#define AMRADIO_SET_FREQ 0xa4
		#define AMRADIO_GET_READY_FLAG 0xa5
		#define AMRADIO_GET_SIGNAL 0xa7
		#define AMRADIO_GET_FREQ 0xa8
		#define AMRADIO_SET_SEARCH_UP 0xa9
		#define AMRADIO_SET_SEARCH_DOWN 0xaa
		#define AMRADIO_SET_MUTE 0xab
		#define AMRADIO_SET_RIGHT_MUTE 0xac
		#define AMRADIO_SET_LEFT_MUTE 0xad
		#define AMRADIO_SET_MONO 0xae

		/* Comfortable defines for amradio_set_mute */
		#define AMRADIO_START 0x00
		#define AMRADIO_STOP 0x01
		#define AMRADIO_SET_SEARCH_LVL 0xb0
		#define AMRADIO_STOP_SEARCH 0xb1

		/* Comfortable defines for amradio_set_stereo */
		#define WANT_STEREO 0x00
		@@ -129,7 +133,7 @@ struct amradio_device {
		struct v4l2_device v4l2_dev;
		struct v4l2_ctrl_handler hdl;

		unsigned char *buffer;
		u8 *buffer;
		struct mutex lock; /* buffer locking */
		int curfreq;
		int stereo;
		@@ -141,8 +145,8 @@ static inline struct amradio_device to_amradio_dev(struct v4l2_device v4l2_dev
		return container_of(v4l2_dev, struct amradio_device, v4l2_dev);
		}

		/* switch on/off the radio. Send 8 bytes to device */
		static int amradio_set_mute(struct amradio_device *radio, char argument)
		static int amradio_send_cmd(struct amradio_device *radio, u8 cmd, u8 arg,
		u8 *extra, u8 extralen, bool reply)
		{
		int retval;
		int size;
		@@ -150,117 +154,89 @@ static int amradio_set_mute(struct amradio_device *radio, char argument)
		radio->buffer[0] = 0x00;
		radio->buffer[1] = 0x55;
		radio->buffer[2] = 0xaa;
		radio->buffer[3] = 0x00;
		radio->buffer[4] = AMRADIO_SET_MUTE;
		radio->buffer[5] = argument;
		radio->buffer[3] = extralen;
		radio->buffer[4] = cmd;
		radio->buffer[5] = arg;
		radio->buffer[6] = 0x00;
		radio->buffer[7] = 0x00;
		radio->buffer[7] = extra \|\| reply ? 8 : 0;

		retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
		radio->buffer, BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH) {
		amradio_dev_warn(&radio->vdev.dev, "set mute failed\n");
		return retval < 0 ? retval : -EIO;
		if (video_is_registered(&radio->vdev))
		amradio_dev_warn(&radio->vdev.dev,
		"cmd %02x failed\n", cmd);
		return retval ? retval : -EIO;
		}
		radio->muted = argument;
		if (!extra && !reply)
		return 0;

		if (extra) {
		memcpy(radio->buffer, extra, extralen);
		memset(radio->buffer + extralen, 0, 8 - extralen);
		retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
		radio->buffer, BUFFER_LENGTH, &size, USB_TIMEOUT);
		} else {
		memset(radio->buffer, 0, 8);
		retval = usb_bulk_msg(radio->usbdev, usb_rcvbulkpipe(radio->usbdev, 0x81),
		radio->buffer, BUFFER_LENGTH, &size, USB_TIMEOUT);
		}
		if (retval == 0 && size == BUFFER_LENGTH)
		return 0;
		if (video_is_registered(&radio->vdev) && cmd != AMRADIO_GET_READY_FLAG)
		amradio_dev_warn(&radio->vdev.dev, "follow-up to cmd %02x failed\n", cmd);
		return retval ? retval : -EIO;
		}

		/* switch on/off the radio. Send 8 bytes to device */
		static int amradio_set_mute(struct amradio_device *radio, bool mute)
		{
		int ret = amradio_send_cmd(radio,
		AMRADIO_SET_MUTE, mute, NULL, 0, false);

		if (!ret)
		radio->muted = mute;
		return ret;
		}

		/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
		static int amradio_setfreq(struct amradio_device *radio, int freq)
		static int amradio_set_freq(struct amradio_device *radio, int freq)
		{
		unsigned short freq_send = 0x10 + (freq >> 3) / 25;
		u8 buf[3];
		int retval;
		int size;

		radio->buffer[0] = 0x00;
		radio->buffer[1] = 0x55;
		radio->buffer[2] = 0xaa;
		radio->buffer[3] = 0x03;
		radio->buffer[4] = AMRADIO_SET_FREQ;
		radio->buffer[5] = 0x00;
		radio->buffer[6] = 0x00;
		radio->buffer[7] = 0x08;

		retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH)
		goto out;

		/* frequency is calculated from freq_send and placed in first 2 bytes */
		radio->buffer[0] = (freq_send >> 8) & 0xff;
		radio->buffer[1] = freq_send & 0xff;
		radio->buffer[2] = 0x01;
		radio->buffer[3] = 0x00;
		radio->buffer[4] = 0x00;
		/* 5 and 6 bytes of buffer already = 0x00 */
		radio->buffer[7] = 0x00;
		buf[0] = (freq_send >> 8) & 0xff;
		buf[1] = freq_send & 0xff;
		buf[2] = 0x01;

		retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval >= 0 && size == BUFFER_LENGTH) {
		retval = amradio_send_cmd(radio, AMRADIO_SET_FREQ, 0, buf, 3, false);
		if (retval)
		return retval;
		radio->curfreq = freq;
		msleep(40);
		return 0;
		}

		out:
		amradio_dev_warn(&radio->vdev.dev, "set frequency failed\n");
		return retval < 0 ? retval : -EIO;
		}

		static int amradio_set_stereo(struct amradio_device *radio, char argument)
		static int amradio_set_stereo(struct amradio_device *radio, bool stereo)
		{
		int retval;
		int size;
		int ret = amradio_send_cmd(radio,
		AMRADIO_SET_MONO, !stereo, NULL, 0, false);

		radio->buffer[0] = 0x00;
		radio->buffer[1] = 0x55;
		radio->buffer[2] = 0xaa;
		radio->buffer[3] = 0x00;
		radio->buffer[4] = AMRADIO_SET_MONO;
		radio->buffer[5] = argument;
		radio->buffer[6] = 0x00;
		radio->buffer[7] = 0x00;

		retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
		(void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval < 0 \|\| size != BUFFER_LENGTH) {
		amradio_dev_warn(&radio->vdev.dev, "set stereo failed\n");
		return retval < 0 ? retval : -EIO;
		}

		radio->stereo = (argument == WANT_STEREO);
		return 0;
		if (!ret)
		radio->stereo = stereo;
		return ret;
		}

		static int amradio_get_stat(struct amradio_device radio, bool is_stereo, u32 *signal)
		{
		int retval;
		int size;
		int ret = amradio_send_cmd(radio,
		AMRADIO_GET_SIGNAL, 0, NULL, 0, true);

		radio->buffer[0] = 0x00;
		radio->buffer[1] = 0x55;
		radio->buffer[2] = 0xaa;
		radio->buffer[3] = 0x00;
		radio->buffer[4] = AMRADIO_GET_SIGNAL;
		radio->buffer[5] = 0x00;
		radio->buffer[6] = 0x00;
		radio->buffer[7] = 0x08;

		retval = usb_bulk_msg(radio->usbdev, usb_sndbulkpipe(radio->usbdev, 0x02),
		radio->buffer, BUFFER_LENGTH, &size, USB_TIMEOUT);
		if (!retval)
		retval = usb_bulk_msg(radio->usbdev, usb_rcvbulkpipe(radio->usbdev, 0x81),
		radio->buffer, BUFFER_LENGTH, &size, USB_TIMEOUT);

		if (retval \|\| size != BUFFER_LENGTH) {
		amradio_dev_warn(&radio->vdev.dev, "get stat failed\n");
		return retval;
		}
		if (ret)
		return ret;
		*is_stereo = radio->buffer[2] >> 7;
		*signal = (radio->buffer[3] & 0xf0) << 8;
		return 0;
		@@ -276,8 +252,9 @@ static void usb_amradio_disconnect(struct usb_interface *intf)
		struct amradio_device *radio = to_amradio_dev(usb_get_intfdata(intf));

		mutex_lock(&radio->lock);
		usb_set_intfdata(intf, NULL);
		video_unregister_device(&radio->vdev);
		amradio_set_mute(radio, true);
		usb_set_intfdata(intf, NULL);
		v4l2_device_disconnect(&radio->v4l2_dev);
		mutex_unlock(&radio->lock);
		v4l2_device_put(&radio->v4l2_dev);
		@@ -292,7 +269,8 @@ static int vidioc_querycap(struct file file, void priv,
		strlcpy(v->driver, "radio-mr800", sizeof(v->driver));
		strlcpy(v->card, "AverMedia MR 800 USB FM Radio", sizeof(v->card));
		usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
		v->device_caps = V4L2_CAP_RADIO \| V4L2_CAP_TUNER;
		v->device_caps = V4L2_CAP_RADIO \| V4L2_CAP_TUNER \|
		V4L2_CAP_HW_FREQ_SEEK;
		v->capabilities = v->device_caps \| V4L2_CAP_DEVICE_CAPS;
		return 0;
		}
		@@ -350,7 +328,7 @@ static int vidioc_s_frequency(struct file file, void priv,

		if (f->tuner != 0)
		return -EINVAL;
		return amradio_setfreq(radio, clamp_t(unsigned, f->frequency,
		return amradio_set_freq(radio, clamp_t(unsigned, f->frequency,
		FREQ_MIN * FREQ_MUL, FREQ_MAX * FREQ_MUL));
		}

		@@ -368,6 +346,59 @@ static int vidioc_g_frequency(struct file file, void priv,
		return 0;
		}

		static int vidioc_s_hw_freq_seek(struct file file, void priv,
		struct v4l2_hw_freq_seek *seek)
		{
		static u8 buf[8] = {
		0x3d, 0x32, 0x0f, 0x08, 0x3d, 0x32, 0x0f, 0x08
		};
		struct amradio_device *radio = video_drvdata(file);
		unsigned long timeout;
		int retval;

		if (seek->tuner != 0 \|\| !seek->wrap_around)
		return -EINVAL;

		retval = amradio_send_cmd(radio,
		AMRADIO_SET_SEARCH_LVL, 0, buf, 8, false);
		if (retval)
		return retval;
		amradio_set_freq(radio, radio->curfreq);
		retval = amradio_send_cmd(radio,
		seek->seek_upward ? AMRADIO_SET_SEARCH_UP : AMRADIO_SET_SEARCH_DOWN,
		0, NULL, 0, false);
		if (retval)
		return retval;
		timeout = jiffies + msecs_to_jiffies(30000);
		for (;;) {
		if (time_after(jiffies, timeout)) {
		retval = -EAGAIN;
		break;
		}
		if (schedule_timeout_interruptible(msecs_to_jiffies(10))) {
		retval = -ERESTARTSYS;
		break;
		}
		retval = amradio_send_cmd(radio, AMRADIO_GET_READY_FLAG,
		0, NULL, 0, true);
		if (retval)
		continue;
		amradio_send_cmd(radio, AMRADIO_GET_FREQ, 0, NULL, 0, true);
		if (radio->buffer[1] \|\| radio->buffer[2]) {
		radio->curfreq = (radio->buffer[1] << 8) \| radio->buffer[2];
		radio->curfreq = (radio->curfreq - 0x10) * 200;
		amradio_send_cmd(radio, AMRADIO_STOP_SEARCH,
		0, NULL, 0, false);
		amradio_set_freq(radio, radio->curfreq);
		retval = 0;
		break;
		}
		}
		amradio_send_cmd(radio, AMRADIO_STOP_SEARCH, 0, NULL, 0, false);
		amradio_set_freq(radio, radio->curfreq);
		return retval;
		}

		static int usb_amradio_s_ctrl(struct v4l2_ctrl *ctrl)
		{
		struct amradio_device *radio =
		@@ -375,8 +406,7 @@ static int usb_amradio_s_ctrl(struct v4l2_ctrl *ctrl)

		switch (ctrl->id) {
		case V4L2_CID_AUDIO_MUTE:
		return amradio_set_mute(radio,
		ctrl->val ? AMRADIO_STOP : AMRADIO_START);
		return amradio_set_mute(radio, ctrl->val);
		}

		return -EINVAL;
		@@ -386,19 +416,19 @@ static int usb_amradio_init(struct amradio_device *radio)
		{
		int retval;

		retval = amradio_set_mute(radio, AMRADIO_STOP);
		retval = amradio_set_mute(radio, true);
		if (retval)
		goto out_err;

		retval = amradio_set_stereo(radio, WANT_STEREO);
		retval = amradio_set_stereo(radio, true);
		if (retval)
		goto out_err;

		goto out;
		retval = amradio_set_freq(radio, radio->curfreq);
		if (retval)
		goto out_err;
		return 0;

		out_err:
		amradio_dev_err(&radio->vdev.dev, "initialization failed\n");
		out:
		return retval;
		}

		@@ -409,8 +439,8 @@ static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message)

		mutex_lock(&radio->lock);
		if (!radio->muted) {
		amradio_set_mute(radio, AMRADIO_STOP);
		radio->muted = 0;
		amradio_set_mute(radio, true);
		radio->muted = false;
		}
		mutex_unlock(&radio->lock);

		@@ -424,15 +454,11 @@ static int usb_amradio_resume(struct usb_interface *intf)
		struct amradio_device *radio = to_amradio_dev(usb_get_intfdata(intf));

		mutex_lock(&radio->lock);
		if (radio->stereo)
		amradio_set_stereo(radio, WANT_STEREO);
		else
		amradio_set_stereo(radio, WANT_MONO);

		amradio_setfreq(radio, radio->curfreq);
		amradio_set_stereo(radio, radio->stereo);
		amradio_set_freq(radio, radio->curfreq);

		if (!radio->muted)
		amradio_set_mute(radio, AMRADIO_START);
		amradio_set_mute(radio, false);

		mutex_unlock(&radio->lock);

		@@ -459,6 +485,7 @@ static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
		.vidioc_s_tuner = vidioc_s_tuner,
		.vidioc_g_frequency = vidioc_g_frequency,
		.vidioc_s_frequency = vidioc_s_frequency,
		.vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
		.vidioc_log_status = v4l2_ctrl_log_status,
		.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
		.vidioc_unsubscribe_event = v4l2_event_unsubscribe,

Admin message