brcmfmac: make use of seq_file API for debugfs entries
authorArend van Spriel <arend@broadcom.com>
Sat, 12 Jul 2014 06:49:35 +0000 (08:49 +0200)
committerJohn W. Linville <linville@tuxdriver.com>
Tue, 15 Jul 2014 20:00:10 +0000 (16:00 -0400)
The use of seq_file simplifies the debugfs code. Simpler is
better.

Reviewed-by: Hante Meuleman <meuleman@broadcom.com>
Reviewed-by: Franky (Zhenhui) Lin <frankyl@broadcom.com>
Reviewed-by: Pieter-Paul Giesberts <pieterpg@broadcom.com>
Signed-off-by: Arend van Spriel <arend@broadcom.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
drivers/net/wireless/brcm80211/brcmfmac/dhd_dbg.c
drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c

index 03fe8ac..e1ac932 100644 (file)
@@ -41,28 +41,27 @@ void brcmf_debugfs_exit(void)
        root_folder = NULL;
 }
 
-static
-ssize_t brcmf_debugfs_chipinfo_read(struct file *f, char __user *data,
-                                  size_t count, loff_t *ppos)
+static int brcmf_debugfs_chipinfo_read(struct seq_file *seq, void *data)
 {
-       struct brcmf_pub *drvr = f->private_data;
+       struct brcmf_pub *drvr = seq->private;
        struct brcmf_bus *bus = drvr->bus_if;
-       char buf[40];
-       int res;
 
-       /* only allow read from start */
-       if (*ppos > 0)
-               return 0;
+       seq_printf(seq, "chip: %x(%u) rev %u\n",
+                  bus->chip, bus->chip, bus->chiprev);
+       return 0;
+}
 
-       res = scnprintf(buf, sizeof(buf), "chip: %x(%u) rev %u\n",
-                       bus->chip, bus->chip, bus->chiprev);
-       return simple_read_from_buffer(data, count, ppos, buf, res);
+static int brcmf_debugfs_chipinfo_open(struct inode *inode, struct file *f)
+{
+       return single_open(f, brcmf_debugfs_chipinfo_read, inode->i_private);
 }
 
 static const struct file_operations brcmf_debugfs_chipinfo_ops = {
        .owner = THIS_MODULE,
-       .open = simple_open,
-       .read = brcmf_debugfs_chipinfo_read
+       .open = brcmf_debugfs_chipinfo_open,
+       .release = single_release,
+       .read = seq_read,
+       .llseek = seq_lseek
 };
 
 static int brcmf_debugfs_create_chipinfo(struct brcmf_pub *drvr)
@@ -98,55 +97,54 @@ struct dentry *brcmf_debugfs_get_devdir(struct brcmf_pub *drvr)
        return drvr->dbgfs_dir;
 }
 
-static
-ssize_t brcmf_debugfs_sdio_counter_read(struct file *f, char __user *data,
-                                       size_t count, loff_t *ppos)
+static int brcmf_debugfs_sdio_count_read(struct seq_file *seq, void *data)
 {
-       struct brcmf_sdio_count *sdcnt = f->private_data;
-       char buf[750];
-       int res;
-
-       /* only allow read from start */
-       if (*ppos > 0)
-               return 0;
-
-       res = scnprintf(buf, sizeof(buf),
-                       "intrcount:    %u\nlastintrs:    %u\n"
-                       "pollcnt:      %u\nregfails:     %u\n"
-                       "tx_sderrs:    %u\nfcqueued:     %u\n"
-                       "rxrtx:        %u\nrx_toolong:   %u\n"
-                       "rxc_errors:   %u\nrx_hdrfail:   %u\n"
-                       "rx_badhdr:    %u\nrx_badseq:    %u\n"
-                       "fc_rcvd:      %u\nfc_xoff:      %u\n"
-                       "fc_xon:       %u\nrxglomfail:   %u\n"
-                       "rxglomframes: %u\nrxglompkts:   %u\n"
-                       "f2rxhdrs:     %u\nf2rxdata:     %u\n"
-                       "f2txdata:     %u\nf1regdata:    %u\n"
-                       "tickcnt:      %u\ntx_ctlerrs:   %lu\n"
-                       "tx_ctlpkts:   %lu\nrx_ctlerrs:   %lu\n"
-                       "rx_ctlpkts:   %lu\nrx_readahead: %lu\n",
-                       sdcnt->intrcount, sdcnt->lastintrs,
-                       sdcnt->pollcnt, sdcnt->regfails,
-                       sdcnt->tx_sderrs, sdcnt->fcqueued,
-                       sdcnt->rxrtx, sdcnt->rx_toolong,
-                       sdcnt->rxc_errors, sdcnt->rx_hdrfail,
-                       sdcnt->rx_badhdr, sdcnt->rx_badseq,
-                       sdcnt->fc_rcvd, sdcnt->fc_xoff,
-                       sdcnt->fc_xon, sdcnt->rxglomfail,
-                       sdcnt->rxglomframes, sdcnt->rxglompkts,
-                       sdcnt->f2rxhdrs, sdcnt->f2rxdata,
-                       sdcnt->f2txdata, sdcnt->f1regdata,
-                       sdcnt->tickcnt, sdcnt->tx_ctlerrs,
-                       sdcnt->tx_ctlpkts, sdcnt->rx_ctlerrs,
-                       sdcnt->rx_ctlpkts, sdcnt->rx_readahead_cnt);
-
-       return simple_read_from_buffer(data, count, ppos, buf, res);
+       struct brcmf_sdio_count *sdcnt = seq->private;
+
+       seq_printf(seq,
+                  "intrcount:    %u\nlastintrs:    %u\n"
+                  "pollcnt:      %u\nregfails:     %u\n"
+                  "tx_sderrs:    %u\nfcqueued:     %u\n"
+                  "rxrtx:        %u\nrx_toolong:   %u\n"
+                  "rxc_errors:   %u\nrx_hdrfail:   %u\n"
+                  "rx_badhdr:    %u\nrx_badseq:    %u\n"
+                  "fc_rcvd:      %u\nfc_xoff:      %u\n"
+                  "fc_xon:       %u\nrxglomfail:   %u\n"
+                  "rxglomframes: %u\nrxglompkts:   %u\n"
+                  "f2rxhdrs:     %u\nf2rxdata:     %u\n"
+                  "f2txdata:     %u\nf1regdata:    %u\n"
+                  "tickcnt:      %u\ntx_ctlerrs:   %lu\n"
+                  "tx_ctlpkts:   %lu\nrx_ctlerrs:   %lu\n"
+                  "rx_ctlpkts:   %lu\nrx_readahead: %lu\n",
+                  sdcnt->intrcount, sdcnt->lastintrs,
+                  sdcnt->pollcnt, sdcnt->regfails,
+                  sdcnt->tx_sderrs, sdcnt->fcqueued,
+                  sdcnt->rxrtx, sdcnt->rx_toolong,
+                  sdcnt->rxc_errors, sdcnt->rx_hdrfail,
+                  sdcnt->rx_badhdr, sdcnt->rx_badseq,
+                  sdcnt->fc_rcvd, sdcnt->fc_xoff,
+                  sdcnt->fc_xon, sdcnt->rxglomfail,
+                  sdcnt->rxglomframes, sdcnt->rxglompkts,
+                  sdcnt->f2rxhdrs, sdcnt->f2rxdata,
+                  sdcnt->f2txdata, sdcnt->f1regdata,
+                  sdcnt->tickcnt, sdcnt->tx_ctlerrs,
+                  sdcnt->tx_ctlpkts, sdcnt->rx_ctlerrs,
+                  sdcnt->rx_ctlpkts, sdcnt->rx_readahead_cnt);
+
+       return 0;
+}
+
+static int brcmf_debugfs_sdio_count_open(struct inode *inode, struct file *f)
+{
+       return single_open(f, brcmf_debugfs_sdio_count_read, inode->i_private);
 }
 
 static const struct file_operations brcmf_debugfs_sdio_counter_ops = {
        .owner = THIS_MODULE,
-       .open = simple_open,
-       .read = brcmf_debugfs_sdio_counter_read
+       .open = brcmf_debugfs_sdio_count_open,
+       .release = single_release,
+       .read = seq_read,
+       .llseek = seq_lseek
 };
 
 void brcmf_debugfs_create_sdio_count(struct brcmf_pub *drvr,
@@ -159,79 +157,78 @@ void brcmf_debugfs_create_sdio_count(struct brcmf_pub *drvr,
                                    sdcnt, &brcmf_debugfs_sdio_counter_ops);
 }
 
-static
-ssize_t brcmf_debugfs_fws_stats_read(struct file *f, char __user *data,
-                                    size_t count, loff_t *ppos)
+static int brcmf_debugfs_fws_stats_read(struct seq_file *seq, void *data)
+{
+       struct brcmf_fws_stats *fwstats = seq->private;
+
+       seq_printf(seq,
+                  "header_pulls:      %u\n"
+                  "header_only_pkt:   %u\n"
+                  "tlv_parse_failed:  %u\n"
+                  "tlv_invalid_type:  %u\n"
+                  "mac_update_fails:  %u\n"
+                  "ps_update_fails:   %u\n"
+                  "if_update_fails:   %u\n"
+                  "pkt2bus:           %u\n"
+                  "generic_error:     %u\n"
+                  "rollback_success:  %u\n"
+                  "rollback_failed:   %u\n"
+                  "delayq_full:       %u\n"
+                  "supprq_full:       %u\n"
+                  "txs_indicate:      %u\n"
+                  "txs_discard:       %u\n"
+                  "txs_suppr_core:    %u\n"
+                  "txs_suppr_ps:      %u\n"
+                  "txs_tossed:        %u\n"
+                  "txs_host_tossed:   %u\n"
+                  "bus_flow_block:    %u\n"
+                  "fws_flow_block:    %u\n"
+                  "send_pkts:         BK:%u BE:%u VO:%u VI:%u BCMC:%u\n"
+                  "requested_sent:    BK:%u BE:%u VO:%u VI:%u BCMC:%u\n",
+                  fwstats->header_pulls,
+                  fwstats->header_only_pkt,
+                  fwstats->tlv_parse_failed,
+                  fwstats->tlv_invalid_type,
+                  fwstats->mac_update_failed,
+                  fwstats->mac_ps_update_failed,
+                  fwstats->if_update_failed,
+                  fwstats->pkt2bus,
+                  fwstats->generic_error,
+                  fwstats->rollback_success,
+                  fwstats->rollback_failed,
+                  fwstats->delayq_full_error,
+                  fwstats->supprq_full_error,
+                  fwstats->txs_indicate,
+                  fwstats->txs_discard,
+                  fwstats->txs_supp_core,
+                  fwstats->txs_supp_ps,
+                  fwstats->txs_tossed,
+                  fwstats->txs_host_tossed,
+                  fwstats->bus_flow_block,
+                  fwstats->fws_flow_block,
+                  fwstats->send_pkts[0], fwstats->send_pkts[1],
+                  fwstats->send_pkts[2], fwstats->send_pkts[3],
+                  fwstats->send_pkts[4],
+                  fwstats->requested_sent[0],
+                  fwstats->requested_sent[1],
+                  fwstats->requested_sent[2],
+                  fwstats->requested_sent[3],
+                  fwstats->requested_sent[4]);
+
+       return 0;
+}
+
+static int brcmf_debugfs_fws_stats_open(struct inode *inode, struct file *f)
 {
-       struct brcmf_fws_stats *fwstats = f->private_data;
-       char buf[650];
-       int res;
-
-       /* only allow read from start */
-       if (*ppos > 0)
-               return 0;
-
-       res = scnprintf(buf, sizeof(buf),
-                       "header_pulls:      %u\n"
-                       "header_only_pkt:   %u\n"
-                       "tlv_parse_failed:  %u\n"
-                       "tlv_invalid_type:  %u\n"
-                       "mac_update_fails:  %u\n"
-                       "ps_update_fails:   %u\n"
-                       "if_update_fails:   %u\n"
-                       "pkt2bus:           %u\n"
-                       "generic_error:     %u\n"
-                       "rollback_success:  %u\n"
-                       "rollback_failed:   %u\n"
-                       "delayq_full:       %u\n"
-                       "supprq_full:       %u\n"
-                       "txs_indicate:      %u\n"
-                       "txs_discard:       %u\n"
-                       "txs_suppr_core:    %u\n"
-                       "txs_suppr_ps:      %u\n"
-                       "txs_tossed:        %u\n"
-                       "txs_host_tossed:   %u\n"
-                       "bus_flow_block:    %u\n"
-                       "fws_flow_block:    %u\n"
-                       "send_pkts:         BK:%u BE:%u VO:%u VI:%u BCMC:%u\n"
-                       "requested_sent:    BK:%u BE:%u VO:%u VI:%u BCMC:%u\n",
-                       fwstats->header_pulls,
-                       fwstats->header_only_pkt,
-                       fwstats->tlv_parse_failed,
-                       fwstats->tlv_invalid_type,
-                       fwstats->mac_update_failed,
-                       fwstats->mac_ps_update_failed,
-                       fwstats->if_update_failed,
-                       fwstats->pkt2bus,
-                       fwstats->generic_error,
-                       fwstats->rollback_success,
-                       fwstats->rollback_failed,
-                       fwstats->delayq_full_error,
-                       fwstats->supprq_full_error,
-                       fwstats->txs_indicate,
-                       fwstats->txs_discard,
-                       fwstats->txs_supp_core,
-                       fwstats->txs_supp_ps,
-                       fwstats->txs_tossed,
-                       fwstats->txs_host_tossed,
-                       fwstats->bus_flow_block,
-                       fwstats->fws_flow_block,
-                       fwstats->send_pkts[0], fwstats->send_pkts[1],
-                       fwstats->send_pkts[2], fwstats->send_pkts[3],
-                       fwstats->send_pkts[4],
-                       fwstats->requested_sent[0],
-                       fwstats->requested_sent[1],
-                       fwstats->requested_sent[2],
-                       fwstats->requested_sent[3],
-                       fwstats->requested_sent[4]);
-
-       return simple_read_from_buffer(data, count, ppos, buf, res);
+       return single_open(f, brcmf_debugfs_fws_stats_read, inode->i_private);
 }
 
 static const struct file_operations brcmf_debugfs_fws_stats_ops = {
        .owner = THIS_MODULE,
-       .open = simple_open,
-       .read = brcmf_debugfs_fws_stats_read
+       .open = brcmf_debugfs_fws_stats_open,
+       .release = single_release,
+       .read = seq_read,
+       .llseek = seq_lseek
 };
 
 void brcmf_debugfs_create_fws_stats(struct brcmf_pub *drvr,
index bf9bc2d..0c98a79 100644 (file)
@@ -2898,16 +2898,13 @@ brcmf_sdio_bus_txctl(struct device *dev, unsigned char *msg, uint msglen)
 }
 
 #ifdef DEBUG
-static int brcmf_sdio_dump_console(struct brcmf_sdio *bus,
-                                  struct sdpcm_shared *sh, char __user *data,
-                                  size_t count)
+static int brcmf_sdio_dump_console(struct seq_file *seq, struct brcmf_sdio *bus,
+                                  struct sdpcm_shared *sh)
 {
        u32 addr, console_ptr, console_size, console_index;
        char *conbuf = NULL;
        __le32 sh_val;
        int rv;
-       loff_t pos = 0;
-       int nbytes = 0;
 
        /* obtain console information from device memory */
        addr = sh->console_addr + offsetof(struct rte_console, log_le);
@@ -2945,33 +2942,24 @@ static int brcmf_sdio_dump_console(struct brcmf_sdio *bus,
        if (rv < 0)
                goto done;
 
-       rv = simple_read_from_buffer(data, count, &pos,
-                                    conbuf + console_index,
-                                    console_size - console_index);
+       rv = seq_write(seq, conbuf + console_index,
+                      console_size - console_index);
        if (rv < 0)
                goto done;
 
-       nbytes = rv;
-       if (console_index > 0) {
-               pos = 0;
-               rv = simple_read_from_buffer(data+nbytes, count, &pos,
-                                            conbuf, console_index - 1);
-               if (rv < 0)
-                       goto done;
-               rv += nbytes;
-       }
+       if (console_index > 0)
+               rv = seq_write(seq, conbuf, console_index - 1);
+
 done:
        vfree(conbuf);
        return rv;
 }
 
-static int brcmf_sdio_trap_info(struct brcmf_sdio *bus, struct sdpcm_shared *sh,
-                               char __user *data, size_t count)
+static int brcmf_sdio_trap_info(struct seq_file *seq, struct brcmf_sdio *bus,
+                               struct sdpcm_shared *sh)
 {
-       int error, res;
-       char buf[350];
+       int error;
        struct brcmf_trap_info tr;
-       loff_t pos = 0;
 
        if ((sh->flags & SDPCM_SHARED_TRAP) == 0) {
                brcmf_dbg(INFO, "no trap in firmware\n");
@@ -2983,34 +2971,30 @@ static int brcmf_sdio_trap_info(struct brcmf_sdio *bus, struct sdpcm_shared *sh,
        if (error < 0)
                return error;
 
-       res = scnprintf(buf, sizeof(buf),
-                       "dongle trap info: type 0x%x @ epc 0x%08x\n"
-                       "  cpsr 0x%08x spsr 0x%08x sp 0x%08x\n"
-                       "  lr   0x%08x pc   0x%08x offset 0x%x\n"
-                       "  r0   0x%08x r1   0x%08x r2 0x%08x r3 0x%08x\n"
-                       "  r4   0x%08x r5   0x%08x r6 0x%08x r7 0x%08x\n",
-                       le32_to_cpu(tr.type), le32_to_cpu(tr.epc),
-                       le32_to_cpu(tr.cpsr), le32_to_cpu(tr.spsr),
-                       le32_to_cpu(tr.r13), le32_to_cpu(tr.r14),
-                       le32_to_cpu(tr.pc), sh->trap_addr,
-                       le32_to_cpu(tr.r0), le32_to_cpu(tr.r1),
-                       le32_to_cpu(tr.r2), le32_to_cpu(tr.r3),
-                       le32_to_cpu(tr.r4), le32_to_cpu(tr.r5),
-                       le32_to_cpu(tr.r6), le32_to_cpu(tr.r7));
-
-       return simple_read_from_buffer(data, count, &pos, buf, res);
+       seq_printf(seq,
+                  "dongle trap info: type 0x%x @ epc 0x%08x\n"
+                  "  cpsr 0x%08x spsr 0x%08x sp 0x%08x\n"
+                  "  lr   0x%08x pc   0x%08x offset 0x%x\n"
+                  "  r0   0x%08x r1   0x%08x r2 0x%08x r3 0x%08x\n"
+                  "  r4   0x%08x r5   0x%08x r6 0x%08x r7 0x%08x\n",
+                  le32_to_cpu(tr.type), le32_to_cpu(tr.epc),
+                  le32_to_cpu(tr.cpsr), le32_to_cpu(tr.spsr),
+                  le32_to_cpu(tr.r13), le32_to_cpu(tr.r14),
+                  le32_to_cpu(tr.pc), sh->trap_addr,
+                  le32_to_cpu(tr.r0), le32_to_cpu(tr.r1),
+                  le32_to_cpu(tr.r2), le32_to_cpu(tr.r3),
+                  le32_to_cpu(tr.r4), le32_to_cpu(tr.r5),
+                  le32_to_cpu(tr.r6), le32_to_cpu(tr.r7));
+
+       return 0;
 }
 
-static int brcmf_sdio_assert_info(struct brcmf_sdio *bus,
-                                 struct sdpcm_shared *sh, char __user *data,
-                                 size_t count)
+static int brcmf_sdio_assert_info(struct seq_file *seq, struct brcmf_sdio *bus,
+                                 struct sdpcm_shared *sh)
 {
        int error = 0;
-       char buf[200];
        char file[80] = "?";
        char expr[80] = "<???>";
-       int res;
-       loff_t pos = 0;
 
        if ((sh->flags & SDPCM_SHARED_ASSERT_BUILT) == 0) {
                brcmf_dbg(INFO, "firmware not built with -assert\n");
@@ -3035,10 +3019,9 @@ static int brcmf_sdio_assert_info(struct brcmf_sdio *bus,
        }
        sdio_release_host(bus->sdiodev->func[1]);
 
-       res = scnprintf(buf, sizeof(buf),
-                       "dongle assert: %s:%d: assert(%s)\n",
-                       file, sh->assert_line, expr);
-       return simple_read_from_buffer(data, count, &pos, buf, res);
+       seq_printf(seq, "dongle assert: %s:%d: assert(%s)\n",
+                  file, sh->assert_line, expr);
+       return 0;
 }
 
 static int brcmf_sdio_checkdied(struct brcmf_sdio *bus)
@@ -3062,58 +3045,47 @@ static int brcmf_sdio_checkdied(struct brcmf_sdio *bus)
        return 0;
 }
 
-static int brcmf_sdio_died_dump(struct brcmf_sdio *bus, char __user *data,
-                               size_t count, loff_t *ppos)
+static int brcmf_sdio_died_dump(struct seq_file *seq, struct brcmf_sdio *bus)
 {
        int error = 0;
        struct sdpcm_shared sh;
-       int nbytes = 0;
-       loff_t pos = *ppos;
-
-       if (pos != 0)
-               return 0;
 
        error = brcmf_sdio_readshared(bus, &sh);
        if (error < 0)
                goto done;
 
-       error = brcmf_sdio_assert_info(bus, &sh, data, count);
+       error = brcmf_sdio_assert_info(seq, bus, &sh);
        if (error < 0)
                goto done;
-       nbytes = error;
 
-       error = brcmf_sdio_trap_info(bus, &sh, data+nbytes, count);
+       error = brcmf_sdio_trap_info(seq, bus, &sh);
        if (error < 0)
                goto done;
-       nbytes += error;
 
-       error = brcmf_sdio_dump_console(bus, &sh, data+nbytes, count);
-       if (error < 0)
-               goto done;
-       nbytes += error;
+       error = brcmf_sdio_dump_console(seq, bus, &sh);
 
-       error = nbytes;
-       *ppos += nbytes;
 done:
        return error;
 }
 
-static ssize_t brcmf_sdio_forensic_read(struct file *f, char __user *data,
-                                       size_t count, loff_t *ppos)
+static int brcmf_sdio_forensic_read(struct seq_file *seq, void *data)
 {
-       struct brcmf_sdio *bus = f->private_data;
-       int res;
+       struct brcmf_sdio *bus = seq->private;
 
-       res = brcmf_sdio_died_dump(bus, data, count, ppos);
-       if (res > 0)
-               *ppos += res;
-       return (ssize_t)res;
+       return brcmf_sdio_died_dump(seq, bus);
+}
+
+static int brcmf_sdio_forensic_open(struct inode *inode, struct file *f)
+{
+       return single_open(f, brcmf_sdio_forensic_read, inode->i_private);
 }
 
 static const struct file_operations brcmf_sdio_forensic_ops = {
        .owner = THIS_MODULE,
-       .open = simple_open,
-       .read = brcmf_sdio_forensic_read
+       .open = brcmf_sdio_forensic_open,
+       .release = single_release,
+       .read = seq_read,
+       .llseek = seq_lseek
 };
 
 static void brcmf_sdio_debugfs_create(struct brcmf_sdio *bus)