Merge 3.7-rc3 into char-misc-next
Greg Kroah-Hartman [Mon, 29 Oct 2012 15:44:40 +0000 (08:44 -0700)]
This brings in the various 3.7-rc3 char fixes into char-misc-next.

Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

23 files changed:
Documentation/DocBook/uio-howto.tmpl
arch/arm/include/asm/io.h
arch/arm/mm/mmap.c
arch/ia64/include/asm/io.h
arch/ia64/kernel/efi.c
arch/sh/include/asm/io.h
arch/sh/mm/mmap.c
drivers/char/mem.c
drivers/char/pc8736x_gpio.c
drivers/hv/channel.c
drivers/hv/channel_mgmt.c
drivers/misc/mei/init.c
drivers/misc/mei/interrupt.c
drivers/misc/mei/iorw.c
drivers/misc/mei/main.c
drivers/misc/mei/mei_dev.h
drivers/misc/ti-st/st_core.c
drivers/uio/Kconfig
drivers/uio/Makefile
drivers/uio/uio_dmem_genirq.c [new file with mode: 0644]
drivers/w1/masters/Kconfig
drivers/w1/masters/ds2482.c
include/linux/platform_data/uio_dmem_genirq.h [new file with mode: 0644]

index ac3d001..fdbf86f 100644 (file)
@@ -719,6 +719,62 @@ framework to set up sysfs files for this region. Simply leave it alone.
        </para>
 </sect1>
 
+<sect1 id="using uio_dmem_genirq">
+<title>Using uio_dmem_genirq for platform devices</title>
+       <para>
+       In addition to statically allocated memory ranges, they may also be
+       a desire to use dynamically allocated regions in a user space driver.
+       In particular, being able to access memory made available through the
+       dma-mapping API, may be particularly useful.  The
+       <varname>uio_dmem_genirq</varname> driver provides a way to accomplish
+       this.
+       </para>
+       <para>
+       This driver is used in a similar manner to the
+       <varname>"uio_pdrv_genirq"</varname> driver with respect to interrupt
+       configuration and handling.
+       </para>
+       <para>
+       Set the <varname>.name</varname> element of
+       <varname>struct platform_device</varname> to
+       <varname>"uio_dmem_genirq"</varname> to use this driver.
+       </para>
+       <para>
+       When using this driver, fill in the <varname>.platform_data</varname>
+       element of <varname>struct platform_device</varname>, which is of type
+       <varname>struct uio_dmem_genirq_pdata</varname> and which contains the
+       following elements:
+       </para>
+       <itemizedlist>
+       <listitem><varname>struct uio_info uioinfo</varname>: The same
+       structure used as the  <varname>uio_pdrv_genirq</varname> platform
+       data</listitem>
+       <listitem><varname>unsigned int *dynamic_region_sizes</varname>:
+       Pointer to list of sizes of dynamic memory regions to be mapped into
+       user space.
+       </listitem>
+       <listitem><varname>unsigned int num_dynamic_regions</varname>:
+       Number of elements in <varname>dynamic_region_sizes</varname> array.
+       </listitem>
+       </itemizedlist>
+       <para>
+       The dynamic regions defined in the platform data will be appended to
+       the <varname> mem[] </varname> array after the platform device
+       resources, which implies that the total number of static and dynamic
+       memory regions cannot exceed <varname>MAX_UIO_MAPS</varname>.
+       </para>
+       <para>
+       The dynamic memory regions will be allocated when the UIO device file,
+       <varname>/dev/uioX</varname> is opened.
+       Simiar to static memory resources, the memory region information for
+       dynamic regions is then visible via sysfs at
+       <varname>/sys/class/uio/uioX/maps/mapY/*</varname>.
+       The dynmaic memory regions will be freed when the UIO device file is
+       closed. When no processes are holding the device file open, the address
+       returned to userspace is DMA_ERROR_CODE.
+       </para>
+</sect1>
+
 </chapter>
 
 <chapter id="userspace_driver" xreflabel="Writing a driver in user space">
index 35c1ed8..f52a93d 100644 (file)
@@ -374,7 +374,7 @@ extern void pci_iounmap(struct pci_dev *dev, void __iomem *addr);
 
 #ifdef CONFIG_MMU
 #define ARCH_HAS_VALID_PHYS_ADDR_RANGE
-extern int valid_phys_addr_range(unsigned long addr, size_t size);
+extern int valid_phys_addr_range(phys_addr_t addr, size_t size);
 extern int valid_mmap_phys_addr_range(unsigned long pfn, size_t size);
 extern int devmem_is_allowed(unsigned long pfn);
 #endif
index ce8cb19..89f2b7f 100644 (file)
@@ -279,7 +279,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm)
  * You really shouldn't be using read() or write() on /dev/mem.  This
  * might go away in the future.
  */
-int valid_phys_addr_range(unsigned long addr, size_t size)
+int valid_phys_addr_range(phys_addr_t addr, size_t size)
 {
        if (addr < PHYS_OFFSET)
                return 0;
index 2c26321..74a7cc3 100644 (file)
@@ -90,7 +90,7 @@ phys_to_virt (unsigned long address)
 
 #define ARCH_HAS_VALID_PHYS_ADDR_RANGE
 extern u64 kern_mem_attribute (unsigned long phys_addr, unsigned long size);
-extern int valid_phys_addr_range (unsigned long addr, size_t count); /* efi.c */
+extern int valid_phys_addr_range (phys_addr_t addr, size_t count); /* efi.c */
 extern int valid_mmap_phys_addr_range (unsigned long pfn, size_t count);
 
 /*
index d37bbd4..f034563 100644 (file)
@@ -870,7 +870,7 @@ kern_mem_attribute (unsigned long phys_addr, unsigned long size)
 EXPORT_SYMBOL(kern_mem_attribute);
 
 int
-valid_phys_addr_range (unsigned long phys_addr, unsigned long size)
+valid_phys_addr_range (phys_addr_t phys_addr, unsigned long size)
 {
        u64 attr;
 
index 73a23f4..629db2a 100644 (file)
@@ -382,7 +382,7 @@ static inline int iounmap_fixed(void __iomem *addr) { return -EINVAL; }
 #define xlate_dev_kmem_ptr(p)  p
 
 #define ARCH_HAS_VALID_PHYS_ADDR_RANGE
-int valid_phys_addr_range(unsigned long addr, size_t size);
+int valid_phys_addr_range(phys_addr_t addr, size_t size);
 int valid_mmap_phys_addr_range(unsigned long pfn, size_t size);
 
 #endif /* __KERNEL__ */
index afeb710..80bf494 100644 (file)
@@ -238,7 +238,7 @@ bottomup:
  * You really shouldn't be using read() or write() on /dev/mem.  This
  * might go away in the future.
  */
-int valid_phys_addr_range(unsigned long addr, size_t count)
+int valid_phys_addr_range(phys_addr_t addr, size_t count)
 {
        if (addr < __MEMORY_START)
                return 0;
index 0537903..c6fa3bc 100644 (file)
@@ -48,7 +48,7 @@ static inline unsigned long size_inside_page(unsigned long start,
 }
 
 #ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
-static inline int valid_phys_addr_range(unsigned long addr, size_t count)
+static inline int valid_phys_addr_range(phys_addr_t addr, size_t count)
 {
        return addr + count <= __pa(high_memory);
 }
@@ -96,7 +96,7 @@ void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr)
 static ssize_t read_mem(struct file *file, char __user *buf,
                        size_t count, loff_t *ppos)
 {
-       unsigned long p = *ppos;
+       phys_addr_t p = *ppos;
        ssize_t read, sz;
        char *ptr;
 
@@ -153,7 +153,7 @@ static ssize_t read_mem(struct file *file, char __user *buf,
 static ssize_t write_mem(struct file *file, const char __user *buf,
                         size_t count, loff_t *ppos)
 {
-       unsigned long p = *ppos;
+       phys_addr_t p = *ppos;
        ssize_t written, sz;
        unsigned long copied;
        void *ptr;
@@ -226,7 +226,7 @@ int __weak phys_mem_access_prot_allowed(struct file *file,
  *
  */
 #ifdef pgprot_noncached
-static int uncached_access(struct file *file, unsigned long addr)
+static int uncached_access(struct file *file, phys_addr_t addr)
 {
 #if defined(CONFIG_IA64)
        /*
@@ -258,7 +258,7 @@ static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
                                     unsigned long size, pgprot_t vma_prot)
 {
 #ifdef pgprot_noncached
-       unsigned long offset = pfn << PAGE_SHIFT;
+       phys_addr_t offset = pfn << PAGE_SHIFT;
 
        if (uncached_access(file, offset))
                return pgprot_noncached(vma_prot);
index b304ec0..3f79a9f 100644 (file)
@@ -345,8 +345,7 @@ static void __exit pc8736x_gpio_cleanup(void)
        unregister_chrdev_region(MKDEV(major,0), PC8736X_GPIO_CT);
        release_region(pc8736x_gpio_base, PC8736X_GPIO_RANGE);
 
-       platform_device_del(pdev);
-       platform_device_put(pdev);
+       platform_device_unregister(pdev);
 }
 
 module_init(pc8736x_gpio_init);
index f4c3d28..773a2f2 100644 (file)
 #define NUM_PAGES_SPANNED(addr, len) \
 ((PAGE_ALIGN(addr + len) >> PAGE_SHIFT) - (addr >> PAGE_SHIFT))
 
-/* Internal routines */
-static int create_gpadl_header(
-       void *kbuffer,  /* must be phys and virt contiguous */
-       u32 size,       /* page-size multiple */
-       struct vmbus_channel_msginfo **msginfo,
-       u32 *messagecount);
-static void vmbus_setevent(struct vmbus_channel *channel);
-
 /*
  * vmbus_setevent- Trigger an event notification on the specified
  * channel.
index 2b8b8d4..2f84c5c 100644 (file)
@@ -265,14 +265,9 @@ static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
 {
        struct vmbus_channel_offer_channel *offer;
        struct vmbus_channel *newchannel;
-       uuid_le *guidtype;
-       uuid_le *guidinstance;
 
        offer = (struct vmbus_channel_offer_channel *)hdr;
 
-       guidtype = &offer->offer.if_type;
-       guidinstance = &offer->offer.if_instance;
-
        /* Allocate the channel object and save this offer. */
        newchannel = alloc_channel();
        if (!newchannel) {
@@ -470,7 +465,6 @@ static void vmbus_onversion_response(
 {
        struct vmbus_channel_msginfo *msginfo;
        struct vmbus_channel_message_header *requestheader;
-       struct vmbus_channel_initiate_contact *initiate;
        struct vmbus_channel_version_response *version_response;
        unsigned long flags;
 
@@ -484,8 +478,6 @@ static void vmbus_onversion_response(
 
                if (requestheader->msgtype ==
                    CHANNELMSG_INITIATE_CONTACT) {
-                       initiate =
-                       (struct vmbus_channel_initiate_contact *)requestheader;
                        memcpy(&msginfo->response.version_response,
                              version_response,
                              sizeof(struct vmbus_channel_version_response));
index 98f1430..1f13eb9 100644 (file)
@@ -48,34 +48,22 @@ const uuid_le mei_amthi_guid  = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, 0xac,
                                                0x81, 0x4c);
 
 /**
- * mei_io_list_init - Sets up a queue list.
- *
- * @list: An instance io list structure
- * @dev: the device structure
- */
-void mei_io_list_init(struct mei_io_list *list)
-{
-       /* initialize our queue list */
-       INIT_LIST_HEAD(&list->mei_cb.cb_list);
-}
-
-/**
  * mei_io_list_flush - removes list entry belonging to cl.
  *
  * @list:  An instance of our list structure
  * @cl: private data of the file object
  */
-void mei_io_list_flush(struct mei_io_list *list, struct mei_cl *cl)
+void mei_io_list_flush(struct mei_cl_cb *list, struct mei_cl *cl)
 {
        struct mei_cl_cb *pos;
        struct mei_cl_cb *next;
 
-       list_for_each_entry_safe(pos, next, &list->mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(pos, next, &list->list, list) {
                if (pos->file_private) {
                        struct mei_cl *cl_tmp;
                        cl_tmp = (struct mei_cl *)pos->file_private;
                        if (mei_cl_cmp_id(cl, cl_tmp))
-                               list_del(&pos->cb_list);
+                               list_del(&pos->list);
                }
        }
 }
@@ -351,10 +339,9 @@ void mei_reset(struct mei_device *dev, int interrupts_enabled)
                }
        }
        /* remove all waiting requests */
-       list_for_each_entry_safe(cb_pos, cb_next,
-                       &dev->write_list.mei_cb.cb_list, cb_list) {
-               list_del(&cb_pos->cb_list);
-               mei_free_cb_private(cb_pos);
+       list_for_each_entry_safe(cb_pos, cb_next, &dev->write_list.list, list) {
+               list_del(&cb_pos->list);
+               mei_io_cb_free(cb_pos);
        }
 }
 
@@ -681,12 +668,10 @@ int mei_disconnect_host_client(struct mei_device *dev, struct mei_cl *cl)
        if (cl->state != MEI_FILE_DISCONNECTING)
                return 0;
 
-       cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
+       cb = mei_io_cb_init(cl, NULL);
        if (!cb)
                return -ENOMEM;
 
-       INIT_LIST_HEAD(&cb->cb_list);
-       cb->file_private = cl;
        cb->major_file_operations = MEI_CLOSE;
        if (dev->mei_host_buffer_is_empty) {
                dev->mei_host_buffer_is_empty = false;
@@ -696,11 +681,11 @@ int mei_disconnect_host_client(struct mei_device *dev, struct mei_cl *cl)
                        goto free;
                }
                mdelay(10); /* Wait for hardware disconnection ready */
-               list_add_tail(&cb->cb_list, &dev->ctrl_rd_list.mei_cb.cb_list);
+               list_add_tail(&cb->list, &dev->ctrl_rd_list.list);
        } else {
                dev_dbg(&dev->pdev->dev, "add disconnect cb to control write list\n");
-               list_add_tail(&cb->cb_list,
-                               &dev->ctrl_wr_list.mei_cb.cb_list);
+               list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
+
        }
        mutex_unlock(&dev->device_lock);
 
@@ -728,7 +713,7 @@ int mei_disconnect_host_client(struct mei_device *dev, struct mei_cl *cl)
        mei_io_list_flush(&dev->ctrl_rd_list, cl);
        mei_io_list_flush(&dev->ctrl_wr_list, cl);
 free:
-       mei_free_cb_private(cb);
+       mei_io_cb_free(cb);
        return rets;
 }
 
index 3533edd..5c65bac 100644 (file)
@@ -58,7 +58,7 @@ irqreturn_t mei_interrupt_quick_handler(int irq, void *dev_id)
 static void _mei_cmpl(struct mei_cl *cl, struct mei_cl_cb *cb_pos)
 {
        if (cb_pos->major_file_operations == MEI_WRITE) {
-               mei_free_cb_private(cb_pos);
+               mei_io_cb_free(cb_pos);
                cb_pos = NULL;
                cl->writing_state = MEI_WRITE_COMPLETE;
                if (waitqueue_active(&cl->tx_wait))
@@ -87,9 +87,8 @@ static void _mei_cmpl_iamthif(struct mei_device *dev, struct mei_cl_cb *cb_pos)
                memcpy(cb_pos->response_buffer.data,
                                dev->iamthif_msg_buf,
                                dev->iamthif_msg_buf_index);
-               list_add_tail(&cb_pos->cb_list,
-                               &dev->amthi_read_complete_list.mei_cb.cb_list);
-               dev_dbg(&dev->pdev->dev, "amthi read completed.\n");
+               list_add_tail(&cb_pos->list, &dev->amthi_read_complete_list.list);
+               dev_dbg(&dev->pdev->dev, "amthi read completed\n");
                dev->iamthif_timer = jiffies;
                dev_dbg(&dev->pdev->dev, "dev->iamthif_timer = %ld\n",
                                dev->iamthif_timer);
@@ -112,7 +111,7 @@ static void _mei_cmpl_iamthif(struct mei_device *dev, struct mei_cl_cb *cb_pos)
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_read_amthi_message(struct mei_io_list *complete_list,
+static int mei_irq_thread_read_amthi_message(struct mei_cl_cb *complete_list,
                struct mei_device *dev,
                struct mei_msg_hdr *mei_hdr)
 {
@@ -149,14 +148,13 @@ static int mei_irq_thread_read_amthi_message(struct mei_io_list *complete_list,
                return -ENODEV;
 
        dev->iamthif_stall_timer = 0;
-       cb->information =       dev->iamthif_msg_buf_index;
+       cb->buf_idx = dev->iamthif_msg_buf_index;
        cb->read_time = jiffies;
        if (dev->iamthif_ioctl && cl == &dev->iamthif_cl) {
                /* found the iamthif cb */
                dev_dbg(&dev->pdev->dev, "complete the amthi read cb.\n ");
                dev_dbg(&dev->pdev->dev, "add the amthi read cb to complete.\n ");
-               list_add_tail(&cb->cb_list,
-                                               &complete_list->mei_cb.cb_list);
+               list_add_tail(&cb->list, &complete_list->list);
        }
        return 0;
 }
@@ -188,7 +186,7 @@ static int _mei_irq_thread_state_ok(struct mei_cl *cl,
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
+static int mei_irq_thread_read_client_message(struct mei_cl_cb *complete_list,
                struct mei_device *dev,
                struct mei_msg_hdr *mei_hdr)
 {
@@ -197,36 +195,36 @@ static int mei_irq_thread_read_client_message(struct mei_io_list *complete_list,
        unsigned char *buffer = NULL;
 
        dev_dbg(&dev->pdev->dev, "start client msg\n");
-       if (list_empty(&dev->read_list.mei_cb.cb_list))
+       if (list_empty(&dev->read_list.list))
                goto quit;
 
-       list_for_each_entry_safe(cb_pos, cb_next,
-                       &dev->read_list.mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(cb_pos, cb_next, &dev->read_list.list, list) {
                cl = (struct mei_cl *)cb_pos->file_private;
                if (cl && _mei_irq_thread_state_ok(cl, mei_hdr)) {
                        cl->reading_state = MEI_READING;
-                       buffer = cb_pos->response_buffer.data + cb_pos->information;
+                       buffer = cb_pos->response_buffer.data + cb_pos->buf_idx;
 
                        if (cb_pos->response_buffer.size <
-                                       mei_hdr->length + cb_pos->information) {
+                                       mei_hdr->length + cb_pos->buf_idx) {
                                dev_dbg(&dev->pdev->dev, "message overflow.\n");
-                               list_del(&cb_pos->cb_list);
+                               list_del(&cb_pos->list);
                                return -ENOMEM;
                        }
                        if (buffer)
                                mei_read_slots(dev, buffer, mei_hdr->length);
 
-                       cb_pos->information += mei_hdr->length;
+                       cb_pos->buf_idx += mei_hdr->length;
                        if (mei_hdr->msg_complete) {
                                cl->status = 0;
-                               list_del(&cb_pos->cb_list);
+                               list_del(&cb_pos->list);
                                dev_dbg(&dev->pdev->dev,
                                        "completed read H cl = %d, ME cl = %d, length = %lu\n",
                                        cl->host_client_id,
                                        cl->me_client_id,
-                                       cb_pos->information);
-                               list_add_tail(&cb_pos->cb_list,
-                                       &complete_list->mei_cb.cb_list);
+                                       cb_pos->buf_idx);
+
+                               list_add_tail(&cb_pos->list,
+                                               &complete_list->list);
                        }
 
                        break;
@@ -290,7 +288,7 @@ static int _mei_irq_thread_iamthif_read(struct mei_device *dev, s32 *slots)
 static int _mei_irq_thread_close(struct mei_device *dev, s32 *slots,
                                struct mei_cl_cb *cb_pos,
                                struct mei_cl *cl,
-                               struct mei_io_list *cmpl_list)
+                               struct mei_cl_cb *cmpl_list)
 {
        if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
                        sizeof(struct hbm_client_disconnect_request)))
@@ -300,16 +298,14 @@ static int _mei_irq_thread_close(struct mei_device *dev, s32 *slots,
 
        if (mei_disconnect(dev, cl)) {
                cl->status = 0;
-               cb_pos->information = 0;
-               list_move_tail(&cb_pos->cb_list,
-                               &cmpl_list->mei_cb.cb_list);
+               cb_pos->buf_idx = 0;
+               list_move_tail(&cb_pos->list, &cmpl_list->list);
                return -EMSGSIZE;
        } else {
                cl->state = MEI_FILE_DISCONNECTING;
                cl->status = 0;
-               cb_pos->information = 0;
-               list_move_tail(&cb_pos->cb_list,
-                               &dev->ctrl_rd_list.mei_cb.cb_list);
+               cb_pos->buf_idx = 0;
+               list_move_tail(&cb_pos->list, &dev->ctrl_rd_list.list);
                cl->timer_count = MEI_CONNECT_TIMEOUT;
        }
 
@@ -356,7 +352,7 @@ static void mei_client_connect_response(struct mei_device *dev,
 {
 
        struct mei_cl *cl;
-       struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
+       struct mei_cl_cb *pos = NULL, *next = NULL;
 
        dev_dbg(&dev->pdev->dev,
                        "connect_response:\n"
@@ -382,17 +378,16 @@ static void mei_client_connect_response(struct mei_device *dev,
                dev->iamthif_state = MEI_IAMTHIF_IDLE;
                return;
        }
-       list_for_each_entry_safe(cb_pos, cb_next,
-                               &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(pos, next, &dev->ctrl_rd_list.list, list) {
 
-               cl = (struct mei_cl *)cb_pos->file_private;
+               cl = (struct mei_cl *)pos->file_private;
                if (!cl) {
-                       list_del(&cb_pos->cb_list);
+                       list_del(&pos->list);
                        return;
                }
-               if (MEI_IOCTL == cb_pos->major_file_operations) {
+               if (MEI_IOCTL == pos->major_file_operations) {
                        if (is_treat_specially_client(cl, rs)) {
-                               list_del(&cb_pos->cb_list);
+                               list_del(&pos->list);
                                cl->status = 0;
                                cl->timer_count = 0;
                                break;
@@ -411,7 +406,7 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                                        struct hbm_client_connect_response *rs)
 {
        struct mei_cl *cl;
-       struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
+       struct mei_cl_cb *pos = NULL, *next = NULL;
 
        dev_dbg(&dev->pdev->dev,
                        "disconnect_response:\n"
@@ -422,12 +417,11 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                        rs->host_addr,
                        rs->status);
 
-       list_for_each_entry_safe(cb_pos, cb_next,
-                       &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
-               cl = (struct mei_cl *)cb_pos->file_private;
+       list_for_each_entry_safe(pos, next, &dev->ctrl_rd_list.list, list) {
+               cl = (struct mei_cl *)pos->file_private;
 
                if (!cl) {
-                       list_del(&cb_pos->cb_list);
+                       list_del(&pos->list);
                        return;
                }
 
@@ -435,7 +429,7 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                if (cl->host_client_id == rs->host_addr &&
                    cl->me_client_id == rs->me_addr) {
 
-                       list_del(&cb_pos->cb_list);
+                       list_del(&pos->list);
                        if (!rs->status)
                                cl->state = MEI_FILE_DISCONNECTED;
 
@@ -821,12 +815,12 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
 static int _mei_irq_thread_read(struct mei_device *dev,        s32 *slots,
                        struct mei_cl_cb *cb_pos,
                        struct mei_cl *cl,
-                       struct mei_io_list *cmpl_list)
+                       struct mei_cl_cb *cmpl_list)
 {
        if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
                        sizeof(struct hbm_flow_control))) {
                /* return the cancel routine */
-               list_del(&cb_pos->cb_list);
+               list_del(&cb_pos->list);
                return -EBADMSG;
        }
 
@@ -834,11 +828,11 @@ static int _mei_irq_thread_read(struct mei_device *dev,   s32 *slots,
 
        if (mei_send_flow_control(dev, cl)) {
                cl->status = -ENODEV;
-               cb_pos->information = 0;
-               list_move_tail(&cb_pos->cb_list, &cmpl_list->mei_cb.cb_list);
+               cb_pos->buf_idx = 0;
+               list_move_tail(&cb_pos->list, &cmpl_list->list);
                return -ENODEV;
        }
-       list_move_tail(&cb_pos->cb_list, &dev->read_list.mei_cb.cb_list);
+       list_move_tail(&cb_pos->list, &dev->read_list.list);
 
        return 0;
 }
@@ -858,12 +852,12 @@ static int _mei_irq_thread_read(struct mei_device *dev,   s32 *slots,
 static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
                        struct mei_cl_cb *cb_pos,
                        struct mei_cl *cl,
-                       struct mei_io_list *cmpl_list)
+                       struct mei_cl_cb *cmpl_list)
 {
        if ((*slots * sizeof(u32)) < (sizeof(struct mei_msg_hdr) +
                        sizeof(struct hbm_client_connect_request))) {
                /* return the cancel routine */
-               list_del(&cb_pos->cb_list);
+               list_del(&cb_pos->list);
                return -EBADMSG;
        }
 
@@ -871,12 +865,11 @@ static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
         *slots -= mei_data2slots(sizeof(struct hbm_client_connect_request));
        if (mei_connect(dev, cl)) {
                cl->status = -ENODEV;
-               cb_pos->information = 0;
-               list_del(&cb_pos->cb_list);
+               cb_pos->buf_idx = 0;
+               list_del(&cb_pos->list);
                return -ENODEV;
        } else {
-               list_move_tail(&cb_pos->cb_list,
-                       &dev->ctrl_rd_list.mei_cb.cb_list);
+               list_move_tail(&cb_pos->list, &dev->ctrl_rd_list.list);
                cl->timer_count = MEI_CONNECT_TIMEOUT;
        }
        return 0;
@@ -896,45 +889,41 @@ static int _mei_irq_thread_ioctl(struct mei_device *dev, s32 *slots,
 static int _mei_irq_thread_cmpl(struct mei_device *dev,        s32 *slots,
                        struct mei_cl_cb *cb_pos,
                        struct mei_cl *cl,
-                       struct mei_io_list *cmpl_list)
+                       struct mei_cl_cb *cmpl_list)
 {
        struct mei_msg_hdr *mei_hdr;
 
        if ((*slots * sizeof(u32)) >= (sizeof(struct mei_msg_hdr) +
-                       (cb_pos->request_buffer.size -
-                       cb_pos->information))) {
+                       (cb_pos->request_buffer.size - cb_pos->buf_idx))) {
                mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
                mei_hdr->host_addr = cl->host_client_id;
                mei_hdr->me_addr = cl->me_client_id;
-               mei_hdr->length = cb_pos->request_buffer.size -
-                                       cb_pos->information;
+               mei_hdr->length = cb_pos->request_buffer.size - cb_pos->buf_idx;
                mei_hdr->msg_complete = 1;
                mei_hdr->reserved = 0;
                dev_dbg(&dev->pdev->dev, "cb_pos->request_buffer.size =%d"
                        "mei_hdr->msg_complete = %d\n",
                                cb_pos->request_buffer.size,
                                mei_hdr->msg_complete);
-               dev_dbg(&dev->pdev->dev, "cb_pos->information  =%lu\n",
-                               cb_pos->information);
+               dev_dbg(&dev->pdev->dev, "cb_pos->buf_idx  =%lu\n",
+                               cb_pos->buf_idx);
                dev_dbg(&dev->pdev->dev, "mei_hdr->length  =%d\n",
                                mei_hdr->length);
                *slots -= mei_data2slots(mei_hdr->length);
                if (mei_write_message(dev, mei_hdr,
                                (unsigned char *)
                                (cb_pos->request_buffer.data +
-                               cb_pos->information),
+                               cb_pos->buf_idx),
                                mei_hdr->length)) {
                        cl->status = -ENODEV;
-                       list_move_tail(&cb_pos->cb_list,
-                               &cmpl_list->mei_cb.cb_list);
+                       list_move_tail(&cb_pos->list, &cmpl_list->list);
                        return -ENODEV;
                } else {
                        if (mei_flow_ctrl_reduce(dev, cl))
                                return -ENODEV;
                        cl->status = 0;
-                       cb_pos->information += mei_hdr->length;
-                       list_move_tail(&cb_pos->cb_list,
-                               &dev->write_waiting_list.mei_cb.cb_list);
+                       cb_pos->buf_idx += mei_hdr->length;
+                       list_move_tail(&cb_pos->list, &dev->write_waiting_list.list);
                }
        } else if (*slots == dev->hbuf_depth) {
                /* buffer is still empty */
@@ -949,21 +938,20 @@ static int _mei_irq_thread_cmpl(struct mei_device *dev,   s32 *slots,
                if (mei_write_message(dev, mei_hdr,
                                        (unsigned char *)
                                        (cb_pos->request_buffer.data +
-                                       cb_pos->information),
+                                       cb_pos->buf_idx),
                                        mei_hdr->length)) {
                        cl->status = -ENODEV;
-                       list_move_tail(&cb_pos->cb_list,
-                               &cmpl_list->mei_cb.cb_list);
+                       list_move_tail(&cb_pos->list, &cmpl_list->list);
                        return -ENODEV;
                } else {
-                       cb_pos->information += mei_hdr->length;
+                       cb_pos->buf_idx += mei_hdr->length;
                        dev_dbg(&dev->pdev->dev,
                                        "cb_pos->request_buffer.size =%d"
                                        " mei_hdr->msg_complete = %d\n",
                                        cb_pos->request_buffer.size,
                                        mei_hdr->msg_complete);
-                       dev_dbg(&dev->pdev->dev, "cb_pos->information  =%lu\n",
-                                       cb_pos->information);
+                       dev_dbg(&dev->pdev->dev, "cb_pos->buf_idx  =%lu\n",
+                                       cb_pos->buf_idx);
                        dev_dbg(&dev->pdev->dev, "mei_hdr->length  =%d\n",
                                        mei_hdr->length);
                }
@@ -989,7 +977,7 @@ static int _mei_irq_thread_cmpl(struct mei_device *dev,     s32 *slots,
 static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                        struct mei_cl_cb *cb_pos,
                        struct mei_cl *cl,
-                       struct mei_io_list *cmpl_list)
+                       struct mei_cl_cb *cmpl_list)
 {
        struct mei_msg_hdr *mei_hdr;
 
@@ -1012,20 +1000,19 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                                        mei_hdr->length)) {
                        dev->iamthif_state = MEI_IAMTHIF_IDLE;
                        cl->status = -ENODEV;
-                       list_del(&cb_pos->cb_list);
+                       list_del(&cb_pos->list);
                        return -ENODEV;
                } else {
                        if (mei_flow_ctrl_reduce(dev, cl))
                                return -ENODEV;
                        dev->iamthif_msg_buf_index += mei_hdr->length;
-                       cb_pos->information = dev->iamthif_msg_buf_index;
+                       cb_pos->buf_idx = dev->iamthif_msg_buf_index;
                        cl->status = 0;
                        dev->iamthif_state = MEI_IAMTHIF_FLOW_CONTROL;
                        dev->iamthif_flow_control_pending = true;
                        /* save iamthif cb sent to amthi client */
                        dev->iamthif_current_cb = cb_pos;
-                       list_move_tail(&cb_pos->cb_list,
-                               &dev->write_waiting_list.mei_cb.cb_list);
+                       list_move_tail(&cb_pos->list, &dev->write_waiting_list.list);
 
                }
        } else if (*slots == dev->hbuf_depth) {
@@ -1045,7 +1032,7 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
                                        dev->iamthif_msg_buf_index),
                                        mei_hdr->length)) {
                        cl->status = -ENODEV;
-                       list_del(&cb_pos->cb_list);
+                       list_del(&cb_pos->list);
                } else {
                        dev->iamthif_msg_buf_index += mei_hdr->length;
                }
@@ -1067,7 +1054,7 @@ static int _mei_irq_thread_cmpl_iamthif(struct mei_device *dev, s32 *slots,
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_read_handler(struct mei_io_list *cmpl_list,
+static int mei_irq_thread_read_handler(struct mei_cl_cb *cmpl_list,
                struct mei_device *dev,
                s32 *slots)
 {
@@ -1170,14 +1157,13 @@ end:
  *
  * returns 0 on success, <0 on failure.
  */
-static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
-               struct mei_device *dev,
-               s32 *slots)
+static int mei_irq_thread_write_handler(struct mei_cl_cb *cmpl_list,
+               struct mei_device *dev, s32 *slots)
 {
 
        struct mei_cl *cl;
        struct mei_cl_cb *pos = NULL, *next = NULL;
-       struct mei_io_list *list;
+       struct mei_cl_cb *list;
        int ret;
 
        if (!mei_hbuf_is_empty(dev)) {
@@ -1192,20 +1178,19 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
        dev_dbg(&dev->pdev->dev, "complete all waiting for write cb.\n");
 
        list = &dev->write_waiting_list;
-       list_for_each_entry_safe(pos, next, &list->mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(pos, next, &list->list, list) {
                cl = (struct mei_cl *)pos->file_private;
                if (cl == NULL)
                        continue;
 
                cl->status = 0;
-               list_del(&pos->cb_list);
+               list_del(&pos->list);
                if (MEI_WRITING == cl->writing_state &&
                   (pos->major_file_operations == MEI_WRITE) &&
                   (cl != &dev->iamthif_cl)) {
                        dev_dbg(&dev->pdev->dev, "MEI WRITE COMPLETE\n");
                        cl->writing_state = MEI_WRITE_COMPLETE;
-                       list_add_tail(&pos->cb_list,
-                                     &cmpl_list->mei_cb.cb_list);
+                       list_add_tail(&pos->list, &cmpl_list->list);
                }
                if (cl == &dev->iamthif_cl) {
                        dev_dbg(&dev->pdev->dev, "check iamthif flow control.\n");
@@ -1251,11 +1236,10 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
 
        /* complete control write list CB */
        dev_dbg(&dev->pdev->dev, "complete control write list cb.\n");
-       list_for_each_entry_safe(pos, next,
-                               &dev->ctrl_wr_list.mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(pos, next, &dev->ctrl_wr_list.list, list) {
                cl = (struct mei_cl *) pos->file_private;
                if (!cl) {
-                       list_del(&pos->cb_list);
+                       list_del(&pos->list);
                        return -ENODEV;
                }
                switch (pos->major_file_operations) {
@@ -1290,8 +1274,7 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
        }
        /* complete  write list CB */
        dev_dbg(&dev->pdev->dev, "complete write list cb.\n");
-       list_for_each_entry_safe(pos, next,
-                               &dev->write_list.mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(pos, next, &dev->write_list.list, list) {
                cl = (struct mei_cl *)pos->file_private;
                if (cl == NULL)
                        continue;
@@ -1385,11 +1368,10 @@ void mei_timer(struct work_struct *work)
                        dev->iamthif_state = MEI_IAMTHIF_IDLE;
                        dev->iamthif_timer = 0;
 
-                       if (dev->iamthif_current_cb)
-                               mei_free_cb_private(dev->iamthif_current_cb);
+                       mei_io_cb_free(dev->iamthif_current_cb);
+                       dev->iamthif_current_cb = NULL;
 
                        dev->iamthif_file_object = NULL;
-                       dev->iamthif_current_cb = NULL;
                        mei_run_next_iamthif_cmd(dev);
                }
        }
@@ -1411,23 +1393,21 @@ void mei_timer(struct work_struct *work)
 
                        dev_dbg(&dev->pdev->dev, "freeing AMTHI for other requests\n");
 
-                       amthi_complete_list = &dev->amthi_read_complete_list.
-                                       mei_cb.cb_list;
+                       amthi_complete_list = &dev->amthi_read_complete_list.list;
 
-                       list_for_each_entry_safe(cb_pos, cb_next, amthi_complete_list, cb_list) {
+                       list_for_each_entry_safe(cb_pos, cb_next, amthi_complete_list, list) {
 
                                cl_pos = cb_pos->file_object->private_data;
 
                                /* Finding the AMTHI entry. */
                                if (cl_pos == &dev->iamthif_cl)
-                                       list_del(&cb_pos->cb_list);
+                                       list_del(&cb_pos->list);
                        }
-                       if (dev->iamthif_current_cb)
-                               mei_free_cb_private(dev->iamthif_current_cb);
+                       mei_io_cb_free(dev->iamthif_current_cb);
+                       dev->iamthif_current_cb = NULL;
 
                        dev->iamthif_file_object->private_data = NULL;
                        dev->iamthif_file_object = NULL;
-                       dev->iamthif_current_cb = NULL;
                        dev->iamthif_timer = 0;
                        mei_run_next_iamthif_cmd(dev);
 
@@ -1451,7 +1431,7 @@ out:
 irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id)
 {
        struct mei_device *dev = (struct mei_device *) dev_id;
-       struct mei_io_list complete_list;
+       struct mei_cl_cb complete_list;
        struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
        struct mei_cl *cl;
        s32 slots;
@@ -1531,14 +1511,13 @@ end:
                wake_up_interruptible(&dev->wait_recvd_msg);
                bus_message_received = false;
        }
-       if (list_empty(&complete_list.mei_cb.cb_list))
+       if (list_empty(&complete_list.list))
                return IRQ_HANDLED;
 
 
-       list_for_each_entry_safe(cb_pos, cb_next,
-                       &complete_list.mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(cb_pos, cb_next, &complete_list.list, list) {
                cl = (struct mei_cl *)cb_pos->file_private;
-               list_del(&cb_pos->cb_list);
+               list_del(&cb_pos->list);
                if (cl) {
                        if (cl != &dev->iamthif_cl) {
                                dev_dbg(&dev->pdev->dev, "completing call back.\n");
index fcba98e..541c157 100644 (file)
 #include "interface.h"
 
 /**
+ * mei_io_cb_free - free mei_cb_private related memory
+ *
+ * @cb: mei callback struct
+ */
+void mei_io_cb_free(struct mei_cl_cb *cb)
+{
+       if (cb == NULL)
+               return;
+
+       kfree(cb->request_buffer.data);
+       kfree(cb->response_buffer.data);
+       kfree(cb);
+}
+/**
+ * mei_io_cb_init - allocate and initialize io callback
+ *
+ * @cl - mei client
+ * @file: pointer to file structure
+ *
+ * returns mei_cl_cb pointer or NULL;
+ */
+struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl, struct file *fp)
+{
+       struct mei_cl_cb *cb;
+
+       cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
+       if (!cb)
+               return NULL;
+
+       mei_io_list_init(cb);
+
+       cb->file_object = fp;
+       cb->file_private = cl;
+       cb->buf_idx = 0;
+       return cb;
+}
+
+
+/**
+ * mei_io_cb_alloc_req_buf - allocate request buffer
+ *
+ * @cb -  io callback structure
+ * @size: size of the buffer
+ *
+ * returns 0 on success
+ *         -EINVAL if cb is NULL
+ *         -ENOMEM if allocation failed
+ */
+int mei_io_cb_alloc_req_buf(struct mei_cl_cb *cb, size_t length)
+{
+       if (!cb)
+               return -EINVAL;
+
+       if (length == 0)
+               return 0;
+
+       cb->request_buffer.data = kmalloc(length, GFP_KERNEL);
+       if (!cb->request_buffer.data)
+               return -ENOMEM;
+       cb->request_buffer.size = length;
+       return 0;
+}
+/**
+ * mei_io_cb_alloc_req_buf - allocate respose buffer
+ *
+ * @cb -  io callback structure
+ * @size: size of the buffer
+ *
+ * returns 0 on success
+ *         -EINVAL if cb is NULL
+ *         -ENOMEM if allocation failed
+ */
+int mei_io_cb_alloc_resp_buf(struct mei_cl_cb *cb, size_t length)
+{
+       if (!cb)
+               return -EINVAL;
+
+       if (length == 0)
+               return 0;
+
+       cb->response_buffer.data = kmalloc(length, GFP_KERNEL);
+       if (!cb->response_buffer.data)
+               return -ENOMEM;
+       cb->response_buffer.size = length;
+       return 0;
+}
+
+
+/**
  * mei_me_cl_by_id return index to me_clients for client_id
  *
  * @dev: the device structure
@@ -97,14 +186,12 @@ int mei_ioctl_connect_client(struct file *file,
 
        dev_dbg(&dev->pdev->dev, "mei_ioctl_connect_client() Entry\n");
 
-
        /* buffered ioctl cb */
-       cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
+       cb = mei_io_cb_init(cl, file);
        if (!cb) {
                rets = -ENOMEM;
                goto end;
        }
-       INIT_LIST_HEAD(&cb->cb_list);
 
        cb->major_file_operations = MEI_IOCTL;
 
@@ -192,19 +279,14 @@ int mei_ioctl_connect_client(struct file *file,
                } else {
                        dev_dbg(&dev->pdev->dev, "Sending connect message - succeeded\n");
                        cl->timer_count = MEI_CONNECT_TIMEOUT;
-                       cb->file_private = cl;
-                       list_add_tail(&cb->cb_list,
-                                     &dev->ctrl_rd_list.mei_cb.
-                                     cb_list);
+                       list_add_tail(&cb->list, &dev->ctrl_rd_list.list);
                }
 
 
        } else {
                dev_dbg(&dev->pdev->dev, "Queuing the connect request due to device busy\n");
-               cb->file_private = cl;
                dev_dbg(&dev->pdev->dev, "add connect cb to control write list.\n");
-               list_add_tail(&cb->cb_list,
-                             &dev->ctrl_wr_list.mei_cb.cb_list);
+               list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
        }
        mutex_unlock(&dev->device_lock);
        err = wait_event_timeout(dev->wait_recvd_msg,
@@ -234,7 +316,7 @@ int mei_ioctl_connect_client(struct file *file,
        rets = 0;
 end:
        dev_dbg(&dev->pdev->dev, "free connect cb memory.");
-       kfree(cb);
+       mei_io_cb_free(cb);
        return rets;
 }
 
@@ -255,7 +337,7 @@ struct mei_cl_cb *find_amthi_read_list_entry(
        struct mei_cl_cb *next = NULL;
 
        list_for_each_entry_safe(pos, next,
-           &dev->amthi_read_complete_list.mei_cb.cb_list, cb_list) {
+           &dev->amthi_read_complete_list.list, list) {
                cl_temp = (struct mei_cl *)pos->file_private;
                if (cl_temp && cl_temp == &dev->iamthif_cl &&
                        pos->file_object == file)
@@ -340,17 +422,17 @@ int amthi_read(struct mei_device *dev, struct file *file,
                if  (time_after(jiffies, timeout)) {
                        dev_dbg(&dev->pdev->dev, "amthi Time out\n");
                        /* 15 sec for the message has expired */
-                       list_del(&cb->cb_list);
+                       list_del(&cb->list);
                        rets = -ETIMEDOUT;
                        goto free;
                }
        }
        /* if the whole message will fit remove it from the list */
-       if (cb->information >= *offset && length >= (cb->information - *offset))
-               list_del(&cb->cb_list);
-       else if (cb->information > 0 && cb->information <= *offset) {
+       if (cb->buf_idx >= *offset && length >= (cb->buf_idx - *offset))
+               list_del(&cb->list);
+       else if (cb->buf_idx > 0 && cb->buf_idx <= *offset) {
                /* end of the message has been reached */
-               list_del(&cb->cb_list);
+               list_del(&cb->list);
                rets = 0;
                goto free;
        }
@@ -360,18 +442,17 @@ int amthi_read(struct mei_device *dev, struct file *file,
 
        dev_dbg(&dev->pdev->dev, "amthi cb->response_buffer size - %d\n",
            cb->response_buffer.size);
-       dev_dbg(&dev->pdev->dev, "amthi cb->information - %lu\n",
-           cb->information);
+       dev_dbg(&dev->pdev->dev, "amthi cb->buf_idx - %lu\n", cb->buf_idx);
 
        /* length is being turncated to PAGE_SIZE, however,
-        * the information may be longer */
-       length = min_t(size_t, length, (cb->information - *offset));
+        * the buf_idx may point beyond */
+       length = min_t(size_t, length, (cb->buf_idx - *offset));
 
        if (copy_to_user(ubuf, cb->response_buffer.data + *offset, length))
                rets = -EFAULT;
        else {
                rets = length;
-               if ((*offset + length) < cb->information) {
+               if ((*offset + length) < cb->buf_idx) {
                        *offset += length;
                        goto out;
                }
@@ -379,7 +460,7 @@ int amthi_read(struct mei_device *dev, struct file *file,
 free:
        dev_dbg(&dev->pdev->dev, "free amthi cb memory.\n");
        *offset = 0;
-       mei_free_cb_private(cb);
+       mei_io_cb_free(cb);
 out:
        return rets;
 }
@@ -396,7 +477,7 @@ out:
 int mei_start_read(struct mei_device *dev, struct mei_cl *cl)
 {
        struct mei_cl_cb *cb;
-       int rets = 0;
+       int rets;
        int i;
 
        if (cl->state != MEI_FILE_CONNECTED)
@@ -405,50 +486,41 @@ int mei_start_read(struct mei_device *dev, struct mei_cl *cl)
        if (dev->dev_state != MEI_DEV_ENABLED)
                return -ENODEV;
 
-       dev_dbg(&dev->pdev->dev, "check if read is pending.\n");
        if (cl->read_pending || cl->read_cb) {
                dev_dbg(&dev->pdev->dev, "read is pending.\n");
                return -EBUSY;
        }
+       i = mei_me_cl_by_id(dev, cl->me_client_id);
+       if (i < 0) {
+               dev_err(&dev->pdev->dev, "no such me client %d\n",
+                       cl->me_client_id);
+               return  -ENODEV;
+       }
 
-       cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
+       cb = mei_io_cb_init(cl, NULL);
        if (!cb)
                return -ENOMEM;
 
-       dev_dbg(&dev->pdev->dev, "allocation call back successful. host client = %d, ME client = %d\n",
-               cl->host_client_id, cl->me_client_id);
-       i = mei_me_cl_by_id(dev, cl->me_client_id);
-       if (i < 0) {
-               rets = -ENODEV;
-               goto unlock;
-       }
+       rets = mei_io_cb_alloc_resp_buf(cb,
+                       dev->me_clients[i].props.max_msg_length);
+       if (rets)
+               goto err;
 
-       cb->response_buffer.size = dev->me_clients[i].props.max_msg_length;
-       cb->response_buffer.data =
-                       kmalloc(cb->response_buffer.size, GFP_KERNEL);
-       if (!cb->response_buffer.data) {
-               rets = -ENOMEM;
-               goto unlock;
-       }
-       dev_dbg(&dev->pdev->dev, "allocation call back data success.\n");
        cb->major_file_operations = MEI_READ;
-       /* make sure information is zero before we start */
-       cb->information = 0;
-       cb->file_private = (void *) cl;
        cl->read_cb = cb;
        if (dev->mei_host_buffer_is_empty) {
                dev->mei_host_buffer_is_empty = false;
                if (mei_send_flow_control(dev, cl)) {
                        rets = -ENODEV;
-                       goto unlock;
+                       goto err;
                }
-               list_add_tail(&cb->cb_list, &dev->read_list.mei_cb.cb_list);
+               list_add_tail(&cb->list, &dev->read_list.list);
        } else {
-               list_add_tail(&cb->cb_list, &dev->ctrl_wr_list.mei_cb.cb_list);
+               list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
        }
        return rets;
-unlock:
-       mei_free_cb_private(cb);
+err:
+       mei_io_cb_free(cb);
        return rets;
 }
 
@@ -511,13 +583,11 @@ int amthi_write(struct mei_device *dev, struct mei_cl_cb *cb)
                        dev_dbg(&dev->pdev->dev, "add amthi cb to write waiting list\n");
                        dev->iamthif_current_cb = cb;
                        dev->iamthif_file_object = cb->file_object;
-                       list_add_tail(&cb->cb_list,
-                                     &dev->write_waiting_list.mei_cb.cb_list);
+                       list_add_tail(&cb->list, &dev->write_waiting_list.list);
                } else {
                        dev_dbg(&dev->pdev->dev, "message does not complete, "
                                        "so add amthi cb to write list.\n");
-                       list_add_tail(&cb->cb_list,
-                                     &dev->write_list.mei_cb.cb_list);
+                       list_add_tail(&cb->list, &dev->write_list.list);
                }
        } else {
                if (!(dev->mei_host_buffer_is_empty))
@@ -525,7 +595,7 @@ int amthi_write(struct mei_device *dev, struct mei_cl_cb *cb)
 
                dev_dbg(&dev->pdev->dev, "No flow control credentials, "
                                "so add iamthif cb to write list.\n");
-               list_add_tail(&cb->cb_list, &dev->write_list.mei_cb.cb_list);
+               list_add_tail(&cb->list, &dev->write_list.list);
        }
        return 0;
 }
@@ -557,9 +627,8 @@ void mei_run_next_iamthif_cmd(struct mei_device *dev)
 
        dev_dbg(&dev->pdev->dev, "complete amthi cmd_list cb.\n");
 
-       list_for_each_entry_safe(pos, next,
-                       &dev->amthi_cmd_list.mei_cb.cb_list, cb_list) {
-               list_del(&pos->cb_list);
+       list_for_each_entry_safe(pos, next, &dev->amthi_cmd_list.list, list) {
+               list_del(&pos->list);
                cl_tmp = (struct mei_cl *)pos->file_private;
 
                if (cl_tmp && cl_tmp == &dev->iamthif_cl) {
@@ -575,17 +644,3 @@ void mei_run_next_iamthif_cmd(struct mei_device *dev)
        }
 }
 
-/**
- * mei_free_cb_private - free mei_cb_private related memory
- *
- * @cb: mei callback struct
- */
-void mei_free_cb_private(struct mei_cl_cb *cb)
-{
-       if (cb == NULL)
-               return;
-
-       kfree(cb->request_buffer.data);
-       kfree(cb->response_buffer.data);
-       kfree(cb);
-}
index e8b0858..ed4943f 100644 (file)
@@ -111,12 +111,12 @@ static bool mei_clear_list(struct mei_device *dev,
        bool removed = false;
 
        /* list all list member */
-       list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, cb_list) {
+       list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, list) {
                file_temp = (struct file *)cb_pos->file_object;
                /* check if list member associated with a file */
                if (file_temp == file) {
                        /* remove member from the list */
-                       list_del(&cb_pos->cb_list);
+                       list_del(&cb_pos->list);
                        /* check if cb equal to current iamthif cb */
                        if (dev->iamthif_current_cb == cb_pos) {
                                dev->iamthif_current_cb = NULL;
@@ -124,7 +124,7 @@ static bool mei_clear_list(struct mei_device *dev,
                                mei_send_flow_control(dev, &dev->iamthif_cl);
                        }
                        /* free all allocated buffers */
-                       mei_free_cb_private(cb_pos);
+                       mei_io_cb_free(cb_pos);
                        cb_pos = NULL;
                        removed = true;
                }
@@ -148,20 +148,20 @@ static bool mei_clear_lists(struct mei_device *dev, struct file *file)
        bool removed = false;
 
        /* remove callbacks associated with a file */
-       mei_clear_list(dev, file, &dev->amthi_cmd_list.mei_cb.cb_list);
+       mei_clear_list(dev, file, &dev->amthi_cmd_list.list);
        if (mei_clear_list(dev, file,
-                           &dev->amthi_read_complete_list.mei_cb.cb_list))
+                           &dev->amthi_read_complete_list.list))
                removed = true;
 
-       mei_clear_list(dev, file, &dev->ctrl_rd_list.mei_cb.cb_list);
+       mei_clear_list(dev, file, &dev->ctrl_rd_list.list);
 
-       if (mei_clear_list(dev, file, &dev->ctrl_wr_list.mei_cb.cb_list))
+       if (mei_clear_list(dev, file, &dev->ctrl_wr_list.list))
                removed = true;
 
-       if (mei_clear_list(dev, file, &dev->write_waiting_list.mei_cb.cb_list))
+       if (mei_clear_list(dev, file, &dev->write_waiting_list.list))
                removed = true;
 
-       if (mei_clear_list(dev, file, &dev->write_list.mei_cb.cb_list))
+       if (mei_clear_list(dev, file, &dev->write_list.list))
                removed = true;
 
        /* check if iamthif_current_cb not NULL */
@@ -169,7 +169,7 @@ static bool mei_clear_lists(struct mei_device *dev, struct file *file)
                /* check file and iamthif current cb association */
                if (dev->iamthif_current_cb->file_object == file) {
                        /* remove cb */
-                       mei_free_cb_private(dev->iamthif_current_cb);
+                       mei_io_cb_free(dev->iamthif_current_cb);
                        dev->iamthif_current_cb = NULL;
                        removed = true;
                }
@@ -192,8 +192,7 @@ static struct mei_cl_cb *find_read_list_entry(
        struct mei_cl_cb *next = NULL;
 
        dev_dbg(&dev->pdev->dev, "remove read_list CB\n");
-       list_for_each_entry_safe(pos, next,
-                       &dev->read_list.mei_cb.cb_list, cb_list) {
+       list_for_each_entry_safe(pos, next, &dev->read_list.list, list) {
                struct mei_cl *cl_temp;
                cl_temp = (struct mei_cl *)pos->file_private;
 
@@ -324,7 +323,7 @@ static int mei_release(struct inode *inode, struct file *file)
                        cb = find_read_list_entry(dev, cl);
                        /* Remove entry from read list */
                        if (cb)
-                               list_del(&cb->cb_list);
+                               list_del(&cb->list);
 
                        cb = cl->read_cb;
                        cl->read_cb = NULL;
@@ -333,7 +332,7 @@ static int mei_release(struct inode *inode, struct file *file)
                file->private_data = NULL;
 
                if (cb) {
-                       mei_free_cb_private(cb);
+                       mei_io_cb_free(cb);
                        cb = NULL;
                }
 
@@ -415,16 +414,15 @@ static ssize_t mei_read(struct file *file, char __user *ubuf,
                goto out;
        }
 
-       if (cl->read_cb && cl->read_cb->information > *offset) {
+       if (cl->read_cb && cl->read_cb->buf_idx > *offset) {
                cb = cl->read_cb;
                goto copy_buffer;
-       } else if (cl->read_cb && cl->read_cb->information > 0 &&
-                  cl->read_cb->information <= *offset) {
+       } else if (cl->read_cb && cl->read_cb->buf_idx > 0 &&
+                  cl->read_cb->buf_idx <= *offset) {
                cb = cl->read_cb;
                rets = 0;
                goto free;
-       } else if ((!cl->read_cb || !cl->read_cb->information) &&
-                   *offset > 0) {
+       } else if ((!cl->read_cb || !cl->read_cb->buf_idx) && *offset > 0) {
                /*Offset needs to be cleaned for contiguous reads*/
                *offset = 0;
                rets = 0;
@@ -481,16 +479,15 @@ static ssize_t mei_read(struct file *file, char __user *ubuf,
 copy_buffer:
        dev_dbg(&dev->pdev->dev, "cb->response_buffer size - %d\n",
            cb->response_buffer.size);
-       dev_dbg(&dev->pdev->dev, "cb->information - %lu\n",
-           cb->information);
-       if (length == 0 || ubuf == NULL || *offset > cb->information) {
+       dev_dbg(&dev->pdev->dev, "cb->buf_idx - %lu\n", cb->buf_idx);
+       if (length == 0 || ubuf == NULL || *offset > cb->buf_idx) {
                rets = -EMSGSIZE;
                goto free;
        }
 
-       /* length is being truncated to PAGE_SIZE, however, */
-       /* information size may be longer */
-       length = min_t(size_t, length, (cb->information - *offset));
+       /* length is being truncated to PAGE_SIZE,
+        * however buf_idx may point beyond that */
+       length = min_t(size_t, length, cb->buf_idx - *offset);
 
        if (copy_to_user(ubuf, cb->response_buffer.data + *offset, length)) {
                rets = -EFAULT;
@@ -499,15 +496,15 @@ copy_buffer:
 
        rets = length;
        *offset += length;
-       if ((unsigned long)*offset < cb->information)
+       if ((unsigned long)*offset < cb->buf_idx)
                goto out;
 
 free:
        cb_pos = find_read_list_entry(dev, cl);
        /* Remove entry from read list */
        if (cb_pos)
-               list_del(&cb_pos->cb_list);
-       mei_free_cb_private(cb);
+               list_del(&cb_pos->list);
+       mei_io_cb_free(cb);
        cl->reading_state = MEI_IDLE;
        cl->read_cb = NULL;
        cl->read_pending = 0;
@@ -516,7 +513,6 @@ out:
        mutex_unlock(&dev->device_lock);
        return rets;
 }
-
 /**
  * mei_write - the write function.
  *
@@ -546,10 +542,26 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
        mutex_lock(&dev->device_lock);
 
        if (dev->dev_state != MEI_DEV_ENABLED) {
-               mutex_unlock(&dev->device_lock);
-               return -ENODEV;
+               rets = -ENODEV;
+               goto unlock_dev;
        }
 
+       i = mei_me_cl_by_id(dev, cl->me_client_id);
+       if (i < 0) {
+               rets = -ENODEV;
+               goto unlock_dev;
+       }
+       if (length > dev->me_clients[i].props.max_msg_length || length <= 0) {
+               rets = -EMSGSIZE;
+               goto unlock_dev;
+       }
+
+       if (cl->state != MEI_FILE_CONNECTED) {
+               rets = -ENODEV;
+               dev_err(&dev->pdev->dev, "host client = %d,  is not connected to ME client = %d",
+                       cl->host_client_id, cl->me_client_id);
+               goto unlock_dev;
+       }
        if (cl == &dev->iamthif_cl) {
                write_cb = find_amthi_read_list_entry(dev, file);
 
@@ -558,11 +570,11 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
                                        msecs_to_jiffies(IAMTHIF_READ_TIMER);
 
                        if (time_after(jiffies, timeout) ||
-                                cl->reading_state == MEI_READ_COMPLETE) {
-                                       *offset = 0;
-                                       list_del(&write_cb->cb_list);
-                                       mei_free_cb_private(write_cb);
-                                       write_cb = NULL;
+                           cl->reading_state == MEI_READ_COMPLETE) {
+                               *offset = 0;
+                               list_del(&write_cb->list);
+                               mei_io_cb_free(write_cb);
+                               write_cb = NULL;
                        }
                }
        }
@@ -572,8 +584,8 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
                *offset = 0;
                write_cb = find_read_list_entry(dev, cl);
                if (write_cb) {
-                       list_del(&write_cb->cb_list);
-                       mei_free_cb_private(write_cb);
+                       list_del(&write_cb->list);
+                       mei_io_cb_free(write_cb);
                        write_cb = NULL;
                        cl->reading_state = MEI_IDLE;
                        cl->read_cb = NULL;
@@ -583,23 +595,20 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
                *offset = 0;
 
 
-       write_cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
+       write_cb = mei_io_cb_init(cl, file);
        if (!write_cb) {
-               mutex_unlock(&dev->device_lock);
-               return -ENOMEM;
+               dev_err(&dev->pdev->dev, "write cb allocation failed\n");
+               rets = -ENOMEM;
+               goto unlock_dev;
        }
-
-       write_cb->file_object = file;
-       write_cb->file_private = cl;
-       write_cb->request_buffer.data = kmalloc(length, GFP_KERNEL);
-       rets = -ENOMEM;
-       if (!write_cb->request_buffer.data)
+       rets = mei_io_cb_alloc_req_buf(write_cb, length);
+       if (rets)
                goto unlock_dev;
 
-       dev_dbg(&dev->pdev->dev, "length =%d\n", (int) length);
+       dev_dbg(&dev->pdev->dev, "cb request size = %zd\n", length);
 
-       rets = -EFAULT;
-       if (copy_from_user(write_cb->request_buffer.data, ubuf, length))
+       rets = copy_from_user(write_cb->request_buffer.data, ubuf, length);
+       if (rets)
                goto unlock_dev;
 
        cl->sm_state = 0;
@@ -612,87 +621,37 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
                                 write_cb->request_buffer.data, 4) == 0)))
                cl->sm_state |= MEI_WD_STATE_INDEPENDENCE_MSG_SENT;
 
-       INIT_LIST_HEAD(&write_cb->cb_list);
        if (cl == &dev->iamthif_cl) {
-               write_cb->response_buffer.data =
-                   kmalloc(dev->iamthif_mtu, GFP_KERNEL);
-               if (!write_cb->response_buffer.data) {
-                       rets = -ENOMEM;
+               rets = mei_io_cb_alloc_resp_buf(write_cb, dev->iamthif_mtu);
+               if (rets)
                        goto unlock_dev;
-               }
-               if (dev->dev_state != MEI_DEV_ENABLED) {
-                       rets = -ENODEV;
-                       goto unlock_dev;
-               }
-               i = mei_me_cl_by_id(dev, dev->iamthif_cl.me_client_id);
-               if (i < 0) {
-                       rets = -ENODEV;
-                       goto unlock_dev;
-               }
-               if (length > dev->me_clients[i].props.max_msg_length ||
-                          length <= 0) {
-                       rets = -EMSGSIZE;
-                       goto unlock_dev;
-               }
 
-               write_cb->response_buffer.size = dev->iamthif_mtu;
                write_cb->major_file_operations = MEI_IOCTL;
-               write_cb->information = 0;
-               write_cb->request_buffer.size = length;
-               if (dev->iamthif_cl.state != MEI_FILE_CONNECTED) {
-                       rets = -ENODEV;
-                       goto unlock_dev;
-               }
 
-               if (!list_empty(&dev->amthi_cmd_list.mei_cb.cb_list) ||
+               if (!list_empty(&dev->amthi_cmd_list.list) ||
                                dev->iamthif_state != MEI_IAMTHIF_IDLE) {
                        dev_dbg(&dev->pdev->dev, "amthi_state = %d\n",
                                        (int) dev->iamthif_state);
                        dev_dbg(&dev->pdev->dev, "add amthi cb to amthi cmd waiting list\n");
-                       list_add_tail(&write_cb->cb_list,
-                                       &dev->amthi_cmd_list.mei_cb.cb_list);
-                       rets = length;
+                       list_add_tail(&write_cb->list, &dev->amthi_cmd_list.list);
                } else {
                        dev_dbg(&dev->pdev->dev, "call amthi write\n");
                        rets = amthi_write(dev, write_cb);
 
                        if (rets) {
-                               dev_dbg(&dev->pdev->dev, "amthi write failed with status = %d\n",
+                               dev_err(&dev->pdev->dev, "amthi write failed with status = %d\n",
                                    rets);
                                goto unlock_dev;
                        }
-                       rets = length;
                }
                mutex_unlock(&dev->device_lock);
-               return rets;
+               return length;
        }
 
        write_cb->major_file_operations = MEI_WRITE;
-       /* make sure information is zero before we start */
-
-       write_cb->information = 0;
-       write_cb->request_buffer.size = length;
 
        dev_dbg(&dev->pdev->dev, "host client = %d, ME client = %d\n",
            cl->host_client_id, cl->me_client_id);
-       if (cl->state != MEI_FILE_CONNECTED) {
-               rets = -ENODEV;
-               dev_dbg(&dev->pdev->dev, "host client = %d,  is not connected to ME client = %d",
-                   cl->host_client_id,
-                   cl->me_client_id);
-               goto unlock_dev;
-       }
-       i = mei_me_cl_by_id(dev, cl->me_client_id);
-       if (i < 0) {
-               rets = -ENODEV;
-               goto unlock_dev;
-       }
-       if (length > dev->me_clients[i].props.max_msg_length || length <= 0) {
-               rets = -EINVAL;
-               goto unlock_dev;
-       }
-       write_cb->file_private = cl;
-
        rets = mei_flow_ctrl_creds(dev, cl);
        if (rets < 0)
                goto unlock_dev;
@@ -719,32 +678,29 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
                        goto unlock_dev;
                }
                cl->writing_state = MEI_WRITING;
-               write_cb->information = mei_hdr.length;
+               write_cb->buf_idx = mei_hdr.length;
                if (mei_hdr.msg_complete) {
                        if (mei_flow_ctrl_reduce(dev, cl)) {
                                rets = -ENODEV;
                                goto unlock_dev;
                        }
-                       list_add_tail(&write_cb->cb_list,
-                                     &dev->write_waiting_list.mei_cb.cb_list);
+                       list_add_tail(&write_cb->list, &dev->write_waiting_list.list);
                } else {
-                       list_add_tail(&write_cb->cb_list,
-                                     &dev->write_list.mei_cb.cb_list);
+                       list_add_tail(&write_cb->list, &dev->write_list.list);
                }
 
        } else {
 
-               write_cb->information = 0;
+               write_cb->buf_idx = 0;
                cl->writing_state = MEI_WRITING;
-               list_add_tail(&write_cb->cb_list,
-                             &dev->write_list.mei_cb.cb_list);
+               list_add_tail(&write_cb->list, &dev->write_list.list);
        }
        mutex_unlock(&dev->device_lock);
        return length;
 
 unlock_dev:
        mutex_unlock(&dev->device_lock);
-       mei_free_cb_private(write_cb);
+       mei_io_cb_free(write_cb);
        return rets;
 }
 
index adb35fb..6adcb3f 100644 (file)
@@ -144,12 +144,12 @@ struct mei_message_data {
 
 
 struct mei_cl_cb {
-       struct list_head cb_list;
+       struct list_head list;
        enum mei_cb_major_types major_file_operations;
        void *file_private;
        struct mei_message_data request_buffer;
        struct mei_message_data response_buffer;
-       unsigned long information;
+       unsigned long buf_idx;
        unsigned long read_time;
        struct file *file_object;
 };
@@ -175,10 +175,6 @@ struct mei_cl {
        struct mei_cl_cb *read_cb;
 };
 
-struct mei_io_list {
-       struct mei_cl_cb mei_cb;
-};
-
 /**
  * struct mei_deive -  MEI private device struct
  * @hbuf_depth - depth of host(write) buffer
@@ -189,15 +185,15 @@ struct mei_device {
         * lists of queues
         */
         /* array of pointers to aio lists */
-       struct mei_io_list read_list;           /* driver read queue */
-       struct mei_io_list write_list;          /* driver write queue */
-       struct mei_io_list write_waiting_list;  /* write waiting queue */
-       struct mei_io_list ctrl_wr_list;        /* managed write IOCTL list */
-       struct mei_io_list ctrl_rd_list;        /* managed read IOCTL list */
-       struct mei_io_list amthi_cmd_list;      /* amthi list for cmd waiting */
+       struct mei_cl_cb read_list;             /* driver read queue */
+       struct mei_cl_cb write_list;            /* driver write queue */
+       struct mei_cl_cb write_waiting_list;    /* write waiting queue */
+       struct mei_cl_cb ctrl_wr_list;          /* managed write IOCTL list */
+       struct mei_cl_cb ctrl_rd_list;          /* managed read IOCTL list */
+       struct mei_cl_cb amthi_cmd_list;        /* amthi list for cmd waiting */
 
        /* driver managed amthi list for reading completed amthi cmd data */
-       struct mei_io_list amthi_read_complete_list;
+       struct mei_cl_cb amthi_read_complete_list;
        /*
         * list of files
         */
@@ -295,10 +291,24 @@ int mei_me_cl_by_uuid(const struct mei_device *dev, const uuid_le *cuuid);
 int mei_me_cl_by_id(struct mei_device *dev, u8 client_id);
 
 /*
- * MEI IO List Functions
+ * MEI IO Functions
  */
-void mei_io_list_init(struct mei_io_list *list);
-void mei_io_list_flush(struct mei_io_list *list, struct mei_cl *cl);
+struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl, struct file *fp);
+void mei_io_cb_free(struct mei_cl_cb *priv_cb);
+int mei_io_cb_alloc_req_buf(struct mei_cl_cb *cb, size_t length);
+int mei_io_cb_alloc_resp_buf(struct mei_cl_cb *cb, size_t length);
+
+
+/**
+ * mei_io_list_init - Sets up a queue list.
+ *
+ * @list: An instance cl callback structure
+ */
+static inline void mei_io_list_init(struct mei_cl_cb *list)
+{
+       INIT_LIST_HEAD(&list->list);
+}
+void mei_io_list_flush(struct mei_cl_cb *list, struct mei_cl *cl);
 
 /*
  * MEI ME Client Functions
@@ -357,7 +367,6 @@ struct mei_cl_cb *find_amthi_read_list_entry(struct mei_device *dev,
 
 void mei_run_next_iamthif_cmd(struct mei_device *dev);
 
-void mei_free_cb_private(struct mei_cl_cb *priv_cb);
 
 
 /*
index 46937b1..b90a224 100644 (file)
@@ -511,7 +511,6 @@ long st_register(struct st_proto_s *new_proto)
        unsigned long flags = 0;
 
        st_kim_ref(&st_gdata, 0);
-       pr_info("%s(%d) ", __func__, new_proto->chnl_id);
        if (st_gdata == NULL || new_proto == NULL || new_proto->recv == NULL
            || new_proto->reg_complete_cb == NULL) {
                pr_err("gdata/new_proto/recv or reg_complete_cb not ready");
index 6f3ea9b..82e2b89 100644 (file)
@@ -44,6 +44,22 @@ config UIO_PDRV_GENIRQ
 
          If you don't know what to do here, say N.
 
+config UIO_DMEM_GENIRQ
+       tristate "Userspace platform driver with generic irq and dynamic memory"
+       help
+         Platform driver for Userspace I/O devices, including generic
+         interrupt handling code. Shared interrupts are not supported.
+
+         Memory regions can be specified with the same platform device
+         resources as the UIO_PDRV drivers, but dynamic regions can also
+         be specified.
+         The number and size of these regions is static,
+         but the memory allocation is not performed until
+         the associated device file is opened. The
+         memory is freed once the uio device is closed.
+
+         If you don't know what to do here, say N.
+
 config UIO_AEC
        tristate "AEC video timestamp device"
        depends on PCI
index d4dd9a5..b354c53 100644 (file)
@@ -2,6 +2,7 @@ obj-$(CONFIG_UIO)       += uio.o
 obj-$(CONFIG_UIO_CIF)  += uio_cif.o
 obj-$(CONFIG_UIO_PDRV) += uio_pdrv.o
 obj-$(CONFIG_UIO_PDRV_GENIRQ)  += uio_pdrv_genirq.o
+obj-$(CONFIG_UIO_DMEM_GENIRQ)  += uio_dmem_genirq.o
 obj-$(CONFIG_UIO_AEC)  += uio_aec.o
 obj-$(CONFIG_UIO_SERCOS3)      += uio_sercos3.o
 obj-$(CONFIG_UIO_PCI_GENERIC)  += uio_pci_generic.o
diff --git a/drivers/uio/uio_dmem_genirq.c b/drivers/uio/uio_dmem_genirq.c
new file mode 100644 (file)
index 0000000..4d4dd00
--- /dev/null
@@ -0,0 +1,354 @@
+/*
+ * drivers/uio/uio_dmem_genirq.c
+ *
+ * Userspace I/O platform driver with generic IRQ handling code.
+ *
+ * Copyright (C) 2012 Damian Hobson-Garcia
+ *
+ * Based on uio_pdrv_genirq.c by Magnus Damm
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/uio_driver.h>
+#include <linux/spinlock.h>
+#include <linux/bitops.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/platform_data/uio_dmem_genirq.h>
+#include <linux/stringify.h>
+#include <linux/pm_runtime.h>
+#include <linux/dma-mapping.h>
+#include <linux/slab.h>
+
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/of_address.h>
+
+#define DRIVER_NAME "uio_dmem_genirq"
+
+struct uio_dmem_genirq_platdata {
+       struct uio_info *uioinfo;
+       spinlock_t lock;
+       unsigned long flags;
+       struct platform_device *pdev;
+       unsigned int dmem_region_start;
+       unsigned int num_dmem_regions;
+       struct mutex alloc_lock;
+       unsigned int refcnt;
+};
+
+static int uio_dmem_genirq_open(struct uio_info *info, struct inode *inode)
+{
+       struct uio_dmem_genirq_platdata *priv = info->priv;
+       struct uio_mem *uiomem;
+       int ret = 0;
+
+       uiomem = &priv->uioinfo->mem[priv->dmem_region_start];
+
+       mutex_lock(&priv->alloc_lock);
+       while (!priv->refcnt && uiomem < &priv->uioinfo->mem[MAX_UIO_MAPS]) {
+               void *addr;
+               if (!uiomem->size)
+                       break;
+
+               addr = dma_alloc_coherent(&priv->pdev->dev, uiomem->size,
+                               (dma_addr_t *)&uiomem->addr, GFP_KERNEL);
+               if (!addr) {
+                       ret = -ENOMEM;
+                       break;
+               }
+
+               uiomem->internal_addr = addr;
+               ++uiomem;
+       }
+       priv->refcnt++;
+
+       mutex_unlock(&priv->alloc_lock);
+       /* Wait until the Runtime PM code has woken up the device */
+       pm_runtime_get_sync(&priv->pdev->dev);
+       return ret;
+}
+
+static int uio_dmem_genirq_release(struct uio_info *info, struct inode *inode)
+{
+       struct uio_dmem_genirq_platdata *priv = info->priv;
+       struct uio_mem *uiomem;
+
+       /* Tell the Runtime PM code that the device has become idle */
+       pm_runtime_put_sync(&priv->pdev->dev);
+
+       uiomem = &priv->uioinfo->mem[priv->dmem_region_start];
+
+       mutex_lock(&priv->alloc_lock);
+
+       priv->refcnt--;
+       while (!priv->refcnt && uiomem < &priv->uioinfo->mem[MAX_UIO_MAPS]) {
+               if (!uiomem->size)
+                       break;
+
+               dma_free_coherent(&priv->pdev->dev, uiomem->size,
+                               uiomem->internal_addr, uiomem->addr);
+               uiomem->addr = DMA_ERROR_CODE;
+               ++uiomem;
+       }
+
+       mutex_unlock(&priv->alloc_lock);
+       return 0;
+}
+
+static irqreturn_t uio_dmem_genirq_handler(int irq, struct uio_info *dev_info)
+{
+       struct uio_dmem_genirq_platdata *priv = dev_info->priv;
+
+       /* Just disable the interrupt in the interrupt controller, and
+        * remember the state so we can allow user space to enable it later.
+        */
+
+       if (!test_and_set_bit(0, &priv->flags))
+               disable_irq_nosync(irq);
+
+       return IRQ_HANDLED;
+}
+
+static int uio_dmem_genirq_irqcontrol(struct uio_info *dev_info, s32 irq_on)
+{
+       struct uio_dmem_genirq_platdata *priv = dev_info->priv;
+       unsigned long flags;
+
+       /* Allow user space to enable and disable the interrupt
+        * in the interrupt controller, but keep track of the
+        * state to prevent per-irq depth damage.
+        *
+        * Serialize this operation to support multiple tasks.
+        */
+
+       spin_lock_irqsave(&priv->lock, flags);
+       if (irq_on) {
+               if (test_and_clear_bit(0, &priv->flags))
+                       enable_irq(dev_info->irq);
+       } else {
+               if (!test_and_set_bit(0, &priv->flags))
+                       disable_irq(dev_info->irq);
+       }
+       spin_unlock_irqrestore(&priv->lock, flags);
+
+       return 0;
+}
+
+static int uio_dmem_genirq_probe(struct platform_device *pdev)
+{
+       struct uio_dmem_genirq_pdata *pdata = pdev->dev.platform_data;
+       struct uio_info *uioinfo = &pdata->uioinfo;
+       struct uio_dmem_genirq_platdata *priv;
+       struct uio_mem *uiomem;
+       int ret = -EINVAL;
+       int i;
+
+       if (!uioinfo) {
+               int irq;
+
+               /* alloc uioinfo for one device */
+               uioinfo = kzalloc(sizeof(*uioinfo), GFP_KERNEL);
+               if (!uioinfo) {
+                       ret = -ENOMEM;
+                       dev_err(&pdev->dev, "unable to kmalloc\n");
+                       goto bad2;
+               }
+               uioinfo->name = pdev->dev.of_node->name;
+               uioinfo->version = "devicetree";
+
+               /* Multiple IRQs are not supported */
+               irq = platform_get_irq(pdev, 0);
+               if (irq == -ENXIO)
+                       uioinfo->irq = UIO_IRQ_NONE;
+               else
+                       uioinfo->irq = irq;
+       }
+
+       if (!uioinfo || !uioinfo->name || !uioinfo->version) {
+               dev_err(&pdev->dev, "missing platform_data\n");
+               goto bad0;
+       }
+
+       if (uioinfo->handler || uioinfo->irqcontrol ||
+           uioinfo->irq_flags & IRQF_SHARED) {
+               dev_err(&pdev->dev, "interrupt configuration error\n");
+               goto bad0;
+       }
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv) {
+               ret = -ENOMEM;
+               dev_err(&pdev->dev, "unable to kmalloc\n");
+               goto bad0;
+       }
+
+       dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
+
+       priv->uioinfo = uioinfo;
+       spin_lock_init(&priv->lock);
+       priv->flags = 0; /* interrupt is enabled to begin with */
+       priv->pdev = pdev;
+       mutex_init(&priv->alloc_lock);
+
+       if (!uioinfo->irq) {
+               ret = platform_get_irq(pdev, 0);
+               if (ret < 0) {
+                       dev_err(&pdev->dev, "failed to get IRQ\n");
+                       goto bad0;
+               }
+               uioinfo->irq = ret;
+       }
+       uiomem = &uioinfo->mem[0];
+
+       for (i = 0; i < pdev->num_resources; ++i) {
+               struct resource *r = &pdev->resource[i];
+
+               if (r->flags != IORESOURCE_MEM)
+                       continue;
+
+               if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) {
+                       dev_warn(&pdev->dev, "device has more than "
+                                       __stringify(MAX_UIO_MAPS)
+                                       " I/O memory resources.\n");
+                       break;
+               }
+
+               uiomem->memtype = UIO_MEM_PHYS;
+               uiomem->addr = r->start;
+               uiomem->size = resource_size(r);
+               ++uiomem;
+       }
+
+       priv->dmem_region_start = i;
+       priv->num_dmem_regions = pdata->num_dynamic_regions;
+
+       for (i = 0; i < pdata->num_dynamic_regions; ++i) {
+               if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) {
+                       dev_warn(&pdev->dev, "device has more than "
+                                       __stringify(MAX_UIO_MAPS)
+                                       " dynamic and fixed memory regions.\n");
+                       break;
+               }
+               uiomem->memtype = UIO_MEM_PHYS;
+               uiomem->addr = DMA_ERROR_CODE;
+               uiomem->size = pdata->dynamic_region_sizes[i];
+               ++uiomem;
+       }
+
+       while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) {
+               uiomem->size = 0;
+               ++uiomem;
+       }
+
+       /* This driver requires no hardware specific kernel code to handle
+        * interrupts. Instead, the interrupt handler simply disables the
+        * interrupt in the interrupt controller. User space is responsible
+        * for performing hardware specific acknowledge and re-enabling of
+        * the interrupt in the interrupt controller.
+        *
+        * Interrupt sharing is not supported.
+        */
+
+       uioinfo->handler = uio_dmem_genirq_handler;
+       uioinfo->irqcontrol = uio_dmem_genirq_irqcontrol;
+       uioinfo->open = uio_dmem_genirq_open;
+       uioinfo->release = uio_dmem_genirq_release;
+       uioinfo->priv = priv;
+
+       /* Enable Runtime PM for this device:
+        * The device starts in suspended state to allow the hardware to be
+        * turned off by default. The Runtime PM bus code should power on the
+        * hardware and enable clocks at open().
+        */
+       pm_runtime_enable(&pdev->dev);
+
+       ret = uio_register_device(&pdev->dev, priv->uioinfo);
+       if (ret) {
+               dev_err(&pdev->dev, "unable to register uio device\n");
+               goto bad1;
+       }
+
+       platform_set_drvdata(pdev, priv);
+       return 0;
+ bad1:
+       kfree(priv);
+       pm_runtime_disable(&pdev->dev);
+ bad0:
+       /* kfree uioinfo for OF */
+       if (pdev->dev.of_node)
+               kfree(uioinfo);
+ bad2:
+       return ret;
+}
+
+static int uio_dmem_genirq_remove(struct platform_device *pdev)
+{
+       struct uio_dmem_genirq_platdata *priv = platform_get_drvdata(pdev);
+
+       uio_unregister_device(priv->uioinfo);
+       pm_runtime_disable(&pdev->dev);
+
+       priv->uioinfo->handler = NULL;
+       priv->uioinfo->irqcontrol = NULL;
+
+       /* kfree uioinfo for OF */
+       if (pdev->dev.of_node)
+               kfree(priv->uioinfo);
+
+       kfree(priv);
+       return 0;
+}
+
+static int uio_dmem_genirq_runtime_nop(struct device *dev)
+{
+       /* Runtime PM callback shared between ->runtime_suspend()
+        * and ->runtime_resume(). Simply returns success.
+        *
+        * In this driver pm_runtime_get_sync() and pm_runtime_put_sync()
+        * are used at open() and release() time. This allows the
+        * Runtime PM code to turn off power to the device while the
+        * device is unused, ie before open() and after release().
+        *
+        * This Runtime PM callback does not need to save or restore
+        * any registers since user space is responsbile for hardware
+        * register reinitialization after open().
+        */
+       return 0;
+}
+
+static const struct dev_pm_ops uio_dmem_genirq_dev_pm_ops = {
+       .runtime_suspend = uio_dmem_genirq_runtime_nop,
+       .runtime_resume = uio_dmem_genirq_runtime_nop,
+};
+
+#ifdef CONFIG_OF
+static const struct of_device_id uio_of_genirq_match[] = {
+       { /* empty for now */ },
+};
+MODULE_DEVICE_TABLE(of, uio_of_genirq_match);
+#else
+# define uio_of_genirq_match NULL
+#endif
+
+static struct platform_driver uio_dmem_genirq = {
+       .probe = uio_dmem_genirq_probe,
+       .remove = uio_dmem_genirq_remove,
+       .driver = {
+               .name = DRIVER_NAME,
+               .owner = THIS_MODULE,
+               .pm = &uio_dmem_genirq_dev_pm_ops,
+               .of_match_table = uio_of_genirq_match,
+       },
+};
+
+module_platform_driver(uio_dmem_genirq);
+
+MODULE_AUTHOR("Damian Hobson-Garcia");
+MODULE_DESCRIPTION("Userspace I/O platform driver with dynamic memory.");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRIVER_NAME);
index 7e98403..c433a74 100644 (file)
@@ -26,7 +26,7 @@ config W1_MASTER_DS2490
 
 config W1_MASTER_DS2482
        tristate "Maxim DS2482 I2C to 1-Wire bridge"
-       depends on I2C && EXPERIMENTAL
+       depends on I2C
        help
          If you say yes here you get support for the Maxim DS2482
          I2C to 1-Wire bridge.
index e5f7441..6429b9e 100644 (file)
@@ -505,19 +505,8 @@ static int ds2482_remove(struct i2c_client *client)
        return 0;
 }
 
-static int __init sensors_ds2482_init(void)
-{
-       return i2c_add_driver(&ds2482_driver);
-}
-
-static void __exit sensors_ds2482_exit(void)
-{
-       i2c_del_driver(&ds2482_driver);
-}
+module_i2c_driver(ds2482_driver);
 
 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
 MODULE_DESCRIPTION("DS2482 driver");
 MODULE_LICENSE("GPL");
-
-module_init(sensors_ds2482_init);
-module_exit(sensors_ds2482_exit);
diff --git a/include/linux/platform_data/uio_dmem_genirq.h b/include/linux/platform_data/uio_dmem_genirq.h
new file mode 100644 (file)
index 0000000..973c1bb
--- /dev/null
@@ -0,0 +1,26 @@
+/*
+ * include/linux/platform_data/uio_dmem_genirq.h
+ *
+ * Copyright (C) 2012 Damian Hobson-Garcia
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _UIO_DMEM_GENIRQ_H
+#define _UIO_DMEM_GENIRQ_H
+
+#include <linux/uio_driver.h>
+
+struct uio_dmem_genirq_pdata {
+       struct uio_info uioinfo;
+       unsigned int *dynamic_region_sizes;
+       unsigned int num_dynamic_regions;
+};
+#endif /* _UIO_DMEM_GENIRQ_H */