Searched refs:minor (Results 1 - 200 of 1156) sorted by relevance

123456

/linux-4.1.27/drivers/media/platform/coda/
H A Dtrace.h20 __field(int, minor)
26 __entry->minor = ctx->fh.vdev->minor;
31 TP_printk("minor = %d, ctx = %d, cmd = %d",
32 __entry->minor, __entry->ctx, __entry->cmd)
41 __field(int, minor)
46 __entry->minor = ctx->fh.vdev->minor;
50 TP_printk("minor = %d, ctx = %d", __entry->minor, __entry->ctx)
59 __field(int, minor)
65 __entry->minor = ctx->fh.vdev->minor;
70 TP_printk("minor = %d, index = %d, ctx = %d",
71 __entry->minor, __entry->index, __entry->ctx)
80 __field(int, minor)
86 __entry->minor = ctx->fh.vdev->minor;
91 TP_printk("minor = %d, index = %d, ctx = %d",
92 __entry->minor, __entry->index, __entry->ctx)
102 __field(int, minor)
110 __entry->minor = ctx->fh.vdev->minor;
117 TP_printk("minor = %d, index = %d, start = 0x%x, end = 0x%x, ctx = %d",
118 __entry->minor, __entry->index, __entry->start, __entry->end,
128 __field(int, minor)
135 __entry->minor = ctx->fh.vdev->minor;
141 TP_printk("minor = %d, start = 0x%x, end = 0x%x, ctx = %d",
142 __entry->minor, __entry->start, __entry->end, __entry->ctx)
151 __field(int, minor)
158 __entry->minor = ctx->fh.vdev->minor;
164 TP_printk("minor = %d, start = 0x%x, end = 0x%x, ctx = %d",
165 __entry->minor, __entry->start, __entry->end, __entry->ctx)
175 __field(int, minor)
183 __entry->minor = ctx->fh.vdev->minor;
190 TP_printk("minor = %d, start = 0x%x, end = 0x%x, index = %d, ctx = %d",
191 __entry->minor, __entry->start, __entry->end, __entry->index,
/linux-4.1.27/drivers/gpu/drm/armada/
H A Darmada_debugfs.c20 struct drm_device *dev = node->minor->dev; armada_debugfs_gem_linear_show()
110 static int drm_add_fake_info_node(struct drm_minor *minor, struct dentry *ent, drm_add_fake_info_node() argument
121 node->minor = minor; drm_add_fake_info_node()
125 mutex_lock(&minor->debugfs_lock); drm_add_fake_info_node()
126 list_add(&node->list, &minor->debugfs_list); drm_add_fake_info_node()
127 mutex_unlock(&minor->debugfs_lock); drm_add_fake_info_node()
132 static int armada_debugfs_create(struct dentry *root, struct drm_minor *minor, armada_debugfs_create() argument
137 de = debugfs_create_file(name, mode, root, minor->dev, fops); armada_debugfs_create()
139 return drm_add_fake_info_node(minor, de, fops); armada_debugfs_create()
142 int armada_drm_debugfs_init(struct drm_minor *minor) armada_drm_debugfs_init() argument
148 minor->debugfs_root, minor); armada_drm_debugfs_init()
152 ret = armada_debugfs_create(minor->debugfs_root, minor, armada_drm_debugfs_init()
157 ret = armada_debugfs_create(minor->debugfs_root, minor, armada_drm_debugfs_init()
164 drm_debugfs_remove_files((struct drm_info_list *)&fops_reg_r, 1, minor); armada_drm_debugfs_init()
167 minor); armada_drm_debugfs_init()
171 void armada_drm_debugfs_cleanup(struct drm_minor *minor) armada_drm_debugfs_cleanup() argument
173 drm_debugfs_remove_files((struct drm_info_list *)&fops_reg_w, 1, minor); armada_drm_debugfs_cleanup()
174 drm_debugfs_remove_files((struct drm_info_list *)&fops_reg_r, 1, minor); armada_drm_debugfs_cleanup()
176 minor); armada_drm_debugfs_cleanup()
/linux-4.1.27/arch/sparc/kernel/
H A Dhvapi.c15 * PRE_API flag set are major 1 minor 0.
20 unsigned long minor; member in struct:api_info
78 p->major = p->minor = 0; __put_ref()
83 * API group and desired major+minor.
90 * API group/major/minor with the hypervisor, and errors returned
94 unsigned long *minor) sun4v_hvapi_register()
107 *minor = p->minor; sun4v_hvapi_register()
114 hv_ret = sun4v_set_version(group, major, *minor, sun4v_hvapi_register()
118 *minor = actual_minor; sun4v_hvapi_register()
120 p->minor = actual_minor; sun4v_hvapi_register()
127 p->minor = 0; sun4v_hvapi_register()
128 *minor = 0; sun4v_hvapi_register()
159 unsigned long *minor) sun4v_hvapi_get()
170 *minor = p->minor; sun4v_hvapi_get()
181 unsigned long group, major, minor; sun4v_hvapi_init() local
185 minor = 0; sun4v_hvapi_init()
186 if (sun4v_hvapi_register(group, major, &minor)) sun4v_hvapi_init()
191 minor = 1; sun4v_hvapi_init()
192 if (sun4v_hvapi_register(group, major, &minor)) sun4v_hvapi_init()
199 "%lx with major(%lu) minor(%lu)\n", sun4v_hvapi_init()
200 group, major, minor); sun4v_hvapi_init()
93 sun4v_hvapi_register(unsigned long group, unsigned long major, unsigned long *minor) sun4v_hvapi_register() argument
157 sun4v_hvapi_get(unsigned long group, unsigned long *major, unsigned long *minor) sun4v_hvapi_get() argument
H A Dsstate.c91 unsigned long major, minor; sstate_init() local
97 minor = 0; sstate_init()
98 if (sun4v_hvapi_register(HV_GRP_SOFT_STATE, major, &minor)) sstate_init()
H A Dviohs.c46 static int send_version(struct vio_driver_state *vio, u16 major, u16 minor) send_version() argument
55 pkt.minor = minor; send_version()
59 major, minor, vio->dev_class); send_version()
74 vio->ver_table[0].minor); start_handshake()
251 pkt->major, pkt->minor, pkt->dev_class); process_ver_info()
266 pkt->minor = 0; process_ver_info()
272 pkt->minor = vap->minor; process_ver_info()
274 pkt->major, pkt->minor); process_ver_info()
279 .minor = pkt->minor, process_ver_info()
281 if (ver.minor > vap->minor) process_ver_info()
282 ver.minor = vap->minor; process_ver_info()
283 pkt->minor = ver.minor; process_ver_info()
286 pkt->major, pkt->minor); process_ver_info()
303 pkt->major, pkt->minor, pkt->dev_class); process_ver_ack()
307 vio->ver.minor != pkt->minor) { process_ver_ack()
314 vio->ver.minor = pkt->minor; process_ver_ack()
338 pkt->major, pkt->minor, pkt->dev_class); process_ver_nack()
340 if (pkt->major == 0 && pkt->minor == 0) process_ver_nack()
346 if (send_version(vio, nver->major, nver->minor) < 0) process_ver_nack()
H A Dldc.c81 u16 minor; member in struct:ldc_version
86 { .major = 1, .minor = 0 },
383 ver->major, ver->minor); start_handshake()
397 u16 major, u16 minor) send_version_nack()
404 ver.minor = minor; send_version_nack()
410 ver.major, ver.minor); send_version_nack()
427 vp->major, vp->minor); send_version_ack()
584 ldcdbg(HS, "GOT VERSION INFO major[%x] minor[%x]\n", process_ver_info()
585 vp->major, vp->minor); process_ver_info()
596 err = send_version_nack(lp, vap->major, vap->minor); process_ver_info()
599 if (ver.minor > vap->minor) process_ver_info()
600 ver.minor = vap->minor; process_ver_info()
615 ldcdbg(HS, "GOT VERSION ACK major[%x] minor[%x]\n", process_ver_ack()
616 vp->major, vp->minor); process_ver_ack()
620 lp->ver.minor != vp->minor) process_ver_ack()
637 if (vp->major == 0 && vp->minor == 0) process_ver_nack()
2318 unsigned long major, minor; ldc_init() local
2338 minor = 0; ldc_init()
2339 if (sun4v_hvapi_register(HV_GRP_LDOM, major, &minor)) { ldc_init()
396 send_version_nack(struct ldc_channel *lp, u16 major, u16 minor) send_version_nack() argument
/linux-4.1.27/drivers/gpu/drm/nouveau/
H A Dnouveau_debugfs.h11 nouveau_debugfs_init(struct drm_minor *minor) nouveau_debugfs_init() argument
16 static inline void nouveau_debugfs_takedown(struct drm_minor *minor) nouveau_debugfs_takedown() argument
H A Dnouveau_debugfs.c38 struct nouveau_drm *drm = nouveau_drm(node->minor->dev); nouveau_debugfs_vbios_image()
52 nouveau_debugfs_init(struct drm_minor *minor) nouveau_debugfs_init() argument
55 minor->debugfs_root, minor); nouveau_debugfs_init()
60 nouveau_debugfs_takedown(struct drm_minor *minor) nouveau_debugfs_takedown() argument
63 minor); nouveau_debugfs_takedown()
/linux-4.1.27/sound/core/
H A Dsound.c80 static void snd_request_other(int minor) snd_request_other() argument
84 switch (minor) { snd_request_other()
96 * @minor: the minor number
99 * Checks that a minor device with the specified type is registered, and returns
103 * if an associated instance with the given minor number and type is found.
109 void *snd_lookup_minor_data(unsigned int minor, int type) snd_lookup_minor_data() argument
114 if (minor >= ARRAY_SIZE(snd_minors)) snd_lookup_minor_data()
117 mreg = snd_minors[minor]; snd_lookup_minor_data()
131 static struct snd_minor *autoload_device(unsigned int minor) autoload_device() argument
135 dev = SNDRV_MINOR_DEVICE(minor); autoload_device()
138 int card = SNDRV_MINOR_CARD(minor); autoload_device()
143 snd_request_other(minor); autoload_device()
146 return snd_minors[minor]; autoload_device()
149 #define autoload_device(minor) NULL
154 unsigned int minor = iminor(inode); snd_open() local
159 if (minor >= ARRAY_SIZE(snd_minors)) snd_open()
162 mptr = snd_minors[minor]; snd_open()
164 mptr = autoload_device(minor); snd_open()
191 int minor; snd_find_free_minor() local
199 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { snd_find_free_minor()
201 if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL) snd_find_free_minor()
203 if (minor == SNDRV_MINOR_SEQUENCER || snd_find_free_minor()
204 minor == SNDRV_MINOR_TIMER) snd_find_free_minor()
206 if (!snd_minors[minor]) snd_find_free_minor()
207 return minor; snd_find_free_minor()
214 int minor; snd_find_free_minor() local
219 minor = type; snd_find_free_minor()
224 minor = SNDRV_MINOR(card->number, type); snd_find_free_minor()
233 minor = SNDRV_MINOR(card->number, type + dev); snd_find_free_minor()
238 if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS)) snd_find_free_minor()
240 if (snd_minors[minor]) snd_find_free_minor()
242 return minor; snd_find_free_minor()
264 int minor; snd_register_device() local
281 minor = snd_find_free_minor(type, card, dev); snd_register_device()
282 if (minor < 0) { snd_register_device()
283 err = minor; snd_register_device()
288 device->devt = MKDEV(major, minor); snd_register_device()
293 snd_minors[minor] = preg; snd_register_device()
313 int minor; snd_unregister_device() local
317 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { snd_unregister_device()
318 preg = snd_minors[minor]; snd_unregister_device()
320 snd_minors[minor] = NULL; snd_unregister_device()
327 if (minor >= ARRAY_SIZE(snd_minors)) snd_unregister_device()
364 int minor; snd_minor_info_read() local
368 for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) { snd_minor_info_read()
369 if (!(mptr = snd_minors[minor])) snd_minor_info_read()
374 minor, mptr->card, mptr->device, snd_minor_info_read()
378 minor, mptr->card, snd_minor_info_read()
381 snd_iprintf(buffer, "%3i: : %s\n", minor, snd_minor_info_read()
H A Dsound_oss.c46 void *snd_lookup_oss_minor_data(unsigned int minor, int type) snd_lookup_oss_minor_data() argument
51 if (minor >= ARRAY_SIZE(snd_oss_minors)) snd_lookup_oss_minor_data()
54 mreg = snd_oss_minors[minor]; snd_lookup_oss_minor_data()
69 int minor; snd_oss_kernel_minor() local
75 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIXER1 : SNDRV_MINOR_OSS_MIXER)); snd_oss_kernel_minor()
78 minor = SNDRV_MINOR_OSS_SEQUENCER; snd_oss_kernel_minor()
81 minor = SNDRV_MINOR_OSS_MUSIC; snd_oss_kernel_minor()
86 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_PCM1 : SNDRV_MINOR_OSS_PCM)); snd_oss_kernel_minor()
91 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIDI1 : SNDRV_MINOR_OSS_MIDI)); snd_oss_kernel_minor()
94 minor = SNDRV_MINOR_OSS(card->number, SNDRV_MINOR_OSS_DMFM); snd_oss_kernel_minor()
97 minor = SNDRV_MINOR_OSS_SNDSTAT; snd_oss_kernel_minor()
102 if (minor < 0 || minor >= SNDRV_OSS_MINORS) snd_oss_kernel_minor()
104 return minor; snd_oss_kernel_minor()
110 int minor = snd_oss_kernel_minor(type, card, dev); snd_register_oss_device() local
113 int cidx = SNDRV_MINOR_OSS_CARD(minor); snd_register_oss_device()
120 if (minor < 0) snd_register_oss_device()
121 return minor; snd_register_oss_device()
132 snd_oss_minors[minor] = preg; snd_register_oss_device()
133 minor_unit = SNDRV_MINOR_OSS_DEVICE(minor); snd_register_oss_device()
145 register1 = register_sound_special_device(f_ops, minor, carddev); snd_register_oss_device()
146 if (register1 != minor) snd_register_oss_device()
163 snd_oss_minors[minor] = NULL; snd_register_oss_device()
173 int minor = snd_oss_kernel_minor(type, card, dev); snd_unregister_oss_device() local
174 int cidx = SNDRV_MINOR_OSS_CARD(minor); snd_unregister_oss_device()
180 if (minor < 0) snd_unregister_oss_device()
181 return minor; snd_unregister_oss_device()
183 mptr = snd_oss_minors[minor]; snd_unregister_oss_device()
188 unregister_sound_special(minor); snd_unregister_oss_device()
189 switch (SNDRV_MINOR_OSS_DEVICE(minor)) { snd_unregister_oss_device()
204 snd_oss_minors[minor] = NULL; snd_unregister_oss_device()
242 int minor; snd_minor_info_oss_read() local
246 for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) { snd_minor_info_oss_read()
247 if (!(mptr = snd_oss_minors[minor])) snd_minor_info_oss_read()
250 snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", minor, snd_minor_info_oss_read()
254 snd_iprintf(buffer, "%3i: : %s\n", minor, snd_minor_info_oss_read()
/linux-4.1.27/sound/pci/asihpi/
H A Dhpi_version.h2 Development releases have odd minor version.
3 Production releases have even minor version.
22 /** Construct hpi version number from major, minor, release numbers */
27 /** Extract minor version from hpi version number */
/linux-4.1.27/drivers/char/
H A Dlp.c205 static int lp_reset(int minor) lp_reset() argument
208 lp_claim_parport_or_block (&lp_table[minor]); lp_reset()
209 w_ctr(minor, LP_PSELECP); lp_reset()
211 w_ctr(minor, LP_PSELECP | LP_PINITP); lp_reset()
212 retval = r_str(minor); lp_reset()
213 lp_release_parport (&lp_table[minor]); lp_reset()
217 static void lp_error (int minor) lp_error() argument
222 if (LP_F(minor) & LP_ABORT) lp_error()
225 polling = lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE; lp_error()
226 if (polling) lp_release_parport (&lp_table[minor]); lp_error()
227 prepare_to_wait(&lp_table[minor].waitq, &wait, TASK_INTERRUPTIBLE); lp_error()
229 finish_wait(&lp_table[minor].waitq, &wait); lp_error()
230 if (polling) lp_claim_parport_or_block (&lp_table[minor]); lp_error()
231 else parport_yield_blocking (lp_table[minor].dev); lp_error()
234 static int lp_check_status(int minor) lp_check_status() argument
237 unsigned int last = lp_table[minor].last_error; lp_check_status()
238 unsigned char status = r_str(minor); lp_check_status()
239 if ((status & LP_PERRORP) && !(LP_F(minor) & LP_CAREFUL)) lp_check_status()
245 printk(KERN_INFO "lp%d out of paper\n", minor); lp_check_status()
251 printk(KERN_INFO "lp%d off-line\n", minor); lp_check_status()
257 printk(KERN_INFO "lp%d on fire\n", minor); lp_check_status()
265 lp_table[minor].last_error = last; lp_check_status()
268 lp_error(minor); lp_check_status()
273 static int lp_wait_ready(int minor, int nonblock) lp_wait_ready() argument
278 if (lp_table[minor].current_mode != IEEE1284_MODE_COMPAT) { lp_wait_ready()
283 error = lp_check_status (minor); lp_wait_ready()
284 if (error && (nonblock || (LP_F(minor) & LP_ABORT))) lp_wait_ready()
297 unsigned int minor = iminor(file_inode(file)); lp_write() local
298 struct parport *port = lp_table[minor].dev->port; lp_write()
299 char *kbuf = lp_table[minor].lp_buffer; lp_write()
304 (LP_F(minor) & LP_ABORT)); lp_write()
307 if (time_after(jiffies, lp_table[minor].lastcall + LP_TIME(minor))) lp_write()
308 lp_table[minor].runchars = 0; lp_write()
310 lp_table[minor].lastcall = jiffies; lp_write()
317 if (mutex_lock_interruptible(&lp_table[minor].port_mutex)) lp_write()
327 lp_claim_parport_or_block (&lp_table[minor]); lp_write()
329 lp_table[minor].current_mode = lp_negotiate (port, lp_write()
330 lp_table[minor].best_mode); lp_write()
332 parport_set_timeout (lp_table[minor].dev, lp_write()
334 : lp_table[minor].timeout)); lp_write()
336 if ((retv = lp_wait_ready (minor, nonblock)) == 0) lp_write()
358 parport_negotiate (lp_table[minor].dev->port, lp_write()
360 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT; lp_write()
362 error = lp_wait_ready (minor, nonblock); lp_write()
374 parport_yield_blocking (lp_table[minor].dev); lp_write()
375 lp_table[minor].current_mode lp_write()
377 lp_table[minor].best_mode); lp_write()
396 &lp_table[minor].bits)) { lp_write()
397 printk(KERN_INFO "lp%d releasing parport\n", minor); lp_write()
398 parport_negotiate (lp_table[minor].dev->port, lp_write()
400 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT; lp_write()
401 lp_release_parport (&lp_table[minor]); lp_write()
404 mutex_unlock(&lp_table[minor].port_mutex); lp_write()
416 unsigned int minor=iminor(file_inode(file)); lp_read() local
417 struct parport *port = lp_table[minor].dev->port; lp_read()
419 char *kbuf = lp_table[minor].lp_buffer; lp_read()
421 (LP_F(minor) & LP_ABORT)); lp_read()
426 if (mutex_lock_interruptible(&lp_table[minor].port_mutex)) lp_read()
429 lp_claim_parport_or_block (&lp_table[minor]); lp_read()
431 parport_set_timeout (lp_table[minor].dev, lp_read()
433 : lp_table[minor].timeout)); lp_read()
435 parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT); lp_read()
436 if (parport_negotiate (lp_table[minor].dev->port, lp_read()
455 if (lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE) { lp_read()
456 parport_negotiate (lp_table[minor].dev->port, lp_read()
458 lp_error (minor); lp_read()
459 if (parport_negotiate (lp_table[minor].dev->port, lp_read()
465 prepare_to_wait(&lp_table[minor].waitq, &wait, TASK_INTERRUPTIBLE); lp_read()
467 finish_wait(&lp_table[minor].waitq, &wait); lp_read()
477 parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT); lp_read()
479 lp_release_parport (&lp_table[minor]); lp_read()
484 mutex_unlock(&lp_table[minor].port_mutex); lp_read()
493 unsigned int minor = iminor(inode); lp_open() local
497 if (minor >= LP_NO) { lp_open()
501 if ((LP_F(minor) & LP_EXIST) == 0) { lp_open()
505 if (test_and_set_bit(LP_BUSY_BIT_POS, &LP_F(minor))) { lp_open()
514 if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) { lp_open()
516 lp_claim_parport_or_block (&lp_table[minor]); lp_open()
517 status = r_str(minor); lp_open()
518 lp_release_parport (&lp_table[minor]); lp_open()
520 printk(KERN_INFO "lp%d out of paper\n", minor); lp_open()
521 LP_F(minor) &= ~LP_BUSY; lp_open()
525 printk(KERN_INFO "lp%d off-line\n", minor); lp_open()
526 LP_F(minor) &= ~LP_BUSY; lp_open()
530 printk(KERN_ERR "lp%d printer error\n", minor); lp_open()
531 LP_F(minor) &= ~LP_BUSY; lp_open()
536 lp_table[minor].lp_buffer = kmalloc(LP_BUFFER_SIZE, GFP_KERNEL); lp_open()
537 if (!lp_table[minor].lp_buffer) { lp_open()
538 LP_F(minor) &= ~LP_BUSY; lp_open()
543 lp_claim_parport_or_block (&lp_table[minor]); lp_open()
544 if ( (lp_table[minor].dev->port->modes & PARPORT_MODE_ECP) && lp_open()
545 !parport_negotiate (lp_table[minor].dev->port, lp_open()
547 printk (KERN_INFO "lp%d: ECP mode\n", minor); lp_open()
548 lp_table[minor].best_mode = IEEE1284_MODE_ECP; lp_open()
550 lp_table[minor].best_mode = IEEE1284_MODE_COMPAT; lp_open()
553 parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT); lp_open()
554 lp_release_parport (&lp_table[minor]); lp_open()
555 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT; lp_open()
563 unsigned int minor = iminor(inode); lp_release() local
565 lp_claim_parport_or_block (&lp_table[minor]); lp_release()
566 parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT); lp_release()
567 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT; lp_release()
568 lp_release_parport (&lp_table[minor]); lp_release()
569 kfree(lp_table[minor].lp_buffer); lp_release()
570 lp_table[minor].lp_buffer = NULL; lp_release()
571 LP_F(minor) &= ~LP_BUSY; lp_release()
575 static int lp_do_ioctl(unsigned int minor, unsigned int cmd, lp_do_ioctl() argument
582 printk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg); lp_do_ioctl()
584 if (minor >= LP_NO) lp_do_ioctl()
586 if ((LP_F(minor) & LP_EXIST) == 0) lp_do_ioctl()
592 LP_TIME(minor) = arg * HZ/100; lp_do_ioctl()
595 LP_CHAR(minor) = arg; lp_do_ioctl()
599 LP_F(minor) |= LP_ABORT; lp_do_ioctl()
601 LP_F(minor) &= ~LP_ABORT; lp_do_ioctl()
605 LP_F(minor) |= LP_ABORTOPEN; lp_do_ioctl()
607 LP_F(minor) &= ~LP_ABORTOPEN; lp_do_ioctl()
611 LP_F(minor) |= LP_CAREFUL; lp_do_ioctl()
613 LP_F(minor) &= ~LP_CAREFUL; lp_do_ioctl()
616 LP_WAIT(minor) = arg; lp_do_ioctl()
622 if (copy_to_user(argp, &LP_IRQ(minor), lp_do_ioctl()
627 if (mutex_lock_interruptible(&lp_table[minor].port_mutex)) lp_do_ioctl()
629 lp_claim_parport_or_block (&lp_table[minor]); lp_do_ioctl()
630 status = r_str(minor); lp_do_ioctl()
631 lp_release_parport (&lp_table[minor]); lp_do_ioctl()
632 mutex_unlock(&lp_table[minor].port_mutex); lp_do_ioctl()
638 lp_reset(minor); lp_do_ioctl()
642 if (copy_to_user(argp, &LP_STAT(minor), lp_do_ioctl()
646 memset(&LP_STAT(minor), 0, lp_do_ioctl()
651 status = LP_F(minor); lp_do_ioctl()
662 static int lp_set_timeout(unsigned int minor, struct timeval *par_timeout) lp_set_timeout() argument
676 lp_table[minor].timeout = to_jiffies; lp_set_timeout()
683 unsigned int minor; lp_ioctl() local
687 minor = iminor(file_inode(file)); lp_ioctl()
696 ret = lp_set_timeout(minor, &par_timeout); lp_ioctl()
699 ret = lp_do_ioctl(minor, cmd, arg, (void __user *)arg); lp_ioctl()
711 unsigned int minor; lp_compat_ioctl() local
715 minor = iminor(file_inode(file)); lp_compat_ioctl()
723 ret = lp_set_timeout(minor, &par_timeout); lp_compat_ioctl()
732 ret = lp_do_ioctl(minor, cmd, arg, compat_ptr(arg)); lp_compat_ioctl()
H A Dmisc.c25 * Handling of mouse minor numbers for kerneld:
86 seq_printf(seq, "%3i %s\n", p->minor, p->name ? p->name : ""); misc_seq_show()
114 int minor = iminor(inode); misc_open() local
122 if (c->minor == minor) { misc_open()
130 request_module("char-major-%d-%d", MISC_MAJOR, minor); misc_open()
134 if (c->minor == minor) { misc_open()
171 * Register a miscellaneous device with the kernel. If the minor
172 * number is set to %MISC_DYNAMIC_MINOR a minor number is assigned
173 * and placed in the minor field of the structure. For other cases
174 * the minor number requested is used.
194 if (misc->minor == MISC_DYNAMIC_MINOR) { misc_register()
200 misc->minor = DYNAMIC_MINORS - i - 1; misc_register()
206 if (c->minor == misc->minor) { misc_register()
213 dev = MKDEV(MISC_MAJOR, misc->minor); misc_register()
219 int i = DYNAMIC_MINORS - misc->minor - 1; misc_register()
248 int i = DYNAMIC_MINORS - misc->minor - 1; misc_deregister()
255 device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor)); misc_deregister()
H A Dpc8736x_gpio.c118 /* select GPIO port/pin from device minor number */ select_pin()
152 static int pc8736x_gpio_get(unsigned minor) pc8736x_gpio_get() argument
156 port = minor >> 3; pc8736x_gpio_get()
157 bit = minor & 7; pc8736x_gpio_get()
163 minor, pc8736x_gpio_base + port_offset[port] + PORT_IN, bit, pc8736x_gpio_get()
169 static void pc8736x_gpio_set(unsigned minor, int val) pc8736x_gpio_set() argument
173 minor &= 0x1f; pc8736x_gpio_set()
174 port = minor >> 3; pc8736x_gpio_set()
175 bit = minor & 7; pc8736x_gpio_set()
184 dev_dbg(&pdev->dev, "gpio_set(minor:%d port:%d bit:%d)" pc8736x_gpio_set()
185 " %2x -> %2x\n", minor, port, bit, curval, val); pc8736x_gpio_set()
196 static int pc8736x_gpio_current(unsigned minor) pc8736x_gpio_current() argument
199 minor &= 0x1f; pc8736x_gpio_current()
200 port = minor >> 3; pc8736x_gpio_current()
201 bit = minor & 7; pc8736x_gpio_current()
324 /* ignore minor errs, and succeed */ pc8736x_gpio_init()
H A Draw.c7 * We reserve minor number 0 for a control interface. ioctl()s on this
8 * device are used to bind the other minor numbers to block devices.
55 const int minor = iminor(inode); raw_open() local
59 if (minor == 0) { /* It is the control device */ raw_open()
69 bdev = raw_devices[minor].binding; raw_open()
82 if (++raw_devices[minor].inuse == 1) raw_open()
102 const int minor= iminor(inode); raw_release() local
106 bdev = raw_devices[minor].binding; raw_release()
107 if (--raw_devices[minor].inuse == 0) raw_release()
126 static int bind_set(int number, u64 major, u64 minor) bind_set() argument
128 dev_t dev = MKDEV(major, minor); bind_set()
135 if (MAJOR(dev) != major || MINOR(dev) != minor) bind_set()
151 * major/minor numbers make sense. bind_set()
H A Dtb0219.c164 unsigned int minor; tanbac_tb0219_read() local
167 minor = iminor(file_inode(file)); tanbac_tb0219_read()
168 switch (minor) { tanbac_tb0219_read()
173 value = get_gpio_input_pin(minor - 16); tanbac_tb0219_read()
176 value = get_gpio_output_pin(minor - 32); tanbac_tb0219_read()
179 value = get_dip_switch(minor - 48); tanbac_tb0219_read()
197 unsigned int minor; tanbac_tb0219_write() local
203 minor = iminor(file_inode(file)); tanbac_tb0219_write()
204 switch (minor) { tanbac_tb0219_write()
224 retval = set_gpio_output_pin(minor - 32, c); tanbac_tb0219_write()
237 unsigned int minor; tanbac_tb0219_open() local
239 minor = iminor(inode); tanbac_tb0219_open()
240 switch (minor) { tanbac_tb0219_open()
H A Dppdev.c110 unsigned int minor = iminor(file_inode(file)); pp_read() local
119 pr_debug(CHRDEV "%x: claim the port first\n", minor); pp_read()
192 unsigned int minor = iminor(file_inode(file)); pp_write() local
202 pr_debug(CHRDEV "%x: claim the port first\n", minor); pp_write()
280 static int register_device (int minor, struct pp_struct *pp) register_device() argument
287 name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor); register_device()
291 port = parport_find_number (minor); register_device()
327 unsigned int minor = iminor(file_inode(file)); pp_do_ioctl() local
340 pr_debug(CHRDEV "%x: you've already got it!\n", minor); pp_do_ioctl()
346 int err = register_device (minor, pp); pp_do_ioctl()
376 "already registered\n", minor); pp_do_ioctl()
451 port = parport_find_number (minor); pp_do_ioctl()
488 pr_debug(CHRDEV "%x: claim the port first\n", minor); pp_do_ioctl()
621 pr_debug(CHRDEV "%x: What? (cmd=0x%x)\n", minor, cmd); pp_do_ioctl()
640 unsigned int minor = iminor(inode); pp_open() local
643 if (minor >= PARPORT_MAX) pp_open()
669 unsigned int minor = iminor(inode); pp_release() local
694 "mode because user-space forgot\n", minor); pp_release()
708 "because user-space forgot\n", minor); pp_release()
717 pr_debug(CHRDEV "%x: unregistered pardevice\n", minor); pp_release()
H A Ddsp56k.c45 /* minor devices */
239 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev); dsp56k_read()
301 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev); dsp56k_write()
399 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev); dsp56k_ioctl()
405 * but how do I then check device minor number?
420 printk("DSP56k driver: Unknown minor device: %d\n", dev);
472 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev); dsp56k_release()
H A Dmem.c809 int minor; memory_open() local
812 minor = iminor(inode); memory_open()
813 if (minor >= ARRAY_SIZE(devlist)) memory_open()
816 dev = &devlist[minor]; memory_open()
845 int minor; chr_dev_init() local
855 for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) { chr_dev_init()
856 if (!devlist[minor].name) chr_dev_init()
862 if ((minor == DEVPORT_MINOR) && !arch_has_dev_port()) chr_dev_init()
865 device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor), chr_dev_init()
866 NULL, devlist[minor].name); chr_dev_init()
/linux-4.1.27/drivers/gpu/drm/
H A Ddrm_debugfs.c81 * \param minor device minor number
88 struct dentry *root, struct drm_minor *minor) drm_debugfs_create_files()
90 struct drm_device *dev = minor->dev; drm_debugfs_create_files()
117 tmp->minor = minor; drm_debugfs_create_files()
121 mutex_lock(&minor->debugfs_lock); drm_debugfs_create_files()
122 list_add(&tmp->list, &minor->debugfs_list); drm_debugfs_create_files()
123 mutex_unlock(&minor->debugfs_lock); drm_debugfs_create_files()
128 drm_debugfs_remove_files(files, count, minor); drm_debugfs_create_files()
137 * \param minor device minor number
141 * "/sys/kernel/debug/dri/%minor%/", and each entry in debugfs_list as
142 * "/sys/kernel/debug/dri/%minor%/%name%".
144 int drm_debugfs_init(struct drm_minor *minor, int minor_id, drm_debugfs_init() argument
147 struct drm_device *dev = minor->dev; drm_debugfs_init()
151 INIT_LIST_HEAD(&minor->debugfs_list); drm_debugfs_init()
152 mutex_init(&minor->debugfs_lock); drm_debugfs_init()
154 minor->debugfs_root = debugfs_create_dir(name, root); drm_debugfs_init()
155 if (!minor->debugfs_root) { drm_debugfs_init()
161 minor->debugfs_root, minor); drm_debugfs_init()
163 debugfs_remove(minor->debugfs_root); drm_debugfs_init()
164 minor->debugfs_root = NULL; drm_debugfs_init()
170 ret = dev->driver->debugfs_init(minor); drm_debugfs_init()
186 * \param minor The minor of which we should remove the files
192 struct drm_minor *minor) drm_debugfs_remove_files()
198 mutex_lock(&minor->debugfs_lock); drm_debugfs_remove_files()
200 list_for_each_safe(pos, q, &minor->debugfs_list) { drm_debugfs_remove_files()
209 mutex_unlock(&minor->debugfs_lock); drm_debugfs_remove_files()
217 * \param minor device minor number.
222 int drm_debugfs_cleanup(struct drm_minor *minor) drm_debugfs_cleanup() argument
224 struct drm_device *dev = minor->dev; drm_debugfs_cleanup()
226 if (!minor->debugfs_root) drm_debugfs_cleanup()
230 dev->driver->debugfs_cleanup(minor); drm_debugfs_cleanup()
232 drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor); drm_debugfs_cleanup()
234 debugfs_remove(minor->debugfs_root); drm_debugfs_cleanup()
235 minor->debugfs_root = NULL; drm_debugfs_cleanup()
379 struct drm_minor *minor = connector->dev->primary; drm_debugfs_connector_add() local
382 if (!minor->debugfs_root) drm_debugfs_connector_add()
385 root = debugfs_create_dir(connector->name, minor->debugfs_root); drm_debugfs_connector_add()
87 drm_debugfs_create_files(const struct drm_info_list *files, int count, struct dentry *root, struct drm_minor *minor) drm_debugfs_create_files() argument
191 drm_debugfs_remove_files(const struct drm_info_list *files, int count, struct drm_minor *minor) drm_debugfs_remove_files() argument
H A Ddrm_drv.c97 struct drm_master *drm_master_create(struct drm_minor *minor) drm_master_create() argument
113 master->minor = minor; drm_master_create()
128 struct drm_device *dev = master->minor->dev; drm_master_destroy()
170 if (file_priv->minor->master) { drm_setmaster_ioctl()
180 file_priv->minor->master = drm_master_get(file_priv->master); drm_setmaster_ioctl()
186 drm_master_put(&file_priv->minor->master); drm_setmaster_ioctl()
204 if (!file_priv->minor->master) drm_dropmaster_ioctl()
210 drm_master_put(&file_priv->minor->master); drm_dropmaster_ioctl()
227 * device. However, this doesn't mean that the minor is active. Minors are
248 struct drm_minor *minor; drm_minor_alloc() local
252 minor = kzalloc(sizeof(*minor), GFP_KERNEL); drm_minor_alloc()
253 if (!minor) drm_minor_alloc()
256 minor->type = type; drm_minor_alloc()
257 minor->dev = dev; drm_minor_alloc()
272 minor->index = r; drm_minor_alloc()
274 minor->kdev = drm_sysfs_minor_alloc(minor); drm_minor_alloc()
275 if (IS_ERR(minor->kdev)) { drm_minor_alloc()
276 r = PTR_ERR(minor->kdev); drm_minor_alloc()
280 *drm_minor_get_slot(dev, type) = minor; drm_minor_alloc()
285 idr_remove(&drm_minors_idr, minor->index); drm_minor_alloc()
288 kfree(minor); drm_minor_alloc()
294 struct drm_minor **slot, *minor; drm_minor_free() local
298 minor = *slot; drm_minor_free()
299 if (!minor) drm_minor_free()
302 drm_mode_group_destroy(&minor->mode_group); drm_minor_free()
303 put_device(minor->kdev); drm_minor_free()
306 idr_remove(&drm_minors_idr, minor->index); drm_minor_free()
309 kfree(minor); drm_minor_free()
315 struct drm_minor *minor; drm_minor_register() local
321 minor = *drm_minor_get_slot(dev, type); drm_minor_register()
322 if (!minor) drm_minor_register()
325 ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); drm_minor_register()
331 ret = device_add(minor->kdev); drm_minor_register()
335 /* replace NULL with @minor so lookups will succeed from now on */ drm_minor_register()
337 idr_replace(&drm_minors_idr, minor, minor->index); drm_minor_register()
340 DRM_DEBUG("new minor registered %d\n", minor->index); drm_minor_register()
344 drm_debugfs_cleanup(minor); drm_minor_register()
350 struct drm_minor *minor; drm_minor_unregister() local
353 minor = *drm_minor_get_slot(dev, type); drm_minor_unregister()
354 if (!minor || !device_is_registered(minor->kdev)) drm_minor_unregister()
357 /* replace @minor with NULL so lookups will fail from now on */ drm_minor_unregister()
359 idr_replace(&drm_minors_idr, NULL, minor->index); drm_minor_unregister()
362 device_del(minor->kdev); drm_minor_unregister()
363 dev_set_drvdata(minor->kdev, NULL); /* safety belt */ drm_minor_unregister()
364 drm_debugfs_cleanup(minor); drm_minor_unregister()
368 * drm_minor_acquire - Acquire a DRM minor
369 * @minor_id: Minor ID of the DRM-minor
371 * Looks up the given minor-ID and returns the respective DRM-minor object. The
375 * As long as you hold this minor, it is guaranteed that the object and the
376 * minor->dev pointer will stay valid! However, the device may get unplugged and
377 * unregistered while you hold the minor.
380 * Pointer to minor-object with increased device-refcount, or PTR_ERR on
385 struct drm_minor *minor; drm_minor_acquire() local
389 minor = idr_find(&drm_minors_idr, minor_id); drm_minor_acquire()
390 if (minor) drm_minor_acquire()
391 drm_dev_ref(minor->dev); drm_minor_acquire()
394 if (!minor) { drm_minor_acquire()
396 } else if (drm_device_is_unplugged(minor->dev)) { drm_minor_acquire()
397 drm_dev_unref(minor->dev); drm_minor_acquire()
401 return minor; drm_minor_acquire()
405 * drm_minor_release - Release DRM minor
406 * @minor: Pointer to DRM minor object
408 * Release a minor that was previously acquired via drm_minor_acquire().
410 void drm_minor_release(struct drm_minor *minor) drm_minor_release() argument
412 drm_dev_unref(minor->dev); drm_minor_release()
811 * - DRM minor management
816 * interface registered on a DRM device, you can request minor numbers from DRM
819 * registered minor.
825 struct drm_minor *minor; drm_stub_open() local
831 minor = drm_minor_acquire(iminor(inode)); drm_stub_open()
832 if (IS_ERR(minor)) { drm_stub_open()
833 err = PTR_ERR(minor); drm_stub_open()
837 new_fops = fops_get(minor->dev->driver->fops); drm_stub_open()
850 drm_minor_release(minor); drm_stub_open()
H A Ddrm_fops.c47 static int drm_open_helper(struct file *filp, struct drm_minor *minor);
76 * Searches the DRM device with the same minor number, calls open_helper(), and
83 struct drm_minor *minor; drm_open() local
87 minor = drm_minor_acquire(iminor(inode)); drm_open()
88 if (IS_ERR(minor)) drm_open()
89 return PTR_ERR(minor); drm_open()
91 dev = minor->dev; drm_open()
98 retcode = drm_open_helper(filp, minor); drm_open()
110 drm_minor_release(minor); drm_open()
132 * \param minor acquired minor-object.
138 static int drm_open_helper(struct file *filp, struct drm_minor *minor) drm_open_helper() argument
140 struct drm_device *dev = minor->dev; drm_open_helper()
151 DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor->index); drm_open_helper()
161 priv->minor = minor; drm_open_helper()
189 if (drm_is_primary_client(priv) && !priv->minor->master) { drm_open_helper()
191 priv->minor->master = drm_master_create(priv->minor); drm_open_helper()
192 if (!priv->minor->master) { drm_open_helper()
199 priv->master = drm_master_get(priv->minor->master); drm_open_helper()
206 drm_master_put(&priv->minor->master); drm_open_helper()
215 drm_master_put(&priv->minor->master); drm_open_helper()
222 priv->master = drm_master_get(priv->minor->master); drm_open_helper()
281 struct drm_device *dev = file_priv->minor->dev; drm_events_release()
373 struct drm_minor *minor = file_priv->minor; drm_release() local
374 struct drm_device *dev = minor->dev; drm_release()
394 (long)old_encode_dev(file_priv->minor->kdev->devt), drm_release()
403 if (file_priv->minor->master) drm_release()
438 if (file_priv->minor->master == file_priv->master) { drm_release()
439 /* drop the reference held my the minor */ drm_release()
442 drm_master_put(&file_priv->minor->master); drm_release()
475 drm_minor_release(minor); drm_release()
485 struct drm_device *dev = file_priv->minor->dev; drm_read()
H A Ddrm_internal.h79 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor);
103 struct drm_master *drm_master_create(struct drm_minor *minor);
107 int drm_debugfs_init(struct drm_minor *minor, int minor_id,
109 int drm_debugfs_cleanup(struct drm_minor *minor);
113 static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id, drm_debugfs_init() argument
119 static inline int drm_debugfs_cleanup(struct drm_minor *minor) drm_debugfs_cleanup() argument
H A Ddrm_info.c51 struct drm_minor *minor = node->minor; drm_name_info() local
52 struct drm_device *dev = minor->dev; drm_name_info()
53 struct drm_master *master = minor->master; drm_name_info()
76 struct drm_device *dev = node->minor->dev; drm_vm_info()
120 struct drm_device *dev = node->minor->dev; drm_bufs_info()
163 struct drm_device *dev = node->minor->dev; drm_clients_info()
186 priv->minor->index, drm_clients_info()
213 struct drm_device *dev = node->minor->dev; drm_gem_name_info()
H A Ddrm_sysfs.c538 * drm_sysfs_minor_alloc() - Allocate sysfs device for given minor
539 * @minor: minor to allocate sysfs device for
541 * This allocates a new sysfs device for @minor and returns it. The device is
545 * Note that dev_get_drvdata() on the new device will return the minor.
546 * However, the device does not hold a ref-count to the minor nor to the
549 * synchronously, so they cannot be called after you cleanup a minor.
551 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor) drm_sysfs_minor_alloc() argument
557 if (minor->type == DRM_MINOR_CONTROL) drm_sysfs_minor_alloc()
559 else if (minor->type == DRM_MINOR_RENDER) drm_sysfs_minor_alloc()
569 kdev->devt = MKDEV(DRM_MAJOR, minor->index); drm_sysfs_minor_alloc()
572 kdev->parent = minor->dev->dev; drm_sysfs_minor_alloc()
574 dev_set_drvdata(kdev, minor); drm_sysfs_minor_alloc()
576 r = dev_set_name(kdev, minor_str, minor->index); drm_sysfs_minor_alloc()
H A Ddrm_platform.c60 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", drm_get_platform_dev()
61 driver->name, driver->major, driver->minor, driver->patchlevel, drm_get_platform_dev()
H A Ddrm_vm.c102 struct drm_device *dev = priv->minor->dev; drm_do_vm_fault()
221 struct drm_device *dev = priv->minor->dev; drm_vm_shm_close()
293 struct drm_device *dev = priv->minor->dev; drm_do_vm_dma_fault()
328 struct drm_device *dev = priv->minor->dev; drm_do_vm_sg_fault()
425 struct drm_device *dev = priv->minor->dev; drm_vm_open()
460 struct drm_device *dev = priv->minor->dev; drm_vm_close()
484 dev = priv->minor->dev; drm_mmap_dma()
543 struct drm_device *dev = priv->minor->dev; drm_mmap_locked()
657 struct drm_device *dev = priv->minor->dev; drm_legacy_mmap()
685 struct drm_device *dev = node->minor->dev; drm_vma_info()
/linux-4.1.27/include/linux/
H A Dlp.h21 #define LP_F(minor) lp_table[(minor)].flags /* flags for busy, etc. */
22 #define LP_CHAR(minor) lp_table[(minor)].chars /* busy timeout */
23 #define LP_TIME(minor) lp_table[(minor)].time /* wait time */
24 #define LP_WAIT(minor) lp_table[(minor)].wait /* strobe wait */
25 #define LP_IRQ(minor) lp_table[(minor)].dev->port->irq /* interrupt # */
28 #define LP_STAT(minor) lp_table[(minor)].stats /* statistics area */
79 * accessed with LP_C(minor)
H A Ddrbd_genl_api.h6 * @minor:
7 * For admin requests (user -> kernel): which minor device to operate on.
9 * (kernel -> user): which minor device the information is about.
11 * the minor value shall be (~0), and the attribute DRBD_NLA_CFG_CONTEXT
16 * When creating a new minor (adding it to a resource), the resource needs
19 * whereas the minor number on the remote side may be different
24 __u32 minor; member in struct:drbd_genlmsghdr
H A Dkdev_t.h46 unsigned minor = MINOR(dev); new_encode_dev() local
47 return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12); new_encode_dev()
53 unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00); new_decode_dev() local
54 return MKDEV(major, minor); new_decode_dev()
H A Dhid-roccat.h24 void roccat_disconnect(int minor);
25 int roccat_report_event(int minor, u8 const *data);
H A Dqcom_scm.h24 #define QCOM_SCM_VERSION(major, minor) (((major) << 16) | ((minor) & 0xFF))
H A Dbsg.h11 int minor; member in struct:bsg_class_device
H A Dmiscdevice.h58 int minor; member in struct:miscdevice
72 #define MODULE_ALIAS_MISCDEV(minor) \
74 "-" __stringify(minor))
H A Dpe.h143 uint8_t ld_minor; /* linker minor version */
155 uint16_t os_minor; /* minor OS version */
157 uint16_t image_minor; /* minor image version */
159 uint16_t subsys_minor; /* minor subsystem version */
178 uint8_t ld_minor; /* linker minor version */
189 uint16_t os_minor; /* minor OS version */
191 uint16_t image_minor; /* minor image version */
193 uint16_t subsys_minor; /* minor subsystem version */
H A Dhidraw.h20 unsigned int minor; member in struct:hidraw
/linux-4.1.27/drivers/usb/core/
H A Dfile.c133 * usb_register_dev - register a USB device, and ask for a minor number
138 * If CONFIG_USB_DYNAMIC_MINORS is enabled, the minor number will be
140 * enabled, the minor number will be based on the next available free minor,
146 * the minor numbers given out by this function.
156 int minor; usb_register_dev() local
164 * no holes in the minor range. usb_register_dev()
171 if (intf->minor >= 0) usb_register_dev()
178 dev_dbg(&intf->dev, "looking for a minor, starting at %d\n", minor_base); usb_register_dev()
181 for (minor = minor_base; minor < MAX_USB_MINORS; ++minor) { usb_register_dev()
182 if (usb_minors[minor]) usb_register_dev()
185 usb_minors[minor] = class_driver->fops; usb_register_dev()
186 intf->minor = minor; usb_register_dev()
190 if (intf->minor < 0) usb_register_dev()
194 snprintf(name, sizeof(name), class_driver->name, minor - minor_base); usb_register_dev()
201 MKDEV(USB_MAJOR, minor), class_driver, usb_register_dev()
205 usb_minors[minor] = NULL; usb_register_dev()
206 intf->minor = -1; usb_register_dev()
215 * usb_deregister_dev - deregister a USB device's dynamic minor.
220 * when the USB driver is finished with the minor numbers gotten from a
231 if (intf->minor == -1) usb_deregister_dev()
234 dev_dbg(&intf->dev, "removing %d minor\n", intf->minor); usb_deregister_dev()
237 usb_minors[intf->minor] = NULL; usb_deregister_dev()
240 device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor)); usb_deregister_dev()
242 intf->minor = -1; usb_deregister_dev()
/linux-4.1.27/drivers/gpu/drm/omapdrm/
H A Domap_debugfs.c31 struct drm_device *dev = node->minor->dev; gem_show()
50 struct drm_device *dev = node->minor->dev; mm_show()
57 struct drm_device *dev = node->minor->dev; fb_show()
89 int omap_debugfs_init(struct drm_minor *minor) omap_debugfs_init() argument
91 struct drm_device *dev = minor->dev; omap_debugfs_init()
96 minor->debugfs_root, minor); omap_debugfs_init()
106 minor->debugfs_root, minor); omap_debugfs_init()
116 void omap_debugfs_cleanup(struct drm_minor *minor) omap_debugfs_cleanup() argument
119 ARRAY_SIZE(omap_debugfs_list), minor); omap_debugfs_cleanup()
122 ARRAY_SIZE(omap_dmm_debugfs_list), minor); omap_debugfs_cleanup()
/linux-4.1.27/include/sound/
H A Dminors.h27 #define SNDRV_MINOR_CARD(minor) ((minor) >> 5)
28 #define SNDRV_MINOR_DEVICE(minor) ((minor) & 0x001f)
44 /* same as first respective minor number to make minor allocation easier */
77 #define SNDRV_MINOR_OSS_CARD(minor) ((minor) >> 4)
78 #define SNDRV_MINOR_OSS_DEVICE(minor) ((minor) & 0x000f)
91 #define SNDRV_MINOR_OSS_DMMIDI 9 /* /dev/dmmidi0 - this device can have another minor # with OSS */
92 #define SNDRV_MINOR_OSS_DMFM 10 /* /dev/dmfm0 - this device can have another minor # with OSS */
H A Dsnd_wavefront.h83 char fw_version[2]; /* major = [0], minor = [1] */
84 char hw_version[2]; /* major = [0], minor = [1] */
/linux-4.1.27/drivers/hid/
H A Dhid-roccat.c43 unsigned int minor; member in struct:roccat_device
153 unsigned int minor = iminor(inode); roccat_open() local
164 device = devices[minor]; roccat_open()
167 pr_emerg("roccat device with minor %d doesn't exist\n", minor); roccat_open()
208 unsigned int minor = iminor(inode); roccat_release() local
214 device = devices[minor]; roccat_release()
217 pr_emerg("roccat device with minor %d doesn't exist\n", minor); roccat_release()
243 * @minor: minor device number returned by roccat_connect()
250 int roccat_report_event(int minor, u8 const *data) roccat_report_event() argument
257 device = devices[minor]; roccat_report_event()
294 * Return value is minor device number in Range [0, ROCCAT_MAX_DEVICES] on
299 unsigned int minor; roccat_connect() local
309 for (minor = 0; minor < ROCCAT_MAX_DEVICES; ++minor) { roccat_connect()
310 if (devices[minor]) roccat_connect()
315 if (minor < ROCCAT_MAX_DEVICES) { roccat_connect()
316 devices[minor] = device; roccat_connect()
324 MKDEV(roccat_major, minor), NULL, roccat_connect()
325 "%s%s%d", "roccat", hid->driver->name, minor); roccat_connect()
328 devices[minor] = NULL; roccat_connect()
341 device->minor = minor; roccat_connect()
347 return minor; roccat_connect()
352 * @minor: the minor device number returned by roccat_connect()
354 void roccat_disconnect(int minor) roccat_disconnect() argument
359 device = devices[minor]; roccat_disconnect()
364 device_destroy(device->dev->class, MKDEV(roccat_major, minor)); roccat_disconnect()
367 devices[minor] = NULL; roccat_disconnect()
383 unsigned int minor = iminor(inode); roccat_ioctl() local
388 device = devices[minor]; roccat_ioctl()
H A Dhidraw.c114 unsigned int minor = iminor(file_inode(file)); hidraw_send_report() local
119 if (!hidraw_table[minor] || !hidraw_table[minor]->exist) { hidraw_send_report()
124 dev = hidraw_table[minor]->hid; hidraw_send_report()
194 unsigned int minor = iminor(file_inode(file)); hidraw_get_report() local
200 dev = hidraw_table[minor]->hid; hidraw_get_report()
271 unsigned int minor = iminor(inode); hidraw_open() local
283 if (!hidraw_table[minor] || !hidraw_table[minor]->exist) { hidraw_open()
288 dev = hidraw_table[minor]; hidraw_open()
304 list->hidraw = hidraw_table[minor]; hidraw_open()
306 spin_lock_irqsave(&hidraw_table[minor]->list_lock, flags); hidraw_open()
307 list_add_tail(&list->node, &hidraw_table[minor]->list); hidraw_open()
308 spin_unlock_irqrestore(&hidraw_table[minor]->list_lock, flags); hidraw_open()
335 MKDEV(hidraw_major, hidraw->minor)); drop_ref()
341 hidraw_table[hidraw->minor] = NULL; drop_ref()
353 unsigned int minor = iminor(inode); hidraw_release() local
359 spin_lock_irqsave(&hidraw_table[minor]->list_lock, flags); hidraw_release()
361 spin_unlock_irqrestore(&hidraw_table[minor]->list_lock, flags); hidraw_release()
364 drop_ref(hidraw_table[minor], 0); hidraw_release()
374 unsigned int minor = iminor(inode); hidraw_ioctl() local
380 dev = hidraw_table[minor]; hidraw_ioctl()
516 int minor, result; hidraw_connect() local
529 for (minor = 0; minor < HIDRAW_MAX_DEVICES; minor++) { hidraw_connect()
530 if (hidraw_table[minor]) hidraw_connect()
532 hidraw_table[minor] = dev; hidraw_connect()
543 dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor), hidraw_connect()
544 NULL, "%s%d", "hidraw", minor); hidraw_connect()
547 hidraw_table[minor] = NULL; hidraw_connect()
559 dev->minor = minor; hidraw_connect()
H A Dhid-thingm.c67 char minor; member in struct:thingm_device::__anon4657
118 tdev->version.minor = buf[4]; thingm_version()
157 const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor; thingm_init_rgb() local
162 "thingm%d:red:led%d", minor, rgb->num); thingm_init_rgb()
174 "thingm%d:green:led%d", minor, rgb->num); thingm_init_rgb()
186 "thingm%d:blue:led%d", minor, rgb->num); thingm_init_rgb()
245 tdev->version.major, tdev->version.minor); thingm_probe()
/linux-4.1.27/drivers/media/rc/
H A Dlirc_dev.c78 ir->d.minor = NOPLUG; lirc_irctl_init()
83 dev_dbg(ir->d.dev, LOGHEAD "cleaning up\n", ir->d.name, ir->d.minor); lirc_irctl_cleanup()
85 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor)); lirc_irctl_cleanup()
131 ir->d.name, ir->d.minor); lirc_thread()
150 ir->d.name, ir->d.minor); lirc_thread()
187 retval = kobject_set_name(&cdev->kobj, "lirc%d", d->minor); lirc_cdev_add()
191 retval = cdev_add(cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1); lirc_cdev_add()
209 int minor; lirc_register_driver() local
228 if (MAX_IRCTL_DEVICES <= d->minor) { lirc_register_driver()
230 "\"minor\" must be between 0 and %d (%d)!\n", lirc_register_driver()
231 MAX_IRCTL_DEVICES - 1, d->minor); lirc_register_driver()
238 "code length in bits for minor (%d) " lirc_register_driver()
240 d->minor, BUFLEN * 8); lirc_register_driver()
278 minor = d->minor; lirc_register_driver()
280 if (minor < 0) { lirc_register_driver()
282 for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++) lirc_register_driver()
283 if (!irctls[minor]) lirc_register_driver()
285 if (MAX_IRCTL_DEVICES == minor) { lirc_register_driver()
291 } else if (irctls[minor]) { lirc_register_driver()
293 "minor (%d) just registered!\n", minor); lirc_register_driver()
304 irctls[minor] = ir; lirc_register_driver()
305 d->minor = minor; lirc_register_driver()
344 MKDEV(MAJOR(lirc_base_dev), ir->d.minor), NULL, lirc_register_driver()
345 "lirc%u", ir->d.minor); lirc_register_driver()
352 "cannot run poll thread for minor = %d\n", lirc_register_driver()
353 d->minor); lirc_register_driver()
366 dev_info(ir->d.dev, "lirc_dev: driver %s registered at minor = %d\n", lirc_register_driver()
367 ir->d.name, ir->d.minor); lirc_register_driver()
368 return minor; lirc_register_driver()
371 device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor)); lirc_register_driver()
379 int lirc_unregister_driver(int minor) lirc_unregister_driver() argument
384 if (minor < 0 || minor >= MAX_IRCTL_DEVICES) { lirc_unregister_driver()
385 printk(KERN_ERR "lirc_dev: %s: minor (%d) must be between " lirc_unregister_driver()
386 "0 and %d!\n", __func__, minor, MAX_IRCTL_DEVICES - 1); lirc_unregister_driver()
390 ir = irctls[minor]; lirc_unregister_driver()
393 "for minor %d!\n", __func__, minor); lirc_unregister_driver()
401 if (ir->d.minor != minor) { lirc_unregister_driver()
402 printk(KERN_ERR "lirc_dev: %s: minor (%d) device not " lirc_unregister_driver()
403 "registered!\n", __func__, minor); lirc_unregister_driver()
412 dev_dbg(ir->d.dev, "lirc_dev: driver %s unregistered from minor = %d\n", lirc_unregister_driver()
413 ir->d.name, ir->d.minor); lirc_unregister_driver()
418 ir->d.name, ir->d.minor); lirc_unregister_driver()
429 irctls[minor] = NULL; lirc_unregister_driver()
459 dev_dbg(ir->d.dev, LOGHEAD "open called\n", ir->d.name, ir->d.minor); lirc_dev_fop_open()
461 if (ir->d.minor == NOPLUG) { lirc_dev_fop_open()
495 ir->d.name, ir->d.minor, retval); lirc_dev_fop_open()
517 dev_dbg(ir->d.dev, LOGHEAD "close called\n", ir->d.name, ir->d.minor); lirc_dev_fop_close()
530 irctls[ir->d.minor] = NULL; lirc_dev_fop_close()
551 dev_dbg(ir->d.dev, LOGHEAD "poll called\n", ir->d.name, ir->d.minor); lirc_dev_fop_poll()
567 ir->d.name, ir->d.minor, ret); lirc_dev_fop_poll()
585 ir->d.name, ir->d.minor, cmd); lirc_dev_fop_ioctl()
587 if (ir->d.minor == NOPLUG || !ir->attached) { lirc_dev_fop_ioctl()
589 ir->d.name, ir->d.minor); lirc_dev_fop_ioctl()
649 ir->d.name, ir->d.minor, result); lirc_dev_fop_ioctl()
672 dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor); lirc_dev_fop_read()
756 ir->d.name, ir->d.minor, ret ? "<fail>" : "<ok>", ret); lirc_dev_fop_read()
779 dev_dbg(ir->d.dev, LOGHEAD "write called\n", ir->d.name, ir->d.minor); lirc_dev_fop_write()
H A Dir-rx51.c406 .minor = -1,
452 lirc_rx51_driver.minor = lirc_register_driver(&lirc_rx51_driver); lirc_rx51_probe()
455 if (lirc_rx51_driver.minor < 0) { lirc_rx51_probe()
457 lirc_rx51_driver.minor); lirc_rx51_probe()
458 return lirc_rx51_driver.minor; lirc_rx51_probe()
460 dev_info(lirc_rx51.dev, "registration ok, minor: %d, pwm: %d\n", lirc_rx51_probe()
461 lirc_rx51_driver.minor, lirc_rx51.pwm_timer_num); lirc_rx51_probe()
468 return lirc_unregister_driver(lirc_rx51_driver.minor); lirc_rx51_remove()
/linux-4.1.27/drivers/tty/
H A Dtty_audit.c19 int major, minor; /* The TTY which the data is from */ member in struct:tty_audit_buf
25 static struct tty_audit_buf *tty_audit_buf_alloc(int major, int minor, tty_audit_buf_alloc() argument
39 buf->minor = minor; tty_audit_buf_alloc()
63 static void tty_audit_log(const char *description, int major, int minor, tty_audit_log() argument
78 " minor=%d comm=", description, pid, uid, tty_audit_log()
79 loginuid, sessionid, major, minor); tty_audit_log()
102 tty_audit_log("tty", buf->major, buf->minor, buf->data, buf->valid); tty_audit_buf_push()
145 int major, minor, should_audit; tty_audit_tiocsti() local
156 minor = tty->driver->minor_start + tty->index; tty_audit_tiocsti()
159 if (buf->major == major && buf->minor == minor) tty_audit_tiocsti()
171 tty_audit_log("ioctl=TIOCSTI", major, minor, &ch, 1); tty_audit_tiocsti()
272 int major, minor; tty_audit_add_data() local
295 minor = tty->driver->minor_start + tty->index; tty_audit_add_data()
296 if (buf->major != major || buf->minor != minor tty_audit_add_data()
300 buf->minor = minor; tty_audit_add_data()
341 int major, minor; tty_audit_push() local
344 minor = tty->driver->minor_start + tty->index; tty_audit_push()
346 if (buf->major == major && buf->minor == minor) tty_audit_push()
/linux-4.1.27/init/
H A Ddo_mounts_md.c34 int minor; member in struct:__anon13948
65 int minor, level, factor, fault, partitioned = 0; md_setup() local
74 if (get_option(&str, &minor) != 2) { /* MD Number */ md_setup()
80 if (md_setup_args[ent].minor == minor && md_setup()
83 "Replacing previous definition.\n", partitioned?"d":"", minor); md_setup()
87 printk(KERN_WARNING "md: md=%s%d - too many md initialisations\n", partitioned?"d":"", minor); md_setup()
118 minor, pername, str); md_setup()
121 md_setup_args[ent].minor = minor; md_setup()
128 int minor, i, ent, partitioned; md_setup_drive() local
139 minor = md_setup_args[ent].minor; md_setup_drive()
143 sprintf(name, "/dev/md%s%d", partitioned?"_d":"", minor); md_setup_drive()
145 dev = MKDEV(mdp_major, minor << MdpMinorShift); md_setup_drive()
147 dev = MKDEV(MD_MAJOR, minor); md_setup_drive()
180 partitioned ? "_d" : "", minor, md_setup_drive()
192 minor); md_setup_drive()
206 ainfo.md_minor =minor; md_setup_drive()
221 dinfo.minor = MINOR(dev); md_setup_drive()
231 dinfo.minor = MINOR(dev); md_setup_drive()
238 printk(KERN_WARNING "md: starting md%d failed\n", minor); md_setup_drive()
H A Dinitramfs.c57 int ino, minor, major; member in struct:hash
63 static inline int hash(int major, int minor, int ino) hash() argument
65 unsigned long tmp = ino + minor + (major << 3); hash()
70 static char __init *find_link(int major, int minor, int ino, find_link() argument
74 for (p = head + hash(major, minor, ino); *p; p = &(*p)->next) { find_link()
77 if ((*p)->minor != minor) find_link()
89 q->minor = minor; find_link()
155 static __initdata unsigned long ino, major, minor, nlink; variable
181 minor = parsed[8]; parse_header()
305 char *old = find_link(major, minor, ino, mode, collected); maybe_link()
/linux-4.1.27/arch/cris/include/uapi/asm/
H A Detraxgpio.h3 * GPIO_MAJOR (120) and a couple of minor numbers.
6 * /dev/gpioa minor 0, 8 bit GPIO, each bit can change direction
7 * /dev/gpiob minor 1, 8 bit GPIO, each bit can change direction
8 * /dev/leds minor 2, Access to leds depending on kernelconfig
9 * /dev/gpiog minor 3
16 * /dev/gpioa minor 0, 8 bit GPIO, each bit can change direction
17 * /dev/gpiob minor 1, 18 bit GPIO, each bit can change direction
18 * /dev/gpioc minor 3, 18 bit GPIO, each bit can change direction
19 * /dev/gpiod minor 4, 18 bit GPIO, each bit can change direction
20 * /dev/gpioe minor 5, 18 bit GPIO, each bit can change direction
21 * /dev/leds minor 2, Access to leds depending on kernelconfig
24 * /dev/gpioa minor 0, 32 bit GPIO, each bit can change direction
25 * /dev/gpiob minor 1, 32 bit GPIO, each bit can change direction
26 * /dev/gpioc minor 3, 16 bit GPIO, each bit can change direction
27 * /dev/gpiod minor 4, 32 bit GPIO, input only
28 * /dev/leds minor 2, Access to leds depending on kernelconfig
29 * /dev/pwm0 minor 16, PWM channel 0 on PA30
30 * /dev/pwm1 minor 17, PWM channel 1 on PA31
31 * /dev/pwm2 minor 18, PWM channel 2 on PB26
32 * /dev/ppwm minor 19, PPWM channel
/linux-4.1.27/security/keys/encrypted-keys/
H A Decryptfs_format.c33 void ecryptfs_get_versions(int *major, int *minor, int *file_version) ecryptfs_get_versions() argument
36 *minor = ECRYPTFS_VERSION_MINOR; ecryptfs_get_versions()
53 int major, minor; ecryptfs_fill_auth_tok() local
55 ecryptfs_get_versions(&major, &minor, NULL); ecryptfs_fill_auth_tok()
57 | ((uint16_t)minor & 0x00FF)); ecryptfs_fill_auth_tok()
H A Decryptfs_format.h26 void ecryptfs_get_versions(int *major, int *minor, int *file_version);
/linux-4.1.27/drivers/staging/vme/devices/
H A Dvme_user.c160 unsigned int minor; member in struct:vme_user_vma_priv
187 unsigned int minor = MINOR(inode->i_rdev); vme_user_open() local
189 mutex_lock(&image[minor].mutex); vme_user_open()
191 if (minor < CONTROL_MINOR && image[minor].resource == NULL) { vme_user_open()
198 image[minor].users++; vme_user_open()
200 mutex_unlock(&image[minor].mutex); vme_user_open()
205 mutex_unlock(&image[minor].mutex); vme_user_open()
212 unsigned int minor = MINOR(inode->i_rdev); vme_user_release() local
214 mutex_lock(&image[minor].mutex); vme_user_release()
217 image[minor].users--; vme_user_release()
219 mutex_unlock(&image[minor].mutex); vme_user_release()
230 static ssize_t resource_to_user(int minor, char __user *buf, size_t count, resource_to_user() argument
236 if (count <= image[minor].size_buf) { resource_to_user()
238 copied = vme_master_read(image[minor].resource, resource_to_user()
239 image[minor].kern_buf, count, *ppos); resource_to_user()
243 retval = __copy_to_user(buf, image[minor].kern_buf, resource_to_user()
269 static ssize_t resource_from_user(unsigned int minor, const char __user *buf, resource_from_user() argument
275 if (count <= image[minor].size_buf) { resource_from_user()
276 retval = __copy_from_user(image[minor].kern_buf, buf, resource_from_user()
283 copied = vme_master_write(image[minor].resource, resource_from_user()
284 image[minor].kern_buf, copied, *ppos); resource_from_user()
297 static ssize_t buffer_to_user(unsigned int minor, char __user *buf, buffer_to_user() argument
303 image_ptr = image[minor].kern_buf + *ppos; buffer_to_user()
316 static ssize_t buffer_from_user(unsigned int minor, const char __user *buf, buffer_from_user() argument
322 image_ptr = image[minor].kern_buf + *ppos; buffer_from_user()
338 unsigned int minor = MINOR(file_inode(file)->i_rdev); vme_user_read() local
343 if (minor == CONTROL_MINOR) vme_user_read()
346 mutex_lock(&image[minor].mutex); vme_user_read()
349 image_size = vme_get_size(image[minor].resource); vme_user_read()
353 mutex_unlock(&image[minor].mutex); vme_user_read()
363 switch (type[minor]) { vme_user_read()
365 retval = resource_to_user(minor, buf, okcount, ppos); vme_user_read()
368 retval = buffer_to_user(minor, buf, okcount, ppos); vme_user_read()
374 mutex_unlock(&image[minor].mutex); vme_user_read()
384 unsigned int minor = MINOR(file_inode(file)->i_rdev); vme_user_write() local
389 if (minor == CONTROL_MINOR) vme_user_write()
392 mutex_lock(&image[minor].mutex); vme_user_write()
394 image_size = vme_get_size(image[minor].resource); vme_user_write()
398 mutex_unlock(&image[minor].mutex); vme_user_write()
408 switch (type[minor]) { vme_user_write()
410 retval = resource_from_user(minor, buf, okcount, ppos); vme_user_write()
413 retval = buffer_from_user(minor, buf, okcount, ppos); vme_user_write()
419 mutex_unlock(&image[minor].mutex); vme_user_write()
429 unsigned int minor = MINOR(file_inode(file)->i_rdev); vme_user_llseek() local
433 if (minor == CONTROL_MINOR) vme_user_llseek()
436 mutex_lock(&image[minor].mutex); vme_user_llseek()
437 image_size = vme_get_size(image[minor].resource); vme_user_llseek()
439 mutex_unlock(&image[minor].mutex); vme_user_llseek()
461 unsigned int minor = MINOR(inode->i_rdev); vme_user_ioctl() local
468 switch (type[minor]) { vme_user_ioctl()
492 retval = vme_master_get(image[minor].resource, vme_user_ioctl()
508 if (image[minor].mmap_count != 0) { vme_user_ioctl()
522 return vme_master_set(image[minor].resource, vme_user_ioctl()
537 retval = vme_slave_get(image[minor].resource, vme_user_ioctl()
562 return vme_slave_set(image[minor].resource, vme_user_ioctl()
564 image[minor].pci_buf, slave.aspace, vme_user_ioctl()
580 unsigned int minor = MINOR(inode->i_rdev); vme_user_unlocked_ioctl() local
582 mutex_lock(&image[minor].mutex); vme_user_unlocked_ioctl()
584 mutex_unlock(&image[minor].mutex); vme_user_unlocked_ioctl()
599 unsigned int minor = vma_priv->minor; vme_user_vm_close() local
604 mutex_lock(&image[minor].mutex); vme_user_vm_close()
605 image[minor].mmap_count--; vme_user_vm_close()
606 mutex_unlock(&image[minor].mutex); vme_user_vm_close()
611 static int vme_user_master_mmap(unsigned int minor, struct vm_area_struct *vma) vme_user_master_mmap() argument
616 mutex_lock(&image[minor].mutex); vme_user_master_mmap()
618 err = vme_master_mmap(image[minor].resource, vma); vme_user_master_mmap()
620 mutex_unlock(&image[minor].mutex); vme_user_master_mmap()
626 mutex_unlock(&image[minor].mutex); vme_user_master_mmap()
630 vma_priv->minor = minor; vme_user_master_mmap()
635 image[minor].mmap_count++; vme_user_master_mmap()
637 mutex_unlock(&image[minor].mutex); vme_user_master_mmap()
644 unsigned int minor = MINOR(file_inode(file)->i_rdev); vme_user_mmap() local
646 if (type[minor] == MASTER_MINOR) vme_user_mmap()
647 return vme_user_master_mmap(minor, vma); vme_user_mmap()
769 /* Assign major and minor numbers for the driver */ vme_user_probe()
942 /* Unregiser the major and minor device numbers */ vme_user_remove()
/linux-4.1.27/arch/cris/arch-v32/drivers/mach-fs/
H A Dgpio.c97 int minor; member in struct:gpio_private
190 if (priv->minor == GPIO_MINOR_A) { gpio_poll()
243 } else if (priv->minor <= GPIO_MINOR_E) gpio_poll()
244 data = *data_in[priv->minor]; gpio_poll()
265 if (priv->minor == GPIO_MINOR_V) etrax_gpio_wake_up_check()
268 data = *data_in[priv->minor]; etrax_gpio_wake_up_check()
269 if (priv->minor == GPIO_MINOR_A) etrax_gpio_wake_up_check()
273 data = *data_in[priv->minor]; etrax_gpio_wake_up_check()
278 "etrax_gpio_wake_up_check %i\n", priv->minor)); etrax_gpio_wake_up_check()
364 if (priv->minor == GPIO_MINOR_V) gpio_write()
367 if (priv->minor == GPIO_MINOR_LEDS) gpio_write()
381 port = data_out[priv->minor]; gpio_write()
435 priv->minor = p; gpio_open()
487 if (p->minor == GPIO_MINOR_A) { gpio_release()
529 dir_shadow = *dir_oe[priv->minor]; setget_input()
530 dir_shadow &= ~(arg & changeable_dir[priv->minor]); setget_input()
531 *dir_oe[priv->minor] = dir_shadow; setget_input()
534 if (priv->minor == GPIO_MINOR_A) setget_input()
537 else if (priv->minor == GPIO_MINOR_V) setget_input()
552 dir_shadow = *dir_oe[priv->minor]; setget_output()
553 dir_shadow |= (arg & changeable_dir[priv->minor]); setget_output()
554 *dir_oe[priv->minor] = dir_shadow; setget_output()
572 if (priv->minor == GPIO_MINOR_V) gpio_ioctl_unlocked()
579 return *data_in[priv->minor]; gpio_ioctl_unlocked()
584 shadow = *data_out[priv->minor]; gpio_ioctl_unlocked()
585 shadow |= (arg & changeable_bits[priv->minor]); gpio_ioctl_unlocked()
586 *data_out[priv->minor] = shadow; gpio_ioctl_unlocked()
592 shadow = *data_out[priv->minor]; gpio_ioctl_unlocked()
593 shadow &= ~(arg & changeable_bits[priv->minor]); gpio_ioctl_unlocked()
594 *data_out[priv->minor] = shadow; gpio_ioctl_unlocked()
602 if (priv->minor == GPIO_MINOR_A) gpio_ioctl_unlocked()
611 if (priv->minor == GPIO_MINOR_A) gpio_ioctl_unlocked()
620 if (priv->minor == GPIO_MINOR_A) { gpio_ioctl_unlocked()
630 return *dir_oe[priv->minor]; gpio_ioctl_unlocked()
646 dir_shadow = *dir_oe[priv->minor]; gpio_ioctl_unlocked()
654 if (!((priv->clk_mask & changeable_bits[priv->minor]) && gpio_ioctl_unlocked()
655 (priv->data_mask & changeable_bits[priv->minor]) && gpio_ioctl_unlocked()
666 val = *data_in[priv->minor]; gpio_ioctl_unlocked()
673 val = *data_out[priv->minor]; gpio_ioctl_unlocked()
698 if (priv->minor == GPIO_MINOR_LEDS) gpio_ioctl_unlocked()
732 shadow |= ~*dir_oe[priv->minor]; virtual_gpio_ioctl()
733 shadow |= (arg & changeable_bits[priv->minor]); virtual_gpio_ioctl()
741 shadow |= ~*dir_oe[priv->minor]; virtual_gpio_ioctl()
742 shadow &= ~(arg & changeable_bits[priv->minor]); virtual_gpio_ioctl()
770 dir_shadow = *dir_oe[priv->minor]; virtual_gpio_ioctl()
778 if (!((priv->clk_mask & changeable_bits[priv->minor]) && virtual_gpio_ioctl()
779 (priv->data_mask & changeable_bits[priv->minor]) && virtual_gpio_ioctl()
791 val &= ~*dir_oe[priv->minor]; virtual_gpio_ioctl()
799 val &= *dir_oe[priv->minor]; virtual_gpio_ioctl()
808 unsigned short input_mask = ~*dir_oe[priv->minor]; virtual_gpio_ioctl()
/linux-4.1.27/drivers/gpu/drm/msm/
H A Dmsm_perf.c20 * tail -f /sys/kernel/debug/dri/<minor>/gpu
206 int msm_perf_debugfs_init(struct drm_minor *minor) msm_perf_debugfs_init() argument
208 struct msm_drm_private *priv = minor->dev->dev_private; msm_perf_debugfs_init()
211 /* only create on first minor: */ msm_perf_debugfs_init()
219 perf->dev = minor->dev; msm_perf_debugfs_init()
229 minor->debugfs_root, perf, &perf_debugfs_fops); msm_perf_debugfs_init()
232 minor->debugfs_root->d_name.name); msm_perf_debugfs_init()
236 perf->node->minor = minor; msm_perf_debugfs_init()
240 mutex_lock(&minor->debugfs_lock); msm_perf_debugfs_init()
241 list_add(&perf->node->list, &minor->debugfs_list); msm_perf_debugfs_init()
242 mutex_unlock(&minor->debugfs_lock); msm_perf_debugfs_init()
247 msm_perf_debugfs_cleanup(minor); msm_perf_debugfs_init()
251 void msm_perf_debugfs_cleanup(struct drm_minor *minor) msm_perf_debugfs_cleanup() argument
253 struct msm_drm_private *priv = minor->dev->dev_private; msm_perf_debugfs_cleanup()
264 mutex_lock(&minor->debugfs_lock); msm_perf_debugfs_cleanup()
266 mutex_unlock(&minor->debugfs_lock); msm_perf_debugfs_cleanup()
H A Dmsm_rd.c20 * tail -f /sys/kernel/debug/dri/<minor>/rd > logfile.rd
208 int msm_rd_debugfs_init(struct drm_minor *minor) msm_rd_debugfs_init() argument
210 struct msm_drm_private *priv = minor->dev->dev_private; msm_rd_debugfs_init()
213 /* only create on first minor: */ msm_rd_debugfs_init()
221 rd->dev = minor->dev; msm_rd_debugfs_init()
234 minor->debugfs_root, rd, &rd_debugfs_fops); msm_rd_debugfs_init()
237 minor->debugfs_root->d_name.name); msm_rd_debugfs_init()
241 rd->node->minor = minor; msm_rd_debugfs_init()
245 mutex_lock(&minor->debugfs_lock); msm_rd_debugfs_init()
246 list_add(&rd->node->list, &minor->debugfs_list); msm_rd_debugfs_init()
247 mutex_unlock(&minor->debugfs_lock); msm_rd_debugfs_init()
252 msm_rd_debugfs_cleanup(minor); msm_rd_debugfs_init()
256 void msm_rd_debugfs_cleanup(struct drm_minor *minor) msm_rd_debugfs_cleanup() argument
258 struct msm_drm_private *priv = minor->dev->dev_private; msm_rd_debugfs_cleanup()
269 mutex_lock(&minor->debugfs_lock); msm_rd_debugfs_cleanup()
271 mutex_unlock(&minor->debugfs_lock); msm_rd_debugfs_cleanup()
H A Dmsm_drv.c550 struct drm_device *dev = node->minor->dev; show_locked()
573 static int late_init_minor(struct drm_minor *minor) late_init_minor() argument
577 if (!minor) late_init_minor()
580 ret = msm_rd_debugfs_init(minor); late_init_minor()
582 dev_err(minor->dev->dev, "could not install rd debugfs\n"); late_init_minor()
586 ret = msm_perf_debugfs_init(minor); late_init_minor()
588 dev_err(minor->dev->dev, "could not install perf debugfs\n"); late_init_minor()
608 static int msm_debugfs_init(struct drm_minor *minor) msm_debugfs_init() argument
610 struct drm_device *dev = minor->dev; msm_debugfs_init()
615 minor->debugfs_root, minor); msm_debugfs_init()
625 static void msm_debugfs_cleanup(struct drm_minor *minor) msm_debugfs_cleanup() argument
628 ARRAY_SIZE(msm_debugfs_list), minor); msm_debugfs_cleanup()
629 if (!minor->dev->dev_private) msm_debugfs_cleanup()
631 msm_rd_debugfs_cleanup(minor); msm_debugfs_cleanup()
632 msm_perf_debugfs_cleanup(minor); msm_debugfs_cleanup()
929 .minor = 0,
/linux-4.1.27/drivers/gpu/drm/qxl/
H A Dqxl_debugfs.c43 struct qxl_device *qdev = node->minor->dev->dev_private; qxl_debugfs_irq_received()
57 struct qxl_device *qdev = node->minor->dev->dev_private; qxl_debugfs_buffers_info()
84 qxl_debugfs_init(struct drm_minor *minor) qxl_debugfs_init() argument
88 minor->debugfs_root, minor); qxl_debugfs_init()
94 qxl_debugfs_takedown(struct drm_minor *minor) qxl_debugfs_takedown() argument
98 minor); qxl_debugfs_takedown()
/linux-4.1.27/include/trace/events/
H A Dv4l2.h97 TP_PROTO(int minor, struct v4l2_buffer *buf), \
99 TP_ARGS(minor, buf), \
102 __field(int, minor) \
123 __entry->minor = minor; \
151 TP_printk("minor = %d, index = %u, type = %s, " \
157 "sequence = %u", __entry->minor, \
/linux-4.1.27/arch/sh/boards/mach-landisk/
H A Dgio.c26 #define GIO_MINOR 2 /* GIO minor no. */
34 int minor; gio_open() local
38 minor = MINOR(inode->i_rdev); gio_open()
39 if (minor < DEVCOUNT) { gio_open()
53 int minor; gio_close() local
55 minor = MINOR(inode->i_rdev); gio_close()
56 if (minor < DEVCOUNT) { gio_close()
/linux-4.1.27/fs/f2fs/
H A Dtrace.c29 last_io.major, last_io.minor, __print_last_io()
87 int major, minor; f2fs_trace_ios() local
98 minor = MINOR(inode->i_sb->s_dev); f2fs_trace_ios()
100 if (last_io.major == major && last_io.minor == minor && f2fs_trace_ios()
112 last_io.minor = minor; f2fs_trace_ios()
H A Dtrace.h28 int major, minor; member in struct:last_io_info
/linux-4.1.27/drivers/usb/serial/
H A Dbus.c47 int minor; usb_serial_device_probe() local
65 minor = port->minor; usb_serial_device_probe()
66 tty_dev = tty_register_device(usb_serial_tty_driver, minor, dev); usb_serial_device_probe()
76 driver->description, minor); usb_serial_device_probe()
94 int minor; usb_serial_device_remove() local
109 minor = port->minor; usb_serial_device_remove()
110 tty_unregister_device(usb_serial_tty_driver, minor); usb_serial_device_remove()
117 driver->description, minor); usb_serial_device_remove()
H A Dusb-serial.c65 struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor) usb_serial_port_get_by_minor() argument
71 port = idr_find(&serial_minors, minor); usb_serial_port_get_by_minor()
92 int minor; allocate_minors() local
99 minor = idr_alloc(&serial_minors, port, 0, 0, GFP_KERNEL); allocate_minors()
100 if (minor < 0) allocate_minors()
102 port->minor = minor; allocate_minors()
111 idr_remove(&serial_minors, serial->port[j]->minor); allocate_minors()
113 return minor; allocate_minors()
122 idr_remove(&serial_minors, serial->port[i]->minor); release_minors()
135 /* return the minor range that this device had */ destroy_serial()
1062 dev_err(ddev, "No more free serial minor numbers\n"); usb_serial_probe()
1069 dev_set_name(&port->dev, "ttyUSB%d", port->minor); usb_serial_probe()
1080 usb_serial_console_init(serial->port[0]->minor); usb_serial_probe()
/linux-4.1.27/drivers/staging/comedi/drivers/
H A Dcomedi_bond.c46 * within each minor will be concatenated together in the order given here.
58 unsigned minor; member in struct:bonded_device
191 int minor = it->options[i]; do_dev_config() local
197 if (minor < 0 || minor >= COMEDI_NUM_BOARD_MINORS) { do_dev_config()
199 "Minor %d is invalid!\n", minor); do_dev_config()
202 if (minor == dev->minor) { do_dev_config()
207 if (test_and_set_bit(minor, devs_opened)) { do_dev_config()
209 "Minor %d specified more than once!\n", minor); do_dev_config()
213 snprintf(file, sizeof(file), "/dev/comedi%d", minor); do_dev_config()
220 "Minor %u could not be opened\n", minor); do_dev_config()
230 "comedi_get_n_channels() returned %d on minor %u subdev %d!\n", do_dev_config()
231 nchans, minor, sdev); do_dev_config()
239 bdev->minor = minor; do_dev_config()
266 bdev->minor, bdev->subdev); do_dev_config()
336 if (!test_and_set_bit(bdev->minor, devs_closed)) bonding_detach()
H A Dunioxx5.c137 unsigned int *data, int channel, int minor) __unioxx5_digital_read()
162 unsigned int *data, int channel, int minor) __unioxx5_analog_read()
205 unsigned int *data, int channel, int minor) __unioxx5_digital_write()
236 unsigned int *data, int channel, int minor) __unioxx5_analog_write()
254 /* saving minor byte */ __unioxx5_analog_write()
286 if (!__unioxx5_digital_read(subdev, data, channel, dev->minor)) unioxx5_subdev_read()
289 if (!__unioxx5_analog_read(subdev, data, channel, dev->minor)) unioxx5_subdev_read()
308 if (!__unioxx5_digital_write(subdev, data, channel, dev->minor)) unioxx5_subdev_write()
311 if (!__unioxx5_analog_write(subdev, data, channel, dev->minor)) unioxx5_subdev_write()
136 __unioxx5_digital_read(struct comedi_subdevice *s, unsigned int *data, int channel, int minor) __unioxx5_digital_read() argument
161 __unioxx5_analog_read(struct comedi_subdevice *s, unsigned int *data, int channel, int minor) __unioxx5_analog_read() argument
204 __unioxx5_digital_write(struct comedi_subdevice *s, unsigned int *data, int channel, int minor) __unioxx5_digital_write() argument
235 __unioxx5_analog_write(struct comedi_subdevice *s, unsigned int *data, int channel, int minor) __unioxx5_analog_write() argument
/linux-4.1.27/drivers/media/
H A Dmedia-devnode.c66 /* Delete the cdev on this minor as well */ media_devnode_release()
70 clear_bit(mdev->minor, media_devnode_nums); media_devnode_release()
224 * The registration code assigns minor numbers and registers the new device node
225 * with the kernel. An error is returned if no free minor number can be found,
237 int minor; media_devnode_register() local
240 /* Part 1: Find a free minor number */ media_devnode_register()
242 minor = find_next_zero_bit(media_devnode_nums, MEDIA_NUM_DEVICES, 0); media_devnode_register()
243 if (minor == MEDIA_NUM_DEVICES) { media_devnode_register()
245 pr_err("could not get a free minor\n"); media_devnode_register()
249 set_bit(minor, media_devnode_nums); media_devnode_register()
252 mdev->minor = minor; media_devnode_register()
258 ret = cdev_add(&mdev->cdev, MKDEV(MAJOR(media_dev_t), mdev->minor), 1); media_devnode_register()
266 mdev->dev.devt = MKDEV(MAJOR(media_dev_t), mdev->minor); media_devnode_register()
270 dev_set_name(&mdev->dev, "media%d", mdev->minor); media_devnode_register()
277 /* Part 4: Activate this minor. The char device can now be used. */ media_devnode_register()
284 clear_bit(mdev->minor, media_devnode_nums); media_devnode_register()
/linux-4.1.27/arch/mips/kernel/
H A Drtlx.c339 int minor = iminor(file_inode(file)); file_poll() local
342 poll_wait(file, &channel_wqs[minor].rt_queue, wait); file_poll()
343 poll_wait(file, &channel_wqs[minor].lx_queue, wait); file_poll()
349 if (rtlx_read_poll(minor, 0)) file_poll()
353 if (rtlx_write_poll(minor)) file_poll()
362 int minor = iminor(file_inode(file)); file_read() local
365 if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) file_read()
368 return rtlx_read(minor, buffer, count); file_read()
374 int minor = iminor(file_inode(file)); file_write() local
377 if (!rtlx_write_poll(minor)) { file_write()
383 ret = __wait_event_interruptible(channel_wqs[minor].rt_queue, file_write()
384 rtlx_write_poll(minor)); file_write()
389 return rtlx_write(minor, buffer, count); file_write()
/linux-4.1.27/arch/cris/arch-v32/drivers/mach-a3/
H A Dgpio.c95 int minor; member in struct:gpio_private
202 if (priv->minor < GPIO_MINOR_LEDS) gpio_set_alarm()
203 pin += priv->minor * 4; gpio_set_alarm()
205 pin += (priv->minor - 1) * 4; gpio_set_alarm()
234 if (priv->minor >= GPIO_MINOR_PWM0 && gpio_poll()
235 priv->minor <= GPIO_MINOR_LAST_PWM) gpio_poll()
239 if (priv->minor <= GPIO_MINOR_D) { gpio_poll()
240 data = readl(data_in[priv->minor]); gpio_poll()
349 if (priv->minor == GPIO_MINOR_V) gpio_write()
352 if (priv->minor == GPIO_MINOR_LEDS) gpio_write()
355 if (priv->minor >= GPIO_MINOR_PWM0 && gpio_write()
356 priv->minor <= GPIO_MINOR_LAST_PWM) gpio_write()
374 gpio_write_byte(priv, data_out[priv->minor], *buf++); gpio_write()
397 priv->minor = p; gpio_open()
432 if (todel->minor <= GPIO_MINOR_LAST) { gpio_release()
449 if (p->minor == GPIO_MINOR_A) { gpio_release()
488 dir_shadow = readl(dir_oe[priv->minor]) & setget_input()
489 ~(arg & changeable_dir[priv->minor]); setget_input()
490 writel(dir_shadow, dir_oe[priv->minor]); setget_input()
494 if (priv->minor == GPIO_MINOR_C) setget_input()
497 else if (priv->minor == GPIO_MINOR_V) setget_input()
515 dir_shadow = readl(dir_oe[priv->minor]) | setget_output()
516 (arg & changeable_dir[priv->minor]); setget_output()
517 writel(dir_shadow, dir_oe[priv->minor]); setget_output()
537 if (priv->minor == GPIO_MINOR_V) gpio_ioctl_unlocked()
541 if (priv->minor == GPIO_MINOR_LEDS) gpio_ioctl_unlocked()
544 if (priv->minor >= GPIO_MINOR_PWM0 && gpio_ioctl_unlocked()
545 priv->minor <= GPIO_MINOR_LAST_PWM) gpio_ioctl_unlocked()
551 return readl(data_in[priv->minor]); gpio_ioctl_unlocked()
555 shadow = readl(data_out[priv->minor]) | gpio_ioctl_unlocked()
556 (arg & changeable_bits[priv->minor]); gpio_ioctl_unlocked()
557 writel(shadow, data_out[priv->minor]); gpio_ioctl_unlocked()
563 shadow = readl(data_out[priv->minor]) & gpio_ioctl_unlocked()
564 ~(arg & changeable_bits[priv->minor]); gpio_ioctl_unlocked()
565 writel(shadow, data_out[priv->minor]); gpio_ioctl_unlocked()
586 return readl(dir_oe[priv->minor]); gpio_ioctl_unlocked()
613 dir_shadow = readl(dir_oe[priv->minor]); gpio_ioctl_unlocked()
614 if ((clk_mask & changeable_bits[priv->minor]) && gpio_ioctl_unlocked()
615 (data_mask & changeable_bits[priv->minor]) && gpio_ioctl_unlocked()
629 val = readl(data_in[priv->minor]); gpio_ioctl_unlocked()
635 val = *data_out[priv->minor]; gpio_ioctl_unlocked()
691 shadow |= ~readl(dir_oe[priv->minor]) | virtual_gpio_ioctl()
692 (arg & changeable_bits[priv->minor]); virtual_gpio_ioctl()
700 shadow |= ~readl(dir_oe[priv->minor]) & virtual_gpio_ioctl()
701 ~(arg & changeable_bits[priv->minor]); virtual_gpio_ioctl()
721 dir_shadow = readl(dir_oe[priv->minor]); virtual_gpio_ioctl()
729 if (!((priv->clk_mask & changeable_bits[priv->minor]) && virtual_gpio_ioctl()
730 (priv->data_mask & changeable_bits[priv->minor]) && virtual_gpio_ioctl()
741 val = cached_virtual_gpio_read & ~readl(dir_oe[priv->minor]); virtual_gpio_ioctl()
749 val &= readl(dir_oe[priv->minor]); virtual_gpio_ioctl()
758 unsigned short input_mask = ~readl(dir_oe[priv->minor]); virtual_gpio_ioctl()
874 int pwm_port = priv->minor - GPIO_MINOR_PWM0; gpio_pwm_ioctl()
/linux-4.1.27/drivers/staging/dgnc/
H A Ddgnc_mgmt.c48 unsigned int minor = iminor(inode); dgnc_mgmt_open() local
53 if (minor < MAXMGMTDEVICES) { dgnc_mgmt_open()
55 if (dgnc_mgmt_in_use[minor]) { dgnc_mgmt_open()
59 dgnc_mgmt_in_use[minor]++; dgnc_mgmt_open()
79 unsigned int minor = iminor(inode); dgnc_mgmt_close() local
84 if (minor < MAXMGMTDEVICES) { dgnc_mgmt_close()
85 if (dgnc_mgmt_in_use[minor]) dgnc_mgmt_close()
86 dgnc_mgmt_in_use[minor] = 0; dgnc_mgmt_close()
/linux-4.1.27/drivers/block/aoe/
H A Daoechr.c29 ulong minor; member in struct:aoe_chardev
82 int major, minor, n; revalidate() local
94 n = sscanf(buf, "e%d.%d", &major, &minor); revalidate()
99 d = aoedev_by_aoeaddr(major, minor, 0); revalidate()
104 aoecmd_cfg(major, minor); revalidate()
198 if (chardevs[i].minor == n) { aoechr_open()
304 MKDEV(AOE_MAJOR, chardevs[i].minor), NULL, aoechr_init()
316 device_destroy(aoe_class, MKDEV(AOE_MAJOR, chardevs[i].minor)); aoechr_exit()
H A Daoedev.c24 MODULE_PARM_DESC(aoe_dyndevs, "Use dynamic minor numbers for devices.");
33 * we need some flexibility in the way the minor numbers
74 "static minor device numbers support only", minor_get_static()
83 "cannot use static minor device numbers", minor_get_static()
92 "existing device already has static minor number", minor_get_static()
113 minor_free(ulong minor) minor_free() argument
117 minor /= AOE_PARTITIONS; minor_free()
118 BUG_ON(minor >= N_DEVS); minor_free()
121 BUG_ON(!test_bit(minor, used_minors)); minor_free()
122 clear_bit(minor, used_minors); minor_free()
/linux-4.1.27/drivers/gpu/drm/nouveau/include/nvkm/subdev/
H A Dbios.h16 u8 minor; member in struct:nvkm_bios::__anon4134
/linux-4.1.27/arch/mips/include/asm/
H A Dvpe.h57 /* (device) minor associated with this vpe */
58 int minor; member in struct:vpe
116 struct vpe *get_vpe(int minor);
118 struct vpe *alloc_vpe(int minor);
/linux-4.1.27/fs/dlm/
H A Dlockspace.h21 struct dlm_ls *dlm_find_lockspace_device(int minor);
/linux-4.1.27/drivers/staging/comedi/
H A Dcomedi_fops.c69 "number of comedi minor devices to reserve for non-auto-configured devices (default 0)"
90 /* Note: indexed by minor - COMEDI_NUM_BOARD_MINORS. */
103 dev->minor = -1; comedi_device_init()
160 unsigned int i = dev->minor; comedi_clear_board_dev()
172 static struct comedi_device *comedi_clear_board_minor(unsigned minor) comedi_clear_board_minor() argument
177 dev = comedi_board_minor_table[minor]; comedi_clear_board_minor()
178 comedi_board_minor_table[minor] = NULL; comedi_clear_board_minor()
189 MKDEV(COMEDI_MAJOR, dev->minor)); comedi_free_board_dev()
196 *comedi_subdevice_from_minor(const struct comedi_device *dev, unsigned minor) comedi_subdevice_from_minor() argument
199 unsigned int i = minor - COMEDI_NUM_BOARD_MINORS; comedi_subdevice_from_minor()
210 static struct comedi_device *comedi_dev_get_from_board_minor(unsigned minor) comedi_dev_get_from_board_minor() argument
214 BUG_ON(minor >= COMEDI_NUM_BOARD_MINORS); comedi_dev_get_from_board_minor()
216 dev = comedi_dev_get(comedi_board_minor_table[minor]); comedi_dev_get_from_board_minor()
221 static struct comedi_device *comedi_dev_get_from_subdevice_minor(unsigned minor) comedi_dev_get_from_subdevice_minor() argument
225 unsigned int i = minor - COMEDI_NUM_BOARD_MINORS; comedi_dev_get_from_subdevice_minor()
236 * comedi_dev_get_from_minor - get comedi device by minor device number
237 * @minor: minor device number
239 * Finds the comedi device associated by the minor device number, if any,
245 * specified minor device number.
247 struct comedi_device *comedi_dev_get_from_minor(unsigned minor) comedi_dev_get_from_minor() argument
249 if (minor < COMEDI_NUM_BOARD_MINORS) comedi_dev_get_from_minor()
250 return comedi_dev_get_from_board_minor(minor); comedi_dev_get_from_minor()
252 return comedi_dev_get_from_subdevice_minor(minor); comedi_dev_get_from_minor()
257 comedi_read_subdevice(const struct comedi_device *dev, unsigned int minor) comedi_read_subdevice() argument
261 if (minor >= COMEDI_NUM_BOARD_MINORS) { comedi_read_subdevice()
262 s = comedi_subdevice_from_minor(dev, minor); comedi_read_subdevice()
270 comedi_write_subdevice(const struct comedi_device *dev, unsigned int minor) comedi_write_subdevice() argument
274 if (minor >= COMEDI_NUM_BOARD_MINORS) { comedi_write_subdevice()
275 s = comedi_subdevice_from_minor(dev, minor); comedi_write_subdevice()
287 unsigned int minor = iminor(file_inode(file)); comedi_file_reset() local
291 if (minor >= COMEDI_NUM_BOARD_MINORS) { comedi_file_reset()
292 s = comedi_subdevice_from_minor(dev, minor); comedi_file_reset()
373 unsigned int minor = MINOR(csdev->devt); max_read_buffer_kb_show() local
378 dev = comedi_dev_get_from_minor(minor); max_read_buffer_kb_show()
383 s = comedi_read_subdevice(dev, minor); max_read_buffer_kb_show()
396 unsigned int minor = MINOR(csdev->devt); max_read_buffer_kb_store() local
409 dev = comedi_dev_get_from_minor(minor); max_read_buffer_kb_store()
414 s = comedi_read_subdevice(dev, minor); max_read_buffer_kb_store()
429 unsigned int minor = MINOR(csdev->devt); read_buffer_kb_show() local
434 dev = comedi_dev_get_from_minor(minor); read_buffer_kb_show()
439 s = comedi_read_subdevice(dev, minor); read_buffer_kb_show()
452 unsigned int minor = MINOR(csdev->devt); read_buffer_kb_store() local
465 dev = comedi_dev_get_from_minor(minor); read_buffer_kb_store()
470 s = comedi_read_subdevice(dev, minor); read_buffer_kb_store()
486 unsigned int minor = MINOR(csdev->devt); max_write_buffer_kb_show() local
491 dev = comedi_dev_get_from_minor(minor); max_write_buffer_kb_show()
496 s = comedi_write_subdevice(dev, minor); max_write_buffer_kb_show()
509 unsigned int minor = MINOR(csdev->devt); max_write_buffer_kb_store() local
522 dev = comedi_dev_get_from_minor(minor); max_write_buffer_kb_store()
527 s = comedi_write_subdevice(dev, minor); max_write_buffer_kb_store()
542 unsigned int minor = MINOR(csdev->devt); write_buffer_kb_show() local
547 dev = comedi_dev_get_from_minor(minor); write_buffer_kb_show()
552 s = comedi_write_subdevice(dev, minor); write_buffer_kb_show()
565 unsigned int minor = MINOR(csdev->devt); write_buffer_kb_store() local
578 dev = comedi_dev_get_from_minor(minor); write_buffer_kb_store()
583 s = comedi_write_subdevice(dev, minor); write_buffer_kb_store()
812 if (dev->minor >= comedi_num_legacy_minors) do_devconfig_ioctl()
1046 x = (dev->minor << 28) | (it.subdev << 24) | (i << 16) | do_chaninfo_ioctl()
2003 unsigned minor = iminor(file_inode(file)); comedi_unlocked_ioctl() local
2015 if (minor >= COMEDI_NUM_BOARD_MINORS) { comedi_unlocked_ioctl()
2024 dev->minor >= comedi_num_legacy_minors) { comedi_unlocked_ioctl()
2553 const unsigned minor = iminor(inode); comedi_open() local
2555 struct comedi_device *dev = comedi_dev_get_from_minor(minor); comedi_open()
2559 pr_debug("invalid minor number\n"); comedi_open()
2735 "ran out of minor numbers for board device files\n"); comedi_alloc_board_minor()
2738 dev->minor = i; comedi_alloc_board_minor()
2748 static void comedi_free_board_minor(unsigned minor) comedi_free_board_minor() argument
2750 BUG_ON(minor >= COMEDI_NUM_BOARD_MINORS); comedi_free_board_minor()
2751 comedi_free_board_dev(comedi_clear_board_minor(minor)); comedi_free_board_minor()
2756 int minor; comedi_release_hardware_device() local
2759 for (minor = comedi_num_legacy_minors; minor < COMEDI_NUM_BOARD_MINORS; comedi_release_hardware_device()
2760 minor++) { comedi_release_hardware_device()
2762 dev = comedi_board_minor_table[minor]; comedi_release_hardware_device()
2764 comedi_board_minor_table[minor] = NULL; comedi_release_hardware_device()
2789 "ran out of minor numbers for subdevice files\n"); comedi_alloc_subdevice_minor()
2793 s->minor = i; comedi_alloc_subdevice_minor()
2796 dev->minor, s->index); comedi_alloc_subdevice_minor()
2809 if (s->minor < 0) comedi_free_subdevice_minor()
2812 BUG_ON(s->minor >= COMEDI_NUM_MINORS); comedi_free_subdevice_minor()
2813 BUG_ON(s->minor < COMEDI_NUM_BOARD_MINORS); comedi_free_subdevice_minor()
2815 i = s->minor - COMEDI_NUM_BOARD_MINORS; comedi_free_subdevice_minor()
2821 device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, s->minor)); comedi_free_subdevice_minor()
/linux-4.1.27/security/
H A Ddevice_cgroup.c41 u32 major, minor; member in struct:dev_exception_item
109 if (walk->minor != ex->minor) dev_exception_add()
137 if (walk->minor != ex->minor) dev_exception_rm()
298 set_majmin(min, ex->minor); devcgroup_seq_show()
313 * @minor: device file minor number, ~0 to match all
322 u32 major, u32 minor, short access) match_exception()
333 if (ex->minor != ~0 && ex->minor != minor) list_for_each_entry_rcu()
348 * @minor: device file minor number, ~0 to match all
359 u32 major, u32 minor, short access) match_exception_partial()
374 if (ex->minor != ~0 && minor != ~0 && ex->minor != minor) list_for_each_entry_rcu()
423 refex->minor, verify_new_ex()
438 refex->major, refex->minor, verify_new_ex()
493 ex->major, ex->minor, ex->access); parent_allows_removal()
682 /* read minor */ devcgroup_update_access()
684 ex.minor = ~0; devcgroup_update_access()
694 rc = kstrtou32(temp, 10, &ex.minor); devcgroup_update_access()
807 * @minor: device minor number
812 static int __devcgroup_check_permission(short type, u32 major, u32 minor, __devcgroup_check_permission() argument
823 type, major, minor, access); __devcgroup_check_permission()
827 minor, access); __devcgroup_check_permission()
321 match_exception(struct list_head *exceptions, short type, u32 major, u32 minor, short access) match_exception() argument
358 match_exception_partial(struct list_head *exceptions, short type, u32 major, u32 minor, short access) match_exception_partial() argument
/linux-4.1.27/drivers/media/dvb-core/
H A Ddvbdev.c184 int type, int minor) dvb_register_media_device()
197 dvbdev->entity->info.dev.minor = minor; dvb_register_media_device()
277 int minor; dvb_register_device() local
319 for (minor = 0; minor < MAX_DVB_MINORS; minor++) dvb_register_device()
320 if (dvb_minors[minor] == NULL) dvb_register_device()
323 if (minor == MAX_DVB_MINORS) { dvb_register_device()
331 minor = nums2minor(adap->num, type, id); dvb_register_device()
334 dvbdev->minor = minor; dvb_register_device()
335 dvb_minors[minor] = dvbdev; dvb_register_device()
341 MKDEV(DVB_MAJOR, minor), dvb_register_device()
348 dprintk(KERN_DEBUG "DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n", dvb_register_device()
349 adap->num, dnames[type], id, minor, minor); dvb_register_device()
351 dvb_register_media_device(dvbdev, type, minor); dvb_register_device()
364 dvb_minors[dvbdev->minor] = NULL; dvb_unregister_device()
367 device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor)); dvb_unregister_device()
183 dvb_register_media_device(struct dvb_device *dvbdev, int type, int minor) dvb_register_media_device() argument
/linux-4.1.27/drivers/fmc/
H A Dfmc-chardev.c34 int minor = iminor(ino); fc_open() local
37 if (fc->misc.minor == minor) fc_open()
39 if (fc->misc.minor != minor) fc_open()
142 fc->misc.minor = MISC_DYNAMIC_MINOR; fc_probe()
/linux-4.1.27/drivers/gpu/drm/msm/mdp/mdp5/
H A Dmdp5_cfg.c237 uint32_t major, uint32_t minor) mdp5_cfg_init()
253 major, minor); mdp5_cfg_init()
260 if (cfg_handlers[i].revision != minor) mdp5_cfg_init()
267 dev_err(dev->dev, "unexpected MDP minor revision: v%d.%d\n", mdp5_cfg_init()
268 major, minor); mdp5_cfg_init()
273 cfg_handler->revision = minor; mdp5_cfg_init()
236 mdp5_cfg_init(struct mdp5_kms *mdp5_kms, uint32_t major, uint32_t minor) mdp5_cfg_init() argument
H A Dmdp5_kms.c381 uint32_t *major, uint32_t *minor) read_hw_revision()
390 *minor = FIELD(version, MDSS_HW_VERSION_MINOR); read_hw_revision()
392 DBG("MDP5 version v%d.%d", *major, *minor); read_hw_revision()
415 uint32_t major, minor; mdp5_kms_init() local
483 read_hw_revision(mdp5_kms, &major, &minor); mdp5_kms_init()
485 mdp5_kms->cfg = mdp5_cfg_init(mdp5_kms, major, minor); mdp5_kms_init()
380 read_hw_revision(struct mdp5_kms *mdp5_kms, uint32_t *major, uint32_t *minor) read_hw_revision() argument
/linux-4.1.27/drivers/usb/gadget/function/
H A Du_printer.h25 int minor; member in struct:f_printer_opts
H A Du_hid.h23 int minor; member in struct:f_hid_opts
H A Df_hid.c63 int minor; member in struct:f_hidg
669 dev = MKDEV(major, hidg->minor); hidg_bind()
675 "%s%d", "hidg", hidg->minor); hidg_bind()
836 static inline void hidg_put_minor(int minor) hidg_put_minor() argument
838 ida_simple_remove(&hidg_ida, minor); hidg_put_minor()
849 hidg_put_minor(opts->minor); hidg_free_inst()
885 opts->minor = hidg_get_minor(); hidg_alloc_inst()
886 if (opts->minor < 0) { hidg_alloc_inst()
887 ret = ERR_PTR(opts->minor); hidg_alloc_inst()
918 device_destroy(hidg_class, MKDEV(major, hidg->minor)); hidg_unbind()
944 hidg->minor = opts->minor; hidg_alloc()
H A Df_printer.c89 int minor; member in struct:printer_dev
1075 devt = MKDEV(major, dev->minor); printer_func_bind()
1077 NULL, "g_printer%d", dev->minor); printer_func_bind()
1254 static inline void gprinter_put_minor(int minor) gprinter_put_minor() argument
1256 ida_simple_remove(&printer_ida, minor); gprinter_put_minor()
1270 gprinter_put_minor(opts->minor); gprinter_free_inst()
1304 opts->minor = gprinter_get_minor(); gprinter_alloc_inst()
1305 if (opts->minor < 0) { gprinter_alloc_inst()
1306 ret = ERR_PTR(opts->minor); gprinter_alloc_inst()
1340 device_destroy(usb_gadget_class, MKDEV(major, dev->minor)); printer_func_unbind()
1384 if (opts->minor >= minors) { gprinter_alloc()
1396 dev->minor = opts->minor; gprinter_alloc()
/linux-4.1.27/fs/nfs/
H A Dnetns.h14 uint32_t major, minor; member in struct:bl_dev_msg
/linux-4.1.27/include/linux/mfd/
H A Dkempld.h59 * @minor: PLD minor revision
64 * @spec_minor: PLD FW specification minor revision
69 unsigned int minor; member in struct:kempld_info
/linux-4.1.27/drivers/isdn/i4l/
H A Disdn_common.c761 * takes care that this is not called for the same minor device number while
764 * of the mapping (di,ch)<->minor, happen during the sleep? --he
874 * takes care that this is not called for the same minor device number while
877 * of the mapping (di,ch)<->minor, happen during the sleep? --he
982 isdn_minor2drv(int minor) isdn_minor2drv() argument
984 return (dev->drvmap[minor]); isdn_minor2drv()
988 isdn_minor2chan(int minor) isdn_minor2chan() argument
990 return (dev->chanmap[minor]); isdn_minor2chan()
1062 uint minor = iminor(file_inode(file)); isdn_read() local
1070 if (minor == ISDN_MINOR_STATUS) { isdn_read()
1097 if (minor <= ISDN_MINOR_BMAX) { isdn_read()
1098 printk(KERN_WARNING "isdn_read minor %d obsolete!\n", minor); isdn_read()
1099 drvidx = isdn_minor2drv(minor); isdn_read()
1108 chidx = isdn_minor2chan(minor); isdn_read()
1122 if (minor <= ISDN_MINOR_CTRLMAX) { isdn_read()
1123 drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); isdn_read()
1140 drvidx, isdn_minor2chan(minor - ISDN_MINOR_CTRL)); isdn_read()
1157 if (minor <= ISDN_MINOR_PPPMAX) { isdn_read()
1158 retval = isdn_ppp_read(minor - ISDN_MINOR_PPP, file, buf, count); isdn_read()
1171 uint minor = iminor(file_inode(file)); isdn_write() local
1176 if (minor == ISDN_MINOR_STATUS) isdn_write()
1182 if (minor <= ISDN_MINOR_BMAX) { isdn_write()
1183 printk(KERN_WARNING "isdn_write minor %d obsolete!\n", minor); isdn_write()
1184 drvidx = isdn_minor2drv(minor); isdn_write()
1193 chidx = isdn_minor2chan(minor); isdn_write()
1198 if (minor <= ISDN_MINOR_CTRLMAX) { isdn_write()
1199 drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); isdn_write()
1213 isdn_minor2chan(minor - ISDN_MINOR_CTRL)); isdn_write()
1219 if (minor <= ISDN_MINOR_PPPMAX) { isdn_write()
1220 retval = isdn_ppp_write(minor - ISDN_MINOR_PPP, file, buf, count); isdn_write()
1234 unsigned int minor = iminor(file_inode(file)); isdn_poll() local
1235 int drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); isdn_poll()
1238 if (minor == ISDN_MINOR_STATUS) { isdn_poll()
1246 if (minor >= ISDN_MINOR_CTRL && minor <= ISDN_MINOR_CTRLMAX) { isdn_poll()
1260 if (minor <= ISDN_MINOR_PPPMAX) { isdn_poll()
1275 uint minor = iminor(file_inode(file)); isdn_ioctl() local
1297 if (minor == ISDN_MINOR_STATUS) { isdn_ioctl()
1333 if (minor <= ISDN_MINOR_BMAX) { isdn_ioctl()
1334 drvidx = isdn_minor2drv(minor); isdn_ioctl()
1341 if (minor <= ISDN_MINOR_CTRLMAX) { isdn_ioctl()
1705 if (minor <= ISDN_MINOR_PPPMAX) isdn_ioctl()
1706 return (isdn_ppp_ioctl(minor - ISDN_MINOR_PPP, file, cmd, arg)); isdn_ioctl()
1735 uint minor = iminor(ino); isdn_open() local
1741 if (minor == ISDN_MINOR_STATUS) { isdn_open()
1759 if (minor <= ISDN_MINOR_BMAX) { isdn_open()
1760 printk(KERN_WARNING "isdn_open minor %d obsolete!\n", minor); isdn_open()
1761 drvidx = isdn_minor2drv(minor); isdn_open()
1764 chidx = isdn_minor2chan(minor); isdn_open()
1773 if (minor <= ISDN_MINOR_CTRLMAX) { isdn_open()
1774 drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); isdn_open()
1782 if (minor <= ISDN_MINOR_PPPMAX) { isdn_open()
1783 retval = isdn_ppp_open(minor - ISDN_MINOR_PPP, filep); isdn_open()
1798 uint minor = iminor(ino); isdn_close() local
1801 if (minor == ISDN_MINOR_STATUS) { isdn_close()
1821 if (minor <= ISDN_MINOR_BMAX) isdn_close()
1823 if (minor <= ISDN_MINOR_CTRLMAX) { isdn_close()
1829 if (minor <= ISDN_MINOR_PPPMAX) isdn_close()
1830 isdn_ppp_release(minor - ISDN_MINOR_PPP, filep); isdn_close()
/linux-4.1.27/arch/sparc/include/asm/
H A Dvio.h49 u16 minor; member in struct:vio_ver_info
353 u16 minor; member in struct:vio_version
424 u16 major, u16 minor) vio_version_before()
426 u32 have = (u32)vio->ver.major << 16 | vio->ver.minor; vio_version_before()
427 u32 want = (u32)major << 16 | minor; vio_version_before()
433 u16 major, u16 minor) vio_version_after()
435 u32 have = (u32)vio->ver.major << 16 | vio->ver.minor; vio_version_after()
436 u32 want = (u32)major << 16 | minor; vio_version_after()
442 u16 major, u16 minor) vio_version_after_eq()
444 u32 have = (u32)vio->ver.major << 16 | vio->ver.minor; vio_version_after_eq()
445 u32 want = (u32)major << 16 | minor; vio_version_after_eq()
423 vio_version_before(struct vio_driver_state *vio, u16 major, u16 minor) vio_version_before() argument
432 vio_version_after(struct vio_driver_state *vio, u16 major, u16 minor) vio_version_after() argument
441 vio_version_after_eq(struct vio_driver_state *vio, u16 major, u16 minor) vio_version_after_eq() argument
/linux-4.1.27/drivers/scsi/aic94xx/
H A Daic94xx_seq.h43 /* numeric minor version */
44 u32 minor; member in struct:sequencer_file_header
/linux-4.1.27/drivers/s390/char/
H A Draw3270.c37 int minor; member in struct:raw3270
733 int minor; raw3270_setup_device() local
758 * Add device to list and find the smallest unused minor raw3270_setup_device()
759 * number for it. Note: there is no device with minor 0, raw3270_setup_device()
764 minor = RAW3270_FIRSTMINOR; raw3270_setup_device()
765 rp->minor = -1; raw3270_setup_device()
768 if (tmp->minor > minor) { raw3270_setup_device()
769 rp->minor = minor; raw3270_setup_device()
773 minor++; raw3270_setup_device()
775 if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) { raw3270_setup_device()
776 rp->minor = minor; raw3270_setup_device()
780 /* No free minor number? Then give up. */ raw3270_setup_device()
781 if (rp->minor == -1) raw3270_setup_device()
956 * Add view to device with minor "minor".
959 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor) raw3270_add_view() argument
965 if (minor <= 0) raw3270_add_view()
970 if (rp->minor != minor) raw3270_add_view()
991 * Find specific view of device with minor "minor".
994 raw3270_find_view(struct raw3270_fn *fn, int minor) raw3270_find_view() argument
1003 if (rp->minor != minor) raw3270_find_view()
1143 notifier->create(rp->minor); raw3270_register_notifier()
1154 notifier->destroy(rp->minor); raw3270_unregister_notifier()
1178 np->create(rp->minor); raw3270_set_online()
1229 np->destroy(rp->minor); raw3270_remove()
H A Dfs3270.c434 int minor, rc = 0; fs3270_open() local
438 minor = iminor(file_inode(filp)); fs3270_open()
439 /* Check for minor 0 multiplexer. */ fs3270_open()
440 if (minor == 0) { fs3270_open()
446 minor = tty->index; fs3270_open()
451 fp = (struct fs3270 *) raw3270_find_view(&fs3270_fn, minor); fs3270_open()
466 rc = raw3270_add_view(&fp->view, &fs3270_fn, minor); fs3270_open()
527 static void fs3270_create_cb(int minor) fs3270_create_cb() argument
529 __register_chrdev(IBM_FS3270_MAJOR, minor, 1, "tub", &fs3270_fops); fs3270_create_cb()
530 device_create(class3270, NULL, MKDEV(IBM_FS3270_MAJOR, minor), fs3270_create_cb()
531 NULL, "3270/tub%d", minor); fs3270_create_cb()
534 static void fs3270_destroy_cb(int minor) fs3270_destroy_cb() argument
536 device_destroy(class3270, MKDEV(IBM_FS3270_MAJOR, minor)); fs3270_destroy_cb()
537 __unregister_chrdev(IBM_FS3270_MAJOR, minor, 1, "tub"); fs3270_destroy_cb()
H A Dvmur.h90 * Device major/minor definitions.
95 * We map minor numbers directly to device numbers (0-FFFF) for simplicity.
H A Dtape_class.h37 * The intended major/minor number. The major number may be 0 to
/linux-4.1.27/drivers/gpu/drm/i915/
H A Di915_sysfs.c306 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_act_freq_mhz_show() local
307 struct drm_device *dev = minor->dev; gt_act_freq_mhz_show()
340 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_cur_freq_mhz_show() local
341 struct drm_device *dev = minor->dev; gt_cur_freq_mhz_show()
361 struct drm_minor *minor = dev_to_drm_minor(kdev); vlv_rpe_freq_mhz_show() local
362 struct drm_device *dev = minor->dev; vlv_rpe_freq_mhz_show()
372 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_max_freq_mhz_show() local
373 struct drm_device *dev = minor->dev; gt_max_freq_mhz_show()
390 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_max_freq_mhz_store() local
391 struct drm_device *dev = minor->dev; gt_max_freq_mhz_store()
435 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_min_freq_mhz_show() local
436 struct drm_device *dev = minor->dev; gt_min_freq_mhz_show()
453 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_min_freq_mhz_store() local
454 struct drm_device *dev = minor->dev; gt_min_freq_mhz_store()
508 struct drm_minor *minor = dev_to_drm_minor(kdev); gt_rp_mhz_show() local
509 struct drm_device *dev = minor->dev; gt_rp_mhz_show()
554 struct drm_minor *minor = dev_to_drm_minor(kdev); error_state_read() local
555 struct drm_device *dev = minor->dev; error_state_read()
589 struct drm_minor *minor = dev_to_drm_minor(kdev); error_state_write() local
590 struct drm_device *dev = minor->dev; error_state_write()
H A Di915_debugfs.c55 * allocated we need to hook into the minor for release. */
57 drm_add_fake_info_node(struct drm_minor *minor, drm_add_fake_info_node() argument
69 node->minor = minor; drm_add_fake_info_node()
73 mutex_lock(&minor->debugfs_lock); drm_add_fake_info_node()
74 list_add(&node->list, &minor->debugfs_list); drm_add_fake_info_node()
75 mutex_unlock(&minor->debugfs_lock); drm_add_fake_info_node()
83 struct drm_device *dev = node->minor->dev; i915_capabilities()
190 struct drm_device *dev = node->minor->dev; i915_gem_object_list_info()
246 struct drm_device *dev = node->minor->dev; i915_gem_stolen_list_info()
405 struct drm_device *dev = node->minor->dev; i915_gem_object_info()
505 struct drm_device *dev = node->minor->dev; i915_gem_gtt_info()
540 struct drm_device *dev = node->minor->dev; i915_gem_pageflip_info()
613 struct drm_device *dev = node->minor->dev; i915_gem_batch_pool_info()
643 struct drm_device *dev = node->minor->dev; i915_gem_request_info()
688 struct drm_device *dev = node->minor->dev; i915_gem_seqno_info()
711 struct drm_device *dev = node->minor->dev; i915_interrupt_info()
897 struct drm_device *dev = node->minor->dev; i915_gem_fence_regs_info()
926 struct drm_device *dev = node->minor->dev; i915_hws_info()
1074 struct drm_device *dev = node->minor->dev; i915_frequency_info()
1242 struct drm_device *dev = node->minor->dev; i915_hangcheck_info()
1289 struct drm_device *dev = node->minor->dev; ironlake_drpc_info()
1358 struct drm_device *dev = node->minor->dev; i915_forcewake_domains()
1377 struct drm_device *dev = node->minor->dev; vlv_drpc_info()
1417 struct drm_device *dev = node->minor->dev; gen6_drpc_info()
1516 struct drm_device *dev = node->minor->dev; i915_drpc_info()
1529 struct drm_device *dev = node->minor->dev; i915_fbc_status()
1632 struct drm_device *dev = node->minor->dev; i915_ips_status()
1662 struct drm_device *dev = node->minor->dev; i915_sr_status()
1691 struct drm_device *dev = node->minor->dev; i915_emon_status()
1719 struct drm_device *dev = node->minor->dev; i915_ring_freq_table()
1762 struct drm_device *dev = node->minor->dev; i915_opregion()
1790 struct drm_device *dev = node->minor->dev; i915_gem_framebuffer_info()
1842 struct drm_device *dev = node->minor->dev; i915_context_status()
1939 struct drm_device *dev = node->minor->dev; i915_dump_lrc()
1970 struct drm_device *dev = node->minor->dev; i915_execlists()
2077 struct drm_device *dev = node->minor->dev; i915_swizzle_info()
2213 struct drm_device *dev = node->minor->dev; i915_ppgtt_info()
2235 struct drm_device *dev = node->minor->dev; i915_llc()
2248 struct drm_device *dev = node->minor->dev; i915_edp_psr_status()
2312 struct drm_device *dev = node->minor->dev; i915_sink_crc()
2352 struct drm_device *dev = node->minor->dev; i915_energy_uJ()
2378 struct drm_device *dev = node->minor->dev; i915_pc8_status()
2463 struct drm_device *dev = node->minor->dev; i915_power_domain_info()
2518 struct drm_device *dev = node->minor->dev; intel_encoder_info()
2545 struct drm_device *dev = node->minor->dev; intel_crtc_info()
2665 struct drm_device *dev = node->minor->dev; i915_display_info()
2713 struct drm_device *dev = node->minor->dev; i915_semaphore_status()
2785 struct drm_device *dev = node->minor->dev; i915_shared_dplls_info()
2814 struct drm_device *dev = node->minor->dev; i915_wa_registers()
2846 struct drm_device *dev = node->minor->dev; i915_ddb_info()
2968 struct drm_device *dev = node->minor->dev; i915_drrs_status()
3000 struct drm_device *dev = node->minor->dev; i915_dp_mst_info()
3169 static int i915_pipe_crc_create(struct dentry *root, struct drm_minor *minor, i915_pipe_crc_create() argument
3172 struct drm_device *dev = minor->dev; i915_pipe_crc_create()
3182 return drm_add_fake_info_node(minor, ent, info); i915_pipe_crc_create()
4479 struct drm_device *dev = node->minor->dev; i915_sseu_status()
4616 static int i915_forcewake_create(struct dentry *root, struct drm_minor *minor) i915_forcewake_create() argument
4618 struct drm_device *dev = minor->dev; i915_forcewake_create()
4628 return drm_add_fake_info_node(minor, ent, &i915_forcewake_fops); i915_forcewake_create()
4632 struct drm_minor *minor, i915_debugfs_create()
4636 struct drm_device *dev = minor->dev; i915_debugfs_create()
4646 return drm_add_fake_info_node(minor, ent, fops); i915_debugfs_create()
4735 int i915_debugfs_init(struct drm_minor *minor) i915_debugfs_init() argument
4739 ret = i915_forcewake_create(minor->debugfs_root, minor); i915_debugfs_init()
4744 ret = i915_pipe_crc_create(minor->debugfs_root, minor, i); i915_debugfs_init()
4750 ret = i915_debugfs_create(minor->debugfs_root, minor, i915_debugfs_init()
4759 minor->debugfs_root, minor); i915_debugfs_init()
4762 void i915_debugfs_cleanup(struct drm_minor *minor) i915_debugfs_cleanup() argument
4767 I915_DEBUGFS_ENTRIES, minor); i915_debugfs_cleanup()
4770 1, minor); i915_debugfs_cleanup()
4776 drm_debugfs_remove_files(info_list, 1, minor); i915_debugfs_cleanup()
4783 drm_debugfs_remove_files(info_list, 1, minor); i915_debugfs_cleanup()
4631 i915_debugfs_create(struct dentry *root, struct drm_minor *minor, const char *name, const struct file_operations *fops) i915_debugfs_create() argument
H A Di915_vgpu.h39 #define INTEL_VGT_IF_VERSION_ENCODE(major, minor) ((major) << 16 | (minor))
/linux-4.1.27/arch/mips/ath79/
H A Dsetup.c60 u32 minor; ath79_detect_sys_type() local
68 minor = id & AR71XX_REV_ID_MINOR_MASK; ath79_detect_sys_type()
71 switch (minor) { ath79_detect_sys_type()
108 minor = id & AR913X_REV_ID_MINOR_MASK; ath79_detect_sys_type()
111 switch (minor) { ath79_detect_sys_type()
/linux-4.1.27/drivers/input/
H A Dmousedev.c824 int minor; mousedev_reserve_minor() local
827 minor = input_get_new_minor(MOUSEDEV_MIX, 1, false); mousedev_reserve_minor()
828 if (minor < 0) mousedev_reserve_minor()
829 pr_err("failed to reserve mixdev minor: %d\n", minor); mousedev_reserve_minor()
831 minor = input_get_new_minor(MOUSEDEV_MINOR_BASE, mousedev_reserve_minor()
833 if (minor < 0) mousedev_reserve_minor()
834 pr_err("failed to reserve new minor: %d\n", minor); mousedev_reserve_minor()
837 return minor; mousedev_reserve_minor()
845 int minor; mousedev_create() local
848 minor = mousedev_reserve_minor(mixdev); mousedev_create()
849 if (minor < 0) { mousedev_create()
850 error = minor; mousedev_create()
874 int dev_no = minor; mousedev_create()
893 mousedev->dev.devt = MKDEV(INPUT_MAJOR, minor); mousedev_create()
923 input_free_minor(minor); mousedev_create()
1061 .minor = MOUSEDEV_MINOR_BASE,
1070 .minor = PSMOUSE_MINOR,
H A Djoydev.c829 int i, j, t, minor, dev_no; joydev_connect() local
832 minor = input_get_new_minor(JOYDEV_MINOR_BASE, JOYDEV_MINORS, true); joydev_connect()
833 if (minor < 0) { joydev_connect()
834 error = minor; joydev_connect()
835 pr_err("failed to reserve new minor: %d\n", error); joydev_connect()
851 dev_no = minor; joydev_connect()
909 joydev->dev.devt = MKDEV(INPUT_MAJOR, minor); joydev_connect()
938 input_free_minor(minor); joydev_connect()
1001 .minor = JOYDEV_MINOR_BASE,
/linux-4.1.27/arch/cris/arch-v10/drivers/
H A Dgpio.c70 int minor; member in struct:gpio_private
140 #define USE_PORTS(priv) ((priv)->minor <= GPIO_MINOR_B)
153 if (priv->minor == GPIO_MINOR_A) { gpio_poll()
164 } else if (priv->minor == GPIO_MINOR_B) gpio_poll()
166 else if (priv->minor == GPIO_MINOR_G) gpio_poll()
197 else if (priv->minor == GPIO_MINOR_G) etrax_gpio_wake_up_check()
202 DP(printk("etrax_gpio_wake_up_check %i\n",priv->minor)); etrax_gpio_wake_up_check()
280 if (priv->minor != GPIO_MINOR_A && priv->minor != GPIO_MINOR_B) gpio_write()
324 priv->minor = p; gpio_open()
412 if (priv->minor != GPIO_MINOR_G) setget_input()
460 if (priv->minor != GPIO_MINOR_G) setget_output()
518 } else if (priv->minor == GPIO_MINOR_G) { gpio_ioctl()
531 } else if (priv->minor == GPIO_MINOR_G) { gpio_ioctl()
543 } else if (priv->minor == GPIO_MINOR_G) { gpio_ioctl()
589 } else if (priv->minor == GPIO_MINOR_G) { gpio_ioctl()
651 } else if (priv->minor == GPIO_MINOR_G) { gpio_ioctl()
663 } else if (priv->minor == GPIO_MINOR_G) { gpio_ioctl()
701 if (priv->minor == GPIO_MINOR_LEDS) gpio_ioctl()
/linux-4.1.27/drivers/net/wireless/iwlwifi/
H A Diwl-devtrace-iwlwifi.h119 u32 gp1, u32 gp2, u32 gp3, u32 major, u32 minor, u32 hw_ver,
123 gp3, major, minor, hw_ver, brd_ver),
140 __field(u32, minor)
160 __entry->minor = minor;
167 "minor 0x%08X hw 0x%08X brd 0x%08X",
173 __entry->gp3, __entry->major, __entry->minor,
/linux-4.1.27/drivers/input/serio/
H A Dserio_raw.c65 static struct serio_raw *serio_raw_locate(int minor) serio_raw_locate() argument
70 if (serio_raw->dev.minor == minor) serio_raw_locate()
327 serio_raw->dev.minor = PSMOUSE_MINOR; serio_raw_connect()
334 serio_raw->dev.minor = MISC_DYNAMIC_MINOR; serio_raw_connect()
345 dev_info(&serio->dev, "raw access enabled on %s (%s, minor %d)\n", serio_raw_connect()
346 serio->phys, serio_raw->name, serio_raw->dev.minor); serio_raw_connect()
/linux-4.1.27/drivers/mcb/
H A Dmcb-internal.h32 * @minor: Revision minor
41 u8 minor; member in struct:chameleon_fpga_header
H A Dmcb-parse.c119 pr_debug("header->minor = %d\n", header->minor); chameleon_parse_cells()
/linux-4.1.27/drivers/usb/class/
H A Dcdc-acm.h18 * Major and minor numbers.
114 unsigned int minor; /* acm minor number */ member in struct:acm
H A Dusblp.c157 int minor; /* minor number of device */ member in struct:usblp
192 dev_dbg(dev, "minor=%d\n", usblp->minor); usblp_dump()
304 usblp->minor, status); usblp_bulk_read()
327 usblp->minor, status); usblp_bulk_write()
358 usblp->minor, error); usblp_check_status()
373 usblp->minor, usblp_messages[newerr]); usblp_check_status()
394 int minor = iminor(inode); usblp_open() local
399 if (minor < 0) usblp_open()
405 intf = usb_find_interface(&usblp_driver, minor); usblp_open()
445 printk(KERN_INFO "usblp%d: removed\n", usblp->minor); usblp_cleanup()
597 usblp->minor, err); usblp_ioctl()
604 usblp->minor, arg, newChannel); usblp_ioctl()
625 usblp->minor, twoints[0], twoints[1]); usblp_ioctl()
646 usblp->minor, twoints[0], twoints[1]); usblp_ioctl()
666 usblp->minor, retval); usblp_ioctl()
826 usblp->minor, (int)avail); usblp_read()
1171 "usblp: Not able to get a minor (base %u, slice default): %d\n", usblp_probe()
1175 usblp->minor = intf->minor; usblp_probe()
1178 usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum, usblp_probe()
1267 usblp->minor); usblp_select_alts()
1315 usblp->minor, protocol); usblp_set_protocol()
1330 usblp->minor, err); usblp_cache_device_id_string()
1346 usblp->minor, length, &usblp->device_id_string[2]); usblp_cache_device_id_string()
H A Dcdc-acm.c95 * Try to find an available minor number and if found, associate it with 'acm'.
99 int minor; acm_alloc_minor() local
102 for (minor = 0; minor < ACM_TTY_MINORS; minor++) { acm_alloc_minor()
103 if (!acm_table[minor]) { acm_alloc_minor()
104 acm_table[minor] = acm; acm_alloc_minor()
110 return minor; acm_alloc_minor()
113 /* Release the minor number associated with 'acm'. */ acm_release_minor()
117 acm_table[acm->minor] = NULL; acm_release_minor()
1094 int minor; acm_probe() local
1322 minor = acm_alloc_minor(acm); acm_probe()
1323 if (minor == ACM_TTY_MINORS) { acm_probe()
1336 acm->minor = minor; acm_probe()
1469 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); acm_probe()
1479 tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor, acm_probe()
1571 tty_unregister_device(acm_tty_driver, acm->minor); acm_disconnect()
/linux-4.1.27/include/media/
H A Dmedia-devnode.h57 * @minor: device node minor number
75 int minor; member in struct:media_devnode
H A Dlirc_dev.h123 int minor; member in struct:lirc_driver
147 * minor:
148 * indicates minor device (/dev/lirc) number for registered driver
149 * if caller fills it with negative value, then the first free minor
195 * returns negative value on error or minor number
203 extern int lirc_unregister_driver(int minor);
/linux-4.1.27/drivers/media/v4l2-core/
H A Dv4l2-dev.c107 /* Any types not assigned to fixed minor ranges must be mapped to devnode_bits()
109 since all those unassigned types use the same minor range. */ devnode_bits()
176 if (WARN_ON(video_device[vdev->minor] != vdev)) { v4l2_device_release()
183 video_device[vdev->minor] = NULL; v4l2_device_release()
185 /* Delete the cdev on this minor as well */ v4l2_device_release()
475 * in the video_device array, but it was able to obtain a minor number.
726 * The registration code assigns minor numbers and device node numbers
733 * An error is returned if no free minor or device node number could be
759 /* A minor value of -1 marks this video device as never __video_register_device()
761 vdev->minor = -1; __video_register_device()
809 /* Part 2: find a free minor, device node number and device index. */ __video_register_device()
814 * of 128-191 and just pick the first free minor there __video_register_device()
847 /* 1-on-1 mapping of device node number to minor number */ __video_register_device()
850 /* The device node number and minor numbers are independent, so __video_register_device()
851 we just find the first free minor number. */ __video_register_device()
857 printk(KERN_ERR "could not get a free minor\n"); __video_register_device()
861 vdev->minor = i + minor_offset; __video_register_device()
865 /* Should not happen since we thought this minor was free */ __video_register_device()
866 WARN_ON(video_device[vdev->minor] != NULL); __video_register_device()
868 video_device[vdev->minor] = vdev; __video_register_device()
882 ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1); __video_register_device()
892 vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor); __video_register_device()
918 vdev->entity.info.dev.minor = vdev->minor; __video_register_device()
927 /* Part 6: Activate this minor. The char device can now be used. */ __video_register_device()
936 video_device[vdev->minor] = NULL; __video_register_device()
940 vdev->minor = -1; __video_register_device()
/linux-4.1.27/drivers/block/xen-blkback/
H A Dxenbus.c34 unsigned minor; member in struct:backend_info
371 VBD_SHOW(physical_device, "%x:%x\n", be->major, be->minor);
414 unsigned major, unsigned minor, int readonly, xen_vbd_create()
426 vbd->pdevice = MKDEV(major, minor); xen_vbd_create()
468 if (be->major || be->minor) xen_blkbk_remove()
564 * the device's physical major and minor numbers. Switch to InitWait.
623 unsigned minor; backend_changed() local
634 &major, &minor); backend_changed()
648 if (be->major | be->minor) { backend_changed()
649 if (be->major != major || be->minor != minor) backend_changed()
651 be->major, be->minor, major, minor); backend_changed()
675 be->minor = minor; backend_changed()
677 err = xen_vbd_create(be->blkif, handle, major, minor, backend_changed()
694 be->minor = 0; backend_changed()
413 xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, unsigned major, unsigned minor, int readonly, int cdrom) xen_vbd_create() argument
/linux-4.1.27/drivers/mfd/
H A Dqcom-spmi-pmic.c63 unsigned int rev2, minor, major, type, subtype; pmic_spmi_show_revid() local
90 ret = regmap_read(map, PMIC_REV3, &minor); pmic_spmi_show_revid()
109 minor = rev2; pmic_spmi_show_revid()
111 dev_dbg(dev, "%x: %s v%d.%d\n", subtype, name, major, minor); pmic_spmi_show_revid()
H A Dtimberdale.c58 u32 minor; member in struct:timberdale_device::__anon5971
644 return sprintf(buf, "%d.%d.%d\n", priv->fw.major, priv->fw.minor, show_fw_ver()
692 priv->fw.minor = ioread32(priv->ctl_membase + TIMB_REV_MINOR); timb_probe()
698 "support %d.%d\n", priv->fw.major, priv->fw.minor); timb_probe()
702 priv->fw.minor < TIMB_REQUIRED_MINOR) { timb_probe()
705 priv->fw.major, priv->fw.minor, timb_probe()
781 priv->fw.major, priv->fw.minor, ip_setup); timb_probe()
815 priv->fw.major, priv->fw.minor, priv->fw.config); timb_probe()
H A Dkempld-core.c60 pld->info.minor = KEMPLD_VERSION_GET_MINOR(version); kempld_get_info_generic()
294 char major, minor; kempld_get_info() local
312 if (pld->info.minor < 10) kempld_get_info()
313 minor = pld->info.minor + '0'; kempld_get_info()
315 minor = (pld->info.minor - 10) + 'A'; kempld_get_info()
318 "P%X%c%c.%04X", pld->info.number, major, minor, kempld_get_info()
/linux-4.1.27/drivers/scsi/ufs/
H A Dufs-qcom.h111 u8 *major, u16 *minor, u16 *step) ufs_qcom_get_controller_revision()
116 *minor = (ver & UFS_HW_VER_MINOR_MASK) >> UFS_HW_VER_MINOR_SHFT; ufs_qcom_get_controller_revision()
154 /* Host controller hardware version: major.minor.step */
157 u16 minor; member in struct:ufs_hw_version
110 ufs_qcom_get_controller_revision(struct ufs_hba *hba, u8 *major, u16 *minor, u16 *step) ufs_qcom_get_controller_revision() argument
/linux-4.1.27/drivers/staging/comedi/kcomedilib/
H A Dkcomedilib_main.c39 unsigned int minor; comedi_open() local
44 if (kstrtouint(filename + 11, 0, &minor)) comedi_open()
47 if (minor >= COMEDI_NUM_BOARD_MINORS) comedi_open()
50 dev = comedi_dev_get_from_minor(minor); comedi_open()
/linux-4.1.27/include/uapi/linux/
H A Dmedia.h89 __u32 minor; member in struct:media_entity_desc::__anon13421::__anon13422
119 * be just major/minor inside the struct, as this is enough
124 __u32 minor; member in struct:media_entity_desc::__anon13421::__anon13424
128 __u32 minor; member in struct:media_entity_desc::__anon13421::__anon13425
H A Dlp.h13 * These are the lp_table[minor].flags flags...
33 * accessed with LP_S(minor), which gets the byte...
84 #define LPGETSTATUS 0x060b /* return LP_S(minor) */
H A Ddlm_device.h52 __u32 minor; member in struct:dlm_lspace_params
H A Dfuse.h123 * of the two minor versions for communication.
133 * supported minor version).
573 uint32_t minor; member in struct:fuse_init_in
583 uint32_t minor; member in struct:fuse_init_out
597 uint32_t minor; member in struct:cuse_init_in
604 uint32_t minor; member in struct:cuse_init_out
610 uint32_t dev_minor; /* chardev minor */
/linux-4.1.27/include/uapi/linux/raid/
H A Dmd_u.h20 * Different minor versions are only downward compatible.
72 int minor; member in struct:mdu_version_s
126 int minor; member in struct:mdu_disk_info_s
137 int minor; member in struct:mdu_start_info_s
/linux-4.1.27/include/xen/interface/
H A Dversion.h15 /* arg == NULL; returns major:minor (16:16). */
/linux-4.1.27/arch/powerpc/platforms/ps3/
H A Dsetup.c58 int ps3_compare_firmware_version(u16 major, u16 minor, u16 rev) ps3_compare_firmware_version() argument
64 x.minor = minor; ps3_compare_firmware_version()
202 ps3_firmware_version.major, ps3_firmware_version.minor, ps3_setup_arch()
/linux-4.1.27/arch/m68k/emu/
H A Dnfblock.c34 static inline s32 nfhd_read_write(u32 major, u32 minor, u32 rwflag, u32 recno, nfhd_read_write() argument
37 return nf_call(nfhd_id + NFHD_READ_WRITE, major, minor, rwflag, recno, nfhd_read_write()
41 static inline s32 nfhd_get_capacity(u32 major, u32 minor, u32 *blocks, nfhd_get_capacity() argument
44 return nf_call(nfhd_id + NFHD_GET_CAPACITY, major, minor, nfhd_get_capacity()
/linux-4.1.27/arch/m68k/include/uapi/asm/
H A Dbootinfo.h149 * number below should be stepped (and the minor reset to 0) for the
150 * appropriate machine. If a change is backward-compatible, the minor
156 #define MK_BI_VERSION(major, minor) (((major) << 16) + (minor))
/linux-4.1.27/drivers/misc/
H A Dphantom.c342 unsigned int minor; phantom_probe() local
351 minor = phantom_get_free(); phantom_probe()
352 if (minor == PHANTOM_MAX_MINORS) { phantom_probe()
358 phantom_devices[minor] = 1; phantom_probe()
404 retval = cdev_add(&pht->cdev, MKDEV(phantom_major, minor), 1); phantom_probe()
411 MKDEV(phantom_major, minor), NULL, phantom_probe()
412 "phantom%u", minor))) phantom_probe()
431 phantom_devices[minor] = 0; phantom_probe()
441 unsigned int minor = MINOR(pht->cdev.dev); phantom_remove() local
443 device_destroy(phantom_class, MKDEV(phantom_major, minor)); phantom_remove()
459 phantom_devices[minor] = 0; phantom_remove()
H A Dhpilo.c582 /* create a channel control block for this minor */ ilo_open()
725 int i, minor; ilo_remove() local
733 minor = MINOR(ilo_hw->cdev.dev); ilo_remove()
734 for (i = minor; i < minor + max_ccb; i++) ilo_remove()
751 ilo_hwdev[(minor / max_ccb)] = 0; ilo_remove()
757 int devnum, minor, start, error = 0; ilo_probe() local
825 for (minor = 0 ; minor < max_ccb; minor++) { ilo_probe()
828 MKDEV(ilo_major, minor), NULL, ilo_probe()
829 "hpilo!d%dccb%d", devnum, minor); ilo_probe()
/linux-4.1.27/drivers/scsi/osd/
H A Dosd_uld.c84 int minor; member in struct:osd_uld_device
413 ida_remove(&osd_minor_ida, oud->minor); __remove()
423 int minor; osd_probe() local
433 error = ida_get_new(&osd_minor_ida, &minor); osd_probe()
438 if (minor >= SCSI_OSD_MAX_MINOR) { osd_probe()
449 oud->minor = minor; osd_probe()
459 disk->first_minor = oud->minor; osd_probe()
460 sprintf(disk->disk_name, "osd%d", oud->minor); osd_probe()
480 MKDEV(SCSI_OSD_MAJOR, oud->minor), 1); osd_probe()
517 ida_remove(&osd_minor_ida, minor); osd_probe()
/linux-4.1.27/drivers/gpu/drm/tilcdc/
H A Dtilcdc_drv.c459 struct drm_device *dev = node->minor->dev; tilcdc_regs_show()
480 struct drm_device *dev = node->minor->dev; tilcdc_mm_show()
490 static int tilcdc_debugfs_init(struct drm_minor *minor) tilcdc_debugfs_init() argument
492 struct drm_device *dev = minor->dev; tilcdc_debugfs_init()
498 minor->debugfs_root, minor); tilcdc_debugfs_init()
502 mod->funcs->debugfs_init(mod, minor); tilcdc_debugfs_init()
512 static void tilcdc_debugfs_cleanup(struct drm_minor *minor) tilcdc_debugfs_cleanup() argument
516 ARRAY_SIZE(tilcdc_debugfs_list), minor); tilcdc_debugfs_cleanup()
520 mod->funcs->debugfs_cleanup(mod, minor); tilcdc_debugfs_cleanup()
566 .minor = 0,
H A Dtilcdc_drv.h103 int (*debugfs_init)(struct tilcdc_module *mod, struct drm_minor *minor);
105 void (*debugfs_cleanup)(struct tilcdc_module *mod, struct drm_minor *minor);
/linux-4.1.27/arch/mips/include/asm/mach-ath25/
H A Dath25_platform.h20 u16 minor; /* Board minor number */ member in struct:ath25_boarddata
/linux-4.1.27/drivers/gpu/drm/udl/
H A Dudl_drv.c63 .minor = DRIVER_MINOR,
83 DRM_INFO("Initialized udl on minor %d\n", dev->primary->index); udl_usb_probe()
/linux-4.1.27/drivers/usb/misc/
H A Dusblcd.c89 printk(KERN_ERR "USBLCD: %s - error, can't find device for minor %d\n", lcd_open()
303 * usb class driver info in order to get a minor number from the usb core,
381 "Not able to get a minor for this device.\n"); lcd_probe()
394 interface->minor); lcd_probe()
430 int minor = interface->minor; lcd_disconnect() local
437 /* give back our minor */ lcd_disconnect()
443 dev_info(&interface->dev, "USB LCD #%d now disconnected\n", minor); lcd_disconnect()
H A Diowarrior.c38 /* Get a minor range for your devices from the usb maintainer */
73 unsigned char minor; /* the starting minor number for this device */ member in struct:iowarrior
247 dev_dbg(&dev->interface->dev, "minor %d\n", dev->minor); iowarrior_delete()
284 dev_dbg(&dev->interface->dev, "minor %d, count = %zd\n", iowarrior_read()
285 dev->minor, count); iowarrior_read()
353 dev_dbg(&dev->interface->dev, "minor %d, count = %zd\n", iowarrior_write()
354 dev->minor, count); iowarrior_write()
503 dev_dbg(&dev->interface->dev, "minor %d, cmd 0x%.4x, arg %ld\n", iowarrior_ioctl()
504 dev->minor, cmd, arg); iowarrior_ioctl()
608 printk(KERN_ERR "%s - error, can't find device for minor %d\n", iowarrior_open()
661 dev_dbg(&dev->interface->dev, "minor %d\n", dev->minor); iowarrior_release()
738 * usb class driver info in order to get a minor number from the usb core,
861 dev_err(&interface->dev, "Not able to get a minor for this device.\n"); iowarrior_probe()
866 dev->minor = interface->minor; iowarrior_probe()
871 iface_desc->desc.bInterfaceNumber, dev->minor - IOWARRIOR_MINOR_BASE); iowarrior_probe()
887 int minor; iowarrior_disconnect() local
893 minor = dev->minor; iowarrior_disconnect()
895 /* give back our minor */ iowarrior_disconnect()
920 minor - IOWARRIOR_MINOR_BASE); iowarrior_disconnect()
H A Dyurex.c119 * usb class driver info in order to get a minor number from the usb core,
305 "Not able to get a minor for this device.\n"); yurex_probe()
312 interface->minor); yurex_probe()
326 int minor = interface->minor; yurex_disconnect() local
331 /* give back our minor */ yurex_disconnect()
346 dev_info(&interface->dev, "USB YUREX #%d now disconnected\n", minor); yurex_disconnect()
376 printk(KERN_ERR "%s - error, can't find device for minor %d", yurex_open()
H A Dlegousbtower.c58 * - log major, minor instead of possibly confusing device filename
176 __u8 minor; member in struct:tower_get_version_reply
197 unsigned char minor; /* the starting minor number for this device */ member in struct:lego_usb_tower
262 * usb class driver info in order to get a minor number from the usb core,
329 pr_err("error, can't find device for minor %d\n", subminor); tower_open()
908 dev_err(idev, "Not able to get a minor for this device.\n"); tower_probe()
912 dev->minor = interface->minor; tower_probe()
916 "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE), tower_probe()
917 USB_MAJOR, dev->minor); tower_probe()
936 get_version_reply.minor, tower_probe()
957 int minor; tower_disconnect() local
963 minor = dev->minor; tower_disconnect()
965 /* give back our minor */ tower_disconnect()
984 (minor - LEGO_USB_TOWER_MINOR_BASE)); tower_disconnect()
H A Dadutux.c79 unsigned int minor; /* the starting minor number for this device */ member in struct:adu_device
240 pr_err("%s - error, can't find device for minor %d\n", adu_open()
641 * usb class driver info in order to get a minor number from the usb core,
776 dev_err(&interface->dev, "Not able to get a minor for this device.\n"); adu_probe()
781 dev->minor = interface->minor; adu_probe()
786 (dev->minor - ADU_MINOR_BASE)); adu_probe()
803 int minor; adu_disconnect() local
809 minor = dev->minor; adu_disconnect()
H A Dldusb.c324 printk(KERN_ERR "%s - error, can't find device for minor %d\n", ld_usb_open()
643 * usb class driver info in order to get a minor number from the usb core,
753 dev_err(&intf->dev, "Not able to get a minor for this device.\n"); ld_usb_probe()
759 dev_info(&intf->dev, "LD USB Device #%d now attached to major %d minor %d\n", ld_usb_probe()
760 (intf->minor - USB_LD_MINOR_BASE), USB_MAJOR, intf->minor); ld_usb_probe()
779 int minor; ld_usb_disconnect() local
784 minor = intf->minor; ld_usb_disconnect()
786 /* give back our minor */ ld_usb_disconnect()
804 (minor - USB_LD_MINOR_BASE)); ld_usb_disconnect()
/linux-4.1.27/include/linux/mtd/
H A Dqinfo.h32 * @major - minor number of qinfo record
38 uint8_t minor; member in struct:qinfo_query_info
/linux-4.1.27/arch/arm/firmware/
H A Dtrusted_foundations.c94 err = of_property_read_u32(node, "tlm,version-minor", of_register_trusted_foundations()
97 panic("Trusted Foundation: missing version-minor property\n"); of_register_trusted_foundations()
/linux-4.1.27/sound/isa/sb/
H A Dsb_common.c108 int major, minor; snd_sbdsp_probe() local
128 minor = version & 0xff; snd_sbdsp_probe()
130 chip->port, major, minor); snd_sbdsp_probe()
140 if (minor) { snd_sbdsp_probe()
158 chip->port, major, minor); snd_sbdsp_probe()
181 chip->version = (major << 8) | minor; snd_sbdsp_probe()
/linux-4.1.27/drivers/block/
H A Dxen-blkfront.c280 static int xlbd_reserve_minors(unsigned int minor, unsigned int nr) xlbd_reserve_minors() argument
282 unsigned int end = minor + nr; xlbd_reserve_minors()
307 if (find_next_bit(minors, end, minor) >= end) { xlbd_reserve_minors()
308 bitmap_set(minors, minor, nr); xlbd_reserve_minors()
317 static void xlbd_release_minors(unsigned int minor, unsigned int nr) xlbd_release_minors() argument
319 unsigned int end = minor + nr; xlbd_release_minors()
323 bitmap_clear(minors, minor, nr); xlbd_release_minors()
721 static int xen_translate_vdev(int vdevice, int *minor, unsigned int *offset) xen_translate_vdev() argument
725 *minor = BLKIF_MINOR(vdevice); xen_translate_vdev()
728 *offset = (*minor / 64) + EMULATED_HD_DISK_NAME_OFFSET; xen_translate_vdev()
729 *minor = ((*minor / 64) * PARTS_PER_DISK) + xen_translate_vdev()
733 *offset = (*minor / 64) + 2 + EMULATED_HD_DISK_NAME_OFFSET; xen_translate_vdev()
734 *minor = (((*minor / 64) + 2) * PARTS_PER_DISK) + xen_translate_vdev()
738 *offset = (*minor / PARTS_PER_DISK) + EMULATED_SD_DISK_NAME_OFFSET; xen_translate_vdev()
739 *minor = *minor + EMULATED_SD_DISK_MINOR_OFFSET; xen_translate_vdev()
748 *offset = (*minor / PARTS_PER_DISK) + xen_translate_vdev()
751 *minor = *minor + xen_translate_vdev()
763 *offset = (*minor / PARTS_PER_DISK) + xen_translate_vdev()
766 *minor = *minor + xen_translate_vdev()
771 *offset = *minor / PARTS_PER_DISK; xen_translate_vdev()
798 int minor; xlvbd_alloc_gendisk() local
812 err = xen_translate_vdev(info->vdevice, &minor, &offset); xlvbd_alloc_gendisk()
817 minor = BLKIF_MINOR_EXT(info->vdevice); xlvbd_alloc_gendisk()
819 offset = minor / nr_parts; xlvbd_alloc_gendisk()
825 if (minor >> MINORBITS) { xlvbd_alloc_gendisk()
826 pr_warn("blkfront: %#x's minor (%#x) out of range; ignoring\n", xlvbd_alloc_gendisk()
827 info->vdevice, minor); xlvbd_alloc_gendisk()
831 if ((minor % nr_parts) == 0) xlvbd_alloc_gendisk()
834 err = xlbd_reserve_minors(minor, nr_minors); xlvbd_alloc_gendisk()
850 "%d", minor & (nr_parts - 1)); xlvbd_alloc_gendisk()
853 gd->first_minor = minor; xlvbd_alloc_gendisk()
883 xlbd_release_minors(minor, nr_minors); xlvbd_alloc_gendisk()
890 unsigned int minor, nr_minors; xlvbd_release_gendisk() local
910 minor = info->gd->first_minor; xlvbd_release_gendisk()
912 xlbd_release_minors(minor, nr_minors); xlvbd_release_gendisk()
/linux-4.1.27/fs/
H A Dchar_dev.c63 * Register a single major with a specified minor range.
115 /* Check for overlapping minor ranges. */ __register_chrdev_region()
202 * @baseminor: first of the requested range of minor numbers
203 * @count: the number of minor numbers required
207 * chosen dynamically, and returned (along with the first minor number)
224 * @baseminor: first of the requested range of minor numbers
225 * @count: the number of minor numbers required
301 * @baseminor: first of the range of minor numbers
302 * @count: the number of minor numbers this cdev is occupying
446 * @count: the number of consecutive minor numbers corresponding to this
/linux-4.1.27/include/drm/
H A DdrmP.h291 /* Whether we're master for a minor. Protected by master_mutex */
307 struct drm_minor *minor; member in struct:drm_file
319 N.B. not always minor->master */
355 * @minor: Link back to minor char device we are master for. Immutable.
365 struct drm_minor *minor; member in struct:drm_master
548 * master_set is called whenever the minor master is set.
549 * master_drop is called whenever the minor master is dropped.
557 int (*debugfs_init)(struct drm_minor *minor);
558 void (*debugfs_cleanup)(struct drm_minor *minor);
616 int minor; member in struct:drm_driver
655 struct drm_minor *minor; member in struct:drm_info_node
661 * DRM minor structure. This structure represents a drm minor number.
865 return file_priv->minor->type == DRM_MINOR_RENDER; drm_is_render_client()
870 return file_priv->minor->type == DRM_MINOR_CONTROL; drm_is_control_client()
875 return file_priv->minor->type == DRM_MINOR_LEGACY; drm_is_primary_client()
980 struct drm_minor *minor);
982 int count, struct drm_minor *minor);
986 struct drm_minor *minor) drm_debugfs_create_files()
992 int count, struct drm_minor *minor) drm_debugfs_remove_files()
1032 void drm_minor_release(struct drm_minor *minor);
984 drm_debugfs_create_files(const struct drm_info_list *files, int count, struct dentry *root, struct drm_minor *minor) drm_debugfs_create_files() argument
991 drm_debugfs_remove_files(const struct drm_info_list *files, int count, struct drm_minor *minor) drm_debugfs_remove_files() argument
/linux-4.1.27/drivers/staging/gdm724x/
H A Dgdm_tty.c61 gdm_table[gdm->index][gdm->minor] = NULL; gdm_port_destruct()
253 gdm->minor = j; register_lte_tty_device()
257 gdm->minor, device); register_lte_tty_device()
278 gdm_table[gdm->index][gdm->minor] = NULL; unregister_lte_tty_device()
287 tty_unregister_device(gdm_driver[i], gdm->minor); unregister_lte_tty_device()
H A Dgdm_tty.h40 unsigned int minor; member in struct:gdm
/linux-4.1.27/drivers/crypto/qce/
H A Dcore.c153 u32 major, minor, step; qce_check_version() local
155 qce_get_version(qce, &major, &minor, &step); qce_check_version()
158 * the driver does not support v5 with minor 0 because it has special qce_check_version()
161 if (major != QCE_MAJOR_VERSION5 || minor == 0) qce_check_version()
168 major, minor, step); qce_check_version()
/linux-4.1.27/drivers/isdn/capi/
H A Dcapi.c80 unsigned int minor; member in struct:capiminor
210 unsigned int minor; capiminor_alloc() local
230 /* Allocate the least unused minor number. */ capiminor_alloc()
232 for (minor = 0; minor < capi_ttyminors; minor++) capiminor_alloc()
233 if (!capiminors[minor]) { capiminor_alloc()
234 capiminors[minor] = mp; capiminor_alloc()
239 if (minor == capi_ttyminors) { capiminor_alloc()
244 mp->minor = minor; capiminor_alloc()
246 dev = tty_port_register_device(&mp->port, capinc_tty_driver, minor, capiminor_alloc()
255 capiminors[minor] = NULL; capiminor_alloc()
263 static struct capiminor *capiminor_get(unsigned int minor) capiminor_get() argument
268 mp = capiminors[minor]; capiminor_get()
283 tty_unregister_device(capinc_tty_driver, mp->minor); capiminor_free()
286 capiminors[mp->minor] = NULL; capiminor_free()
920 unit = mp->minor; capi_ioctl()
1322 * minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt capinc_tty_exit()
/linux-4.1.27/drivers/phy/
H A Dphy-qcom-ufs-qmp-20nm.c26 u16 minor = ufs_qcom_phy->host_ctrl_rev_minor; ufs_qcom_phy_qmp_20nm_phy_calibrate() local
30 if ((major == 0x1) && (minor == 0x002) && (step == 0x0000)) { ufs_qcom_phy_qmp_20nm_phy_calibrate()
33 } else if ((major == 0x1) && (minor == 0x003) && (step == 0x0000)) { ufs_qcom_phy_qmp_20nm_phy_calibrate()
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/subdev/bios/
H A Dbase.c151 bios->version.minor = nv_ro08(bios, bit_i.offset + 1); nvkm_bios_ctor()
158 bios->version.minor = nv_ro08(bios, bios->bmp_offset + 11); nvkm_bios_ctor()
164 bios->version.minor, bios->version.micro, bios->version.patch); nvkm_bios_ctor()
/linux-4.1.27/drivers/media/usb/as102/
H A Das102_usb_drv.c429 int ret = 0, minor = 0; as102_open() local
433 /* read minor from inode */ as102_open()
434 minor = iminor(inode); as102_open()
437 intf = usb_find_interface(&as102_usb_driver, minor); as102_open()
439 pr_err("%s: can't find device for minor %d\n", as102_open()
440 __func__, minor); as102_open()
/linux-4.1.27/drivers/staging/media/lirc/
H A Dlirc_zilog.c159 static int minor = -1; /* minor number */ variable
187 if (ir->l.minor >= 0 && ir->l.minor < MAX_IRCTL_DEVICES) { release_ir_device()
188 lirc_unregister_driver(ir->l.minor); release_ir_device()
189 ir->l.minor = MAX_IRCTL_DEVICES; release_ir_device()
1293 static struct IR *get_ir_device_by_minor(unsigned int minor) get_ir_device_by_minor() argument
1302 if (ir->l.minor == minor) { get_ir_device_by_minor()
1320 unsigned int minor = MINOR(node->i_rdev); open() local
1323 ir = get_ir_device_by_minor(minor); open()
1394 .minor = -1,
1612 ir->l.minor = minor; /* module option: user requested minor number */ ir_probe()
1613 ir->l.minor = lirc_register_driver(&ir->l); ir_probe()
1614 if (ir->l.minor < 0 || ir->l.minor >= MAX_IRCTL_DEVICES) { ir_probe()
1616 "%s: \"minor\" must be between 0 and %d (%d)!\n", ir_probe()
1617 __func__, MAX_IRCTL_DEVICES-1, ir->l.minor); ir_probe()
1623 adap->name, adap->nr, ir->l.minor); ir_probe()
1690 module_param(minor, int, 0444);
1691 MODULE_PARM_DESC(minor, "Preferred minor device number");
H A Dlirc_sasem.c178 int minor = context->driver->minor; deregister_from_lirc() local
180 retval = lirc_unregister_driver(minor); deregister_from_lirc()
187 "Deregistered Sasem driver (minor:%d)\n", minor); deregister_from_lirc()
208 pr_err("%s: could not find interface for minor %d\n", vfd_open()
216 dev_err(&interface->dev, "no context found for minor %d\n", vfd_open()
788 driver->minor = -1; sasem_probe()
810 "%s: Registered Sasem driver (minor:%d)\n", sasem_probe()
814 driver->minor = lirc_minor; sasem_probe()
837 "%s: could not get a minor number for VFD\n", sasem_probe()
/linux-4.1.27/drivers/isdn/hisax/
H A Davma1_cs.c138 unsigned long minor = (unsigned long) link->priv; avma1cs_release() local
143 HiSax_closecard(minor); avma1cs_release()
/linux-4.1.27/drivers/staging/fsl-mc/include/
H A Ddpmng.h50 * @minor: Minor version number: incremented on API additions (that are
57 uint32_t minor; member in struct:mc_version
/linux-4.1.27/arch/x86/include/asm/
H A Dolpc.h24 * and the minor build number within 0x000f. Pre-builds have a minor
/linux-4.1.27/include/uapi/linux/nfsd/
H A Dnfsfh.h49 * 0 - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
53 * 2 - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
/linux-4.1.27/arch/m68k/mvme16x/
H A Drtc.c26 * We sponge a minor off of the misc major. No need slurping
151 .minor = RTC_MINOR,
/linux-4.1.27/fs/ocfs2/
H A Dstack_user.c58 * SETV<space><2-char-hex-major><space><2-char-hex-minor><newline>
66 * ocfs2_user_plugin.sp_max_proto.pv_major, and the minor number
144 /* SETV<space><2-char-hex-major><space><2-char-hex-minor><newline> */
150 char minor[OCFS2_CONTROL_MESSAGE_VERNUM_LEN]; member in struct:ocfs2_control_message_setv
402 long major, minor; ocfs2_control_do_setversion_msg() local
424 minor = simple_strtol(msg->minor, &ptr, 16); ocfs2_control_do_setversion_msg()
429 * The major must be between 1 and 255, inclusive. The minor ocfs2_control_do_setversion_msg()
436 if ((minor == LONG_MIN) || (minor == LONG_MAX) || ocfs2_control_do_setversion_msg()
437 (minor > (u8)-1) || (minor < 0)) ocfs2_control_do_setversion_msg()
440 (minor > max->pv_minor)) ocfs2_control_do_setversion_msg()
444 p->op_proto.pv_minor = minor; ocfs2_control_do_setversion_msg()
635 .minor = MISC_DYNAMIC_MINOR,
786 * If the current minor is greater than the request, they are incompatible.
787 * If the current minor is less than or equal to the request, they are
788 * compatible, and the requester should run at the current minor version.
/linux-4.1.27/arch/sh/kernel/
H A Dtraps_64.c460 int major, minor; misaligned_fixup() local
472 minor = (opcode >> 16) & 0xf; misaligned_fixup()
499 switch (minor) { misaligned_fixup()
519 switch (minor) { misaligned_fixup()
545 switch (minor) { misaligned_fixup()
570 switch (minor) { misaligned_fixup()
628 Form a 10-bit value by concatenating the major/minor opcodes i.e.
652 unsigned long major, minor, combined; do_reserved_inst() local
690 minor = (opcode >> 16) & 0xf; do_reserved_inst()
691 combined = (major << 4) | minor; do_reserved_inst()
693 shift = minor << 1; do_reserved_inst()
/linux-4.1.27/drivers/block/drbd/
H A Ddrbd_debugfs.c123 seq_printf(m, "%u\t%u\t", req->device->minor, req->device->vnr); seq_print_minor_vnr_req()
132 seq_puts(m, "minor\tvnr\tstart\tsubmit\tintent\n"); seq_print_resource_pending_meta_io()
143 device->minor, device->vnr, seq_print_resource_pending_meta_io()
160 seq_puts(m, "minor\tvnr\tage\t#waiting\n"); seq_print_waiting_for_AL()
179 seq_printf(m, "%u\t%u\t", device->minor, device->vnr); seq_print_waiting_for_AL()
208 device->minor, device->vnr, seq_print_device_bitmap_io()
220 seq_puts(m, "minor\tvnr\trw\tage\t#in-flight\n"); seq_print_resource_pending_bitmap_io()
262 seq_printf(m, "%u\t%u\t", device->minor, device->vnr); list_for_each_entry()
279 seq_puts(m, "minor\tvnr\tsector\tsize\trw\tage\tflags\n"); seq_print_device_peer_requests()
287 device->minor, device->vnr, seq_print_device_peer_requests()
825 snprintf(minor_buf, sizeof(minor_buf), "%u", device->minor); drbd_debugfs_device_attr()
/linux-4.1.27/arch/mips/include/uapi/asm/
H A Dinst.h246 * (microMIPS) POOL32I minor opcodes.
261 * (microMIPS) POOL32A minor opcodes.
316 * (microMIPS) POOL32AXF minor opcodes.
339 * (microMIPS) POOL32F minor opcodes.
363 * (microMIPS) POOL32F secondary minor opcodes.
382 * (microMIPS) POOL32F secondary minor opcodes.
390 * (microMIPS) POOL32F secondary minor opcodes.
400 * (microMIPS) POOL32F secondary minor opcodes.
408 * (microMIPS) POOL32FXF secondary minor opcodes for POOL32F.
447 * (microMIPS) POOL16C minor opcodes.
460 * (microMIPS) POOL16D minor opcodes.
/linux-4.1.27/drivers/mtd/lpddr/
H A Dqinfo_probe.c63 int major, minor; lpddr_get_qinforec_pos() local
68 minor = qinfo_array[i].minor & ((1 << bankwidth) - 1); lpddr_get_qinforec_pos()
69 return minor | (major << bankwidth); lpddr_get_qinforec_pos()
/linux-4.1.27/drivers/misc/genwqe/
H A Dgenwqe_driver.h42 * Static minor number assignement, until we decide/implement
/linux-4.1.27/drivers/staging/speakup/
H A Ddevsynth.c69 .minor = SYNTH_MINOR,
/linux-4.1.27/drivers/staging/vt6655/
H A Ddevice_cfg.h35 unsigned char minor; member in struct:_version
/linux-4.1.27/block/partitions/
H A Dsgi.c65 * have 15 minor's. Luckily there are always a few zero length sgi_partition()
/linux-4.1.27/drivers/gpu/drm/msm/adreno/
H A Dadreno_device.c92 _rev_match(info->rev.minor, rev.minor) && adreno_info()
120 rev.core, rev.major, rev.minor, rev.patchid); adreno_load_gpu()
125 rev.minor, rev.patchid); adreno_load_gpu()
/linux-4.1.27/drivers/uwb/i1480/dfu/
H A Di1480-dfu.h206 __le16 mac_fw_rev; /* major = v >> 8; minor = v & 0xff */
209 u8 phy_rev; /* major v = >> 8; minor = v & 0xff */
220 __le16 mac_fw_rev; /* major = v >> 8; minor = v & 0xff */
221 __le16 phy_fw_rev; /* major v = >> 8; minor = v & 0xff */
/linux-4.1.27/include/linux/phy/
H A Dphy-qcom-ufs.h57 u8 major, u16 minor, u16 step);
/linux-4.1.27/include/linux/sunrpc/
H A Dauth_gss.h56 u32 gr_minor; /* minor status */
/linux-4.1.27/arch/blackfin/mach-bf561/
H A Dcoreb.c58 .minor = MISC_DYNAMIC_MINOR,
/linux-4.1.27/arch/cris/include/uapi/arch-v32/arch/
H A Dcryptocop.h3 * CRYPTOCOP_MAJOR (254) and minor number 0.
/linux-4.1.27/arch/arm/lib/
H A Dcsumpartialcopyuser.S66 * FIXME: minor buglet here
/linux-4.1.27/arch/arc/kernel/
H A Darc_hostlink.c48 .minor = MISC_DYNAMIC_MINOR,
/linux-4.1.27/fs/cachefiles/
H A Dmain.c38 .minor = MISC_DYNAMIC_MINOR,
/linux-4.1.27/sound/oss/
H A Dsoundcard.c208 printk(KERN_ERR "Invalid minor device %d\n", dev); sound_open()
244 printk(KERN_ERR "Invalid minor device %d\n", dev); sound_open()
531 unsigned short minor; member in struct:oss_minor_dev
560 unsigned short minor = dev_list[i].minor + j * 0x10; oss_init() local
561 if (!register_sound_special(&oss_sound_fops, minor)) oss_init()
580 unregister_sound_special(dev_list[i].minor); oss_cleanup()
H A Dsb_common.c258 devc->major = devc->minor = 0; dsp_get_vers()
269 devc->minor = inb(DSP_READ); dsp_get_vers()
275 DDB(printk("DSP version %d.%02d\n", devc->major, devc->minor)); dsp_get_vers()
576 if (devc->major == 0 || (devc->major == 3 && devc->minor == 1)) sb_dsp_detect()
593 if (devc->major == 3 && devc->minor == 1) sb_dsp_detect()
631 MDB(printk(KERN_INFO "SB %d.%02d detected OK (%x)\n", devc->major, devc->minor, hw_config->io_base)); sb_dsp_detect()
694 devc->major == 3 && devc->minor == 1) sb_dsp_init()
706 if (devc->major == 4 && devc->minor <= 11 ) /* Won't work */ sb_dsp_init()
739 if (devc->minor == 0) sb_dsp_init()
767 if ((devc->minor == 2) && sb_getmixer(devc,0x3c) && sb_getmixer(devc,0x4c)) sb_dsp_init()
823 sprintf(name, "%s (%d.%02d)", hw_config->name, devc->major, devc->minor); sb_dsp_init()
835 if (devc->major == 3 && devc->minor != 1) /* "True" SB Pro should have v3.1 (rare ones may have 3.2). */ sb_dsp_init()
844 printk(KERN_INFO "SB DSP version is just %d.%02d which means that your card is\n", devc->major, devc->minor); sb_dsp_init()
1198 if(devc->model == MDL_SB16 && devc->minor >= 12) probe_sbmpu()
1244 if (devc->minor > 12) /* What is Vibra's version??? */ probe_sbmpu()
/linux-4.1.27/drivers/misc/mei/
H A Dmain.c643 * mei_minor_get - obtain next free device minor number
647 * Return: allocated minor, or -ENOSPC if no free minor left
656 dev->minor = ret; mei_minor_get()
665 * mei_minor_free - mark device minor number as free
672 idr_remove(&mei_idr, dev->minor); mei_minor_free()
686 devno = MKDEV(MAJOR(mei_devt), dev->minor); mei_register()
694 MAJOR(mei_devt), dev->minor); mei_register()
700 "mei%d", dev->minor); mei_register()
704 MAJOR(mei_devt), dev->minor); mei_register()
/linux-4.1.27/drivers/scsi/
H A Dch.c109 int minor; member in struct:__anon8760
580 int minor = iminor(inode); ch_open() local
584 ch = idr_find(&ch_index_idr, minor); ch_open()
924 ch->minor = ret; ch_probe()
925 sprintf(ch->name,"ch%d",ch->minor); ch_probe()
928 MKDEV(SCSI_CHANGER_MAJOR, ch->minor), ch, ch_probe()
932 ch->minor); ch_probe()
948 idr_remove(&ch_index_idr, ch->minor); ch_probe()
959 idr_remove(&ch_index_idr, ch->minor); ch_remove()
962 device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor)); ch_remove()
/linux-4.1.27/drivers/spi/
H A Dspidev.c46 * SPI has a character major number assigned. We allocate minor numbers
49 * nodes, since there is no fixed association of minor numbers with any
610 pr_debug("spidev: nothing for minor %d\n", iminor(inode)); spidev_open()
721 unsigned long minor; spidev_probe() local
746 /* If we can allocate a minor number, hook up this device. spidev_probe()
750 minor = find_first_zero_bit(minors, N_SPI_MINORS); spidev_probe()
751 if (minor < N_SPI_MINORS) { spidev_probe()
754 spidev->devt = MKDEV(SPIDEV_MAJOR, minor); spidev_probe()
760 dev_dbg(&spi->dev, "no minor number available!\n"); spidev_probe()
764 set_bit(minor, minors); spidev_probe()
/linux-4.1.27/drivers/s390/block/
H A Ddcssblk.c100 * get a minor number. needs to be called with
108 int minor, found; dcssblk_assign_free_minor() local
113 for (minor = 0; minor < (1<<MINORBITS); minor++) { dcssblk_assign_free_minor()
115 // test if minor available dcssblk_assign_free_minor()
117 if (minor == entry->gd->first_minor) dcssblk_assign_free_minor()
119 if (!found) break; // got unused minor dcssblk_assign_free_minor()
123 dev_info->gd->first_minor = minor; dcssblk_assign_free_minor()
630 *get minor, add to list dcssblk_add_store()
/linux-4.1.27/drivers/ide/
H A Dide-tape.c177 unsigned int minor; member in struct:ide_tape_obj
1464 unsigned int minor = iminor(inode), i = minor & ~0xc0; idetape_chrdev_open() local
1547 static void idetape_write_release(ide_drive_t *drive, unsigned int minor) idetape_write_release() argument
1568 unsigned int minor = iminor(inode); idetape_chrdev_release() local
1577 idetape_write_release(drive, minor); idetape_chrdev_release()
1579 if (minor < 128) idetape_chrdev_release()
1583 if (minor < 128 && test_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT), idetape_chrdev_release()
1743 static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor) idetape_setup() argument
1750 ide_debug_log(IDE_DBG_FUNC, "minor: %d", minor); idetape_setup()
1766 tape->minor = minor; idetape_setup()
1769 tape->name[2] = '0' + minor; idetape_setup()
1829 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor)); ide_tape_release()
1831 MKDEV(IDETAPE_MAJOR, tape->minor + 128)); ide_tape_release()
1832 idetape_devs[tape->minor] = NULL; ide_tape_release()
1957 int minor; ide_tape_probe() local
2002 for (minor = 0; idetape_devs[minor]; minor++) ide_tape_probe()
2004 idetape_devs[minor] = tape; ide_tape_probe()
2007 idetape_setup(drive, tape, minor); ide_tape_probe()
2010 MKDEV(IDETAPE_MAJOR, minor), NULL, "%s", tape->name); ide_tape_probe()
2012 MKDEV(IDETAPE_MAJOR, minor + 128), NULL, ide_tape_probe()
/linux-4.1.27/drivers/usb/
H A Dusb-skeleton.c37 /* Get a minor range for your devices from the usb maintainer */
94 pr_err("%s - error, can't find device for minor %d\n", skel_open()
481 * usb class driver info in order to get a minor number from the usb core,
562 "Not able to get a minor for this device.\n"); skel_probe()
570 interface->minor); skel_probe()
583 int minor = interface->minor; skel_disconnect() local
588 /* give back our minor */ skel_disconnect()
601 dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor); skel_disconnect()
/linux-4.1.27/drivers/char/pcmcia/
H A Dcm4040_cs.c439 int minor = iminor(inode);
442 if (minor >= CM_MAX_DEV)
446 link = dev_table[minor];
482 int minor = iminor(inode);
487 if (minor >= CM_MAX_DEV)
490 link = dev_table[minor];
/linux-4.1.27/arch/mips/sibyte/common/
H A Dsb_tbprof.c403 int minor; sbprof_tb_open() local
405 minor = iminor(inode); sbprof_tb_open()
406 if (minor != 0) sbprof_tb_open()
432 int minor; sbprof_tb_release() local
434 minor = iminor(inode); sbprof_tb_release()
435 if (minor != 0 || sbp.open != SB_CLOSED) sbprof_tb_release()
/linux-4.1.27/usr/
H A Dgen_init_cpio.c88 0, /* minor */ cpio_trailer()
120 1, /* minor */ cpio_mkslink()
169 1, /* minor */ cpio_mkgeneric()
263 1, /* minor */ cpio_mknod()
353 1, /* minor */ cpio_mkfile()
476 "<min> minor number of nod\n" usage()
/linux-4.1.27/drivers/gpu/drm/msm/dsi/
H A Ddsi_host.c55 u32 minor; member in struct:dsi_config
65 .minor = MSM_DSI_6G_VER_MINOR_V1_0,
80 .minor = MSM_DSI_6G_VER_MINOR_V1_1,
95 .minor = MSM_DSI_6G_VER_MINOR_V1_1_1,
110 .minor = MSM_DSI_6G_VER_MINOR_V1_2,
125 .minor = MSM_DSI_6G_VER_MINOR_V1_3_1,
140 static int dsi_get_version(const void __iomem *base, u32 *major, u32 *minor) dsi_get_version() argument
145 if (!major || !minor) dsi_get_version()
158 *minor = 0; dsi_get_version()
169 *minor = ver_6g; dsi_get_version()
273 u32 major = 0, minor = 0; dsi_get_config() local
294 ret = dsi_get_version(msm_host->ctrl_base, &major, &minor); dsi_get_config()
306 if ((cfg->major == major) && (cfg->minor == minor)) dsi_get_config()
309 pr_err("%s: Version %x:%x not support\n", __func__, major, minor); dsi_get_config()
754 (msm_host->cfg->minor >= MSM_DSI_6G_VER_MINOR_V1_2)) dsi_ctrl_config()
1727 (msm_host->cfg->minor >= MSM_DSI_6G_VER_MINOR_V1_1)) { msm_dsi_host_cmd_rx()
/linux-4.1.27/drivers/char/xillybus/
H A Dxillybus_core.c1413 int minor = iminor(inode); xillybus_open() local
1422 (minor >= ep_iter->lowest_minor) && xillybus_open()
1423 (minor < (ep_iter->lowest_minor + xillybus_open()
1432 pr_err("xillybus: open() failed to find a device for major=%d and minor=%d\n", xillybus_open()
1433 major, minor); xillybus_open()
1440 channel = endpoint->channels[1 + minor - endpoint->lowest_minor]; xillybus_open()
1808 int devnum, i, minor, major; xillybus_init_chrdev() local
1812 rc = alloc_chrdev_region(&dev, 0, /* minor start */ xillybus_init_chrdev()
1821 endpoint->lowest_minor = minor = MINOR(dev); xillybus_init_chrdev()
1825 rc = cdev_add(&endpoint->cdev, MKDEV(major, minor), xillybus_init_chrdev()
1834 for (i = minor, devnum = 0; xillybus_init_chrdev()
1870 unregister_chrdev_region(MKDEV(major, minor), endpoint->num_channels); xillybus_init_chrdev()
1877 int minor; xillybus_cleanup_chrdev() local
1879 for (minor = endpoint->lowest_minor; xillybus_cleanup_chrdev()
1880 minor < (endpoint->lowest_minor + endpoint->num_channels); xillybus_cleanup_chrdev()
1881 minor++) xillybus_cleanup_chrdev()
1882 device_destroy(xillybus_class, MKDEV(endpoint->major, minor)); xillybus_cleanup_chrdev()
/linux-4.1.27/drivers/vfio/
H A Dvfio.c73 int minor; member in struct:vfio_group
147 * Group minor allocation/free - both called with vfio.group_lock held
154 static void vfio_free_group_minor(int minor) vfio_free_group_minor() argument
156 idr_remove(&vfio.group_idr, minor); vfio_free_group_minor()
205 int ret, minor; vfio_create_group() local
246 minor = vfio_alloc_group_minor(group); vfio_create_group()
247 if (minor < 0) { vfio_create_group()
249 return ERR_PTR(minor); vfio_create_group()
253 MKDEV(MAJOR(vfio.group_devt), minor), vfio_create_group()
256 vfio_free_group_minor(minor); vfio_create_group()
261 group->minor = minor; vfio_create_group()
286 device_destroy(vfio.class, MKDEV(MAJOR(vfio.group_devt), group->minor)); vfio_group_release()
288 vfio_free_group_minor(group->minor); vfio_group_release()
343 static struct vfio_group *vfio_group_get_from_minor(int minor) vfio_group_get_from_minor() argument
348 group = idr_find(&vfio.group_idr, minor); vfio_group_get_from_minor()
1528 .minor = VFIO_MINOR,
/linux-4.1.27/drivers/isdn/gigaset/
H A Dcommon.c1007 static struct cardstate *gigaset_get_cs_by_minor(unsigned minor) gigaset_get_cs_by_minor() argument
1016 if (minor < drv->minor || minor >= drv->minor + drv->minors) gigaset_get_cs_by_minor()
1018 index = minor - drv->minor; gigaset_get_cs_by_minor()
1060 * @minor: First minor number
1063 * @devname: Name of the device files (prefix without minor number)
1070 struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors, gigaset_initdriver() argument
1085 drv->minor = minor; gigaset_initdriver()
/linux-4.1.27/drivers/net/ethernet/intel/i40e/
H A Di40e_adminq.h95 u16 fw_min_ver; /* firmware minor version */
98 u16 api_min_ver; /* api minor version */
/linux-4.1.27/drivers/net/ethernet/intel/i40evf/
H A Di40e_adminq.h95 u16 fw_min_ver; /* firmware minor version */
98 u16 api_min_ver; /* api minor version */
/linux-4.1.27/arch/um/drivers/
H A Dharddog_kern.c25 * NB: uses same minor as wdt (WATCHDOG_MINOR); we could use separate
174 .minor = WATCHDOG_MINOR,
/linux-4.1.27/drivers/tty/serial/
H A Dsuncore.c32 drv->minor = sunserial_current_minor; sunserial_register_minors()
39 drv->tty_driver->name_base = drv->minor - 64; sunserial_register_minors()
/linux-4.1.27/drivers/watchdog/
H A Dindydog.c164 .minor = WATCHDOG_MINOR,
185 pr_err("cannot register miscdev on minor=%d (err=%d)\n", watchdog_init()
H A Dsbc_epx_c3.c168 .minor = WATCHDOG_MINOR,
192 pr_err("cannot register miscdev on minor=%d (err=%d)\n", watchdog_init()
H A Dsbc_fitpc2_wdt.c194 .minor = WATCHDOG_MINOR,
231 pr_err("cannot register miscdev on minor=%d (err=%d)\n", fitpc2_wdt_init()
/linux-4.1.27/arch/mn10300/boot/tools/
H A Dbuild.c89 minor_root = minor(sb.st_dev); main()
96 minor_root = minor(sb.st_rdev); main()
/linux-4.1.27/arch/m68k/bvme6000/
H A Drtc.c27 * We sponge a minor off of the misc major. No need slurping
161 .minor = RTC_MINOR,

Completed in 6926 milliseconds

123456