Commit bae3ce49 authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: usx2y: Avoid camelCase 

For improving readability, convert camelCase fields, variables and
functions to the plain names with underscore.  Also align the macros
to be capital letters.

All done via sed, no functional changes.

Note that you'll still see many coding style issues even after this
patch; the fixes will follow.

Link: https://lore.kernel.org/r/20210517131545.27252-2-tiwai@suse.de


Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 08fdced6

sound/usb/usx2y/usX2Yhwdep.c

+28 −28
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ static vm_fault_t snd_us428ctls_vm_fault(struct vm_fault *vmf) 
		   vmf->pgoff);

	

	offset = vmf->pgoff << PAGE_SHIFT;

	vaddr = (char *)((struct usX2Ydev *)vmf->vma->vm_private_data)->us428ctls_sharedmem + offset;

	vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->us428ctls_sharedmem + offset;

	page = virt_to_page(vaddr);

	get_page(page);

	vmf->page = page;
@@ -47,7 +47,7 @@ static const struct vm_operations_struct us428ctls_vm_ops = { 
static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area)

{

	unsigned long	size = (unsigned long)(area->vm_end - area->vm_start);

	struct usX2Ydev	*us428 = hw->private_data;

	struct usx2ydev	*us428 = hw->private_data;



	// FIXME this hwdep interface is used twice: fpga download and mmap for controlling Lights etc. Maybe better using 2 hwdep devs?

	// so as long as the device isn't fully initialised yet we return -EBUSY here.
@@ -66,7 +66,7 @@ static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct v 
		if (!us428->us428ctls_sharedmem)

			return -ENOMEM;

		memset(us428->us428ctls_sharedmem, -1, sizeof(struct us428ctls_sharedmem));

		us428->us428ctls_sharedmem->CtlSnapShotLast = -2;

		us428->us428ctls_sharedmem->ctl_snapshot_last = -2;

	}

	area->vm_ops = &us428ctls_vm_ops;

	area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
@@ -77,21 +77,21 @@ static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct v 
static __poll_t snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait)

{

	__poll_t	mask = 0;

	struct usX2Ydev	*us428 = hw->private_data;

	struct usx2ydev	*us428 = hw->private_data;

	struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem;

	if (us428->chip_status & USX2Y_STAT_CHIP_HUP)

		return EPOLLHUP;



	poll_wait(file, &us428->us428ctls_wait_queue_head, wait);



	if (shm != NULL && shm->CtlSnapShotLast != shm->CtlSnapShotRed)

	if (shm != NULL && shm->ctl_snapshot_last != shm->ctl_snapshot_red)

		mask |= EPOLLIN;



	return mask;

}





static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw,

static int snd_usx2y_hwdep_dsp_status(struct snd_hwdep *hw,

				      struct snd_hwdep_dsp_status *info)

{

	static const char * const type_ids[USX2Y_TYPE_NUMS] = {
@@ -99,7 +99,7 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, 
		[USX2Y_TYPE_224] = "us224",

		[USX2Y_TYPE_428] = "us428",

	};

	struct usX2Ydev	*us428 = hw->private_data;

	struct usx2ydev	*us428 = hw->private_data;

	int id = -1;



	switch (le16_to_cpu(us428->dev->descriptor.idProduct)) {
@@ -124,7 +124,7 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, 
}





static int usX2Y_create_usbmidi(struct snd_card *card)

static int usx2y_create_usbmidi(struct snd_card *card)

{

	static const struct snd_usb_midi_endpoint_info quirk_data_1 = {

		.out_ep = 0x06,
@@ -152,28 +152,28 @@ static int usX2Y_create_usbmidi(struct snd_card *card) 
       		.type = QUIRK_MIDI_FIXED_ENDPOINT,

		.data = &quirk_data_2

	};

	struct usb_device *dev = usX2Y(card)->dev;

	struct usb_device *dev = usx2y(card)->dev;

	struct usb_interface *iface = usb_ifnum_to_if(dev, 0);

	const struct snd_usb_audio_quirk *quirk =

		le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ?

		&quirk_2 : &quirk_1;



	snd_printdd("usX2Y_create_usbmidi \n");

	return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk);

	snd_printdd("usx2y_create_usbmidi \n");

	return snd_usbmidi_create(card, iface, &usx2y(card)->midi_list, quirk);

}



static int usX2Y_create_alsa_devices(struct snd_card *card)

static int usx2y_create_alsa_devices(struct snd_card *card)

{

	int err;



	do {

		if ((err = usX2Y_create_usbmidi(card)) < 0) {

			snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i \n", err);

		if ((err = usx2y_create_usbmidi(card)) < 0) {

			snd_printk(KERN_ERR "usx2y_create_alsa_devices: usx2y_create_usbmidi error %i \n", err);

			break;

		}

		if ((err = usX2Y_audio_create(card)) < 0) 

		if ((err = usx2y_audio_create(card)) < 0) 

			break;

		if ((err = usX2Y_hwdep_pcm_new(card)) < 0)

		if ((err = usx2y_hwdep_pcm_new(card)) < 0)

			break;

		if ((err = snd_card_register(card)) < 0)

			break;
@@ -182,10 +182,10 @@ static int usX2Y_create_alsa_devices(struct snd_card *card) 
	return err;

} 



static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw,

static int snd_usx2y_hwdep_dsp_load(struct snd_hwdep *hw,

				    struct snd_hwdep_dsp_image *dsp)

{

	struct usX2Ydev *priv = hw->private_data;

	struct usx2ydev *priv = hw->private_data;

	struct usb_device* dev = priv->dev;

	int lret, err;

	char *buf;
@@ -206,19 +206,19 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, 
		return err;

	if (dsp->index == 1) {

		msleep(250);				// give the device some time

		err = usX2Y_AsyncSeq04_init(priv);

		err = usx2y_async_seq04_init(priv);

		if (err) {

			snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error \n");

			snd_printk(KERN_ERR "usx2y_async_seq04_init error \n");

			return err;

		}

		err = usX2Y_In04_init(priv);

		err = usx2y_in04_init(priv);

		if (err) {

			snd_printk(KERN_ERR "usX2Y_In04_init error \n");

			snd_printk(KERN_ERR "usx2y_in04_init error \n");

			return err;

		}

		err = usX2Y_create_alsa_devices(hw->card);

		err = usx2y_create_alsa_devices(hw->card);

		if (err) {

			snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i \n", err);

			snd_printk(KERN_ERR "usx2y_create_alsa_devices error %i \n", err);

			snd_card_free(hw->card);

			return err;

		}
@@ -229,7 +229,7 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, 
}





int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device)

int usx2y_hwdep_new(struct snd_card *card, struct usb_device* device)

{

	int err;

	struct snd_hwdep *hw;
@@ -238,9 +238,9 @@ int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device) 
		return err;



	hw->iface = SNDRV_HWDEP_IFACE_USX2Y;

	hw->private_data = usX2Y(card);

	hw->ops.dsp_status = snd_usX2Y_hwdep_dsp_status;

	hw->ops.dsp_load = snd_usX2Y_hwdep_dsp_load;

	hw->private_data = usx2y(card);

	hw->ops.dsp_status = snd_usx2y_hwdep_dsp_status;

	hw->ops.dsp_load = snd_usx2y_hwdep_dsp_load;

	hw->ops.mmap = snd_us428ctls_mmap;

	hw->ops.poll = snd_us428ctls_poll;

	hw->exclusive = 1;

sound/usb/usx2y/usX2Yhwdep.h

+1 −1
Original line number Diff line number Diff line
@@ -2,6 +2,6 @@ 
#ifndef USX2YHWDEP_H

#define USX2YHWDEP_H



int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device);

int usx2y_hwdep_new(struct snd_card *card, struct usb_device* device);



#endif

sound/usb/usx2y/usbus428ctldefs.h

+51 −51
Original line number Diff line number Diff line
@@ -4,28 +4,28 @@ 
 * Copyright (c) 2003 by Karsten Wiese <annabellesgarden@yahoo.de>

 */



enum E_In84{

	eFader0 = 0,

	eFader1,

	eFader2,

	eFader3,

	eFader4,

	eFader5,

	eFader6,

	eFader7,

	eFaderM,

	eTransport,

	eModifier = 10,

	eFilterSelect,

	eSelect,

	eMute,

enum E_IN84 {

	E_FADER_0 = 0,

	E_FADER_1,

	E_FADER_2,

	E_FADER_3,

	E_FADER_4,

	E_FADER_5,

	E_FADER_6,

	E_FADER_7,

	E_FADER_M,

	E_TRANSPORT,

	E_MODIFIER = 10,

	E_FILTER_SELECT,

	E_SELECT,

	E_MUTE,



	eSwitch   = 15,

	eWheelGain,

	eWheelFreq,

	eWheelQ,

	eWheelPan,

	eWheel    = 20

	E_SWITCH   = 15,

	E_WHEEL_GAIN,

	E_WHEEL_FREQ,

	E_WHEEL_Q,

	E_WHEEL_PAN,

	E_WHEEL    = 20

};



#define T_RECORD   1
@@ -39,53 +39,53 @@ enum E_In84{ 




struct us428_ctls {

	unsigned char   Fader[9];

	unsigned char 	Transport;

	unsigned char 	Modifier;

	unsigned char 	FilterSelect;

	unsigned char 	Select;

	unsigned char   Mute;

	unsigned char   UNKNOWN;

	unsigned char   Switch;	     

	unsigned char   Wheel[5];

	unsigned char   fader[9];

	unsigned char 	transport;

	unsigned char 	modifier;

	unsigned char 	filters_elect;

	unsigned char 	select;

	unsigned char   mute;

	unsigned char   unknown;

	unsigned char   wswitch;	     

	unsigned char   wheel[5];

};



struct us428_setByte {

	unsigned char Offset,

		Value;

struct us428_set_byte {

	unsigned char offset,

		value;

};



enum {

	eLT_Volume = 0,

	eLT_Light

	ELT_VOLUME = 0,

	ELT_LIGHT

};



struct usX2Y_volume {

	unsigned char Channel,

		LH,

		LL,

		RH,

		RL;

struct usx2y_volume {

	unsigned char channel,

		lh,

		ll,

		rh,

		rl;

};



struct us428_lights {

	struct us428_setByte Light[7];

	struct us428_set_byte light[7];

};



struct us428_p4out {

	char type;

	union {

		struct usX2Y_volume vol;

		struct usx2y_volume vol;

		struct us428_lights lights;

	} val;

};



#define N_us428_ctl_BUFS 16

#define N_us428_p4out_BUFS 16

#define N_US428_CTL_BUFS 16

#define N_US428_P4OUT_BUFS 16

struct us428ctls_sharedmem {

	struct us428_ctls	CtlSnapShot[N_us428_ctl_BUFS];

	int			CtlSnapShotDiffersAt[N_us428_ctl_BUFS];

	int			CtlSnapShotLast, CtlSnapShotRed;

	struct us428_p4out	p4out[N_us428_p4out_BUFS];

	int			p4outLast, p4outSent;

	struct us428_ctls	ctl_snapshot[N_US428_CTL_BUFS];

	int			ctl_snapshot_differs_at[N_US428_CTL_BUFS];

	int			ctl_snapshot_last, ctl_snapshot_red;

	struct us428_p4out	p4out[N_US428_P4OUT_BUFS];

	int			p4out_last, p4out_sent;

};

sound/usb/usx2y/usbusx2y.c

+109 −109
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ 


2004-10-26 Karsten Wiese

	Version 0.8.6:

	wake_up() process waiting in usX2Y_urbs_start() on error.

	wake_up() process waiting in usx2y_urbs_start() on error.



2004-10-21 Karsten Wiese

	Version 0.8.5:
@@ -48,7 +48,7 @@ 
2004-06-12 Karsten Wiese

	Version 0.6.3:

	Made it thus the following rule is enforced:

	"All pcm substreams of one usX2Y have to operate at the same rate & format."

	"All pcm substreams of one usx2y have to operate at the same rate & format."



2004-04-06 Karsten Wiese

	Version 0.6.0:
@@ -150,161 +150,161 @@ module_param_array(enable, bool, NULL, 0444); 
MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS".");





static int snd_usX2Y_card_used[SNDRV_CARDS];

static int snd_usx2y_card_used[SNDRV_CARDS];



static void usX2Y_usb_disconnect(struct usb_device* usb_device, void* ptr);

static void snd_usX2Y_card_private_free(struct snd_card *card);

static void usx2y_usb_disconnect(struct usb_device* usb_device, void* ptr);

static void snd_usx2y_card_private_free(struct snd_card *card);



/* 

 * pipe 4 is used for switching the lamps, setting samplerate, volumes ....   

 */

static void i_usX2Y_Out04Int(struct urb *urb)

static void i_usx2y_out04_int(struct urb *urb)

{

#ifdef CONFIG_SND_DEBUG

	if (urb->status) {

		int 		i;

		struct usX2Ydev *usX2Y = urb->context;

		for (i = 0; i < 10 && usX2Y->AS04.urb[i] != urb; i++);

		snd_printdd("i_usX2Y_Out04Int() urb %i status=%i\n", i, urb->status);

		struct usx2ydev *usx2y = urb->context;

		for (i = 0; i < 10 && usx2y->as04.urb[i] != urb; i++);

		snd_printdd("i_usx2y_out04_int() urb %i status=%i\n", i, urb->status);

	}

#endif

}



static void i_usX2Y_In04Int(struct urb *urb)

static void i_usx2y_in04_int(struct urb *urb)

{

	int			err = 0;

	struct usX2Ydev		*usX2Y = urb->context;

	struct us428ctls_sharedmem	*us428ctls = usX2Y->us428ctls_sharedmem;

	struct usx2ydev		*usx2y = urb->context;

	struct us428ctls_sharedmem	*us428ctls = usx2y->us428ctls_sharedmem;



	usX2Y->In04IntCalls++;

	usx2y->in04_int_calls++;



	if (urb->status) {

		snd_printdd("Interrupt Pipe 4 came back with status=%i\n", urb->status);

		return;

	}



	//	printk("%i:0x%02X ", 8, (int)((unsigned char*)usX2Y->In04Buf)[8]); Master volume shows 0 here if fader is at max during boot ?!?

	//	printk("%i:0x%02X ", 8, (int)((unsigned char*)usx2y->in04_buf)[8]); Master volume shows 0 here if fader is at max during boot ?!?

	if (us428ctls) {

		int diff = -1;

		if (-2 == us428ctls->CtlSnapShotLast) {

		if (-2 == us428ctls->ctl_snapshot_last) {

			diff = 0;

			memcpy(usX2Y->In04Last, usX2Y->In04Buf, sizeof(usX2Y->In04Last));

			us428ctls->CtlSnapShotLast = -1;

			memcpy(usx2y->in04_last, usx2y->in04_buf, sizeof(usx2y->in04_last));

			us428ctls->ctl_snapshot_last = -1;

		} else {

			int i;

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

				if (usX2Y->In04Last[i] != ((char*)usX2Y->In04Buf)[i]) {

				if (usx2y->in04_last[i] != ((char*)usx2y->in04_buf)[i]) {

					if (diff < 0)

						diff = i;

					usX2Y->In04Last[i] = ((char*)usX2Y->In04Buf)[i];

					usx2y->in04_last[i] = ((char*)usx2y->in04_buf)[i];

				}

			}

		}

		if (0 <= diff) {

			int n = us428ctls->CtlSnapShotLast + 1;

			if (n >= N_us428_ctl_BUFS  ||  n < 0)

			int n = us428ctls->ctl_snapshot_last + 1;

			if (n >= N_US428_CTL_BUFS  ||  n < 0)

				n = 0;

			memcpy(us428ctls->CtlSnapShot + n, usX2Y->In04Buf, sizeof(us428ctls->CtlSnapShot[0]));

			us428ctls->CtlSnapShotDiffersAt[n] = diff;

			us428ctls->CtlSnapShotLast = n;

			wake_up(&usX2Y->us428ctls_wait_queue_head);

			memcpy(us428ctls->ctl_snapshot + n, usx2y->in04_buf, sizeof(us428ctls->ctl_snapshot[0]));

			us428ctls->ctl_snapshot_differs_at[n] = diff;

			us428ctls->ctl_snapshot_last = n;

			wake_up(&usx2y->us428ctls_wait_queue_head);

		}

	}

	

	

	if (usX2Y->US04) {

		if (0 == usX2Y->US04->submitted)

	if (usx2y->us04) {

		if (0 == usx2y->us04->submitted)

			do {

				err = usb_submit_urb(usX2Y->US04->urb[usX2Y->US04->submitted++], GFP_ATOMIC);

			} while (!err && usX2Y->US04->submitted < usX2Y->US04->len);

				err = usb_submit_urb(usx2y->us04->urb[usx2y->us04->submitted++], GFP_ATOMIC);

			} while (!err && usx2y->us04->submitted < usx2y->us04->len);

	} else

		if (us428ctls && us428ctls->p4outLast >= 0 && us428ctls->p4outLast < N_us428_p4out_BUFS) {

			if (us428ctls->p4outLast != us428ctls->p4outSent) {

				int j, send = us428ctls->p4outSent + 1;

				if (send >= N_us428_p4out_BUFS)

		if (us428ctls && us428ctls->p4out_last >= 0 && us428ctls->p4out_last < N_US428_P4OUT_BUFS) {

			if (us428ctls->p4out_last != us428ctls->p4out_sent) {

				int j, send = us428ctls->p4out_sent + 1;

				if (send >= N_US428_P4OUT_BUFS)

					send = 0;

				for (j = 0; j < URBS_AsyncSeq  &&  !err; ++j)

					if (0 == usX2Y->AS04.urb[j]->status) {

				for (j = 0; j < URBS_ASYNC_SEQ  &&  !err; ++j)

					if (0 == usx2y->as04.urb[j]->status) {

						struct us428_p4out *p4out = us428ctls->p4out + send;	// FIXME if more than 1 p4out is new, 1 gets lost.

						usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->dev,

								  usb_sndbulkpipe(usX2Y->dev, 0x04), &p4out->val.vol,

								  p4out->type == eLT_Light ? sizeof(struct us428_lights) : 5,

								  i_usX2Y_Out04Int, usX2Y);

						err = usb_submit_urb(usX2Y->AS04.urb[j], GFP_ATOMIC);

						us428ctls->p4outSent = send;

						usb_fill_bulk_urb(usx2y->as04.urb[j], usx2y->dev,

								  usb_sndbulkpipe(usx2y->dev, 0x04), &p4out->val.vol,

								  p4out->type == ELT_LIGHT ? sizeof(struct us428_lights) : 5,

								  i_usx2y_out04_int, usx2y);

						err = usb_submit_urb(usx2y->as04.urb[j], GFP_ATOMIC);

						us428ctls->p4out_sent = send;

						break;

					}

			}

		}



	if (err)

		snd_printk(KERN_ERR "In04Int() usb_submit_urb err=%i\n", err);

		snd_printk(KERN_ERR "in04_int() usb_submit_urb err=%i\n", err);



	urb->dev = usX2Y->dev;

	urb->dev = usx2y->dev;

	usb_submit_urb(urb, GFP_ATOMIC);

}



/*

 * Prepare some urbs

 */

int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y)

int usx2y_async_seq04_init(struct usx2ydev *usx2y)

{

	int	err = 0,

		i;



	usX2Y->AS04.buffer = kmalloc_array(URBS_AsyncSeq,

					   URB_DataLen_AsyncSeq, GFP_KERNEL);

	if (NULL == usX2Y->AS04.buffer) {

	usx2y->as04.buffer = kmalloc_array(URBS_ASYNC_SEQ,

					   URB_DATA_LEN_ASYNC_SEQ, GFP_KERNEL);

	if (NULL == usx2y->as04.buffer) {

		err = -ENOMEM;

	} else

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

			if (NULL == (usX2Y->AS04.urb[i] = usb_alloc_urb(0, GFP_KERNEL))) {

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

			if (NULL == (usx2y->as04.urb[i] = usb_alloc_urb(0, GFP_KERNEL))) {

				err = -ENOMEM;

				break;

			}

			usb_fill_bulk_urb(	usX2Y->AS04.urb[i], usX2Y->dev,

						usb_sndbulkpipe(usX2Y->dev, 0x04),

						usX2Y->AS04.buffer + URB_DataLen_AsyncSeq*i, 0,

						i_usX2Y_Out04Int, usX2Y

			usb_fill_bulk_urb(	usx2y->as04.urb[i], usx2y->dev,

						usb_sndbulkpipe(usx2y->dev, 0x04),

						usx2y->as04.buffer + URB_DATA_LEN_ASYNC_SEQ*i, 0,

						i_usx2y_out04_int, usx2y

				);

			err = usb_urb_ep_type_check(usX2Y->AS04.urb[i]);

			err = usb_urb_ep_type_check(usx2y->as04.urb[i]);

			if (err < 0)

				break;

		}

	return err;

}



int usX2Y_In04_init(struct usX2Ydev *usX2Y)

int usx2y_in04_init(struct usx2ydev *usx2y)

{

	if (! (usX2Y->In04urb = usb_alloc_urb(0, GFP_KERNEL)))

	if (! (usx2y->in04_urb = usb_alloc_urb(0, GFP_KERNEL)))

		return -ENOMEM;



	if (! (usX2Y->In04Buf = kmalloc(21, GFP_KERNEL)))

	if (! (usx2y->in04_buf = kmalloc(21, GFP_KERNEL)))

		return -ENOMEM;

	 

	init_waitqueue_head(&usX2Y->In04WaitQueue);

	usb_fill_int_urb(usX2Y->In04urb, usX2Y->dev, usb_rcvintpipe(usX2Y->dev, 0x4),

			 usX2Y->In04Buf, 21,

			 i_usX2Y_In04Int, usX2Y,

	init_waitqueue_head(&usx2y->in04_wait_queue);

	usb_fill_int_urb(usx2y->in04_urb, usx2y->dev, usb_rcvintpipe(usx2y->dev, 0x4),

			 usx2y->in04_buf, 21,

			 i_usx2y_in04_int, usx2y,

			 10);

	if (usb_urb_ep_type_check(usX2Y->In04urb))

	if (usb_urb_ep_type_check(usx2y->in04_urb))

		return -EINVAL;

	return usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);

	return usb_submit_urb(usx2y->in04_urb, GFP_KERNEL);

}



static void usX2Y_unlinkSeq(struct snd_usX2Y_AsyncSeq *S)

static void usx2y_unlinkseq(struct snd_usx2y_async_seq *s)

{

	int	i;

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

		usb_kill_urb(S->urb[i]);

		usb_free_urb(S->urb[i]);

		S->urb[i] = NULL;

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

		usb_kill_urb(s->urb[i]);

		usb_free_urb(s->urb[i]);

		s->urb[i] = NULL;

	}

	kfree(S->buffer);

	kfree(s->buffer);

}





static const struct usb_device_id snd_usX2Y_usb_id_table[] = {

static const struct usb_device_id snd_usx2y_usb_id_table[] = {

	{

		.match_flags =	USB_DEVICE_ID_MATCH_DEVICE,

		.idVendor =	0x1604,
@@ -323,7 +323,7 @@ static const struct usb_device_id snd_usX2Y_usb_id_table[] = { 
	{ /* terminator */ }

};



static int usX2Y_create_card(struct usb_device *device,

static int usx2y_create_card(struct usb_device *device,

			     struct usb_interface *intf,

			     struct snd_card **cardp)

{
@@ -332,20 +332,20 @@ static int usX2Y_create_card(struct usb_device *device, 
	int err;



	for (dev = 0; dev < SNDRV_CARDS; ++dev)

		if (enable[dev] && !snd_usX2Y_card_used[dev])

		if (enable[dev] && !snd_usx2y_card_used[dev])

			break;

	if (dev >= SNDRV_CARDS)

		return -ENODEV;

	err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE,

			   sizeof(struct usX2Ydev), &card);

			   sizeof(struct usx2ydev), &card);

	if (err < 0)

		return err;

	snd_usX2Y_card_used[usX2Y(card)->card_index = dev] = 1;

	card->private_free = snd_usX2Y_card_private_free;

	usX2Y(card)->dev = device;

	init_waitqueue_head(&usX2Y(card)->prepare_wait_queue);

	mutex_init(&usX2Y(card)->pcm_mutex);

	INIT_LIST_HEAD(&usX2Y(card)->midi_list);

	snd_usx2y_card_used[usx2y(card)->card_index = dev] = 1;

	card->private_free = snd_usx2y_card_private_free;

	usx2y(card)->dev = device;

	init_waitqueue_head(&usx2y(card)->prepare_wait_queue);

	mutex_init(&usx2y(card)->pcm_mutex);

	INIT_LIST_HEAD(&usx2y(card)->midi_list);

	strcpy(card->driver, "USB "NAME_ALLCAPS"");

	sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");

	sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
@@ -353,14 +353,14 @@ static int usX2Y_create_card(struct usb_device *device, 
		le16_to_cpu(device->descriptor.idVendor),

		le16_to_cpu(device->descriptor.idProduct),

		0,//us428(card)->usbmidi.ifnum,

		usX2Y(card)->dev->bus->busnum, usX2Y(card)->dev->devnum

		usx2y(card)->dev->bus->busnum, usx2y(card)->dev->devnum

		);

	*cardp = card;

	return 0;

}





static int usX2Y_usb_probe(struct usb_device *device,

static int usx2y_usb_probe(struct usb_device *device,

			   struct usb_interface *intf,

			   const struct usb_device_id *device_id,

			   struct snd_card **cardp)
@@ -375,10 +375,10 @@ static int usX2Y_usb_probe(struct usb_device *device, 
	     le16_to_cpu(device->descriptor.idProduct) != USB_ID_US428))

		return -EINVAL;



	err = usX2Y_create_card(device, intf, &card);

	err = usx2y_create_card(device, intf, &card);

	if (err < 0)

		return err;

	if ((err = usX2Y_hwdep_new(card, device)) < 0  ||

	if ((err = usx2y_hwdep_new(card, device)) < 0  ||

	    (err = snd_card_register(card)) < 0) {

		snd_card_free(card);

		return err;
@@ -390,64 +390,64 @@ static int usX2Y_usb_probe(struct usb_device *device, 
/*

 * new 2.5 USB kernel API

 */

static int snd_usX2Y_probe(struct usb_interface *intf, const struct usb_device_id *id)

static int snd_usx2y_probe(struct usb_interface *intf, const struct usb_device_id *id)

{

	struct snd_card *card;

	int err;



	err = usX2Y_usb_probe(interface_to_usbdev(intf), intf, id, &card);

	err = usx2y_usb_probe(interface_to_usbdev(intf), intf, id, &card);

	if (err < 0)

		return err;

	dev_set_drvdata(&intf->dev, card);

	return 0;

}



static void snd_usX2Y_disconnect(struct usb_interface *intf)

static void snd_usx2y_disconnect(struct usb_interface *intf)

{

	usX2Y_usb_disconnect(interface_to_usbdev(intf),

	usx2y_usb_disconnect(interface_to_usbdev(intf),

				 usb_get_intfdata(intf));

}



MODULE_DEVICE_TABLE(usb, snd_usX2Y_usb_id_table);

static struct usb_driver snd_usX2Y_usb_driver = {

MODULE_DEVICE_TABLE(usb, snd_usx2y_usb_id_table);

static struct usb_driver snd_usx2y_usb_driver = {

	.name =		"snd-usb-usx2y",

	.probe =	snd_usX2Y_probe,

	.disconnect =	snd_usX2Y_disconnect,

	.id_table =	snd_usX2Y_usb_id_table,

	.probe =	snd_usx2y_probe,

	.disconnect =	snd_usx2y_disconnect,

	.id_table =	snd_usx2y_usb_id_table,

};



static void snd_usX2Y_card_private_free(struct snd_card *card)

static void snd_usx2y_card_private_free(struct snd_card *card)

{

	kfree(usX2Y(card)->In04Buf);

	usb_free_urb(usX2Y(card)->In04urb);

	if (usX2Y(card)->us428ctls_sharedmem)

		free_pages_exact(usX2Y(card)->us428ctls_sharedmem,

				 sizeof(*usX2Y(card)->us428ctls_sharedmem));

	if (usX2Y(card)->card_index >= 0  &&  usX2Y(card)->card_index < SNDRV_CARDS)

		snd_usX2Y_card_used[usX2Y(card)->card_index] = 0;

	kfree(usx2y(card)->in04_buf);

	usb_free_urb(usx2y(card)->in04_urb);

	if (usx2y(card)->us428ctls_sharedmem)

		free_pages_exact(usx2y(card)->us428ctls_sharedmem,

				 sizeof(*usx2y(card)->us428ctls_sharedmem));

	if (usx2y(card)->card_index >= 0  &&  usx2y(card)->card_index < SNDRV_CARDS)

		snd_usx2y_card_used[usx2y(card)->card_index] = 0;

}



/*

 * Frees the device.

 */

static void usX2Y_usb_disconnect(struct usb_device *device, void* ptr)

static void usx2y_usb_disconnect(struct usb_device *device, void* ptr)

{

	if (ptr) {

		struct snd_card *card = ptr;

		struct usX2Ydev *usX2Y = usX2Y(card);

		struct usx2ydev *usx2y = usx2y(card);

		struct list_head *p;

		usX2Y->chip_status = USX2Y_STAT_CHIP_HUP;

		usX2Y_unlinkSeq(&usX2Y->AS04);

		usb_kill_urb(usX2Y->In04urb);

		usx2y->chip_status = USX2Y_STAT_CHIP_HUP;

		usx2y_unlinkseq(&usx2y->as04);

		usb_kill_urb(usx2y->in04_urb);

		snd_card_disconnect(card);

		/* release the midi resources */

		list_for_each(p, &usX2Y->midi_list) {

		list_for_each(p, &usx2y->midi_list) {

			snd_usbmidi_disconnect(p);

		}

		if (usX2Y->us428ctls_sharedmem) 

			wake_up(&usX2Y->us428ctls_wait_queue_head);

		if (usx2y->us428ctls_sharedmem) 

			wake_up(&usx2y->us428ctls_wait_queue_head);

		snd_card_free(card);

	}

}



module_usb_driver(snd_usX2Y_usb_driver);
 
module_usb_driver(snd_usx2y_usb_driver);

sound/usb/usx2y/usbusx2y.h

+29 −29
Original line number Diff line number Diff line
@@ -8,14 +8,14 @@ 
#define NRURBS	        2	





#define URBS_AsyncSeq 10

#define URB_DataLen_AsyncSeq 32

struct snd_usX2Y_AsyncSeq {

	struct urb	*urb[URBS_AsyncSeq];

#define URBS_ASYNC_SEQ 10

#define URB_DATA_LEN_ASYNC_SEQ 32

struct snd_usx2y_async_seq {

	struct urb	*urb[URBS_ASYNC_SEQ];

	char		*buffer;

};



struct snd_usX2Y_urbSeq {

struct snd_usx2y_urb_seq {

	int	submitted;

	int	len;

	struct urb	*urb[];
@@ -23,17 +23,17 @@ struct snd_usX2Y_urbSeq { 


#include "usx2yhwdeppcm.h"



struct usX2Ydev {

struct usx2ydev {

	struct usb_device	*dev;

	int			card_index;

	int			stride;

	struct urb		*In04urb;

	void			*In04Buf;

	char			In04Last[24];

	unsigned		In04IntCalls;

	struct snd_usX2Y_urbSeq	*US04;

	wait_queue_head_t	In04WaitQueue;

	struct snd_usX2Y_AsyncSeq	AS04;

	struct urb		*in04_urb;

	void			*in04_buf;

	char			in04_last[24];

	unsigned		in04_int_calls;

	struct snd_usx2y_urb_seq	*us04;

	wait_queue_head_t	in04_wait_queue;

	struct snd_usx2y_async_seq	as04;

	unsigned int		rate,

				format;

	int			chip_status;
@@ -41,9 +41,9 @@ struct usX2Ydev { 
	struct us428ctls_sharedmem	*us428ctls_sharedmem;

	int			wait_iso_frame;

	wait_queue_head_t	us428ctls_wait_queue_head;

	struct snd_usX2Y_hwdep_pcm_shm	*hwdep_pcm_shm;

	struct snd_usX2Y_substream	*subs[4];

	struct snd_usX2Y_substream	* volatile  prepare_subs;

	struct snd_usx2y_hwdep_pcm_shm	*hwdep_pcm_shm;

	struct snd_usx2y_substream	*subs[4];

	struct snd_usx2y_substream	* volatile  prepare_subs;

	wait_queue_head_t	prepare_wait_queue;

	struct list_head	midi_list;

	struct list_head	pcm_list;
@@ -51,21 +51,21 @@ struct usX2Ydev { 
};





struct snd_usX2Y_substream {

	struct usX2Ydev	*usX2Y;

struct snd_usx2y_substream {

	struct usx2ydev	*usx2y;

	struct snd_pcm_substream *pcm_substream;



	int			endpoint;		

	unsigned int		maxpacksize;		/* max packet size in bytes */



	atomic_t		state;

#define state_STOPPED	0

#define state_STARTING1 1

#define state_STARTING2 2

#define state_STARTING3 3

#define state_PREPARED	4

#define state_PRERUNNING  6

#define state_RUNNING	8

#define STATE_STOPPED	0

#define STATE_STARTING1 1

#define STATE_STARTING2 2

#define STATE_STARTING3 3

#define STATE_PREPARED	4

#define STATE_PRERUNNING  6

#define STATE_RUNNING	8



	int			hwptr;			/* free frame position in the buffer (only for playback) */

	int			hwptr_done;		/* processed frame position in the buffer */
@@ -77,12 +77,12 @@ struct snd_usX2Y_substream { 
};





#define usX2Y(c) ((struct usX2Ydev *)(c)->private_data)

#define usx2y(c) ((struct usx2ydev *)(c)->private_data)



int usX2Y_audio_create(struct snd_card *card);

int usx2y_audio_create(struct snd_card *card);



int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y);

int usX2Y_In04_init(struct usX2Ydev *usX2Y);

int usx2y_async_seq04_init(struct usx2ydev *usx2y);

int usx2y_in04_init(struct usx2ydev *usx2y);



#define NAME_ALLCAPS "US-X2Y"