Changeset 37280


Ignore:
Timestamp:
2013-07-14T13:30:31+02:00 (5 years ago)
Author:
hauke
Message:

broadcom-diag: make it work with kernel 3.10

In kernel 3.10 the proc interface changed, this patch adds the changes needed for the new interface.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/kernel/broadcom-diag/src/diag.c

    r37279 r37280  
    4646 
    4747extern char *nvram_get(char *str); 
    48  
    49 static void register_leds(struct led_t *l); 
    50 static void unregister_leds(struct led_t *l); 
    5148static void led_flash(unsigned long dummy); 
    5249 
     
    5754static struct proc_dir_entry *diag, *leds; 
    5855 
    59 static struct prochandler_t proc_model = { .type = PROC_MODEL }; 
    60 static struct prochandler_t proc_gpiomask = { .type = PROC_GPIOMASK }; 
     56#if LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0) 
     57static inline struct inode *file_inode(struct file *f) 
     58{ 
     59        return f->f_path.dentry->d_inode; 
     60} 
     61#endif 
     62 
     63#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) 
     64static inline void *PDE_DATA(const struct inode *inode) 
     65{ 
     66        return PDE(inode)->data; 
     67} 
     68#endif 
     69 
    6170 
    6271enum { 
     
    15871596} 
    15881597 
    1589 static ssize_t diag_proc_read(struct file *file, char *buf, size_t count, loff_t *ppos) 
    1590 { 
    1591         struct proc_dir_entry *dent = PDE(file->f_dentry->d_inode); 
    1592         char *page; 
    1593         int len = 0; 
    1594  
    1595         if ((page = kmalloc(1024, GFP_KERNEL)) == NULL) 
    1596                 return -ENOBUFS; 
    1597  
    1598         if (dent->data != NULL) { 
    1599                 struct prochandler_t *handler = (struct prochandler_t *) dent->data; 
    1600                 switch (handler->type) { 
    1601                         case PROC_LED: { 
    1602                                 struct led_t * led = (struct led_t *) handler->ptr; 
    1603                                 u8 p = (led->polarity == NORMAL ? 0 : 1); 
    1604                                 if (led->flash) { 
    1605                                         len = sprintf(page, "f\n"); 
    1606                                 } else if ((led->gpio & GPIO_TYPE_MASK) != GPIO_TYPE_NORMAL) { 
    1607                                         len = sprintf(page, "%d\n", ((led->state ^ p) ? 1 : 0)); 
    1608                                 } else { 
    1609                                         u32 in = (bcm47xx_gpio_in(~0) & led->gpio ? 1 : 0); 
    1610                                         len = sprintf(page, "%d\n", ((in ^ p) ? 1 : 0)); 
    1611                                 } 
    1612                                 break; 
    1613                         } 
    1614                         case PROC_MODEL: 
    1615                                 len = sprintf(page, "%s\n", platform.name); 
    1616                                 break; 
    1617                         case PROC_GPIOMASK: 
    1618                                 len = sprintf(page, "0x%04x\n", gpiomask); 
    1619                                 break; 
     1598static int diag_led_show(struct seq_file *m, void *v) 
     1599{ 
     1600        struct led_t * led = m->private; 
     1601 
     1602        u8 p = (led->polarity == NORMAL ? 0 : 1); 
     1603        if (led->flash) { 
     1604                return seq_printf(m, "f\n"); 
     1605        } else if ((led->gpio & GPIO_TYPE_MASK) != GPIO_TYPE_NORMAL) { 
     1606                return seq_printf(m, "%d\n", ((led->state ^ p) ? 1 : 0)); 
     1607        } else { 
     1608                u32 in = (bcm47xx_gpio_in(~0) & led->gpio ? 1 : 0); 
     1609                return seq_printf(m, "%d\n", ((in ^ p) ? 1 : 0)); 
     1610        } 
     1611} 
     1612 
     1613static int diag_led_open(struct inode *inode, struct file *file) 
     1614{ 
     1615        return single_open(file, diag_led_show, PDE_DATA(inode)); 
     1616} 
     1617 
     1618static ssize_t diag_led_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 
     1619{ 
     1620        struct led_t *led = PDE_DATA(file_inode(file)); 
     1621        char cmd[5]; 
     1622        size_t len; 
     1623        int p; 
     1624 
     1625        len = min(count, sizeof(cmd) - 1); 
     1626        if (copy_from_user(cmd, buf, len)) 
     1627                return -EFAULT; 
     1628 
     1629        cmd[len] = 0; 
     1630 
     1631        p = (led->polarity == NORMAL ? 0 : 1); 
     1632        if (cmd[0] == 'f') { 
     1633                led->flash = 1; 
     1634                led_flash(0); 
     1635        } else { 
     1636                led->flash = 0; 
     1637                if ((led->gpio & GPIO_TYPE_MASK) == GPIO_TYPE_EXTIF) { 
     1638                        led->state = p ^ ((cmd[0] == '1') ? 1 : 0); 
     1639                        set_led_extif(led); 
     1640                } else if ((led->gpio & GPIO_TYPE_MASK) == GPIO_TYPE_SHIFT) { 
     1641                        led->state = p ^ ((cmd[0] == '1') ? 1 : 0); 
     1642                        set_led_shift(led); 
     1643                } else { 
     1644                        bcm47xx_gpio_outen(led->gpio, led->gpio); 
     1645                        bcm47xx_gpio_control(led->gpio, 0); 
     1646                        bcm47xx_gpio_out(led->gpio, ((p ^ (cmd[0] == '1')) ? led->gpio : 0)); 
    16201647                } 
    16211648        } 
    1622         len += 1; 
    1623  
    1624         if (*ppos < len) { 
    1625                 len = min_t(int, len - *ppos, count); 
    1626                 if (copy_to_user(buf, (page + *ppos), len)) { 
    1627                         kfree(page); 
    1628                         return -EFAULT; 
    1629                 } 
    1630                 *ppos += len; 
    1631         } else { 
    1632                 len = 0; 
    1633         } 
    1634  
    1635         kfree(page); 
    1636         return len; 
    1637 } 
    1638  
    1639  
    1640 static ssize_t diag_proc_write(struct file *file, const char *buf, size_t count, loff_t *ppos) 
    1641 { 
    1642         struct proc_dir_entry *dent = PDE(file->f_dentry->d_inode); 
    1643         char *page; 
    1644         int ret = -EINVAL; 
    1645  
    1646         if ((page = kmalloc(count + 1, GFP_KERNEL)) == NULL) 
    1647                 return -ENOBUFS; 
    1648  
    1649         if (copy_from_user(page, buf, count)) { 
    1650                 kfree(page); 
    1651                 return -EINVAL; 
    1652         } 
    1653         page[count] = 0; 
    1654  
    1655         if (dent->data != NULL) { 
    1656                 struct prochandler_t *handler = (struct prochandler_t *) dent->data; 
    1657                 switch (handler->type) { 
    1658                         case PROC_LED: { 
    1659                                 struct led_t *led = (struct led_t *) handler->ptr; 
    1660                                 int p = (led->polarity == NORMAL ? 0 : 1); 
    1661  
    1662                                 if (page[0] == 'f') { 
    1663                                         led->flash = 1; 
    1664                                         led_flash(0); 
    1665                                 } else { 
    1666                                         led->flash = 0; 
    1667                                         if ((led->gpio & GPIO_TYPE_MASK) == GPIO_TYPE_EXTIF) { 
    1668                                                 led->state = p ^ ((page[0] == '1') ? 1 : 0); 
    1669                                                 set_led_extif(led); 
    1670                                         } else if ((led->gpio & GPIO_TYPE_MASK) == GPIO_TYPE_SHIFT) { 
    1671                                                 led->state = p ^ ((page[0] == '1') ? 1 : 0); 
    1672                                                 set_led_shift(led); 
    1673                                         } else { 
    1674                                                 bcm47xx_gpio_outen(led->gpio, led->gpio); 
    1675                                                 bcm47xx_gpio_control(led->gpio, 0); 
    1676                                                 bcm47xx_gpio_out(led->gpio, ((p ^ (page[0] == '1')) ? led->gpio : 0)); 
    1677                                         } 
    1678                                 } 
    1679                                 break; 
    1680                         } 
    1681                         case PROC_GPIOMASK: 
    1682                                 gpiomask = simple_strtoul(page, NULL, 0); 
    1683  
    1684                                 if (platform.buttons) { 
    1685                                         unregister_buttons(platform.buttons); 
    1686                                         register_buttons(platform.buttons); 
    1687                                 } 
    1688  
    1689                                 if (platform.leds) { 
    1690                                         unregister_leds(platform.leds); 
    1691                                         register_leds(platform.leds); 
    1692                                 } 
    1693                                 break; 
    1694                 } 
    1695                 ret = count; 
    1696         } 
    1697  
    1698         kfree(page); 
    1699         return ret; 
    1700 } 
    1701  
    1702 static struct file_operations diag_proc_fops = { 
    1703         read: diag_proc_read, 
    1704         write: diag_proc_write 
     1649        return count; 
     1650} 
     1651 
     1652static const struct file_operations diag_led_fops = { 
     1653        .open = diag_led_open, 
     1654        .read = seq_read, 
     1655        .llseek = seq_lseek, 
     1656        .write = diag_led_write 
    17051657}; 
    17061658 
     
    17411693                if (l->polarity == INPUT) continue; 
    17421694 
    1743                 if ((p = create_proc_entry(l->name, S_IRUSR, leds))) { 
    1744                         l->proc.type = PROC_LED; 
    1745                         l->proc.ptr = l; 
    1746                         p->data = (void *) &l->proc; 
    1747                         p->proc_fops = &diag_proc_fops; 
    1748                 } 
     1695                p = proc_create_data(l->name, S_IRUSR, leds, &diag_led_fops, l); 
    17491696        } 
    17501697 
     
    17631710} 
    17641711 
     1712static int diag_model_show(struct seq_file *m, void *v) 
     1713{ 
     1714        return seq_printf(m, "%s\n", platform.name); 
     1715} 
     1716 
     1717static int diag_model_open(struct inode *inode, struct file *file) 
     1718{ 
     1719        return single_open(file, diag_model_show, PDE_DATA(inode)); 
     1720} 
     1721 
     1722static const struct file_operations diag_model_fops = { 
     1723        .open = diag_model_open, 
     1724        .read = seq_read, 
     1725        .llseek = seq_lseek 
     1726}; 
     1727 
     1728static int diag_gpiomask_show(struct seq_file *m, void *v) 
     1729{ 
     1730        return seq_printf(m, "0x%04x\n", gpiomask); 
     1731} 
     1732 
     1733static int diag_gpiomask_open(struct inode *inode, struct file *file) 
     1734{ 
     1735        return single_open(file, diag_gpiomask_show, PDE_DATA(inode)); 
     1736} 
     1737 
     1738static ssize_t diag_gpiomask_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 
     1739{ 
     1740        int err = kstrtouint_from_user(buf, count, 0, &gpiomask); 
     1741        if (err) 
     1742                return err; 
     1743 
     1744        if (platform.buttons) { 
     1745                unregister_buttons(platform.buttons); 
     1746                register_buttons(platform.buttons); 
     1747        } 
     1748 
     1749        if (platform.leds) { 
     1750                unregister_leds(platform.leds); 
     1751                register_leds(platform.leds); 
     1752        } 
     1753 
     1754        return count; 
     1755} 
     1756 
     1757static const struct file_operations diag_gpiomask_fops = { 
     1758        .open = diag_gpiomask_open, 
     1759        .read = seq_read, 
     1760        .llseek = seq_lseek, 
     1761        .write = diag_gpiomask_write 
     1762}; 
     1763 
    17651764static int __init diag_init(void) 
    17661765{ 
     
    17851784        } 
    17861785 
    1787         if ((p = create_proc_entry("model", S_IRUSR, diag))) { 
    1788                 p->data = (void *) &proc_model; 
    1789                 p->proc_fops = &diag_proc_fops; 
    1790         } 
    1791  
    1792         if ((p = create_proc_entry("gpiomask", S_IRUSR | S_IWUSR, diag))) { 
    1793                 p->data = (void *) &proc_gpiomask; 
    1794                 p->proc_fops = &diag_proc_fops; 
     1786        p = proc_create("model", S_IRUSR, diag, &diag_model_fops); 
     1787        if (!p) { 
     1788                remove_proc_entry("diag", NULL); 
     1789                return -EINVAL; 
     1790        } 
     1791 
     1792        p = proc_create("gpiomask", S_IRUSR | S_IWUSR, diag, &diag_gpiomask_fops); 
     1793        if (!p) { 
     1794                remove_proc_entry("model", diag); 
     1795                remove_proc_entry("diag", NULL); 
     1796                return -EINVAL; 
    17951797        } 
    17961798 
Note: See TracChangeset for help on using the changeset viewer.