static void
rcu_stutter_wait(char *title)
{
while (stutter_pause_test || !rcutorture_runnable) {
if (rcutorture_runnable)
schedule_timeout_interruptible(1);
else
schedule_timeout_interruptible(round_jiffies_relative(HZ));
rcutorture_shutdown_absorb(title);
}
}
static bool esas2r_flash_access(struct esas2r_adapter *a, u32 function)
{
u32 starttime;
u32 timeout;
u32 intstat;
u32 doorbell;
/* Disable chip interrupts awhile */
if (function == DRBL_FLASH_REQ)
esas2r_disable_chip_interrupts(a);
/* Issue the request to the firmware */
esas2r_write_register_dword(a, MU_DOORBELL_IN, function);
/* Now wait for the firmware to process it */
starttime = jiffies_to_msecs(jiffies);
timeout = a->flags &
(AF_CHPRST_PENDING | AF_DISC_PENDING) ? 40000 : 5000;
while (true) {
intstat = esas2r_read_register_dword(a, MU_INT_STATUS_OUT);
if (intstat & MU_INTSTAT_DRBL) {
/* Got a doorbell interrupt. Check for the function */
doorbell =
esas2r_read_register_dword(a, MU_DOORBELL_OUT);
esas2r_write_register_dword(a, MU_DOORBELL_OUT,
doorbell);
if (doorbell & function)
break;
}
schedule_timeout_interruptible(msecs_to_jiffies(100));
if ((jiffies_to_msecs(jiffies) - starttime) > timeout) {
/*
* Iimeout. If we were requesting flash access,
* indicate we are done so the firmware knows we gave
* up. If this was a REQ, we also need to re-enable
* chip interrupts.
*/
if (function == DRBL_FLASH_REQ) {
esas2r_hdebug("flash access timeout");
esas2r_write_register_dword(a, MU_DOORBELL_IN,
DRBL_FLASH_DONE);
esas2r_enable_chip_interrupts(a);
} else {
esas2r_hdebug("flash release timeout");
}
return false;
}
}
/* if we're done, re-enable chip interrupts */
if (function == DRBL_FLASH_DONE)
esas2r_enable_chip_interrupts(a);
return true;
}
static int log_worker(void *p)
{
/* The thread should have never started */
if (log_buf == NULL)
return -EFAULT;
while (!kthread_should_stop()) {
if (log_buf->write_pos == log_pos)
schedule_timeout_interruptible(MAX_SCHEDULE_TIMEOUT);
switch (log_buf->version) {
case 1:
log_pos = process_v1log();
break;
case 2:
log_pos = process_v2log();
break;
default:
MCDRV_DBG_ERROR("Unknown Mobicore log data "
"version %d logging disabled.",
log_buf->version);
log_pos = log_buf->write_pos;
/* Stop the thread as we have no idea what
* happens next */
return -EFAULT;
}
}
MCDRV_DBG("Logging thread stopped!");
return 0;
}
static long compat_nanosleep_restart(struct restart_block *restart)
{
unsigned long expire = restart->arg0, now = jiffies;
struct compat_timespec __user *rmtp;
/* Did it expire while we handled signals? */
if (!time_after(expire, now))
return 0;
expire = schedule_timeout_interruptible(expire - now);
if (expire == 0)
return 0;
rmtp = (struct compat_timespec __user *)restart->arg1;
if (rmtp) {
struct compat_timespec ct;
struct timespec t;
jiffies_to_timespec(expire, &t);
ct.tv_sec = t.tv_sec;
ct.tv_nsec = t.tv_nsec;
if (copy_to_user(rmtp, &ct, sizeof(ct)))
return -EFAULT;
}
/* The 'restart' block is already filled in */
return -ERESTART_RESTARTBLOCK;
}
/**
* exit_dsm() - Called when chip needs to be put out of DSM Mode.
*
* The enter_dsm() function is called to put chip out of DSM Mode.
*
*/
void exit_dsm(void)
{
CG2900_DBG("exit_dsm");
mutex_lock(&uart_info->sleep_mutex);
if (uart_info->sleep_state == CHIP_AWAKE) {
CG2900_ERR("Chip already in normal mode");
mutex_unlock(&uart_info->sleep_mutex);
return;
}
/* Enable the RTS Flow and remove BREAK on UART */
cg29xx_uart_enable();
mutex_unlock(&uart_info->sleep_mutex);
/* Wait some time to check the acknowledgement from chip for DSM */
schedule_timeout_interruptible(
msecs_to_jiffies(CG2900_DSM_ACK_TIMEOUT));
/* Check the HOST CTS Level */
if (!cg29xx_cts_gpio_level()) {
/* HOST_CTS made LOW by chip */
CG2900_DBG("exit_dsm: Chip out of DSM Mode");
SET_SLEEP_STATE(CHIP_AWAKE);
} else {
/* No acknowledgement from Chip, major error */
CG2900_ERR("exit_dsm: HOST_CTS still HIGH, "
"chip still in DSM Mode");
SET_SLEEP_STATE(CHIP_ASLEEP);
}
}
static int bt866_write(struct bt866 *encoder,
unsigned char subaddr, unsigned char data)
{
unsigned char buffer[2];
int err;
buffer[0] = subaddr;
buffer[1] = data;
encoder->reg[subaddr] = data;
DEBUG(printk
("%s: write 0x%02X = 0x%02X\n",
encoder->i2c->name, subaddr, data));
for (err = 0; err < 3;) {
if (i2c_master_send(encoder->i2c, buffer, 2) == 2)
break;
err++;
printk(KERN_WARNING "%s: I/O error #%d "
"(write 0x%02x/0x%02x)\n",
encoder->i2c->name, err, encoder->addr, subaddr);
schedule_timeout_interruptible(msecs_to_jiffies(100));
}
if (err == 3) {
printk(KERN_WARNING "%s: giving up\n",
encoder->i2c->name);
return -1;
}
return 0;
}
asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
struct compat_timespec __user *rmtp)
{
struct timespec t;
struct restart_block *restart;
unsigned long expire;
if (get_compat_timespec(&t, rqtp))
return -EFAULT;
if ((t.tv_nsec >= 1000000000L) || (t.tv_nsec < 0) || (t.tv_sec < 0))
return -EINVAL;
expire = timespec_to_jiffies(&t) + (t.tv_sec || t.tv_nsec);
expire = schedule_timeout_interruptible(expire);
if (expire == 0)
return 0;
if (rmtp) {
jiffies_to_timespec(expire, &t);
if (put_compat_timespec(&t, rmtp))
return -EFAULT;
}
restart = ¤t_thread_info()->restart_block;
restart->fn = compat_nanosleep_restart;
restart->arg0 = jiffies + expire;
restart->arg1 = (unsigned long) rmtp;
return -ERESTART_RESTARTBLOCK;
}
static int __init kthread_init()
{
int cpu;
unsigned int cpu_count = num_online_cpus();
unsigned int parameter[cpu_count];
struct task_struct *t_thread[cpu_count];
for_each_present_cpu(cpu) {
parameter[cpu] = cpu;
t_thread[cpu] = kthread_create(mythread, (void *)(parameter + cpu), "thread/%d", cpu);
if (IS_ERR(t_thread[cpu])) {
printk(KERN_ERR "[thread/%d]: creating kthread failed \n", cpu);
goto out;
}
kthread_bind(t_thread[cpu], cpu);
wake_up_process(t_thread[cpu]);
}
schedule_timeout_interruptible(msecs_to_jiffies(sleep_millisecs));
for (cpu = 0; cpu < cpu_count; cpu++) {
kthread_stop(t_thread[cpu]);
}
out:
return 0;
}
void usb_serial_generic_wait_until_sent(struct tty_struct *tty, long timeout)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int bps;
unsigned long period;
unsigned long expire;
bps = tty_get_baud_rate(tty);
if (!bps)
bps = 9600; /* B0 */
/*
* Use a poll-period of roughly the time it takes to send one
* character or at least one jiffy.
*/
period = max_t(unsigned long, (10 * HZ / bps), 1);
period = min_t(unsigned long, period, timeout);
dev_dbg(&port->dev, "%s - timeout = %u ms, period = %u ms\n",
__func__, jiffies_to_msecs(timeout),
jiffies_to_msecs(period));
expire = jiffies + timeout;
while (!port->serial->type->tx_empty(port)) {
schedule_timeout_interruptible(period);
if (signal_pending(current))
break;
if (time_after(jiffies, expire))
break;
}
}
static void usbrh_disconnect(struct usb_interface *interface)
{
struct usbrh *dev;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
while(!mutex_lock_interruptible(&usbrh_ioctl_mutex)) {
schedule_timeout_interruptible(msecs_to_jiffies(100));
}
#else
lock_kernel();
#endif
dev = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
usb_deregister_dev(interface, &usbrh_class);
mutex_lock(&dev->io_mutex);
dev->interface = NULL;
mutex_unlock(&dev->io_mutex);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
mutex_unlock(&usbrh_ioctl_mutex);
#else
unlock_kernel();
#endif
kref_put(&dev->kref, usbrh_delete);
info("USBRH disconnected");
}
/*
* On a 5-minute timeout, wait for all devices currently configured. We need
* to do this to guarantee that the filesystems and / or network devices
* needed for boot are available, before we can allow the boot to proceed.
*
* This needs to be on a late_initcall, to happen after the frontend device
* drivers have been initialised, but before the root fs is mounted.
*
* A possible improvement here would be to have the tools add a per-device
* flag to the store entry, indicating whether it is needed at boot time.
* This would allow people who knew what they were doing to accelerate their
* boot slightly, but of course needs tools or manual intervention to set up
* those flags correctly.
*/
static void wait_for_devices(struct xenbus_driver *xendrv)
{
unsigned long start = jiffies;
struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
unsigned int seconds_waited = 0;
if (!ready_to_wait_for_devices || !xen_domain())
return;
while (exists_connecting_device(drv)) {
if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
if (!seconds_waited)
printk(KERN_WARNING "XENBUS: Waiting for "
"devices to initialise: ");
seconds_waited += 5;
printk("%us...", 300 - seconds_waited);
if (seconds_waited == 300)
break;
}
schedule_timeout_interruptible(HZ/10);
}
if (seconds_waited)
printk("\n");
bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
print_device_status);
}
/* sleeps that many milliseconds with a reschedule */
static void long_sleep(int ms)
{
if (in_interrupt())
mdelay(ms);
else
schedule_timeout_interruptible(msecs_to_jiffies(ms));
}
static void usleep(unsigned int usecs)
{
unsigned long timeout = usecs_to_jiffies(usecs);
while (timeout)
timeout = schedule_timeout_interruptible(timeout);
}
static void
qm_sleep(PT3_QM *qm, PT3_BUS *bus, __u32 ms)
{
if (bus)
pt3_bus_sleep(bus, ms);
else
schedule_timeout_interruptible(msecs_to_jiffies(ms));
}
static int
wavefront_sleep (int limit)
{
schedule_timeout_interruptible(limit);
return signal_pending(current);
}
STATUS
pt3_mx_set_frequency(PT3_MX *mx, __u32 channel, __s32 offset)
{
STATUS status;
int catv, locked1, locked2;
__u32 number, freq;
__u32 real_freq;
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)
struct timeval begin, now;
#else
struct timespec64 begin, now;
#endif
status = pt3_tc_set_agc_t(mx->tc, NULL, PT3_TC_AGC_MANUAL);
if (status)
return status;
pt3_mx_get_channel_frequency(mx, channel, &catv, &number, &freq);
//real_freq = (7 * freq + 1 + offset) * 1000000.0 /7.0;
real_freq = REAL_TABLE[channel];
mx_set_frequency(mx, NULL, real_freq);
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)
do_gettimeofday(&begin);
#else
ktime_get_real_ts64(&begin);
#endif
locked1 = locked2 = 0;
while (1) {
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)
do_gettimeofday(&now);
#else
ktime_get_real_ts64(&now);
#endif
pt3_mx_get_locked1(mx, NULL, &locked1);
pt3_mx_get_locked2(mx, NULL, &locked2);
if (locked1 && locked2)
break;
if (time_diff(&begin, &now) > 1000)
break;
schedule_timeout_interruptible(msecs_to_jiffies(1));
}
#if 0
PT3_PRINTK(7, KERN_DEBUG, "mx_get_locked1 %d locked2 %d\n", locked1, locked2);
#endif
if (!(locked1 && locked2))
return STATUS_PLL_LOCK_TIMEOUT_ERROR;
status = pt3_tc_set_agc_t(mx->tc, NULL, PT3_TC_AGC_AUTO);
if (status)
return status;
return status;
}
int parport_wait_peripheral(struct parport *port,
unsigned char mask,
unsigned char result)
{
int ret;
int usec;
unsigned long deadline;
unsigned char status;
usec = port->physport->spintime; /* usecs of fast polling */
if (!port->physport->cad->timeout)
/* A zero timeout is "special": busy wait for the
entire 35ms. */
usec = 35000;
/* Fast polling.
*
* This should be adjustable.
* How about making a note (in the device structure) of how long
* it takes, so we know for next time?
*/
ret = parport_poll_peripheral (port, mask, result, usec);
if (ret != 1)
return ret;
if (!port->physport->cad->timeout)
/* We may be in an interrupt handler, so we can't poll
* slowly anyway. */
return 1;
/* 40ms of slow polling. */
deadline = jiffies + msecs_to_jiffies(40);
while (time_before (jiffies, deadline)) {
int ret;
if (signal_pending (current))
return -EINTR;
/* Wait for 10ms (or until an interrupt occurs if
* the handler is set) */
if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0)
return ret;
status = parport_read_status (port);
if ((status & mask) == result)
return 0;
if (!ret) {
/* parport_wait_event didn't time out, but the
* peripheral wasn't actually ready either.
* Wait for another 10ms. */
schedule_timeout_interruptible(msecs_to_jiffies(10));
}
}
return 1;
}
/* Identify device by flashing LEDs */
static int efx_ethtool_phys_id(struct net_device *net_dev, u32 seconds)
{
struct efx_nic *efx = net_dev->priv;
efx->board_info.blink(efx, 1);
schedule_timeout_interruptible(seconds * HZ);
efx->board_info.blink(efx, 0);
return 0;
}
/* Xceive tuner reset function */
int ivtv_reset_tuner_gpio(void *dev, int component, int cmd, int value)
{
struct i2c_algo_bit_data *algo = dev;
struct ivtv *itv = algo->data;
u32 curout;
if (cmd != XC2028_TUNER_RESET)
return 0;
IVTV_DEBUG_INFO("Resetting tuner\n");
curout = read_reg(IVTV_REG_GPIO_OUT);
curout &= ~(1 << itv->card->xceive_pin);
write_reg(curout, IVTV_REG_GPIO_OUT);
schedule_timeout_interruptible(msecs_to_jiffies(1));
curout |= 1 << itv->card->xceive_pin;
write_reg(curout, IVTV_REG_GPIO_OUT);
schedule_timeout_interruptible(msecs_to_jiffies(1));
return 0;
}
static int watchdog_thread(void *data)
{
pr_info("%s: Enter into watchdog_thread\n", __func__);
while (1) {
pr_debug("%s: feed the watchdog\n", __func__);
s3c2410wdt_keepalive(&s3c2410_wdd);
schedule_timeout_interruptible(HZ);
}
return 0;
}
static int wait_isoch_resource_delay_after_bus_reset(struct fw_card *card)
{
for (;;) {
s64 delay = (card->reset_jiffies + HZ) - get_jiffies_64();
if (delay <= 0)
return 0;
if (schedule_timeout_interruptible(delay) > 0)
return -ERESTARTSYS;
}
}
/*
* This work ramps both output PGA's at stream start/stop time to
* minimise pop associated with DAPM power switching.
* It's best to enable Zero Cross when ramping occurs to minimise any
* zipper noises.
*/
static void wm8350_pga_work(struct work_struct *work)
{
struct snd_soc_codec *codec =
container_of(work, struct snd_soc_codec, delayed_work.work);
struct wm8350_out_ramp *or = codec->private_data;
struct wm8350_output *out1 = &or->out1, *out2 = &or->out2;
int i, out1_complete, out2_complete;
/* do we need to ramp at all ? */
if (out1->ramp == WM8350_RAMP_NONE && out2->ramp == WM8350_RAMP_NONE)
return;
/* PGA volumes have 6 bits of resolution to ramp */
for (i = 0; i <= 63; i++) {
out1_complete = 1, out2_complete = 1;
if (out1->ramp != WM8350_RAMP_NONE)
out1_complete = wm8350_out1_ramp_step(codec);
if (out2->ramp != WM8350_RAMP_NONE)
out2_complete = wm8350_out2_ramp_step(codec);
/* ramp finished ? */
if (out1_complete && out2_complete)
break;
/* we need to delay longer on the up ramp */
if (out1->ramp == WM8350_RAMP_UP ||
out2->ramp == WM8350_RAMP_UP) {
/* delay is longer over 0dB as increases are larger */
if (i >= WM8350_OUTn_0dB)
schedule_timeout_interruptible(
msecs_to_jiffies(2));
else
schedule_timeout_interruptible(
msecs_to_jiffies(1));
} else
udelay(50); /* doesn't matter if we delay longer */
}
out1->ramp = WM8350_RAMP_NONE;
out2->ramp = WM8350_RAMP_NONE;
}
static int tps65090_charger_poll_task(void *data)
{
set_freezable();
while (!kthread_should_stop()) {
schedule_timeout_interruptible(POLL_INTERVAL);
try_to_freeze();
tps65090_charger_isr(-1, data);
}
return 0;
}
v_VOID_t vos_sleep_us( v_U32_t usInterval )
{
unsigned long timeout = usecs_to_jiffies(usInterval) + 1;
if (in_interrupt())
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s cannot be called from interrupt context!!!", __func__);
return;
}
while (timeout && !signal_pending(current))
timeout = schedule_timeout_interruptible(timeout);
}
static int run_network(void *data)
{
struct msghdr msg;
struct iovec iov;
mm_segment_t oldfs;
char buffer[0x200];// = "Hello";
int cc;
struct socket *csock = data;
struct nm_packet_rp *reply;
printk(KERN_INFO "NetMalloc: creating client thread\n");
while (network_is_running)
{
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = MSG_DONTWAIT;
msg.msg_iov->iov_len = sizeof(buffer);
msg.msg_iov->iov_base = buffer;
oldfs = get_fs();
set_fs(KERNEL_DS);
cc = sock_recvmsg(csock, &msg, sizeof(buffer), MSG_DONTWAIT);
set_fs(oldfs);
if (!cc)
break;
else if (cc == -EWOULDBLOCK)
schedule_timeout_interruptible(125);
else if (cc > 0)
{
printk(KERN_INFO "%d bytes received\n", cc);
reply = handle_packet((struct nm_packet_rq *) buffer, cc);
if (reply)
{
cc = sizeof(struct nm_packet_rp) + reply->data_len;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = MSG_DONTWAIT;
msg.msg_iov->iov_len = cc;
msg.msg_iov->iov_base = reply;
oldfs = get_fs();
set_fs(KERNEL_DS);
cc = sock_sendmsg(csock, &msg, cc);
set_fs(oldfs);
printk(KERN_INFO "%d bytes sent\n", cc);
kfree(reply);
}
}
}
sock_release(csock);
printk(KERN_INFO "NetMalloc: closing client thread\n");
return 0;
}
void hw_camdrv_msleep(unsigned int ms)
{
struct timeval now;
unsigned long jiffies;
if (ms > 0) {
now.tv_sec = ms / 1000;
now.tv_usec = (ms % 1000) * 1000;
jiffies = timeval_to_jiffies(&now);
schedule_timeout_interruptible(jiffies);
}
}
int gfs2_recoverd(void *data)
{
struct gfs2_sbd *sdp = data;
unsigned long t;
while (!kthread_should_stop()) {
gfs2_check_journals(sdp);
t = gfs2_tune_get(sdp, gt_recoverd_secs) * HZ;
schedule_timeout_interruptible(t);
}
return 0;
}
int update_counter_thread(void *data)
{
TZ_RESULT ret;
KREE_SESSION_HANDLE icnt_session;
uint32_t result;
uint32_t a, b, rate;
uint32_t nsec = THREAD_COUNT_FREQ;
ret = KREE_CreateSession(TZ_TA_ICNT_UUID, &icnt_session);
if (ret != TZ_RESULT_SUCCESS)
{
printk("CreateSession error %d\n", ret);
return 1;
}
result = TEECK_Icnt_Rate(icnt_session, &rate);
if (result == TZ_RESULT_SUCCESS)
{
//printk("(yjdbg) rate: %d\n", rate);
nsec = (0xffffffff / rate);
nsec -= 600;
//printk("(yjdbg) rate: %d\n", nsec);
}
set_freezable();
for (;;) {
if (kthread_should_stop())
break;
if (try_to_freeze())
continue;
result = TEECK_Icnt_Counter(icnt_session, &a, &b);
if (result == TZ_RESULT_SUCCESS)
{
//printk("(yjdbg) tz_test TZCMD_ICNT_COUNT: 0x%x, 0x%x\n", a, b);
}
schedule_timeout_interruptible(HZ * nsec);
}
ret = KREE_CloseSession(icnt_session);
if (ret != TZ_RESULT_SUCCESS)
{
printk("CloseSession error %d\n", ret);
return 1;
}
return 0;
}
/* pay attention: application should lock the route set period. */
static int bb_control_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
unsigned short reg;
struct snd_soc_codec *codec = wm9713_dai[WM9713_DAI_PCM_VOICE].codec;
if (bb_enable == 1 && ucontrol->value.integer.value[0] == 0)
printk(KERN_INFO "Disable BB!!\n");
if (bb_enable == 0 && ucontrol->value.integer.value[0] == 1) {
printk(KERN_INFO "Enable BB!!\n");
snd_soc_dapm_stream_event(codec, "Voice Playback",
SND_SOC_DAPM_STREAM_START);
snd_soc_dapm_stream_event(codec, "Voice Capture",
SND_SOC_DAPM_STREAM_START);
/*enable VRA mode*/
codec->write(codec, AC97_EXTENDED_STATUS, 0x1);
codec->write(codec, AC97_PCM_LR_ADC_RATE, 0x1F40);
codec->write(codec, AC97_EXTENDED_MID,
codec->read(codec, AC97_EXTENDED_MID)&0xffc3);
codec->write(codec, AC97_EXTENDED_MSTATUS,
codec->read(codec, AC97_EXTENDED_MSTATUS)&0xf9f5);
codec->write(codec, AC97_POWERDOWN, 0);
codec->write(codec, AC97_HANDSET_RATE, 0x0f80);
schedule_timeout_interruptible(msecs_to_jiffies(10));
codec->write(codec, AC97_CENTER_LFE_MASTER, 0xa8b3);
reg = codec->read(codec, AC97_GPIO_CFG);
reg |= (0x1<<1);
reg |= (0x1<<3);
reg |= (0x1<<4);
reg &= ~(0x1<<5);
codec->write(codec, AC97_GPIO_CFG, reg);
schedule_timeout_interruptible(msecs_to_jiffies(10));
}
bb_enable = ucontrol->value.integer.value[0];
return 0;
}
static void snd_msnd_dsp_write_flush(struct snd_msnd *chip)
{
if (!(chip->mode & FMODE_WRITE) || !test_bit(F_WRITING, &chip->flags))
return;
set_bit(F_WRITEFLUSH, &chip->flags);
/* interruptible_sleep_on_timeout(
&chip->writeflush,
get_play_delay_jiffies(&chip, chip->DAPF.len));*/
clear_bit(F_WRITEFLUSH, &chip->flags);
if (!signal_pending(current))
schedule_timeout_interruptible(
get_play_delay_jiffies(chip, chip->play_period_bytes));
clear_bit(F_WRITING, &chip->flags);
}
