| /linux-4.1.27/net/netfilter/ |
| H A D | nf_conntrack_h323_asn1.c | 103 #define INC_BIT(bs) if((++(bs)->bit)>7){(bs)->cur++;(bs)->bit=0;}
104 #define INC_BITS(bs,b) if(((bs)->bit+=(b))>7){(bs)->cur+=(bs)->bit>>3;(bs)->bit&=7;}
105 #define BYTE_ALIGN(bs) if((bs)->bit){(bs)->cur++;(bs)->bit=0;}
106 #define CHECK_BOUND(bs,n) if((bs)->cur+(n)>(bs)->end)return(H323_ERROR_BOUND)
107 static unsigned int get_len(bitstr_t *bs);
108 static unsigned int get_bit(bitstr_t *bs);
109 static unsigned int get_bits(bitstr_t *bs, unsigned int b);
110 static unsigned int get_bitmap(bitstr_t *bs, unsigned int b);
111 static unsigned int get_uint(bitstr_t *bs, int b);
114 static int decode_nul(bitstr_t *bs, const struct field_t *f, char *base, int level);
115 static int decode_bool(bitstr_t *bs, const struct field_t *f, char *base, int level);
116 static int decode_oid(bitstr_t *bs, const struct field_t *f, char *base, int level);
117 static int decode_int(bitstr_t *bs, const struct field_t *f, char *base, int level);
118 static int decode_enum(bitstr_t *bs, const struct field_t *f, char *base, int level);
119 static int decode_bitstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
120 static int decode_numstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
121 static int decode_octstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
122 static int decode_bmpstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
123 static int decode_seq(bitstr_t *bs, const struct field_t *f, char *base, int level);
124 static int decode_seqof(bitstr_t *bs, const struct field_t *f, char *base, int level);
125 static int decode_choice(bitstr_t *bs, const struct field_t *f, char *base, int level);
152 /* Assume bs is aligned && v < 16384 */ get_len()
153 static unsigned int get_len(bitstr_t *bs) get_len() argument
157 v = *bs->cur++; get_len()
162 v += *bs->cur++; get_len()
169 static unsigned int get_bit(bitstr_t *bs) get_bit() argument
171 unsigned int b = (*bs->cur) & (0x80 >> bs->bit); get_bit()
173 INC_BIT(bs); get_bit()
180 static unsigned int get_bits(bitstr_t *bs, unsigned int b) get_bits() argument
184 v = (*bs->cur) & (0xffU >> bs->bit); get_bits()
185 l = b + bs->bit; get_bits()
189 bs->bit = l; get_bits()
191 bs->cur++; get_bits()
192 bs->bit = 0; get_bits()
196 v += *(++bs->cur); get_bits()
198 bs->bit = l - 8; get_bits()
206 static unsigned int get_bitmap(bitstr_t *bs, unsigned int b) get_bitmap() argument
213 l = bs->bit + b; get_bitmap()
216 v = (unsigned int)(*bs->cur) << (bs->bit + 24); get_bitmap()
217 bs->bit = l; get_bitmap()
219 v = (unsigned int)(*bs->cur++) << (bs->bit + 24); get_bitmap()
220 bs->bit = 0; get_bitmap()
224 v |= (unsigned int)(*bs->cur++) << shift; get_bitmap()
227 v |= (unsigned int)(*bs->cur) << shift; get_bitmap()
228 v <<= bs->bit; get_bitmap()
230 v <<= bs->bit; get_bitmap()
231 v |= (*bs->cur) >> (8 - bs->bit); get_bitmap()
234 bs->bit = l & 0x7; get_bitmap()
243 * Assume bs is aligned and sizeof(unsigned int) == 4
245 static unsigned int get_uint(bitstr_t *bs, int b) get_uint() argument
251 v |= *bs->cur++; get_uint()
254 v |= *bs->cur++; get_uint()
257 v |= *bs->cur++; get_uint()
260 v |= *bs->cur++; get_uint()
267 static int decode_nul(bitstr_t *bs, const struct field_t *f, decode_nul() argument
276 static int decode_bool(bitstr_t *bs, const struct field_t *f, decode_bool() argument
281 INC_BIT(bs); decode_bool()
283 CHECK_BOUND(bs, 0); decode_bool()
288 static int decode_oid(bitstr_t *bs, const struct field_t *f, decode_oid() argument
295 BYTE_ALIGN(bs); decode_oid()
296 CHECK_BOUND(bs, 1); decode_oid()
297 len = *bs->cur++; decode_oid()
298 bs->cur += len; decode_oid()
300 CHECK_BOUND(bs, 0); decode_oid()
305 static int decode_int(bitstr_t *bs, const struct field_t *f, decode_int() argument
314 BYTE_ALIGN(bs); decode_int()
315 bs->cur++; decode_int()
318 BYTE_ALIGN(bs); decode_int()
319 bs->cur += 2; decode_int()
322 len = get_bits(bs, 2) + 1; decode_int()
323 BYTE_ALIGN(bs); decode_int()
325 unsigned int v = get_uint(bs, len) + f->lb; decode_int()
329 bs->cur += len; decode_int()
332 BYTE_ALIGN(bs); decode_int()
333 CHECK_BOUND(bs, 2); decode_int()
334 len = get_len(bs); decode_int()
335 bs->cur += len; decode_int()
338 INC_BITS(bs, f->sz); decode_int()
344 CHECK_BOUND(bs, 0); decode_int()
349 static int decode_enum(bitstr_t *bs, const struct field_t *f, decode_enum() argument
354 if ((f->attr & EXT) && get_bit(bs)) { decode_enum()
355 INC_BITS(bs, 7); decode_enum()
357 INC_BITS(bs, f->sz); decode_enum()
360 CHECK_BOUND(bs, 0); decode_enum()
365 static int decode_bitstr(bitstr_t *bs, const struct field_t *f, decode_bitstr() argument
372 BYTE_ALIGN(bs); decode_bitstr()
378 CHECK_BOUND(bs, 2); decode_bitstr()
379 len = (*bs->cur++) << 8; decode_bitstr()
380 len += (*bs->cur++) + f->lb; decode_bitstr()
383 CHECK_BOUND(bs, 2); decode_bitstr()
384 len = get_len(bs); decode_bitstr()
391 bs->cur += len >> 3; decode_bitstr()
392 bs->bit = len & 7; decode_bitstr()
394 CHECK_BOUND(bs, 0); decode_bitstr()
399 static int decode_numstr(bitstr_t *bs, const struct field_t *f, decode_numstr() argument
407 len = get_bits(bs, f->sz) + f->lb; decode_numstr()
409 BYTE_ALIGN(bs); decode_numstr()
410 INC_BITS(bs, (len << 2)); decode_numstr()
412 CHECK_BOUND(bs, 0); decode_numstr()
417 static int decode_octstr(bitstr_t *bs, const struct field_t *f, decode_octstr() argument
427 BYTE_ALIGN(bs); decode_octstr()
432 bs->cur[0], bs->cur[1], decode_octstr()
433 bs->cur[2], bs->cur[3], decode_octstr()
434 bs->cur[4] * 256 + bs->cur[5])); decode_octstr()
436 bs->cur - bs->buf; decode_octstr()
442 BYTE_ALIGN(bs); decode_octstr()
443 CHECK_BOUND(bs, 1); decode_octstr()
444 len = (*bs->cur++) + f->lb; decode_octstr()
447 BYTE_ALIGN(bs); decode_octstr()
448 CHECK_BOUND(bs, 2); decode_octstr()
449 len = get_len(bs) + f->lb; decode_octstr()
452 len = get_bits(bs, f->sz) + f->lb; decode_octstr()
453 BYTE_ALIGN(bs); decode_octstr()
457 bs->cur += len; decode_octstr()
461 CHECK_BOUND(bs, 0); decode_octstr()
466 static int decode_bmpstr(bitstr_t *bs, const struct field_t *f, decode_bmpstr() argument
475 BYTE_ALIGN(bs); decode_bmpstr()
476 CHECK_BOUND(bs, 1); decode_bmpstr()
477 len = (*bs->cur++) + f->lb; decode_bmpstr()
480 len = get_bits(bs, f->sz) + f->lb; decode_bmpstr()
481 BYTE_ALIGN(bs); decode_bmpstr()
485 bs->cur += len << 1; decode_bmpstr()
487 CHECK_BOUND(bs, 0); decode_bmpstr()
492 static int decode_seq(bitstr_t *bs, const struct field_t *f, decode_seq() argument
506 ext = (f->attr & EXT) ? get_bit(bs) : 0; decode_seq()
509 bmp = get_bitmap(bs, f->sz); decode_seq()
528 CHECK_BOUND(bs, 2); decode_seq()
529 len = get_len(bs); decode_seq()
530 CHECK_BOUND(bs, len); decode_seq()
534 bs->cur += len; decode_seq()
537 beg = bs->cur; decode_seq()
540 if ((err = (Decoders[son->type]) (bs, son, base, decode_seq()
545 bs->cur = beg + len; decode_seq()
546 bs->bit = 0; decode_seq()
547 } else if ((err = (Decoders[son->type]) (bs, son, base, decode_seq()
558 bmp2_len = get_bits(bs, 7) + 1; decode_seq()
559 CHECK_BOUND(bs, (bmp2_len + 7) >> 3); decode_seq()
560 bmp2 = get_bitmap(bs, bmp2_len); decode_seq()
564 BYTE_ALIGN(bs); decode_seq()
570 CHECK_BOUND(bs, 2); decode_seq()
571 len = get_len(bs); decode_seq()
572 CHECK_BOUND(bs, len); decode_seq()
573 bs->cur += len; decode_seq()
586 CHECK_BOUND(bs, 2); decode_seq()
587 len = get_len(bs); decode_seq()
588 CHECK_BOUND(bs, len); decode_seq()
592 bs->cur += len; decode_seq()
595 beg = bs->cur; decode_seq()
597 if ((err = (Decoders[son->type]) (bs, son, base, decode_seq()
602 bs->cur = beg + len; decode_seq()
603 bs->bit = 0; decode_seq()
609 static int decode_seqof(bitstr_t *bs, const struct field_t *f, decode_seqof() argument
625 BYTE_ALIGN(bs); decode_seqof()
626 CHECK_BOUND(bs, 1); decode_seqof()
627 count = *bs->cur++; decode_seqof()
630 BYTE_ALIGN(bs); decode_seqof()
631 CHECK_BOUND(bs, 2); decode_seqof()
632 count = *bs->cur++; decode_seqof()
634 count += *bs->cur++; decode_seqof()
637 BYTE_ALIGN(bs); decode_seqof()
638 CHECK_BOUND(bs, 2); decode_seqof()
639 count = get_len(bs); decode_seqof()
642 count = get_bits(bs, f->sz); decode_seqof()
660 BYTE_ALIGN(bs); decode_seqof()
661 len = get_len(bs); decode_seqof()
662 CHECK_BOUND(bs, len); decode_seqof()
666 bs->cur += len; decode_seqof()
669 beg = bs->cur; decode_seqof()
671 if ((err = (Decoders[son->type]) (bs, son, decode_seqof()
679 bs->cur = beg + len; decode_seqof()
680 bs->bit = 0; decode_seqof()
682 if ((err = (Decoders[son->type]) (bs, son, decode_seqof()
699 static int decode_choice(bitstr_t *bs, const struct field_t *f, decode_choice() argument
713 if ((f->attr & EXT) && get_bit(bs)) { decode_choice()
715 type = get_bits(bs, 7) + f->lb; decode_choice()
718 type = get_bits(bs, f->sz); decode_choice()
729 BYTE_ALIGN(bs); decode_choice()
730 len = get_len(bs); decode_choice()
731 CHECK_BOUND(bs, len); decode_choice()
732 bs->cur += len; decode_choice()
744 BYTE_ALIGN(bs); decode_choice()
745 len = get_len(bs); decode_choice()
746 CHECK_BOUND(bs, len); decode_choice()
750 bs->cur += len; decode_choice()
753 beg = bs->cur; decode_choice()
755 if ((err = (Decoders[son->type]) (bs, son, base, level + 1)) < decode_choice()
759 bs->cur = beg + len; decode_choice()
760 bs->bit = 0; decode_choice()
761 } else if ((err = (Decoders[son->type]) (bs, son, base, level + 1)) < decode_choice()
775 bitstr_t bs; DecodeRasMessage() local
777 bs.buf = bs.beg = bs.cur = buf; DecodeRasMessage()
778 bs.end = buf + sz; DecodeRasMessage()
779 bs.bit = 0; DecodeRasMessage()
781 return decode_choice(&bs, &ras_message, (char *) ras, 0); DecodeRasMessage()
792 bitstr_t bs; DecodeH323_UserInformation() local
794 bs.buf = buf; DecodeH323_UserInformation()
795 bs.beg = bs.cur = beg; DecodeH323_UserInformation()
796 bs.end = beg + sz; DecodeH323_UserInformation()
797 bs.bit = 0; DecodeH323_UserInformation()
799 return decode_seq(&bs, &h323_userinformation, (char *) uuie, 0); DecodeH323_UserInformation()
811 bitstr_t bs; DecodeMultimediaSystemControlMessage() local
813 bs.buf = bs.beg = bs.cur = buf; DecodeMultimediaSystemControlMessage()
814 bs.end = buf + sz; DecodeMultimediaSystemControlMessage()
815 bs.bit = 0; DecodeMultimediaSystemControlMessage()
817 return decode_choice(&bs, &multimediasystemcontrolmessage, DecodeMultimediaSystemControlMessage()
|
| /linux-4.1.27/drivers/spi/ |
| H A D | spi-bcm63xx-hsspi.c | 108 static void bcm63xx_hsspi_set_cs(struct bcm63xx_hsspi *bs, unsigned cs, bcm63xx_hsspi_set_cs() argument
113 mutex_lock(&bs->bus_mutex); bcm63xx_hsspi_set_cs()
114 reg = __raw_readl(bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_set_cs()
117 if (active == !(bs->cs_polarity & BIT(cs))) bcm63xx_hsspi_set_cs()
120 __raw_writel(reg, bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_set_cs()
121 mutex_unlock(&bs->bus_mutex); bcm63xx_hsspi_set_cs()
124 static void bcm63xx_hsspi_set_clk(struct bcm63xx_hsspi *bs, bcm63xx_hsspi_set_clk() argument
130 reg = DIV_ROUND_UP(2048, DIV_ROUND_UP(bs->speed_hz, hz)); bcm63xx_hsspi_set_clk()
132 bs->regs + HSSPI_PROFILE_CLK_CTRL_REG(profile)); bcm63xx_hsspi_set_clk()
134 reg = __raw_readl(bs->regs + HSSPI_PROFILE_SIGNAL_CTRL_REG(profile)); bcm63xx_hsspi_set_clk()
139 __raw_writel(reg, bs->regs + HSSPI_PROFILE_SIGNAL_CTRL_REG(profile)); bcm63xx_hsspi_set_clk()
141 mutex_lock(&bs->bus_mutex); bcm63xx_hsspi_set_clk()
143 reg = __raw_readl(bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_set_clk()
147 __raw_writel(reg, bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_set_clk()
148 mutex_unlock(&bs->bus_mutex); bcm63xx_hsspi_set_clk()
153 struct bcm63xx_hsspi *bs = spi_master_get_devdata(spi->master); bcm63xx_hsspi_do_txrx() local
161 bcm63xx_hsspi_set_clk(bs, spi, t->speed_hz); bcm63xx_hsspi_do_txrx()
162 bcm63xx_hsspi_set_cs(bs, spi->chip_select, true); bcm63xx_hsspi_do_txrx()
177 bs->regs + HSSPI_PROFILE_MODE_CTRL_REG(chip_select)); bcm63xx_hsspi_do_txrx()
182 reinit_completion(&bs->done); bcm63xx_hsspi_do_txrx()
184 memcpy_toio(bs->fifo + HSSPI_OPCODE_LEN, tx, curr_step); bcm63xx_hsspi_do_txrx()
188 __raw_writew(opcode | curr_step, bs->fifo); bcm63xx_hsspi_do_txrx()
192 bs->regs + HSSPI_INT_MASK_REG); bcm63xx_hsspi_do_txrx()
198 bs->regs + HSSPI_PINGPONG_COMMAND_REG(0)); bcm63xx_hsspi_do_txrx()
200 if (wait_for_completion_timeout(&bs->done, HZ) == 0) { bcm63xx_hsspi_do_txrx()
201 dev_err(&bs->pdev->dev, "transfer timed out!\n"); bcm63xx_hsspi_do_txrx()
206 memcpy_fromio(rx, bs->fifo, curr_step); bcm63xx_hsspi_do_txrx()
218 struct bcm63xx_hsspi *bs = spi_master_get_devdata(spi->master); bcm63xx_hsspi_setup() local
221 reg = __raw_readl(bs->regs + bcm63xx_hsspi_setup()
228 __raw_writel(reg, bs->regs + bcm63xx_hsspi_setup()
231 mutex_lock(&bs->bus_mutex); bcm63xx_hsspi_setup()
232 reg = __raw_readl(bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_setup()
235 if ((reg & GLOBAL_CTRL_CS_POLARITY_MASK) == bs->cs_polarity) { bcm63xx_hsspi_setup()
240 __raw_writel(reg, bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_setup()
244 bs->cs_polarity |= BIT(spi->chip_select); bcm63xx_hsspi_setup()
246 bs->cs_polarity &= ~BIT(spi->chip_select); bcm63xx_hsspi_setup()
248 mutex_unlock(&bs->bus_mutex); bcm63xx_hsspi_setup()
256 struct bcm63xx_hsspi *bs = spi_master_get_devdata(master); bcm63xx_hsspi_transfer_one() local
278 bcm63xx_hsspi_set_cs(bs, dummy_cs, true); bcm63xx_hsspi_transfer_one()
291 bcm63xx_hsspi_set_cs(bs, spi->chip_select, false); bcm63xx_hsspi_transfer_one()
294 mutex_lock(&bs->bus_mutex); bcm63xx_hsspi_transfer_one()
295 reg = __raw_readl(bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_transfer_one()
297 reg |= bs->cs_polarity; bcm63xx_hsspi_transfer_one()
298 __raw_writel(reg, bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_transfer_one()
299 mutex_unlock(&bs->bus_mutex); bcm63xx_hsspi_transfer_one()
309 struct bcm63xx_hsspi *bs = (struct bcm63xx_hsspi *)dev_id; bcm63xx_hsspi_interrupt() local
311 if (__raw_readl(bs->regs + HSSPI_INT_STATUS_MASKED_REG) == 0) bcm63xx_hsspi_interrupt()
314 __raw_writel(HSSPI_INT_CLEAR_ALL, bs->regs + HSSPI_INT_STATUS_REG); bcm63xx_hsspi_interrupt()
315 __raw_writel(0, bs->regs + HSSPI_INT_MASK_REG); bcm63xx_hsspi_interrupt()
317 complete(&bs->done); bcm63xx_hsspi_interrupt()
325 struct bcm63xx_hsspi *bs; bcm63xx_hsspi_probe() local
357 master = spi_alloc_master(&pdev->dev, sizeof(*bs)); bcm63xx_hsspi_probe()
363 bs = spi_master_get_devdata(master); bcm63xx_hsspi_probe()
364 bs->pdev = pdev; bcm63xx_hsspi_probe()
365 bs->clk = clk; bcm63xx_hsspi_probe()
366 bs->regs = regs; bcm63xx_hsspi_probe()
367 bs->speed_hz = rate; bcm63xx_hsspi_probe()
368 bs->fifo = (u8 __iomem *)(bs->regs + HSSPI_FIFO_REG(0)); bcm63xx_hsspi_probe()
370 mutex_init(&bs->bus_mutex); bcm63xx_hsspi_probe()
371 init_completion(&bs->done); bcm63xx_hsspi_probe()
384 __raw_writel(0, bs->regs + HSSPI_INT_MASK_REG); bcm63xx_hsspi_probe()
387 __raw_writel(HSSPI_INT_CLEAR_ALL, bs->regs + HSSPI_INT_STATUS_REG); bcm63xx_hsspi_probe()
390 reg = __raw_readl(bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_probe()
391 bs->cs_polarity = reg & GLOBAL_CTRL_CS_POLARITY_MASK; bcm63xx_hsspi_probe()
393 bs->regs + HSSPI_GLOBAL_CTRL_REG); bcm63xx_hsspi_probe()
396 pdev->name, bs); bcm63xx_hsspi_probe()
419 struct bcm63xx_hsspi *bs = spi_master_get_devdata(master); bcm63xx_hsspi_remove() local
422 __raw_writel(0, bs->regs + HSSPI_INT_MASK_REG); bcm63xx_hsspi_remove()
423 clk_disable_unprepare(bs->clk); bcm63xx_hsspi_remove()
432 struct bcm63xx_hsspi *bs = spi_master_get_devdata(master); bcm63xx_hsspi_suspend() local
435 clk_disable_unprepare(bs->clk); bcm63xx_hsspi_suspend()
443 struct bcm63xx_hsspi *bs = spi_master_get_devdata(master); bcm63xx_hsspi_resume() local
446 ret = clk_prepare_enable(bs->clk); bcm63xx_hsspi_resume()
|
| H A D | spi-bcm63xx.c | 53 static inline u8 bcm_spi_readb(struct bcm63xx_spi *bs, bcm_spi_readb() argument
56 return bcm_readb(bs->regs + bcm63xx_spireg(offset)); bcm_spi_readb()
59 static inline u16 bcm_spi_readw(struct bcm63xx_spi *bs, bcm_spi_readw() argument
62 return bcm_readw(bs->regs + bcm63xx_spireg(offset)); bcm_spi_readw()
65 static inline void bcm_spi_writeb(struct bcm63xx_spi *bs, bcm_spi_writeb() argument
68 bcm_writeb(value, bs->regs + bcm63xx_spireg(offset)); bcm_spi_writeb()
71 static inline void bcm_spi_writew(struct bcm63xx_spi *bs, bcm_spi_writew() argument
74 bcm_writew(value, bs->regs + bcm63xx_spireg(offset)); bcm_spi_writew()
90 struct bcm63xx_spi *bs = spi_master_get_devdata(spi->master); bcm63xx_spi_setup_transfer() local
107 reg = bcm_spi_readb(bs, SPI_CLK_CFG); bcm63xx_spi_setup_transfer()
111 bcm_spi_writeb(bs, reg, SPI_CLK_CFG); bcm63xx_spi_setup_transfer()
122 struct bcm63xx_spi *bs = spi_master_get_devdata(spi->master); bcm63xx_txrx_bufs() local
132 bcm_spi_writeb(bs, 0, SPI_INT_MASK); bcm63xx_txrx_bufs()
144 memcpy_toio(bs->tx_io + len, t->tx_buf, t->len); bcm63xx_txrx_bufs()
164 reinit_completion(&bs->done); bcm63xx_txrx_bufs()
170 msg_ctl |= (SPI_FD_RW << bs->msg_type_shift); bcm63xx_txrx_bufs()
172 msg_ctl |= (SPI_HD_R << bs->msg_type_shift); bcm63xx_txrx_bufs()
174 msg_ctl |= (SPI_HD_W << bs->msg_type_shift); bcm63xx_txrx_bufs()
176 switch (bs->msg_ctl_width) { bcm63xx_txrx_bufs()
178 bcm_spi_writeb(bs, msg_ctl, SPI_MSG_CTL); bcm63xx_txrx_bufs()
181 bcm_spi_writew(bs, msg_ctl, SPI_MSG_CTL); bcm63xx_txrx_bufs()
189 bcm_spi_writew(bs, cmd, SPI_CMD); bcm63xx_txrx_bufs()
192 bcm_spi_writeb(bs, SPI_INTR_CMD_DONE, SPI_INT_MASK); bcm63xx_txrx_bufs()
194 timeout = wait_for_completion_timeout(&bs->done, HZ); bcm63xx_txrx_bufs()
206 memcpy_fromio(t->rx_buf, bs->rx_io + len, t->len); bcm63xx_txrx_bufs()
221 struct bcm63xx_spi *bs = spi_master_get_devdata(master); bcm63xx_spi_transfer_one() local
249 total_len > (bs->fifo_size + BCM63XX_SPI_MAX_PREPEND)) || bcm63xx_spi_transfer_one()
250 (!can_use_prepend && total_len > bs->fifo_size)) { bcm63xx_spi_transfer_one()
252 total_len, bs->fifo_size); bcm63xx_spi_transfer_one()
302 struct bcm63xx_spi *bs = spi_master_get_devdata(master); bcm63xx_spi_interrupt() local
306 intr = bcm_spi_readb(bs, SPI_INT_STATUS); bcm63xx_spi_interrupt()
307 bcm_spi_writeb(bs, SPI_INTR_CLEAR_ALL, SPI_INT_STATUS); bcm63xx_spi_interrupt()
308 bcm_spi_writeb(bs, 0, SPI_INT_MASK); bcm63xx_spi_interrupt()
312 complete(&bs->done); bcm63xx_spi_interrupt()
326 struct bcm63xx_spi *bs; bcm63xx_spi_probe() local
341 master = spi_alloc_master(dev, sizeof(*bs)); bcm63xx_spi_probe()
347 bs = spi_master_get_devdata(master); bcm63xx_spi_probe()
348 init_completion(&bs->done); bcm63xx_spi_probe()
351 bs->pdev = pdev; bcm63xx_spi_probe()
354 bs->regs = devm_ioremap_resource(&pdev->dev, r); bcm63xx_spi_probe()
355 if (IS_ERR(bs->regs)) { bcm63xx_spi_probe()
356 ret = PTR_ERR(bs->regs); bcm63xx_spi_probe()
360 bs->irq = irq; bcm63xx_spi_probe()
361 bs->clk = clk; bcm63xx_spi_probe()
362 bs->fifo_size = pdata->fifo_size; bcm63xx_spi_probe()
377 bs->msg_type_shift = pdata->msg_type_shift; bcm63xx_spi_probe()
378 bs->msg_ctl_width = pdata->msg_ctl_width; bcm63xx_spi_probe()
379 bs->tx_io = (u8 *)(bs->regs + bcm63xx_spireg(SPI_MSG_DATA)); bcm63xx_spi_probe()
380 bs->rx_io = (const u8 *)(bs->regs + bcm63xx_spireg(SPI_RX_DATA)); bcm63xx_spi_probe()
382 switch (bs->msg_ctl_width) { bcm63xx_spi_probe()
388 bs->msg_ctl_width); bcm63xx_spi_probe()
393 ret = clk_prepare_enable(bs->clk); bcm63xx_spi_probe()
397 bcm_spi_writeb(bs, SPI_INTR_CLEAR_ALL, SPI_INT_STATUS); bcm63xx_spi_probe()
407 r->start, irq, bs->fifo_size); bcm63xx_spi_probe()
421 struct bcm63xx_spi *bs = spi_master_get_devdata(master); bcm63xx_spi_remove() local
424 bcm_spi_writeb(bs, 0, SPI_INT_MASK); bcm63xx_spi_remove()
427 clk_disable_unprepare(bs->clk); bcm63xx_spi_remove()
436 struct bcm63xx_spi *bs = spi_master_get_devdata(master); bcm63xx_spi_suspend() local
440 clk_disable_unprepare(bs->clk); bcm63xx_spi_suspend()
448 struct bcm63xx_spi *bs = spi_master_get_devdata(master); bcm63xx_spi_resume() local
451 ret = clk_prepare_enable(bs->clk); bcm63xx_spi_resume()
|
| H A D | spi-bcm2835.c | 88 static inline u32 bcm2835_rd(struct bcm2835_spi *bs, unsigned reg) bcm2835_rd() argument
90 return readl(bs->regs + reg); bcm2835_rd()
93 static inline void bcm2835_wr(struct bcm2835_spi *bs, unsigned reg, u32 val) bcm2835_wr() argument
95 writel(val, bs->regs + reg); bcm2835_wr()
98 static inline void bcm2835_rd_fifo(struct bcm2835_spi *bs) bcm2835_rd_fifo() argument
102 while ((bs->rx_len) && bcm2835_rd_fifo()
103 (bcm2835_rd(bs, BCM2835_SPI_CS) & BCM2835_SPI_CS_RXD)) { bcm2835_rd_fifo()
104 byte = bcm2835_rd(bs, BCM2835_SPI_FIFO); bcm2835_rd_fifo()
105 if (bs->rx_buf) bcm2835_rd_fifo()
106 *bs->rx_buf++ = byte; bcm2835_rd_fifo()
107 bs->rx_len--; bcm2835_rd_fifo()
111 static inline void bcm2835_wr_fifo(struct bcm2835_spi *bs) bcm2835_wr_fifo() argument
115 while ((bs->tx_len) && bcm2835_wr_fifo()
116 (bcm2835_rd(bs, BCM2835_SPI_CS) & BCM2835_SPI_CS_TXD)) { bcm2835_wr_fifo()
117 byte = bs->tx_buf ? *bs->tx_buf++ : 0; bcm2835_wr_fifo()
118 bcm2835_wr(bs, BCM2835_SPI_FIFO, byte); bcm2835_wr_fifo()
119 bs->tx_len--; bcm2835_wr_fifo()
125 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_reset_hw() local
126 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS); bcm2835_spi_reset_hw()
136 bcm2835_wr(bs, BCM2835_SPI_CS, cs); bcm2835_spi_reset_hw()
142 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_interrupt() local
145 bcm2835_rd_fifo(bs); bcm2835_spi_interrupt()
147 bcm2835_wr_fifo(bs); bcm2835_spi_interrupt()
150 if (bcm2835_rd(bs, BCM2835_SPI_CS) & BCM2835_SPI_CS_DONE) { bcm2835_spi_interrupt()
166 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_transfer_one_poll() local
171 bcm2835_wr(bs, BCM2835_SPI_CS, cs | BCM2835_SPI_CS_TA); bcm2835_spi_transfer_one_poll()
174 while (bs->rx_len) { bcm2835_spi_transfer_one_poll()
176 bcm2835_rd_fifo(bs); bcm2835_spi_transfer_one_poll()
178 bcm2835_wr_fifo(bs); bcm2835_spi_transfer_one_poll()
182 if (bs->rx_len && time_after(jiffies, timeout)) { bcm2835_spi_transfer_one_poll()
201 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_transfer_one_irq() local
213 bcm2835_wr(bs, BCM2835_SPI_CS, bcm2835_spi_transfer_one_irq()
216 bcm2835_wr_fifo(bs); bcm2835_spi_transfer_one_irq()
226 bcm2835_wr(bs, BCM2835_SPI_CS, cs); bcm2835_spi_transfer_one_irq()
236 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_transfer_one() local
239 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS); bcm2835_spi_transfer_one()
243 clk_hz = clk_get_rate(bs->clk); bcm2835_spi_transfer_one()
258 bcm2835_wr(bs, BCM2835_SPI_CLK, cdiv); bcm2835_spi_transfer_one()
274 bs->tx_buf = tfr->tx_buf; bcm2835_spi_transfer_one()
275 bs->rx_buf = tfr->rx_buf; bcm2835_spi_transfer_one()
276 bs->tx_len = tfr->len; bcm2835_spi_transfer_one()
277 bs->rx_len = tfr->len; bcm2835_spi_transfer_one()
296 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_prepare_message() local
297 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS); bcm2835_spi_prepare_message()
306 bcm2835_wr(bs, BCM2835_SPI_CS, cs); bcm2835_spi_prepare_message()
330 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_set_cs() local
331 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS); bcm2835_spi_set_cs()
367 bcm2835_wr(bs, BCM2835_SPI_CS, cs); bcm2835_spi_set_cs()
430 struct bcm2835_spi *bs; bcm2835_spi_probe() local
434 master = spi_alloc_master(&pdev->dev, sizeof(*bs)); bcm2835_spi_probe()
452 bs = spi_master_get_devdata(master); bcm2835_spi_probe()
455 bs->regs = devm_ioremap_resource(&pdev->dev, res); bcm2835_spi_probe()
456 if (IS_ERR(bs->regs)) { bcm2835_spi_probe()
457 err = PTR_ERR(bs->regs); bcm2835_spi_probe()
461 bs->clk = devm_clk_get(&pdev->dev, NULL); bcm2835_spi_probe()
462 if (IS_ERR(bs->clk)) { bcm2835_spi_probe()
463 err = PTR_ERR(bs->clk); bcm2835_spi_probe()
468 bs->irq = irq_of_parse_and_map(pdev->dev.of_node, 0); bcm2835_spi_probe()
469 if (bs->irq <= 0) { bcm2835_spi_probe()
470 dev_err(&pdev->dev, "could not get IRQ: %d\n", bs->irq); bcm2835_spi_probe()
471 err = bs->irq ? bs->irq : -ENODEV; bcm2835_spi_probe()
475 clk_prepare_enable(bs->clk); bcm2835_spi_probe()
477 err = devm_request_irq(&pdev->dev, bs->irq, bcm2835_spi_interrupt, 0, bcm2835_spi_probe()
485 bcm2835_wr(bs, BCM2835_SPI_CS, bcm2835_spi_probe()
497 clk_disable_unprepare(bs->clk); bcm2835_spi_probe()
506 struct bcm2835_spi *bs = spi_master_get_devdata(master); bcm2835_spi_remove() local
509 bcm2835_wr(bs, BCM2835_SPI_CS, bcm2835_spi_remove()
512 clk_disable_unprepare(bs->clk); bcm2835_spi_remove()
|
| H A D | spi-mxs.c | 398 * dd if=/dev/mtdblock0 of=/dev/null bs=1024k count=1 mxs_spi_transfer_one()
|
| /linux-4.1.27/tools/testing/selftests/powerpc/mm/ |
| H A D | Makefile | 13 dd if=/dev/zero of=tempfile bs=64k count=1
|
| /linux-4.1.27/drivers/block/drbd/ |
| H A D | drbd_vli.h | 238 static inline void bitstream_init(struct bitstream *bs, void *s, size_t len, unsigned int pad_bits) bitstream_init() argument
240 bs->buf = s; bitstream_init()
241 bs->buf_len = len; bitstream_init()
242 bs->pad_bits = pad_bits; bitstream_init()
243 bitstream_cursor_reset(&bs->cur, bs->buf); bitstream_init()
246 static inline void bitstream_rewind(struct bitstream *bs) bitstream_rewind() argument
248 bitstream_cursor_reset(&bs->cur, bs->buf); bitstream_rewind()
249 memset(bs->buf, 0, bs->buf_len); bitstream_rewind()
260 static inline int bitstream_put_bits(struct bitstream *bs, u64 val, const unsigned int bits) bitstream_put_bits() argument
262 unsigned char *b = bs->cur.b; bitstream_put_bits()
268 if ((bs->cur.b + ((bs->cur.bit + bits -1) >> 3)) - bs->buf >= bs->buf_len) bitstream_put_bits()
275 *b++ |= (val & 0xff) << bs->cur.bit; bitstream_put_bits()
277 for (tmp = 8 - bs->cur.bit; tmp < bits; tmp += 8) bitstream_put_bits()
280 bitstream_cursor_advance(&bs->cur, bits); bitstream_put_bits()
293 static inline int bitstream_get_bits(struct bitstream *bs, u64 *out, int bits) bitstream_get_bits() argument
301 if (bs->cur.b + ((bs->cur.bit + bs->pad_bits + bits -1) >> 3) - bs->buf >= bs->buf_len) bitstream_get_bits()
302 bits = ((bs->buf_len - (bs->cur.b - bs->buf)) << 3) bitstream_get_bits()
303 - bs->cur.bit - bs->pad_bits; bitstream_get_bits()
312 n = (bs->cur.bit + bits + 7) >> 3; bitstream_get_bits()
316 memcpy(&val, bs->cur.b+1, n - 1); bitstream_get_bits()
317 val = le64_to_cpu(val) << (8 - bs->cur.bit); bitstream_get_bits()
321 val |= bs->cur.b[0] >> bs->cur.bit; bitstream_get_bits()
326 bitstream_cursor_advance(&bs->cur, bits); bitstream_get_bits()
332 /* encodes @in as vli into @bs;
336 * -ENOBUFS @bs is full
340 static inline int vli_encode_bits(struct bitstream *bs, u64 in) vli_encode_bits() argument
348 return bitstream_put_bits(bs, code, bits); vli_encode_bits()
|
| H A D | drbd_main.c | 1086 struct bitstream bs; fill_bitmap_rle_bits() local
1105 bitstream_init(&bs, p->code, size, 0); fill_bitmap_rle_bits()
1144 bits = vli_encode_bits(&bs, rl); fill_bitmap_rle_bits()
1157 len = bs.cur.b - p->code + !!bs.cur.bit; fill_bitmap_rle_bits()
1173 dcbp_set_pad_bits(p, (8 - bs.cur.bit) & 0x7); fill_bitmap_rle_bits()
|
| H A D | drbd_receiver.c | 4307 struct bitstream bs; recv_bm_rle_bits() local
4317 bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); recv_bm_rle_bits()
4319 bits = bitstream_get_bits(&bs, &look_ahead, 64); recv_bm_rle_bits()
4340 (unsigned int)(bs.cur.b - p->code), recv_bm_rle_bits()
4341 (unsigned int)bs.buf_len); recv_bm_rle_bits()
4351 bits = bitstream_get_bits(&bs, &tmp, 64 - have); recv_bm_rle_bits()
|
| /linux-4.1.27/crypto/ |
| H A D | xcbc.c | 66 int bs = crypto_shash_blocksize(parent); crypto_xcbc_digest_setkey() local
69 u8 key1[bs]; crypto_xcbc_digest_setkey()
74 crypto_cipher_encrypt_one(ctx->child, consts, (u8 *)ks + bs); crypto_xcbc_digest_setkey()
75 crypto_cipher_encrypt_one(ctx->child, consts + bs, (u8 *)ks + bs * 2); crypto_xcbc_digest_setkey()
78 return crypto_cipher_setkey(ctx->child, key1, bs); crypto_xcbc_digest_setkey()
86 int bs = crypto_shash_blocksize(pdesc->tfm); crypto_xcbc_digest_init() local
87 u8 *prev = PTR_ALIGN(&ctx->ctx[0], alignmask + 1) + bs; crypto_xcbc_digest_init()
90 memset(prev, 0, bs); crypto_xcbc_digest_init()
103 int bs = crypto_shash_blocksize(parent); crypto_xcbc_digest_update() local
105 u8 *prev = odds + bs; crypto_xcbc_digest_update()
108 if ((ctx->len + len) <= bs) { crypto_xcbc_digest_update()
115 memcpy(odds + ctx->len, p, bs - ctx->len); crypto_xcbc_digest_update()
116 len -= bs - ctx->len; crypto_xcbc_digest_update()
117 p += bs - ctx->len; crypto_xcbc_digest_update()
119 crypto_xor(prev, odds, bs); crypto_xcbc_digest_update()
126 while (len > bs) { crypto_xcbc_digest_update()
127 crypto_xor(prev, p, bs); crypto_xcbc_digest_update()
129 p += bs; crypto_xcbc_digest_update()
130 len -= bs; crypto_xcbc_digest_update()
149 int bs = crypto_shash_blocksize(parent); crypto_xcbc_digest_final() local
152 u8 *prev = odds + bs; crypto_xcbc_digest_final()
155 if (ctx->len != bs) { crypto_xcbc_digest_final()
162 rlen = bs - ctx->len -1; crypto_xcbc_digest_final()
166 offset += bs; crypto_xcbc_digest_final()
169 crypto_xor(prev, odds, bs); crypto_xcbc_digest_final()
170 crypto_xor(prev, consts + offset, bs); crypto_xcbc_digest_final()
|
| H A D | cmac.c | 59 unsigned int bs = crypto_shash_blocksize(parent); crypto_cmac_digest_setkey() local
70 memset(consts, 0, bs); crypto_cmac_digest_setkey()
73 switch (bs) { crypto_cmac_digest_setkey()
112 int bs = crypto_shash_blocksize(pdesc->tfm); crypto_cmac_digest_init() local
113 u8 *prev = PTR_ALIGN((void *)ctx->ctx, alignmask + 1) + bs; crypto_cmac_digest_init()
116 memset(prev, 0, bs); crypto_cmac_digest_init()
129 int bs = crypto_shash_blocksize(parent); crypto_cmac_digest_update() local
131 u8 *prev = odds + bs; crypto_cmac_digest_update()
134 if ((ctx->len + len) <= bs) { crypto_cmac_digest_update()
141 memcpy(odds + ctx->len, p, bs - ctx->len); crypto_cmac_digest_update()
142 len -= bs - ctx->len; crypto_cmac_digest_update()
143 p += bs - ctx->len; crypto_cmac_digest_update()
145 crypto_xor(prev, odds, bs); crypto_cmac_digest_update()
152 while (len > bs) { crypto_cmac_digest_update()
153 crypto_xor(prev, p, bs); crypto_cmac_digest_update()
155 p += bs; crypto_cmac_digest_update()
156 len -= bs; crypto_cmac_digest_update()
175 int bs = crypto_shash_blocksize(parent); crypto_cmac_digest_final() local
178 u8 *prev = odds + bs; crypto_cmac_digest_final()
181 if (ctx->len != bs) { crypto_cmac_digest_final()
188 rlen = bs - ctx->len - 1; crypto_cmac_digest_final()
192 offset += bs; crypto_cmac_digest_final()
195 crypto_xor(prev, odds, bs); crypto_cmac_digest_final()
196 crypto_xor(prev, consts + offset, bs); crypto_cmac_digest_final()
|
| H A D | hmac.c | 47 int bs = crypto_shash_blocksize(parent); hmac_setkey() local
62 if (keylen > bs) { hmac_setkey()
73 memset(ipad + keylen, 0, bs - keylen); hmac_setkey()
74 memcpy(opad, ipad, bs); hmac_setkey()
76 for (i = 0; i < bs; i++) { hmac_setkey()
82 crypto_shash_update(shash, ipad, bs) ?: hmac_setkey()
85 crypto_shash_update(shash, opad, bs) ?: hmac_setkey()
|
| H A D | lrw.c | 144 const int bs = LRW_BLOCK_SIZE; crypt() local
180 wsrc += bs; crypt()
181 wdst += bs; crypt()
182 } while ((avail -= bs) >= bs); crypt()
|
| H A D | xts.c | 100 const int bs = XTS_BLOCK_SIZE; crypt() local
130 wsrc += bs; crypt()
131 wdst += bs; crypt()
132 } while ((avail -= bs) >= bs); crypt()
|
| H A D | algif_aead.c | 355 unsigned bs = crypto_aead_blocksize(crypto_aead_reqtfm(&ctx->aead_req)); aead_recvmsg() local
417 outlen = ((used + bs - 1) / bs * bs); aead_recvmsg()
424 outlen = ((outlen + bs - 1) / bs * bs); aead_recvmsg()
|
| H A D | ccm.c | 167 unsigned int bs = 16; compute_mac() local
175 getlen = bs - pctx->ilen; compute_mac()
178 crypto_xor(odata, idata, bs); compute_mac()
186 while (datalen >= bs) { compute_mac()
187 crypto_xor(odata, data, bs); compute_mac()
190 datalen -= bs; compute_mac()
191 data += bs; compute_mac()
|
| H A D | ablkcipher.c | 193 unsigned bs = walk->blocksize; ablkcipher_copy_iv() local
195 unsigned aligned_bs = ALIGN(bs, alignmask + 1); ablkcipher_copy_iv()
206 iv = ablkcipher_get_spot(iv, bs) + aligned_bs; ablkcipher_copy_iv()
207 iv = ablkcipher_get_spot(iv, bs) + aligned_bs; ablkcipher_copy_iv()
|
| H A D | blkcipher.c | 277 unsigned bs = walk->walk_blocksize; blkcipher_copy_iv() local
278 unsigned aligned_bs = ALIGN(bs, walk->alignmask + 1); blkcipher_copy_iv()
290 iv = blkcipher_get_spot(iv, bs) + aligned_bs; blkcipher_copy_iv()
291 iv = blkcipher_get_spot(iv, bs) + aligned_bs; blkcipher_copy_iv()
|
| H A D | algif_skcipher.c | 641 unsigned bs = crypto_ablkcipher_blocksize(crypto_ablkcipher_reqtfm( skcipher_recvmsg_sync() local
672 used -= used % bs; skcipher_recvmsg_sync()
|
| /linux-4.1.27/drivers/net/wireless/ath/ath9k/ |
| H A D | common-beacon.c | 57 struct ath9k_beacon_state *bs) ath9k_cmn_beacon_config_sta()
70 memset(bs, 0, sizeof(*bs)); ath9k_cmn_beacon_config_sta()
86 bs->bs_intval = TU_TO_USEC(conf->intval); ath9k_cmn_beacon_config_sta()
87 bs->bs_dtimperiod = conf->dtim_period * bs->bs_intval; ath9k_cmn_beacon_config_sta()
88 bs->bs_nexttbtt = conf->nexttbtt; ath9k_cmn_beacon_config_sta()
89 bs->bs_nextdtim = conf->nexttbtt; ath9k_cmn_beacon_config_sta()
91 bs->bs_nextdtim = ath9k_get_next_tbtt(ah, tsf, dtim_intval); ath9k_cmn_beacon_config_sta()
99 bs->bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, conf->intval); ath9k_cmn_beacon_config_sta()
100 if (bs->bs_bmissthreshold > 15) ath9k_cmn_beacon_config_sta()
101 bs->bs_bmissthreshold = 15; ath9k_cmn_beacon_config_sta()
102 else if (bs->bs_bmissthreshold <= 0) ath9k_cmn_beacon_config_sta()
103 bs->bs_bmissthreshold = 1; ath9k_cmn_beacon_config_sta()
114 bs->bs_sleepduration = TU_TO_USEC(roundup(IEEE80211_MS_TO_TU(100), ath9k_cmn_beacon_config_sta()
116 if (bs->bs_sleepduration > bs->bs_dtimperiod) ath9k_cmn_beacon_config_sta()
117 bs->bs_sleepduration = bs->bs_dtimperiod; ath9k_cmn_beacon_config_sta()
120 bs->bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD; ath9k_cmn_beacon_config_sta()
123 bs->bs_bmissthreshold, bs->bs_sleepduration); ath9k_cmn_beacon_config_sta()
55 ath9k_cmn_beacon_config_sta(struct ath_hw *ah, struct ath_beacon_config *conf, struct ath9k_beacon_state *bs) ath9k_cmn_beacon_config_sta() argument
|
| H A D | htc_drv_beacon.c | 95 struct ath9k_beacon_state bs; ath9k_htc_beacon_config_sta() local
101 if (ath9k_cmn_beacon_config_sta(priv->ah, bss_conf, &bs) == -EPERM) ath9k_htc_beacon_config_sta()
105 ath9k_hw_set_sta_beacon_timers(priv->ah, &bs); ath9k_htc_beacon_config_sta()
|
| H A D | hw.c | 2269 const struct ath9k_beacon_state *bs) ath9k_hw_set_sta_beacon_timers()
2277 REG_WRITE(ah, AR_NEXT_TBTT_TIMER, bs->bs_nexttbtt); ath9k_hw_set_sta_beacon_timers()
2278 REG_WRITE(ah, AR_BEACON_PERIOD, bs->bs_intval); ath9k_hw_set_sta_beacon_timers()
2279 REG_WRITE(ah, AR_DMA_BEACON_PERIOD, bs->bs_intval); ath9k_hw_set_sta_beacon_timers()
2284 AR_RSSI_THR_BM_THR, bs->bs_bmissthreshold); ath9k_hw_set_sta_beacon_timers()
2286 beaconintval = bs->bs_intval; ath9k_hw_set_sta_beacon_timers()
2288 if (bs->bs_sleepduration > beaconintval) ath9k_hw_set_sta_beacon_timers()
2289 beaconintval = bs->bs_sleepduration; ath9k_hw_set_sta_beacon_timers()
2291 dtimperiod = bs->bs_dtimperiod; ath9k_hw_set_sta_beacon_timers()
2292 if (bs->bs_sleepduration > dtimperiod) ath9k_hw_set_sta_beacon_timers()
2293 dtimperiod = bs->bs_sleepduration; ath9k_hw_set_sta_beacon_timers()
2296 nextTbtt = bs->bs_nextdtim; ath9k_hw_set_sta_beacon_timers()
2298 nextTbtt = bs->bs_nexttbtt; ath9k_hw_set_sta_beacon_timers()
2300 ath_dbg(common, BEACON, "next DTIM %d\n", bs->bs_nextdtim); ath9k_hw_set_sta_beacon_timers()
2307 REG_WRITE(ah, AR_NEXT_DTIM, bs->bs_nextdtim - SLEEP_SLOP); ath9k_hw_set_sta_beacon_timers()
2332 REG_WRITE(ah, AR_TSFOOR_THRESHOLD, bs->bs_tsfoor_threshold); ath9k_hw_set_sta_beacon_timers()
2268 ath9k_hw_set_sta_beacon_timers(struct ath_hw *ah, const struct ath9k_beacon_state *bs) ath9k_hw_set_sta_beacon_timers() argument
|
| H A D | beacon.c | 476 struct ath9k_beacon_state bs; ath9k_beacon_config_sta() local
478 if (ath9k_cmn_beacon_config_sta(ah, conf, &bs) == -EPERM) ath9k_beacon_config_sta()
482 ath9k_hw_set_sta_beacon_timers(ah, &bs); ath9k_beacon_config_sta()
|
| H A D | hw.h | 1063 const struct ath9k_beacon_state *bs);
|
| /linux-4.1.27/block/ |
| H A D | blk-mq-tag.c | 81 struct bt_wait_state *bs = &bt->bs[wake_index]; blk_mq_tag_wakeup_all() local
83 if (waitqueue_active(&bs->wait)) blk_mq_tag_wakeup_all()
84 wake_up(&bs->wait); blk_mq_tag_wakeup_all()
91 if (waitqueue_active(&bt->bs[0].wait)) blk_mq_tag_wakeup_all()
92 wake_up(&bt->bs[0].wait); blk_mq_tag_wakeup_all()
242 struct bt_wait_state *bs; bt_wait_ptr() local
246 return &bt->bs[0]; bt_wait_ptr()
249 bs = &bt->bs[wait_index]; bt_wait_ptr()
251 return bs; bt_wait_ptr()
259 struct bt_wait_state *bs; bt_get() local
270 bs = bt_wait_ptr(bt, hctx); bt_get()
272 prepare_to_wait(&bs->wait, &wait, TASK_UNINTERRUPTIBLE); bt_get()
309 finish_wait(&bs->wait, &wait); bt_get()
310 bs = bt_wait_ptr(bt, hctx); bt_get()
313 finish_wait(&bs->wait, &wait); bt_get()
360 struct bt_wait_state *bs = &bt->bs[wake_index]; bt_wake_ptr() local
362 if (waitqueue_active(&bs->wait)) { bt_wake_ptr()
367 return bs; bt_wake_ptr()
379 struct bt_wait_state *bs; bt_clear_tag() local
387 bs = bt_wake_ptr(bt); bt_clear_tag()
388 if (!bs) bt_clear_tag()
391 wait_cnt = atomic_dec_return(&bs->wait_cnt); bt_clear_tag()
393 wait_cnt = atomic_inc_return(&bs->wait_cnt); bt_clear_tag()
395 atomic_add(bt->wake_cnt, &bs->wait_cnt); bt_clear_tag()
397 wake_up(&bs->wait); bt_clear_tag()
526 bt->bs = kzalloc(BT_WAIT_QUEUES * sizeof(*bt->bs), GFP_KERNEL); bt_alloc()
527 if (!bt->bs) { bt_alloc()
536 init_waitqueue_head(&bt->bs[i].wait); bt_alloc()
537 atomic_set(&bt->bs[i].wait_cnt, bt->wake_cnt); bt_alloc()
546 kfree(bt->bs); bt_free()
|
| H A D | bio-integrity.c | 50 struct bio_set *bs = bio->bi_pool; bio_integrity_alloc() local
54 if (!bs || !bs->bio_integrity_pool) { bio_integrity_alloc()
59 bip = mempool_alloc(bs->bio_integrity_pool, gfp_mask); bio_integrity_alloc()
70 bs->bvec_integrity_pool); bio_integrity_alloc()
86 mempool_free(bip, bs->bio_integrity_pool); bio_integrity_alloc()
101 struct bio_set *bs = bio->bi_pool; bio_integrity_free() local
107 if (bs && bs->bio_integrity_pool) { bio_integrity_free()
109 bvec_free(bs->bvec_integrity_pool, bip->bip_vec, bio_integrity_free()
112 mempool_free(bip, bs->bio_integrity_pool); bio_integrity_free()
473 int bioset_integrity_create(struct bio_set *bs, int pool_size) bioset_integrity_create() argument
475 if (bs->bio_integrity_pool) bioset_integrity_create()
478 bs->bio_integrity_pool = mempool_create_slab_pool(pool_size, bip_slab); bioset_integrity_create()
479 if (!bs->bio_integrity_pool) bioset_integrity_create()
482 bs->bvec_integrity_pool = biovec_create_pool(pool_size); bioset_integrity_create()
483 if (!bs->bvec_integrity_pool) { bioset_integrity_create()
484 mempool_destroy(bs->bio_integrity_pool); bioset_integrity_create()
492 void bioset_integrity_free(struct bio_set *bs) bioset_integrity_free() argument
494 if (bs->bio_integrity_pool) bioset_integrity_free()
495 mempool_destroy(bs->bio_integrity_pool); bioset_integrity_free()
497 if (bs->bvec_integrity_pool) bioset_integrity_free()
498 mempool_destroy(bs->bvec_integrity_pool); bioset_integrity_free()
|
| H A D | bio.c | 127 static void bio_put_slab(struct bio_set *bs) bio_put_slab() argument
135 if (bs->bio_slab == bio_slabs[i].slab) { bio_put_slab()
247 struct bio_set *bs = bio->bi_pool; bio_free() local
252 if (bs) { bio_free()
254 bvec_free(bs->bvec_pool, bio->bi_io_vec, BIO_POOL_IDX(bio)); bio_free()
260 p -= bs->front_pad; bio_free()
262 mempool_free(p, bs->bio_pool); bio_free()
329 struct bio_set *bs = container_of(work, struct bio_set, rescue_work); bio_alloc_rescue() local
333 spin_lock(&bs->rescue_lock); bio_alloc_rescue()
334 bio = bio_list_pop(&bs->rescue_list); bio_alloc_rescue()
335 spin_unlock(&bs->rescue_lock); bio_alloc_rescue()
344 static void punt_bios_to_rescuer(struct bio_set *bs) punt_bios_to_rescuer() argument
364 bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio); punt_bios_to_rescuer()
368 spin_lock(&bs->rescue_lock); punt_bios_to_rescuer()
369 bio_list_merge(&bs->rescue_list, &punt); punt_bios_to_rescuer()
370 spin_unlock(&bs->rescue_lock); punt_bios_to_rescuer()
372 queue_work(bs->rescue_workqueue, &bs->rescue_work); punt_bios_to_rescuer()
379 * @bs: the bio_set to allocate from.
382 * If @bs is NULL, uses kmalloc() to allocate the bio; else the allocation is
383 * backed by the @bs's mempool.
385 * When @bs is not NULL, if %__GFP_WAIT is set then bio_alloc will always be
410 struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs) bio_alloc_bioset() argument
420 if (!bs) { bio_alloc_bioset()
431 if (WARN_ON_ONCE(!bs->bvec_pool && nr_iovecs > 0)) bio_alloc_bioset()
457 p = mempool_alloc(bs->bio_pool, gfp_mask); bio_alloc_bioset()
459 punt_bios_to_rescuer(bs); bio_alloc_bioset()
461 p = mempool_alloc(bs->bio_pool, gfp_mask); bio_alloc_bioset()
464 front_pad = bs->front_pad; bio_alloc_bioset()
475 bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool); bio_alloc_bioset()
477 punt_bios_to_rescuer(bs); bio_alloc_bioset()
479 bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool); bio_alloc_bioset()
490 bio->bi_pool = bs; bio_alloc_bioset()
497 mempool_free(p, bs->bio_pool); bio_alloc_bioset()
577 * @bs: bio_set to allocate from
581 struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs) bio_clone_fast() argument
585 b = bio_alloc_bioset(gfp_mask, 0, bs); bio_clone_fast()
610 * @bs: bio_set to allocate from
616 struct bio_set *bs) bio_clone_bioset()
644 bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs); bio_clone_bioset()
1815 * @bs: bio set to allocate from
1825 gfp_t gfp, struct bio_set *bs) bio_split()
1837 split = bio_clone_bioset(bio, gfp, bs); bio_split()
1839 split = bio_clone_fast(bio, gfp, bs); bio_split()
1890 void bioset_free(struct bio_set *bs) bioset_free() argument
1892 if (bs->rescue_workqueue) bioset_free()
1893 destroy_workqueue(bs->rescue_workqueue); bioset_free()
1895 if (bs->bio_pool) bioset_free()
1896 mempool_destroy(bs->bio_pool); bioset_free()
1898 if (bs->bvec_pool) bioset_free()
1899 mempool_destroy(bs->bvec_pool); bioset_free()
1901 bioset_integrity_free(bs); bioset_free()
1902 bio_put_slab(bs); bioset_free()
1904 kfree(bs); bioset_free()
1913 struct bio_set *bs; __bioset_create() local
1915 bs = kzalloc(sizeof(*bs), GFP_KERNEL); __bioset_create()
1916 if (!bs) __bioset_create()
1919 bs->front_pad = front_pad; __bioset_create()
1921 spin_lock_init(&bs->rescue_lock); __bioset_create()
1922 bio_list_init(&bs->rescue_list); __bioset_create()
1923 INIT_WORK(&bs->rescue_work, bio_alloc_rescue); __bioset_create()
1925 bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad); __bioset_create()
1926 if (!bs->bio_slab) { __bioset_create()
1927 kfree(bs); __bioset_create()
1931 bs->bio_pool = mempool_create_slab_pool(pool_size, bs->bio_slab); __bioset_create()
1932 if (!bs->bio_pool) __bioset_create()
1936 bs->bvec_pool = biovec_create_pool(pool_size); __bioset_create()
1937 if (!bs->bvec_pool) __bioset_create()
1941 bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0); __bioset_create()
1942 if (!bs->rescue_workqueue) __bioset_create()
1945 return bs; __bioset_create()
1947 bioset_free(bs); __bioset_create()
615 bio_clone_bioset(struct bio *bio_src, gfp_t gfp_mask, struct bio_set *bs) bio_clone_bioset() argument
1824 bio_split(struct bio *bio, int sectors, gfp_t gfp, struct bio_set *bs) bio_split() argument
|
| H A D | blk-mq-tag.h | 28 struct bt_wait_state *bs; member in struct:blk_mq_bitmap_tags
|
| H A D | blk-core.c | 2946 * @bs: bio_set that bios for clone are allocated from
2962 struct bio_set *bs, gfp_t gfp_mask, blk_rq_prep_clone()
2968 if (!bs) blk_rq_prep_clone()
2969 bs = fs_bio_set; blk_rq_prep_clone()
2972 bio = bio_clone_fast(bio_src, gfp_mask, bs); __rq_for_each_bio()
2961 blk_rq_prep_clone(struct request *rq, struct request *rq_src, struct bio_set *bs, gfp_t gfp_mask, int (*bio_ctr)(struct bio *, struct bio *, void *), void *data) blk_rq_prep_clone() argument
|
| /linux-4.1.27/arch/cris/boot/rescue/ |
| H A D | Makefile | 34 dd if=/dev/zero of=tmp2423 bs=1 count=784
36 dd if=testrescue_tmp.bin of=$(obj)/testrescue.bin bs=1 count=784
43 dd if=/dev/zero of=tmp2423 bs=1 count=784
45 dd if=kimagerescue_tmp.bin of=$(obj)/kimagerescue.bin bs=1 count=784
|
| /linux-4.1.27/fs/ext3/ |
| H A D | xattr.c | 632 struct ext3_xattr_block_find *bs) ext3_xattr_block_find()
642 bs->bh = sb_bread(sb, EXT3_I(inode)->i_file_acl); ext3_xattr_block_find()
644 if (!bs->bh) ext3_xattr_block_find()
646 ea_bdebug(bs->bh, "b_count=%d, refcount=%d", ext3_xattr_block_find()
647 atomic_read(&(bs->bh->b_count)), ext3_xattr_block_find()
648 le32_to_cpu(BHDR(bs->bh)->h_refcount)); ext3_xattr_block_find()
649 if (ext3_xattr_check_block(bs->bh)) { ext3_xattr_block_find()
657 bs->s.base = BHDR(bs->bh); ext3_xattr_block_find()
658 bs->s.first = BFIRST(bs->bh); ext3_xattr_block_find()
659 bs->s.end = bs->bh->b_data + bs->bh->b_size; ext3_xattr_block_find()
660 bs->s.here = bs->s.first; ext3_xattr_block_find()
661 error = ext3_xattr_find_entry(&bs->s.here, i->name_index, ext3_xattr_block_find()
662 i->name, bs->bh->b_size, 1); ext3_xattr_block_find()
665 bs->s.not_found = error; ext3_xattr_block_find()
676 struct ext3_xattr_block_find *bs) ext3_xattr_block_set()
680 struct ext3_xattr_search *s = &bs->s; ext3_xattr_block_set()
689 ce = mb_cache_entry_get(ext3_xattr_cache, bs->bh->b_bdev, ext3_xattr_block_set()
690 bs->bh->b_blocknr); ext3_xattr_block_set()
691 error = ext3_journal_get_write_access(handle, bs->bh); ext3_xattr_block_set()
694 lock_buffer(bs->bh); ext3_xattr_block_set()
701 ea_bdebug(bs->bh, "modifying in-place"); ext3_xattr_block_set()
707 ext3_xattr_cache_insert(bs->bh); ext3_xattr_block_set()
709 unlock_buffer(bs->bh); ext3_xattr_block_set()
714 bs->bh); ext3_xattr_block_set()
719 int offset = (char *)s->here - bs->bh->b_data; ext3_xattr_block_set()
721 unlock_buffer(bs->bh); ext3_xattr_block_set()
722 journal_release_buffer(handle, bs->bh); ext3_xattr_block_set()
728 ea_bdebug(bs->bh, "cloning"); ext3_xattr_block_set()
729 s->base = kmalloc(bs->bh->b_size, GFP_NOFS); ext3_xattr_block_set()
733 memcpy(s->base, BHDR(bs->bh), bs->bh->b_size); ext3_xattr_block_set()
737 s->end = s->base + bs->bh->b_size; ext3_xattr_block_set()
767 if (new_bh == bs->bh) ext3_xattr_block_set()
791 } else if (bs->bh && s->base == bs->bh->b_data) { ext3_xattr_block_set()
793 ea_bdebug(bs->bh, "keeping this block"); ext3_xattr_block_set()
794 new_bh = bs->bh; ext3_xattr_block_set()
841 if (bs->bh && bs->bh != new_bh) ext3_xattr_block_set()
842 ext3_xattr_release_block(handle, inode, bs->bh); ext3_xattr_block_set()
849 if (!(bs->bh && s->base == bs->bh->b_data)) ext3_xattr_block_set()
954 struct ext3_xattr_block_find bs = { ext3_xattr_set_handle() local
982 error = ext3_xattr_block_find(inode, &i, &bs); ext3_xattr_set_handle()
985 if (is.s.not_found && bs.s.not_found) { ext3_xattr_set_handle()
1000 else if (!bs.s.not_found) ext3_xattr_set_handle()
1001 error = ext3_xattr_block_set(handle, inode, &i, &bs); ext3_xattr_set_handle()
1004 if (!error && !bs.s.not_found) { ext3_xattr_set_handle()
1006 error = ext3_xattr_block_set(handle, inode, &i, &bs); ext3_xattr_set_handle()
1008 if (EXT3_I(inode)->i_file_acl && !bs.s.base) { ext3_xattr_set_handle()
1009 error = ext3_xattr_block_find(inode, &i, &bs); ext3_xattr_set_handle()
1013 error = ext3_xattr_block_set(handle, inode, &i, &bs); ext3_xattr_set_handle()
1038 brelse(bs.bh); ext3_xattr_set_handle()
631 ext3_xattr_block_find(struct inode *inode, struct ext3_xattr_info *i, struct ext3_xattr_block_find *bs) ext3_xattr_block_find() argument
674 ext3_xattr_block_set(handle_t *handle, struct inode *inode, struct ext3_xattr_info *i, struct ext3_xattr_block_find *bs) ext3_xattr_block_set() argument
|
| H A D | super.c | 1423 ext3_msg(sb, KERN_INFO, "[bs=%lu, gc=%lu, " ext3_setup_super()
|
| /linux-4.1.27/drivers/misc/sgi-gru/ |
| H A D | grukservices.c | 152 static void gru_load_kernel_context(struct gru_blade_state *bs, int blade_id) gru_load_kernel_context() argument
159 up_read(&bs->bs_kgts_sema); gru_load_kernel_context()
160 down_write(&bs->bs_kgts_sema); gru_load_kernel_context()
162 if (!bs->bs_kgts) { gru_load_kernel_context()
163 bs->bs_kgts = gru_alloc_gts(NULL, 0, 0, 0, 0, 0); gru_load_kernel_context()
164 bs->bs_kgts->ts_user_blade_id = blade_id; gru_load_kernel_context()
166 kgts = bs->bs_kgts; gru_load_kernel_context()
172 GRU_NUM_KERNEL_CBR * ncpus + bs->bs_async_cbrs); gru_load_kernel_context()
175 bs->bs_async_dsr_bytes); gru_load_kernel_context()
181 gru = bs->bs_kgts->ts_gru; gru_load_kernel_context()
184 bs->kernel_cb = get_gseg_base_address_cb(vaddr, ctxnum, 0); gru_load_kernel_context()
185 bs->kernel_dsr = get_gseg_base_address_ds(vaddr, ctxnum, 0); gru_load_kernel_context()
187 downgrade_write(&bs->bs_kgts_sema); gru_load_kernel_context()
196 struct gru_blade_state *bs; gru_free_kernel_contexts() local
201 bs = gru_base[bid]; gru_free_kernel_contexts()
202 if (!bs) gru_free_kernel_contexts()
206 if (down_write_trylock(&bs->bs_kgts_sema)) { gru_free_kernel_contexts()
207 kgts = bs->bs_kgts; gru_free_kernel_contexts()
210 bs->bs_kgts = NULL; gru_free_kernel_contexts()
211 up_write(&bs->bs_kgts_sema); gru_free_kernel_contexts()
225 struct gru_blade_state *bs; gru_lock_kernel_context() local
231 bs = gru_base[bid]; gru_lock_kernel_context()
234 down_read(&bs->bs_kgts_sema); gru_lock_kernel_context()
236 up_read(&bs->bs_kgts_sema); gru_lock_kernel_context()
239 if (!bs->bs_kgts || !bs->bs_kgts->ts_gru) gru_lock_kernel_context()
240 gru_load_kernel_context(bs, bid); gru_lock_kernel_context()
241 return bs; gru_lock_kernel_context()
251 struct gru_blade_state *bs; gru_unlock_kernel_context() local
253 bs = gru_base[blade_id]; gru_unlock_kernel_context()
254 up_read(&bs->bs_kgts_sema); gru_unlock_kernel_context()
264 struct gru_blade_state *bs; gru_get_cpu_resources() local
269 bs = gru_lock_kernel_context(-1); gru_get_cpu_resources()
271 *cb = bs->kernel_cb + lcpu * GRU_HANDLE_STRIDE; gru_get_cpu_resources()
272 *dsr = bs->kernel_dsr + lcpu * GRU_NUM_KERNEL_DSR_BYTES; gru_get_cpu_resources()
300 struct gru_blade_state *bs; gru_reserve_async_resources() local
304 bs = gru_base[blade_id]; gru_reserve_async_resources()
306 down_write(&bs->bs_kgts_sema); gru_reserve_async_resources()
309 if (bs->bs_async_dsr_bytes + bs->bs_async_cbrs) gru_reserve_async_resources()
311 bs->bs_async_dsr_bytes = dsr_bytes; gru_reserve_async_resources()
312 bs->bs_async_cbrs = cbrs; gru_reserve_async_resources()
313 bs->bs_async_wq = cmp; gru_reserve_async_resources()
314 kgts = bs->bs_kgts; gru_reserve_async_resources()
322 up_write(&bs->bs_kgts_sema); gru_reserve_async_resources()
334 struct gru_blade_state *bs = ASYNC_HAN_TO_BS(han); gru_release_async_resources() local
336 down_write(&bs->bs_kgts_sema); gru_release_async_resources()
337 bs->bs_async_dsr_bytes = 0; gru_release_async_resources()
338 bs->bs_async_cbrs = 0; gru_release_async_resources()
339 bs->bs_async_wq = NULL; gru_release_async_resources()
340 up_write(&bs->bs_kgts_sema); gru_release_async_resources()
351 struct gru_blade_state *bs = ASYNC_HAN_TO_BS(han); gru_wait_async_cbr() local
353 wait_for_completion(bs->bs_async_wq); gru_wait_async_cbr()
368 struct gru_blade_state *bs = ASYNC_HAN_TO_BS(han); gru_lock_async_resource() local
375 *cb = bs->kernel_cb + ncpus * GRU_HANDLE_STRIDE; gru_lock_async_resource()
377 *dsr = bs->kernel_dsr + ncpus * GRU_NUM_KERNEL_DSR_BYTES; gru_lock_async_resource()
|
| H A D | grumain.c | 763 struct gru_blade_state *bs) is_gts_stealable()
766 return down_write_trylock(&bs->bs_kgts_sema); is_gts_stealable()
772 struct gru_blade_state *bs) gts_stolen()
775 up_write(&bs->bs_kgts_sema); gts_stolen()
762 is_gts_stealable(struct gru_thread_state *gts, struct gru_blade_state *bs) is_gts_stealable() argument
771 gts_stolen(struct gru_thread_state *gts, struct gru_blade_state *bs) gts_stolen() argument
|
| /linux-4.1.27/fs/ext4/ |
| H A D | xattr.c | 734 struct ext4_xattr_block_find *bs) ext4_xattr_block_find()
744 bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl); ext4_xattr_block_find()
746 if (!bs->bh) ext4_xattr_block_find()
748 ea_bdebug(bs->bh, "b_count=%d, refcount=%d", ext4_xattr_block_find()
749 atomic_read(&(bs->bh->b_count)), ext4_xattr_block_find()
750 le32_to_cpu(BHDR(bs->bh)->h_refcount)); ext4_xattr_block_find()
751 if (ext4_xattr_check_block(inode, bs->bh)) { ext4_xattr_block_find()
758 bs->s.base = BHDR(bs->bh); ext4_xattr_block_find()
759 bs->s.first = BFIRST(bs->bh); ext4_xattr_block_find()
760 bs->s.end = bs->bh->b_data + bs->bh->b_size; ext4_xattr_block_find()
761 bs->s.here = bs->s.first; ext4_xattr_block_find()
762 error = ext4_xattr_find_entry(&bs->s.here, i->name_index, ext4_xattr_block_find()
763 i->name, bs->bh->b_size, 1); ext4_xattr_block_find()
766 bs->s.not_found = error; ext4_xattr_block_find()
777 struct ext4_xattr_block_find *bs) ext4_xattr_block_set()
781 struct ext4_xattr_search *s = &bs->s; ext4_xattr_block_set()
791 ce = mb_cache_entry_get(ext4_mb_cache, bs->bh->b_bdev, ext4_xattr_block_set()
792 bs->bh->b_blocknr); ext4_xattr_block_set()
793 BUFFER_TRACE(bs->bh, "get_write_access"); ext4_xattr_block_set()
794 error = ext4_journal_get_write_access(handle, bs->bh); ext4_xattr_block_set()
797 lock_buffer(bs->bh); ext4_xattr_block_set()
804 ea_bdebug(bs->bh, "modifying in-place"); ext4_xattr_block_set()
811 bs->bh); ext4_xattr_block_set()
813 unlock_buffer(bs->bh); ext4_xattr_block_set()
819 bs->bh); ext4_xattr_block_set()
824 int offset = (char *)s->here - bs->bh->b_data; ext4_xattr_block_set()
826 unlock_buffer(bs->bh); ext4_xattr_block_set()
831 ea_bdebug(bs->bh, "cloning"); ext4_xattr_block_set()
832 s->base = kmalloc(bs->bh->b_size, GFP_NOFS); ext4_xattr_block_set()
836 memcpy(s->base, BHDR(bs->bh), bs->bh->b_size); ext4_xattr_block_set()
840 s->end = s->base + bs->bh->b_size; ext4_xattr_block_set()
870 if (new_bh == bs->bh) ext4_xattr_block_set()
897 } else if (bs->bh && s->base == bs->bh->b_data) { ext4_xattr_block_set()
899 ea_bdebug(bs->bh, "keeping this block"); ext4_xattr_block_set()
900 new_bh = bs->bh; ext4_xattr_block_set()
954 if (bs->bh && bs->bh != new_bh) ext4_xattr_block_set()
955 ext4_xattr_release_block(handle, inode, bs->bh); ext4_xattr_block_set()
962 if (!(bs->bh && s->base == bs->bh->b_data)) ext4_xattr_block_set()
1098 struct ext4_xattr_block_find bs = { ext4_xattr_set_handle() local
1126 error = ext4_xattr_block_find(inode, &i, &bs); ext4_xattr_set_handle()
1129 if (is.s.not_found && bs.s.not_found) { ext4_xattr_set_handle()
1144 else if (!bs.s.not_found) ext4_xattr_set_handle()
1145 error = ext4_xattr_block_set(handle, inode, &i, &bs); ext4_xattr_set_handle()
1148 if (!error && !bs.s.not_found) { ext4_xattr_set_handle()
1150 error = ext4_xattr_block_set(handle, inode, &i, &bs); ext4_xattr_set_handle()
1152 if (EXT4_I(inode)->i_file_acl && !bs.s.base) { ext4_xattr_set_handle()
1153 error = ext4_xattr_block_find(inode, &i, &bs); ext4_xattr_set_handle()
1157 error = ext4_xattr_block_set(handle, inode, &i, &bs); ext4_xattr_set_handle()
1184 brelse(bs.bh); ext4_xattr_set_handle()
1263 struct ext4_xattr_block_find *bs = NULL; ext4_expand_extra_isize_ea() local
1351 bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS); ext4_expand_extra_isize_ea()
1352 if (!is || !bs) { ext4_expand_extra_isize_ea()
1358 bs->s.not_found = -ENODATA; ext4_expand_extra_isize_ea()
1360 bs->bh = NULL; ext4_expand_extra_isize_ea()
1388 kfree(bs); bs = NULL; ext4_expand_extra_isize_ea()
1445 error = ext4_xattr_block_find(inode, &i, bs); ext4_expand_extra_isize_ea()
1450 error = ext4_xattr_block_set(handle, inode, &i, bs); ext4_expand_extra_isize_ea()
1459 kfree(bs); ext4_expand_extra_isize_ea()
1471 kfree(bs); ext4_expand_extra_isize_ea()
733 ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i, struct ext4_xattr_block_find *bs) ext4_xattr_block_find() argument
775 ext4_xattr_block_set(handle_t *handle, struct inode *inode, struct ext4_xattr_info *i, struct ext4_xattr_block_find *bs) ext4_xattr_block_set() argument
|
| H A D | super.c | 1939 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, " ext4_setup_super()
|
| /linux-4.1.27/drivers/media/tuners/ |
| H A D | tda827x.c | 97 u8 bs; member in struct:tda827x_data
105 { .lomax = 62000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 1},
106 { .lomax = 66000000, .spd = 3, .bs = 3, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 1},
107 { .lomax = 76000000, .spd = 3, .bs = 1, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 0},
108 { .lomax = 84000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 0},
109 { .lomax = 93000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 1, .div1p5 = 0},
110 { .lomax = 98000000, .spd = 3, .bs = 3, .bp = 0, .cp = 0, .gc3 = 1, .div1p5 = 0},
111 { .lomax = 109000000, .spd = 3, .bs = 3, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
112 { .lomax = 123000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 1},
113 { .lomax = 133000000, .spd = 2, .bs = 3, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 1},
114 { .lomax = 151000000, .spd = 2, .bs = 1, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
115 { .lomax = 154000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
116 { .lomax = 181000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 0, .div1p5 = 0},
117 { .lomax = 185000000, .spd = 2, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
118 { .lomax = 217000000, .spd = 2, .bs = 3, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
119 { .lomax = 244000000, .spd = 1, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 1},
120 { .lomax = 265000000, .spd = 1, .bs = 3, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 1},
121 { .lomax = 302000000, .spd = 1, .bs = 1, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
122 { .lomax = 324000000, .spd = 1, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
123 { .lomax = 370000000, .spd = 1, .bs = 2, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
124 { .lomax = 454000000, .spd = 1, .bs = 3, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
125 { .lomax = 493000000, .spd = 0, .bs = 2, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 1},
126 { .lomax = 530000000, .spd = 0, .bs = 3, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 1},
127 { .lomax = 554000000, .spd = 0, .bs = 1, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
128 { .lomax = 604000000, .spd = 0, .bs = 1, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
129 { .lomax = 696000000, .spd = 0, .bs = 2, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
130 { .lomax = 740000000, .spd = 0, .bs = 2, .bp = 4, .cp = 1, .gc3 = 0, .div1p5 = 0},
131 { .lomax = 820000000, .spd = 0, .bs = 3, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
132 { .lomax = 865000000, .spd = 0, .bs = 3, .bp = 4, .cp = 1, .gc3 = 0, .div1p5 = 0},
133 { .lomax = 0, .spd = 0, .bs = 0, .bp = 0, .cp = 0, .gc3 = 0, .div1p5 = 0}
195 (tda827x_table[i].bs << 3) + tda827xo_set_params()
284 (tda827x_table[i].bs << 3) + tda827x_table[i].bp; tda827xo_set_analog_params()
|
| /linux-4.1.27/drivers/pcmcia/ |
| H A D | sa11xx_base.h | 69 #define MECR_SET(mecr, sock, shift, mask, bs) \
72 (((bs)<<(shift))<<((sock)==0?MECR_SOCKET_0_SHIFT:MECR_SOCKET_1_SHIFT)))
78 #define MECR_BSIO_SET(mecr, sock, bs) \
79 MECR_SET((mecr), (sock), MECR_BSIO_SHIFT, MECR_BS_MASK, (bs))
84 #define MECR_BSA_SET(mecr, sock, bs) \
85 MECR_SET((mecr), (sock), MECR_BSA_SHIFT, MECR_BS_MASK, (bs))
90 #define MECR_BSM_SET(mecr, sock, bs) \
91 MECR_SET((mecr), (sock), MECR_BSM_SHIFT, MECR_BS_MASK, (bs))
|
| /linux-4.1.27/arch/mips/txx9/generic/ |
| H A D | mem_tx4927.c | 43 unsigned int bs = 0; tx4927_process_sdccr() local
58 bs = 2 << sdccr_bs; tx4927_process_sdccr()
64 return rs * cs * mw * bs; tx4927_process_sdccr()
|
| /linux-4.1.27/arch/arm/crypto/ |
| H A D | Makefile | 6 obj-$(CONFIG_CRYPTO_AES_ARM_BS) += aes-arm-bs.o
28 aes-arm-bs-y := aesbs-core.o aesbs-glue.o
|
| H A D | aesbs-glue.c | 24 u8 __aligned(8) bs[BIT_SLICED_KEY_MAXSIZE]; member in struct:BS_KEY
|
| /linux-4.1.27/arch/powerpc/lib/ |
| H A D | rheap.c | 158 unsigned long s, e, bs, be; attach_free_block() local
175 bs = blk->start; attach_free_block()
176 be = bs + blk->size; attach_free_block()
178 if (next == NULL && s >= bs) attach_free_block()
184 if (e == bs) attach_free_block()
374 unsigned long s, e, m, bs, be; rh_detach_region() local
398 bs = blk->start; rh_detach_region()
400 if (s >= bs && e <= be) rh_detach_region()
409 if (bs == s && be == e) { rh_detach_region()
417 if (bs == s || be == e) { rh_detach_region()
418 if (bs == s) rh_detach_region()
424 blk->size = s - bs; rh_detach_region()
531 unsigned long s, e, m, bs = 0, be = 0; rh_alloc_fixed() local
555 bs = blk->start; rh_alloc_fixed()
557 if (s >= bs && e <= be) rh_alloc_fixed()
566 if (bs == s && be == e) { rh_alloc_fixed()
579 if (bs == s || be == e) { rh_alloc_fixed()
580 if (bs == s) rh_alloc_fixed()
586 blk->size = s - bs; rh_alloc_fixed()
|
| /linux-4.1.27/drivers/staging/fbtft/ |
| H A D | fb_pcd8544.c | 43 static unsigned bs = 4; variable
44 module_param(bs, uint, 0);
45 MODULE_PARM_DESC(bs, "BS[2:0] Bias voltage level: 0-7 (default: 4)");
79 write_reg(par, 0x10 | (bs & 0x7)); init_display()
|
| H A D | fb_tls8204.c | 40 static unsigned bs = 4; variable
41 module_param(bs, uint, 0);
42 MODULE_PARM_DESC(bs, "BS[2:0] Bias voltage level: 0-7 (default: 4)");
58 write_reg(par, 0x10 | (bs & 0x7)); /* init_display()
|
| /linux-4.1.27/drivers/crypto/ |
| H A D | omap-sham.c | 460 int bs, nr_dr; omap_sham_write_ctrl_omap4() local
465 bs = get_block_size(ctx); omap_sham_write_ctrl_omap4()
466 nr_dr = bs / (2 * sizeof(u32)); omap_sham_write_ctrl_omap4()
472 ctx->digcnt += bs; omap_sham_write_ctrl_omap4()
715 #define SG_SA(sg, bs) (IS_ALIGNED(sg->length, bs))
722 int ret, bs; omap_sham_update_dma_start() local
743 bs = get_block_size(ctx); omap_sham_update_dma_start()
748 if (!sg_is_last(sg) && !SG_SA(sg, bs)) omap_sham_update_dma_start()
757 tail = length & (bs - 1); omap_sham_update_dma_start()
760 tail = bs; omap_sham_update_dma_start()
835 int bs = 0; omap_sham_init() local
859 bs = SHA1_BLOCK_SIZE; omap_sham_init()
863 bs = SHA1_BLOCK_SIZE; omap_sham_init()
867 bs = SHA224_BLOCK_SIZE; omap_sham_init()
871 bs = SHA256_BLOCK_SIZE; omap_sham_init()
875 bs = SHA384_BLOCK_SIZE; omap_sham_init()
879 bs = SHA512_BLOCK_SIZE; omap_sham_init()
891 memcpy(ctx->buffer, bctx->ipad, bs); omap_sham_init()
892 ctx->bufcnt = bs; omap_sham_init()
951 int bs = crypto_shash_blocksize(bctx->shash); omap_sham_finish_hmac() local
959 crypto_shash_update(shash, bctx->opad, bs) ?: omap_sham_finish_hmac()
1082 int bs = get_block_size(ctx); omap_sham_update() local
1100 } else if ((ctx->bufcnt + ctx->total <= bs) || omap_sham_update()
1188 int bs = crypto_shash_blocksize(bctx->shash); omap_sham_setkey() local
1209 if (keylen > bs) { omap_sham_setkey()
1220 memset(bctx->ipad + keylen, 0, bs - keylen); omap_sham_setkey()
1223 memcpy(bctx->opad, bctx->ipad, bs); omap_sham_setkey()
1225 for (i = 0; i < bs; i++) { omap_sham_setkey()
|
| H A D | mv_cesa.c | 778 int bs, ds, ss; mv_hash_setkey() local
789 bs = crypto_shash_blocksize(ctx->base_hash); mv_hash_setkey()
804 if (keylen > bs) { mv_hash_setkey()
816 memset(ipad + keylen, 0, bs - keylen); mv_hash_setkey()
817 memcpy(opad, ipad, bs); mv_hash_setkey()
819 for (i = 0; i < bs; i++) { mv_hash_setkey()
825 crypto_shash_update(shash, ipad, bs) ? : mv_hash_setkey()
828 crypto_shash_update(shash, opad, bs) ? : mv_hash_setkey()
|
| H A D | n2_core.c | 449 int err, bs, ds; n2_hmac_async_setkey() local
460 bs = crypto_shash_blocksize(child_shash); n2_hmac_async_setkey()
463 if (keylen > bs) { n2_hmac_async_setkey()
|
| /linux-4.1.27/drivers/atm/ |
| H A D | nicstarmac.c | 108 #define NICSTAR_REG_WRITE(bs, reg, val) \
109 while ( readl(bs + STAT) & 0x0200 ) ; \
111 #define NICSTAR_REG_READ(bs, reg) \
|
| /linux-4.1.27/lib/ |
| H A D | ts_bm.c | 67 int shift = bm->patlen - 1, bs; bm_find() local
89 next: bs = bm->bad_shift[text[shift-i]]; bm_find()
92 shift = max_t(int, shift-i+bs, shift+bm->good_shift[i]); bm_find()
|
| /linux-4.1.27/fs/hpfs/ |
| H A D | alloc.c | 118 unsigned bs = near & ~0x3fff; alloc_in_bmp() local
128 if (bs != ~0x3fff) { alloc_in_bmp()
134 ret = bs + nr; alloc_in_bmp()
149 ret = bs + q; alloc_in_bmp()
172 ret = bs + q; alloc_in_bmp()
180 if (hpfs_sb(s)->sb_chk && ((ret >> 14) != (bs >> 14) || (le32_to_cpu(bmp[(ret & 0x3fff) >> 5]) | ~(((1 << n) - 1) << (ret & 0x1f))) != 0xffffffff)) { alloc_in_bmp()
|
| /linux-4.1.27/drivers/block/ |
| H A D | null_blk.c | 114 static int bs = 512; variable
115 module_param(bs, int, S_IRUGO);
116 MODULE_PARM_DESC(bs, "Block size (in bytes)");
575 blk_queue_logical_block_size(nullb->q, bs); null_add_dev()
576 blk_queue_physical_block_size(nullb->q, bs); null_add_dev()
579 sector_div(size, bs); null_add_dev()
609 if (bs > PAGE_SIZE) { null_init()
612 bs = PAGE_SIZE; null_init()
|
| H A D | nvme-core.c | 1997 unsigned short bs; nvme_revalidate_disk() local
2025 bs = 1 << ns->lba_shift; nvme_revalidate_disk()
2033 bs != queue_logical_block_size(disk->queue) || nvme_revalidate_disk()
2038 blk_queue_logical_block_size(ns->queue, bs); nvme_revalidate_disk()
|
| H A D | skd_main.c | 2107 pr_debug("%s:%s:%d last lba %d, bs %d\n", skd_complete_internal()
|
| /linux-4.1.27/drivers/media/pci/bt8xx/ |
| H A D | dvb-bt8xx.c | 158 unsigned char bs = 0; thomson_dtt7579_tuner_calc_regs() local
174 bs = 0x03; thomson_dtt7579_tuner_calc_regs()
176 bs = 0x02; thomson_dtt7579_tuner_calc_regs()
178 bs = 0x08; thomson_dtt7579_tuner_calc_regs()
184 pllbuf[4] = bs; thomson_dtt7579_tuner_calc_regs()
353 unsigned char bs = 0; advbt771_samsung_tdtc9251dh0_tuner_calc_regs() local
380 bs = 0x01; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
382 bs = 0x01; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
384 bs = 0x02; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
386 bs = 0x02; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
388 bs = 0x02; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
390 bs = 0x02; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
392 bs = 0x08; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
394 bs = 0x08; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
396 bs = 0x08; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
402 pllbuf[4] = bs; advbt771_samsung_tdtc9251dh0_tuner_calc_regs()
|
| /linux-4.1.27/arch/s390/include/asm/ |
| H A D | eadm.h | 44 u16 bs:4; member in struct:msb
|
| /linux-4.1.27/arch/sh/boot/romimage/ |
| H A D | mmcif-sh7724.c | 29 * # dd if=arch/sh/boot/romImage of=/dev/sdx bs=512 seek=512
|
| /linux-4.1.27/arch/ia64/sn/kernel/ |
| H A D | io_common.c | 231 struct pcibus_bussoft *bs; sn_pci_fixup_slot() local
252 bs = SN_PCIBUS_BUSSOFT(dev->bus); sn_pci_fixup_slot()
253 pcidev_info->pdi_pcibus_info = bs; sn_pci_fixup_slot()
255 if (bs && bs->bs_asic_type < PCIIO_ASIC_MAX_TYPES) { sn_pci_fixup_slot()
256 SN_PCIDEV_BUSPROVIDER(dev) = sn_pci_provider[bs->bs_asic_type]; sn_pci_fixup_slot()
262 if (bs && sn_irq_info->irq_irq) { sn_pci_fixup_slot()
|
| /linux-4.1.27/drivers/block/paride/ |
| H A D | pt.c | 223 int bs; /* block size */ member in struct:pt_unit
556 tape->bs = 0; pt_identify()
564 tape->bs = xn(buf, 10, 2); pt_identify()
576 printk(", blocksize %d, %d MB\n", tape->bs, tape->capacity / 1024); pt_identify()
784 b = (n - 1 + tape->bs) / tape->bs; pt_read()
785 n = b * tape->bs; /* rounded up to even block */ pt_read()
885 b = (n - 1 + tape->bs) / tape->bs; pt_write()
886 n = b * tape->bs; /* rounded up to even block */ pt_write()
|
| H A D | pf.c | 607 int bs; pf_get_capacity() local
614 bs = xl(buf, 4); pf_get_capacity()
615 if (bs != 512) { pf_get_capacity()
620 pf->name, pf->drive, pf->lun, bs); pf_get_capacity()
|
| /linux-4.1.27/drivers/staging/dgap/ |
| H A D | dgap.c | 1521 struct bs_t __iomem *bs; dgap_input() local
1542 bs = ch->ch_bs; dgap_input()
1543 if (!bs) dgap_input()
1560 head = readw(&(bs->rx_head)); dgap_input()
1562 tail = readw(&(bs->rx_tail)); dgap_input()
1568 writeb(1, &(bs->idata)); dgap_input()
1584 writew(head, &(bs->rx_tail)); dgap_input()
1585 writeb(1, &(bs->idata)); dgap_input()
1595 writeb(1, &(bs->idata)); dgap_input()
1604 tmpchar = readb(&(bs->orun)); dgap_input()
1607 writeb(0, &(bs->orun)); dgap_input()
1642 writew(head, &(bs->rx_tail)); dgap_input()
1648 writeb(1, &(bs->idata)); dgap_input()
1682 writew(tail, &(bs->rx_tail)); dgap_input()
1683 writeb(1, &(bs->idata)); dgap_input()
1871 struct bs_t __iomem *bs; dgap_event() local
1947 bs = ch->ch_bs; dgap_event()
1949 if (!bs) { dgap_event()
1975 writeb(1, &(bs->idata)); dgap_event()
2669 struct bs_t __iomem *bs; dgap_wmove() local
2678 bs = ch->ch_bs; dgap_wmove()
2679 head = readw(&(bs->tx_head)); dgap_wmove()
2711 writew(head, &(bs->tx_head)); dgap_wmove()
3288 struct bs_t __iomem *bs; dgap_tty_chars_in_buffer() local
3310 bs = ch->ch_bs; dgap_tty_chars_in_buffer()
3311 if (!bs) dgap_tty_chars_in_buffer()
3320 thead = readw(&(bs->tx_head)) & tmask; dgap_tty_chars_in_buffer()
3321 ttail = readw(&(bs->tx_tail)) & tmask; dgap_tty_chars_in_buffer()
3324 tbusy = readb(&(bs->tbusy)); dgap_tty_chars_in_buffer()
3364 writeb(1, &(bs->iempty)); dgap_tty_chars_in_buffer()
3379 struct bs_t __iomem *bs; dgap_wait_for_drain() local
3395 bs = ch->ch_bs; dgap_wait_for_drain()
3396 if (!bs) dgap_wait_for_drain()
3410 writeb(1, &(bs->iempty)); dgap_wait_for_drain()
3475 struct bs_t __iomem *bs; dgap_set_firmware_event() local
3482 bs = ch->ch_bs; dgap_set_firmware_event()
3483 if (!bs) dgap_set_firmware_event()
3489 writeb(1, &(bs->ilow)); dgap_set_firmware_event()
3495 writeb(1, &(bs->iempty)); dgap_set_firmware_event()
3509 struct bs_t __iomem *bs; dgap_tty_write_room() local
3525 bs = ch->ch_bs; dgap_tty_write_room()
3526 if (!bs) dgap_tty_write_room()
3532 head = readw(&(bs->tx_head)) & tmask; dgap_tty_write_room()
3533 tail = readw(&(bs->tx_tail)) & tmask; dgap_tty_write_room()
3582 struct bs_t __iomem *bs; dgap_tty_write() local
3599 bs = ch->ch_bs; dgap_tty_write()
3600 if (!bs) dgap_tty_write()
3610 head = readw(&(bs->tx_head)) & tmask; dgap_tty_write()
3611 tail = readw(&(bs->tx_tail)) & tmask; dgap_tty_write()
3645 head = readw(&(bs->tx_head)) & tmask; dgap_tty_write()
3656 head = readw(&(bs->tx_head)) & tmask; dgap_tty_write()
3695 writew(head, &(bs->tx_head)); dgap_tty_write()
3708 tail = readw(&(bs->tx_tail)) & tmask; dgap_tty_write()
3712 writeb(1, &(bs->iempty)); dgap_tty_write()
3716 head = readw(&(bs->tx_head)) & tmask; dgap_tty_write()
4438 struct bs_t __iomem *bs; dgap_tty_open() local
4505 bs = ch->ch_bs; dgap_tty_open()
4506 if (!bs) { dgap_tty_open()
4533 head = readw(&(bs->rx_head)); dgap_tty_open()
4534 writew(head, &(bs->rx_tail)); dgap_tty_open()
6757 struct bs_t __iomem *bs; dgap_tty_init() local
6815 bs = (struct bs_t __iomem *) ((ulong) vaddr + CHANBUF); dgap_tty_init()
6818 brd->bd_bs = bs; dgap_tty_init()
6821 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i], bs++) { dgap_tty_init()
6838 ch->ch_bs = bs; dgap_tty_init()
|
| /linux-4.1.27/drivers/net/fddi/skfp/h/ |
| H A D | smtstate.h | 93 unsigned char pcm_bsf ; /* flag bs : TRUE/FALSE */
|
| /linux-4.1.27/arch/powerpc/include/asm/ |
| H A D | bitops.h | 52 #define PPC_BITMASK(bs, be) ((PPC_BIT(bs) - PPC_BIT(be)) | PPC_BIT(bs))
|
| /linux-4.1.27/include/linux/ |
| H A D | bio.h | 359 gfp_t gfp, struct bio_set *bs);
366 * @bs: bio set to allocate from
372 gfp_t gfp, struct bio_set *bs) bio_next_split()
377 return bio_split(bio, sectors, gfp, bs); bio_next_split()
390 extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);
724 static inline int bioset_integrity_create(struct bio_set *bs, int pool_size) bioset_integrity_create() argument
729 static inline void bioset_integrity_free (struct bio_set *bs) bioset_integrity_free() argument
371 bio_next_split(struct bio *bio, int sectors, gfp_t gfp, struct bio_set *bs) bio_next_split() argument
|
| H A D | blkdev.h | 808 struct bio_set *bs, gfp_t gfp_mask,
|
| /linux-4.1.27/drivers/mmc/card/ |
| H A D | mmc_test.c | 162 unsigned int *bs; member in struct:mmc_test_multiple_rw
2161 ret = mmc_test_rw_multiple(test, rw, rw->bs[i], rw->size, 0); mmc_test_rw_multiple_size()
2188 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, mmc_test_profile_mult_write_blocking_perf() local
2191 .bs = bs, mmc_test_profile_mult_write_blocking_perf()
2193 .len = ARRAY_SIZE(bs), mmc_test_profile_mult_write_blocking_perf()
2207 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, mmc_test_profile_mult_write_nonblock_perf() local
2210 .bs = bs, mmc_test_profile_mult_write_nonblock_perf()
2212 .len = ARRAY_SIZE(bs), mmc_test_profile_mult_write_nonblock_perf()
2226 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, mmc_test_profile_mult_read_blocking_perf() local
2229 .bs = bs, mmc_test_profile_mult_read_blocking_perf()
2231 .len = ARRAY_SIZE(bs), mmc_test_profile_mult_read_blocking_perf()
2245 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, mmc_test_profile_mult_read_nonblock_perf() local
2248 .bs = bs, mmc_test_profile_mult_read_nonblock_perf()
2250 .len = ARRAY_SIZE(bs), mmc_test_profile_mult_read_nonblock_perf()
|
| /linux-4.1.27/drivers/md/ |
| H A D | dm-log.c | 258 static inline int log_test_bit(uint32_t *bs, unsigned bit) log_test_bit() argument
260 return test_bit_le(bit, bs) ? 1 : 0; log_test_bit()
264 uint32_t *bs, unsigned bit) log_set_bit()
266 __set_bit_le(bit, bs); log_set_bit()
271 uint32_t *bs, unsigned bit) log_clear_bit()
273 __clear_bit_le(bit, bs); log_clear_bit()
263 log_set_bit(struct log_c *l, uint32_t *bs, unsigned bit) log_set_bit() argument
270 log_clear_bit(struct log_c *l, uint32_t *bs, unsigned bit) log_clear_bit() argument
|
| H A D | dm.c | 189 struct bio_set *bs; member in struct:mapped_device
251 struct bio_set *bs; member in struct:dm_md_mempools
1508 clone = bio_alloc_bioset(GFP_NOIO, 0, ci->md->bs); alloc_tio()
1839 r = blk_rq_prep_clone(clone, rq, tio->md->bs, gfp_mask, setup_clone()
2380 if (md->bs) free_dev()
2381 bioset_free(md->bs); free_dev()
2408 if (md->bs) { __bind_mempools()
2415 bioset_free(md->bs); __bind_mempools()
2416 md->bs = p->bs; __bind_mempools()
2417 p->bs = NULL; __bind_mempools()
2430 BUG_ON(!p || md->io_pool || md->rq_pool || md->bs); __bind_mempools()
2436 md->bs = p->bs; __bind_mempools()
2437 p->bs = NULL; __bind_mempools()
3578 pools->bs = bioset_create_nobvec(pool_size, front_pad); dm_alloc_md_mempools()
3579 if (!pools->bs) dm_alloc_md_mempools()
3582 if (integrity && bioset_integrity_create(pools->bs, pool_size)) dm_alloc_md_mempools()
3604 if (pools->bs) dm_free_md_mempools()
3605 bioset_free(pools->bs); dm_free_md_mempools()
|
| H A D | dm-crypt.c | 130 struct bio_set *bs; member in struct:crypt_config
421 unsigned bs = crypto_ablkcipher_blocksize(any_tfm(cc)); crypt_iv_benbi_ctr() local
422 int log = ilog2(bs); crypt_iv_benbi_ctr()
427 if (1 << log != bs) { crypt_iv_benbi_ctr()
987 clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs); crypt_alloc_buffer()
1136 clone = bio_clone_fast(io->base_bio, gfp, cc->bs); kcryptd_io_read()
1526 if (cc->bs) crypt_dtr()
1527 bioset_free(cc->bs); crypt_dtr()
1782 cc->bs = bioset_create(MIN_IOS, 0); crypt_ctr()
1783 if (!cc->bs) { crypt_ctr()
|
| H A D | md.c | 480 struct bio_set *bs = NULL; mddev_put() local
489 bs = mddev->bio_set; mddev_put()
503 if (bs) mddev_put()
504 bioset_free(bs); mddev_put()
|
| /linux-4.1.27/arch/x86/boot/ |
| H A D | Makefile | 138 dd if=/dev/zero of=$(obj)/fdimage bs=1024 count=1440
149 dd if=/dev/zero of=$(obj)/fdimage bs=1024 count=2880
|
| /linux-4.1.27/drivers/uwb/ |
| H A D | beacon.c | 473 struct uwb_rc_evt_beacon_size *bs; uwbd_evt_handle_rc_beacon_size() local
476 if (evt->notif.size < sizeof(*bs)) { uwbd_evt_handle_rc_beacon_size()
479 evt->notif.size, sizeof(*bs)); uwbd_evt_handle_rc_beacon_size()
482 bs = container_of(evt->notif.rceb, struct uwb_rc_evt_beacon_size, rceb); uwbd_evt_handle_rc_beacon_size()
485 "(FIXME: action?)\n", le16_to_cpu(bs->wNewBeaconSize)); uwbd_evt_handle_rc_beacon_size()
|
| /linux-4.1.27/drivers/media/pci/zoran/ |
| H A D | zoran_driver.c | 545 zr->v4l_buffers.buffer[num].bs.length = zoran_v4l_queue_frame()
765 static int jpg_sync(struct zoran_fh *fh, struct zoran_sync *bs) jpg_sync() argument
820 *bs = zr->jpg_buffers.buffer[frame].bs; jpg_sync()
821 bs->frame = frame; jpg_sync()
853 fh->buffers.buffer[i].bs.frame = i; zoran_open_init_session()
1365 buf->bytesused = fh->buffers.buffer[num].bs.length; zoran_v4l2_buffer_status()
1368 buf->sequence = fh->buffers.buffer[num].bs.seq; zoran_v4l2_buffer_status()
1370 buf->timestamp = fh->buffers.buffer[num].bs.timestamp; zoran_v4l2_buffer_status()
1403 buf->sequence = fh->buffers.buffer[num].bs.seq; zoran_v4l2_buffer_status()
1404 buf->timestamp = fh->buffers.buffer[num].bs.timestamp; zoran_v4l2_buffer_status()
1405 buf->bytesused = fh->buffers.buffer[num].bs.length; zoran_v4l2_buffer_status()
2185 struct zoran_sync bs; zoran_dqbuf() local
2207 bs.frame = 0; /* suppress compiler warning */ zoran_dqbuf()
2208 res = jpg_sync(fh, &bs); zoran_dqbuf()
2211 res = zoran_v4l2_buffer_status(fh, buf, bs.frame); zoran_dqbuf()
|
| H A D | zoran_device.c | 1172 v4l2_get_timestamp(&buffer->bs.timestamp); zoran_reap_stat_com()
1175 buffer->bs.length = (stat_com & 0x7fffff) >> 1; zoran_reap_stat_com()
1183 buffer->bs.length = 0; zoran_reap_stat_com()
1185 buffer->bs.seq = zoran_reap_stat_com()
1409 zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.seq = zr->v4l_grab_seq; zoran_irq()
1410 v4l2_get_timestamp(&zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.timestamp); zoran_irq()
|
| H A D | zoran.h | 185 struct zoran_sync bs; /* DONE: info to return to application */ member in struct:zoran_buffer
|
| /linux-4.1.27/drivers/s390/block/ |
| H A D | scm_blk_cluster.c | 147 msb->bs = MSB_BS_4K; scm_prepare_cluster_request()
|
| H A D | scm_blk.c | 196 msb->bs = MSB_BS_4K; scm_request_prepare()
|
| /linux-4.1.27/drivers/target/ |
| H A D | target_core_iblock.c | 162 struct bio_set *bs = ib_dev->ibd_bio_set; iblock_configure_device() local
179 if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) { iblock_configure_device()
184 pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n", iblock_configure_device()
185 bs->bio_integrity_pool); iblock_configure_device()
|
| /linux-4.1.27/drivers/pnp/pnpbios/ |
| H A D | pnpbios.h | 8 * Original BIOS code (C) 1998 Christian Schmidt (chr.schmidt@tu-bs.de)
|
| /linux-4.1.27/net/atm/ |
| H A D | br2684.c | 806 #define bs(var) b1(var, 0), b1(var, 1), b1(var, 2), b1(var, 3) br2684_seq_show() macro
809 "%d.%d.%d.%d\n", bs(prefix), bs(netmask)); br2684_seq_show()
810 #undef bs br2684_seq_show() macro
|
| /linux-4.1.27/fs/udf/ |
| H A D | inode.c | 1289 int bs = inode->i_sb->s_blocksize; udf_read_inode() local
1376 ret = udf_alloc_i_data(inode, bs - udf_read_inode()
1382 bs - sizeof(struct extendedFileEntry)); udf_read_inode()
1386 ret = udf_alloc_i_data(inode, bs - sizeof(struct fileEntry)); udf_read_inode()
1391 bs - sizeof(struct fileEntry)); udf_read_inode()
1398 ret = udf_alloc_i_data(inode, bs - udf_read_inode()
1404 bs - sizeof(struct unallocSpaceEntry)); udf_read_inode()
1492 if (iinfo->i_lenEAttr > bs || iinfo->i_lenAlloc > bs) udf_read_inode()
1495 if (udf_file_entry_alloc_offset(inode) + iinfo->i_lenAlloc > bs) udf_read_inode()
1506 if (inode->i_size > bs - udf_file_entry_alloc_offset(inode)) udf_read_inode()
|
| H A D | super.c | 343 seq_printf(seq, ",bs=%lu", sb->s_blocksize); udf_show_options()
402 * bs= Set the block size.
457 {Opt_bs, "bs=%u"},
|
| /linux-4.1.27/drivers/video/console/ |
| H A D | bitblit.c | 213 unsigned int bs = info->var.yres - bh; bit_clear_margins() local
229 region.dy = info->var.yoffset + bs; bit_clear_margins()
|
| H A D | fbcon_ccw.c | 198 unsigned int bs = vc->vc_rows*ch; ccw_clear_margins() local
213 region.dx = info->var.xoffset + bs; ccw_clear_margins()
|
| /linux-4.1.27/arch/powerpc/boot/ |
| H A D | wrapper | 461 count=$overlay_size bs=1
465 count=$overlay_size bs=1
|
| /linux-4.1.27/fs/xfs/libxfs/ |
| H A D | xfs_fs.h | 322 bstat_get_projid(struct xfs_bstat *bs) bstat_get_projid() argument
324 return (__uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo; bstat_get_projid()
|
| /linux-4.1.27/kernel/trace/ |
| H A D | trace_probe.c | 231 unsigned long bs; find_fetch_type() local
238 if (kstrtoul(type, 0, &bs)) find_fetch_type()
241 switch (bs) { find_fetch_type()
|
| /linux-4.1.27/tools/perf/util/ |
| H A D | machine.c | 1470 const struct branch_stack *bs = sample->branch_stack; sample__resolve_bstack() local
1471 struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info)); sample__resolve_bstack()
1476 for (i = 0; i < bs->nr; i++) { sample__resolve_bstack()
1477 ip__resolve_ams(al->thread, &bi[i].to, bs->entries[i].to); sample__resolve_bstack()
1478 ip__resolve_ams(al->thread, &bi[i].from, bs->entries[i].from); sample__resolve_bstack()
1479 bi[i].flags = bs->entries[i].flags; sample__resolve_bstack()
|
| H A D | pmu.c | 866 const char * const *bs = b; cmp_string() local
867 return strcmp(*as, *bs); cmp_string()
|
| H A D | parse-events.c | 1096 const char * const *bs = b; cmp_string() local
1098 return strcmp(*as, *bs); cmp_string()
|
| /linux-4.1.27/fs/affs/ |
| H A D | super.c | 170 {Opt_bs, "bs=%u"},
386 pr_debug("Dev %s, trying root=%u, bs=%d, " affs_fill_super()
|
| /linux-4.1.27/drivers/media/usb/dvb-usb/ |
| H A D | af9005-script.h | 5 dd if=AF05BDA.sys of=initsequence bs=1 skip=88316 count=1110
|
| /linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/engine/gr/ |
| H A D | ctxgm107.c | 920 const u32 bs = attrib * priv->ppc_tpc_nr[gpc][ppc]; gm107_grctx_generate_attrib() local
923 mmio_wr32(info, o + 0xc0, bs); gm107_grctx_generate_attrib()
929 mmio_wr32(info, u, ((bs / 3 /*XXX*/) << 16) | bs); gm107_grctx_generate_attrib()
|
| /linux-4.1.27/fs/nfsd/ |
| H A D | nfs3xdr.c | 1021 u64 bs = s->f_bsize; nfs3svc_encode_fsstatres() local
1026 p = xdr_encode_hyper(p, bs * s->f_blocks); /* total bytes */ nfs3svc_encode_fsstatres()
1027 p = xdr_encode_hyper(p, bs * s->f_bfree); /* free bytes */ nfs3svc_encode_fsstatres()
1028 p = xdr_encode_hyper(p, bs * s->f_bavail); /* user available bytes */ nfs3svc_encode_fsstatres()
|
| /linux-4.1.27/arch/m68k/include/asm/ |
| H A D | dma.h | 19 * Oliver Kamphenkel (O.Kamphenkel@tu-bs.de)
22 * Oliver Kamphenkel (O.Kamphenkel@tu-bs.de)
|
| /linux-4.1.27/net/nfc/ |
| H A D | digital_dep.c | 75 u8 bs; member in struct:digital_atr_req
86 u8 bs; member in struct:digital_atr_res
479 atr_req->bs = 0; digital_in_send_atr_req()
|
| /linux-4.1.27/fs/btrfs/ |
| H A D | ioctl.c | 2886 u64 bs = BTRFS_I(inode)->root->fs_info->sb->s_blocksize; extent_same_check_offsets() local
2891 if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs)) extent_same_check_offsets()
2953 u64 bs = BTRFS_I(src)->root->fs_info->sb->s_blocksize; btrfs_ioctl_file_extent_same() local
2990 if (WARN_ON_ONCE(bs < PAGE_CACHE_SIZE)) { btrfs_ioctl_file_extent_same()
3689 u64 bs = root->fs_info->sb->s_blocksize; btrfs_ioctl_clone() local
3767 len = ALIGN(src->i_size, bs) - off; btrfs_ioctl_clone()
3775 if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) || btrfs_ioctl_clone()
3776 !IS_ALIGNED(destoff, bs)) btrfs_ioctl_clone()
|
| H A D | ctree.h | 389 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
|
| H A D | send.c | 4619 u64 bs = sctx->send_root->fs_info->sb->s_blocksize; send_write_or_clone() local
4644 if (clone_root && IS_ALIGNED(offset + len, bs)) { send_write_or_clone()
|
| /linux-4.1.27/drivers/input/tablet/ |
| H A D | aiptek.c | 440 int retval, macro, x, y, z, left, right, middle, p, dv, tip, bs, pck; aiptek_irq() local
543 bs = (data[5] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0; aiptek_irq()
571 input_report_key(inputdev, BTN_STYLUS, bs); aiptek_irq()
678 bs = (data[1] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0; aiptek_irq()
|
| /linux-4.1.27/drivers/firmware/ |
| H A D | dcdbas.c | 649 MODULE_ALIAS("dmi:*:[bs]vnD[Ee][Ll][Ll]*:*");
|
| /linux-4.1.27/net/ipv4/ |
| H A D | proc.c | 13 * Erik Schoenfelder, <schoenfr@ibr.cs.tu-bs.de>
|
| /linux-4.1.27/drivers/scsi/ |
| H A D | osst.c | 2691 osst_block_size_page_t * bs; osst_configure_onstream()
2732 bs = (osst_block_size_page_t *) ((STp->buffer)->b_data + sizeof(osst_mode_parameter_header_t) + header->bdl); osst_configure_onstream()
2735 printk(OSST_DEB_MSG "%s:D: 32KB play back: %s\n", name, bs->play32 ? "Yes" : "No"); osst_configure_onstream()
2736 printk(OSST_DEB_MSG "%s:D: 32.5KB play back: %s\n", name, bs->play32_5 ? "Yes" : "No"); osst_configure_onstream()
2737 printk(OSST_DEB_MSG "%s:D: 32KB record: %s\n", name, bs->record32 ? "Yes" : "No"); osst_configure_onstream()
2738 printk(OSST_DEB_MSG "%s:D: 32.5KB record: %s\n", name, bs->record32_5 ? "Yes" : "No"); osst_configure_onstream()
2744 bs->one = 1; osst_configure_onstream()
2745 bs->play32 = 0; osst_configure_onstream()
2746 bs->play32_5 = 1; osst_configure_onstream()
2747 bs->record32 = 0; osst_configure_onstream()
2748 bs->record32_5 = 1; osst_configure_onstream()
2689 osst_block_size_page_t * bs; osst_configure_onstream() local
|
| H A D | mesh.c | 251 printk(KERN_DEBUG "mesh log %d: bs=%.2x%.2x ph=%.2x ", dumplog()
276 printk(KERN_DEBUG "mesh log: bs=%.2x%.2x ph=%.2x t%d ", dumpslog()
311 printk(KERN_DEBUG " ct=%4x seq=%2x bs=%4x fc=%2x " mesh_dump_regs()
|
| /linux-4.1.27/drivers/misc/cxl/ |
| H A D | pci.c | 94 #define EXTRACT_PPC_BITS(val, bs, be) ((val & PPC_BITMASK(bs, be)) >> PPC_BITLSHIFT(be))
|
| /linux-4.1.27/drivers/usb/mon/ |
| H A D | mon_text.c | 379 * dd if=/dbg/usbmon/0t bs=10
|
| /linux-4.1.27/drivers/video/fbdev/ |
| H A D | au1200fb.c | 1593 * "bs" for board-switch, or number/index */ au1200fb_setup()
1604 else if (strcmp(this_opt, "bs") == 0) au1200fb_setup()
|
| /linux-4.1.27/drivers/video/fbdev/intelfb/ |
| H A D | intelfbhw.c | 1183 DBG_MSG("H: act %d, ss %d, se %d, tot %d bs %d, be %d\n", intelfbhw_mode_to_hw()
1196 DBG_MSG("V: act %d, ss %d, se %d, tot %d bs %d, be %d\n", intelfbhw_mode_to_hw()
|
| /linux-4.1.27/drivers/tty/ |
| H A D | cyclades.c | 3442 const struct zfile_block *b, *bs; __cyz_load_fw() local
3451 bs = ptr + h->block_offset; __cyz_load_fw()
3454 (void *)(bs + h->n_blocks) > ptr + len) { __cyz_load_fw()
3485 for (b = bs; b < bs + h->n_blocks; b++) __cyz_load_fw()
3497 b = &bs[c->block_list[a]]; __cyz_load_fw()
|
| /linux-4.1.27/drivers/net/ethernet/tile/ |
| H A D | tilegx.c | 362 size_t bs = gxio_mpipe_buffer_size_enum_to_buffer_size(bse); tile_net_provide_buffer() local
367 len = sizeof(struct sk_buff **) + buffer_alignment + bs; tile_net_provide_buffer()
|
| /linux-4.1.27/drivers/char/ |
| H A D | random.c | 182 * dd if=/dev/urandom of=$random_seed count=1 bs=512
193 * dd if=/dev/urandom of=$random_seed count=1 bs=512
|
| /linux-4.1.27/drivers/video/fbdev/riva/ |
| H A D | riva_hw.c | 1053 /* printf("CRT LWM: %f bytes, prog: 0x%x, bs: 256\n", clwm, data ); */ nv10CalcArbitration()
1056 /* printf("VID LWM: %f bytes, prog: 0x%x, bs: %d\n, ", vlwm, data, vbs ); */ nv10CalcArbitration()
|
| /linux-4.1.27/drivers/usb/storage/ |
| H A D | alauda.c | 180 unsigned char blockshift; /* 1<<bs pages per block */
|
| H A D | sddr09.c | 119 char blockshift; /* 1<<bs pages in an erase block */
|
| /linux-4.1.27/sound/pci/ |
| H A D | azt3328.c | 228 dd if=/dev/port skip=`printf %d ${addr}` count=${count} bs=1 \
237 printf "\x""$VALSTRING"|dd of=/dev/port seek=`printf %d ${addr}` bs=1 \
|
| /linux-4.1.27/drivers/video/fbdev/nvidia/ |
| H A D | nv_hw.c | 608 /* printf("CRT LWM: %f bytes, prog: 0x%x, bs: 256\n", nv10CalcArbitration()
|
| /linux-4.1.27/fs/ext2/ |
| H A D | super.c | 649 ext2_msg(sb, KERN_INFO, "%s, %s, bs=%lu, fs=%lu, gc=%lu, " ext2_setup_super()
|
| /linux-4.1.27/scripts/ |
| H A D | get_maintainer.pl | 1529 bs use blame signatures [$email_git_blame_signatures]
|
| /linux-4.1.27/drivers/tty/vt/ |
| H A D | vt.c | 1138 static inline void bs(struct vc_data *vc) bs() function
1746 bs(vc); do_con_trol()
2579 bs(vc); vt_console_print()
|
| /linux-4.1.27/drivers/net/wireless/ |
| H A D | wl3501_cs.c | 19 * rsh 192.168.1.3 "dd if=/dev/zero bs=1k count=1000" > /dev/null
|
| /linux-4.1.27/drivers/scsi/lpfc/ |
| H A D | lpfc_debugfs.c | 2032 "bs:x%x proc:x%llx]\n", lpfc_idiag_queinfo_read()
2293 "bs:x%x proc:x%llx]\n", lpfc_idiag_queinfo_read()
|
| /linux-4.1.27/sound/pci/rme9652/ |
| H A D | hdspm.c | 5627 "set_hwparams: %s %d Hz, %d channels, bs = %d\n", snd_hdspm_hw_params()
|
| /linux-4.1.27/drivers/isdn/hardware/eicon/ |
| H A D | message.c | 3572 if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) { manufacturer_req()
|