tag	line	file	source code
minor	116	arch/i386/boot/tools/build.c	minor_root = minor(sb.st_dev);
minor	123	arch/i386/boot/tools/build.c	minor_root = minor(sb.st_rdev);
minor	67	drivers/block/genhd.c	char *disk_name (struct gendisk *hd, int minor, char *buf)
minor	71	drivers/block/genhd.c	char unit = (minor >> hd->minor_shift) + 'a';
minor	90	drivers/block/genhd.c	part = minor & ((1 << hd->minor_shift) - 1);
minor	98	drivers/block/genhd.c	static void add_partition (struct gendisk *hd, int minor, int start, int size)
minor	101	drivers/block/genhd.c	hd->part[minor].start_sect = start;
minor	102	drivers/block/genhd.c	hd->part[minor].nr_sects   = size;
minor	103	drivers/block/genhd.c	printk(" %s", disk_name(hd, minor, buf));
minor	213	drivers/block/genhd.c	int i, minor = current_minor;
minor	311	drivers/block/genhd.c	for (i=1 ; i<=4 ; minor++,i++,p++) {
minor	314	drivers/block/genhd.c	add_partition(hd, minor, first_sector+START_SECT(p), NR_SECTS(p));
minor	323	drivers/block/genhd.c	hd->sizes[minor] = hd->part[minor].nr_sects
minor	325	drivers/block/genhd.c	extended_partition(hd, MKDEV(hd->major, minor));
minor	329	drivers/block/genhd.c	if (hd->part[minor].nr_sects > 2)
minor	330	drivers/block/genhd.c	hd->part[minor].nr_sects = 2;
minor	1105	drivers/block/hd.c	int minor = start + i;
minor	1106	drivers/block/hd.c	kdev_t devi = MKDEV(MAJOR_NR, minor);
minor	1110	drivers/block/hd.c	gdev->part[minor].start_sect = 0;
minor	1111	drivers/block/hd.c	gdev->part[minor].nr_sects = 0;
minor	1158	drivers/block/ide-cd.c	int minor = MINOR (rq->rq_dev);
minor	1162	drivers/block/ide-cd.c	if ((minor & PARTN_MASK) != 0) {
minor	1164	drivers/block/ide-cd.c	minor &= ~PARTN_MASK;
minor	1165	drivers/block/ide-cd.c	rq->rq_dev = MKDEV (MAJOR(rq->rq_dev), minor);
minor	595	drivers/block/ide-tape.c	int major,minor;
minor	1164	drivers/block/ide-tape.c	idetape_chrdev.minor=0;
minor	1185	drivers/block/ide-tape.c	int major,minor;
minor	1193	drivers/block/ide-tape.c	minor=idetape_chrdev.minor;
minor	4093	drivers/block/ide-tape.c	unsigned int minor=MINOR (inode->i_rdev),allocation_length;
minor	4101	drivers/block/ide-tape.c	if (minor!=0 && minor!=128) {    /* Currently supporting only one */
minor	4154	drivers/block/ide-tape.c	unsigned int minor=MINOR (inode->i_rdev);
minor	4170	drivers/block/ide-tape.c	if (minor < 128)
minor	4176	drivers/block/ide-tape.c	if (minor < 128)
minor	1356	drivers/block/ide.c	unsigned int minor, unit;
minor	1364	drivers/block/ide.c	minor = MINOR(rq->rq_dev);
minor	1365	drivers/block/ide.c	unit = minor >> PARTN_BITS;
minor	1380	drivers/block/ide.c	if ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
minor	1382	drivers/block/ide.c	(minor&PARTN_MASK)?'0'+(minor&PARTN_MASK):' ', block, rq->nr_sectors);
minor	1385	drivers/block/ide.c	block += drive->part[minor&PARTN_MASK].start_sect + drive->sect0;
minor	1846	drivers/block/ide.c	unsigned int p, major, minor;
minor	1853	drivers/block/ide.c	minor = drive->select.b.unit << PARTN_BITS;
minor	1865	drivers/block/ide.c	kdev_t devp = MKDEV(major, minor+p);
minor	32	drivers/block/linear.c	static int linear_run (int minor, struct md_dev *mddev)
minor	48	drivers/block/linear.c	data->smallest=devices[minor];
minor	50	drivers/block/linear.c	if (data->smallest->size > devices[minor][i].size)
minor	51	drivers/block/linear.c	data->smallest=devices[minor]+i;
minor	54	drivers/block/linear.c	md_size[minor]/data->smallest->size +
minor	55	drivers/block/linear.c	(md_size[minor]%data->smallest->size ? 1 : 0);
minor	59	drivers/block/linear.c	size=devices[minor][cur].size;
minor	64	drivers/block/linear.c	data->hash_table[i].dev0=devices[minor]+cur;
minor	74	drivers/block/linear.c	size=devices[minor][cur].size;
minor	87	drivers/block/linear.c	size=devices[minor][cur].size;
minor	88	drivers/block/linear.c	data->hash_table[i++].dev1=devices[minor]+cur;
minor	95	drivers/block/linear.c	static int linear_stop (int minor, struct md_dev *mddev)
minor	108	drivers/block/linear.c	static int linear_map (int minor, struct md_dev *mddev, struct request *req)
minor	146	drivers/block/linear.c	queue=tmp_dev - devices[minor];
minor	153	drivers/block/linear.c	printk("md%d: block %ld not locked\n", minor, bh->b_blocknr);
minor	179	drivers/block/linear.c	static int linear_status (char *page, int minor, struct md_dev *mddev)
minor	187	drivers/block/ll_rw_blk.c	int minor,major;
minor	190	drivers/block/ll_rw_blk.c	minor = MINOR(dev);
minor	192	drivers/block/ll_rw_blk.c	return ro_bits[major][minor >> 5] & (1 << (minor & 31));
minor	197	drivers/block/ll_rw_blk.c	int minor,major;
minor	200	drivers/block/ll_rw_blk.c	minor = MINOR(dev);
minor	202	drivers/block/ll_rw_blk.c	if (flag) ro_bits[major][minor >> 5] |= 1 << (minor & 31);
minor	203	drivers/block/ll_rw_blk.c	else ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
minor	136	drivers/block/md.c	int minor, index, err, current_ra;
minor	144	drivers/block/md.c	if (((minor=MINOR(inode->i_rdev)) & 0x80) &&
minor	145	drivers/block/md.c	(minor & 0x7f) < MAX_PERSONALITY &&
minor	146	drivers/block/md.c	pers[minor & 0x7f] &&
minor	147	drivers/block/md.c	pers[minor & 0x7f]->ioctl)
minor	148	drivers/block/md.c	return (pers[minor & 0x7f]->ioctl (inode, file, cmd, arg));
minor	150	drivers/block/md.c	if (minor >= MAX_MD_DEV)
minor	157	drivers/block/md.c	if (MAJOR(dev)==MD_MAJOR || md_dev[minor].nb_dev==MAX_REAL)
minor	160	drivers/block/md.c	if (!fs_may_mount (dev) || md_dev[minor].pers)
minor	166	drivers/block/md.c	index=md_dev[minor].nb_dev++;
minor	167	drivers/block/md.c	devices[minor][index].dev=dev;
minor	174	drivers/block/md.c	devices[minor][index].inode=get_empty_inode ();
minor	175	drivers/block/md.c	devices[minor][index].inode->i_dev=dev; /* don't care about
minor	177	drivers/block/md.c	insert_inode_hash (devices[minor][index].inode);
minor	183	drivers/block/md.c	devices[minor][index].size=gen_real->sizes[MINOR(dev)] & ~((PAGE_SIZE >> 10)-1);
minor	184	drivers/block/md.c	devices[minor][index].offset=index ?
minor	185	drivers/block/md.c	(devices[minor][index-1].offset + devices[minor][index-1].size) : 0;
minor	188	drivers/block/md.c	md_size[minor]=devices[minor][index].size;
minor	190	drivers/block/md.c	md_size[minor]+=devices[minor][index].size;
minor	192	drivers/block/md.c	printk("REGISTER_DEV %s to md%x done\n", partition_name(dev), minor);
minor	196	drivers/block/md.c	if (!md_dev[minor].nb_dev)
minor	199	drivers/block/md.c	if (md_dev[minor].pers)
minor	202	drivers/block/md.c	md_dev[minor].repartition=(int) arg;
minor	204	drivers/block/md.c	if ((index=PERSONALITY(md_dev+minor) >> (PERSONALITY_SHIFT))
minor	219	drivers/block/md.c	md_dev[minor].pers=pers[index];
minor	221	drivers/block/md.c	if ((err=md_dev[minor].pers->run (minor, md_dev+minor)))
minor	223	drivers/block/md.c	md_dev[minor].pers=NULL;
minor	230	drivers/block/md.c	md_hd_struct[minor].start_sect=0;
minor	231	drivers/block/md.c	md_hd_struct[minor].nr_sects=md_size[minor]<<1;
minor	238	drivers/block/md.c	for (index=0; index<md_dev[minor].nb_dev; index++)
minor	240	drivers/block/md.c	if (current_ra>read_ahead[MAJOR(devices[minor][index].dev)])
minor	241	drivers/block/md.c	current_ra=read_ahead[MAJOR(devices[minor][index].dev)];
minor	243	drivers/block/md.c	devices[minor][index].fault_count=0;
minor	244	drivers/block/md.c	devices[minor][index].invalid=VALID;
minor	249	drivers/block/md.c	printk ("START_DEV md%x %s\n", minor, md_dev[minor].pers->name);
minor	253	drivers/block/md.c	if (inode->i_count>1 || md_dev[minor].busy>1) /* ioctl : one open channel */
minor	255	drivers/block/md.c	printk ("STOP_MD md%x failed : i_count=%d, busy=%d\n", minor, inode->i_count, md_dev[minor].busy);
minor	259	drivers/block/md.c	if (md_dev[minor].pers)
minor	264	drivers/block/md.c	md_dev[minor].pers->stop (minor, md_dev+minor);
minor	268	drivers/block/md.c	for (index=0; index<md_dev[minor].nb_dev; index++)
minor	269	drivers/block/md.c	clear_inode (devices[minor][index].inode);
minor	271	drivers/block/md.c	md_dev[minor].nb_dev=md_size[minor]=0;
minor	272	drivers/block/md.c	md_dev[minor].pers=NULL;
minor	276	drivers/block/md.c	printk ("STOP_DEV md%x\n", minor);
minor	282	drivers/block/md.c	if (!(err=md_valid_device (minor, dev, INVALID_ALWAYS)))
minor	283	drivers/block/md.c	printk ("md%d : %s disabled\n", minor, partition_name (dev));
minor	289	drivers/block/md.c	if (!(err=md_valid_device (minor, dev, VALID)))
minor	290	drivers/block/md.c	printk ("md%d : %s enabled\n", minor, partition_name (dev));
minor	329	drivers/block/md.c	put_user (md_hd_struct[minor].nr_sects/8, (short *) &loc->cylinders);
minor	347	drivers/block/md.c	int minor=MINOR(inode->i_rdev);
minor	349	drivers/block/md.c	md_dev[minor].busy++;
minor	356	drivers/block/md.c	int minor=MINOR(inode->i_rdev);
minor	359	drivers/block/md.c	md_dev[minor].busy--;
minor	378	drivers/block/md.c	static inline int remap_request (int minor, struct request *req)
minor	380	drivers/block/md.c	if (!md_dev[minor].pers)
minor	382	drivers/block/md.c	printk ("Oops ! md%d not running, giving up !\n", minor);
minor	386	drivers/block/md.c	return (md_dev[minor].pers->map(minor, md_dev+minor, req));
minor	391	drivers/block/md.c	int minor;
minor	421	drivers/block/md.c	minor = MINOR(req->rq_dev);
minor	422	drivers/block/md.c	if ((MAJOR(req->rq_dev) != MD_MAJOR) || (minor >= MAX_REAL))
minor	429	drivers/block/md.c	switch (remap_request (minor, req))
minor	684	drivers/block/md.c	int md_valid_device (int minor, kdev_t dev, int mode)
minor	688	drivers/block/md.c	for (i=0; i<md_dev[minor].nb_dev; i++)
minor	689	drivers/block/md.c	if (devices[minor][i].dev==dev)
minor	692	drivers/block/md.c	if (i>md_dev[minor].nb_dev)
minor	704	drivers/block/md.c	if (devices[minor][i].invalid==INVALID_ALWAYS)
minor	706	drivers/block/md.c	devices[minor][i].fault_count=0; /* reset fault count */
minor	707	drivers/block/md.c	if (md_dev[minor].invalid_dev_count)
minor	708	drivers/block/md.c	md_dev[minor].invalid_dev_count--;
minor	713	drivers/block/md.c	if (devices[minor][i].invalid != VALID )
minor	716	drivers/block/md.c	if (++devices[minor][i].fault_count > MAX_FAULT(md_dev+minor) &&
minor	717	drivers/block/md.c	MAX_FAULT(md_dev+minor)!=0xFF)
minor	723	drivers/block/md.c	md_dev[minor].invalid_dev_count++;
minor	731	drivers/block/md.c	if (md_dev[minor].invalid_dev_count<=md_dev[minor].pers->max_invalid_dev)
minor	738	drivers/block/md.c	md_dev[minor].invalid_dev_count++;
minor	741	drivers/block/md.c	devices[minor][i].invalid=mode;
minor	746	drivers/block/md.c	int md_can_reemit (int minor)
minor	755	drivers/block/md.c	if (!md_dev[minor].pers)
minor	758	drivers/block/md.c	return(md_dev[minor].pers->max_invalid_dev &&
minor	759	drivers/block/md.c	((md_dev[minor].pers->max_invalid_dev==-1) ?
minor	761	drivers/block/md.c	md_dev[minor].invalid_dev_count<=md_dev[minor].pers->max_invalid_dev));
minor	32	drivers/block/raid0.c	static void create_strip_zones (int minor, struct md_dev *mddev)
minor	44	drivers/block/raid0.c	if (devices[minor][i].size==devices[minor][j].size)
minor	68	drivers/block/raid0.c	if (devices[minor][j].size>current_offset)
minor	70	drivers/block/raid0.c	data->strip_zone[i].dev[c++]=devices[minor]+j;
minor	72	drivers/block/raid0.c	smallest_by_zone->size > devices[minor][j].size)
minor	73	drivers/block/raid0.c	smallest_by_zone=devices[minor]+j;
minor	89	drivers/block/raid0.c	static int raid0_run (int minor, struct md_dev *mddev)
minor	97	drivers/block/raid0.c	if (devices[minor][i].size<min)
minor	100	drivers/block/raid0.c	partition_name (devices[minor][i].dev));
minor	107	drivers/block/raid0.c	md_size[minor]=0;
minor	111	drivers/block/raid0.c	devices[minor][i].size &= ~((1 << FACTOR_SHIFT(FACTOR(mddev))) - 1);
minor	112	drivers/block/raid0.c	md_size[minor] += devices[minor][i].size;
minor	118	drivers/block/raid0.c	create_strip_zones (minor, mddev);
minor	121	drivers/block/raid0.c	md_size[minor]/data->smallest->size +
minor	122	drivers/block/raid0.c	(md_size[minor]%data->smallest->size ? 1 : 0);
minor	163	drivers/block/raid0.c	static int raid0_stop (int minor, struct md_dev *mddev)
minor	182	drivers/block/raid0.c	static int raid0_map (int minor, struct md_dev *mddev, struct request *req)
minor	224	drivers/block/raid0.c	queue=tmp_dev - devices[minor];
minor	233	drivers/block/raid0.c	printk("md%d: block %ld not locked\n", minor, bh->b_blocknr);
minor	268	drivers/block/raid0.c	static int raid0_status (char *page, int minor, struct md_dev *mddev)
minor	109	drivers/block/rd.c	unsigned int minor;
minor	115	drivers/block/rd.c	minor = MINOR(CURRENT->rq_dev);
minor	117	drivers/block/rd.c	if (minor >= NUM_RAMDISKS) {
minor	125	drivers/block/rd.c	if ((offset + len) > rd_length[minor]) {
minor	315	drivers/block/xd.c	int minor = (start | partition);
minor	316	drivers/block/xd.c	kdev_t devp = MKDEV(MAJOR_NR, minor);
minor	320	drivers/block/xd.c	xd_gendisk.part[minor].start_sect = 0;
minor	321	drivers/block/xd.c	xd_gendisk.part[minor].nr_sects = 0;
minor	170	drivers/cdrom/mcdx.c	int minor;      /* minor number of this drive */
minor	1251	drivers/cdrom/mcdx.c	stuffp->minor = drive;
minor	1440	drivers/cdrom/sjcd.c	unsigned char major, minor;
minor	1517	drivers/cdrom/sjcd.c	( int )sjcd_version.minor );
minor	43	drivers/char/lp.c	#define LP_READY(minor, status) \
minor	44	drivers/char/lp.c	((LP_F(minor) & LP_CAREFUL) ? _LP_CAREFUL_READY(status) : (status & LP_PBUSY))
minor	45	drivers/char/lp.c	#define LP_CAREFUL_READY(minor, status) \
minor	46	drivers/char/lp.c	((LP_F(minor) & LP_CAREFUL) ? _LP_CAREFUL_READY(status) : 1)
minor	59	drivers/char/lp.c	static int lp_reset(int minor)
minor	61	drivers/char/lp.c	outb_p(LP_PSELECP, LP_C(minor));
minor	63	drivers/char/lp.c	outb_p(LP_PSELECP | LP_PINITP, LP_C(minor));
minor	64	drivers/char/lp.c	return LP_S(minor);
minor	67	drivers/char/lp.c	static inline int lp_char_polled(char lpchar, int minor)
minor	74	drivers/char/lp.c	status = LP_S(minor);
minor	78	drivers/char/lp.c	} while(!LP_READY(minor,status) && count < LP_CHAR(minor));
minor	80	drivers/char/lp.c	if (count == LP_CHAR(minor)) {
minor	84	drivers/char/lp.c	outb_p(lpchar, LP_B(minor));
minor	85	drivers/char/lp.c	stats = &LP_STAT(minor);
minor	89	drivers/char/lp.c	while(wait != LP_WAIT(minor)) wait++;
minor	91	drivers/char/lp.c	outb_p(( LP_PSELECP | LP_PINITP | LP_PSTROBE ), ( LP_C( minor )));
minor	94	drivers/char/lp.c	outb_p(( LP_PSELECP | LP_PINITP ), ( LP_C( minor )));
minor	98	drivers/char/lp.c	printk(KERN_DEBUG "lp%d success after %d counts.\n",minor,count);
minor	111	drivers/char/lp.c	static inline int lp_char_interrupt(char lpchar, int minor)
minor	119	drivers/char/lp.c	if ((status = LP_S(minor)) & LP_PBUSY) {
minor	120	drivers/char/lp.c	if (!LP_CAREFUL_READY(minor, status))
minor	122	drivers/char/lp.c	outb_p(lpchar, LP_B(minor));
minor	123	drivers/char/lp.c	stats = &LP_STAT(minor);
minor	128	drivers/char/lp.c	while(wait != LP_WAIT(minor)) wait++;
minor	130	drivers/char/lp.c	outb_p(( LP_PSELECP | LP_PINITP | LP_PSTROBE ), ( LP_C( minor )));
minor	133	drivers/char/lp.c	outb_p(( LP_PSELECP | LP_PINITP ), ( LP_C( minor )));
minor	146	drivers/char/lp.c	} while (count++ < LP_CHAR(minor));
minor	163	drivers/char/lp.c	static inline int lp_write_interrupt(unsigned int minor, const char * buf, int count)
minor	168	drivers/char/lp.c	struct lp_struct *lp = &lp_table[minor];
minor	177	drivers/char/lp.c	if (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
minor	180	drivers/char/lp.c	lp_table[minor].runchars++;
minor	183	drivers/char/lp.c	if (lp_table[minor].runchars > LP_STAT(minor).maxrun)
minor	184	drivers/char/lp.c	LP_STAT(minor).maxrun = lp_table[minor].runchars;
minor	185	drivers/char/lp.c	status = LP_S(minor);
minor	187	drivers/char/lp.c	printk(KERN_INFO "lp%d out of paper\n", minor);
minor	188	drivers/char/lp.c	if (LP_F(minor) & LP_ABORT)
minor	191	drivers/char/lp.c	printk(KERN_INFO "lp%d off-line\n", minor);
minor	192	drivers/char/lp.c	if (LP_F(minor) & LP_ABORT)
minor	195	drivers/char/lp.c	printk(KERN_ERR "lp%d printer error\n", minor);
minor	196	drivers/char/lp.c	if (LP_F(minor) & LP_ABORT)
minor	199	drivers/char/lp.c	LP_STAT(minor).sleeps++;
minor	201	drivers/char/lp.c	outb_p((LP_PSELECP|LP_PINITP|LP_PINTEN), (LP_C(minor)));
minor	202	drivers/char/lp.c	status = LP_S(minor);
minor	204	drivers/char/lp.c	&& LP_CAREFUL_READY(minor, status)) {
minor	205	drivers/char/lp.c	outb_p((LP_PSELECP|LP_PINITP), (LP_C(minor)));
minor	209	drivers/char/lp.c	lp_table[minor].runchars=0;
minor	212	drivers/char/lp.c	outb_p((LP_PSELECP|LP_PINITP), (LP_C(minor)));
minor	232	drivers/char/lp.c	static inline int lp_write_polled(unsigned int minor, const char * buf, int count)
minor	241	drivers/char/lp.c	retval = lp_char_polled(c, minor);
minor	245	drivers/char/lp.c	lp_table[minor].runchars++;
minor	247	drivers/char/lp.c	if (lp_table[minor].runchars > LP_STAT(minor).maxrun)
minor	248	drivers/char/lp.c	LP_STAT(minor).maxrun = lp_table[minor].runchars;
minor	249	drivers/char/lp.c	status = LP_S(minor);
minor	252	drivers/char/lp.c	printk(KERN_INFO "lp%d out of paper\n", minor);
minor	253	drivers/char/lp.c	if(LP_F(minor) & LP_ABORT)
minor	260	drivers/char/lp.c	printk(KERN_INFO "lp%d off-line\n", minor);
minor	261	drivers/char/lp.c	if(LP_F(minor) & LP_ABORT)
minor	269	drivers/char/lp.c	printk(KERN_ERR "lp%d reported invalid error status (on fire, eh?)\n", minor);
minor	270	drivers/char/lp.c	if(LP_F(minor) & LP_ABORT)
minor	284	drivers/char/lp.c	LP_STAT(minor).sleeps++;
minor	287	drivers/char/lp.c	minor,lp_table[minor].runchars, LP_TIME(minor));
minor	289	drivers/char/lp.c	lp_table[minor].runchars=0;
minor	291	drivers/char/lp.c	current->timeout = jiffies + LP_TIME(minor);
minor	300	drivers/char/lp.c	unsigned int minor = MINOR(inode->i_rdev);
minor	302	drivers/char/lp.c	if (jiffies-lp_table[minor].lastcall > LP_TIME(minor))
minor	303	drivers/char/lp.c	lp_table[minor].runchars = 0;
minor	304	drivers/char/lp.c	lp_table[minor].lastcall = jiffies;
minor	306	drivers/char/lp.c	if (LP_IRQ(minor))
minor	307	drivers/char/lp.c	return lp_write_interrupt(minor, buf, count);
minor	309	drivers/char/lp.c	return lp_write_polled(minor, buf, count);
minor	320	drivers/char/lp.c	unsigned int minor = MINOR(inode->i_rdev);
minor	324	drivers/char/lp.c	if (minor >= LP_NO)
minor	326	drivers/char/lp.c	if ((LP_F(minor) & LP_EXIST) == 0)
minor	328	drivers/char/lp.c	if (LP_F(minor) & LP_BUSY)
minor	338	drivers/char/lp.c	if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) {
minor	339	drivers/char/lp.c	int status = LP_S(minor);
minor	341	drivers/char/lp.c	printk(KERN_INFO "lp%d out of paper\n", minor);
minor	345	drivers/char/lp.c	printk(KERN_INFO "lp%d off-line\n", minor);
minor	349	drivers/char/lp.c	printk(KERN_ERR "lp%d printer error\n", minor);
minor	355	drivers/char/lp.c	if ((irq = LP_IRQ(minor))) {
minor	356	drivers/char/lp.c	lp_table[minor].lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
minor	357	drivers/char/lp.c	if (!lp_table[minor].lp_buffer) {
minor	364	drivers/char/lp.c	kfree_s(lp_table[minor].lp_buffer, LP_BUFFER_SIZE);
minor	365	drivers/char/lp.c	lp_table[minor].lp_buffer = NULL;
minor	366	drivers/char/lp.c	printk("lp%d unable to use interrupt %d, error %d\n", minor, irq, ret);
minor	372	drivers/char/lp.c	LP_F(minor) |= LP_BUSY;
minor	378	drivers/char/lp.c	unsigned int minor = MINOR(inode->i_rdev);
minor	381	drivers/char/lp.c	if ((irq = LP_IRQ(minor))) {
minor	383	drivers/char/lp.c	kfree_s(lp_table[minor].lp_buffer, LP_BUFFER_SIZE);
minor	384	drivers/char/lp.c	lp_table[minor].lp_buffer = NULL;
minor	387	drivers/char/lp.c	LP_F(minor) &= ~LP_BUSY;
minor	395	drivers/char/lp.c	unsigned int minor = MINOR(inode->i_rdev);
minor	399	drivers/char/lp.c	printk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%x\n", minor, cmd, arg);
minor	401	drivers/char/lp.c	if (minor >= LP_NO)
minor	403	drivers/char/lp.c	if ((LP_F(minor) & LP_EXIST) == 0)
minor	407	drivers/char/lp.c	LP_TIME(minor) = arg * HZ/100;
minor	410	drivers/char/lp.c	LP_CHAR(minor) = arg;
minor	414	drivers/char/lp.c	LP_F(minor) |= LP_ABORT;
minor	416	drivers/char/lp.c	LP_F(minor) &= ~LP_ABORT;
minor	420	drivers/char/lp.c	LP_F(minor) |= LP_ABORTOPEN;
minor	422	drivers/char/lp.c	LP_F(minor) &= ~LP_ABORTOPEN;
minor	426	drivers/char/lp.c	LP_F(minor) |= LP_CAREFUL;
minor	428	drivers/char/lp.c	LP_F(minor) &= ~LP_CAREFUL;
minor	431	drivers/char/lp.c	LP_WAIT(minor) = arg;
minor	436	drivers/char/lp.c	struct lp_struct *lp = &lp_table[minor];
minor	441	drivers/char/lp.c	oldirq = LP_IRQ(minor);
minor	472	drivers/char/lp.c	LP_IRQ(minor) = newirq;
minor	473	drivers/char/lp.c	lp_reset(minor);
minor	481	drivers/char/lp.c	memcpy_tofs((int *) arg, &LP_IRQ(minor), sizeof(int));
minor	489	drivers/char/lp.c	int status = LP_S(minor);
minor	494	drivers/char/lp.c	lp_reset(minor);
minor	502	drivers/char/lp.c	memcpy_tofs((int *) arg, &LP_STAT(minor), sizeof(struct lp_stats));
minor	504	drivers/char/lp.c	memset(&LP_STAT(minor), 0, sizeof(struct lp_stats));
minor	513	drivers/char/lp.c	int status = LP_F(minor);
minor	77	drivers/char/misc.c	len += sprintf(buf+len, "%3i %s\n",p->minor, p->name ?: "");
minor	86	drivers/char/misc.c	int minor = MINOR(inode->i_rdev);
minor	90	drivers/char/misc.c	while ((c != &misc_list) && (c->minor != minor))
minor	95	drivers/char/misc.c	sprintf(modname, "char-major-%d-%d", MISC_MAJOR, minor);
minor	98	drivers/char/misc.c	while ((c != &misc_list) && (c->minor != minor))
minor	127	drivers/char/misc.c	if (misc->minor == MISC_DYNAMIC_MINOR) {
minor	133	drivers/char/misc.c	misc->minor = i;
minor	135	drivers/char/misc.c	if (misc->minor < DYNAMIC_MINORS)
minor	136	drivers/char/misc.c	misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
minor	147	drivers/char/misc.c	int i = misc->minor;
minor	156	drivers/char/misc.c	misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
minor	274	drivers/char/tty_io.c	int  major, minor;
minor	277	drivers/char/tty_io.c	minor = MINOR(device);
minor	283	drivers/char/tty_io.c	if (minor < p->minor_start)
minor	285	drivers/char/tty_io.c	if (minor >= p->minor_start + p->num)
minor	1168	drivers/char/tty_io.c	int minor;
minor	1185	drivers/char/tty_io.c	minor = MINOR(device);
minor	648	drivers/isdn/isdn_common.c	static __inline int isdn_minor2drv(int minor)
minor	650	drivers/isdn/isdn_common.c	return (dev->drvmap[minor]);
minor	653	drivers/isdn/isdn_common.c	static __inline int isdn_minor2chan(int minor)
minor	655	drivers/isdn/isdn_common.c	return (dev->chanmap[minor]);
minor	725	drivers/isdn/isdn_common.c	uint minor = MINOR(inode->i_rdev);
minor	731	drivers/isdn/isdn_common.c	if (minor == ISDN_MINOR_STATUS) {
minor	748	drivers/isdn/isdn_common.c	if (minor < ISDN_MINOR_CTRL) {
minor	749	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor);
minor	754	drivers/isdn/isdn_common.c	chidx = isdn_minor2chan(minor);
minor	759	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_CTRLMAX) {
minor	760	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
minor	778	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_PPPMAX)
minor	779	drivers/isdn/isdn_common.c	return (isdn_ppp_read(minor - ISDN_MINOR_PPP, file, buf, count));
minor	791	drivers/isdn/isdn_common.c	uint minor = MINOR(inode->i_rdev);
minor	795	drivers/isdn/isdn_common.c	if (minor == ISDN_MINOR_STATUS)
minor	799	drivers/isdn/isdn_common.c	if (minor < ISDN_MINOR_CTRL) {
minor	800	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor);
minor	805	drivers/isdn/isdn_common.c	chidx = isdn_minor2chan(minor);
minor	810	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_CTRLMAX) {
minor	811	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
minor	826	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_PPPMAX)
minor	827	drivers/isdn/isdn_common.c	return (isdn_ppp_write(minor - ISDN_MINOR_PPP, file, buf, count));
minor	834	drivers/isdn/isdn_common.c	uint minor = MINOR(inode->i_rdev);
minor	836	drivers/isdn/isdn_common.c	if (minor == ISDN_MINOR_STATUS) {
minor	845	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_CTRLMAX)
minor	848	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_PPPMAX)
minor	849	drivers/isdn/isdn_common.c	return (isdn_ppp_select(minor - ISDN_MINOR_PPP, file, type, st));
minor	999	drivers/isdn/isdn_common.c	uint minor = MINOR(inode->i_rdev);
minor	1011	drivers/isdn/isdn_common.c	if (minor == ISDN_MINOR_STATUS)
minor	1015	drivers/isdn/isdn_common.c	if (minor < ISDN_MINOR_CTRL) {
minor	1016	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor);
minor	1019	drivers/isdn/isdn_common.c	chidx = isdn_minor2chan(minor);
minor	1024	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_CTRLMAX) {
minor	1350	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_PPPMAX)
minor	1351	drivers/isdn/isdn_common.c	return (isdn_ppp_ioctl(minor - ISDN_MINOR_PPP, file, cmd, arg));
minor	1363	drivers/isdn/isdn_common.c	uint minor = MINOR(ino->i_rdev);
minor	1368	drivers/isdn/isdn_common.c	if (minor == ISDN_MINOR_STATUS) {
minor	1384	drivers/isdn/isdn_common.c	if (minor < ISDN_MINOR_CTRL) {
minor	1385	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor);
minor	1388	drivers/isdn/isdn_common.c	chidx = isdn_minor2chan(minor);
minor	1399	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_CTRLMAX) {
minor	1400	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
minor	1410	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_PPPMAX) {
minor	1412	drivers/isdn/isdn_common.c	if (!(ret = isdn_ppp_open(minor - ISDN_MINOR_PPP, filep)))
minor	1422	drivers/isdn/isdn_common.c	uint minor = MINOR(ino->i_rdev);
minor	1429	drivers/isdn/isdn_common.c	if (minor == ISDN_MINOR_STATUS) {
minor	1445	drivers/isdn/isdn_common.c	if (minor < ISDN_MINOR_CTRL) {
minor	1446	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor);
minor	1454	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_CTRLMAX) {
minor	1455	drivers/isdn/isdn_common.c	drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
minor	1466	drivers/isdn/isdn_common.c	if (minor <= ISDN_MINOR_PPPMAX) {
minor	1467	drivers/isdn/isdn_common.c	isdn_ppp_release(minor - ISDN_MINOR_PPP, filep);
minor	57	drivers/isdn/isdn_ppp.c	static int isdn_ppp_fill_rq(char *buf, int len, int minor);
minor	162	drivers/isdn/isdn_ppp.c	static int isdn_ppp_hangup(int minor)
minor	164	drivers/isdn/isdn_ppp.c	if (minor < 0 || minor >= ISDN_MAX_CHANNELS)
minor	167	drivers/isdn/isdn_ppp.c	if (ippp_table[minor].state && ippp_table[minor].wq)
minor	168	drivers/isdn/isdn_ppp.c	wake_up_interruptible(&ippp_table[minor].wq);
minor	170	drivers/isdn/isdn_ppp.c	ippp_table[minor].state = IPPP_CLOSEWAIT;
minor	178	drivers/isdn/isdn_ppp.c	int isdn_ppp_open(int minor, struct file *file)
minor	181	drivers/isdn/isdn_ppp.c	printk(KERN_DEBUG "ippp, open, minor: %d state: %04x\n", minor,ippp_table[minor].state);
minor	183	drivers/isdn/isdn_ppp.c	if (ippp_table[minor].state)
minor	186	drivers/isdn/isdn_ppp.c	ippp_table[minor].lp = 0;
minor	187	drivers/isdn/isdn_ppp.c	ippp_table[minor].mp_seqno = 0;  /* MP sequence number */
minor	188	drivers/isdn/isdn_ppp.c	ippp_table[minor].pppcfg = 0;    /* ppp configuration */
minor	189	drivers/isdn/isdn_ppp.c	ippp_table[minor].mpppcfg = 0;   /* mppp configuration */
minor	190	drivers/isdn/isdn_ppp.c	ippp_table[minor].range = 0x1000000;  /* MP: 24 bit range */
minor	191	drivers/isdn/isdn_ppp.c	ippp_table[minor].last_link_seqno = -1;  /* MP: maybe set to Bundle-MIN, when joining a bundle ?? */
minor	192	drivers/isdn/isdn_ppp.c	ippp_table[minor].unit = -1;  /* set, when we have our interface */
minor	193	drivers/isdn/isdn_ppp.c	ippp_table[minor].mru = 1524;  /* MRU, default 1524 */
minor	194	drivers/isdn/isdn_ppp.c	ippp_table[minor].maxcid = 16;  /* VJ: maxcid */
minor	195	drivers/isdn/isdn_ppp.c	ippp_table[minor].tk = current;
minor	196	drivers/isdn/isdn_ppp.c	ippp_table[minor].wq = NULL;    /* read() wait queue */
minor	197	drivers/isdn/isdn_ppp.c	ippp_table[minor].wq1 = NULL;   /* select() wait queue */
minor	198	drivers/isdn/isdn_ppp.c	ippp_table[minor].first = ippp_table[minor].rq + NUM_RCV_BUFFS - 1; /* receive queue */
minor	199	drivers/isdn/isdn_ppp.c	ippp_table[minor].last = ippp_table[minor].rq;
minor	204	drivers/isdn/isdn_ppp.c	ippp_table[minor].cbuf = kmalloc(ippp_table[minor].mru + PPP_HARD_HDR_LEN + 2, GFP_KERNEL);
minor	206	drivers/isdn/isdn_ppp.c	if (ippp_table[minor].cbuf == NULL) {
minor	210	drivers/isdn/isdn_ppp.c	ippp_table[minor].slcomp = slhc_init(16, 16);  /* not necessary for 2. link in bundle */
minor	213	drivers/isdn/isdn_ppp.c	ippp_table[minor].state = IPPP_OPEN;
minor	218	drivers/isdn/isdn_ppp.c	void isdn_ppp_release(int minor, struct file *file)
minor	222	drivers/isdn/isdn_ppp.c	if (minor < 0 || minor >= ISDN_MAX_CHANNELS)
minor	226	drivers/isdn/isdn_ppp.c	printk(KERN_DEBUG "ippp: release, minor: %d %lx\n", minor, (long) ippp_table[minor].lp);
minor	229	drivers/isdn/isdn_ppp.c	if (ippp_table[minor].lp) {  /* a lp address says: this link is still up */
minor	232	drivers/isdn/isdn_ppp.c	if(&p->local == ippp_table[minor].lp)
minor	238	drivers/isdn/isdn_ppp.c	p = ippp_table[minor].lp->netdev;
minor	240	drivers/isdn/isdn_ppp.c	ippp_table[minor].lp->ppp_minor = -1;
minor	242	drivers/isdn/isdn_ppp.c	ippp_table[minor].lp = NULL;
minor	245	drivers/isdn/isdn_ppp.c	if (ippp_table[minor].rq[i].buf)
minor	246	drivers/isdn/isdn_ppp.c	kfree(ippp_table[minor].rq[i].buf);
minor	250	drivers/isdn/isdn_ppp.c	slhc_free(ippp_table[minor].slcomp);
minor	251	drivers/isdn/isdn_ppp.c	kfree(ippp_table[minor].cbuf);
minor	254	drivers/isdn/isdn_ppp.c	ippp_table[minor].state = 0;
minor	275	drivers/isdn/isdn_ppp.c	int isdn_ppp_ioctl(int minor, struct file *file, unsigned int cmd, unsigned long arg)
minor	281	drivers/isdn/isdn_ppp.c	printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x",minor,cmd);
minor	282	drivers/isdn/isdn_ppp.c	printk(KERN_DEBUG " state: %x\n",ippp_table[minor].state);
minor	285	drivers/isdn/isdn_ppp.c	if (!(ippp_table[minor].state & IPPP_OPEN))
minor	299	drivers/isdn/isdn_ppp.c	(int) minor, (int) ippp_table[minor].unit, (int) val);
minor	300	drivers/isdn/isdn_ppp.c	return isdn_ppp_bundle(minor, val);
minor	306	drivers/isdn/isdn_ppp.c	if ((r = set_arg((void *) arg, ippp_table[minor].unit)))
minor	310	drivers/isdn/isdn_ppp.c	if ((r = set_arg((void *) arg, ippp_table[minor].mpppcfg)))
minor	316	drivers/isdn/isdn_ppp.c	ippp_table[minor].mpppcfg = val;
minor	319	drivers/isdn/isdn_ppp.c	if ((r = set_arg((void *) arg, ippp_table[minor].pppcfg)))
minor	326	drivers/isdn/isdn_ppp.c	if (val & SC_ENABLE_IP && !(ippp_table[minor].pppcfg & SC_ENABLE_IP)) {
minor	327	drivers/isdn/isdn_ppp.c	ippp_table[minor].lp->netdev->dev.tbusy = 0;
minor	330	drivers/isdn/isdn_ppp.c	ippp_table[minor].pppcfg = val;
minor	341	drivers/isdn/isdn_ppp.c	ippp_table[minor].mru = val;
minor	350	drivers/isdn/isdn_ppp.c	ippp_table[minor].maxcid = val;
minor	362	drivers/isdn/isdn_ppp.c	int isdn_ppp_select(int minor, struct file *file, int type, select_table * st)
minor	368	drivers/isdn/isdn_ppp.c	printk(KERN_DEBUG "isdn_ppp_select: minor: %d, type: %d \n",minor,type);
minor	371	drivers/isdn/isdn_ppp.c	if (!(ippp_table[minor].state & IPPP_OPEN))
minor	378	drivers/isdn/isdn_ppp.c	bl = ippp_table[minor].last;
minor	379	drivers/isdn/isdn_ppp.c	bf = ippp_table[minor].first;
minor	380	drivers/isdn/isdn_ppp.c	if (bf->next == bl && !(ippp_table[minor].state & IPPP_NOBLOCK)) {
minor	381	drivers/isdn/isdn_ppp.c	select_wait(&ippp_table[minor].wq, st);
minor	385	drivers/isdn/isdn_ppp.c	ippp_table[minor].state &= ~IPPP_NOBLOCK;
minor	392	drivers/isdn/isdn_ppp.c	select_wait(&ippp_table[minor].wq1, st);
minor	402	drivers/isdn/isdn_ppp.c	static int isdn_ppp_fill_rq(char *buf, int len, int minor)
minor	407	drivers/isdn/isdn_ppp.c	if (minor < 0 || minor >= ISDN_MAX_CHANNELS) {
minor	411	drivers/isdn/isdn_ppp.c	if (!(ippp_table[minor].state & IPPP_CONNECT)) {
minor	418	drivers/isdn/isdn_ppp.c	bf = ippp_table[minor].first;
minor	419	drivers/isdn/isdn_ppp.c	bl = ippp_table[minor].last;
minor	425	drivers/isdn/isdn_ppp.c	ippp_table[minor].first = bf;
minor	437	drivers/isdn/isdn_ppp.c	ippp_table[minor].last = bl->next;
minor	440	drivers/isdn/isdn_ppp.c	if (ippp_table[minor].wq)
minor	441	drivers/isdn/isdn_ppp.c	wake_up_interruptible(&ippp_table[minor].wq);
minor	451	drivers/isdn/isdn_ppp.c	int isdn_ppp_read(int minor, struct file *file, char *buf, int count)
minor	453	drivers/isdn/isdn_ppp.c	struct ippp_struct *c = &ippp_table[minor];
minor	458	drivers/isdn/isdn_ppp.c	if (!(ippp_table[minor].state & IPPP_OPEN))
minor	487	drivers/isdn/isdn_ppp.c	int isdn_ppp_write(int minor, struct file *file,  const char *buf, int count)
minor	491	drivers/isdn/isdn_ppp.c	if (!(ippp_table[minor].state & IPPP_CONNECT))
minor	494	drivers/isdn/isdn_ppp.c	lp = ippp_table[minor].lp;
minor	897	drivers/isdn/isdn_ppp.c	static int isdn_ppp_bundle(int minor, int unit)
minor	914	drivers/isdn/isdn_ppp.c	nlp = ippp_table[minor].lp;
minor	1402	drivers/scsi/sd.c	int minor = start+i;
minor	1403	drivers/scsi/sd.c	kdev_t devi = MKDEV(MAJOR_NR, minor);
minor	1407	drivers/scsi/sd.c	gdev->part[minor].start_sect = 0;
minor	1408	drivers/scsi/sd.c	gdev->part[minor].nr_sects = 0;
minor	1413	drivers/scsi/sd.c	blksize_size[MAJOR_NR][minor] = 1024;
minor	1448	drivers/scsi/sd.c	int minor = start+i;
minor	1449	drivers/scsi/sd.c	kdev_t devi = MKDEV(MAJOR_NR, minor);
minor	1453	drivers/scsi/sd.c	sd_gendisk.part[minor].start_sect = 0;
minor	1454	drivers/scsi/sd.c	sd_gendisk.part[minor].nr_sects = 0;
minor	1455	drivers/scsi/sd.c	sd_sizes[minor] = 0;
minor	580	include/linux/fs.h	extern int floppy_is_wp(int minor);
minor	75	include/linux/genhd.h	char *disk_name (struct gendisk *hd, int minor, char *buf);
minor	89	include/linux/kdev_t.h	int major, minor;
minor	94	include/linux/kdev_t.h	minor = (dev & 0xff);
minor	96	include/linux/kdev_t.h	minor = (dev & 0xffff);
minor	99	include/linux/kdev_t.h	minor = (dev & 0xff);
minor	101	include/linux/kdev_t.h	return MKDEV(major, minor);
minor	81	include/linux/lp.h	#define LP_B(minor)  lp_table[(minor)].base    /* IO address */
minor	82	include/linux/lp.h	#define LP_F(minor)  lp_table[(minor)].flags    /* flags for busy, etc. */
minor	83	include/linux/lp.h	#define LP_S(minor)  inb_p(LP_B((minor)) + 1)  /* status port */
minor	84	include/linux/lp.h	#define LP_C(minor)  (lp_table[(minor)].base + 2)  /* control port */
minor	85	include/linux/lp.h	#define LP_CHAR(minor)  lp_table[(minor)].chars    /* busy timeout */
minor	86	include/linux/lp.h	#define LP_TIME(minor)  lp_table[(minor)].time    /* wait time */
minor	87	include/linux/lp.h	#define LP_WAIT(minor)  lp_table[(minor)].wait    /* strobe wait */
minor	88	include/linux/lp.h	#define LP_IRQ(minor)  lp_table[(minor)].irq    /* interrupt # */
minor	90	include/linux/lp.h	#define LP_STAT(minor)  lp_table[(minor)].stats    /* statistics area */
minor	110	include/linux/md.h	int (*map)(int minor, struct md_dev *md_dev, struct request *req);
minor	111	include/linux/md.h	int (*run)(int minor, struct md_dev *md_dev);
minor	112	include/linux/md.h	int (*stop)(int minor, struct md_dev *md_dev);
minor	113	include/linux/md.h	int (*status)(char *page, int minor, struct md_dev *md_dev);
minor	142	include/linux/md.h	extern int md_valid_device (int minor, kdev_t dev, int mode);
minor	143	include/linux/md.h	extern int md_can_reemit (int minor);
minor	14	include/linux/miscdevice.h	int minor;
minor	72	net/netlink.c	unsigned int minor = MINOR(inode->i_rdev);
minor	77	net/netlink.c	return (netlink_handler[minor])(skb);
minor	86	net/netlink.c	unsigned int minor = MINOR(inode->i_rdev);
minor	89	net/netlink.c	while((skb=skb_dequeue(&skb_queue_rd[minor]))==NULL)
minor	96	net/netlink.c	interruptible_sleep_on(&read_space_wait[minor]);
minor	103	net/netlink.c	rdq_size[minor]-=skb->len;
minor	120	net/netlink.c	unsigned int minor = MINOR(inode->i_rdev);
minor	122	net/netlink.c	if(minor>=MAX_LINKS)
minor	124	net/netlink.c	if(open_map&(1<<minor))
minor	126	net/netlink.c	if(active_map&(1<<minor))
minor	128	net/netlink.c	open_map|=(1<<minor);
minor	137	net/netlink.c	unsigned int minor = MINOR(inode->i_rdev);
minor	138	net/netlink.c	open_map&=~(1<<minor);
minor	146	net/netlink.c	unsigned int minor = MINOR(inode->i_rdev);
minor	149	net/netlink.c	if (minor >= MAX_LINKS)