static void nfs4_shutdown_client(struct nfs_client *clp)
{
if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
nfs4_kill_renewd(clp);
nfs4_shutdown_session(clp);
nfs4_destroy_callback(clp);
if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
nfs_idmap_delete(clp);
rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
kfree(clp->cl_serverowner);
kfree(clp->cl_serverscope);
kfree(clp->cl_implid);
}
static void mpc8xxx_gpio_set_multiple(struct gpio_chip *gc,
unsigned long *mask, unsigned long *bits)
{
struct of_mm_gpio_chip *mm = to_of_mm_gpio_chip(gc);
struct mpc8xxx_gpio_chip *mpc8xxx_gc = to_mpc8xxx_gpio_chip(mm);
unsigned long flags;
int i;
raw_spin_lock_irqsave(&mpc8xxx_gc->lock, flags);
for (i = 0; i < gc->ngpio; i++) {
if (*mask == 0)
break;
if (__test_and_clear_bit(i, mask)) {
if (test_bit(i, bits))
mpc8xxx_gc->data |= mpc8xxx_gpio2mask(i);
else
mpc8xxx_gc->data &= ~mpc8xxx_gpio2mask(i);
}
}
out_be32(mm->regs + GPIO_DAT, mpc8xxx_gc->data);
raw_spin_unlock_irqrestore(&mpc8xxx_gc->lock, flags);
}
/*
* This is called by a user process when it sees the DISARM_BUFS event
* bit is set.
*/
int qib_disarm_piobufs_ifneeded(struct qib_ctxtdata *rcd)
{
struct qib_devdata *dd = rcd->dd;
unsigned i;
unsigned last;
unsigned n = 0;
last = rcd->pio_base + rcd->piocnt;
/*
* Don't need uctxt_lock here, since user has called in to us.
* Clear at start in case more interrupts set bits while we
* are disarming
*/
if (rcd->user_event_mask) {
/*
* subctxt_cnt is 0 if not shared, so do base
* separately, first, then remaining subctxt, if any
*/
clear_bit(_QIB_EVENT_DISARM_BUFS_BIT, &rcd->user_event_mask[0]);
for (i = 1; i < rcd->subctxt_cnt; i++)
clear_bit(_QIB_EVENT_DISARM_BUFS_BIT,
&rcd->user_event_mask[i]);
}
spin_lock_irq(&dd->pioavail_lock);
for (i = rcd->pio_base; i < last; i++) {
if (__test_and_clear_bit(i, dd->pio_need_disarm)) {
n++;
dd->f_sendctrl(rcd->ppd, QIB_SENDCTRL_DISARM_BUF(i));
}
}
spin_unlock_irq(&dd->pioavail_lock);
return 0;
}
static void pm8921_chg_disable_irq(struct pm8921_chg_chip *chip, int interrupt)
{
if (__test_and_clear_bit(interrupt, chip->enabled_irqs)) {
dev_dbg(chip->dev, "%d\n", chip->pmic_chg_irq[interrupt]);
disable_irq_nosync(chip->pmic_chg_irq[interrupt]);
}
}
/* Must be called hw IRQs off. */
void __ipipe_lock_irq(unsigned int irq)
{
struct ipipe_domain *ipd = ipipe_root_domain;
struct ipipe_percpu_domain_data *p;
int l0b, l1b;
IPIPE_WARN_ONCE(!hard_irqs_disabled());
/*
* Interrupts requested by a registered head domain cannot be
* locked, since this would make no sense: interrupts are
* globally masked at CPU level when the head domain is
* stalled, so there is no way we could encounter the
* situation IRQ locks are handling.
*/
if (test_and_set_bit(IPIPE_LOCK_FLAG, &ipd->irqs[irq].control))
return;
l0b = irq / (BITS_PER_LONG * BITS_PER_LONG);
l1b = irq / BITS_PER_LONG;
p = ipipe_this_cpu_context(ipd);
if (__test_and_clear_bit(irq, p->irqpend_lomap)) {
__set_bit(irq, p->irqheld_map);
if (p->irqpend_lomap[l1b] == 0) {
__clear_bit(l1b, p->irqpend_mdmap);
if (p->irqpend_mdmap[l0b] == 0)
__clear_bit(l0b, &p->irqpend_himap);
}
}
}
static void pm8058_chg_disable_irq(int interrupt)
{
if (__test_and_clear_bit(interrupt, pm8058_chg.enabled_irqs)) {
dev_dbg(pm8058_chg.dev, "%s %d\n", __func__,
pm8058_chg.pmic_chg_irq[interrupt]);
disable_irq_nosync(pm8058_chg.pmic_chg_irq[interrupt]);
}
}
static void test_and_clear_bit_test(int *bits, unsigned long *flags, int num)
{
int i,
result = 1;
for(i = 0; i < num; i++)
result &= __test_and_clear_bit(bits[i], flags);
assert(result && (flags[0] == 0UL && flags[1] == 0UL));
}
static void rfkill_op_handler(struct work_struct *work)
{
unsigned int i;
bool c;
spin_lock_irq(&rfkill_op_lock);
do {
if (rfkill_op_pending) {
enum rfkill_sched_op op = rfkill_op;
rfkill_op_pending = false;
memset(rfkill_sw_pending, 0,
sizeof(rfkill_sw_pending));
spin_unlock_irq(&rfkill_op_lock);
__rfkill_handle_global_op(op);
spin_lock_irq(&rfkill_op_lock);
/*
* handle global ops first -- during unlocked period
* we might have gotten a new global op.
*/
if (rfkill_op_pending)
continue;
}
if (rfkill_is_epo_lock_active())
continue;
for (i = 0; i < NUM_RFKILL_TYPES; i++) {
if (__test_and_clear_bit(i, rfkill_sw_pending)) {
c = __test_and_clear_bit(i, rfkill_sw_state);
spin_unlock_irq(&rfkill_op_lock);
__rfkill_handle_normal_op(i, c);
spin_lock_irq(&rfkill_op_lock);
}
}
} while (rfkill_op_pending);
spin_unlock_irq(&rfkill_op_lock);
}
static void dealloc_unique_number(struct unique_numspace *s, int number)
{
int old_val;
if (number >= 0) {
down(&numspace_mutex);
old_val = __test_and_clear_bit(number, s->bits);
if (old_val)
++s->num_free;
up(&numspace_mutex);
}
}
static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
int out=0, in;
int key_index;
int gpio;
struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
struct gpio_event_matrix_info *mi = kp->keypad_info;
unsigned gpio_keypad_flags = mi->flags;
unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
kp->last_key_state_changed = kp->key_state_changed;
kp->key_state_changed = 0;
kp->some_keys_pressed = 0;
key_index = 0;
for (in = 0; in < mi->ninputs; in++, key_index++) {
gpio = mi->input_gpios[in];
if (gpio_get_value(gpio) ^ !polarity) {
if (kp->some_keys_pressed < 3)
kp->some_keys_pressed++;
kp->key_state_changed |= !__test_and_set_bit(
key_index, kp->keys_pressed);
} else
kp->key_state_changed |= __test_and_clear_bit(
key_index, kp->keys_pressed);
}
if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
if (kp->key_state_changed) {
hrtimer_start(&kp->timer, mi->debounce_delay,
HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
kp->key_state_changed = kp->last_key_state_changed;
}
if (kp->key_state_changed) {
if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
remove_phantom_keys(kp);
key_index = 0;
for (in = 0; in < mi->ninputs; in++, key_index++)
report_key(kp, key_index, out, in);
}
if (!kp->use_irq || kp->some_keys_pressed) {
hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
/* No keys are pressed, reenable interrupt */
for (in = 0; in < mi->ninputs; in++)
enable_irq(gpio_to_irq(mi->input_gpios[in]));
wake_unlock(&kp->wake_lock);
return HRTIMER_NORESTART;
}
static void ack_work(struct work_struct *work)
{
struct pptp_opt *opt=container_of(work,struct pptp_opt,ack_work);
struct pppox_sock *po=container_of(opt,struct pppox_sock,proto.pptp);
#else
static void ack_work(struct pppox_sock *po)
{
struct pptp_opt *opt=&po->proto.pptp;
#endif
INC_ACK_WORKS;
pptp_xmit(&po->chan,0);
if (!test_and_set_bit(PPTP_FLAG_PROC,(unsigned long*)&opt->flags)){
if (ppp_unit_number(&po->chan)!=-1){
char unit[10];
sprintf(unit,"ppp%i",ppp_unit_number(&po->chan));
create_proc_read_entry(unit,0,proc_dir,read_proc,po);
}else clear_bit(PPTP_FLAG_PROC,(unsigned long*)&opt->flags);
}
}
static void do_ack_timeout_work(struct pppox_sock *po)
{
struct pptp_opt *opt=&po->proto.pptp;
int paused;
spin_lock_bh(&opt->xmit_lock);
paused=__test_and_clear_bit(PPTP_FLAG_PAUSE,(unsigned long*)&opt->flags);
if (paused){
if (opt->window>min_window) --opt->window;
opt->ack_recv=opt->seq_sent;
}
spin_unlock_bh(&opt->xmit_lock);
if (paused) ppp_output_wakeup(&po->chan);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
static void _ack_timeout_work(struct work_struct *work)
{
struct pptp_opt *opt=container_of(work,struct pptp_opt,ack_timeout_work.work);
struct pppox_sock *po=container_of(opt,struct pppox_sock,proto.pptp);
INC_ACK_TIMEOUTS;
do_ack_timeout_work(po);
}
#else
static void _ack_timeout_work(struct pppox_sock *po)
{
INC_ACK_TIMEOUTS;
do_ack_timeout_work(po);
}
void drbd_bm_unlock(struct drbd_conf *mdev)
{
struct drbd_bitmap *b = mdev->bitmap;
if (!b) {
dev_err(DEV, "FIXME no bitmap in drbd_bm_unlock!?\n");
return;
}
if (!__test_and_clear_bit(BM_LOCKED, &mdev->bitmap->bm_flags))
dev_err(DEV, "FIXME bitmap not locked in bm_unlock\n");
b->bm_why = NULL;
b->bm_task = NULL;
mutex_unlock(&b->bm_change);
}
void hvm_isa_irq_deassert(
struct domain *d, unsigned int isa_irq)
{
struct hvm_irq *hvm_irq = &d->arch.hvm_domain.irq;
unsigned int gsi = hvm_isa_irq_to_gsi(isa_irq);
ASSERT(isa_irq <= 15);
spin_lock(&d->arch.hvm_domain.irq_lock);
if ( __test_and_clear_bit(isa_irq, &hvm_irq->isa_irq.i) &&
(--hvm_irq->gsi_assert_count[gsi] == 0) )
deassert_irq(d, isa_irq);
spin_unlock(&d->arch.hvm_domain.irq_lock);
}
void hvm_pci_intx_deassert(
struct domain *d, unsigned int device, unsigned int intx)
{
struct hvm_irq *hvm_irq = &d->arch.hvm_domain.irq;
unsigned int gsi;
ASSERT((device <= 31) && (intx <= 3));
if ( !__test_and_clear_bit(device * 4 + intx, &hvm_irq->pci_intx.i) )
return;
gsi = hvm_pci_intx_gsi(device, intx);
if (--hvm_irq->gsi_assert_count[gsi] == 0)
viosapic_set_irq(d, gsi, 0);
}
/**
* hpsb_free_tlabel - free an allocated transaction label
* @packet: packet whose tlabel and tl_pool needs to be cleared
*
* Frees the transaction label allocated with hpsb_get_tlabel(). The
* tlabel has to be freed after the transaction is complete (i.e. response
* was received for a split transaction or packet was sent for a unified
* transaction).
*
* A tlabel must not be freed twice.
*/
void hpsb_free_tlabel(struct hpsb_packet *packet)
{
unsigned long flags, *tp;
int tlabel, n = NODEID_TO_NODE(packet->node_id);
if (unlikely(n == ALL_NODES))
return;
tp = packet->host->tl_pool[n].map;
tlabel = packet->tlabel;
BUG_ON(tlabel > 63 || tlabel < 0);
spin_lock_irqsave(&hpsb_tlabel_lock, flags);
BUG_ON(!__test_and_clear_bit(tlabel, tp));
spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
wake_up_interruptible(&tlabel_wq);
}
int rt2x00mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
{
struct rt2x00_dev *rt2x00dev = hw->priv;
int force_reconfig;
/*
* Mac80211 might be calling this function while we are trying
* to remove the device or perhaps suspending it.
*/
if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags))
return 0;
/*
* Check if we need to disable the radio,
* if this is not the case, at least the RX must be disabled.
*/
if (test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags)) {
if (!conf->radio_enabled)
rt2x00lib_disable_radio(rt2x00dev);
else
rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
}
/*
* When the DEVICE_DIRTY_CONFIG flag is set, the device has recently
* been started and the configuration must be forced upon the hardware.
* Otherwise registers will not be intialized correctly and could
* result in non-working hardware because essential registers aren't
* initialized.
*/
force_reconfig =
__test_and_clear_bit(DEVICE_DIRTY_CONFIG, &rt2x00dev->flags);
rt2x00lib_config(rt2x00dev, conf, force_reconfig);
/*
* Reenable RX only if the radio should be on.
*/
if (test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
else if (conf->radio_enabled)
return rt2x00lib_enable_radio(rt2x00dev);
return 0;
}
void __init microcode_grab_module(
unsigned long *module_map,
const multiboot_info_t *mbi,
void *(*map)(const module_t *))
{
module_t *mod = (module_t *)__va(mbi->mods_addr);
if ( ucode_mod_idx < 0 )
ucode_mod_idx += mbi->mods_count;
if ( ucode_mod_idx <= 0 || ucode_mod_idx >= mbi->mods_count ||
!__test_and_clear_bit(ucode_mod_idx, module_map) )
goto scan;
ucode_mod = mod[ucode_mod_idx];
ucode_mod_map = map;
scan:
if ( ucode_scan )
microcode_scan_module(module_map, mbi, map);
}
/* Must be called hw IRQs off. */
void __ipipe_lock_irq(unsigned int irq)
{
struct ipipe_percpu_domain_data *p;
int l0b = irq / BITS_PER_LONG;
IPIPE_WARN_ONCE(!hard_irqs_disabled());
if (test_and_set_bit(IPIPE_LOCK_FLAG,
&ipipe_root_domain->irqs[irq].control))
return;
p = ipipe_this_cpu_root_context();
if (__test_and_clear_bit(irq, p->irqpend_lomap)) {
__set_bit(irq, p->irqheld_map);
if (p->irqpend_lomap[l0b] == 0)
__clear_bit(l0b, &p->irqpend_himap);
}
}
static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
int out, in;
int key_index;
int gpio;
struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
struct gpio_event_matrix_info *mi = kp->keypad_info;
unsigned gpio_keypad_flags = mi->flags;
unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
out = kp->current_output;
if (out == mi->noutputs) {
out = 0;
kp->last_key_state_changed = kp->key_state_changed;
kp->key_state_changed = 0;
kp->some_keys_pressed = 0;
} else {
key_index = out * mi->ninputs;
for (in = 0; in < mi->ninputs; in++, key_index++) {
gpio = mi->input_gpios[in];
if (gpio_get_value(gpio) ^ !polarity) {
if (kp->some_keys_pressed < 3)
kp->some_keys_pressed++;
kp->key_state_changed |= !__test_and_set_bit(
key_index, kp->keys_pressed);
} else
kp->key_state_changed |= __test_and_clear_bit(
key_index, kp->keys_pressed);
}
gpio = mi->output_gpios[out];
if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
#ifdef ROW_SCAN //ZTE_KB_ZFJ_20110325
{
gpio_set_value(gpio, !polarity);
gpio_direction_input(gpio);
}
#else
gpio_set_value(gpio, !polarity);
#endif
else
gpio_direction_input(gpio);
out++;
}
/*
* TX data handlers.
*/
static void rt2x00usb_interrupt_txdone(struct urb *urb)
{
struct queue_entry *entry = (struct queue_entry *)urb->context;
struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
struct queue_entry_priv_usb_tx *priv_tx = entry->priv_data;
struct txdone_entry_desc txdesc;
__le32 *txd = (__le32 *)entry->skb->data;
u32 word;
if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
!__test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
return;
rt2x00_desc_read(txd, 0, &word);
/*
* Remove the descriptor data from the buffer.
*/
skb_pull(entry->skb, entry->queue->desc_size);
/*
* Obtain the status about this packet.
*/
txdesc.status = !urb->status ? TX_SUCCESS : TX_FAIL_RETRY;
txdesc.retry = 0;
txdesc.control = &priv_tx->control;
rt2x00lib_txdone(entry, &txdesc);
/*
* Make this entry available for reuse.
*/
entry->flags = 0;
rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE);
/*
* If the data queue was full before the txdone handler
* we must make sure the packet queue in the mac80211 stack
* is reenabled when the txdone handler has finished.
*/
if (!rt2x00queue_full(entry->queue))
ieee80211_wake_queue(rt2x00dev->hw, priv_tx->control.queue);
}
/*
* Initialization/uninitialization handlers.
*/
static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
{
if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
return;
/*
* Unregister extra components.
*/
rt2x00rfkill_unregister(rt2x00dev);
/*
* Allow the HW to uninitialize.
*/
rt2x00dev->ops->lib->uninitialize(rt2x00dev);
/*
* Free allocated queue entries.
*/
rt2x00queue_uninitialize(rt2x00dev);
}
static void __hvm_pci_intx_deassert(
struct domain *d, unsigned int device, unsigned int intx)
{
struct hvm_irq *hvm_irq = &d->arch.hvm_domain.irq;
unsigned int gsi, link, isa_irq;
ASSERT((device <= 31) && (intx <= 3));
if ( !__test_and_clear_bit(device*4 + intx, &hvm_irq->pci_intx.i) )
return;
gsi = hvm_pci_intx_gsi(device, intx);
--hvm_irq->gsi_assert_count[gsi];
link = hvm_pci_intx_link(device, intx);
isa_irq = hvm_irq->pci_link.route[link];
if ( (--hvm_irq->pci_link_assert_count[link] == 0) && isa_irq &&
(--hvm_irq->gsi_assert_count[isa_irq] == 0) )
deassert_irq(d, isa_irq);
}
/**
* wufs_free_inode: (utility routine)
* Reverse the effects of wufs_new_inode.
*/
void wufs_free_inode(struct inode * inode)
{
struct wufs_sb_info *sbi = wufs_sb(inode->i_sb);
struct buffer_head *bh;
int bits_per_block = 8 * WUFS_BLOCKSIZE;
unsigned long ino, bit, mapBlock;
/* grab the inode *number* */
ino = inode->i_ino;
if (ino < 1 || ino > sbi->sbi_inodes) {
printk("wufs_free_inode: nonexistent inode (%lu)\n",ino);
goto out;
}
/* we now compute the inode index as a block and bit offset */
ino--;
bit = ino % bits_per_block;
mapBlock = ino/bits_per_block;
if (mapBlock >= sbi->sbi_imap_bcnt) {
printk("wufs_free_inode: nonexistent imap block (%lu) in superblock\n",
mapBlock);
goto out;
}
/* mark the on-disk inode as free */
wufs_clear_inode(inode);
/* now, clear the associated bit */
bh = sbi->sbi_imap[mapBlock];
spin_lock(&bitmap_lock);
/* clear the bit: */
if (!__test_and_clear_bit(bit, (unsigned long*)bh->b_data))
printk("wufs_free_inode: bit %lu already cleared\n", bit);
spin_unlock(&bitmap_lock);
/* write back bitmap */
mark_buffer_dirty(bh);
out:
/* clear the vfs inode, marking it for deletion (see linux/fs/inode.c) */
clear_inode(inode);
}
static void bgpio_multiple_get_masks(struct bgpio_chip *bgc,
unsigned long *mask, unsigned long *bits,
unsigned long *set_mask,
unsigned long *clear_mask)
{
int i;
*set_mask = 0;
*clear_mask = 0;
for (i = 0; i < bgc->bits; i++) {
if (*mask == 0)
break;
if (__test_and_clear_bit(i, mask)) {
if (test_bit(i, bits))
*set_mask |= bgc->pin2mask(bgc, i);
else
*clear_mask |= bgc->pin2mask(bgc, i);
}
}
}
void vm_free(const void *va)
{
unsigned int bit = vm_index(va);
if ( !bit )
{
WARN_ON(va != NULL);
return;
}
spin_lock(&vm_lock);
if ( bit < vm_low )
{
vm_low = bit - 1;
while ( !test_bit(vm_low - 1, vm_bitmap) )
--vm_low;
}
while ( __test_and_clear_bit(bit, vm_bitmap) )
if ( ++bit == vm_top )
break;
spin_unlock(&vm_lock);
}
/**
* wufs_free_block: (utility function)
* Undoes the accounting of allocating a block.
* Simply: clear the bit at the appropriate offset in the bitmap.
*/
void wufs_free_block(struct inode *inode, unsigned long block)
{
/* grab our local info structures */
struct super_block *sb = inode->i_sb;
struct wufs_sb_info *sbi = wufs_sb(sb);
struct buffer_head *bh;
int bits_per_block = 8 * inode->i_sb->s_blocksize;
unsigned long bit, mapBlock;
int previous;
/* sanity check: we're only working with data blocks */
if (block < sbi->sbi_first_block || block >= sbi->sbi_blocks) {
printk("wufs_free_block: Trying to free non-data block %lu\n",block);
return;
}
/* break bit offset into block offset in map and bit offset in block */
bit = block % bits_per_block;
mapBlock = block/bits_per_block;
if (mapBlock >= sbi->sbi_bmap_bcnt) {
printk("wufs_free_block: nonexistent bitmap buffer, %lu\n",mapBlock);
return;
}
/* grab the buffer head */
bh = sbi->sbi_bmap[mapBlock];
/* get exclusive access */
spin_lock(&bitmap_lock);
previous = __test_and_clear_bit(bit, (unsigned long*)bh->b_data); /* see <linux/Documentation/atomic_ops.txt> */
spin_unlock(&bitmap_lock);
/* check status (outside the critical section!) */
if (!previous) printk("wufs_free_block (%s:%lu): bit already cleared\n",
sb->s_id, block);
/* flush bitmap buffer */
mark_buffer_dirty(bh);
return;
}
void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
{
if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
return;
/*
* Stop the TX queues.
*/
ieee80211_stop_queues(rt2x00dev->hw);
/*
* Disable RX.
*/
rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
/*
* Disable radio.
*/
rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
rt2x00led_led_activity(rt2x00dev, false);
rt2x00leds_led_radio(rt2x00dev, false);
}
/**
* xgpio_set_multiple - Write the specified signals of the GPIO device.
* @gc: Pointer to gpio_chip device structure.
* @mask: Mask of the GPIOS to modify.
* @bits: Value to be wrote on each GPIO
*
* This function writes the specified values into the specified signals of the
* GPIO devices.
*/
static void xgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
unsigned long *bits)
{
unsigned long flags;
struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
struct xgpio_instance *chip = gpiochip_get_data(gc);
int index = xgpio_index(chip, 0);
int offset, i;
spin_lock_irqsave(&chip->gpio_lock[index], flags);
/* Write to GPIO signals */
for (i = 0; i < gc->ngpio; i++) {
if (*mask == 0)
break;
if (index != xgpio_index(chip, i)) {
xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET +
xgpio_regoffset(chip, i),
chip->gpio_state[index]);
spin_unlock_irqrestore(&chip->gpio_lock[index], flags);
index = xgpio_index(chip, i);
spin_lock_irqsave(&chip->gpio_lock[index], flags);
}
if (__test_and_clear_bit(i, mask)) {
offset = xgpio_offset(chip, i);
if (test_bit(i, bits))
chip->gpio_state[index] |= BIT(offset);
else
chip->gpio_state[index] &= ~BIT(offset);
}
}
xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET +
xgpio_regoffset(chip, i), chip->gpio_state[index]);
spin_unlock_irqrestore(&chip->gpio_lock[index], flags);
}
/*
* Destroy the NFS4 callback service
*/
static void nfs4_destroy_callback(struct nfs_client *clp)
{
if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
nfs_callback_down(clp->cl_mvops->minor_version, clp->cl_net);
}
static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
int out, in;
int key_index;
int gpio;
struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
struct gpio_event_matrix_info *mi = kp->keypad_info;
unsigned gpio_keypad_flags = mi->flags;
#ifdef CONFIG_ZTE_PLATFORM
unsigned polarity = !!(gpio_keypad_flags & !GPIOKPF_ACTIVE_HIGH);
#else
unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
#endif
out = kp->current_output;
if (out == mi->noutputs) {
out = 0;
kp->last_key_state_changed = kp->key_state_changed;
kp->key_state_changed = 0;
kp->some_keys_pressed = 0;
} else {
key_index = out * mi->ninputs;
for (in = 0; in < mi->ninputs; in++, key_index++) {
gpio = mi->input_gpios[in];
if (gpio_get_value(gpio) ^ !polarity) {
if (kp->some_keys_pressed < 3)
kp->some_keys_pressed++;
kp->key_state_changed |= !__test_and_set_bit(
key_index, kp->keys_pressed);
} else
kp->key_state_changed |= __test_and_clear_bit(
key_index, kp->keys_pressed);
}
gpio = mi->output_gpios[out];
if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
gpio_set_value(gpio, !polarity);
else
gpio_direction_input(gpio);
out++;
}
kp->current_output = out;
if (out < mi->noutputs) {
gpio = mi->output_gpios[out];
if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
gpio_set_value(gpio, polarity);
else
gpio_direction_output(gpio, polarity);
hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
if (kp->key_state_changed) {
hrtimer_start(&kp->timer, mi->debounce_delay,
HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
kp->key_state_changed = kp->last_key_state_changed;
}
if (kp->key_state_changed) {
if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
remove_phantom_keys(kp);
key_index = 0;
for (out = 0; out < mi->noutputs; out++)
for (in = 0; in < mi->ninputs; in++, key_index++)
report_key(kp, key_index, out, in);
}
if (!kp->use_irq || kp->some_keys_pressed) {
hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
/* No keys are pressed, reenable interrupt */
for (out = 0; out < mi->noutputs; out++) {
if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
gpio_set_value(mi->output_gpios[out], polarity);
else
gpio_direction_output(mi->output_gpios[out], polarity);
}
for (in = 0; in < mi->ninputs; in++)
enable_irq(gpio_to_irq(mi->input_gpios[in]));
wake_unlock(&kp->wake_lock);
return HRTIMER_NORESTART;
}
