Changeset 37278


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

broadcom-diag: reoder some parts.

This was done to reduce the number of forward declaration needed.
This does not contain any real change in the code.

Location:
trunk/package/kernel/broadcom-diag/src
Files:
2 edited

Legend:

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

    r37007 r37278  
    4444static unsigned int gpiomask = 0; 
    4545module_param(gpiomask, int, 0644); 
     46 
     47extern char *nvram_get(char *str); 
     48 
     49static void register_leds(struct led_t *l); 
     50static void unregister_leds(struct led_t *l); 
     51static void led_flash(unsigned long dummy); 
     52 
     53static struct platform_t platform; 
     54 
     55static struct timer_list led_timer = TIMER_INITIALIZER(&led_flash, 0, 0); 
     56 
     57static struct proc_dir_entry *diag, *leds; 
     58 
     59static struct prochandler_t proc_model = { .type = PROC_MODEL }; 
     60static struct prochandler_t proc_gpiomask = { .type = PROC_GPIOMASK }; 
    4661 
    4762enum { 
     
    13821397} 
    13831398 
     1399static void hotplug_button(struct work_struct *work) 
     1400{ 
     1401        struct event_t *event = container_of(work, struct event_t, wq); 
     1402        char *s; 
     1403 
     1404        event->skb = alloc_skb(2048, GFP_KERNEL); 
     1405 
     1406        s = skb_put(event->skb, strlen(event->action) + 2); 
     1407        sprintf(s, "%s@", event->action); 
     1408        fill_event(event); 
     1409 
     1410        NETLINK_CB(event->skb).dst_group = 1; 
     1411        broadcast_uevent(event->skb, 0, 1, GFP_KERNEL); 
     1412 
     1413        kfree(event); 
     1414} 
     1415 
     1416static irqreturn_t button_handler(int irq, void *dev_id) 
     1417{ 
     1418        struct button_t *b; 
     1419        u32 in, changed; 
     1420 
     1421        in = bcm47xx_gpio_in(~0) & platform.button_mask; 
     1422        bcm47xx_gpio_polarity(platform.button_mask, in); 
     1423        changed = platform.button_polarity ^ in; 
     1424        platform.button_polarity = in; 
     1425 
     1426        changed &= ~bcm47xx_gpio_outen(0, 0); 
     1427 
     1428        for (b = platform.buttons; b->name; b++) { 
     1429                struct event_t *event; 
     1430 
     1431                if (!(b->gpio & changed)) continue; 
     1432 
     1433                b->pressed ^= 1; 
     1434 
     1435                if ((event = (struct event_t *)kzalloc (sizeof(struct event_t), GFP_ATOMIC))) { 
     1436                        event->seen = (jiffies - b->seen)/HZ; 
     1437                        event->name = b->name; 
     1438                        event->action = b->pressed ? "pressed" : "released"; 
     1439                        INIT_WORK(&event->wq, (void *)(void *)hotplug_button); 
     1440                        schedule_work(&event->wq); 
     1441                } 
     1442 
     1443                b->seen = jiffies; 
     1444        } 
     1445        return IRQ_HANDLED; 
     1446} 
     1447 
    13841448static void register_buttons(struct button_t *b) 
    13851449{ 
     
    14161480        strcpy(s, msg); 
    14171481} 
    1418  
    1419 static void hotplug_button(struct work_struct *work) 
    1420 { 
    1421         struct event_t *event = container_of(work, struct event_t, wq); 
    1422         char *s; 
    1423  
    1424         event->skb = alloc_skb(2048, GFP_KERNEL); 
    1425  
    1426         s = skb_put(event->skb, strlen(event->action) + 2); 
    1427         sprintf(s, "%s@", event->action); 
    1428         fill_event(event); 
    1429  
    1430         NETLINK_CB(event->skb).dst_group = 1; 
    1431         broadcast_uevent(event->skb, 0, 1, GFP_KERNEL); 
    1432  
    1433         kfree(event); 
    1434 } 
    1435  
    14361482 
    14371483static int fill_event (struct event_t *event) 
     
    14541500} 
    14551501 
    1456  
    1457 static irqreturn_t button_handler(int irq, void *dev_id) 
    1458 { 
    1459         struct button_t *b; 
    1460         u32 in, changed; 
    1461  
    1462         in = bcm47xx_gpio_in(~0) & platform.button_mask; 
    1463         bcm47xx_gpio_polarity(platform.button_mask, in); 
    1464         changed = platform.button_polarity ^ in; 
    1465         platform.button_polarity = in; 
    1466  
    1467         changed &= ~bcm47xx_gpio_outen(0, 0); 
    1468  
    1469         for (b = platform.buttons; b->name; b++) { 
    1470                 struct event_t *event; 
    1471  
    1472                 if (!(b->gpio & changed)) continue; 
    1473  
    1474                 b->pressed ^= 1; 
    1475  
    1476                 if ((event = (struct event_t *)kzalloc (sizeof(struct event_t), GFP_ATOMIC))) { 
    1477                         event->seen = (jiffies - b->seen)/HZ; 
    1478                         event->name = b->name; 
    1479                         event->action = b->pressed ? "pressed" : "released"; 
    1480                         INIT_WORK(&event->wq, (void *)(void *)hotplug_button); 
    1481                         schedule_work(&event->wq); 
    1482                 } 
    1483  
    1484                 b->seen = jiffies; 
    1485         } 
    1486         return IRQ_HANDLED; 
    1487 } 
    1488  
    1489 static void register_leds(struct led_t *l) 
    1490 { 
    1491         struct proc_dir_entry *p; 
    1492         u32 mask = 0; 
    1493         u32 oe_mask = 0; 
    1494         u32 val = 0; 
    1495  
    1496         leds = proc_mkdir("led", diag); 
    1497         if (!leds) 
    1498                 return; 
    1499  
    1500         for(; l->name; l++) { 
    1501                 if (l->gpio & gpiomask) 
    1502                         continue; 
    1503  
    1504                 switch (l->gpio & GPIO_TYPE_MASK) { 
    1505                 case GPIO_TYPE_EXTIF: 
    1506                         l->state = 0; 
    1507                         set_led_extif(l); 
    1508                         break; 
    1509                 case GPIO_TYPE_SHIFT: 
    1510                         mask |= (SHIFTREG_DATA | SHIFTREG_CLK); 
    1511                         oe_mask |= (SHIFTREG_DATA | SHIFTREG_CLK); 
    1512                         l->state = (l->polarity != NORMAL); 
    1513                         set_led_shift(l); 
    1514                         break; 
    1515                 case GPIO_TYPE_NORMAL: 
    1516                 default: 
    1517                         if (l->polarity != INPUT) oe_mask |= l->gpio; 
    1518                         mask |= l->gpio; 
    1519                         val |= (l->polarity == NORMAL)?0:l->gpio; 
    1520                         break; 
    1521                 } 
    1522  
    1523                 if (l->polarity == INPUT) continue; 
    1524  
    1525                 if ((p = create_proc_entry(l->name, S_IRUSR, leds))) { 
    1526                         l->proc.type = PROC_LED; 
    1527                         l->proc.ptr = l; 
    1528                         p->data = (void *) &l->proc; 
    1529                         p->proc_fops = &diag_proc_fops; 
    1530                 } 
    1531         } 
    1532  
    1533         bcm47xx_gpio_outen(mask, oe_mask); 
    1534         bcm47xx_gpio_control(mask, 0); 
    1535         bcm47xx_gpio_out(mask, val); 
    1536         bcm47xx_gpio_intmask(mask, 0); 
    1537 } 
    1538  
    1539 static void unregister_leds(struct led_t *l) 
    1540 { 
    1541         for(; l->name; l++) 
    1542                 remove_proc_entry(l->name, leds); 
    1543  
    1544         remove_proc_entry("led", diag); 
    1545 } 
    1546  
    1547 static void set_led_extif(struct led_t *led) 
    1548 { 
    1549         volatile u8 *addr = (volatile u8 *) KSEG1ADDR(EXTIF_UART) + (led->gpio & ~GPIO_TYPE_MASK); 
    1550         if (led->state) 
    1551                 *addr = 0xFF; 
    1552         else 
    1553                 *addr; 
    1554 } 
    1555  
    15561502/* 
    15571503 * This should be extended to allow the platform to specify the pins and width 
     
    15911537                shiftreg_output(shiftreg); 
    15921538        } 
     1539} 
     1540 
     1541static void set_led_extif(struct led_t *led) 
     1542{ 
     1543        volatile u8 *addr = (volatile u8 *) KSEG1ADDR(EXTIF_UART) + (led->gpio & ~GPIO_TYPE_MASK); 
     1544        if (led->state) 
     1545                *addr = 0xFF; 
     1546        else 
     1547                *addr; 
    15931548} 
    15941549 
     
    17451700} 
    17461701 
     1702static struct file_operations diag_proc_fops = { 
     1703        read: diag_proc_read, 
     1704        write: diag_proc_write 
     1705}; 
     1706 
     1707static void register_leds(struct led_t *l) 
     1708{ 
     1709        struct proc_dir_entry *p; 
     1710        u32 mask = 0; 
     1711        u32 oe_mask = 0; 
     1712        u32 val = 0; 
     1713 
     1714        leds = proc_mkdir("led", diag); 
     1715        if (!leds) 
     1716                return; 
     1717 
     1718        for(; l->name; l++) { 
     1719                if (l->gpio & gpiomask) 
     1720                        continue; 
     1721 
     1722                switch (l->gpio & GPIO_TYPE_MASK) { 
     1723                case GPIO_TYPE_EXTIF: 
     1724                        l->state = 0; 
     1725                        set_led_extif(l); 
     1726                        break; 
     1727                case GPIO_TYPE_SHIFT: 
     1728                        mask |= (SHIFTREG_DATA | SHIFTREG_CLK); 
     1729                        oe_mask |= (SHIFTREG_DATA | SHIFTREG_CLK); 
     1730                        l->state = (l->polarity != NORMAL); 
     1731                        set_led_shift(l); 
     1732                        break; 
     1733                case GPIO_TYPE_NORMAL: 
     1734                default: 
     1735                        if (l->polarity != INPUT) oe_mask |= l->gpio; 
     1736                        mask |= l->gpio; 
     1737                        val |= (l->polarity == NORMAL)?0:l->gpio; 
     1738                        break; 
     1739                } 
     1740 
     1741                if (l->polarity == INPUT) continue; 
     1742 
     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                } 
     1749        } 
     1750 
     1751        bcm47xx_gpio_outen(mask, oe_mask); 
     1752        bcm47xx_gpio_control(mask, 0); 
     1753        bcm47xx_gpio_out(mask, val); 
     1754        bcm47xx_gpio_intmask(mask, 0); 
     1755} 
     1756 
     1757static void unregister_leds(struct led_t *l) 
     1758{ 
     1759        for(; l->name; l++) 
     1760                remove_proc_entry(l->name, leds); 
     1761 
     1762        remove_proc_entry("led", diag); 
     1763} 
     1764 
    17471765static int __init diag_init(void) 
    17481766{ 
  • trunk/package/kernel/broadcom-diag/src/diag.h

    r37007 r37278  
    8686#endif 
    8787}; 
    88  
    89 extern char *nvram_get(char *str); 
    90  
    91 static struct platform_t platform; 
    92  
    93 /* buttons */ 
    94  
    95 static void register_buttons(struct button_t *b); 
    96 static void unregister_buttons(struct button_t *b); 
    97  
    98 static void hotplug_button(struct work_struct *work); 
    99 static irqreturn_t button_handler(int irq, void *dev_id); 
    100  
    101 /* leds */ 
    102  
    103 static void register_leds(struct led_t *l); 
    104 static void unregister_leds(struct led_t *l); 
    105  
    106 static void set_led_extif(struct led_t *led); 
    107 static void set_led_shift(struct led_t *led); 
    108 static void led_flash(unsigned long dummy); 
    109  
    110 /* 2.4 compatibility */ 
    111 #ifndef TIMER_INITIALIZER 
    112 #define TIMER_INITIALIZER(_function, _expires, _data) \ 
    113         { \ 
    114                 /* _expires and _data currently unused */ \ 
    115                 function: _function \ 
    116         } 
    117 #endif 
    118  
    119 static struct timer_list led_timer = TIMER_INITIALIZER(&led_flash, 0, 0); 
    120  
    121 /* proc */ 
    122  
    123 static struct proc_dir_entry *diag, *leds; 
    124  
    125 static ssize_t diag_proc_read(struct file *file, char *buf, size_t count, loff_t *ppos); 
    126 static ssize_t diag_proc_write(struct file *file, const char *buf, size_t count, loff_t *ppos); 
    127  
    128 static struct file_operations diag_proc_fops = { 
    129         read: diag_proc_read, 
    130         write: diag_proc_write 
    131 }; 
    132  
    133 static struct prochandler_t proc_model = { .type = PROC_MODEL }; 
    134 static struct prochandler_t proc_gpiomask = { .type = PROC_GPIOMASK }; 
    135  
Note: See TracChangeset for help on using the changeset viewer.