自学教程：C++ spin_lock_irq函数代码示例

//.........这里部分代码省略.........//	printk("[%d]:ring_buf_num %d/n", substream->stream, ring_buf_num);	/* return if this is a bufferless transfer e.g.	 * codec <--> BT codec or GSM modem -- lg FIXME */	if (!dma)		return 0;	/* this may get called several times by oss emulation	 * with different params */	if (prtd->params == NULL) {		prtd->params = dma;		s3cdbg("params %p, client %p, channel %d/n", prtd->params,			prtd->params->client, prtd->params->channel);		/* prepare DMA */		ret = s3c2410_dma_request(prtd->params->channel,					  prtd->params->client, NULL);		if (ret) {			printk(KERN_ERR "failed to get dma channel/n");			return ret;		}	} else if (prtd->params != dma) {		s3c2410_dma_free(prtd->params->channel, prtd->params->client);		prtd->params = dma;		s3cdbg("params %p, client %p, channel %d/n", prtd->params,			prtd->params->client, prtd->params->channel);		/* prepare DMA */		ret = s3c2410_dma_request(prtd->params->channel,					  prtd->params->client, NULL);		if (ret) {			printk(KERN_ERR "failed to get dma channel/n");			return ret;		}	}	/* channel needs configuring for mem=>device, increment memory addr,	 * sync to pclk, half-word transfers to the IIS-FIFO. */#if !defined (CONFIG_CPU_S3C6400) && !defined (CONFIG_CPU_S3C6410)  && !defined(CONFIG_CPU_S5PC100) && !defined (CONFIG_CPU_S5P6440)	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {		s3c2410_dma_devconfig(prtd->params->channel,				S3C2410_DMASRC_MEM, S3C2410_DISRCC_INC |				S3C2410_DISRCC_APB, prtd->params->dma_addr);		s3c2410_dma_config(prtd->params->channel,				prtd->params->dma_size,				S3C2410_DCON_SYNC_PCLK | 				S3C2410_DCON_HANDSHAKE);	} else {		s3c2410_dma_config(prtd->params->channel,				prtd->params->dma_size,				S3C2410_DCON_HANDSHAKE | 				S3C2410_DCON_SYNC_PCLK);		s3c2410_dma_devconfig(prtd->params->channel,					S3C2410_DMASRC_HW, 0x3,					prtd->params->dma_addr);	}#else	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {		s3c2410_dma_devconfig(prtd->params->channel,				S3C2410_DMASRC_MEM, 0,				prtd->params->dma_addr);		s3c2410_dma_config(prtd->params->channel,				prtd->params->dma_size, 0);	} else {		s3c2410_dma_devconfig(prtd->params->channel,				S3C2410_DMASRC_HW, 0,				prtd->params->dma_addr);				s3c2410_dma_config(prtd->params->channel,				prtd->params->dma_size, 0);	}#endif	s3c2410_dma_set_buffdone_fn(prtd->params->channel,				    s3c24xx_audio_buffdone);	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);	runtime->dma_bytes = totbytes;	spin_lock_irq(&prtd->lock);	prtd->dma_limit = runtime->hw.periods_min;	prtd->dma_period = params_period_bytes(params);	prtd->dma_start = runtime->dma_addr;	prtd->dma_pos = prtd->dma_start;	prtd->dma_end = prtd->dma_start + totbytes;	spin_unlock_irq(&prtd->lock);	s3cdbg("Entered %s, line %d /n", __FUNCTION__, __LINE__);	return 0;}

/* * Wireless Handler: set encode mode */int iwctl_siwencode(struct net_device *dev, struct iw_request_info *info,		union iwreq_data *wrqu, char *extra){	struct vnt_private *pDevice = netdev_priv(dev);	struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;	struct iw_point *wrq = &wrqu->encoding;	u32 dwKeyIndex = (u32)(wrq->flags & IW_ENCODE_INDEX);	int ii;	int uu;	int rc = 0;	int index = (wrq->flags & IW_ENCODE_INDEX);	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODE/n");	if (pMgmt == NULL)		return -EFAULT;	// Check the size of the key	if (wrq->length > WLAN_WEP232_KEYLEN) {		rc = -EINVAL;		return rc;	}	if (dwKeyIndex > WLAN_WEP_NKEYS) {		rc = -EINVAL;		return rc;	}	if (dwKeyIndex > 0)		dwKeyIndex--;	// Send the key to the card	if (wrq->length > 0) {		if (wrq->length == WLAN_WEP232_KEYLEN) {			DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 232 bit wep key/n");		} else if (wrq->length == WLAN_WEP104_KEYLEN) {			DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 104 bit wep key/n");		} else if (wrq->length == WLAN_WEP40_KEYLEN) {			DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 40 bit wep key, index= %d/n", (int)dwKeyIndex);		}		memset(pDevice->abyKey, 0, WLAN_WEP232_KEYLEN);		memcpy(pDevice->abyKey, extra, wrq->length);		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"abyKey: ");		for (ii = 0; ii < wrq->length; ii++)			DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pDevice->abyKey[ii]);		if (pDevice->flags & DEVICE_FLAGS_OPENED) {			spin_lock_irq(&pDevice->lock);			KeybSetDefaultKey(pDevice,					&(pDevice->sKey),					dwKeyIndex | (1 << 31),					wrq->length, NULL,					pDevice->abyKey,					KEY_CTL_WEP);			spin_unlock_irq(&pDevice->lock);		}		pDevice->byKeyIndex = (u8)dwKeyIndex;		pDevice->uKeyLength = wrq->length;		pDevice->bTransmitKey = true;		pDevice->bEncryptionEnable = true;		pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;		// Do we want to just set the transmit key index?		if (index < 4) {			pDevice->byKeyIndex = index;		} else if (!(wrq->flags & IW_ENCODE_MODE)) {			rc = -EINVAL;			return rc;		}	}	// Read the flags	if (wrq->flags & IW_ENCODE_DISABLED) {		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable WEP function/n");		pMgmt->bShareKeyAlgorithm = false;		pDevice->bEncryptionEnable = false;		pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;		if (pDevice->flags & DEVICE_FLAGS_OPENED) {			spin_lock_irq(&pDevice->lock);			for (uu = 0; uu < MAX_KEY_TABLE; uu++)				MACvDisableKeyEntry(pDevice, uu);			spin_unlock_irq(&pDevice->lock);		}	}	if (wrq->flags & IW_ENCODE_RESTRICTED) {		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable WEP & ShareKey System/n");		pMgmt->bShareKeyAlgorithm = true;	}	if (wrq->flags & IW_ENCODE_OPEN) {		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable WEP & Open System/n");		pMgmt->bShareKeyAlgorithm = false;	}	memset(pMgmt->abyDesireBSSID, 0xFF, 6);	return rc;}

/* * Wireless Handler: set operation mode */int iwctl_siwmode(struct net_device *dev, struct iw_request_info *info,		union iwreq_data *wrqu, char *extra){	struct vnt_private *pDevice = netdev_priv(dev);	__u32 *wmode = &wrqu->mode;	struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;	int rc = 0;	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMODE/n");	if (pMgmt == NULL)		return -EFAULT;	if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP && pDevice->bEnableHostapd) {		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO			"Can't set operation mode, hostapd is running/n");		return rc;	}	switch (*wmode) {	case IW_MODE_ADHOC:		if (pMgmt->eConfigMode != WMAC_CONFIG_IBSS_STA) {			pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;			if (pDevice->flags & DEVICE_FLAGS_OPENED)				pDevice->bCommit = true;		}		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to ad-hoc /n");		break;	case IW_MODE_AUTO:	case IW_MODE_INFRA:		if (pMgmt->eConfigMode != WMAC_CONFIG_ESS_STA) {			pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;			if (pDevice->flags & DEVICE_FLAGS_OPENED)				pDevice->bCommit = true;		}		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to infrastructure /n");		break;	case IW_MODE_MASTER:		pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;		rc = -EOPNOTSUPP;		break;		if (pMgmt->eConfigMode != WMAC_CONFIG_AP) {			pMgmt->eConfigMode = WMAC_CONFIG_AP;			if (pDevice->flags & DEVICE_FLAGS_OPENED)				pDevice->bCommit = true;		}		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to Access Point /n");		break;	case IW_MODE_REPEAT:		pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;		rc = -EOPNOTSUPP;		break;	default:		rc = -EINVAL;	}	if (pDevice->bCommit) {		if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {			netif_stop_queue(pDevice->dev);			spin_lock_irq(&pDevice->lock);			bScheduleCommand((void *) pDevice,				WLAN_CMD_RUN_AP, NULL);			spin_unlock_irq(&pDevice->lock);		} else {			DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO				"Commit the settings/n");			spin_lock_irq(&pDevice->lock);			if (pDevice->bLinkPass &&				memcmp(pMgmt->abyCurrSSID,					pMgmt->abyDesireSSID,					WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {				bScheduleCommand((void *) pDevice,					WLAN_CMD_DISASSOCIATE, NULL);			} else {				pDevice->bLinkPass = false;				pMgmt->eCurrState = WMAC_STATE_IDLE;				memset(pMgmt->abyCurrBSSID, 0, 6);			}			ControlvMaskByte(pDevice,				MESSAGE_REQUEST_MACREG,	MAC_REG_PAPEDELAY,					LEDSTS_STS, LEDSTS_SLOW);			netif_stop_queue(pDevice->dev);			pMgmt->eScanType = WMAC_SCAN_ACTIVE;			if (!pDevice->bWPASuppWextEnabled)				bScheduleCommand((void *) pDevice,					 WLAN_CMD_BSSID_SCAN,					 pMgmt->abyDesireSSID);//.........这里部分代码省略.........

static int btusb_resume(struct usb_interface *intf){    struct btusb_data *data = usb_get_intfdata(intf);    struct hci_dev *hdev = data->hdev;    int err = 0;    if (intf->cur_altsetting->desc.bInterfaceNumber != 0)        return 0;    /*******************************/    RTKBT_DBG("btusb_resume data->suspend_count=%d",data->suspend_count);    if (!test_bit(HCI_RUNNING, &hdev->flags))    {        RTKBT_DBG("btusb_resume-----bt is off,download patch");        download_patch(intf);    }    else        RTKBT_DBG("btusb_resume,----bt is on");    /*******************************/    if (--data->suspend_count)        return 0;    if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {        err = btusb_submit_intr_urb(hdev, GFP_NOIO);        if (err < 0) {            clear_bit(BTUSB_INTR_RUNNING, &data->flags);            goto failed;        }    }    if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {        err = btusb_submit_bulk_urb(hdev, GFP_NOIO);        if (err < 0) {            clear_bit(BTUSB_BULK_RUNNING, &data->flags);            goto failed;        }        btusb_submit_bulk_urb(hdev, GFP_NOIO);    }    if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {        if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)            clear_bit(BTUSB_ISOC_RUNNING, &data->flags);        else            btusb_submit_isoc_urb(hdev, GFP_NOIO);    }    spin_lock_irq(&data->txlock);    play_deferred(data);    clear_bit(BTUSB_SUSPENDING, &data->flags);    spin_unlock_irq(&data->txlock);    schedule_work(&data->work);    return 0;failed:    mdelay(URB_CANCELING_DELAY_MS);      // Added by Realtek    usb_scuttle_anchored_urbs(&data->deferred);//done:    spin_lock_irq(&data->txlock);    clear_bit(BTUSB_SUSPENDING, &data->flags);    spin_unlock_irq(&data->txlock);    return err;}

/** * ipath_create_cq - create a completion queue * @ibdev: the device this completion queue is attached to * @entries: the minimum size of the completion queue * @context: unused by the InfiniPath driver * @udata: unused by the InfiniPath driver * * Returns a pointer to the completion queue or negative errno values * for failure. * * Called by ib_create_cq() in the generic verbs code. */struct ib_cq *ipath_create_cq(struct ib_device *ibdev, int entries, int comp_vector,			      struct ib_ucontext *context,			      struct ib_udata *udata){	struct ipath_ibdev *dev = to_idev(ibdev);	struct ipath_cq *cq;	struct ipath_cq_wc *wc;	struct ib_cq *ret;	u32 sz;	if (entries < 1 || entries > ib_ipath_max_cqes) {		ret = ERR_PTR(-EINVAL);		goto done;	}	/* Allocate the completion queue structure. */	cq = kmalloc(sizeof(*cq), GFP_KERNEL);	if (!cq) {		ret = ERR_PTR(-ENOMEM);		goto done;	}	/*	 * Allocate the completion queue entries and head/tail pointers.	 * This is allocated separately so that it can be resized and	 * also mapped into user space.	 * We need to use vmalloc() in order to support mmap and large	 * numbers of entries.	 */	sz = sizeof(*wc);	if (udata && udata->outlen >= sizeof(__u64))		sz += sizeof(struct ib_uverbs_wc) * (entries + 1);	else		sz += sizeof(struct ib_wc) * (entries + 1);	wc = vmalloc_user(sz);	if (!wc) {		ret = ERR_PTR(-ENOMEM);		goto bail_cq;	}	/*	 * Return the address of the WC as the offset to mmap.	 * See ipath_mmap() for details.	 */	if (udata && udata->outlen >= sizeof(__u64)) {		int err;		cq->ip = ipath_create_mmap_info(dev, sz, context, wc);		if (!cq->ip) {			ret = ERR_PTR(-ENOMEM);			goto bail_wc;		}		err = ib_copy_to_udata(udata, &cq->ip->offset,				       sizeof(cq->ip->offset));		if (err) {			ret = ERR_PTR(err);			goto bail_ip;		}	} else		cq->ip = NULL;	spin_lock(&dev->n_cqs_lock);	if (dev->n_cqs_allocated == ib_ipath_max_cqs) {		spin_unlock(&dev->n_cqs_lock);		ret = ERR_PTR(-ENOMEM);		goto bail_ip;	}	dev->n_cqs_allocated++;	spin_unlock(&dev->n_cqs_lock);	if (cq->ip) {		spin_lock_irq(&dev->pending_lock);		list_add(&cq->ip->pending_mmaps, &dev->pending_mmaps);		spin_unlock_irq(&dev->pending_lock);	}	/*	 * ib_create_cq() will initialize cq->ibcq except for cq->ibcq.cqe.	 * The number of entries should be >= the number requested or return	 * an error.	 */	cq->ibcq.cqe = entries;	cq->notify = IB_CQ_NONE;	cq->triggered = 0;	spin_lock_init(&cq->lock);	tasklet_init(&cq->comptask, send_complete, (unsigned long)cq);//.........这里部分代码省略.........

/* * Description: *      vt6655_hostap_ioctl main function supported for hostap deamon. * * Parameters: *  In: *      pDevice   - *      iw_point  - *  Out: * * Return Value: * */int vt6655_hostap_ioctl(PSDevice pDevice, struct iw_point *p){	struct viawget_hostapd_param *param;	int ret = 0;	int ap_ioctl = 0;	if (p->length < sizeof(struct viawget_hostapd_param) ||	    p->length > VIAWGET_HOSTAPD_MAX_BUF_SIZE || !p->pointer)		return -EINVAL;	param = kmalloc((int)p->length, GFP_KERNEL);	if (param == NULL)		return -ENOMEM;	if (copy_from_user(param, p->pointer, p->length)) {		ret = -EFAULT;		goto out;	}	switch (param->cmd) {	case VIAWGET_HOSTAPD_SET_ENCRYPTION:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_ENCRYPTION /n");		spin_lock_irq(&pDevice->lock);		ret = hostap_set_encryption(pDevice, param, p->length);		spin_unlock_irq(&pDevice->lock);		break;	case VIAWGET_HOSTAPD_GET_ENCRYPTION:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_GET_ENCRYPTION /n");		spin_lock_irq(&pDevice->lock);		ret = hostap_get_encryption(pDevice, param, p->length);		spin_unlock_irq(&pDevice->lock);		break;	case VIAWGET_HOSTAPD_SET_ASSOC_AP_ADDR:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_ASSOC_AP_ADDR /n");		ret = -EOPNOTSUPP;		goto out;	case VIAWGET_HOSTAPD_FLUSH:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_FLUSH /n");		spin_lock_irq(&pDevice->lock);		hostap_flush_sta(pDevice);		spin_unlock_irq(&pDevice->lock);		break;	case VIAWGET_HOSTAPD_ADD_STA:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_ADD_STA /n");		spin_lock_irq(&pDevice->lock);		ret = hostap_add_sta(pDevice, param);		spin_unlock_irq(&pDevice->lock);		break;	case VIAWGET_HOSTAPD_REMOVE_STA:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_REMOVE_STA /n");		spin_lock_irq(&pDevice->lock);		ret = hostap_remove_sta(pDevice, param);		spin_unlock_irq(&pDevice->lock);		break;	case VIAWGET_HOSTAPD_GET_INFO_STA:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_GET_INFO_STA /n");		ret = hostap_get_info_sta(pDevice, param);		ap_ioctl = 1;		break;/*	case VIAWGET_HOSTAPD_RESET_TXEXC_STA:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_RESET_TXEXC_STA /n");		ret = hostap_reset_txexc_sta(pDevice, param);		break;*/	case VIAWGET_HOSTAPD_SET_FLAGS_STA:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_FLAGS_STA /n");		ret = hostap_set_flags_sta(pDevice, param);		break;	case VIAWGET_HOSTAPD_MLME:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_MLME /n");		ret = -EOPNOTSUPP;		goto out;	case VIAWGET_HOSTAPD_SET_GENERIC_ELEMENT:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_GENERIC_ELEMENT /n");		ret = hostap_set_generic_element(pDevice, param);		break;	case VIAWGET_HOSTAPD_SCAN_REQ:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SCAN_REQ /n");		ret = -EOPNOTSUPP;		goto out;	case VIAWGET_HOSTAPD_STA_CLEAR_STATS:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_STA_CLEAR_STATS /n");		ret = -EOPNOTSUPP;		goto out;	default:		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "vt6655_hostap_ioctl: unknown cmd=%d/n",//.........这里部分代码省略.........

/* * RX tasklet takes data out of the RX queue and hands it up to the TTY * layer until it refuses to take any more data (or is throttled back). * Then it issues reads for any further data. * * If the RX queue becomes full enough that no usb_request is queued, * the OUT endpoint may begin NAKing as soon as its FIFO fills up. * So QUEUE_SIZE packets plus however many the FIFO holds (usually two) * can be buffered before the TTY layer's buffers (currently 64 KB). */static void gs_rx_push(unsigned long _port){	struct gs_port		*port = (void *)_port;	struct tty_struct	*tty;	struct list_head	*queue = &port->read_queue;	bool			disconnect = false;	bool			do_push = false;	/* hand any queued data to the tty */	spin_lock_irq(&port->port_lock);	tty = port->port_tty;	while (!list_empty(queue)) {		struct usb_request	*req;		req = list_first_entry(queue, struct usb_request, list);		/* discard data if tty was closed */		if (!tty)			goto recycle;		/* leave data queued if tty was rx throttled */		if (test_bit(TTY_THROTTLED, &tty->flags))			break;		switch (req->status) {		case -ESHUTDOWN:			disconnect = true;			pr_vdebug(PREFIX "%d: shutdown/n", port->port_num);			break;		default:			/* presumably a transient fault */			pr_warning(PREFIX "%d: unexpected RX status %d/n",					port->port_num, req->status);			/* FALLTHROUGH */		case 0:			/* normal completion */			break;		}		/* push data to (open) tty */		if (req->actual) {			char		*packet = req->buf;			unsigned	size = req->actual;			unsigned	n;			int		count;			/* we may have pushed part of this packet already... */			n = port->n_read;			if (n) {				packet += n;				size -= n;			}			count = tty_insert_flip_string(tty, packet, size);			if (count)				do_push = true;			if (count != size) {				/* stop pushing; TTY layer can't handle more */				port->n_read += count;				pr_vdebug(PREFIX "%d: rx block %d/%d/n",						port->port_num,						count, req->actual);				break;			}			port->n_read = 0;		}recycle:		list_move(&req->list, &port->read_pool);		port->read_started--;	}	/* Push from tty to ldisc; without low_latency set this is handled by	 * a workqueue, so we won't get callbacks and can hold port_lock	 */	if (tty && do_push)		tty_flip_buffer_push(tty);	/* We want our data queue to become empty ASAP, keeping data	 * in the tty and ldisc (not here).  If we couldn't push any	 * this time around, there may be trouble unless there's an	 * implicit tty_unthrottle() call on its way...	 *	 * REVISIT we should probably add a timer to keep the tasklet	 * from starving ... but it's not clear that case ever happens.	 */	if (!list_empty(queue) && tty) {		if (!test_bit(TTY_THROTTLED, &tty->flags)) {			if (do_push)//.........这里部分代码省略.........

static int s5p_ehci_resume(struct device *dev){	struct platform_device *pdev = to_platform_device(dev);	struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);	struct usb_hcd *hcd = s5p_ehci->hcd;	struct ehci_hcd *ehci = hcd_to_ehci(hcd);	clk_enable(s5p_ehci->clk);	s5p_ehci_phy_init(pdev);	/* if EHCI was off, hcd was removed */	if (!s5p_ehci->power_on) {		dev_info(dev, "Nothing to do for the device (power off)/n");		return 0;	}	if (time_before(jiffies, ehci->next_statechange))		usleep_range(10000, 11000);	/* Mark hardware accessible again as we are out of D3 state by now */	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);	if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {		int	mask = INTR_MASK;		if (!hcd->self.root_hub->do_remote_wakeup)			mask &= ~STS_PCD;		ehci_writel(ehci, mask, &ehci->regs->intr_enable);		ehci_readl(ehci, &ehci->regs->intr_enable);		return 0;	}	ehci_dbg(ehci, "lost power, restarting/n");	usb_root_hub_lost_power(hcd->self.root_hub);	(void) ehci_halt(ehci);	(void) ehci_reset(ehci);	/* emptying the schedule aborts any urbs */	spin_lock_irq(&ehci->lock);	if (ehci->reclaim)		end_unlink_async(ehci);	ehci_work(ehci);	spin_unlock_irq(&ehci->lock);	ehci_writel(ehci, ehci->command, &ehci->regs->command);	ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);	ehci_readl(ehci, &ehci->regs->command);	/* unblock posted writes */	/* here we "know" root ports should always stay powered */	ehci_port_power(ehci, 1);	hcd->state = HC_STATE_SUSPENDED;	/* Update runtime PM status and clear runtime_error */	pm_runtime_disable(dev);	pm_runtime_set_active(dev);	pm_runtime_enable(dev);	/* Prevent device from runtime suspend during resume time */	pm_runtime_get_sync(dev);#ifdef CONFIG_MDM_HSIC_PM	set_host_stat(hsic_pm_dev, POWER_ON);	wait_dev_pwr_stat(hsic_pm_dev, POWER_ON);#endif#if defined(CONFIG_LINK_DEVICE_HSIC) || defined(CONFIG_LINK_DEVICE_USB) /	|| defined(CONFIG_MDM_HSIC_PM)	pm_runtime_mark_last_busy(&hcd->self.root_hub->dev);#endif	return 0;}

void lock_ipi_call_lock(void){	spin_lock_irq(&call_lock);}

/* Note that 'init' is a special process: it doesn't get signals it doesn't * want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. */asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,			 unsigned long orig_i0, int restart_syscall){	unsigned long signr;	siginfo_t info;	struct k_sigaction *ka;		if (!oldset)		oldset = &current->blocked;#ifdef CONFIG_SPARC32_COMPAT	if (current->thread.flags & SPARC_FLAG_32BIT) {		extern asmlinkage int do_signal32(sigset_t *, struct pt_regs *,						  unsigned long, int);		return do_signal32(oldset, regs, orig_i0, restart_syscall);	}#endif		for (;;) {		spin_lock_irq(&current->sigmask_lock);		signr = dequeue_signal(&current->blocked, &info);		spin_unlock_irq(&current->sigmask_lock);				if (!signr) break;		if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {			current->exit_code = signr;			current->state = TASK_STOPPED;			notify_parent(current, SIGCHLD);			schedule();			if (!(signr = current->exit_code))				continue;			current->exit_code = 0;			if (signr == SIGSTOP)				continue;			/* Update the siginfo structure.  Is this good?  */			if (signr != info.si_signo) {				info.si_signo = signr;				info.si_errno = 0;				info.si_code = SI_USER;				info.si_pid = current->p_pptr->pid;				info.si_uid = current->p_pptr->uid;			}			/* If the (new) signal is now blocked, requeue it.  */			if (sigismember(&current->blocked, signr)) {				send_sig_info(signr, &info, current);				continue;			}		}				ka = &current->sig->action[signr-1];				if(ka->sa.sa_handler == SIG_IGN) {			if(signr != SIGCHLD)				continue;                        /* sys_wait4() grabs the master kernel lock, so                         * we need not do so, that sucker should be                         * threaded and would not be that difficult to                         * do anyways.                         */                        while(sys_wait4(-1, NULL, WNOHANG, NULL) > 0)                                ;			continue;		}		if(ka->sa.sa_handler == SIG_DFL) {			unsigned long exit_code = signr;						if(current->pid == 1)				continue;			switch(signr) {			case SIGCONT: case SIGCHLD: case SIGWINCH:				continue;			case SIGTSTP: case SIGTTIN: case SIGTTOU:				if (is_orphaned_pgrp(current->pgrp))					continue;			case SIGSTOP:				if (current->ptrace & PT_PTRACED)					continue;				current->state = TASK_STOPPED;				current->exit_code = signr;				if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &				     SA_NOCLDSTOP))					notify_parent(current, SIGCHLD);				schedule();				continue;			case SIGQUIT: case SIGILL: case SIGTRAP:			case SIGABRT: case SIGFPE: case SIGSEGV:			case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:				if (do_coredump(signr, regs))					exit_code |= 0x80;#ifdef DEBUG_SIGNALS//.........这里部分代码省略.........

/* {set, get}context() needed for 64-bit SparcLinux userland. */asmlinkage void sparc64_set_context(struct pt_regs *regs){	struct ucontext *ucp = (struct ucontext *) regs->u_regs[UREG_I0];	struct thread_struct *tp = &current->thread;	mc_gregset_t *grp;	unsigned long pc, npc, tstate;	unsigned long fp, i7;	unsigned char fenab;	int err;	flush_user_windows();	if(tp->w_saved						||	   (((unsigned long)ucp) & (sizeof(unsigned long)-1))	||	   (!__access_ok((unsigned long)ucp, sizeof(*ucp))))		goto do_sigsegv;	grp  = &ucp->uc_mcontext.mc_gregs;	err  = __get_user(pc, &((*grp)[MC_PC]));	err |= __get_user(npc, &((*grp)[MC_NPC]));	if(err || ((pc | npc) & 3))		goto do_sigsegv;	if(regs->u_regs[UREG_I1]) {		sigset_t set;		if (_NSIG_WORDS == 1) {			if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))				goto do_sigsegv;		} else {			if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))				goto do_sigsegv;		}		sigdelsetmask(&set, ~_BLOCKABLE);		spin_lock_irq(&current->sigmask_lock);		current->blocked = set;		recalc_sigpending(current);		spin_unlock_irq(&current->sigmask_lock);	}	if ((tp->flags & SPARC_FLAG_32BIT) != 0) {		pc &= 0xffffffff;		npc &= 0xffffffff;	}	regs->tpc = pc;	regs->tnpc = npc;	err |= __get_user(regs->y, &((*grp)[MC_Y]));	err |= __get_user(tstate, &((*grp)[MC_TSTATE]));	regs->tstate &= ~(TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ICC | TSTATE_XCC));	err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));	err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));	err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));	err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));	err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));	err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));	err |= __get_user(regs->u_regs[UREG_G7], (&(*grp)[MC_G7]));	err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));	err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));	err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));	err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));	err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));	err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));	err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));	err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));	err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));	err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));	err |= __put_user(fp,	      (&(((struct reg_window *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));	err |= __put_user(i7,	      (&(((struct reg_window *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));	err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));	if(fenab) {		unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);		unsigned long fprs;				fprs_write(0);		err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));		if (fprs & FPRS_DL)			err |= copy_from_user(fpregs,					      &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),					      (sizeof(unsigned int) * 32));		if (fprs & FPRS_DU)			err |= copy_from_user(fpregs+16,			 ((unsigned long *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,			 (sizeof(unsigned int) * 32));		err |= __get_user(current->thread.xfsr[0],				  &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));		err |= __get_user(current->thread.gsr[0],				  &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));		regs->tstate &= ~TSTATE_PEF;	}	if (err)		goto do_sigsegv;	return;do_sigsegv:	do_exit(SIGSEGV);}

/* * Note that 'init' is a special process: it doesn't get signals it doesn't * want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. * * Note that we go through the signals twice: once to check the signals that * the kernel can handle, and then we build all the user-level signal handling * stack-frames in one go after that. */asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall){	struct k_sigaction *ka;	siginfo_t info;	int single_stepping;	/*	 * We want the common case to go fast, which	 * is why we may in certain cases get here from	 * kernel mode. Just return without doing anything	 * if so.	 */	if (!user_mode(regs))		return 0;	if (!oldset)		oldset = &current->blocked;	single_stepping = ptrace_cancel_bpt(current);	for (;;) {		unsigned long signr;		spin_lock_irq (&current->sigmask_lock);		signr = dequeue_signal(&current->blocked, &info);		spin_unlock_irq (&current->sigmask_lock);		if (!signr)			break;		if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {			/* Let the debugger run.  */			current->exit_code = signr;			current->state = TASK_STOPPED;			notify_parent(current, SIGCHLD);			schedule();			single_stepping |= ptrace_cancel_bpt(current);			/* We're back.  Did the debugger cancel the sig?  */			if (!(signr = current->exit_code))				continue;			current->exit_code = 0;			/* The debugger continued.  Ignore SIGSTOP.  */			if (signr == SIGSTOP)				continue;			/* Update the siginfo structure.  Is this good? */			if (signr != info.si_signo) {				info.si_signo = signr;				info.si_errno = 0;				info.si_code = SI_USER;				info.si_pid = current->p_pptr->pid;				info.si_uid = current->p_pptr->uid;			}			/* If the (new) signal is now blocked, requeue it.  */			if (sigismember(&current->blocked, signr)) {				send_sig_info(signr, &info, current);				continue;			}		}		ka = &current->sig->action[signr-1];		if (ka->sa.sa_handler == SIG_IGN) {			if (signr != SIGCHLD)				continue;			/* Check for SIGCHLD: it's special.  */			while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)				/* nothing */;			continue;		}		if (ka->sa.sa_handler == SIG_DFL) {			int exit_code = signr;			/* Init gets no signals it doesn't want.  */			if (current->pid == 1)				continue;			switch (signr) {			case SIGCONT: case SIGCHLD: case SIGWINCH: case SIGURG:				continue;			case SIGTSTP: case SIGTTIN: case SIGTTOU:				if (is_orphaned_pgrp(current->pgrp))					continue;				/* FALLTHRU */			case SIGSTOP: {				struct signal_struct *sig;//.........这里部分代码省略.........

static int target_fabric_mappedlun_link(	struct config_item *lun_acl_ci,	struct config_item *lun_ci){	struct se_dev_entry *deve;	struct se_lun *lun = container_of(to_config_group(lun_ci),			struct se_lun, lun_group);	struct se_lun_acl *lacl = container_of(to_config_group(lun_acl_ci),			struct se_lun_acl, se_lun_group);	struct se_portal_group *se_tpg;	struct config_item *nacl_ci, *tpg_ci, *tpg_ci_s, *wwn_ci, *wwn_ci_s;	int ret = 0, lun_access;	/*	 * Ensure that the source port exists	 */	if (!lun->lun_sep || !lun->lun_sep->sep_tpg) {		pr_err("Source se_lun->lun_sep or lun->lun_sep->sep"				"_tpg does not exist/n");		return -EINVAL;	}	se_tpg = lun->lun_sep->sep_tpg;	nacl_ci = &lun_acl_ci->ci_parent->ci_group->cg_item;	tpg_ci = &nacl_ci->ci_group->cg_item;	wwn_ci = &tpg_ci->ci_group->cg_item;	tpg_ci_s = &lun_ci->ci_parent->ci_group->cg_item;	wwn_ci_s = &tpg_ci_s->ci_group->cg_item;	/*	 * Make sure the SymLink is going to the same $FABRIC/$WWN/tpgt_$TPGT	 */	if (strcmp(config_item_name(wwn_ci), config_item_name(wwn_ci_s))) {		pr_err("Illegal Initiator ACL SymLink outside of %s/n",			config_item_name(wwn_ci));		return -EINVAL;	}	if (strcmp(config_item_name(tpg_ci), config_item_name(tpg_ci_s))) {		pr_err("Illegal Initiator ACL Symlink outside of %s"			" TPGT: %s/n", config_item_name(wwn_ci),			config_item_name(tpg_ci));		return -EINVAL;	}	/*	 * If this struct se_node_acl was dynamically generated with	 * tpg_1/attrib/generate_node_acls=1, use the existing deve->lun_flags,	 * which be will write protected (READ-ONLY) when	 * tpg_1/attrib/demo_mode_write_protect=1	 */	spin_lock_irq(&lacl->se_lun_nacl->device_list_lock);	deve = &lacl->se_lun_nacl->device_list[lacl->mapped_lun];	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS)		lun_access = deve->lun_flags;	else		lun_access =			(se_tpg->se_tpg_tfo->tpg_check_prod_mode_write_protect(				se_tpg)) ? TRANSPORT_LUNFLAGS_READ_ONLY :					   TRANSPORT_LUNFLAGS_READ_WRITE;	spin_unlock_irq(&lacl->se_lun_nacl->device_list_lock);	/*	 * Determine the actual mapped LUN value user wants..	 *	 * This value is what the SCSI Initiator actually sees the	 * iscsi/$IQN/$TPGT/lun/lun_* as on their SCSI Initiator Ports.	 */	ret = core_dev_add_initiator_node_lun_acl(se_tpg, lacl,			lun->unpacked_lun, lun_access);	return (ret < 0) ? -EINVAL : 0;}

asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit __user *rlim){	struct rlimit new_rlim, *old_rlim;	unsigned long it_prof_secs;	int retval;	if (resource >= RLIM_NLIMITS)		return -EINVAL;	if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))		return -EFAULT;	if (new_rlim.rlim_cur > new_rlim.rlim_max)		return -EINVAL;	old_rlim = current->signal->rlim + resource;	if ((new_rlim.rlim_max > old_rlim->rlim_max) &&	    !capable(CAP_SYS_RESOURCE))		return -EPERM;	if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > NR_OPEN)		return -EPERM;	retval = security_task_setrlimit(resource, &new_rlim);	if (retval)		return retval;	task_lock(current->group_leader);	*old_rlim = new_rlim;	task_unlock(current->group_leader);	if (resource != RLIMIT_CPU)		goto out;	/*	 * RLIMIT_CPU handling.   Note that the kernel fails to return an error	 * code if it rejected the user's attempt to set RLIMIT_CPU.  This is a	 * very long-standing error, and fixing it now risks breakage of	 * applications, so we live with it	 */	if (new_rlim.rlim_cur == RLIM_INFINITY)		goto out;	it_prof_secs = cputime_to_secs(current->signal->it_prof_expires);	if (it_prof_secs == 0 || new_rlim.rlim_cur <= it_prof_secs) {		unsigned long rlim_cur = new_rlim.rlim_cur;		cputime_t cputime;		if (rlim_cur == 0) {			/*			 * The caller is asking for an immediate RLIMIT_CPU			 * expiry.  But we use the zero value to mean "it was			 * never set".  So let's cheat and make it one second			 * instead			 */			rlim_cur = 1;		}		cputime = secs_to_cputime(rlim_cur);		read_lock(&tasklist_lock);		spin_lock_irq(&current->sighand->siglock);		set_process_cpu_timer(current, CPUCLOCK_PROF, &cputime, NULL);		spin_unlock_irq(&current->sighand->siglock);		read_unlock(&tasklist_lock);	}out:	return 0;}

/** * nilfs_btnode_prepare_change_key *  prepare to move contents of the block for old key to one of new key. *  the old buffer will not be removed, but might be reused for new buffer. *  it might return -ENOMEM because of memory allocation errors, *  and might return -EIO because of disk read errors. */int nilfs_btnode_prepare_change_key(struct address_space *btnc,				    struct nilfs_btnode_chkey_ctxt *ctxt){	struct buffer_head *obh, *nbh;	struct inode *inode = NILFS_BTNC_I(btnc);	__u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey;	int err;	if (oldkey == newkey)		return 0;	obh = ctxt->bh;	ctxt->newbh = NULL;	if (inode->i_blkbits == PAGE_CACHE_SHIFT) {		lock_page(obh->b_page);		/*		 * We cannot call radix_tree_preload for the kernels older		 * than 2.6.23, because it is not exported for modules.		 */retry:		err = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);		if (err)			goto failed_unlock;		/* BUG_ON(oldkey != obh->b_page->index); */		if (unlikely(oldkey != obh->b_page->index))			NILFS_PAGE_BUG(obh->b_page,				       "invalid oldkey %lld (newkey=%lld)",				       (unsigned long long)oldkey,				       (unsigned long long)newkey);		spin_lock_irq(&btnc->tree_lock);		err = radix_tree_insert(&btnc->page_tree, newkey, obh->b_page);		spin_unlock_irq(&btnc->tree_lock);		/*		 * Note: page->index will not change to newkey until		 * nilfs_btnode_commit_change_key() will be called.		 * To protect the page in intermediate state, the page lock		 * is held.		 */		radix_tree_preload_end();		if (!err)			return 0;		else if (err != -EEXIST)			goto failed_unlock;		err = invalidate_inode_pages2_range(btnc, newkey, newkey);		if (!err)			goto retry;		/* fallback to copy mode */		unlock_page(obh->b_page);	}	nbh = nilfs_btnode_create_block(btnc, newkey);	if (!nbh)		return -ENOMEM;	BUG_ON(nbh == obh);	ctxt->newbh = nbh;	return 0; failed_unlock:	unlock_page(obh->b_page);	return err;}

int do_syslog(int type, char __user *buf, int len, bool from_file){	unsigned i, j, limit, count;	int do_clear = 0;	char c;	int error;	error = check_syslog_permissions(type, from_file);	if (error)		goto out;	error = security_syslog(type);	if (error)		return error;	switch (type) {	case SYSLOG_ACTION_CLOSE:	/* Close log */		break;	case SYSLOG_ACTION_OPEN:	/* Open log */		break;	case SYSLOG_ACTION_READ:	/* Read from log */		error = -EINVAL;		if (!buf || len < 0)			goto out;		error = 0;		if (!len)			goto out;		if (!access_ok(VERIFY_WRITE, buf, len)) {			error = -EFAULT;			goto out;		}		error = wait_event_interruptible(log_wait,							(log_start - log_end));		if (error)			goto out;		i = 0;		spin_lock_irq(&logbuf_lock);		while (!error && (log_start != log_end) && i < len) {			c = LOG_BUF(log_start);			log_start++;			spin_unlock_irq(&logbuf_lock);			error = __put_user(c,buf);			buf++;			i++;			cond_resched();			spin_lock_irq(&logbuf_lock);		}		spin_unlock_irq(&logbuf_lock);		if (!error)			error = i;		break;	/* Read/clear last kernel messages */	case SYSLOG_ACTION_READ_CLEAR:		do_clear = 1;		/* FALL THRU */	/* Read last kernel messages */	case SYSLOG_ACTION_READ_ALL:		error = -EINVAL;		if (!buf || len < 0)			goto out;		error = 0;		if (!len)			goto out;		if (!access_ok(VERIFY_WRITE, buf, len)) {			error = -EFAULT;			goto out;		}		count = len;		if (count > log_buf_len)			count = log_buf_len;		spin_lock_irq(&logbuf_lock);		if (count > logged_chars)			count = logged_chars;		if (do_clear)			logged_chars = 0;		limit = log_end;		/*		 * __put_user() could sleep, and while we sleep		 * printk() could overwrite the messages		 * we try to copy to user space. Therefore		 * the messages are copied in reverse. <manfreds>		 */		for (i = 0; i < count && !error; i++) {			j = limit-1-i;			if (j + log_buf_len < log_end)				break;			c = LOG_BUF(j);			spin_unlock_irq(&logbuf_lock);			error = __put_user(c,&buf[count-1-i]);			cond_resched();			spin_lock_irq(&logbuf_lock);		}		spin_unlock_irq(&logbuf_lock);		if (error)			break;		error = i;		if (i != count) {			int offset = count-error;			/* buffer overflow during copy, correct user buffer. */			for (i = 0; i < error; i++) {//.........这里部分代码省略.........

/** *	ld_usb_read */static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,			   loff_t *ppos){	struct ld_usb *dev;	size_t *actual_buffer;	size_t bytes_to_read;	int retval = 0;	int rv;	dev = file->private_data;	/* verify that we actually have some data to read */	if (count == 0)		goto exit;	/* lock this object */	if (down_interruptible(&dev->sem)) {		retval = -ERESTARTSYS;		goto exit;	}	/* verify that the device wasn't unplugged */	if (dev->intf == NULL) {		retval = -ENODEV;		err("No device or device unplugged %d/n", retval);		goto unlock_exit;	}	/* wait for data */	spin_lock_irq(&dev->rbsl);	if (dev->ring_head == dev->ring_tail) {		dev->interrupt_in_done = 0;		spin_unlock_irq(&dev->rbsl);		if (file->f_flags & O_NONBLOCK) {			retval = -EAGAIN;			goto unlock_exit;		}		retval = wait_event_interruptible(dev->read_wait, dev->interrupt_in_done);		if (retval < 0)			goto unlock_exit;	} else {		spin_unlock_irq(&dev->rbsl);	}	/* actual_buffer contains actual_length + interrupt_in_buffer */	actual_buffer = (size_t*)(dev->ring_buffer + dev->ring_tail*(sizeof(size_t)+dev->interrupt_in_endpoint_size));	bytes_to_read = min(count, *actual_buffer);	if (bytes_to_read < *actual_buffer)		dev_warn(&dev->intf->dev, "Read buffer overflow, %zd bytes dropped/n",			 *actual_buffer-bytes_to_read);	/* copy one interrupt_in_buffer from ring_buffer into userspace */	if (copy_to_user(buffer, actual_buffer+1, bytes_to_read)) {		retval = -EFAULT;		goto unlock_exit;	}	dev->ring_tail = (dev->ring_tail+1) % ring_buffer_size;	retval = bytes_to_read;	spin_lock_irq(&dev->rbsl);	if (dev->buffer_overflow) {		dev->buffer_overflow = 0;		spin_unlock_irq(&dev->rbsl);		rv = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);		if (rv < 0)			dev->buffer_overflow = 1;	} else {		spin_unlock_irq(&dev->rbsl);	}unlock_exit:	/* unlock the device */	up(&dev->sem);exit:	return retval;}

static int dma_hw_params(struct snd_pcm_substream *substream,	struct snd_pcm_hw_params *params){	struct snd_pcm_runtime *runtime = substream->runtime;	struct runtime_data *prtd = runtime->private_data;	struct snd_soc_pcm_runtime *rtd = substream->private_data;	unsigned long totbytes = params_buffer_bytes(params);	struct s3c_dma_params *dma =		snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);	struct samsung_dma_req req;	struct samsung_dma_config config;	pr_debug("Entered %s/n", __func__);	/* return if this is a bufferless transfer e.g.	 * codec <--> BT codec or GSM modem -- lg FIXME */	if (!dma)		return 0;	/* this may get called several times by oss emulation	 * with different params -HW */	if (prtd->params == NULL) {		/* prepare DMA */		prtd->params = dma;		pr_debug("params %p, client %p, channel %d/n", prtd->params,			prtd->params->client, prtd->params->channel);		prtd->params->ops = samsung_dma_get_ops();		req.cap = (samsung_dma_has_circular() ?			DMA_CYCLIC : DMA_SLAVE);		req.client = prtd->params->client;		config.direction =			(substream->stream == SNDRV_PCM_STREAM_PLAYBACK			? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM);		config.width = prtd->params->dma_size;		config.maxburst = 1;		config.fifo = prtd->params->dma_addr;		prtd->params->ch = prtd->params->ops->request(				prtd->params->channel, &req);		prtd->params->ops->config(prtd->params->ch, &config);	}	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);	runtime->dma_bytes = totbytes;	spin_lock_irq(&prtd->lock);	prtd->dma_loaded = 0;	prtd->dma_period = params_period_bytes(params);	prtd->dma_start = runtime->dma_addr;	prtd->dma_pos = prtd->dma_start;	prtd->dma_end = prtd->dma_start + totbytes;	if (runtime->dma_addr > EXYNOS_PA_AUDSS)		prtd->dram_used = true;	else		prtd->dram_used = false;	spin_unlock_irq(&prtd->lock);	pr_debug("ADMA:%s:[email
C++ spin_lock_irqsave函数代码示例
C++ spin_lock_init函数代码示例