Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 766d100d authored by David Howells's avatar David Howells Committed by Al Viro
Browse files

cxt1e1: Don't use create_proc_read_entry() 



Don't use create_proc_read_entry() as that is deprecated, but rather use
proc_create_data() and seq_file instead.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
cc: Bob Beers <bob.beers@gmail.com>
cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
cc: devel@driverdev.osuosl.org
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent 294a08e4

drivers/staging/cxt1e1/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -12,8 +12,9 @@ cxt1e1-y := \ 
  linux.o 		\

  functions.o 		\

  hwprobe.o 		\

  sbeproc.o 		\

  pmc93x6_eeprom.o 	\

  sbecrc.o 		\

  comet_tables.o 	\

  sbeid.o



cxt1e1-$(CONFIG_PROC_FS) += sbeproc.o

drivers/staging/cxt1e1/sbeproc.c

+161 −299
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/proc_fs.h>

#include <linux/seq_file.h>

#include <linux/sched.h>

#include <asm/uaccess.h>

#include "pmcc4_sysdep.h"
@@ -26,22 +27,12 @@ 
#include "pmcc4_private.h"

#include "sbeproc.h"



/* forwards */

void        sbecom_get_brdinfo (ci_t *, struct sbe_brd_info *, u_int8_t *);

extern void sbecom_get_brdinfo(ci_t *, struct sbe_brd_info *, u_int8_t *);

extern struct s_hdw_info hdw_info[MAX_BOARDS];



#ifdef CONFIG_PROC_FS



/********************************************************************/

/* procfs stuff                                                     */

/********************************************************************/





void

sbecom_proc_brd_cleanup (ci_t * ci)

{

    if (ci->dir_dev)

void sbecom_proc_brd_cleanup(ci_t *ci)

{

	if (ci->dir_dev) {

		char dir[7 + SBE_IFACETMPL_SIZE + 1];

		snprintf(dir, sizeof(dir), "driver/%s", ci->devname);

		remove_proc_entry("info", ci->dir_dev);
@@ -50,29 +41,9 @@ sbecom_proc_brd_cleanup (ci_t * ci) 
	}

}





static int

sbecom_proc_get_sbe_info (char *buffer, char **start, off_t offset,

                          int length, int *eof, void *priv)

{

    ci_t       *ci = (ci_t *) priv;

    int         len = 0;

    char       *spd;

    struct sbe_brd_info *bip;



    if (!(bip = OS_kmalloc (sizeof (struct sbe_brd_info))))

    {

        return -ENOMEM;

    }

#if 0

    /** RLD DEBUG **/

    pr_info(">> sbecom_proc_get_sbe_info: entered, offset %d. length %d.\n",

            (int) offset, (int) length);

#endif



static void sbecom_proc_get_brdinfo(ci_t *ci, struct sbe_brd_info *bip)

{

	hdw_info_t *hi = &hdw_info[ci->brdno];



	u_int8_t *bsn = 0;



	switch (hi->promfmt)
@@ -86,76 +57,88 @@ sbecom_proc_get_sbe_info (char *buffer, char **start, off_t offset, 
	}



	sbecom_get_brdinfo (ci, bip, bsn);



	pr_devel(">> sbecom_get_brdinfo: returned, first_if %p <%s> last_if %p <%s>\n",

		 bip->first_iname, bip->first_iname,

		 bip->last_iname, bip->last_iname);

}



#if 0

    /** RLD DEBUG **/

    pr_info(">> sbecom_get_brdinfo: returned, first_if %p <%s> last_if %p <%s>\n",

            (char *) &bip->first_iname, (char *) &bip->first_iname,

            (char *) &bip->last_iname, (char *) &bip->last_iname);

#endif

    len += sprintf (buffer + len, "Board Type:    ");

    switch (bip->brd_id)

/*

 * Describe the driver state through /proc

 */

static int sbecom_proc_get_sbe_info(struct seq_file *m, void *v)

{

	ci_t       *ci = m->private;

	char       *spd;

	struct sbe_brd_info *bip;



	if (!(bip = OS_kmalloc(sizeof(struct sbe_brd_info))))

		return -ENOMEM;



	pr_devel(">> sbecom_proc_get_sbe_info: entered\n");



	sbecom_proc_get_brdinfo(ci, bip);



	seq_puts(m, "Board Type:    ");

	switch (bip->brd_id) {

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C1T3):

        len += sprintf (buffer + len, "wanPMC-C1T3");

		seq_puts(m, "wanPMC-C1T3");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPTMC_256T3_E1):

        len += sprintf (buffer + len, "wanPTMC-256T3 <E1>");

		seq_puts(m, "wanPTMC-256T3 <E1>");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPTMC_256T3_T1):

        len += sprintf (buffer + len, "wanPTMC-256T3 <T1>");

		seq_puts(m, "wanPTMC-256T3 <T1>");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPTMC_C24TE1):

        len += sprintf (buffer + len, "wanPTMC-C24TE1");

		seq_puts(m, "wanPTMC-C24TE1");

		break;



	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C4T1E1):

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C4T1E1_L):

        len += sprintf (buffer + len, "wanPMC-C4T1E1");

		seq_puts(m, "wanPMC-C4T1E1");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C2T1E1):

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C2T1E1_L):

        len += sprintf (buffer + len, "wanPMC-C2T1E1");

		seq_puts(m, "wanPMC-C2T1E1");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C1T1E1):

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPMC_C1T1E1_L):

        len += sprintf (buffer + len, "wanPMC-C1T1E1");

		seq_puts(m, "wanPMC-C1T1E1");

		break;



	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPCI_C4T1E1):

        len += sprintf (buffer + len, "wanPCI-C4T1E1");

		seq_puts(m, "wanPCI-C4T1E1");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPCI_C2T1E1):

        len += sprintf (buffer + len, "wanPCI-C2T1E1");

		seq_puts(m, "wanPCI-C2T1E1");

		break;

	case SBE_BOARD_ID(PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_WANPCI_C1T1E1):

        len += sprintf (buffer + len, "wanPCI-C1T1E1");

		seq_puts(m, "wanPCI-C1T1E1");

		break;



	default:

        len += sprintf (buffer + len, "unknown");

		seq_puts(m, "unknown");

		break;

	}

    len += sprintf (buffer + len, "  [%08X]\n", bip->brd_id);



    len += sprintf (buffer + len, "Board Number:  %d\n", bip->brdno);

    len += sprintf (buffer + len, "Hardware ID:   0x%02X\n", ci->hdw_bid);

    len += sprintf (buffer + len, "Board SN:      %06X\n", bip->brd_sn);

	len += sprintf(buffer + len, "Board MAC:     %pMF\n",

		bip->brd_mac_addr);

    len += sprintf (buffer + len, "Ports:         %d\n", ci->max_port);

    len += sprintf (buffer + len, "Channels:      %d\n", bip->brd_chan_cnt);

	seq_printf(m, "  [%08X]\n", bip->brd_id);



	seq_printf(m, "Board Number:  %d\n", bip->brdno);

	seq_printf(m, "Hardware ID:   0x%02X\n", ci->hdw_bid);

	seq_printf(m, "Board SN:      %06X\n", bip->brd_sn);

	seq_printf(m, "Board MAC:     %pMF\n", bip->brd_mac_addr);

	seq_printf(m, "Ports:         %d\n", ci->max_port);

	seq_printf(m, "Channels:      %d\n", bip->brd_chan_cnt);

#if 1

    len += sprintf (buffer + len, "Interface:     %s -> %s\n",

                    (char *) &bip->first_iname, (char *) &bip->last_iname);

	seq_printf(m, "Interface:     %s -> %s\n",

		   bip->first_iname, bip->last_iname);

#else

    len += sprintf (buffer + len, "Interface:     <not available> 1st %p lst %p\n",

                    (char *) &bip->first_iname, (char *) &bip->last_iname);

	seq_printf(m, "Interface:     <not available> 1st %p lst %p\n",

		   bip->first_iname, bip->last_iname);

#endif



    switch (bip->brd_pci_speed)

    {

	switch (bip->brd_pci_speed) {

	case BINFO_PCI_SPEED_33:

		spd = "33Mhz";

		break;
@@ -166,8 +149,8 @@ sbecom_proc_get_sbe_info (char *buffer, char **start, off_t offset, 
		spd = "<not available>";

		break;

	}

    len += sprintf (buffer + len, "PCI Bus Speed: %s\n", spd);

    len += sprintf (buffer + len, "Release:       %s\n", ci->release);

	seq_printf(m, "PCI Bus Speed: %s\n", spd);

	seq_printf(m, "Release:       %s\n", ci->release);



#ifdef SBE_PMCC4_ENABLE

	{
@@ -178,154 +161,53 @@ sbecom_proc_get_sbe_info (char *buffer, char **start, off_t offset, 
#endif

		extern int max_rxdesc_used, max_txdesc_used;



        len += sprintf (buffer + len, "\ncxt1e1_max_mru:         %d\n", cxt1e1_max_mru);

		seq_printf(m, "\ncxt1e1_max_mru:         %d\n", cxt1e1_max_mru);

#if 0

        len += sprintf (buffer + len, "\nmax_chans_used:  %d\n", max_chans_used);

        len += sprintf (buffer + len, "cxt1e1_max_mtu:         %d\n", cxt1e1_max_mtu);

		seq_printf(m, "\nmax_chans_used:  %d\n", max_chans_used);

		seq_printf(m, "cxt1e1_max_mtu:         %d\n", cxt1e1_max_mtu);

#endif

        len += sprintf (buffer + len, "max_rxdesc_used: %d\n", max_rxdesc_used);

        len += sprintf (buffer + len, "max_txdesc_used: %d\n", max_txdesc_used);

		seq_printf(m, "max_rxdesc_used: %d\n", max_rxdesc_used);

		seq_printf(m, "max_txdesc_used: %d\n", max_txdesc_used);

	}

#endif



    OS_kfree (bip);                 /* cleanup */



    /***

     * How to be a proc read function

     * ------------------------------

     * Prototype:

     *    int f(char *buffer, char **start, off_t offset,

     *          int count, int *peof, void *dat)

     *

     * Assume that the buffer is "count" bytes in size.

     *

     * If you know you have supplied all the data you

     * have, set *peof.

     *

     * You have three ways to return data:

     * 0) Leave *start = NULL.  (This is the default.)

     *    Put the data of the requested offset at that

     *    offset within the buffer.  Return the number (n)

     *    of bytes there are from the beginning of the

     *    buffer up to the last byte of data.  If the

     *    number of supplied bytes (= n - offset) is

     *    greater than zero and you didn't signal eof

     *    and the reader is prepared to take more data

     *    you will be called again with the requested

     *    offset advanced by the number of bytes

     *    absorbed.  This interface is useful for files

     *    no larger than the buffer.

     * 1) Set *start = an unsigned long value less than

     *    the buffer address but greater than zero.

     *    Put the data of the requested offset at the

     *    beginning of the buffer.  Return the number of

     *    bytes of data placed there.  If this number is

     *    greater than zero and you didn't signal eof

     *    and the reader is prepared to take more data

     *    you will be called again with the requested

     *    offset advanced by *start.  This interface is

     *    useful when you have a large file consisting

     *    of a series of blocks which you want to count

     *    and return as wholes.

     *    (Hack by Paul.Russell@rustcorp.com.au)

     * 2) Set *start = an address within the buffer.

     *    Put the data of the requested offset at *start.

     *    Return the number of bytes of data placed there.

     *    If this number is greater than zero and you

     *    didn't signal eof and the reader is prepared to

     *    take more data you will be called again with the

     *    requested offset advanced by the number of bytes

     *    absorbed.

     */

	kfree(bip);



#if 1

    /* #4 - interpretation of above = set EOF, return len */

    *eof = 1;

#endif

	pr_devel(">> proc_fs: finished\n");

	return 0;

}



#if 0

/*

     * #1 - from net/wireless/atmel.c RLD NOTE -there's something wrong with

     * this plagarized code which results in this routine being called TWICE.

     * The second call returns ZERO, resulting in hidden failure, but at

     * least only a single message set is being displayed.

 * seq_file wrappers for procfile show routines.

 */

    if (len <= offset + length)

        *eof = 1;

    *start = buffer + offset;

    len -= offset;

    if (len > length)

        len = length;

    if (len < 0)

        len = 0;

#endif



#if 0                               /* #2 from net/tokenring/olympic.c +

                                     * lanstreamer.c */

    {

        off_t       begin = 0;

        int         size = 0;

        off_t       pos = 0;



        size = len;

        pos = begin + size;

        if (pos < offset)

static int sbecom_proc_open(struct inode *inode, struct file *file)

{

            len = 0;

            begin = pos;

        }

        *start = buffer + (offset - begin);     /* Start of wanted data */

        len -= (offset - begin);    /* Start slop */

        if (len > length)

            len = length;           /* Ending slop */

    }

#endif



#if 0                               /* #3 from

                                     * char/ftape/lowlevel/ftape-proc.c */

    len = strlen (buffer);

    *start = NULL;

    if (offset + length >= len)

        *eof = 1;

    else

        *eof = 0;

#endif



#if 0

    pr_info(">> proc_fs: returned len = %d., start %p\n", len, start);  /* RLD DEBUG */

#endif



/***

   using NONE: returns = 314.314.314.

   using #1  : returns = 314, 0.

   using #2  : returns = 314, 0, 0.

   using #3  : returns = 314, 314.

   using #4  : returns = 314, 314.

***/



    return len;

	return single_open(file, sbecom_proc_get_sbe_info, PDE_DATA(inode));

}



/* initialize the /proc subsystem for the specific SBE driver */

static const struct file_operations sbecom_proc_fops = {

	.open		= sbecom_proc_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= seq_release,

};



int         __init

sbecom_proc_brd_init (ci_t * ci)

/*

 * Initialize the /proc subsystem for the specific SBE driver

 */

int __init sbecom_proc_brd_init(ci_t *ci)

{

    struct proc_dir_entry *e;

	char dir[7 + SBE_IFACETMPL_SIZE + 1];



    /* create a directory in the root procfs */

	snprintf(dir, sizeof(dir), "driver/%s", ci->devname);

	ci->dir_dev = proc_mkdir(dir, NULL);

    if (!ci->dir_dev)

    {

	if (!ci->dir_dev) {

		pr_err("Unable to create directory /proc/driver/%s\n", ci->devname);

		goto fail;

	}

    e = create_proc_read_entry ("info", S_IFREG | S_IRUGO,

                                ci->dir_dev, sbecom_proc_get_sbe_info, ci);

    if (!e)

    {



	if (!proc_create_data("info", S_IFREG | S_IRUGO, ci->dir_dev,

			      &sbecom_proc_fops, ci)) {

		pr_err("Unable to create entry /proc/driver/%s/info\n", ci->devname);

		goto fail;

	}
@@ -335,23 +217,3 @@ fail: 
	sbecom_proc_brd_cleanup(ci);

	return 1;

}
 


#else                           /*** ! CONFIG_PROC_FS ***/



/* stubbed off dummy routines */



void

sbecom_proc_brd_cleanup (ci_t * ci)

{

}



int         __init

sbecom_proc_brd_init (ci_t * ci)

{

    return 0;

}



#endif                          /*** CONFIG_PROC_FS ***/





/*** End-of-File ***/

drivers/staging/cxt1e1/sbeproc.h

+12 −2
Original line number Diff line number Diff line
@@ -23,10 +23,20 @@ 




#ifdef CONFIG_PROC_FS

#ifdef __KERNEL__

void        sbecom_proc_brd_cleanup (ci_t *);

int __init  sbecom_proc_brd_init (ci_t *);



#endif                          /*** __KERNEL__ ***/

#else



static inline void sbecom_proc_brd_cleanup(ci_t * ci)

{

}



static inline int __init sbecom_proc_brd_init(ci_t * ci)

{

	return 0;

}



#endif                          /*** CONFIG_PROC_FS ***/



#endif                          /*** _INC_SBEPROC_H_ ***/