Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 713eab88 authored by Ian Abbott's avatar Ian Abbott Committed by Greg Kroah-Hartman
Browse files

staging: comedi: jr3_pci: rename channel to sensor 



The driver overloads the term "channel" a lot.  To help reduce
confusion, rename the `channel` member of `struct
jr3_pci_subdev_private` to `sensor` as it points to a `struct
jr3_sensor`.  Also rename the various function parameters and local
variables called `channel` that point to a `struct jr3_sensor` to
`sensor`.

Signed-off-by: default avatarIan Abbott <abbotti@mev.co.uk>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent c5ad0c7b

drivers/staging/comedi/drivers/jr3_pci.c

+75 −77
Original line number Original line Diff line number Diff line
@@ -113,7 +113,7 @@ enum jr3_pci_poll_state { 
};

};





struct jr3_pci_subdev_private {

struct jr3_pci_subdev_private {

	struct jr3_sensor __iomem *channel;

	struct jr3_sensor __iomem *sensor;

	unsigned long next_time_min;

	unsigned long next_time_min;

	enum jr3_pci_poll_state state;

	enum jr3_pci_poll_state state;

	int serial_no;

	int serial_no;
@@ -134,22 +134,22 @@ static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max) 
	return result;

	return result;

}

}





static int is_complete(struct jr3_sensor __iomem *channel)

static int is_complete(struct jr3_sensor __iomem *sensor)

{

{

	return get_s16(&channel->command_word0) == 0;

	return get_s16(&sensor->command_word0) == 0;

}

}





static void set_transforms(struct jr3_sensor __iomem *channel,

static void set_transforms(struct jr3_sensor __iomem *sensor,

			   const struct jr3_pci_transform *transf, short num)

			   const struct jr3_pci_transform *transf, short num)

{

{

	int i;

	int i;





	num &= 0x000f;		/* Make sure that 0 <= num <= 15 */

	num &= 0x000f;		/* Make sure that 0 <= num <= 15 */

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

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

		set_u16(&channel->transforms[num].link[i].link_type,

		set_u16(&sensor->transforms[num].link[i].link_type,

			transf->link[i].link_type);

			transf->link[i].link_type);

		udelay(1);

		udelay(1);

		set_s16(&channel->transforms[num].link[i].link_amount,

		set_s16(&sensor->transforms[num].link[i].link_amount,

			transf->link[i].link_amount);

			transf->link[i].link_amount);

		udelay(1);

		udelay(1);

		if (transf->link[i].link_type == end_x_form)

		if (transf->link[i].link_type == end_x_form)
@@ -157,20 +157,20 @@ static void set_transforms(struct jr3_sensor __iomem *channel, 
	}

	}

}

}





static void use_transform(struct jr3_sensor __iomem *channel,

static void use_transform(struct jr3_sensor __iomem *sensor,

			  short transf_num)

			  short transf_num)

{

{

	set_s16(&channel->command_word0, 0x0500 + (transf_num & 0x000f));

	set_s16(&sensor->command_word0, 0x0500 + (transf_num & 0x000f));

}

}





static void use_offset(struct jr3_sensor __iomem *channel, short offset_num)

static void use_offset(struct jr3_sensor __iomem *sensor, short offset_num)

{

{

	set_s16(&channel->command_word0, 0x0600 + (offset_num & 0x000f));

	set_s16(&sensor->command_word0, 0x0600 + (offset_num & 0x000f));

}

}





static void set_offset(struct jr3_sensor __iomem *channel)

static void set_offset(struct jr3_sensor __iomem *sensor)

{

{

	set_s16(&channel->command_word0, 0x0700);

	set_s16(&sensor->command_word0, 0x0700);

}

}





struct six_axis_t {

struct six_axis_t {
@@ -182,43 +182,41 @@ struct six_axis_t { 
	s16 mz;

	s16 mz;

};

};





static void set_full_scales(struct jr3_sensor __iomem *channel,

static void set_full_scales(struct jr3_sensor __iomem *sensor,

			    struct six_axis_t full_scale)

			    struct six_axis_t full_scale)

{

{

	set_s16(&channel->full_scale.fx, full_scale.fx);

	set_s16(&sensor->full_scale.fx, full_scale.fx);

	set_s16(&channel->full_scale.fy, full_scale.fy);

	set_s16(&sensor->full_scale.fy, full_scale.fy);

	set_s16(&channel->full_scale.fz, full_scale.fz);

	set_s16(&sensor->full_scale.fz, full_scale.fz);

	set_s16(&channel->full_scale.mx, full_scale.mx);

	set_s16(&sensor->full_scale.mx, full_scale.mx);

	set_s16(&channel->full_scale.my, full_scale.my);

	set_s16(&sensor->full_scale.my, full_scale.my);

	set_s16(&channel->full_scale.mz, full_scale.mz);

	set_s16(&sensor->full_scale.mz, full_scale.mz);

	set_s16(&channel->command_word0, 0x0a00);

	set_s16(&sensor->command_word0, 0x0a00);

}

}





static struct six_axis_t get_min_full_scales(struct jr3_sensor __iomem

static struct six_axis_t get_min_full_scales(struct jr3_sensor __iomem *sensor)

					     *channel)

{

{

	struct six_axis_t result;

	struct six_axis_t result;





	result.fx = get_s16(&channel->min_full_scale.fx);

	result.fx = get_s16(&sensor->min_full_scale.fx);

	result.fy = get_s16(&channel->min_full_scale.fy);

	result.fy = get_s16(&sensor->min_full_scale.fy);

	result.fz = get_s16(&channel->min_full_scale.fz);

	result.fz = get_s16(&sensor->min_full_scale.fz);

	result.mx = get_s16(&channel->min_full_scale.mx);

	result.mx = get_s16(&sensor->min_full_scale.mx);

	result.my = get_s16(&channel->min_full_scale.my);

	result.my = get_s16(&sensor->min_full_scale.my);

	result.mz = get_s16(&channel->min_full_scale.mz);

	result.mz = get_s16(&sensor->min_full_scale.mz);

	return result;

	return result;

}

}





static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem

static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)

					     *channel)

{

{

	struct six_axis_t result;

	struct six_axis_t result;





	result.fx = get_s16(&channel->max_full_scale.fx);

	result.fx = get_s16(&sensor->max_full_scale.fx);

	result.fy = get_s16(&channel->max_full_scale.fy);

	result.fy = get_s16(&sensor->max_full_scale.fy);

	result.fz = get_s16(&channel->max_full_scale.fz);

	result.fz = get_s16(&sensor->max_full_scale.fz);

	result.mx = get_s16(&channel->max_full_scale.mx);

	result.mx = get_s16(&sensor->max_full_scale.mx);

	result.my = get_s16(&channel->max_full_scale.my);

	result.my = get_s16(&sensor->max_full_scale.my);

	result.mz = get_s16(&channel->max_full_scale.mz);

	result.mz = get_s16(&sensor->max_full_scale.mz);

	return result;

	return result;

}

}
@@ -238,35 +236,35 @@ static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev, 




		switch (axis) {

		switch (axis) {

		case 0:

		case 0:

			val = get_s16(&spriv->channel->filter[filter].fx);

			val = get_s16(&spriv->sensor->filter[filter].fx);

			break;

			break;

		case 1:

		case 1:

			val = get_s16(&spriv->channel->filter[filter].fy);

			val = get_s16(&spriv->sensor->filter[filter].fy);

			break;

			break;

		case 2:

		case 2:

			val = get_s16(&spriv->channel->filter[filter].fz);

			val = get_s16(&spriv->sensor->filter[filter].fz);

			break;

			break;

		case 3:

		case 3:

			val = get_s16(&spriv->channel->filter[filter].mx);

			val = get_s16(&spriv->sensor->filter[filter].mx);

			break;

			break;

		case 4:

		case 4:

			val = get_s16(&spriv->channel->filter[filter].my);

			val = get_s16(&spriv->sensor->filter[filter].my);

			break;

			break;

		case 5:

		case 5:

			val = get_s16(&spriv->channel->filter[filter].mz);

			val = get_s16(&spriv->sensor->filter[filter].mz);

			break;

			break;

		case 6:

		case 6:

			val = get_s16(&spriv->channel->filter[filter].v1);

			val = get_s16(&spriv->sensor->filter[filter].v1);

			break;

			break;

		case 7:

		case 7:

			val = get_s16(&spriv->channel->filter[filter].v2);

			val = get_s16(&spriv->sensor->filter[filter].v2);

			break;

			break;

		}

		}

		val += 0x4000;

		val += 0x4000;

	} else if (chan == 56) {

	} else if (chan == 56) {

		val = get_u16(&spriv->channel->model_no);

		val = get_u16(&spriv->sensor->model_no);

	} else if (chan == 57) {

	} else if (chan == 57) {

		val = get_u16(&spriv->channel->serial_no);

		val = get_u16(&spriv->sensor->serial_no);

	}

	}





	return val;

	return val;
@@ -282,7 +280,7 @@ static int jr3_pci_ai_insn_read(struct comedi_device *dev, 
	u16 errors;

	u16 errors;

	int i;

	int i;





	errors = get_u16(&spriv->channel->errors);

	errors = get_u16(&spriv->sensor->errors);

	if (spriv->state != state_jr3_done ||

	if (spriv->state != state_jr3_done ||

	    (errors & (watch_dog | watch_dog2 | sensor_change))) {

	    (errors & (watch_dog | watch_dog2 | sensor_change))) {

		/* No sensor or sensor changed */

		/* No sensor or sensor changed */
@@ -451,14 +449,14 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) 
{

{

	struct jr3_pci_subdev_private *spriv = s->private;

	struct jr3_pci_subdev_private *spriv = s->private;

	struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);

	struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);

	struct jr3_sensor __iomem *channel;

	struct jr3_sensor __iomem *sensor;

	u16 model_no;

	u16 model_no;

	u16 serial_no;

	u16 serial_no;

	int errors;

	int errors;

	int i;

	int i;





	channel = spriv->channel;

	sensor = spriv->sensor;

	errors = get_u16(&channel->errors);

	errors = get_u16(&sensor->errors);





	if (errors != spriv->errors)

	if (errors != spriv->errors)

		spriv->errors = errors;

		spriv->errors = errors;
@@ -469,8 +467,8 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) 




	switch (spriv->state) {

	switch (spriv->state) {

	case state_jr3_poll:

	case state_jr3_poll:

		model_no = get_u16(&channel->model_no);

		model_no = get_u16(&sensor->model_no);

		serial_no = get_u16(&channel->serial_no);

		serial_no = get_u16(&sensor->serial_no);





		if ((errors & (watch_dog | watch_dog2)) ||

		if ((errors & (watch_dog | watch_dog2)) ||

		    model_no == 0 || serial_no == 0) {

		    model_no == 0 || serial_no == 0) {
@@ -494,8 +492,8 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) 
		} else {

		} else {

			struct jr3_pci_transform transf;

			struct jr3_pci_transform transf;





			spriv->model_no = get_u16(&channel->model_no);

			spriv->model_no = get_u16(&sensor->model_no);

			spriv->serial_no = get_u16(&channel->serial_no);

			spriv->serial_no = get_u16(&sensor->serial_no);





			/* Transformation all zeros */

			/* Transformation all zeros */

			for (i = 0; i < ARRAY_SIZE(transf.link); i++) {

			for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
@@ -503,24 +501,24 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) 
				transf.link[i].link_amount = 0;

				transf.link[i].link_amount = 0;

			}

			}





			set_transforms(channel, &transf, 0);

			set_transforms(sensor, &transf, 0);

			use_transform(channel, 0);

			use_transform(sensor, 0);

			spriv->state = state_jr3_init_transform_complete;

			spriv->state = state_jr3_init_transform_complete;

			/* Allow 20 ms for completion */

			/* Allow 20 ms for completion */

			result = poll_delay_min_max(20, 100);

			result = poll_delay_min_max(20, 100);

		}

		}

		break;

		break;

	case state_jr3_init_transform_complete:

	case state_jr3_init_transform_complete:

		if (!is_complete(channel)) {

		if (!is_complete(sensor)) {

			result = poll_delay_min_max(20, 100);

			result = poll_delay_min_max(20, 100);

		} else {

		} else {

			/* Set full scale */

			/* Set full scale */

			struct six_axis_t min_full_scale;

			struct six_axis_t min_full_scale;

			struct six_axis_t max_full_scale;

			struct six_axis_t max_full_scale;





			min_full_scale = get_min_full_scales(channel);

			min_full_scale = get_min_full_scales(sensor);

			max_full_scale = get_max_full_scales(channel);

			max_full_scale = get_max_full_scales(sensor);

			set_full_scales(channel, max_full_scale);

			set_full_scales(sensor, max_full_scale);





			spriv->state = state_jr3_init_set_full_scale_complete;

			spriv->state = state_jr3_init_set_full_scale_complete;

			/* Allow 20 ms for completion */

			/* Allow 20 ms for completion */
@@ -528,10 +526,10 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) 
		}

		}

		break;

		break;

	case state_jr3_init_set_full_scale_complete:

	case state_jr3_init_set_full_scale_complete:

		if (!is_complete(channel)) {

		if (!is_complete(sensor)) {

			result = poll_delay_min_max(20, 100);

			result = poll_delay_min_max(20, 100);

		} else {

		} else {

			struct force_array __iomem *fs = &channel->full_scale;

			struct force_array __iomem *fs = &sensor->full_scale;

			union jr3_pci_single_range *r = spriv->range;

			union jr3_pci_single_range *r = spriv->range;





			/* Use ranges in kN or we will overflow around 2000N! */

			/* Use ranges in kN or we will overflow around 2000N! */
@@ -555,24 +553,24 @@ jr3_pci_poll_subdevice(struct comedi_subdevice *s) 
			r[8].l.range[0].min = 0;

			r[8].l.range[0].min = 0;

			r[8].l.range[0].max = 65535;

			r[8].l.range[0].max = 65535;





			use_offset(channel, 0);

			use_offset(sensor, 0);

			spriv->state = state_jr3_init_use_offset_complete;

			spriv->state = state_jr3_init_use_offset_complete;

			/* Allow 40 ms for completion */

			/* Allow 40 ms for completion */

			result = poll_delay_min_max(40, 100);

			result = poll_delay_min_max(40, 100);

		}

		}

		break;

		break;

	case state_jr3_init_use_offset_complete:

	case state_jr3_init_use_offset_complete:

		if (!is_complete(channel)) {

		if (!is_complete(sensor)) {

			result = poll_delay_min_max(20, 100);

			result = poll_delay_min_max(20, 100);

		} else {

		} else {

			set_s16(&channel->offsets.fx, 0);

			set_s16(&sensor->offsets.fx, 0);

			set_s16(&channel->offsets.fy, 0);

			set_s16(&sensor->offsets.fy, 0);

			set_s16(&channel->offsets.fz, 0);

			set_s16(&sensor->offsets.fz, 0);

			set_s16(&channel->offsets.mx, 0);

			set_s16(&sensor->offsets.mx, 0);

			set_s16(&channel->offsets.my, 0);

			set_s16(&sensor->offsets.my, 0);

			set_s16(&channel->offsets.mz, 0);

			set_s16(&sensor->offsets.mz, 0);





			set_offset(channel);

			set_offset(sensor);





			spriv->state = state_jr3_done;

			spriv->state = state_jr3_done;

		}

		}
@@ -602,7 +600,7 @@ static void jr3_pci_poll_dev(unsigned long data) 
	delay = 1000;

	delay = 1000;

	now = jiffies;

	now = jiffies;





	/* Poll all channels that are ready to be polled */

	/* Poll all sensors that are ready to be polled */

	for (i = 0; i < dev->n_subdevices; i++) {

	for (i = 0; i < dev->n_subdevices; i++) {

		s = &dev->subdevices[i];

		s = &dev->subdevices[i];

		spriv = s->private;

		spriv = s->private;
@@ -618,7 +616,7 @@ static void jr3_pci_poll_dev(unsigned long data) 
			if (sub_delay.max && sub_delay.max < delay)

			if (sub_delay.max && sub_delay.max < delay)

				/*

				/*

				 * Wake up as late as possible ->

				 * Wake up as late as possible ->

				 * poll as many channels as possible at once.

				 * poll as many sensors as possible at once.

				 */

				 */

				delay = sub_delay.max;

				delay = sub_delay.max;

		}

		}
@@ -641,7 +639,7 @@ jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s) 
	if (!spriv)

	if (!spriv)

		return NULL;

		return NULL;





	spriv->channel = &iobase->channel[s->index].data;

	spriv->sensor = &iobase->channel[s->index].data;





	for (j = 0; j < 8; j++) {

	for (j = 0; j < 8; j++) {

		spriv->range[j].l.length = 1;

		spriv->range[j].l.length = 1;
@@ -662,9 +660,9 @@ jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s) 
	spriv->maxdata_list[56] = 0xffff;

	spriv->maxdata_list[56] = 0xffff;

	spriv->maxdata_list[57] = 0xffff;

	spriv->maxdata_list[57] = 0xffff;





	dev_dbg(dev->class_dev, "p->channel %p %p (%tx)\n",

	dev_dbg(dev->class_dev, "p->sensor %p %p (%tx)\n",

		spriv->channel, iobase,

		spriv->sensor, iobase,

		((char __iomem *)spriv->channel -

		((char __iomem *)spriv->sensor -

		 (char __iomem *)iobase));

		 (char __iomem *)iobase));





	return spriv;

	return spriv;