v2.4.9.7 -> v2.4.9.8

  - Christoph Hellwig: clean up personality handling a bit
  - Robert Love: update sysctl/vm documentation
  - make the three-argument (that everybody hates) "min()" be "min_t()",
  and introduce a type-anal "min()" that complains about arguments of
  different types.

81 files changed, 318 insertions, 289 deletions

diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index 779a38ab5147..43239b602531 100644
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -1210,6 +1210,8 @@ static int mfm_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long a
 
 	case BLKGETSIZE:
 		return put_user (mfm[minor].nr_sects, (long *)arg);
+	case BLKGETSIZE64:
+		return put_user ((u64)mfm[minor].nr_sects << 9, (u64 *)arg);
 
 	case BLKFRASET:
 		if (!capable(CAP_SYS_ADMIN))
diff --git a/drivers/acorn/scsi/acornscsi.c b/drivers/acorn/scsi/acornscsi.c
index 66525f304374..9d43392b6cba 100644
--- a/drivers/acorn/scsi/acornscsi.c
+++ b/drivers/acorn/scsi/acornscsi.c
@@ -1059,7 +1059,7 @@ void acornscsi_dma_setup(AS_Host *host, dmadir_t direction)
     /*
      * Allocate some buffer space, limited to half the buffer size
      */
-    length = min(unsigned int, host->scsi.SCp.this_residual, DMAC_BUFFER_SIZE / 2);
+    length = min_t(unsigned int, host->scsi.SCp.this_residual, DMAC_BUFFER_SIZE / 2);
     if (length) {
 	host->dma.start_addr = address = host->dma.free_addr;
 	host->dma.free_addr = (host->dma.free_addr + length) &
@@ -1187,7 +1187,7 @@ void acornscsi_dma_intr(AS_Host *host)
     /*
      * Allocate some buffer space, limited to half the on-board RAM size
      */
-    length = min(unsigned int, host->scsi.SCp.this_residual, DMAC_BUFFER_SIZE / 2);
+    length = min_t(unsigned int, host->scsi.SCp.this_residual, DMAC_BUFFER_SIZE / 2);
     if (length) {
 	host->dma.start_addr = address = host->dma.free_addr;
 	host->dma.free_addr = (host->dma.free_addr + length) &
@@ -1656,8 +1656,8 @@ void acornscsi_message(AS_Host *host)
 		 * to be in operation AFTER the target leaves message out phase.
 		 */
 		acornscsi_sbic_issuecmd(host, CMND_ASSERTATN);
-		period = max(unsigned int, message[3], sdtr_period / 4);
-		length = min(unsigned int, message[4], sdtr_size);
+		period = max_t(unsigned int, message[3], sdtr_period / 4);
+		length = min_t(unsigned int, message[4], sdtr_size);
 		msgqueue_addmsg(&host->scsi.msgs, 5, EXTENDED_MESSAGE, 3,
 				 EXTENDED_SDTR, period, length);
 		host->device[host->SCpnt->target].sync_xfer =
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 1f4b9bce5c72..f77ca63e4be1 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -5074,10 +5074,12 @@ static int DAC960_IOCTL(Inode_T *Inode, File_T *File,
 			   sizeof(DiskGeometry_T)) ? -EFAULT : 0);
     case BLKGETSIZE:
       /* Get Device Size. */
-      if ((long *) Argument == NULL) return -EINVAL;
       return put_user(Controller->GenericDiskInfo.part[MINOR(Inode->i_rdev)]
 						 .nr_sects,
 		      (long *) Argument);
+    case BLKGETSIZE64:
+      return put_user((u64)Controller->GenericDiskInfo.part[MINOR(Inode->i_rdev)].nr_sects << 9,
+		      (u64 *) Argument);
     case BLKRAGET:
     case BLKRASET:
     case BLKFLSBUF:
diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index 6d44e211f1f8..7ea29ae90e59 100644
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -1138,6 +1138,10 @@ static int acsi_ioctl( struct inode *inode, struct file *file,
 		return put_user(acsi_part[MINOR(inode->i_rdev)].nr_sects,
 				(long *) arg);
 
+	  case BLKGETSIZE64:   /* Return device size */
+		return put_user((u64)acsi_part[MINOR(inode->i_rdev)].nr_sects << 9,
+				(u64 *) arg);
+
 	  case BLKROSET:
 	  case BLKROGET:
 	  case BLKFLSBUF:
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index c322a942fe5e..36239305ea37 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1556,6 +1556,9 @@ static int fd_ioctl(struct inode *inode, struct file *filp,
 	case BLKGETSIZE:
 		return put_user(unit[drive].blocks,(long *)param);
 		break;
+	case BLKGETSIZE64:
+		return put_user((u64)unit[drive].blocks << 9, (u64 *)param);
+		break;
 	case FDSETPRM:
 	case FDDEFPRM:
 		return -EINVAL;
diff --git a/drivers/block/blkpg.c b/drivers/block/blkpg.c
index 166ae2505130..63705f54f4da 100644
--- a/drivers/block/blkpg.c
+++ b/drivers/block/blkpg.c
@@ -239,6 +239,7 @@ int blk_ioctl(kdev_t dev, unsigned int cmd, unsigned long arg)
 		case BLKGETSIZE:
 			/* Today get_gendisk() requires a linear scan;
 			   add this when dev has pointer type. */
+			/* add BLKGETSIZE64 too */
 			g = get_gendisk(dev);
 			if (!g)
 				longval = 0;
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 0539f3aa5945..341cd09c87e6 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -400,9 +400,11 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 		put_user(hba[ctlr]->hd[MINOR(inode->i_rdev)].start_sect, &geo->start);
 		return 0;
 	case BLKGETSIZE:
-		if (!arg) return -EINVAL;
 		put_user(hba[ctlr]->hd[MINOR(inode->i_rdev)].nr_sects, (long*)arg);
 		return 0;
+	case BLKGETSIZE64:
+		put_user((u64)hba[ctlr]->hd[MINOR(inode->i_rdev)].nr_sects << 9, (u64*)arg);
+		return 0;
 	case BLKRRPART:
 		return revalidate_logvol(inode->i_rdev, 1);
 	case BLKFLSBUF:
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index b8ed321cae32..def052deb126 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -1216,9 +1216,9 @@ static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
 	case IDAGETDRVINFO:
 		return copy_to_user(&io->c.drv,&hba[ctlr]->drv[dsk],sizeof(drv_info_t));
 	case BLKGETSIZE:
-		if (!arg) return -EINVAL;
-		put_user(ida[(ctlr<<CTLR_SHIFT)+MINOR(inode->i_rdev)].nr_sects, (long*)arg);
-		return 0;
+		return put_user(ida[(ctlr<<CTLR_SHIFT)+MINOR(inode->i_rdev)].nr_sects, (long*)arg);
+	case BLKGETSIZE64:
+		return put_user((u64)(ida[(ctlr<<CTLR_SHIFT)+MINOR(inode->i_rdev)].nr_sects) << 9, (u64*)arg);
 	case BLKRRPART:
 		return revalidate_logvol(inode->i_rdev, 1);
 	case IDAPASSTHRU:
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 297d350b0544..941e63c2e59b 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3497,6 +3497,10 @@ static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
 		case BLKGETSIZE:
 			ECALL(get_floppy_geometry(drive, type, &g));
 			return put_user(g->size, (long *) param);
+
+		case BLKGETSIZE64:
+			ECALL(get_floppy_geometry(drive, type, &g));
+			return put_user((u64)g->size << 9, (u64 *) param);
 		/* BLKRRPART is not defined as floppies don't have
 		 * partition tables */
 	}
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 8b4d168a5dec..d2b6c8f44752 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -849,11 +849,14 @@ static int lo_ioctl(struct inode * inode, struct file * file,
 			err = -ENXIO;
 			break;
 		}
-		if (!arg) {
-			err = -EINVAL;
+		err = put_user(loop_sizes[lo->lo_number] << 1, (long *) arg);
+		break;
+	case BLKGETSIZE64:
+		if (lo->lo_state != Lo_bound) {
+			err = -ENXIO;
 			break;
 		}
-		err = put_user(loop_sizes[lo->lo_number] << 1, (long *) arg);
+		err = put_user((u64)loop_sizes[lo->lo_number] << 10, (u64*)arg);
 		break;
 	case BLKBSZGET:
 	case BLKBSZSET:
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index f37c95d299c7..09ca5dcd89e1 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -446,6 +446,8 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
 #endif
 	case BLKGETSIZE:
 		return put_user(nbd_bytesizes[dev] >> 9, (long *) arg);
+	case BLKGETSIZE64:
+		return put_user((u64)nbd_bytesizes[dev], (u64 *) arg);
 	}
 	return -EINVAL;
 }
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 43c6510f41cc..0ace2dee0d4e 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -287,6 +287,7 @@ static void pd_eject( int unit);
 static struct hd_struct pd_hd[PD_DEVS];
 static int pd_sizes[PD_DEVS];
 static int pd_blocksizes[PD_DEVS];
+static int pd_maxsectors[PD_DEVS];
 
 #define PD_NAMELEN	8
 
@@ -382,56 +383,6 @@ void pd_init_units( void )
 	}
 }
 
-static inline int pd_new_segment(request_queue_t *q, struct request *req, int max_segments)
-{
-	if (max_segments > cluster)
-		max_segments = cluster;
-
-	if (req->nr_segments < max_segments) {
-		req->nr_segments++;
-		return 1;
-	}
-	return 0;
-}
-
-static int pd_back_merge_fn(request_queue_t *q, struct request *req, 
-			    struct buffer_head *bh, int max_segments)
-{
-	if (req->bhtail->b_data + req->bhtail->b_size == bh->b_data)
-		return 1;
-	return pd_new_segment(q, req, max_segments);
-}
-
-static int pd_front_merge_fn(request_queue_t *q, struct request *req, 
-			     struct buffer_head *bh, int max_segments)
-{
-	if (bh->b_data + bh->b_size == req->bh->b_data)
-		return 1;
-	return pd_new_segment(q, req, max_segments);
-}
-
-static int pd_merge_requests_fn(request_queue_t *q, struct request *req,
-				struct request *next, int max_segments)
-{
-	int total_segments = req->nr_segments + next->nr_segments;
-	int same_segment;
-
-	if (max_segments > cluster)
-		max_segments = cluster;
-
-	same_segment = 0;
-	if (req->bhtail->b_data + req->bhtail->b_size == next->bh->b_data) {
-		total_segments--;
-		same_segment = 1;
-	}
-    
-	if (total_segments > max_segments)
-		return 0;
-
-	req->nr_segments = total_segments;
-	return 1;
-}
-
 int pd_init (void)
 
 {       int i;
@@ -445,9 +396,6 @@ int pd_init (void)
         }
 	q = BLK_DEFAULT_QUEUE(MAJOR_NR);
 	blk_init_queue(q, DEVICE_REQUEST);
-	q->back_merge_fn = pd_back_merge_fn;
-	q->front_merge_fn = pd_front_merge_fn;
-	q->merge_requests_fn = pd_merge_requests_fn;
         read_ahead[MAJOR_NR] = 8;       /* 8 sector (4kB) read ahead */
         
 	pd_gendisk.major = major;
@@ -457,6 +405,9 @@ int pd_init (void)
 	for(i=0;i<PD_DEVS;i++) pd_blocksizes[i] = 1024;
 	blksize_size[MAJOR_NR] = pd_blocksizes;
 
+	for(i=0;i<PD_DEVS;i++) pd_maxsectors[i] = cluster;
+	max_sectors[MAJOR_NR] = pd_maxsectors;
+
 	printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 		name,name,PD_VERSION,major,cluster,nice);
 	pd_init_units();
@@ -531,6 +482,8 @@ static int pd_ioctl(struct inode *inode,struct file *file,
                 if (err) return (err);
                 put_user(pd_hd[dev].nr_sects,(long *) arg);
                 return (0);
+            case BLKGETSIZE64:
+                return put_user((u64)pd_hd[dev].nr_sects << 9, (u64 *)arg);
             case BLKRRPART:
 		if (!capable(CAP_SYS_ADMIN))
 			return -EACCES;
@@ -639,6 +592,11 @@ void    cleanup_module(void)
 
         devfs_unregister_blkdev(MAJOR_NR,name);
 	del_gendisk(&pd_gendisk);
+
+	for (unit=0;unit<PD_UNITS;unit++) 
+	   if (PD.present) pi_release(PI);
+
+	max_sectors[MAJOR_NR] = NULL;
 }
 
 #endif
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index e935c00c459b..952631012021 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -482,11 +482,9 @@ static int pf_ioctl(struct inode *inode,struct file *file,
                 put_user(0,(long *)&geo->start);
                 return 0;
             case BLKGETSIZE:
-                if (!arg) return -EINVAL;
-                err = verify_area(VERIFY_WRITE,(long *) arg,sizeof(long));
-                if (err) return (err);
-                put_user(PF.capacity,(long *) arg);
-                return (0);
+                return put_user(PF.capacity,(long *) arg);
+            case BLKGETSIZE64:
+                return put_user((u64)PF.capacity << 9,(u64 *)arg);
 	    case BLKROSET:
 	    case BLKROGET:
 	    case BLKRASET:
diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 5845927e04ab..537d27922650 100644
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -1114,6 +1114,9 @@ static int ps2esdi_ioctl(struct inode *inode,
 			}
 			break;
 
+		case BLKGETSIZE64:
+			return put_user((u64)ps2esdi[MINOR(inode->i_rdev)].nr_sects << 9, (u64 *) arg);
+
 		case BLKRRPART:
                         if (!capable(CAP_SYS_ADMIN)) 
 				return -EACCES;
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 7ccda2a70567..73d31e6b62ef 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -269,6 +269,9 @@ static int rd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
 			if (!arg)  return -EINVAL;
 			return put_user(rd_kbsize[minor] << 1, (long *) arg);
 
+         	case BLKGETSIZE64:
+			return put_user((u64)rd_kbsize[minor] << 10, (u64*)arg);
+
 		case BLKROSET:
 		case BLKROGET:
 		case BLKSSZGET:
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 12e4877cedd3..5e8b34b035a8 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -337,6 +337,8 @@ static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
 		case BLKGETSIZE:
 			if (!arg) return -EINVAL;
 			return put_user(xd_struct[MINOR(inode->i_rdev)].nr_sects,(long *) arg);
+		case BLKGETSIZE64:
+			return put_user((u64)xd_struct[MINOR(inode->i_rdev)].nr_sects << 9, (u64 *)arg);
 		case HDIO_SET_DMA:
 			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
 			if (xdc_busy) return -EBUSY;
diff --git a/drivers/char/agp/agpgart_be.c b/drivers/char/agp/agpgart_be.c
index 060c63691dda..8669b29e6d61 100644
--- a/drivers/char/agp/agpgart_be.c
+++ b/drivers/char/agp/agpgart_be.c
@@ -437,8 +437,8 @@ static void agp_generic_agp_enable(u32 mode)
 			/* adjust RQ depth */
 			command =
 			    ((command & ~0xff000000) |
-			     min(u32, (mode & 0xff000000),
-				 min(u32, (command & 0xff000000),
+			     min_t(u32, (mode & 0xff000000),
+				 min_t(u32, (command & 0xff000000),
 				     (scratch & 0xff000000))));
 
 			/* disable SBA if it's not supported */
@@ -2674,8 +2674,8 @@ static void serverworks_agp_enable(u32 mode)
 			/* adjust RQ depth */
 			command =
 			    ((command & ~0xff000000) |
-			     min(u32, (mode & 0xff000000),
-				 min(u32, (command & 0xff000000),
+			     min_t(u32, (mode & 0xff000000),
+				 min_t(u32, (command & 0xff000000),
 				     (scratch & 0xff000000))));
 
 			/* disable SBA if it's not supported */
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index a9c385602cde..a0a99fe49475 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -1629,8 +1629,8 @@ cyz_handle_rx(struct cyclades_port *info, volatile struct CH_CTRL *ch_ctrl,
 	       for performance, but because of buffer boundaries, there
 	       may be several steps to the operation */
 	    while(0 < (small_count = 
-		       min(unsigned int, (rx_bufsize - new_rx_get),
-		       min(unsigned int, (TTY_FLIPBUF_SIZE - tty->flip.count), char_count))
+		       min_t(unsigned int, (rx_bufsize - new_rx_get),
+		       min_t(unsigned int, (TTY_FLIPBUF_SIZE - tty->flip.count), char_count))
 		 )) {
 		memcpy_fromio(tty->flip.char_buf_ptr,
 			      (char *)(cinfo->base_addr
@@ -1724,9 +1724,9 @@ cyz_handle_tx(struct cyclades_port *info, volatile struct CH_CTRL *ch_ctrl,
 	}
 #ifdef BLOCKMOVE
 	while(0 < (small_count = 
-		   min(unsigned int, (tx_bufsize - tx_put),
-		       min(unsigned int, (SERIAL_XMIT_SIZE - info->xmit_tail),
-			   min(unsigned int, info->xmit_cnt, char_count))))) {
+		   min_t(unsigned int, (tx_bufsize - tx_put),
+		       min_t(unsigned int, (SERIAL_XMIT_SIZE - info->xmit_tail),
+			   min_t(unsigned int, info->xmit_cnt, char_count))))) {
 
 	    memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr + tx_put),
 			&info->xmit_buf[info->xmit_tail],
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index b438c9c63d8e..9eac58218bad 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -69,7 +69,7 @@
 { \
 	long i, t, m; \
 	while (count > 0) { \
-		m = min(unsigned long, count, maxio); \
+		m = min_t(unsigned long, count, maxio); \
 		for (i = 0; i < m; i++) { \
 			for (t = 0; t < timeout && !ENABLE; t++) \
 				wait_some(HZ/50); \
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index d4c94cc492f2..8152f7e6b8f7 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -118,7 +118,7 @@ static ssize_t pp_read (struct file * file, char * buf, size_t count,
 		return -EINVAL;
 	}
 
-	kbuffer = kmalloc(min(unsigned int, count, PP_BUFFER_SIZE), GFP_KERNEL);
+	kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
 	if (!kbuffer) {
 		return -ENOMEM;
 	}
@@ -126,7 +126,7 @@ static ssize_t pp_read (struct file * file, char * buf, size_t count,
 	mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 
 	while (bytes_read < count) {
-		ssize_t need = min(unsigned long, count - bytes_read, PP_BUFFER_SIZE);
+		ssize_t need = min_t(unsigned long, count - bytes_read, PP_BUFFER_SIZE);
 
 		if (mode == IEEE1284_MODE_EPP) {
 			/* various specials for EPP mode */
@@ -198,7 +198,7 @@ static ssize_t pp_write (struct file * file, const char * buf, size_t count,
 		return -EINVAL;
 	}
 
-	kbuffer = kmalloc(min(unsigned int, count, PP_BUFFER_SIZE), GFP_KERNEL);
+	kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
 	if (!kbuffer) {
 		return -ENOMEM;
 	}
@@ -206,7 +206,7 @@ static ssize_t pp_write (struct file * file, const char * buf, size_t count,
 	mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 
 	while (bytes_written < count) {
-		ssize_t n = min(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
+		ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
 
 		if (copy_from_user (kbuffer, buf + bytes_written, n)) {
 			bytes_written = -EFAULT;
diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index ad8a70df19f8..31297e3e88fa 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -819,7 +819,7 @@ struct Port *		PortP;
 	  ** and available space.
 	  */
 			
-	  transCount = min(unsigned int, PacketP->len & PKT_LEN_MASK,
+	  transCount = min_t(unsigned int, PacketP->len & PKT_LEN_MASK,
 			   TTY_FLIPBUF_SIZE - TtyP->flip.count);
 	  rio_dprintk (RIO_DEBUG_REC,  "port %d: Copy %d bytes\n", 
 				      PortP->PortNum, transCount);
diff --git a/drivers/i2o/i2o_block.c b/drivers/i2o/i2o_block.c
index 0ec403f178d4..a933eaa57a35 100644
--- a/drivers/i2o/i2o_block.c
+++ b/drivers/i2o/i2o_block.c
@@ -1141,6 +1141,8 @@ static int i2ob_ioctl(struct inode *inode, struct file *file,
 	switch (cmd) {
 		case BLKGETSIZE:
 			return put_user(i2ob[minor].nr_sects, (long *) arg);
+		case BLKGETSIZE64:
+			return put_user((u64)i2ob[minor].nr_sects << 9, (u64 *)arg);
 
 		case HDIO_GETGEO:
 		{
diff --git a/drivers/ide/hd.c b/drivers/ide/hd.c
index bdc854f46a3a..385ac5752f55 100644
--- a/drivers/ide/hd.c
+++ b/drivers/ide/hd.c
@@ -639,9 +639,11 @@ static int hd_ioctl(struct inode * inode, struct file * file,
 		}
 
          	case BLKGETSIZE:   /* Return device size */
-			if (!arg)  return -EINVAL;
 			return put_user(hd[MINOR(inode->i_rdev)].nr_sects, 
 					(long *) arg);
+         	case BLKGETSIZE64:
+			return put_user((u64)hd[MINOR(inode->i_rdev)].nr_sects << 9, 
+					(u64 *) arg);
 
 		case BLKRRPART: /* Re-read partition tables */
 			if (!capable(CAP_SYS_ADMIN))
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index c64ba73fcf07..9723d0c5bcd4 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -2660,6 +2660,8 @@ static int ide_ioctl (struct inode *inode, struct file *file,
 
 	 	case BLKGETSIZE:   /* Return device size */
 			return put_user(drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects, (long *) arg);
+	 	case BLKGETSIZE64:
+			return put_user((u64)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects << 9, (u64 *) arg);
 
 		case BLKRRPART: /* Re-read partition tables */
 			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
diff --git a/drivers/md/lvm-snap.c b/drivers/md/lvm-snap.c
index ed19d45fc895..20e40c022e90 100644
--- a/drivers/md/lvm-snap.c
+++ b/drivers/md/lvm-snap.c
@@ -386,8 +386,8 @@ int lvm_snapshot_COW(kdev_t org_phys_dev,
 
 	blksize_org = lvm_get_blksize(org_phys_dev);
 	blksize_snap = lvm_get_blksize(snap_phys_dev);
-	max_blksize = max(int, blksize_org, blksize_snap);
-	min_blksize = min(int, blksize_org, blksize_snap);
+	max_blksize = max(blksize_org, blksize_snap);
+	min_blksize = min(blksize_org, blksize_snap);
 	max_sectors = KIO_MAX_SECTORS * (min_blksize>>9);
 
 	if (chunk_size % (max_blksize>>9))
@@ -395,7 +395,7 @@ int lvm_snapshot_COW(kdev_t org_phys_dev,
 
 	while (chunk_size)
 	{
-		nr_sectors = min(int, chunk_size, max_sectors);
+		nr_sectors = min(chunk_size, max_sectors);
 		chunk_size -= nr_sectors;
 
 		iobuf->length = nr_sectors << 9;
@@ -503,7 +503,7 @@ int lvm_snapshot_alloc_hash_table(lv_t * lv)
 
 	buckets = lv->lv_remap_end;
 	max_buckets = calc_max_buckets();
-	buckets = min(unsigned long, buckets, max_buckets);
+	buckets = min(buckets, max_buckets);
 	while (buckets & (buckets-1))
 		buckets &= (buckets-1);
 
diff --git a/drivers/md/lvm.c b/drivers/md/lvm.c
index cb830201c87d..3b758a70c40e 100644
--- a/drivers/md/lvm.c
+++ b/drivers/md/lvm.c
@@ -877,6 +877,11 @@ static int lvm_blk_ioctl(struct inode *inode, struct file *file,
 			return -EFAULT;
 		break;
 
+	case BLKGETSIZE64:
+		if (put_user((u64)lv_ptr->lv_size << 9, (u64 *)arg))
+			return -EFAULT;
+		break;
+
 
 	case BLKFLSBUF:
 		/* flush buffer cache */
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 3ca62c0b18af..02472fa1410f 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2478,6 +2478,11 @@ static int md_ioctl (struct inode *inode, struct file *file,
 						(long *) arg);
 			goto done;
 
+		case BLKGETSIZE64:   /* Return device size */
+			err = md_put_user((u64)md_hd_struct[minor].nr_sects << 9,
+						(u64 *) arg);
+			goto done;
+
 		case BLKRAGET:
 		case BLKRASET:
 		case BLKFLSBUF:
diff --git a/drivers/mtd/devices/docecc.c b/drivers/mtd/devices/docecc.c
index f161a130a12f..3732075548e3 100644
--- a/drivers/mtd/devices/docecc.c
+++ b/drivers/mtd/devices/docecc.c
@@ -402,7 +402,7 @@ eras_dec_rs(dtype Alpha_to[NN + 1], dtype Index_of[NN + 1],
     den = 0;
     
     /* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
-    for (i = min(int, deg_lambda,NN-KK-1) & ~1; i >= 0; i -=2) {
+    for (i = min_t(int, deg_lambda,NN-KK-1) & ~1; i >= 0; i -=2) {
       if(lambda[i+1] != A0)
 	den ^= Alpha_to[modnn(lambda[i+1] + i * root[j])];
     }
diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index 02b217399c4a..8248afd070f7 100644
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -1174,10 +1174,10 @@ static int ftl_ioctl(struct inode *inode, struct file *file,
 	put_user(ftl_hd[minor].start_sect, (u_long *)&geo->start);
 	break;
     case BLKGETSIZE:
-	ret = verify_area(VERIFY_WRITE, (long *)arg, sizeof(long));
-	if (ret) return ret;
-	put_user(ftl_hd[minor].nr_sects, 
-		 (long *)arg);
+	ret = put_user(ftl_hd[minor].nr_sects, (long *)arg);
+	break;
+    case BLKGETSIZE64:
+	ret = put_user((u64)ftl_hd[minor].nr_sects << 9, (u64 *)arg);
 	break;
     case BLKRRPART:
 	ret = ftl_reread_partitions(minor);
diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 132ce13eca04..e025fb3e7c51 100644
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -529,10 +529,9 @@ static int mtdblock_ioctl(struct inode * inode, struct file * file,
 
 	switch (cmd) {
 	case BLKGETSIZE:   /* Return device size */
-		if (!arg)
-			return -EFAULT;
-		return put_user((mtdblk->mtd->size >> 9),
-                                (long *) arg)?-EFAULT:0;
+		return put_user((mtdblk->mtd->size >> 9), (long *) arg);
+	case BLKGETSIZE64:
+		return put_user((u64)mtdblk->mtd->size, (u64 *)arg);
 		
 	case BLKFLSBUF:
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
diff --git a/drivers/mtd/mtdblock_ro.c b/drivers/mtd/mtdblock_ro.c
index 1905bd29e794..2d2873b6a3c1 100644
--- a/drivers/mtd/mtdblock_ro.c
+++ b/drivers/mtd/mtdblock_ro.c
@@ -211,9 +211,9 @@ static int mtdblock_ioctl(struct inode * inode, struct file * file,
 
 	switch (cmd) {
 	case BLKGETSIZE:   /* Return device size */
-		if (!arg)  return -EFAULT;
-		return Put_user((mtd->size >> 9),
-                                (long *) arg);
+		return put_user((mtd->size >> 9), (long *) arg);
+	case BLKGETSIZE64:
+		return put_user((u64)mtd->size, (u64 *)arg);
 		
 	case BLKFLSBUF:
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index 4bec8ae88122..ac2c4bf229f6 100644
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -791,9 +791,11 @@ static int nftl_ioctl(struct inode * inode, struct file * file, unsigned int cmd
 		return copy_to_user((void *)arg, &g, sizeof g) ? -EFAULT : 0;
 	}
 	case BLKGETSIZE:   /* Return device size */
-		if (!arg) return -EINVAL;
 		return put_user(part_table[MINOR(inode->i_rdev)].nr_sects,
                                 (long *) arg);
+	case BLKGETSIZE64:
+		return put_user((u64)part_table[MINOR(inode->i_rdev)].nr_sects << 9,
+                                (u64 *)arg);
 		
 	case BLKFLSBUF:
 		if (!capable(CAP_SYS_ADMIN)) return -EACCES;
diff --git a/drivers/net/acenic.c b/drivers/net/acenic.c
index 3b5f6df4f130..1fb3c1785c7a 100644
--- a/drivers/net/acenic.c
+++ b/drivers/net/acenic.c
@@ -2995,8 +2995,8 @@ static void __init ace_copy(struct ace_regs *regs, void *src,
 		return;
 
 	while (size > 0) {
-		tsize = min(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
-			    min(u32, size, ACE_WINDOW_SIZE));
+		tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
+			    min_t(u32, size, ACE_WINDOW_SIZE));
 		tdest = (unsigned long)&regs->Window +
 			(dest & (ACE_WINDOW_SIZE - 1));
 		writel(dest & ~(ACE_WINDOW_SIZE - 1), &regs->WinBase);
@@ -3026,8 +3026,8 @@ static void __init ace_clear(struct ace_regs *regs, u32 dest, int size)
 		return;
 
 	while (size > 0) {
-		tsize = min(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
-			    min(u32, size, ACE_WINDOW_SIZE));
+		tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
+			    min_t(u32, size, ACE_WINDOW_SIZE));
 		tdest = (unsigned long)&regs->Window +
 			(dest & (ACE_WINDOW_SIZE - 1));
 		writel(dest & ~(ACE_WINDOW_SIZE - 1), &regs->WinBase);
diff --git a/drivers/net/de600.c b/drivers/net/de600.c
index d582b16db936..22314569e65c 100644
--- a/drivers/net/de600.c
+++ b/drivers/net/de600.c
@@ -814,7 +814,7 @@ de600_rspace(struct sock *sk)
  */
 
 	if (atomic_read(&sk->rmem_alloc) >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
-	amt = min(int, (sk->rcvbuf-atomic_read(&sk->rmem_alloc))/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
+	amt = min_t(int, (sk->rcvbuf-atomic_read(&sk->rmem_alloc))/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
 	if (amt < 0) return(0);
 	return(amt);
   }
diff --git a/drivers/net/dgrs.c b/drivers/net/dgrs.c
index 7a6f1385cfe8..a3422c810244 100644
--- a/drivers/net/dgrs.c
+++ b/drivers/net/dgrs.c
@@ -733,7 +733,7 @@ static int dgrs_start_xmit(struct sk_buff *skb, struct net_device *devN)
 			goto no_resources;
 		}
 
-		amt = min(unsigned int, len, rbdp->size - count);
+		amt = min_t(unsigned int, len, rbdp->size - count);
 		memcpy( (char *) S2H(rbdp->buf) + count, skb->data + i, amt);
 		i += amt;
 		count += amt;
diff --git a/drivers/net/hamradio/baycom_epp.c b/drivers/net/hamradio/baycom_epp.c
index 403577fda957..e058dd89d3be 100644
--- a/drivers/net/hamradio/baycom_epp.c
+++ b/drivers/net/hamradio/baycom_epp.c
@@ -610,7 +610,7 @@ static int transmit(struct baycom_state *bc, int cnt, unsigned char stat)
 	while (cnt > 0) {
 		switch (bc->hdlctx.state) {
 		case tx_keyup:
-			i = min(int, cnt, bc->hdlctx.flags);
+			i = min_t(int, cnt, bc->hdlctx.flags);
 			cnt -= i;
 			bc->hdlctx.flags -= i;
 			if (bc->hdlctx.flags <= 0)
@@ -633,7 +633,7 @@ static int transmit(struct baycom_state *bc, int cnt, unsigned char stat)
 					break;
 				}
 			}
-			i = min(int, cnt, bc->hdlctx.bufcnt);
+			i = min_t(int, cnt, bc->hdlctx.bufcnt);
 			bc->hdlctx.bufcnt -= i;
 			cnt -= i;
 			if (i != pp->ops->epp_write_data(pp, bc->hdlctx.bufptr, i, 0))
@@ -647,7 +647,7 @@ static int transmit(struct baycom_state *bc, int cnt, unsigned char stat)
 				bc->hdlctx.state = tx_data;
 				break;
 			}
-			i = min(int, cnt, bc->hdlctx.flags);
+			i = min_t(int, cnt, bc->hdlctx.flags);
 			if (i) {
 				cnt -= i;
 				bc->hdlctx.flags -= i;
@@ -664,7 +664,7 @@ static int transmit(struct baycom_state *bc, int cnt, unsigned char stat)
 		default:  /* fall through */
 			if (bc->hdlctx.calibrate <= 0)
 				return 0;
-			i = min(int, cnt, bc->hdlctx.calibrate);
+			i = min_t(int, cnt, bc->hdlctx.calibrate);
 			cnt -= i;
 			bc->hdlctx.calibrate -= i;
 			memset(tmp, 0, sizeof(tmp));
diff --git a/drivers/net/sk98lin/skproc.c b/drivers/net/sk98lin/skproc.c
index 1abb4dd124bb..34f853ec8572 100644
--- a/drivers/net/sk98lin/skproc.c
+++ b/drivers/net/sk98lin/skproc.c
@@ -293,7 +293,7 @@ void *data)
 	if (buffer_length >= len - offset) {
 		*eof = 1;
 	}
-	return (min(int, buffer_length, len - offset));
+	return (min_t(int, buffer_length, len - offset));
 }
 
 
diff --git a/drivers/net/wan/comx-hw-comx.c b/drivers/net/wan/comx-hw-comx.c
index 86737b11e28a..8bb67edb0fb2 100644
--- a/drivers/net/wan/comx-hw-comx.c
+++ b/drivers/net/wan/comx-hw-comx.c
@@ -1044,7 +1044,7 @@ static int comxhw_write_proc(struct file *file, const char *buffer,
 		if (!(page = (char *)__get_free_page(GFP_KERNEL))) {
 			return -ENOMEM;
 		}
-		if(copy_from_user(page, buffer, count = (min(int, count, PAGE_SIZE))))
+		if(copy_from_user(page, buffer, count = (min_t(int, count, PAGE_SIZE))))
 		{
 			count = -EFAULT;
 			goto out;
@@ -1182,8 +1182,8 @@ static int comxhw_read_proc(char *page, char **start, off_t off, int count,
 			len = sprintf(page, "external\n");
 		}
 	} else if (strcmp(file->name, FILENAME_FIRMWARE) == 0) {
-		len = min(int, FILE_PAGESIZE,
-			  min(int, count, 
+		len = min_t(int, FILE_PAGESIZE,
+			  min_t(int, count, 
 			      hw->firmware ?
 			      (hw->firmware->len - off) : 0));
 		if (len < 0) {
@@ -1205,7 +1205,7 @@ static int comxhw_read_proc(char *page, char **start, off_t off, int count,
 	if (count >= len - off) {
 		*eof = 1;
 	}
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 /* Called on echo comx >boardtype */
diff --git a/drivers/net/wan/comx-hw-locomx.c b/drivers/net/wan/comx-hw-locomx.c
index 4b64939e864e..7a9521888a45 100644
--- a/drivers/net/wan/comx-hw-locomx.c
+++ b/drivers/net/wan/comx-hw-locomx.c
@@ -324,7 +324,7 @@ static int locomx_read_proc(char *page, char **start, off_t off, int count,
 	if (count >= len - off) {
 		*eof = 1;
 	}
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 static int locomx_write_proc(struct file *file, const char *buffer,
@@ -339,7 +339,7 @@ static int locomx_write_proc(struct file *file, const char *buffer,
 		return -ENOMEM;
 	}
 
-	copy_from_user(page, buffer, count = min(unsigned long, count, PAGE_SIZE));
+	copy_from_user(page, buffer, count = min_t(unsigned long, count, PAGE_SIZE));
 	if (*(page + count - 1) == '\n') {
 		*(page + count - 1) = 0;
 	}
diff --git a/drivers/net/wan/comx-hw-mixcom.c b/drivers/net/wan/comx-hw-mixcom.c
index adf829894ff2..9bb74ba06cd4 100644
--- a/drivers/net/wan/comx-hw-mixcom.c
+++ b/drivers/net/wan/comx-hw-mixcom.c
@@ -121,7 +121,7 @@ static inline void hscx_fill_fifo(struct net_device *dev)
 
 
 	outsb(dev->base_addr + HSCX_FIFO,
-        	&(hw->sending->data[hw->tx_ptr]), min(unsigned int, to_send, 32));
+        	&(hw->sending->data[hw->tx_ptr]), min_t(unsigned int, to_send, 32));
 	if (to_send <= 32) {
         	hscx_cmd(dev, HSCX_XTF | HSCX_XME);
 	        kfree_skb(hw->sending);
@@ -696,7 +696,7 @@ static int mixcom_read_proc(char *page, char **start, off_t off, int count,
 	}
 	*start = page + off;
 	if (count >= len - off) *eof = 1;
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 
@@ -763,7 +763,7 @@ static int mixcom_write_proc(struct file *file, const char *buffer,
 		return -ENOMEM;
 	}
 
-	copy_from_user(page, buffer, count = min(unsigned long, count, PAGE_SIZE));
+	copy_from_user(page, buffer, count = min_t(unsigned long, count, PAGE_SIZE));
 	if (*(page + count - 1) == '\n') {
 		*(page + count - 1) = 0;
 	}
diff --git a/drivers/net/wan/comx-proto-fr.c b/drivers/net/wan/comx-proto-fr.c
index 75ef5c56c9a4..7929952b03de 100644
--- a/drivers/net/wan/comx-proto-fr.c
+++ b/drivers/net/wan/comx-proto-fr.c
@@ -634,7 +634,7 @@ static int fr_read_proc(char *page, char **start, off_t off, int count,
 
 	*start = page + off;
 	if (count >= len - off) *eof = 1;
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 static int fr_write_proc(struct file *file, const char *buffer, 
diff --git a/drivers/net/wan/comx-proto-lapb.c b/drivers/net/wan/comx-proto-lapb.c
index 520074f72f94..a6ed23818c74 100644
--- a/drivers/net/wan/comx-proto-lapb.c
+++ b/drivers/net/wan/comx-proto-lapb.c
@@ -212,7 +212,7 @@ static int comxlapb_read_proc(char *page, char **start, off_t off, int count,
 	if (count >= len - off) {
 		*eof = 1;
 	}
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 static int comxlapb_write_proc(struct file *file, const char *buffer, 
diff --git a/drivers/net/wan/comx.c b/drivers/net/wan/comx.c
index 3d4986ea7ca1..5e2c5647ac33 100644
--- a/drivers/net/wan/comx.c
+++ b/drivers/net/wan/comx.c
@@ -151,8 +151,8 @@ int comx_debug(struct net_device *dev, char *fmt, ...)
 		int free = (ch->debug_start - ch->debug_end + ch->debug_size) 
 			% ch->debug_size;
 
-		to_copy = min(int, free ? free : ch->debug_size, 
-			      min(int, ch->debug_size - ch->debug_end, len));
+		to_copy = min_t(int, free ? free : ch->debug_size, 
+			      min_t(int, ch->debug_size - ch->debug_end, len));
 		memcpy(ch->debug_area + ch->debug_end, str, to_copy);
 		str += to_copy;
 		len -= to_copy;
@@ -567,7 +567,7 @@ static int comx_read_proc(char *page, char **start, off_t off, int count,
 	if (count >= len - off) {
 		*eof = 1;
 	}
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 
@@ -597,7 +597,7 @@ static int comx_root_read_proc(char *page, char **start, off_t off, int count,
 	if (count >= len - off) {
 		*eof = 1;
 	}
-	return min(int, count, len - off);
+	return min_t(int, count, len - off);
 }
 
 
diff --git a/drivers/net/wan/cycx_main.c b/drivers/net/wan/cycx_main.c
index 22ffa2e56a34..c66f3c492eed 100644
--- a/drivers/net/wan/cycx_main.c
+++ b/drivers/net/wan/cycx_main.c
@@ -111,8 +111,8 @@ int __init cyclomx_init (void)
 		fullname, DRV_VERSION, DRV_RELEASE, copyright);
 
 	/* Verify number of cards and allocate adapter data space */
-	ncards = min(int, ncards, MAX_CARDS);
-	ncards = max(int, ncards, 1);
+	ncards = min_t(int, ncards, MAX_CARDS);
+	ncards = max_t(int, ncards, 1);
 	card_array = kmalloc(sizeof(cycx_t) * ncards, GFP_KERNEL);
 	if (!card_array)
 		goto out;
diff --git a/drivers/net/wan/cycx_x25.c b/drivers/net/wan/cycx_x25.c
index 125a07b7eab2..6699b3e6d40b 100644
--- a/drivers/net/wan/cycx_x25.c
+++ b/drivers/net/wan/cycx_x25.c
@@ -260,13 +260,13 @@ int cyx_init (cycx_t *card, wandev_conf_t *conf)
 	        cfg.flags = 0;      /* FIXME just reset the 2nd bit */
 
 	if (conf->u.x25.hi_pvc) {
-		card->u.x.hi_pvc = min(unsigned int, conf->u.x25.hi_pvc, 4095);
-		card->u.x.lo_pvc = min(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
+		card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, 4095);
+		card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
 	}
 
 	if (conf->u.x25.hi_svc) {
-		card->u.x.hi_svc = min(unsigned int, conf->u.x25.hi_svc, 4095);
-		card->u.x.lo_svc = min(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
+		card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, 4095);
+		card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
 	}
 
 	if (card->u.x.lo_pvc == 255)
@@ -277,25 +277,25 @@ int cyx_init (cycx_t *card, wandev_conf_t *conf)
 	cfg.nvc = card->u.x.hi_svc - card->u.x.lo_svc + 1 + cfg.npvc;
 
 	if (conf->u.x25.hdlc_window)
-		cfg.n2win = min(unsigned int, conf->u.x25.hdlc_window, 7);
+		cfg.n2win = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
 
 	if (conf->u.x25.pkt_window)
-		cfg.n3win = min(unsigned int, conf->u.x25.pkt_window, 7);
+		cfg.n3win = min_t(unsigned int, conf->u.x25.pkt_window, 7);
 
 	if (conf->u.x25.t1)
-		cfg.t1 = min(unsigned int, conf->u.x25.t1, 30);
+		cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
 
 	if (conf->u.x25.t2)
-		cfg.t2 = min(unsigned int, conf->u.x25.t2, 30);
+		cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 30);
 
 	if (conf->u.x25.t11_t21)
-		cfg.t21 = min(unsigned int, conf->u.x25.t11_t21, 30);
+		cfg.t21 = min_t(unsigned int, conf->u.x25.t11_t21, 30);
 
 	if (conf->u.x25.t13_t23)
-		cfg.t23 = min(unsigned int, conf->u.x25.t13_t23, 30);
+		cfg.t23 = min_t(unsigned int, conf->u.x25.t13_t23, 30);
 
 	if (conf->u.x25.n2)
-		cfg.n2 = min(unsigned int, conf->u.x25.n2, 30);
+		cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
 
 	/* initialize adapter */
 	if (x25_configure(card, &cfg))
diff --git a/drivers/net/wan/sbni.c b/drivers/net/wan/sbni.c
index 157ec0df84bd..84a9826147b1 100644
--- a/drivers/net/wan/sbni.c
+++ b/drivers/net/wan/sbni.c
@@ -659,7 +659,7 @@ download_data( struct net_device  *dev,  u32  *crc_p )
 	struct net_local  *nl    = (struct net_local *) dev->priv;
 	struct sk_buff    *skb	 = nl->tx_buf_p;
 
-	unsigned  len = min(unsigned int, skb->len - nl->outpos, nl->framelen);
+	unsigned  len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
 
 	outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
 	*crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
@@ -760,7 +760,7 @@ interpret_ack( struct net_device  *dev,  unsigned  ack )
 			nl->outpos += nl->framelen;
 
 			if( --nl->tx_frameno )
-				nl->framelen = min(unsigned int,
+				nl->framelen = min_t(unsigned int,
 						   nl->maxframe,
 						   nl->tx_buf_p->len - nl->outpos);
 			else
diff --git a/drivers/net/wan/sdla_chdlc.c b/drivers/net/wan/sdla_chdlc.c
index 3595ab117fab..06023ffb5dcb 100644
--- a/drivers/net/wan/sdla_chdlc.c
+++ b/drivers/net/wan/sdla_chdlc.c
@@ -506,13 +506,13 @@ int wpc_init (sdla_t* card, wandev_conf_t* conf)
 		/* For Primary Port 0 */
 		card->wandev.mtu =
 			(conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
-			min(unsigned int, conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
+			min_t(unsigned int, conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
 			CHDLC_DFLT_DATA_LEN;
 	} else if(port_num == WANOPT_SEC) { 
 		/* For Secondary Port 1 */
 		card->wandev.mtu =
 			(conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
-			min(unsigned int, conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
+			min_t(unsigned int, conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
 			CHDLC_DFLT_DATA_LEN;
 	}
 
@@ -828,19 +828,19 @@ static int new_if (wan_device_t* wandev, netdevice_t* dev, wanif_conf_t* conf)
 			card->u.c.kpalv_tx =
 				((conf->keepalive_tx_tmr - MIN_Tx_KPALV_TIMER)
 				>= 0) ?
-	   			min(unsigned int, conf->keepalive_tx_tmr,MAX_Tx_KPALV_TIMER) :
+	   			min_t(unsigned int, conf->keepalive_tx_tmr,MAX_Tx_KPALV_TIMER) :
 				DEFAULT_Tx_KPALV_TIMER;
 
 			card->u.c.kpalv_rx =
 		   		((conf->keepalive_rx_tmr - MIN_Rx_KPALV_TIMER)
 				>= 0) ?
-	   			min(unsigned int, conf->keepalive_rx_tmr,MAX_Rx_KPALV_TIMER) :
+	   			min_t(unsigned int, conf->keepalive_rx_tmr,MAX_Rx_KPALV_TIMER) :
 				DEFAULT_Rx_KPALV_TIMER;
 
 			card->u.c.kpalv_err =
 		   		((conf->keepalive_err_margin-MIN_KPALV_ERR_TOL)
 				>= 0) ?
-	   			min(unsigned int, conf->keepalive_err_margin,
+	   			min_t(unsigned int, conf->keepalive_err_margin,
 				MAX_KPALV_ERR_TOL) : 
 	   			DEFAULT_KPALV_ERR_TOL;
 		}
@@ -848,7 +848,7 @@ static int new_if (wan_device_t* wandev, netdevice_t* dev, wanif_conf_t* conf)
 		/* Setup slarp timer to control delay between slarps */
 		card->u.c.slarp_timer = 
 			((conf->slarp_timer - MIN_SLARP_REQ_TIMER) >= 0) ?
-			min(unsigned int, conf->slarp_timer, MAX_SLARP_REQ_TIMER) :
+			min_t(unsigned int, conf->slarp_timer, MAX_SLARP_REQ_TIMER) :
 			DEFAULT_SLARP_REQ_TIMER;
 
 #ifdef LINUX_2_0
diff --git a/drivers/net/wan/sdla_fr.c b/drivers/net/wan/sdla_fr.c
index ac21b5d108d1..3a0e84277d9f 100644
--- a/drivers/net/wan/sdla_fr.c
+++ b/drivers/net/wan/sdla_fr.c
@@ -549,10 +549,10 @@ int wpf_init(sdla_t *card, wandev_conf_t *conf)
 	/* Adjust configuration */
 	conf->mtu += FR_HEADER_LEN;
 	conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
-			min(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
+			min_t(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
                         FR_CHANNEL_MTU + FR_HEADER_LEN;
      
-	conf->bps = min(unsigned int, conf->bps, 2048000);
+	conf->bps = min_t(unsigned int, conf->bps, 2048000);
 
 	/* Initialze the configuration structure sent to the board to zero */
 	memset(&u.cfg, 0, sizeof(u.cfg));
@@ -619,7 +619,7 @@ int wpf_init(sdla_t *card, wandev_conf_t *conf)
 		 * command in fr_configure() routine. 
 		 */
 
-		card->u.f.dlci_num  = min(unsigned int, max(unsigned int, conf->u.fr.dlci_num, 1), 100);
+		card->u.f.dlci_num  = min_t(unsigned int, max_t(unsigned int, conf->u.fr.dlci_num, 1), 100);
 	
 		for ( i = 0; i < card->u.f.dlci_num; i++) {
 
@@ -636,27 +636,27 @@ int wpf_init(sdla_t *card, wandev_conf_t *conf)
 		u.cfg.port |= 0x0002;
 
 	if (conf->u.fr.t391)
-		u.cfg.t391 = min(unsigned int, conf->u.fr.t391, 30);
+		u.cfg.t391 = min_t(unsigned int, conf->u.fr.t391, 30);
 	else
 		u.cfg.t391 = 5;
 
 	if (conf->u.fr.t392)
-		u.cfg.t392 = min(unsigned int, conf->u.fr.t392, 30);
+		u.cfg.t392 = min_t(unsigned int, conf->u.fr.t392, 30);
 	else
 		u.cfg.t392 = 15;
 
 	if (conf->u.fr.n391)
-		u.cfg.n391 = min(unsigned int, conf->u.fr.n391, 255);
+		u.cfg.n391 = min_t(unsigned int, conf->u.fr.n391, 255);
 	else
 		u.cfg.n391 = 2;
 
 	if (conf->u.fr.n392)
-		u.cfg.n392 = min(unsigned int, conf->u.fr.n392, 10);
+		u.cfg.n392 = min_t(unsigned int, conf->u.fr.n392, 10);
 	else
 		u.cfg.n392 = 3;	
 
 	if (conf->u.fr.n393)
-		u.cfg.n393 = min(unsigned int, conf->u.fr.n393, 10);
+		u.cfg.n393 = min_t(unsigned int, conf->u.fr.n393, 10);
 	else
 		u.cfg.n393 = 4;
 
@@ -953,8 +953,8 @@ static int new_if (wan_device_t* wandev, netdevice_t* dev, wanif_conf_t* conf)
          */
 	if (conf->cir) {
 
-		chan->cir = max(unsigned int, 1,
-				min(unsigned int, conf->cir, 512));
+		chan->cir = max_t(unsigned int, 1,
+				min_t(unsigned int, conf->cir, 512));
 		chan->cir_status = CIR_ENABLED; 
 
 		
@@ -965,8 +965,8 @@ static int new_if (wan_device_t* wandev, netdevice_t* dev, wanif_conf_t* conf)
 		chan->bc = chan->cir;
 
 		if (conf->be){
-			chan->be = max(unsigned int,
-				       0, min(unsigned int, conf->be, 511));
+			chan->be = max_t(unsigned int,
+				       0, min_t(unsigned int, conf->be, 511));
 		}else{	
 			conf->be = 0;
 		}
diff --git a/drivers/net/wan/sdla_ppp.c b/drivers/net/wan/sdla_ppp.c
index 66402177f8cc..e3221f73ed8a 100644
--- a/drivers/net/wan/sdla_ppp.c
+++ b/drivers/net/wan/sdla_ppp.c
@@ -401,7 +401,7 @@ int wpp_init(sdla_t *card, wandev_conf_t *conf)
 	printk(KERN_INFO "%s: running PPP firmware v%s\n",card->devname, u.str); 
 	/* Adjust configuration and set defaults */
 	card->wandev.mtu = (conf->mtu) ?
-		min(unsigned int, conf->mtu, PPP_MAX_MTU) : PPP_DFLT_MTU;
+		min_t(unsigned int, conf->mtu, PPP_MAX_MTU) : PPP_DFLT_MTU;
 
 	card->wandev.bps	= conf->bps;
 	card->wandev.interface	= conf->interface;
@@ -630,7 +630,7 @@ static int new_if(wan_device_t *wandev, netdevice_t *dev, wanif_conf_t *conf)
 	
 	dev->init = &if_init;
 	dev->priv = ppp_priv_area;
-	dev->mtu = min(unsigned int, dev->mtu, card->wandev.mtu);
+	dev->mtu = min_t(unsigned int, dev->mtu, card->wandev.mtu);
 
 	/* Initialize the polling task routine */
 #ifndef LINUX_2_4
diff --git a/drivers/net/wan/sdla_x25.c b/drivers/net/wan/sdla_x25.c
index 1ce92859616a..8be7d748ef93 100644
--- a/drivers/net/wan/sdla_x25.c
+++ b/drivers/net/wan/sdla_x25.c
@@ -654,13 +654,13 @@ int wpx_init (sdla_t* card, wandev_conf_t* conf)
 	u.cfg.defPktSize = u.cfg.pktMTU = card->wandev.mtu;
 
 	if (conf->u.x25.hi_pvc){
-		card->u.x.hi_pvc = min(unsigned int, conf->u.x25.hi_pvc, MAX_LCN_NUM);
-		card->u.x.lo_pvc = min(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
+		card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, MAX_LCN_NUM);
+		card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
 	}
 
 	if (conf->u.x25.hi_svc){
-		card->u.x.hi_svc = min(unsigned int, conf->u.x25.hi_svc, MAX_LCN_NUM);
-		card->u.x.lo_svc = min(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
+		card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, MAX_LCN_NUM);
+		card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
 	}
 
 	/* Figure out the total number of channels to configure */
@@ -685,38 +685,38 @@ int wpx_init (sdla_t* card, wandev_conf_t* conf)
 	u.cfg.hiTwoWaySVC = card->u.x.hi_svc;
 
 	if (conf->u.x25.hdlc_window)
-		u.cfg.hdlcWindow = min(unsigned int, conf->u.x25.hdlc_window, 7);
+		u.cfg.hdlcWindow = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
 	if (conf->u.x25.pkt_window)
-		u.cfg.pktWindow = min(unsigned int, conf->u.x25.pkt_window, 7);
+		u.cfg.pktWindow = min_t(unsigned int, conf->u.x25.pkt_window, 7);
 
 	if (conf->u.x25.t1)
-		u.cfg.t1 = min(unsigned int, conf->u.x25.t1, 30);
+		u.cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
 	if (conf->u.x25.t2)
-		u.cfg.t2 = min(unsigned int, conf->u.x25.t2, 29);
+		u.cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 29);
 	if (conf->u.x25.t4)
-		u.cfg.t4 = min(unsigned int, conf->u.x25.t4, 240);
+		u.cfg.t4 = min_t(unsigned int, conf->u.x25.t4, 240);
 	if (conf->u.x25.n2)
-		u.cfg.n2 = min(unsigned int, conf->u.x25.n2, 30);
+		u.cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
 
 	if (conf->u.x25.t10_t20)
-		u.cfg.t10t20 = min(unsigned int, conf->u.x25.t10_t20,255);
+		u.cfg.t10t20 = min_t(unsigned int, conf->u.x25.t10_t20,255);
 	if (conf->u.x25.t11_t21)
-		u.cfg.t11t21 = min(unsigned int, conf->u.x25.t11_t21,255);
+		u.cfg.t11t21 = min_t(unsigned int, conf->u.x25.t11_t21,255);
 	if (conf->u.x25.t12_t22)
-		u.cfg.t12t22 = min(unsigned int, conf->u.x25.t12_t22,255);
+		u.cfg.t12t22 = min_t(unsigned int, conf->u.x25.t12_t22,255);
 	if (conf->u.x25.t13_t23)	
-		u.cfg.t13t23 = min(unsigned int, conf->u.x25.t13_t23,255);
+		u.cfg.t13t23 = min_t(unsigned int, conf->u.x25.t13_t23,255);
 	if (conf->u.x25.t16_t26)
-		u.cfg.t16t26 = min(unsigned int, conf->u.x25.t16_t26, 255);
+		u.cfg.t16t26 = min_t(unsigned int, conf->u.x25.t16_t26, 255);
 	if (conf->u.x25.t28)
-		u.cfg.t28 = min(unsigned int, conf->u.x25.t28, 255);
+		u.cfg.t28 = min_t(unsigned int, conf->u.x25.t28, 255);
 
 	if (conf->u.x25.r10_r20)
-		u.cfg.r10r20 = min(unsigned int, conf->u.x25.r10_r20,250);
+		u.cfg.r10r20 = min_t(unsigned int, conf->u.x25.r10_r20,250);
 	if (conf->u.x25.r12_r22)
-		u.cfg.r12r22 = min(unsigned int, conf->u.x25.r12_r22,250);
+		u.cfg.r12r22 = min_t(unsigned int, conf->u.x25.r12_r22,250);
 	if (conf->u.x25.r13_r23)
-		u.cfg.r13r23 = min(unsigned int, conf->u.x25.r13_r23,250);
+		u.cfg.r13r23 = min_t(unsigned int, conf->u.x25.r13_r23,250);
 
 
 	if (conf->u.x25.ccitt_compat)
diff --git a/drivers/net/wan/wanpipe_multppp.c b/drivers/net/wan/wanpipe_multppp.c
index 17a0f1f3f409..59823688dff6 100644
--- a/drivers/net/wan/wanpipe_multppp.c
+++ b/drivers/net/wan/wanpipe_multppp.c
@@ -376,13 +376,13 @@ int wsppp_init (sdla_t* card, wandev_conf_t* conf)
 		/* For Primary Port 0 */
 		card->wandev.mtu =
 			(conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
-			min(unsigned int, conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
+			min_t(unsigned int, conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
 			CHDLC_DFLT_DATA_LEN;
 	} else if(port_num == WANOPT_SEC) { 
 		/* For Secondary Port 1 */
 		card->wandev.mtu =
 			(conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
-			min(unsigned int, conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
+			min_t(unsigned int, conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
 			CHDLC_DFLT_DATA_LEN;
 	}
 
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 78b666462b01..595aba251d2e 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -1753,7 +1753,7 @@ static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len)
 	// read the rid length field
 	bap_read(ai, pBuf, 2, BAP1);
 	// length for remaining part of rid
-	len = min(unsigned int, len, le16_to_cpu(*(u16*)pBuf)) - 2;
+	len = min_t(unsigned int, len, le16_to_cpu(*(u16*)pBuf)) - 2;
 	
 	if ( len <= 2 ) {
 		printk( KERN_ERR 
@@ -3997,7 +3997,7 @@ static int readrids(struct net_device *dev, aironet_ioctl *comp) {
 	 */
 
 	if (copy_to_user(comp->data, iobuf,
-			 min(unsigned int, comp->len, sizeof(iobuf))))
+			 min_t(unsigned int, comp->len, sizeof(iobuf))))
 		return -EFAULT;
 	return 0;
 }
@@ -4057,7 +4057,7 @@ static int writerids(struct net_device *dev, aironet_ioctl *comp) {
 		PC4500_readrid(dev->priv,ridcode,iobuf,sizeof(iobuf));
 
 		if (copy_to_user(comp->data, iobuf,
-				 min(unsigned int, comp->len, sizeof(iobuf))))
+				 min_t(unsigned int, comp->len, sizeof(iobuf))))
 			return -EFAULT;
 		return 0;
 
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 0a8c1bae7dd5..a27159bae3bd 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -2175,11 +2175,13 @@ do_dasd_ioctl (struct inode *inp, /* unsigned */ int no, unsigned long data)
 	case BLKGETSIZE:{	/* Return device size */
 			long blocks = major_info->gendisk.sizes 
                                       [MINOR (inp->i_rdev)] << 1;
-			rc =
-			    copy_to_user ((long *) data, &blocks,
-					  sizeof (long));
-			if (rc)
-				rc = -EFAULT;
+			rc = put_user(blocks, (long *)arg);
+			break;
+		}
+	case BLKGETSIZE64:{
+			u64 blocks = major_info->gendisk.sizes 
+                                      [MINOR (inp->i_rdev)];
+			rc = put_user(blocks << 10, (u64 *)arg);
 			break;
 		}
 	case BLKRRPART:{
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index c56b72c4a7ba..40da008cf41d 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -647,14 +647,14 @@ int xpram_ioctl (struct inode *inode, struct file *filp,
 
 	case BLKGETSIZE:  /* 0x1260 */
 		/* Return the device size, expressed in sectors */
-		if (!arg) return -EINVAL; /* NULL pointer: not valid */
-		err= 0; /* verify_area_20(VERIFY_WRITE, (long *) arg, sizeof(long)); 
-			 *  if (err) return err;
-			 */
-		put_user ( 1024* xpram_sizes[MINOR(inode->i_rdev)]
+		return put_user( 1024* xpram_sizes[MINOR(inode->i_rdev)]
                            / XPRAM_SOFTSECT,
 			   (long *) arg);
-		return 0;
+
+	case BLKGETSIZE64:
+		return put_user( (u64)(1024* xpram_sizes[MINOR(inode->i_rdev)]
+                           / XPRAM_SOFTSECT) << 9,
+			   (u64 *) arg);
 
 	case BLKFLSBUF: /* flush, 0x1261 */
 		fsync_dev(inode->i_rdev);
diff --git a/drivers/s390/net/iucv.c b/drivers/s390/net/iucv.c
index 8b6b662f1124..26ea68ce650d 100644
--- a/drivers/s390/net/iucv.c
+++ b/drivers/s390/net/iucv.c
@@ -1309,7 +1309,7 @@ iucv_receive (u16 pathid, u32 msgid, u32 trgcls,
 			if (residual_buffer)
 				*residual_buffer = parm.ipbfadr1;
 		} else {
-			moved = min(unsigned int, buflen, 8);
+			moved = min_t(unsigned int, buflen, 8);
 
 			memcpy ((char *) buffer,
 				(char *) &parm.ipbfadr1, moved);
@@ -1402,7 +1402,7 @@ iucv_receive_array (u16 pathid,
 
 			while ((moved < 8) && (moved < buflen)) {
 				dyn_len =
-				    min(unsigned int,
+				    min_t(unsigned int,
 					(buffer + i)->length, need_to_move);
 
 				memcpy ((char *)((ulong)((buffer + i)->address)),
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
index 09660e03ac75..7ea2bf79f691 100644
--- a/drivers/s390/net/netiucv.c
+++ b/drivers/s390/net/netiucv.c
@@ -828,7 +828,7 @@ register_iucv_dev (int devnumber, char *userid)
 
 	memset (iucv_userid[devnumber], ' ', 8);
 	memcpy (iucv_userid[devnumber], userid,
-		min(unsigned int, strlen(userid), 8));
+		min_t(unsigned int, strlen(userid), 8));
 	dev = &iucv_netdev[devnumber];
 	sprintf (dev->name, "iucv%i", devnumber);
 
diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index 21e1a7552c34..f0107ea38285 100644
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -454,6 +454,8 @@ static int jsfd_ioctl(struct inode *inode, struct file *file,
 	switch (cmd) {
 	case BLKGETSIZE:
 		return put_user(jsfd_bytesizes[dev] >> 9, (long *) arg);
+	case BLKGETSIZE64:
+		return put_user(jsfd_bytesizes[dev], (u64 *) arg);
 
 #if 0
 	case BLKROSET:
diff --git a/drivers/scsi/eata_pio.c b/drivers/scsi/eata_pio.c
index 7a070be69aa4..13e918a23e8c 100644
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
@@ -161,7 +161,7 @@ void eata_pio_int_handler(int irq, void *dev_id, struct pt_regs * regs)
 			    IncStat(&cmd->SCp,1);
 			    odd=FALSE;
 			}
-			x=min(unsigned int,z,cmd->SCp.this_residual/2);
+			x=min_t(unsigned int,z,cmd->SCp.this_residual/2);
 			insw(base+HA_RDATA,cmd->SCp.ptr,x);
 			z-=x; 
 			IncStat(&cmd->SCp,2*x);
@@ -191,7 +191,7 @@ void eata_pio_int_handler(int irq, void *dev_id, struct pt_regs * regs)
 			    z--; 
 			    odd=FALSE; 
 			}
-			x=min(unsigned int,z,cmd->SCp.this_residual/2);
+			x=min_t(unsigned int,z,cmd->SCp.this_residual/2);
 			outsw(base+HA_RDATA,cmd->SCp.ptr,x);
 			z-=x; 
 			IncStat(&cmd->SCp,2*x);
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index bea96170a4df..32d257fa1f92 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -90,6 +90,7 @@ static Scsi_Disk *rscsi_disks;
 static int *sd_sizes;
 static int *sd_blocksizes;
 static int *sd_hardsizes;	/* Hardware sector size */
+static int *sd_max_sectors;
 
 static int check_scsidisk_media_change(kdev_t);
 static int fop_revalidate_scsidisk(kdev_t);
@@ -227,9 +228,9 @@ static int sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd,
 			return 0;
 		}
 		case BLKGETSIZE:   /* Return device size */
-			if (!arg)
-				return -EINVAL;
 			return put_user(sd[SD_PARTITION(inode->i_rdev)].nr_sects, (long *) arg);
+		case BLKGETSIZE64:
+			return put_user((u64)sd[SD_PARTITION(inode->i_rdev)].nr_sects << 9, (u64 *)arg);
 
 		case BLKROSET:
 		case BLKROGET:
@@ -1100,15 +1101,30 @@ static int sd_init()
 	if (!sd_hardsizes)
 		goto cleanup_blocksizes;
 
+	sd_max_sectors = kmalloc((sd_template.dev_max << 4) * sizeof(int), GFP_ATOMIC);
+	if (!sd_max_sectors)
+		goto cleanup_max_sectors;
+
 	for (i = 0; i < sd_template.dev_max << 4; i++) {
 		sd_blocksizes[i] = 1024;
 		sd_hardsizes[i] = 512;
+		/*
+		 * Allow lowlevel device drivers to generate 512k large scsi
+		 * commands if they know what they're doing and they ask for it
+		 * explicitly via the SHpnt->max_sectors API.
+		 */
+		sd_max_sectors[i] = MAX_SEGMENTS*8;
 	}
 
 	for (i = 0; i < N_USED_SD_MAJORS; i++) {
 		blksize_size[SD_MAJOR(i)] = sd_blocksizes + i * (SCSI_DISKS_PER_MAJOR << 4);
 		hardsect_size[SD_MAJOR(i)] = sd_hardsizes + i * (SCSI_DISKS_PER_MAJOR << 4);
+		max_sectors[SD_MAJOR(i)] = sd_max_sectors + i * (SCSI_DISKS_PER_MAJOR << 4);
 	}
+	/*
+	 * FIXME: should unregister blksize_size, hardsect_size and max_sectors when
+	 * the module is unloaded.
+	 */
 	sd = kmalloc((sd_template.dev_max << 4) *
 					  sizeof(struct hd_struct),
 					  GFP_ATOMIC);
@@ -1158,6 +1174,8 @@ cleanup_gendisks_de_arr:
 cleanup_sd_gendisks:
 	kfree(sd);
 cleanup_sd:
+	kfree(sd_max_sectors);
+cleanup_max_sectors:
 	kfree(sd_hardsizes);
 cleanup_blocksizes:
 	kfree(sd_blocksizes);
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 6abdd0360e6c..f79877af7ae0 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -546,6 +546,8 @@ int sr_dev_ioctl(struct cdrom_device_info *cdi,
 	switch (cmd) {
 	case BLKGETSIZE:
 		return put_user(scsi_CDs[target].capacity, (long *) arg);
+	case BLKGETSIZE64:
+		return put_user((u64)scsi_CDs[target].capacity << 9, (u64 *)arg);
 	case BLKROSET:
 	case BLKROGET:
 	case BLKRASET:
diff --git a/drivers/scsi/sym53c8xx.h b/drivers/scsi/sym53c8xx.h
index 32b0fc288fee..63883cd24c2e 100644
--- a/drivers/scsi/sym53c8xx.h
+++ b/drivers/scsi/sym53c8xx.h
@@ -96,6 +96,7 @@ int sym53c8xx_release(struct Scsi_Host *);
 			this_id:        7,			\
 			sg_tablesize:   SCSI_NCR_SG_TABLESIZE,	\
 			cmd_per_lun:    SCSI_NCR_CMD_PER_LUN,	\
+			max_sectors:    MAX_SEGMENTS*8,		\
 			use_clustering: DISABLE_CLUSTERING} 
 
 #else
diff --git a/drivers/sound/dmasound/dmasound_atari.c b/drivers/sound/dmasound/dmasound_atari.c
index 619a3e874c28..343219585a75 100644
--- a/drivers/sound/dmasound/dmasound_atari.c
+++ b/drivers/sound/dmasound/dmasound_atari.c
@@ -154,7 +154,7 @@ static ssize_t ata_ct_law(const u_char *userPtr, size_t userCount,
 	ssize_t count, used;
 	u_char *p = &frame[*frameUsed];
 
-	count = min(unsigned long, userCount, frameLeft);
+	count = min_t(unsigned long, userCount, frameLeft);
 	if (dmasound.soft.stereo)
 		count &= ~1;
 	used = count;
@@ -177,7 +177,7 @@ static ssize_t ata_ct_s8(const u_char *userPtr, size_t userCount,
 	ssize_t count, used;
 	void *p = &frame[*frameUsed];
 
-	count = min(unsigned long, userCount, frameLeft);
+	count = min_t(unsigned long, userCount, frameLeft);
 	if (dmasound.soft.stereo)
 		count &= ~1;
 	used = count;
@@ -196,7 +196,7 @@ static ssize_t ata_ct_u8(const u_char *userPtr, size_t userCount,
 
 	if (!dmasound.soft.stereo) {
 		u_char *p = &frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft);
+		count = min_t(unsigned long, userCount, frameLeft);
 		used = count;
 		while (count > 0) {
 			u_char data;
@@ -207,7 +207,7 @@ static ssize_t ata_ct_u8(const u_char *userPtr, size_t userCount,
 		}
 	} else {
 		u_short *p = (u_short *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>1;
+		count = min_t(unsigned long, userCount, frameLeft)>>1;
 		used = count*2;
 		while (count > 0) {
 			u_short data;
@@ -230,7 +230,7 @@ static ssize_t ata_ct_s16be(const u_char *userPtr, size_t userCount,
 
 	if (!dmasound.soft.stereo) {
 		u_short *p = (u_short *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>1;
+		count = min_t(unsigned long, userCount, frameLeft)>>1;
 		used = count*2;
 		while (count > 0) {
 			u_short data;
@@ -243,7 +243,7 @@ static ssize_t ata_ct_s16be(const u_char *userPtr, size_t userCount,
 		*frameUsed += used*2;
 	} else {
 		void *p = (u_short *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft) & ~3;
+		count = min_t(unsigned long, userCount, frameLeft) & ~3;
 		used = count;
 		if (copy_from_user(p, userPtr, count))
 			return -EFAULT;
@@ -261,7 +261,7 @@ static ssize_t ata_ct_u16be(const u_char *userPtr, size_t userCount,
 
 	if (!dmasound.soft.stereo) {
 		u_short *p = (u_short *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>1;
+		count = min_t(unsigned long, userCount, frameLeft)>>1;
 		used = count*2;
 		while (count > 0) {
 			u_short data;
@@ -275,7 +275,7 @@ static ssize_t ata_ct_u16be(const u_char *userPtr, size_t userCount,
 		*frameUsed += used*2;
 	} else {
 		u_long *p = (u_long *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>2;
+		count = min_t(unsigned long, userCount, frameLeft)>>2;
 		used = count*4;
 		while (count > 0) {
 			u_long data;
@@ -299,7 +299,7 @@ static ssize_t ata_ct_s16le(const u_char *userPtr, size_t userCount,
 	count = frameLeft;
 	if (!dmasound.soft.stereo) {
 		u_short *p = (u_short *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>1;
+		count = min_t(unsigned long, userCount, frameLeft)>>1;
 		used = count*2;
 		while (count > 0) {
 			u_short data;
@@ -313,7 +313,7 @@ static ssize_t ata_ct_s16le(const u_char *userPtr, size_t userCount,
 		*frameUsed += used*2;
 	} else {
 		u_long *p = (u_long *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>2;
+		count = min_t(unsigned long, userCount, frameLeft)>>2;
 		used = count*4;
 		while (count > 0) {
 			u_long data;
@@ -338,7 +338,7 @@ static ssize_t ata_ct_u16le(const u_char *userPtr, size_t userCount,
 	count = frameLeft;
 	if (!dmasound.soft.stereo) {
 		u_short *p = (u_short *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>1;
+		count = min_t(unsigned long, userCount, frameLeft)>>1;
 		used = count*2;
 		while (count > 0) {
 			u_short data;
@@ -351,7 +351,7 @@ static ssize_t ata_ct_u16le(const u_char *userPtr, size_t userCount,
 		*frameUsed += used*2;
 	} else {
 		u_long *p = (u_long *)&frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft)>>2;
+		count = min_t(unsigned long, userCount, frameLeft)>>2;
 		used = count;
 		while (count > 0) {
 			u_long data;
diff --git a/drivers/sound/dmasound/dmasound_awacs.c b/drivers/sound/dmasound/dmasound_awacs.c
index 9143101a52ea..166ec6611d05 100644
--- a/drivers/sound/dmasound/dmasound_awacs.c
+++ b/drivers/sound/dmasound/dmasound_awacs.c
@@ -267,7 +267,7 @@ static ssize_t pmac_ct_law(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 2;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 		if (get_user(data, userPtr++))
@@ -298,7 +298,7 @@ static ssize_t pmac_ct_s8(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 2;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 		if (get_user(data, userPtr++))
@@ -329,7 +329,7 @@ static ssize_t pmac_ct_u8(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 2;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 		if (get_user(data, userPtr++))
@@ -359,7 +359,7 @@ static ssize_t pmac_ct_s16(const u_char *userPtr, size_t userCount,
 
 	frameLeft >>= 2;
 	userCount >>= (stereo? 2: 1);
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	if (!stereo) {
 		short *up = (short *) userPtr;
 		while (count > 0) {
@@ -390,7 +390,7 @@ static ssize_t pmac_ct_u16(const u_char *userPtr, size_t userCount,
 
 	frameLeft >>= 2;
 	userCount >>= (stereo? 2: 1);
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		int data;
 		if (get_user(data, up++))
@@ -648,7 +648,7 @@ static ssize_t pmac_ct_s8_read(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 2;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 
@@ -681,7 +681,7 @@ static ssize_t pmac_ct_u8_read(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 2;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 
@@ -713,7 +713,7 @@ static ssize_t pmac_ct_s16_read(const u_char *userPtr, size_t userCount,
 
 	frameLeft >>= 2;
 	userCount >>= (stereo? 2: 1);
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	if (!stereo) {
 		short *up = (short *) userPtr;
 		while (count > 0) {
@@ -744,7 +744,7 @@ static ssize_t pmac_ct_u16_read(const u_char *userPtr, size_t userCount,
 
 	frameLeft >>= 2;
 	userCount >>= (stereo? 2: 1);
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(unsigned long, userCount, frameLeft);
 	while (count > 0) {
 		int data;
 
diff --git a/drivers/sound/dmasound/dmasound_paula.c b/drivers/sound/dmasound/dmasound_paula.c
index 1ec6382759e5..9a9d69401ab7 100644
--- a/drivers/sound/dmasound/dmasound_paula.c
+++ b/drivers/sound/dmasound/dmasound_paula.c
@@ -155,14 +155,14 @@ static ssize_t ami_ct_s8(const u_char *userPtr, size_t userCount,
 
 	if (!dmasound.soft.stereo) {
 		void *p = &frame[*frameUsed];
-		count = min(unsigned long, userCount, frameLeft) & ~1;
+		count = min_t(unsigned long, userCount, frameLeft) & ~1;
 		used = count;
 		if (copy_from_user(p, userPtr, count))
 			return -EFAULT;
 	} else {
 		u_char *left = &frame[*frameUsed>>1];
 		u_char *right = left+write_sq_block_size_half;
-		count = min(unsigned long, userCount, frameLeft)>>1 & ~1;
+		count = min_t(unsigned long, userCount, frameLeft)>>1 & ~1;
 		used = count*2;
 		while (count > 0) {
 			if (get_user(*left++, userPtr++)
@@ -189,7 +189,7 @@ static ssize_t funcname(const u_char *userPtr, size_t userCount,	\
 									\
 	if (!dmasound.soft.stereo) {					\
 		u_char *p = &frame[*frameUsed];				\
-		count = min(unsigned long, userCount, frameLeft) & ~1;	\
+		count = min_t(size_t, userCount, frameLeft) & ~1;	\
 		used = count;						\
 		while (count > 0) {					\
 			u_char data;					\
@@ -201,7 +201,7 @@ static ssize_t funcname(const u_char *userPtr, size_t userCount,	\
 	} else {							\
 		u_char *left = &frame[*frameUsed>>1];			\
 		u_char *right = left+write_sq_block_size_half;		\
-		count = min(unsigned long, userCount, frameLeft)>>1 & ~1;\
+		count = min_t(size_t, userCount, frameLeft)>>1 & ~1;	\
 		used = count*2;						\
 		while (count > 0) {					\
 			u_char data;					\
@@ -242,7 +242,7 @@ static ssize_t funcname(const u_char *userPtr, size_t userCount,	\
 	if (!dmasound.soft.stereo) {					\
 		u_char *high = &frame[*frameUsed>>1];			\
 		u_char *low = high+write_sq_block_size_half;		\
-		count = min(unsigned long, userCount, frameLeft)>>1 & ~1;\
+		count = min_t(size_t, userCount, frameLeft)>>1 & ~1;	\
 		used = count*2;						\
 		while (count > 0) {					\
 			if (get_user(data, ((u_short *)userPtr)++))	\
@@ -257,7 +257,7 @@ static ssize_t funcname(const u_char *userPtr, size_t userCount,	\
 		u_char *leftl = lefth+write_sq_block_size_quarter;	\
 		u_char *righth = lefth+write_sq_block_size_half;	\
 		u_char *rightl = righth+write_sq_block_size_quarter;	\
-		count = min(unsigned long, userCount, frameLeft)>>2 & ~1;\
+		count = min_t(size_t, userCount, frameLeft)>>2 & ~1;	\
 		used = count*4;						\
 		while (count > 0) {					\
 			if (get_user(data, ((u_short *)userPtr)++))	\
diff --git a/drivers/sound/dmasound/dmasound_q40.c b/drivers/sound/dmasound/dmasound_q40.c
index 542935113ecf..cca93c04cc9b 100644
--- a/drivers/sound/dmasound/dmasound_q40.c
+++ b/drivers/sound/dmasound/dmasound_q40.c
@@ -58,7 +58,7 @@ static ssize_t q40_ct_law(const u_char *userPtr, size_t userCount,
 	ssize_t count, used;
 	u_char *p = (u_char *) &frame[*frameUsed];
 
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(size_t, userCount, frameLeft);
 	if (copy_from_user(p,userPtr,count))
 	  return -EFAULT;
 	while (count > 0) {
@@ -84,7 +84,7 @@ static ssize_t q40_ct_law(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 1;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(size_t, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 		if (get_user(data, userPtr++))
@@ -112,7 +112,7 @@ static ssize_t q40_ct_s8(const u_char *userPtr, size_t userCount,
 	ssize_t count, used;
 	u_char *p = (u_char *) &frame[*frameUsed];
 
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(size_t, userCount, frameLeft);
 	if (copy_from_user(p,userPtr,count))
 	  return -EFAULT;
 	while (count > 0) {
@@ -136,7 +136,7 @@ static ssize_t q40_ct_s8(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 1;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(size_t, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 		if (get_user(data, userPtr++))
@@ -164,7 +164,7 @@ static ssize_t q40_ct_u8(const u_char *userPtr, size_t userCount,
 	ssize_t count, used;
 	u_char *p = (u_char *) &frame[*frameUsed];
 
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(size_t, userCount, frameLeft);
 	if (copy_from_user(p,userPtr,count))
 	  return -EFAULT;
 	*frameUsed += used;
@@ -184,7 +184,7 @@ static ssize_t q40_ct_u8(const u_char *userPtr, size_t userCount,
 	frameLeft >>= 1;
 	if (stereo)
 		userCount >>= 1;
-	used = count = min(unsigned long, userCount, frameLeft);
+	used = count = min_t(size_t, userCount, frameLeft);
 	while (count > 0) {
 		u_char data;
 		if (get_user(data, userPtr++))
diff --git a/drivers/sound/emu10k1/audio.c b/drivers/sound/emu10k1/audio.c
index dd49c2f4a128..899bb3cac3c7 100644
--- a/drivers/sound/emu10k1/audio.c
+++ b/drivers/sound/emu10k1/audio.c
@@ -115,7 +115,7 @@ static ssize_t emu10k1_audio_read(struct file *file, char *buffer, size_t count,
 
 		if ((bytestocopy >= wiinst->buffer.fragment_size)
 		    || (bytestocopy >= count)) {
-			bytestocopy = min(u32, bytestocopy, count);
+			bytestocopy = min_t(u32, bytestocopy, count);
 
 			emu10k1_wavein_xferdata(wiinst, (u8 *) buffer, &bytestocopy);
 
@@ -215,7 +215,7 @@ static ssize_t emu10k1_audio_write(struct file *file, const char *buffer, size_t
 		if ((bytestocopy >= woinst->buffer.fragment_size)
 		    || (bytestocopy >= count)) {
 
-			bytestocopy = min(u32, bytestocopy, count);
+			bytestocopy = min_t(u32, bytestocopy, count);
 
 			emu10k1_waveout_xferdata(woinst, (u8 *) buffer, &bytestocopy);
 
diff --git a/drivers/sound/emu10k1/cardwi.c b/drivers/sound/emu10k1/cardwi.c
index 184dcd5a8c8d..fde98545a1cb 100644
--- a/drivers/sound/emu10k1/cardwi.c
+++ b/drivers/sound/emu10k1/cardwi.c
@@ -325,7 +325,7 @@ void emu10k1_wavein_xferdata(struct wiinst *wiinst, u8 * data, u32 * size)
 	u32 sizetocopy, sizetocopy_now, start;
 	unsigned long flags;
 
-	sizetocopy = min(u32, buffer->size, *size);
+	sizetocopy = min_t(u32, buffer->size, *size);
 	*size = sizetocopy;
 
 	if (!sizetocopy)
diff --git a/drivers/sound/emu10k1/cardwo.c b/drivers/sound/emu10k1/cardwo.c
index c01919627663..9ec4adf565a3 100644
--- a/drivers/sound/emu10k1/cardwo.c
+++ b/drivers/sound/emu10k1/cardwo.c
@@ -581,7 +581,7 @@ void emu10k1_waveout_xferdata(struct woinst *woinst, u8 *data, u32 *size)
 	u32 sizetocopy, sizetocopy_now, start;
 	unsigned long flags;
 
-	sizetocopy = min(u32, buffer->size, *size);
+	sizetocopy = min_t(u32, buffer->size, *size);
 	*size = sizetocopy;
 
 	if (!sizetocopy)
diff --git a/drivers/usb/bluetooth.c b/drivers/usb/bluetooth.c
index cf8877031085..05b00131a374 100644
--- a/drivers/usb/bluetooth.c
+++ b/drivers/usb/bluetooth.c
@@ -517,7 +517,7 @@ static int bluetooth_write (struct tty_struct * tty, int from_user, const unsign
 				}
 				
 
-				buffer_size = min (int, count, bluetooth->bulk_out_buffer_size);
+				buffer_size = min_t (int, count, bluetooth->bulk_out_buffer_size);
 				memcpy (urb->transfer_buffer, current_position, buffer_size);
 
 				/* build up our urb */
diff --git a/drivers/usb/devio.c b/drivers/usb/devio.c
index 0a89c09a6eff..4e89bacb2e4c 100644
--- a/drivers/usb/devio.c
+++ b/drivers/usb/devio.c
@@ -1082,7 +1082,7 @@ static int proc_ioctl (struct dev_state *ps, void *arg)
 		if (retval == 0)
 			/* ifno might usefully be passed ... */
 			retval = ifp->driver->ioctl (ps->dev, ctrl.ioctl_code, buf);
-			/* size = min(int, size, retval)? */
+			/* size = min_t(int, size, retval)? */
 	}
 
 	/* cleanup and return */
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 882bbd49255e..4e286f65c869 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -670,7 +670,7 @@ dbg( "digi_write_oob_command: TOP: port=%d, count=%d", oob_priv->dp_port_num, co
 		}
 
 		/* len must be a multiple of 4, so commands are not split */
-		len = min(int, count, oob_port->bulk_out_size );
+		len = min_t(int, count, oob_port->bulk_out_size );
 		if( len > 4 )
 			len &= ~3;
 
@@ -747,7 +747,7 @@ count );
 		/* len must be a multiple of 4 and small enough to */
 		/* guarantee the write will send buffered data first, */
 		/* so commands are in order with data and not split */
-		len = min(int, count, port->bulk_out_size-2-priv->dp_out_buf_len );
+		len = min_t(int, count, port->bulk_out_size-2-priv->dp_out_buf_len );
 		if( len > 4 )
 			len &= ~3;
 
@@ -951,7 +951,7 @@ dbg( "digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num );
 	spin_lock_irqsave( &priv->dp_port_lock, flags );
 
 	/* send any buffered chars from throttle time on to tty subsystem */
-	len = min(int, priv->dp_in_buf_len, TTY_FLIPBUF_SIZE - tty->flip.count );
+	len = min_t(int, priv->dp_in_buf_len, TTY_FLIPBUF_SIZE - tty->flip.count );
 	if( len > 0 ) {
 		memcpy( tty->flip.char_buf_ptr, priv->dp_in_buf, len );
 		memcpy( tty->flip.flag_buf_ptr, priv->dp_in_flag_buf, len );
@@ -1272,7 +1272,7 @@ dbg( "digi_write: TOP: port=%d, count=%d, from_user=%d, in_interrupt=%d",
 priv->dp_port_num, count, from_user, in_interrupt() );
 
 	/* copy user data (which can sleep) before getting spin lock */
-	count = min(int, 64, min(int, count, port->bulk_out_size-2 ) );
+	count = min_t(int, 64, min_t(int, count, port->bulk_out_size-2 ) );
 	if( from_user && copy_from_user( user_buf, buf, count ) ) {
 		return( -EFAULT );
 	}
@@ -1303,7 +1303,7 @@ priv->dp_port_num, count, from_user, in_interrupt() );
 
 	/* allow space for any buffered data and for new data, up to */
 	/* transfer buffer size - 2 (for command and length bytes) */
-	new_len = min(int, count, port->bulk_out_size-2-priv->dp_out_buf_len );
+	new_len = min_t(int, count, port->bulk_out_size-2-priv->dp_out_buf_len );
 	data_len = new_len + priv->dp_out_buf_len;
 
 	if( data_len == 0 ) {
@@ -1929,7 +1929,7 @@ static int digi_read_inb_callback( struct urb *urb )
 
 		if( throttled ) {
 
-			len = min( int, len,
+			len = min_t( int, len,
 				DIGI_IN_BUF_SIZE - priv->dp_in_buf_len );
 
 			if( len > 0 ) {
@@ -1942,7 +1942,7 @@ static int digi_read_inb_callback( struct urb *urb )
 
 		} else {
 
-			len = min( int, len, TTY_FLIPBUF_SIZE - tty->flip.count );
+			len = min_t( int, len, TTY_FLIPBUF_SIZE - tty->flip.count );
 
 			if( len > 0 ) {
 				memcpy( tty->flip.char_buf_ptr, data, len );
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index d8fe9ce3497a..c334710448fd 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -276,7 +276,7 @@ static int empeg_write (struct usb_serial_port *port, int from_user, const unsig
 			}
 		}
 
-		transfer_size = min (int, count, URB_TRANSFER_BUFFER_SIZE);
+		transfer_size = min_t (int, count, URB_TRANSFER_BUFFER_SIZE);
 
 		if (from_user) {
 			if (copy_from_user (urb->transfer_buffer, current_position, transfer_size)) {
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 02a17ef2de1d..7e0b853e3be3 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -1311,7 +1311,7 @@ static int edge_write (struct usb_serial_port *port, int from_user, const unsign
 	fifo = &edge_port->txfifo;
 
 	// calculate number of bytes to put in fifo
-	copySize = min (int, count, (edge_port->txCredits - fifo->count));
+	copySize = min_t (int, count, (edge_port->txCredits - fifo->count));
 
 	dbg(__FUNCTION__"(%d) of %d byte(s) Fifo room  %d -- will copy %d bytes", 
 	    port->number, count, edge_port->txCredits - fifo->count, copySize);
@@ -1329,7 +1329,7 @@ static int edge_write (struct usb_serial_port *port, int from_user, const unsign
 	// then copy the reset from the start of the buffer 
 
 	bytesleft = fifo->size - fifo->head;
-	firsthalf = min (int, bytesleft, copySize);
+	firsthalf = min_t (int, bytesleft, copySize);
 	dbg (__FUNCTION__" - copy %d bytes of %d into fifo ", firsthalf, bytesleft);
 
 	/* now copy our data */
@@ -1454,7 +1454,7 @@ static void send_more_port_data(struct edgeport_serial *edge_serial, struct edge
 
 	/* now copy our data */
 	bytesleft =  fifo->size - fifo->tail;
-	firsthalf = min (int, bytesleft, count);
+	firsthalf = min_t (int, bytesleft, count);
 	memcpy(&buffer[2], &fifo->fifo[fifo->tail], firsthalf);
 	fifo->tail  += firsthalf;
 	fifo->count -= firsthalf;
diff --git a/drivers/usb/serial/io_usbvend.h b/drivers/usb/serial/io_usbvend.h
index 3cfac6cf6838..e76cafd2a688 100644
--- a/drivers/usb/serial/io_usbvend.h
+++ b/drivers/usb/serial/io_usbvend.h
@@ -115,7 +115,7 @@
 
 // TxCredits value below which driver won't bother sending (to prevent too many small writes).
 // Send only if above 25%
-#define EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(InitialCredit)	(max(int, ((InitialCredit) / 4), EDGE_FW_BULK_MAX_PACKET_SIZE))
+#define EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(InitialCredit)	(max_t(int, ((InitialCredit) / 4), EDGE_FW_BULK_MAX_PACKET_SIZE))
 
 #define	EDGE_FW_BULK_MAX_PACKET_SIZE		64	// Max Packet Size for Bulk In Endpoint (EP1)
 #define EDGE_FW_BULK_READ_BUFFER_SIZE		1024	// Size to use for Bulk reads
diff --git a/drivers/usb/serial/usbserial.c b/drivers/usb/serial/usbserial.c
index e8a88bcd1fa4..8b781a871018 100644
--- a/drivers/usb/serial/usbserial.c
+++ b/drivers/usb/serial/usbserial.c
@@ -1259,9 +1259,9 @@ static void * usb_serial_probe(struct usb_device *dev, unsigned int ifnum,
 
 	/* initialize some parts of the port structures */
 	/* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
-	max_endpoints = max(int, num_bulk_in, num_bulk_out);
-	max_endpoints = max(int, max_endpoints, num_interrupt_in);
-	max_endpoints = max(int, max_endpoints, serial->num_ports);
+	max_endpoints = max_t(int, num_bulk_in, num_bulk_out);
+	max_endpoints = max_t(int, max_endpoints, num_interrupt_in);
+	max_endpoints = max_t(int, max_endpoints, serial->num_ports);
 	dbg (__FUNCTION__ " - setting up %d port structures for this device", max_endpoints);
 	for (i = 0; i < max_endpoints; ++i) {
 		port = &serial->port[i];
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 13d2693b4cba..5c5b737c204d 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -441,7 +441,7 @@ static int visor_write (struct usb_serial_port *port, int from_user, const unsig
 			}
 		}
 		
-		transfer_size = min (int, count, URB_TRANSFER_BUFFER_SIZE);
+		transfer_size = min_t (int, count, URB_TRANSFER_BUFFER_SIZE);
 		if (from_user) {
 			if (copy_from_user (urb->transfer_buffer, current_position, transfer_size)) {
 				bytes_sent = -EFAULT;
diff --git a/drivers/usb/storage/datafab.c b/drivers/usb/storage/datafab.c
index c98b8caac680..5bc78795dd5e 100644
--- a/drivers/usb/storage/datafab.c
+++ b/drivers/usb/storage/datafab.c
@@ -204,7 +204,7 @@ static int datafab_read_data(struct us_data *us,
 
 	do {
 		// loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
-		len = min(int, totallen, 65536);
+		len = min_t(int, totallen, 65536);
 
 		if (use_sg) {
 			sg = (struct scatterlist *) dest;
@@ -329,7 +329,7 @@ static int datafab_write_data(struct us_data *us,
 
 	do {
 		// loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
-		len = min(int, totallen, 65536);
+		len = min_t(int, totallen, 65536);
 
 		if (use_sg) {
 			sg = (struct scatterlist *) src;
diff --git a/drivers/usb/storage/jumpshot.c b/drivers/usb/storage/jumpshot.c
index 9462a601572a..ea05a32ff04c 100644
--- a/drivers/usb/storage/jumpshot.c
+++ b/drivers/usb/storage/jumpshot.c
@@ -280,7 +280,7 @@ static int jumpshot_read_data(struct us_data *us,
 
 	do {
                // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
-                len = min(int, totallen, 65536);
+                len = min_t(int, totallen, 65536);
 
                 if (use_sg) {
                         sg = (struct scatterlist *) dest;
@@ -395,7 +395,7 @@ static int jumpshot_write_data(struct us_data *us,
 
 	do {
                 // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
-                len = min(int, totallen, 65536);
+                len = min_t(int, totallen, 65536);
 
                 if (use_sg) {
                         sg = (struct scatterlist *) src;
diff --git a/drivers/usb/uhci.c b/drivers/usb/uhci.c
index dbba809ff82e..ce0237107d00 100644
--- a/drivers/usb/uhci.c
+++ b/drivers/usb/uhci.c
@@ -2131,14 +2131,14 @@ static int rh_submit_urb(struct urb *urb)
 	case RH_GET_DESCRIPTOR:
 		switch ((wValue & 0xff00) >> 8) {
 		case 0x01:	/* device descriptor */
-			len = min(unsigned int, leni,
-				  min(unsigned int,
+			len = min_t(unsigned int, leni,
+				  min_t(unsigned int,
 				      sizeof(root_hub_dev_des), wLength));
 			memcpy(data, root_hub_dev_des, len);
 			OK(len);
 		case 0x02:	/* configuration descriptor */
-			len = min(unsigned int, leni,
-				  min(unsigned int,
+			len = min_t(unsigned int, leni,
+				  min_t(unsigned int,
 				      sizeof(root_hub_config_des), wLength));
 			memcpy (data, root_hub_config_des, len);
 			OK(len);
@@ -2147,15 +2147,15 @@ static int rh_submit_urb(struct urb *urb)
 				uhci->io_addr, "UHCI-alt",
 				data, wLength);
 			if (len > 0) {
-				OK(min(int, leni, len));
+				OK(min_t(int, leni, len));
 			} else 
 				stat = -EPIPE;
 		}
 		break;
 	case RH_GET_DESCRIPTOR | RH_CLASS:
 		root_hub_hub_des[2] = uhci->rh.numports;
-		len = min(unsigned int, leni,
-			  min(unsigned int, sizeof(root_hub_hub_des), wLength));
+		len = min_t(unsigned int, leni,
+			  min_t(unsigned int, sizeof(root_hub_hub_des), wLength));
 		memcpy(data, root_hub_hub_des, len);
 		OK(len);
 	case RH_GET_CONFIGURATION:
diff --git a/drivers/usb/usb-ohci.c b/drivers/usb/usb-ohci.c
index dd1c2d0d2f31..b8b5d0732166 100644
--- a/drivers/usb/usb-ohci.c
+++ b/drivers/usb/usb-ohci.c
@@ -1806,8 +1806,8 @@ static int rh_send_irq (ohci_t * ohci, void * rh_data, int rh_len)
   
 	if (ret > 0) { 
 		memcpy(rh_data, data,
-		       min(unsigned int, len,
-			   min(unsigned int, rh_len, sizeof(data))));
+		       min_t(unsigned int, len,
+			   min_t(unsigned int, rh_len, sizeof(data))));
 		return len;
 	}
 	return 0;
@@ -1989,16 +1989,16 @@ static int rh_submit_urb (urb_t * urb)
 		case RH_GET_DESCRIPTOR:
 			switch ((wValue & 0xff00) >> 8) {
 				case (0x01): /* device descriptor */
-					len = min(unsigned int,
+					len = min_t(unsigned int,
 						  leni,
-						  min(unsigned int,
+						  min_t(unsigned int,
 						      sizeof (root_hub_dev_des),
 						      wLength));
 					data_buf = root_hub_dev_des; OK(len);
 				case (0x02): /* configuration descriptor */
-					len = min(unsigned int,
+					len = min_t(unsigned int,
 						  leni,
-						  min(unsigned int,
+						  min_t(unsigned int,
 						      sizeof (root_hub_config_des),
 						      wLength));
 					data_buf = root_hub_config_des; OK(len);
@@ -2008,7 +2008,7 @@ static int rh_submit_urb (urb_t * urb)
 						data, wLength);
 					if (len > 0) {
 						data_buf = data;
-						OK(min(int, leni, len));
+						OK(min_t(int, leni, len));
 					}
 					// else fallthrough
 				default: 
@@ -2043,8 +2043,8 @@ static int rh_submit_urb (urb_t * urb)
 				data_buf [10] = data_buf [9] = 0xff;
 			    }
 				
-			    len = min(unsigned int, leni,
-				      min(unsigned int, data_buf [0], wLength));
+			    len = min_t(unsigned int, leni,
+				      min_t(unsigned int, data_buf [0], wLength));
 			    OK (len);
 			}
  
@@ -2061,7 +2061,7 @@ static int rh_submit_urb (urb_t * urb)
 	// ohci_dump_roothub (ohci, 0);
 #endif
 
-	len = min(int, len, leni);
+	len = min_t(int, len, leni);
 	if (data != data_buf)
 	    memcpy (data, data_buf, len);
   	urb->actual_length = len;
diff --git a/drivers/usb/usb-uhci.c b/drivers/usb/usb-uhci.c
index 4657eba0bf81..f5ccb10ea2ca 100644
--- a/drivers/usb/usb-uhci.c
+++ b/drivers/usb/usb-uhci.c
@@ -2111,14 +2111,14 @@ _static int rh_submit_urb (urb_t *urb)
 	case RH_GET_DESCRIPTOR:
 		switch ((wValue & 0xff00) >> 8) {
 		case (0x01):	/* device descriptor */
-			len = min(unsigned int, leni,
-				  min(unsigned int,
+			len = min_t(unsigned int, leni,
+				  min_t(unsigned int,
 				      sizeof (root_hub_dev_des), wLength));
 			memcpy (data, root_hub_dev_des, len);
 			OK (len);
 		case (0x02):	/* configuration descriptor */
-			len = min(unsigned int, leni,
-				  min(unsigned int,
+			len = min_t(unsigned int, leni,
+				  min_t(unsigned int,
 				      sizeof (root_hub_config_des), wLength));
 			memcpy (data, root_hub_config_des, len);
 			OK (len);
@@ -2127,7 +2127,7 @@ _static int rh_submit_urb (urb_t *urb)
 			        uhci->io_addr, "UHCI",
 				data, wLength);
 			if (len > 0) {
-				OK(min(int, leni, len));
+				OK(min_t(int, leni, len));
 			} else 
 				stat = -EPIPE;
 		}
@@ -2135,8 +2135,8 @@ _static int rh_submit_urb (urb_t *urb)
 
 	case RH_GET_DESCRIPTOR | RH_CLASS:
 		root_hub_hub_des[2] = uhci->rh.numports;
-		len = min(unsigned int, leni,
-			  min(unsigned int, sizeof (root_hub_hub_des), wLength));
+		len = min_t(unsigned int, leni,
+			  min_t(unsigned int, sizeof (root_hub_hub_des), wLength));
 		memcpy (data, root_hub_hub_des, len);
 		OK (len);