diff -ur a/common/lib/modules/fglrx/build_mod/drm_proc.h b/common/lib/modules/fglrx/build_mod/drm_proc.h
--- a/common/lib/modules/fglrx/build_mod/drm_proc.h	2013-04-16 16:29:55.000000000 -0500
+++ b/common/lib/modules/fglrx/build_mod/drm_proc.h	2013-07-22 20:32:11.544145268 -0500
@@ -95,22 +95,35 @@
 	int		      i, j;
 	char                  name[64];
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 	if (!minor) root = create_proc_entry("dri", S_IFDIR, NULL);
+#else
+	if (!minor) root = proc_mkdir("dri", NULL);
+#endif
 	if (!root) {
 		DRM_ERROR("Cannot create /proc/ati\n");
 		return NULL;
 	}
 
 	sprintf(name, "%d", minor);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 	*dev_root = create_proc_entry(name, S_IFDIR, root);
+#else
+	*dev_root = proc_mkdir(name, root);
+#endif
 	if (!*dev_root) {
 		DRM_ERROR("Cannot create /proc/ati/%s\n", name);
 		return NULL;
 	}
 
 	for (i = 0; i < DRM_PROC_ENTRIES; i++) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 		ent = create_proc_entry(DRM(proc_list)[i].name,
 					S_IFREG|S_IRUGO, *dev_root);
+#else
+		ent = proc_create_data(DRM(proc_list)[i].name,
+					S_IFREG|S_IRUGO, *dev_root, &firegl_fops, dev);
+#endif
 		if (!ent) {
 			DRM_ERROR("Cannot create /proc/ati/%s/%s\n",
 				  name, DRM(proc_list)[i].name);
@@ -121,8 +134,10 @@
 			if (!minor) remove_proc_entry("dri", NULL);
 			return NULL;
 		}
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 		ent->read_proc = DRM(proc_list)[i].f;
 		ent->data      = dev;
+#endif
 	}
 
 	return root;
diff -ur a/common/lib/modules/fglrx/build_mod/firegl_public.c b/common/lib/modules/fglrx/build_mod/firegl_public.c
--- a/common/lib/modules/fglrx/build_mod/firegl_public.c	2013-04-16 16:29:55.000000000 -0500
+++ b/common/lib/modules/fglrx/build_mod/firegl_public.c	2013-07-22 20:33:08.837143138 -0500
@@ -112,6 +112,7 @@
 #include <linux/fs.h>
 #include <linux/proc_fs.h>
 #include <linux/init.h>
+#include <linux/seq_file.h>
 #include <linux/file.h>
 #include <linux/pci.h>
 #include <linux/wait.h>
@@ -520,14 +521,25 @@
 #ifdef DEBUG
 READ_PROC_WRAP(drm_bq_info)
 #endif
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 READ_PROC_WRAP(firegl_debug_proc_read)
+#endif
 READ_PROC_WRAP(firegl_bios_version)
 READ_PROC_WRAP(firegl_interrupt_info)
 READ_PROC_WRAP(firegl_ptm_info)
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 static int firegl_debug_proc_write_wrap(void* file, const char *buffer, unsigned long count, void *data)
-{                                                                  
-    return firegl_debug_proc_write(file, buffer, count, data);     
+#else
+static int firegl_debug_proc_read_wrap(struct seq_file *m, void* data)
+{
+    return firegl_debug_proc_read(m->buf, m->from, m->index, m->size, m->size - m->count, data);
+}
+
+static ssize_t firegl_debug_proc_write_wrap(struct file *file, const char *buffer, size_t count, void *data)
+#endif
+{
+		return firegl_debug_proc_write(file, buffer, count, data);
 }
 
 /** \brief Callback function for reading from /proc/ati/major
@@ -543,9 +555,14 @@
  *
  * \return number of bytes written
  */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
 static int firegl_major_proc_read(char *buf, char **start, kcl_off_t offset,
                                   int request, int* eof, void* data)
+#else
+static int firegl_major_proc_read(struct seq_file *m, void* data)
+#endif
 {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
     int len = 0;    // For ProcFS: fill buf from the beginning
 
     KCL_DEBUG1(FN_FIREGL_PROC, "offset %d\n", (int)offset);
@@ -561,6 +578,9 @@
 
     len = snprintf(buf, request, "%d\n", major);
 
+#else
+	int len = seq_printf(m, "%d\n", major);
+#endif
     KCL_DEBUG1(FN_FIREGL_PROC, "return len=%i\n",len);
 
     return len;
@@ -583,6 +603,29 @@
     { "NULL",           NULL,                       NULL} // Terminate List!!!
 };
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
+static int firegl_major_proc_open(struct inode *inode, struct file *file){
+		return single_open(file, firegl_major_proc_read, NULL);
+}
+
+static const struct file_operations firegl_major_fops = {
+		.open = firegl_major_proc_open,
+		.read = seq_read,
+		.llseek = seq_lseek,
+};
+
+static int firegl_debug_proc_open(struct inode *inode, struct file *file){
+		return single_open(file, firegl_debug_proc_read_wrap, NULL);
+}
+
+static const struct file_operations firegl_debug_fops = {
+		.open = firegl_debug_proc_open,
+		.write = firegl_debug_proc_write_wrap,
+		.read = seq_read,
+		.llseek = seq_lseek,
+};
+#endif
+
 static struct proc_dir_entry *firegl_proc_init( device_t *dev,
                                                 int minor,
                                                 struct proc_dir_entry *root,
@@ -595,7 +638,11 @@
     KCL_DEBUG1(FN_FIREGL_PROC, "minor %d, proc_list 0x%08lx\n", minor, (unsigned long)proc_list);
     if (!minor)
     {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
         root = create_proc_entry("ati", S_IFDIR, NULL);
+#else
+		root = proc_mkdir("ati", NULL);
+#endif
     }
 
     if (!root)
@@ -607,18 +654,28 @@
     if (minor == 0)
     {
         // Global major debice number entry
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
         ent = create_proc_entry("major", S_IFREG|S_IRUGO, root);
+#else
+		ent = proc_create("major", S_IFREG|S_IRUGO, root, &firegl_major_fops);
+#endif
         if (!ent)
         {
             remove_proc_entry("ati", NULL);
             KCL_DEBUG_ERROR("Cannot create /proc/ati/major\n");
             return NULL;
         }
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
         ent->read_proc = (read_proc_t*)firegl_major_proc_read;
+#endif
     }
 
     sprintf(name, "%d", minor);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
     *dev_root = create_proc_entry(name, S_IFDIR, root);
+#else
+	*dev_root = proc_mkdir(name, root);
+#endif
     if (!*dev_root) {
         remove_proc_entry("major", root);
         remove_proc_entry("ati", NULL);
@@ -628,7 +685,12 @@
 
     while (list->f || list->fops)
     {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
         ent = create_proc_entry(list->name, S_IFREG|S_IRUGO, *dev_root);
+#else
+		ent = proc_create_data(list->name, S_IFREG|S_IRUGO, *dev_root, &firegl_fops,
+			(dev->pubdev.signature == FGL_DEVICE_SIGNATURE)? firegl_find_device(minor) : (dev));
+#endif
         if (!ent)
         {
             KCL_DEBUG_ERROR("Cannot create /proc/ati/%s/%s\n", name, list->name);
@@ -646,6 +708,7 @@
             return NULL;
         }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
         if (list->f)
         {
             ent->read_proc = (read_proc_t*)list->f;
@@ -659,19 +722,25 @@
         {
             ent->data = (dev->pubdev.signature == FGL_DEVICE_SIGNATURE)? firegl_find_device(minor) : (dev);
         }
-
+#endif
         list++;
     }
 
     if (minor == 0)
     {
         // Global debug entry, only create it once
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
         ent = create_proc_entry("debug", S_IFREG|S_IRUGO, root);
+#else
+        ent = proc_create_data("debug", S_IFREG|S_IRUGO, root, &firegl_debug_fops, dev);
+#endif
         if (ent) 
         {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
             ent->read_proc = (read_proc_t*)firegl_debug_proc_read_wrap;     
             ent->write_proc = (write_proc_t*)firegl_debug_proc_write_wrap;  
             ent->data = dev;
+#endif
         }
     }
 
@@ -1197,15 +1266,15 @@
     }
 #endif // FIREGL_USWC_SUPPORT
 
+    firegl_cleanup_devices();
+
     for (i = 0; i < count; i++)
     {
         if ( firegl_stub_unregister(i) ) 
         {
             KCL_DEBUG_ERROR("Cannot unload module on minor: %d\n", i);
         }
-    }
-
-    firegl_cleanup_devices();
+    }   
 
 #if !defined(KCL_OSCONFIG_IOCTL_COMPAT) && defined(__x86_64__)
     firegl_kill_32compat_ioctls();
@@ -3088,7 +3157,11 @@
 int ATI_API_CALL KCL_EFI_IS_ENABLED(void)
 {
 #ifdef CONFIG_EFI
+#ifdef EFI_BOOT
+    return efi_enabled(EFI_BOOT);
+#else
     return efi_enabled;
+#endif
 #else
     return 0;
 #endif
@@ -6131,4 +6204,71 @@
     kernel_fpu_end();
 }
 
+/** Create new directory entry under "/proc/ati/...."
+ * Where
+ * root_dir - Root directory. If NULL then we should use "/proc/ati" root.
+ * name    - Pointer to the name of directory
+ * access  - Access attribute. We could use it to disable access to the directory for everybody accept owner.
+ *                By default owner is root.
+ * Return NULL if failure. Pointer to proc_dir_entry otherwise
+ */
+void * KCL_create_proc_dir(void *root_dir, const char *name, unsigned int access)
+{
+    struct proc_dir_entry *dir = NULL;
+
+    if (root_dir == NULL)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
+         dir = create_proc_entry(name, S_IFDIR | access, firegl_stub_root);
+#else
+         dir = proc_mkdir(name, firegl_stub_root);
+#endif
+    else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
+         dir = create_proc_entry(name, S_IFDIR | access, (struct proc_dir_entry *)root_dir);
+#else
+         dir = proc_mkdir(name, (struct proc_dir_entry *)root_dir);
+#endif
+    return dir;
+}
+
+/* Remove proc directory entry
+ * root   - Pointer to directory proc entry or NULL if for "/proc/ati"
+ * name - Name to delete
+ */
+void KCL_remove_proc_dir_entry(void *root, const char *name)
+{
+    if (root == NULL)
+        remove_proc_entry(name, firegl_stub_root);
+    else
+        remove_proc_entry(name, (struct proc_dir_entry *)root);
+}
+
+
+/* Create proc_entry under "root_dir"
+ * read_fn - Function which will be called on read request
+ * write_fn - Function which will be called on write request
+ * private_data - Pointer to private data which will be passed
+ */
+void KCL_create_proc_entry(void *root_dir, const char *name, unsigned int access_mode, void *read_fn, void *write_fn, void *private_data)
+{
+    struct proc_dir_entry *ent = NULL;
+
+    if (root_dir == NULL || name == NULL)
+        return;
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
+    ent = create_proc_entry(name, access_mode, (struct proc_dir_entry *)root_dir);
+#else
+    ent = proc_create_data(name, access_mode, (struct proc_dir_entry *)root_dir, &firegl_fops, private_data);
+#endif
+    if (ent)
+    {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
+        ent->read_proc = (read_proc_t *)read_fn;    
+        ent->write_proc = (write_proc_t *)write_fn; 
+        ent->data = private_data;
+#endif
+    }
+}
+
 #endif /* __KERNEL__ */
